@tanstack/vue-query 5.0.0-alpha.50 → 5.0.0-alpha.51

package/build/lib/queryCache.mjs

@@ -1,14 +0,0 @@
-import { QueryCache as QueryCache$1 } from '@tanstack/query-core';
-import { cloneDeepUnref } from './utils.mjs';
-
-class QueryCache extends QueryCache$1 {
-  find(filters) {
-    return super.find(cloneDeepUnref(filters));
-  }
-  findAll(filters = {}) {
-    return super.findAll(cloneDeepUnref(filters));
-  }
-}
-
-export { QueryCache };
-//# sourceMappingURL=queryCache.mjs.map

package/build/lib/queryClient.mjs

@@ -1,84 +0,0 @@
-import { ref } from 'vue-demi';
-import { QueryClient as QueryClient$1 } from '@tanstack/query-core';
-import { cloneDeepUnref } from './utils.mjs';
-import { QueryCache } from './queryCache.mjs';
-import { MutationCache } from './mutationCache.mjs';
-
-class QueryClient extends QueryClient$1 {
-  constructor(config = {}) {
-    const unreffedConfig = cloneDeepUnref(config);
-    const vueQueryConfig = {
-      defaultOptions: unreffedConfig.defaultOptions,
-      queryCache: unreffedConfig.queryCache || new QueryCache(),
-      mutationCache: unreffedConfig.mutationCache || new MutationCache()
-    };
-    super(vueQueryConfig);
-  }
-  isRestoring = ref(false);
-  isFetching(filters = {}) {
-    return super.isFetching(cloneDeepUnref(filters));
-  }
-  isMutating(filters = {}) {
-    return super.isMutating(cloneDeepUnref(filters));
-  }
-  getQueryData(queryKey) {
-    return super.getQueryData(cloneDeepUnref(queryKey));
-  }
-  getQueriesData(filters) {
-    return super.getQueriesData(cloneDeepUnref(filters));
-  }
-  setQueryData(queryKey, updater, options = {}) {
-    return super.setQueryData(cloneDeepUnref(queryKey), updater, cloneDeepUnref(options));
-  }
-  setQueriesData(filters, updater, options = {}) {
-    return super.setQueriesData(cloneDeepUnref(filters), updater, cloneDeepUnref(options));
-  }
-  getQueryState(queryKey) {
-    return super.getQueryState(cloneDeepUnref(queryKey));
-  }
-  removeQueries(filters = {}) {
-    return super.removeQueries(cloneDeepUnref(filters));
-  }
-  resetQueries(filters = {}, options = {}) {
-    return super.resetQueries(cloneDeepUnref(filters), cloneDeepUnref(options));
-  }
-  cancelQueries(filters = {}, options = {}) {
-    return super.cancelQueries(cloneDeepUnref(filters), cloneDeepUnref(options));
-  }
-  invalidateQueries(filters = {}, options = {}) {
-    return super.invalidateQueries(cloneDeepUnref(filters), cloneDeepUnref(options));
-  }
-  refetchQueries(filters = {}, options = {}) {
-    return super.refetchQueries(cloneDeepUnref(filters), cloneDeepUnref(options));
-  }
-  fetchQuery(options) {
-    return super.fetchQuery(cloneDeepUnref(options));
-  }
-  prefetchQuery(options) {
-    return super.prefetchQuery(cloneDeepUnref(options));
-  }
-  fetchInfiniteQuery(options) {
-    return super.fetchInfiniteQuery(cloneDeepUnref(options));
-  }
-  prefetchInfiniteQuery(options) {
-    return super.prefetchInfiniteQuery(cloneDeepUnref(options));
-  }
-  setDefaultOptions(options) {
-    super.setDefaultOptions(cloneDeepUnref(options));
-  }
-  setQueryDefaults(queryKey, options) {
-    super.setQueryDefaults(cloneDeepUnref(queryKey), cloneDeepUnref(options));
-  }
-  getQueryDefaults(queryKey) {
-    return super.getQueryDefaults(cloneDeepUnref(queryKey));
-  }
-  setMutationDefaults(mutationKey, options) {
-    super.setMutationDefaults(cloneDeepUnref(mutationKey), cloneDeepUnref(options));
-  }
-  getMutationDefaults(mutationKey) {
-    return super.getMutationDefaults(cloneDeepUnref(mutationKey));
-  }
-}
-
-export { QueryClient };
-//# sourceMappingURL=queryClient.mjs.map

