@px-ui/core 1.23.0 → 1.25.0

package/dist/node_modules/.pnpm/@tanstack_query-core@5.90.1/node_modules/@tanstack/query-core/build/modern/queryObserver.js

@@ -0,0 +1,299 @@
+var ct = (i) => {
+  throw TypeError(i);
+};
+var K = (i, t, s) => t.has(i) || ct("Cannot " + s);
+var e = (i, t, s) => (K(i, t, "read from private field"), s ? s.call(i) : t.get(i)), c = (i, t, s) => t.has(i) ? ct("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(i) : t.set(i, s), h = (i, t, s, a) => (K(i, t, "write to private field"), a ? a.call(i, s) : t.set(i, s), s), o = (i, t, s) => (K(i, t, "access private method"), s);
+import { focusManager as Rt } from "./focusManager.js";
+import { notifyManager as yt } from "./notifyManager.js";
+import { fetchState as Ot } from "./query.js";
+import { Subscribable as St } from "./subscribable.js";
+import { pendingThenable as ut } from "./thenable.js";
+import { resolveEnabled as v, shallowEqualObjects as N, resolveStaleTime as L, noop as Ct, isServer as dt, isValidTimeout as ft, timeUntilStale as It, replaceData as pt } from "./utils.js";
+import { timeoutManager as z } from "./timeoutManager.js";
+var b, r, P, d, C, F, R, y, A, Q, D, I, U, O, E, n, M, G, J, X, Y, Z, $, q, gt, vt, At = (vt = class extends St {
+  constructor(t, s) {
+    super();
+    c(this, n);
+    c(this, b);
+    c(this, r);
+    c(this, P);
+    c(this, d);
+    c(this, C);
+    c(this, F);
+    c(this, R);
+    c(this, y);
+    c(this, A);
+    c(this, Q);
+    // 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.
+    c(this, D);
+    c(this, I);
+    c(this, U);
+    c(this, O);
+    c(this, E, /* @__PURE__ */ new Set());
+    this.options = s, h(this, b, t), h(this, y, null), h(this, R, ut()), this.bindMethods(), this.setOptions(s);
+  }
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && (e(this, r).addObserver(this), bt(e(this, r), this.options) ? o(this, n, M).call(this) : this.updateResult(), o(this, n, Y).call(this));
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.destroy();
+  }
+  shouldFetchOnReconnect() {
+    return tt(
+      e(this, r),
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return tt(
+      e(this, r),
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), o(this, n, Z).call(this), o(this, n, $).call(this), e(this, r).removeObserver(this);
+  }
+  setOptions(t) {
+    const s = this.options, a = e(this, r);
+    if (this.options = e(this, b).defaultQueryOptions(t), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof v(this.options.enabled, e(this, r)) != "boolean")
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    o(this, n, q).call(this), e(this, r).setOptions(this.options), s._defaulted && !N(this.options, s) && e(this, b).getQueryCache().notify({
+      type: "observerOptionsUpdated",
+      query: e(this, r),
+      observer: this
+    });
+    const f = this.hasListeners();
+    f && mt(
+      e(this, r),
+      a,
+      this.options,
+      s
+    ) && o(this, n, M).call(this), this.updateResult(), f && (e(this, r) !== a || v(this.options.enabled, e(this, r)) !== v(s.enabled, e(this, r)) || L(this.options.staleTime, e(this, r)) !== L(s.staleTime, e(this, r))) && o(this, n, G).call(this);
+    const l = o(this, n, J).call(this);
+    f && (e(this, r) !== a || v(this.options.enabled, e(this, r)) !== v(s.enabled, e(this, r)) || l !== e(this, O)) && o(this, n, X).call(this, l);
+  }
+  getOptimisticResult(t) {
+    const s = e(this, b).getQueryCache().build(e(this, b), t), a = this.createResult(s, t);
+    return wt(this, a) && (h(this, d, a), h(this, F, this.options), h(this, C, e(this, r).state)), a;
+  }
+  getCurrentResult() {
+    return e(this, d);
+  }
+  trackResult(t, s) {
+    return new Proxy(t, {
+      get: (a, f) => (this.trackProp(f), s == null || s(f), f === "promise" && !this.options.experimental_prefetchInRender && e(this, R).status === "pending" && e(this, R).reject(
+        new Error(
+          "experimental_prefetchInRender feature flag is not enabled"
+        )
+      ), Reflect.get(a, f))
+    });
+  }
+  trackProp(t) {
+    e(this, E).add(t);
+  }
+  getCurrentQuery() {
+    return e(this, r);
+  }
+  refetch({ ...t } = {}) {
+    return this.fetch({
+      ...t
+    });
+  }
+  fetchOptimistic(t) {
+    const s = e(this, b).defaultQueryOptions(t), a = e(this, b).getQueryCache().build(e(this, b), s);
+    return a.fetch().then(() => this.createResult(a, s));
+  }
+  fetch(t) {
+    return o(this, n, M).call(this, {
+      ...t,
+      cancelRefetch: t.cancelRefetch ?? !0
+    }).then(() => (this.updateResult(), e(this, d)));
+  }
+  createResult(t, s) {
+    var lt;
+    const a = e(this, r), f = this.options, l = e(this, d), w = e(this, C), x = e(this, F), W = t !== a ? t.state : e(this, P), { state: st } = t;
+    let u = { ...st }, it = !1, p;
+    if (s._optimisticResults) {
+      const m = this.hasListeners(), j = !m && bt(t, s), T = m && mt(t, a, s, f);
+      (j || T) && (u = {
+        ...u,
+        ...Ot(st.data, t.options)
+      }), s._optimisticResults === "isRestoring" && (u.fetchStatus = "idle");
+    }
+    let { error: rt, errorUpdatedAt: nt, status: S } = u;
+    p = u.data;
+    let at = !1;
+    if (s.placeholderData !== void 0 && p === void 0 && S === "pending") {
+      let m;
+      l != null && l.isPlaceholderData && s.placeholderData === (x == null ? void 0 : x.placeholderData) ? (m = l.data, at = !0) : m = typeof s.placeholderData == "function" ? s.placeholderData(
+        (lt = e(this, D)) == null ? void 0 : lt.state.data,
+        e(this, D)
+      ) : s.placeholderData, m !== void 0 && (S = "success", p = pt(
+        l == null ? void 0 : l.data,
+        m,
+        s
+      ), it = !0);
+    }
+    if (s.select && p !== void 0 && !at)
+      if (l && p === (w == null ? void 0 : w.data) && s.select === e(this, A))
+        p = e(this, Q);
+      else
+        try {
+          h(this, A, s.select), p = s.select(p), p = pt(l == null ? void 0 : l.data, p, s), h(this, Q, p), h(this, y, null);
+        } catch (m) {
+          h(this, y, m);
+        }
+    e(this, y) && (rt = e(this, y), p = e(this, Q), nt = Date.now(), S = "error");
+    const B = u.fetchStatus === "fetching", H = S === "pending", V = S === "error", ht = H && B, ot = p !== void 0, g = {
+      status: S,
+      fetchStatus: u.fetchStatus,
+      isPending: H,
+      isSuccess: S === "success",
+      isError: V,
+      isInitialLoading: ht,
+      isLoading: ht,
+      data: p,
+      dataUpdatedAt: u.dataUpdatedAt,
+      error: rt,
+      errorUpdatedAt: nt,
+      failureCount: u.fetchFailureCount,
+      failureReason: u.fetchFailureReason,
+      errorUpdateCount: u.errorUpdateCount,
+      isFetched: u.dataUpdateCount > 0 || u.errorUpdateCount > 0,
+      isFetchedAfterMount: u.dataUpdateCount > W.dataUpdateCount || u.errorUpdateCount > W.errorUpdateCount,
+      isFetching: B,
+      isRefetching: B && !H,
+      isLoadingError: V && !ot,
+      isPaused: u.fetchStatus === "paused",
+      isPlaceholderData: it,
+      isRefetchError: V && ot,
+      isStale: et(t, s),
+      refetch: this.refetch,
+      promise: e(this, R),
+      isEnabled: v(s.enabled, t) !== !1
+    };
+    if (this.options.experimental_prefetchInRender) {
+      const m = (k) => {
+        g.status === "error" ? k.reject(g.error) : g.data !== void 0 && k.resolve(g.data);
+      }, j = () => {
+        const k = h(this, R, g.promise = ut());
+        m(k);
+      }, T = e(this, R);
+      switch (T.status) {
+        case "pending":
+          t.queryHash === a.queryHash && m(T);
+          break;
+        case "fulfilled":
+          (g.status === "error" || g.data !== T.value) && j();
+          break;
+        case "rejected":
+          (g.status !== "error" || g.error !== T.reason) && j();
+          break;
+      }
+    }
+    return g;
+  }
+  updateResult() {
+    const t = e(this, d), s = this.createResult(e(this, r), this.options);
+    if (h(this, C, e(this, r).state), h(this, F, this.options), e(this, C).data !== void 0 && h(this, D, e(this, r)), N(s, t))
+      return;
+    h(this, d, s);
+    const a = () => {
+      if (!t)
+        return !0;
+      const { notifyOnChangeProps: f } = this.options, l = typeof f == "function" ? f() : f;
+      if (l === "all" || !l && !e(this, E).size)
+        return !0;
+      const w = new Set(
+        l ?? e(this, E)
+      );
+      return this.options.throwOnError && w.add("error"), Object.keys(e(this, d)).some((x) => {
+        const _ = x;
+        return e(this, d)[_] !== t[_] && w.has(_);
+      });
+    };
+    o(this, n, gt).call(this, { listeners: a() });
+  }
+  onQueryUpdate() {
+    this.updateResult(), this.hasListeners() && o(this, n, Y).call(this);
+  }
+}, b = new WeakMap(), r = new WeakMap(), P = new WeakMap(), d = new WeakMap(), C = new WeakMap(), F = new WeakMap(), R = new WeakMap(), y = new WeakMap(), A = new WeakMap(), Q = new WeakMap(), D = new WeakMap(), I = new WeakMap(), U = new WeakMap(), O = new WeakMap(), E = new WeakMap(), n = new WeakSet(), M = function(t) {
+  o(this, n, q).call(this);
+  let s = e(this, r).fetch(
+    this.options,
+    t
+  );
+  return t != null && t.throwOnError || (s = s.catch(Ct)), s;
+}, G = function() {
+  o(this, n, Z).call(this);
+  const t = L(
+    this.options.staleTime,
+    e(this, r)
+  );
+  if (dt || e(this, d).isStale || !ft(t))
+    return;
+  const a = It(e(this, d).dataUpdatedAt, t) + 1;
+  h(this, I, z.setTimeout(() => {
+    e(this, d).isStale || this.updateResult();
+  }, a));
+}, J = function() {
+  return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(e(this, r)) : this.options.refetchInterval) ?? !1;
+}, X = function(t) {
+  o(this, n, $).call(this), h(this, O, t), !(dt || v(this.options.enabled, e(this, r)) === !1 || !ft(e(this, O)) || e(this, O) === 0) && h(this, U, z.setInterval(() => {
+    (this.options.refetchIntervalInBackground || Rt.isFocused()) && o(this, n, M).call(this);
+  }, e(this, O)));
+}, Y = function() {
+  o(this, n, G).call(this), o(this, n, X).call(this, o(this, n, J).call(this));
+}, Z = function() {
+  e(this, I) && (z.clearTimeout(e(this, I)), h(this, I, void 0));
+}, $ = function() {
+  e(this, U) && (z.clearInterval(e(this, U)), h(this, U, void 0));
+}, q = function() {
+  const t = e(this, b).getQueryCache().build(e(this, b), this.options);
+  if (t === e(this, r))
+    return;
+  const s = e(this, r);
+  h(this, r, t), h(this, P, t.state), this.hasListeners() && (s == null || s.removeObserver(this), t.addObserver(this));
+}, gt = function(t) {
+  yt.batch(() => {
+    t.listeners && this.listeners.forEach((s) => {
+      s(e(this, d));
+    }), e(this, b).getQueryCache().notify({
+      query: e(this, r),
+      type: "observerResultsUpdated"
+    });
+  });
+}, vt);
+function Ut(i, t) {
+  return v(t.enabled, i) !== !1 && i.state.data === void 0 && !(i.state.status === "error" && t.retryOnMount === !1);
+}
+function bt(i, t) {
+  return Ut(i, t) || i.state.data !== void 0 && tt(i, t, t.refetchOnMount);
+}
+function tt(i, t, s) {
+  if (v(t.enabled, i) !== !1 && L(t.staleTime, i) !== "static") {
+    const a = typeof s == "function" ? s(i) : s;
+    return a === "always" || a !== !1 && et(i, t);
+  }
+  return !1;
+}
+function mt(i, t, s, a) {
+  return (i !== t || v(a.enabled, i) === !1) && (!s.suspense || i.state.status !== "error") && et(i, s);
+}
+function et(i, t) {
+  return v(t.enabled, i) !== !1 && i.isStaleByTime(L(t.staleTime, i));
+}
+function wt(i, t) {
+  return !N(i.getCurrentResult(), t);
+}
+export {
+  At as QueryObserver
+};

