@rune-hub/utils 1.0.0

package/hooks/persistentBool/persistentBool.js

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../persistent/index.js');
+var persistent = require('../persistent/persistent.js');
+
+/**
+ * Creates a persistent Rune for boolean values with customizable string representations.
+ *
+ * The Rune automatically loads the initial value from storage (localStorage by default) and saves changes back.
+ * It also listens to `storage` and `pageshow` events to sync state across tabs and page navigations.
+ *
+ * @param key - Storage key to persist the value under.
+ * @param initial - Initial value to use when storage is empty. Can be `boolean` or `null`.
+ * @param params - Optional parameters to customize string representations for `true` and `false` values.
+ * @returns The current value (from storage or initial value). Return type depends on `initial`:
+ * - If `initial` is `null`, returns `boolean | null`.
+ * - Otherwise, returns `boolean`.
+ *
+ * @example Basic usage without initial value
+ * ```ts
+ * const isDarkMode = () => persistentBool('darkMode')
+ *
+ * console.log(get(isDarkMode)) // null initially
+ *
+ * set(isDarkMode, true)
+ * console.log(localStorage.getItem('darkMode')) // '+'
+ *
+ * set(isDarkMode, null)
+ * console.log(localStorage.getItem('darkMode')) // null
+ * ```
+ *
+ * @example Basic usage with initial value
+ * ```ts
+ * const isDarkMode = () => persistentBool('darkMode', false)
+ *
+ * console.log(get(isDarkMode)) // false initially
+ *
+ * set(isDarkMode, true)
+ * console.log(localStorage.getItem('darkMode')) // '+'
+ *
+ * set(isDarkMode, false)
+ * console.log(localStorage.getItem('darkMode')) // '-'
+ * ```
+ *
+ * @example Basic usage with custom storage values
+ * ```ts
+ * const isEnabled = () => persistentBool('isEnabled', false, {
+ *   true: 'enabled',
+ *   false: 'disabled'
+ * })
+ *
+ * set(isEnabled, true)
+ * console.log(localStorage.getItem('isEnabled')) // 'enabled'
+ * ```
+ *
+ * @example Usage with custom storage
+ * ```ts
+ * const isEnabled = () => persistentBool('isEnabled', false, {
+ *   storage: sessionStorage,
+ * })
+ *
+ * set(isEnabled, true)
+ * console.log(sessionStorage.getItem('isEnabled')) // '+'
+ * ```
+ */
+function persistentBool(key, initial, params) {
+    var _a, _b;
+    const positive = (_a = params === null || params === void 0 ? void 0 : params.true) !== null && _a !== void 0 ? _a : '+';
+    const negative = (_b = params === null || params === void 0 ? void 0 : params.false) !== null && _b !== void 0 ? _b : '-';
+    return persistent.persistent(key, initial, Object.assign(Object.assign({}, params), { decode: v => v === positive, encode: v => v === null ? null : v ? positive : negative }));
+}
+
+exports.persistentBool = persistentBool;

package/hooks/persistentBool/persistentBool.mjs

