@tanstack/react-query-persist-client 4.0.11-beta.0 → 4.2.1

package/build/types/packages/react-query/src/useIsMutating.d.ts

@@ -0,0 +1,7 @@
+import { MutationKey, MutationFilters } from '@tanstack/query-core';
+import { ContextOptions } from './types';
+interface Options extends ContextOptions {
+}
+export declare function useIsMutating(filters?: MutationFilters, options?: Options): number;
+export declare function useIsMutating(mutationKey?: MutationKey, filters?: Omit<MutationFilters, 'mutationKey'>, options?: Options): number;
+export {};

package/build/types/packages/react-query/src/useMutation.d.ts

@@ -0,0 +1,6 @@
+import { MutationFunction, MutationKey } from '@tanstack/query-core';
+import { UseMutationOptions, UseMutationResult } from './types';
+export declare function useMutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(options: UseMutationOptions<TData, TError, TVariables, TContext>): UseMutationResult<TData, TError, TVariables, TContext>;
+export declare function useMutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(mutationFn: MutationFunction<TData, TVariables>, options?: Omit<UseMutationOptions<TData, TError, TVariables, TContext>, 'mutationFn'>): UseMutationResult<TData, TError, TVariables, TContext>;
+export declare function useMutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(mutationKey: MutationKey, options?: Omit<UseMutationOptions<TData, TError, TVariables, TContext>, 'mutationKey'>): UseMutationResult<TData, TError, TVariables, TContext>;
+export declare function useMutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(mutationKey: MutationKey, mutationFn?: MutationFunction<TData, TVariables>, options?: Omit<UseMutationOptions<TData, TError, TVariables, TContext>, 'mutationKey' | 'mutationFn'>): UseMutationResult<TData, TError, TVariables, TContext>;

package/build/types/packages/react-query/src/useQueries.d.ts

@@ -0,0 +1,49 @@
+import { QueryKey, QueryFunction } from '@tanstack/query-core';
+import { UseQueryOptions, UseQueryResult } from './types';
+declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'context'>;
+declare type MAXIMUM_DEPTH = 20;
+declare type GetOptions<T> = T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+    select: (data: any) => infer TData;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown, TData, TQueryKey> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown, TQueryFnData, TQueryKey> : UseQueryOptionsForUseQueries;
+declare type GetResults<T> = T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? UseQueryResult<TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseQueryResult<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryResult<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<unknown, any>;
+    select: (data: any) => infer TData;
+} ? UseQueryResult<TData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any>;
+} ? UseQueryResult<TQueryFnData> : UseQueryResult;
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+export declare type QueriesOptions<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? UseQueryOptionsForUseQueries[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[...Tail], [...Result, GetOptions<Head>], [...Depth, 1]> : unknown[] extends T ? T : T extends UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>[] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>[] : UseQueryOptionsForUseQueries[];
+/**
+ * QueriesResults reducer recursively maps type param to results
+ */
+export declare type QueriesResults<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? UseQueryResult[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]> : T extends UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, any>[] ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>[] : UseQueryResult[];
+export declare function useQueries<T extends any[]>({ queries, context, }: {
+    queries: readonly [...QueriesOptions<T>];
+    context?: UseQueryOptions['context'];
+}): QueriesResults<T>;
+export {};

package/build/types/packages/react-query/src/useQuery.d.ts

@@ -0,0 +1,23 @@
+import { QueryFunction, QueryKey } from '@tanstack/query-core';
+import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from './types';
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'initialData'> & {
+    initialData?: () => undefined;
+}): UseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'initialData'> & {
+    initialData: TQueryFnData | (() => TQueryFnData);
+}): DefinedUseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>): UseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'initialData'> & {
+    initialData?: () => undefined;
+}): UseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'initialData'> & {
+    initialData: TQueryFnData | (() => TQueryFnData);
+}): DefinedUseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'>): UseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'queryFn' | 'initialData'> & {
+    initialData?: () => undefined;
+}): UseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'queryFn' | 'initialData'> & {
+    initialData: TQueryFnData | (() => TQueryFnData);
+}): DefinedUseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'queryFn'>): UseQueryResult<TData, TError>;

package/build/types/packages/react-query/src/utils.d.ts

@@ -0,0 +1 @@
+export declare function shouldThrowError<T extends (...args: any[]) => boolean>(_useErrorBoundary: boolean | T | undefined, params: Parameters<T>): boolean;

