@duxweb/dvha-naiveui 1.0.10 → 1.0.12

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

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

package/dist/esm/node_modules/.pnpm/@tanstack_query-core@5.80.7/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/esm/node_modules/.pnpm/@tanstack_query-core@5.80.7/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/esm/node_modules/.pnpm/@tanstack_query-core@5.80.7/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/esm/node_modules/.pnpm/@tanstack_query-core@5.80.7/node_modules/@tanstack/query-core/build/modern/utils.js

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

package/dist/esm/node_modules/.pnpm/@tanstack_vue-query@5.80.7_vue@3.5.17_typescript@5.8.3_/node_modules/@tanstack/vue-query/build/modern/useBaseQuery.js

@@ -0,0 +1,73 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { shouldThrowError as d } from "../../../../../../@tanstack_query-core@5.80.7/node_modules/@tanstack/query-core/build/modern/utils.js";
+import { useQueryClient as b } from "./useQueryClient.js";
+import { cloneDeepUnref as O, updateState as h } from "./utils.js";
+import { shallowReactive as C, reactive as E, onScopeDispose as Q, shallowReadonly as S, readonly as k, toRefs as D, getCurrentScope as q } from "../../../../../../@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+import { computed as N, watch as l } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+function U(y, g, T) {
+  process.env.NODE_ENV === "development" && (q() || console.warn(
+    'vue-query composable like "useQuery()" should only be used inside a "setup()" function or a running effect scope. They might otherwise lead to memory leaks.'
+  ));
+  const i = b(), t = N(() => {
+    var n;
+    const e = O(g);
+    typeof e.enabled == "function" && (e.enabled = e.enabled());
+    const r = i.defaultQueryOptions(e);
+    return r._optimisticResults = (n = i.isRestoring) != null && n.value ? "isRestoring" : "optimistic", r;
+  }), o = new y(i, t.value), s = t.value.shallow ? C(o.getCurrentResult()) : E(o.getCurrentResult());
+  let c = () => {
+  };
+  i.isRestoring && l(
+    i.isRestoring,
+    (e) => {
+      e || (c(), c = o.subscribe((r) => {
+        h(s, r);
+      }));
+    },
+    { immediate: !0 }
+  );
+  const a = () => {
+    o.setOptions(t.value), h(s, o.getCurrentResult());
+  };
+  l(t, a), Q(() => {
+    c();
+  });
+  const v = (...e) => (a(), s.refetch(...e)), R = () => new Promise(
+    (e, r) => {
+      let n = () => {
+      };
+      const f = () => {
+        if (t.value.enabled !== !1) {
+          o.setOptions(t.value);
+          const p = o.getOptimisticResult(
+            t.value
+          );
+          p.isStale ? (n(), o.fetchOptimistic(t.value).then(e, (m) => {
+            d(t.value.throwOnError, [
+              m,
+              o.getCurrentQuery()
+            ]) ? r(m) : e(o.getCurrentResult());
+          })) : (n(), e(p));
+        }
+      };
+      f(), n = l(t, f);
+    }
+  );
+  l(
+    () => s.error,
+    (e) => {
+      if (s.isError && !s.isFetching && d(t.value.throwOnError, [
+        e,
+        o.getCurrentQuery()
+      ]))
+        throw e;
+    }
+  );
+  const w = t.value.shallow ? S(s) : k(s), u = D(w);
+  for (const e in s)
+    typeof s[e] == "function" && (u[e] = s[e]);
+  return u.suspense = R, u.refetch = v, u;
+}
+export {
+  U as useBaseQuery
+};

package/dist/esm/node_modules/.pnpm/@tanstack_vue-query@5.80.7_vue@3.5.17_typescript@5.8.3_/node_modules/@tanstack/vue-query/build/modern/useInfiniteQuery.js

@@ -0,0 +1,12 @@
+import { InfiniteQueryObserver as r } from "../../../../../../@tanstack_query-core@5.80.7/node_modules/@tanstack/query-core/build/modern/infiniteQueryObserver.js";
+import { useBaseQuery as i } from "./useBaseQuery.js";
+function o(e, n) {
+  return i(
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    r,
+    e
+  );
+}
+export {
+  o as useInfiniteQuery
+};

package/dist/esm/node_modules/.pnpm/@tanstack_vue-query@5.80.7_vue@3.5.17_typescript@5.8.3_/node_modules/@tanstack/vue-query/build/modern/useMutation.js

