@tanstack/react-query-persist-client 4.0.0 → 4.0.2

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,20 @@
+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>(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, 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>;

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/PersistQueryClientProvider.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { PersistQueryClientOptions } from './persist';
+import { QueryClientProviderProps } from '@tanstack/react-query';
+export declare type PersistQueryClientProviderProps = QueryClientProviderProps & {
+    persistOptions: Omit<PersistQueryClientOptions, 'queryClient'>;
+    onSuccess?: () => void;
+};
+export declare const PersistQueryClientProvider: ({ client, children, persistOptions, onSuccess, ...props }: PersistQueryClientProviderProps) => JSX.Element;

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/packages/react-query-persist-client/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './persist';
+export * from './PersistQueryClientProvider';
+export * from './retryStrategies';

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

@@ -0,0 +1,58 @@
+import { QueryClient, DehydratedState, DehydrateOptions, HydrateOptions } from '@tanstack/query-core';
+export declare type Promisable<T> = T | PromiseLike<T>;
+export interface Persister {
+    persistClient(persistClient: PersistedClient): Promisable<void>;
+    restoreClient(): Promisable<PersistedClient | undefined>;
+    removeClient(): Promisable<void>;
+}
+export interface PersistedClient {
+    timestamp: number;
+    buster: string;
+    clientState: DehydratedState;
+}
+export interface PersistQueryClienRootOptions {
+    /** The QueryClient to persist */
+    queryClient: QueryClient;
+    /** The Persister interface for storing and restoring the cache
+     * to/from a persisted location */
+    persister: Persister;
+    /** A unique string that can be used to forcefully
+     * invalidate existing caches if they do not share the same buster string */
+    buster?: string;
+}
+export interface PersistedQueryClientRestoreOptions extends PersistQueryClienRootOptions {
+    /** The max-allowed age of the cache in milliseconds.
+     * If a persisted cache is found that is older than this
+     * time, it will be discarded */
+    maxAge?: number;
+    /** The options passed to the hydrate function */
+    hydrateOptions?: HydrateOptions;
+}
+export interface PersistedQueryClientSaveOptions extends PersistQueryClienRootOptions {
+    /** The options passed to the dehydrate function */
+    dehydrateOptions?: DehydrateOptions;
+}
+export interface PersistQueryClientOptions extends PersistedQueryClientRestoreOptions, PersistedQueryClientSaveOptions, PersistQueryClienRootOptions {
+}
+/**
+ * Restores persisted data to the QueryCache
+ *  - data obtained from persister.restoreClient
+ *  - data is hydrated using hydrateOptions
+ * If data is expired, busted, empty, or throws, it runs persister.removeClient
+ */
+export declare function persistQueryClientRestore({ queryClient, persister, maxAge, buster, hydrateOptions, }: PersistedQueryClientRestoreOptions): Promise<void>;
+/**
+ * Persists data from the QueryCache
+ *  - data dehydrated using dehydrateOptions
+ *  - data is persisted using persister.persistClient
+ */
+export declare function persistQueryClientSave({ queryClient, persister, buster, dehydrateOptions, }: PersistedQueryClientSaveOptions): Promise<void>;
+/**
+ * Subscribe to QueryCache and MutationCache updates (for persisting)
+ * @returns an unsubscribe function (to discontinue monitoring)
+ */
+export declare function persistQueryClientSubscribe(props: PersistedQueryClientSaveOptions): () => void;
+/**
+ * Restores persisted data to QueryCache and persists further changes.
+ */
+export declare function persistQueryClient(props: PersistQueryClientOptions): [() => void, Promise<void>];

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

@@ -0,0 +1,7 @@
+import { PersistedClient } from './persist';
+export declare type PersistRetryer = (props: {
+    persistedClient: PersistedClient;
+    error: Error;
+    errorCount: number;
+}) => PersistedClient | undefined;
+export declare const removeOldestQuery: PersistRetryer;

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('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';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('use-sync-external-store/shim')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', 'use-sync-external-store/shim'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactQueryPersistClient = {}, global.React));
+})(this, (function (exports, React) { 'use strict';
 
   function _interopNamespace(e) {
     if (e && e.__esModule) return e;
@@ -44,7 +44,7 @@
    *
    * @license MIT
    */
-  class Subscribable {
+  class Subscribable$1 {
     constructor() {
       this.listeners = [];
       this.subscribe = this.subscribe.bind(this);
@@ -73,16 +73,16 @@
 
   // TYPES
   // UTILS
-  const isServer = typeof window === 'undefined';
+  const isServer$1 = typeof window === 'undefined';
 
-  class FocusManager extends Subscribable {
+  class FocusManager$1 extends Subscribable$1 {
     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) {
+        if (!isServer$1 && window.addEventListener) {
           const listener = () => onFocus(); // Listen to visibillitychange and focus
 
 
@@ -154,16 +154,16 @@
     }
 
   }
-  new FocusManager();
+  new FocusManager$1();
 
-  class OnlineManager extends Subscribable {
+  class OnlineManager$1 extends Subscribable$1 {
     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) {
+        if (!isServer$1 && window.addEventListener) {
           const listener = () => onOnline(); // Listen to online
 
 
@@ -234,7 +234,7 @@
     }
 
   }
-  new OnlineManager();
+  new OnlineManager$1();
 
   // TYPES
   // FUNCTIONS
@@ -446,6 +446,266 @@
     return _extends.apply(this, arguments);
   }
 
+  /**
+   * react-query
+   *
+   * 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
+   */
+
+  /**
+   * 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();
+
+  const defaultContext = /*#__PURE__*/React__namespace.createContext(undefined);
+  const QueryClientSharingContext = /*#__PURE__*/React__namespace.createContext(false); // If we are given a context, we will use it.
+  // Otherwise, if contextSharing is on, we share the first and at least one
+  // instance of the context across the window
+  // to ensure that if React Query is used across
+  // different bundles or microfrontends they will
+  // all use the same **instance** of context, regardless
+  // of module scoping.
+
+  function getQueryClientContext(context, contextSharing) {
+    if (context) {
+      return context;
+    }
+
+    if (contextSharing && typeof window !== 'undefined') {
+      if (!window.ReactQueryClientContext) {
+        window.ReactQueryClientContext = defaultContext;
+      }
+
+      return window.ReactQueryClientContext;
+    }
+
+    return defaultContext;
+  }
+  const QueryClientProvider = ({
+    client,
+    children,
+    context,
+    contextSharing = false
+  }) => {
+    React__namespace.useEffect(() => {
+      client.mount();
+      return () => {
+        client.unmount();
+      };
+    }, [client]);
+    const Context = getQueryClientContext(context, contextSharing);
+    return /*#__PURE__*/React__namespace.createElement(QueryClientSharingContext.Provider, {
+      value: !context && contextSharing
+    }, /*#__PURE__*/React__namespace.createElement(Context.Provider, {
+      value: client
+    }, children));
+  };
+
+  const IsRestoringContext = /*#__PURE__*/React__namespace.createContext(false);
+  const IsRestoringProvider = IsRestoringContext.Provider;
+
   const PersistQueryClientProvider = ({
     client,
     children,
@@ -481,9 +741,9 @@
         unsubscribe();
       };
     }, [client]);
-    return /*#__PURE__*/React__namespace.createElement(reactQuery.QueryClientProvider, _extends({
+    return /*#__PURE__*/React__namespace.createElement(QueryClientProvider, _extends({
       client: client
-    }, props), /*#__PURE__*/React__namespace.createElement(reactQuery.IsRestoringProvider, {
+    }, props), /*#__PURE__*/React__namespace.createElement(IsRestoringProvider, {
       value: isRestoring
     }, children));
   };