react-simplikit 0.0.50 → 0.0.52

package/dist/hooks/useSet/{index.d.cts → useSet.d.cts}

@@ -1,10 +1,12 @@
+
+//#region src/hooks/useSet/useSet.d.ts
 type SetOrValues<T> = Set<T> | T[];
 type SetActions<T> = {
-    add: (value: T) => void;
-    remove: (value: T) => void;
-    toggle: (value: T) => void;
-    setAll: (values: SetOrValues<T>) => void;
-    reset: () => void;
+  add: (value: T) => void;
+  remove: (value: T) => void;
+  toggle: (value: T) => void;
+  setAll: (values: SetOrValues<T>) => void;
+  reset: () => void;
 };
 type UseSetReturn<T> = [Omit<Set<T>, 'add' | 'clear' | 'delete'>, SetActions<T>];
 /**
@@ -35,5 +37,5 @@ type UseSetReturn<T> = [Omit<Set<T>, 'add' | 'clear' | 'delete'>, SetActions<T>]
  * ```
  */
 declare function useSet<T>(initialState?: SetOrValues<T>): UseSetReturn<T>;
-
-export { useSet };
+//#endregion
+export { useSet };

package/{esm/hooks/useSet/index.d.ts → dist/hooks/useSet/useSet.d.mts}

@@ -1,10 +1,12 @@
+
+//#region src/hooks/useSet/useSet.d.ts
 type SetOrValues<T> = Set<T> | T[];
 type SetActions<T> = {
-    add: (value: T) => void;
-    remove: (value: T) => void;
-    toggle: (value: T) => void;
-    setAll: (values: SetOrValues<T>) => void;
-    reset: () => void;
+  add: (value: T) => void;
+  remove: (value: T) => void;
+  toggle: (value: T) => void;
+  setAll: (values: SetOrValues<T>) => void;
+  reset: () => void;
 };
 type UseSetReturn<T> = [Omit<Set<T>, 'add' | 'clear' | 'delete'>, SetActions<T>];
 /**
@@ -35,5 +37,5 @@ type UseSetReturn<T> = [Omit<Set<T>, 'add' | 'clear' | 'delete'>, SetActions<T>]
  * ```
  */
 declare function useSet<T>(initialState?: SetOrValues<T>): UseSetReturn<T>;
-
-export { useSet };
+//#endregion
+export { useSet };

package/dist/hooks/useSet/useSet.mjs

@@ -0,0 +1,79 @@
+"use client";
+import { usePreservedCallback } from "../usePreservedCallback/usePreservedCallback.mjs";
+import { usePreservedReference } from "../usePreservedReference/usePreservedReference.mjs";
+import { useMemo, useState } from "react";
+//#region src/hooks/useSet/useSet.ts
+/**
+* @description
+* A React hook that manages a Set as state.
+* Provides efficient state management and stable action functions.
+*
+* @param {SetOrValues<T>} initialState - Initial Set state (Set object or array of values)
+* @returns {UseSetReturn<T>} A tuple containing the Set state and actions to manipulate it
+*
+* @example
+* ```tsx
+* import { useSet } from 'react-simplikit';
+*
+* function TagSelector() {
+*   const [selectedTags, { add, remove, toggle }] = useSet<string>(['react']);
+*
+*   return (
+*     <div>
+*       {['react', 'vue', 'svelte'].map(tag => (
+*         <button key={tag} onClick={() => toggle(tag)}>
+*           {selectedTags.has(tag) ? '✓' : ''} {tag}
+*         </button>
+*       ))}
+*     </div>
+*   );
+* }
+* ```
+*/
+function useSet(initialState = /* @__PURE__ */ new Set()) {
+	const [set, setSet] = useState(() => new Set(initialState));
+	const preservedInitialState = usePreservedReference(initialState);
+	const add = usePreservedCallback((value) => {
+		setSet((prev) => {
+			const nextSet = new Set(prev);
+			nextSet.add(value);
+			return nextSet;
+		});
+	});
+	const remove = usePreservedCallback((value) => {
+		setSet((prev) => {
+			const nextSet = new Set(prev);
+			nextSet.delete(value);
+			return nextSet;
+		});
+	});
+	const toggle = usePreservedCallback((value) => {
+		setSet((prev) => {
+			const nextSet = new Set(prev);
+			if (nextSet.has(value)) nextSet.delete(value);
+			else nextSet.add(value);
+			return nextSet;
+		});
+	});
+	const setAll = usePreservedCallback((values) => {
+		setSet(() => new Set(values));
+	});
+	const reset = usePreservedCallback(() => {
+		setSet(() => new Set(preservedInitialState));
+	});
+	return [set, useMemo(() => ({
+		add,
+		remove,
+		toggle,
+		setAll,
+		reset
+	}), [
+		add,
+		remove,
+		toggle,
+		setAll,
+		reset
+	])];
+}
+//#endregion
+export { useSet };