@@ -0,0 +1,71 @@
+import '../persistent/index.mjs';
+import { persistent } from '../persistent/persistent.mjs';
+
+/**
+ * Creates a persistent Rune for boolean values with customizable string representations.
+ *
+ * The Rune automatically loads the initial value from storage (localStorage by default) and saves changes back.
+ * It also listens to `storage` and `pageshow` events to sync state across tabs and page navigations.
+ *
+ * @param key - Storage key to persist the value under.
+ * @param initial - Initial value to use when storage is empty. Can be `boolean` or `null`.
+ * @param params - Optional parameters to customize string representations for `true` and `false` values.
+ * @returns The current value (from storage or initial value). Return type depends on `initial`:
+ * - If `initial` is `null`, returns `boolean | null`.
+ * - Otherwise, returns `boolean`.
+ *
+ * @example Basic usage without initial value
+ * ```ts
+ * const isDarkMode = () => persistentBool('darkMode')
+ *
+ * console.log(get(isDarkMode)) // null initially
+ *
+ * set(isDarkMode, true)
+ * console.log(localStorage.getItem('darkMode')) // '+'
+ *
+ * set(isDarkMode, null)
+ * console.log(localStorage.getItem('darkMode')) // null
+ * ```
+ *
+ * @example Basic usage with initial value
+ * ```ts
+ * const isDarkMode = () => persistentBool('darkMode', false)
+ *
+ * console.log(get(isDarkMode)) // false initially
+ *
+ * set(isDarkMode, true)
+ * console.log(localStorage.getItem('darkMode')) // '+'
+ *
+ * set(isDarkMode, false)
+ * console.log(localStorage.getItem('darkMode')) // '-'
+ * ```
+ *
+ * @example Basic usage with custom storage values
+ * ```ts
+ * const isEnabled = () => persistentBool('isEnabled', false, {
+ *   true: 'enabled',
+ *   false: 'disabled'
+ * })
+ *
+ * set(isEnabled, true)
+ * console.log(localStorage.getItem('isEnabled')) // 'enabled'
+ * ```
+ *
+ * @example Usage with custom storage
+ * ```ts
+ * const isEnabled = () => persistentBool('isEnabled', false, {
+ *   storage: sessionStorage,
+ * })
+ *
+ * set(isEnabled, true)
+ * console.log(sessionStorage.getItem('isEnabled')) // '+'
+ * ```
+ */
+function persistentBool(key, initial, params) {
+    var _a, _b;
+    const positive = (_a = params === null || params === void 0 ? void 0 : params.true) !== null && _a !== void 0 ? _a : '+';
+    const negative = (_b = params === null || params === void 0 ? void 0 : params.false) !== null && _b !== void 0 ? _b : '-';
+    return persistent(key, initial, Object.assign(Object.assign({}, params), { decode: v => v === positive, encode: v => v === null ? null : v ? positive : negative }));
+}
+
+export { persistentBool };

package/hooks/persistentJSON/index.d.ts

@@ -0,0 +1 @@
+export * from './persistentJSON';

package/hooks/persistentJSON/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var persistentJSON = require('./persistentJSON.js');
+
+
+
+exports.persistentJSON = persistentJSON.persistentJSON;

package/hooks/persistentJSON/index.mjs

@@ -0,0 +1 @@
+export { persistentJSON } from './persistentJSON.mjs';

package/hooks/persistentJSON/persistentJSON.d.ts

@@ -0,0 +1,46 @@
+import type { PersistentParams } from '../persistent';
+type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+export type PersistentJSONParams<T = unknown> = Omit<PersistentParams<T>, 'decode' | 'encode'>;
+/**
+ * Creates a persistent Rune for JSON-serializable values.
+ *
+ * The Rune automatically loads the initial value from storage (localStorage by default) and saves changes back.
+ * It also listens to `storage` and `pageshow` events to sync state across tabs and page navigations.
+ *
+ * @param key - Storage key to persist the value under.
+ * @param initial - Initial value to use when storage is empty. Can be any JSON-serializable value or `undefined`.
+ * @param params - Optional parameters to customize storage behavior.
+ * @returns The current value (from storage or initial value). Return type matches the type of `initial` or `unknown` if `initial` is not provided.
+ *
+ * @example Basic usage with object
+ * ```ts
+ * const userSettings = () => persistentJSON('userSettings', { theme: 'light', notifications: true })
+ *
+ * console.log(get(userSettings)) // { theme: 'light', notifications: true } initially
+ *
+ * set(userSettings, { theme: 'dark', notifications: false })
+ * console.log(localStorage.getItem('userSettings')) // '{"theme":"dark","notifications":false}'
+ * ```
+ *
+ * @example Basic usage with array
+ * ```ts
+ * const favorites = () => persistentJSON('favorites', [])
+ *
+ * console.log(get(favorites)) // [] initially
+ *
+ * set(favorites, ['item1', 'item2'])
+ * console.log(localStorage.getItem('favorites')) // '["item1","item2"]'
+ * ```
+ *
+ * @example Usage with custom storage
+ * ```ts
+ * const preferences = () => persistentJSON('preferences', { lang: 'en' }, {
+ *   storage: sessionStorage,
+ * })
+ *
+ * set(preferences, { lang: 'ru' })
+ * console.log(sessionStorage.getItem('preferences')) // '{"lang":"ru"}'
+ * ```
+ */
+export declare function persistentJSON<T = unknown>(key: string, initial?: T, params?: PersistentJSONParams<T>): T extends undefined ? unknown : Widen<T>;
+export {};

