b6bff318d9
- Agent roles integration progress - Various backend and frontend updates - Storybook cache cleanup 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
3490 lines
119 KiB
JavaScript
3490 lines
119 KiB
JavaScript
import {
|
|
require_jsx_runtime
|
|
} from "./chunk-S77I6LSE.js";
|
|
import {
|
|
require_react
|
|
} from "./chunk-3TFVT2CW.js";
|
|
import {
|
|
__privateAdd,
|
|
__privateGet,
|
|
__privateMethod,
|
|
__privateSet,
|
|
__privateWrapper,
|
|
__toESM
|
|
} from "./chunk-4MBMRILA.js";
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/subscribable.js
|
|
var Subscribable = class {
|
|
constructor() {
|
|
this.listeners = /* @__PURE__ */ new Set();
|
|
this.subscribe = this.subscribe.bind(this);
|
|
}
|
|
subscribe(listener) {
|
|
this.listeners.add(listener);
|
|
this.onSubscribe();
|
|
return () => {
|
|
this.listeners.delete(listener);
|
|
this.onUnsubscribe();
|
|
};
|
|
}
|
|
hasListeners() {
|
|
return this.listeners.size > 0;
|
|
}
|
|
onSubscribe() {
|
|
}
|
|
onUnsubscribe() {
|
|
}
|
|
};
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/utils.js
|
|
var isServer = typeof window === "undefined" || "Deno" in globalThis;
|
|
function noop() {
|
|
}
|
|
function functionalUpdate(updater, input) {
|
|
return typeof updater === "function" ? updater(input) : updater;
|
|
}
|
|
function isValidTimeout(value) {
|
|
return typeof value === "number" && value >= 0 && value !== Infinity;
|
|
}
|
|
function timeUntilStale(updatedAt, staleTime) {
|
|
return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
|
|
}
|
|
function resolveStaleTime(staleTime, query) {
|
|
return typeof staleTime === "function" ? staleTime(query) : staleTime;
|
|
}
|
|
function resolveEnabled(enabled, query) {
|
|
return typeof enabled === "function" ? enabled(query) : enabled;
|
|
}
|
|
function matchQuery(filters, query) {
|
|
const {
|
|
type = "all",
|
|
exact,
|
|
fetchStatus,
|
|
predicate,
|
|
queryKey,
|
|
stale
|
|
} = filters;
|
|
if (queryKey) {
|
|
if (exact) {
|
|
if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
|
|
return false;
|
|
}
|
|
} else if (!partialMatchKey(query.queryKey, queryKey)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (type !== "all") {
|
|
const isActive = query.isActive();
|
|
if (type === "active" && !isActive) {
|
|
return false;
|
|
}
|
|
if (type === "inactive" && isActive) {
|
|
return false;
|
|
}
|
|
}
|
|
if (typeof stale === "boolean" && query.isStale() !== stale) {
|
|
return false;
|
|
}
|
|
if (fetchStatus && fetchStatus !== query.state.fetchStatus) {
|
|
return false;
|
|
}
|
|
if (predicate && !predicate(query)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function matchMutation(filters, mutation) {
|
|
const { exact, status, predicate, mutationKey } = filters;
|
|
if (mutationKey) {
|
|
if (!mutation.options.mutationKey) {
|
|
return false;
|
|
}
|
|
if (exact) {
|
|
if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) {
|
|
return false;
|
|
}
|
|
} else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (status && mutation.state.status !== status) {
|
|
return false;
|
|
}
|
|
if (predicate && !predicate(mutation)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function hashQueryKeyByOptions(queryKey, options) {
|
|
const hashFn = (options == null ? void 0 : options.queryKeyHashFn) || hashKey;
|
|
return hashFn(queryKey);
|
|
}
|
|
function hashKey(queryKey) {
|
|
return JSON.stringify(
|
|
queryKey,
|
|
(_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
|
|
result[key] = val[key];
|
|
return result;
|
|
}, {}) : val
|
|
);
|
|
}
|
|
function partialMatchKey(a, b) {
|
|
if (a === b) {
|
|
return true;
|
|
}
|
|
if (typeof a !== typeof b) {
|
|
return false;
|
|
}
|
|
if (a && b && typeof a === "object" && typeof b === "object") {
|
|
return Object.keys(b).every((key) => partialMatchKey(a[key], b[key]));
|
|
}
|
|
return false;
|
|
}
|
|
function replaceEqualDeep(a, b) {
|
|
if (a === b) {
|
|
return a;
|
|
}
|
|
const array = isPlainArray(a) && isPlainArray(b);
|
|
if (array || isPlainObject(a) && isPlainObject(b)) {
|
|
const aItems = array ? a : Object.keys(a);
|
|
const aSize = aItems.length;
|
|
const bItems = array ? b : Object.keys(b);
|
|
const bSize = bItems.length;
|
|
const copy = array ? [] : {};
|
|
const aItemsSet = new Set(aItems);
|
|
let equalItems = 0;
|
|
for (let i = 0; i < bSize; i++) {
|
|
const key = array ? i : bItems[i];
|
|
if ((!array && aItemsSet.has(key) || array) && a[key] === void 0 && b[key] === void 0) {
|
|
copy[key] = void 0;
|
|
equalItems++;
|
|
} else {
|
|
copy[key] = replaceEqualDeep(a[key], b[key]);
|
|
if (copy[key] === a[key] && a[key] !== void 0) {
|
|
equalItems++;
|
|
}
|
|
}
|
|
}
|
|
return aSize === bSize && equalItems === aSize ? a : copy;
|
|
}
|
|
return b;
|
|
}
|
|
function shallowEqualObjects(a, b) {
|
|
if (!b || Object.keys(a).length !== Object.keys(b).length) {
|
|
return false;
|
|
}
|
|
for (const key in a) {
|
|
if (a[key] !== b[key]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function isPlainArray(value) {
|
|
return Array.isArray(value) && value.length === Object.keys(value).length;
|
|
}
|
|
function isPlainObject(o) {
|
|
if (!hasObjectPrototype(o)) {
|
|
return false;
|
|
}
|
|
const ctor = o.constructor;
|
|
if (ctor === void 0) {
|
|
return true;
|
|
}
|
|
const prot = ctor.prototype;
|
|
if (!hasObjectPrototype(prot)) {
|
|
return false;
|
|
}
|
|
if (!prot.hasOwnProperty("isPrototypeOf")) {
|
|
return false;
|
|
}
|
|
if (Object.getPrototypeOf(o) !== Object.prototype) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function hasObjectPrototype(o) {
|
|
return Object.prototype.toString.call(o) === "[object Object]";
|
|
}
|
|
function sleep(timeout) {
|
|
return new Promise((resolve) => {
|
|
setTimeout(resolve, timeout);
|
|
});
|
|
}
|
|
function replaceData(prevData, data, options) {
|
|
if (typeof options.structuralSharing === "function") {
|
|
return options.structuralSharing(prevData, data);
|
|
} else if (options.structuralSharing !== false) {
|
|
if (true) {
|
|
try {
|
|
return replaceEqualDeep(prevData, data);
|
|
} catch (error) {
|
|
console.error(
|
|
`Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}`
|
|
);
|
|
throw error;
|
|
}
|
|
}
|
|
return replaceEqualDeep(prevData, data);
|
|
}
|
|
return data;
|
|
}
|
|
function keepPreviousData(previousData) {
|
|
return previousData;
|
|
}
|
|
function addToEnd(items, item, max = 0) {
|
|
const newItems = [...items, item];
|
|
return max && newItems.length > max ? newItems.slice(1) : newItems;
|
|
}
|
|
function addToStart(items, item, max = 0) {
|
|
const newItems = [item, ...items];
|
|
return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
|
|
}
|
|
var skipToken = Symbol();
|
|
function ensureQueryFn(options, fetchOptions) {
|
|
if (true) {
|
|
if (options.queryFn === skipToken) {
|
|
console.error(
|
|
`Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'`
|
|
);
|
|
}
|
|
}
|
|
if (!options.queryFn && (fetchOptions == null ? void 0 : fetchOptions.initialPromise)) {
|
|
return () => fetchOptions.initialPromise;
|
|
}
|
|
if (!options.queryFn || options.queryFn === skipToken) {
|
|
return () => Promise.reject(new Error(`Missing queryFn: '${options.queryHash}'`));
|
|
}
|
|
return options.queryFn;
|
|
}
|
|
function shouldThrowError(throwOnError, params) {
|
|
if (typeof throwOnError === "function") {
|
|
return throwOnError(...params);
|
|
}
|
|
return !!throwOnError;
|
|
}
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/focusManager.js
|
|
var _focused, _cleanup, _setup, _a;
|
|
var FocusManager = (_a = class extends Subscribable {
|
|
constructor() {
|
|
super();
|
|
__privateAdd(this, _focused);
|
|
__privateAdd(this, _cleanup);
|
|
__privateAdd(this, _setup);
|
|
__privateSet(this, _setup, (onFocus) => {
|
|
if (!isServer && window.addEventListener) {
|
|
const listener = () => onFocus();
|
|
window.addEventListener("visibilitychange", listener, false);
|
|
return () => {
|
|
window.removeEventListener("visibilitychange", listener);
|
|
};
|
|
}
|
|
return;
|
|
});
|
|
}
|
|
onSubscribe() {
|
|
if (!__privateGet(this, _cleanup)) {
|
|
this.setEventListener(__privateGet(this, _setup));
|
|
}
|
|
}
|
|
onUnsubscribe() {
|
|
var _a12;
|
|
if (!this.hasListeners()) {
|
|
(_a12 = __privateGet(this, _cleanup)) == null ? void 0 : _a12.call(this);
|
|
__privateSet(this, _cleanup, void 0);
|
|
}
|
|
}
|
|
setEventListener(setup) {
|
|
var _a12;
|
|
__privateSet(this, _setup, setup);
|
|
(_a12 = __privateGet(this, _cleanup)) == null ? void 0 : _a12.call(this);
|
|
__privateSet(this, _cleanup, setup((focused) => {
|
|
if (typeof focused === "boolean") {
|
|
this.setFocused(focused);
|
|
} else {
|
|
this.onFocus();
|
|
}
|
|
}));
|
|
}
|
|
setFocused(focused) {
|
|
const changed = __privateGet(this, _focused) !== focused;
|
|
if (changed) {
|
|
__privateSet(this, _focused, focused);
|
|
this.onFocus();
|
|
}
|
|
}
|
|
onFocus() {
|
|
const isFocused = this.isFocused();
|
|
this.listeners.forEach((listener) => {
|
|
listener(isFocused);
|
|
});
|
|
}
|
|
isFocused() {
|
|
var _a12;
|
|
if (typeof __privateGet(this, _focused) === "boolean") {
|
|
return __privateGet(this, _focused);
|
|
}
|
|
return ((_a12 = globalThis.document) == null ? void 0 : _a12.visibilityState) !== "hidden";
|
|
}
|
|
}, _focused = new WeakMap(), _cleanup = new WeakMap(), _setup = new WeakMap(), _a);
|
|
var focusManager = new FocusManager();
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/onlineManager.js
|
|
var _online, _cleanup2, _setup2, _a2;
|
|
var OnlineManager = (_a2 = class extends Subscribable {
|
|
constructor() {
|
|
super();
|
|
__privateAdd(this, _online, true);
|
|
__privateAdd(this, _cleanup2);
|
|
__privateAdd(this, _setup2);
|
|
__privateSet(this, _setup2, (onOnline) => {
|
|
if (!isServer && window.addEventListener) {
|
|
const onlineListener = () => onOnline(true);
|
|
const offlineListener = () => onOnline(false);
|
|
window.addEventListener("online", onlineListener, false);
|
|
window.addEventListener("offline", offlineListener, false);
|
|
return () => {
|
|
window.removeEventListener("online", onlineListener);
|
|
window.removeEventListener("offline", offlineListener);
|
|
};
|
|
}
|
|
return;
|
|
});
|
|
}
|
|
onSubscribe() {
|
|
if (!__privateGet(this, _cleanup2)) {
|
|
this.setEventListener(__privateGet(this, _setup2));
|
|
}
|
|
}
|
|
onUnsubscribe() {
|
|
var _a12;
|
|
if (!this.hasListeners()) {
|
|
(_a12 = __privateGet(this, _cleanup2)) == null ? void 0 : _a12.call(this);
|
|
__privateSet(this, _cleanup2, void 0);
|
|
}
|
|
}
|
|
setEventListener(setup) {
|
|
var _a12;
|
|
__privateSet(this, _setup2, setup);
|
|
(_a12 = __privateGet(this, _cleanup2)) == null ? void 0 : _a12.call(this);
|
|
__privateSet(this, _cleanup2, setup(this.setOnline.bind(this)));
|
|
}
|
|
setOnline(online) {
|
|
const changed = __privateGet(this, _online) !== online;
|
|
if (changed) {
|
|
__privateSet(this, _online, online);
|
|
this.listeners.forEach((listener) => {
|
|
listener(online);
|
|
});
|
|
}
|
|
}
|
|
isOnline() {
|
|
return __privateGet(this, _online);
|
|
}
|
|
}, _online = new WeakMap(), _cleanup2 = new WeakMap(), _setup2 = new WeakMap(), _a2);
|
|
var onlineManager = new OnlineManager();
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/thenable.js
|
|
function pendingThenable() {
|
|
let resolve;
|
|
let reject;
|
|
const thenable = new Promise((_resolve, _reject) => {
|
|
resolve = _resolve;
|
|
reject = _reject;
|
|
});
|
|
thenable.status = "pending";
|
|
thenable.catch(() => {
|
|
});
|
|
function finalize(data) {
|
|
Object.assign(thenable, data);
|
|
delete thenable.resolve;
|
|
delete thenable.reject;
|
|
}
|
|
thenable.resolve = (value) => {
|
|
finalize({
|
|
status: "fulfilled",
|
|
value
|
|
});
|
|
resolve(value);
|
|
};
|
|
thenable.reject = (reason) => {
|
|
finalize({
|
|
status: "rejected",
|
|
reason
|
|
});
|
|
reject(reason);
|
|
};
|
|
return thenable;
|
|
}
|
|
function tryResolveSync(promise) {
|
|
var _a12;
|
|
let data;
|
|
(_a12 = promise.then((result) => {
|
|
data = result;
|
|
return result;
|
|
}, noop)) == null ? void 0 : _a12.catch(noop);
|
|
if (data !== void 0) {
|
|
return { data };
|
|
}
|
|
return void 0;
|
|
}
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/retryer.js
|
|
function defaultRetryDelay(failureCount) {
|
|
return Math.min(1e3 * 2 ** failureCount, 3e4);
|
|
}
|
|
function canFetch(networkMode) {
|
|
return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
|
|
}
|
|
var CancelledError = class extends Error {
|
|
constructor(options) {
|
|
super("CancelledError");
|
|
this.revert = options == null ? void 0 : options.revert;
|
|
this.silent = options == null ? void 0 : options.silent;
|
|
}
|
|
};
|
|
function isCancelledError(value) {
|
|
return value instanceof CancelledError;
|
|
}
|
|
function createRetryer(config) {
|
|
let isRetryCancelled = false;
|
|
let failureCount = 0;
|
|
let isResolved = false;
|
|
let continueFn;
|
|
const thenable = pendingThenable();
|
|
const cancel = (cancelOptions) => {
|
|
var _a12;
|
|
if (!isResolved) {
|
|
reject(new CancelledError(cancelOptions));
|
|
(_a12 = config.abort) == null ? void 0 : _a12.call(config);
|
|
}
|
|
};
|
|
const cancelRetry = () => {
|
|
isRetryCancelled = true;
|
|
};
|
|
const continueRetry = () => {
|
|
isRetryCancelled = false;
|
|
};
|
|
const canContinue = () => focusManager.isFocused() && (config.networkMode === "always" || onlineManager.isOnline()) && config.canRun();
|
|
const canStart = () => canFetch(config.networkMode) && config.canRun();
|
|
const resolve = (value) => {
|
|
var _a12;
|
|
if (!isResolved) {
|
|
isResolved = true;
|
|
(_a12 = config.onSuccess) == null ? void 0 : _a12.call(config, value);
|
|
continueFn == null ? void 0 : continueFn();
|
|
thenable.resolve(value);
|
|
}
|
|
};
|
|
const reject = (value) => {
|
|
var _a12;
|
|
if (!isResolved) {
|
|
isResolved = true;
|
|
(_a12 = config.onError) == null ? void 0 : _a12.call(config, value);
|
|
continueFn == null ? void 0 : continueFn();
|
|
thenable.reject(value);
|
|
}
|
|
};
|
|
const pause = () => {
|
|
return new Promise((continueResolve) => {
|
|
var _a12;
|
|
continueFn = (value) => {
|
|
if (isResolved || canContinue()) {
|
|
continueResolve(value);
|
|
}
|
|
};
|
|
(_a12 = config.onPause) == null ? void 0 : _a12.call(config);
|
|
}).then(() => {
|
|
var _a12;
|
|
continueFn = void 0;
|
|
if (!isResolved) {
|
|
(_a12 = config.onContinue) == null ? void 0 : _a12.call(config);
|
|
}
|
|
});
|
|
};
|
|
const run = () => {
|
|
if (isResolved) {
|
|
return;
|
|
}
|
|
let promiseOrValue;
|
|
const initialPromise = failureCount === 0 ? config.initialPromise : void 0;
|
|
try {
|
|
promiseOrValue = initialPromise ?? config.fn();
|
|
} catch (error) {
|
|
promiseOrValue = Promise.reject(error);
|
|
}
|
|
Promise.resolve(promiseOrValue).then(resolve).catch((error) => {
|
|
var _a12;
|
|
if (isResolved) {
|
|
return;
|
|
}
|
|
const retry = config.retry ?? (isServer ? 0 : 3);
|
|
const retryDelay = config.retryDelay ?? defaultRetryDelay;
|
|
const delay = typeof retryDelay === "function" ? retryDelay(failureCount, error) : retryDelay;
|
|
const shouldRetry = retry === true || typeof retry === "number" && failureCount < retry || typeof retry === "function" && retry(failureCount, error);
|
|
if (isRetryCancelled || !shouldRetry) {
|
|
reject(error);
|
|
return;
|
|
}
|
|
failureCount++;
|
|
(_a12 = config.onFail) == null ? void 0 : _a12.call(config, failureCount, error);
|
|
sleep(delay).then(() => {
|
|
return canContinue() ? void 0 : pause();
|
|
}).then(() => {
|
|
if (isRetryCancelled) {
|
|
reject(error);
|
|
} else {
|
|
run();
|
|
}
|
|
});
|
|
});
|
|
};
|
|
return {
|
|
promise: thenable,
|
|
cancel,
|
|
continue: () => {
|
|
continueFn == null ? void 0 : continueFn();
|
|
return thenable;
|
|
},
|
|
cancelRetry,
|
|
continueRetry,
|
|
canStart,
|
|
start: () => {
|
|
if (canStart()) {
|
|
run();
|
|
} else {
|
|
pause().then(run);
|
|
}
|
|
return thenable;
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/notifyManager.js
|
|
var defaultScheduler = (cb) => setTimeout(cb, 0);
|
|
function createNotifyManager() {
|
|
let queue = [];
|
|
let transactions = 0;
|
|
let notifyFn = (callback) => {
|
|
callback();
|
|
};
|
|
let batchNotifyFn = (callback) => {
|
|
callback();
|
|
};
|
|
let scheduleFn = defaultScheduler;
|
|
const schedule = (callback) => {
|
|
if (transactions) {
|
|
queue.push(callback);
|
|
} else {
|
|
scheduleFn(() => {
|
|
notifyFn(callback);
|
|
});
|
|
}
|
|
};
|
|
const flush = () => {
|
|
const originalQueue = queue;
|
|
queue = [];
|
|
if (originalQueue.length) {
|
|
scheduleFn(() => {
|
|
batchNotifyFn(() => {
|
|
originalQueue.forEach((callback) => {
|
|
notifyFn(callback);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
};
|
|
return {
|
|
batch: (callback) => {
|
|
let result;
|
|
transactions++;
|
|
try {
|
|
result = callback();
|
|
} finally {
|
|
transactions--;
|
|
if (!transactions) {
|
|
flush();
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
/**
|
|
* All calls to the wrapped function will be batched.
|
|
*/
|
|
batchCalls: (callback) => {
|
|
return (...args) => {
|
|
schedule(() => {
|
|
callback(...args);
|
|
});
|
|
};
|
|
},
|
|
schedule,
|
|
/**
|
|
* Use this method to set a custom notify function.
|
|
* This can be used to for example wrap notifications with `React.act` while running tests.
|
|
*/
|
|
setNotifyFunction: (fn) => {
|
|
notifyFn = fn;
|
|
},
|
|
/**
|
|
* Use this method to set a custom function to batch notifications together into a single tick.
|
|
* By default React Query will use the batch function provided by ReactDOM or React Native.
|
|
*/
|
|
setBatchNotifyFunction: (fn) => {
|
|
batchNotifyFn = fn;
|
|
},
|
|
setScheduler: (fn) => {
|
|
scheduleFn = fn;
|
|
}
|
|
};
|
|
}
|
|
var notifyManager = createNotifyManager();
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/removable.js
|
|
var _gcTimeout, _a3;
|
|
var Removable = (_a3 = class {
|
|
constructor() {
|
|
__privateAdd(this, _gcTimeout);
|
|
}
|
|
destroy() {
|
|
this.clearGcTimeout();
|
|
}
|
|
scheduleGc() {
|
|
this.clearGcTimeout();
|
|
if (isValidTimeout(this.gcTime)) {
|
|
__privateSet(this, _gcTimeout, setTimeout(() => {
|
|
this.optionalRemove();
|
|
}, this.gcTime));
|
|
}
|
|
}
|
|
updateGcTime(newGcTime) {
|
|
this.gcTime = Math.max(
|
|
this.gcTime || 0,
|
|
newGcTime ?? (isServer ? Infinity : 5 * 60 * 1e3)
|
|
);
|
|
}
|
|
clearGcTimeout() {
|
|
if (__privateGet(this, _gcTimeout)) {
|
|
clearTimeout(__privateGet(this, _gcTimeout));
|
|
__privateSet(this, _gcTimeout, void 0);
|
|
}
|
|
}
|
|
}, _gcTimeout = new WeakMap(), _a3);
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/query.js
|
|
var _initialState, _revertState, _cache, _client, _retryer, _defaultOptions, _abortSignalConsumed, _Query_instances, dispatch_fn, _a4;
|
|
var Query = (_a4 = class extends Removable {
|
|
constructor(config) {
|
|
super();
|
|
__privateAdd(this, _Query_instances);
|
|
__privateAdd(this, _initialState);
|
|
__privateAdd(this, _revertState);
|
|
__privateAdd(this, _cache);
|
|
__privateAdd(this, _client);
|
|
__privateAdd(this, _retryer);
|
|
__privateAdd(this, _defaultOptions);
|
|
__privateAdd(this, _abortSignalConsumed);
|
|
__privateSet(this, _abortSignalConsumed, false);
|
|
__privateSet(this, _defaultOptions, config.defaultOptions);
|
|
this.setOptions(config.options);
|
|
this.observers = [];
|
|
__privateSet(this, _client, config.client);
|
|
__privateSet(this, _cache, __privateGet(this, _client).getQueryCache());
|
|
this.queryKey = config.queryKey;
|
|
this.queryHash = config.queryHash;
|
|
__privateSet(this, _initialState, getDefaultState(this.options));
|
|
this.state = config.state ?? __privateGet(this, _initialState);
|
|
this.scheduleGc();
|
|
}
|
|
get meta() {
|
|
return this.options.meta;
|
|
}
|
|
get promise() {
|
|
var _a12;
|
|
return (_a12 = __privateGet(this, _retryer)) == null ? void 0 : _a12.promise;
|
|
}
|
|
setOptions(options) {
|
|
this.options = { ...__privateGet(this, _defaultOptions), ...options };
|
|
this.updateGcTime(this.options.gcTime);
|
|
}
|
|
optionalRemove() {
|
|
if (!this.observers.length && this.state.fetchStatus === "idle") {
|
|
__privateGet(this, _cache).remove(this);
|
|
}
|
|
}
|
|
setData(newData, options) {
|
|
const data = replaceData(this.state.data, newData, this.options);
|
|
__privateMethod(this, _Query_instances, dispatch_fn).call(this, {
|
|
data,
|
|
type: "success",
|
|
dataUpdatedAt: options == null ? void 0 : options.updatedAt,
|
|
manual: options == null ? void 0 : options.manual
|
|
});
|
|
return data;
|
|
}
|
|
setState(state, setStateOptions) {
|
|
__privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "setState", state, setStateOptions });
|
|
}
|
|
cancel(options) {
|
|
var _a12, _b;
|
|
const promise = (_a12 = __privateGet(this, _retryer)) == null ? void 0 : _a12.promise;
|
|
(_b = __privateGet(this, _retryer)) == null ? void 0 : _b.cancel(options);
|
|
return promise ? promise.then(noop).catch(noop) : Promise.resolve();
|
|
}
|
|
destroy() {
|
|
super.destroy();
|
|
this.cancel({ silent: true });
|
|
}
|
|
reset() {
|
|
this.destroy();
|
|
this.setState(__privateGet(this, _initialState));
|
|
}
|
|
isActive() {
|
|
return this.observers.some(
|
|
(observer) => resolveEnabled(observer.options.enabled, this) !== false
|
|
);
|
|
}
|
|
isDisabled() {
|
|
if (this.getObserversCount() > 0) {
|
|
return !this.isActive();
|
|
}
|
|
return this.options.queryFn === skipToken || this.state.dataUpdateCount + this.state.errorUpdateCount === 0;
|
|
}
|
|
isStatic() {
|
|
if (this.getObserversCount() > 0) {
|
|
return this.observers.some(
|
|
(observer) => resolveStaleTime(observer.options.staleTime, this) === "static"
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
isStale() {
|
|
if (this.getObserversCount() > 0) {
|
|
return this.observers.some(
|
|
(observer) => observer.getCurrentResult().isStale
|
|
);
|
|
}
|
|
return this.state.data === void 0 || this.state.isInvalidated;
|
|
}
|
|
isStaleByTime(staleTime = 0) {
|
|
if (this.state.data === void 0) {
|
|
return true;
|
|
}
|
|
if (staleTime === "static") {
|
|
return false;
|
|
}
|
|
if (this.state.isInvalidated) {
|
|
return true;
|
|
}
|
|
return !timeUntilStale(this.state.dataUpdatedAt, staleTime);
|
|
}
|
|
onFocus() {
|
|
var _a12;
|
|
const observer = this.observers.find((x) => x.shouldFetchOnWindowFocus());
|
|
observer == null ? void 0 : observer.refetch({ cancelRefetch: false });
|
|
(_a12 = __privateGet(this, _retryer)) == null ? void 0 : _a12.continue();
|
|
}
|
|
onOnline() {
|
|
var _a12;
|
|
const observer = this.observers.find((x) => x.shouldFetchOnReconnect());
|
|
observer == null ? void 0 : observer.refetch({ cancelRefetch: false });
|
|
(_a12 = __privateGet(this, _retryer)) == null ? void 0 : _a12.continue();
|
|
}
|
|
addObserver(observer) {
|
|
if (!this.observers.includes(observer)) {
|
|
this.observers.push(observer);
|
|
this.clearGcTimeout();
|
|
__privateGet(this, _cache).notify({ type: "observerAdded", query: this, observer });
|
|
}
|
|
}
|
|
removeObserver(observer) {
|
|
if (this.observers.includes(observer)) {
|
|
this.observers = this.observers.filter((x) => x !== observer);
|
|
if (!this.observers.length) {
|
|
if (__privateGet(this, _retryer)) {
|
|
if (__privateGet(this, _abortSignalConsumed)) {
|
|
__privateGet(this, _retryer).cancel({ revert: true });
|
|
} else {
|
|
__privateGet(this, _retryer).cancelRetry();
|
|
}
|
|
}
|
|
this.scheduleGc();
|
|
}
|
|
__privateGet(this, _cache).notify({ type: "observerRemoved", query: this, observer });
|
|
}
|
|
}
|
|
getObserversCount() {
|
|
return this.observers.length;
|
|
}
|
|
invalidate() {
|
|
if (!this.state.isInvalidated) {
|
|
__privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "invalidate" });
|
|
}
|
|
}
|
|
fetch(options, fetchOptions) {
|
|
var _a12, _b, _c;
|
|
if (this.state.fetchStatus !== "idle") {
|
|
if (this.state.data !== void 0 && (fetchOptions == null ? void 0 : fetchOptions.cancelRefetch)) {
|
|
this.cancel({ silent: true });
|
|
} else if (__privateGet(this, _retryer)) {
|
|
__privateGet(this, _retryer).continueRetry();
|
|
return __privateGet(this, _retryer).promise;
|
|
}
|
|
}
|
|
if (options) {
|
|
this.setOptions(options);
|
|
}
|
|
if (!this.options.queryFn) {
|
|
const observer = this.observers.find((x) => x.options.queryFn);
|
|
if (observer) {
|
|
this.setOptions(observer.options);
|
|
}
|
|
}
|
|
if (true) {
|
|
if (!Array.isArray(this.options.queryKey)) {
|
|
console.error(
|
|
`As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']`
|
|
);
|
|
}
|
|
}
|
|
const abortController = new AbortController();
|
|
const addSignalProperty = (object) => {
|
|
Object.defineProperty(object, "signal", {
|
|
enumerable: true,
|
|
get: () => {
|
|
__privateSet(this, _abortSignalConsumed, true);
|
|
return abortController.signal;
|
|
}
|
|
});
|
|
};
|
|
const fetchFn = () => {
|
|
const queryFn = ensureQueryFn(this.options, fetchOptions);
|
|
const createQueryFnContext = () => {
|
|
const queryFnContext2 = {
|
|
client: __privateGet(this, _client),
|
|
queryKey: this.queryKey,
|
|
meta: this.meta
|
|
};
|
|
addSignalProperty(queryFnContext2);
|
|
return queryFnContext2;
|
|
};
|
|
const queryFnContext = createQueryFnContext();
|
|
__privateSet(this, _abortSignalConsumed, false);
|
|
if (this.options.persister) {
|
|
return this.options.persister(
|
|
queryFn,
|
|
queryFnContext,
|
|
this
|
|
);
|
|
}
|
|
return queryFn(queryFnContext);
|
|
};
|
|
const createFetchContext = () => {
|
|
const context2 = {
|
|
fetchOptions,
|
|
options: this.options,
|
|
queryKey: this.queryKey,
|
|
client: __privateGet(this, _client),
|
|
state: this.state,
|
|
fetchFn
|
|
};
|
|
addSignalProperty(context2);
|
|
return context2;
|
|
};
|
|
const context = createFetchContext();
|
|
(_a12 = this.options.behavior) == null ? void 0 : _a12.onFetch(context, this);
|
|
__privateSet(this, _revertState, this.state);
|
|
if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== ((_b = context.fetchOptions) == null ? void 0 : _b.meta)) {
|
|
__privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "fetch", meta: (_c = context.fetchOptions) == null ? void 0 : _c.meta });
|
|
}
|
|
const onError = (error) => {
|
|
var _a13, _b2, _c2, _d;
|
|
if (!(isCancelledError(error) && error.silent)) {
|
|
__privateMethod(this, _Query_instances, dispatch_fn).call(this, {
|
|
type: "error",
|
|
error
|
|
});
|
|
}
|
|
if (!isCancelledError(error)) {
|
|
(_b2 = (_a13 = __privateGet(this, _cache).config).onError) == null ? void 0 : _b2.call(
|
|
_a13,
|
|
error,
|
|
this
|
|
);
|
|
(_d = (_c2 = __privateGet(this, _cache).config).onSettled) == null ? void 0 : _d.call(
|
|
_c2,
|
|
this.state.data,
|
|
error,
|
|
this
|
|
);
|
|
}
|
|
this.scheduleGc();
|
|
};
|
|
__privateSet(this, _retryer, createRetryer({
|
|
initialPromise: fetchOptions == null ? void 0 : fetchOptions.initialPromise,
|
|
fn: context.fetchFn,
|
|
abort: abortController.abort.bind(abortController),
|
|
onSuccess: (data) => {
|
|
var _a13, _b2, _c2, _d;
|
|
if (data === void 0) {
|
|
if (true) {
|
|
console.error(
|
|
`Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`
|
|
);
|
|
}
|
|
onError(new Error(`${this.queryHash} data is undefined`));
|
|
return;
|
|
}
|
|
try {
|
|
this.setData(data);
|
|
} catch (error) {
|
|
onError(error);
|
|
return;
|
|
}
|
|
(_b2 = (_a13 = __privateGet(this, _cache).config).onSuccess) == null ? void 0 : _b2.call(_a13, data, this);
|
|
(_d = (_c2 = __privateGet(this, _cache).config).onSettled) == null ? void 0 : _d.call(
|
|
_c2,
|
|
data,
|
|
this.state.error,
|
|
this
|
|
);
|
|
this.scheduleGc();
|
|
},
|
|
onError,
|
|
onFail: (failureCount, error) => {
|
|
__privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "failed", failureCount, error });
|
|
},
|
|
onPause: () => {
|
|
__privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "pause" });
|
|
},
|
|
onContinue: () => {
|
|
__privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "continue" });
|
|
},
|
|
retry: context.options.retry,
|
|
retryDelay: context.options.retryDelay,
|
|
networkMode: context.options.networkMode,
|
|
canRun: () => true
|
|
}));
|
|
return __privateGet(this, _retryer).start();
|
|
}
|
|
}, _initialState = new WeakMap(), _revertState = new WeakMap(), _cache = new WeakMap(), _client = new WeakMap(), _retryer = new WeakMap(), _defaultOptions = new WeakMap(), _abortSignalConsumed = new WeakMap(), _Query_instances = new WeakSet(), dispatch_fn = function(action) {
|
|
const reducer = (state) => {
|
|
switch (action.type) {
|
|
case "failed":
|
|
return {
|
|
...state,
|
|
fetchFailureCount: action.failureCount,
|
|
fetchFailureReason: action.error
|
|
};
|
|
case "pause":
|
|
return {
|
|
...state,
|
|
fetchStatus: "paused"
|
|
};
|
|
case "continue":
|
|
return {
|
|
...state,
|
|
fetchStatus: "fetching"
|
|
};
|
|
case "fetch":
|
|
return {
|
|
...state,
|
|
...fetchState(state.data, this.options),
|
|
fetchMeta: action.meta ?? null
|
|
};
|
|
case "success":
|
|
__privateSet(this, _revertState, void 0);
|
|
return {
|
|
...state,
|
|
data: action.data,
|
|
dataUpdateCount: state.dataUpdateCount + 1,
|
|
dataUpdatedAt: action.dataUpdatedAt ?? Date.now(),
|
|
error: null,
|
|
isInvalidated: false,
|
|
status: "success",
|
|
...!action.manual && {
|
|
fetchStatus: "idle",
|
|
fetchFailureCount: 0,
|
|
fetchFailureReason: null
|
|
}
|
|
};
|
|
case "error":
|
|
const error = action.error;
|
|
if (isCancelledError(error) && error.revert && __privateGet(this, _revertState)) {
|
|
return { ...__privateGet(this, _revertState), fetchStatus: "idle" };
|
|
}
|
|
return {
|
|
...state,
|
|
error,
|
|
errorUpdateCount: state.errorUpdateCount + 1,
|
|
errorUpdatedAt: Date.now(),
|
|
fetchFailureCount: state.fetchFailureCount + 1,
|
|
fetchFailureReason: error,
|
|
fetchStatus: "idle",
|
|
status: "error"
|
|
};
|
|
case "invalidate":
|
|
return {
|
|
...state,
|
|
isInvalidated: true
|
|
};
|
|
case "setState":
|
|
return {
|
|
...state,
|
|
...action.state
|
|
};
|
|
}
|
|
};
|
|
this.state = reducer(this.state);
|
|
notifyManager.batch(() => {
|
|
this.observers.forEach((observer) => {
|
|
observer.onQueryUpdate();
|
|
});
|
|
__privateGet(this, _cache).notify({ query: this, type: "updated", action });
|
|
});
|
|
}, _a4);
|
|
function fetchState(data, options) {
|
|
return {
|
|
fetchFailureCount: 0,
|
|
fetchFailureReason: null,
|
|
fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
|
|
...data === void 0 && {
|
|
error: null,
|
|
status: "pending"
|
|
}
|
|
};
|
|
}
|
|
function getDefaultState(options) {
|
|
const data = typeof options.initialData === "function" ? options.initialData() : options.initialData;
|
|
const hasData = data !== void 0;
|
|
const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
|
|
return {
|
|
data,
|
|
dataUpdateCount: 0,
|
|
dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,
|
|
error: null,
|
|
errorUpdateCount: 0,
|
|
errorUpdatedAt: 0,
|
|
fetchFailureCount: 0,
|
|
fetchFailureReason: null,
|
|
fetchMeta: null,
|
|
isInvalidated: false,
|
|
status: hasData ? "success" : "pending",
|
|
fetchStatus: "idle"
|
|
};
|
|
}
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/queryCache.js
|
|
var _queries, _a5;
|
|
var QueryCache = (_a5 = class extends Subscribable {
|
|
constructor(config = {}) {
|
|
super();
|
|
__privateAdd(this, _queries);
|
|
this.config = config;
|
|
__privateSet(this, _queries, /* @__PURE__ */ new Map());
|
|
}
|
|
build(client, options, state) {
|
|
const queryKey = options.queryKey;
|
|
const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options);
|
|
let query = this.get(queryHash);
|
|
if (!query) {
|
|
query = new Query({
|
|
client,
|
|
queryKey,
|
|
queryHash,
|
|
options: client.defaultQueryOptions(options),
|
|
state,
|
|
defaultOptions: client.getQueryDefaults(queryKey)
|
|
});
|
|
this.add(query);
|
|
}
|
|
return query;
|
|
}
|
|
add(query) {
|
|
if (!__privateGet(this, _queries).has(query.queryHash)) {
|
|
__privateGet(this, _queries).set(query.queryHash, query);
|
|
this.notify({
|
|
type: "added",
|
|
query
|
|
});
|
|
}
|
|
}
|
|
remove(query) {
|
|
const queryInMap = __privateGet(this, _queries).get(query.queryHash);
|
|
if (queryInMap) {
|
|
query.destroy();
|
|
if (queryInMap === query) {
|
|
__privateGet(this, _queries).delete(query.queryHash);
|
|
}
|
|
this.notify({ type: "removed", query });
|
|
}
|
|
}
|
|
clear() {
|
|
notifyManager.batch(() => {
|
|
this.getAll().forEach((query) => {
|
|
this.remove(query);
|
|
});
|
|
});
|
|
}
|
|
get(queryHash) {
|
|
return __privateGet(this, _queries).get(queryHash);
|
|
}
|
|
getAll() {
|
|
return [...__privateGet(this, _queries).values()];
|
|
}
|
|
find(filters) {
|
|
const defaultedFilters = { exact: true, ...filters };
|
|
return this.getAll().find(
|
|
(query) => matchQuery(defaultedFilters, query)
|
|
);
|
|
}
|
|
findAll(filters = {}) {
|
|
const queries = this.getAll();
|
|
return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries;
|
|
}
|
|
notify(event) {
|
|
notifyManager.batch(() => {
|
|
this.listeners.forEach((listener) => {
|
|
listener(event);
|
|
});
|
|
});
|
|
}
|
|
onFocus() {
|
|
notifyManager.batch(() => {
|
|
this.getAll().forEach((query) => {
|
|
query.onFocus();
|
|
});
|
|
});
|
|
}
|
|
onOnline() {
|
|
notifyManager.batch(() => {
|
|
this.getAll().forEach((query) => {
|
|
query.onOnline();
|
|
});
|
|
});
|
|
}
|
|
}, _queries = new WeakMap(), _a5);
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/mutation.js
|
|
var _observers, _mutationCache, _retryer2, _Mutation_instances, dispatch_fn2, _a6;
|
|
var Mutation = (_a6 = class extends Removable {
|
|
constructor(config) {
|
|
super();
|
|
__privateAdd(this, _Mutation_instances);
|
|
__privateAdd(this, _observers);
|
|
__privateAdd(this, _mutationCache);
|
|
__privateAdd(this, _retryer2);
|
|
this.mutationId = config.mutationId;
|
|
__privateSet(this, _mutationCache, config.mutationCache);
|
|
__privateSet(this, _observers, []);
|
|
this.state = config.state || getDefaultState2();
|
|
this.setOptions(config.options);
|
|
this.scheduleGc();
|
|
}
|
|
setOptions(options) {
|
|
this.options = options;
|
|
this.updateGcTime(this.options.gcTime);
|
|
}
|
|
get meta() {
|
|
return this.options.meta;
|
|
}
|
|
addObserver(observer) {
|
|
if (!__privateGet(this, _observers).includes(observer)) {
|
|
__privateGet(this, _observers).push(observer);
|
|
this.clearGcTimeout();
|
|
__privateGet(this, _mutationCache).notify({
|
|
type: "observerAdded",
|
|
mutation: this,
|
|
observer
|
|
});
|
|
}
|
|
}
|
|
removeObserver(observer) {
|
|
__privateSet(this, _observers, __privateGet(this, _observers).filter((x) => x !== observer));
|
|
this.scheduleGc();
|
|
__privateGet(this, _mutationCache).notify({
|
|
type: "observerRemoved",
|
|
mutation: this,
|
|
observer
|
|
});
|
|
}
|
|
optionalRemove() {
|
|
if (!__privateGet(this, _observers).length) {
|
|
if (this.state.status === "pending") {
|
|
this.scheduleGc();
|
|
} else {
|
|
__privateGet(this, _mutationCache).remove(this);
|
|
}
|
|
}
|
|
}
|
|
continue() {
|
|
var _a12;
|
|
return ((_a12 = __privateGet(this, _retryer2)) == null ? void 0 : _a12.continue()) ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
|
|
this.execute(this.state.variables);
|
|
}
|
|
async execute(variables) {
|
|
var _a12, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
|
|
const onContinue = () => {
|
|
__privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "continue" });
|
|
};
|
|
__privateSet(this, _retryer2, createRetryer({
|
|
fn: () => {
|
|
if (!this.options.mutationFn) {
|
|
return Promise.reject(new Error("No mutationFn found"));
|
|
}
|
|
return this.options.mutationFn(variables);
|
|
},
|
|
onFail: (failureCount, error) => {
|
|
__privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "failed", failureCount, error });
|
|
},
|
|
onPause: () => {
|
|
__privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "pause" });
|
|
},
|
|
onContinue,
|
|
retry: this.options.retry ?? 0,
|
|
retryDelay: this.options.retryDelay,
|
|
networkMode: this.options.networkMode,
|
|
canRun: () => __privateGet(this, _mutationCache).canRun(this)
|
|
}));
|
|
const restored = this.state.status === "pending";
|
|
const isPaused = !__privateGet(this, _retryer2).canStart();
|
|
try {
|
|
if (restored) {
|
|
onContinue();
|
|
} else {
|
|
__privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "pending", variables, isPaused });
|
|
await ((_b = (_a12 = __privateGet(this, _mutationCache).config).onMutate) == null ? void 0 : _b.call(
|
|
_a12,
|
|
variables,
|
|
this
|
|
));
|
|
const context = await ((_d = (_c = this.options).onMutate) == null ? void 0 : _d.call(_c, variables));
|
|
if (context !== this.state.context) {
|
|
__privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, {
|
|
type: "pending",
|
|
context,
|
|
variables,
|
|
isPaused
|
|
});
|
|
}
|
|
}
|
|
const data = await __privateGet(this, _retryer2).start();
|
|
await ((_f = (_e = __privateGet(this, _mutationCache).config).onSuccess) == null ? void 0 : _f.call(
|
|
_e,
|
|
data,
|
|
variables,
|
|
this.state.context,
|
|
this
|
|
));
|
|
await ((_h = (_g = this.options).onSuccess) == null ? void 0 : _h.call(_g, data, variables, this.state.context));
|
|
await ((_j = (_i = __privateGet(this, _mutationCache).config).onSettled) == null ? void 0 : _j.call(
|
|
_i,
|
|
data,
|
|
null,
|
|
this.state.variables,
|
|
this.state.context,
|
|
this
|
|
));
|
|
await ((_l = (_k = this.options).onSettled) == null ? void 0 : _l.call(_k, data, null, variables, this.state.context));
|
|
__privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "success", data });
|
|
return data;
|
|
} catch (error) {
|
|
try {
|
|
await ((_n = (_m = __privateGet(this, _mutationCache).config).onError) == null ? void 0 : _n.call(
|
|
_m,
|
|
error,
|
|
variables,
|
|
this.state.context,
|
|
this
|
|
));
|
|
await ((_p = (_o = this.options).onError) == null ? void 0 : _p.call(
|
|
_o,
|
|
error,
|
|
variables,
|
|
this.state.context
|
|
));
|
|
await ((_r = (_q = __privateGet(this, _mutationCache).config).onSettled) == null ? void 0 : _r.call(
|
|
_q,
|
|
void 0,
|
|
error,
|
|
this.state.variables,
|
|
this.state.context,
|
|
this
|
|
));
|
|
await ((_t = (_s = this.options).onSettled) == null ? void 0 : _t.call(
|
|
_s,
|
|
void 0,
|
|
error,
|
|
variables,
|
|
this.state.context
|
|
));
|
|
throw error;
|
|
} finally {
|
|
__privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "error", error });
|
|
}
|
|
} finally {
|
|
__privateGet(this, _mutationCache).runNext(this);
|
|
}
|
|
}
|
|
}, _observers = new WeakMap(), _mutationCache = new WeakMap(), _retryer2 = new WeakMap(), _Mutation_instances = new WeakSet(), dispatch_fn2 = function(action) {
|
|
const reducer = (state) => {
|
|
switch (action.type) {
|
|
case "failed":
|
|
return {
|
|
...state,
|
|
failureCount: action.failureCount,
|
|
failureReason: action.error
|
|
};
|
|
case "pause":
|
|
return {
|
|
...state,
|
|
isPaused: true
|
|
};
|
|
case "continue":
|
|
return {
|
|
...state,
|
|
isPaused: false
|
|
};
|
|
case "pending":
|
|
return {
|
|
...state,
|
|
context: action.context,
|
|
data: void 0,
|
|
failureCount: 0,
|
|
failureReason: null,
|
|
error: null,
|
|
isPaused: action.isPaused,
|
|
status: "pending",
|
|
variables: action.variables,
|
|
submittedAt: Date.now()
|
|
};
|
|
case "success":
|
|
return {
|
|
...state,
|
|
data: action.data,
|
|
failureCount: 0,
|
|
failureReason: null,
|
|
error: null,
|
|
status: "success",
|
|
isPaused: false
|
|
};
|
|
case "error":
|
|
return {
|
|
...state,
|
|
data: void 0,
|
|
error: action.error,
|
|
failureCount: state.failureCount + 1,
|
|
failureReason: action.error,
|
|
isPaused: false,
|
|
status: "error"
|
|
};
|
|
}
|
|
};
|
|
this.state = reducer(this.state);
|
|
notifyManager.batch(() => {
|
|
__privateGet(this, _observers).forEach((observer) => {
|
|
observer.onMutationUpdate(action);
|
|
});
|
|
__privateGet(this, _mutationCache).notify({
|
|
mutation: this,
|
|
type: "updated",
|
|
action
|
|
});
|
|
});
|
|
}, _a6);
|
|
function getDefaultState2() {
|
|
return {
|
|
context: void 0,
|
|
data: void 0,
|
|
error: null,
|
|
failureCount: 0,
|
|
failureReason: null,
|
|
isPaused: false,
|
|
status: "idle",
|
|
variables: void 0,
|
|
submittedAt: 0
|
|
};
|
|
}
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/mutationCache.js
|
|
var _mutations, _scopes, _mutationId, _a7;
|
|
var MutationCache = (_a7 = class extends Subscribable {
|
|
constructor(config = {}) {
|
|
super();
|
|
__privateAdd(this, _mutations);
|
|
__privateAdd(this, _scopes);
|
|
__privateAdd(this, _mutationId);
|
|
this.config = config;
|
|
__privateSet(this, _mutations, /* @__PURE__ */ new Set());
|
|
__privateSet(this, _scopes, /* @__PURE__ */ new Map());
|
|
__privateSet(this, _mutationId, 0);
|
|
}
|
|
build(client, options, state) {
|
|
const mutation = new Mutation({
|
|
mutationCache: this,
|
|
mutationId: ++__privateWrapper(this, _mutationId)._,
|
|
options: client.defaultMutationOptions(options),
|
|
state
|
|
});
|
|
this.add(mutation);
|
|
return mutation;
|
|
}
|
|
add(mutation) {
|
|
__privateGet(this, _mutations).add(mutation);
|
|
const scope = scopeFor(mutation);
|
|
if (typeof scope === "string") {
|
|
const scopedMutations = __privateGet(this, _scopes).get(scope);
|
|
if (scopedMutations) {
|
|
scopedMutations.push(mutation);
|
|
} else {
|
|
__privateGet(this, _scopes).set(scope, [mutation]);
|
|
}
|
|
}
|
|
this.notify({ type: "added", mutation });
|
|
}
|
|
remove(mutation) {
|
|
if (__privateGet(this, _mutations).delete(mutation)) {
|
|
const scope = scopeFor(mutation);
|
|
if (typeof scope === "string") {
|
|
const scopedMutations = __privateGet(this, _scopes).get(scope);
|
|
if (scopedMutations) {
|
|
if (scopedMutations.length > 1) {
|
|
const index = scopedMutations.indexOf(mutation);
|
|
if (index !== -1) {
|
|
scopedMutations.splice(index, 1);
|
|
}
|
|
} else if (scopedMutations[0] === mutation) {
|
|
__privateGet(this, _scopes).delete(scope);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.notify({ type: "removed", mutation });
|
|
}
|
|
canRun(mutation) {
|
|
const scope = scopeFor(mutation);
|
|
if (typeof scope === "string") {
|
|
const mutationsWithSameScope = __privateGet(this, _scopes).get(scope);
|
|
const firstPendingMutation = mutationsWithSameScope == null ? void 0 : mutationsWithSameScope.find(
|
|
(m) => m.state.status === "pending"
|
|
);
|
|
return !firstPendingMutation || firstPendingMutation === mutation;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
runNext(mutation) {
|
|
var _a12;
|
|
const scope = scopeFor(mutation);
|
|
if (typeof scope === "string") {
|
|
const foundMutation = (_a12 = __privateGet(this, _scopes).get(scope)) == null ? void 0 : _a12.find((m) => m !== mutation && m.state.isPaused);
|
|
return (foundMutation == null ? void 0 : foundMutation.continue()) ?? Promise.resolve();
|
|
} else {
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
clear() {
|
|
notifyManager.batch(() => {
|
|
__privateGet(this, _mutations).forEach((mutation) => {
|
|
this.notify({ type: "removed", mutation });
|
|
});
|
|
__privateGet(this, _mutations).clear();
|
|
__privateGet(this, _scopes).clear();
|
|
});
|
|
}
|
|
getAll() {
|
|
return Array.from(__privateGet(this, _mutations));
|
|
}
|
|
find(filters) {
|
|
const defaultedFilters = { exact: true, ...filters };
|
|
return this.getAll().find(
|
|
(mutation) => matchMutation(defaultedFilters, mutation)
|
|
);
|
|
}
|
|
findAll(filters = {}) {
|
|
return this.getAll().filter((mutation) => matchMutation(filters, mutation));
|
|
}
|
|
notify(event) {
|
|
notifyManager.batch(() => {
|
|
this.listeners.forEach((listener) => {
|
|
listener(event);
|
|
});
|
|
});
|
|
}
|
|
resumePausedMutations() {
|
|
const pausedMutations = this.getAll().filter((x) => x.state.isPaused);
|
|
return notifyManager.batch(
|
|
() => Promise.all(
|
|
pausedMutations.map((mutation) => mutation.continue().catch(noop))
|
|
)
|
|
);
|
|
}
|
|
}, _mutations = new WeakMap(), _scopes = new WeakMap(), _mutationId = new WeakMap(), _a7);
|
|
function scopeFor(mutation) {
|
|
var _a12;
|
|
return (_a12 = mutation.options.scope) == null ? void 0 : _a12.id;
|
|
}
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js
|
|
function infiniteQueryBehavior(pages) {
|
|
return {
|
|
onFetch: (context, query) => {
|
|
var _a12, _b, _c, _d, _e;
|
|
const options = context.options;
|
|
const direction = (_c = (_b = (_a12 = context.fetchOptions) == null ? void 0 : _a12.meta) == null ? void 0 : _b.fetchMore) == null ? void 0 : _c.direction;
|
|
const oldPages = ((_d = context.state.data) == null ? void 0 : _d.pages) || [];
|
|
const oldPageParams = ((_e = context.state.data) == null ? void 0 : _e.pageParams) || [];
|
|
let result = { pages: [], pageParams: [] };
|
|
let currentPage = 0;
|
|
const fetchFn = async () => {
|
|
let cancelled = false;
|
|
const addSignalProperty = (object) => {
|
|
Object.defineProperty(object, "signal", {
|
|
enumerable: true,
|
|
get: () => {
|
|
if (context.signal.aborted) {
|
|
cancelled = true;
|
|
} else {
|
|
context.signal.addEventListener("abort", () => {
|
|
cancelled = true;
|
|
});
|
|
}
|
|
return context.signal;
|
|
}
|
|
});
|
|
};
|
|
const queryFn = ensureQueryFn(context.options, context.fetchOptions);
|
|
const fetchPage = async (data, param, previous) => {
|
|
if (cancelled) {
|
|
return Promise.reject();
|
|
}
|
|
if (param == null && data.pages.length) {
|
|
return Promise.resolve(data);
|
|
}
|
|
const createQueryFnContext = () => {
|
|
const queryFnContext2 = {
|
|
client: context.client,
|
|
queryKey: context.queryKey,
|
|
pageParam: param,
|
|
direction: previous ? "backward" : "forward",
|
|
meta: context.options.meta
|
|
};
|
|
addSignalProperty(queryFnContext2);
|
|
return queryFnContext2;
|
|
};
|
|
const queryFnContext = createQueryFnContext();
|
|
const page = await queryFn(queryFnContext);
|
|
const { maxPages } = context.options;
|
|
const addTo = previous ? addToStart : addToEnd;
|
|
return {
|
|
pages: addTo(data.pages, page, maxPages),
|
|
pageParams: addTo(data.pageParams, param, maxPages)
|
|
};
|
|
};
|
|
if (direction && oldPages.length) {
|
|
const previous = direction === "backward";
|
|
const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
|
|
const oldData = {
|
|
pages: oldPages,
|
|
pageParams: oldPageParams
|
|
};
|
|
const param = pageParamFn(options, oldData);
|
|
result = await fetchPage(oldData, param, previous);
|
|
} else {
|
|
const remainingPages = pages ?? oldPages.length;
|
|
do {
|
|
const param = currentPage === 0 ? oldPageParams[0] ?? options.initialPageParam : getNextPageParam(options, result);
|
|
if (currentPage > 0 && param == null) {
|
|
break;
|
|
}
|
|
result = await fetchPage(result, param);
|
|
currentPage++;
|
|
} while (currentPage < remainingPages);
|
|
}
|
|
return result;
|
|
};
|
|
if (context.options.persister) {
|
|
context.fetchFn = () => {
|
|
var _a13, _b2;
|
|
return (_b2 = (_a13 = context.options).persister) == null ? void 0 : _b2.call(
|
|
_a13,
|
|
fetchFn,
|
|
{
|
|
client: context.client,
|
|
queryKey: context.queryKey,
|
|
meta: context.options.meta,
|
|
signal: context.signal
|
|
},
|
|
query
|
|
);
|
|
};
|
|
} else {
|
|
context.fetchFn = fetchFn;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function getNextPageParam(options, { pages, pageParams }) {
|
|
const lastIndex = pages.length - 1;
|
|
return pages.length > 0 ? options.getNextPageParam(
|
|
pages[lastIndex],
|
|
pages,
|
|
pageParams[lastIndex],
|
|
pageParams
|
|
) : void 0;
|
|
}
|
|
function getPreviousPageParam(options, { pages, pageParams }) {
|
|
var _a12;
|
|
return pages.length > 0 ? (_a12 = options.getPreviousPageParam) == null ? void 0 : _a12.call(options, pages[0], pages, pageParams[0], pageParams) : void 0;
|
|
}
|
|
function hasNextPage(options, data) {
|
|
if (!data) return false;
|
|
return getNextPageParam(options, data) != null;
|
|
}
|
|
function hasPreviousPage(options, data) {
|
|
if (!data || !options.getPreviousPageParam) return false;
|
|
return getPreviousPageParam(options, data) != null;
|
|
}
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/queryClient.js
|
|
var _queryCache, _mutationCache2, _defaultOptions2, _queryDefaults, _mutationDefaults, _mountCount, _unsubscribeFocus, _unsubscribeOnline, _a8;
|
|
var QueryClient = (_a8 = class {
|
|
constructor(config = {}) {
|
|
__privateAdd(this, _queryCache);
|
|
__privateAdd(this, _mutationCache2);
|
|
__privateAdd(this, _defaultOptions2);
|
|
__privateAdd(this, _queryDefaults);
|
|
__privateAdd(this, _mutationDefaults);
|
|
__privateAdd(this, _mountCount);
|
|
__privateAdd(this, _unsubscribeFocus);
|
|
__privateAdd(this, _unsubscribeOnline);
|
|
__privateSet(this, _queryCache, config.queryCache || new QueryCache());
|
|
__privateSet(this, _mutationCache2, config.mutationCache || new MutationCache());
|
|
__privateSet(this, _defaultOptions2, config.defaultOptions || {});
|
|
__privateSet(this, _queryDefaults, /* @__PURE__ */ new Map());
|
|
__privateSet(this, _mutationDefaults, /* @__PURE__ */ new Map());
|
|
__privateSet(this, _mountCount, 0);
|
|
}
|
|
mount() {
|
|
__privateWrapper(this, _mountCount)._++;
|
|
if (__privateGet(this, _mountCount) !== 1) return;
|
|
__privateSet(this, _unsubscribeFocus, focusManager.subscribe(async (focused) => {
|
|
if (focused) {
|
|
await this.resumePausedMutations();
|
|
__privateGet(this, _queryCache).onFocus();
|
|
}
|
|
}));
|
|
__privateSet(this, _unsubscribeOnline, onlineManager.subscribe(async (online) => {
|
|
if (online) {
|
|
await this.resumePausedMutations();
|
|
__privateGet(this, _queryCache).onOnline();
|
|
}
|
|
}));
|
|
}
|
|
unmount() {
|
|
var _a12, _b;
|
|
__privateWrapper(this, _mountCount)._--;
|
|
if (__privateGet(this, _mountCount) !== 0) return;
|
|
(_a12 = __privateGet(this, _unsubscribeFocus)) == null ? void 0 : _a12.call(this);
|
|
__privateSet(this, _unsubscribeFocus, void 0);
|
|
(_b = __privateGet(this, _unsubscribeOnline)) == null ? void 0 : _b.call(this);
|
|
__privateSet(this, _unsubscribeOnline, void 0);
|
|
}
|
|
isFetching(filters) {
|
|
return __privateGet(this, _queryCache).findAll({ ...filters, fetchStatus: "fetching" }).length;
|
|
}
|
|
isMutating(filters) {
|
|
return __privateGet(this, _mutationCache2).findAll({ ...filters, status: "pending" }).length;
|
|
}
|
|
/**
|
|
* Imperative (non-reactive) way to retrieve data for a QueryKey.
|
|
* Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
|
|
*
|
|
* Hint: Do not use this function inside a component, because it won't receive updates.
|
|
* Use `useQuery` to create a `QueryObserver` that subscribes to changes.
|
|
*/
|
|
getQueryData(queryKey) {
|
|
var _a12;
|
|
const options = this.defaultQueryOptions({ queryKey });
|
|
return (_a12 = __privateGet(this, _queryCache).get(options.queryHash)) == null ? void 0 : _a12.state.data;
|
|
}
|
|
ensureQueryData(options) {
|
|
const defaultedOptions = this.defaultQueryOptions(options);
|
|
const query = __privateGet(this, _queryCache).build(this, defaultedOptions);
|
|
const cachedData = query.state.data;
|
|
if (cachedData === void 0) {
|
|
return this.fetchQuery(options);
|
|
}
|
|
if (options.revalidateIfStale && query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))) {
|
|
void this.prefetchQuery(defaultedOptions);
|
|
}
|
|
return Promise.resolve(cachedData);
|
|
}
|
|
getQueriesData(filters) {
|
|
return __privateGet(this, _queryCache).findAll(filters).map(({ queryKey, state }) => {
|
|
const data = state.data;
|
|
return [queryKey, data];
|
|
});
|
|
}
|
|
setQueryData(queryKey, updater, options) {
|
|
const defaultedOptions = this.defaultQueryOptions({ queryKey });
|
|
const query = __privateGet(this, _queryCache).get(
|
|
defaultedOptions.queryHash
|
|
);
|
|
const prevData = query == null ? void 0 : query.state.data;
|
|
const data = functionalUpdate(updater, prevData);
|
|
if (data === void 0) {
|
|
return void 0;
|
|
}
|
|
return __privateGet(this, _queryCache).build(this, defaultedOptions).setData(data, { ...options, manual: true });
|
|
}
|
|
setQueriesData(filters, updater, options) {
|
|
return notifyManager.batch(
|
|
() => __privateGet(this, _queryCache).findAll(filters).map(({ queryKey }) => [
|
|
queryKey,
|
|
this.setQueryData(queryKey, updater, options)
|
|
])
|
|
);
|
|
}
|
|
getQueryState(queryKey) {
|
|
var _a12;
|
|
const options = this.defaultQueryOptions({ queryKey });
|
|
return (_a12 = __privateGet(this, _queryCache).get(
|
|
options.queryHash
|
|
)) == null ? void 0 : _a12.state;
|
|
}
|
|
removeQueries(filters) {
|
|
const queryCache = __privateGet(this, _queryCache);
|
|
notifyManager.batch(() => {
|
|
queryCache.findAll(filters).forEach((query) => {
|
|
queryCache.remove(query);
|
|
});
|
|
});
|
|
}
|
|
resetQueries(filters, options) {
|
|
const queryCache = __privateGet(this, _queryCache);
|
|
return notifyManager.batch(() => {
|
|
queryCache.findAll(filters).forEach((query) => {
|
|
query.reset();
|
|
});
|
|
return this.refetchQueries(
|
|
{
|
|
type: "active",
|
|
...filters
|
|
},
|
|
options
|
|
);
|
|
});
|
|
}
|
|
cancelQueries(filters, cancelOptions = {}) {
|
|
const defaultedCancelOptions = { revert: true, ...cancelOptions };
|
|
const promises = notifyManager.batch(
|
|
() => __privateGet(this, _queryCache).findAll(filters).map((query) => query.cancel(defaultedCancelOptions))
|
|
);
|
|
return Promise.all(promises).then(noop).catch(noop);
|
|
}
|
|
invalidateQueries(filters, options = {}) {
|
|
return notifyManager.batch(() => {
|
|
__privateGet(this, _queryCache).findAll(filters).forEach((query) => {
|
|
query.invalidate();
|
|
});
|
|
if ((filters == null ? void 0 : filters.refetchType) === "none") {
|
|
return Promise.resolve();
|
|
}
|
|
return this.refetchQueries(
|
|
{
|
|
...filters,
|
|
type: (filters == null ? void 0 : filters.refetchType) ?? (filters == null ? void 0 : filters.type) ?? "active"
|
|
},
|
|
options
|
|
);
|
|
});
|
|
}
|
|
refetchQueries(filters, options = {}) {
|
|
const fetchOptions = {
|
|
...options,
|
|
cancelRefetch: options.cancelRefetch ?? true
|
|
};
|
|
const promises = notifyManager.batch(
|
|
() => __privateGet(this, _queryCache).findAll(filters).filter((query) => !query.isDisabled() && !query.isStatic()).map((query) => {
|
|
let promise = query.fetch(void 0, fetchOptions);
|
|
if (!fetchOptions.throwOnError) {
|
|
promise = promise.catch(noop);
|
|
}
|
|
return query.state.fetchStatus === "paused" ? Promise.resolve() : promise;
|
|
})
|
|
);
|
|
return Promise.all(promises).then(noop);
|
|
}
|
|
fetchQuery(options) {
|
|
const defaultedOptions = this.defaultQueryOptions(options);
|
|
if (defaultedOptions.retry === void 0) {
|
|
defaultedOptions.retry = false;
|
|
}
|
|
const query = __privateGet(this, _queryCache).build(this, defaultedOptions);
|
|
return query.isStaleByTime(
|
|
resolveStaleTime(defaultedOptions.staleTime, query)
|
|
) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
|
|
}
|
|
prefetchQuery(options) {
|
|
return this.fetchQuery(options).then(noop).catch(noop);
|
|
}
|
|
fetchInfiniteQuery(options) {
|
|
options.behavior = infiniteQueryBehavior(options.pages);
|
|
return this.fetchQuery(options);
|
|
}
|
|
prefetchInfiniteQuery(options) {
|
|
return this.fetchInfiniteQuery(options).then(noop).catch(noop);
|
|
}
|
|
ensureInfiniteQueryData(options) {
|
|
options.behavior = infiniteQueryBehavior(options.pages);
|
|
return this.ensureQueryData(options);
|
|
}
|
|
resumePausedMutations() {
|
|
if (onlineManager.isOnline()) {
|
|
return __privateGet(this, _mutationCache2).resumePausedMutations();
|
|
}
|
|
return Promise.resolve();
|
|
}
|
|
getQueryCache() {
|
|
return __privateGet(this, _queryCache);
|
|
}
|
|
getMutationCache() {
|
|
return __privateGet(this, _mutationCache2);
|
|
}
|
|
getDefaultOptions() {
|
|
return __privateGet(this, _defaultOptions2);
|
|
}
|
|
setDefaultOptions(options) {
|
|
__privateSet(this, _defaultOptions2, options);
|
|
}
|
|
setQueryDefaults(queryKey, options) {
|
|
__privateGet(this, _queryDefaults).set(hashKey(queryKey), {
|
|
queryKey,
|
|
defaultOptions: options
|
|
});
|
|
}
|
|
getQueryDefaults(queryKey) {
|
|
const defaults = [...__privateGet(this, _queryDefaults).values()];
|
|
const result = {};
|
|
defaults.forEach((queryDefault) => {
|
|
if (partialMatchKey(queryKey, queryDefault.queryKey)) {
|
|
Object.assign(result, queryDefault.defaultOptions);
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
setMutationDefaults(mutationKey, options) {
|
|
__privateGet(this, _mutationDefaults).set(hashKey(mutationKey), {
|
|
mutationKey,
|
|
defaultOptions: options
|
|
});
|
|
}
|
|
getMutationDefaults(mutationKey) {
|
|
const defaults = [...__privateGet(this, _mutationDefaults).values()];
|
|
const result = {};
|
|
defaults.forEach((queryDefault) => {
|
|
if (partialMatchKey(mutationKey, queryDefault.mutationKey)) {
|
|
Object.assign(result, queryDefault.defaultOptions);
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
defaultQueryOptions(options) {
|
|
if (options._defaulted) {
|
|
return options;
|
|
}
|
|
const defaultedOptions = {
|
|
...__privateGet(this, _defaultOptions2).queries,
|
|
...this.getQueryDefaults(options.queryKey),
|
|
...options,
|
|
_defaulted: true
|
|
};
|
|
if (!defaultedOptions.queryHash) {
|
|
defaultedOptions.queryHash = hashQueryKeyByOptions(
|
|
defaultedOptions.queryKey,
|
|
defaultedOptions
|
|
);
|
|
}
|
|
if (defaultedOptions.refetchOnReconnect === void 0) {
|
|
defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== "always";
|
|
}
|
|
if (defaultedOptions.throwOnError === void 0) {
|
|
defaultedOptions.throwOnError = !!defaultedOptions.suspense;
|
|
}
|
|
if (!defaultedOptions.networkMode && defaultedOptions.persister) {
|
|
defaultedOptions.networkMode = "offlineFirst";
|
|
}
|
|
if (defaultedOptions.queryFn === skipToken) {
|
|
defaultedOptions.enabled = false;
|
|
}
|
|
return defaultedOptions;
|
|
}
|
|
defaultMutationOptions(options) {
|
|
if (options == null ? void 0 : options._defaulted) {
|
|
return options;
|
|
}
|
|
return {
|
|
...__privateGet(this, _defaultOptions2).mutations,
|
|
...(options == null ? void 0 : options.mutationKey) && this.getMutationDefaults(options.mutationKey),
|
|
...options,
|
|
_defaulted: true
|
|
};
|
|
}
|
|
clear() {
|
|
__privateGet(this, _queryCache).clear();
|
|
__privateGet(this, _mutationCache2).clear();
|
|
}
|
|
}, _queryCache = new WeakMap(), _mutationCache2 = new WeakMap(), _defaultOptions2 = new WeakMap(), _queryDefaults = new WeakMap(), _mutationDefaults = new WeakMap(), _mountCount = new WeakMap(), _unsubscribeFocus = new WeakMap(), _unsubscribeOnline = new WeakMap(), _a8);
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/queryObserver.js
|
|
var _client2, _currentQuery, _currentQueryInitialState, _currentResult, _currentResultState, _currentResultOptions, _currentThenable, _selectError, _selectFn, _selectResult, _lastQueryWithDefinedData, _staleTimeoutId, _refetchIntervalId, _currentRefetchInterval, _trackedProps, _QueryObserver_instances, executeFetch_fn, updateStaleTimeout_fn, computeRefetchInterval_fn, updateRefetchInterval_fn, updateTimers_fn, clearStaleTimeout_fn, clearRefetchInterval_fn, updateQuery_fn, notify_fn, _a9;
|
|
var QueryObserver = (_a9 = class extends Subscribable {
|
|
constructor(client, options) {
|
|
super();
|
|
__privateAdd(this, _QueryObserver_instances);
|
|
__privateAdd(this, _client2);
|
|
__privateAdd(this, _currentQuery);
|
|
__privateAdd(this, _currentQueryInitialState);
|
|
__privateAdd(this, _currentResult);
|
|
__privateAdd(this, _currentResultState);
|
|
__privateAdd(this, _currentResultOptions);
|
|
__privateAdd(this, _currentThenable);
|
|
__privateAdd(this, _selectError);
|
|
__privateAdd(this, _selectFn);
|
|
__privateAdd(this, _selectResult);
|
|
// This property keeps track of the last query with defined data.
|
|
// It will be used to pass the previous data and query to the placeholder function between renders.
|
|
__privateAdd(this, _lastQueryWithDefinedData);
|
|
__privateAdd(this, _staleTimeoutId);
|
|
__privateAdd(this, _refetchIntervalId);
|
|
__privateAdd(this, _currentRefetchInterval);
|
|
__privateAdd(this, _trackedProps, /* @__PURE__ */ new Set());
|
|
this.options = options;
|
|
__privateSet(this, _client2, client);
|
|
__privateSet(this, _selectError, null);
|
|
__privateSet(this, _currentThenable, pendingThenable());
|
|
if (!this.options.experimental_prefetchInRender) {
|
|
__privateGet(this, _currentThenable).reject(
|
|
new Error("experimental_prefetchInRender feature flag is not enabled")
|
|
);
|
|
}
|
|
this.bindMethods();
|
|
this.setOptions(options);
|
|
}
|
|
bindMethods() {
|
|
this.refetch = this.refetch.bind(this);
|
|
}
|
|
onSubscribe() {
|
|
if (this.listeners.size === 1) {
|
|
__privateGet(this, _currentQuery).addObserver(this);
|
|
if (shouldFetchOnMount(__privateGet(this, _currentQuery), this.options)) {
|
|
__privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
|
|
} else {
|
|
this.updateResult();
|
|
}
|
|
__privateMethod(this, _QueryObserver_instances, updateTimers_fn).call(this);
|
|
}
|
|
}
|
|
onUnsubscribe() {
|
|
if (!this.hasListeners()) {
|
|
this.destroy();
|
|
}
|
|
}
|
|
shouldFetchOnReconnect() {
|
|
return shouldFetchOn(
|
|
__privateGet(this, _currentQuery),
|
|
this.options,
|
|
this.options.refetchOnReconnect
|
|
);
|
|
}
|
|
shouldFetchOnWindowFocus() {
|
|
return shouldFetchOn(
|
|
__privateGet(this, _currentQuery),
|
|
this.options,
|
|
this.options.refetchOnWindowFocus
|
|
);
|
|
}
|
|
destroy() {
|
|
this.listeners = /* @__PURE__ */ new Set();
|
|
__privateMethod(this, _QueryObserver_instances, clearStaleTimeout_fn).call(this);
|
|
__privateMethod(this, _QueryObserver_instances, clearRefetchInterval_fn).call(this);
|
|
__privateGet(this, _currentQuery).removeObserver(this);
|
|
}
|
|
setOptions(options) {
|
|
const prevOptions = this.options;
|
|
const prevQuery = __privateGet(this, _currentQuery);
|
|
this.options = __privateGet(this, _client2).defaultQueryOptions(options);
|
|
if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) !== "boolean") {
|
|
throw new Error(
|
|
"Expected enabled to be a boolean or a callback that returns a boolean"
|
|
);
|
|
}
|
|
__privateMethod(this, _QueryObserver_instances, updateQuery_fn).call(this);
|
|
__privateGet(this, _currentQuery).setOptions(this.options);
|
|
if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {
|
|
__privateGet(this, _client2).getQueryCache().notify({
|
|
type: "observerOptionsUpdated",
|
|
query: __privateGet(this, _currentQuery),
|
|
observer: this
|
|
});
|
|
}
|
|
const mounted = this.hasListeners();
|
|
if (mounted && shouldFetchOptionally(
|
|
__privateGet(this, _currentQuery),
|
|
prevQuery,
|
|
this.options,
|
|
prevOptions
|
|
)) {
|
|
__privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
|
|
}
|
|
this.updateResult();
|
|
if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveEnabled(prevOptions.enabled, __privateGet(this, _currentQuery)) || resolveStaleTime(this.options.staleTime, __privateGet(this, _currentQuery)) !== resolveStaleTime(prevOptions.staleTime, __privateGet(this, _currentQuery)))) {
|
|
__privateMethod(this, _QueryObserver_instances, updateStaleTimeout_fn).call(this);
|
|
}
|
|
const nextRefetchInterval = __privateMethod(this, _QueryObserver_instances, computeRefetchInterval_fn).call(this);
|
|
if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveEnabled(prevOptions.enabled, __privateGet(this, _currentQuery)) || nextRefetchInterval !== __privateGet(this, _currentRefetchInterval))) {
|
|
__privateMethod(this, _QueryObserver_instances, updateRefetchInterval_fn).call(this, nextRefetchInterval);
|
|
}
|
|
}
|
|
getOptimisticResult(options) {
|
|
const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), options);
|
|
const result = this.createResult(query, options);
|
|
if (shouldAssignObserverCurrentProperties(this, result)) {
|
|
__privateSet(this, _currentResult, result);
|
|
__privateSet(this, _currentResultOptions, this.options);
|
|
__privateSet(this, _currentResultState, __privateGet(this, _currentQuery).state);
|
|
}
|
|
return result;
|
|
}
|
|
getCurrentResult() {
|
|
return __privateGet(this, _currentResult);
|
|
}
|
|
trackResult(result, onPropTracked) {
|
|
return new Proxy(result, {
|
|
get: (target, key) => {
|
|
this.trackProp(key);
|
|
onPropTracked == null ? void 0 : onPropTracked(key);
|
|
return Reflect.get(target, key);
|
|
}
|
|
});
|
|
}
|
|
trackProp(key) {
|
|
__privateGet(this, _trackedProps).add(key);
|
|
}
|
|
getCurrentQuery() {
|
|
return __privateGet(this, _currentQuery);
|
|
}
|
|
refetch({ ...options } = {}) {
|
|
return this.fetch({
|
|
...options
|
|
});
|
|
}
|
|
fetchOptimistic(options) {
|
|
const defaultedOptions = __privateGet(this, _client2).defaultQueryOptions(options);
|
|
const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), defaultedOptions);
|
|
return query.fetch().then(() => this.createResult(query, defaultedOptions));
|
|
}
|
|
fetch(fetchOptions) {
|
|
return __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this, {
|
|
...fetchOptions,
|
|
cancelRefetch: fetchOptions.cancelRefetch ?? true
|
|
}).then(() => {
|
|
this.updateResult();
|
|
return __privateGet(this, _currentResult);
|
|
});
|
|
}
|
|
createResult(query, options) {
|
|
var _a12;
|
|
const prevQuery = __privateGet(this, _currentQuery);
|
|
const prevOptions = this.options;
|
|
const prevResult = __privateGet(this, _currentResult);
|
|
const prevResultState = __privateGet(this, _currentResultState);
|
|
const prevResultOptions = __privateGet(this, _currentResultOptions);
|
|
const queryChange = query !== prevQuery;
|
|
const queryInitialState = queryChange ? query.state : __privateGet(this, _currentQueryInitialState);
|
|
const { state } = query;
|
|
let newState = { ...state };
|
|
let isPlaceholderData = false;
|
|
let data;
|
|
if (options._optimisticResults) {
|
|
const mounted = this.hasListeners();
|
|
const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
|
|
const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
|
|
if (fetchOnMount || fetchOptionally) {
|
|
newState = {
|
|
...newState,
|
|
...fetchState(state.data, query.options)
|
|
};
|
|
}
|
|
if (options._optimisticResults === "isRestoring") {
|
|
newState.fetchStatus = "idle";
|
|
}
|
|
}
|
|
let { error, errorUpdatedAt, status } = newState;
|
|
data = newState.data;
|
|
let skipSelect = false;
|
|
if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
|
|
let placeholderData;
|
|
if ((prevResult == null ? void 0 : prevResult.isPlaceholderData) && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
|
|
placeholderData = prevResult.data;
|
|
skipSelect = true;
|
|
} else {
|
|
placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(
|
|
(_a12 = __privateGet(this, _lastQueryWithDefinedData)) == null ? void 0 : _a12.state.data,
|
|
__privateGet(this, _lastQueryWithDefinedData)
|
|
) : options.placeholderData;
|
|
}
|
|
if (placeholderData !== void 0) {
|
|
status = "success";
|
|
data = replaceData(
|
|
prevResult == null ? void 0 : prevResult.data,
|
|
placeholderData,
|
|
options
|
|
);
|
|
isPlaceholderData = true;
|
|
}
|
|
}
|
|
if (options.select && data !== void 0 && !skipSelect) {
|
|
if (prevResult && data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === __privateGet(this, _selectFn)) {
|
|
data = __privateGet(this, _selectResult);
|
|
} else {
|
|
try {
|
|
__privateSet(this, _selectFn, options.select);
|
|
data = options.select(data);
|
|
data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);
|
|
__privateSet(this, _selectResult, data);
|
|
__privateSet(this, _selectError, null);
|
|
} catch (selectError) {
|
|
__privateSet(this, _selectError, selectError);
|
|
}
|
|
}
|
|
}
|
|
if (__privateGet(this, _selectError)) {
|
|
error = __privateGet(this, _selectError);
|
|
data = __privateGet(this, _selectResult);
|
|
errorUpdatedAt = Date.now();
|
|
status = "error";
|
|
}
|
|
const isFetching = newState.fetchStatus === "fetching";
|
|
const isPending = status === "pending";
|
|
const isError = status === "error";
|
|
const isLoading = isPending && isFetching;
|
|
const hasData = data !== void 0;
|
|
const result = {
|
|
status,
|
|
fetchStatus: newState.fetchStatus,
|
|
isPending,
|
|
isSuccess: status === "success",
|
|
isError,
|
|
isInitialLoading: isLoading,
|
|
isLoading,
|
|
data,
|
|
dataUpdatedAt: newState.dataUpdatedAt,
|
|
error,
|
|
errorUpdatedAt,
|
|
failureCount: newState.fetchFailureCount,
|
|
failureReason: newState.fetchFailureReason,
|
|
errorUpdateCount: newState.errorUpdateCount,
|
|
isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0,
|
|
isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
|
|
isFetching,
|
|
isRefetching: isFetching && !isPending,
|
|
isLoadingError: isError && !hasData,
|
|
isPaused: newState.fetchStatus === "paused",
|
|
isPlaceholderData,
|
|
isRefetchError: isError && hasData,
|
|
isStale: isStale(query, options),
|
|
refetch: this.refetch,
|
|
promise: __privateGet(this, _currentThenable)
|
|
};
|
|
const nextResult = result;
|
|
if (this.options.experimental_prefetchInRender) {
|
|
const finalizeThenableIfPossible = (thenable) => {
|
|
if (nextResult.status === "error") {
|
|
thenable.reject(nextResult.error);
|
|
} else if (nextResult.data !== void 0) {
|
|
thenable.resolve(nextResult.data);
|
|
}
|
|
};
|
|
const recreateThenable = () => {
|
|
const pending = __privateSet(this, _currentThenable, nextResult.promise = pendingThenable());
|
|
finalizeThenableIfPossible(pending);
|
|
};
|
|
const prevThenable = __privateGet(this, _currentThenable);
|
|
switch (prevThenable.status) {
|
|
case "pending":
|
|
if (query.queryHash === prevQuery.queryHash) {
|
|
finalizeThenableIfPossible(prevThenable);
|
|
}
|
|
break;
|
|
case "fulfilled":
|
|
if (nextResult.status === "error" || nextResult.data !== prevThenable.value) {
|
|
recreateThenable();
|
|
}
|
|
break;
|
|
case "rejected":
|
|
if (nextResult.status !== "error" || nextResult.error !== prevThenable.reason) {
|
|
recreateThenable();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return nextResult;
|
|
}
|
|
updateResult() {
|
|
const prevResult = __privateGet(this, _currentResult);
|
|
const nextResult = this.createResult(__privateGet(this, _currentQuery), this.options);
|
|
__privateSet(this, _currentResultState, __privateGet(this, _currentQuery).state);
|
|
__privateSet(this, _currentResultOptions, this.options);
|
|
if (__privateGet(this, _currentResultState).data !== void 0) {
|
|
__privateSet(this, _lastQueryWithDefinedData, __privateGet(this, _currentQuery));
|
|
}
|
|
if (shallowEqualObjects(nextResult, prevResult)) {
|
|
return;
|
|
}
|
|
__privateSet(this, _currentResult, nextResult);
|
|
const shouldNotifyListeners = () => {
|
|
if (!prevResult) {
|
|
return true;
|
|
}
|
|
const { notifyOnChangeProps } = this.options;
|
|
const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
|
|
if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !__privateGet(this, _trackedProps).size) {
|
|
return true;
|
|
}
|
|
const includedProps = new Set(
|
|
notifyOnChangePropsValue ?? __privateGet(this, _trackedProps)
|
|
);
|
|
if (this.options.throwOnError) {
|
|
includedProps.add("error");
|
|
}
|
|
return Object.keys(__privateGet(this, _currentResult)).some((key) => {
|
|
const typedKey = key;
|
|
const changed = __privateGet(this, _currentResult)[typedKey] !== prevResult[typedKey];
|
|
return changed && includedProps.has(typedKey);
|
|
});
|
|
};
|
|
__privateMethod(this, _QueryObserver_instances, notify_fn).call(this, { listeners: shouldNotifyListeners() });
|
|
}
|
|
onQueryUpdate() {
|
|
this.updateResult();
|
|
if (this.hasListeners()) {
|
|
__privateMethod(this, _QueryObserver_instances, updateTimers_fn).call(this);
|
|
}
|
|
}
|
|
}, _client2 = new WeakMap(), _currentQuery = new WeakMap(), _currentQueryInitialState = new WeakMap(), _currentResult = new WeakMap(), _currentResultState = new WeakMap(), _currentResultOptions = new WeakMap(), _currentThenable = new WeakMap(), _selectError = new WeakMap(), _selectFn = new WeakMap(), _selectResult = new WeakMap(), _lastQueryWithDefinedData = new WeakMap(), _staleTimeoutId = new WeakMap(), _refetchIntervalId = new WeakMap(), _currentRefetchInterval = new WeakMap(), _trackedProps = new WeakMap(), _QueryObserver_instances = new WeakSet(), executeFetch_fn = function(fetchOptions) {
|
|
__privateMethod(this, _QueryObserver_instances, updateQuery_fn).call(this);
|
|
let promise = __privateGet(this, _currentQuery).fetch(
|
|
this.options,
|
|
fetchOptions
|
|
);
|
|
if (!(fetchOptions == null ? void 0 : fetchOptions.throwOnError)) {
|
|
promise = promise.catch(noop);
|
|
}
|
|
return promise;
|
|
}, updateStaleTimeout_fn = function() {
|
|
__privateMethod(this, _QueryObserver_instances, clearStaleTimeout_fn).call(this);
|
|
const staleTime = resolveStaleTime(
|
|
this.options.staleTime,
|
|
__privateGet(this, _currentQuery)
|
|
);
|
|
if (isServer || __privateGet(this, _currentResult).isStale || !isValidTimeout(staleTime)) {
|
|
return;
|
|
}
|
|
const time = timeUntilStale(__privateGet(this, _currentResult).dataUpdatedAt, staleTime);
|
|
const timeout = time + 1;
|
|
__privateSet(this, _staleTimeoutId, setTimeout(() => {
|
|
if (!__privateGet(this, _currentResult).isStale) {
|
|
this.updateResult();
|
|
}
|
|
}, timeout));
|
|
}, computeRefetchInterval_fn = function() {
|
|
return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(__privateGet(this, _currentQuery)) : this.options.refetchInterval) ?? false;
|
|
}, updateRefetchInterval_fn = function(nextInterval) {
|
|
__privateMethod(this, _QueryObserver_instances, clearRefetchInterval_fn).call(this);
|
|
__privateSet(this, _currentRefetchInterval, nextInterval);
|
|
if (isServer || resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) === false || !isValidTimeout(__privateGet(this, _currentRefetchInterval)) || __privateGet(this, _currentRefetchInterval) === 0) {
|
|
return;
|
|
}
|
|
__privateSet(this, _refetchIntervalId, setInterval(() => {
|
|
if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
|
|
__privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
|
|
}
|
|
}, __privateGet(this, _currentRefetchInterval)));
|
|
}, updateTimers_fn = function() {
|
|
__privateMethod(this, _QueryObserver_instances, updateStaleTimeout_fn).call(this);
|
|
__privateMethod(this, _QueryObserver_instances, updateRefetchInterval_fn).call(this, __privateMethod(this, _QueryObserver_instances, computeRefetchInterval_fn).call(this));
|
|
}, clearStaleTimeout_fn = function() {
|
|
if (__privateGet(this, _staleTimeoutId)) {
|
|
clearTimeout(__privateGet(this, _staleTimeoutId));
|
|
__privateSet(this, _staleTimeoutId, void 0);
|
|
}
|
|
}, clearRefetchInterval_fn = function() {
|
|
if (__privateGet(this, _refetchIntervalId)) {
|
|
clearInterval(__privateGet(this, _refetchIntervalId));
|
|
__privateSet(this, _refetchIntervalId, void 0);
|
|
}
|
|
}, updateQuery_fn = function() {
|
|
const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), this.options);
|
|
if (query === __privateGet(this, _currentQuery)) {
|
|
return;
|
|
}
|
|
const prevQuery = __privateGet(this, _currentQuery);
|
|
__privateSet(this, _currentQuery, query);
|
|
__privateSet(this, _currentQueryInitialState, query.state);
|
|
if (this.hasListeners()) {
|
|
prevQuery == null ? void 0 : prevQuery.removeObserver(this);
|
|
query.addObserver(this);
|
|
}
|
|
}, notify_fn = function(notifyOptions) {
|
|
notifyManager.batch(() => {
|
|
if (notifyOptions.listeners) {
|
|
this.listeners.forEach((listener) => {
|
|
listener(__privateGet(this, _currentResult));
|
|
});
|
|
}
|
|
__privateGet(this, _client2).getQueryCache().notify({
|
|
query: __privateGet(this, _currentQuery),
|
|
type: "observerResultsUpdated"
|
|
});
|
|
});
|
|
}, _a9);
|
|
function shouldLoadOnMount(query, options) {
|
|
return resolveEnabled(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false);
|
|
}
|
|
function shouldFetchOnMount(query, options) {
|
|
return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
|
|
}
|
|
function shouldFetchOn(query, options, field) {
|
|
if (resolveEnabled(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
|
|
const value = typeof field === "function" ? field(query) : field;
|
|
return value === "always" || value !== false && isStale(query, options);
|
|
}
|
|
return false;
|
|
}
|
|
function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
|
|
return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
|
|
}
|
|
function isStale(query, options) {
|
|
return resolveEnabled(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
|
|
}
|
|
function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
|
|
if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/queriesObserver.js
|
|
function difference(array1, array2) {
|
|
const excludeSet = new Set(array2);
|
|
return array1.filter((x) => !excludeSet.has(x));
|
|
}
|
|
function replaceAt(array, index, value) {
|
|
const copy = array.slice(0);
|
|
copy[index] = value;
|
|
return copy;
|
|
}
|
|
var _client3, _result, _queries2, _options, _observers2, _combinedResult, _lastCombine, _lastResult, _observerMatches, _QueriesObserver_instances, trackResult_fn, combineResult_fn, findMatchingObservers_fn, onUpdate_fn, notify_fn2, _a10;
|
|
var QueriesObserver = (_a10 = class extends Subscribable {
|
|
constructor(client, queries, options) {
|
|
super();
|
|
__privateAdd(this, _QueriesObserver_instances);
|
|
__privateAdd(this, _client3);
|
|
__privateAdd(this, _result);
|
|
__privateAdd(this, _queries2);
|
|
__privateAdd(this, _options);
|
|
__privateAdd(this, _observers2);
|
|
__privateAdd(this, _combinedResult);
|
|
__privateAdd(this, _lastCombine);
|
|
__privateAdd(this, _lastResult);
|
|
__privateAdd(this, _observerMatches, []);
|
|
__privateSet(this, _client3, client);
|
|
__privateSet(this, _options, options);
|
|
__privateSet(this, _queries2, []);
|
|
__privateSet(this, _observers2, []);
|
|
__privateSet(this, _result, []);
|
|
this.setQueries(queries);
|
|
}
|
|
onSubscribe() {
|
|
if (this.listeners.size === 1) {
|
|
__privateGet(this, _observers2).forEach((observer) => {
|
|
observer.subscribe((result) => {
|
|
__privateMethod(this, _QueriesObserver_instances, onUpdate_fn).call(this, observer, result);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
onUnsubscribe() {
|
|
if (!this.listeners.size) {
|
|
this.destroy();
|
|
}
|
|
}
|
|
destroy() {
|
|
this.listeners = /* @__PURE__ */ new Set();
|
|
__privateGet(this, _observers2).forEach((observer) => {
|
|
observer.destroy();
|
|
});
|
|
}
|
|
setQueries(queries, options) {
|
|
__privateSet(this, _queries2, queries);
|
|
__privateSet(this, _options, options);
|
|
if (true) {
|
|
const queryHashes = queries.map(
|
|
(query) => __privateGet(this, _client3).defaultQueryOptions(query).queryHash
|
|
);
|
|
if (new Set(queryHashes).size !== queryHashes.length) {
|
|
console.warn(
|
|
"[QueriesObserver]: Duplicate Queries found. This might result in unexpected behavior."
|
|
);
|
|
}
|
|
}
|
|
notifyManager.batch(() => {
|
|
const prevObservers = __privateGet(this, _observers2);
|
|
const newObserverMatches = __privateMethod(this, _QueriesObserver_instances, findMatchingObservers_fn).call(this, __privateGet(this, _queries2));
|
|
__privateSet(this, _observerMatches, newObserverMatches);
|
|
newObserverMatches.forEach(
|
|
(match) => match.observer.setOptions(match.defaultedQueryOptions)
|
|
);
|
|
const newObservers = newObserverMatches.map((match) => match.observer);
|
|
const newResult = newObservers.map(
|
|
(observer) => observer.getCurrentResult()
|
|
);
|
|
const hasIndexChange = newObservers.some(
|
|
(observer, index) => observer !== prevObservers[index]
|
|
);
|
|
if (prevObservers.length === newObservers.length && !hasIndexChange) {
|
|
return;
|
|
}
|
|
__privateSet(this, _observers2, newObservers);
|
|
__privateSet(this, _result, newResult);
|
|
if (!this.hasListeners()) {
|
|
return;
|
|
}
|
|
difference(prevObservers, newObservers).forEach((observer) => {
|
|
observer.destroy();
|
|
});
|
|
difference(newObservers, prevObservers).forEach((observer) => {
|
|
observer.subscribe((result) => {
|
|
__privateMethod(this, _QueriesObserver_instances, onUpdate_fn).call(this, observer, result);
|
|
});
|
|
});
|
|
__privateMethod(this, _QueriesObserver_instances, notify_fn2).call(this);
|
|
});
|
|
}
|
|
getCurrentResult() {
|
|
return __privateGet(this, _result);
|
|
}
|
|
getQueries() {
|
|
return __privateGet(this, _observers2).map((observer) => observer.getCurrentQuery());
|
|
}
|
|
getObservers() {
|
|
return __privateGet(this, _observers2);
|
|
}
|
|
getOptimisticResult(queries, combine) {
|
|
const matches = __privateMethod(this, _QueriesObserver_instances, findMatchingObservers_fn).call(this, queries);
|
|
const result = matches.map(
|
|
(match) => match.observer.getOptimisticResult(match.defaultedQueryOptions)
|
|
);
|
|
return [
|
|
result,
|
|
(r) => {
|
|
return __privateMethod(this, _QueriesObserver_instances, combineResult_fn).call(this, r ?? result, combine);
|
|
},
|
|
() => {
|
|
return __privateMethod(this, _QueriesObserver_instances, trackResult_fn).call(this, result, matches);
|
|
}
|
|
];
|
|
}
|
|
}, _client3 = new WeakMap(), _result = new WeakMap(), _queries2 = new WeakMap(), _options = new WeakMap(), _observers2 = new WeakMap(), _combinedResult = new WeakMap(), _lastCombine = new WeakMap(), _lastResult = new WeakMap(), _observerMatches = new WeakMap(), _QueriesObserver_instances = new WeakSet(), trackResult_fn = function(result, matches) {
|
|
return matches.map((match, index) => {
|
|
const observerResult = result[index];
|
|
return !match.defaultedQueryOptions.notifyOnChangeProps ? match.observer.trackResult(observerResult, (accessedProp) => {
|
|
matches.forEach((m) => {
|
|
m.observer.trackProp(accessedProp);
|
|
});
|
|
}) : observerResult;
|
|
});
|
|
}, combineResult_fn = function(input, combine) {
|
|
if (combine) {
|
|
if (!__privateGet(this, _combinedResult) || __privateGet(this, _result) !== __privateGet(this, _lastResult) || combine !== __privateGet(this, _lastCombine)) {
|
|
__privateSet(this, _lastCombine, combine);
|
|
__privateSet(this, _lastResult, __privateGet(this, _result));
|
|
__privateSet(this, _combinedResult, replaceEqualDeep(
|
|
__privateGet(this, _combinedResult),
|
|
combine(input)
|
|
));
|
|
}
|
|
return __privateGet(this, _combinedResult);
|
|
}
|
|
return input;
|
|
}, findMatchingObservers_fn = function(queries) {
|
|
const prevObserversMap = new Map(
|
|
__privateGet(this, _observers2).map((observer) => [observer.options.queryHash, observer])
|
|
);
|
|
const observers = [];
|
|
queries.forEach((options) => {
|
|
const defaultedOptions = __privateGet(this, _client3).defaultQueryOptions(options);
|
|
const match = prevObserversMap.get(defaultedOptions.queryHash);
|
|
if (match) {
|
|
observers.push({
|
|
defaultedQueryOptions: defaultedOptions,
|
|
observer: match
|
|
});
|
|
} else {
|
|
observers.push({
|
|
defaultedQueryOptions: defaultedOptions,
|
|
observer: new QueryObserver(__privateGet(this, _client3), defaultedOptions)
|
|
});
|
|
}
|
|
});
|
|
return observers;
|
|
}, onUpdate_fn = function(observer, result) {
|
|
const index = __privateGet(this, _observers2).indexOf(observer);
|
|
if (index !== -1) {
|
|
__privateSet(this, _result, replaceAt(__privateGet(this, _result), index, result));
|
|
__privateMethod(this, _QueriesObserver_instances, notify_fn2).call(this);
|
|
}
|
|
}, notify_fn2 = function() {
|
|
var _a12;
|
|
if (this.hasListeners()) {
|
|
const previousResult = __privateGet(this, _combinedResult);
|
|
const newTracked = __privateMethod(this, _QueriesObserver_instances, trackResult_fn).call(this, __privateGet(this, _result), __privateGet(this, _observerMatches));
|
|
const newResult = __privateMethod(this, _QueriesObserver_instances, combineResult_fn).call(this, newTracked, (_a12 = __privateGet(this, _options)) == null ? void 0 : _a12.combine);
|
|
if (previousResult !== newResult) {
|
|
notifyManager.batch(() => {
|
|
this.listeners.forEach((listener) => {
|
|
listener(__privateGet(this, _result));
|
|
});
|
|
});
|
|
}
|
|
}
|
|
}, _a10);
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/infiniteQueryObserver.js
|
|
var InfiniteQueryObserver = class extends QueryObserver {
|
|
constructor(client, options) {
|
|
super(client, options);
|
|
}
|
|
bindMethods() {
|
|
super.bindMethods();
|
|
this.fetchNextPage = this.fetchNextPage.bind(this);
|
|
this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
|
|
}
|
|
setOptions(options) {
|
|
super.setOptions({
|
|
...options,
|
|
behavior: infiniteQueryBehavior()
|
|
});
|
|
}
|
|
getOptimisticResult(options) {
|
|
options.behavior = infiniteQueryBehavior();
|
|
return super.getOptimisticResult(options);
|
|
}
|
|
fetchNextPage(options) {
|
|
return this.fetch({
|
|
...options,
|
|
meta: {
|
|
fetchMore: { direction: "forward" }
|
|
}
|
|
});
|
|
}
|
|
fetchPreviousPage(options) {
|
|
return this.fetch({
|
|
...options,
|
|
meta: {
|
|
fetchMore: { direction: "backward" }
|
|
}
|
|
});
|
|
}
|
|
createResult(query, options) {
|
|
var _a12, _b;
|
|
const { state } = query;
|
|
const parentResult = super.createResult(query, options);
|
|
const { isFetching, isRefetching, isError, isRefetchError } = parentResult;
|
|
const fetchDirection = (_b = (_a12 = state.fetchMeta) == null ? void 0 : _a12.fetchMore) == null ? void 0 : _b.direction;
|
|
const isFetchNextPageError = isError && fetchDirection === "forward";
|
|
const isFetchingNextPage = isFetching && fetchDirection === "forward";
|
|
const isFetchPreviousPageError = isError && fetchDirection === "backward";
|
|
const isFetchingPreviousPage = isFetching && fetchDirection === "backward";
|
|
const result = {
|
|
...parentResult,
|
|
fetchNextPage: this.fetchNextPage,
|
|
fetchPreviousPage: this.fetchPreviousPage,
|
|
hasNextPage: hasNextPage(options, state.data),
|
|
hasPreviousPage: hasPreviousPage(options, state.data),
|
|
isFetchNextPageError,
|
|
isFetchingNextPage,
|
|
isFetchPreviousPageError,
|
|
isFetchingPreviousPage,
|
|
isRefetchError: isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,
|
|
isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage
|
|
};
|
|
return result;
|
|
}
|
|
};
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/mutationObserver.js
|
|
var _client4, _currentResult2, _currentMutation, _mutateOptions, _MutationObserver_instances, updateResult_fn, notify_fn3, _a11;
|
|
var MutationObserver = (_a11 = class extends Subscribable {
|
|
constructor(client, options) {
|
|
super();
|
|
__privateAdd(this, _MutationObserver_instances);
|
|
__privateAdd(this, _client4);
|
|
__privateAdd(this, _currentResult2);
|
|
__privateAdd(this, _currentMutation);
|
|
__privateAdd(this, _mutateOptions);
|
|
__privateSet(this, _client4, client);
|
|
this.setOptions(options);
|
|
this.bindMethods();
|
|
__privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
|
|
}
|
|
bindMethods() {
|
|
this.mutate = this.mutate.bind(this);
|
|
this.reset = this.reset.bind(this);
|
|
}
|
|
setOptions(options) {
|
|
var _a12;
|
|
const prevOptions = this.options;
|
|
this.options = __privateGet(this, _client4).defaultMutationOptions(options);
|
|
if (!shallowEqualObjects(this.options, prevOptions)) {
|
|
__privateGet(this, _client4).getMutationCache().notify({
|
|
type: "observerOptionsUpdated",
|
|
mutation: __privateGet(this, _currentMutation),
|
|
observer: this
|
|
});
|
|
}
|
|
if ((prevOptions == null ? void 0 : prevOptions.mutationKey) && this.options.mutationKey && hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)) {
|
|
this.reset();
|
|
} else if (((_a12 = __privateGet(this, _currentMutation)) == null ? void 0 : _a12.state.status) === "pending") {
|
|
__privateGet(this, _currentMutation).setOptions(this.options);
|
|
}
|
|
}
|
|
onUnsubscribe() {
|
|
var _a12;
|
|
if (!this.hasListeners()) {
|
|
(_a12 = __privateGet(this, _currentMutation)) == null ? void 0 : _a12.removeObserver(this);
|
|
}
|
|
}
|
|
onMutationUpdate(action) {
|
|
__privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
|
|
__privateMethod(this, _MutationObserver_instances, notify_fn3).call(this, action);
|
|
}
|
|
getCurrentResult() {
|
|
return __privateGet(this, _currentResult2);
|
|
}
|
|
reset() {
|
|
var _a12;
|
|
(_a12 = __privateGet(this, _currentMutation)) == null ? void 0 : _a12.removeObserver(this);
|
|
__privateSet(this, _currentMutation, void 0);
|
|
__privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
|
|
__privateMethod(this, _MutationObserver_instances, notify_fn3).call(this);
|
|
}
|
|
mutate(variables, options) {
|
|
var _a12;
|
|
__privateSet(this, _mutateOptions, options);
|
|
(_a12 = __privateGet(this, _currentMutation)) == null ? void 0 : _a12.removeObserver(this);
|
|
__privateSet(this, _currentMutation, __privateGet(this, _client4).getMutationCache().build(__privateGet(this, _client4), this.options));
|
|
__privateGet(this, _currentMutation).addObserver(this);
|
|
return __privateGet(this, _currentMutation).execute(variables);
|
|
}
|
|
}, _client4 = new WeakMap(), _currentResult2 = new WeakMap(), _currentMutation = new WeakMap(), _mutateOptions = new WeakMap(), _MutationObserver_instances = new WeakSet(), updateResult_fn = function() {
|
|
var _a12;
|
|
const state = ((_a12 = __privateGet(this, _currentMutation)) == null ? void 0 : _a12.state) ?? getDefaultState2();
|
|
__privateSet(this, _currentResult2, {
|
|
...state,
|
|
isPending: state.status === "pending",
|
|
isSuccess: state.status === "success",
|
|
isError: state.status === "error",
|
|
isIdle: state.status === "idle",
|
|
mutate: this.mutate,
|
|
reset: this.reset
|
|
});
|
|
}, notify_fn3 = function(action) {
|
|
notifyManager.batch(() => {
|
|
var _a12, _b, _c, _d, _e, _f, _g, _h;
|
|
if (__privateGet(this, _mutateOptions) && this.hasListeners()) {
|
|
const variables = __privateGet(this, _currentResult2).variables;
|
|
const context = __privateGet(this, _currentResult2).context;
|
|
if ((action == null ? void 0 : action.type) === "success") {
|
|
(_b = (_a12 = __privateGet(this, _mutateOptions)).onSuccess) == null ? void 0 : _b.call(_a12, action.data, variables, context);
|
|
(_d = (_c = __privateGet(this, _mutateOptions)).onSettled) == null ? void 0 : _d.call(_c, action.data, null, variables, context);
|
|
} else if ((action == null ? void 0 : action.type) === "error") {
|
|
(_f = (_e = __privateGet(this, _mutateOptions)).onError) == null ? void 0 : _f.call(_e, action.error, variables, context);
|
|
(_h = (_g = __privateGet(this, _mutateOptions)).onSettled) == null ? void 0 : _h.call(
|
|
_g,
|
|
void 0,
|
|
action.error,
|
|
variables,
|
|
context
|
|
);
|
|
}
|
|
}
|
|
this.listeners.forEach((listener) => {
|
|
listener(__privateGet(this, _currentResult2));
|
|
});
|
|
});
|
|
}, _a11);
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/hydration.js
|
|
function defaultTransformerFn(data) {
|
|
return data;
|
|
}
|
|
function dehydrateMutation(mutation) {
|
|
return {
|
|
mutationKey: mutation.options.mutationKey,
|
|
state: mutation.state,
|
|
...mutation.options.scope && { scope: mutation.options.scope },
|
|
...mutation.meta && { meta: mutation.meta }
|
|
};
|
|
}
|
|
function dehydrateQuery(query, serializeData, shouldRedactErrors) {
|
|
var _a12;
|
|
return {
|
|
dehydratedAt: Date.now(),
|
|
state: {
|
|
...query.state,
|
|
...query.state.data !== void 0 && {
|
|
data: serializeData(query.state.data)
|
|
}
|
|
},
|
|
queryKey: query.queryKey,
|
|
queryHash: query.queryHash,
|
|
...query.state.status === "pending" && {
|
|
promise: (_a12 = query.promise) == null ? void 0 : _a12.then(serializeData).catch((error) => {
|
|
if (!shouldRedactErrors(error)) {
|
|
return Promise.reject(error);
|
|
}
|
|
if (true) {
|
|
console.error(
|
|
`A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`
|
|
);
|
|
}
|
|
return Promise.reject(new Error("redacted"));
|
|
})
|
|
},
|
|
...query.meta && { meta: query.meta }
|
|
};
|
|
}
|
|
function defaultShouldDehydrateMutation(mutation) {
|
|
return mutation.state.isPaused;
|
|
}
|
|
function defaultShouldDehydrateQuery(query) {
|
|
return query.state.status === "success";
|
|
}
|
|
function defaultShouldRedactErrors(_) {
|
|
return true;
|
|
}
|
|
function dehydrate(client, options = {}) {
|
|
var _a12, _b, _c, _d;
|
|
const filterMutation = options.shouldDehydrateMutation ?? ((_a12 = client.getDefaultOptions().dehydrate) == null ? void 0 : _a12.shouldDehydrateMutation) ?? defaultShouldDehydrateMutation;
|
|
const mutations = client.getMutationCache().getAll().flatMap(
|
|
(mutation) => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []
|
|
);
|
|
const filterQuery = options.shouldDehydrateQuery ?? ((_b = client.getDefaultOptions().dehydrate) == null ? void 0 : _b.shouldDehydrateQuery) ?? defaultShouldDehydrateQuery;
|
|
const shouldRedactErrors = options.shouldRedactErrors ?? ((_c = client.getDefaultOptions().dehydrate) == null ? void 0 : _c.shouldRedactErrors) ?? defaultShouldRedactErrors;
|
|
const serializeData = options.serializeData ?? ((_d = client.getDefaultOptions().dehydrate) == null ? void 0 : _d.serializeData) ?? defaultTransformerFn;
|
|
const queries = client.getQueryCache().getAll().flatMap(
|
|
(query) => filterQuery(query) ? [dehydrateQuery(query, serializeData, shouldRedactErrors)] : []
|
|
);
|
|
return { mutations, queries };
|
|
}
|
|
function hydrate(client, dehydratedState, options) {
|
|
var _a12, _b;
|
|
if (typeof dehydratedState !== "object" || dehydratedState === null) {
|
|
return;
|
|
}
|
|
const mutationCache = client.getMutationCache();
|
|
const queryCache = client.getQueryCache();
|
|
const deserializeData = ((_a12 = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _a12.deserializeData) ?? ((_b = client.getDefaultOptions().hydrate) == null ? void 0 : _b.deserializeData) ?? defaultTransformerFn;
|
|
const mutations = dehydratedState.mutations || [];
|
|
const queries = dehydratedState.queries || [];
|
|
mutations.forEach(({ state, ...mutationOptions }) => {
|
|
var _a13, _b2;
|
|
mutationCache.build(
|
|
client,
|
|
{
|
|
...(_a13 = client.getDefaultOptions().hydrate) == null ? void 0 : _a13.mutations,
|
|
...(_b2 = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _b2.mutations,
|
|
...mutationOptions
|
|
},
|
|
state
|
|
);
|
|
});
|
|
queries.forEach(
|
|
({ queryKey, state, queryHash, meta, promise, dehydratedAt }) => {
|
|
var _a13, _b2;
|
|
const syncData = promise ? tryResolveSync(promise) : void 0;
|
|
const rawData = state.data === void 0 ? syncData == null ? void 0 : syncData.data : state.data;
|
|
const data = rawData === void 0 ? rawData : deserializeData(rawData);
|
|
let query = queryCache.get(queryHash);
|
|
const existingQueryIsPending = (query == null ? void 0 : query.state.status) === "pending";
|
|
const existingQueryIsFetching = (query == null ? void 0 : query.state.fetchStatus) === "fetching";
|
|
if (query) {
|
|
const hasNewerSyncData = syncData && // We only need this undefined check to handle older dehydration
|
|
// payloads that might not have dehydratedAt
|
|
dehydratedAt !== void 0 && dehydratedAt > query.state.dataUpdatedAt;
|
|
if (state.dataUpdatedAt > query.state.dataUpdatedAt || hasNewerSyncData) {
|
|
const { fetchStatus: _ignored, ...serializedState } = state;
|
|
query.setState({
|
|
...serializedState,
|
|
data
|
|
});
|
|
}
|
|
} else {
|
|
query = queryCache.build(
|
|
client,
|
|
{
|
|
...(_a13 = client.getDefaultOptions().hydrate) == null ? void 0 : _a13.queries,
|
|
...(_b2 = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _b2.queries,
|
|
queryKey,
|
|
queryHash,
|
|
meta
|
|
},
|
|
// Reset fetch status to idle to avoid
|
|
// query being stuck in fetching state upon hydration
|
|
{
|
|
...state,
|
|
data,
|
|
fetchStatus: "idle",
|
|
status: data !== void 0 ? "success" : state.status
|
|
}
|
|
);
|
|
}
|
|
if (promise && !existingQueryIsPending && !existingQueryIsFetching && // Only hydrate if dehydration is newer than any existing data,
|
|
// this is always true for new queries
|
|
(dehydratedAt === void 0 || dehydratedAt > query.state.dataUpdatedAt)) {
|
|
void query.fetch(void 0, {
|
|
// RSC transformed promises are not thenable
|
|
initialPromise: Promise.resolve(promise).then(deserializeData)
|
|
});
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/streamedQuery.js
|
|
function streamedQuery({
|
|
queryFn,
|
|
refetchMode = "reset",
|
|
maxChunks
|
|
}) {
|
|
return async (context) => {
|
|
const query = context.client.getQueryCache().find({ queryKey: context.queryKey, exact: true });
|
|
const isRefetch = !!query && query.state.data !== void 0;
|
|
if (isRefetch && refetchMode === "reset") {
|
|
query.setState({
|
|
status: "pending",
|
|
data: void 0,
|
|
error: null,
|
|
fetchStatus: "fetching"
|
|
});
|
|
}
|
|
let result = [];
|
|
const stream = await queryFn(context);
|
|
for await (const chunk of stream) {
|
|
if (context.signal.aborted) {
|
|
break;
|
|
}
|
|
if (!isRefetch || refetchMode !== "replace") {
|
|
context.client.setQueryData(
|
|
context.queryKey,
|
|
(prev = []) => {
|
|
return addToEnd(prev, chunk, maxChunks);
|
|
}
|
|
);
|
|
}
|
|
result = addToEnd(result, chunk, maxChunks);
|
|
}
|
|
if (isRefetch && refetchMode === "replace" && !context.signal.aborted) {
|
|
context.client.setQueryData(context.queryKey, result);
|
|
}
|
|
return context.client.getQueryData(context.queryKey);
|
|
};
|
|
}
|
|
|
|
// node_modules/@tanstack/query-core/build/modern/types.js
|
|
var dataTagSymbol = Symbol("dataTagSymbol");
|
|
var dataTagErrorSymbol = Symbol("dataTagErrorSymbol");
|
|
var unsetMarker = Symbol("unsetMarker");
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/useQueries.js
|
|
var React5 = __toESM(require_react(), 1);
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
|
|
var React = __toESM(require_react(), 1);
|
|
var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
|
|
var QueryClientContext = React.createContext(
|
|
void 0
|
|
);
|
|
var useQueryClient = (queryClient) => {
|
|
const client = 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
|
|
}) => {
|
|
React.useEffect(() => {
|
|
client.mount();
|
|
return () => {
|
|
client.unmount();
|
|
};
|
|
}, [client]);
|
|
return (0, import_jsx_runtime.jsx)(QueryClientContext.Provider, { value: client, children });
|
|
};
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
|
|
var React2 = __toESM(require_react(), 1);
|
|
var IsRestoringContext = React2.createContext(false);
|
|
var useIsRestoring = () => React2.useContext(IsRestoringContext);
|
|
var IsRestoringProvider = IsRestoringContext.Provider;
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
|
|
var React3 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
|
|
function createValue() {
|
|
let isReset = false;
|
|
return {
|
|
clearReset: () => {
|
|
isReset = false;
|
|
},
|
|
reset: () => {
|
|
isReset = true;
|
|
},
|
|
isReset: () => {
|
|
return isReset;
|
|
}
|
|
};
|
|
}
|
|
var QueryErrorResetBoundaryContext = React3.createContext(createValue());
|
|
var useQueryErrorResetBoundary = () => React3.useContext(QueryErrorResetBoundaryContext);
|
|
var QueryErrorResetBoundary = ({
|
|
children
|
|
}) => {
|
|
const [value] = React3.useState(() => createValue());
|
|
return (0, import_jsx_runtime2.jsx)(QueryErrorResetBoundaryContext.Provider, { value, children: typeof children === "function" ? children(value) : children });
|
|
};
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
|
|
var React4 = __toESM(require_react(), 1);
|
|
var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
|
|
if (options.suspense || options.throwOnError || options.experimental_prefetchInRender) {
|
|
if (!errorResetBoundary.isReset()) {
|
|
options.retryOnMount = false;
|
|
}
|
|
}
|
|
};
|
|
var useClearResetErrorBoundary = (errorResetBoundary) => {
|
|
React4.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]));
|
|
};
|
|
|
|
// 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 clamp = (value) => value === "static" ? value : Math.max(value ?? 1e3, 1e3);
|
|
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, 1e3);
|
|
}
|
|
}
|
|
};
|
|
var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
|
|
var shouldSuspend = (defaultedOptions, result) => (defaultedOptions == null ? void 0 : defaultedOptions.suspense) && result.isPending;
|
|
var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
|
|
errorResetBoundary.clearReset();
|
|
});
|
|
|
|
// 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 = React5.useMemo(
|
|
() => queries.map((opts) => {
|
|
const defaultedOptions = client.defaultQueryOptions(
|
|
opts
|
|
);
|
|
defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
|
|
return defaultedOptions;
|
|
}),
|
|
[queries, client, isRestoring]
|
|
);
|
|
defaultedQueries.forEach((query) => {
|
|
ensureSuspenseTimers(query);
|
|
ensurePreventErrorBoundaryRetry(query, errorResetBoundary);
|
|
});
|
|
useClearResetErrorBoundary(errorResetBoundary);
|
|
const [observer] = React5.useState(
|
|
() => new QueriesObserver(
|
|
client,
|
|
defaultedQueries,
|
|
options
|
|
)
|
|
);
|
|
const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(
|
|
defaultedQueries,
|
|
options.combine
|
|
);
|
|
const shouldSubscribe = !isRestoring && options.subscribed !== false;
|
|
React5.useSyncExternalStore(
|
|
React5.useCallback(
|
|
(onStoreChange) => shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop,
|
|
[observer, shouldSubscribe]
|
|
),
|
|
() => observer.getCurrentResult(),
|
|
() => observer.getCurrentResult()
|
|
);
|
|
React5.useEffect(() => {
|
|
observer.setQueries(
|
|
defaultedQueries,
|
|
options
|
|
);
|
|
}, [defaultedQueries, options, observer]);
|
|
const shouldAtLeastOneSuspend = optimisticResult.some(
|
|
(result, index) => shouldSuspend(defaultedQueries[index], result)
|
|
);
|
|
const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
|
|
const opts = defaultedQueries[index];
|
|
if (opts) {
|
|
const queryObserver = new QueryObserver(client, opts);
|
|
if (shouldSuspend(opts, result)) {
|
|
return fetchOptimistic(opts, queryObserver, errorResetBoundary);
|
|
} else if (willFetch(result, isRestoring)) {
|
|
void fetchOptimistic(opts, queryObserver, 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 == null ? void 0 : firstSingleResultWhichShouldThrow.error) {
|
|
throw firstSingleResultWhichShouldThrow.error;
|
|
}
|
|
return getCombinedResult(trackResult());
|
|
}
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
|
|
var React6 = __toESM(require_react(), 1);
|
|
function useBaseQuery(options, Observer, queryClient) {
|
|
var _a12, _b, _c, _d, _e;
|
|
if (true) {
|
|
if (typeof options !== "object" || Array.isArray(options)) {
|
|
throw new Error(
|
|
'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
|
|
);
|
|
}
|
|
}
|
|
const isRestoring = useIsRestoring();
|
|
const errorResetBoundary = useQueryErrorResetBoundary();
|
|
const client = useQueryClient(queryClient);
|
|
const defaultedOptions = client.defaultQueryOptions(options);
|
|
(_b = (_a12 = client.getDefaultOptions().queries) == null ? void 0 : _a12._experimental_beforeQuery) == null ? void 0 : _b.call(
|
|
_a12,
|
|
defaultedOptions
|
|
);
|
|
if (true) {
|
|
if (!defaultedOptions.queryFn) {
|
|
console.error(
|
|
`[${defaultedOptions.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`
|
|
);
|
|
}
|
|
}
|
|
defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
|
|
ensureSuspenseTimers(defaultedOptions);
|
|
ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
|
|
useClearResetErrorBoundary(errorResetBoundary);
|
|
const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
|
|
const [observer] = React6.useState(
|
|
() => new Observer(
|
|
client,
|
|
defaultedOptions
|
|
)
|
|
);
|
|
const result = observer.getOptimisticResult(defaultedOptions);
|
|
const shouldSubscribe = !isRestoring && options.subscribed !== false;
|
|
React6.useSyncExternalStore(
|
|
React6.useCallback(
|
|
(onStoreChange) => {
|
|
const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
|
|
observer.updateResult();
|
|
return unsubscribe;
|
|
},
|
|
[observer, shouldSubscribe]
|
|
),
|
|
() => observer.getCurrentResult(),
|
|
() => observer.getCurrentResult()
|
|
);
|
|
React6.useEffect(() => {
|
|
observer.setOptions(defaultedOptions);
|
|
}, [defaultedOptions, observer]);
|
|
if (shouldSuspend(defaultedOptions, result)) {
|
|
throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
|
|
}
|
|
if (getHasError({
|
|
result,
|
|
errorResetBoundary,
|
|
throwOnError: defaultedOptions.throwOnError,
|
|
query: client.getQueryCache().get(defaultedOptions.queryHash),
|
|
suspense: defaultedOptions.suspense
|
|
})) {
|
|
throw result.error;
|
|
}
|
|
;
|
|
(_d = (_c = client.getDefaultOptions().queries) == null ? void 0 : _c._experimental_afterQuery) == null ? void 0 : _d.call(
|
|
_c,
|
|
defaultedOptions,
|
|
result
|
|
);
|
|
if (defaultedOptions.experimental_prefetchInRender && !isServer && willFetch(result, isRestoring)) {
|
|
const promise = isNewCacheEntry ? (
|
|
// Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
|
|
fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
|
|
) : (
|
|
// subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
|
|
(_e = client.getQueryCache().get(defaultedOptions.queryHash)) == null ? void 0 : _e.promise
|
|
);
|
|
promise == null ? void 0 : promise.catch(noop).finally(() => {
|
|
observer.updateResult();
|
|
});
|
|
}
|
|
return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/useQuery.js
|
|
function useQuery(options, queryClient) {
|
|
return useBaseQuery(options, QueryObserver, queryClient);
|
|
}
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/useSuspenseQuery.js
|
|
function useSuspenseQuery(options, queryClient) {
|
|
if (true) {
|
|
if (options.queryFn === skipToken) {
|
|
console.error("skipToken is not allowed for useSuspenseQuery");
|
|
}
|
|
}
|
|
return useBaseQuery(
|
|
{
|
|
...options,
|
|
enabled: true,
|
|
suspense: true,
|
|
throwOnError: defaultThrowOnError,
|
|
placeholderData: void 0
|
|
},
|
|
QueryObserver,
|
|
queryClient
|
|
);
|
|
}
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/useSuspenseInfiniteQuery.js
|
|
function useSuspenseInfiniteQuery(options, queryClient) {
|
|
if (true) {
|
|
if (options.queryFn === skipToken) {
|
|
console.error("skipToken is not allowed for useSuspenseInfiniteQuery");
|
|
}
|
|
}
|
|
return useBaseQuery(
|
|
{
|
|
...options,
|
|
enabled: true,
|
|
suspense: true,
|
|
throwOnError: defaultThrowOnError
|
|
},
|
|
InfiniteQueryObserver,
|
|
queryClient
|
|
);
|
|
}
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/useSuspenseQueries.js
|
|
function useSuspenseQueries(options, queryClient) {
|
|
return useQueries(
|
|
{
|
|
...options,
|
|
queries: options.queries.map((query) => {
|
|
if (true) {
|
|
if (query.queryFn === skipToken) {
|
|
console.error("skipToken is not allowed for useSuspenseQueries");
|
|
}
|
|
}
|
|
return {
|
|
...query,
|
|
suspense: true,
|
|
throwOnError: defaultThrowOnError,
|
|
enabled: true,
|
|
placeholderData: void 0
|
|
};
|
|
})
|
|
},
|
|
queryClient
|
|
);
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
}
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/queryOptions.js
|
|
function queryOptions(options) {
|
|
return options;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/infiniteQueryOptions.js
|
|
function infiniteQueryOptions(options) {
|
|
return options;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/HydrationBoundary.js
|
|
var React7 = __toESM(require_react(), 1);
|
|
var HydrationBoundary = ({
|
|
children,
|
|
options = {},
|
|
state,
|
|
queryClient
|
|
}) => {
|
|
const client = useQueryClient(queryClient);
|
|
const optionsRef = React7.useRef(options);
|
|
optionsRef.current = options;
|
|
const hydrationQueue = React7.useMemo(() => {
|
|
if (state) {
|
|
if (typeof state !== "object") {
|
|
return;
|
|
}
|
|
const queryCache = client.getQueryCache();
|
|
const queries = state.queries || [];
|
|
const newQueries = [];
|
|
const existingQueries = [];
|
|
for (const dehydratedQuery of queries) {
|
|
const existingQuery = queryCache.get(dehydratedQuery.queryHash);
|
|
if (!existingQuery) {
|
|
newQueries.push(dehydratedQuery);
|
|
} else {
|
|
const hydrationIsNewer = dehydratedQuery.state.dataUpdatedAt > existingQuery.state.dataUpdatedAt || dehydratedQuery.promise && existingQuery.state.status !== "pending" && existingQuery.state.fetchStatus !== "fetching" && dehydratedQuery.dehydratedAt !== void 0 && dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt;
|
|
if (hydrationIsNewer) {
|
|
existingQueries.push(dehydratedQuery);
|
|
}
|
|
}
|
|
}
|
|
if (newQueries.length > 0) {
|
|
hydrate(client, { queries: newQueries }, optionsRef.current);
|
|
}
|
|
if (existingQueries.length > 0) {
|
|
return existingQueries;
|
|
}
|
|
}
|
|
return void 0;
|
|
}, [client, state]);
|
|
React7.useEffect(() => {
|
|
if (hydrationQueue) {
|
|
hydrate(client, { queries: hydrationQueue }, optionsRef.current);
|
|
}
|
|
}, [client, hydrationQueue]);
|
|
return children;
|
|
};
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/useIsFetching.js
|
|
var React8 = __toESM(require_react(), 1);
|
|
function useIsFetching(filters, queryClient) {
|
|
const client = useQueryClient(queryClient);
|
|
const queryCache = client.getQueryCache();
|
|
return React8.useSyncExternalStore(
|
|
React8.useCallback(
|
|
(onStoreChange) => queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),
|
|
[queryCache]
|
|
),
|
|
() => client.isFetching(filters),
|
|
() => client.isFetching(filters)
|
|
);
|
|
}
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/useMutationState.js
|
|
var React9 = __toESM(require_react(), 1);
|
|
function useIsMutating(filters, queryClient) {
|
|
const client = useQueryClient(queryClient);
|
|
return useMutationState(
|
|
{ filters: { ...filters, status: "pending" } },
|
|
client
|
|
).length;
|
|
}
|
|
function getResult(mutationCache, options) {
|
|
return mutationCache.findAll(options.filters).map(
|
|
(mutation) => options.select ? options.select(mutation) : mutation.state
|
|
);
|
|
}
|
|
function useMutationState(options = {}, queryClient) {
|
|
const mutationCache = useQueryClient(queryClient).getMutationCache();
|
|
const optionsRef = React9.useRef(options);
|
|
const result = React9.useRef(null);
|
|
if (!result.current) {
|
|
result.current = getResult(mutationCache, options);
|
|
}
|
|
React9.useEffect(() => {
|
|
optionsRef.current = options;
|
|
});
|
|
return React9.useSyncExternalStore(
|
|
React9.useCallback(
|
|
(onStoreChange) => mutationCache.subscribe(() => {
|
|
const nextResult = replaceEqualDeep(
|
|
result.current,
|
|
getResult(mutationCache, optionsRef.current)
|
|
);
|
|
if (result.current !== nextResult) {
|
|
result.current = nextResult;
|
|
notifyManager.schedule(onStoreChange);
|
|
}
|
|
}),
|
|
[mutationCache]
|
|
),
|
|
() => result.current,
|
|
() => result.current
|
|
);
|
|
}
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/useMutation.js
|
|
var React10 = __toESM(require_react(), 1);
|
|
function useMutation(options, queryClient) {
|
|
const client = useQueryClient(queryClient);
|
|
const [observer] = React10.useState(
|
|
() => new MutationObserver(
|
|
client,
|
|
options
|
|
)
|
|
);
|
|
React10.useEffect(() => {
|
|
observer.setOptions(options);
|
|
}, [observer, options]);
|
|
const result = React10.useSyncExternalStore(
|
|
React10.useCallback(
|
|
(onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)),
|
|
[observer]
|
|
),
|
|
() => observer.getCurrentResult(),
|
|
() => observer.getCurrentResult()
|
|
);
|
|
const mutate = React10.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 };
|
|
}
|
|
|
|
// node_modules/@tanstack/react-query/build/modern/useInfiniteQuery.js
|
|
function useInfiniteQuery(options, queryClient) {
|
|
return useBaseQuery(
|
|
options,
|
|
InfiniteQueryObserver,
|
|
queryClient
|
|
);
|
|
}
|
|
export {
|
|
CancelledError,
|
|
HydrationBoundary,
|
|
InfiniteQueryObserver,
|
|
IsRestoringProvider,
|
|
Mutation,
|
|
MutationCache,
|
|
MutationObserver,
|
|
QueriesObserver,
|
|
Query,
|
|
QueryCache,
|
|
QueryClient,
|
|
QueryClientContext,
|
|
QueryClientProvider,
|
|
QueryErrorResetBoundary,
|
|
QueryObserver,
|
|
dataTagErrorSymbol,
|
|
dataTagSymbol,
|
|
defaultScheduler,
|
|
defaultShouldDehydrateMutation,
|
|
defaultShouldDehydrateQuery,
|
|
dehydrate,
|
|
streamedQuery as experimental_streamedQuery,
|
|
focusManager,
|
|
hashKey,
|
|
hydrate,
|
|
infiniteQueryOptions,
|
|
isCancelledError,
|
|
isServer,
|
|
keepPreviousData,
|
|
matchMutation,
|
|
matchQuery,
|
|
noop,
|
|
notifyManager,
|
|
onlineManager,
|
|
partialMatchKey,
|
|
queryOptions,
|
|
replaceEqualDeep,
|
|
shouldThrowError,
|
|
skipToken,
|
|
unsetMarker,
|
|
useInfiniteQuery,
|
|
useIsFetching,
|
|
useIsMutating,
|
|
useIsRestoring,
|
|
useMutation,
|
|
useMutationState,
|
|
usePrefetchInfiniteQuery,
|
|
usePrefetchQuery,
|
|
useQueries,
|
|
useQuery,
|
|
useQueryClient,
|
|
useQueryErrorResetBoundary,
|
|
useSuspenseInfiniteQuery,
|
|
useSuspenseQueries,
|
|
useSuspenseQuery
|
|
};
|
|
//# sourceMappingURL=@tanstack_react-query.js.map
|