package/dist/hooks/useStorageState/index.d.cts

@@ -1,61 +1,3 @@
-import { SetStateAction } from 'react';
 
-type Storage = {
-    get(key: string): string | null;
-    set(key: string, value: string): void;
-    remove(key: string): void;
-    clear(): void;
-};
-
-type ToObject<T> = T extends unknown[] | Record<string, unknown> ? T : never;
-type Serializable<T> = T extends string | number | boolean ? T : ToObject<T>;
-type StorageStateOptions<T> = {
-    storage?: Storage;
-    defaultValue?: T;
-};
-type StorageStateOptionsWithDefaultValue<T> = StorageStateOptions<T> & {
-    defaultValue: T;
-};
-type StorageStateOptionsWithSerializer<T> = StorageStateOptions<T> & {
-    serializer: (value: Serializable<T>) => string;
-    deserializer: (value: string) => Serializable<T>;
-};
-type SerializableGuard<T extends readonly any[]> = T[0] extends any ? T : T[0] extends never ? 'Received a non-serializable value' : T;
-/**
- * @deprecated This hook is deprecated as it depends on browser-specific APIs (localStorage/sessionStorage).
- * react-simplikit is now focused on platform-independent, pure state/logic hooks.
- * This hook will be removed in a future major version.
- *
- * @description
- * `useStorageState` is a React that functions like `useState` but persists the state value in browser storage.
- * The value is retained across page reloads and can be shared between tabs when using `localStorage`.
- *
- * @param {string} key - The key used to store the value in storage.
- * @param {Object} [options] - Configuration options for storage behavior.
- * @param {Storage} [options.storage=localStorage] - The storage type (`localStorage` or `sessionStorage`). Defaults to `localStorage`.
- * @param {T} [options.defaultValue] - The initial value if no existing value is found.
- * @param {Function} [options.serializer] - A function to serialize the state value to a string.
- * @param {Function} [options.deserializer] - A function to deserialize the state value from a string.
- *
- * @returns {readonly [state: Serializable<T> | undefined, setState: (value: SetStateAction<Serializable<T> | undefined>) => void, refreshState: () => void]} A tuple:
- * - state `Serializable<T> | undefined` - The current state value retrieved from storage;
- * - setState `(value: SetStateAction<Serializable<T> | undefined>) => void` - A function to update and persist the state;
- * - refreshState `() => void` - A function to refresh the state from storage;
- * @example
- * // Counter with persistent state
- * import { useStorageState } from 'react-simplikit';
- *
- * function Counter() {
- *   const [count, setCount] = useStorageState<number>('counter', {
- *     defaultValue: 0,
- *   });
- *
- *   return <button onClick={() => setCount(prev => prev + 1)}>Count: {count}</button>;
- * }
- */
-declare function useStorageState<T>(key: string): SerializableGuard<readonly [Serializable<T> | undefined, (value: SetStateAction<Serializable<T> | undefined>) => void, () => void]>;
-declare function useStorageState<T>(key: string, options: StorageStateOptionsWithDefaultValue<T>): SerializableGuard<readonly [Serializable<T>, (value: SetStateAction<Serializable<T>>) => void, () => void]>;
-declare function useStorageState<T>(key: string, options: StorageStateOptions<T>): SerializableGuard<readonly [Serializable<T> | undefined, (value: SetStateAction<Serializable<T> | undefined>) => void, () => void]>;
-declare function useStorageState<T>(key: string, options: StorageStateOptionsWithSerializer<T>): SerializableGuard<readonly [Serializable<T> | undefined, (value: SetStateAction<Serializable<T> | undefined>) => void, () => void]>;
-
-export { type Serializable, useStorageState };
+import { Serializable, useStorageState } from "./useStorageState.cjs";
+export { useStorageState };

package/dist/hooks/useStorageState/index.d.mts

@@ -0,0 +1,3 @@
+
+import { Serializable, useStorageState } from "./useStorageState.mjs";
+export { useStorageState };