package/hooks/persistentJSON/persistentJSON.js

@@ -0,0 +1,53 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../persistent/index.js');
+var persistent = require('../persistent/persistent.js');
+
+/**
+ * Creates a persistent Rune for JSON-serializable values.
+ *
+ * The Rune automatically loads the initial value from storage (localStorage by default) and saves changes back.
+ * It also listens to `storage` and `pageshow` events to sync state across tabs and page navigations.
+ *
+ * @param key - Storage key to persist the value under.
+ * @param initial - Initial value to use when storage is empty. Can be any JSON-serializable value or `undefined`.
+ * @param params - Optional parameters to customize storage behavior.
+ * @returns The current value (from storage or initial value). Return type matches the type of `initial` or `unknown` if `initial` is not provided.
+ *
+ * @example Basic usage with object
+ * ```ts
+ * const userSettings = () => persistentJSON('userSettings', { theme: 'light', notifications: true })
+ *
+ * console.log(get(userSettings)) // { theme: 'light', notifications: true } initially
+ *
+ * set(userSettings, { theme: 'dark', notifications: false })
+ * console.log(localStorage.getItem('userSettings')) // '{"theme":"dark","notifications":false}'
+ * ```
+ *
+ * @example Basic usage with array
+ * ```ts
+ * const favorites = () => persistentJSON('favorites', [])
+ *
+ * console.log(get(favorites)) // [] initially
+ *
+ * set(favorites, ['item1', 'item2'])
+ * console.log(localStorage.getItem('favorites')) // '["item1","item2"]'
+ * ```
+ *
+ * @example Usage with custom storage
+ * ```ts
+ * const preferences = () => persistentJSON('preferences', { lang: 'en' }, {
+ *   storage: sessionStorage,
+ * })
+ *
+ * set(preferences, { lang: 'ru' })
+ * console.log(sessionStorage.getItem('preferences')) // '{"lang":"ru"}'
+ * ```
+ */
+function persistentJSON(key, initial, params) {
+    return persistent.persistent(key, initial, Object.assign(Object.assign({}, params), { decode: v => JSON.parse(v), encode: v => JSON.stringify(v) }));
+}
+
+exports.persistentJSON = persistentJSON;

package/hooks/persistentJSON/persistentJSON.mjs

@@ -0,0 +1,49 @@
+import '../persistent/index.mjs';
+import { persistent } from '../persistent/persistent.mjs';
+
+/**
+ * Creates a persistent Rune for JSON-serializable values.
+ *
+ * The Rune automatically loads the initial value from storage (localStorage by default) and saves changes back.
+ * It also listens to `storage` and `pageshow` events to sync state across tabs and page navigations.
+ *
+ * @param key - Storage key to persist the value under.
+ * @param initial - Initial value to use when storage is empty. Can be any JSON-serializable value or `undefined`.
+ * @param params - Optional parameters to customize storage behavior.
+ * @returns The current value (from storage or initial value). Return type matches the type of `initial` or `unknown` if `initial` is not provided.
+ *
+ * @example Basic usage with object
+ * ```ts
+ * const userSettings = () => persistentJSON('userSettings', { theme: 'light', notifications: true })
+ *
+ * console.log(get(userSettings)) // { theme: 'light', notifications: true } initially
+ *
+ * set(userSettings, { theme: 'dark', notifications: false })
+ * console.log(localStorage.getItem('userSettings')) // '{"theme":"dark","notifications":false}'
+ * ```
+ *
+ * @example Basic usage with array
+ * ```ts
+ * const favorites = () => persistentJSON('favorites', [])
+ *
+ * console.log(get(favorites)) // [] initially
+ *
+ * set(favorites, ['item1', 'item2'])
+ * console.log(localStorage.getItem('favorites')) // '["item1","item2"]'
+ * ```
+ *
+ * @example Usage with custom storage
+ * ```ts
+ * const preferences = () => persistentJSON('preferences', { lang: 'en' }, {
+ *   storage: sessionStorage,
+ * })
+ *
+ * set(preferences, { lang: 'ru' })
+ * console.log(sessionStorage.getItem('preferences')) // '{"lang":"ru"}'
+ * ```
+ */
+function persistentJSON(key, initial, params) {
+    return persistent(key, initial, Object.assign(Object.assign({}, params), { decode: v => JSON.parse(v), encode: v => JSON.stringify(v) }));
+}
+
+export { persistentJSON };