package/dist/node_modules/.pnpm/@tanstack_query-core@5.90.1/node_modules/@tanstack/query-core/build/modern/retryer.js

@@ -0,0 +1,7 @@
+import { onlineManager as e } from "./onlineManager.js";
+function o(n) {
+  return (n ?? "online") === "online" ? e.isOnline() : !0;
+}
+export {
+  o as canFetch
+};

package/dist/node_modules/.pnpm/@tanstack_query-core@5.90.1/node_modules/@tanstack/query-core/build/modern/subscribable.js

@@ -0,0 +1,20 @@
+var e = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(s) {
+    return this.listeners.add(s), this.onSubscribe(), () => {
+      this.listeners.delete(s), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+};
+export {
+  e as Subscribable
+};

package/dist/node_modules/.pnpm/@tanstack_query-core@5.90.1/node_modules/@tanstack/query-core/build/modern/thenable.js

@@ -0,0 +1,25 @@
+function r() {
+  let n, l;
+  const t = new Promise((e, c) => {
+    n = e, l = c;
+  });
+  t.status = "pending", t.catch(() => {
+  });
+  function s(e) {
+    Object.assign(t, e), delete t.resolve, delete t.reject;
+  }
+  return t.resolve = (e) => {
+    s({
+      status: "fulfilled",
+      value: e
+    }), n(e);
+  }, t.reject = (e) => {
+    s({
+      status: "rejected",
+      reason: e
+    }), l(e);
+  }, t;
+}
+export {
+  r as pendingThenable
+};

package/dist/node_modules/.pnpm/@tanstack_query-core@5.90.1/node_modules/@tanstack/query-core/build/modern/timeoutManager.js

@@ -0,0 +1,59 @@
+var l = (e) => {
+  throw TypeError(e);
+};
+var c = (e, t, r) => t.has(e) || l("Cannot " + r);
+var o = (e, t, r) => (c(e, t, "read from private field"), r ? r.call(e) : t.get(e)), u = (e, t, r) => t.has(e) ? l("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, r), a = (e, t, r, n) => (c(e, t, "write to private field"), n ? n.call(e, r) : t.set(e, r), r);
+var m = {
+  // 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)
+}, i, s, v, h = (v = 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.
+    u(this, i, m);
+    u(this, s, !1);
+  }
+  setTimeoutProvider(e) {
+    process.env.NODE_ENV !== "production" && o(this, s) && e !== o(this, i) && console.error(
+      "[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.",
+      { previous: o(this, i), provider: e }
+    ), a(this, i, e), process.env.NODE_ENV !== "production" && a(this, s, !1);
+  }
+  setTimeout(e, t) {
+    return process.env.NODE_ENV !== "production" && a(this, s, !0), o(this, i).setTimeout(e, t);
+  }
+  clearTimeout(e) {
+    o(this, i).clearTimeout(e);
+  }
+  setInterval(e, t) {
+    return process.env.NODE_ENV !== "production" && a(this, s, !0), o(this, i).setInterval(e, t);
+  }
+  clearInterval(e) {
+    o(this, i).clearInterval(e);
+  }
+}, i = new WeakMap(), s = new WeakMap(), v), T = new h();
+function d(e) {
+  setTimeout(e, 0);
+}
+export {
+  h as TimeoutManager,
+  m as defaultTimeoutProvider,
+  d as systemSetTimeoutZero,
+  T as timeoutManager
+};

