@plitzi/plitzi-ui 1.6.2

package/dist/helpers/lodash/omit.js

@@ -0,0 +1,26 @@
+import { toPath as e } from "./shared.js";
+import { cloneAtPath as t } from "./cloneDeep.js";
+import { has as n } from "./has.js";
+//#region src/helpers/lodash/omit.ts
+function r(r, i) {
+	let a = Array.isArray(i) ? i : i ? [i] : [];
+	if (a.length === 0) return { ...r };
+	let o = r;
+	for (let r of a) {
+		let i = e(r);
+		if (!i.length || !n(o, r)) continue;
+		let a = t(o, r), s = a;
+		for (let e = 0; e < i.length - 1 && !(!s || typeof s != "object"); e++) {
+			let t = i[e];
+			s = s[t];
+		}
+		if (s && typeof s == "object") {
+			let e = i[i.length - 1];
+			Object.prototype.hasOwnProperty.call(s, e) && delete s[e];
+		}
+		o = a;
+	}
+	return o;
+}
+//#endregion
+export { r as omit };

package/dist/helpers/lodash/pick.d.ts

@@ -0,0 +1,3 @@
+import { Path } from './shared';
+export declare function pick<T extends Record<string, unknown>, K extends keyof T & string>(obj: T, paths: K | readonly [K] | readonly K[]): Pick<T, K>;
+export declare function pick<T extends Record<string, unknown>>(obj: T, paths: Path | readonly Path[]): Partial<T>;

package/dist/helpers/lodash/pick.js

@@ -0,0 +1,13 @@
+import { get as e } from "./get.js";
+import { set as t } from "./set.js";
+//#region src/helpers/lodash/pick.ts
+function n(n, r) {
+	let i = {}, a = Array.isArray(r) ? r : [r];
+	for (let r of a) {
+		let a = e(n, r);
+		a !== void 0 && t(i, r, a);
+	}
+	return i;
+}
+//#endregion
+export { n as pick };

package/dist/helpers/lodash/set.d.ts

@@ -0,0 +1,2 @@
+import { Path } from './shared';
+export declare function set<T extends Record<string, unknown> | Record<string, unknown>[]>(obj: T, path: Path, value: unknown): T;

package/dist/helpers/lodash/set.js

@@ -0,0 +1,21 @@
+import { toPath as e } from "./shared.js";
+//#region src/helpers/lodash/set.ts
+function t(t, n, r) {
+	let i = e(n);
+	if (!i.length) return t;
+	let a = t;
+	for (let e = 0; e < i.length - 1; e++) {
+		let n = i[e], r = i[e + 1];
+		if (typeof a != "object" || !a) return t;
+		let o = a;
+		(o[n] == null || typeof o[n] != "object") && (o[n] = /^\d+$/.test(r) ? [] : {}), a = o[n];
+	}
+	let o = i[i.length - 1];
+	if (typeof a == "object" && a) {
+		let e = a;
+		e[o] = r;
+	}
+	return t;
+}
+//#endregion
+export { t as set };

package/dist/helpers/lodash/shared.d.ts

@@ -0,0 +1,2 @@
+export type Path = string | readonly (string | number)[];
+export declare function toPath(path: Path, strict?: boolean): string[];

package/dist/helpers/lodash/shared.js

