@plitzi/nexus 0.31.1

package/dist/createStore/helpers/createSetState.mjs

@@ -0,0 +1,163 @@
+import e from "../../helpers/parsePath.mjs";
+import t from "../../helpers/getByPath.mjs";
+import { UNCHANGED as n, writeByPath as r } from "./writeByPath.mjs";
+import i from "../../helpers/setByPath.mjs";
+import { CANCEL as a } from "../../types/StoreTypes.mjs";
+//#region src/createStore/helpers/createSetState.ts
+var o = Symbol("no-error"), s = (e, t, n) => {
+	let r = 0, i = o;
+	for (; r < n;) try {
+		for (; r < n; r++) e[r](t);
+	} catch (e) {
+		i === o && (i = e), r++;
+	}
+	return i;
+}, c = "__proto__", l = (e, t) => {
+	let n = e;
+	for (let e = 0, r = t.length; e < r; e++) {
+		if (typeof n != "object" || !n || !Object.hasOwn(n, t[e])) return !1;
+		n = n[t[e]];
+	}
+	return !0;
+};
+function u(u) {
+	let { getOwnState: d, getOwnSnapshot: f, setOwnState: p, mutateOwnKey: m, parent: h, listeners: g, pathListeners: _, changeListeners: v, interceptors: y, reportError: b, invalidateDescendants: x, onDelegateToParent: S } = u, C = (e, t, n) => {
+		let r = t;
+		for (let t = 0, i = y.length; t < i; t++) {
+			let i;
+			try {
+				i = y[t]({
+					path: e,
+					value: r,
+					prev: n
+				});
+			} catch (t) {
+				return b(t, "beforeChange", e), a;
+			}
+			if (i === a) return a;
+			i !== void 0 && (r = i);
+		}
+		return r;
+	}, w = 0, T = /* @__PURE__ */ new Set(), E = (e, t) => {
+		let { items: n } = e;
+		if (w > 0) {
+			for (let e = 0, t = n.length; e < t; e++) T.add(n[e]);
+			return;
+		}
+		e.begin();
+		try {
+			let e = s(n, t, n.length);
+			e !== o && b(e, "notify", t);
+		} finally {
+			e.end();
+		}
+	}, D = (e) => {
+		w++;
+		try {
+			return e();
+		} finally {
+			if (w--, w === 0 && T.size > 0) {
+				let e = [...T];
+				T.clear();
+				let t = s(e, void 0, e.length);
+				t !== o && b(t, "notify", void 0);
+			}
+		}
+	}, O = (e, t, n) => {
+		let r = {
+			path: e,
+			prev: t,
+			next: n
+		}, { items: i } = v;
+		v.begin();
+		try {
+			let t = s(i, r, i.length);
+			t !== o && b(t, "onChange", e);
+		} finally {
+			v.end();
+		}
+	}, k = (e, t) => {
+		let n = "";
+		for (let r = 0; r < t.length; r++) {
+			n = n ? `${n}.${t[r]}` : t[r];
+			let i = _.direct.get(n);
+			i && E(i, e);
+		}
+	}, A = (e, n, r, i) => {
+		let a = _.getDescendants(e);
+		if (a) for (let o of a) {
+			let a = _.direct.get(o);
+			if (!a) continue;
+			let s = o.slice(i);
+			t(n, s) !== t(r, s) && E(a, e);
+		}
+	}, j = (e, n, r, o) => {
+		let s = e ? t(r, e) : void 0, c = e ? typeof n == "function" ? n(s) : n : void 0;
+		if (e && y.length > 0) {
+			let t = C(e, c, s);
+			if (t === a) return;
+			c = t;
+		}
+		if (e && s === c) return;
+		let l = e ? i(r, e, c) : typeof n == "function" ? n(r) : {
+			...r,
+			...n
+		};
+		if (!e && y.length > 0) {
+			let e = C(void 0, l, r);
+			if (e === a) return;
+			l = e;
+		}
+		if (l !== r) {
+			if (p(l), v.length > 0 && O(e, r, l), !o) {
+				x();
+				return;
+			}
+			E(g, e), _.size > 0 && _.direct.forEach((n, i) => {
+				t(r, i) !== t(l, i) && E(n, e);
+			});
+		}
+	};
+	return {
+		setState: (i, o, s = !0) => {
+			let u = d();
+			if (typeof i == "string" && i.indexOf(c) !== -1 && e(i).indexOf(c) !== -1) throw Error(`@plitzi/nexus: refused to write to unsafe path "${i}" (\`__proto__\` segment)`);
+			if (h && typeof i == "string" && !(i.indexOf(".") === -1 ? Object.hasOwn(u, i) : l(u, e(i)))) {
+				S?.(i), h.setState(i, o, s);
+				return;
+			}
+			if (typeof i != "string") {
+				j(i, o, u, s);
+				return;
+			}
+			if (i.indexOf(".") === -1) {
+				let e = u[i], t = typeof o == "function" ? o(e) : o, n = t;
+				if (y.length > 0) {
+					let r = C(i, t, e);
+					if (r === a) return;
+					n = r;
+				}
+				if (e === n) return;
+				let r = v.length > 0 ? f() : void 0;
+				if (m(i, n), r !== void 0 && O(i, r, f()), s) {
+					E(g, i);
+					let t = _.direct.get(i);
+					t && E(t, i), A(i, e, n, i.length + 1);
+				} else x();
+				return;
+			}
+			let b = e(i), w;
+			if (y.length > 0) {
+				let e = t(u, i), n = C(i, typeof o == "function" ? o(e) : o, e);
+				if (n === a) return;
+				w = r(u, i, b, n, !1);
+			} else w = r(u, i, b, o, typeof o == "function");
+			if (w === n) return;
+			let T = w;
+			p(T), v.length > 0 && O(i, u, T), s ? (E(g, i), k(i, b), A(i, u, T, 0)) : x();
+		},
+		batch: D
+	};
+}
+//#endregion
+export { u as createSetState };

