663 lines
28 KiB
JavaScript
663 lines
28 KiB
JavaScript
import { o as __toESM, t as __commonJSMin } from "../_runtime.mjs";
|
|
import { a as QueryObserver, i as InfiniteQueryObserver, l as noop, n as QueriesObserver, o as notifyManager, r as MutationObserver, s as environmentManager, u as shouldThrowError } from "./tanstack__query-core.mjs";
|
|
//#region node_modules/react/cjs/react.production.js
|
|
/**
|
|
* @license React
|
|
* react.production.js
|
|
*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
var require_react_production = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
|
|
function getIteratorFn(maybeIterable) {
|
|
if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
|
|
maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
|
|
return "function" === typeof maybeIterable ? maybeIterable : null;
|
|
}
|
|
var ReactNoopUpdateQueue = {
|
|
isMounted: function() {
|
|
return !1;
|
|
},
|
|
enqueueForceUpdate: function() {},
|
|
enqueueReplaceState: function() {},
|
|
enqueueSetState: function() {}
|
|
}, assign = Object.assign, emptyObject = {};
|
|
function Component(props, context, updater) {
|
|
this.props = props;
|
|
this.context = context;
|
|
this.refs = emptyObject;
|
|
this.updater = updater || ReactNoopUpdateQueue;
|
|
}
|
|
Component.prototype.isReactComponent = {};
|
|
Component.prototype.setState = function(partialState, callback) {
|
|
if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState) throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
|
|
this.updater.enqueueSetState(this, partialState, callback, "setState");
|
|
};
|
|
Component.prototype.forceUpdate = function(callback) {
|
|
this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
|
|
};
|
|
function ComponentDummy() {}
|
|
ComponentDummy.prototype = Component.prototype;
|
|
function PureComponent(props, context, updater) {
|
|
this.props = props;
|
|
this.context = context;
|
|
this.refs = emptyObject;
|
|
this.updater = updater || ReactNoopUpdateQueue;
|
|
}
|
|
var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
|
|
pureComponentPrototype.constructor = PureComponent;
|
|
assign(pureComponentPrototype, Component.prototype);
|
|
pureComponentPrototype.isPureReactComponent = !0;
|
|
var isArrayImpl = Array.isArray;
|
|
function noop() {}
|
|
var ReactSharedInternals = {
|
|
H: null,
|
|
A: null,
|
|
T: null,
|
|
S: null
|
|
}, hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
function ReactElement(type, key, props) {
|
|
var refProp = props.ref;
|
|
return {
|
|
$$typeof: REACT_ELEMENT_TYPE,
|
|
type,
|
|
key,
|
|
ref: void 0 !== refProp ? refProp : null,
|
|
props
|
|
};
|
|
}
|
|
function cloneAndReplaceKey(oldElement, newKey) {
|
|
return ReactElement(oldElement.type, newKey, oldElement.props);
|
|
}
|
|
function isValidElement(object) {
|
|
return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
|
|
}
|
|
function escape(key) {
|
|
var escaperLookup = {
|
|
"=": "=0",
|
|
":": "=2"
|
|
};
|
|
return "$" + key.replace(/[=:]/g, function(match) {
|
|
return escaperLookup[match];
|
|
});
|
|
}
|
|
var userProvidedKeyEscapeRegex = /\/+/g;
|
|
function getElementKey(element, index) {
|
|
return "object" === typeof element && null !== element && null != element.key ? escape("" + element.key) : index.toString(36);
|
|
}
|
|
function resolveThenable(thenable) {
|
|
switch (thenable.status) {
|
|
case "fulfilled": return thenable.value;
|
|
case "rejected": throw thenable.reason;
|
|
default: switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(function(fulfilledValue) {
|
|
"pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
|
|
}, function(error) {
|
|
"pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
|
|
})), thenable.status) {
|
|
case "fulfilled": return thenable.value;
|
|
case "rejected": throw thenable.reason;
|
|
}
|
|
}
|
|
throw thenable;
|
|
}
|
|
function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
|
|
var type = typeof children;
|
|
if ("undefined" === type || "boolean" === type) children = null;
|
|
var invokeCallback = !1;
|
|
if (null === children) invokeCallback = !0;
|
|
else switch (type) {
|
|
case "bigint":
|
|
case "string":
|
|
case "number":
|
|
invokeCallback = !0;
|
|
break;
|
|
case "object": switch (children.$$typeof) {
|
|
case REACT_ELEMENT_TYPE:
|
|
case REACT_PORTAL_TYPE:
|
|
invokeCallback = !0;
|
|
break;
|
|
case REACT_LAZY_TYPE: return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback);
|
|
}
|
|
}
|
|
if (invokeCallback) return callback = callback(children), invokeCallback = "" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar, isArrayImpl(callback) ? (escapedPrefix = "", null != invokeCallback && (escapedPrefix = invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
|
|
return c;
|
|
})) : null != callback && (isValidElement(callback) && (callback = cloneAndReplaceKey(callback, escapedPrefix + (null == callback.key || children && children.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + invokeCallback)), array.push(callback)), 1;
|
|
invokeCallback = 0;
|
|
var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
|
|
if (isArrayImpl(children)) for (var i = 0; i < children.length; i++) nameSoFar = children[i], type = nextNamePrefix + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
|
|
else if (i = getIteratorFn(children), "function" === typeof i) for (children = i.call(children), i = 0; !(nameSoFar = children.next()).done;) nameSoFar = nameSoFar.value, type = nextNamePrefix + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
|
|
else if ("object" === type) {
|
|
if ("function" === typeof children.then) return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback);
|
|
array = String(children);
|
|
throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead.");
|
|
}
|
|
return invokeCallback;
|
|
}
|
|
function mapChildren(children, func, context) {
|
|
if (null == children) return children;
|
|
var result = [], count = 0;
|
|
mapIntoArray(children, result, "", "", function(child) {
|
|
return func.call(context, child, count++);
|
|
});
|
|
return result;
|
|
}
|
|
function lazyInitializer(payload) {
|
|
if (-1 === payload._status) {
|
|
var ctor = payload._result;
|
|
ctor = ctor();
|
|
ctor.then(function(moduleObject) {
|
|
if (0 === payload._status || -1 === payload._status) payload._status = 1, payload._result = moduleObject;
|
|
}, function(error) {
|
|
if (0 === payload._status || -1 === payload._status) payload._status = 2, payload._result = error;
|
|
});
|
|
-1 === payload._status && (payload._status = 0, payload._result = ctor);
|
|
}
|
|
if (1 === payload._status) return payload._result.default;
|
|
throw payload._result;
|
|
}
|
|
var reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
|
|
if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
|
|
var event = new window.ErrorEvent("error", {
|
|
bubbles: !0,
|
|
cancelable: !0,
|
|
message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
|
|
error
|
|
});
|
|
if (!window.dispatchEvent(event)) return;
|
|
} else if ("object" === typeof process && "function" === typeof process.emit) {
|
|
process.emit("uncaughtException", error);
|
|
return;
|
|
}
|
|
console.error(error);
|
|
}, Children = {
|
|
map: mapChildren,
|
|
forEach: function(children, forEachFunc, forEachContext) {
|
|
mapChildren(children, function() {
|
|
forEachFunc.apply(this, arguments);
|
|
}, forEachContext);
|
|
},
|
|
count: function(children) {
|
|
var n = 0;
|
|
mapChildren(children, function() {
|
|
n++;
|
|
});
|
|
return n;
|
|
},
|
|
toArray: function(children) {
|
|
return mapChildren(children, function(child) {
|
|
return child;
|
|
}) || [];
|
|
},
|
|
only: function(children) {
|
|
if (!isValidElement(children)) throw Error("React.Children.only expected to receive a single React element child.");
|
|
return children;
|
|
}
|
|
};
|
|
exports.Activity = REACT_ACTIVITY_TYPE;
|
|
exports.Children = Children;
|
|
exports.Component = Component;
|
|
exports.Fragment = REACT_FRAGMENT_TYPE;
|
|
exports.Profiler = REACT_PROFILER_TYPE;
|
|
exports.PureComponent = PureComponent;
|
|
exports.StrictMode = REACT_STRICT_MODE_TYPE;
|
|
exports.Suspense = REACT_SUSPENSE_TYPE;
|
|
exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
|
|
exports.__COMPILER_RUNTIME = {
|
|
__proto__: null,
|
|
c: function(size) {
|
|
return ReactSharedInternals.H.useMemoCache(size);
|
|
}
|
|
};
|
|
exports.cache = function(fn) {
|
|
return function() {
|
|
return fn.apply(null, arguments);
|
|
};
|
|
};
|
|
exports.cacheSignal = function() {
|
|
return null;
|
|
};
|
|
exports.cloneElement = function(element, config, children) {
|
|
if (null === element || void 0 === element) throw Error("The argument must be a React element, but you passed " + element + ".");
|
|
var props = assign({}, element.props), key = element.key;
|
|
if (null != config) for (propName in void 0 !== config.key && (key = "" + config.key), config) !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
|
|
var propName = arguments.length - 2;
|
|
if (1 === propName) props.children = children;
|
|
else if (1 < propName) {
|
|
for (var childArray = Array(propName), i = 0; i < propName; i++) childArray[i] = arguments[i + 2];
|
|
props.children = childArray;
|
|
}
|
|
return ReactElement(element.type, key, props);
|
|
};
|
|
exports.createContext = function(defaultValue) {
|
|
defaultValue = {
|
|
$$typeof: REACT_CONTEXT_TYPE,
|
|
_currentValue: defaultValue,
|
|
_currentValue2: defaultValue,
|
|
_threadCount: 0,
|
|
Provider: null,
|
|
Consumer: null
|
|
};
|
|
defaultValue.Provider = defaultValue;
|
|
defaultValue.Consumer = {
|
|
$$typeof: REACT_CONSUMER_TYPE,
|
|
_context: defaultValue
|
|
};
|
|
return defaultValue;
|
|
};
|
|
exports.createElement = function(type, config, children) {
|
|
var propName, props = {}, key = null;
|
|
if (null != config) for (propName in void 0 !== config.key && (key = "" + config.key), config) hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (props[propName] = config[propName]);
|
|
var childrenLength = arguments.length - 2;
|
|
if (1 === childrenLength) props.children = children;
|
|
else if (1 < childrenLength) {
|
|
for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++) childArray[i] = arguments[i + 2];
|
|
props.children = childArray;
|
|
}
|
|
if (type && type.defaultProps) for (propName in childrenLength = type.defaultProps, childrenLength) void 0 === props[propName] && (props[propName] = childrenLength[propName]);
|
|
return ReactElement(type, key, props);
|
|
};
|
|
exports.createRef = function() {
|
|
return { current: null };
|
|
};
|
|
exports.forwardRef = function(render) {
|
|
return {
|
|
$$typeof: REACT_FORWARD_REF_TYPE,
|
|
render
|
|
};
|
|
};
|
|
exports.isValidElement = isValidElement;
|
|
exports.lazy = function(ctor) {
|
|
return {
|
|
$$typeof: REACT_LAZY_TYPE,
|
|
_payload: {
|
|
_status: -1,
|
|
_result: ctor
|
|
},
|
|
_init: lazyInitializer
|
|
};
|
|
};
|
|
exports.memo = function(type, compare) {
|
|
return {
|
|
$$typeof: REACT_MEMO_TYPE,
|
|
type,
|
|
compare: void 0 === compare ? null : compare
|
|
};
|
|
};
|
|
exports.startTransition = function(scope) {
|
|
var prevTransition = ReactSharedInternals.T, currentTransition = {};
|
|
ReactSharedInternals.T = currentTransition;
|
|
try {
|
|
var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
|
|
null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
|
|
"object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop, reportGlobalError);
|
|
} catch (error) {
|
|
reportGlobalError(error);
|
|
} finally {
|
|
null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
|
|
}
|
|
};
|
|
exports.unstable_useCacheRefresh = function() {
|
|
return ReactSharedInternals.H.useCacheRefresh();
|
|
};
|
|
exports.use = function(usable) {
|
|
return ReactSharedInternals.H.use(usable);
|
|
};
|
|
exports.useActionState = function(action, initialState, permalink) {
|
|
return ReactSharedInternals.H.useActionState(action, initialState, permalink);
|
|
};
|
|
exports.useCallback = function(callback, deps) {
|
|
return ReactSharedInternals.H.useCallback(callback, deps);
|
|
};
|
|
exports.useContext = function(Context) {
|
|
return ReactSharedInternals.H.useContext(Context);
|
|
};
|
|
exports.useDebugValue = function() {};
|
|
exports.useDeferredValue = function(value, initialValue) {
|
|
return ReactSharedInternals.H.useDeferredValue(value, initialValue);
|
|
};
|
|
exports.useEffect = function(create, deps) {
|
|
return ReactSharedInternals.H.useEffect(create, deps);
|
|
};
|
|
exports.useEffectEvent = function(callback) {
|
|
return ReactSharedInternals.H.useEffectEvent(callback);
|
|
};
|
|
exports.useId = function() {
|
|
return ReactSharedInternals.H.useId();
|
|
};
|
|
exports.useImperativeHandle = function(ref, create, deps) {
|
|
return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
|
|
};
|
|
exports.useInsertionEffect = function(create, deps) {
|
|
return ReactSharedInternals.H.useInsertionEffect(create, deps);
|
|
};
|
|
exports.useLayoutEffect = function(create, deps) {
|
|
return ReactSharedInternals.H.useLayoutEffect(create, deps);
|
|
};
|
|
exports.useMemo = function(create, deps) {
|
|
return ReactSharedInternals.H.useMemo(create, deps);
|
|
};
|
|
exports.useOptimistic = function(passthrough, reducer) {
|
|
return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
|
|
};
|
|
exports.useReducer = function(reducer, initialArg, init) {
|
|
return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
|
|
};
|
|
exports.useRef = function(initialValue) {
|
|
return ReactSharedInternals.H.useRef(initialValue);
|
|
};
|
|
exports.useState = function(initialState) {
|
|
return ReactSharedInternals.H.useState(initialState);
|
|
};
|
|
exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
|
|
return ReactSharedInternals.H.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
|
|
};
|
|
exports.useTransition = function() {
|
|
return ReactSharedInternals.H.useTransition();
|
|
};
|
|
exports.version = "19.2.6";
|
|
}));
|
|
//#endregion
|
|
//#region node_modules/react/index.js
|
|
var require_react = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
module.exports = require_react_production();
|
|
}));
|
|
//#endregion
|
|
//#region node_modules/react/cjs/react-jsx-runtime.production.js
|
|
/**
|
|
* @license React
|
|
* react-jsx-runtime.production.js
|
|
*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
var require_react_jsx_runtime_production = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
|
|
function jsxProd(type, config, maybeKey) {
|
|
var key = null;
|
|
void 0 !== maybeKey && (key = "" + maybeKey);
|
|
void 0 !== config.key && (key = "" + config.key);
|
|
if ("key" in config) {
|
|
maybeKey = {};
|
|
for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
|
|
} else maybeKey = config;
|
|
config = maybeKey.ref;
|
|
return {
|
|
$$typeof: REACT_ELEMENT_TYPE,
|
|
type,
|
|
key,
|
|
ref: void 0 !== config ? config : null,
|
|
props: maybeKey
|
|
};
|
|
}
|
|
exports.Fragment = REACT_FRAGMENT_TYPE;
|
|
exports.jsx = jsxProd;
|
|
exports.jsxs = jsxProd;
|
|
}));
|
|
//#endregion
|
|
//#region node_modules/react/jsx-runtime.js
|
|
var require_jsx_runtime = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
module.exports = require_react_jsx_runtime_production();
|
|
}));
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
|
|
var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
|
|
var import_jsx_runtime = require_jsx_runtime();
|
|
var QueryClientContext = import_react.createContext(void 0);
|
|
var useQueryClient = (queryClient) => {
|
|
const client = import_react.useContext(QueryClientContext);
|
|
if (queryClient) return queryClient;
|
|
if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
|
|
return client;
|
|
};
|
|
var QueryClientProvider = ({ client, children }) => {
|
|
import_react.useEffect(() => {
|
|
client.mount();
|
|
return () => {
|
|
client.unmount();
|
|
};
|
|
}, [client]);
|
|
return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(QueryClientContext.Provider, {
|
|
value: client,
|
|
children
|
|
});
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
|
|
var IsRestoringContext = import_react.createContext(false);
|
|
var useIsRestoring = () => import_react.useContext(IsRestoringContext);
|
|
IsRestoringContext.Provider;
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
|
|
function createValue() {
|
|
let isReset = false;
|
|
return {
|
|
clearReset: () => {
|
|
isReset = false;
|
|
},
|
|
reset: () => {
|
|
isReset = true;
|
|
},
|
|
isReset: () => {
|
|
return isReset;
|
|
}
|
|
};
|
|
}
|
|
var QueryErrorResetBoundaryContext = import_react.createContext(createValue());
|
|
var useQueryErrorResetBoundary = () => import_react.useContext(QueryErrorResetBoundaryContext);
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
|
|
var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
|
|
const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError;
|
|
if (options.suspense || options.experimental_prefetchInRender || throwOnError) {
|
|
if (!errorResetBoundary.isReset()) options.retryOnMount = false;
|
|
}
|
|
};
|
|
var useClearResetErrorBoundary = (errorResetBoundary) => {
|
|
import_react.useEffect(() => {
|
|
errorResetBoundary.clearReset();
|
|
}, [errorResetBoundary]);
|
|
};
|
|
var getHasError = ({ result, errorResetBoundary, throwOnError, query, suspense }) => {
|
|
return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
|
|
};
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/suspense.js
|
|
var defaultThrowOnError = (_error, query) => query.state.data === void 0;
|
|
var ensureSuspenseTimers = (defaultedOptions) => {
|
|
if (defaultedOptions.suspense) {
|
|
const MIN_SUSPENSE_TIME_MS = 1e3;
|
|
const clamp = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS);
|
|
const originalStaleTime = defaultedOptions.staleTime;
|
|
defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp(originalStaleTime(...args)) : clamp(originalStaleTime);
|
|
if (typeof defaultedOptions.gcTime === "number") defaultedOptions.gcTime = Math.max(defaultedOptions.gcTime, MIN_SUSPENSE_TIME_MS);
|
|
}
|
|
};
|
|
var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
|
|
var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
|
|
var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
|
|
errorResetBoundary.clearReset();
|
|
});
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/useQueries.js
|
|
function useQueries({ queries, ...options }, queryClient) {
|
|
const client = useQueryClient(queryClient);
|
|
const isRestoring = useIsRestoring();
|
|
const errorResetBoundary = useQueryErrorResetBoundary();
|
|
const defaultedQueries = import_react.useMemo(() => queries.map((opts) => {
|
|
const defaultedOptions = client.defaultQueryOptions(opts);
|
|
defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
|
|
return defaultedOptions;
|
|
}), [
|
|
queries,
|
|
client,
|
|
isRestoring
|
|
]);
|
|
defaultedQueries.forEach((queryOptions) => {
|
|
ensureSuspenseTimers(queryOptions);
|
|
ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, client.getQueryCache().get(queryOptions.queryHash));
|
|
});
|
|
useClearResetErrorBoundary(errorResetBoundary);
|
|
const [observer] = import_react.useState(() => new QueriesObserver(client, defaultedQueries, options));
|
|
const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(defaultedQueries, options.combine);
|
|
const shouldSubscribe = !isRestoring && options.subscribed !== false;
|
|
import_react.useSyncExternalStore(import_react.useCallback((onStoreChange) => shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
|
|
import_react.useEffect(() => {
|
|
observer.setQueries(defaultedQueries, options);
|
|
}, [
|
|
defaultedQueries,
|
|
options,
|
|
observer
|
|
]);
|
|
const suspensePromises = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result)) ? optimisticResult.flatMap((result, index) => {
|
|
const opts = defaultedQueries[index];
|
|
if (opts && shouldSuspend(opts, result)) return fetchOptimistic(opts, new QueryObserver(client, opts), errorResetBoundary);
|
|
return [];
|
|
}) : [];
|
|
if (suspensePromises.length > 0) throw Promise.all(suspensePromises);
|
|
const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
|
|
const query = defaultedQueries[index];
|
|
return query && getHasError({
|
|
result,
|
|
errorResetBoundary,
|
|
throwOnError: query.throwOnError,
|
|
query: client.getQueryCache().get(query.queryHash),
|
|
suspense: query.suspense
|
|
});
|
|
});
|
|
if (firstSingleResultWhichShouldThrow?.error) throw firstSingleResultWhichShouldThrow.error;
|
|
return getCombinedResult(trackResult());
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
|
|
function useBaseQuery(options, Observer, queryClient) {
|
|
const isRestoring = useIsRestoring();
|
|
const errorResetBoundary = useQueryErrorResetBoundary();
|
|
const client = useQueryClient(queryClient);
|
|
const defaultedOptions = client.defaultQueryOptions(options);
|
|
client.getDefaultOptions().queries?._experimental_beforeQuery?.(defaultedOptions);
|
|
const query = client.getQueryCache().get(defaultedOptions.queryHash);
|
|
defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
|
|
ensureSuspenseTimers(defaultedOptions);
|
|
ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
|
|
useClearResetErrorBoundary(errorResetBoundary);
|
|
const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
|
|
const [observer] = import_react.useState(() => new Observer(client, defaultedOptions));
|
|
const result = observer.getOptimisticResult(defaultedOptions);
|
|
const shouldSubscribe = !isRestoring && options.subscribed !== false;
|
|
import_react.useSyncExternalStore(import_react.useCallback((onStoreChange) => {
|
|
const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
|
|
observer.updateResult();
|
|
return unsubscribe;
|
|
}, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
|
|
import_react.useEffect(() => {
|
|
observer.setOptions(defaultedOptions);
|
|
}, [defaultedOptions, observer]);
|
|
if (shouldSuspend(defaultedOptions, result)) throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
|
|
if (getHasError({
|
|
result,
|
|
errorResetBoundary,
|
|
throwOnError: defaultedOptions.throwOnError,
|
|
query,
|
|
suspense: defaultedOptions.suspense
|
|
})) throw result.error;
|
|
client.getDefaultOptions().queries?._experimental_afterQuery?.(defaultedOptions, result);
|
|
if (defaultedOptions.experimental_prefetchInRender && !environmentManager.isServer() && willFetch(result, isRestoring)) (isNewCacheEntry ? fetchOptimistic(defaultedOptions, observer, errorResetBoundary) : query?.promise)?.catch(noop).finally(() => {
|
|
observer.updateResult();
|
|
});
|
|
return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/useQuery.js
|
|
function useQuery(options, queryClient) {
|
|
return useBaseQuery(options, QueryObserver, queryClient);
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/useSuspenseQuery.js
|
|
function useSuspenseQuery(options, queryClient) {
|
|
return useBaseQuery({
|
|
...options,
|
|
enabled: true,
|
|
suspense: true,
|
|
throwOnError: defaultThrowOnError,
|
|
placeholderData: void 0
|
|
}, QueryObserver, queryClient);
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/useSuspenseInfiniteQuery.js
|
|
function useSuspenseInfiniteQuery(options, queryClient) {
|
|
return useBaseQuery({
|
|
...options,
|
|
enabled: true,
|
|
suspense: true,
|
|
throwOnError: defaultThrowOnError
|
|
}, InfiniteQueryObserver, queryClient);
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/useSuspenseQueries.js
|
|
function useSuspenseQueries(options, queryClient) {
|
|
return useQueries({
|
|
...options,
|
|
queries: options.queries.map((query) => {
|
|
return {
|
|
...query,
|
|
suspense: true,
|
|
throwOnError: defaultThrowOnError,
|
|
enabled: true,
|
|
placeholderData: void 0
|
|
};
|
|
})
|
|
}, queryClient);
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/usePrefetchQuery.js
|
|
function usePrefetchQuery(options, queryClient) {
|
|
const client = useQueryClient(queryClient);
|
|
if (!client.getQueryState(options.queryKey)) client.prefetchQuery(options);
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/usePrefetchInfiniteQuery.js
|
|
function usePrefetchInfiniteQuery(options, queryClient) {
|
|
const client = useQueryClient(queryClient);
|
|
if (!client.getQueryState(options.queryKey)) client.prefetchInfiniteQuery(options);
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/queryOptions.js
|
|
function queryOptions(options) {
|
|
return options;
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/infiniteQueryOptions.js
|
|
function infiniteQueryOptions(options) {
|
|
return options;
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/useMutation.js
|
|
function useMutation(options, queryClient) {
|
|
const client = useQueryClient(queryClient);
|
|
const [observer] = import_react.useState(() => new MutationObserver(client, options));
|
|
import_react.useEffect(() => {
|
|
observer.setOptions(options);
|
|
}, [observer, options]);
|
|
const result = import_react.useSyncExternalStore(import_react.useCallback((onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
|
|
const mutate = import_react.useCallback((variables, mutateOptions) => {
|
|
observer.mutate(variables, mutateOptions).catch(noop);
|
|
}, [observer]);
|
|
if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) throw result.error;
|
|
return {
|
|
...result,
|
|
mutate,
|
|
mutateAsync: result.mutate
|
|
};
|
|
}
|
|
//#endregion
|
|
//#region node_modules/@tanstack/react-query/build/modern/useInfiniteQuery.js
|
|
function useInfiniteQuery(options, queryClient) {
|
|
return useBaseQuery(options, InfiniteQueryObserver, queryClient);
|
|
}
|
|
//#endregion
|
|
export { usePrefetchInfiniteQuery as a, useSuspenseInfiniteQuery as c, useQueries as d, QueryClientProvider as f, require_react as h, queryOptions as i, useSuspenseQuery as l, require_jsx_runtime as m, useMutation as n, usePrefetchQuery as o, useQueryClient as p, infiniteQueryOptions as r, useSuspenseQueries as s, useInfiniteQuery as t, useQuery as u };
|