package/build/lib/useIsFetching.mjs

@@ -1,24 +0,0 @@
-import { computed, ref, watch, onScopeDispose } from 'vue-demi';
-import { useQueryClient } from './useQueryClient.mjs';
-import { cloneDeepUnref } from './utils.mjs';
-
-function useIsFetching(fetchingFilters = {}, queryClient) {
-  const filters = computed(() => cloneDeepUnref(fetchingFilters));
-  const client = queryClient || useQueryClient();
-  const isFetching = ref(client.isFetching(filters));
-  const unsubscribe = client.getQueryCache().subscribe(() => {
-    isFetching.value = client.isFetching(filters);
-  });
-  watch(filters, () => {
-    isFetching.value = client.isFetching(filters);
-  }, {
-    deep: true
-  });
-  onScopeDispose(() => {
-    unsubscribe();
-  });
-  return isFetching;
-}
-
-export { useIsFetching };
-//# sourceMappingURL=useIsFetching.mjs.map

package/build/lib/useMutation.mjs

@@ -1,39 +0,0 @@
-import { computed, reactive, watch, onScopeDispose, toRefs, readonly } from 'vue-demi';
-import { MutationObserver } from '@tanstack/query-core';
-import { cloneDeepUnref, updateState } from './utils.mjs';
-import { useQueryClient } from './useQueryClient.mjs';
-
-function useMutation(mutationOptions, queryClient) {
-  const client = queryClient || useQueryClient();
-  const options = computed(() => {
-    return client.defaultMutationOptions(cloneDeepUnref(mutationOptions));
-  });
-  const observer = new MutationObserver(client, options.value);
-  const state = reactive(observer.getCurrentResult());
-  const unsubscribe = observer.subscribe(result => {
-    updateState(state, result);
-  });
-  const mutate = (variables, mutateOptions) => {
-    observer.mutate(variables, mutateOptions).catch(() => {
-      // This is intentional
-    });
-  };
-  watch(options, () => {
-    observer.setOptions(options.value);
-  }, {
-    deep: true
-  });
-  onScopeDispose(() => {
-    unsubscribe();
-  });
-  const resultRefs = toRefs(readonly(state));
-  return {
-    ...resultRefs,
-    mutate,
-    mutateAsync: state.mutate,
-    reset: state.reset
-  };
-}
-
-export { useMutation };
-//# sourceMappingURL=useMutation.mjs.map

package/build/lib/useMutationState.mjs

@@ -1,33 +0,0 @@
-import { computed, ref, onScopeDispose, readonly } from 'vue-demi';
-import { useQueryClient } from './useQueryClient.mjs';
-import { cloneDeepUnref } from './utils.mjs';
-
-function useIsMutating(filters = {}, queryClient) {
-  const client = queryClient || useQueryClient();
-  const unreffedFilters = computed(() => ({
-    ...cloneDeepUnref(filters),
-    status: 'pending'
-  }));
-  const length = computed(() => useMutationState({
-    filters: unreffedFilters
-  }, client).value.length);
-  return length;
-}
-function getResult(mutationCache, options) {
-  return mutationCache.findAll(options.filters).map(mutation => options.select ? options.select(mutation) : mutation.state);
-}
-function useMutationState(options = {}, queryClient) {
-  const mutationCache = (queryClient || useQueryClient()).getMutationCache();
-  const state = ref(getResult(mutationCache, options));
-  const unsubscribe = mutationCache.subscribe(() => {
-    const result = getResult(mutationCache, options);
-    state.value = result;
-  });
-  onScopeDispose(() => {
-    unsubscribe();
-  });
-  return readonly(state);
-}
-
-export { useIsMutating, useMutationState };
-//# sourceMappingURL=useMutationState.mjs.map

package/build/lib/useQuery.mjs

@@ -1,13 +0,0 @@
-import { QueryObserver } from '@tanstack/query-core';
-import { useBaseQuery } from './useBaseQuery.mjs';
-
-function useQuery(options, queryClient) {
-  const result = useBaseQuery(QueryObserver, options, queryClient);
-  return {
-    ...result,
-    refetch: result.refetch.value
-  };
-}
-
-export { useQuery };
-//# sourceMappingURL=useQuery.mjs.map