package/dist/createStore/helpers/deepMerge.d.ts

@@ -0,0 +1,2 @@
+export declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
+export declare const deepMerge: (base: unknown, override: unknown) => unknown;

package/dist/createStore/helpers/deepMerge.mjs

@@ -0,0 +1,9 @@
+//#region src/createStore/helpers/deepMerge.ts
+var e = (e) => typeof e == "object" && !!e && !Array.isArray(e), t = (n, r) => {
+	if (!e(n) || !e(r)) return r;
+	let i = { ...n };
+	for (let e of Object.keys(r)) e !== "__proto__" && (i[e] = e in n ? t(n[e], r[e]) : r[e]);
+	return i;
+};
+//#endregion
+export { t as deepMerge, e as isPlainObject };

package/dist/createStore/helpers/forwardParentChanges.d.ts

@@ -0,0 +1,7 @@
+import { default as PathTrie } from './PathTrie';
+import { default as Subscribers } from './Subscribers';
+import { ChangeListener, GetState, Listener, StoreErrorReporter, StoreApi } from '../../types';
+export declare function forwardParentChanges<TState extends object>(parent: StoreApi<TState>, listeners: Subscribers<Listener>, pathListeners: PathTrie, changeListeners: Subscribers<ChangeListener<TState>>, getState: GetState<TState>, reportError: StoreErrorReporter<TState>, invalidate: () => void): {
+    unsubscribe: () => void;
+    seedBaseline: () => void;
+};

package/dist/createStore/helpers/forwardParentChanges.mjs

@@ -0,0 +1,23 @@
+//#region src/createStore/helpers/forwardParentChanges.ts
+function e(e, t, n, r, i, a, o) {
+	let s;
+	return {
+		unsubscribe: e.subscribe((e) => {
+			o();
+			let c = e;
+			if (t.forEach((t) => t(e), (e) => a(e, "notify", c)), n.size > 0 && n.forEachAffected(e, (t) => t(e), (e) => a(e, "notify", c)), r.length > 0) {
+				let e = i(), t = {
+					path: c,
+					prev: s ?? e,
+					next: e
+				};
+				s = e, r.forEach((e) => e(t), (e) => a(e, "onChange", c));
+			}
+		}),
+		seedBaseline: () => {
+			s ??= i();
+		}
+	};
+}
+//#endregion
+export { e as forwardParentChanges };

