@tanstack/query-async-storage-persister 4.3.4 → 4.3.7

package/build/lib/__tests__/asyncThrottle.test.d.ts

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

package/build/lib/__tests__/utils.d.ts

@@ -0,0 +1 @@
+export declare function sleep(timeout: number): Promise<void>;

package/build/lib/asyncThrottle.esm.js

@@ -0,0 +1,57 @@
+const noop = () => {
+  /* do nothing */
+};
+
+function asyncThrottle(func, {
+  interval = 1000,
+  onError = noop
+} = {}) {
+  if (typeof func !== 'function') throw new Error('argument is not function.');
+  let running = false;
+  let lastTime = 0;
+  let timeout;
+  let currentArgs = null;
+
+  const execFunc = async () => {
+    if (currentArgs) {
+      const args = currentArgs;
+      currentArgs = null;
+
+      try {
+        running = true;
+        await func(...args);
+      } catch (error) {
+        onError(error);
+      } finally {
+        lastTime = Date.now(); // this line must after 'func' executed to avoid two 'func' running in concurrent.
+
+        running = false;
+      }
+    }
+  };
+
+  const delayFunc = async () => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      if (running) {
+        delayFunc(); // Will come here when 'func' execution time is greater than the interval.
+      } else {
+        execFunc();
+      }
+    }, interval);
+  };
+
+  return (...args) => {
+    currentArgs = args;
+    const tooSoon = Date.now() - lastTime < interval;
+
+    if (running || tooSoon) {
+      delayFunc();
+    } else {
+      execFunc();
+    }
+  };
+}
+
+export { asyncThrottle };
+//# sourceMappingURL=asyncThrottle.esm.js.map

