953 lines
33 KiB
JavaScript
953 lines
33 KiB
JavaScript
// Module ID: 4154
|
|
// Function ID: 4155
|
|
// Name: createJSONStorage
|
|
// Dependencies: [32, 109]
|
|
// Exports: combine, devtools, persist, redux, subscribeWithSelector
|
|
|
|
// Module 4154 (createJSONStorage)
|
|
import _slicedToArray from "_slicedToArray";
|
|
import _objectWithoutProperties from "_objectWithoutProperties";
|
|
|
|
function createJSONStorage(arg0) {
|
|
let closure_0 = arg1;
|
|
try {
|
|
let closure_1 = arg0();
|
|
const obj = { getItem: null, setItem: null, removeItem: null };
|
|
obj[0] = function getItem(arg0) {
|
|
const value = store.getItem(arg0);
|
|
let tmp2 = null;
|
|
if (null != value) {
|
|
tmp2 = value;
|
|
}
|
|
if (tmp2 instanceof Promise) {
|
|
let nextPromise = tmp2.then(function parse(arg0) {
|
|
let parsed = null;
|
|
if (null !== arg0) {
|
|
let reviver;
|
|
if (null != reviver) {
|
|
reviver = reviver.reviver;
|
|
}
|
|
parsed = JSON.parse(arg0, reviver);
|
|
}
|
|
return parsed;
|
|
});
|
|
} else {
|
|
nextPromise = null;
|
|
if (null !== tmp2) {
|
|
let reviver;
|
|
if (null != closure_0) {
|
|
reviver = closure_0.reviver;
|
|
}
|
|
nextPromise = JSON.parse(tmp2, reviver);
|
|
}
|
|
}
|
|
return nextPromise;
|
|
};
|
|
obj[1] = function setItem(arg0, arg1) {
|
|
let replacer;
|
|
if (null != closure_0) {
|
|
replacer = closure_0.replacer;
|
|
}
|
|
return store.setItem(arg0, JSON.stringify(arg1, replacer));
|
|
};
|
|
obj[2] = function removeItem(arg0) {
|
|
return store.removeItem(arg0);
|
|
};
|
|
return obj;
|
|
} catch (err) {
|
|
}
|
|
}
|
|
let closure_2 = ["enabled", "anonymousActionType", "store"];
|
|
let closure_3 = ["connection"];
|
|
const map = new Map();
|
|
function getTrackedConnectionState(arg0) {
|
|
|
|
}
|
|
function findCallerName(arg0) {
|
|
|
|
}
|
|
function parseJsonThen(arg0, arg1) {
|
|
try {
|
|
const _JSON = JSON;
|
|
const parsed = JSON.parse(arg0);
|
|
if (undefined !== parsed) {
|
|
arg1(parsed);
|
|
}
|
|
} catch (tmp4) {
|
|
const _console = console;
|
|
console.error("[zustand devtools middleware] Could not parse the received json", tmp4);
|
|
}
|
|
}
|
|
function toThenable(arg0) {
|
|
|
|
}
|
|
|
|
export function combine(arg0, arg1) {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
return () => Object.assign({}, closure_0, callback(...HermesBuiltin.copyRestArgs()));
|
|
}
|
|
export { createJSONStorage };
|
|
export function devtools(arg0) {
|
|
let closure_0 = arg0;
|
|
let obj = arg1;
|
|
if (arg1 === undefined) {
|
|
obj = {};
|
|
}
|
|
return (arg0, arg1, setState) => {
|
|
let closure_3;
|
|
let enabled;
|
|
let store;
|
|
const callback = arg0;
|
|
let closure_1 = arg1;
|
|
let closure_2 = setState;
|
|
({ enabled, anonymousActionType: closure_3, store } = closure_1);
|
|
const tmp2 = obj(closure_1, outer1_2);
|
|
let closure_5 = tmp2;
|
|
try {
|
|
let __REDUX_DEVTOOLS_EXTENSION__ = null != enabled;
|
|
if (__REDUX_DEVTOOLS_EXTENSION__) {
|
|
__REDUX_DEVTOOLS_EXTENSION__ = enabled;
|
|
}
|
|
if (__REDUX_DEVTOOLS_EXTENSION__) {
|
|
const _window = window;
|
|
__REDUX_DEVTOOLS_EXTENSION__ = window.__REDUX_DEVTOOLS_EXTENSION__;
|
|
}
|
|
if (__REDUX_DEVTOOLS_EXTENSION__) {
|
|
const tmp9 = ((store, connect, name) => {
|
|
if (undefined === store) {
|
|
let obj = { type: "untracked", connection: null };
|
|
obj[1] = connect.connect(name);
|
|
return obj;
|
|
} else {
|
|
const value = store.get(name.name);
|
|
if (value) {
|
|
obj = { type: "tracked", store: null };
|
|
obj[1] = store;
|
|
const merged = Object.assign(value);
|
|
return obj;
|
|
} else {
|
|
obj = { connection: null, stores: null };
|
|
obj[0] = connect.connect(name);
|
|
obj[1] = {};
|
|
const result = obj5.set(name.name, obj);
|
|
const obj1 = { type: "tracked", store: null };
|
|
obj1[1] = store;
|
|
const merged1 = Object.assign(obj);
|
|
return obj1;
|
|
}
|
|
obj5 = store;
|
|
}
|
|
})(store, tmp5, tmp2);
|
|
const connection = tmp9.connection;
|
|
const tmpResult = obj(tmp9, outer1_3);
|
|
let closure_7 = tmpResult;
|
|
let c8 = true;
|
|
setState.setState = (arg0, arg1, str) => {
|
|
const tmp = callback(arg0, arg1);
|
|
if (c8) {
|
|
if (undefined === str) {
|
|
str = closure_3;
|
|
if (!closure_3) {
|
|
const _Error = Error;
|
|
const error = new Error();
|
|
if (typeof connection !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let tmp10;
|
|
if (error.stack) {
|
|
const parts = str2.split("\n");
|
|
const findIndexResult = parts.findIndex((arr) => arr.includes("api.setState"));
|
|
if (findIndexResult >= 0) {
|
|
let str5;
|
|
if (null != parts[findIndexResult + 1]) {
|
|
str5 = str4.trim();
|
|
}
|
|
if (!str5) {
|
|
str5 = "";
|
|
}
|
|
let obj1 = /.+ (.+) .+/;
|
|
const match = obj1.exec(str5);
|
|
let tmp14;
|
|
if (null != match) {
|
|
tmp14 = match[1];
|
|
}
|
|
tmp10 = tmp14;
|
|
}
|
|
}
|
|
str = tmp10;
|
|
}
|
|
if (!str) {
|
|
str = "anonymous";
|
|
}
|
|
let obj = { type: null };
|
|
obj[0] = str;
|
|
let tmp3 = obj;
|
|
} else {
|
|
tmp3 = str;
|
|
if (typeof str === "string") {
|
|
obj = { type: null };
|
|
obj[0] = str;
|
|
tmp3 = obj;
|
|
}
|
|
}
|
|
if (undefined === store) {
|
|
if (null != connection) {
|
|
obj6.send(tmp3, callback2());
|
|
}
|
|
obj6 = connection;
|
|
} else {
|
|
if (null != connection) {
|
|
obj1 = {};
|
|
const merged = Object.assign(tmp3);
|
|
const _HermesInternal = HermesInternal;
|
|
obj1.type = "" + tmp15 + "/" + tmp3.type;
|
|
if (typeof tmp2 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
const value = store.get(tmp2.name);
|
|
if (value) {
|
|
const _Object = Object;
|
|
const _Object2 = Object;
|
|
const entries = Object.entries(value.stores);
|
|
let fromEntriesResult = Object.fromEntries(entries.map((arg0) => {
|
|
let obj;
|
|
let tmp;
|
|
[tmp, obj] = arg0;
|
|
const items = [tmp, obj.getState()];
|
|
return items;
|
|
}));
|
|
} else {
|
|
fromEntriesResult = {};
|
|
}
|
|
const obj2 = {};
|
|
const merged1 = Object.assign(fromEntriesResult);
|
|
obj2[tmp15] = setState.getState();
|
|
obj8.send(obj1, obj2);
|
|
}
|
|
obj8 = connection;
|
|
}
|
|
return tmp;
|
|
} else {
|
|
return tmp;
|
|
}
|
|
};
|
|
obj = { cleanup: null };
|
|
obj[0] = function cleanup() {
|
|
let tmp3 = connection;
|
|
if (connection) {
|
|
tmp3 = typeof obj.unsubscribe === "function";
|
|
}
|
|
if (tmp3) {
|
|
obj.unsubscribe();
|
|
}
|
|
const name = tmp2.name;
|
|
if (undefined !== store) {
|
|
const value = store.get(name);
|
|
if (value) {
|
|
const stores = value.stores;
|
|
delete tmp[tmp2];
|
|
const _Object = Object;
|
|
if (0 === Object.keys(value.stores).length) {
|
|
obj2.delete(name);
|
|
}
|
|
}
|
|
obj2 = store;
|
|
}
|
|
};
|
|
setState.devtools = obj;
|
|
function setStateFromDevtools(closure_10) {
|
|
let closure_8 = false;
|
|
callback(...HermesBuiltin.copyRestArgs());
|
|
}
|
|
const tmp13 = callback(setState.setState, arg1, setState);
|
|
let closure_10 = tmp13;
|
|
if ("untracked" === tmpResult.type) {
|
|
if (null != connection) {
|
|
connection.init(tmp13);
|
|
}
|
|
} else {
|
|
tmpResult.stores[tmpResult.store] = setState;
|
|
if (null != connection) {
|
|
let _Object = Object;
|
|
let _Object2 = Object;
|
|
let entries = Object.entries(tmpResult.stores);
|
|
connection.init(Object.fromEntries(entries.map((arg0) => {
|
|
let obj;
|
|
let tmp;
|
|
[tmp, obj] = arg0;
|
|
const items = [tmp, ];
|
|
if (tmp === tmpResult.store) {
|
|
let state = closure_10;
|
|
} else {
|
|
state = obj.getState();
|
|
}
|
|
items[1] = state;
|
|
return items;
|
|
})));
|
|
}
|
|
}
|
|
if (setState.dispatchFromDevtools) {
|
|
if (typeof setState.dispatch === "function") {
|
|
const dispatch = setState.dispatch;
|
|
setState.dispatch = () => {
|
|
dispatch(...HermesBuiltin.copyRestArgs());
|
|
};
|
|
}
|
|
}
|
|
const subscription = connection.subscribe((type) => {
|
|
type = type.type;
|
|
if ("ACTION" === type) {
|
|
if (typeof type.payload !== "string") {
|
|
let _console = console;
|
|
console.error("[zustand devtools middleware] Unsupported action format");
|
|
} else {
|
|
tmpResult(type.payload, (type) => {
|
|
if ("__setState" !== type.type) {
|
|
if (tmp10) {
|
|
obj.dispatch(type);
|
|
}
|
|
tmp10 = store.dispatchFromDevtools && typeof store.dispatch === "function";
|
|
} else if (undefined === closure_4) {
|
|
callback(type.state);
|
|
} else {
|
|
const _Object = Object;
|
|
if (1 !== Object.keys(type.state).length) {
|
|
const _console = console;
|
|
console.error("\n [zustand devtools middleware] Unsupported __setState action format.\n When using 'store' option in devtools(), the 'state' should have only one key, which is a value of 'store' that was passed in devtools(),\n and value of this only key should be a state object. Example: { \"type\": \"__setState\", \"state\": { \"abc123Store\": { \"foo\": \"bar\" } } }\n ");
|
|
}
|
|
if (null != type.state[tmp12]) {
|
|
const _JSON = JSON;
|
|
const _JSON2 = JSON;
|
|
const json = JSON.stringify(store.getState());
|
|
if (json !== JSON.stringify(tmp2)) {
|
|
callback(tmp2);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return tmp41;
|
|
} else if ("DISPATCH" === type) {
|
|
const type2 = type.payload.type;
|
|
if ("RESET" === type2) {
|
|
setStateFromDevtools(closure_10);
|
|
if (undefined === store) {
|
|
let initResult;
|
|
if (null != connection) {
|
|
initResult = obj5.init(setState.getState());
|
|
}
|
|
obj5 = connection;
|
|
const tmp38 = initResult;
|
|
} else {
|
|
if (null != connection) {
|
|
if (typeof tmp2 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let mapped = store.get(tmp2.name);
|
|
if (mapped) {
|
|
const _Object3 = Object;
|
|
const _Object4 = Object;
|
|
let entries = Object.entries(mapped.stores);
|
|
mapped = entries.map((arg0) => {
|
|
let obj;
|
|
let tmp;
|
|
[tmp, obj] = arg0;
|
|
const items = [tmp, obj.getState()];
|
|
return items;
|
|
});
|
|
let fromEntriesResult = Object.fromEntries(mapped);
|
|
} else {
|
|
fromEntriesResult = {};
|
|
}
|
|
obj7.init(fromEntriesResult);
|
|
}
|
|
obj7 = connection;
|
|
}
|
|
return tmp38;
|
|
} else if ("COMMIT" === type2) {
|
|
if (undefined === store) {
|
|
if (null != connection) {
|
|
obj3.init(setState.getState());
|
|
}
|
|
obj3 = connection;
|
|
} else {
|
|
if (null != connection) {
|
|
if (typeof tmp2 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let value = store.get(tmp2.name);
|
|
if (value) {
|
|
let _Object = Object;
|
|
let _Object2 = Object;
|
|
const entries1 = Object.entries(value.stores);
|
|
value = entries1.map((arg0) => {
|
|
let obj;
|
|
let tmp;
|
|
[tmp, obj] = arg0;
|
|
const items = [tmp, obj.getState()];
|
|
return items;
|
|
});
|
|
let fromEntriesResult1 = Object.fromEntries(value);
|
|
} else {
|
|
fromEntriesResult1 = {};
|
|
}
|
|
obj6.init(fromEntriesResult1);
|
|
}
|
|
obj6 = connection;
|
|
}
|
|
return tmp24;
|
|
} else if ("ROLLBACK" === type2) {
|
|
tmpResult(type.state, (arg0) => {
|
|
if (undefined === closure_4) {
|
|
callback(arg0);
|
|
if (null != closure_6) {
|
|
closure_6.init(store.getState());
|
|
}
|
|
} else {
|
|
callback(arg0[tmp]);
|
|
if (null != closure_6) {
|
|
if (typeof outer1_5 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let mapped = outer1_4.get(name.name);
|
|
if (mapped) {
|
|
const _Object = Object;
|
|
const _Object2 = Object;
|
|
const entries = Object.entries(mapped.stores);
|
|
mapped = entries.map((arg0) => {
|
|
let obj;
|
|
let tmp;
|
|
[tmp, obj] = arg0;
|
|
const items = [tmp, obj.getState()];
|
|
return items;
|
|
});
|
|
let fromEntriesResult = Object.fromEntries(mapped);
|
|
} else {
|
|
fromEntriesResult = {};
|
|
}
|
|
obj3.init(fromEntriesResult);
|
|
}
|
|
obj3 = closure_6;
|
|
}
|
|
});
|
|
} else {
|
|
if ("JUMP_TO_STATE" !== type2) {
|
|
if ("JUMP_TO_ACTION" !== type2) {
|
|
if ("IMPORT_STATE" === type2) {
|
|
const nextLiftedState = type.payload.nextLiftedState;
|
|
const computedStates = nextLiftedState.computedStates;
|
|
const first = computedStates.slice(-1)[0];
|
|
let state;
|
|
if (null != first) {
|
|
state = first.state;
|
|
}
|
|
if (state) {
|
|
let tmp7 = state;
|
|
if (undefined !== store) {
|
|
tmp7 = state[store];
|
|
}
|
|
setStateFromDevtools(tmp7);
|
|
if (null != connection) {
|
|
connection.send(null, nextLiftedState);
|
|
}
|
|
}
|
|
} else if ("PAUSE_RECORDING" === type2) {
|
|
let c8 = tmp2;
|
|
return !c8;
|
|
}
|
|
}
|
|
}
|
|
tmpResult(type.state, (arg0) => {
|
|
if (undefined !== closure_4) {
|
|
const _JSON = JSON;
|
|
const _JSON2 = JSON;
|
|
const json = JSON.stringify(store.getState());
|
|
if (json !== JSON.stringify(arg0[tmp])) {
|
|
callback(arg0[tmp]);
|
|
}
|
|
} else {
|
|
callback(arg0);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
return tmp13;
|
|
} else {
|
|
return callback(arg0, arg1, setState);
|
|
}
|
|
} catch (err) {
|
|
}
|
|
};
|
|
}
|
|
export function persist(arg0, arg1) {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
return (arg0, arg1, setState) => {
|
|
const callback = arg0;
|
|
let closure_1 = arg1;
|
|
let obj = {
|
|
storage: outer1_8(() => globalThis.localStorage),
|
|
partialize(arg0) {
|
|
return arg0;
|
|
},
|
|
version: 0,
|
|
merge(arg0, arg1) {
|
|
const merged = Object.assign(arg1);
|
|
const merged1 = Object.assign(arg0);
|
|
return {};
|
|
}
|
|
};
|
|
let merged = Object.assign(closure_1);
|
|
let c3 = false;
|
|
const set = new Set();
|
|
const set1 = new Set();
|
|
let storage = obj.storage;
|
|
if (storage) {
|
|
function setItem() {
|
|
|
|
}
|
|
setState = setState.setState;
|
|
setState.setState = (arg0, arg1) => {
|
|
setState(arg0, arg1);
|
|
if (typeof setItem !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let obj = {};
|
|
const merged = Object.assign(callback2());
|
|
obj = { state: obj.partialize(obj), version: obj.version };
|
|
return storage.setItem(obj.name, obj);
|
|
};
|
|
let tmp6 = callback(() => {
|
|
callback(...HermesBuiltin.copyRestArgs());
|
|
if (typeof setItem !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let obj = {};
|
|
const merged = Object.assign(callback2());
|
|
obj = { state: obj.partialize(obj), version: obj.version };
|
|
return storage.setItem(obj.name, obj);
|
|
}, arg1, setState);
|
|
let closure_10 = tmp6;
|
|
setState.getInitialState = () => closure_10;
|
|
function hydrate() {
|
|
if (storage) {
|
|
let c3 = false;
|
|
let item = set.forEach((arg0) => {
|
|
let tmp = callback();
|
|
if (null == tmp) {
|
|
tmp = closure_10;
|
|
}
|
|
return arg0(tmp);
|
|
});
|
|
const onRehydrateStorage = obj.onRehydrateStorage;
|
|
if (null == onRehydrateStorage) {
|
|
let closure_0 = tmp5;
|
|
const getItem = storage.getItem;
|
|
if (typeof outer1_9 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
closure_0 = getItem.bind(storage);
|
|
const bindResult = getItem.bind(storage);
|
|
const promise = ((closure_0) => {
|
|
try {
|
|
const tmp3 = bindResult(closure_0);
|
|
if (tmp3 instanceof Promise) {
|
|
let obj = tmp3;
|
|
} else {
|
|
obj = { then: null, catch: null };
|
|
obj[0] = function then(closure_0) {
|
|
if (typeof outer1_9 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
return (() => { ... })(closure_0);
|
|
};
|
|
obj[1] = function catch(arg0) {
|
|
return this;
|
|
};
|
|
}
|
|
return obj;
|
|
} catch (tmp6) {
|
|
let closure_1 = tmp6;
|
|
obj = { then: null, catch: null };
|
|
obj[0] = function then(arg0) {
|
|
return this;
|
|
};
|
|
obj[1] = function catch(arg0) {
|
|
if (typeof outer1_9 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let closure_0 = arg0;
|
|
return (() => { ... })(closure_1);
|
|
};
|
|
return obj;
|
|
}
|
|
})(obj.name);
|
|
let nextPromise = ((closure_0) => {
|
|
try {
|
|
const tmp3 = bindResult(closure_0);
|
|
if (tmp3 instanceof Promise) {
|
|
let obj = tmp3;
|
|
} else {
|
|
obj = { then: null, catch: null };
|
|
obj[0] = function then(closure_0) {
|
|
if (typeof outer1_9 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
return (() => { ... })(closure_0);
|
|
};
|
|
obj[1] = function catch(arg0) {
|
|
return this;
|
|
};
|
|
}
|
|
return obj;
|
|
} catch (tmp6) {
|
|
let closure_1 = tmp6;
|
|
obj = { then: null, catch: null };
|
|
obj[0] = function then(arg0) {
|
|
return this;
|
|
};
|
|
obj[1] = function catch(arg0) {
|
|
if (typeof outer1_9 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let closure_0 = arg0;
|
|
return (() => { ... })(closure_1);
|
|
};
|
|
return obj;
|
|
}
|
|
})(obj.name).then((version) => {
|
|
if (version) {
|
|
if (typeof version.version === "number") {
|
|
if (version.version !== closure_2.version) {
|
|
if (closure_2.migrate) {
|
|
const migrateResult = closure_2.migrate(version.state, version.version);
|
|
if (migrateResult instanceof Promise) {
|
|
let nextPromise = migrateResult.then((arg0) => {
|
|
const items = [true, arg0];
|
|
return items;
|
|
});
|
|
} else {
|
|
nextPromise = [true, migrateResult];
|
|
}
|
|
return nextPromise;
|
|
} else {
|
|
const _console = console;
|
|
console.error("State loaded from storage couldn't be migrated since no migrate function was provided");
|
|
}
|
|
}
|
|
}
|
|
let items = [false, version.state];
|
|
return items;
|
|
}
|
|
const items1 = [false, undefined];
|
|
return items1;
|
|
});
|
|
const nextPromise1 = ((closure_0) => {
|
|
try {
|
|
const tmp3 = bindResult(closure_0);
|
|
if (tmp3 instanceof Promise) {
|
|
let obj = tmp3;
|
|
} else {
|
|
obj = { then: null, catch: null };
|
|
obj[0] = function then(closure_0) {
|
|
if (typeof outer1_9 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
return (() => { ... })(closure_0);
|
|
};
|
|
obj[1] = function catch(arg0) {
|
|
return this;
|
|
};
|
|
}
|
|
return obj;
|
|
} catch (tmp6) {
|
|
let closure_1 = tmp6;
|
|
obj = { then: null, catch: null };
|
|
obj[0] = function then(arg0) {
|
|
return this;
|
|
};
|
|
obj[1] = function catch(arg0) {
|
|
if (typeof outer1_9 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let closure_0 = arg0;
|
|
return (() => { ... })(closure_1);
|
|
};
|
|
return obj;
|
|
}
|
|
})(obj.name).then((version) => {
|
|
if (version) {
|
|
if (typeof version.version === "number") {
|
|
if (version.version !== closure_2.version) {
|
|
if (closure_2.migrate) {
|
|
const migrateResult = closure_2.migrate(version.state, version.version);
|
|
if (migrateResult instanceof Promise) {
|
|
let nextPromise = migrateResult.then((arg0) => {
|
|
const items = [true, arg0];
|
|
return items;
|
|
});
|
|
} else {
|
|
nextPromise = [true, migrateResult];
|
|
}
|
|
return nextPromise;
|
|
} else {
|
|
const _console = console;
|
|
console.error("State loaded from storage couldn't be migrated since no migrate function was provided");
|
|
}
|
|
}
|
|
}
|
|
let items = [false, version.state];
|
|
return items;
|
|
}
|
|
const items1 = [false, undefined];
|
|
return items1;
|
|
}).then((arg0) => {
|
|
let tmp2;
|
|
let tmp3;
|
|
[tmp2, tmp3] = bindResult(arg0, 2);
|
|
let tmp6 = callback();
|
|
if (null == tmp6) {
|
|
tmp6 = closure_10;
|
|
}
|
|
const mergeResult = closure_2.merge(tmp3, tmp6);
|
|
let closure_9 = mergeResult;
|
|
bindResult(mergeResult, true);
|
|
if (tmp2) {
|
|
if (typeof closure_7 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let obj = {};
|
|
const merged = Object.assign(tmp5());
|
|
obj = { state: null, version: null };
|
|
obj[0] = closure_2.partialize(obj);
|
|
obj[1] = closure_2.version;
|
|
return item.setItem(closure_2.name, obj);
|
|
}
|
|
const tmp = bindResult(arg0, 2);
|
|
tmp5 = callback;
|
|
});
|
|
return ((closure_0) => {
|
|
try {
|
|
const tmp3 = bindResult(closure_0);
|
|
if (tmp3 instanceof Promise) {
|
|
let obj = tmp3;
|
|
} else {
|
|
obj = { then: null, catch: null };
|
|
obj[0] = function then(closure_0) {
|
|
if (typeof outer1_9 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
return (() => { ... })(closure_0);
|
|
};
|
|
obj[1] = function catch(arg0) {
|
|
return this;
|
|
};
|
|
}
|
|
return obj;
|
|
} catch (tmp6) {
|
|
let closure_1 = tmp6;
|
|
obj = { then: null, catch: null };
|
|
obj[0] = function then(arg0) {
|
|
return this;
|
|
};
|
|
obj[1] = function catch(arg0) {
|
|
if (typeof outer1_9 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let closure_0 = arg0;
|
|
return (() => { ... })(closure_1);
|
|
};
|
|
return obj;
|
|
}
|
|
})(obj.name).then((version) => {
|
|
if (version) {
|
|
if (typeof version.version === "number") {
|
|
if (version.version !== closure_2.version) {
|
|
if (closure_2.migrate) {
|
|
const migrateResult = closure_2.migrate(version.state, version.version);
|
|
if (migrateResult instanceof Promise) {
|
|
let nextPromise = migrateResult.then((arg0) => {
|
|
const items = [true, arg0];
|
|
return items;
|
|
});
|
|
} else {
|
|
nextPromise = [true, migrateResult];
|
|
}
|
|
return nextPromise;
|
|
} else {
|
|
const _console = console;
|
|
console.error("State loaded from storage couldn't be migrated since no migrate function was provided");
|
|
}
|
|
}
|
|
}
|
|
let items = [false, version.state];
|
|
return items;
|
|
}
|
|
const items1 = [false, undefined];
|
|
return items1;
|
|
}).then((arg0) => {
|
|
let tmp2;
|
|
let tmp3;
|
|
[tmp2, tmp3] = bindResult(arg0, 2);
|
|
let tmp6 = callback();
|
|
if (null == tmp6) {
|
|
tmp6 = closure_10;
|
|
}
|
|
const mergeResult = closure_2.merge(tmp3, tmp6);
|
|
let closure_9 = mergeResult;
|
|
bindResult(mergeResult, true);
|
|
if (tmp2) {
|
|
if (typeof closure_7 !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let obj = {};
|
|
const merged = Object.assign(tmp5());
|
|
obj = { state: null, version: null };
|
|
obj[0] = closure_2.partialize(obj);
|
|
obj[1] = closure_2.version;
|
|
return item.setItem(closure_2.name, obj);
|
|
}
|
|
const tmp = bindResult(arg0, 2);
|
|
tmp5 = callback;
|
|
}).then(() => {
|
|
if (null != closure_0) {
|
|
tmp(outer1_9, undefined);
|
|
}
|
|
outer1_9 = outer1_1();
|
|
let c3 = true;
|
|
const item = outer1_5.forEach((arg0) => arg0(closure_9));
|
|
}).catch((arg0) => {
|
|
if (null != closure_0) {
|
|
tmp(undefined, arg0);
|
|
}
|
|
});
|
|
} else {
|
|
const call = onRehydrateStorage.call;
|
|
let tmp8 = callback2();
|
|
if (null == tmp8) {
|
|
tmp8 = closure_10;
|
|
}
|
|
typeof call === "unknown" ? onRehydrateStorage(tmp8) : call(obj, tmp8);
|
|
let tmp6 = obj;
|
|
}
|
|
}
|
|
}
|
|
obj = { setOptions: null, clearStorage: null, getOptions: null, rehydrate: null, hasHydrated: null, onHydrate: null, onFinishHydration: null };
|
|
obj[0] = function setOptions(storage) {
|
|
const obj = {};
|
|
const merged = Object.assign(obj);
|
|
const merged1 = Object.assign(storage);
|
|
if (storage.storage) {
|
|
storage = storage.storage;
|
|
}
|
|
};
|
|
obj[1] = function clearStorage() {
|
|
if (null != storage) {
|
|
storage.removeItem(obj.name);
|
|
}
|
|
};
|
|
obj[2] = function getOptions() {
|
|
return obj;
|
|
};
|
|
obj[3] = function rehydrate() {
|
|
return hydrate();
|
|
};
|
|
obj[4] = function hasHydrated() {
|
|
return c3;
|
|
};
|
|
obj[5] = function onHydrate(arg0) {
|
|
let closure_0 = arg0;
|
|
set.add(arg0);
|
|
return () => {
|
|
outer1_4.delete(closure_0);
|
|
};
|
|
};
|
|
obj[6] = function onFinishHydration(arg0) {
|
|
let closure_0 = arg0;
|
|
set1.add(arg0);
|
|
return () => {
|
|
outer1_5.delete(closure_0);
|
|
};
|
|
};
|
|
setState.persist = obj;
|
|
if (!obj.skipHydration) {
|
|
hydrate();
|
|
}
|
|
let tmp9 = closure_9;
|
|
if (!closure_9) {
|
|
tmp9 = tmp6;
|
|
}
|
|
return tmp9;
|
|
} else {
|
|
return callback(() => {
|
|
const items = [...arguments];
|
|
console.warn("[zustand persist middleware] Unable to update item '" + obj.name + "', the given storage is currently unavailable.");
|
|
callback(...items);
|
|
}, arg1, setState);
|
|
}
|
|
};
|
|
}
|
|
export function redux(arg0, arg1) {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
return (arg0, arg1, arg2) => {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg2;
|
|
arg2.dispatch = (arg0) => {
|
|
const callback = arg0;
|
|
callback((arg0) => callback(arg0, callback), false, arg0);
|
|
return arg0;
|
|
};
|
|
arg2.dispatchFromDevtools = true;
|
|
const merged = Object.assign(closure_1);
|
|
return {
|
|
dispatch() {
|
|
const items = [...HermesBuiltin.copyRestArgs()];
|
|
return store.dispatch.apply(items);
|
|
}
|
|
};
|
|
};
|
|
}
|
|
export function subscribeWithSelector(arg0) {
|
|
let closure_0 = arg0;
|
|
return (arg0, arg1, subscribe) => {
|
|
const callback = subscribe;
|
|
subscribe = subscribe.subscribe;
|
|
subscribe.subscribe = (arg0, arg1, equalityFn) => {
|
|
const subscribe = arg0;
|
|
const subscribe2 = arg1;
|
|
let tmp = arg0;
|
|
if (arg1) {
|
|
equalityFn = undefined;
|
|
if (null != equalityFn) {
|
|
equalityFn = equalityFn.equalityFn;
|
|
}
|
|
if (!equalityFn) {
|
|
const _Object = Object;
|
|
equalityFn = Object.is;
|
|
}
|
|
let closure_3 = arg0(subscribe.getState());
|
|
let fireImmediately;
|
|
if (null != equalityFn) {
|
|
fireImmediately = equalityFn.fireImmediately;
|
|
}
|
|
const fn = function o(arg0) {
|
|
const tmp = callback(arg0);
|
|
if (!equalityFn(closure_3, tmp)) {
|
|
closure_3 = tmp;
|
|
callback2(tmp, closure_3);
|
|
}
|
|
};
|
|
tmp = fn;
|
|
if (fireImmediately) {
|
|
arg1(closure_3, closure_3);
|
|
tmp = fn;
|
|
}
|
|
}
|
|
return subscribe2(tmp);
|
|
};
|
|
return callback(arg0, arg1, subscribe);
|
|
};
|
|
}
|