924 lines
33 KiB
JavaScript
924 lines
33 KiB
JavaScript
import { r as __toESM } from "./rolldown-runtime-DC62tzP2.js";
|
|
import { t as require_react } from "./react.js";
|
|
import { t as require_shim } from "./shim-BX6a9SD7.js";
|
|
//#region node_modules/dequal/lite/index.mjs
|
|
var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
|
|
var import_shim = require_shim();
|
|
var has = Object.prototype.hasOwnProperty;
|
|
function dequal(foo, bar) {
|
|
var ctor, len;
|
|
if (foo === bar) return true;
|
|
if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
|
|
if (ctor === Date) return foo.getTime() === bar.getTime();
|
|
if (ctor === RegExp) return foo.toString() === bar.toString();
|
|
if (ctor === Array) {
|
|
if ((len = foo.length) === bar.length) while (len-- && dequal(foo[len], bar[len]));
|
|
return len === -1;
|
|
}
|
|
if (!ctor || typeof foo === "object") {
|
|
len = 0;
|
|
for (ctor in foo) {
|
|
if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
|
|
if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
|
|
}
|
|
return Object.keys(bar).length === len;
|
|
}
|
|
}
|
|
return foo !== foo && bar !== bar;
|
|
}
|
|
var SWRGlobalState = /* @__PURE__ */ new WeakMap();
|
|
var noop = () => {};
|
|
var OBJECT = Object;
|
|
var isUndefined = (v) => v === void 0;
|
|
var isFunction = (v) => typeof v == "function";
|
|
var mergeObjects = (a, b) => ({
|
|
...a,
|
|
...b
|
|
});
|
|
var isPromiseLike = (x) => isFunction(x.then);
|
|
var EMPTY_CACHE = {};
|
|
var INITIAL_CACHE = {};
|
|
var STR_UNDEFINED = "undefined";
|
|
var isWindowDefined = typeof window != STR_UNDEFINED;
|
|
var isDocumentDefined = typeof document != STR_UNDEFINED;
|
|
var isLegacyDeno = isWindowDefined && "Deno" in window;
|
|
var hasRequestAnimationFrame = () => isWindowDefined && typeof window["requestAnimationFrame"] != STR_UNDEFINED;
|
|
var createCacheHelper = (cache, key) => {
|
|
const state = SWRGlobalState.get(cache);
|
|
return [
|
|
() => !isUndefined(key) && cache.get(key) || EMPTY_CACHE,
|
|
(info) => {
|
|
if (!isUndefined(key)) {
|
|
const prev = cache.get(key);
|
|
if (!(key in INITIAL_CACHE)) INITIAL_CACHE[key] = prev;
|
|
state[5](key, mergeObjects(prev, info), prev || EMPTY_CACHE);
|
|
}
|
|
},
|
|
state[6],
|
|
() => {
|
|
if (!isUndefined(key)) {
|
|
if (key in INITIAL_CACHE) return INITIAL_CACHE[key];
|
|
}
|
|
return !isUndefined(key) && cache.get(key) || EMPTY_CACHE;
|
|
}
|
|
];
|
|
};
|
|
/**
|
|
* Due to the bug https://bugs.chromium.org/p/chromium/issues/detail?id=678075,
|
|
* it's not reliable to detect if the browser is currently online or offline
|
|
* based on `navigator.onLine`.
|
|
* As a workaround, we always assume it's online on the first load, and change
|
|
* the status upon `online` or `offline` events.
|
|
*/ var online = true;
|
|
var isOnline = () => online;
|
|
var [onWindowEvent, offWindowEvent] = isWindowDefined && window.addEventListener ? [window.addEventListener.bind(window), window.removeEventListener.bind(window)] : [noop, noop];
|
|
var isVisible = () => {
|
|
const visibilityState = isDocumentDefined && document.visibilityState;
|
|
return isUndefined(visibilityState) || visibilityState !== "hidden";
|
|
};
|
|
var initFocus = (callback) => {
|
|
if (isDocumentDefined) document.addEventListener("visibilitychange", callback);
|
|
onWindowEvent("focus", callback);
|
|
return () => {
|
|
if (isDocumentDefined) document.removeEventListener("visibilitychange", callback);
|
|
offWindowEvent("focus", callback);
|
|
};
|
|
};
|
|
var initReconnect = (callback) => {
|
|
const onOnline = () => {
|
|
online = true;
|
|
callback();
|
|
};
|
|
const onOffline = () => {
|
|
online = false;
|
|
};
|
|
onWindowEvent("online", onOnline);
|
|
onWindowEvent("offline", onOffline);
|
|
return () => {
|
|
offWindowEvent("online", onOnline);
|
|
offWindowEvent("offline", onOffline);
|
|
};
|
|
};
|
|
var preset = {
|
|
isOnline,
|
|
isVisible
|
|
};
|
|
var defaultConfigOptions = {
|
|
initFocus,
|
|
initReconnect
|
|
};
|
|
var IS_REACT_LEGACY = !import_react.useId;
|
|
var IS_SERVER = !isWindowDefined || isLegacyDeno;
|
|
var rAF = (f) => hasRequestAnimationFrame() ? window["requestAnimationFrame"](f) : setTimeout(f, 1);
|
|
var useIsomorphicLayoutEffect = IS_SERVER ? import_react.useEffect : import_react.useLayoutEffect;
|
|
var navigatorConnection = typeof navigator !== "undefined" && navigator.connection;
|
|
var slowConnection = !IS_SERVER && navigatorConnection && (["slow-2g", "2g"].includes(navigatorConnection.effectiveType) || navigatorConnection.saveData);
|
|
var table = /* @__PURE__ */ new WeakMap();
|
|
var getTypeName = (value) => OBJECT.prototype.toString.call(value);
|
|
var isObjectTypeName = (typeName, type) => typeName === `[object ${type}]`;
|
|
var counter = 0;
|
|
var stableHash = (arg) => {
|
|
const type = typeof arg;
|
|
const typeName = getTypeName(arg);
|
|
const isDate = isObjectTypeName(typeName, "Date");
|
|
const isRegex = isObjectTypeName(typeName, "RegExp");
|
|
const isPlainObject = isObjectTypeName(typeName, "Object");
|
|
let result;
|
|
let index;
|
|
if (OBJECT(arg) === arg && !isDate && !isRegex) {
|
|
result = table.get(arg);
|
|
if (result) return result;
|
|
result = ++counter + "~";
|
|
table.set(arg, result);
|
|
if (Array.isArray(arg)) {
|
|
result = "@";
|
|
for (index = 0; index < arg.length; index++) result += stableHash(arg[index]) + ",";
|
|
table.set(arg, result);
|
|
}
|
|
if (isPlainObject) {
|
|
result = "#";
|
|
const keys = OBJECT.keys(arg).sort();
|
|
while (!isUndefined(index = keys.pop())) if (!isUndefined(arg[index])) result += index + ":" + stableHash(arg[index]) + ",";
|
|
table.set(arg, result);
|
|
}
|
|
} else result = isDate ? arg.toJSON() : type == "symbol" ? arg.toString() : type == "string" ? JSON.stringify(arg) : "" + arg;
|
|
return result;
|
|
};
|
|
var serialize = (key) => {
|
|
if (isFunction(key)) try {
|
|
key = key();
|
|
} catch (err) {
|
|
key = "";
|
|
}
|
|
const args = key;
|
|
key = typeof key == "string" ? key : (Array.isArray(key) ? key.length : key) ? stableHash(key) : "";
|
|
return [key, args];
|
|
};
|
|
var __timestamp = 0;
|
|
var getTimestamp = () => ++__timestamp;
|
|
async function internalMutate(...args) {
|
|
const [cache, _key, _data, _opts] = args;
|
|
const options = mergeObjects({
|
|
populateCache: true,
|
|
throwOnError: true
|
|
}, typeof _opts === "boolean" ? { revalidate: _opts } : _opts || {});
|
|
let populateCache = options.populateCache;
|
|
const rollbackOnErrorOption = options.rollbackOnError;
|
|
let optimisticData = options.optimisticData;
|
|
const rollbackOnError = (error) => {
|
|
return typeof rollbackOnErrorOption === "function" ? rollbackOnErrorOption(error) : rollbackOnErrorOption !== false;
|
|
};
|
|
const throwOnError = options.throwOnError;
|
|
if (isFunction(_key)) {
|
|
const keyFilter = _key;
|
|
const matchedKeys = [];
|
|
const it = cache.keys();
|
|
for (const key of it) if (!/^\$(inf|sub)\$/.test(key) && keyFilter(cache.get(key)._k)) matchedKeys.push(key);
|
|
return Promise.all(matchedKeys.map(mutateByKey));
|
|
}
|
|
return mutateByKey(_key);
|
|
async function mutateByKey(_k) {
|
|
const [key] = serialize(_k);
|
|
if (!key) return;
|
|
const [get, set] = createCacheHelper(cache, key);
|
|
const [EVENT_REVALIDATORS, MUTATION, FETCH, PRELOAD] = SWRGlobalState.get(cache);
|
|
const startRevalidate = () => {
|
|
const revalidators = EVENT_REVALIDATORS[key];
|
|
if (isFunction(options.revalidate) ? options.revalidate(get().data, _k) : options.revalidate !== false) {
|
|
delete FETCH[key];
|
|
delete PRELOAD[key];
|
|
if (revalidators && revalidators[0]) return revalidators[0](2).then(() => get().data);
|
|
}
|
|
return get().data;
|
|
};
|
|
if (args.length < 3) return startRevalidate();
|
|
let data = _data;
|
|
let error;
|
|
let isError = false;
|
|
const beforeMutationTs = getTimestamp();
|
|
MUTATION[key] = [beforeMutationTs, 0];
|
|
const hasOptimisticData = !isUndefined(optimisticData);
|
|
const state = get();
|
|
const displayedData = state.data;
|
|
const currentData = state._c;
|
|
const committedData = isUndefined(currentData) ? displayedData : currentData;
|
|
if (hasOptimisticData) {
|
|
optimisticData = isFunction(optimisticData) ? optimisticData(committedData, displayedData) : optimisticData;
|
|
set({
|
|
data: optimisticData,
|
|
_c: committedData
|
|
});
|
|
}
|
|
if (isFunction(data)) try {
|
|
data = data(committedData);
|
|
} catch (err) {
|
|
error = err;
|
|
isError = true;
|
|
}
|
|
if (data && isPromiseLike(data)) {
|
|
data = await data.catch((err) => {
|
|
error = err;
|
|
isError = true;
|
|
});
|
|
if (beforeMutationTs !== MUTATION[key][0]) {
|
|
if (isError) throw error;
|
|
return data;
|
|
} else if (isError && hasOptimisticData && rollbackOnError(error)) {
|
|
populateCache = true;
|
|
set({
|
|
data: committedData,
|
|
_c: void 0
|
|
});
|
|
}
|
|
}
|
|
if (populateCache) {
|
|
if (!isError) {
|
|
if (isFunction(populateCache)) set({
|
|
data: populateCache(data, committedData),
|
|
error: void 0,
|
|
_c: void 0
|
|
});
|
|
else set({
|
|
data,
|
|
error: void 0,
|
|
_c: void 0
|
|
});
|
|
}
|
|
}
|
|
MUTATION[key][1] = getTimestamp();
|
|
Promise.resolve(startRevalidate()).then(() => {
|
|
set({ _c: void 0 });
|
|
});
|
|
if (isError) {
|
|
if (throwOnError) throw error;
|
|
return;
|
|
}
|
|
return data;
|
|
}
|
|
}
|
|
var revalidateAllKeys = (revalidators, type) => {
|
|
for (const key in revalidators) if (revalidators[key][0]) revalidators[key][0](type);
|
|
};
|
|
var initCache = (provider, options) => {
|
|
if (!SWRGlobalState.has(provider)) {
|
|
const opts = mergeObjects(defaultConfigOptions, options);
|
|
const EVENT_REVALIDATORS = Object.create(null);
|
|
const mutate = internalMutate.bind(void 0, provider);
|
|
let unmount = noop;
|
|
const subscriptions = Object.create(null);
|
|
const subscribe = (key, callback) => {
|
|
const subs = subscriptions[key] || [];
|
|
subscriptions[key] = subs;
|
|
subs.push(callback);
|
|
return () => {
|
|
const index = subs.indexOf(callback);
|
|
if (index >= 0) {
|
|
subs[index] = subs[subs.length - 1];
|
|
subs.pop();
|
|
}
|
|
};
|
|
};
|
|
const setter = (key, value, prev) => {
|
|
provider.set(key, value);
|
|
const subs = subscriptions[key];
|
|
if (subs) for (const fn of subs) fn(value, prev);
|
|
};
|
|
const unload = (unloadOptions) => {
|
|
const state = SWRGlobalState.get(provider);
|
|
const [, MUTATION, FETCH, PRELOAD] = state;
|
|
const ts = getTimestamp();
|
|
state[8]++;
|
|
for (const key in FETCH) delete FETCH[key];
|
|
for (const key in PRELOAD) delete PRELOAD[key];
|
|
for (const key in MUTATION) MUTATION[key] = [ts, ts];
|
|
const emptyState = {};
|
|
for (const key of [...provider.keys()]) {
|
|
const prev = provider.get(key);
|
|
provider.delete(key);
|
|
const subs = subscriptions[key];
|
|
if (subs) for (const fn of subs) fn(emptyState, prev);
|
|
}
|
|
const revalidate = !unloadOptions || unloadOptions.revalidate !== false;
|
|
for (const key in EVENT_REVALIDATORS) {
|
|
const revalidators = EVENT_REVALIDATORS[key];
|
|
for (let i = 0; i < revalidators.length; i++) revalidators[i](4, { revalidate: revalidate && !i });
|
|
}
|
|
};
|
|
const initProvider = () => {
|
|
if (!SWRGlobalState.has(provider)) {
|
|
SWRGlobalState.set(provider, [
|
|
EVENT_REVALIDATORS,
|
|
Object.create(null),
|
|
Object.create(null),
|
|
Object.create(null),
|
|
mutate,
|
|
setter,
|
|
subscribe,
|
|
unload,
|
|
0
|
|
]);
|
|
if (!IS_SERVER) {
|
|
const releaseFocus = opts.initFocus(setTimeout.bind(void 0, revalidateAllKeys.bind(void 0, EVENT_REVALIDATORS, 0)));
|
|
const releaseReconnect = opts.initReconnect(setTimeout.bind(void 0, revalidateAllKeys.bind(void 0, EVENT_REVALIDATORS, 1)));
|
|
unmount = () => {
|
|
releaseFocus && releaseFocus();
|
|
releaseReconnect && releaseReconnect();
|
|
SWRGlobalState.delete(provider);
|
|
};
|
|
}
|
|
}
|
|
};
|
|
initProvider();
|
|
return [
|
|
provider,
|
|
mutate,
|
|
initProvider,
|
|
unmount,
|
|
unload
|
|
];
|
|
}
|
|
const state = SWRGlobalState.get(provider);
|
|
return [
|
|
provider,
|
|
state[4],
|
|
void 0,
|
|
void 0,
|
|
state[7]
|
|
];
|
|
};
|
|
var onErrorRetry = (_, __, config, revalidate, opts) => {
|
|
const maxRetryCount = config.errorRetryCount;
|
|
const currentRetryCount = opts.retryCount;
|
|
const timeout = ~~((Math.random() + .5) * (1 << (currentRetryCount < 8 ? currentRetryCount : 8))) * config.errorRetryInterval;
|
|
if (!isUndefined(maxRetryCount) && currentRetryCount > maxRetryCount) return;
|
|
setTimeout(revalidate, timeout, opts);
|
|
};
|
|
var compare = dequal;
|
|
var [cache, mutate, , , unload] = initCache(/* @__PURE__ */ new Map());
|
|
var defaultConfig = mergeObjects({
|
|
onLoadingSlow: noop,
|
|
onSuccess: noop,
|
|
onError: noop,
|
|
onErrorRetry,
|
|
onDiscarded: noop,
|
|
revalidateOnFocus: true,
|
|
revalidateOnReconnect: true,
|
|
revalidateIfStale: true,
|
|
shouldRetryOnError: true,
|
|
errorRetryInterval: slowConnection ? 1e4 : 5e3,
|
|
focusThrottleInterval: 5e3,
|
|
dedupingInterval: 2e3,
|
|
loadingTimeout: slowConnection ? 5e3 : 3e3,
|
|
compare,
|
|
isPaused: () => false,
|
|
cache,
|
|
mutate,
|
|
unload,
|
|
fallback: {}
|
|
}, preset);
|
|
var mergeConfigs = (a, b) => {
|
|
const v = mergeObjects(a, b);
|
|
if (b) {
|
|
const { use: u1, fallback: f1, cacheData: c1 } = a;
|
|
const { use: u2, fallback: f2, cacheData: c2 } = b;
|
|
if (u1 && u2) v.use = u1.concat(u2);
|
|
if (f1 && f2) v.fallback = mergeObjects(f1, f2);
|
|
if (c1 && c2) v.cacheData = mergeObjects(c1, c2);
|
|
}
|
|
return v;
|
|
};
|
|
var SWRConfigContext = (0, import_react.createContext)({});
|
|
var SWRConfig$1 = (props) => {
|
|
const { value } = props;
|
|
const parentConfig = (0, import_react.useContext)(SWRConfigContext);
|
|
const isFunctionalConfig = isFunction(value);
|
|
const config = (0, import_react.useMemo)(() => isFunctionalConfig ? value(parentConfig) : value, [
|
|
isFunctionalConfig,
|
|
parentConfig,
|
|
value
|
|
]);
|
|
const extendedConfig = (0, import_react.useMemo)(() => isFunctionalConfig ? config : mergeConfigs(parentConfig, config), [
|
|
isFunctionalConfig,
|
|
parentConfig,
|
|
config
|
|
]);
|
|
const provider = config && config.provider;
|
|
const cacheContextRef = (0, import_react.useRef)(void 0);
|
|
if (provider && !cacheContextRef.current) cacheContextRef.current = initCache(provider(extendedConfig.cache || cache), config);
|
|
const cacheContext = cacheContextRef.current;
|
|
if (cacheContext) {
|
|
extendedConfig.cache = cacheContext[0];
|
|
extendedConfig.mutate = cacheContext[1];
|
|
extendedConfig.unload = cacheContext[4];
|
|
}
|
|
useIsomorphicLayoutEffect(() => {
|
|
if (cacheContext) {
|
|
cacheContext[2] && cacheContext[2]();
|
|
return cacheContext[3];
|
|
}
|
|
}, []);
|
|
return (0, import_react.createElement)(SWRConfigContext.Provider, mergeObjects(props, { value: extendedConfig }));
|
|
};
|
|
//#endregion
|
|
//#region node_modules/swr/dist/_internal/index.mjs
|
|
var enableDevtools = isWindowDefined && window.__SWR_DEVTOOLS_USE__;
|
|
var use$1 = enableDevtools ? window.__SWR_DEVTOOLS_USE__ : [];
|
|
var setupDevTools = () => {
|
|
if (enableDevtools) window.__SWR_DEVTOOLS_REACT__ = import_react.default;
|
|
};
|
|
var normalize = (args) => {
|
|
return isFunction(args[1]) ? [
|
|
args[0],
|
|
args[1],
|
|
args[2] || {}
|
|
] : [
|
|
args[0],
|
|
null,
|
|
(args[1] === null ? args[2] : args[1]) || {}
|
|
];
|
|
};
|
|
var useSWRConfig = () => {
|
|
const parentConfig = (0, import_react.useContext)(SWRConfigContext);
|
|
return (0, import_react.useMemo)(() => mergeObjects(defaultConfig, parentConfig), [parentConfig]);
|
|
};
|
|
var preload = (key_, fetcher) => {
|
|
if (IS_SERVER) return;
|
|
const [key, fnArg] = serialize(key_);
|
|
const [, , , PRELOAD] = SWRGlobalState.get(cache);
|
|
if (PRELOAD[key]) return PRELOAD[key];
|
|
const req = fetcher(fnArg);
|
|
PRELOAD[key] = req;
|
|
return req;
|
|
};
|
|
var middleware = (useSWRNext) => (key_, fetcher_, config) => {
|
|
return useSWRNext(key_, fetcher_ && ((...args) => {
|
|
const [key] = serialize(key_);
|
|
const [, , , PRELOAD] = SWRGlobalState.get(cache);
|
|
if (key.startsWith("$inf$")) return fetcher_(...args);
|
|
const req = PRELOAD[key];
|
|
if (isUndefined(req)) return fetcher_(...args);
|
|
delete PRELOAD[key];
|
|
return req;
|
|
}), config);
|
|
};
|
|
var BUILT_IN_MIDDLEWARE = use$1.concat(middleware);
|
|
var withArgs = (hook) => {
|
|
return function useSWRArgs(...args) {
|
|
const fallbackConfig = useSWRConfig();
|
|
const [key, fn, _config] = normalize(args);
|
|
const config = mergeConfigs(fallbackConfig, _config);
|
|
let next = hook;
|
|
const { use } = config;
|
|
const middleware = (use || []).concat(BUILT_IN_MIDDLEWARE);
|
|
for (let i = middleware.length; i--;) next = middleware[i](next);
|
|
return next(key, fn || config.fetcher || null, config);
|
|
};
|
|
};
|
|
var subscribeCallback = (key, callbacks, callback) => {
|
|
const keyedRevalidators = callbacks[key] || (callbacks[key] = []);
|
|
keyedRevalidators.push(callback);
|
|
return () => {
|
|
const index = keyedRevalidators.indexOf(callback);
|
|
if (index >= 0) {
|
|
keyedRevalidators[index] = keyedRevalidators[keyedRevalidators.length - 1];
|
|
keyedRevalidators.pop();
|
|
}
|
|
};
|
|
};
|
|
setupDevTools();
|
|
//#endregion
|
|
//#region node_modules/swr/dist/use-swr-emll9s78.mjs
|
|
var use = import_react.use || ((thenable) => {
|
|
switch (thenable.status) {
|
|
case "pending": throw thenable;
|
|
case "fulfilled": return thenable.value;
|
|
case "rejected": throw thenable.reason;
|
|
default:
|
|
thenable.status = "pending";
|
|
thenable.then((v) => {
|
|
thenable.status = "fulfilled";
|
|
thenable.value = v;
|
|
}, (e) => {
|
|
thenable.status = "rejected";
|
|
thenable.reason = e;
|
|
});
|
|
throw thenable;
|
|
}
|
|
});
|
|
var WITH_DEDUPE = { dedupe: true };
|
|
var isCacheDataConsumed = (consumedCacheData, cacheData, key) => {
|
|
var _consumedCacheData_get;
|
|
return cacheData ? ((_consumedCacheData_get = consumedCacheData.get(cacheData)) == null ? void 0 : _consumedCacheData_get.has(key)) === true : false;
|
|
};
|
|
var markCacheDataConsumed = (consumedCacheData, cacheData, key) => {
|
|
if (!cacheData) return;
|
|
let consumedKeys = consumedCacheData.get(cacheData);
|
|
if (!consumedKeys) {
|
|
consumedKeys = /* @__PURE__ */ new Set();
|
|
consumedCacheData.set(cacheData, consumedKeys);
|
|
}
|
|
consumedKeys.add(key);
|
|
};
|
|
var commitCacheData = ({ value, getCacheData, canCommit, setCache }) => {
|
|
const commit = (state) => {
|
|
if (canCommit() && isUndefined(getCacheData())) setCache(state);
|
|
};
|
|
Promise.resolve(value).then((data) => {
|
|
commit({
|
|
data,
|
|
error: void 0
|
|
});
|
|
}, (error) => {
|
|
commit({ error });
|
|
});
|
|
};
|
|
var resolvedUndef = Promise.resolve(void 0);
|
|
resolvedUndef.status = "fulfilled";
|
|
resolvedUndef.value = void 0;
|
|
var sub = () => noop;
|
|
/**
|
|
* The core implementation of the useSWR hook.
|
|
*
|
|
* This is the main handler function that implements all SWR functionality including
|
|
* data fetching, caching, revalidation, error handling, and state management.
|
|
* It manages the complete lifecycle of SWR requests from initialization through
|
|
* cleanup.
|
|
*
|
|
* Key responsibilities:
|
|
* - Key serialization and normalization
|
|
* - Cache state management and synchronization
|
|
* - Automatic and manual revalidation
|
|
* - Error handling and retry logic
|
|
* - Suspense integration
|
|
* - Loading state management
|
|
* - Effect cleanup and memory management
|
|
*
|
|
* @template Data - The type of data returned by the fetcher
|
|
* @template Error - The type of error that can be thrown
|
|
*
|
|
* @param _key - The SWR key (string, array, object, function, or falsy)
|
|
* @param fetcher - The fetcher function to retrieve data, or null to disable fetching
|
|
* @param config - Complete SWR configuration object with both public and internal options
|
|
*
|
|
* @returns SWRResponse object containing data, error, mutate function, and loading states
|
|
*
|
|
* @internal This is the internal implementation. Use `useSWR` instead.
|
|
*/ var useSWRHandler = (_key, fetcher, config) => {
|
|
const { cache, compare, suspense, fallbackData, revalidateOnMount, revalidateIfStale, refreshInterval, refreshWhenHidden, refreshWhenOffline, keepPreviousData, strictServerPrefetchWarning } = config;
|
|
const [EVENT_REVALIDATORS, MUTATION, FETCH, PRELOAD] = SWRGlobalState.get(cache);
|
|
const [key, fnArg] = serialize(_key);
|
|
const initialMountedRef = (0, import_react.useRef)(false);
|
|
const unmountedRef = (0, import_react.useRef)(false);
|
|
const keyRef = (0, import_react.useRef)(key);
|
|
const fetcherRef = (0, import_react.useRef)(fetcher);
|
|
const configRef = (0, import_react.useRef)(config);
|
|
const getConfig = () => configRef.current;
|
|
const isActive = () => getConfig().isVisible() && getConfig().isOnline();
|
|
const [getCache, setCache, subscribeCache, getInitialCache] = createCacheHelper(cache, key);
|
|
const stateDependencies = (0, import_react.useRef)({}).current;
|
|
const fallback = isUndefined(fallbackData) ? isUndefined(config.fallback) ? void 0 : config.fallback[key] : fallbackData;
|
|
const serverCacheData = config.cacheData;
|
|
const configCacheData = !key ? void 0 : serverCacheData == null ? void 0 : serverCacheData[key];
|
|
const req = key ? PRELOAD[key] : void 0;
|
|
const hasCacheData = isUndefined(req) && !isUndefined(configCacheData);
|
|
const preloadedData = hasCacheData ? configCacheData : req;
|
|
const isEqual = (prev, current) => {
|
|
for (const _ in stateDependencies) {
|
|
const t = _;
|
|
if (t === "data") {
|
|
if (!compare(prev[t], current[t])) {
|
|
if (!isUndefined(prev[t])) return false;
|
|
if (!compare(returnedData, current[t])) return false;
|
|
}
|
|
} else if (current[t] !== prev[t]) return false;
|
|
}
|
|
return true;
|
|
};
|
|
const isInitialMount = !initialMountedRef.current;
|
|
const getSnapshot = (0, import_react.useMemo)(() => {
|
|
const cachedData = getCache();
|
|
const initialData = getInitialCache();
|
|
const getSelectedCache = (state) => {
|
|
const snapshot = mergeObjects(state);
|
|
delete snapshot._k;
|
|
if (!(() => {
|
|
if (!key) return false;
|
|
if (!fetcher) return false;
|
|
if (getConfig().isPaused()) return false;
|
|
if (isInitialMount && !isUndefined(revalidateOnMount)) return revalidateOnMount;
|
|
const data = !isUndefined(fallback) ? fallback : snapshot.data;
|
|
if (suspense && hasCacheData && isUndefined(data)) return false;
|
|
if (suspense) return isUndefined(data) || revalidateIfStale;
|
|
return isUndefined(data) || revalidateIfStale;
|
|
})()) return snapshot;
|
|
return {
|
|
isValidating: true,
|
|
isLoading: true,
|
|
...snapshot
|
|
};
|
|
};
|
|
const clientSnapshot = getSelectedCache(cachedData);
|
|
const serverSnapshot = cachedData === initialData ? clientSnapshot : getSelectedCache(initialData);
|
|
let memorizedSnapshot = clientSnapshot;
|
|
return [() => {
|
|
const newSnapshot = getSelectedCache(getCache());
|
|
if (isEqual(newSnapshot, memorizedSnapshot)) {
|
|
memorizedSnapshot.data = newSnapshot.data;
|
|
memorizedSnapshot.isLoading = newSnapshot.isLoading;
|
|
memorizedSnapshot.isValidating = newSnapshot.isValidating;
|
|
memorizedSnapshot.error = newSnapshot.error;
|
|
return memorizedSnapshot;
|
|
} else {
|
|
memorizedSnapshot = newSnapshot;
|
|
return newSnapshot;
|
|
}
|
|
}, () => serverSnapshot];
|
|
}, [cache, key]);
|
|
const cached = (0, import_shim.useSyncExternalStore)((0, import_react.useCallback)((callback) => subscribeCache(key, (current, prev) => {
|
|
if (!isEqual(prev, current)) callback();
|
|
}), [cache, key]), getSnapshot[0], getSnapshot[1]);
|
|
const hasRevalidator = EVENT_REVALIDATORS[key] && EVENT_REVALIDATORS[key].length > 0;
|
|
const cachedData = cached.data;
|
|
let data = isUndefined(cachedData) ? fallback && isPromiseLike(fallback) ? use(fallback) : fallback : cachedData;
|
|
const error = cached.error;
|
|
const laggyDataRef = (0, import_react.useRef)(data);
|
|
const consumedCacheDataRef = (0, import_react.useRef)(void 0);
|
|
let consumedCacheData = consumedCacheDataRef.current;
|
|
if (!consumedCacheData) {
|
|
consumedCacheData = /* @__PURE__ */ new WeakMap();
|
|
consumedCacheDataRef.current = consumedCacheData;
|
|
}
|
|
const preloadCacheRef = (0, import_react.useRef)(null);
|
|
let returnedData = keepPreviousData ? isUndefined(cachedData) ? isUndefined(laggyDataRef.current) ? data : laggyDataRef.current : cachedData : data;
|
|
const hasKeyButNoData = key && isUndefined(data);
|
|
const hydrationRef = (0, import_react.useRef)(null);
|
|
!IS_SERVER && (0, import_shim.useSyncExternalStore)(sub, () => {
|
|
hydrationRef.current = false;
|
|
return hydrationRef;
|
|
}, () => {
|
|
hydrationRef.current = true;
|
|
return hydrationRef;
|
|
});
|
|
const isHydration = hydrationRef.current;
|
|
if (strictServerPrefetchWarning && isHydration && !suspense && hasKeyButNoData) console.warn(`Missing pre-initiated data for serialized key "${key}" during server-side rendering. Data fetching should be initiated on the server and provided to SWR via fallback data. You can set "strictServerPrefetchWarning: false" to disable this warning.`);
|
|
const shouldDoInitialRevalidation = (() => {
|
|
if (!key || !fetcher) return false;
|
|
if (getConfig().isPaused()) return false;
|
|
if (hasRevalidator && !isUndefined(error)) return false;
|
|
if (isInitialMount && !isUndefined(revalidateOnMount)) return revalidateOnMount;
|
|
if (suspense && hasCacheData && hasKeyButNoData) return false;
|
|
if (suspense) return isUndefined(data) ? false : revalidateIfStale;
|
|
return isUndefined(data) || revalidateIfStale;
|
|
})();
|
|
const defaultValidatingState = isInitialMount && shouldDoInitialRevalidation;
|
|
const isValidating = isUndefined(cached.isValidating) ? defaultValidatingState : cached.isValidating;
|
|
const isLoading = isUndefined(cached.isLoading) ? defaultValidatingState : cached.isLoading;
|
|
const revalidate = (0, import_react.useCallback)(async (revalidateOpts) => {
|
|
const currentFetcher = fetcherRef.current;
|
|
if (!key || !currentFetcher || unmountedRef.current || getConfig().isPaused()) return false;
|
|
let newData;
|
|
let startAt;
|
|
let loading = true;
|
|
const opts = revalidateOpts || {};
|
|
const shouldStartNewRequest = !FETCH[key] || !opts.dedupe;
|
|
const shouldUseRSCPreload = hasCacheData && !isCacheDataConsumed(consumedCacheData, serverCacheData, key) && !isUndefined(preloadedData) && isUndefined(getCache().data);
|
|
const callbackSafeguard = () => {
|
|
if (IS_REACT_LEGACY) return !unmountedRef.current && key === keyRef.current && initialMountedRef.current;
|
|
return key === keyRef.current;
|
|
};
|
|
const finalState = {
|
|
isValidating: false,
|
|
isLoading: false
|
|
};
|
|
const finishRequestAndUpdateState = () => {
|
|
setCache(finalState);
|
|
};
|
|
const cleanupState = () => {
|
|
const requestInfo = FETCH[key];
|
|
if (requestInfo && requestInfo[1] === startAt) delete FETCH[key];
|
|
};
|
|
const initialState = { isValidating: true };
|
|
if (isUndefined(getCache().data)) initialState.isLoading = true;
|
|
try {
|
|
if (shouldStartNewRequest) {
|
|
setCache(initialState);
|
|
if (config.loadingTimeout && isUndefined(getCache().data)) setTimeout(() => {
|
|
if (loading && callbackSafeguard()) getConfig().onLoadingSlow(key, config);
|
|
}, config.loadingTimeout);
|
|
if (shouldUseRSCPreload) markCacheDataConsumed(consumedCacheData, serverCacheData, key);
|
|
FETCH[key] = [shouldUseRSCPreload ? preloadedData : currentFetcher(fnArg), getTimestamp()];
|
|
if (shouldUseRSCPreload && PRELOAD[key]) delete PRELOAD[key];
|
|
}
|
|
[newData, startAt] = FETCH[key];
|
|
newData = await newData;
|
|
if (shouldStartNewRequest) setTimeout(cleanupState, config.dedupingInterval);
|
|
if (!FETCH[key] || FETCH[key][1] !== startAt) {
|
|
if (shouldStartNewRequest) {
|
|
if (callbackSafeguard()) getConfig().onDiscarded(key);
|
|
}
|
|
return false;
|
|
}
|
|
finalState.error = void 0;
|
|
const mutationInfo = MUTATION[key];
|
|
if (!isUndefined(mutationInfo) && (startAt <= mutationInfo[0] || startAt <= mutationInfo[1] || mutationInfo[1] === 0)) {
|
|
finishRequestAndUpdateState();
|
|
if (shouldStartNewRequest) {
|
|
if (callbackSafeguard()) getConfig().onDiscarded(key);
|
|
}
|
|
return false;
|
|
}
|
|
const cacheData = getCache().data;
|
|
finalState.data = compare(cacheData, newData) ? cacheData : newData;
|
|
if (shouldStartNewRequest) {
|
|
if (callbackSafeguard()) getConfig().onSuccess(newData, key, config);
|
|
}
|
|
} catch (err) {
|
|
cleanupState();
|
|
const currentConfig = getConfig();
|
|
const { shouldRetryOnError } = currentConfig;
|
|
if (!currentConfig.isPaused()) {
|
|
finalState.error = err;
|
|
if (shouldStartNewRequest && callbackSafeguard()) {
|
|
currentConfig.onError(err, key, currentConfig);
|
|
if (shouldRetryOnError === true || isFunction(shouldRetryOnError) && shouldRetryOnError(err)) {
|
|
if (!getConfig().revalidateOnFocus || !getConfig().revalidateOnReconnect || isActive()) currentConfig.onErrorRetry(err, key, currentConfig, (_opts) => {
|
|
const revalidators = EVENT_REVALIDATORS[key];
|
|
if (revalidators && revalidators[0]) revalidators[0](3, _opts);
|
|
}, {
|
|
retryCount: (opts.retryCount || 0) + 1,
|
|
dedupe: true
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
loading = false;
|
|
finishRequestAndUpdateState();
|
|
return true;
|
|
}, [key, cache]);
|
|
const boundMutate = (0, import_react.useCallback)((...args) => {
|
|
return internalMutate(cache, keyRef.current, ...args);
|
|
}, []);
|
|
useIsomorphicLayoutEffect(() => {
|
|
const preloaded = preloadCacheRef.current;
|
|
if (!preloaded) return;
|
|
preloadCacheRef.current = null;
|
|
markCacheDataConsumed(consumedCacheData, preloaded.cacheData, preloaded.key);
|
|
if (isUndefined(getCache().data)) setCache({
|
|
data: preloaded.data,
|
|
error: void 0,
|
|
_k: preloaded._k
|
|
});
|
|
if (PRELOAD[preloaded.key]) delete PRELOAD[preloaded.key];
|
|
});
|
|
useIsomorphicLayoutEffect(() => {
|
|
fetcherRef.current = fetcher;
|
|
configRef.current = config;
|
|
if (!isUndefined(cachedData)) laggyDataRef.current = cachedData;
|
|
});
|
|
useIsomorphicLayoutEffect(() => {
|
|
if (fetcher || !hasCacheData || isUndefined(preloadedData) || isCacheDataConsumed(consumedCacheData, serverCacheData, key) || !isUndefined(getCache().data)) return;
|
|
markCacheDataConsumed(consumedCacheData, serverCacheData, key);
|
|
const mutation = MUTATION[key];
|
|
commitCacheData({
|
|
value: preloadedData,
|
|
getCacheData: () => getCache().data,
|
|
canCommit: () => !unmountedRef.current && key === keyRef.current && MUTATION[key] === mutation,
|
|
setCache: (state) => setCache({
|
|
...state,
|
|
_k: fnArg
|
|
})
|
|
});
|
|
});
|
|
useIsomorphicLayoutEffect(() => {
|
|
if (!key) return;
|
|
const softRevalidate = revalidate.bind(void 0, WITH_DEDUPE);
|
|
let nextFocusRevalidatedAt = 0;
|
|
if (getConfig().revalidateOnFocus) nextFocusRevalidatedAt = Date.now() + getConfig().focusThrottleInterval;
|
|
const onRevalidate = (type, opts = {}) => {
|
|
if (type == 0) {
|
|
const now = Date.now();
|
|
if (getConfig().revalidateOnFocus && now > nextFocusRevalidatedAt && isActive()) {
|
|
nextFocusRevalidatedAt = now + getConfig().focusThrottleInterval;
|
|
softRevalidate();
|
|
}
|
|
} else if (type == 1) {
|
|
if (getConfig().revalidateOnReconnect && isActive()) softRevalidate();
|
|
} else if (type == 2) return revalidate();
|
|
else if (type == 3) return revalidate(opts);
|
|
else if (type == 4) {
|
|
laggyDataRef.current = void 0;
|
|
if (opts.revalidate) return revalidate();
|
|
}
|
|
};
|
|
const unsubEvents = subscribeCallback(key, EVENT_REVALIDATORS, onRevalidate);
|
|
unmountedRef.current = false;
|
|
keyRef.current = key;
|
|
initialMountedRef.current = true;
|
|
setCache({ _k: fnArg });
|
|
if (shouldDoInitialRevalidation) {
|
|
if (!FETCH[key]) {
|
|
if (isUndefined(data) || IS_SERVER) softRevalidate();
|
|
else rAF(softRevalidate);
|
|
}
|
|
}
|
|
return () => {
|
|
unmountedRef.current = true;
|
|
unsubEvents();
|
|
};
|
|
}, [key]);
|
|
useIsomorphicLayoutEffect(() => {
|
|
let timer;
|
|
function next() {
|
|
const interval = isFunction(refreshInterval) ? refreshInterval(getCache().data) : refreshInterval;
|
|
if (interval && timer !== -1) timer = setTimeout(execute, interval);
|
|
}
|
|
function execute() {
|
|
if (!getCache().error && (refreshWhenHidden || getConfig().isVisible()) && (refreshWhenOffline || getConfig().isOnline())) revalidate(WITH_DEDUPE).then(next);
|
|
else next();
|
|
}
|
|
next();
|
|
return () => {
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
timer = -1;
|
|
}
|
|
};
|
|
}, [
|
|
refreshInterval,
|
|
refreshWhenHidden,
|
|
refreshWhenOffline,
|
|
key
|
|
]);
|
|
(0, import_react.useDebugValue)(returnedData);
|
|
if (suspense) {
|
|
if (!IS_REACT_LEGACY && IS_SERVER && hasKeyButNoData && isUndefined(preloadedData)) throw new Error("Fallback data is required when using Suspense in SSR.");
|
|
if (hasKeyButNoData) {
|
|
fetcherRef.current = fetcher;
|
|
configRef.current = config;
|
|
unmountedRef.current = false;
|
|
}
|
|
const shouldConsumePreload = !isUndefined(preloadedData) && hasKeyButNoData;
|
|
let preloadData = void 0;
|
|
if (shouldConsumePreload && hasCacheData) {
|
|
preloadData = preloadedData && isPromiseLike(preloadedData) ? use(preloadedData) : preloadedData;
|
|
data = preloadData;
|
|
returnedData = preloadData;
|
|
if (!IS_SERVER) preloadCacheRef.current = {
|
|
data: preloadData,
|
|
_k: fnArg,
|
|
key,
|
|
cacheData: serverCacheData
|
|
};
|
|
} else use(shouldConsumePreload ? boundMutate(preloadedData) : resolvedUndef);
|
|
if (!isUndefined(error) && hasKeyButNoData) throw error;
|
|
const revalidation = hasKeyButNoData && isUndefined(preloadData) ? revalidate(WITH_DEDUPE) : resolvedUndef;
|
|
if (!isUndefined(returnedData) && hasKeyButNoData) {
|
|
revalidation.status = "fulfilled";
|
|
revalidation.value = true;
|
|
}
|
|
use(revalidation);
|
|
}
|
|
return {
|
|
mutate: boundMutate,
|
|
get data() {
|
|
stateDependencies.data = true;
|
|
return returnedData;
|
|
},
|
|
get error() {
|
|
stateDependencies.error = true;
|
|
return error;
|
|
},
|
|
get isValidating() {
|
|
stateDependencies.isValidating = true;
|
|
return isValidating;
|
|
},
|
|
get isLoading() {
|
|
stateDependencies.isLoading = true;
|
|
return isLoading;
|
|
}
|
|
};
|
|
};
|
|
var SWRConfig = OBJECT.defineProperty(SWRConfig$1, "defaultValue", { value: defaultConfig });
|
|
/**
|
|
* A hook to fetch data.
|
|
*
|
|
* @see {@link https://swr.vercel.app}
|
|
*
|
|
* @example
|
|
* ```jsx
|
|
* import useSWR from 'swr'
|
|
* function Profile() {
|
|
* const { data, error, isLoading } = useSWR('/api/user', fetcher)
|
|
* if (error) return <div>failed to load</div>
|
|
* if (isLoading) return <div>loading...</div>
|
|
* return <div>hello {data.name}!</div>
|
|
* }
|
|
* ```
|
|
*/ var useSWR = withArgs(useSWRHandler);
|
|
//#endregion
|
|
//#region node_modules/swr/dist/index/index.mjs
|
|
var unstable_serialize = (key) => serialize(key)[0];
|
|
//#endregion
|
|
export { SWRConfig, useSWR as default, mutate, preload, unload, unstable_serialize, useSWRConfig };
|