package/dist/createStore/helpers/scopeCollisions.d.ts

@@ -0,0 +1,4 @@
+export type ScopeClaims = {
+    claimDelegatedWrite: (path: string, scopeId: number) => void;
+};
+export declare const createScopeClaims: () => ScopeClaims;

package/dist/createStore/helpers/scopeCollisions.mjs

@@ -0,0 +1,14 @@
+//#region src/createStore/helpers/scopeCollisions.ts
+var e = () => {
+	let e = /* @__PURE__ */ new Map();
+	return { claimDelegatedWrite(t, n) {
+		let r = e.get(t);
+		if (r !== void 0 && r !== n) {
+			console.warn(`@plitzi/nexus: scope collision — two sibling scopes under the same parent both delegate a write to "${t}", clobbering each other through the shared parent. Write to a path each scope owns, or move the shared value into the parent and update it there.`);
+			return;
+		}
+		e.set(t, n);
+	} };
+};
+//#endregion
+export { e as createScopeClaims };

package/dist/createStore/helpers/writeByPath.d.ts

@@ -0,0 +1,11 @@
+export declare const UNCHANGED: unique symbol;
+/**
+ * Force the codegen path on/off.
+ *
+ * - `undefined` (default) — auto-detection: probes `new Function` at first use; if CSP blocks it, falls back
+ *   to the recursive writer automatically.
+ * - `false` — skip auto-detection and go directly to the recursive fallback (no `new Function`).
+ * - `true` — force codegen even if the probe fails (useful for testing).
+ */
+export declare const setCodegenEnabled: (enabled: boolean | undefined) => void;
+export declare const writeByPath: (root: unknown, path: string, segments: readonly string[], value: unknown, isFn: boolean) => Record<string, unknown> | typeof UNCHANGED;

package/dist/createStore/helpers/writeByPath.mjs

@@ -0,0 +1,51 @@
+//#region src/createStore/helpers/writeByPath.ts
+var e = Symbol("unchanged"), t = (e) => /^\d+$/.test(e), n = (e) => Array.isArray(e) ? e.slice() : { ...e }, r = (t, i, a, o, s) => {
+	let c = i[a], l = typeof t == "object" && t ? t : {};
+	if (a === i.length - 1) {
+		let t = l[c], r = s ? o(t) : o;
+		if (t === r) return e;
+		let i = n(l);
+		return i[c] = r, i;
+	}
+	let u = r(l[c], i, a + 1, o, s);
+	if (u === e) return e;
+	let d = n(l);
+	return d[c] = u, d;
+}, i = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/, a = (e) => i.test(e) ? `.${e}` : `[${JSON.stringify(e)}]`, o = (e) => i.test(e) ? e : JSON.stringify(e), s = (e) => {
+	let t = e.length, n = "";
+	for (let r = 0; r < t - 1; r++) {
+		let t = r === 0 ? "o" : `_${r - 1}`;
+		n += `var _${r}=${t}==null?void 0:${t}${a(e[r])};\n`;
+	}
+	let r = t > 1 ? `_${t - 2}` : "o";
+	n += `var _p=${r}==null?void 0:${r}${a(e[t - 1])};\n`, n += "var _v=f?v(_p):v;\nif(_p===_v)return null;\n";
+	let i = "_v";
+	for (let n = t - 1; n >= 0; n--) i = `{...${n === 0 ? "o" : `(_${n - 1}||{})`},${o(e[n])}:${i}}`;
+	return n += `return ${i};`, Function("o", "v", "f", n);
+}, c, l, u = () => {
+	if (l !== void 0) return l;
+	if (c === void 0) try {
+		s(["x", "y"])({ x: {} }, 1, !1), c = !0;
+	} catch {
+		c = !1;
+	}
+	return c;
+}, d = (e) => {
+	l = e;
+}, f = /* @__PURE__ */ new Map(), p = 256, m = (e, n) => {
+	if (!u()) return;
+	let r = f.get(e);
+	if (r) return r;
+	if (n.some(t)) return;
+	let i = s(n);
+	return f.size >= p && f.delete(f.keys().next().value), f.set(e, i), i;
+}, h = (t, n, i, a, o) => {
+	let s = m(n, i);
+	if (s) {
+		let n = s(t, a, o);
+		return n === null ? e : n;
+	}
+	return r(t, i, 0, a, o);
+};
+//#endregion
+export { e as UNCHANGED, d as setCodegenEnabled, h as writeByPath };

