@plq/use-persisted-state 1.3.0 → 1.4.1

package/lib/utils/storage-event-router.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRoute = addRoute;
+exports.removeRoute = removeRoute;
+const routes = new Set();
+let subscription = null;
+function routeStorageEvent(event) {
+    if (!event.key)
+        return;
+    const changes = {
+        [event.key]: {
+            newValue: event.newValue,
+            oldValue: event.oldValue,
+        },
+    };
+    for (const route of routes) {
+        // A browser always names the area it changed, so real cross-tab events
+        // reach only the adapter of that area. An event a consumer synthesized —
+        // the sole way to test cross-tab sync under jsdom, and a common way to
+        // notify the writing tab in production — often cannot name one: the
+        // StorageEvent constructor rejects a mocked storage there. Those still go
+        // everywhere, exactly as they did before areas were told apart.
+        if (event.storageArea == null || event.storageArea === route.storage) {
+            route.fire(changes);
+        }
+    }
+}
+// A runtime can provide storage without the DOM event API, and can provide half
+// of that API: subscribing where nothing can unsubscribe strands a listener and
+// makes releasing it throw, so both halves are required before taking one.
+function canSubscribe() {
+    return typeof globalThis.addEventListener === 'function' && typeof globalThis.removeEventListener === 'function';
+}
+/**
+ * Starts routing DOM storage events to `route`. Every adapter shares one
+ * subscription on the global object, so creating adapters nobody listens to
+ * costs nothing.
+ */
+function addRoute(route) {
+    routes.add(route);
+    if (!subscription && canSubscribe()) {
+        subscription = routeStorageEvent;
+        globalThis.addEventListener('storage', subscription);
+    }
+}
+/** Stops routing to `route`, releasing the shared subscription with the last one. */
+function removeRoute(route) {
+    routes.delete(route);
+    if (routes.size === 0 && subscription) {
+        globalThis.removeEventListener('storage', subscription);
+        subscription = null;
+    }
+}
+//# sourceMappingURL=storage-event-router.js.map

package/lib/utils/storage-event-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-event-router.js","sourceRoot":"","sources":["../../src/utils/storage-event-router.ts"],"names":[],"mappings":";;AA+CA,4BAQC;AAGD,kCAQC;AA1DD,MAAM,MAAM,GAAG,IAAI,GAAG,EAAqB,CAAA;AAE3C,IAAI,YAAY,GAA2C,IAAI,CAAA;AAE/D,SAAS,iBAAiB,CAAC,KAAmB;IAC5C,IAAI,CAAC,KAAK,CAAC,GAAG;QAAE,OAAM;IAEtB,MAAM,OAAO,GAAG;QACd,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;YACX,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,QAAQ,EAAE,KAAK,CAAC,QAAQ;SACzB;KACF,CAAA;IAED,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,uEAAuE;QACvE,yEAAyE;QACzE,uEAAuE;QACvE,oEAAoE;QACpE,0EAA0E;QAC1E,gEAAgE;QAChE,IAAI,KAAK,CAAC,WAAW,IAAI,IAAI,IAAI,KAAK,CAAC,WAAW,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC;YACrE,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QACrB,CAAC;IACH,CAAC;AACH,CAAC;AAED,gFAAgF;AAChF,gFAAgF;AAChF,2EAA2E;AAC3E,SAAS,YAAY;IACnB,OAAO,OAAO,UAAU,CAAC,gBAAgB,KAAK,UAAU,IAAI,OAAO,UAAU,CAAC,mBAAmB,KAAK,UAAU,CAAA;AAClH,CAAC;AAED;;;;GAIG;AACH,SAAgB,QAAQ,CAAC,KAAwB;IAC/C,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;IAEjB,IAAI,CAAC,YAAY,IAAI,YAAY,EAAE,EAAE,CAAC;QACpC,YAAY,GAAG,iBAAiB,CAAA;QAEhC,UAAU,CAAC,gBAAgB,CAAC,SAAS,EAAE,YAAY,CAAC,CAAA;IACtD,CAAC;AACH,CAAC;AAED,qFAAqF;AACrF,SAAgB,WAAW,CAAC,KAAwB;IAClD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAEpB,IAAI,MAAM,CAAC,IAAI,KAAK,CAAC,IAAI,YAAY,EAAE,CAAC;QACtC,UAAU,CAAC,mBAAmB,CAAC,SAAS,EAAE,YAAY,CAAC,CAAA;QAEvD,YAAY,GAAG,IAAI,CAAA;IACrB,CAAC;AACH,CAAC"}

