@ram_28/kf-ai-sdk 1.0.11 → 1.0.13

package/dist/useQuery-KpZFg80c.js

@@ -0,0 +1,748 @@
+var Re = (t) => {
+  throw TypeError(t);
+};
+var oe = (t, e, s) => e.has(t) || Re("Cannot " + s);
+var r = (t, e, s) => (oe(t, e, "read from private field"), s ? s.call(t) : e.get(t)), d = (t, e, s) => e.has(t) ? Re("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, s), o = (t, e, s, i) => (oe(t, e, "write to private field"), i ? i.call(t, s) : e.set(t, s), s), y = (t, e, s) => (oe(t, e, "access private method"), s);
+import * as C from "react";
+import "./jsx-runtime-DGlMoOmv.js";
+var me = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(t) {
+    return this.listeners.add(t), this.onSubscribe(), () => {
+      this.listeners.delete(t), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+}, Ve = {
+  // 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: (t, e) => setTimeout(t, e),
+  clearTimeout: (t) => clearTimeout(t),
+  setInterval: (t, e) => setInterval(t, e),
+  clearInterval: (t) => clearInterval(t)
+}, T, j, Pe, ze = (Pe = class {
+  constructor() {
+    // 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 ReturnType<typeof setTimeout>, which is infeasible.
+    //
+    // We settle for type safety for the TimeoutProvider type, and accept that
+    // this class is unsafe internally to allow for extension.
+    d(this, T, Ve);
+    d(this, j, !1);
+  }
+  setTimeoutProvider(t) {
+    process.env.NODE_ENV !== "production" && r(this, j) && t !== r(this, T) && console.error(
+      "[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.",
+      { previous: r(this, T), provider: t }
+    ), o(this, T, t), process.env.NODE_ENV !== "production" && o(this, j, !1);
+  }
+  setTimeout(t, e) {
+    return process.env.NODE_ENV !== "production" && o(this, j, !0), r(this, T).setTimeout(t, e);
+  }
+  clearTimeout(t) {
+    r(this, T).clearTimeout(t);
+  }
+  setInterval(t, e) {
+    return process.env.NODE_ENV !== "production" && o(this, j, !0), r(this, T).setInterval(t, e);
+  }
+  clearInterval(t) {
+    r(this, T).clearInterval(t);
+  }
+}, T = new WeakMap(), j = new WeakMap(), Pe), se = new ze();
+function Be(t) {
+  setTimeout(t, 0);
+}
+var Z = typeof window > "u" || "Deno" in globalThis;
+function ae() {
+}
+function Ce(t) {
+  return typeof t == "number" && t >= 0 && t !== 1 / 0;
+}
+function He(t, e) {
+  return Math.max(t + (e || 0) - Date.now(), 0);
+}
+function K(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function R(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function mt(t) {
+  return JSON.stringify(
+    t,
+    (e, s) => he(s) ? Object.keys(s).sort().reduce((i, n) => (i[n] = s[n], i), {}) : s
+  );
+}
+var qe = Object.prototype.hasOwnProperty;
+function ce(t, e) {
+  if (t === e)
+    return t;
+  const s = Ie(t) && Ie(e);
+  if (!s && !(he(t) && he(e))) return e;
+  const n = (s ? t : Object.keys(t)).length, u = s ? e : Object.keys(e), h = u.length, a = s ? new Array(h) : {};
+  let v = 0;
+  for (let p = 0; p < h; p++) {
+    const g = s ? p : u[p], f = t[g], S = e[g];
+    if (f === S) {
+      a[g] = f, (s ? p < n : qe.call(t, g)) && v++;
+      continue;
+    }
+    if (f === null || S === null || typeof f != "object" || typeof S != "object") {
+      a[g] = S;
+      continue;
+    }
+    const b = ce(f, S);
+    a[g] = b, b === f && v++;
+  }
+  return n === h && v === n ? t : a;
+}
+function ue(t, e) {
+  if (!e || Object.keys(t).length !== Object.keys(e).length)
+    return !1;
+  for (const s in t)
+    if (t[s] !== e[s])
+      return !1;
+  return !0;
+}
+function Ie(t) {
+  return Array.isArray(t) && t.length === Object.keys(t).length;
+}
+function he(t) {
+  if (!Te(t))
+    return !1;
+  const e = t.constructor;
+  if (e === void 0)
+    return !0;
+  const s = e.prototype;
+  return !(!Te(s) || !s.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(t) !== Object.prototype);
+}
+function Te(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function Fe(t, e, s) {
+  if (typeof s.structuralSharing == "function")
+    return s.structuralSharing(t, e);
+  if (s.structuralSharing !== !1) {
+    if (process.env.NODE_ENV !== "production")
+      try {
+        return ce(t, e);
+      } catch (i) {
+        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}]: ${i}`
+        ), i;
+      }
+    return ce(t, e);
+  }
+  return e;
+}
+function Et(t) {
+  return t;
+}
+function De(t, e) {
+  return typeof t == "function" ? t(...e) : !!t;
+}
+var Q, M, A, je, Je = (je = class extends me {
+  constructor() {
+    super();
+    d(this, Q);
+    d(this, M);
+    d(this, A);
+    o(this, A, (e) => {
+      if (!Z && window.addEventListener) {
+        const s = () => e();
+        return window.addEventListener("visibilitychange", s, !1), () => {
+          window.removeEventListener("visibilitychange", s);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    r(this, M) || this.setEventListener(r(this, A));
+  }
+  onUnsubscribe() {
+    var e;
+    this.hasListeners() || ((e = r(this, M)) == null || e.call(this), o(this, M, void 0));
+  }
+  setEventListener(e) {
+    var s;
+    o(this, A, e), (s = r(this, M)) == null || s.call(this), o(this, M, e((i) => {
+      typeof i == "boolean" ? this.setFocused(i) : this.onFocus();
+    }));
+  }
+  setFocused(e) {
+    r(this, Q) !== e && (o(this, Q, e), this.onFocus());
+  }
+  onFocus() {
+    const e = this.isFocused();
+    this.listeners.forEach((s) => {
+      s(e);
+    });
+  }
+  isFocused() {
+    var e;
+    return typeof r(this, Q) == "boolean" ? r(this, Q) : ((e = globalThis.document) == null ? void 0 : e.visibilityState) !== "hidden";
+  }
+}, Q = new WeakMap(), M = new WeakMap(), A = new WeakMap(), je), We = new Je();
+function Me() {
+  let t, e;
+  const s = new Promise((n, u) => {
+    t = n, e = u;
+  });
+  s.status = "pending", s.catch(() => {
+  });
+  function i(n) {
+    Object.assign(s, n), delete s.resolve, delete s.reject;
+  }
+  return s.resolve = (n) => {
+    i({
+      status: "fulfilled",
+      value: n
+    }), t(n);
+  }, s.reject = (n) => {
+    i({
+      status: "rejected",
+      reason: n
+    }), e(n);
+  }, s;
+}
+var $e = Be;
+function Ke() {
+  let t = [], e = 0, s = (a) => {
+    a();
+  }, i = (a) => {
+    a();
+  }, n = $e;
+  const u = (a) => {
+    e ? t.push(a) : n(() => {
+      s(a);
+    });
+  }, h = () => {
+    const a = t;
+    t = [], a.length && n(() => {
+      i(() => {
+        a.forEach((v) => {
+          s(v);
+        });
+      });
+    });
+  };
+  return {
+    batch: (a) => {
+      let v;
+      e++;
+      try {
+        v = a();
+      } finally {
+        e--, e || h();
+      }
+      return v;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (a) => (...v) => {
+      u(() => {
+        a(...v);
+      });
+    },
+    schedule: u,
+    /**
+     * 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) => {
+      i = a;
+    },
+    setScheduler: (a) => {
+      n = a;
+    }
+  };
+}
+var Ue = Ke(), V, N, z, Qe, Ze = (Qe = class extends me {
+  constructor() {
+    super();
+    d(this, V, !0);
+    d(this, N);
+    d(this, z);
+    o(this, z, (e) => {
+      if (!Z && window.addEventListener) {
+        const s = () => e(!0), i = () => e(!1);
+        return window.addEventListener("online", s, !1), window.addEventListener("offline", i, !1), () => {
+          window.removeEventListener("online", s), window.removeEventListener("offline", i);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    r(this, N) || this.setEventListener(r(this, z));
+  }
+  onUnsubscribe() {
+    var e;
+    this.hasListeners() || ((e = r(this, N)) == null || e.call(this), o(this, N, void 0));
+  }
+  setEventListener(e) {
+    var s;
+    o(this, z, e), (s = r(this, N)) == null || s.call(this), o(this, N, e(this.setOnline.bind(this)));
+  }
+  setOnline(e) {
+    r(this, V) !== e && (o(this, V, e), this.listeners.forEach((i) => {
+      i(e);
+    }));
+  }
+  isOnline() {
+    return r(this, V);
+  }
+}, V = new WeakMap(), N = new WeakMap(), z = new WeakMap(), Qe), Ge = new Ze();
+function Xe(t) {
+  return (t ?? "online") === "online" ? Ge.isOnline() : !0;
+}
+function Ye(t, e) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: Xe(e.networkMode) ? "fetching" : "paused",
+    ...t === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+var E, c, G, m, L, B, F, _, X, H, q, D, U, x, J, l, $, le, fe, de, pe, be, ye, ve, ke, Le, et = (Le = class extends me {
+  constructor(e, s) {
+    super();
+    d(this, l);
+    d(this, E);
+    d(this, c);
+    d(this, G);
+    d(this, m);
+    d(this, L);
+    d(this, B);
+    d(this, F);
+    d(this, _);
+    d(this, X);
+    d(this, H);
+    // This property keeps track of the last query with defined data.
+    // It will be used to pass the previous data and query to the placeholder function between renders.
+    d(this, q);
+    d(this, D);
+    d(this, U);
+    d(this, x);
+    d(this, J, /* @__PURE__ */ new Set());
+    this.options = s, o(this, E, e), o(this, _, null), o(this, F, Me()), this.bindMethods(), this.setOptions(s);
+  }
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && (r(this, c).addObserver(this), Ne(r(this, c), this.options) ? y(this, l, $).call(this) : this.updateResult(), y(this, l, pe).call(this));
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.destroy();
+  }
+  shouldFetchOnReconnect() {
+    return ge(
+      r(this, c),
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return ge(
+      r(this, c),
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), y(this, l, be).call(this), y(this, l, ye).call(this), r(this, c).removeObserver(this);
+  }
+  setOptions(e) {
+    const s = this.options, i = r(this, c);
+    if (this.options = r(this, E).defaultQueryOptions(e), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof R(this.options.enabled, r(this, c)) != "boolean")
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    y(this, l, ve).call(this), r(this, c).setOptions(this.options), s._defaulted && !ue(this.options, s) && r(this, E).getQueryCache().notify({
+      type: "observerOptionsUpdated",
+      query: r(this, c),
+      observer: this
+    });
+    const n = this.hasListeners();
+    n && _e(
+      r(this, c),
+      i,
+      this.options,
+      s
+    ) && y(this, l, $).call(this), this.updateResult(), n && (r(this, c) !== i || R(this.options.enabled, r(this, c)) !== R(s.enabled, r(this, c)) || K(this.options.staleTime, r(this, c)) !== K(s.staleTime, r(this, c))) && y(this, l, le).call(this);
+    const u = y(this, l, fe).call(this);
+    n && (r(this, c) !== i || R(this.options.enabled, r(this, c)) !== R(s.enabled, r(this, c)) || u !== r(this, x)) && y(this, l, de).call(this, u);
+  }
+  getOptimisticResult(e) {
+    const s = r(this, E).getQueryCache().build(r(this, E), e), i = this.createResult(s, e);
+    return st(this, i) && (o(this, m, i), o(this, B, this.options), o(this, L, r(this, c).state)), i;
+  }
+  getCurrentResult() {
+    return r(this, m);
+  }
+  trackResult(e, s) {
+    return new Proxy(e, {
+      get: (i, n) => (this.trackProp(n), s == null || s(n), n === "promise" && (this.trackProp("data"), !this.options.experimental_prefetchInRender && r(this, F).status === "pending" && r(this, F).reject(
+        new Error(
+          "experimental_prefetchInRender feature flag is not enabled"
+        )
+      )), Reflect.get(i, n))
+    });
+  }
+  trackProp(e) {
+    r(this, J).add(e);
+  }
+  getCurrentQuery() {
+    return r(this, c);
+  }
+  refetch({ ...e } = {}) {
+    return this.fetch({
+      ...e
+    });
+  }
+  fetchOptimistic(e) {
+    const s = r(this, E).defaultQueryOptions(e), i = r(this, E).getQueryCache().build(r(this, E), s);
+    return i.fetch().then(() => this.createResult(i, s));
+  }
+  fetch(e) {
+    return y(this, l, $).call(this, {
+      ...e,
+      cancelRefetch: e.cancelRefetch ?? !0
+    }).then(() => (this.updateResult(), r(this, m)));
+  }
+  createResult(e, s) {
+    var Oe;
+    const i = r(this, c), n = this.options, u = r(this, m), h = r(this, L), a = r(this, B), p = e !== i ? e.state : r(this, G), { state: g } = e;
+    let f = { ...g }, S = !1, b;
+    if (s._optimisticResults) {
+      const O = this.hasListeners(), ee = !O && Ne(e, s), k = O && _e(e, i, s, n);
+      (ee || k) && (f = {
+        ...f,
+        ...Ye(g.data, e.options)
+      }), s._optimisticResults === "isRestoring" && (f.fetchStatus = "idle");
+    }
+    let { error: P, errorUpdatedAt: W, status: w } = f;
+    b = f.data;
+    let Y = !1;
+    if (s.placeholderData !== void 0 && b === void 0 && w === "pending") {
+      let O;
+      u != null && u.isPlaceholderData && s.placeholderData === (a == null ? void 0 : a.placeholderData) ? (O = u.data, Y = !0) : O = typeof s.placeholderData == "function" ? s.placeholderData(
+        (Oe = r(this, q)) == null ? void 0 : Oe.state.data,
+        r(this, q)
+      ) : s.placeholderData, O !== void 0 && (w = "success", b = Fe(
+        u == null ? void 0 : u.data,
+        O,
+        s
+      ), S = !0);
+    }
+    if (s.select && b !== void 0 && !Y)
+      if (u && b === (h == null ? void 0 : h.data) && s.select === r(this, X))
+        b = r(this, H);
+      else
+        try {
+          o(this, X, s.select), b = s.select(b), b = Fe(u == null ? void 0 : u.data, b, s), o(this, H, b), o(this, _, null);
+        } catch (O) {
+          o(this, _, O);
+        }
+    r(this, _) && (P = r(this, _), b = r(this, H), W = Date.now(), w = "error");
+    const re = f.fetchStatus === "fetching", ie = w === "pending", ne = w === "error", Se = ie && re, we = b !== void 0, I = {
+      status: w,
+      fetchStatus: f.fetchStatus,
+      isPending: ie,
+      isSuccess: w === "success",
+      isError: ne,
+      isInitialLoading: Se,
+      isLoading: Se,
+      data: b,
+      dataUpdatedAt: f.dataUpdatedAt,
+      error: P,
+      errorUpdatedAt: W,
+      failureCount: f.fetchFailureCount,
+      failureReason: f.fetchFailureReason,
+      errorUpdateCount: f.errorUpdateCount,
+      isFetched: f.dataUpdateCount > 0 || f.errorUpdateCount > 0,
+      isFetchedAfterMount: f.dataUpdateCount > p.dataUpdateCount || f.errorUpdateCount > p.errorUpdateCount,
+      isFetching: re,
+      isRefetching: re && !ie,
+      isLoadingError: ne && !we,
+      isPaused: f.fetchStatus === "paused",
+      isPlaceholderData: S,
+      isRefetchError: ne && we,
+      isStale: Ee(e, s),
+      refetch: this.refetch,
+      promise: r(this, F),
+      isEnabled: R(s.enabled, e) !== !1
+    };
+    if (this.options.experimental_prefetchInRender) {
+      const O = (te) => {
+        I.status === "error" ? te.reject(I.error) : I.data !== void 0 && te.resolve(I.data);
+      }, ee = () => {
+        const te = o(this, F, I.promise = Me());
+        O(te);
+      }, k = r(this, F);
+      switch (k.status) {
+        case "pending":
+          e.queryHash === i.queryHash && O(k);
+          break;
+        case "fulfilled":
+          (I.status === "error" || I.data !== k.value) && ee();
+          break;
+        case "rejected":
+          (I.status !== "error" || I.error !== k.reason) && ee();
+          break;
+      }
+    }
+    return I;
+  }
+  updateResult() {
+    const e = r(this, m), s = this.createResult(r(this, c), this.options);
+    if (o(this, L, r(this, c).state), o(this, B, this.options), r(this, L).data !== void 0 && o(this, q, r(this, c)), ue(s, e))
+      return;
+    o(this, m, s);
+    const i = () => {
+      if (!e)
+        return !0;
+      const { notifyOnChangeProps: n } = this.options, u = typeof n == "function" ? n() : n;
+      if (u === "all" || !u && !r(this, J).size)
+        return !0;
+      const h = new Set(
+        u ?? r(this, J)
+      );
+      return this.options.throwOnError && h.add("error"), Object.keys(r(this, m)).some((a) => {
+        const v = a;
+        return r(this, m)[v] !== e[v] && h.has(v);
+      });
+    };
+    y(this, l, ke).call(this, { listeners: i() });
+  }
+  onQueryUpdate() {
+    this.updateResult(), this.hasListeners() && y(this, l, pe).call(this);
+  }
+}, E = new WeakMap(), c = new WeakMap(), G = new WeakMap(), m = new WeakMap(), L = new WeakMap(), B = new WeakMap(), F = new WeakMap(), _ = new WeakMap(), X = new WeakMap(), H = new WeakMap(), q = new WeakMap(), D = new WeakMap(), U = new WeakMap(), x = new WeakMap(), J = new WeakMap(), l = new WeakSet(), $ = function(e) {
+  y(this, l, ve).call(this);
+  let s = r(this, c).fetch(
+    this.options,
+    e
+  );
+  return e != null && e.throwOnError || (s = s.catch(ae)), s;
+}, le = function() {
+  y(this, l, be).call(this);
+  const e = K(
+    this.options.staleTime,
+    r(this, c)
+  );
+  if (Z || r(this, m).isStale || !Ce(e))
+    return;
+  const i = He(r(this, m).dataUpdatedAt, e) + 1;
+  o(this, D, se.setTimeout(() => {
+    r(this, m).isStale || this.updateResult();
+  }, i));
+}, fe = function() {
+  return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(r(this, c)) : this.options.refetchInterval) ?? !1;
+}, de = function(e) {
+  y(this, l, ye).call(this), o(this, x, e), !(Z || R(this.options.enabled, r(this, c)) === !1 || !Ce(r(this, x)) || r(this, x) === 0) && o(this, U, se.setInterval(() => {
+    (this.options.refetchIntervalInBackground || We.isFocused()) && y(this, l, $).call(this);
+  }, r(this, x)));
+}, pe = function() {
+  y(this, l, le).call(this), y(this, l, de).call(this, y(this, l, fe).call(this));
+}, be = function() {
+  r(this, D) && (se.clearTimeout(r(this, D)), o(this, D, void 0));
+}, ye = function() {
+  r(this, U) && (se.clearInterval(r(this, U)), o(this, U, void 0));
+}, ve = function() {
+  const e = r(this, E).getQueryCache().build(r(this, E), this.options);
+  if (e === r(this, c))
+    return;
+  const s = r(this, c);
+  o(this, c, e), o(this, G, e.state), this.hasListeners() && (s == null || s.removeObserver(this), e.addObserver(this));
+}, ke = function(e) {
+  Ue.batch(() => {
+    e.listeners && this.listeners.forEach((s) => {
+      s(r(this, m));
+    }), r(this, E).getQueryCache().notify({
+      query: r(this, c),
+      type: "observerResultsUpdated"
+    });
+  });
+}, Le);
+function tt(t, e) {
+  return R(e.enabled, t) !== !1 && t.state.data === void 0 && !(t.state.status === "error" && e.retryOnMount === !1);
+}
+function Ne(t, e) {
+  return tt(t, e) || t.state.data !== void 0 && ge(t, e, e.refetchOnMount);
+}
+function ge(t, e, s) {
+  if (R(e.enabled, t) !== !1 && K(e.staleTime, t) !== "static") {
+    const i = typeof s == "function" ? s(t) : s;
+    return i === "always" || i !== !1 && Ee(t, e);
+  }
+  return !1;
+}
+function _e(t, e, s, i) {
+  return (t !== e || R(i.enabled, t) === !1) && (!s.suspense || t.state.status !== "error") && Ee(t, s);
+}
+function Ee(t, e) {
+  return R(e.enabled, t) !== !1 && t.isStaleByTime(K(e.staleTime, t));
+}
+function st(t, e) {
+  return !ue(t.getCurrentResult(), e);
+}
+var rt = C.createContext(
+  void 0
+), it = (t) => {
+  const e = C.useContext(rt);
+  if (!e)
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  return e;
+}, Ae = C.createContext(!1), nt = () => C.useContext(Ae);
+Ae.Provider;
+function ot() {
+  let t = !1;
+  return {
+    clearReset: () => {
+      t = !1;
+    },
+    reset: () => {
+      t = !0;
+    },
+    isReset: () => t
+  };
+}
+var at = C.createContext(ot()), ct = () => C.useContext(at), ut = (t, e, s) => {
+  const i = s != null && s.state.error && typeof t.throwOnError == "function" ? De(t.throwOnError, [s.state.error, s]) : t.throwOnError;
+  (t.suspense || t.experimental_prefetchInRender || i) && (e.isReset() || (t.retryOnMount = !1));
+}, ht = (t) => {
+  C.useEffect(() => {
+    t.clearReset();
+  }, [t]);
+}, lt = ({
+  result: t,
+  errorResetBoundary: e,
+  throwOnError: s,
+  query: i,
+  suspense: n
+}) => t.isError && !e.isReset() && !t.isFetching && i && (n && t.data === void 0 || De(s, [t.error, i])), ft = (t) => {
+  if (t.suspense) {
+    const s = (n) => n === "static" ? n : Math.max(n ?? 1e3, 1e3), i = t.staleTime;
+    t.staleTime = typeof i == "function" ? (...n) => s(i(...n)) : s(i), typeof t.gcTime == "number" && (t.gcTime = Math.max(
+      t.gcTime,
+      1e3
+    ));
+  }
+}, dt = (t, e) => t.isLoading && t.isFetching && !e, pt = (t, e) => (t == null ? void 0 : t.suspense) && e.isPending, xe = (t, e, s) => e.fetchOptimistic(t).catch(() => {
+  s.clearReset();
+});
+function bt(t, e, s) {
+  var S, b, P, W;
+  if (process.env.NODE_ENV !== "production" && (typeof t != "object" || Array.isArray(t)))
+    throw new Error(
+      'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
+    );
+  const i = nt(), n = ct(), u = it(), h = u.defaultQueryOptions(t);
+  (b = (S = u.getDefaultOptions().queries) == null ? void 0 : S._experimental_beforeQuery) == null || b.call(
+    S,
+    h
+  );
+  const a = u.getQueryCache().get(h.queryHash);
+  process.env.NODE_ENV !== "production" && (h.queryFn || console.error(
+    `[${h.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`
+  )), h._optimisticResults = i ? "isRestoring" : "optimistic", ft(h), ut(h, n, a), ht(n);
+  const v = !u.getQueryCache().get(h.queryHash), [p] = C.useState(
+    () => new e(
+      u,
+      h
+    )
+  ), g = p.getOptimisticResult(h), f = !i && t.subscribed !== !1;
+  if (C.useSyncExternalStore(
+    C.useCallback(
+      (w) => {
+        const Y = f ? p.subscribe(Ue.batchCalls(w)) : ae;
+        return p.updateResult(), Y;
+      },
+      [p, f]
+    ),
+    () => p.getCurrentResult(),
+    () => p.getCurrentResult()
+  ), C.useEffect(() => {
+    p.setOptions(h);
+  }, [h, p]), pt(h, g))
+    throw xe(h, p, n);
+  if (lt({
+    result: g,
+    errorResetBoundary: n,
+    throwOnError: h.throwOnError,
+    query: a,
+    suspense: h.suspense
+  }))
+    throw g.error;
+  if ((W = (P = u.getDefaultOptions().queries) == null ? void 0 : P._experimental_afterQuery) == null || W.call(
+    P,
+    h,
+    g
+  ), h.experimental_prefetchInRender && !Z && dt(g, i)) {
+    const w = v ? (
+      // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+      xe(h, p, n)
+    ) : (
+      // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+      a == null ? void 0 : a.promise
+    );
+    w == null || w.catch(ae).finally(() => {
+      p.updateResult();
+    });
+  }
+  return h.notifyOnChangeProps ? g : p.trackResult(g);
+}
+function St(t, e) {
+  return bt(t, et);
+}
+export {
+  et as Q,
+  me as S,
+  it as a,
+  nt as b,
+  ct as c,
+  ut as d,
+  ft as e,
+  ht as f,
+  ae as g,
+  mt as h,
+  pt as i,
+  xe as j,
+  lt as k,
+  De as l,
+  Et as m,
+  Ue as n,
+  ce as r,
+  ue as s,
+  St as u,
+  dt as w
+};