package/hooks/persistentNum/index.d.ts

@@ -0,0 +1 @@
+export * from './persistentNum';

package/hooks/persistentNum/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var persistentNum = require('./persistentNum.js');
+
+
+
+exports.persistentNum = persistentNum.persistentNum;

package/hooks/persistentNum/index.mjs

@@ -0,0 +1 @@
+export { persistentNum } from './persistentNum.mjs';

package/hooks/persistentNum/persistentNum.d.ts

@@ -0,0 +1,57 @@
+import type { PersistentParams } from '../persistent';
+export type PersistentNumParams<T extends number | null = number | null> = Omit<PersistentParams<T>, 'decode' | 'encode'>;
+/**
+ * Creates a persistent Rune for numeric values.
+ *
+ * The Rune automatically loads the initial value from storage (localStorage by default) and saves changes back.
+ * It also listens to `storage` and `pageshow` events to sync state across tabs and page navigations.
+ *
+ * @param key - Storage key to persist the value under.
+ * @param initial - Initial value to use when storage is empty. Can be `number` or `null`.
+ * @param params - Optional parameters to customize storage behavior.
+ * @returns The current value (from storage or initial value). Return type depends on `initial`:
+ * - If `initial` is `null`, returns `number | null`.
+ * - Otherwise, returns `number`.
+ *
+ * @example Basic usage without initial value
+ * ```ts
+ * const counter = () => persistentNum('counter')
+ *
+ * console.log(get(counter)) // null initially
+ *
+ * set(counter, 42)
+ * console.log(localStorage.getItem('counter')) // '42'
+ *
+ * set(counter, null)
+ * console.log(localStorage.getItem('counter')) // null
+ * ```
+ *
+ * @example Basic usage with initial value
+ * ```ts
+ * const counter = () => persistentNum('counter', 0)
+ *
+ * console.log(get(counter)) // 0 initially
+ *
+ * set(counter, 42)
+ * console.log(localStorage.getItem('counter')) // '42'
+ *
+ * set(counter, 0)
+ * console.log(localStorage.getItem('counter')) // '0'
+ * ```
+ *
+ * @example Usage with custom storage
+ * ```ts
+ * const counter = () => persistentNum('counter', 0, {
+ *   storage: sessionStorage,
+ * })
+ *
+ * console.log(get(counter)) // 0 initially
+ *
+ * set(counter, 42)
+ * console.log(sessionStorage.getItem('counter')) // '42'
+ *
+ * set(counter, 0)
+ * console.log(sessionStorage.getItem('counter')) // '0'
+ * ```
+ */
+export declare function persistentNum<T extends number | null = number | null>(key: string, initial?: T, params?: PersistentNumParams<T>): T extends null ? null | number : number;