package/lib/utils/use-storage-handler.d.ts

@@ -1,4 +1,15 @@
-import React from 'react';
-import { AsyncStorage, Storage } from '../@types/storage';
-export default function <T>(key: string, storageKey: string, setState: React.Dispatch<React.SetStateAction<T>>, storage: AsyncStorage | Storage, initialValue: T | (() => T)): void;
+import type React from 'react';
+import type { AsyncStorage, Storage } from '../@types/storage';
+/**
+ * Remembers an entry the hook is about to write, so the change the backend
+ * reports for it can be told apart from someone else's write.
+ *
+ * Recorded before the write, because a backend may report it before the call
+ * settles. One slot was not enough: a backend free to report after its write
+ * settles - chrome and browser storage both are - lets the next write overwrite
+ * the record of a write still waiting to be reported, and that unsuppressed echo
+ * then puts the earlier value back over the later one.
+ */
+export declare function recordOwnWrite(pendingOwnWrites: React.RefObject<string[]>, item: string): void;
+export default function useStorageHandler<T>(key: string, storageKey: string, applyValue: (value: T) => void, storage: AsyncStorage | Storage, initialValue: T | (() => T), pendingOwnWrites: React.RefObject<string[]>): void;
 //# sourceMappingURL=use-storage-handler.d.ts.map