package/dist/createStore/hooks/shared.d.ts

@@ -0,0 +1,12 @@
+import { PathOf, PathOrFn, StoreApi, SyncMode } from '../../types';
+import { RefObject } from 'react';
+export declare const defaultMultiEqualityFn: (a: unknown[], b: unknown[]) => boolean;
+export declare function makeSingleSnapshot<TState extends object>(store: StoreApi<TState>, pathOrFn: PathOf<TState> | ((state: TState) => PathOf<TState>) | undefined, defaultValue?: unknown): () => unknown;
+export declare function makeMultiSnapshot<TState extends object>(store: StoreApi<TState>, pathsRef: RefObject<ReadonlyArray<PathOrFn<TState>>>, lastRef: RefObject<unknown[] | null>, options?: {
+    equalityFn?: (a: unknown[], b: unknown[]) => boolean;
+    defaultValue?: unknown;
+}): () => unknown[];
+export declare function useResolvedStore<TState extends object>(optionStore: StoreApi<TState> | undefined, hookName: string, storeId?: string): StoreApi<TState>;
+export declare function useMultiSubscribe<TState extends object>(store: StoreApi<TState>, pathsRef: RefObject<ReadonlyArray<PathOrFn<TState>>>, pathsKey: string, enabled: boolean, mode: SyncMode): (cb: () => void) => () => void;
+export declare function useMultiSetters<TState extends object>(store: StoreApi<TState>, pathsRef: RefObject<ReadonlyArray<PathOrFn<TState>>>, pathsKey: string): Array<(value: any) => void>;
+export declare function useMultiExternalStore(subscribe: (cb: () => void) => () => void, getSnapshot: () => unknown[], enabled: boolean, lastRef: RefObject<unknown[] | null>): unknown[];

package/dist/createStore/hooks/shared.mjs