@@ -0,0 +1,38 @@
+//#region src/helpers/lodash/shared.ts
+function e(e) {
+	if (typeof e == "string" || typeof e == "number") {
+		let t = String(e);
+		return t === "" ? null : /^[a-zA-Z0-9_-]+$/.test(t) || /^\d+$/.test(t) ? t : null;
+	}
+	return null;
+}
+function t(t, n) {
+	if (!t || t.startsWith(".") || t.endsWith(".") || /[^a-zA-Z0-9_.[\]-]/.test(t) || n && (/\.\.|(\[\])/g.test(t) || (t.match(/\[/g) || []).length !== (t.match(/\]/g) || []).length || /\][^.[]/.test(t))) return [];
+	let r = [], i = /([^.[\]]+)|\[(\d+)\]/g, a;
+	for (; a = i.exec(t);) if (a[1]) {
+		if (!n && a[1] === "") continue;
+		let t = e(a[1]);
+		if (t !== null) r.push(t);
+		else if (n) return [];
+	} else if (a[2]) {
+		let t = e(a[2]);
+		if (t !== null) r.push(t);
+		else if (n) return [];
+	}
+	return r.length ? r : [];
+}
+function n(t, n) {
+	if (!Array.isArray(t)) return [];
+	let r = [];
+	for (let i of t) {
+		let t = e(i);
+		if (t !== null) r.push(t);
+		else if (n) return [];
+	}
+	return r;
+}
+function r(e, r = !0) {
+	return e ? typeof e == "string" ? t(e, r) : Array.isArray(e) ? n(e, r) : [] : [];
+}
+//#endregion
+export { r as toPath };

package/dist/helpers/lodash/snakeCase.d.ts

@@ -0,0 +1 @@
+export declare function snakeCase(value: string): string;

package/dist/helpers/lodash/snakeCase.js

@@ -0,0 +1,6 @@
+//#region src/helpers/lodash/snakeCase.ts
+function e(e) {
+	return e ? e.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([0-9])([a-zA-Z])/g, "$1 $2").replace(/([a-zA-Z])([0-9])/g, "$1 $2").replace(/[_\s-]+/g, " ").trim().split(/\s+/).map((e) => e.toLowerCase()).join("_") : "";
+}
+//#endregion
+export { e as snakeCase };

package/dist/helpers/lodash/throttle.d.ts

@@ -0,0 +1,2 @@
+import { DebouncedFunction, DebounceOptions } from './debounce';
+export declare function throttle<F extends (...args: any[]) => any>(func: F, wait?: number, options?: DebounceOptions): DebouncedFunction<F>;

package/dist/helpers/lodash/throttle.js

@@ -0,0 +1,11 @@
+import { debounce as e } from "./debounce.js";
+//#region src/helpers/lodash/throttle.ts
+function t(t, n = 0, r = {}) {
+	return e(t, n, {
+		leading: r.leading ?? !0,
+		trailing: r.trailing ?? !0,
+		maxWait: n
+	});
+}
+//#endregion
+export { t as throttle };

package/dist/helpers/lodash/upperFirst.d.ts

@@ -0,0 +1 @@
+export declare function upperFirst(value: string): string;

package/dist/helpers/lodash/upperFirst.js

@@ -0,0 +1,6 @@
+//#region src/helpers/lodash/upperFirst.ts
+function e(e) {
+	return !e || typeof e != "string" || !e.trim() ? "" : e.charAt(0).toUpperCase() + e.slice(1);
+}
+//#endregion
+export { e as upperFirst };

package/dist/helpers/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const arrayDifference: <T>(array1: T[], array2: T[], resultType?: "left" | "right" | "both") => T[];
+export declare const isInViewport: (el?: HTMLElement) => boolean;
+export declare const isFunction: <T = unknown>(value: T | ((state: T) => T)) => value is (prevState: T) => T;
+export declare const isString: <T = unknown>(value: T | ((state: T) => T)) => value is (prevState: T) => T;

package/dist/helpers/utils.js

@@ -0,0 +1,14 @@
+//#region src/helpers/utils.ts
+var e = (e, t, n = "right") => {
+	let r = new Set(e), i = new Set(t);
+	if (n === "left") return [...r].filter((e) => !i.has(e));
+	if (n === "right") return [...i].filter((e) => !r.has(e));
+	let a = [...r].filter((e) => !i.has(e)), o = [...i].filter((e) => !r.has(e));
+	return [...a, ...o];
+}, t = (e) => {
+	if (!e) return !1;
+	let { top: t, left: n, bottom: r, right: i } = e.getBoundingClientRect(), { innerHeight: a, innerWidth: o } = window, { documentElement: { clientHeight: s, clientWidth: c } } = document;
+	return t >= 0 && n >= 0 && r <= (a || s) && i <= (o || c);
+}, n = (e) => typeof e == "function", r = (e) => typeof e == "string";
+//#endregion
+export { e as arrayDifference, n as isFunction, t as isInViewport, r as isString };