package/lib/utils/use-storage-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-storage-handler.d.ts","sourceRoot":"","sources":["../../src/utils/use-storage-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAiB,MAAM,mBAAmB,CAAA;AAiDxE,MAAM,CAAC,OAAO,WAAU,CAAC,EACvB,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EACjD,OAAO,EAAE,YAAY,GAAG,OAAO,EAC/B,YAAY,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAC1B,IAAI,CAYN"}
+{"version":3,"file":"use-storage-handler.d.ts","sourceRoot":"","sources":["../../src/utils/use-storage-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAiB,MAAM,mBAAmB,CAAA;AAkE7E;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,gBAAgB,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAM9F;AA+DD,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,CAAC,EACzC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC9B,OAAO,EAAE,YAAY,GAAG,OAAO,EAC/B,YAAY,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAC3B,gBAAgB,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,GAC1C,IAAI,CAsBN"}

package/lib/utils/use-storage-handler.js

@@ -1,48 +1,131 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
+exports.recordOwnWrite = recordOwnWrite;
+exports.default = useStorageHandler;
 const react_1 = require("react");
 const is_1 = require("@plq/is");
-function getValue(key, value) {
-    let newState = null;
+function readStoredValue(key, entry) {
+    let parsed;
     try {
-        newState = JSON.parse(value);
+        parsed = JSON.parse(entry);
     }
     catch (err) {
-        console.error('use-persisted-state: Can\'t parse value from storage', err);
+        console.error("use-persisted-state: Can't parse value from storage", err);
+        return { status: 'unavailable' };
     }
-    return newState && key in newState ? newState[key] : null;
+    // A foreign entry can be any JSON value, and `in` throws on a primitive. This
+    // runs inside the adapter's notify loop, where a throw also cuts off every
+    // listener queued behind this one.
+    if (!(0, is_1.isObject)(parsed) || !(key in parsed))
+        return { status: 'unavailable' };
+    return { status: 'stored', value: parsed[key] };
 }
-function useStorageHandler(itemKey, storageKey, setState, initialValue) {
+// Restores the initial value when the whole entry is removed from the storage.
+function applyRemoval(change, itemKey, applyValue, latestInitialValue) {
+    if (change.oldValue === null || change.oldValue === undefined)
+        return;
+    const oldValue = readStoredValue(itemKey, change.oldValue);
+    const declaredInitialValue = latestInitialValue.current;
+    // Compared against the resolved value: a factory is never equal to what it
+    // produces, so comparing the declaration re-applies the initial value on every
+    // removal.
+    const initialValue = (0, is_1.isFunction)(declaredInitialValue) ? declaredInitialValue() : declaredInitialValue;
+    // An entry with no readable value for the key cannot be shown to have held the
+    // initial value, so the fallback is applied rather than skipped. The entry is
+    // gone either way, and stale state left in place is worse than a redundant
+    // restore.
+    if (oldValue.status === 'stored' && oldValue.value === initialValue)
+        return;
+    applyValue(initialValue);
+}
+// A backend that reports nothing back leaves every record unmatched, so the list
+// needs a ceiling or it grows by one string per write for as long as the hook is
+// mounted. A bound, not a tuning: a backend that does report drains the list on
+// every echo, and one that reports late is what the list exists for.
+const MAX_PENDING_OWN_WRITES = 8;
+/**
+ * Remembers an entry the hook is about to write, so the change the backend
+ * reports for it can be told apart from someone else's write.
+ *
+ * Recorded before the write, because a backend may report it before the call
+ * settles. One slot was not enough: a backend free to report after its write
+ * settles - chrome and browser storage both are - lets the next write overwrite
+ * the record of a write still waiting to be reported, and that unsuppressed echo
+ * then puts the earlier value back over the later one.
+ */
+function recordOwnWrite(pendingOwnWrites, item) {
+    const pending = pendingOwnWrites.current;
+    if (pending.length >= MAX_PENDING_OWN_WRITES)
+        pending.shift();
+    pending.push(item);
+}
+/**
+ * Reports whether this change is a write the hook itself made, forgetting the
+ * record when it is. A backend reports a write to every listener, the one that
+ * made it included, and applying that echo is the storage-to-state re-sync this
+ * hook was rebuilt without, arriving by another road: it decodes the entry again
+ * and hands the caller an equal value with a new identity, plus a render for a
+ * value it already holds.
+ *
+ * The price, accepted knowingly: for a value JSON cannot carry, the writer keeps
+ * what it set - NaN - while every other component on the key decodes the null
+ * that reached storage, so the two disagree until one of them remounts. Applying
+ * the echo would settle that disagreement and bring back both the second
+ * storage-to-state path and the render per write, so it is not the repair it
+ * looks like.
+ *
+ * Forgetting on the first match keeps a later identical entry a change. Another
+ * hook writing the same bytes is suppressed along with it, and nothing is lost:
+ * it would have replaced a value with an equal one.
+ */
+function consumeOwnWriteEcho(entry, pendingOwnWrites) {
+    const matched = pendingOwnWrites.current.indexOf(entry);
+    if (matched === -1)
+        return false;
+    // Everything recorded before the reported entry goes with it: a backend applies
+    // writes in the order it took them and reports them in that order too, so a
+    // record still unmatched by now has no echo left to wait for.
+    pendingOwnWrites.current.splice(0, matched + 1);
+    return true;
+}
+// Builds the change handler. Not a hook, despite living next to one.
+function createStorageHandler(itemKey, storageKey, applyValue, latestInitialValue, pendingOwnWrites) {
     return (changes) => {
-        Object.entries(changes).forEach(([key, change]) => {
-            if (key === storageKey
-                && (change.newValue === null || change.newValue === undefined)
-                && change.oldValue !== null
-                && change.oldValue !== undefined) {
-                const oldValue = getValue(itemKey, change.oldValue);
-                if (oldValue !== initialValue)
-                    setState((0, is_1.isFunction)(initialValue) ? initialValue() : initialValue);
-            }
-            if (key === storageKey
-                && change.newValue !== null
-                && change.newValue !== undefined) {
-                const newValue = getValue(itemKey, change.newValue);
-                if (newValue !== null)
-                    setState(newValue);
+        for (const [key, change] of Object.entries(changes)) {
+            if (key !== storageKey)
+                continue;
+            // Ahead of the echo check, which needs an entry to match and a removal has
+            // none. A removal is never one of this hook's own writes anyway: only the
+            // entries it stores are recorded.
+            if (change.newValue === null || change.newValue === undefined) {
+                applyRemoval(change, itemKey, applyValue, latestInitialValue);
+                continue;
             }
-        });
+            if (consumeOwnWriteEcho(change.newValue, pendingOwnWrites))
+                continue;
+            const newValue = readStoredValue(itemKey, change.newValue);
+            if (newValue.status === 'stored')
+                applyValue(newValue.value);
+        }
     };
 }
-function default_1(key, storageKey, setState, storage, initialValue) {
+function useStorageHandler(key, storageKey, applyValue, storage, initialValue, pendingOwnWrites) {
+    // A removal restores the initial value the hook holds now, the same one the
+    // key-change path reads, so a caller whose default travels with its data gets
+    // that record's default back rather than the mounted one. Tracked through a ref
+    // rather than a dependency because an inline object or factory has a new
+    // identity every render, which would tear the subscription down and rebuild it;
+    // written during render, as the key the hook is rendering for is.
+    const latestInitialValue = (0, react_1.useRef)(initialValue);
+    latestInitialValue.current = initialValue;
     (0, react_1.useEffect)(() => {
-        const handleStorage = useStorageHandler(key, storageKey, setState, initialValue);
+        const handleStorage = createStorageHandler(key, storageKey, applyValue, latestInitialValue, pendingOwnWrites);
         storage.onChanged.addListener(handleStorage);
         return () => {
             if (storage.onChanged.hasListener(handleStorage)) {
                 storage.onChanged.removeListener(handleStorage);
             }
         };
-    }, [initialValue, key, storage.onChanged, storageKey, setState]);
+    }, [key, storage.onChanged, storageKey, applyValue, pendingOwnWrites]);
 }
 //# sourceMappingURL=use-storage-handler.js.map

package/lib/utils/use-storage-handler.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-storage-handler.js","sourceRoot":"","sources":["../../src/utils/use-storage-handler.ts"],"names":[],"mappings":";;AAkDA,4BAkBC;AApED,iCAAsC;AAEtC,gCAAoC;AAEpC,SAAS,QAAQ,CAAI,GAAW,EAAE,KAAa;IAC7C,IAAI,QAAQ,GAAG,IAAI,CAAA;IAEnB,IAAI,CAAC;QACH,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IAC9B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,sDAAsD,EAAE,GAAG,CAAC,CAAA;IAC5E,CAAC;IAED,OAAO,QAAQ,IAAI,GAAG,IAAI,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAM,CAAC,CAAC,CAAC,IAAI,CAAA;AAChE,CAAC;AAED,SAAS,iBAAiB,CACxB,OAAe,EACf,UAAkB,EAClB,QAAiD,EACjD,YAA2B;IAE3B,OAAO,CAAC,OAAyC,EAAQ,EAAE;QACzD,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,EAAE;YAChD,IACE,GAAG,KAAK,UAAU;mBACf,CACD,MAAM,CAAC,QAAQ,KAAK,IAAI,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,CAC1D;mBACE,MAAM,CAAC,QAAQ,KAAK,IAAI;mBACxB,MAAM,CAAC,QAAQ,KAAK,SAAS,EAChC,CAAC;gBACD,MAAM,QAAQ,GAAG,QAAQ,CAAI,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAA;gBAEtD,IAAI,QAAQ,KAAK,YAAY;oBAAE,QAAQ,CAAC,IAAA,eAAU,EAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,CAAA;YACnG,CAAC;YAED,IACE,GAAG,KAAK,UAAU;mBACf,MAAM,CAAC,QAAQ,KAAK,IAAI;mBACxB,MAAM,CAAC,QAAQ,KAAK,SAAS,EAChC,CAAC;gBACD,MAAM,QAAQ,GAAG,QAAQ,CAAI,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAA;gBAEtD,IAAI,QAAQ,KAAK,IAAI;oBAAE,QAAQ,CAAC,QAAQ,CAAC,CAAA;YAC3C,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC,CAAA;AACH,CAAC;AAED,mBACE,GAAW,EACX,UAAkB,EAClB,QAAiD,EACjD,OAA+B,EAC/B,YAA2B;IAE3B,IAAA,iBAAS,EAAC,GAAG,EAAE;QACb,MAAM,aAAa,GAAG,iBAAiB,CAAI,GAAG,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAA;QAEnF,OAAO,CAAC,SAAS,CAAC,WAAW,CAAC,aAAa,CAAC,CAAA;QAE5C,OAAO,GAAG,EAAE;YACV,IAAI,OAAO,CAAC,SAAS,CAAC,WAAW,CAAC,aAAa,CAAC,EAAE,CAAC;gBACjD,OAAO,CAAC,SAAS,CAAC,cAAc,CAAC,aAAa,CAAC,CAAA;YACjD,CAAC;QACH,CAAC,CAAA;IACH,CAAC,EAAE,CAAC,YAAY,EAAE,GAAG,EAAE,OAAO,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAA;AAClE,CAAC"}
+{"version":3,"file":"use-storage-handler.js","sourceRoot":"","sources":["../../src/utils/use-storage-handler.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,49 +1,110 @@
 {
   "name": "@plq/use-persisted-state",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "useState hook with persistence in storage",
+  "type": "commonjs",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./esm/index.d.mts",
+        "default": "./esm/index.mjs"
+      },
+      "require": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "default": "./lib/index.js"
+    },
+    "./storages/local-storage": {
+      "import": {
+        "types": "./esm/storages/local-storage.d.mts",
+        "default": "./esm/storages/local-storage.mjs"
+      },
+      "require": {
+        "types": "./lib/storages/local-storage.d.ts",
+        "default": "./lib/storages/local-storage.js"
+      },
+      "default": "./lib/storages/local-storage.js"
+    },
+    "./storages/session-storage": {
+      "import": {
+        "types": "./esm/storages/session-storage.d.mts",
+        "default": "./esm/storages/session-storage.mjs"
+      },
+      "require": {
+        "types": "./lib/storages/session-storage.d.ts",
+        "default": "./lib/storages/session-storage.js"
+      },
+      "default": "./lib/storages/session-storage.js"
+    },
+    "./storages/browser-storage": {
+      "import": {
+        "types": "./esm/storages/browser-storage.d.mts",
+        "default": "./esm/storages/browser-storage.mjs"
+      },
+      "require": {
+        "types": "./lib/storages/browser-storage.d.ts",
+        "default": "./lib/storages/browser-storage.js"
+      },
+      "default": "./lib/storages/browser-storage.js"
+    },
+    "./storages/chrome-storage": {
+      "import": {
+        "types": "./esm/storages/chrome-storage.d.mts",
+        "default": "./esm/storages/chrome-storage.mjs"
+      },
+      "require": {
+        "types": "./lib/storages/chrome-storage.d.ts",
+        "default": "./lib/storages/chrome-storage.js"
+      },
+      "default": "./lib/storages/chrome-storage.js"
+    },
+    "./lib": "./lib/index.js",
+    "./lib/*.js": "./lib/*.js",
+    "./lib/*": "./lib/*.js",
+    "./src": "./src/index.ts",
+    "./src/*.ts": "./src/*.ts",
+    "./src/*": "./src/*.ts",
+    "./package.json": "./package.json"
+  },
   "engines": {
     "node": ">=16.0.0"
   },
   "files": [
     "/src",
     "/lib",
+    "/esm",
+    "/storages",
     "LICENSE"
   ],
   "scripts": {
     "build": "tsc",
     "build:watch": "tsc --watch",
     "build:types": "tsc --emitDeclarationOnly",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit",
     "test": "jest --verbose",
+    "test:random": "jest --randomize --showSeed",
     "test:watch": "npm test -- --watchAll",
-    "lint": "eslint ./src/**/*.ts",
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "check:package": "node scripts/check-package.mjs",
+    "check:publint": "npx --yes publint",
+    "check:attw": "npx --yes @arethetypeswrong/cli --pack . --exclude-entrypoints lib",
+    "check:smoke": "node scripts/smoke.mjs",
+    "check:types": "tsc -p tsconfig.package.json --noEmit",
+    "prepublishOnly": "npm run build",
+    "format": "biome format --write",
     "release": "dotenv release-it",
-    "demo": "vite demo",
-    "demo:build": "vite build demo",
-    "demo:preview": "vite preview demo"
+    "demo": "vite",
+    "demo:build": "vite build",
+    "demo:preview": "vite preview"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Akurganow/use-persisted-state.git"
   },
-  "release-it": {
-    "hooks": {
-      "before:init": [
-        "npm run lint",
-        "npm test",
-        "npm run build"
-      ],
-      "after:release": "echo Successfully released ${name} v${version} to ${repo.repository}."
-    },
-    "plugins": {
-      "@release-it/conventional-changelog": {
-        "preset": "conventionalcommits",
-        "infile": "CHANGELOG.md"
-      }
-    }
-  },
   "keywords": [
     "react",
     "hook",
@@ -54,8 +115,9 @@
     "persist",
     "sync"
   ],
-  "author": "Alex Kurganov <me@akurganow.ru>",
+  "author": "Alexander Kurganov <a.kurganow@gmail.com>",
   "license": "MIT",
+  "funding": "https://ko-fi.com/akurganow",
   "publishConfig": {
     "access": "public"
   },
@@ -64,38 +126,32 @@
   },
   "homepage": "https://github.com/Akurganow/use-persisted-state#readme",
   "devDependencies": {
-    "@eslint/js": "^9.32.0",
-    "@release-it/conventional-changelog": "^10.0.1",
-    "@testing-library/jest-dom": "^6.1.3",
+    "@biomejs/biome": "^2.5.6",
+    "@release-it/conventional-changelog": "^12.0.0",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/jest-dom": "^7.0.0",
     "@testing-library/react": "^16.3.0",
-    "@types/chrome": "0.1.1",
-    "@types/firefox-webext-browser": "^120.0.0",
+    "@types/chrome": "^0.2.2",
+    "@types/firefox-webext-browser": "^143.0.0",
     "@types/jest": "^30.0.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
-    "@vitejs/plugin-react": "^4.7.0",
-    "conventional-changelog-cli": "^5.0.0",
-    "dotenv-cli": "^10.0.0",
-    "eslint": "^9.32.0",
-    "eslint-plugin-jest": "^29.0.1",
-    "eslint-plugin-react": "^7.37.0",
-    "eslint-plugin-react-hooks": "^5.0.0",
+    "@vitejs/plugin-react": "^6.0.0",
+    "dotenv-cli": "^11.0.0",
     "jest": "^30.0.5",
     "jest-environment-jsdom": "^30.0.5",
     "jest-localstorage-mock": "^2.4.6",
     "jest-webextension-mock": "^4.0.0",
-    "process": "^0.11.10",
     "react": "^19.1.1",
     "react-dom": "^19.1.1",
-    "release-it": "^19.0.4",
+    "release-it": "^21.0.0",
     "ts-jest": "^29.4.0",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.15.0",
-    "vite": "^7.0.6"
+    "typescript": "^6.0.3",
+    "vite": "^8.2.0"
   },
   "peerDependencies": {
-    "react": ">=16.8.0 || >=18.0.0 || >=19.0.0",
-    "react-dom": ">=16.8.0 || >=18.0.0 || >=19.0.0"
+    "react": ">=16.8.0",
+    "react-dom": ">=16.8.0"
   },
   "dependencies": {
     "@plq/is": "^1.2.0"

package/src/@types/storage.ts

@@ -1,26 +1,26 @@
 export interface StorageChange {
-  oldValue?: string | null;
-  newValue?: string | null;
+  oldValue?: string | null
+  newValue?: string | null
 }
 
 export type StorageChangeListener = (changes: { [key: string]: StorageChange }) => void
 
 export interface StorageChangeEvent {
-  addListener(listener: StorageChangeListener): void;
-  removeListener(listener: StorageChangeListener): void;
-  hasListener(listener: StorageChangeListener): boolean;
+  addListener(listener: StorageChangeListener): void
+  removeListener(listener: StorageChangeListener): void
+  hasListener(listener: StorageChangeListener): boolean
 }
 
 export interface Storage {
-  get: (keys: string | string[]) => { [key: string]: string };
-  set: (items: { [key: string]: string }) => void;
-  remove: (keys: string | string[]) => void;
-  onChanged: StorageChangeEvent;
+  get: (keys: string | string[]) => { [key: string]: string }
+  set: (items: { [key: string]: string }) => void
+  remove: (keys: string | string[]) => void
+  onChanged: StorageChangeEvent
 }
 
 export interface AsyncStorage {
-  get: (keys: string | string[]) => Promise<{ [key: string]: string }>;
-  set: (items: { [key: string]: string }) => Promise<void>;
-  remove: (keys: string | string[]) => Promise<void>;
-  onChanged: StorageChangeEvent;
+  get: (keys: string | string[]) => Promise<{ [key: string]: string }>
+  set: (items: { [key: string]: string }) => Promise<void>
+  remove: (keys: string | string[]) => Promise<void>
+  onChanged: StorageChangeEvent
 }