@tanstack/vue-query/build/legacy/useBaseQuery.cjs

Hooks for managing, caching and syncing asynchronous and remote data in Vue

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/useBaseQuery.ts
var useBaseQuery_exports = {};
__export(useBaseQuery_exports, {
  useBaseQuery: () => useBaseQuery
});
module.exports = __toCommonJS(useBaseQuery_exports);
var import_vue_demi = require("vue-demi");
var import_query_core = require("@tanstack/query-core");
var import_useQueryClient = require("./useQueryClient.cjs");
var import_utils = require("./utils.cjs");
function useBaseQuery(Observer, options, queryClient) {
  if (process.env.NODE_ENV === "development") {
    if (!(0, import_vue_demi.getCurrentScope)()) {
      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 client = queryClient || (0, import_useQueryClient.useQueryClient)();
  const defaultedOptions = (0, import_vue_demi.computed)(() => {
    var _a;
    const clonedOptions = (0, import_utils.cloneDeepUnref)(options);
    if (typeof clonedOptions.enabled === "function") {
      clonedOptions.enabled = clonedOptions.enabled();
    }
    const defaulted = client.defaultQueryOptions(clonedOptions);
    defaulted._optimisticResults = ((_a = client.isRestoring) == null ? void 0 : _a.value) ? "isRestoring" : "optimistic";
    return defaulted;
  });
  const observer = new Observer(client, defaultedOptions.value);
  const state = defaultedOptions.value.shallow ? (0, import_vue_demi.shallowReactive)(observer.getCurrentResult()) : (0, import_vue_demi.reactive)(observer.getCurrentResult());
  let unsubscribe = () => {
  };
  if (client.isRestoring) {
    (0, import_vue_demi.watch)(
      client.isRestoring,
      (isRestoring) => {
        if (!isRestoring) {
          unsubscribe();
          unsubscribe = observer.subscribe((result) => {
            (0, import_utils.updateState)(state, result);
          });
        }
      },
      { immediate: true }
    );
  }
  const updater = () => {
    observer.setOptions(defaultedOptions.value);
    (0, import_utils.updateState)(state, observer.getCurrentResult());
  };
  (0, import_vue_demi.watch)(defaultedOptions, updater);
  (0, import_vue_demi.onScopeDispose)(() => {
    unsubscribe();
  });
  const refetch = (...args) => {
    updater();
    return state.refetch(...args);
  };
  const suspense = () => {
    return new Promise(
      (resolve, reject) => {
        let stopWatch = () => {
        };
        const run = () => {
          if (defaultedOptions.value.enabled !== false) {
            observer.setOptions(defaultedOptions.value);
            const optimisticResult = observer.getOptimisticResult(
              defaultedOptions.value
            );
            if (optimisticResult.isStale) {
              stopWatch();
              observer.fetchOptimistic(defaultedOptions.value).then(resolve, (error) => {
                if ((0, import_query_core.shouldThrowError)(defaultedOptions.value.throwOnError, [
                  error,
                  observer.getCurrentQuery()
                ])) {
                  reject(error);
                } else {
                  resolve(observer.getCurrentResult());
                }
              });
            } else {
              stopWatch();
              resolve(optimisticResult);
            }
          }
        };
        run();
        stopWatch = (0, import_vue_demi.watch)(defaultedOptions, run);
      }
    );
  };
  (0, import_vue_demi.watch)(
    () => state.error,
    (error) => {
      if (state.isError && !state.isFetching && (0, import_query_core.shouldThrowError)(defaultedOptions.value.throwOnError, [
        error,
        observer.getCurrentQuery()
      ])) {
        throw error;
      }
    }
  );
  const readonlyState = defaultedOptions.value.shallow ? (0, import_vue_demi.shallowReadonly)(state) : (0, import_vue_demi.readonly)(state);
  const object = (0, import_vue_demi.toRefs)(readonlyState);
  for (const key in state) {
    if (typeof state[key] === "function") {
      object[key] = state[key];
    }
  }
  object.suspense = suspense;
  object.refetch = refetch;
  return object;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  useBaseQuery
});
//# sourceMappingURL=useBaseQuery.cjs.map