@@ -0,0 +1,85 @@
+import e from "../../helpers/getByPath.mjs";
+import { StoreContext as t, StoreRegistryContext as n, findStoreInRegistry as r } from "../../StoreContext.mjs";
+import { useCallback as i, useContext as a, useMemo as o, useSyncExternalStore as s } from "react";
+//#region src/createStore/hooks/shared.ts
+var c = (e, t) => {
+	if (e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (!Object.is(e[n], t[n])) return !1;
+	return !0;
+};
+function l(t, n, r) {
+	return () => {
+		if (typeof n == "string") {
+			let e = t.getPath(n);
+			return e === void 0 ? r : e;
+		}
+		if (typeof n == "function") {
+			let i = t.getState(), a = e(i, n(i));
+			return a === void 0 ? r : a;
+		}
+		return t.getState();
+	};
+}
+function u(t, n, r, i = {}) {
+	let { equalityFn: a = c, defaultValue: o } = i;
+	return () => {
+		let i = n.current, s = i.some((e) => typeof e == "function") ? t.getState() : void 0, c = i.map((n, r) => {
+			let i = typeof n == "function" ? e(s, n(s)) : t.getPath(n);
+			if (i !== void 0 || o === void 0) return i;
+			if (Array.isArray(o)) {
+				let e = o[r];
+				return e === void 0 ? i : e;
+			}
+			return o;
+		}), l = r.current;
+		return l !== null && a(l, c) ? l : (r.current = c, c);
+	};
+}
+function d(e, i, o) {
+	let s = a(t), c = a(n);
+	if (e) return e;
+	if (o !== void 0) {
+		let e = r(c, o);
+		if (!e) throw Error(`${i}: no store registered with id "${o}" in any ancestor StoreProvider`);
+		return e;
+	}
+	if (!s) throw Error(`${i} must be used inside a StoreProvider`);
+	return s;
+}
+function f(e, t, n, r, i) {
+	return o(() => (n) => {
+		if (!r || i === "mount") return () => {};
+		let a = t.current;
+		if (a.some((e) => typeof e == "function")) return e.subscribe(n);
+		let o = a.map((t) => e.subscribePath(t, n));
+		return () => o.forEach((e) => e());
+	}, [
+		e,
+		n,
+		r,
+		i
+	]);
+}
+function p(e, t, n) {
+	let r = t.current.length;
+	return o(() => Array.from({ length: r }, (n, r) => (n) => {
+		let i = t.current[r], a = typeof i == "function" ? i(e.getState()) : i;
+		e.setState(a, n);
+	}), [e, n]);
+}
+function m(e, t, n, r) {
+	let a = i(() => {
+		if (!n) {
+			let e = r.current ?? t();
+			return r.current = e, e;
+		}
+		return t();
+	}, [
+		n,
+		t,
+		r
+	]);
+	return s(e, a, a);
+}
+//#endregion
+export { c as defaultMultiEqualityFn, u as makeMultiSnapshot, l as makeSingleSnapshot, m as useMultiExternalStore, p as useMultiSetters, f as useMultiSubscribe, d as useResolvedStore };

package/dist/createStore/hooks/useStore.d.ts

@@ -0,0 +1,73 @@
+import { ___NoDefault, MultiPathReturn, PathOf, PathOrFn, PathOrFnSetters, PathOrFnValue, PathOrFnValues, PathSetter, PathSetters, PathValue, PathValues, StoreApi, UseStoreMultiOptions, UseStoreOptions, UseStoreReturn } from '../../types';
+export { defaultMultiEqualityFn } from './shared';
+export type { MultiPathReturn, UseStoreOptions, UseStoreMultiOptions, UseStoreReturn };
+declare function useStore<TState extends object>(arg?: undefined, options?: UseStoreOptions<TState>): [TState, StoreApi<TState>['setState']];
+declare function useStore<TState extends object, P extends PathOf<TState>>(path: P, options: Omit<UseStoreOptions<PathValue<TState, P>>, 'defaultValue'> & {
+    defaultValue: undefined;
+    transformer?: never;
+}): [PathValue<TState, P> | undefined, PathSetter<TState, P>];
+declare function useStore<TState extends object, P extends PathOf<TState>>(path: P, options?: UseStoreOptions<PathValue<TState, P>> & {
+    defaultValue?: never;
+    transformer?: never;
+}): [PathValue<TState, P>, PathSetter<TState, P>];
+declare function useStore<TState extends object, P extends PathOf<TState>, D>(path: P, options: UseStoreOptions<PathValue<TState, P>> & {
+    defaultValue: D;
+    transformer?: never;
+}): [NonNullable<PathValue<TState, P>> | D, PathSetter<TState, P>];
+declare function useStore<TState extends object, P extends PathOf<TState>, TResult>(path: P, options: UseStoreOptions<PathValue<TState, P>> & {
+    transformer: (value: PathValue<TState, P>) => TResult;
+}): [TResult, PathSetter<TState, P>];
+declare function useStore<TState extends object, P extends PathOf<TState>>(pathFn: (state: TState) => P, options: Omit<UseStoreOptions<PathValue<TState, P>, TState>, 'defaultValue'> & {
+    defaultValue: undefined;
+    transformer?: never;
+}): [PathValue<TState, P> | undefined, PathSetter<TState, P>];
+declare function useStore<TState extends object, P extends PathOf<TState>>(pathFn: (state: TState) => P, options?: UseStoreOptions<PathValue<TState, P>, TState> & {
+    defaultValue?: never;
+    transformer?: never;
+}): [PathValue<TState, P>, PathSetter<TState, P>];
+declare function useStore<TState extends object, P extends PathOf<TState>, D>(pathFn: (state: TState) => P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
+    defaultValue: D;
+    transformer?: never;
+}): [NonNullable<PathValue<TState, P>> | D, PathSetter<TState, P>];
+declare function useStore<TState extends object, P extends PathOf<TState>, TResult>(pathFn: (state: TState) => P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
+    transformer: (value: PathValue<TState, P>) => TResult;
+}): [TResult, PathSetter<TState, P>];
+declare function useStore<TState extends object, const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, options?: Omit<UseStoreMultiOptions<TState, Paths>, 'defaultValue' | 'transformer'>): MultiPathReturn<TState, Paths, __NoDefault>;
+declare function useStore<TState extends object, const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, options: UseStoreMultiOptions<TState, Paths> & {
+    defaultValue: undefined;
+    transformer?: never;
+}): MultiPathReturn<TState, Paths, undefined>;
+declare function useStore<TState extends object, const Paths extends ReadonlyArray<PathOf<TState>>, const TDefaultValue extends readonly (PathValue<TState, Paths[number]> | undefined)[]>(paths: Paths, options: UseStoreMultiOptions<TState, Paths, TDefaultValue> & {
+    defaultValue: TDefaultValue;
+    transformer?: never;
+}): MultiPathReturn<TState, Paths, TDefaultValue>;
+declare function useStore<TState extends object, const Paths extends ReadonlyArray<PathOf<TState>>, TDefaultValue extends PathValue<TState, Paths[number]>>(paths: Paths, options: UseStoreMultiOptions<TState, Paths, TDefaultValue> & {
+    defaultValue: TDefaultValue;
+    transformer?: never;
+}): MultiPathReturn<TState, Paths, TDefaultValue>;
+declare function useStore<TState extends object, const Paths extends ReadonlyArray<PathOf<TState>>, TResult>(paths: Paths, options: UseStoreMultiOptions<TState, Paths> & {
+    transformer: (values: PathValues<TState, Paths>) => TResult;
+}): [TResult, ...PathSetters<TState, Paths>];
+declare function useStore<TState extends object, const Entries extends ReadonlyArray<PathOrFn<TState>>>(paths: Entries, options?: Omit<UseStoreMultiOptions<TState, any>, 'defaultValue' | 'transformer'> & {
+    transformer?: never;
+}): [PathOrFnValues<TState, Entries>, ...PathOrFnSetters<TState, Entries>];
+declare function useStore<TState extends object, const Entries extends ReadonlyArray<PathOrFn<TState>>>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, 'defaultValue' | 'transformer'> & {
+    defaultValue: undefined;
+    transformer?: never;
+}): [{
+    [I in keyof Entries]: PathOrFnValue<TState, Entries[I]> | undefined;
+}, ...PathOrFnSetters<TState, Entries>];
+declare function useStore<TState extends object, const Entries extends ReadonlyArray<PathOrFn<TState>>, const TDefaultValue extends readonly unknown[]>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, 'defaultValue' | 'transformer'> & {
+    defaultValue: TDefaultValue;
+    transformer?: never;
+}): [
+    {
+        [I in keyof Entries]: I extends keyof TDefaultValue ? TDefaultValue[I] extends undefined ? PathOrFnValue<TState, Entries[I]> | undefined : NonNullable<PathOrFnValue<TState, Entries[I]>> | TDefaultValue[I] : PathOrFnValue<TState, Entries[I]>;
+    },
+    ...PathOrFnSetters<TState, Entries>
+];
+declare function useStore<TState extends object, const Entries extends ReadonlyArray<PathOrFn<TState>>, TResult>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, 'defaultValue' | 'transformer'> & {
+    transformer: (values: PathOrFnValues<TState, Entries>) => TResult;
+}): [TResult, ...PathOrFnSetters<TState, Entries>];
+export type { PathSetters, PathValues };
+export default useStore;