package/dist/hooks/index.d.ts

@@ -0,0 +1,17 @@
+import { default as useDidUpdateEffect } from './useDidUpdateEffect';
+import { default as useDisclosure } from './useDisclosure';
+import { default as useReducerWithMiddleware } from './useReducerWithMiddleware';
+import { default as useStateDebounce } from './useStateDebounce';
+import { default as useStateMemo } from './useStateMemo';
+import { default as useStorage } from './useStorage';
+import { default as useTheme } from './useTheme';
+import { default as useValueMemo } from './useValueMemo';
+export * from './useReducerWithMiddleware';
+export * from './useStateMemo';
+export * from './useStateDebounce';
+export * from './useStorage';
+export * from './useDisclosure';
+export * from './useValueMemo';
+export * from './useDidUpdateEffect';
+export * from './useTheme';
+export { useReducerWithMiddleware, useStateMemo, useStateDebounce, useTheme, useDisclosure, useDidUpdateEffect, useValueMemo, useStorage };

package/dist/hooks/index.js

@@ -0,0 +1,22 @@
+import { __exportAll as e } from "../_virtual/_rolldown/runtime.js";
+import t from "./useValueMemo/index.js";
+import n from "./useTheme/index.js";
+import r from "./useDidUpdateEffect/index.js";
+import i from "./useDisclosure/index.js";
+import a from "./useReducerWithMiddleware/index.js";
+import o from "./useStateDebounce/index.js";
+import s from "./useStateMemo/index.js";
+import c from "./useStorage/index.js";
+//#region src/hooks/index.ts
+var l = /* @__PURE__ */ e({
+	useDidUpdateEffect: () => r,
+	useDisclosure: () => i,
+	useReducerWithMiddleware: () => a,
+	useStateDebounce: () => o,
+	useStateMemo: () => s,
+	useStorage: () => c,
+	useTheme: () => n,
+	useValueMemo: () => t
+});
+//#endregion
+export { l as hooks_exports };

package/dist/hooks/useDidUpdateEffect/index.d.ts

@@ -0,0 +1,3 @@
+import { default as useDidUpdateEffect } from './useDidUpdateEffect';
+export * from './useDidUpdateEffect';
+export default useDidUpdateEffect;

package/dist/hooks/useDidUpdateEffect/index.js

@@ -0,0 +1,5 @@
+import e from "./useDidUpdateEffect.js";
+//#region src/hooks/useDidUpdateEffect/index.ts
+var t = e;
+//#endregion
+export { t as default };

package/dist/hooks/useDidUpdateEffect/useDidUpdateEffect.d.ts

@@ -0,0 +1,4 @@
+import { DependencyList, EffectCallback } from 'react';
+export type UpdateEffectCallback = EffectCallback | ((prevDependencies: DependencyList) => void);
+declare const useDidUpdateEffect: (callback: UpdateEffectCallback, dependencies: DependencyList, asEffect?: boolean) => void;
+export default useDidUpdateEffect;

package/dist/hooks/useDidUpdateEffect/useDidUpdateEffect.js

@@ -0,0 +1,14 @@
+import { useEffect as e, useRef as t } from "react";
+//#region src/hooks/useDidUpdateEffect/useDidUpdateEffect.ts
+var n = (n, r, i = !1) => {
+	let a = t(i), o = t(r);
+	e(() => {
+		if (a.current) {
+			let e = o.current;
+			return o.current = r, n(e);
+		}
+		a.current = !0, o.current = r;
+	}, r);
+};
+//#endregion
+export { n as default };

package/dist/hooks/useDisclosure/index.d.ts

@@ -0,0 +1,3 @@
+import { default as useDisclosure } from './useDisclosure';
+export * from './useDisclosure';
+export default useDisclosure;

package/dist/hooks/useDisclosure/index.js

@@ -0,0 +1,5 @@
+import e from "./useDisclosure.js";
+//#region src/hooks/useDisclosure/index.ts
+var t = e;
+//#endregion
+export { t as default };