package/hooks/persistentNum/persistentNum.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../persistent/index.js');
+var persistent = require('../persistent/persistent.js');
+
+/**
+ * Creates a persistent Rune for numeric values.
+ *
+ * The Rune automatically loads the initial value from storage (localStorage by default) and saves changes back.
+ * It also listens to `storage` and `pageshow` events to sync state across tabs and page navigations.
+ *
+ * @param key - Storage key to persist the value under.
+ * @param initial - Initial value to use when storage is empty. Can be `number` or `null`.
+ * @param params - Optional parameters to customize storage behavior.
+ * @returns The current value (from storage or initial value). Return type depends on `initial`:
+ * - If `initial` is `null`, returns `number | null`.
+ * - Otherwise, returns `number`.
+ *
+ * @example Basic usage without initial value
+ * ```ts
+ * const counter = () => persistentNum('counter')
+ *
+ * console.log(get(counter)) // null initially
+ *
+ * set(counter, 42)
+ * console.log(localStorage.getItem('counter')) // '42'
+ *
+ * set(counter, null)
+ * console.log(localStorage.getItem('counter')) // null
+ * ```
+ *
+ * @example Basic usage with initial value
+ * ```ts
+ * const counter = () => persistentNum('counter', 0)
+ *
+ * console.log(get(counter)) // 0 initially
+ *
+ * set(counter, 42)
+ * console.log(localStorage.getItem('counter')) // '42'
+ *
+ * set(counter, 0)
+ * console.log(localStorage.getItem('counter')) // '0'
+ * ```
+ *
+ * @example Usage with custom storage
+ * ```ts
+ * const counter = () => persistentNum('counter', 0, {
+ *   storage: sessionStorage,
+ * })
+ *
+ * console.log(get(counter)) // 0 initially
+ *
+ * set(counter, 42)
+ * console.log(sessionStorage.getItem('counter')) // '42'
+ *
+ * set(counter, 0)
+ * console.log(sessionStorage.getItem('counter')) // '0'
+ * ```
+ */
+function persistentNum(key, initial, params) {
+    return persistent.persistent(key, initial, Object.assign(Object.assign({}, params), { decode: Number, encode: v => v === null ? null : String(v) }));
+}
+
+exports.persistentNum = persistentNum;

package/hooks/persistentNum/persistentNum.mjs

@@ -0,0 +1,62 @@
+import '../persistent/index.mjs';
+import { persistent } from '../persistent/persistent.mjs';
+
+/**
+ * Creates a persistent Rune for numeric values.
+ *
+ * The Rune automatically loads the initial value from storage (localStorage by default) and saves changes back.
+ * It also listens to `storage` and `pageshow` events to sync state across tabs and page navigations.
+ *
+ * @param key - Storage key to persist the value under.
+ * @param initial - Initial value to use when storage is empty. Can be `number` or `null`.
+ * @param params - Optional parameters to customize storage behavior.
+ * @returns The current value (from storage or initial value). Return type depends on `initial`:
+ * - If `initial` is `null`, returns `number | null`.
+ * - Otherwise, returns `number`.
+ *
+ * @example Basic usage without initial value
+ * ```ts
+ * const counter = () => persistentNum('counter')
+ *
+ * console.log(get(counter)) // null initially
+ *
+ * set(counter, 42)
+ * console.log(localStorage.getItem('counter')) // '42'
+ *
+ * set(counter, null)
+ * console.log(localStorage.getItem('counter')) // null
+ * ```
+ *
+ * @example Basic usage with initial value
+ * ```ts
+ * const counter = () => persistentNum('counter', 0)
+ *
+ * console.log(get(counter)) // 0 initially
+ *
+ * set(counter, 42)
+ * console.log(localStorage.getItem('counter')) // '42'
+ *
+ * set(counter, 0)
+ * console.log(localStorage.getItem('counter')) // '0'
+ * ```
+ *
+ * @example Usage with custom storage
+ * ```ts
+ * const counter = () => persistentNum('counter', 0, {
+ *   storage: sessionStorage,
+ * })
+ *
+ * console.log(get(counter)) // 0 initially
+ *
+ * set(counter, 42)
+ * console.log(sessionStorage.getItem('counter')) // '42'
+ *
+ * set(counter, 0)
+ * console.log(sessionStorage.getItem('counter')) // '0'
+ * ```
+ */
+function persistentNum(key, initial, params) {
+    return persistent(key, initial, Object.assign(Object.assign({}, params), { decode: Number, encode: v => v === null ? null : String(v) }));
+}
+
+export { persistentNum };

package/hooks/persistentRune/index.d.ts

@@ -0,0 +1 @@
+export * from './persistentRune';

package/hooks/persistentRune/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var persistentRune = require('./persistentRune.js');
+
+
+
+exports.persistentRune = persistentRune.persistentRune;
+exports.persistentStorageMap = persistentRune.persistentStorageMap;

package/hooks/persistentRune/index.mjs

@@ -0,0 +1 @@
+export { persistentRune, persistentStorageMap } from './persistentRune.mjs';

package/hooks/persistentRune/persistentRune.d.ts