package/dist/createStore/hooks/useStore.mjs

@@ -0,0 +1,57 @@
+import { defaultMultiEqualityFn as e, makeMultiSnapshot as t, makeSingleSnapshot as n, useMultiExternalStore as r, useMultiSetters as i, useMultiSubscribe as a, useResolvedStore as o } from "./shared.mjs";
+import s from "../../helpers/shallowEqual.mjs";
+import { useCallback as c, useMemo as l, useRef as u, useSyncExternalStore as d } from "react";
+//#region src/createStore/hooks/useStore.ts
+var f = [];
+function p(e, t, r) {
+	let i = r.mode ?? "sync", a = r.enabled ?? !0, o = r.defaultValue, f = t === void 0, p = r.equalityFn ?? (f ? s : Object.is), m = r.transformer, h = u(m);
+	h.current = m;
+	let g = l(() => n(e, t, o), [
+		e,
+		t,
+		o
+	]), _ = u(g()), v = l(() => (n) => !a || i === "mount" ? () => {} : typeof t == "string" ? e.subscribePath(t, n) : e.subscribe(n), [
+		a,
+		i,
+		t,
+		e
+	]), y = () => {
+		if (!a) return _.current;
+		if (i === "mount") return g();
+		let e = g();
+		return p(_.current, e) ? _.current : (_.current = e, e);
+	}, b = d(v, y, y);
+	return [l(() => h.current ? h.current(b) : b, [b]), c((n) => {
+		f ? e.setState(void 0, n) : typeof t == "function" ? e.setState(t(e.getState()), n) : e.setState(t, n);
+	}, [e, t])];
+}
+function m(n, o, s) {
+	let c = s.mode ?? "sync", d = s.enabled ?? !0, f = s.defaultValue, p = s.equalityFn ?? e, m = s.transformer, h = u(m);
+	h.current = m;
+	let g = u(o);
+	g.current = o;
+	let _ = o.map((e, t) => typeof e == "function" ? `fn_${t}` : e).join("|"), v = u(null), y = l(() => t(n, g, v, {
+		equalityFn: p,
+		defaultValue: f
+	}), [
+		n,
+		_,
+		p,
+		f
+	]), b = r(a(n, g, _, d, c), y, d, v);
+	return [l(() => h.current ? h.current(b) : b, [b]), ...i(n, g, _)];
+}
+function h(e, t = {}) {
+	let n = o(t.store, "useStore", t.storeId), r = Array.isArray(e), i = p(n, r ? void 0 : e, r ? {
+		...t,
+		enabled: !1,
+		transformer: void 0
+	} : t), a = m(n, r ? e : f, r ? t : {
+		...t,
+		enabled: !1,
+		transformer: void 0
+	});
+	return r ? a : i;
+}
+//#endregion
+export { h as default };