package/dist/hooks/useDisclosure/useDisclosure.d.ts

@@ -0,0 +1,23 @@
+export type UseDisclosureProps<TValue = unknown, TState = unknown> = {
+    id?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    delay?: number;
+    onOpen?: (e?: MouseEvent | React.MouseEvent, initialState?: TState) => void;
+    onClose?: ((e?: MouseEvent | React.MouseEvent, value?: TValue, state?: TState) => boolean | Promise<boolean>) | ((e?: MouseEvent | React.MouseEvent, value?: TValue, state?: TState) => void | Promise<void>);
+    stopEventPropagation?: boolean;
+};
+export type UseDisclosureReturn<TValue = unknown, TState = unknown> = [
+    id: string,
+    open: boolean,
+    onOpen: (e?: MouseEvent | React.MouseEvent, initialState?: TState) => void,
+    onClose: (e?: MouseEvent | React.MouseEvent, value?: TValue) => Promise<void>,
+    onToggle: (e?: MouseEvent | React.MouseEvent) => void,
+    state: TState,
+    delayState: {
+        delay: number;
+        isClosing: boolean;
+    }
+];
+declare const useDisclosure: <TValue = unknown, TState = unknown>({ onClose: onCloseProp, onOpen: onOpenProp, open: openProp, defaultOpen, id: idProp, delay, stopEventPropagation }?: UseDisclosureProps<TValue, TState>) => UseDisclosureReturn<TValue, TState>;
+export default useDisclosure;

package/dist/hooks/useDisclosure/useDisclosure.js

@@ -0,0 +1,45 @@
+import { useCallback as e, useEffect as t, useId as n, useState as r } from "react";
+//#region src/hooks/useDisclosure/useDisclosure.ts
+var i = ({ onClose: i, onOpen: a, open: o, defaultOpen: s, id: c, delay: l = 0, stopEventPropagation: u = !0 } = {}) => {
+	let [d, f] = r(o ?? s ?? !1), [p, m] = r(!1), [h, g] = r(), [_, v] = r(void 0), y = n(), b = c ?? `disclosure-${y}`, x = e(async (e, t) => {
+		if (u && (e?.stopPropagation(), e?.preventDefault()), l && !p) {
+			m(!0), g(t);
+			return;
+		}
+		p && !t && h && (t = h), await i?.(e, t, _) !== !1 && (v(void 0), o === void 0 && f(!1));
+	}, [
+		u,
+		l,
+		p,
+		h,
+		i,
+		_,
+		o
+	]), S = e((e, t) => {
+		u && (e?.stopPropagation(), e?.preventDefault()), o === void 0 && f(!0), a?.(e, t), v(t);
+	}, [
+		u,
+		o,
+		a
+	]), C = e((e) => d ? x(e) : S(e), [
+		d,
+		S,
+		x
+	]);
+	return t(() => () => {
+		d && m(!1);
+	}, [d]), [
+		b,
+		d,
+		S,
+		x,
+		C,
+		_,
+		{
+			delay: l,
+			isClosing: p
+		}
+	];
+};
+//#endregion
+export { i as default };

package/dist/hooks/useReducerWithMiddleware/index.d.ts

@@ -0,0 +1,3 @@
+import { default as useReducerWithMiddleware } from './useReducerWithMiddleware';
+export * from './useReducerWithMiddleware';
+export default useReducerWithMiddleware;

package/dist/hooks/useReducerWithMiddleware/index.js

@@ -0,0 +1,5 @@
+import e from "./useReducerWithMiddleware.js";
+//#region src/hooks/useReducerWithMiddleware/index.ts
+var t = e;
+//#endregion
+export { t as default };

package/dist/hooks/useReducerWithMiddleware/useReducerWithMiddleware.d.ts

