359 lines
11 KiB
JavaScript
359 lines
11 KiB
JavaScript
// Module ID: 619
|
|
// Function ID: 7066
|
|
// Name: _isNativeReflectConstruct
|
|
// Dependencies: []
|
|
// Exports: createFetchStore
|
|
|
|
// Module 619 (_isNativeReflectConstruct)
|
|
function _isNativeReflectConstruct() {
|
|
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
|
|
|
|
}));
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
const result = _isNativeReflectConstruct();
|
|
}
|
|
function coerceRetryAfterSecs(arg0) {
|
|
if ("number" === typeof arg0) {
|
|
const _Number = Number;
|
|
if (Number.isFinite(arg0)) {
|
|
if (arg0 > 0) {
|
|
return arg0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function areStatesEqual(arg0, arg1) {
|
|
if (Array.isArray(arg0)) {
|
|
const _Array = Array;
|
|
if (Array.isArray(arg1)) {
|
|
let result = arg1(dependencyMap[9]).areArraysShallowEqual(arg0, arg1);
|
|
const obj = arg1(dependencyMap[9]);
|
|
}
|
|
return result;
|
|
}
|
|
result = Object.is(arg0, arg1);
|
|
}
|
|
function defaultRetryableErrors(status) {
|
|
let tmp = status instanceof closure_14;
|
|
if (tmp) {
|
|
let tmp2 = status.status >= 500;
|
|
if (!tmp2) {
|
|
tmp2 = 429 === status.status;
|
|
}
|
|
tmp = tmp2;
|
|
}
|
|
return tmp;
|
|
}
|
|
function defaultBackoff() {
|
|
let tmp = importDefault(dependencyMap[10]);
|
|
tmp = new tmp();
|
|
return tmp;
|
|
}
|
|
let closure_3 = importDefault(dependencyMap[0]);
|
|
let closure_4 = importDefault(dependencyMap[1]);
|
|
let closure_5 = importDefault(dependencyMap[2]);
|
|
let closure_6 = importDefault(dependencyMap[3]);
|
|
let closure_7 = importDefault(dependencyMap[4]);
|
|
let closure_8 = importDefault(dependencyMap[5]);
|
|
let closure_9 = importDefault(dependencyMap[6]);
|
|
const importDefaultResult = importDefault(dependencyMap[7]);
|
|
({ useCallback: closure_10, useEffect: closure_11, useState: closure_12 } = arg1(dependencyMap[8]));
|
|
const SymbolResult = Symbol("NO_DATA");
|
|
let closure_14 = (arg0) => {
|
|
class HTTPResponseError {
|
|
constructor(arg0) {
|
|
self = this;
|
|
items = [...arguments];
|
|
tmp = closure_5(this, HTTPResponseError);
|
|
items1 = [...items];
|
|
obj = closure_8(HTTPResponseError);
|
|
tmp2 = closure_7;
|
|
if (closure_16()) {
|
|
tmp4 = globalThis;
|
|
_Reflect = Reflect;
|
|
tmp5 = closure_8;
|
|
constructResult = Reflect.construct(obj, items1, closure_8(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, items1);
|
|
}
|
|
tmp2Result = tmp2(self, constructResult);
|
|
tmp2Result.name = "HTTPResponseError";
|
|
tmp2Result.status = 0;
|
|
return tmp2Result;
|
|
}
|
|
}
|
|
const arg1 = HTTPResponseError;
|
|
callback3(HTTPResponseError, arg0);
|
|
let obj = {
|
|
key: "setStatus",
|
|
value(status) {
|
|
this.status = status;
|
|
}
|
|
};
|
|
const items = [obj, ];
|
|
obj = {
|
|
key: "setRetryAfter",
|
|
value(retryAfter) {
|
|
this.retryAfter = retryAfter;
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
return callback2(HTTPResponseError, items);
|
|
}(importDefaultResult(Error));
|
|
const tmp3 = arg1(dependencyMap[8]);
|
|
let closure_15 = arg1(dependencyMap[11]).create(() => {
|
|
const obj = { "Null": true, "Null": true, "Null": true, "Null": true, "Null": true };
|
|
let tmp = importDefault(dependencyMap[10]);
|
|
tmp = new tmp();
|
|
obj.backoff = tmp;
|
|
return obj;
|
|
});
|
|
const obj = arg1(dependencyMap[11]);
|
|
const result = arg1(dependencyMap[13]).fileFinishedImporting("../discord_common/js/packages/flux/createFetchStore.tsx");
|
|
|
|
export const NO_DATA = SymbolResult;
|
|
export const createFetchStore = function createFetchStore(importDefaultResult, arg1) {
|
|
let retryConfig;
|
|
arg1 = importDefaultResult;
|
|
({ getQueryId: closure_1, get: closure_2, load: closure_3, getIsLoading: closure_4, getError: closure_5, retryConfig } = arg1);
|
|
if (retryConfig === undefined) {
|
|
retryConfig = {};
|
|
}
|
|
let num = retryConfig.maxRetries;
|
|
if (num === undefined) {
|
|
num = 5;
|
|
}
|
|
let closure_6 = num;
|
|
let backoff = retryConfig.backoff;
|
|
if (backoff === undefined) {
|
|
backoff = defaultBackoff;
|
|
}
|
|
let closure_7 = backoff;
|
|
let retryableErrors = retryConfig.retryableErrors;
|
|
if (retryableErrors === undefined) {
|
|
retryableErrors = defaultRetryableErrors;
|
|
}
|
|
let closure_8 = retryableErrors;
|
|
({ staleAfter: closure_9, failureStaleAfter: closure_10 } = arg1);
|
|
let map;
|
|
function getUseStoreState(items) {
|
|
if (null == items) {
|
|
return closure_15;
|
|
} else {
|
|
let value = map.get(items);
|
|
if (null == value) {
|
|
let obj = items(closure_2[11]);
|
|
obj = obj.create(() => {
|
|
const obj = { "Null": true, "Null": true, "Null": true, "Null": true, "Null": true, backoff: callback() };
|
|
return obj;
|
|
});
|
|
const result = map.set(items, obj);
|
|
value = obj;
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
function loader(param) {
|
|
return _loader(...arguments);
|
|
}
|
|
async function _loader(arg0, arg1) {
|
|
const fn = function*(queryId) {
|
|
queryId = queryId.queryId;
|
|
const args = queryId.args;
|
|
let flag = queryId.refetch;
|
|
if (flag === undefined) {
|
|
flag = false;
|
|
}
|
|
let useStoreState = queryId.useStoreState;
|
|
if (useStoreState === undefined) {
|
|
useStoreState = callback(queryId);
|
|
}
|
|
let obj = useStoreState;
|
|
let backoff;
|
|
let closure_5;
|
|
yield undefined;
|
|
backoff = obj.getState().backoff;
|
|
let applyResult;
|
|
if (null != backoff) {
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(tmp, 0);
|
|
applyResult = HermesBuiltin.apply(items, undefined);
|
|
}
|
|
if (null == applyResult) {
|
|
applyResult = obj.getState().isLoading;
|
|
}
|
|
if (null != queryId) {
|
|
if (!applyResult) {
|
|
if (!flag) {
|
|
const items1 = [];
|
|
HermesBuiltin.arraySpread(tmp, 0);
|
|
const applyResult1 = HermesBuiltin.apply(items1, undefined);
|
|
if (applyResult1 !== closure_13) {
|
|
if (null != applyResult1) {
|
|
let flag2 = false;
|
|
if (null != closure_9) {
|
|
const lastSuccessAt = obj.getState().lastSuccessAt;
|
|
let tmp22 = null == lastSuccessAt;
|
|
if (!tmp22) {
|
|
const _Date = Date;
|
|
tmp22 = Date.now() - lastSuccessAt > 1000 * tmp21;
|
|
}
|
|
flag2 = tmp22;
|
|
}
|
|
}
|
|
const failureLockedUntil = obj.getState().failureLockedUntil;
|
|
if (null != failureLockedUntil) {
|
|
const _Date2 = Date;
|
|
}
|
|
}
|
|
}
|
|
obj = { isLoading: true };
|
|
obj.setState(obj);
|
|
const items2 = [];
|
|
HermesBuiltin.arraySpread(tmp, 0);
|
|
yield HermesBuiltin.apply(items2, undefined);
|
|
backoff.succeed();
|
|
obj = { 4831993: "midnight", 9223372036854775807: "noon", 0: "morning", 0: "afternoon" };
|
|
const _Date3 = Date;
|
|
obj.lastSuccessAt = Date.now();
|
|
obj.setState(obj);
|
|
}
|
|
}
|
|
};
|
|
fn.next();
|
|
return fn;
|
|
}
|
|
function useCfsHook(arg0) {
|
|
const items = [...arguments];
|
|
let tmp8;
|
|
let tmp9;
|
|
const tmp = callback2(getUseStoreState(items), 2);
|
|
const first = tmp[0];
|
|
let result = items === first;
|
|
if (!result) {
|
|
let obj = arg0(tmp9[9]);
|
|
result = obj.areArraysShallowEqual(items, first);
|
|
}
|
|
if (!result) {
|
|
tmp[1](items);
|
|
}
|
|
arg0 = first;
|
|
if (Array.isArray(arg0)) {
|
|
let items1 = tmp7;
|
|
} else {
|
|
items1 = [tmp7];
|
|
}
|
|
tmp8 = tmp8(...first);
|
|
tmp9 = getUseStoreState(tmp8);
|
|
const items2 = [first];
|
|
const stateFromStores = arg0(tmp9[12]).useStateFromStores(items1, () => {
|
|
let applyResult;
|
|
if (null != closure_4) {
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(first, 0);
|
|
applyResult = HermesBuiltin.apply(items, undefined);
|
|
}
|
|
return applyResult;
|
|
}, items2);
|
|
let tmp9Result = tmp9((isLoading) => {
|
|
isLoading = null == closure_4;
|
|
if (isLoading) {
|
|
isLoading = isLoading.isLoading;
|
|
}
|
|
return isLoading;
|
|
});
|
|
if (null != stateFromStores) {
|
|
tmp9Result = stateFromStores;
|
|
}
|
|
const obj2 = arg0(tmp9[12]);
|
|
const tmp12 = items1;
|
|
const items3 = [first];
|
|
const stateFromStores1 = arg0(tmp9[12]).useStateFromStores(items1, () => {
|
|
let applyResult;
|
|
if (null != closure_5) {
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(first, 0);
|
|
applyResult = HermesBuiltin.apply(items, undefined);
|
|
}
|
|
return applyResult;
|
|
}, items3);
|
|
tmp9Result = tmp9((error) => {
|
|
error = null;
|
|
if (null == closure_5) {
|
|
error = error.error;
|
|
}
|
|
return error;
|
|
});
|
|
if (null != stateFromStores1) {
|
|
tmp9Result = stateFromStores1;
|
|
}
|
|
const obj3 = arg0(tmp9[12]);
|
|
const items4 = [first];
|
|
const stateFromStores2 = arg0(tmp9[12]).useStateFromStores(tmp12, () => tmp9(...closure_0), items4, closure_18);
|
|
const items5 = [tmp8, first, tmp9];
|
|
map(() => {
|
|
callback({ queryId: tmp8, args: first, useStoreState: tmp9 });
|
|
}, items5);
|
|
const items6 = [tmp8, first, tmp9];
|
|
obj = {};
|
|
let tmp18 = null;
|
|
const obj4 = arg0(tmp9[12]);
|
|
if (stateFromStores2 !== loader) {
|
|
tmp18 = stateFromStores2;
|
|
}
|
|
obj.data = tmp18;
|
|
obj.error = tmp9Result;
|
|
obj.isLoading = tmp9Result;
|
|
obj.refetch = callback3(() => {
|
|
callback({ queryId: tmp8, args: first, useStoreState: tmp9, refetch: true });
|
|
}, items6);
|
|
return obj;
|
|
}
|
|
map = new Map();
|
|
useCfsHook.refetch = callback(async (arg0) => {
|
|
const fn = function*(arg0) {
|
|
const items = [...arguments];
|
|
yield undefined;
|
|
const tmp2 = callback(...items);
|
|
const obj = callback2(tmp2);
|
|
const backoff = obj.getState().backoff;
|
|
backoff.succeed();
|
|
obj.setState({ failureLockedUntil: null });
|
|
yield closure_13({ queryId: tmp2, args: items, useStoreState: obj, refetch: true });
|
|
};
|
|
fn.next();
|
|
return fn;
|
|
});
|
|
useCfsHook.fetchMany = callback(async (arg0) => {
|
|
const fn = function*(arg0) {
|
|
const items = [...arguments];
|
|
yield undefined;
|
|
yield Promise.all(items.map((args) => {
|
|
const tmp = callback(...args);
|
|
return callback3({ queryId: tmp, args, useStoreState: callback2(tmp) });
|
|
}));
|
|
};
|
|
fn.next();
|
|
return fn;
|
|
});
|
|
useCfsHook.refetchMany = callback(async (arg0) => {
|
|
const fn = function*(arg0) {
|
|
const items = [...arguments];
|
|
yield undefined;
|
|
yield Promise.all(items.map((args) => {
|
|
const tmp = callback(...args);
|
|
let obj = callback2(tmp);
|
|
const backoff = obj.getState().backoff;
|
|
backoff.succeed();
|
|
obj.setState({ failureLockedUntil: null });
|
|
obj = { queryId: tmp, args, useStoreState: obj, refetch: true };
|
|
return callback3(obj);
|
|
}));
|
|
};
|
|
fn.next();
|
|
return fn;
|
|
});
|
|
return useCfsHook;
|
|
};
|