package/dist/createStore/hooks/useStoreById.d.ts

@@ -0,0 +1,3 @@
+import { StoreApi } from '../../types';
+export declare function useStoreById<TState extends object = object>(id?: string): StoreApi<TState>;
+export default useStoreById;

package/dist/createStore/hooks/useStoreById.mjs

@@ -0,0 +1,7 @@
+import { useResolvedStore as e } from "./shared.mjs";
+//#region src/createStore/hooks/useStoreById.ts
+function t(t) {
+	return e(void 0, "useStoreById", t);
+}
+//#endregion
+export { t as default };

package/dist/createStore/hooks/useStoreGetter.d.ts

@@ -0,0 +1,9 @@
+import { GetterTuple, GetValueFromBaseWithDefaultFn, GetValueFromBaseFn, GetValueFn, PathOf, PathValue, UseStoreGetterOptions } from '../../types';
+export type { GetValueFn, GetValueFromBaseFn, GetValueFromBaseWithDefaultFn, GetterTuple, UseStoreGetterOptions };
+declare function useStoreGetter<TState extends object>(options?: UseStoreGetterOptions<TState>): GetValueFn<TState>;
+declare function useStoreGetter<TState extends object, P extends PathOf<TState>>(basePath: P, options?: UseStoreGetterOptions<TState>): GetValueFromBaseFn<PathValue<TState, P>>;
+declare function useStoreGetter<TState extends object, P extends PathOf<TState>, D>(basePath: P, options: UseStoreGetterOptions<TState, D> & {
+    defaultValue: D;
+}): GetValueFromBaseWithDefaultFn<PathValue<TState, P>, D>;
+declare function useStoreGetter<TState extends object, const Entries extends ReadonlyArray<PathOf<TState> | ((state: TState) => unknown)>>(entries: Entries, options?: UseStoreGetterOptions<TState>): GetterTuple<TState, Entries>;
+export default useStoreGetter;