@@ -0,0 +1,10 @@
+import { DeepEqualMetadata } from '../../utils';
+import { ActionDispatch, AnyActionArg } from 'react';
+export type ReducerMiddlewareCallback<S, A extends AnyActionArg> = (prevState: S, state: S, dispatch: ActionDispatch<A>, ...args: A) => void;
+export type ReducerFilterCallback<A extends AnyActionArg> = (...args: A) => boolean;
+declare const useReducerWithMiddleware: <S, A extends AnyActionArg>(reducer: (prevState: S, ...args: A) => S, initialState: S, middlewares?: {
+    middleware?: ReducerMiddlewareCallback<S, A>;
+    typeFilter?: string[];
+    filterCallback?: ReducerFilterCallback<A>;
+}[], middlewaresDeepEqualMode?: "soft" | "hard", middlewaresDeepEqualMetadata?: DeepEqualMetadata) => [S, ActionDispatch<A>];
+export default useReducerWithMiddleware;

package/dist/hooks/useReducerWithMiddleware/useReducerWithMiddleware.js

@@ -0,0 +1,21 @@
+import { cloneDeep as e } from "../../helpers/lodash/cloneDeep.js";
+import t from "../useValueMemo/index.js";
+import { useCallback as n, useReducer as r, useRef as i } from "react";
+//#region src/hooks/useReducerWithMiddleware/useReducerWithMiddleware.ts
+var a = (a, o, s = [], c, l = { skipFunctions: !0 }) => {
+	let [u, d] = r(a, o), f = t(s, c, l), p = i(u);
+	p.current = u;
+	let m = n((...t) => {
+		if (f.length > 0) {
+			let n = a(p.current, ...e(t));
+			f.forEach(({ middleware: e, typeFilter: r = [], filterCallback: i }) => {
+				let a = !i || typeof i == "function" && i(...t);
+				e && a && (!Array.isArray(r) || r.length === 0 || r.includes(t[0].type)) && e(p.current, n, m, ...t);
+			});
+		}
+		d(...t);
+	}, [a, f]);
+	return [u, m];
+};
+//#endregion
+export { a as default };

package/dist/hooks/useReducerWithMiddleware/useReducerWithMiddleware.test.d.ts

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

package/dist/hooks/useStateDebounce/index.d.ts

@@ -0,0 +1,3 @@
+import { default as useStateDebounce } from './useStateDebounce';
+export * from './useStateDebounce';
+export default useStateDebounce;

package/dist/hooks/useStateDebounce/index.js

@@ -0,0 +1,5 @@
+import e from "./useStateDebounce.js";
+//#region src/hooks/useStateDebounce/index.ts
+var t = e;
+//#endregion
+export { t as default };

package/dist/hooks/useStateDebounce/useStateDebounce.d.ts

@@ -0,0 +1,3 @@
+import { Dispatch, SetStateAction } from 'react';
+declare const useStateDebounce: <T = unknown>(initialState: T, callback?: (state: T) => void, timeout?: number) => [T, Dispatch<SetStateAction<T>>];
+export default useStateDebounce;

package/dist/hooks/useStateDebounce/useStateDebounce.js

@@ -0,0 +1,18 @@
+import { debounce as e } from "../../helpers/lodash/debounce.js";
+import { isFunction as t } from "../../helpers/utils.js";
+import { useCallback as n, useMemo as r, useRef as i, useState as a } from "react";
+//#region src/hooks/useStateDebounce/useStateDebounce.ts
+var o = (o, s, c = 250) => {
+	let [l, u] = a(o), d = i(o);
+	d.current !== o && (u(o), d.current = o);
+	let f = r(() => s ? e(s, c) : void 0, [s, c]);
+	return [l, n((e) => {
+		if (t(e)) {
+			u((t) => (f && f(e(t)), e(t)));
+			return;
+		}
+		u(e), f && f(e);
+	}, [u, f])];
+};
+//#endregion
+export { o as default };

package/dist/hooks/useStateMemo/index.d.ts

@@ -0,0 +1,3 @@
+import { default as useStateMemo } from './useStateMemo';
+export * from './useStateMemo';
+export default useStateMemo;

package/dist/hooks/useStateMemo/index.js

@@ -0,0 +1,5 @@
+import e from "./useStateMemo.js";
+//#region src/hooks/useStateMemo/index.ts
+var t = e;
+//#endregion
+export { t as default };

