@tanstack/react-query-persist-client 4.0.0

package/build/cjs/PersistQueryClientProvider.js

@@ -0,0 +1,83 @@
+/**
+ * react-query-persist-client
+ *
+ * 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
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('./_virtual/_rollupPluginBabelHelpers.js');
+var React = require('react');
+var persist = require('./persist.js');
+var reactQuery = require('@tanstack/react-query');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+const PersistQueryClientProvider = ({
+  client,
+  children,
+  persistOptions,
+  onSuccess,
+  ...props
+}) => {
+  const [isRestoring, setIsRestoring] = React__namespace.useState(true);
+  const refs = React__namespace.useRef({
+    persistOptions,
+    onSuccess
+  });
+  React__namespace.useEffect(() => {
+    refs.current = {
+      persistOptions,
+      onSuccess
+    };
+  });
+  React__namespace.useEffect(() => {
+    let isStale = false;
+    setIsRestoring(true);
+    const [unsubscribe, promise] = persist.persistQueryClient({ ...refs.current.persistOptions,
+      queryClient: client
+    });
+    promise.then(() => {
+      if (!isStale) {
+        refs.current.onSuccess == null ? void 0 : refs.current.onSuccess();
+        setIsRestoring(false);
+      }
+    });
+    return () => {
+      isStale = true;
+      unsubscribe();
+    };
+  }, [client]);
+  return /*#__PURE__*/React__namespace.createElement(reactQuery.QueryClientProvider, _rollupPluginBabelHelpers["extends"]({
+    client: client
+  }, props), /*#__PURE__*/React__namespace.createElement(reactQuery.IsRestoringProvider, {
+    value: isRestoring
+  }, children));
+};
+
+exports.PersistQueryClientProvider = PersistQueryClientProvider;
+//# sourceMappingURL=PersistQueryClientProvider.js.map

package/build/cjs/PersistQueryClientProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistQueryClientProvider.js","sources":["../../src/PersistQueryClientProvider.tsx"],"sourcesContent":["import * as React from 'react'\n\nimport { persistQueryClient, PersistQueryClientOptions } from './persist'\nimport { QueryClientProvider, QueryClientProviderProps, IsRestoringProvider } from '@tanstack/react-query'\n\nexport type PersistQueryClientProviderProps = QueryClientProviderProps & {\n  persistOptions: Omit<PersistQueryClientOptions, 'queryClient'>\n  onSuccess?: () => void\n}\n\nexport const PersistQueryClientProvider = ({\n  client,\n  children,\n  persistOptions,\n  onSuccess,\n  ...props\n}: PersistQueryClientProviderProps): JSX.Element => {\n  const [isRestoring, setIsRestoring] = React.useState(true)\n  const refs = React.useRef({ persistOptions, onSuccess })\n\n  React.useEffect(() => {\n    refs.current = { persistOptions, onSuccess }\n  })\n\n  React.useEffect(() => {\n    let isStale = false\n    setIsRestoring(true)\n    const [unsubscribe, promise] = persistQueryClient({\n      ...refs.current.persistOptions,\n      queryClient: client,\n    })\n\n    promise.then(() => {\n      if (!isStale) {\n        refs.current.onSuccess?.()\n        setIsRestoring(false)\n      }\n    })\n\n    return () => {\n      isStale = true\n      unsubscribe()\n    }\n  }, [client])\n\n  return (\n    <QueryClientProvider client={client} {...props}>\n      <IsRestoringProvider value={isRestoring}>{children}</IsRestoringProvider>\n    </QueryClientProvider>\n  )\n}\n"],"names":["PersistQueryClientProvider","client","children","persistOptions","onSuccess","props","isRestoring","setIsRestoring","React","useState","refs","useRef","useEffect","current","isStale","unsubscribe","promise","persistQueryClient","queryClient","then","QueryClientProvider","_extends","IsRestoringProvider"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUO,MAAMA,0BAA0B,GAAG,CAAC;AACzCC,EAAAA,MADyC;AAEzCC,EAAAA,QAFyC;AAGzCC,EAAAA,cAHyC;AAIzCC,EAAAA,SAJyC;AAKzC,EAAGC,GAAAA,KAAAA;AALsC,CAAD,KAMU;AAClD,EAAM,MAAA,CAACC,WAAD,EAAcC,cAAd,CAAA,GAAgCC,gBAAK,CAACC,QAAN,CAAe,IAAf,CAAtC,CAAA;AACA,EAAA,MAAMC,IAAI,GAAGF,gBAAK,CAACG,MAAN,CAAa;AAAER,IAAAA,cAAF;AAAkBC,IAAAA,SAAAA;AAAlB,GAAb,CAAb,CAAA;AAEAI,EAAAA,gBAAK,CAACI,SAAN,CAAgB,MAAM;AACpBF,IAAAA,IAAI,CAACG,OAAL,GAAe;AAAEV,MAAAA,cAAF;AAAkBC,MAAAA,SAAAA;AAAlB,KAAf,CAAA;AACD,GAFD,CAAA,CAAA;AAIAI,EAAAA,gBAAK,CAACI,SAAN,CAAgB,MAAM;AACpB,IAAIE,IAAAA,OAAO,GAAG,KAAd,CAAA;AACAP,IAAAA,cAAc,CAAC,IAAD,CAAd,CAAA;AACA,IAAA,MAAM,CAACQ,WAAD,EAAcC,OAAd,CAAyBC,GAAAA,0BAAkB,CAAC,EAChD,GAAGP,IAAI,CAACG,OAAL,CAAaV,cADgC;AAEhDe,MAAAA,WAAW,EAAEjB,MAAAA;AAFmC,KAAD,CAAjD,CAAA;AAKAe,IAAAA,OAAO,CAACG,IAAR,CAAa,MAAM;AACjB,MAAI,IAAA,CAACL,OAAL,EAAc;AACZJ,QAAAA,IAAI,CAACG,OAAL,CAAaT,SAAb,oBAAAM,IAAI,CAACG,OAAL,CAAaT,SAAb,EAAA,CAAA;AACAG,QAAAA,cAAc,CAAC,KAAD,CAAd,CAAA;AACD,OAAA;AACF,KALD,CAAA,CAAA;AAOA,IAAA,OAAO,MAAM;AACXO,MAAAA,OAAO,GAAG,IAAV,CAAA;AACAC,MAAAA,WAAW,EAAA,CAAA;AACZ,KAHD,CAAA;AAID,GAnBD,EAmBG,CAACd,MAAD,CAnBH,CAAA,CAAA;AAqBA,EAAA,oBACEO,+BAACY,8BAAD,EAAAC,oCAAA,CAAA;AAAqB,IAAA,MAAM,EAAEpB,MAAAA;AAA7B,GAAyCI,EAAAA,KAAzC,CACE,eAAAG,gBAAA,CAAA,aAAA,CAACc,8BAAD,EAAA;AAAqB,IAAA,KAAK,EAAEhB,WAAAA;AAA5B,GAA0CJ,EAAAA,QAA1C,CADF,CADF,CAAA;AAKD;;;;"}

