@airma/react-effect
Version:
This is a react async state management tool
1,580 lines (1,555 loc) • 79.5 kB
JavaScript
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var index_exports = {};
__export(index_exports, {
ConfigProvider: () => ConfigProvider,
Provider: () => Provider,
Strategy: () => Strategy,
createSessionKey: () => createSessionKey,
createSessionStore: () => createSessionStore,
provide: () => provide,
session: () => session,
useIsFetching: () => useIsFetching,
useLazyComponent: () => useLazyComponent,
useLoadedSession: () => useLoadedSession,
useMutation: () => useMutation,
useQuery: () => useQuery,
useResponse: () => useResponse,
useSession: () => useSession
});
module.exports = __toCommonJS(index_exports);
// ../../../node_modules/@swc/helpers/esm/_define_property.js
function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value,
enumerable: true,
configurable: true,
writable: true
});
} else obj[key] = value;
return obj;
}
// ../../../node_modules/@swc/helpers/esm/_object_spread.js
function _object_spread(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys2 = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys2.forEach(function(key) {
_define_property(target, key, source[key]);
});
}
return target;
}
// ../../../node_modules/@swc/helpers/esm/_object_spread_props.js
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
if (enumerableOnly) {
symbols = symbols.filter(function(sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
});
}
keys.push.apply(keys, symbols);
}
return keys;
}
function _object_spread_props(target, source) {
source = source != null ? source : {};
if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
else {
ownKeys(Object(source)).forEach(function(key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
// ../../../node_modules/@swc/helpers/esm/_array_with_holes.js
function _array_with_holes(arr) {
if (Array.isArray(arr)) return arr;
}
// ../../../node_modules/@swc/helpers/esm/_iterable_to_array_limit.js
function _iterable_to_array_limit(arr, i) {
var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
if (_i == null) return;
var _arr = [];
var _n = true;
var _d = false;
var _s, _e;
try {
for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally {
try {
if (!_n && _i["return"] != null) _i["return"]();
} finally {
if (_d) throw _e;
}
}
return _arr;
}
// ../../../node_modules/@swc/helpers/esm/_non_iterable_rest.js
function _non_iterable_rest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
// ../../../node_modules/@swc/helpers/esm/_array_like_to_array.js
function _array_like_to_array(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
// ../../../node_modules/@swc/helpers/esm/_unsupported_iterable_to_array.js
function _unsupported_iterable_to_array(o, minLen) {
if (!o) return;
if (typeof o === "string") return _array_like_to_array(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(n);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
// ../../../node_modules/@swc/helpers/esm/_sliced_to_array.js
function _sliced_to_array(arr, i) {
return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
}
// ../../../node_modules/@swc/helpers/esm/_array_without_holes.js
function _array_without_holes(arr) {
if (Array.isArray(arr)) return _array_like_to_array(arr);
}
// ../../../node_modules/@swc/helpers/esm/_iterable_to_array.js
function _iterable_to_array(iter) {
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
return Array.from(iter);
}
}
// ../../../node_modules/@swc/helpers/esm/_non_iterable_spread.js
function _non_iterable_spread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
// ../../../node_modules/@swc/helpers/esm/_to_consumable_array.js
function _to_consumable_array(arr) {
return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
}
// src/index.ts
var import_react3 = require("react");
var import_react_state4 = require("@airma/react-state");
var import_react_hooks_core2 = require("@airma/react-hooks-core");
// ../../../node_modules/@swc/helpers/esm/_object_without_properties_loose.js
function _object_without_properties_loose(source, excluded) {
if (source == null) return {};
var target = {};
var sourceKeys = Object.keys(source);
var key, i;
for (i = 0; i < sourceKeys.length; i++) {
key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) continue;
target[key] = source[key];
}
return target;
}
// ../../../node_modules/@swc/helpers/esm/_object_without_properties.js
function _object_without_properties(source, excluded) {
if (source == null) return {};
var target = _object_without_properties_loose(source, excluded);
var key, i;
if (Object.getOwnPropertySymbols) {
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
for (i = 0; i < sourceSymbolKeys.length; i++) {
key = sourceSymbolKeys[i];
if (excluded.indexOf(key) >= 0) continue;
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
target[key] = source[key];
}
}
return target;
}
// src/libs/model.ts
var import_react_state = require("@airma/react-state");
function effectModel(state) {
var request = state.request, rest = _object_without_properties(state, [
"request"
]);
var mergeVersion = function(s) {
return _object_spread_props(_object_spread({}, s), {
request,
uniqueKey: state.uniqueKey
});
};
var checkIfANewRound = function(nextS) {
var roundStatus = nextS.roundStatus, s = _object_without_properties(nextS, [
"roundStatus"
]);
if (!roundStatus) {
return s;
}
if (roundStatus === "start") {
return _object_spread_props(_object_spread({}, s), {
stale: state.stale || {
data: state.data
}
});
}
return _object_spread_props(_object_spread({}, s), {
visited: state.visited ? state.visited : !s.isError,
round: state.round + 1,
lastSuccessfulRound: s.isError ? state.lastSuccessfulRound : state.round + 1,
lastFailedRound: s.isError ? state.round + 1 : state.lastFailedRound,
lastSuccessfulRoundVariables: s.isError ? state.lastSuccessfulRoundVariables : s.variables,
lastFailedRoundVariables: s.isError ? s.variables : state.lastFailedRoundVariables,
stale: void 0
});
};
var requestVersion = request ? request.version : 0;
return {
state: rest,
request,
onlyEndIsFetching: function onlyEndIsFetching() {
return _object_spread_props(_object_spread({}, state), {
isFetching: false
});
},
setState: function setState(s) {
if (typeof s !== "function") {
return checkIfANewRound(mergeVersion(s));
}
return checkIfANewRound(mergeVersion(s(state)));
},
trigger: function trigger() {
return _object_spread_props(_object_spread({}, state), {
request: {
version: requestVersion + 1
}
});
},
execute: function execute(variables) {
return _object_spread_props(_object_spread({}, state), {
request: {
version: requestVersion + 1,
variables
}
});
}
};
}
function globalController(fetchingKeys) {
return {
isFetching: fetchingKeys.length > 0,
setGlobalFetchingKey: function setGlobalFetchingKey(fetchingKey) {
var isFetching = fetchingKeys.some(function(k) {
return k === fetchingKey;
});
if (isFetching) {
return fetchingKeys;
}
return fetchingKeys.concat(fetchingKey);
},
removeGlobalFetchingKey: function removeGlobalFetchingKey(fetchingKey) {
var isFetching = fetchingKeys.some(function(k) {
return k === fetchingKey;
});
if (!isFetching) {
return fetchingKeys;
}
return fetchingKeys.filter(function(k) {
return k !== fetchingKey;
});
}
};
}
var defaultPromiseResult = function(config) {
return _object_spread({
data: void 0,
variables: void 0,
isError: false,
isFetching: false,
abandon: false,
triggerType: void 0,
loaded: false,
sessionLoaded: false,
cache: [],
maxCacheCapacity: 1,
round: 0,
executeVariables: void 0,
visited: false,
lastSuccessfulRound: 0,
lastFailedRound: 0,
lastSuccessfulRoundVariables: void 0,
lastFailedRoundVariables: void 0,
online: true
}, config);
};
function parseStoreMeta(callback) {
var storeLike = callback;
var isSessionKey = import_react_state.validations.isModelKey(callback);
var errorMessage = "API `useSession` can not use a session callback directly. Please set a session key or session store.";
if (!isSessionKey && !import_react_state.validations.isModelKey(storeLike.key)) {
throw new Error(errorMessage);
}
var sessionCaller = callback;
if (import_react_state.validations.isModelStore(sessionCaller) || import_react_state.validations.isModelKey(sessionCaller)) {
return sessionCaller;
}
if (!import_react_state.validations.isModelKey(storeLike.key)) {
throw new Error(errorMessage);
}
return sessionCaller.key;
}
function parseMeta(callback) {
var storeLike = callback;
var isSessionKey = import_react_state.validations.isModelKey(callback);
if (!isSessionKey && !import_react_state.validations.isModelKey(storeLike.key)) {
return callback;
}
var sessionCaller = callback;
if (import_react_state.validations.isModelStore(sessionCaller) || import_react_state.validations.isModelKey(sessionCaller)) {
return sessionCaller;
}
if (!import_react_state.validations.isModelKey(storeLike.key)) {
return callback;
}
return sessionCaller.key;
}
function parseEffect(callback, sessionType, config) {
var storeLike = callback;
var isSessionKey = import_react_state.validations.isModelKey(callback);
if (!isSessionKey && !import_react_state.validations.isModelKey(storeLike.key)) {
return [
effectModel,
callback,
config,
false
];
}
var sessionCaller = callback;
var caller = import_react_state.validations.isModelStore(sessionCaller) || import_react_state.validations.isModelKey(sessionCaller) ? sessionCaller : sessionCaller.key;
var sessionPayload = caller.sessionPayload;
var _sessionPayload = _sliced_to_array(sessionPayload, 2), effectCallback = _sessionPayload[0], _sessionPayload_ = _sessionPayload[1], keyType = _sessionPayload_.sessionType;
if (keyType != null && keyType !== sessionType) {
throw new Error("The sessionType is not matched, can not use '".concat(keyType, " type' sessionKey with '").concat(sessionType === "query" ? "useQuery" : "useMutation", "'"));
}
return [
caller,
effectCallback,
config,
true
];
}
function parseConfig(callback, sessionType, config) {
var cg = Array.isArray(config) ? {
variables: config
} : config;
var _parseEffect = _sliced_to_array(parseEffect(callback, sessionType, cg), 3), con = _parseEffect[2];
return con || {};
}
function useSessionBuildModel(callback, uniqueKey, sessionType, config) {
var cg = Array.isArray(config) ? {
variables: config
} : config;
var _parseEffect = _sliced_to_array(parseEffect(callback, sessionType, cg), 4), model2 = _parseEffect[0], effectCallback = _parseEffect[1], con = _parseEffect[2], isSessionKeyOrStore = _parseEffect[3];
var configuration = con || {};
var defaultData = configuration.defaultData, loaded = configuration.loaded;
var hasDefaultData = Object.prototype.hasOwnProperty.call(configuration, "defaultData");
var modelParams = (function computeParams() {
if (!isSessionKeyOrStore) {
return [
model2,
defaultPromiseResult(hasDefaultData ? {
data: defaultData,
uniqueKey,
loaded: true
} : void 0)
];
}
return hasDefaultData ? [
model2,
defaultPromiseResult({
data: defaultData,
uniqueKey: callback,
loaded: true
})
] : [
model2
];
})();
var signal = import_react_state.useSignal.apply(void 0, _to_consumable_array(modelParams));
var stableInstance = signal();
if (loaded && !stableInstance.state.loaded) {
throw new Error('This session is not loaded, you should remove "config.loaded" option.');
}
return [
stableInstance,
signal,
configuration,
effectCallback
];
}
function createSessionKey(effectCallback, sessionType) {
var modelKey = (0, import_react_state.createKey)(effectModel, defaultPromiseResult());
var effectCallbackReplace = function effectCallbackReplace2() {
for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
params[_key] = arguments[_key];
}
return effectCallback.apply(void 0, _to_consumable_array(params));
};
modelKey.sessionPayload = [
effectCallbackReplace,
sessionType ? {
sessionType
} : {}
];
return modelKey;
}
function createSessionStore(effectCallback, sessionType) {
var modelStore = (0, import_react_state.createStore)(effectModel, defaultPromiseResult());
var effectCallbackReplace = function effectCallbackReplace2() {
for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
params[_key] = arguments[_key];
}
return effectCallback.apply(void 0, _to_consumable_array(params));
};
var createSessionPayload = function() {
return [
effectCallbackReplace,
sessionType ? {
sessionType
} : {}
];
};
modelStore.sessionPayload = createSessionPayload();
modelStore.key.sessionPayload = createSessionPayload();
return modelStore;
}
// src/libs/global.ts
var import_react_state2 = require("@airma/react-state");
var import_react = require("react");
var defaultIsFetchingState = [];
var globalControllerStore = (0, import_react_state2.model)(globalController).createStore(defaultIsFetchingState);
var GlobalConfigContext = (0, import_react.createContext)(null);
function ConfigProvider(param) {
var value = param.value, children = param.children;
var stateConfig = (0, import_react.useMemo)(function() {
if (value == null) {
return void 0;
}
var batchUpdate = value.batchUpdate, test = value.test;
return {
batchUpdate,
test
};
}, []);
var child = (0, import_react.createElement)(GlobalConfigContext.Provider, {
value
}, children);
return (0, import_react.createElement)(import_react_state2.ConfigProvider, {
value: stateConfig
}, child);
}
function useGlobalConfig() {
return (0, import_react.useContext)(GlobalConfigContext);
}
// src/libs/strategy.ts
var import_react2 = require("react");
var import_react_hooks_core = require("@airma/react-hooks-core");
var import_react_state3 = require("@airma/react-state");
function composeStrategies(strategies) {
return function strategy(v) {
var tempSessionSetters = [];
var defaultStrategy = function(value) {
return value.runner(function(s) {
return tempSessionSetters.reduce(function(r, c) {
if (r.abandon) {
return r;
}
return c(r);
}, s);
});
};
var storeSlots = v.localCache.current;
var callback = _to_consumable_array(strategies).reverse().reduce(function(r, c, i) {
var storage = storeSlots[i] || {
current: void 0
};
return function middle(value) {
var nextValue = _object_spread_props(_object_spread({}, value), {
localCache: storage
});
if (c == null) {
return r(nextValue);
}
var nextRunner = function(setSessionState) {
if (setSessionState != null) {
tempSessionSetters.push(setSessionState);
}
if (nextValue.getSessionToken().status === "abandon") {
var currentState = nextValue.getSessionState();
return Promise.resolve(_object_spread_props(_object_spread({}, currentState), {
abandon: true
}));
}
return r(nextValue).then(function(d) {
return nextValue.getSessionToken().status === "abandon" ? _object_spread_props(_object_spread({}, d), {
abandon: true
}) : d;
});
};
return c(_object_spread_props(_object_spread({}, nextValue), {
runner: nextRunner
}));
};
}, defaultStrategy);
return callback(v).then(function(d) {
var _v_getSessionState = v.getSessionState(), loaded = _v_getSessionState.loaded, sessionLoaded = _v_getSessionState.sessionLoaded;
var abandon = d.abandon, isError = d.isError, isFetching = d.isFetching;
var currentLoaded = loaded || !abandon && !isError && !isFetching;
var currentIsSessionLoaded = sessionLoaded || !abandon && !isError && !isFetching;
return _object_spread_props(_object_spread({}, d), {
loaded: currentLoaded,
sessionLoaded: currentIsSessionLoaded
});
});
};
}
function toStrategies(strategy) {
if (Array.isArray(strategy)) {
return {
list: strategy
};
}
if (strategy == null || typeof strategy === "function") {
return {
list: [
strategy
]
};
}
return strategy;
}
function createRuntimeCache() {
var runtimeCacheStore = [];
var fetchTuple = function(key) {
var data = runtimeCacheStore.find(function(param) {
var _param = _sliced_to_array(param, 1), k = _param[0];
return k === key;
});
if (!Array.isArray(data)) {
return void 0;
}
return data;
};
return {
set: function set(key, value) {
var data = fetchTuple(key);
if (data) {
data[1] = value;
return;
}
runtimeCacheStore.push([
key,
value
]);
},
get: function get(key) {
var tuple = fetchTuple(key);
if (!tuple) {
return void 0;
}
return tuple[1];
}
};
}
function useSessionToken() {
var tokensRef = (0, import_react2.useRef)([]);
var createToken = function() {
var currentTokens = tokensRef.current;
var token = {
status: "normal",
abandon: function abandon() {
throw new Error("This Session token has not been initialized");
},
silence: function silence() {
throw new Error("This Session token has not been initialized");
}
};
token.abandon = function abandon(tokens) {
if (tokens != null) {
tokens.forEach(function(t) {
t.abandon();
});
return;
}
token.status = "abandon";
tokensRef.current = tokensRef.current.filter(function(t) {
return t !== token;
});
};
token.silence = function silence() {
if (token.status === "abandon") {
return;
}
token.status = "silent";
};
tokensRef.current = _to_consumable_array(currentTokens).concat([
token
]);
return token;
};
return {
createToken,
removeToken: function removeToken(token) {
tokensRef.current = tokensRef.current.filter(function(t) {
return t !== token;
});
},
getTokens: function getTokens() {
return tokensRef.current;
}
};
}
function useStrategyExecution(signal, sessionRunner, config) {
var sessionTokens = useSessionToken();
var processor = (0, import_react_state3.useActProcess)();
var strategy = config.strategy;
var _toStrategies = toStrategies(strategy), strategies = _toStrategies.list;
var strategyStoreRef = (0, import_react2.useRef)(strategies.map(function() {
return {
current: void 0
};
}));
var unmountRef = (0, import_react2.useRef)(false);
(0, import_react_hooks_core.useUnmount)(function() {
unmountRef.current = true;
});
var effects = strategies.map(function(s) {
if (!s) {
return void 0;
}
return s.effect;
}).filter(function(e) {
return !!e;
}).reverse();
return [
function callWithStrategy(triggerType, payload, variables) {
var runtimeVariables = variables || [];
var runner = function runner2(setSessionState) {
var _signal = signal(), current = _signal.state, setState = _signal.setState;
var initialFetchingState = current;
var fetchingState = setSessionState ? setSessionState(initialFetchingState) : _object_spread_props(_object_spread({}, initialFetchingState), {
abandon: true
});
if (!fetchingState.abandon) {
processor.act(function() {
setState(_object_spread_props(_object_spread({}, fetchingState), {
triggerType
}));
});
}
return sessionRunner(triggerType, payload, runtimeVariables);
};
var execute = function execute2(tType, pd, vars) {
return sessionRunner(tType, pd, vars);
};
var token = sessionTokens.createToken();
var requires = {
getSessionState: function() {
var s = signal().state;
var online = !signal.store.isDestroyed();
return _object_spread_props(_object_spread({}, s), {
online
});
},
getSessionToken: function() {
return token;
},
getSessionWork: function() {
return {
online: !unmountRef.current
};
},
abandon: function abandon(data) {
return data ? _object_spread_props(_object_spread({}, data), {
abandon: true
}) : _object_spread_props(_object_spread({}, signal().state), {
abandon: true
});
},
variables: runtimeVariables,
runner,
execute,
triggerType,
config,
payload,
localCache: strategyStoreRef,
executeContext: createRuntimeCache()
};
function ifFetching() {
return !!sessionTokens.getTokens().filter(function(t) {
return t.status === "normal";
}).length;
}
var roundWork = composeStrategies(strategies)(requires);
processor.act(function() {
signal().setState(_object_spread_props(_object_spread({}, signal().state), {
isFetching: ifFetching(),
roundStatus: "start"
}));
});
return roundWork.then(function(data) {
if (token.status !== "abandon") {
sessionTokens.removeToken(token);
}
var currentState = signal().state;
var isFetching = ifFetching();
if (data.abandon) {
if (!isFetching && currentState.isFetching) {
processor.act(function() {
signal().onlyEndIsFetching();
});
}
return _object_spread_props(_object_spread({}, currentState), {
abandon: true
});
}
processor.act(function() {
signal().setState(_object_spread_props(_object_spread({}, data), {
isFetching,
roundStatus: "end"
}));
});
return data;
});
},
effects
];
}
function latest() {
return function latestStrategy(requires) {
var runner = requires.runner, localCache = requires.localCache, getSessionToken = requires.getSessionToken;
var token = getSessionToken();
localCache.current = localCache.current || {
version: null,
tokens: []
};
var tokens = localCache.current.tokens;
var version = token;
localCache.current = {
version,
tokens: _to_consumable_array(tokens).concat([
token
])
};
return runner().then(function(sessionData) {
if (localCache.current.version === version) {
var otherTokens = localCache.current.tokens.filter(function(t) {
return t !== token;
});
token.abandon(otherTokens);
localCache.current = {
version: null,
tokens: []
};
}
return sessionData;
});
};
}
function block() {
return function blockStrategy(requires) {
var runner = requires.runner, localCache = requires.localCache, triggerType = requires.triggerType, abandon = requires.abandon;
if (triggerType !== "manual") {
return runner();
}
if (localCache.current) {
return localCache.current.then(function(sessionData) {
return abandon(sessionData);
});
}
var promise = runner();
localCache.current = promise.then(function(sessionData) {
localCache.current = void 0;
return sessionData;
});
return promise;
};
}
// src/libs/tools.ts
function warn(message) {
var error = new Error(message);
if (typeof console !== "undefined" && typeof console.error === "function") {
console.error(error);
}
try {
throw error;
} catch (e) {
}
}
var logger = {
warn
};
// ../../../node_modules/@swc/helpers/esm/_to_array.js
function _to_array(arr) {
return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_rest();
}
// ../../../node_modules/@swc/helpers/esm/_type_of.js
function _type_of(obj) {
"@swc/helpers - typeof";
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
// src/strategies.ts
function noop() {
}
function debounce(op) {
var time = typeof op === "number" ? op : op.duration;
var lead = typeof op === "number" ? false : !!op.lead;
return function db(value) {
function leading() {
var abandon = value.abandon, runner = value.runner, store = value.localCache, getSessionToken = value.getSessionToken;
if (store.current && store.current.id) {
clearTimeout(store.current.id);
store.current.id = void 0;
}
var timeoutId = setTimeout(function() {
store.current = void 0;
}, time);
if (store.current != null) {
getSessionToken().abandon();
store.current.id = timeoutId;
return store.current.promise.then(function(d) {
return abandon(d);
});
}
var defaultPromise = new Promise(function(resolve) {
resolve(abandon());
});
var storeRef = {
id: timeoutId,
version: 0,
resolve: function() {
return void 0;
},
promise: defaultPromise
};
var promise = new Promise(function(resolve) {
resolve(runner());
storeRef.resolve = resolve;
});
storeRef.promise = promise;
store.current = storeRef;
return promise;
}
function normal() {
var current = value.getSessionState, abandon = value.abandon, runner = value.runner, store = value.localCache;
if (store.current) {
var _store_current = store.current, id = _store_current.id, resolve = _store_current.resolve;
clearTimeout(id);
store.current.id = setTimeout(function() {
store.current = void 0;
resolve(runner());
}, time);
store.current.version += 1;
var cVersion = store.current.version;
return store.current.promise.then(function(d) {
var _store_current2;
return cVersion === ((_store_current2 = store.current) === null || _store_current2 === void 0 ? void 0 : _store_current2.version) || 0 ? d : abandon(d);
});
}
var defaultPromise = new Promise(function(resolve2) {
resolve2(abandon());
});
var storeRef = {
id: null,
version: 0,
resolve: function() {
return void 0;
},
promise: defaultPromise
};
var promise = new Promise(function(resolve2) {
storeRef.id = setTimeout(function() {
store.current = void 0;
resolve2(runner());
}, time);
storeRef.resolve = resolve2;
});
storeRef.promise = promise;
store.current = storeRef;
var currentVersion = storeRef.version;
return promise.then(function(d) {
var _store_current2;
return ((_store_current2 = store.current) === null || _store_current2 === void 0 ? void 0 : _store_current2.version) || currentVersion === 0 ? d : abandon(d);
});
}
return lead ? leading() : normal();
};
}
function once() {
return function oc(runtime) {
var runner = runtime.runner, store = runtime.localCache, abandon = runtime.abandon;
if (store.current) {
return store.current.then(function(d) {
return abandon(d);
});
}
store.current = runner().then(function(d) {
if (d.isError) {
store.current = void 0;
}
return d;
});
return store.current;
};
}
var stringifyComparator = function comparator(s, t) {
if (Object.is(s, t)) {
return true;
}
if (s == null || t == null) {
return false;
}
return JSON.stringify(s) === JSON.stringify(t);
};
function memo() {
var equalFn = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : stringifyComparator;
return function mo(value) {
var runner = value.runner, current = value.getSessionState;
return runner().then(function(d) {
var state = current();
if (typeof equalFn === "function" ? equalFn(state.data, d.data) : state.data === d.data) {
return _object_spread_props(_object_spread({}, d), {
data: state.data
});
}
return d;
});
};
}
function throttle(op) {
var duration = (function computeDuration() {
if (op == null) {
return void 0;
}
return typeof op === "number" ? op : op.duration;
})();
function hasChanged(cacheVariables, variables) {
if (cacheVariables == null) {
return true;
}
var equality = stringifyComparator(cacheVariables, variables);
return !equality;
}
return function th(value) {
var current = value.getSessionState, runner = value.runner, store = value.localCache, _value_variables = value.variables, variables = _value_variables === void 0 ? [] : _value_variables;
store.current = store.current || {
timeoutId: null,
variables: void 0
};
var storedVariables = store.current.variables;
var timeoutId = store.current.timeoutId;
if (!hasChanged(storedVariables, variables) && (timeoutId != null || duration == null)) {
return new Promise(function(resolve) {
resolve(current());
});
}
store.current.variables = variables;
if (duration == null) {
return runner();
}
if (timeoutId != null) {
clearTimeout(timeoutId);
}
store.current.timeoutId = setTimeout(function() {
store.current = store.current || {};
store.current.timeoutId = null;
}, duration);
return runner();
};
}
function reduce(call) {
return function reduceStrategy(requires) {
var runner = requires.runner, current = requires.getSessionState;
return runner().then(function(d) {
if (d.isError || d.abandon) {
return d;
}
var state = current();
var newData = call(state.data, d.data, [
state,
d
]);
return _object_spread_props(_object_spread({}, d), {
data: newData
});
});
};
}
function failure(process, option) {
var unit = {
process,
option,
type: "process"
};
var next = function next2(value) {
var runner = value.runner, runtimeCache = value.executeContext, getSessionWork = value.getSessionWork, config = value.config;
var failureProcessUnits = runtimeCache.get(failure) || [];
var processUnits = [
unit
].concat(_to_consumable_array(failureProcessUnits));
runtimeCache.set(failure, processUnits);
return runner().then(function(d) {
var failureProcesses = runtimeCache.get(failure) || [];
var online = getSessionWork().online;
var validateFailureProcesses = failureProcesses.filter(function(s) {
return online || s.type === "process";
});
if (!validateFailureProcesses.length || validateFailureProcesses.some(function(t) {
return t.type !== "process";
})) {
return d;
}
var _validateFailureProcesses = _sliced_to_array(validateFailureProcesses, 1), start = _validateFailureProcesses[0];
if (start !== unit || !d.isError) {
return d;
}
processUnits.reduce(function(res, param) {
var p = param.process, o = param.option, t = param.type;
if (!res.isError || t === "response.process") {
return res;
}
if (res.abandon && !(o === null || o === void 0 ? void 0 : o.withAbandoned)) {
return res;
}
try {
p(res.error, d);
return _object_spread_props(_object_spread({}, d), {
isError: false,
error: void 0
});
} catch (e) {
return _object_spread_props(_object_spread({}, d), {
isError: true,
error: e
});
}
}, d);
return d;
});
};
var er = function er2(value) {
return next(value);
};
er.process = process;
er.from = failure;
return er;
}
function success(process, option) {
var withAbandoned = (option || {}).withAbandoned;
return function sc(value) {
var runner = value.runner, store = value.localCache;
store.current = process;
return runner().then(function(d) {
var currentProcess = store.current;
if (!d.isError && currentProcess && (!d.abandon || withAbandoned)) {
currentProcess(d.data, d);
}
return d;
});
};
}
function validate(callback) {
return function validStrategy(param) {
var runner = param.runner, abandon = param.abandon, current = param.getSessionState, getSessionToken = param.getSessionToken, variables = param.variables;
var result = callback(variables, function() {
return current().online;
});
if (!result) {
getSessionToken().abandon();
return new Promise(function(resolve) {
resolve(abandon());
});
}
if ((typeof result === "undefined" ? "undefined" : _type_of(result)) === "object" && typeof result.then === "function") {
return result.then(function(r) {
if (!r) {
return new Promise(function(resolve) {
resolve(abandon());
});
}
return runner();
}, function() {
return new Promise(function(resolve) {
resolve(abandon());
});
});
}
return runner();
};
}
function response(callback) {
var sc = function sc2(value) {
var runner = value.runner;
return runner();
};
sc.effect = [
function responseEffect(s, p) {
var res = callback(s);
if (typeof res === "function") {
return res;
}
return noop;
},
function(s, p) {
return s.round !== 0 && s.round !== p.round;
}
];
return sc;
}
response.success = function responseSuccess(process) {
var sc = function sc2(value) {
var runner = value.runner;
return runner();
};
sc.effect = [
function effectCallback(state, prevState) {
if (state.round === 0 || state.round === prevState.round || !state.loaded) {
return noop;
}
if (state.isError || !state.sessionLoaded) {
return noop;
}
var res = process(state.data, state);
if (typeof res === "function") {
return res;
}
return noop;
},
function(state, prevState) {
if (state.round === 0 || state.round === prevState.round || !state.loaded) {
return false;
}
if (state.isError || !state.sessionLoaded) {
return false;
}
return true;
}
];
return sc;
};
var responseFailure = function responseFailure2(process) {
var unit = {
process,
type: "response.process"
};
var sc = function sc2(value) {
var runner = value.runner, runtimeCache = value.executeContext, config = value.config;
var failureProcessUnits = runtimeCache.get(failure) || [];
var processUnits = [
unit
].concat(_to_consumable_array(failureProcessUnits));
runtimeCache.set(failure, processUnits);
return runner();
};
sc.effect = [
function effectCallback(state, prevState, config, context) {
if (!state.isError) {
return noop;
}
var strategy = config.strategy;
var sourceStrategies = (function pickStrategies() {
if (!strategy) {
return [];
}
if (Array.isArray(strategy)) {
return strategy;
}
if (typeof strategy === "function") {
return [
strategy
];
}
return strategy.list;
})();
var strategies = _to_consumable_array(sourceStrategies).reverse();
var currentIndex = strategies.indexOf(sc);
if (context.get(responseFailure2) != null) {
return noop;
}
context.set(responseFailure2, currentIndex);
var failureStrategies = strategies.filter(function(s, ind) {
return typeof s === "function" && (s.from === failure || s.from === responseFailure2) && ind >= currentIndex;
});
var failureProcesses = failureStrategies.map(function(s) {
return s.process;
});
var destroy = failureProcesses.reduce(function(result, current) {
var stateInReduce = result.state;
if (!stateInReduce.isError) {
return result;
}
try {
var r = current(stateInReduce.error, stateInReduce);
return {
state: _object_spread_props(_object_spread({}, stateInReduce), {
error: void 0,
isError: false
}),
destroy: typeof r === "function" ? r : noop
};
} catch (e) {
return {
state: _object_spread_props(_object_spread({}, stateInReduce), {
error: e
}),
destroy: noop
};
}
}, {
state,
destroy: noop
}).destroy;
var res = destroy;
if (typeof res === "function") {
return res;
}
return noop;
},
function(state, prevState) {
if (state.round === 0 || state.round === prevState.round) {
return false;
}
if (!state.isError) {
return false;
}
return true;
}
];
sc.from = responseFailure2;
sc.process = process;
return sc;
};
response.failure = responseFailure;
function now() {
return (/* @__PURE__ */ new Date()).getTime();
}
function cacheOperation(cacheRecords, size) {
var cacheLimit = size == null ? 1 : size;
function getByKey(c, k) {
var found = c.find(function(param) {
var _param = _sliced_to_array(param, 1), ke = _param[0];
return ke === k;
}) || [
void 0,
void 0
];
var _found = _sliced_to_array(found, 2), v = _found[1];
return v;
}
return {
get: function(k) {
return getByKey(cacheRecords, k);
},
set: function set(k, data) {
if (cacheLimit < 1) {
return [];
}
var updater = {
data,
lastUpdateTime: now()
};
var target = getByKey(cacheRecords, k);
if (target != null) {
return cacheRecords.map(function(param) {
var _param = _sliced_to_array(param, 2), ke = _param[0], va = _param[1];
if (k !== ke) {
return [
ke,
va
];
}
return [
k,
updater
];
});
}
var cacheData = _to_consumable_array(cacheRecords).concat([
[
k,
updater
]
]);
return cacheData.length > cacheLimit ? cacheData.slice(cacheData.length - cacheLimit) : cacheData;
}
};
}
function cache(option) {
function defaultKeyBy(vars) {
return JSON.stringify(vars);
}
var _ref = option || {}, tmp = _ref.key, keyBy = tmp === void 0 ? defaultKeyBy : tmp, staleTime = _ref.staleTime, tmp1 = _ref.capacity, cp = tmp1 === void 0 ? 1 : tmp1, isStatic = _ref.static;
return function cacheStrategy(requies) {
var getSessionState = requies.getSessionState, getSessionToken = requies.getSessionToken, runner = requies.runner, variables = requies.variables;
var currentState = getSessionState();
var cacheInState = currentState.cache;
var variableKey = keyBy(variables);
var cacheData = cacheOperation(cacheInState, cp).get(variableKey);
if (cacheData && (staleTime && now() < staleTime + cacheData.lastUpdateTime || isStatic)) {
var cacheState = _object_spread_props(_object_spread({}, currentState), {
data: cacheData.data,
variables,
visited: true
});
getSessionToken().silence();
return new Promise(function(resolve) {
resolve(cacheState);
});
}
return runner(function(c) {
return cacheData && (!staleTime || staleTime < 0) ? _object_spread_props(_object_spread({}, c), {
data: cacheData.data,
visited: true
}) : _object_spread_props(_object_spread({}, c), {
visited: false
});
}).then(function(next) {
if (next.isError) {
return _object_spread_props(_object_spread({}, next), {
data: next.stale ? next.stale.data : next.data
});
}
var nextKey = keyBy(next.variables || []);
var maxCacheCapacity = getSessionState().maxCacheCapacity;
var capacity = maxCacheCapacity < cp ? cp : maxCacheCapacity;
var nextCache = cacheOperation(next.cache, capacity).set(nextKey, next.data);
return _object_spread_props(_object_spread({}, next), {
cache: nextCache,
maxCacheCapacity: capacity
});
});
};
}
function atomic(option) {
var _ref = option !== null && option !== void 0 ? option : {}, tmp = _ref.throttle, t = tmp === void 0 ? true : tmp, _ref_stopWhenError = _ref.stopWhenError, stopWhenError = _ref_stopWhenError === void 0 ? true : _ref_stopWhenError, defineTask = _ref.defineTask;
return function atomicStrategy(requires) {
var runner = requires.runner, abandon = requires.abandon, localCache = requires.localCache, triggerType = requires.triggerType, payload = requires.payload, variables = requires.variables, execute = requires.execute;
if (localCache.current) {
localCache.current.queue = t ? [
{
triggerType,
payload,
variables
}
] : _to_consumable_array(localCache.current.queue).concat([
{
triggerType,
payload,
variables
}
]);
return localCache.current.promise.then(function(sessionData) {
return abandon(sessionData);
});
}
var promise = runner();
var consumeCacheQueue = function consumeCacheQueue2(lastSessionData) {
if (lastSessionData.isError && stopWhenError) {
return new Promise(function(resolve) {
resolve(lastSessionData);
});
}
var currentCache = localCache.current;
if (!currentCache || !currentCache.queue.length) {
return new Promise(function(resolve) {
resolve(lastSessionData);
});
}
var _currentCache_queue = _to_array(currentCache.queue), lastTask = _currentCache_queue[0], rest = _currentCache_queue.slice(1);
var taskFragments = defineTask ? (function defineTaskFragment() {
var task = defineTask(lastTask, lastSessionData);
if (!Array.isArray(task)) {
return [
task
];
}
return task;
})() : [
lastTask
];
var _taskFragments = _to_array(taskFragments), currentTask = _taskFragments[0], restFragments = _taskFragments.slice(1);
localCache.current.queue = _to_consumable_array(restFragments).concat(_to_consumable_array(rest));
var _currentTask_variables;
return execute(currentTask.triggerType, currentTask.payload, (_currentTask_variables = currentTask.variables) !== null && _currentTask_variables !== void 0 ? _currentTask_variables : []).then(function(data) {
return consumeCacheQueue2(data);
});
};
localCache.current = {
queue: [],
promise: promise.then(function(sessionData) {
return consumeCacheQueue(sessionData).then(function(data) {
localCache.current = void 0;
return data;
});
})
};
return localCache.current.promise;
};
}
var Strategy = {
atomic,
cache,
debounce,
failure,
memo,
once,
success,
throttle,
validate,
reduce,
response
};
// src/index.ts
function noop2() {
}
function useInitialize(callback) {
var ref = (0, import_react3.useRef)(null);
if (ref.current == null) {
ref.current = {
result: callback()
};
return ref.current.result;
}
return ref.current.result;
}
function toNoRejectionPromiseCallback(callback) {
return function noRejectionPromiseCallback(payload, variables) {
var result = callback(variables);
if (!result || typeof result.then !== "function") {
throw new Error("The callback have to return a promise object.");
}
return result.then(function(d) {
return {
data: d,
variables,
payload,
error: void 0,
isError: false
};
}, function(e) {
return {
variables,
payload,
error: e,
isError: true
};
});
};
}
function useController(signal) {
function getController() {
var payload = signal.store.payload();
return payload;
}
return {
getData: function getData(key) {
var controller = getController();
if (controller == null || controller.data == null) {
return null;
}
return controller.data[key];
},
setData: function setData(key, data) {
var controller = getController();
if (controller == null) {
return;
}
controller.data = _object_spread_props(_object_spread({}, controller.data || {}), _define_property({}, key, data));
}
};
}
function useFetchingKey(controller) {
return {
getFetchingKey: function getFetchingKey() {
return controller.getData("fetchingKey");
},
getFinalFetchingKey: function getFinalFetchingKey() {
return controller.getData("finalFetchingKey");
},
setFetchingKey: function setFetchingKey(key) {
controller.setData("fetchingKey", key);
if (key == null) {
return;
}
controller.setData("finalFetchingKey", key);
},
removeFetchingKey: function removeFetchingKey(key) {
if (key !== controller.getData("fetchingKey")) {
return;
}
controller.setData("fetchingKey", void 0);
}
};
}
function usePromise(controller) {
return {
requirePromise: function requirePromise(name) {
var resolver = {
name,
resolve: function(data) {
},
reject: function(data) {
}
};
var promise = new Promise(function(resolve, reject) {
resolver.resolve = resolve;
resolver.reject = reject;
});
var resolvers = controller.getData("resolvers") || [];
controller.setData("resolvers", _to_consumable_array(resolvers).concat([
resolver
]));
return promise;
},
responsePromise: function responsePromise(sessionState) {
var resolvers = controller.getData("resolvers") || [];
controller.setData("resolvers", void 0);
resolvers.forEach(function(param) {
var resolve = param.resolve, name = param.name;
resolve(sessionState);
});
}
};
}
function useTunnels(controller) {
var getTunnels = function getTunnels2() {
return controller.getData("tunnels") || [];
};
return {
getTunnels,
registry: function registry(tunnel) {
var tunnels = getTunnels();
if (tun