@hz52410/uni-query 1.0.1

package/dist/index.esm.js

@@ -0,0 +1,1203 @@
+import { isRef as F, unref as M, hasInjectionContext as H, inject as L, nextTick as J, getCurrentScope as C, computed as Q, shallowReactive as I, reactive as U, watch as y, onScopeDispose as v, shallowReadonly as R, readonly as P, toRefs as x, shallowRef as N, ref as $, watchEffect as k } from "vue";
+let T = class {
+  constructor() {
+    this.queries = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 添加查询
+   */
+  add(t) {
+    this.queries.set(t.queryHash, t);
+  }
+  /**
+   * 移除查询
+   */
+  remove(t) {
+    this.queries.delete(t.queryHash);
+  }
+  /**
+   * 查找查询
+   */
+  find(t) {
+    const e = this.hashQueryKey(t.queryKey);
+    return this.queries.get(e);
+  }
+  /**
+   * 查找所有匹配的查询
+   */
+  findAll(t = {}) {
+    const e = [];
+    for (const s of this.queries.values())
+      this.matchQuery(s, t) && e.push(s);
+    return e;
+  }
+  /**
+   * 清除所有查询
+   */
+  clear() {
+    this.queries.clear();
+  }
+  /**
+   * 订阅缓存变化
+   */
+  subscribe(t) {
+    return () => {
+    };
+  }
+  /**
+   * 生成查询哈希
+   */
+  hashQueryKey(t) {
+    return JSON.stringify(t);
+  }
+  /**
+   * 匹配查询
+   */
+  matchQuery(t, e) {
+    if (e.queryKey) {
+      const s = this.hashQueryKey(e.queryKey);
+      return e.exact ? t.queryHash === s : t.queryHash.startsWith(s);
+    }
+    return e.predicate ? e.predicate(t) : !0;
+  }
+}, j = class {
+  constructor() {
+    this.mutations = /* @__PURE__ */ new Map(), this.mutationId = 0;
+  }
+  /**
+   * 添加 Mutation
+   */
+  add(t) {
+    this.mutations.set(t.mutationId, t);
+  }
+  /**
+   * 移除 Mutation
+   */
+  remove(t) {
+    this.mutations.delete(t.mutationId);
+  }
+  /**
+   * 查找 Mutation
+   */
+  find(t) {
+    for (const e of this.mutations.values())
+      if (this.matchMutation(e, t))
+        return e;
+  }
+  /**
+   * 查找所有匹配的 Mutation
+   */
+  findAll(t = {}) {
+    const e = [];
+    for (const s of this.mutations.values())
+      this.matchMutation(s, t) && e.push(s);
+    return e;
+  }
+  /**
+   * 清除所有 Mutation
+   */
+  clear() {
+    this.mutations.clear();
+  }
+  /**
+   * 订阅缓存变化
+   */
+  subscribe(t) {
+    return () => {
+    };
+  }
+  /**
+   * 生成 Mutation ID
+   */
+  generateMutationId() {
+    return ++this.mutationId;
+  }
+  /**
+   * 匹配 Mutation
+   */
+  matchMutation(t, e) {
+    return !(e.mutationKey && t.options.mutationKey && !this.matchKeys(t.options.mutationKey, e.mutationKey, e.exact) || e.status && t.state.status !== e.status || e.predicate && !e.predicate(t));
+  }
+  /**
+   * 匹配键
+   */
+  matchKeys(t, e, s) {
+    return s ? JSON.stringify(t) === JSON.stringify(e) : JSON.stringify(t).startsWith(JSON.stringify(e));
+  }
+}, W = class {
+  constructor(t = {}) {
+    this.queryCache = t.queryCache || new T(), this.mutationCache = t.mutationCache || new j(), this.defaultOptions = t.defaultOptions || {};
+  }
+  /**
+   * 挂载（uni-app 不需要特殊处理）
+   */
+  mount() {
+  }
+  /**
+   * 卸载
+   */
+  unmount() {
+    this.queryCache.clear(), this.mutationCache.clear();
+  }
+  /**
+   * 获取查询数据
+   */
+  getQueryData(t) {
+    const e = this.queryCache.find({ queryKey: t, exact: !0 });
+    return e == null ? void 0 : e.state.data;
+  }
+  /**
+   * 设置查询数据
+   */
+  setQueryData(t, e, s) {
+    const r = this.queryCache.find({ queryKey: t, exact: !0 });
+    if (!r)
+      return;
+    const u = r.state.data, a = typeof e == "function" ? e(u) : e;
+    return r.state = {
+      ...r.state,
+      data: a,
+      dataUpdatedAt: (s == null ? void 0 : s.updatedAt) || Date.now()
+    }, a;
+  }
+  /**
+   * 设置多个查询数据
+   */
+  setQueriesData(t, e, s) {
+    return this.queryCache.findAll(t).map((u) => {
+      const a = this.setQueryData(u.queryKey, e, s);
+      return [u.queryKey, a];
+    });
+  }
+  /**
+   * 获取查询状态
+   */
+  getQueryState(t) {
+    const e = this.queryCache.find({ queryKey: t, exact: !0 });
+    return e == null ? void 0 : e.state;
+  }
+  /**
+   * 获取多个查询数据
+   */
+  getQueriesData(t) {
+    return this.queryCache.findAll(t).map((s) => [s.queryKey, s.state.data]);
+  }
+  /**
+   * 获取查询
+   */
+  getQuery(t) {
+    return this.queryCache.find({ queryKey: t, exact: !0 });
+  }
+  /**
+   * 获取所有查询
+   */
+  getQueries(t = {}) {
+    return this.queryCache.findAll(t);
+  }
+  /**
+   * 获取所有 Mutations
+   */
+  getMutations(t = {}) {
+    return this.mutationCache.findAll(t);
+  }
+  /**
+   * 判断是否正在获取
+   */
+  isFetching(t = {}) {
+    return this.queryCache.findAll(t).filter((s) => s.state.fetchStatus === "fetching").length;
+  }
+  /**
+   * 判断是否正在执行 Mutation
+   */
+  isMutating(t = {}) {
+    return this.mutationCache.findAll(t).filter((s) => s.state.status === "loading").length;
+  }
+  /**
+   * 获取默认查询选项
+   */
+  defaultQueryOptions(t) {
+    return {
+      ...this.defaultOptions.queries || {},
+      ...t,
+      _defaulted: !0
+    };
+  }
+  /**
+   * 获取默认 Mutation 选项
+   */
+  defaultMutationOptions(t) {
+    return {
+      ...this.defaultOptions.mutations || {},
+      ...t
+    };
+  }
+  /**
+   * 设置默认选项
+   */
+  setDefaultOptions(t) {
+    this.defaultOptions = {
+      ...this.defaultOptions,
+      ...t
+    };
+  }
+  /**
+   * 设置查询默认值
+   */
+  setQueryDefaults(t, e) {
+  }
+  /**
+   * 获取查询默认值
+   */
+  getQueryDefaults(t) {
+    return {};
+  }
+  /**
+   * 设置 Mutation 默认值
+   */
+  setMutationDefaults(t, e) {
+  }
+  /**
+   * 获取 Mutation 默认值
+   */
+  getMutationDefaults(t) {
+    return {};
+  }
+  /**
+   * 获取查询数据（确保存在）
+   */
+  async ensureQueryData(t) {
+    const e = this.getQuery(t.queryKey);
+    return e && e.state.data !== void 0 ? e.state.data : this.fetchQuery(t);
+  }
+  /**
+   * 获取查询
+   */
+  async fetchQuery(t) {
+    const e = this.defaultQueryOptions(t), s = await e.queryFn({ queryKey: e.queryKey });
+    return e.select ? e.select(s) : s;
+  }
+  /**
+   * 预取查询
+   */
+  async prefetchQuery(t) {
+    await this.fetchQuery(t);
+  }
+  /**
+   * 获取无限查询
+   */
+  async fetchInfiniteQuery(t) {
+    return {
+      pages: [await t.queryFn({ queryKey: t.queryKey })],
+      pageParams: [t.initialPageParam]
+    };
+  }
+  /**
+   * 预取无限查询
+   */
+  async prefetchInfiniteQuery(t) {
+    await this.fetchInfiniteQuery(t);
+  }
+  /**
+   * 移除查询
+   */
+  removeQueries(t = {}) {
+    this.queryCache.findAll(t).forEach((s) => this.queryCache.remove(s));
+  }
+  /**
+   * 重置查询
+   */
+  async resetQueries(t = {}, e) {
+    this.queryCache.findAll(t).forEach((r) => {
+      r.state = {
+        ...r.state,
+        data: void 0,
+        error: null,
+        status: "pending",
+        fetchStatus: "idle"
+      };
+    });
+  }
+  /**
+   * 取消查询
+   */
+  async cancelQueries(t = {}, e) {
+  }
+  /**
+   * 使查询失效
+   */
+  async invalidateQueries(t = {}, e) {
+    this.queryCache.findAll(t).forEach((r) => {
+      r.state.isInvalidated = !0;
+    });
+  }
+  /**
+   * 重新获取查询
+   */
+  async refetchQueries(t = {}, e) {
+    const s = this.queryCache.findAll(t);
+    for (const r of s)
+      if (r.options.queryFn)
+        try {
+          const u = await r.options.queryFn({ queryKey: r.queryKey });
+          r.state = {
+            ...r.state,
+            data: u,
+            status: "success",
+            fetchStatus: "idle",
+            dataUpdatedAt: Date.now()
+          };
+        } catch (u) {
+          r.state = {
+            ...r.state,
+            error: u,
+            status: "error",
+            fetchStatus: "idle",
+            errorUpdatedAt: Date.now()
+          };
+        }
+  }
+};
+function Y(n) {
+  return JSON.stringify(n);
+}
+function O(n, t) {
+  return typeof n == "function" ? n(...t) : n === !0;
+}
+class b {
+  constructor(t, e) {
+    this.subscribers = /* @__PURE__ */ new Set(), this.client = t, this.options = e, this.query = this.client.getQuery(e.queryKey), this.query || this.createQuery(), this.currentResult = this.createResult(), e.enabled !== !1 && this.shouldFetch() && this.fetch().catch(() => {
+    });
+  }
+  /**
+   * 创建查询对象
+   */
+  createQuery() {
+    const t = Y(this.options.queryKey), e = {
+      queryKey: this.options.queryKey,
+      queryHash: t,
+      state: this.createInitialState(),
+      options: this.options
+    };
+    this.client.queryCache.add(e), this.query = e;
+  }
+  /**
+   * 判断是否应该获取数据
+   */
+  shouldFetch() {
+    if (!this.query)
+      return !0;
+    const t = this.query.state;
+    if (t.data === void 0)
+      return !0;
+    if (this.options.staleTime !== void 0 && this.options.staleTime > 0) {
+      const e = Date.now(), s = this.options.staleTime;
+      if (e - t.dataUpdatedAt > s)
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * 订阅结果变化
+   */
+  subscribe(t) {
+    return this.subscribers.add(t), t(this.currentResult), () => {
+      this.subscribers.delete(t);
+    };
+  }
+  /**
+   * 获取当前结果
+   */
+  getCurrentResult() {
+    return this.currentResult;
+  }
+  /**
+   * 获取乐观结果
+   */
+  getOptimisticResult(t) {
+    return this.createResult();
+  }
+  /**
+   * 获取当前查询
+   */
+  getCurrentQuery() {
+    return this.query;
+  }
+  /**
+   * 设置选项
+   */
+  setOptions(t) {
+    this.options = t, this.query = this.client.getQuery(t.queryKey), this.query || this.createQuery(), this.updateResult(), t.enabled !== !1 && this.shouldFetch() && this.fetch().catch(() => {
+    });
+  }
+  /**
+   * 获取乐观结果（用于 suspense）
+   */
+  fetchOptimistic(t) {
+    return this.fetch();
+  }
+  /**
+   * 获取数据
+   */
+  async fetch() {
+    if (!this.options.queryFn)
+      throw new Error("queryFn is required");
+    this.query || this.createQuery(), this.query && (this.query.state = {
+      ...this.query.state,
+      fetchStatus: "fetching"
+    }, this.updateResult());
+    try {
+      const t = await this.options.queryFn({ queryKey: this.options.queryKey }), e = this.options.select ? this.options.select(t) : t;
+      return this.query && (this.query.state = {
+        ...this.query.state,
+        data: e,
+        status: "success",
+        fetchStatus: "idle",
+        dataUpdatedAt: Date.now(),
+        error: null,
+        errorUpdateCount: 0,
+        failureCount: 0
+      }), this.updateResult(), this.currentResult;
+    } catch (t) {
+      if (this.query) {
+        const e = (this.query.state.errorUpdateCount || 0) + 1;
+        this.query.state = {
+          ...this.query.state,
+          error: t,
+          status: "error",
+          fetchStatus: "idle",
+          errorUpdatedAt: Date.now(),
+          errorUpdateCount: e,
+          failureCount: e,
+          failureReason: t
+        };
+      }
+      throw this.updateResult(), t;
+    }
+  }
+  /**
+   * 创建结果对象
+   */
+  createResult() {
+    var r;
+    const e = ((r = this.query) == null ? void 0 : r.state) || this.createInitialState();
+    return {
+      data: this.options.select && e.data ? this.options.select(e.data) : e.data,
+      dataUpdatedAt: e.dataUpdatedAt,
+      error: e.error,
+      errorUpdatedAt: e.errorUpdatedAt,
+      errorUpdateCount: e.errorUpdateCount,
+      failureCount: e.failureCount,
+      failureReason: e.failureReason,
+      fetchFailureCount: e.fetchFailureCount,
+      fetchFailureReason: e.fetchFailureReason,
+      fetchStatus: e.fetchStatus,
+      isError: e.status === "error",
+      isFetched: e.dataUpdatedAt > 0,
+      isFetchedAfterMount: e.dataUpdatedAt > 0 && e.fetchStatus !== "fetching",
+      isFetching: e.fetchStatus === "fetching",
+      isInitialLoading: e.status === "pending" && e.fetchStatus === "fetching",
+      isLoading: e.status === "pending",
+      isLoadingError: e.status === "error" && e.fetchStatus !== "fetching",
+      isPaused: e.fetchStatus === "paused",
+      isPlaceholderData: !1,
+      isRefetchError: e.status === "error" && e.fetchStatus === "fetching",
+      isRefetching: e.status === "success" && e.fetchStatus === "fetching",
+      isStale: this.isStale(e),
+      isSuccess: e.status === "success",
+      refetch: this.refetch.bind(this),
+      status: e.status
+    };
+  }
+  /**
+   * 创建初始状态
+   */
+  createInitialState() {
+    return {
+      data: void 0,
+      dataUpdatedAt: 0,
+      error: null,
+      errorUpdatedAt: 0,
+      errorUpdateCount: 0,
+      failureCount: 0,
+      failureReason: null,
+      fetchFailureCount: 0,
+      fetchFailureReason: null,
+      fetchMeta: void 0,
+      isInvalidated: !1,
+      status: "pending",
+      fetchStatus: "idle"
+    };
+  }
+  /**
+   * 判断是否过期
+   */
+  isStale(t) {
+    return this.options.staleTime ? Date.now() - t.dataUpdatedAt > this.options.staleTime : !0;
+  }
+  /**
+   * 更新结果并通知订阅者
+   */
+  updateResult() {
+    this.currentResult = this.createResult(), this.subscribers.forEach((t) => t(this.currentResult));
+  }
+  /**
+   * 重新获取
+   */
+  async refetch(t) {
+    return this.fetch();
+  }
+}
+class B {
+  constructor(t, e) {
+    this.subscribers = /* @__PURE__ */ new Set(), this.client = t, this.options = e, this.mutation = this.createMutation(), this.currentResult = this.createResult();
+  }
+  /**
+   * 订阅结果变化
+   */
+  subscribe(t) {
+    return this.subscribers.add(t), t(this.currentResult), () => {
+      this.subscribers.delete(t);
+    };
+  }
+  /**
+   * 获取当前结果
+   */
+  getCurrentResult() {
+    return this.currentResult;
+  }
+  /**
+   * 设置选项
+   */
+  setOptions(t) {
+    this.options = t, this.mutation.options = t, this.updateResult();
+  }
+  /**
+   * 执行 Mutation
+   */
+  async mutate(t, e) {
+    this.mutation.state = {
+      ...this.mutation.state,
+      status: "loading",
+      isLoading: !0,
+      variables: t
+    }, this.updateResult();
+    let s;
+    try {
+      this.options.onMutate && (s = await this.options.onMutate(t), this.mutation.state.context = s);
+      const r = await this.options.mutationFn(t);
+      return this.mutation.state = {
+        ...this.mutation.state,
+        data: r,
+        status: "success",
+        isLoading: !1,
+        isSuccess: !0,
+        isError: !1
+      }, this.updateResult(), this.options.onSuccess && await this.options.onSuccess(r, t, s), r;
+    } catch (r) {
+      throw this.mutation.state = {
+        ...this.mutation.state,
+        error: r,
+        status: "error",
+        isLoading: !1,
+        isSuccess: !1,
+        isError: !0,
+        failureCount: (this.mutation.state.failureCount || 0) + 1,
+        failureReason: r
+      }, this.updateResult(), this.options.onError && await this.options.onError(r, t, s), r;
+    } finally {
+      this.options.onSettled && await this.options.onSettled(
+        this.mutation.state.data,
+        this.mutation.state.error,
+        t,
+        s
+      );
+    }
+  }
+  /**
+   * 创建 Mutation
+   */
+  createMutation() {
+    return {
+      mutationId: this.client.mutationCache.generateMutationId(),
+      options: this.options,
+      state: this.createInitialResult()
+    };
+  }
+  /**
+   * 创建初始结果
+   */
+  createInitialResult() {
+    return {
+      data: void 0,
+      error: null,
+      failureCount: 0,
+      failureReason: null,
+      isError: !1,
+      isIdle: !0,
+      isPaused: !1,
+      isLoading: !1,
+      isSuccess: !1,
+      mutate: () => {
+      },
+      mutateAsync: async () => {
+        throw new Error("Not implemented");
+      },
+      reset: () => {
+      },
+      status: "idle",
+      variables: void 0,
+      context: void 0
+    };
+  }
+  /**
+   * 创建结果对象
+   */
+  createResult() {
+    return {
+      ...this.mutation.state,
+      mutate: (t, e) => {
+        this.mutate(t, e).catch(() => {
+        });
+      },
+      mutateAsync: (t, e) => this.mutate(t, e),
+      reset: () => {
+        this.mutation.state = this.createInitialResult(), this.updateResult();
+      }
+    };
+  }
+  /**
+   * 更新结果并通知订阅者
+   */
+  updateResult() {
+    this.currentResult = this.createResult(), this.subscribers.forEach((t) => t(this.currentResult));
+  }
+}
+class X extends b {
+  constructor(t, e) {
+    super(t, e), this.infiniteOptions = e;
+  }
+  /**
+   * 获取下一页
+   */
+  async fetchNextPage(t) {
+    return this.getCurrentResult();
+  }
+  /**
+   * 获取上一页
+   */
+  async fetchPreviousPage(t) {
+    return this.getCurrentResult();
+  }
+  /**
+   * 获取当前结果（覆盖父类方法）
+   */
+  getCurrentResult() {
+    const t = super.getCurrentResult(), e = t.data;
+    return {
+      ...t,
+      fetchNextPage: this.fetchNextPage.bind(this),
+      fetchPreviousPage: this.fetchPreviousPage.bind(this),
+      hasNextPage: this.hasNextPage(e),
+      hasPreviousPage: this.hasPreviousPage(e),
+      isFetchingNextPage: !1,
+      isFetchingPreviousPage: !1
+    };
+  }
+  /**
+   * 判断是否有下一页
+   */
+  hasNextPage(t) {
+    if (!t || !t.pages.length)
+      return !1;
+    const e = t.pages[t.pages.length - 1], s = this.infiniteOptions.getNextPageParam(e, t.pages);
+    return s != null;
+  }
+  /**
+   * 判断是否有上一页
+   */
+  hasPreviousPage(t) {
+    if (!t || !t.pages.length || !this.infiniteOptions.getPreviousPageParam)
+      return !1;
+    const e = t.pages[0], s = this.infiniteOptions.getPreviousPageParam(
+      e,
+      t.pages
+    );
+    return s != null;
+  }
+}
+class Z {
+  constructor(t, e, s) {
+    this.observers = [], this.subscribers = /* @__PURE__ */ new Set(), this.client = t, this.options = s || { queries: e }, this.observers = e.map((r) => {
+      const u = t.defaultQueryOptions(r);
+      return new b(t, u);
+    }), this.currentResult = this.getCombinedResult();
+  }
+  /**
+   * 订阅结果变化
+   */
+  subscribe(t) {
+    this.subscribers.add(t), t(this.currentResult);
+    const e = this.observers.map(
+      (s) => s.subscribe(() => {
+        this.currentResult = this.getCombinedResult(), this.subscribers.forEach((r) => r(this.currentResult));
+      })
+    );
+    return () => {
+      this.subscribers.delete(t), e.forEach((s) => s());
+    };
+  }
+  /**
+   * 获取乐观结果
+   */
+  getOptimisticResult(t, e) {
+    const s = t.map((u) => {
+      const a = this.client.defaultQueryOptions(u);
+      return new b(this.client, a).getCurrentResult();
+    }), r = e || this.options.combine || ((u) => u);
+    return [s, r];
+  }
+  /**
+   * 设置查询
+   */
+  setQueries(t, e) {
+    this.options = e || { queries: t }, this.observers = t.map((s) => {
+      const r = this.client.defaultQueryOptions(s);
+      return new b(this.client, r);
+    }), this.currentResult = this.getCombinedResult(), this.subscribers.forEach((s) => s(this.currentResult));
+  }
+  /**
+   * 获取组合结果
+   */
+  getCombinedResult() {
+    const t = this.observers.map((s) => s.getCurrentResult());
+    return (this.options.combine || ((s) => s))(t);
+  }
+}
+const z = "VUE_QUERY_CLIENT";
+function _(n) {
+  const t = n ? `:${n}` : "";
+  return `${z}${t}`;
+}
+function S(n, t) {
+  Object.keys(n).forEach((e) => {
+    n[e] = t[e];
+  });
+}
+function D(n, t, e = "", s = 0) {
+  if (t) {
+    const r = t(n, e, s);
+    if (r === void 0 && F(n) || r !== void 0)
+      return r;
+  }
+  if (Array.isArray(n))
+    return n.map(
+      (r, u) => D(r, t, String(u), s + 1)
+    );
+  if (typeof n == "object" && tt(n)) {
+    const r = Object.entries(n).map(([u, a]) => [
+      u,
+      D(a, t, u, s + 1)
+    ]);
+    return Object.fromEntries(r);
+  }
+  return n;
+}
+function G(n, t) {
+  return D(n, t);
+}
+function i(n, t = !1) {
+  return G(n, (e, s, r) => {
+    if (r === 1 && s === "queryKey")
+      return i(e, !0);
+    if (t && et(e))
+      return i(e(), t);
+    if (F(e))
+      return i(M(e), t);
+  });
+}
+function tt(n) {
+  if (Object.prototype.toString.call(n) !== "[object Object]")
+    return !1;
+  const t = Object.getPrototypeOf(n);
+  return t === null || t === Object.prototype;
+}
+function et(n) {
+  return typeof n == "function";
+}
+function q(n = "") {
+  if (!H())
+    throw new Error(
+      "vue-query hooks can only be used inside setup() function or functions that support injection context."
+    );
+  const t = _(n), e = L(t);
+  if (!e)
+    throw new Error(
+      "No 'queryClient' found in Vue context, use 'VueQueryPlugin' to properly initialize the library."
+    );
+  return e;
+}
+class st extends T {
+  find(t) {
+    return super.find(i(t));
+  }
+  findAll(t = {}) {
+    return super.findAll(i(t));
+  }
+}
+class rt extends j {
+  find(t) {
+    return super.find(i(t));
+  }
+  findAll(t = {}) {
+    return super.findAll(i(t));
+  }
+}
+class nt extends W {
+  constructor(t = {}) {
+    const e = {
+      defaultOptions: t.defaultOptions,
+      queryCache: t.queryCache || new st(),
+      mutationCache: t.mutationCache || new rt()
+    };
+    super(e);
+  }
+  // 移除 SSR isRestoring（uni-app 不需要）
+  isFetching(t = {}) {
+    return super.isFetching(i(t));
+  }
+  isMutating(t = {}) {
+    return super.isMutating(i(t));
+  }
+  getQueryData(t) {
+    return super.getQueryData(i(t));
+  }
+  ensureQueryData(t) {
+    return super.ensureQueryData(i(t));
+  }
+  getQueriesData(t) {
+    return super.getQueriesData(i(t));
+  }
+  setQueryData(t, e, s = {}) {
+    return super.setQueryData(
+      i(t),
+      e,
+      i(s)
+    );
+  }
+  setQueriesData(t, e, s = {}) {
+    return super.setQueriesData(
+      i(t),
+      e,
+      i(s)
+    );
+  }
+  getQueryState(t) {
+    return super.getQueryState(i(t));
+  }
+  removeQueries(t = {}) {
+    return super.removeQueries(i(t));
+  }
+  resetQueries(t = {}, e = {}) {
+    return super.resetQueries(i(t), i(e));
+  }
+  cancelQueries(t = {}, e = {}) {
+    return super.cancelQueries(i(t), i(e));
+  }
+  invalidateQueries(t = {}, e = {}) {
+    const s = i(t), r = i(e);
+    if (super.invalidateQueries(
+      { ...s, refetchType: "none" },
+      r
+    ), s.refetchType === "none")
+      return Promise.resolve();
+    const u = {
+      ...s,
+      type: s.refetchType ?? s.type ?? "active"
+    };
+    return J().then(() => super.refetchQueries(u, r));
+  }
+  refetchQueries(t = {}, e = {}) {
+    return super.refetchQueries(
+      i(t),
+      i(e)
+    );
+  }
+  fetchQuery(t) {
+    return super.fetchQuery(i(t));
+  }
+  prefetchQuery(t) {
+    return super.prefetchQuery(i(t));
+  }
+  fetchInfiniteQuery(t) {
+    return super.fetchInfiniteQuery(i(t));
+  }
+  prefetchInfiniteQuery(t) {
+    return super.prefetchInfiniteQuery(i(t));
+  }
+  setDefaultOptions(t) {
+    super.setDefaultOptions(i(t));
+  }
+  setQueryDefaults(t, e) {
+    const s = i(t), r = i(e);
+    super.setQueryDefaults(s, r);
+  }
+  getQueryDefaults(t) {
+    return super.getQueryDefaults(i(t));
+  }
+  setMutationDefaults(t, e) {
+    super.setMutationDefaults(
+      i(t),
+      i(e)
+    );
+  }
+  getMutationDefaults(t) {
+    return super.getMutationDefaults(i(t));
+  }
+}
+const ht = {
+  install: (n, t = {}) => {
+    var a;
+    const e = _(t.queryClientKey);
+    let s;
+    if ("queryClient" in t && t.queryClient)
+      s = t.queryClient;
+    else {
+      const h = "queryClientConfig" in t ? t.queryClientConfig : void 0;
+      s = new nt(h);
+    }
+    if (t.refetchOnShow !== !1 && typeof uni < "u" && uni.onShow) {
+      const h = () => {
+        s.refetchQueries({ type: "active" }).catch(() => {
+        });
+      };
+      uni.onShow(h);
+    }
+    const u = () => {
+    };
+    (a = n.onUnmount) == null || a.call(n, u), n.provide(e, s);
+  }
+};
+function lt(n) {
+  return n;
+}
+function ft(n) {
+  return n;
+}
+function V(n, t, e) {
+  process.env.NODE_ENV === "development" && (C() || 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 = e || q(), r = Q(() => {
+    let o = t;
+    typeof o == "function" && (o = o());
+    const g = i(o);
+    typeof g.enabled == "function" && (g.enabled = g.enabled());
+    const m = s.defaultQueryOptions(g);
+    return m._optimisticResults = "optimistic", m;
+  }), u = new n(s, r.value), a = r.value.shallow ? I(u.getCurrentResult()) : U(u.getCurrentResult());
+  let h = () => {
+  };
+  h = u.subscribe((o) => {
+    S(a, o);
+  });
+  const f = () => {
+    u.setOptions(r.value), S(a, u.getCurrentResult());
+  };
+  y(r, f), v(() => {
+    h();
+  });
+  const p = (...o) => (f(), a.refetch(...o)), d = () => new Promise(
+    (o, g) => {
+      let m = () => {
+      };
+      const E = () => {
+        if (r.value.enabled !== !1) {
+          u.setOptions(r.value);
+          const A = u.getOptimisticResult(
+            r.value
+          );
+          A.isStale ? (m(), u.fetchOptimistic(r.value).then(o, (K) => {
+            O(r.value.throwOnError, [
+              K,
+              u.getCurrentQuery()
+            ]) ? g(K) : o(u.getCurrentResult());
+          })) : (m(), o(A));
+        }
+      };
+      E(), m = y(r, E);
+    }
+  );
+  y(
+    () => a.error,
+    (o) => {
+      if (a.isError && !a.isFetching && O(r.value.throwOnError, [
+        o,
+        u.getCurrentQuery()
+      ]))
+        throw o;
+    }
+  );
+  const c = r.value.shallow ? R(a) : P(a), l = x(c);
+  for (const o in a)
+    typeof a[o] == "function" && (l[o] = a[o]);
+  return l.suspense = d, l.refetch = p, l;
+}
+function dt(n, t) {
+  return V(b, n, t);
+}
+function yt({
+  queries: n,
+  ...t
+}, e) {
+  process.env.NODE_ENV === "development" && (C() || 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 = e || q(), r = Q(() => {
+    const f = typeof n == "function" ? n() : n;
+    return M(f).map((d) => {
+      const c = i(d);
+      typeof c.enabled == "function" && (c.enabled = d.enabled());
+      const l = s.defaultQueryOptions(c);
+      return l._optimisticResults = "optimistic", l;
+    });
+  }), u = new Z(
+    s,
+    r.value,
+    t
+  ), a = () => {
+    const [f, p] = u.getOptimisticResult(
+      r.value,
+      t.combine
+    );
+    return p(
+      f.map((d, c) => ({
+        ...d,
+        refetch: async (...l) => {
+          const [{ [c]: o }] = u.getOptimisticResult(
+            r.value,
+            t.combine
+          );
+          return o.refetch(...l);
+        }
+      }))
+    );
+  }, h = N(a());
+  return y(r, (f) => {
+    u.setQueries(
+      f,
+      t
+    ), h.value = a();
+  }), v(() => {
+  }), t.shallow ? R(h) : P(h);
+}
+function pt(n, t) {
+  return V(
+    X,
+    n,
+    t
+  );
+}
+function gt(n, t) {
+  process.env.NODE_ENV === "development" && (C() || 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 e = t || q(), s = Q(() => {
+    const c = typeof n == "function" ? n() : n;
+    return e.defaultMutationOptions(i(c));
+  }), r = new B(e, s.value), u = s.value.shallow ?? !1, a = u ? I(r.getCurrentResult()) : U(r.getCurrentResult()), h = r.subscribe((c) => {
+    S(a, c);
+  }), f = (c, l) => {
+    r.mutate(c, l).catch(() => {
+    });
+  };
+  y(s, () => {
+    r.setOptions(s.value);
+  }), v(() => {
+    h();
+  });
+  const p = u ? R(a) : P(a), d = x(p);
+  return y(
+    () => a.error,
+    (c) => {
+      if (c && O(s.value.throwOnError, [c, void 0]))
+        throw c;
+    }
+  ), {
+    ...d,
+    mutate: f,
+    mutateAsync: a.mutateAsync,
+    reset: a.reset
+  };
+}
+function mt(n = {}, t) {
+  process.env.NODE_ENV === "development" && (C() || 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 e = t || q(), s = $(), r = () => {
+    const a = typeof n == "function" ? n() : n;
+    s.value = e.isFetching(i(a));
+  }, u = e.queryCache.subscribe(r);
+  return k(r), v(() => {
+    u();
+  }), s;
+}
+function Qt(n = {}, t) {
+  process.env.NODE_ENV === "development" && (C() || 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 e = t || q(), s = ut(
+    {
+      filters: Q(() => ({
+        ...i(typeof n == "function" ? n() : n),
+        status: "pending"
+      }))
+    },
+    e
+  );
+  return Q(() => s.value.length);
+}
+function w(n, t) {
+  return n.findAll(t.filters).map(
+    (e) => t.select ? t.select(e) : e.state
+  );
+}
+function ut(n = {}, t) {
+  const e = Q(() => {
+    const a = typeof n == "function" ? n() : n;
+    return {
+      filters: i(a.filters),
+      select: a.select
+    };
+  }), s = (t || q()).mutationCache, r = N(w(s, e.value)), u = s.subscribe(() => {
+    r.value = w(s, e.value);
+  });
+  return y(e, () => {
+    r.value = w(s, e.value);
+  }), v(() => {
+    u();
+  }), R(r);
+}
+export {
+  X as InfiniteQueryObserver,
+  rt as MutationCache,
+  B as MutationObserver,
+  Z as QueriesObserver,
+  st as QueryCache,
+  nt as QueryClient,
+  b as QueryObserver,
+  ht as UniQueryPlugin,
+  z as VUE_QUERY_CLIENT,
+  ht as VueQueryPlugin,
+  Y as hashQueryKey,
+  ft as infiniteQueryOptions,
+  lt as queryOptions,
+  O as shouldThrowError,
+  pt as useInfiniteQuery,
+  mt as useIsFetching,
+  Qt as useIsMutating,
+  gt as useMutation,
+  ut as useMutationState,
+  yt as useQueries,
+  dt as useQuery,
+  q as useQueryClient
+};