package/dist/hooks/useStorageState/storage.cjs

@@ -0,0 +1,85 @@
+"use client";
+//#region src/hooks/useStorageState/storage.ts
+var MemoStorage = class {
+	storage = /* @__PURE__ */ new Map();
+	get(key) {
+		return this.storage.get(key) ?? null;
+	}
+	set(key, value) {
+		this.storage.set(key, value);
+	}
+	remove(key) {
+		this.storage.delete(key);
+	}
+	clear() {
+		this.storage.clear();
+	}
+};
+var LocalStorage = class {
+	static canUse() {
+		const TEST_KEY = generateTestKey();
+		try {
+			localStorage.setItem(TEST_KEY, "test");
+			localStorage.removeItem(TEST_KEY);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	get(key) {
+		return localStorage.getItem(key);
+	}
+	set(key, value) {
+		localStorage.setItem(key, value);
+	}
+	remove(key) {
+		localStorage.removeItem(key);
+	}
+	clear() {
+		localStorage.clear();
+	}
+};
+var SessionStorage = class {
+	static canUse() {
+		const TEST_KEY = generateTestKey();
+		try {
+			sessionStorage.setItem(TEST_KEY, "test");
+			sessionStorage.removeItem(TEST_KEY);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	get(key) {
+		return sessionStorage.getItem(key);
+	}
+	set(key, value) {
+		sessionStorage.setItem(key, value);
+	}
+	remove(key) {
+		sessionStorage.removeItem(key);
+	}
+	clear() {
+		sessionStorage.clear();
+	}
+};
+function generateTestKey() {
+	return new Array(4).fill(null).map(() => Math.random().toString(36).slice(2)).join("");
+}
+function generateStorage() {
+	if (LocalStorage.canUse()) return new LocalStorage();
+	return new MemoStorage();
+}
+function generateSessionStorage() {
+	if (SessionStorage.canUse()) return new SessionStorage();
+	return new MemoStorage();
+}
+const safeLocalStorage = generateStorage();
+generateSessionStorage();
+//#endregion
+exports.LocalStorage = LocalStorage;
+exports.MemoStorage = MemoStorage;
+exports.SessionStorage = SessionStorage;
+exports.generateSessionStorage = generateSessionStorage;
+exports.generateStorage = generateStorage;
+exports.safeLocalStorage = safeLocalStorage;

package/dist/hooks/useStorageState/storage.d.cts

@@ -0,0 +1,10 @@
+
+//#region src/hooks/useStorageState/storage.d.ts
+type Storage = {
+  get(key: string): string | null;
+  set(key: string, value: string): void;
+  remove(key: string): void;
+  clear(): void;
+};
+//#endregion
+export { Storage };

package/dist/hooks/useStorageState/storage.d.mts

@@ -0,0 +1,10 @@
+
+//#region src/hooks/useStorageState/storage.d.ts
+type Storage = {
+  get(key: string): string | null;
+  set(key: string, value: string): void;
+  remove(key: string): void;
+  clear(): void;
+};
+//#endregion
+export { Storage };

package/dist/hooks/useStorageState/storage.mjs

@@ -0,0 +1,80 @@
+"use client";
+//#region src/hooks/useStorageState/storage.ts
+var MemoStorage = class {
+	storage = /* @__PURE__ */ new Map();
+	get(key) {
+		return this.storage.get(key) ?? null;
+	}
+	set(key, value) {
+		this.storage.set(key, value);
+	}
+	remove(key) {
+		this.storage.delete(key);
+	}
+	clear() {
+		this.storage.clear();
+	}
+};
+var LocalStorage = class {
+	static canUse() {
+		const TEST_KEY = generateTestKey();
+		try {
+			localStorage.setItem(TEST_KEY, "test");
+			localStorage.removeItem(TEST_KEY);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	get(key) {
+		return localStorage.getItem(key);
+	}
+	set(key, value) {
+		localStorage.setItem(key, value);
+	}
+	remove(key) {
+		localStorage.removeItem(key);
+	}
+	clear() {
+		localStorage.clear();
+	}
+};
+var SessionStorage = class {
+	static canUse() {
+		const TEST_KEY = generateTestKey();
+		try {
+			sessionStorage.setItem(TEST_KEY, "test");
+			sessionStorage.removeItem(TEST_KEY);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	get(key) {
+		return sessionStorage.getItem(key);
+	}
+	set(key, value) {
+		sessionStorage.setItem(key, value);
+	}
+	remove(key) {
+		sessionStorage.removeItem(key);
+	}
+	clear() {
+		sessionStorage.clear();
+	}
+};
+function generateTestKey() {
+	return new Array(4).fill(null).map(() => Math.random().toString(36).slice(2)).join("");
+}
+function generateStorage() {
+	if (LocalStorage.canUse()) return new LocalStorage();
+	return new MemoStorage();
+}
+function generateSessionStorage() {
+	if (SessionStorage.canUse()) return new SessionStorage();
+	return new MemoStorage();
+}
+const safeLocalStorage = generateStorage();
+generateSessionStorage();
+//#endregion
+export { LocalStorage, MemoStorage, SessionStorage, generateSessionStorage, generateStorage, safeLocalStorage };

package/dist/hooks/useStorageState/useStorageState.cjs

@@ -0,0 +1,81 @@
+"use client";
+const require_storage = require("./storage.cjs");
+let react = require("react");
+//#region src/hooks/useStorageState/useStorageState.ts
+const listeners = /* @__PURE__ */ new Set();
+const emitListeners = () => {
+	listeners.forEach((listener) => listener());
+};
+function isPlainObject(value) {
+	if (typeof value !== "object") return false;
+	if (!(Object.getPrototypeOf(value) === Object.prototype)) return false;
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+const ensureSerializable = (value) => {
+	if (value[0] != null && ![
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value[0]) && !(isPlainObject(value[0]) || Array.isArray(value[0]))) throw new Error("Received a non-serializable value");
+	return value;
+};
+function useStorageState(key, { storage = require_storage.safeLocalStorage, defaultValue, ...options } = {}) {
+	const serializedDefaultValue = defaultValue;
+	const cache = (0, react.useRef)({
+		data: null,
+		parsed: serializedDefaultValue
+	});
+	const getSnapshot = (0, react.useCallback)(() => {
+		const deserializer = "deserializer" in options ? options.deserializer : JSON.parse;
+		const data = storage.get(key);
+		if (data !== cache.current.data) {
+			try {
+				cache.current.parsed = data != null ? deserializer(data) : defaultValue;
+			} catch {
+				cache.current.parsed = serializedDefaultValue;
+			}
+			cache.current.data = data;
+		}
+		return cache.current.parsed;
+	}, [
+		defaultValue,
+		key,
+		storage
+	]);
+	const storageState = (0, react.useSyncExternalStore)((onStoreChange) => {
+		listeners.add(onStoreChange);
+		const handler = (event) => {
+			if (event.key === key) onStoreChange();
+		};
+		window.addEventListener("storage", handler);
+		return () => {
+			listeners.delete(onStoreChange);
+			window.removeEventListener("storage", handler);
+		};
+	}, () => getSnapshot(), () => serializedDefaultValue);
+	const setStorageState = (0, react.useCallback)((value) => {
+		const serializer = "serializer" in options ? options.serializer : JSON.stringify;
+		const nextValue = typeof value === "function" ? value(getSnapshot()) : value;
+		if (nextValue == null) storage.remove(key);
+		else storage.set(key, serializer(nextValue));
+		emitListeners();
+	}, [
+		getSnapshot,
+		key,
+		storage
+	]);
+	const refreshStorageState = (0, react.useCallback)(() => {
+		setStorageState(getSnapshot());
+	}, [
+		storage,
+		getSnapshot,
+		setStorageState
+	]);
+	return ensureSerializable([
+		storageState,
+		setStorageState,
+		refreshStorageState
+	]);
+}
+//#endregion
+exports.useStorageState = useStorageState;

package/{esm/hooks/useStorageState/index.d.ts → dist/hooks/useStorageState/useStorageState.d.cts}

@@ -1,24 +1,19 @@
-import { SetStateAction } from 'react';
-
-type Storage = {
-    get(key: string): string | null;
-    set(key: string, value: string): void;
-    remove(key: string): void;
-    clear(): void;
-};
 
+import { Storage } from "./storage.cjs";
+import { SetStateAction } from "react";
+//#region src/hooks/useStorageState/useStorageState.d.ts
 type ToObject<T> = T extends unknown[] | Record<string, unknown> ? T : never;
 type Serializable<T> = T extends string | number | boolean ? T : ToObject<T>;
 type StorageStateOptions<T> = {
-    storage?: Storage;
-    defaultValue?: T;
+  storage?: Storage;
+  defaultValue?: T;
 };
 type StorageStateOptionsWithDefaultValue<T> = StorageStateOptions<T> & {
-    defaultValue: T;
+  defaultValue: T;
 };
 type StorageStateOptionsWithSerializer<T> = StorageStateOptions<T> & {
-    serializer: (value: Serializable<T>) => string;
-    deserializer: (value: string) => Serializable<T>;
+  serializer: (value: Serializable<T>) => string;
+  deserializer: (value: string) => Serializable<T>;
 };
 type SerializableGuard<T extends readonly any[]> = T[0] extends any ? T : T[0] extends never ? 'Received a non-serializable value' : T;
 /**
@@ -57,5 +52,5 @@ declare function useStorageState<T>(key: string): SerializableGuard<readonly [Se
 declare function useStorageState<T>(key: string, options: StorageStateOptionsWithDefaultValue<T>): SerializableGuard<readonly [Serializable<T>, (value: SetStateAction<Serializable<T>>) => void, () => void]>;
 declare function useStorageState<T>(key: string, options: StorageStateOptions<T>): SerializableGuard<readonly [Serializable<T> | undefined, (value: SetStateAction<Serializable<T> | undefined>) => void, () => void]>;
 declare function useStorageState<T>(key: string, options: StorageStateOptionsWithSerializer<T>): SerializableGuard<readonly [Serializable<T> | undefined, (value: SetStateAction<Serializable<T> | undefined>) => void, () => void]>;
-
-export { type Serializable, useStorageState };
+//#endregion
+export { Serializable, useStorageState };

package/dist/hooks/useStorageState/useStorageState.d.mts

@@ -0,0 +1,56 @@
+
+import { Storage } from "./storage.mjs";
+import { SetStateAction } from "react";
+//#region src/hooks/useStorageState/useStorageState.d.ts
+type ToObject<T> = T extends unknown[] | Record<string, unknown> ? T : never;
+type Serializable<T> = T extends string | number | boolean ? T : ToObject<T>;
+type StorageStateOptions<T> = {
+  storage?: Storage;
+  defaultValue?: T;
+};
+type StorageStateOptionsWithDefaultValue<T> = StorageStateOptions<T> & {
+  defaultValue: T;
+};
+type StorageStateOptionsWithSerializer<T> = StorageStateOptions<T> & {
+  serializer: (value: Serializable<T>) => string;
+  deserializer: (value: string) => Serializable<T>;
+};
+type SerializableGuard<T extends readonly any[]> = T[0] extends any ? T : T[0] extends never ? 'Received a non-serializable value' : T;
+/**
+ * @deprecated This hook is deprecated as it depends on browser-specific APIs (localStorage/sessionStorage).
+ * react-simplikit is now focused on platform-independent, pure state/logic hooks.
+ * This hook will be removed in a future major version.
+ *
+ * @description
+ * `useStorageState` is a React that functions like `useState` but persists the state value in browser storage.
+ * The value is retained across page reloads and can be shared between tabs when using `localStorage`.
+ *
+ * @param {string} key - The key used to store the value in storage.
+ * @param {Object} [options] - Configuration options for storage behavior.
+ * @param {Storage} [options.storage=localStorage] - The storage type (`localStorage` or `sessionStorage`). Defaults to `localStorage`.
+ * @param {T} [options.defaultValue] - The initial value if no existing value is found.
+ * @param {Function} [options.serializer] - A function to serialize the state value to a string.
+ * @param {Function} [options.deserializer] - A function to deserialize the state value from a string.
+ *
+ * @returns {readonly [state: Serializable<T> | undefined, setState: (value: SetStateAction<Serializable<T> | undefined>) => void, refreshState: () => void]} A tuple:
+ * - state `Serializable<T> | undefined` - The current state value retrieved from storage;
+ * - setState `(value: SetStateAction<Serializable<T> | undefined>) => void` - A function to update and persist the state;
+ * - refreshState `() => void` - A function to refresh the state from storage;
+ * @example
+ * // Counter with persistent state
+ * import { useStorageState } from 'react-simplikit';
+ *
+ * function Counter() {
+ *   const [count, setCount] = useStorageState<number>('counter', {
+ *     defaultValue: 0,
+ *   });
+ *
+ *   return <button onClick={() => setCount(prev => prev + 1)}>Count: {count}</button>;
+ * }
+ */
+declare function useStorageState<T>(key: string): SerializableGuard<readonly [Serializable<T> | undefined, (value: SetStateAction<Serializable<T> | undefined>) => void, () => void]>;
+declare function useStorageState<T>(key: string, options: StorageStateOptionsWithDefaultValue<T>): SerializableGuard<readonly [Serializable<T>, (value: SetStateAction<Serializable<T>>) => void, () => void]>;
+declare function useStorageState<T>(key: string, options: StorageStateOptions<T>): SerializableGuard<readonly [Serializable<T> | undefined, (value: SetStateAction<Serializable<T> | undefined>) => void, () => void]>;
+declare function useStorageState<T>(key: string, options: StorageStateOptionsWithSerializer<T>): SerializableGuard<readonly [Serializable<T> | undefined, (value: SetStateAction<Serializable<T> | undefined>) => void, () => void]>;
+//#endregion
+export { Serializable, useStorageState };

package/dist/hooks/useStorageState/useStorageState.mjs

@@ -0,0 +1,81 @@
+"use client";
+import { safeLocalStorage } from "./storage.mjs";
+import { useCallback, useRef, useSyncExternalStore } from "react";
+//#region src/hooks/useStorageState/useStorageState.ts
+const listeners = /* @__PURE__ */ new Set();
+const emitListeners = () => {
+	listeners.forEach((listener) => listener());
+};
+function isPlainObject(value) {
+	if (typeof value !== "object") return false;
+	if (!(Object.getPrototypeOf(value) === Object.prototype)) return false;
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+const ensureSerializable = (value) => {
+	if (value[0] != null && ![
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value[0]) && !(isPlainObject(value[0]) || Array.isArray(value[0]))) throw new Error("Received a non-serializable value");
+	return value;
+};
+function useStorageState(key, { storage = safeLocalStorage, defaultValue, ...options } = {}) {
+	const serializedDefaultValue = defaultValue;
+	const cache = useRef({
+		data: null,
+		parsed: serializedDefaultValue
+	});
+	const getSnapshot = useCallback(() => {
+		const deserializer = "deserializer" in options ? options.deserializer : JSON.parse;
+		const data = storage.get(key);
+		if (data !== cache.current.data) {
+			try {
+				cache.current.parsed = data != null ? deserializer(data) : defaultValue;
+			} catch {
+				cache.current.parsed = serializedDefaultValue;
+			}
+			cache.current.data = data;
+		}
+		return cache.current.parsed;
+	}, [
+		defaultValue,
+		key,
+		storage
+	]);
+	const storageState = useSyncExternalStore((onStoreChange) => {
+		listeners.add(onStoreChange);
+		const handler = (event) => {
+			if (event.key === key) onStoreChange();
+		};
+		window.addEventListener("storage", handler);
+		return () => {
+			listeners.delete(onStoreChange);
+			window.removeEventListener("storage", handler);
+		};
+	}, () => getSnapshot(), () => serializedDefaultValue);
+	const setStorageState = useCallback((value) => {
+		const serializer = "serializer" in options ? options.serializer : JSON.stringify;
+		const nextValue = typeof value === "function" ? value(getSnapshot()) : value;
+		if (nextValue == null) storage.remove(key);
+		else storage.set(key, serializer(nextValue));
+		emitListeners();
+	}, [
+		getSnapshot,
+		key,
+		storage
+	]);
+	const refreshStorageState = useCallback(() => {
+		setStorageState(getSnapshot());
+	}, [
+		storage,
+		getSnapshot,
+		setStorageState
+	]);
+	return ensureSerializable([
+		storageState,
+		setStorageState,
+		refreshStorageState
+	]);
+}
+//#endregion
+export { useStorageState };

package/dist/hooks/useThrottle/throttle.cjs

@@ -0,0 +1,19 @@
+"use client";
+const require_debounce = require("../useDebounce/debounce.cjs");
+//#region src/hooks/useThrottle/throttle.ts
+function throttle(func, throttleMs, { edges = ["leading", "trailing"] } = {}) {
+	let pendingAt = null;
+	const debounced = require_debounce.debounce(func, throttleMs, { edges });
+	const throttled = function(...args) {
+		if (pendingAt == null) pendingAt = Date.now();
+		else if (Date.now() - pendingAt >= throttleMs) {
+			pendingAt = Date.now();
+			debounced.cancel();
+		}
+		debounced(...args);
+	};
+	throttled.cancel = debounced.cancel;
+	return throttled;
+}
+//#endregion
+exports.throttle = throttle;