@@ -0,0 +1,39 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { MutationObserver as p } from "../../../../../../@tanstack_query-core@5.80.7/node_modules/@tanstack/query-core/build/modern/mutationObserver.js";
+import { shouldThrowError as f } from "../../../../../../@tanstack_query-core@5.80.7/node_modules/@tanstack/query-core/build/modern/utils.js";
+import { cloneDeepUnref as h, updateState as d } from "./utils.js";
+import { useQueryClient as v } from "./useQueryClient.js";
+import { computed as w, watch as n } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+import { shallowReactive as y, reactive as b, onScopeDispose as R, shallowReadonly as g, readonly as C, toRefs as O, getCurrentScope as E } from "../../../../../../@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+function x(u, S) {
+  process.env.NODE_ENV === "development" && (E() || console.warn(
+    'vue-query composable like "useQuery()" should only be used inside a "setup()" function or a running effect scope. They might otherwise lead to memory leaks.'
+  ));
+  const s = v(), t = w(() => s.defaultMutationOptions(h(u))), r = new p(s, t.value), o = t.value.shallow ? y(r.getCurrentResult()) : b(r.getCurrentResult()), a = r.subscribe((e) => {
+    d(o, e);
+  }), l = (e, m) => {
+    r.mutate(e, m).catch(() => {
+    });
+  };
+  n(t, () => {
+    r.setOptions(t.value);
+  }), R(() => {
+    a();
+  });
+  const i = t.value.shallow ? g(o) : C(o), c = O(i);
+  return n(
+    () => o.error,
+    (e) => {
+      if (e && f(t.value.throwOnError, [e]))
+        throw e;
+    }
+  ), {
+    ...c,
+    mutate: l,
+    mutateAsync: o.mutate,
+    reset: o.reset
+  };
+}
+export {
+  x as useMutation
+};

package/dist/esm/node_modules/.pnpm/@tanstack_vue-query@5.80.7_vue@3.5.17_typescript@5.8.3_/node_modules/@tanstack/vue-query/build/modern/useQuery.js

@@ -0,0 +1,8 @@
+import { QueryObserver as e } from "../../../../../../@tanstack_query-core@5.80.7/node_modules/@tanstack/query-core/build/modern/queryObserver.js";
+import { useBaseQuery as u } from "./useBaseQuery.js";
+function m(r, o) {
+  return u(e, r);
+}
+export {
+  m as useQuery
+};

package/dist/esm/node_modules/.pnpm/@tanstack_vue-query@5.80.7_vue@3.5.17_typescript@5.8.3_/node_modules/@tanstack/vue-query/build/modern/useQueryClient.js

@@ -0,0 +1,18 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { getClientKey as o } from "./utils.js";
+import { hasInjectionContext as r, inject as i } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+function y(t = "") {
+  if (!r())
+    throw new Error(
+      "vue-query hooks can only be used inside setup() function or functions that support injection context."
+    );
+  const n = o(t), e = i(n);
+  if (!e)
+    throw new Error(
+      "No 'queryClient' found in Vue context, use 'VueQueryPlugin' to properly initialize the library."
+    );
+  return e;
+}
+export {
+  y as useQueryClient
+};

package/dist/esm/node_modules/.pnpm/@tanstack_vue-query@5.80.7_vue@3.5.17_typescript@5.8.3_/node_modules/@tanstack/vue-query/build/modern/utils.js

@@ -0,0 +1,60 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { isRef as p, unref as b } from "../../../../../../@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+var j = "VUE_QUERY_CLIENT";
+function _(t) {
+  const r = t ? `:${t}` : "";
+  return `${j}${r}`;
+}
+function d(t, r) {
+  Object.keys(t).forEach((n) => {
+    t[n] = r[n];
+  });
+}
+function c(t, r, n = "", o = 0) {
+  if (r) {
+    const e = r(t, n, o);
+    if (e === void 0 && p(t) || e !== void 0)
+      return e;
+  }
+  if (Array.isArray(t))
+    return t.map(
+      (e, i) => c(e, r, String(i), o + 1)
+    );
+  if (typeof t == "object" && y(t)) {
+    const e = Object.entries(t).map(([i, u]) => [
+      i,
+      c(u, r, i, o + 1)
+    ]);
+    return Object.fromEntries(e);
+  }
+  return t;
+}
+function s(t, r) {
+  return c(t, r);
+}
+function f(t, r = !1) {
+  return s(t, (n, o, e) => {
+    if (e === 1 && o === "queryKey")
+      return f(n, !0);
+    if (r && O(n))
+      return f(n(), r);
+    if (p(n))
+      return f(b(n), r);
+  });
+}
+function y(t) {
+  if (Object.prototype.toString.call(t) !== "[object Object]")
+    return !1;
+  const r = Object.getPrototypeOf(t);
+  return r === null || r === Object.prototype;
+}
+function O(t) {
+  return typeof t == "function";
+}
+export {
+  j as VUE_QUERY_CLIENT,
+  s as cloneDeep,
+  f as cloneDeepUnref,
+  _ as getClientKey,
+  d as updateState
+};