package/dist/createStore/hooks/useStoreGetter.mjs

@@ -0,0 +1,38 @@
+import e from "../../helpers/getByPath.mjs";
+import { useResolvedStore as t } from "./shared.mjs";
+import { useMemo as n } from "react";
+//#region src/createStore/hooks/useStoreGetter.ts
+function r(r, i) {
+	let a = typeof r == "string" ? r : void 0, o = Array.isArray(r) ? r : void 0, s = typeof r == "object" && !Array.isArray(r) ? r : i, c = t(s?.store, "useStoreGetter", s?.storeId), { defaultValue: l } = s ?? {}, u = o?.map((e) => typeof e == "function" ? e.toString() : e).join("|");
+	return n(() => o ? o.map((t) => (n, r) => {
+		let i = typeof t == "function" ? t(c.getState()) : e(c.getState(), t);
+		if (n !== void 0) {
+			let t = e(i, n);
+			return t === void 0 && r !== void 0 ? r : t;
+		}
+		return i === void 0 && r !== void 0 ? r : i;
+	}) : (t, n) => {
+		let r = c.getState();
+		if (a !== void 0) {
+			let i = e(r, a);
+			if (t !== void 0) {
+				let r = e(i, t);
+				return r === void 0 && n !== void 0 ? n : r;
+			}
+			let o = n === void 0 ? l : n;
+			return i === void 0 && o !== void 0 ? o : i;
+		}
+		if (t !== void 0) {
+			let i = e(r, t);
+			return i === void 0 && n !== void 0 ? n : i;
+		}
+		return r;
+	}, [
+		c,
+		a,
+		u,
+		l
+	]);
+}
+//#endregion
+export { r as default };

package/dist/createStore/hooks/useStoreSetter.d.ts

@@ -0,0 +1,5 @@
+import { PathOf, PathValue, SetFromBaseFn, SetStateFn, UseStoreSetterOptions } from '../../types';
+export type { SetFromBaseFn, SetStateFn, UseStoreSetterOptions };
+declare function useStoreSetter<TState extends object>(options?: UseStoreSetterOptions<TState>): SetStateFn<TState>;
+declare function useStoreSetter<TState extends object, P extends PathOf<TState>>(basePath: P, options?: UseStoreSetterOptions<TState>): SetFromBaseFn<PathValue<TState, P>>;
+export default useStoreSetter;

package/dist/createStore/hooks/useStoreSetter.mjs

@@ -0,0 +1,11 @@
+import { useResolvedStore as e } from "./shared.mjs";
+import { useCallback as t } from "react";
+//#region src/createStore/hooks/useStoreSetter.ts
+function n(n, r) {
+	let i = typeof n == "string" ? n : void 0, a = typeof n == "object" ? n : r, o = e(a?.store, "useStoreSetter", a?.storeId);
+	return t((e, t) => {
+		i === void 0 ? o.setState(e, t) : e === void 0 ? o.setState(i, t) : o.setState(`${i}.${e}`, t);
+	}, [o, i]);
+}
+//#endregion
+export { n as default };

package/dist/createStore/hooks/useStoreSync.d.ts

@@ -0,0 +1,7 @@
+import { PathOf, PathOrFn, PathValue, PathValues, UseStoreSyncMultiOptions, UseStoreSyncOptions } from '../../types';
+export type { UseStoreSyncOptions, UseStoreSyncMultiOptions };
+declare function useStoreSync<TState extends object>(path: undefined, value: TState | Partial<TState>, options?: UseStoreSyncOptions<TState, TState>): void;
+declare function useStoreSync<TState extends object, P extends PathOf<TState>>(path: P | ((state: TState) => P), value: PathValue<TState, P>, options?: UseStoreSyncOptions<PathValue<TState, P>, TState>): void;
+declare function useStoreSync<TState extends object, const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, values: PathValues<TState, Paths>, options?: UseStoreSyncMultiOptions<TState>): void;
+declare function useStoreSync<TState extends object>(paths: ReadonlyArray<PathOrFn<TState>>, values: readonly unknown[], options?: UseStoreSyncMultiOptions<TState>): void;
+export default useStoreSync;