package/dist/hooks/useStateMemo/useStateMemo.d.ts

@@ -0,0 +1,3 @@
+import { DependencyList, Dispatch, SetStateAction } from 'react';
+declare const useStateMemo: <T>(initialState: T | (() => T), deps?: DependencyList, mode?: "soft" | "hard") => [T, Dispatch<SetStateAction<T>>];
+export default useStateMemo;

package/dist/hooks/useStateMemo/useStateMemo.js

@@ -0,0 +1,12 @@
+import e from "../../utils/deepEqual/index.js";
+import { isFunction as t } from "../../helpers/utils.js";
+import { useCallback as n, useRef as r, useState as i } from "react";
+//#region src/hooks/useStateMemo/useStateMemo.ts
+var a = (a, o = [], s = "soft") => {
+	let [, c] = i(0), l = r(t(a) ? a() : a), u = r(o), d = n((e) => {
+		t(e) && (e = e(l.current)), l.current !== e && (l.current = e, c(Math.random()));
+	}, []);
+	return e(o, u.current, s) || (u.current = o, l.current = t(a) ? a() : a), [l.current, d];
+};
+//#endregion
+export { a as default };

package/dist/hooks/useStorage/index.d.ts

@@ -0,0 +1,3 @@
+import { default as useStorage } from './useStorage';
+export * from './useStorage';
+export default useStorage;

package/dist/hooks/useStorage/index.js

@@ -0,0 +1,5 @@
+import e from "./useStorage.js";
+//#region src/hooks/useStorage/index.ts
+var t = e;
+//#endregion
+export { t as default };

package/dist/hooks/useStorage/useStorage.d.ts

@@ -0,0 +1,2 @@
+declare function useLocalStorage<T = unknown>(keyProp: string, initialValue: T, mode?: 'localStorage' | 'sessionStorage', autoSync?: boolean): readonly [T, import('react').Dispatch<import('react').SetStateAction<T>>];
+export default useLocalStorage;

package/dist/hooks/useStorage/useStorage.js

@@ -0,0 +1,84 @@
+import { get as e } from "../../helpers/lodash/get.js";
+import { set as t } from "../../helpers/lodash/set.js";
+import n from "../useDidUpdateEffect/index.js";
+import { storageProxy as r } from "./useStorageHelper.js";
+import { useCallback as i, useEffect as a, useMemo as o, useRef as s, useState as c } from "react";
+import { produce as l } from "immer";
+//#region src/hooks/useStorage/useStorage.ts
+function u(u, d, f = "localStorage", p = !0) {
+	let [m, h] = o(() => {
+		if (u.includes(".")) {
+			let e = u.split(".").filter(Boolean);
+			return [e.shift(), e.join(".")];
+		}
+		return [u, ""];
+	}, [u]), g = s(f === "localStorage" ? typeof localStorage < "u" ? r(localStorage) : void 0 : typeof sessionStorage < "u" ? r(sessionStorage) : void 0);
+	n(() => {
+		if (f === "localStorage" && typeof localStorage > "u" || f === "sessionStorage" && typeof sessionStorage > "u") {
+			g.current = void 0;
+			return;
+		}
+		g.current = r(f === "localStorage" ? localStorage : sessionStorage);
+	}, [f]);
+	let [_, v] = c(() => {
+		try {
+			if (!g.current) return d;
+			let t = g.current.getItem(m);
+			if (!t) return d;
+			let n = JSON.parse(t);
+			return h ? e(n, h, d) : n;
+		} catch {
+			return d;
+		}
+	});
+	a(() => {
+		try {
+			if (!g.current) return;
+			let e = _;
+			if (h) {
+				let n = g.current.getItem(m);
+				e = l(n ? JSON.parse(n) : {}, (e) => {
+					t(e, h, _);
+				});
+			}
+			g.current.setItem(m, JSON.stringify(e));
+		} catch (e) {
+			console.log(e.message);
+		}
+	}, [
+		m,
+		h,
+		_
+	]);
+	let y = i((t) => {
+		if (t.key === m) try {
+			let n = t.newValue ? JSON.parse(t.newValue) : d;
+			v(h ? e(n, h, d) : n);
+		} catch {}
+	}, [
+		m,
+		h,
+		d
+	]), b = i((t) => {
+		if (t.detail.key === m) try {
+			let n = t.detail.newValue ? JSON.parse(t.detail.newValue) : d;
+			v(h ? e(n, h, d) : n);
+		} catch {}
+	}, [
+		m,
+		h,
+		d
+	]);
+	return a(() => {
+		if (!(typeof window > "u" || !p)) return window.addEventListener("storage", y), window.addEventListener("customstorage-changed", b), () => {
+			window.removeEventListener("storage", y), window.removeEventListener("customstorage-changed", b);
+		};
+	}, [
+		y,
+		b,
+		f,
+		p
+	]), [_, v];
+}
+//#endregion
+export { u as default };