package/dist/node_modules/.pnpm/@tanstack_query-core@5.90.1/node_modules/@tanstack/query-core/build/modern/utils.js

@@ -0,0 +1,112 @@
+var O = typeof window > "u" || "Deno" in globalThis;
+function S() {
+}
+function k(e) {
+  return typeof e == "number" && e >= 0 && e !== 1 / 0;
+}
+function d(e, r) {
+  return Math.max(e + (r || 0) - Date.now(), 0);
+}
+function w(e, r) {
+  return typeof e == "function" ? e(r) : e;
+}
+function P(e, r) {
+  return typeof e == "function" ? e(r) : e;
+}
+var q = Object.prototype.hasOwnProperty;
+function a(e, r) {
+  if (e === r)
+    return e;
+  const t = g(e) && g(r);
+  if (!t && !(j(e) && j(r))) return r;
+  const f = (t ? e : Object.keys(e)).length, h = t ? r : Object.keys(r), l = h.length, s = t ? new Array(l) : {};
+  let y = 0;
+  for (let i = 0; i < l; i++) {
+    const o = t ? i : h[i], u = e[o], c = r[o];
+    if (u === c) {
+      s[o] = u, (t ? i < f : q.call(e, o)) && y++;
+      continue;
+    }
+    if (u === null || c === null || typeof u != "object" || typeof c != "object") {
+      s[o] = c;
+      continue;
+    }
+    const p = a(u, c);
+    s[o] = p, p === u && y++;
+  }
+  return f === l && y === f ? e : s;
+}
+function F(e, r) {
+  if (!r || Object.keys(e).length !== Object.keys(r).length)
+    return !1;
+  for (const t in e)
+    if (e[t] !== r[t])
+      return !1;
+  return !0;
+}
+function g(e) {
+  return Array.isArray(e) && e.length === Object.keys(e).length;
+}
+function j(e) {
+  if (!b(e))
+    return !1;
+  const r = e.constructor;
+  if (r === void 0)
+    return !0;
+  const t = r.prototype;
+  return !(!b(t) || !t.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(e) !== Object.prototype);
+}
+function b(e) {
+  return Object.prototype.toString.call(e) === "[object Object]";
+}
+function I(e, r, t) {
+  if (typeof t.structuralSharing == "function")
+    return t.structuralSharing(e, r);
+  if (t.structuralSharing !== !1) {
+    if (process.env.NODE_ENV !== "production")
+      try {
+        return a(e, r);
+      } catch (n) {
+        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. [${t.queryHash}]: ${n}`
+        ), n;
+      }
+    return a(e, r);
+  }
+  return r;
+}
+function E(e, r, t = 0) {
+  const n = [...e, r];
+  return t && n.length > t ? n.slice(1) : n;
+}
+function T(e, r, t = 0) {
+  const n = [r, ...e];
+  return t && n.length > t ? n.slice(0, -1) : n;
+}
+var m = Symbol();
+function N(e, r) {
+  return process.env.NODE_ENV !== "production" && e.queryFn === m && console.error(
+    `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${e.queryHash}'`
+  ), !e.queryFn && (r != null && r.initialPromise) ? () => r.initialPromise : !e.queryFn || e.queryFn === m ? () => Promise.reject(new Error(`Missing queryFn: '${e.queryHash}'`)) : e.queryFn;
+}
+function v(e, r) {
+  return typeof e == "function" ? e(...r) : !!e;
+}
+export {
+  E as addToEnd,
+  T as addToStart,
+  N as ensureQueryFn,
+  g as isPlainArray,
+  j as isPlainObject,
+  O as isServer,
+  k as isValidTimeout,
+  S as noop,
+  I as replaceData,
+  a as replaceEqualDeep,
+  P as resolveEnabled,
+  w as resolveStaleTime,
+  F as shallowEqualObjects,
+  v as shouldThrowError,
+  m as skipToken,
+  d as timeUntilStale
+};

package/dist/node_modules/.pnpm/@tanstack_react-query@5.90.1_react@19.2.0/node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js

@@ -0,0 +1,6 @@
+import * as e from "react";
+var t = e.createContext(!1), r = () => e.useContext(t);
+t.Provider;
+export {
+  r as useIsRestoring
+};

package/dist/node_modules/.pnpm/@tanstack_react-query@5.90.1_react@19.2.0/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js

@@ -0,0 +1,14 @@
+import * as t from "react";
+import "../../../../../../../../_virtual/jsx-runtime.js";
+var r = t.createContext(
+  void 0
+), i = (o) => {
+  const e = t.useContext(r);
+  if (!e)
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  return e;
+};
+export {
+  r as QueryClientContext,
+  i as useQueryClient
+};

package/dist/node_modules/.pnpm/@tanstack_react-query@5.90.1_react@19.2.0/node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js

@@ -0,0 +1,18 @@
+import * as r from "react";
+import "../../../../../../../../_virtual/jsx-runtime.js";
+function t() {
+  let e = !1;
+  return {
+    clearReset: () => {
+      e = !1;
+    },
+    reset: () => {
+      e = !0;
+    },
+    isReset: () => e
+  };
+}
+var s = r.createContext(t()), o = () => r.useContext(s);
+export {
+  o as useQueryErrorResetBoundary
+};

package/dist/node_modules/.pnpm/@tanstack_react-query@5.90.1_react@19.2.0/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js

@@ -0,0 +1,20 @@
+import * as s from "react";
+import { shouldThrowError as n } from "../../../../../../@tanstack_query-core@5.90.1/node_modules/@tanstack/query-core/build/modern/utils.js";
+var i = (r, e) => {
+  (r.suspense || r.throwOnError || r.experimental_prefetchInRender) && (e.isReset() || (r.retryOnMount = !1));
+}, E = (r) => {
+  s.useEffect(() => {
+    r.clearReset();
+  }, [r]);
+}, R = ({
+  result: r,
+  errorResetBoundary: e,
+  throwOnError: t,
+  query: a,
+  suspense: o
+}) => r.isError && !e.isReset() && !r.isFetching && a && (o && r.data === void 0 || n(t, [r.error, a]));
+export {
+  i as ensurePreventErrorBoundaryRetry,
+  R as getHasError,
+  E as useClearResetErrorBoundary
+};

package/dist/node_modules/.pnpm/@tanstack_react-query@5.90.1_react@19.2.0/node_modules/@tanstack/react-query/build/modern/suspense.js

@@ -0,0 +1,17 @@
+var m = (S) => {
+  if (S.suspense) {
+    const s = (i) => i === "static" ? i : Math.max(i ?? 1e3, 1e3), M = S.staleTime;
+    S.staleTime = typeof M == "function" ? (...i) => s(M(...i)) : s(M), typeof S.gcTime == "number" && (S.gcTime = Math.max(
+      S.gcTime,
+      1e3
+    ));
+  }
+}, E = (S, c) => S.isLoading && S.isFetching && !c, _ = (S, c) => (S == null ? void 0 : S.suspense) && c.isPending, e = (S, c, s) => c.fetchOptimistic(S).catch(() => {
+  s.clearReset();
+});
+export {
+  m as ensureSuspenseTimers,
+  e as fetchOptimistic,
+  _ as shouldSuspend,
+  E as willFetch
+};

package/dist/node_modules/.pnpm/@tanstack_react-query@5.90.1_react@19.2.0/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js

@@ -0,0 +1,70 @@
+import * as c from "react";
+import { notifyManager as R } from "../../../../../../@tanstack_query-core@5.90.1/node_modules/@tanstack/query-core/build/modern/notifyManager.js";
+import { noop as m, isServer as b } from "../../../../../../@tanstack_query-core@5.90.1/node_modules/@tanstack/query-core/build/modern/utils.js";
+import { useQueryClient as E } from "./QueryClientProvider.js";
+import { useQueryErrorResetBoundary as O } from "./QueryErrorResetBoundary.js";
+import { ensurePreventErrorBoundaryRetry as C, useClearResetErrorBoundary as Q, getHasError as S } from "./errorBoundaryUtils.js";
+import { useIsRestoring as _ } from "./IsRestoringProvider.js";
+import { ensureSuspenseTimers as v, shouldSuspend as k, fetchOptimistic as d, willFetch as B } from "./suspense.js";
+function A(u, g, F) {
+  var i, p, a, y, h;
+  if (process.env.NODE_ENV !== "production" && (typeof u != "object" || Array.isArray(u)))
+    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 l = _(), o = O(), t = E(), e = t.defaultQueryOptions(u);
+  (p = (i = t.getDefaultOptions().queries) == null ? void 0 : i._experimental_beforeQuery) == null || p.call(
+    i,
+    e
+  ), process.env.NODE_ENV !== "production" && (e.queryFn || console.error(
+    `[${e.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`
+  )), e._optimisticResults = l ? "isRestoring" : "optimistic", v(e), C(e, o), Q(o);
+  const q = !t.getQueryCache().get(e.queryHash), [r] = c.useState(
+    () => new g(
+      t,
+      e
+    )
+  ), s = r.getOptimisticResult(e), f = !l && u.subscribed !== !1;
+  if (c.useSyncExternalStore(
+    c.useCallback(
+      (n) => {
+        const w = f ? r.subscribe(R.batchCalls(n)) : m;
+        return r.updateResult(), w;
+      },
+      [r, f]
+    ),
+    () => r.getCurrentResult(),
+    () => r.getCurrentResult()
+  ), c.useEffect(() => {
+    r.setOptions(e);
+  }, [e, r]), k(e, s))
+    throw d(e, r, o);
+  if (S({
+    result: s,
+    errorResetBoundary: o,
+    throwOnError: e.throwOnError,
+    query: t.getQueryCache().get(e.queryHash),
+    suspense: e.suspense
+  }))
+    throw s.error;
+  if ((y = (a = t.getDefaultOptions().queries) == null ? void 0 : a._experimental_afterQuery) == null || y.call(
+    a,
+    e,
+    s
+  ), e.experimental_prefetchInRender && !b && B(s, l)) {
+    const n = q ? (
+      // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+      d(e, r, o)
+    ) : (
+      // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+      (h = t.getQueryCache().get(e.queryHash)) == null ? void 0 : h.promise
+    );
+    n == null || n.catch(m).finally(() => {
+      r.updateResult();
+    });
+  }
+  return e.notifyOnChangeProps ? s : r.trackResult(s);
+}
+export {
+  A as useBaseQuery
+};