package/build/lib/asyncThrottle.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncThrottle.esm.js","sources":["../../src/asyncThrottle.ts"],"sourcesContent":["export interface AsyncThrottleOptions {\n  interval?: number\n  onError?: (error: unknown) => void\n}\n\nconst noop = () => {\n  /* do nothing */\n}\n\nexport function asyncThrottle<Args extends readonly unknown[]>(\n  func: (...args: Args) => Promise<void>,\n  { interval = 1000, onError = noop }: AsyncThrottleOptions = {},\n) {\n  if (typeof func !== 'function') throw new Error('argument is not function.')\n\n  let running = false\n  let lastTime = 0\n  let timeout: ReturnType<typeof setTimeout>\n  let currentArgs: Args | null = null\n\n  const execFunc = async () => {\n    if (currentArgs) {\n      const args = currentArgs\n      currentArgs = null\n      try {\n        running = true\n        await func(...args)\n      } catch (error) {\n        onError(error)\n      } finally {\n        lastTime = Date.now() // this line must after 'func' executed to avoid two 'func' running in concurrent.\n        running = false\n      }\n    }\n  }\n\n  const delayFunc = async () => {\n    clearTimeout(timeout)\n    timeout = setTimeout(() => {\n      if (running) {\n        delayFunc() // Will come here when 'func' execution time is greater than the interval.\n      } else {\n        execFunc()\n      }\n    }, interval)\n  }\n\n  return (...args: Args) => {\n    currentArgs = args\n\n    const tooSoon = Date.now() - lastTime < interval\n    if (running || tooSoon) {\n      delayFunc()\n    } else {\n      execFunc()\n    }\n  }\n}\n"],"names":["noop","asyncThrottle","func","interval","onError","Error","running","lastTime","timeout","currentArgs","execFunc","args","error","Date","now","delayFunc","clearTimeout","setTimeout","tooSoon"],"mappings":"AAKA,MAAMA,IAAI,GAAG,MAAM;AACjB;AACD,CAFD,CAAA;;AAIO,SAASC,aAAT,CACLC,IADK,EAEL;AAAEC,EAAAA,QAAQ,GAAG,IAAb;AAAmBC,EAAAA,OAAO,GAAGJ,IAAAA;AAA7B,CAAA,GAA4D,EAFvD,EAGL;EACA,IAAI,OAAOE,IAAP,KAAgB,UAApB,EAAgC,MAAM,IAAIG,KAAJ,CAAU,2BAAV,CAAN,CAAA;EAEhC,IAAIC,OAAO,GAAG,KAAd,CAAA;EACA,IAAIC,QAAQ,GAAG,CAAf,CAAA;AACA,EAAA,IAAIC,OAAJ,CAAA;EACA,IAAIC,WAAwB,GAAG,IAA/B,CAAA;;EAEA,MAAMC,QAAQ,GAAG,YAAY;AAC3B,IAAA,IAAID,WAAJ,EAAiB;MACf,MAAME,IAAI,GAAGF,WAAb,CAAA;AACAA,MAAAA,WAAW,GAAG,IAAd,CAAA;;MACA,IAAI;AACFH,QAAAA,OAAO,GAAG,IAAV,CAAA;AACA,QAAA,MAAMJ,IAAI,CAAC,GAAGS,IAAJ,CAAV,CAAA;OAFF,CAGE,OAAOC,KAAP,EAAc;QACdR,OAAO,CAACQ,KAAD,CAAP,CAAA;AACD,OALD,SAKU;AACRL,QAAAA,QAAQ,GAAGM,IAAI,CAACC,GAAL,EAAX,CADQ;;AAERR,QAAAA,OAAO,GAAG,KAAV,CAAA;AACD,OAAA;AACF,KAAA;GAbH,CAAA;;EAgBA,MAAMS,SAAS,GAAG,YAAY;IAC5BC,YAAY,CAACR,OAAD,CAAZ,CAAA;IACAA,OAAO,GAAGS,UAAU,CAAC,MAAM;AACzB,MAAA,IAAIX,OAAJ,EAAa;AACXS,QAAAA,SAAS,GADE;AAEZ,OAFD,MAEO;QACLL,QAAQ,EAAA,CAAA;AACT,OAAA;KALiB,EAMjBP,QANiB,CAApB,CAAA;GAFF,CAAA;;EAWA,OAAO,CAAC,GAAGQ,IAAJ,KAAmB;AACxBF,IAAAA,WAAW,GAAGE,IAAd,CAAA;IAEA,MAAMO,OAAO,GAAGL,IAAI,CAACC,GAAL,EAAaP,GAAAA,QAAb,GAAwBJ,QAAxC,CAAA;;IACA,IAAIG,OAAO,IAAIY,OAAf,EAAwB;MACtBH,SAAS,EAAA,CAAA;AACV,KAFD,MAEO;MACLL,QAAQ,EAAA,CAAA;AACT,KAAA;GARH,CAAA;AAUD;;;;"}

package/build/lib/index.esm.js

@@ -0,0 +1,64 @@
+import { asyncThrottle } from './asyncThrottle.esm.js';
+
+const createAsyncStoragePersister = ({
+  storage,
+  key = "REACT_QUERY_OFFLINE_CACHE",
+  throttleTime = 1000,
+  serialize = JSON.stringify,
+  deserialize = JSON.parse,
+  retry
+}) => {
+  if (typeof storage !== 'undefined') {
+    const trySave = async persistedClient => {
+      try {
+        await storage.setItem(key, serialize(persistedClient));
+      } catch (error) {
+        return error;
+      }
+    };
+
+    return {
+      persistClient: asyncThrottle(async persistedClient => {
+        let client = persistedClient;
+        let error = await trySave(client);
+        let errorCount = 0;
+
+        while (error && client) {
+          errorCount++;
+          client = await (retry == null ? void 0 : retry({
+            persistedClient: client,
+            error,
+            errorCount
+          }));
+
+          if (client) {
+            error = await trySave(client);
+          }
+        }
+      }, {
+        interval: throttleTime
+      }),
+      restoreClient: async () => {
+        const cacheString = await storage.getItem(key);
+
+        if (!cacheString) {
+          return;
+        }
+
+        return deserialize(cacheString);
+      },
+      removeClient: () => storage.removeItem(key)
+    };
+  }
+
+  return {
+    persistClient: noop,
+    restoreClient: () => Promise.resolve(undefined),
+    removeClient: noop
+  };
+}; // eslint-disable-next-line @typescript-eslint/no-empty-function
+
+function noop() {}
+
+export { createAsyncStoragePersister };
+//# sourceMappingURL=index.esm.js.map

package/build/lib/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":["../../src/index.ts"],"sourcesContent":["import {\n  PersistedClient,\n  Persister,\n  Promisable,\n} from '@tanstack/react-query-persist-client'\nimport { asyncThrottle } from './asyncThrottle'\n\ninterface AsyncStorage {\n  getItem: (key: string) => Promise<string | null>\n  setItem: (key: string, value: string) => Promise<void>\n  removeItem: (key: string) => Promise<void>\n}\n\nexport type AsyncPersistRetryer = (props: {\n  persistedClient: PersistedClient\n  error: Error\n  errorCount: number\n}) => Promisable<PersistedClient | undefined>\n\ninterface CreateAsyncStoragePersisterOptions {\n  /** The storage client used for setting and retrieving items from cache.\n   * For SSR pass in `undefined`.\n   */\n  storage: AsyncStorage | undefined\n  /** The key to use when storing the cache */\n  key?: string\n  /** To avoid spamming,\n   * pass a time in ms to throttle saving the cache to disk */\n  throttleTime?: number\n  /**\n   * How to serialize the data to storage.\n   * @default `JSON.stringify`\n   */\n  serialize?: (client: PersistedClient) => string\n  /**\n   * How to deserialize the data from storage.\n   * @default `JSON.parse`\n   */\n  deserialize?: (cachedString: string) => PersistedClient\n\n  retry?: AsyncPersistRetryer\n}\n\nexport const createAsyncStoragePersister = ({\n  storage,\n  key = `REACT_QUERY_OFFLINE_CACHE`,\n  throttleTime = 1000,\n  serialize = JSON.stringify,\n  deserialize = JSON.parse,\n  retry,\n}: CreateAsyncStoragePersisterOptions): Persister => {\n  if (typeof storage !== 'undefined') {\n    const trySave = async (\n      persistedClient: PersistedClient,\n    ): Promise<Error | undefined> => {\n      try {\n        await storage.setItem(key, serialize(persistedClient))\n      } catch (error) {\n        return error as Error\n      }\n    }\n\n    return {\n      persistClient: asyncThrottle(\n        async (persistedClient) => {\n          let client: PersistedClient | undefined = persistedClient\n          let error = await trySave(client)\n          let errorCount = 0\n          while (error && client) {\n            errorCount++\n            client = await retry?.({\n              persistedClient: client,\n              error,\n              errorCount,\n            })\n\n            if (client) {\n              error = await trySave(client)\n            }\n          }\n        },\n        { interval: throttleTime },\n      ),\n      restoreClient: async () => {\n        const cacheString = await storage.getItem(key)\n\n        if (!cacheString) {\n          return\n        }\n\n        return deserialize(cacheString) as PersistedClient\n      },\n      removeClient: () => storage.removeItem(key),\n    }\n  }\n\n  return {\n    persistClient: noop,\n    restoreClient: () => Promise.resolve(undefined),\n    removeClient: noop,\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nfunction noop() {}\n"],"names":["createAsyncStoragePersister","storage","key","throttleTime","serialize","JSON","stringify","deserialize","parse","retry","trySave","persistedClient","setItem","error","persistClient","asyncThrottle","client","errorCount","interval","restoreClient","cacheString","getItem","removeClient","removeItem","noop","Promise","resolve","undefined"],"mappings":";;AA2CO,MAAMA,2BAA2B,GAAG,CAAC;EAC1CC,OAD0C;AAE1CC,EAAAA,GAAG,GAFuC,2BAAA;AAG1CC,EAAAA,YAAY,GAAG,IAH2B;EAI1CC,SAAS,GAAGC,IAAI,CAACC,SAJyB;EAK1CC,WAAW,GAAGF,IAAI,CAACG,KALuB;AAM1CC,EAAAA,KAAAA;AAN0C,CAAD,KAOU;AACnD,EAAA,IAAI,OAAOR,OAAP,KAAmB,WAAvB,EAAoC;AAClC,IAAA,MAAMS,OAAO,GAAG,MACdC,eADc,IAEiB;MAC/B,IAAI;QACF,MAAMV,OAAO,CAACW,OAAR,CAAgBV,GAAhB,EAAqBE,SAAS,CAACO,eAAD,CAA9B,CAAN,CAAA;OADF,CAEE,OAAOE,KAAP,EAAc;AACd,QAAA,OAAOA,KAAP,CAAA;AACD,OAAA;KAPH,CAAA;;IAUA,OAAO;AACLC,MAAAA,aAAa,EAAEC,aAAa,CAC1B,MAAOJ,eAAP,IAA2B;QACzB,IAAIK,MAAmC,GAAGL,eAA1C,CAAA;AACA,QAAA,IAAIE,KAAK,GAAG,MAAMH,OAAO,CAACM,MAAD,CAAzB,CAAA;QACA,IAAIC,UAAU,GAAG,CAAjB,CAAA;;QACA,OAAOJ,KAAK,IAAIG,MAAhB,EAAwB;UACtBC,UAAU,EAAA,CAAA;AACVD,UAAAA,MAAM,GAAG,OAAMP,KAAN,IAAA,IAAA,GAAA,KAAA,CAAA,GAAMA,KAAK,CAAG;AACrBE,YAAAA,eAAe,EAAEK,MADI;YAErBH,KAFqB;AAGrBI,YAAAA,UAAAA;AAHqB,WAAH,CAAX,CAAT,CAAA;;AAMA,UAAA,IAAID,MAAJ,EAAY;AACVH,YAAAA,KAAK,GAAG,MAAMH,OAAO,CAACM,MAAD,CAArB,CAAA;AACD,WAAA;AACF,SAAA;AACF,OAjByB,EAkB1B;AAAEE,QAAAA,QAAQ,EAAEf,YAAAA;AAAZ,OAlB0B,CADvB;AAqBLgB,MAAAA,aAAa,EAAE,YAAY;QACzB,MAAMC,WAAW,GAAG,MAAMnB,OAAO,CAACoB,OAAR,CAAgBnB,GAAhB,CAA1B,CAAA;;QAEA,IAAI,CAACkB,WAAL,EAAkB;AAChB,UAAA,OAAA;AACD,SAAA;;QAED,OAAOb,WAAW,CAACa,WAAD,CAAlB,CAAA;OA5BG;AA8BLE,MAAAA,YAAY,EAAE,MAAMrB,OAAO,CAACsB,UAAR,CAAmBrB,GAAnB,CAAA;KA9BtB,CAAA;AAgCD,GAAA;;EAED,OAAO;AACLY,IAAAA,aAAa,EAAEU,IADV;AAELL,IAAAA,aAAa,EAAE,MAAMM,OAAO,CAACC,OAAR,CAAgBC,SAAhB,CAFhB;AAGLL,IAAAA,YAAY,EAAEE,IAAAA;GAHhB,CAAA;AAKD;;AAGD,SAASA,IAAT,GAAgB;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/query-async-storage-persister",
-  "version": "4.3.4",
+  "version": "4.3.7",
   "description": "TODO",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -12,6 +12,7 @@
   },
   "types": "build/lib/index.d.ts",
   "main": "build/lib/index.js",
+  "module": "build/lib/index.esm.js",
   "exports": {
     ".": {
       "types": "./build/lib/index.d.ts",
@@ -31,6 +32,6 @@
     "test:eslint": "../../node_modules/.bin/eslint --ext .ts,.tsx ./src"
   },
   "dependencies": {
-    "@tanstack/react-query-persist-client": "4.3.4"
+    "@tanstack/react-query-persist-client": "4.3.7"
   }
 }

package/src/__tests__/asyncThrottle.test.ts

@@ -1,5 +1,5 @@
 import { asyncThrottle } from '../asyncThrottle'
-import { sleep as delay } from '../../../../tests/utils'
+import { sleep as delay } from './utils'
 
 describe('asyncThrottle', () => {
   test('basic', async () => {

package/src/__tests__/utils.ts

@@ -0,0 +1,5 @@
+export function sleep(timeout: number): Promise<void> {
+  return new Promise((resolve, _reject) => {
+    setTimeout(resolve, timeout)
+  })
+}