package/dist/hooks/useStorage/useStorage.test.d.ts

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

package/dist/hooks/useStorage/useStorageHelper.d.ts

@@ -0,0 +1 @@
+export declare const storageProxy: (storage: Storage) => Storage;

package/dist/hooks/useStorage/useStorageHelper.js

@@ -0,0 +1,27 @@
+//#region src/hooks/useStorage/useStorageHelper.ts
+var e = (e, t, n) => {
+	process.env.NODE_ENV === "test" ? queueMicrotask(() => {
+		window.dispatchEvent(new CustomEvent("customstorage-changed", { detail: {
+			key: e,
+			oldValue: t,
+			newValue: n
+		} }));
+	}) : window.dispatchEvent(new CustomEvent("customstorage-changed", { detail: {
+		key: e,
+		oldValue: t,
+		newValue: n
+	} }));
+}, t = (t) => new Proxy(t, { get(t, n, r) {
+	if (n === "setItem") return (n, r) => {
+		let i = t.getItem(n);
+		t.setItem.call(t, n, r), i !== r && e(n, i, r);
+	};
+	if (n === "removeItem") return (n) => {
+		let r = t.getItem(n);
+		t.removeItem.call(t, n), r !== null && e(n, r, null);
+	};
+	let i = Reflect.get(t, n, r);
+	return typeof i == "function" ? i.bind(t) : i;
+} });
+//#endregion
+export { t as storageProxy };

package/dist/hooks/useTheme/index.d.ts

@@ -0,0 +1,3 @@
+import { default as useTheme } from './useTheme';
+export * from './useTheme';
+export default useTheme;

package/dist/hooks/useTheme/index.js

@@ -0,0 +1,5 @@
+import e from "./useTheme.js";
+//#region src/hooks/useTheme/index.ts
+var t = e;
+//#endregion
+export { t as default };

package/dist/hooks/useTheme/useTheme.d.ts

@@ -0,0 +1,28 @@
+type ThemeSlot = Record<string, object>;
+type ThemeClassName<T> = {
+    [K in keyof T]?: string;
+} | string;
+type VariantKeys = {
+    [key: string]: readonly (string | number | boolean)[];
+};
+type ThemeVariantKey<T extends VariantKeys> = {
+    [K in keyof T]?: T[K][number];
+};
+export type useThemeSharedProps<T extends ThemeSlot, K extends VariantKeys> = {
+    className?: ThemeClassName<{
+        [K in keyof T]?: string;
+    }>;
+} & ThemeVariantKey<K>;
+type BaseUseThemeProps<T extends ThemeSlot, K extends VariantKeys> = {
+    className?: ThemeClassName<T>;
+    variants?: ThemeVariantKey<K>;
+};
+declare function useTheme<T extends ThemeSlot, K extends VariantKeys>(componentName: string | string[], props: {
+    componentKey: keyof T;
+} & BaseUseThemeProps<T, K>): string;
+declare function useTheme<T extends ThemeSlot, K extends VariantKeys>(componentName: string | string[], props: {
+    componentKey?: (keyof T)[];
+} & BaseUseThemeProps<T, K>): {
+    [K in [keyof T][number]]: string;
+};
+export default useTheme;