@@ -0,0 +1,4 @@
+import type { Rune } from 'rune-hub';
+export type PersistentStorage = Record<string, string | null>;
+export declare const persistentStorageMap: Map<PersistentStorage, Record<string, Rune<string | null>>>;
+export declare function persistentRune(key: string, storage?: PersistentStorage): Rune<string | null>;

package/hooks/persistentRune/persistentRune.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runeHub = require('rune-hub');
+
+const persistentStorageMap = new Map();
+function persistentRune(key, storage = typeof localStorage !== 'undefined' ? localStorage : {}) {
+    let map = persistentStorageMap.get(storage);
+    if (!map) {
+        persistentStorageMap.set(storage, map = {});
+    }
+    if (!map[key]) {
+        map[key] = () => {
+            var _a;
+            const ctx = ((_a = runeHub.Hub.cur) !== null && _a !== void 0 ? _a : runeHub.Hub.root).ctx;
+            if (!ctx)
+                return null;
+            if (!ctx.inited) {
+                ctx.on('change', () => {
+                    const value = ctx.cur;
+                    if (value === null) {
+                        delete storage[key];
+                    }
+                    else {
+                        storage[key] = value;
+                    }
+                });
+                ctx.on('get', () => {
+                    if (!ctx.up) {
+                        const cur = storage[key];
+                        if (ctx.cur !== cur) {
+                            ctx.prev = ctx.cur;
+                            ctx.cur = cur;
+                        }
+                    }
+                });
+                if (typeof window !== 'undefined') {
+                    const listener = (e) => {
+                        if (e.key !== key || e.storageArea !== storage)
+                            return;
+                        ctx.set(e.newValue);
+                    };
+                    const restore = () => {
+                        ctx.set(storage[key]);
+                    };
+                    ctx.on('up', () => {
+                        window.addEventListener('storage', listener);
+                        window.addEventListener('pageshow', restore);
+                    });
+                    const clear = () => {
+                        window.removeEventListener('storage', listener);
+                        window.removeEventListener('pageshow', restore);
+                    };
+                    ctx.on('down', clear);
+                    ctx.on('destroy', clear);
+                }
+            }
+            return storage[key];
+        };
+    }
+    return map[key];
+}
+
+exports.persistentRune = persistentRune;
+exports.persistentStorageMap = persistentStorageMap;

package/hooks/persistentRune/persistentRune.mjs

@@ -0,0 +1,61 @@
+import { Hub } from 'rune-hub';
+
+const persistentStorageMap = new Map();
+function persistentRune(key, storage = typeof localStorage !== 'undefined' ? localStorage : {}) {
+    let map = persistentStorageMap.get(storage);
+    if (!map) {
+        persistentStorageMap.set(storage, map = {});
+    }
+    if (!map[key]) {
+        map[key] = () => {
+            var _a;
+            const ctx = ((_a = Hub.cur) !== null && _a !== void 0 ? _a : Hub.root).ctx;
+            if (!ctx)
+                return null;
+            if (!ctx.inited) {
+                ctx.on('change', () => {
+                    const value = ctx.cur;
+                    if (value === null) {
+                        delete storage[key];
+                    }
+                    else {
+                        storage[key] = value;
+                    }
+                });
+                ctx.on('get', () => {
+                    if (!ctx.up) {
+                        const cur = storage[key];
+                        if (ctx.cur !== cur) {
+                            ctx.prev = ctx.cur;
+                            ctx.cur = cur;
+                        }
+                    }
+                });
+                if (typeof window !== 'undefined') {
+                    const listener = (e) => {
+                        if (e.key !== key || e.storageArea !== storage)
+                            return;
+                        ctx.set(e.newValue);
+                    };
+                    const restore = () => {
+                        ctx.set(storage[key]);
+                    };
+                    ctx.on('up', () => {
+                        window.addEventListener('storage', listener);
+                        window.addEventListener('pageshow', restore);
+                    });
+                    const clear = () => {
+                        window.removeEventListener('storage', listener);
+                        window.removeEventListener('pageshow', restore);
+                    };
+                    ctx.on('down', clear);
+                    ctx.on('destroy', clear);
+                }
+            }
+            return storage[key];
+        };
+    }
+    return map[key];
+}
+
+export { persistentRune, persistentStorageMap };

package/index.d.ts

@@ -0,0 +1 @@
+export * from './hooks';