package/build/types/packages/react-query-persist-client/src/__tests__/PersistQueryClientProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/packages/react-query-persist-client/src/__tests__/persist.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/tests/utils.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="jest" />
+/// <reference types="node" />
+import { MutationOptions, QueryClient, QueryClientConfig } from '@tanstack/query-core';
+export declare function createQueryClient(config?: QueryClientConfig): QueryClient;
+export declare function mockVisibilityState(value: DocumentVisibilityState): jest.SpyInstance<DocumentVisibilityState, []>;
+export declare function mockNavigatorOnLine(value: boolean): jest.SpyInstance<boolean, []>;
+export declare const mockLogger: {
+    log: jest.Mock<any, any>;
+    warn: jest.Mock<any, any>;
+    error: jest.Mock<any, any>;
+};
+export declare function queryKey(): Array<string>;
+export declare function sleep(timeout: number): Promise<void>;
+export declare function setActTimeout(fn: () => void, ms?: number): NodeJS.Timeout;
+/**
+ * Assert the parameter is of a specific type.
+ */
+export declare const expectType: <T>(_: T) => void;
+/**
+ * Assert the parameter is not typed as `any`
+ */
+export declare const expectTypeNotAny: <T>(_: 0 extends 1 & T ? never : T) => void;
+export declare const executeMutation: (queryClient: QueryClient, options: MutationOptions<any, any, any, any>) => Promise<unknown>;
+export declare function setIsServer(isServer: boolean): () => void;

package/build/umd/index.development.js

