@hortiview/modulebase 1.1.0 → 1.1.1

package/dist/IsRestoringProvider-SzKJZczp.js

@@ -0,0 +1,931 @@
+import * as S from "react";
+import { jsx as H } from "react/jsx-runtime";
+var k = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(e) {
+    return this.listeners.add(e), this.onSubscribe(), () => {
+      this.listeners.delete(e), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+}, z = class extends k {
+  #e;
+  #t;
+  #r;
+  constructor() {
+    super(), this.#r = (e) => {
+      if (typeof window < "u" && window.addEventListener) {
+        const t = () => e();
+        return window.addEventListener("visibilitychange", t, !1), () => {
+          window.removeEventListener("visibilitychange", t);
+        };
+      }
+    };
+  }
+  onSubscribe() {
+    this.#t || this.setEventListener(this.#r);
+  }
+  onUnsubscribe() {
+    this.hasListeners() || (this.#t?.(), this.#t = void 0);
+  }
+  setEventListener(e) {
+    this.#r = e, this.#t?.(), this.#t = e((t) => {
+      typeof t == "boolean" ? this.setFocused(t) : this.onFocus();
+    });
+  }
+  setFocused(e) {
+    this.#e !== e && (this.#e = e, this.onFocus());
+  }
+  onFocus() {
+    const e = this.isFocused();
+    this.listeners.forEach((t) => {
+      t(e);
+    });
+  }
+  isFocused() {
+    return typeof this.#e == "boolean" ? this.#e : globalThis.document?.visibilityState !== "hidden";
+  }
+}, B = new z(), $ = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (e, t) => setTimeout(e, t),
+  clearTimeout: (e) => clearTimeout(e),
+  setInterval: (e, t) => setInterval(e, t),
+  clearInterval: (e) => clearInterval(e)
+}, J = class {
+  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+  // type at app boot; and if we leave that type, then any new timer provider
+  // would need to support the default provider's concrete timer ID, which is
+  // infeasible across environments.
+  //
+  // We settle for type safety for the TimeoutProvider type, and accept that
+  // this class is unsafe internally to allow for extension.
+  #e = $;
+  #t = !1;
+  setTimeoutProvider(e) {
+    process.env.NODE_ENV !== "production" && this.#t && e !== this.#e && console.error(
+      "[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.",
+      { previous: this.#e, provider: e }
+    ), this.#e = e, process.env.NODE_ENV !== "production" && (this.#t = !1);
+  }
+  setTimeout(e, t) {
+    return process.env.NODE_ENV !== "production" && (this.#t = !0), this.#e.setTimeout(e, t);
+  }
+  clearTimeout(e) {
+    this.#e.clearTimeout(e);
+  }
+  setInterval(e, t) {
+    return process.env.NODE_ENV !== "production" && (this.#t = !0), this.#e.setInterval(e, t);
+  }
+  clearInterval(e) {
+    this.#e.clearInterval(e);
+  }
+}, C = new J();
+function W(e) {
+  setTimeout(e, 0);
+}
+var Z = typeof window > "u" || "Deno" in globalThis;
+function P() {
+}
+function Se(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function X(e) {
+  return typeof e == "number" && e >= 0 && e !== 1 / 0;
+}
+function Y(e, t) {
+  return Math.max(e + (t || 0) - Date.now(), 0);
+}
+function ee(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function te(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Fe(e, t) {
+  const {
+    type: s = "all",
+    exact: r,
+    fetchStatus: i,
+    predicate: o,
+    queryKey: u,
+    stale: a
+  } = e;
+  if (u) {
+    if (r) {
+      if (t.queryHash !== se(u, t.options))
+        return !1;
+    } else if (!I(t.queryKey, u))
+      return !1;
+  }
+  if (s !== "all") {
+    const n = t.isActive();
+    if (s === "active" && !n || s === "inactive" && n)
+      return !1;
+  }
+  return !(typeof a == "boolean" && t.isStale() !== a || i && i !== t.state.fetchStatus || o && !o(t));
+}
+function we(e, t) {
+  const { exact: s, status: r, predicate: i, mutationKey: o } = e;
+  if (o) {
+    if (!t.options.mutationKey)
+      return !1;
+    if (s) {
+      if (O(t.options.mutationKey) !== O(o))
+        return !1;
+    } else if (!I(t.options.mutationKey, o))
+      return !1;
+  }
+  return !(r && t.state.status !== r || i && !i(t));
+}
+function se(e, t) {
+  return (t?.queryKeyHashFn || O)(e);
+}
+function O(e) {
+  return JSON.stringify(
+    e,
+    (t, s) => E(s) ? Object.keys(s).sort().reduce((r, i) => (r[i] = s[i], r), {}) : s
+  );
+}
+function I(e, t) {
+  return e === t ? !0 : typeof e != typeof t ? !1 : e && t && typeof e == "object" && typeof t == "object" ? Object.keys(t).every((s) => I(e[s], t[s])) : !1;
+}
+var re = Object.prototype.hasOwnProperty;
+function q(e, t, s = 0) {
+  if (e === t)
+    return e;
+  if (s > 500) return t;
+  const r = R(e) && R(t);
+  if (!r && !(E(e) && E(t))) return t;
+  const o = (r ? e : Object.keys(e)).length, u = r ? t : Object.keys(t), a = u.length, n = r ? new Array(a) : {};
+  let h = 0;
+  for (let f = 0; f < a; f++) {
+    const d = r ? f : u[f], y = e[d], v = t[d];
+    if (y === v) {
+      n[d] = y, (r ? f < o : re.call(e, d)) && h++;
+      continue;
+    }
+    if (y === null || v === null || typeof y != "object" || typeof v != "object") {
+      n[d] = v;
+      continue;
+    }
+    const l = q(y, v, s + 1);
+    n[d] = l, l === y && h++;
+  }
+  return o === a && h === o ? e : n;
+}
+function Pe(e, t) {
+  if (!t || Object.keys(e).length !== Object.keys(t).length)
+    return !1;
+  for (const s in e)
+    if (e[s] !== t[s])
+      return !1;
+  return !0;
+}
+function R(e) {
+  return Array.isArray(e) && e.length === Object.keys(e).length;
+}
+function E(e) {
+  if (!N(e))
+    return !1;
+  const t = e.constructor;
+  if (t === void 0)
+    return !0;
+  const s = t.prototype;
+  return !(!N(s) || !s.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(e) !== Object.prototype);
+}
+function N(e) {
+  return Object.prototype.toString.call(e) === "[object Object]";
+}
+function ne(e) {
+  return new Promise((t) => {
+    C.setTimeout(t, e);
+  });
+}
+function ie(e, t, s) {
+  if (typeof s.structuralSharing == "function")
+    return s.structuralSharing(e, t);
+  if (s.structuralSharing !== !1) {
+    if (process.env.NODE_ENV !== "production")
+      try {
+        return q(e, t);
+      } catch (r) {
+        throw console.error(
+          `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${s.queryHash}]: ${r}`
+        ), r;
+      }
+    return q(e, t);
+  }
+  return t;
+}
+function ae(e, t, s = 0) {
+  const r = [...e, t];
+  return s && r.length > s ? r.slice(1) : r;
+}
+function oe(e, t, s = 0) {
+  const r = [t, ...e];
+  return s && r.length > s ? r.slice(0, -1) : r;
+}
+var T = /* @__PURE__ */ Symbol();
+function K(e, t) {
+  return process.env.NODE_ENV !== "production" && e.queryFn === T && console.error(
+    `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${e.queryHash}'`
+  ), !e.queryFn && t?.initialPromise ? () => t.initialPromise : !e.queryFn || e.queryFn === T ? () => Promise.reject(new Error(`Missing queryFn: '${e.queryHash}'`)) : e.queryFn;
+}
+function Ce(e, t) {
+  return typeof e == "function" ? e(...t) : !!e;
+}
+function ue(e, t, s) {
+  let r = !1, i;
+  return Object.defineProperty(e, "signal", {
+    enumerable: !0,
+    get: () => (i ??= t(), r || (r = !0, i.aborted ? s() : i.addEventListener("abort", s, { once: !0 })), i)
+  }), e;
+}
+var Q = /* @__PURE__ */ (() => {
+  let e = () => Z;
+  return {
+    /**
+     * Returns whether the current runtime should be treated as a server environment.
+     */
+    isServer() {
+      return e();
+    },
+    /**
+     * Overrides the server check globally.
+     */
+    setIsServer(t) {
+      e = t;
+    }
+  };
+})();
+function ce() {
+  let e, t;
+  const s = new Promise((i, o) => {
+    e = i, t = o;
+  });
+  s.status = "pending", s.catch(() => {
+  });
+  function r(i) {
+    Object.assign(s, i), delete s.resolve, delete s.reject;
+  }
+  return s.resolve = (i) => {
+    r({
+      status: "fulfilled",
+      value: i
+    }), e(i);
+  }, s.reject = (i) => {
+    r({
+      status: "rejected",
+      reason: i
+    }), t(i);
+  }, s;
+}
+function Oe(e) {
+  let t;
+  if (e.then((s) => (t = s, s), P)?.catch(P), t !== void 0)
+    return { data: t };
+}
+var le = W;
+function he() {
+  let e = [], t = 0, s = (a) => {
+    a();
+  }, r = (a) => {
+    a();
+  }, i = le;
+  const o = (a) => {
+    t ? e.push(a) : i(() => {
+      s(a);
+    });
+  }, u = () => {
+    const a = e;
+    e = [], a.length && i(() => {
+      r(() => {
+        a.forEach((n) => {
+          s(n);
+        });
+      });
+    });
+  };
+  return {
+    batch: (a) => {
+      let n;
+      t++;
+      try {
+        n = a();
+      } finally {
+        t--, t || u();
+      }
+      return n;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (a) => (...n) => {
+      o(() => {
+        a(...n);
+      });
+    },
+    schedule: o,
+    /**
+     * 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: (a) => {
+      s = a;
+    },
+    /**
+     * 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: (a) => {
+      r = a;
+    },
+    setScheduler: (a) => {
+      i = a;
+    }
+  };
+}
+var fe = he(), de = class extends k {
+  #e = !0;
+  #t;
+  #r;
+  constructor() {
+    super(), this.#r = (e) => {
+      if (typeof window < "u" && window.addEventListener) {
+        const t = () => e(!0), s = () => e(!1);
+        return window.addEventListener("online", t, !1), window.addEventListener("offline", s, !1), () => {
+          window.removeEventListener("online", t), window.removeEventListener("offline", s);
+        };
+      }
+    };
+  }
+  onSubscribe() {
+    this.#t || this.setEventListener(this.#r);
+  }
+  onUnsubscribe() {
+    this.hasListeners() || (this.#t?.(), this.#t = void 0);
+  }
+  setEventListener(e) {
+    this.#r = e, this.#t?.(), this.#t = e(this.setOnline.bind(this));
+  }
+  setOnline(e) {
+    this.#e !== e && (this.#e = e, this.listeners.forEach((s) => {
+      s(e);
+    }));
+  }
+  isOnline() {
+    return this.#e;
+  }
+}, L = new de();
+function ye(e) {
+  return Math.min(1e3 * 2 ** e, 3e4);
+}
+function x(e) {
+  return (e ?? "online") === "online" ? L.isOnline() : !0;
+}
+var j = class extends Error {
+  constructor(e) {
+    super("CancelledError"), this.revert = e?.revert, this.silent = e?.silent;
+  }
+};
+function pe(e) {
+  let t = !1, s = 0, r;
+  const i = ce(), o = () => i.status !== "pending", u = (c) => {
+    if (!o()) {
+      const p = new j(c);
+      y(p), e.onCancel?.(p);
+    }
+  }, a = () => {
+    t = !0;
+  }, n = () => {
+    t = !1;
+  }, h = () => B.isFocused() && (e.networkMode === "always" || L.isOnline()) && e.canRun(), f = () => x(e.networkMode) && e.canRun(), d = (c) => {
+    o() || (r?.(), i.resolve(c));
+  }, y = (c) => {
+    o() || (r?.(), i.reject(c));
+  }, v = () => new Promise((c) => {
+    r = (p) => {
+      (o() || h()) && c(p);
+    }, e.onPause?.();
+  }).then(() => {
+    r = void 0, o() || e.onContinue?.();
+  }), l = () => {
+    if (o())
+      return;
+    let c;
+    const p = s === 0 ? e.initialPromise : void 0;
+    try {
+      c = p ?? e.fn();
+    } catch (m) {
+      c = Promise.reject(m);
+    }
+    Promise.resolve(c).then(d).catch((m) => {
+      if (o())
+        return;
+      const g = e.retry ?? (Q.isServer() ? 0 : 3), b = e.retryDelay ?? ye, F = typeof b == "function" ? b(s, m) : b, w = g === !0 || typeof g == "number" && s < g || typeof g == "function" && g(s, m);
+      if (t || !w) {
+        y(m);
+        return;
+      }
+      s++, e.onFail?.(s, m), ne(F).then(() => h() ? void 0 : v()).then(() => {
+        t ? y(m) : l();
+      });
+    });
+  };
+  return {
+    promise: i,
+    status: () => i.status,
+    cancel: u,
+    continue: () => (r?.(), i),
+    cancelRetry: a,
+    continueRetry: n,
+    canStart: f,
+    start: () => (f() ? l() : v().then(l), i)
+  };
+}
+var ve = class {
+  #e;
+  destroy() {
+    this.clearGcTimeout();
+  }
+  scheduleGc() {
+    this.clearGcTimeout(), X(this.gcTime) && (this.#e = C.setTimeout(() => {
+      this.optionalRemove();
+    }, this.gcTime));
+  }
+  updateGcTime(e) {
+    this.gcTime = Math.max(
+      this.gcTime || 0,
+      e ?? (Q.isServer() ? 1 / 0 : 300 * 1e3)
+    );
+  }
+  clearGcTimeout() {
+    this.#e !== void 0 && (C.clearTimeout(this.#e), this.#e = void 0);
+  }
+};
+function me(e) {
+  return {
+    onFetch: (t, s) => {
+      const r = t.options, i = t.fetchOptions?.meta?.fetchMore?.direction, o = t.state.data?.pages || [], u = t.state.data?.pageParams || [];
+      let a = { pages: [], pageParams: [] }, n = 0;
+      const h = async () => {
+        let f = !1;
+        const d = (l) => {
+          ue(
+            l,
+            () => t.signal,
+            () => f = !0
+          );
+        }, y = K(t.options, t.fetchOptions), v = async (l, c, p) => {
+          if (f)
+            return Promise.reject(t.signal.reason);
+          if (c == null && l.pages.length)
+            return Promise.resolve(l);
+          const g = (() => {
+            const A = {
+              client: t.client,
+              queryKey: t.queryKey,
+              pageParam: c,
+              direction: p ? "backward" : "forward",
+              meta: t.options.meta
+            };
+            return d(A), A;
+          })(), b = await y(g), { maxPages: F } = t.options, w = p ? oe : ae;
+          return {
+            pages: w(l.pages, b, F),
+            pageParams: w(l.pageParams, c, F)
+          };
+        };
+        if (i && o.length) {
+          const l = i === "backward", c = l ? _ : D, p = {
+            pages: o,
+            pageParams: u
+          }, m = c(r, p);
+          a = await v(p, m, l);
+        } else {
+          const l = e ?? o.length;
+          do {
+            const c = n === 0 ? u[0] ?? r.initialPageParam : D(r, a);
+            if (n > 0 && c == null)
+              break;
+            a = await v(a, c), n++;
+          } while (n < l);
+        }
+        return a;
+      };
+      t.options.persister ? t.fetchFn = () => t.options.persister?.(
+        h,
+        {
+          client: t.client,
+          queryKey: t.queryKey,
+          meta: t.options.meta,
+          signal: t.signal
+        },
+        s
+      ) : t.fetchFn = h;
+    }
+  };
+}
+function D(e, { pages: t, pageParams: s }) {
+  const r = t.length - 1;
+  return t.length > 0 ? e.getNextPageParam(
+    t[r],
+    t,
+    s[r],
+    s
+  ) : void 0;
+}
+function _(e, { pages: t, pageParams: s }) {
+  return t.length > 0 ? e.getPreviousPageParam?.(t[0], t, s[0], s) : void 0;
+}
+function qe(e, t) {
+  return t ? D(e, t) != null : !1;
+}
+function Ee(e, t) {
+  return !t || !e.getPreviousPageParam ? !1 : _(e, t) != null;
+}
+var Te = class extends ve {
+  #e;
+  #t;
+  #r;
+  #n;
+  #a;
+  #s;
+  #u;
+  #o;
+  constructor(e) {
+    super(), this.#o = !1, this.#u = e.defaultOptions, this.setOptions(e.options), this.observers = [], this.#a = e.client, this.#n = this.#a.getQueryCache(), this.queryKey = e.queryKey, this.queryHash = e.queryHash, this.#t = M(this.options), this.state = e.state ?? this.#t, this.scheduleGc();
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  get queryType() {
+    return this.#e;
+  }
+  get promise() {
+    return this.#s?.promise;
+  }
+  setOptions(e) {
+    if (this.options = { ...this.#u, ...e }, e?._type && (this.#e = e._type), this.updateGcTime(this.options.gcTime), this.state && this.state.data === void 0) {
+      const t = M(this.options);
+      t.data !== void 0 && (this.setState(
+        U(t.data, t.dataUpdatedAt)
+      ), this.#t = t);
+    }
+  }
+  optionalRemove() {
+    !this.observers.length && this.state.fetchStatus === "idle" && this.#n.remove(this);
+  }
+  setData(e, t) {
+    const s = ie(this.state.data, e, this.options);
+    return this.#i({
+      data: s,
+      type: "success",
+      dataUpdatedAt: t?.updatedAt,
+      manual: t?.manual
+    }), s;
+  }
+  setState(e) {
+    this.#i({ type: "setState", state: e });
+  }
+  cancel(e) {
+    const t = this.#s?.promise;
+    return this.#s?.cancel(e), t ? t.then(P).catch(P) : Promise.resolve();
+  }
+  destroy() {
+    super.destroy(), this.cancel({ silent: !0 });
+  }
+  get resetState() {
+    return this.#t;
+  }
+  reset() {
+    this.destroy(), this.setState(this.resetState);
+  }
+  isActive() {
+    return this.observers.some(
+      (e) => te(e.options.enabled, this) !== !1
+    );
+  }
+  isDisabled() {
+    return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === T || !this.isFetched();
+  }
+  isFetched() {
+    return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
+  }
+  isStatic() {
+    return this.getObserversCount() > 0 ? this.observers.some(
+      (e) => ee(e.options.staleTime, this) === "static"
+    ) : !1;
+  }
+  isStale() {
+    return this.getObserversCount() > 0 ? this.observers.some(
+      (e) => e.getCurrentResult().isStale
+    ) : this.state.data === void 0 || this.state.isInvalidated;
+  }
+  isStaleByTime(e = 0) {
+    return this.state.data === void 0 ? !0 : e === "static" ? !1 : this.state.isInvalidated ? !0 : !Y(this.state.dataUpdatedAt, e);
+  }
+  onFocus() {
+    this.observers.find((t) => t.shouldFetchOnWindowFocus())?.refetch({ cancelRefetch: !1 }), this.#s?.continue();
+  }
+  onOnline() {
+    this.observers.find((t) => t.shouldFetchOnReconnect())?.refetch({ cancelRefetch: !1 }), this.#s?.continue();
+  }
+  addObserver(e) {
+    this.observers.includes(e) || (this.observers.push(e), this.clearGcTimeout(), this.#n.notify({ type: "observerAdded", query: this, observer: e }));
+  }
+  removeObserver(e) {
+    this.observers.includes(e) && (this.observers = this.observers.filter((t) => t !== e), this.observers.length || (this.#s && (this.#o || this.#c() ? this.#s.cancel({ revert: !0 }) : this.#s.cancelRetry()), this.scheduleGc()), this.#n.notify({ type: "observerRemoved", query: this, observer: e }));
+  }
+  getObserversCount() {
+    return this.observers.length;
+  }
+  #c() {
+    return this.state.fetchStatus === "paused" && this.state.status === "pending";
+  }
+  invalidate() {
+    this.state.isInvalidated || this.#i({ type: "invalidate" });
+  }
+  async fetch(e, t) {
+    if (this.state.fetchStatus !== "idle" && // If the promise in the retryer is already rejected, we have to definitely
+    // re-start the fetch; there is a chance that the query is still in a
+    // pending state when that happens
+    this.#s?.status() !== "rejected") {
+      if (this.state.data !== void 0 && t?.cancelRefetch)
+        this.cancel({ silent: !0 });
+      else if (this.#s)
+        return this.#s.continueRetry(), this.#s.promise;
+    }
+    if (e && this.setOptions(e), !this.options.queryFn) {
+      const n = this.observers.find((h) => h.options.queryFn);
+      n && this.setOptions(n.options);
+    }
+    process.env.NODE_ENV !== "production" && (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 s = new AbortController(), r = (n) => {
+      Object.defineProperty(n, "signal", {
+        enumerable: !0,
+        get: () => (this.#o = !0, s.signal)
+      });
+    }, i = () => {
+      const n = K(this.options, t), f = (() => {
+        const d = {
+          client: this.#a,
+          queryKey: this.queryKey,
+          meta: this.meta
+        };
+        return r(d), d;
+      })();
+      return this.#o = !1, this.options.persister ? this.options.persister(
+        n,
+        f,
+        this
+      ) : n(f);
+    }, u = (() => {
+      const n = {
+        fetchOptions: t,
+        options: this.options,
+        queryKey: this.queryKey,
+        client: this.#a,
+        state: this.state,
+        fetchFn: i
+      };
+      return r(n), n;
+    })();
+    (this.#e === "infinite" ? me(
+      this.options.pages
+    ) : this.options.behavior)?.onFetch(u, this), this.#r = this.state, (this.state.fetchStatus === "idle" || this.state.fetchMeta !== u.fetchOptions?.meta) && this.#i({ type: "fetch", meta: u.fetchOptions?.meta }), this.#s = pe({
+      initialPromise: t?.initialPromise,
+      fn: u.fetchFn,
+      onCancel: (n) => {
+        n instanceof j && n.revert && this.setState({
+          ...this.#r,
+          fetchStatus: "idle"
+        }), s.abort();
+      },
+      onFail: (n, h) => {
+        this.#i({ type: "failed", failureCount: n, error: h });
+      },
+      onPause: () => {
+        this.#i({ type: "pause" });
+      },
+      onContinue: () => {
+        this.#i({ type: "continue" });
+      },
+      retry: u.options.retry,
+      retryDelay: u.options.retryDelay,
+      networkMode: u.options.networkMode,
+      canRun: () => !0
+    });
+    try {
+      const n = await this.#s.start();
+      if (n === void 0)
+        throw process.env.NODE_ENV !== "production" && 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}`
+        ), new Error(`${this.queryHash} data is undefined`);
+      return this.setData(n), this.#n.config.onSuccess?.(n, this), this.#n.config.onSettled?.(
+        n,
+        this.state.error,
+        this
+      ), n;
+    } catch (n) {
+      if (n instanceof j) {
+        if (n.silent)
+          return this.#s.promise;
+        if (n.revert) {
+          if (this.state.data === void 0)
+            throw n;
+          return this.state.data;
+        }
+      }
+      throw this.#i({
+        type: "error",
+        error: n
+      }), this.#n.config.onError?.(
+        n,
+        this
+      ), this.#n.config.onSettled?.(
+        this.state.data,
+        n,
+        this
+      ), n;
+    } finally {
+      this.scheduleGc();
+    }
+  }
+  #i(e) {
+    const t = (s) => {
+      switch (e.type) {
+        case "failed":
+          return {
+            ...s,
+            fetchFailureCount: e.failureCount,
+            fetchFailureReason: e.error
+          };
+        case "pause":
+          return {
+            ...s,
+            fetchStatus: "paused"
+          };
+        case "continue":
+          return {
+            ...s,
+            fetchStatus: "fetching"
+          };
+        case "fetch":
+          return {
+            ...s,
+            ...ge(s.data, this.options),
+            fetchMeta: e.meta ?? null
+          };
+        case "success":
+          const r = {
+            ...s,
+            ...U(e.data, e.dataUpdatedAt),
+            dataUpdateCount: s.dataUpdateCount + 1,
+            ...!e.manual && {
+              fetchStatus: "idle",
+              fetchFailureCount: 0,
+              fetchFailureReason: null
+            }
+          };
+          return this.#r = e.manual ? r : void 0, r;
+        case "error":
+          const i = e.error;
+          return {
+            ...s,
+            error: i,
+            errorUpdateCount: s.errorUpdateCount + 1,
+            errorUpdatedAt: Date.now(),
+            fetchFailureCount: s.fetchFailureCount + 1,
+            fetchFailureReason: i,
+            fetchStatus: "idle",
+            status: "error",
+            // flag existing data as invalidated if we get a background error
+            // note that "no data" always means stale so we can set unconditionally here
+            isInvalidated: !0
+          };
+        case "invalidate":
+          return {
+            ...s,
+            isInvalidated: !0
+          };
+        case "setState":
+          return {
+            ...s,
+            ...e.state
+          };
+      }
+    };
+    this.state = t(this.state), fe.batch(() => {
+      this.observers.forEach((s) => {
+        s.onQueryUpdate();
+      }), this.#n.notify({ query: this, type: "updated", action: e });
+    });
+  }
+};
+function ge(e, t) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: x(t.networkMode) ? "fetching" : "paused",
+    ...e === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+function U(e, t) {
+  return {
+    data: e,
+    dataUpdatedAt: t ?? Date.now(),
+    error: null,
+    isInvalidated: !1,
+    status: "success"
+  };
+}
+function M(e) {
+  const t = typeof e.initialData == "function" ? e.initialData() : e.initialData, s = t !== void 0, r = s ? typeof e.initialDataUpdatedAt == "function" ? e.initialDataUpdatedAt() : e.initialDataUpdatedAt : 0;
+  return {
+    data: t,
+    dataUpdateCount: 0,
+    dataUpdatedAt: s ? r ?? Date.now() : 0,
+    error: null,
+    errorUpdateCount: 0,
+    errorUpdatedAt: 0,
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchMeta: null,
+    isInvalidated: !1,
+    status: s ? "success" : "pending",
+    fetchStatus: "idle"
+  };
+}
+var G = S.createContext(
+  void 0
+), je = (e) => {
+  const t = S.useContext(G);
+  if (e)
+    return e;
+  if (!t)
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  return t;
+}, De = ({
+  client: e,
+  children: t
+}) => (S.useEffect(() => (e.mount(), () => {
+  e.unmount();
+}), [e]), /* @__PURE__ */ H(G.Provider, { value: e, children: t })), V = S.createContext(!1), Ie = () => S.useContext(V), Ae = V.Provider;
+export {
+  I as A,
+  T as B,
+  De as C,
+  Ae as I,
+  Te as Q,
+  ve as R,
+  k as S,
+  qe as a,
+  O as b,
+  P as c,
+  Ce as d,
+  ee as e,
+  Q as f,
+  C as g,
+  Ee as h,
+  X as i,
+  B as j,
+  ge as k,
+  ie as l,
+  Ie as m,
+  fe as n,
+  Oe as o,
+  ce as p,
+  pe as q,
+  te as r,
+  Pe as s,
+  Y as t,
+  je as u,
+  we as v,
+  se as w,
+  Fe as x,
+  L as y,
+  Se as z
+};