@plitzi/nexus 0.31.2 → 0.32.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @plitzi/nexus
 
+## 0.32.0
+
+### Minor Changes
+
+- v0.32.0
+
 ## 0.31.2
 
 ### Patch Changes

package/dist/async/createAsync.mjs

@@ -11,7 +11,14 @@ function t(t, n, r, i = {}) {
 	}, d = l.get, f = (...e) => {
 		a = "pending", o = void 0;
 		let i = Promise.resolve().then(() => r(...e));
-		return s = i, c = i.then(() => void 0, () => void 0), u(), i.then((e) => (i === s && (s = void 0, c = void 0, a = "success", t.setState(n, e), u()), e), (e) => {
+		return s = i, c = i.then(() => void 0, () => void 0), u(), i.then((e) => {
+			if (i === s) {
+				s = void 0, c = void 0, a = "success";
+				let r = t.getPath(n);
+				t.setState(n, e), Object.is(r, e) && u();
+			}
+			return e;
+		}, (e) => {
 			throw i === s && (s = void 0, c = void 0, a = "error", o = e, u()), e;
 		});
 	}, p = t.subscribePath(n, u);

package/dist/createStore/createStore.d.ts

@@ -1,4 +1,4 @@
-import { GetState, GetterTuple, GetValueFn, GetValueFromBaseFn, GetValueFromBaseWithDefaultFn, MultiPathReturn, PathOf, PathOrFn, PathOrFnSetters, PathOrFnValue, PathOrFnValues, PathSetters, PathSetter, PathValue, PathValues, SetFromBaseFn, SetState, SetStateFn, StoreApi, StoreMiddleware, UseStoreGetterOptions, UseStoreMultiOptions, UseStoreOptions, UseStoreSetterOptions, UseStoreSyncMultiOptions, UseStoreSyncOptions } from '../types';
+import { GetState, GetterTuple, GetValueFn, GetValueFromBaseFn, MultiPathReturn, PathOf, PathOrFn, PathOrFnSetters, PathOrFnValues, PathSetters, PathSetter, PathValue, PathValues, SetFromBaseFn, SetState, SetStateFn, StoreApi, StoreMiddleware, UseStoreGetterOptions, UseStoreMultiOptions, UseStoreOptions, UseStoreSetterOptions, UseStoreSyncMultiOptions, UseStoreSyncOptions } from '../types';
 export type CreateStoreOptions<TState extends object> = {
     id?: string;
     parent?: StoreApi<TState>;
@@ -12,64 +12,26 @@ declare function createStore<TState extends object>(initializer: Partial<TState>
 export declare const createStoreHook: <TState extends object>() => {
     useStore: {
         (options?: UseStoreOptions<TState, TState>): [TState, StoreApi<TState>["setState"]];
-        <P extends PathOf<TState>>(path: P, options: Omit<UseStoreOptions<PathValue<TState, P>, TState>, "defaultValue"> & {
-            defaultValue: undefined;
-            transformer?: never;
-        }): [PathValue<TState, P> | undefined, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
         <P extends PathOf<TState>>(path: P, options?: UseStoreOptions<PathValue<TState, P>, TState> & {
-            defaultValue?: never;
             transformer?: never;
         }): [PathValue<TState, P>, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
-        <P extends PathOf<TState>, D>(path: P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
-            defaultValue: D;
-            transformer?: never;
-        }): [NonNullable<PathValue<TState, P>> | D, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
         <P extends PathOf<TState>, TResult>(path: P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
             transformer: (value: PathValue<TState, P>) => TResult;
         }): [TResult, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
-        <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>];
         <P extends PathOf<TState>>(pathFn: (state: TState) => P, options?: UseStoreOptions<PathValue<TState, P>, TState> & {
-            defaultValue?: never;
             transformer?: never;
         }): [PathValue<TState, P>, PathSetter<TState, P>];
-        <P extends PathOf<TState>, D_1>(pathFn: (state: TState) => P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
-            defaultValue: D_1;
-            transformer?: never;
-        }): [NonNullable<PathValue<TState, P>> | D_1, PathSetter<TState, P>];
         <P extends PathOf<TState>, TResult_1>(pathFn: (state: TState) => P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
             transformer: (value: PathValue<TState, P>) => TResult_1;
         }): [TResult_1, PathSetter<TState, P>];
-        <const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, options?: Omit<UseStoreMultiOptions<TState, Paths>, "defaultValue" | "transformer">): MultiPathReturn<TState, Paths>;
-        <const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, options: UseStoreMultiOptions<TState, Paths> & {
-            defaultValue: undefined;
-            transformer?: never;
-        }): MultiPathReturn<TState, Paths, undefined>;
-        <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>;
-        <const Paths extends ReadonlyArray<PathOf<TState>>, TDefaultValue_1 extends PathValue<TState, Paths[number]>>(paths: Paths, options: UseStoreMultiOptions<TState, Paths, TDefaultValue_1> & {
-            defaultValue: TDefaultValue_1;
-            transformer?: never;
-        }): MultiPathReturn<TState, Paths, TDefaultValue_1>;
+        <const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, options?: Omit<UseStoreMultiOptions<TState, Paths>, "transformer">): MultiPathReturn<TState, Paths>;
         <const Paths extends ReadonlyArray<PathOf<TState>>, TResult_2>(paths: Paths, options: UseStoreMultiOptions<TState, Paths> & {
             transformer: (values: PathValues<TState, Paths>) => TResult_2;
         }): [TResult_2, ...PathSetters<TState, Paths>];
-        <const Entries extends ReadonlyArray<PathOrFn<TState>>>(paths: Entries, options?: Omit<UseStoreMultiOptions<TState, any>, "defaultValue" | "transformer"> & {
+        <const Entries extends ReadonlyArray<PathOrFn<TState>>>(paths: Entries, options?: Omit<UseStoreMultiOptions<TState, any>, "transformer"> & {
             transformer?: never;
         }): [PathOrFnValues<TState, Entries>, ...PathOrFnSetters<TState, Entries>];
-        <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>];
-        <const Entries extends ReadonlyArray<PathOrFn<TState>>, const TDefaultValue_2 extends readonly unknown[]>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, "defaultValue" | "transformer"> & {
-            defaultValue: TDefaultValue_2;
-            transformer?: never;
-        }): [{ [I in keyof Entries]: I extends keyof TDefaultValue_2 ? TDefaultValue_2[I] extends undefined ? PathOrFnValue<TState, Entries[I]> | undefined : NonNullable<PathOrFnValue<TState, Entries[I]>> | TDefaultValue_2[I] : PathOrFnValue<TState, Entries[I]>; }, ...PathOrFnSetters<TState, Entries>];
-        <const Entries extends ReadonlyArray<PathOrFn<TState>>, TResult_3>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, "defaultValue" | "transformer"> & {
+        <const Entries extends ReadonlyArray<PathOrFn<TState>>, TResult_3>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, "transformer"> & {
             transformer: (values: PathOrFnValues<TState, Entries>) => TResult_3;
         }): [TResult_3, ...PathOrFnSetters<TState, Entries>];
     };
@@ -82,9 +44,6 @@ export declare const createStoreHook: <TState extends object>() => {
     useStoreGetter: {
         (options?: UseStoreGetterOptions<TState>): GetValueFn<TState>;
         <P extends PathOf<TState>>(basePath: P, options?: UseStoreGetterOptions<TState>): GetValueFromBaseFn<PathValue<TState, P>>;
-        <P extends PathOf<TState>, D_2>(basePath: P, options: UseStoreGetterOptions<TState, D_2> & {
-            defaultValue: D_2;
-        }): GetValueFromBaseWithDefaultFn<PathValue<TState, P>, D_2>;
         <const Entries extends ReadonlyArray<PathOf<TState> | ((state: TState) => unknown)>>(entries: Entries, options?: UseStoreGetterOptions<TState>): GetterTuple<TState, Entries>;
     };
     useStoreSetter: {

package/dist/createStore/createStore.mjs

@@ -12,7 +12,7 @@ import c from "./hooks/useStoreSync.mjs";
 var l = 0;
 function u(a, o) {
 	let s = {}, c, u = new r(), d = new r(), f = new i(), p = new r(), m = () => {
-		p.forEach((e) => e());
+		p.length !== 0 && p.forEach((e) => e());
 	}, h = [], g = [], _ = [], v = o?.parent;
 	++l;
 	let y = (e, t, n) => {
@@ -23,9 +23,11 @@ function u(a, o) {
 			path: n
 		};
 		for (let e = 0, t = g.length; e < t; e++) g[e](r);
-	}, b = () => s, x = () => c ??= { ...s }, { getState: S, getPath: C, invalidate: w, setActive: T, getMergeCount: E } = e(b, x, v);
-	v && T(!1);
-	let { setState: D, batch: O } = t({
+	}, b = () => s, x = () => c ??= { ...s }, { getState: S, getPath: C, invalidate: w, resetCache: T, getMergeCount: E } = e(b, x, v), D = () => {
+		w(), m();
+	}, O, k, A = !1;
+	v && (T(), k = v.subscribeInvalidate?.(D));
+	let { setState: j, batch: M } = t({
 		getOwnState: b,
 		getOwnSnapshot: x,
 		setOwnState: (e) => {
@@ -42,35 +44,46 @@ function u(a, o) {
 		reportError: y,
 		invalidateDescendants: m,
 		onDelegateToParent: void 0
-	}), k = () => {
-		w(), m();
-	}, A, j, M = !1, N = () => u.length > 0 || f.size > 0 || d.length > 0, P = () => {
-		A || !v || (w(), T(!0), A = n(v, u, f, d, S, y, w), j = v.subscribeInvalidate?.(k), d.length > 0 && A.seedBaseline());
+	}), N = () => u.length > 0 || f.size > 0 || d.length > 0, P = () => {
+		O || !v || (w(), T(), O = n(v, u, f, d, S, y, w), d.length > 0 && O.seedBaseline());
 	}, F = () => {
-		A && (A.unsubscribe(), A = void 0, j?.(), j = void 0, T(!1));
+		O && (O.unsubscribe(), O = void 0, T());
 	}, I = () => {
-		v && (!M && N() ? P() : F());
+		v && (!A && N() ? P() : F());
 	}, L = (e) => (I(), () => {
 		e(), I();
 	}), R = (e) => L(u.add(e)), z = (e, t) => L(f.add(e, t)), B = (e) => {
 		let t = L(d.add(e));
-		return A?.seedBaseline(), t;
+		return O?.seedBaseline(), t;
 	};
-	s = typeof a == "function" ? a(D, S) : a;
+	s = typeof a == "function" ? a(j, S) : a;
 	let V = {
 		id: o?.id,
 		getState: S,
 		getPath: C,
-		setState: D,
-		batch: O,
+		setState: j,
+		withBase: (e) => ({
+			getState: (t) => {
+				let n = C(e);
+				return n === void 0 && t !== void 0 ? t : n;
+			},
+			getPath: (t, n) => {
+				let r = C(`${e}.${t}`);
+				return r === void 0 && n !== void 0 ? n : r;
+			},
+			setState: (t, n) => j(t === void 0 ? e : `${e}.${t}`, n),
+			subscribe: (t) => z(e, t),
+			subscribePath: (t, n) => z(`${e}.${t}`, n)
+		}),
+		batch: M,
 		subscribe: R,
 		subscribePath: z,
 		subscribeChange: B,
 		destroy: () => {
-			M = !0, F(), u.clear(), f.clear(), d.clear(), p.clear();
+			A = !0, F(), u.clear(), f.clear(), d.clear(), p.clear(), k?.();
 		},
 		reconnect: () => {
-			M = !1, I();
+			A = !1, v && (k?.(), k = v.subscribeInvalidate?.(D)), I();
 		},
 		subscribeInvalidate: (e) => p.add(e),
 		hydrate: () => {

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

@@ -3,9 +3,11 @@ import { Listener, Path } from '../../types';
 declare class PathTrie {
     readonly direct: Map<string, Subscribers<Listener>>;
     private readonly descendants;
+    private readonly root;
     size: number;
     add(path: string, listener: Listener): () => void;
     private remove;
+    walkAncestors(segments: readonly string[], cb: (subs: Subscribers<Listener>) => void): void;
     getDescendants(path: string): Set<string> | undefined;
     forEachAffected(changedPath: Path | undefined, cb: (listener: Listener) => void, onError?: (error: unknown) => void): void;
     clear(): void;

package/dist/createStore/helpers/PathTrie.mjs

@@ -1,42 +1,77 @@
 import e from "../../helpers/parsePath.mjs";
 import t from "./Subscribers.mjs";
 //#region src/createStore/helpers/PathTrie.ts
-var n = (e, t, n) => {
-	let r = "";
-	for (let i = 0; i < t; i++) r = r ? `${r}.${e[i]}` : e[i], n(r);
+var n = class {
+	subscribers = null;
+	children = null;
 }, r = class {
 	direct = /* @__PURE__ */ new Map();
 	descendants = /* @__PURE__ */ new Map();
+	root = new n();
 	size = 0;
 	add(r, i) {
-		let a = this.direct.get(r), o = e(r);
-		return a || (a = new t(), this.direct.set(r, a), this.size++, n(o, o.length - 1, (e) => {
-			let t = this.descendants.get(e);
-			t || (t = /* @__PURE__ */ new Set(), this.descendants.set(e, t)), t.add(r);
-		})), a.add(i), () => this.remove(r, a, i, o);
+		let a = e(r), o = this.direct.get(r);
+		if (!o) {
+			o = new t(), this.direct.set(r, o);
+			let e = this.root;
+			for (let t of a) {
+				e.children ||= /* @__PURE__ */ new Map();
+				let r = e.children.get(t);
+				r || (r = new n(), e.children.set(t, r)), e = r;
+			}
+			e.subscribers = o, this.size++;
+			let i = "";
+			for (let e = 0; e < a.length - 1; e++) {
+				i = i ? `${i}.${a[e]}` : a[e];
+				let t = this.descendants.get(i);
+				t || (t = /* @__PURE__ */ new Set(), this.descendants.set(i, t)), t.add(r);
+			}
+		}
+		return o.add(i), () => this.remove(r, o, i, a);
 	}
-	remove(e, t, r, i) {
-		this.direct.get(e) === t && (t.remove(r), !(t.length > 0) && (this.direct.delete(e), this.size--, n(i, i.length - 1, (t) => {
-			let n = this.descendants.get(t);
-			n && (n.delete(e), n.size === 0 && this.descendants.delete(t));
-		})));
+	remove(e, t, n, r) {
+		if (this.direct.get(e) !== t || (t.remove(n), t.length > 0)) return;
+		this.direct.delete(e), this.size--;
+		let i = this.root;
+		for (let e of r) {
+			if (!i.children) return;
+			let t = i.children.get(e);
+			if (!t) return;
+			i = t;
+		}
+		i.subscribers === t && (i.subscribers = null);
+		let a = "";
+		for (let t = 0; t < r.length - 1; t++) {
+			a = a ? `${a}.${r[t]}` : r[t];
+			let n = this.descendants.get(a);
+			n && (n.delete(e), n.size === 0 && this.descendants.delete(a));
+		}
+	}
+	walkAncestors(e, t) {
+		let n = this.root;
+		for (let r of e) {
+			if (!n.children) return;
+			let e = n.children.get(r);
+			if (!e) return;
+			n = e, n.subscribers && t(n.subscribers);
+		}
 	}
 	getDescendants(e) {
 		return this.descendants.get(e);
 	}
-	forEachAffected(t, r, i) {
-		let a = (e) => {
-			e && e.forEach(r, i);
+	forEachAffected(t, n, r) {
+		let i = (e) => {
+			e && e.forEach(n, r);
 		};
 		if (typeof t != "string") {
-			this.direct.forEach(a);
+			this.direct.forEach(i);
 			return;
 		}
-		let o = e(t);
-		n(o, o.length, (e) => a(this.direct.get(e))), this.descendants.get(t)?.forEach((e) => a(this.direct.get(e)));
+		let a = e(t);
+		this.walkAncestors(a, i), this.descendants.get(t)?.forEach((e) => i(this.direct.get(e)));
 	}
 	clear() {
-		this.direct.clear(), this.descendants.clear(), this.size = 0;
+		this.direct.clear(), this.descendants.clear(), this.root.children = null, this.root.subscribers = null, this.size = 0;
 	}
 };
 //#endregion

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

@@ -4,7 +4,7 @@ export type ChainReads<TState extends object> = {
     getState: GetState<TState>;
     getPath: GetPath<TState>;
     invalidate: () => void;
-    setActive: (active: boolean) => void;
+    resetCache: () => void;
     getMergeCount: () => number;
 };
 export declare function createChainReads<TState extends object>(getOwnState: () => TState, getOwnSnapshot: () => TState, parent: StoreApi<TState> | undefined): ChainReads<TState>;

package/dist/createStore/helpers/createChainReads.mjs

@@ -6,31 +6,30 @@ function r(r, i, a) {
 		getState: i,
 		getPath: (e) => n(r(), e),
 		invalidate: () => {},
-		setActive: () => {},
+		resetCache: () => {},
 		getMergeCount: () => 0
 	};
-	let o = a, s = !0, c = !0, l = !1, u, d = 0, f = /* @__PURE__ */ new Map(), p = () => (d++, e(o.getState(), i())), m = () => s ? ((c || u === void 0) && (u = p(), c = !1), u) : p(), h = (e) => {
+	let o = a, s = !0, c = !1, l, u = 0, d = /* @__PURE__ */ new Map(), f = () => (u++, e(o.getState(), i())), p = () => ((s || l === void 0) && (l = f(), s = !1), l), m = (e) => {
 		let i = n(r(), e);
 		if (i === void 0) return o.getPath(e);
 		let a = o.getPath(e);
-		return a === void 0 || !t(i) || !t(a) ? i : n(m(), e);
+		return a === void 0 || !t(i) || !t(a) ? i : n(p(), e);
 	};
 	return {
-		getState: m,
+		getState: p,
 		getPath: (e) => {
-			if (!s) return h(e);
-			if (l) f.clear(), l = !1;
-			else if (f.has(e)) return f.get(e);
-			let t = h(e);
-			return f.set(e, t), t;
+			if (c) d.clear(), c = !1;
+			else if (d.has(e)) return d.get(e);
+			let t = m(e);
+			return d.set(e, t), t;
 		},
 		invalidate: () => {
-			c = !0, l = !0;
+			s = !0, c = !0;
 		},
-		setActive: (e) => {
-			s = e, e || (f.clear(), u = void 0, c = !0, l = !1);
+		resetCache: () => {
+			d.clear(), l = void 0, s = !0, c = !1;
 		},
-		getMergeCount: () => d
+		getMergeCount: () => u
 	};
 }
 //#endregion

package/dist/createStore/helpers/createSetState.mjs

@@ -44,12 +44,14 @@ function u(u) {
 			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();
+		if (n.length !== 0) {
+			e.begin();
+			try {
+				let e = s(n, t, n.length);
+				e !== o && b(e, "notify", t);
+			} finally {
+				e.end();
+			}
 		}
 	}, D = (e) => {
 		w++;
@@ -77,19 +79,14 @@ function u(u) {
 			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);
+		_.walkAncestors(t, (t) => E(t, e));
+	}, A = (n, r, i, a) => {
+		let o = _.getDescendants(n);
+		if (o) for (let s of o) {
+			let o = _.direct.get(s);
+			if (!o) continue;
+			let c = e(s).slice(a);
+			t(r, c) !== t(i, c) && E(o, n);
 		}
 	}, j = (e, n, r, o) => {
 		let s = e ? t(r, e) : void 0, c = e ? typeof n == "function" ? n(s) : n : void 0;
@@ -108,15 +105,9 @@ function u(u) {
 			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);
-			});
-		}
+		l !== r && (p(l), v.length > 0 && O(e, r, l), x(), o && (E(g, e), _.size > 0 && _.direct.forEach((n, i) => {
+			t(r, i) !== t(l, i) && E(n, e);
+		})));
 	};
 	return {
 		setState: (i, o, s = !0) => {
@@ -139,11 +130,11 @@ function u(u) {
 				}
 				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);
+				if (m(i, n), r !== void 0 && O(i, r, f()), s && (E(g, i), _.size > 0)) {
 					let t = _.direct.get(i);
-					t && E(t, i), A(i, e, n, i.length + 1);
-				} else x();
+					t && E(t, i), A(i, e, n, 1);
+				}
+				x();
 				return;
 			}
 			let b = e(i), w;
@@ -154,7 +145,7 @@ function u(u) {
 			} 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();
+			p(T), v.length > 0 && O(i, u, T), s && (E(g, i), _.size > 0 && (k(i, b), A(i, u, T, 0))), x();
 		},
 		batch: D
 	};

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

@@ -1,10 +1,9 @@
 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 makeSingleSnapshot<TState extends object>(store: StoreApi<TState>, pathOrFn: PathOf<TState> | ((state: TState) => PathOf<TState>) | undefined): () => 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;

package/dist/createStore/hooks/shared.mjs

@@ -7,32 +7,21 @@ var c = (e, t) => {
 	for (let n = 0; n < e.length; n++) if (!Object.is(e[n], t[n])) return !1;
 	return !0;
 };
-function l(t, n, r) {
+function l(t, n) {
 	return () => {
-		if (typeof n == "string") {
-			let e = t.getPath(n);
-			return e === void 0 ? r : e;
-		}
+		if (typeof n == "string") return t.getPath(n);
 		if (typeof n == "function") {
-			let i = t.getState(), a = e(i, n(i));
-			return a === void 0 ? r : a;
+			let r = t.getState();
+			return e(r, n(r));
 		}
 		return t.getState();
 	};
 }
 function u(t, n, r, i = {}) {
-	let { equalityFn: a = c, defaultValue: o } = i;
+	let { equalityFn: a = c } = 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);
+		let i = n.current, o = i.some((e) => typeof e == "function") ? t.getState() : void 0, s = i.map((n) => typeof n == "function" ? e(o, n(o)) : t.getPath(n)), c = r.current;
+		return c !== null && a(c, s) ? c : (r.current = s, s);
 	};
 }
 function d(e, i, o) {

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

@@ -1,72 +1,27 @@
-import { ___NoDefault, MultiPathReturn, PathOf, PathOrFn, PathOrFnSetters, PathOrFnValue, PathOrFnValues, PathSetter, PathSetters, PathValue, PathValues, StoreApi, UseStoreMultiOptions, UseStoreOptions, UseStoreReturn } from '../../types';
+import { MultiPathReturn, PathOf, PathOrFn, PathOrFnSetters, 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>>>(paths: Paths, options?: Omit<UseStoreMultiOptions<TState, Paths>, 'transformer'>): MultiPathReturn<TState, Paths>;
 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'> & {
+declare function useStore<TState extends object, const Entries extends ReadonlyArray<PathOrFn<TState>>>(paths: Entries, options?: Omit<UseStoreMultiOptions<TState, any>, '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'> & {
+declare function useStore<TState extends object, const Entries extends ReadonlyArray<PathOrFn<TState>>, TResult>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, 'transformer'> & {
     transformer: (values: PathOrFnValues<TState, Entries>) => TResult;
 }): [TResult, ...PathOrFnSetters<TState, Entries>];
 export type { PathSetters, PathValues };