package/build/cjs/_virtual/_rollupPluginBabelHelpers.js

@@ -0,0 +1,33 @@
+/**
+ * react-query-persist-client
+ *
+ * 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
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+exports["extends"] = _extends;
+//# sourceMappingURL=_rollupPluginBabelHelpers.js.map

package/build/cjs/_virtual/_rollupPluginBabelHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_rollupPluginBabelHelpers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/cjs/index.js

@@ -0,0 +1,27 @@
+/**
+ * react-query-persist-client
+ *
+ * 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
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var persist = require('./persist.js');
+var PersistQueryClientProvider = require('./PersistQueryClientProvider.js');
+var retryStrategies = require('./retryStrategies.js');
+
+
+
+exports.persistQueryClient = persist.persistQueryClient;
+exports.persistQueryClientRestore = persist.persistQueryClientRestore;
+exports.persistQueryClientSave = persist.persistQueryClientSave;
+exports.persistQueryClientSubscribe = persist.persistQueryClientSubscribe;
+exports.PersistQueryClientProvider = PersistQueryClientProvider.PersistQueryClientProvider;
+exports.removeOldestQuery = retryStrategies.removeOldestQuery;
+//# sourceMappingURL=index.js.map

package/build/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/cjs/persist.js

@@ -0,0 +1,119 @@
+/**
+ * react-query-persist-client
+ *
+ * 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
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var queryCore = require('@tanstack/query-core');
+
+/**
+ * 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
+ */
+async function persistQueryClientRestore({
+  queryClient,
+  persister,
+  maxAge = 1000 * 60 * 60 * 24,
+  buster = '',
+  hydrateOptions
+}) {
+  try {
+    const persistedClient = await persister.restoreClient();
+
+    if (persistedClient) {
+      if (persistedClient.timestamp) {
+        const expired = Date.now() - persistedClient.timestamp > maxAge;
+        const busted = persistedClient.buster !== buster;
+
+        if (expired || busted) {
+          persister.removeClient();
+        } else {
+          queryCore.hydrate(queryClient, persistedClient.clientState, hydrateOptions);
+        }
+      } else {
+        persister.removeClient();
+      }
+    }
+  } catch (err) {
+    if (process.env.NODE_ENV !== 'production') {
+      queryClient.getLogger().error(err);
+      queryClient.getLogger().warn('Encountered an error attempting to restore client cache from persisted location. As a precaution, the persisted cache will be discarded.');
+    }
+
+    persister.removeClient();
+  }
+}
+/**
+ * Persists data from the QueryCache
+ *  - data dehydrated using dehydrateOptions
+ *  - data is persisted using persister.persistClient
+ */
+
+async function persistQueryClientSave({
+  queryClient,
+  persister,
+  buster = '',
+  dehydrateOptions
+}) {
+  const persistClient = {
+    buster,
+    timestamp: Date.now(),
+    clientState: queryCore.dehydrate(queryClient, dehydrateOptions)
+  };
+  await persister.persistClient(persistClient);
+}
+/**
+ * Subscribe to QueryCache and MutationCache updates (for persisting)
+ * @returns an unsubscribe function (to discontinue monitoring)
+ */
+
+function persistQueryClientSubscribe(props) {
+  const unsubscribeQueryCache = props.queryClient.getQueryCache().subscribe(() => {
+    persistQueryClientSave(props);
+  });
+  const unusbscribeMutationCache = props.queryClient.getMutationCache().subscribe(() => {
+    persistQueryClientSave(props);
+  });
+  return () => {
+    unsubscribeQueryCache();
+    unusbscribeMutationCache();
+  };
+}
+/**
+ * Restores persisted data to QueryCache and persists further changes.
+ */
+
+function persistQueryClient(props) {
+  let hasUnsubscribed = false;
+  let persistQueryClientUnsubscribe;
+
+  const unsubscribe = () => {
+    hasUnsubscribed = true;
+    persistQueryClientUnsubscribe == null ? void 0 : persistQueryClientUnsubscribe();
+  }; // Attempt restore
+
+
+  const restorePromise = persistQueryClientRestore(props).then(() => {
+    if (!hasUnsubscribed) {
+      // Subscribe to changes in the query cache to trigger the save
+      persistQueryClientUnsubscribe = persistQueryClientSubscribe(props);
+    }
+  });
+  return [unsubscribe, restorePromise];
+}
+
+exports.persistQueryClient = persistQueryClient;
+exports.persistQueryClientRestore = persistQueryClientRestore;
+exports.persistQueryClientSave = persistQueryClientSave;
+exports.persistQueryClientSubscribe = persistQueryClientSubscribe;
+//# sourceMappingURL=persist.js.map

