strapi-plugin-link-custom-field
Version:
Grab Slugs and url paths from other content types
1,542 lines • 278 kB
JavaScript
"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const jsxRuntime = require("react/jsx-runtime");
const ReactDOM = require("react-dom");
const React = require("react");
const designSystem = require("@strapi/design-system");
const admin = require("@strapi/strapi/admin");
const reactIntl = require("react-intl");
const index = require("./index-waT6oiZf.js");
const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
const ReactDOM__default = /* @__PURE__ */ _interopDefault(ReactDOM);
const React__default = /* @__PURE__ */ _interopDefault(React);
function _setPrototypeOf(t, e) {
return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
return t2.__proto__ = e2, t2;
}, _setPrototypeOf(t, e);
}
function _inheritsLoose(t, o) {
t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
}
var Subscribable = /* @__PURE__ */ function() {
function Subscribable2() {
this.listeners = [];
}
var _proto = Subscribable2.prototype;
_proto.subscribe = function subscribe(listener) {
var _this = this;
var callback = listener || function() {
return void 0;
};
this.listeners.push(callback);
this.onSubscribe();
return function() {
_this.listeners = _this.listeners.filter(function(x) {
return x !== callback;
});
_this.onUnsubscribe();
};
};
_proto.hasListeners = function hasListeners() {
return this.listeners.length > 0;
};
_proto.onSubscribe = function onSubscribe() {
};
_proto.onUnsubscribe = function onUnsubscribe() {
};
return Subscribable2;
}();
function _extends$5() {
return _extends$5 = Object.assign ? Object.assign.bind() : function(n) {
for (var e = 1; e < arguments.length; e++) {
var t = arguments[e];
for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
}
return n;
}, _extends$5.apply(null, arguments);
}
var isServer = typeof window === "undefined";
function noop() {
return void 0;
}
function functionalUpdate(updater, input) {
return typeof updater === "function" ? updater(input) : updater;
}
function isValidTimeout(value) {
return typeof value === "number" && value >= 0 && value !== Infinity;
}
function ensureQueryKeyArray(value) {
return Array.isArray(value) ? value : [value];
}
function timeUntilStale(updatedAt, staleTime) {
return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
}
function parseQueryArgs(arg1, arg2, arg3) {
if (!isQueryKey(arg1)) {
return arg1;
}
if (typeof arg2 === "function") {
return _extends$5({}, arg3, {
queryKey: arg1,
queryFn: arg2
});
}
return _extends$5({}, arg2, {
queryKey: arg1
});
}
function parseFilterArgs(arg1, arg2, arg3) {
return isQueryKey(arg1) ? [_extends$5({}, arg2, {
queryKey: arg1
}), arg3] : [arg1 || {}, arg2];
}
function mapQueryStatusFilter(active, inactive) {
if (active === true && inactive === true || active == null && inactive == null) {
return "all";
} else if (active === false && inactive === false) {
return "none";
} else {
var isActive = active != null ? active : !inactive;
return isActive ? "active" : "inactive";
}
}
function matchQuery(filters, query) {
var active = filters.active, exact = filters.exact, fetching = filters.fetching, inactive = filters.inactive, predicate = filters.predicate, queryKey = filters.queryKey, stale = filters.stale;
if (isQueryKey(queryKey)) {
if (exact) {
if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
return false;
}
} else if (!partialMatchKey(query.queryKey, queryKey)) {
return false;
}
}
var queryStatusFilter = mapQueryStatusFilter(active, inactive);
if (queryStatusFilter === "none") {
return false;
} else if (queryStatusFilter !== "all") {
var isActive = query.isActive();
if (queryStatusFilter === "active" && !isActive) {
return false;
}
if (queryStatusFilter === "inactive" && isActive) {
return false;
}
}
if (typeof stale === "boolean" && query.isStale() !== stale) {
return false;
}
if (typeof fetching === "boolean" && query.isFetching() !== fetching) {
return false;
}
if (predicate && !predicate(query)) {
return false;
}
return true;
}
function matchMutation(filters, mutation) {
var exact = filters.exact, fetching = filters.fetching, predicate = filters.predicate, mutationKey = filters.mutationKey;
if (isQueryKey(mutationKey)) {
if (!mutation.options.mutationKey) {
return false;
}
if (exact) {
if (hashQueryKey(mutation.options.mutationKey) !== hashQueryKey(mutationKey)) {
return false;
}
} else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {
return false;
}
}
if (typeof fetching === "boolean" && mutation.state.status === "loading" !== fetching) {
return false;
}
if (predicate && !predicate(mutation)) {
return false;
}
return true;
}
function hashQueryKeyByOptions(queryKey, options) {
var hashFn = (options == null ? void 0 : options.queryKeyHashFn) || hashQueryKey;
return hashFn(queryKey);
}
function hashQueryKey(queryKey) {
var asArray = ensureQueryKeyArray(queryKey);
return stableValueHash(asArray);
}
function stableValueHash(value) {
return JSON.stringify(value, function(_, val) {
return isPlainObject(val) ? Object.keys(val).sort().reduce(function(result, key) {
result[key] = val[key];
return result;
}, {}) : val;
});
}
function partialMatchKey(a, b) {
return partialDeepEqual(ensureQueryKeyArray(a), ensureQueryKeyArray(b));
}
function partialDeepEqual(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).some(function(key) {
return !partialDeepEqual(a[key], b[key]);
});
}
return false;
}
function replaceEqualDeep(a, b) {
if (a === b) {
return a;
}
var array2 = Array.isArray(a) && Array.isArray(b);
if (array2 || isPlainObject(a) && isPlainObject(b)) {
var aSize = array2 ? a.length : Object.keys(a).length;
var bItems = array2 ? b : Object.keys(b);
var bSize = bItems.length;
var copy = array2 ? [] : {};
var equalItems = 0;
for (var i = 0; i < bSize; i++) {
var key = array2 ? i : bItems[i];
copy[key] = replaceEqualDeep(a[key], b[key]);
if (copy[key] === a[key]) {
equalItems++;
}
}
return aSize === bSize && equalItems === aSize ? a : copy;
}
return b;
}
function shallowEqualObjects(a, b) {
if (a && !b || b && !a) {
return false;
}
for (var key in a) {
if (a[key] !== b[key]) {
return false;
}
}
return true;
}
function isPlainObject(o) {
if (!hasObjectPrototype(o)) {
return false;
}
var ctor = o.constructor;
if (typeof ctor === "undefined") {
return true;
}
var prot = ctor.prototype;
if (!hasObjectPrototype(prot)) {
return false;
}
if (!prot.hasOwnProperty("isPrototypeOf")) {
return false;
}
return true;
}
function hasObjectPrototype(o) {
return Object.prototype.toString.call(o) === "[object Object]";
}
function isQueryKey(value) {
return typeof value === "string" || Array.isArray(value);
}
function sleep(timeout) {
return new Promise(function(resolve) {
setTimeout(resolve, timeout);
});
}
function scheduleMicrotask(callback) {
Promise.resolve().then(callback).catch(function(error) {
return setTimeout(function() {
throw error;
});
});
}
function getAbortController() {
if (typeof AbortController === "function") {
return new AbortController();
}
}
var FocusManager = /* @__PURE__ */ function(_Subscribable) {
_inheritsLoose(FocusManager2, _Subscribable);
function FocusManager2() {
var _this;
_this = _Subscribable.call(this) || this;
_this.setup = function(onFocus) {
var _window;
if (!isServer && ((_window = window) == null ? void 0 : _window.addEventListener)) {
var listener = function listener2() {
return onFocus();
};
window.addEventListener("visibilitychange", listener, false);
window.addEventListener("focus", listener, false);
return function() {
window.removeEventListener("visibilitychange", listener);
window.removeEventListener("focus", listener);
};
}
};
return _this;
}
var _proto = FocusManager2.prototype;
_proto.onSubscribe = function onSubscribe() {
if (!this.cleanup) {
this.setEventListener(this.setup);
}
};
_proto.onUnsubscribe = function onUnsubscribe() {
if (!this.hasListeners()) {
var _this$cleanup;
(_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
this.cleanup = void 0;
}
};
_proto.setEventListener = function setEventListener(setup) {
var _this$cleanup2, _this2 = this;
this.setup = setup;
(_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
this.cleanup = setup(function(focused) {
if (typeof focused === "boolean") {
_this2.setFocused(focused);
} else {
_this2.onFocus();
}
});
};
_proto.setFocused = function setFocused(focused) {
this.focused = focused;
if (focused) {
this.onFocus();
}
};
_proto.onFocus = function onFocus() {
this.listeners.forEach(function(listener) {
listener();
});
};
_proto.isFocused = function isFocused() {
if (typeof this.focused === "boolean") {
return this.focused;
}
if (typeof document === "undefined") {
return true;
}
return [void 0, "visible", "prerender"].includes(document.visibilityState);
};
return FocusManager2;
}(Subscribable);
var focusManager = new FocusManager();
var OnlineManager = /* @__PURE__ */ function(_Subscribable) {
_inheritsLoose(OnlineManager2, _Subscribable);
function OnlineManager2() {
var _this;
_this = _Subscribable.call(this) || this;
_this.setup = function(onOnline) {
var _window;
if (!isServer && ((_window = window) == null ? void 0 : _window.addEventListener)) {
var listener = function listener2() {
return onOnline();
};
window.addEventListener("online", listener, false);
window.addEventListener("offline", listener, false);
return function() {
window.removeEventListener("online", listener);
window.removeEventListener("offline", listener);
};
}
};
return _this;
}
var _proto = OnlineManager2.prototype;
_proto.onSubscribe = function onSubscribe() {
if (!this.cleanup) {
this.setEventListener(this.setup);
}
};
_proto.onUnsubscribe = function onUnsubscribe() {
if (!this.hasListeners()) {
var _this$cleanup;
(_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
this.cleanup = void 0;
}
};
_proto.setEventListener = function setEventListener(setup) {
var _this$cleanup2, _this2 = this;
this.setup = setup;
(_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
this.cleanup = setup(function(online) {
if (typeof online === "boolean") {
_this2.setOnline(online);
} else {
_this2.onOnline();
}
});
};
_proto.setOnline = function setOnline(online) {
this.online = online;
if (online) {
this.onOnline();
}
};
_proto.onOnline = function onOnline() {
this.listeners.forEach(function(listener) {
listener();
});
};
_proto.isOnline = function isOnline() {
if (typeof this.online === "boolean") {
return this.online;
}
if (typeof navigator === "undefined" || typeof navigator.onLine === "undefined") {
return true;
}
return navigator.onLine;
};
return OnlineManager2;
}(Subscribable);
var onlineManager = new OnlineManager();
function defaultRetryDelay(failureCount) {
return Math.min(1e3 * Math.pow(2, failureCount), 3e4);
}
function isCancelable(value) {
return typeof (value == null ? void 0 : value.cancel) === "function";
}
var CancelledError = function CancelledError2(options) {
this.revert = options == null ? void 0 : options.revert;
this.silent = options == null ? void 0 : options.silent;
};
function isCancelledError(value) {
return value instanceof CancelledError;
}
var Retryer = function Retryer2(config) {
var _this = this;
var cancelRetry = false;
var cancelFn;
var continueFn;
var promiseResolve;
var promiseReject;
this.abort = config.abort;
this.cancel = function(cancelOptions) {
return cancelFn == null ? void 0 : cancelFn(cancelOptions);
};
this.cancelRetry = function() {
cancelRetry = true;
};
this.continueRetry = function() {
cancelRetry = false;
};
this.continue = function() {
return continueFn == null ? void 0 : continueFn();
};
this.failureCount = 0;
this.isPaused = false;
this.isResolved = false;
this.isTransportCancelable = false;
this.promise = new Promise(function(outerResolve, outerReject) {
promiseResolve = outerResolve;
promiseReject = outerReject;
});
var resolve = function resolve2(value) {
if (!_this.isResolved) {
_this.isResolved = true;
config.onSuccess == null ? void 0 : config.onSuccess(value);
continueFn == null ? void 0 : continueFn();
promiseResolve(value);
}
};
var reject = function reject2(value) {
if (!_this.isResolved) {
_this.isResolved = true;
config.onError == null ? void 0 : config.onError(value);
continueFn == null ? void 0 : continueFn();
promiseReject(value);
}
};
var pause = function pause2() {
return new Promise(function(continueResolve) {
continueFn = continueResolve;
_this.isPaused = true;
config.onPause == null ? void 0 : config.onPause();
}).then(function() {
continueFn = void 0;
_this.isPaused = false;
config.onContinue == null ? void 0 : config.onContinue();
});
};
var run = function run2() {
if (_this.isResolved) {
return;
}
var promiseOrValue;
try {
promiseOrValue = config.fn();
} catch (error) {
promiseOrValue = Promise.reject(error);
}
cancelFn = function cancelFn2(cancelOptions) {
if (!_this.isResolved) {
reject(new CancelledError(cancelOptions));
_this.abort == null ? void 0 : _this.abort();
if (isCancelable(promiseOrValue)) {
try {
promiseOrValue.cancel();
} catch (_unused) {
}
}
}
};
_this.isTransportCancelable = isCancelable(promiseOrValue);
Promise.resolve(promiseOrValue).then(resolve).catch(function(error) {
var _config$retry, _config$retryDelay;
if (_this.isResolved) {
return;
}
var retry = (_config$retry = config.retry) != null ? _config$retry : 3;
var retryDelay = (_config$retryDelay = config.retryDelay) != null ? _config$retryDelay : defaultRetryDelay;
var delay = typeof retryDelay === "function" ? retryDelay(_this.failureCount, error) : retryDelay;
var shouldRetry = retry === true || typeof retry === "number" && _this.failureCount < retry || typeof retry === "function" && retry(_this.failureCount, error);
if (cancelRetry || !shouldRetry) {
reject(error);
return;
}
_this.failureCount++;
config.onFail == null ? void 0 : config.onFail(_this.failureCount, error);
sleep(delay).then(function() {
if (!focusManager.isFocused() || !onlineManager.isOnline()) {
return pause();
}
}).then(function() {
if (cancelRetry) {
reject(error);
} else {
run2();
}
});
});
};
run();
};
var NotifyManager = /* @__PURE__ */ function() {
function NotifyManager2() {
this.queue = [];
this.transactions = 0;
this.notifyFn = function(callback) {
callback();
};
this.batchNotifyFn = function(callback) {
callback();
};
}
var _proto = NotifyManager2.prototype;
_proto.batch = function batch(callback) {
var result;
this.transactions++;
try {
result = callback();
} finally {
this.transactions--;
if (!this.transactions) {
this.flush();
}
}
return result;
};
_proto.schedule = function schedule(callback) {
var _this = this;
if (this.transactions) {
this.queue.push(callback);
} else {
scheduleMicrotask(function() {
_this.notifyFn(callback);
});
}
};
_proto.batchCalls = function batchCalls(callback) {
var _this2 = this;
return function() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_this2.schedule(function() {
callback.apply(void 0, args);
});
};
};
_proto.flush = function flush() {
var _this3 = this;
var queue = this.queue;
this.queue = [];
if (queue.length) {
scheduleMicrotask(function() {
_this3.batchNotifyFn(function() {
queue.forEach(function(callback) {
_this3.notifyFn(callback);
});
});
});
}
};
_proto.setNotifyFunction = function setNotifyFunction(fn) {
this.notifyFn = fn;
};
_proto.setBatchNotifyFunction = function setBatchNotifyFunction(fn) {
this.batchNotifyFn = fn;
};
return NotifyManager2;
}();
var notifyManager = new NotifyManager();
var logger$1 = console;
function getLogger() {
return logger$1;
}
function setLogger(newLogger) {
logger$1 = newLogger;
}
var Query = /* @__PURE__ */ function() {
function Query2(config) {
this.abortSignalConsumed = false;
this.hadObservers = false;
this.defaultOptions = config.defaultOptions;
this.setOptions(config.options);
this.observers = [];
this.cache = config.cache;
this.queryKey = config.queryKey;
this.queryHash = config.queryHash;
this.initialState = config.state || this.getDefaultState(this.options);
this.state = this.initialState;
this.meta = config.meta;
this.scheduleGc();
}
var _proto = Query2.prototype;
_proto.setOptions = function setOptions(options) {
var _this$options$cacheTi;
this.options = _extends$5({}, this.defaultOptions, options);
this.meta = options == null ? void 0 : options.meta;
this.cacheTime = Math.max(this.cacheTime || 0, (_this$options$cacheTi = this.options.cacheTime) != null ? _this$options$cacheTi : 5 * 60 * 1e3);
};
_proto.setDefaultOptions = function setDefaultOptions(options) {
this.defaultOptions = options;
};
_proto.scheduleGc = function scheduleGc() {
var _this = this;
this.clearGcTimeout();
if (isValidTimeout(this.cacheTime)) {
this.gcTimeout = setTimeout(function() {
_this.optionalRemove();
}, this.cacheTime);
}
};
_proto.clearGcTimeout = function clearGcTimeout() {
if (this.gcTimeout) {
clearTimeout(this.gcTimeout);
this.gcTimeout = void 0;
}
};
_proto.optionalRemove = function optionalRemove() {
if (!this.observers.length) {
if (this.state.isFetching) {
if (this.hadObservers) {
this.scheduleGc();
}
} else {
this.cache.remove(this);
}
}
};
_proto.setData = function setData(updater, options) {
var _this$options$isDataE, _this$options;
var prevData = this.state.data;
var data = functionalUpdate(updater, prevData);
if ((_this$options$isDataE = (_this$options = this.options).isDataEqual) == null ? void 0 : _this$options$isDataE.call(_this$options, prevData, data)) {
data = prevData;
} else if (this.options.structuralSharing !== false) {
data = replaceEqualDeep(prevData, data);
}
this.dispatch({
data,
type: "success",
dataUpdatedAt: options == null ? void 0 : options.updatedAt
});
return data;
};
_proto.setState = function setState(state, setStateOptions) {
this.dispatch({
type: "setState",
state,
setStateOptions
});
};
_proto.cancel = function cancel(options) {
var _this$retryer;
var promise = this.promise;
(_this$retryer = this.retryer) == null ? void 0 : _this$retryer.cancel(options);
return promise ? promise.then(noop).catch(noop) : Promise.resolve();
};
_proto.destroy = function destroy() {
this.clearGcTimeout();
this.cancel({
silent: true
});
};
_proto.reset = function reset() {
this.destroy();
this.setState(this.initialState);
};
_proto.isActive = function isActive() {
return this.observers.some(function(observer) {
return observer.options.enabled !== false;
});
};
_proto.isFetching = function isFetching() {
return this.state.isFetching;
};
_proto.isStale = function isStale2() {
return this.state.isInvalidated || !this.state.dataUpdatedAt || this.observers.some(function(observer) {
return observer.getCurrentResult().isStale;
});
};
_proto.isStaleByTime = function isStaleByTime(staleTime) {
if (staleTime === void 0) {
staleTime = 0;
}
return this.state.isInvalidated || !this.state.dataUpdatedAt || !timeUntilStale(this.state.dataUpdatedAt, staleTime);
};
_proto.onFocus = function onFocus() {
var _this$retryer2;
var observer = this.observers.find(function(x) {
return x.shouldFetchOnWindowFocus();
});
if (observer) {
observer.refetch();
}
(_this$retryer2 = this.retryer) == null ? void 0 : _this$retryer2.continue();
};
_proto.onOnline = function onOnline() {
var _this$retryer3;
var observer = this.observers.find(function(x) {
return x.shouldFetchOnReconnect();
});
if (observer) {
observer.refetch();
}
(_this$retryer3 = this.retryer) == null ? void 0 : _this$retryer3.continue();
};
_proto.addObserver = function addObserver(observer) {
if (this.observers.indexOf(observer) === -1) {
this.observers.push(observer);
this.hadObservers = true;
this.clearGcTimeout();
this.cache.notify({
type: "observerAdded",
query: this,
observer
});
}
};
_proto.removeObserver = function removeObserver(observer) {
if (this.observers.indexOf(observer) !== -1) {
this.observers = this.observers.filter(function(x) {
return x !== observer;
});
if (!this.observers.length) {
if (this.retryer) {
if (this.retryer.isTransportCancelable || this.abortSignalConsumed) {
this.retryer.cancel({
revert: true
});
} else {
this.retryer.cancelRetry();
}
}
if (this.cacheTime) {
this.scheduleGc();
} else {
this.cache.remove(this);
}
}
this.cache.notify({
type: "observerRemoved",
query: this,
observer
});
}
};
_proto.getObserversCount = function getObserversCount() {
return this.observers.length;
};
_proto.invalidate = function invalidate() {
if (!this.state.isInvalidated) {
this.dispatch({
type: "invalidate"
});
}
};
_proto.fetch = function fetch(options, fetchOptions) {
var _this2 = this, _this$options$behavio, _context$fetchOptions, _abortController$abor;
if (this.state.isFetching) {
if (this.state.dataUpdatedAt && (fetchOptions == null ? void 0 : fetchOptions.cancelRefetch)) {
this.cancel({
silent: true
});
} else if (this.promise) {
var _this$retryer4;
(_this$retryer4 = this.retryer) == null ? void 0 : _this$retryer4.continueRetry();
return this.promise;
}
}
if (options) {
this.setOptions(options);
}
if (!this.options.queryFn) {
var observer = this.observers.find(function(x) {
return x.options.queryFn;
});
if (observer) {
this.setOptions(observer.options);
}
}
var queryKey = ensureQueryKeyArray(this.queryKey);
var abortController = getAbortController();
var queryFnContext = {
queryKey,
pageParam: void 0,
meta: this.meta
};
Object.defineProperty(queryFnContext, "signal", {
enumerable: true,
get: function get2() {
if (abortController) {
_this2.abortSignalConsumed = true;
return abortController.signal;
}
return void 0;
}
});
var fetchFn = function fetchFn2() {
if (!_this2.options.queryFn) {
return Promise.reject("Missing queryFn");
}
_this2.abortSignalConsumed = false;
return _this2.options.queryFn(queryFnContext);
};
var context = {
fetchOptions,
options: this.options,
queryKey,
state: this.state,
fetchFn,
meta: this.meta
};
if ((_this$options$behavio = this.options.behavior) == null ? void 0 : _this$options$behavio.onFetch) {
var _this$options$behavio2;
(_this$options$behavio2 = this.options.behavior) == null ? void 0 : _this$options$behavio2.onFetch(context);
}
this.revertState = this.state;
if (!this.state.isFetching || this.state.fetchMeta !== ((_context$fetchOptions = context.fetchOptions) == null ? void 0 : _context$fetchOptions.meta)) {
var _context$fetchOptions2;
this.dispatch({
type: "fetch",
meta: (_context$fetchOptions2 = context.fetchOptions) == null ? void 0 : _context$fetchOptions2.meta
});
}
this.retryer = new Retryer({
fn: context.fetchFn,
abort: abortController == null ? void 0 : (_abortController$abor = abortController.abort) == null ? void 0 : _abortController$abor.bind(abortController),
onSuccess: function onSuccess(data) {
_this2.setData(data);
_this2.cache.config.onSuccess == null ? void 0 : _this2.cache.config.onSuccess(data, _this2);
if (_this2.cacheTime === 0) {
_this2.optionalRemove();
}
},
onError: function onError(error) {
if (!(isCancelledError(error) && error.silent)) {
_this2.dispatch({
type: "error",
error
});
}
if (!isCancelledError(error)) {
_this2.cache.config.onError == null ? void 0 : _this2.cache.config.onError(error, _this2);
getLogger().error(error);
}
if (_this2.cacheTime === 0) {
_this2.optionalRemove();
}
},
onFail: function onFail() {
_this2.dispatch({
type: "failed"
});
},
onPause: function onPause() {
_this2.dispatch({
type: "pause"
});
},
onContinue: function onContinue() {
_this2.dispatch({
type: "continue"
});
},
retry: context.options.retry,
retryDelay: context.options.retryDelay
});
this.promise = this.retryer.promise;
return this.promise;
};
_proto.dispatch = function dispatch(action) {
var _this3 = this;
this.state = this.reducer(this.state, action);
notifyManager.batch(function() {
_this3.observers.forEach(function(observer) {
observer.onQueryUpdate(action);
});
_this3.cache.notify({
query: _this3,
type: "queryUpdated",
action
});
});
};
_proto.getDefaultState = function getDefaultState2(options) {
var data = typeof options.initialData === "function" ? options.initialData() : options.initialData;
var hasInitialData = typeof options.initialData !== "undefined";
var initialDataUpdatedAt = hasInitialData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
var hasData = typeof data !== "undefined";
return {
data,
dataUpdateCount: 0,
dataUpdatedAt: hasData ? initialDataUpdatedAt != null ? initialDataUpdatedAt : Date.now() : 0,
error: null,
errorUpdateCount: 0,
errorUpdatedAt: 0,
fetchFailureCount: 0,
fetchMeta: null,
isFetching: false,
isInvalidated: false,
isPaused: false,
status: hasData ? "success" : "idle"
};
};
_proto.reducer = function reducer2(state, action) {
var _action$meta, _action$dataUpdatedAt;
switch (action.type) {
case "failed":
return _extends$5({}, state, {
fetchFailureCount: state.fetchFailureCount + 1
});
case "pause":
return _extends$5({}, state, {
isPaused: true
});
case "continue":
return _extends$5({}, state, {
isPaused: false
});
case "fetch":
return _extends$5({}, state, {
fetchFailureCount: 0,
fetchMeta: (_action$meta = action.meta) != null ? _action$meta : null,
isFetching: true,
isPaused: false
}, !state.dataUpdatedAt && {
error: null,
status: "loading"
});
case "success":
return _extends$5({}, state, {
data: action.data,
dataUpdateCount: state.dataUpdateCount + 1,
dataUpdatedAt: (_action$dataUpdatedAt = action.dataUpdatedAt) != null ? _action$dataUpdatedAt : Date.now(),
error: null,
fetchFailureCount: 0,
isFetching: false,
isInvalidated: false,
isPaused: false,
status: "success"
});
case "error":
var error = action.error;
if (isCancelledError(error) && error.revert && this.revertState) {
return _extends$5({}, this.revertState);
}
return _extends$5({}, state, {
error,
errorUpdateCount: state.errorUpdateCount + 1,
errorUpdatedAt: Date.now(),
fetchFailureCount: state.fetchFailureCount + 1,
isFetching: false,
isPaused: false,
status: "error"
});
case "invalidate":
return _extends$5({}, state, {
isInvalidated: true
});
case "setState":
return _extends$5({}, state, action.state);
default:
return state;
}
};
return Query2;
}();
var QueryCache = /* @__PURE__ */ function(_Subscribable) {
_inheritsLoose(QueryCache2, _Subscribable);
function QueryCache2(config) {
var _this;
_this = _Subscribable.call(this) || this;
_this.config = config || {};
_this.queries = [];
_this.queriesMap = {};
return _this;
}
var _proto = QueryCache2.prototype;
_proto.build = function build(client, options, state) {
var _options$queryHash;
var queryKey = options.queryKey;
var queryHash = (_options$queryHash = options.queryHash) != null ? _options$queryHash : hashQueryKeyByOptions(queryKey, options);
var query = this.get(queryHash);
if (!query) {
query = new Query({
cache: this,
queryKey,
queryHash,
options: client.defaultQueryOptions(options),
state,
defaultOptions: client.getQueryDefaults(queryKey),
meta: options.meta
});
this.add(query);
}
return query;
};
_proto.add = function add(query) {
if (!this.queriesMap[query.queryHash]) {
this.queriesMap[query.queryHash] = query;
this.queries.push(query);
this.notify({
type: "queryAdded",
query
});
}
};
_proto.remove = function remove(query) {
var queryInMap = this.queriesMap[query.queryHash];
if (queryInMap) {
query.destroy();
this.queries = this.queries.filter(function(x) {
return x !== query;
});
if (queryInMap === query) {
delete this.queriesMap[query.queryHash];
}
this.notify({
type: "queryRemoved",
query
});
}
};
_proto.clear = function clear() {
var _this2 = this;
notifyManager.batch(function() {
_this2.queries.forEach(function(query) {
_this2.remove(query);
});
});
};
_proto.get = function get2(queryHash) {
return this.queriesMap[queryHash];
};
_proto.getAll = function getAll() {
return this.queries;
};
_proto.find = function find(arg1, arg2) {
var _parseFilterArgs = parseFilterArgs(arg1, arg2), filters = _parseFilterArgs[0];
if (typeof filters.exact === "undefined") {
filters.exact = true;
}
return this.queries.find(function(query) {
return matchQuery(filters, query);
});
};
_proto.findAll = function findAll(arg1, arg2) {
var _parseFilterArgs2 = parseFilterArgs(arg1, arg2), filters = _parseFilterArgs2[0];
return Object.keys(filters).length > 0 ? this.queries.filter(function(query) {
return matchQuery(filters, query);
}) : this.queries;
};
_proto.notify = function notify(event) {
var _this3 = this;
notifyManager.batch(function() {
_this3.listeners.forEach(function(listener) {
listener(event);
});
});
};
_proto.onFocus = function onFocus() {
var _this4 = this;
notifyManager.batch(function() {
_this4.queries.forEach(function(query) {
query.onFocus();
});
});
};
_proto.onOnline = function onOnline() {
var _this5 = this;
notifyManager.batch(function() {
_this5.queries.forEach(function(query) {
query.onOnline();
});
});
};
return QueryCache2;
}(Subscribable);
var Mutation = /* @__PURE__ */ function() {
function Mutation2(config) {
this.options = _extends$5({}, config.defaultOptions, config.options);
this.mutationId = config.mutationId;
this.mutationCache = config.mutationCache;
this.observers = [];
this.state = config.state || getDefaultState();
this.meta = config.meta;
}
var _proto = Mutation2.prototype;
_proto.setState = function setState(state) {
this.dispatch({
type: "setState",
state
});
};
_proto.addObserver = function addObserver(observer) {
if (this.observers.indexOf(observer) === -1) {
this.observers.push(observer);
}
};
_proto.removeObserver = function removeObserver(observer) {
this.observers = this.observers.filter(function(x) {
return x !== observer;
});
};
_proto.cancel = function cancel() {
if (this.retryer) {
this.retryer.cancel();
return this.retryer.promise.then(noop).catch(noop);
}
return Promise.resolve();
};
_proto.continue = function _continue() {
if (this.retryer) {
this.retryer.continue();
return this.retryer.promise;
}
return this.execute();
};
_proto.execute = function execute() {
var _this = this;
var data;
var restored = this.state.status === "loading";
var promise = Promise.resolve();
if (!restored) {
this.dispatch({
type: "loading",
variables: this.options.variables
});
promise = promise.then(function() {
_this.mutationCache.config.onMutate == null ? void 0 : _this.mutationCache.config.onMutate(_this.state.variables, _this);
}).then(function() {
return _this.options.onMutate == null ? void 0 : _this.options.onMutate(_this.state.variables);
}).then(function(context) {
if (context !== _this.state.context) {
_this.dispatch({
type: "loading",
context,
variables: _this.state.variables
});
}
});
}
return promise.then(function() {
return _this.executeMutation();
}).then(function(result) {
data = result;
_this.mutationCache.config.onSuccess == null ? void 0 : _this.mutationCache.config.onSuccess(data, _this.state.variables, _this.state.context, _this);
}).then(function() {
return _this.options.onSuccess == null ? void 0 : _this.options.onSuccess(data, _this.state.variables, _this.state.context);
}).then(function() {
return _this.options.onSettled == null ? void 0 : _this.options.onSettled(data, null, _this.state.variables, _this.state.context);
}).then(function() {
_this.dispatch({
type: "success",
data
});
return data;
}).catch(function(error) {
_this.mutationCache.config.onError == null ? void 0 : _this.mutationCache.config.onError(error, _this.state.variables, _this.state.context, _this);
getLogger().error(error);
return Promise.resolve().then(function() {
return _this.options.onError == null ? void 0 : _this.options.onError(error, _this.state.variables, _this.state.context);
}).then(function() {
return _this.options.onSettled == null ? void 0 : _this.options.onSettled(void 0, error, _this.state.variables, _this.state.context);
}).then(function() {
_this.dispatch({
type: "error",
error
});
throw error;
});
});
};
_proto.executeMutation = function executeMutation() {
var _this2 = this, _this$options$retry;
this.retryer = new Retryer({
fn: function fn() {
if (!_this2.options.mutationFn) {
return Promise.reject("No mutationFn found");
}
return _this2.options.mutationFn(_this2.state.variables);
},
onFail: function onFail() {
_this2.dispatch({
type: "failed"
});
},
onPause: function onPause() {
_this2.dispatch({
type: "pause"
});
},
onContinue: function onContinue() {
_this2.dispatch({
type: "continue"
});
},
retry: (_this$options$retry = this.options.retry) != null ? _this$options$retry : 0,
retryDelay: this.options.retryDelay
});
return this.retryer.promise;
};
_proto.dispatch = function dispatch(action) {
var _this3 = this;
this.state = reducer(this.state, action);
notifyManager.batch(function() {
_this3.observers.forEach(function(observer) {
observer.onMutationUpdate(action);
});
_this3.mutationCache.notify(_this3);
});
};
return Mutation2;
}();
function getDefaultState() {
return {
context: void 0,
data: void 0,
error: null,
failureCount: 0,
isPaused: false,
status: "idle",
variables: void 0
};
}
function reducer(state, action) {
switch (action.type) {
case "failed":
return _extends$5({}, state, {
failureCount: state.failureCount + 1
});
case "pause":
return _extends$5({}, state, {
isPaused: true
});
case "continue":
return _extends$5({}, state, {
isPaused: false
});
case "loading":
return _extends$5({}, state, {
context: action.context,
data: void 0,
error: null,
isPaused: false,
status: "loading",
variables: action.variables
});
case "success":
return _extends$5({}, state, {
data: action.data,
error: null,
status: "success",
isPaused: false
});
case "error":
return _extends$5({}, state, {
data: void 0,
error: action.error,
failureCount: state.failureCount + 1,
isPaused: false,
status: "error"
});
case "setState":
return _extends$5({}, state, action.state);
default:
return state;
}
}
var MutationCache = /* @__PURE__ */ function(_Subscribable) {
_inheritsLoose(MutationCache2, _Subscribable);
function MutationCache2(config) {
var _this;
_this = _Subscribable.call(this) || this;
_this.config = config || {};
_this.mutations = [];
_this.mutationId = 0;
return _this;
}
var _proto = MutationCache2.prototype;
_proto.build = function build(client, options, state) {
var mutation = new Mutation({
mutationCache: this,
mutationId: ++this.mutationId,
options: client.defaultMutationOptions(options),
state,
defaultOptions: options.mutationKey ? client.getMutationDefaults(options.mutationKey) : void 0,
meta: options.meta
});
this.add(mutation);
return mutation;
};
_proto.add = function add(mutation) {
this.mutations.push(mutation);
this.notify(mutation);
};
_proto.remove = function remove(mutation) {
this.mutations = this.mutations.filter(function(x) {
return x !== mutation;
});
mutation.cancel();
this.notify(mutation);
};
_proto.clear = function clear() {
var _this2 = this;
notifyManager.batch(function() {
_this2.mutations.forEach(function(mutation) {
_this2.remove(mutation);
});
});
};
_proto.getAll = function getAll() {
return this.mutations;
};
_proto.find = function find(filters) {
if (typeof filters.exact === "undefined") {
filters.exact = true;
}
return this.mutations.find(function(mutation) {
return matchMutation(filters, mutation);
});
};
_proto.findAll = function findAll(filters) {
return this.mutations.filter(function(mutation) {
return matchMutation(filters, mutation);
});
};
_proto.notify = function notify(mutation) {
var _this3 = this;
notifyManager.batch(function() {
_this3.listeners.forEach(function(listener) {
listener(mutation);
});
});
};
_proto.onFocus = function onFocus() {
this.resumePausedMutations();
};
_proto.onOnline = function onOnline() {
this.resumePausedMutations();
};
_proto.resumePausedMutations = function resumePausedMutations() {
var pausedMutations = this.mutations.filter(function(x) {
return x.state.isPaused;
});
return notifyManager.batch(function() {
return pausedMutations.reduce(function(promise, mutation) {
return promise.then(function() {
return mutation.continue().catch(noop);
});
}, Promise.resolve());
});
};
return MutationCache2;
}(Subscribable);
function infiniteQueryBehavior() {
return {
onFetch: function onFetch(context) {
context.fetchFn = function() {
var _context$fetchOptions, _context$fetchOptions2, _context$fetchOptions3, _context$fetchOptions4, _context$state$data, _context$state$data2;
var refetchPage = (_context$fetchOptions = context.fetchOptions) == null ? void 0 : (_context$fetchOptions2 = _context$fetchOptions.meta) == null ? void 0 : _context$fetchOptions2.refetchPage;
var fetchMore = (_context$fetchOptions3 = context.fetchOptions) == null ? void 0 : (_context$fetchOptions4 = _context$fetchOptions3.meta) == null ? void 0 : _context$fetchOptions4.fetchMore;
var pageParam = fetchMore == null ? void 0 : fetchMore.pageParam;
var isFetchingNextPage = (fetchMore == null ? void 0 : fetchMore.direction) === "forward";
var isFetchingPreviousPage = (fetchMore == null ? void 0 : fetchMore.direction) === "backward";
var oldPages = ((_context$state$data = context.state.data) == null ? void 0 : _context$state$data.pages) || [];
var oldPageParams = ((_context$state$data2 = context.state.data) == null ? void 0 : _context$state$data2.pageParams) || [];
var abortController = getAbortController();
var abortSignal = abortController == null ? void 0 : abortController.signal;
var newPageParams = oldPageParams;
var cancelled = false;
var queryFn = context.options.queryFn || function() {
return Promise.reject("Missing queryFn");
};
var buildNewPages = function buildNewPages2(pages, param2, page, previous) {
newPageParams = previous ? [param2].concat(newPageParams) : [].concat(newPageParams, [param2]);
return previous ? [page].concat(pages) : [].concat(pages, [page]);
};
var fetchPage = function fetchPage2(pages, manual2, param2, previous) {
if (cancelled) {
return Promise.reject("Cancelled");
}
if (typeof param2 === "undefined" && !manual2 && pages.length) {
return Promise.resolve(pages);
}
var queryFnContext = {
queryKey: context.queryKey,
signal: abortSignal,
pageParam: param2,
meta: context.meta
};
var queryFnResult = queryFn(queryFnContext);
var promise2 = Promise.resolve(queryFnResult).then(function(page) {
return buildNewPages(pages, param2, page, previous);
});
if (isCancelable(queryFnResult)) {
var promiseAsAny = promise2;
promiseAsAny.cancel = queryFnResult.cancel;
}
return promise2;
};
var promise;
if (!oldPages.length) {
promise = fetchPage([]);
} else if (isFetchingNextPage) {
var manual = typeof pageParam !== "undefined";
var param = manual ? pageParam : getNextPageParam(context.options, oldPages);
promise = fetchPage(oldPages, manual, param);
} else if (isFetchingPreviousPage) {
var _manual = typeof pageParam !== "undefined";
var _param = _manual ? pageParam : getPreviousPageParam(context.options, oldPages);
promise = fetchPage(oldPages, _manual, _param, true);
} else {
(function() {
newPageParams = [];
var manual2 = typeof context.options.getNextPageParam === "undefined";
var shouldFetchFirstPage = refetchPage && oldPages[0] ? refetchPage(oldPages[0], 0, oldPages) : true;
promise = shouldFetchFirstPage ? fetchPage([], manual2, oldPageParams[0]) : Promise.resolve(buildNewPages([], oldPageParams[0], oldPages[0]));
var _loop = function _loop2(i2) {
promise = promise.then(function(pages) {
var shouldFetchNextPage = refetchPage && oldPages[i2] ? refetchPage(oldPages[i2], i2, oldPages) : true;
if (shouldFetchNextPage) {
var _param2 = manual2 ? oldPageParams[i2] : getNextPageParam(context.options, pages);
return fetchPage(pages, manual2, _param2);
}
return Promise.resolve(buildNewPages(pages, oldPageParams[i2], oldPages[i2]));
});
};
for (var i = 1; i < oldPages.length; i++) {
_loop(i);
}
})();
}
var finalPromise = promise.then(function(pages) {
return {
pages,
pageParams: newPageParams
};
});
var finalPromiseAsAny = finalPromise;
finalPromiseAsAny.cancel = function() {
cancelled = true;
abortController == null ? void 0 : abortController.abort();
if (isCancelable(promise)) {
promise.cancel();
}
};
return finalPromise;
};
}
};
}
function getNextPageParam(options, pages) {
return options.getNextPageParam == null ? void 0 : options.getNextPageParam(pages[pages.length - 1], pages);
}
function getPreviousPageParam(options, pages) {
return options.getPreviousPageParam == null ? void 0 : options.getPreviousPageParam(pages[0], pages);
}
function hasNextPage(options, pages) {
if (options.getNextPageParam && Array.isArray(pages)) {
var nextPageParam = getNextPageParam(options, pages);
return typeof nextPageParam !== "undefined" && nextPageParam !== null && nextPageParam !== false;
}
}
function hasPreviousPage(options, pages) {
if (options.getPreviousPageParam && Array.isArray(pages)) {
var previousPageParam = getPreviousPageParam(options, pages);
return typeof previousPageParam !== "undefined" && previousPageParam !== null && previousPageParam !== false;
}
}
var QueryClient = /* @__PURE__ */ function() {
function QueryClient2(config) {
if (config === void 0) {
config = {};
}
this.queryCache = config.queryCache || new QueryCache();
this.mutationCache = config.mutationCache || new MutationCache();
this.defaultOptions = config.defaultOptions || {};
this.queryDefaults = [];
this.mutationDefaults = [];
}
var _proto = QueryClient2.prototype;
_proto.mount = function mount() {
var _this = this;
this.unsubscribeFocus = focusManager.subscribe(function() {
if (focusManager.isFocused() && onlineManager.isOnline()) {
_this.mutationCache.onFocus();
_this.queryCache.onFocus();
}
});
this.unsubscribeOnline = onlineManager.subscribe(function() {
if (focusManager.isFocused() && onlineManager.isOnline()) {
_this.mutationCache.onOnline();
_this.queryCache.onOnline();
}
});
};
_proto.unmount = function unmount() {
var _this$unsubscribeFocu, _this$unsubscribeOnli;
(_this$unsubscribeFocu = this.unsubscribeFocus) == null ? void 0 : _this$unsubscribeFocu.call(this);
(_this$unsubscribeOnli = this.unsubscribeOnline) == null ? void 0 : _this$unsubscribeOnli.call(this);
};
_proto.isFetching = function isFetching(arg1, arg2) {
var _parseFilterArgs = parseFilterArgs(arg1, arg2), filters = _parseFilterArgs[0];
filters.fetching = true;
return this.queryCache.findAll(filters).length;
};
_proto.isMutating = function isMutating(filters) {
return this.mutationCache.findAll(_extends$5({}, filters, {
fetching: true
})).length;
};
_proto.getQueryData = function getQueryData(queryKey, filters) {
var _this$queryCache$find;
return (_this$queryCache$find = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find.state.data;
};
_proto.getQueriesData = function getQueriesData(queryKeyOrFilters) {
return this.getQueryCache().findAll(queryKeyOrFilters).map(function(_ref) {
var queryKey = _ref.queryKey, state = _ref.state;
var data = state.data;