@@ -9,10 +9,10 @@
  * @license MIT
  */
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@tanstack/query-core'), require('react'), require('@tanstack/react-query')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@tanstack/query-core', 'react', '@tanstack/react-query'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactQueryPersistClient = {}, global.QueryCore, global.React, global.ReactQuery));
-})(this, (function (exports, queryCore, React, reactQuery) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('@tanstack/react-query')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', '@tanstack/react-query'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactQueryPersistClient = {}, global.React, global.ReactQuery));
+})(this, (function (exports, React, reactQuery) { 'use strict';
 
   function _interopNamespace(e) {
     if (e && e.__esModule) return e;
@@ -34,6 +34,303 @@
 
   var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
+  /**
+   * query-core
+   *
+   * Copyright (c) TanStack
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE.md file in the root directory of this source tree.
+   *
+   * @license MIT
+   */
+  class Subscribable {
+    constructor() {
+      this.listeners = [];
+      this.subscribe = this.subscribe.bind(this);
+    }
+
+    subscribe(listener) {
+      this.listeners.push(listener);
+      this.onSubscribe();
+      return () => {
+        this.listeners = this.listeners.filter(x => x !== listener);
+        this.onUnsubscribe();
+      };
+    }
+
+    hasListeners() {
+      return this.listeners.length > 0;
+    }
+
+    onSubscribe() {// Do nothing
+    }
+
+    onUnsubscribe() {// Do nothing
+    }
+
+  }
+
+  // TYPES
+  // UTILS
+  const isServer = typeof window === 'undefined';
+
+  class FocusManager extends Subscribable {
+    constructor() {
+      super();
+
+      this.setup = onFocus => {
+        // addEventListener does not exist in React Native, but window does
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!isServer && window.addEventListener) {
+          const listener = () => onFocus(); // Listen to visibillitychange and focus
+
+
+          window.addEventListener('visibilitychange', listener, false);
+          window.addEventListener('focus', listener, false);
+          return () => {
+            // Be sure to unsubscribe if a new handler is set
+            window.removeEventListener('visibilitychange', listener);
+            window.removeEventListener('focus', listener);
+          };
+        }
+      };
+    }
+
+    onSubscribe() {
+      if (!this.cleanup) {
+        this.setEventListener(this.setup);
+      }
+    }
+
+    onUnsubscribe() {
+      if (!this.hasListeners()) {
+        var _this$cleanup;
+
+        (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
+        this.cleanup = undefined;
+      }
+    }
+
+    setEventListener(setup) {
+      var _this$cleanup2;
+
+      this.setup = setup;
+      (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
+      this.cleanup = setup(focused => {
+        if (typeof focused === 'boolean') {
+          this.setFocused(focused);
+        } else {
+          this.onFocus();
+        }
+      });
+    }
+
+    setFocused(focused) {
+      this.focused = focused;
+
+      if (focused) {
+        this.onFocus();
+      }
+    }
+
+    onFocus() {
+      this.listeners.forEach(listener => {
+        listener();
+      });
+    }
+
+    isFocused() {
+      if (typeof this.focused === 'boolean') {
+        return this.focused;
+      } // document global can be unavailable in react native
+
+
+      if (typeof document === 'undefined') {
+        return true;
+      }
+
+      return [undefined, 'visible', 'prerender'].includes(document.visibilityState);
+    }
+
+  }
+  new FocusManager();
+
+  class OnlineManager extends Subscribable {
+    constructor() {
+      super();
+
+      this.setup = onOnline => {
+        // addEventListener does not exist in React Native, but window does
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!isServer && window.addEventListener) {
+          const listener = () => onOnline(); // Listen to online
+
+
+          window.addEventListener('online', listener, false);
+          window.addEventListener('offline', listener, false);
+          return () => {
+            // Be sure to unsubscribe if a new handler is set
+            window.removeEventListener('online', listener);
+            window.removeEventListener('offline', listener);
+          };
+        }
+      };
+    }
+
+    onSubscribe() {
+      if (!this.cleanup) {
+        this.setEventListener(this.setup);
+      }
+    }
+
+    onUnsubscribe() {
+      if (!this.hasListeners()) {
+        var _this$cleanup;
+
+        (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
+        this.cleanup = undefined;
+      }
+    }
+
+    setEventListener(setup) {
+      var _this$cleanup2;
+
+      this.setup = setup;
+      (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
+      this.cleanup = setup(online => {
+        if (typeof online === 'boolean') {
+          this.setOnline(online);
+        } else {
+          this.onOnline();
+        }
+      });
+    }
+
+    setOnline(online) {
+      this.online = online;
+
+      if (online) {
+        this.onOnline();
+      }
+    }
+
+    onOnline() {
+      this.listeners.forEach(listener => {
+        listener();
+      });
+    }
+
+    isOnline() {
+      if (typeof this.online === 'boolean') {
+        return this.online;
+      }
+
+      if (typeof navigator === 'undefined' || typeof navigator.onLine === 'undefined') {
+        return true;
+      }
+
+      return navigator.onLine;
+    }
+
+  }
+  new OnlineManager();
+
+  // TYPES
+  // FUNCTIONS
+  function dehydrateMutation(mutation) {
+    return {
+      mutationKey: mutation.options.mutationKey,
+      state: mutation.state
+    };
+  } // Most config is not dehydrated but instead meant to configure again when
+  // consuming the de/rehydrated data, typically with useQuery on the client.
+  // Sometimes it might make sense to prefetch data on the server and include
+  // in the html-payload, but not consume it on the initial render.
+
+
+  function dehydrateQuery(query) {
+    return {
+      state: query.state,
+      queryKey: query.queryKey,
+      queryHash: query.queryHash
+    };
+  }
+
+  function defaultShouldDehydrateMutation(mutation) {
+    return mutation.state.isPaused;
+  }
+
+  function defaultShouldDehydrateQuery(query) {
+    return query.state.status === 'success';
+  }
+
+  function dehydrate(client, options = {}) {
+    const mutations = [];
+    const queries = [];
+
+    if (options.dehydrateMutations !== false) {
+      const shouldDehydrateMutation = options.shouldDehydrateMutation || defaultShouldDehydrateMutation;
+      client.getMutationCache().getAll().forEach(mutation => {
+        if (shouldDehydrateMutation(mutation)) {
+          mutations.push(dehydrateMutation(mutation));
+        }
+      });
+    }
+
+    if (options.dehydrateQueries !== false) {
+      const shouldDehydrateQuery = options.shouldDehydrateQuery || defaultShouldDehydrateQuery;
+      client.getQueryCache().getAll().forEach(query => {
+        if (shouldDehydrateQuery(query)) {
+          queries.push(dehydrateQuery(query));
+        }
+      });
+    }
+
+    return {
+      mutations,
+      queries
+    };
+  }
+  function hydrate(client, dehydratedState, options) {
+    if (typeof dehydratedState !== 'object' || dehydratedState === null) {
+      return;
+    }
+
+    const mutationCache = client.getMutationCache();
+    const queryCache = client.getQueryCache(); // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+
+    const mutations = dehydratedState.mutations || []; // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+
+    const queries = dehydratedState.queries || [];
+    mutations.forEach(dehydratedMutation => {
+      var _options$defaultOptio;
+
+      mutationCache.build(client, { ...(options == null ? void 0 : (_options$defaultOptio = options.defaultOptions) == null ? void 0 : _options$defaultOptio.mutations),
+        mutationKey: dehydratedMutation.mutationKey
+      }, dehydratedMutation.state);
+    });
+    queries.forEach(dehydratedQuery => {
+      var _options$defaultOptio2;
+
+      const query = queryCache.get(dehydratedQuery.queryHash); // Do not hydrate if an existing query exists with newer data
+
+      if (query) {
+        if (query.state.dataUpdatedAt < dehydratedQuery.state.dataUpdatedAt) {
+          query.setState(dehydratedQuery.state);
+        }
+
+        return;
+      } // Restore query
+
+
+      queryCache.build(client, { ...(options == null ? void 0 : (_options$defaultOptio2 = options.defaultOptions) == null ? void 0 : _options$defaultOptio2.queries),
+        queryKey: dehydratedQuery.queryKey,
+        queryHash: dehydratedQuery.queryHash
+      }, dehydratedQuery.state);
+    });
+  }
+
   /**
    * Restores persisted data to the QueryCache
    *  - data obtained from persister.restoreClient
@@ -58,7 +355,7 @@
           if (expired || busted) {
             persister.removeClient();
           } else {
-            queryCore.hydrate(queryClient, persistedClient.clientState, hydrateOptions);
+            hydrate(queryClient, persistedClient.clientState, hydrateOptions);
           }
         } else {
           persister.removeClient();
@@ -88,7 +385,7 @@
     const persistClient = {
       buster,
       timestamp: Date.now(),
-      clientState: queryCore.dehydrate(queryClient, dehydrateOptions)
+      clientState: dehydrate(queryClient, dehydrateOptions)
     };
     await persister.persistClient(persistClient);
   }