package/build/cjs/persist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persist.js","sources":["../../src/persist.ts"],"sourcesContent":["import {\n  QueryClient,\n  dehydrate,\n  DehydratedState,\n  DehydrateOptions,\n  HydrateOptions,\n  hydrate,\n} from '@tanstack/query-core'\n\nexport type Promisable<T> = T | PromiseLike<T>\n\nexport interface Persister {\n  persistClient(persistClient: PersistedClient): Promisable<void>\n  restoreClient(): Promisable<PersistedClient | undefined>\n  removeClient(): Promisable<void>\n}\n\nexport interface PersistedClient {\n  timestamp: number\n  buster: string\n  clientState: DehydratedState\n}\n\nexport interface PersistQueryClienRootOptions {\n  /** The QueryClient to persist */\n  queryClient: QueryClient\n  /** The Persister interface for storing and restoring the cache\n   * to/from a persisted location */\n  persister: Persister\n  /** A unique string that can be used to forcefully\n   * invalidate existing caches if they do not share the same buster string */\n  buster?: string\n}\n\nexport interface PersistedQueryClientRestoreOptions\n  extends PersistQueryClienRootOptions {\n  /** The max-allowed age of the cache in milliseconds.\n   * If a persisted cache is found that is older than this\n   * time, it will be discarded */\n  maxAge?: number\n  /** The options passed to the hydrate function */\n  hydrateOptions?: HydrateOptions\n}\n\nexport interface PersistedQueryClientSaveOptions\n  extends PersistQueryClienRootOptions {\n  /** The options passed to the dehydrate function */\n  dehydrateOptions?: DehydrateOptions\n}\n\nexport interface PersistQueryClientOptions\n  extends PersistedQueryClientRestoreOptions,\n    PersistedQueryClientSaveOptions,\n    PersistQueryClienRootOptions {}\n\n/**\n * Restores persisted data to the QueryCache\n *  - data obtained from persister.restoreClient\n *  - data is hydrated using hydrateOptions\n * If data is expired, busted, empty, or throws, it runs persister.removeClient\n */\nexport async function persistQueryClientRestore({\n  queryClient,\n  persister,\n  maxAge = 1000 * 60 * 60 * 24,\n  buster = '',\n  hydrateOptions,\n}: PersistedQueryClientRestoreOptions) {\n  try {\n    const persistedClient = await persister.restoreClient()\n\n    if (persistedClient) {\n      if (persistedClient.timestamp) {\n        const expired = Date.now() - persistedClient.timestamp > maxAge\n        const busted = persistedClient.buster !== buster\n        if (expired || busted) {\n          persister.removeClient()\n        } else {\n          hydrate(queryClient, persistedClient.clientState, hydrateOptions)\n        }\n      } else {\n        persister.removeClient()\n      }\n    }\n  } catch (err) {\n    if (process.env.NODE_ENV !== 'production') {\n      queryClient.getLogger().error(err)\n      queryClient\n        .getLogger()\n        .warn(\n          'Encountered an error attempting to restore client cache from persisted location. As a precaution, the persisted cache will be discarded.'\n        )\n    }\n    persister.removeClient()\n  }\n}\n\n/**\n * Persists data from the QueryCache\n *  - data dehydrated using dehydrateOptions\n *  - data is persisted using persister.persistClient\n */\nexport async function persistQueryClientSave({\n  queryClient,\n  persister,\n  buster = '',\n  dehydrateOptions,\n}: PersistedQueryClientSaveOptions) {\n  const persistClient: PersistedClient = {\n    buster,\n    timestamp: Date.now(),\n    clientState: dehydrate(queryClient, dehydrateOptions),\n  }\n\n  await persister.persistClient(persistClient)\n}\n\n/**\n * Subscribe to QueryCache and MutationCache updates (for persisting)\n * @returns an unsubscribe function (to discontinue monitoring)\n */\nexport function persistQueryClientSubscribe(\n  props: PersistedQueryClientSaveOptions\n) {\n  const unsubscribeQueryCache = props.queryClient\n    .getQueryCache()\n    .subscribe(() => {\n      persistQueryClientSave(props)\n    })\n\n  const unusbscribeMutationCache = props.queryClient\n    .getMutationCache()\n    .subscribe(() => {\n      persistQueryClientSave(props)\n    })\n\n  return () => {\n    unsubscribeQueryCache()\n    unusbscribeMutationCache()\n  }\n}\n\n/**\n * Restores persisted data to QueryCache and persists further changes.\n */\nexport function persistQueryClient(\n  props: PersistQueryClientOptions\n): [() => void, Promise<void>] {\n  let hasUnsubscribed = false\n  let persistQueryClientUnsubscribe: (() => void) | undefined\n  const unsubscribe = () => {\n    hasUnsubscribed = true\n    persistQueryClientUnsubscribe?.()\n  }\n\n  // Attempt restore\n  const restorePromise = persistQueryClientRestore(props).then(() => {\n    if (!hasUnsubscribed) {\n      // Subscribe to changes in the query cache to trigger the save\n      persistQueryClientUnsubscribe = persistQueryClientSubscribe(props)\n    }\n  })\n\n  return [unsubscribe, restorePromise]\n}\n"],"names":["persistQueryClientRestore","queryClient","persister","maxAge","buster","hydrateOptions","persistedClient","restoreClient","timestamp","expired","Date","now","busted","removeClient","hydrate","clientState","err","process","env","NODE_ENV","getLogger","error","warn","persistQueryClientSave","dehydrateOptions","persistClient","dehydrate","persistQueryClientSubscribe","props","unsubscribeQueryCache","getQueryCache","subscribe","unusbscribeMutationCache","getMutationCache","persistQueryClient","hasUnsubscribed","persistQueryClientUnsubscribe","unsubscribe","restorePromise","then"],"mappings":"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"}

package/build/cjs/query-core/build/esm/index.js

@@ -0,0 +1,314 @@
+/**
+ * react-query-persist-client
+ *
+ * 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
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * 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);
+  });
+}
+
+exports.dehydrate = dehydrate;
+exports.hydrate = hydrate;
+//# sourceMappingURL=index.js.map