@plitzi/nexus 0.31.2 → 0.32.1

package/dist/middleware/historyMiddleware.mjs

@@ -1,26 +1,27 @@
-import { isPlainObject as e } from "../createStore/helpers/deepMerge.mjs";
-import t from "../helpers/getByPath.mjs";
-import n from "../helpers/isPathAffected.mjs";
+import e from "../helpers/getByPath.mjs";
+import { isDisabled as t } from "./isDisabled.mjs";
+import { isPlainObject as n } from "../createStore/helpers/deepMerge.mjs";
+import r from "../helpers/isPathAffected.mjs";
 //#region src/middleware/historyMiddleware.ts
-var r = (t, n, i = 12) => {
-	if (!Object.is(t, n)) {
-		if (i <= 0 || !e(t) || !e(n)) return {
+var i = (e, t, r = 12) => {
+	if (!Object.is(e, t)) {
+		if (r <= 0 || !n(e) || !n(t)) return {
 			path: "",
-			value: n
+			value: t
 		};
-		for (let e of new Set([...Object.keys(t), ...Object.keys(n)])) {
-			if (Object.is(t[e], n[e])) continue;
-			let a = r(t[e], n[e], i - 1);
+		for (let n of new Set([...Object.keys(e), ...Object.keys(t)])) {
+			if (Object.is(e[n], t[n])) continue;
+			let a = i(e[n], t[n], r - 1);
 			if (a) return {
-				path: a.path ? `${e}.${a.path}` : e,
+				path: a.path ? `${n}.${a.path}` : n,
 				value: a.value
 			};
 		}
 	}
 };
-function i(e, i = {}) {
-	let a = i.limit ?? 100, o = i.path, s = i.shouldRecord, c = [{
-		state: e.getState(),
+function a(t, n = {}) {
+	let a = n.limit ?? 100, o = n.path, s = n.shouldRecord, c = [{
+		state: t.getState(),
 		timestamp: Date.now()
 	}], l = 0, u = !1, d = () => ({
 		entries: c,
@@ -29,12 +30,12 @@ function i(e, i = {}) {
 		canRedo: l < c.length - 1
 	}), f = d(), p = /* @__PURE__ */ new Set(), m = () => {
 		f = d(), p.forEach((e) => e());
-	}, h = ({ path: i }) => {
-		if (u || s && !s(i) || o && i !== void 0 && !n(i, o)) return;
-		let d = l < c.length - 1 ? c.slice(0, l + 1) : c, f = d[d.length - 1].state, p = e.getState(), h = i ?? o, g, _ = i ?? o;
+	}, h = ({ path: n }) => {
+		if (u || s && !s(n) || o && n !== void 0 && !r(n, o)) return;
+		let d = l < c.length - 1 ? c.slice(0, l + 1) : c, f = d[d.length - 1].state, p = t.getState(), h = n ?? o, g, _ = n ?? o;
 		if (_) try {
-			let e = r(t(f, _), t(p, _));
-			e && (h = e.path ? `${_}.${e.path}` : _, g = e.value);
+			let t = i(e(f, _), e(p, _));
+			t && (h = t.path ? `${_}.${t.path}` : _, g = t.value);
 		} catch {}
 		let v = [...d, {
 			path: h,
@@ -47,9 +48,9 @@ function i(e, i = {}) {
 		if (n < 0 || n >= c.length || n === l) return;
 		let r = c[n].state;
 		if (u = !0, o) {
-			let n = t(r, o);
-			e.setState(o, () => n);
-		} else e.setState(void 0, () => r);
+			let n = e(r, o);
+			t.setState(o, () => n);
+		} else t.setState(void 0, () => r);
 		u = !1, l = n, m();
 	};
 	return {
@@ -61,7 +62,7 @@ function i(e, i = {}) {
 			travelTo: g,
 			clear: () => {
 				c = [{
-					state: e.getState(),
+					state: t.getState(),
 					timestamp: Date.now()
 				}], l = 0, m();
 			}
@@ -69,13 +70,17 @@ function i(e, i = {}) {
 		record: h
 	};
 }
-var a = /* @__PURE__ */ new WeakMap();
-function o(e) {
-	return a.get(e);
+var o = /* @__PURE__ */ new WeakMap();
+function s(e) {
+	return o.get(e);
 }
-var s = (e) => (t) => {
-	let { handle: n, record: r } = i(t, e);
-	return a.set(t, n), { onChange: r };
+var c = (e) => {
+	let n = e?.enabled;
+	return (r) => {
+		if (t(n, r.getState())) return;
+		let { handle: i, record: s } = a(r, e);
+		return o.set(r, i), { onChange: s };
+	};
 };
 //#endregion
-export { o as getStoreHistory, s as historyMiddleware };
+export { s as getStoreHistory, c as historyMiddleware };

package/dist/middleware/index.d.ts

@@ -4,5 +4,5 @@ export { historyMiddleware } from './historyMiddleware';
 export { reduxDevToolsMiddleware } from './reduxDevToolsMiddleware';
 export { cascade } from './cascade';
 export type { LoggerOptions } from './loggerMiddleware';
-export type { PersistOptions, PersistStorage } from './persistMiddleware';
+export type { PersistOptions, PersistStorage, PersistTarget, PersistTargetOption } from './persistMiddleware';
 export type { ReduxDevToolsOptions } from './reduxDevToolsMiddleware';

package/dist/middleware/isDisabled.d.ts

@@ -0,0 +1,2 @@
+import { MiddlewareOptions } from '../types';
+export declare const isDisabled: <T extends object>(enabled: MiddlewareOptions<T>["enabled"], state: T) => boolean;

package/dist/middleware/isDisabled.mjs

@@ -0,0 +1,4 @@
+//#region src/middleware/isDisabled.ts
+var e = (e, t) => typeof e == "function" ? !e(t) : e === !1;
+//#endregion
+export { e as isDisabled };

package/dist/middleware/loggerMiddleware.d.ts

@@ -1,5 +1,5 @@
-import { StoreChange, StoreError, StoreMiddleware } from '../types';
-export type LoggerOptions<TState extends object> = {
+import { MiddlewareOptions, StoreChange, StoreError, StoreMiddleware } from '../types';
+export type LoggerOptions<TState extends object> = MiddlewareOptions<TState> & {
     filter?: (change: StoreChange<TState>) => boolean;
     sink?: (change: StoreChange<TState>) => void;
     errorSink?: (failure: StoreError<TState>) => void;

package/dist/middleware/loggerMiddleware.mjs

@@ -1,20 +1,19 @@
+import { isDisabled as e } from "./isDisabled.mjs";
 //#region src/middleware/loggerMiddleware.ts
-var e = (e) => {
+var t = (e) => {
 	console.log("[store]", e.path ?? "(root)", e.next);
-}, t = (e) => {
+}, n = (e) => {
 	console.error("[store]", `${e.phase} error at`, e.path ?? "(root)", e.error);
-}, n = (n = {}) => {
-	let { filter: r, sink: i = e, errorSink: a = t } = typeof n == "function" ? {
-		filter: void 0,
-		sink: n,
-		errorSink: t
-	} : n;
-	return () => ({
-		onChange: (e) => {
-			(!r || r(e)) && i(e);
-		},
-		onError: a
-	});
+}, r = (r = {}) => {
+	let { filter: i, sink: a = t, errorSink: o = n, enabled: s } = typeof r == "function" ? { sink: r } : r;
+	return (t) => {
+		if (!e(s, t.getState())) return {
+			onChange: (e) => {
+				(!i || i(e)) && a(e);
+			},
+			onError: o
+		};
+	};
 };
 //#endregion
-export { n as loggerMiddleware };
+export { r as loggerMiddleware };

package/dist/middleware/persistMiddleware.d.ts

@@ -1,16 +1,18 @@
-import { StoreMiddleware } from '../types';
+import { MiddlewareOptions, PathOf, StoreMiddleware } from '../types';
 export type PersistStorage = {
     getItem: (key: string) => string | null;
     setItem: (key: string, value: string) => void;
     removeItem: (key: string) => void;
 };
-export type PersistOptions<TState extends object> = {
+export type PersistTarget = PersistStorage | 'local' | 'session';
+export type PersistTargetOption<TState extends object> = PersistTarget | ((state: TState) => PersistTarget | false);
+export type PersistOptions<TState extends object> = MiddlewareOptions<TState> & {
     key: string;
-    storage?: PersistStorage;
+    storage?: PersistTargetOption<TState>;
+    paths?: ReadonlyArray<PathOf<TState>>;
     partialize?: (state: TState) => Partial<TState>;
     version?: number;
-    migrate?: (persisted: unknown, version: number) => Partial<TState>;
+    migrate?: (persisted: unknown, version: number) => unknown;
     merge?: (persisted: Partial<TState>, current: TState) => Partial<TState>;
-    debounce?: number;
 };
 export declare const persistMiddleware: <TState extends object>(options: PersistOptions<TState>) => StoreMiddleware<TState>;

package/dist/middleware/persistMiddleware.mjs

@@ -1,40 +1,68 @@
+import e from "../helpers/getByPath.mjs";
+import { isDisabled as t } from "./isDisabled.mjs";
+import n from "../helpers/isPathAffected.mjs";
 //#region src/middleware/persistMiddleware.ts
-var e = {
-	getItem: () => null,
-	setItem: () => {},
-	removeItem: () => {}
-}, t = () => typeof localStorage < "u" ? localStorage : e, n = (e) => {
-	let { key: n, storage: i = t(), partialize: a, version: o = 0, migrate: s, merge: c, debounce: l = 0 } = e, u = (e) => {
-		let t = e.getState(), r = {
-			version: o,
-			state: a ? a(t) : t
+var r = (e = "local") => {
+	if (typeof e != "string") return e;
+	try {
+		return e === "session" ? globalThis.sessionStorage : globalThis.localStorage;
+	} catch {
+		return;
+	}
+}, i = (i) => {
+	let { key: o, storage: s, paths: c, partialize: l, version: u = 0, migrate: d, merge: f, enabled: p } = i, m = typeof s == "function" ? s : void 0, h = typeof s == "function" ? void 0 : r(s);
+	if (!m && !h) return () => void 0;
+	let g = (e) => {
+		if (!m) return h;
+		let t = m(e);
+		return t ? r(t) : void 0;
+	}, _ = (t) => {
+		if (c) {
+			let n = {};
+			for (let r of c) n[r] = e(t, r);
+			return n;
+		}
+		return l ? l(t) : t;
+	}, v = (e) => {
+		let t = e.getState(), n = g(t);
+		if (!n) return;
+		let r = {
+			version: u,
+			state: _(t)
 		};
-		i.setItem(n, JSON.stringify(r));
-	};
+		n.setItem(o, JSON.stringify(r));
+	}, y = (e) => !c || c.some((t) => n(e, t));
 	return (e) => {
-		let t;
+		if (t(p, e.getState())) return;
+		let n = !1, r = () => {
+			if (n) return;
+			let t = g(e.getState());
+			t && (n = !0, a(e, o, t, u, c, d, f));
+		};
 		return {
-			hydrate: (e) => {
-				r(e, n, i, o, s, c);
-			},
-			onChange: () => {
-				if (l <= 0) {
-					u(e);
-					return;
-				}
-				clearTimeout(t), t = setTimeout(() => u(e), l);
+			hydrate: r,
+			onChange: (t) => {
+				r(), y(t.path) && v(e);
 			}
 		};
 	};
 };
-function r(e, t, n, r, i, a) {
-	let o = n.getItem(t);
-	if (o) try {
-		let t = JSON.parse(o), n = t.version !== r && i ? i(t.state, t.version) : t.state;
-		e.setState(void 0, a ? a(n, e.getState()) : n);
+function a(e, t, n, r, i, a, o) {
+	let s = n?.getItem(t);
+	if (s) try {
+		let t = JSON.parse(s), n = t.version !== r && a ? a(t.state, t.version) : t.state;
+		if (i) {
+			let t = n;
+			e.batch(() => {
+				for (let n of i) n in t && e.setState(n, t[n]);
+			});
+			return;
+		}
+		let c = n;
+		e.setState(void 0, o ? o(c, e.getState()) : c);
 	} catch {
-		n.removeItem(t);
+		n?.removeItem(t);
 	}
 }
 //#endregion
-export { n as persistMiddleware };
+export { i as persistMiddleware };

package/dist/middleware/reduxDevToolsMiddleware.d.ts

@@ -1,5 +1,5 @@
-import { StoreChange, StoreMiddleware } from '../types';
-export type ReduxDevToolsOptions<TState extends object> = {
+import { MiddlewareOptions, StoreChange, StoreMiddleware } from '../types';
+export type ReduxDevToolsOptions<TState extends object> = MiddlewareOptions<TState> & {
     name?: string;
     action?: (change: StoreChange<TState>) => string;
 };

package/dist/middleware/reduxDevToolsMiddleware.mjs

@@ -1,26 +1,31 @@
+import { isDisabled as e } from "./isDisabled.mjs";
 //#region src/middleware/reduxDevToolsMiddleware.ts
-var e = () => {
+var t = () => {
 	if (!(typeof window > "u")) return window.__REDUX_DEVTOOLS_EXTENSION__;
-}, t = (t = {}) => (n) => {
-	let r = e();
-	if (!r) return;
-	let { name: i = "nexus", action: a } = t, o = r.connect({ name: i });
-	o.init(n.getState());
-	let s = !1;
-	return o.subscribe((e) => {
-		if (e.type !== "DISPATCH" || e.state === void 0) return;
-		let t = e.payload?.type;
-		if (!(t !== "JUMP_TO_STATE" && t !== "JUMP_TO_ACTION" && t !== "ROLLBACK")) {
-			s = !0;
-			try {
-				n.setState(void 0, JSON.parse(e.state));
-			} finally {
-				s = !1;
+}, n = (n = {}) => {
+	let { enabled: r } = n;
+	return (i) => {
+		if (e(r, i.getState())) return;
+		let a = t();
+		if (!a) return;
+		let { name: o = "nexus", action: s } = n, c = a.connect({ name: o });
+		c.init(i.getState());
+		let l = !1;
+		return c.subscribe((e) => {
+			if (e.type !== "DISPATCH" || e.state === void 0) return;
+			let t = e.payload?.type;
+			if (!(t !== "JUMP_TO_STATE" && t !== "JUMP_TO_ACTION" && t !== "ROLLBACK")) {
+				l = !0;
+				try {
+					i.setState(void 0, JSON.parse(e.state));
+				} finally {
+					l = !1;
+				}
 			}
-		}
-	}), { onChange: (e) => {
-		s || o.send({ type: a ? a(e) : e.path ?? "SET_STATE" }, n.getState());
-	} };
+		}), { onChange: (e) => {
+			l || c.send({ type: s ? s(e) : e.path ?? "SET_STATE" }, i.getState());
+		} };
+	};
 };
 //#endregion
-export { t as reduxDevToolsMiddleware };
+export { n as reduxDevToolsMiddleware };

package/dist/types/StoreTypes.d.ts

@@ -2,17 +2,13 @@ import { default as PathTrie } from '../createStore/helpers/PathTrie';
 import { default as Subscribers } from '../createStore/helpers/Subscribers';
 export type Path = string;
 export type Primitive = string | number | boolean | null | undefined | symbol | bigint;
-export type PathOf<T, Seen = never> = T extends Primitive ? never : T extends Seen ? never : {
-    [K in keyof T & string]-?: T[K] extends Primitive ? K : T[K] extends Array<infer U> ? K | `${K}.${number}` | `${K}.${number}.${PathOf<U, Seen | T>}` : K | `${K}.${PathOf<T[K], Seen | T>}`;
+export type PathOf<T, Seen = never> = T extends Primitive ? never : T extends Seen ? never : [string] extends [keyof T & string] ? string : {
+    [K in keyof T & string]-?: T[K] extends Primitive ? K : NonNullable<T[K]> extends Array<infer U> ? K | `${K}.${number}` | `${K}.${number}.${PathOf<U, Seen | T>}` : K | `${K}.${PathOf<NonNullable<T[K]>, Seen | T>}`;
 }[keyof T & string];
 export type PathValue<T, P> = T extends undefined ? undefined : P extends `${infer K}.${infer Rest}` ? K extends keyof NonNullable<T> ? NonNullable<T>[K] extends Array<infer U> ? Rest extends `${number}.${infer R}` ? PathValue<U, R> : Rest extends `${number}` ? U : never : PathValue<NonNullable<T>[K], Rest> : never : P extends keyof NonNullable<T> ? NonNullable<T>[P] : never;
 export type PathSetter<TState extends object, P extends PathOf<TState>> = (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void;
-export type __NoDefault = {
-    __noDefault: true;
-};
-type NumericIndex<I> = I extends `${infer N extends number}` ? N : I extends number ? I : never;
-export type PathValues<TState extends object, Paths extends ReadonlyArray<PathOf<TState>>, DefaultValue = __NoDefault> = {
-    [I in keyof Paths]: Paths[I] extends PathOf<TState> ? [DefaultValue] extends [__NoDefault] ? PathValue<TState, Paths[I]> : DefaultValue extends readonly any[] ? NumericIndex<I> extends infer NI ? NI extends keyof DefaultValue ? DefaultValue[NI] extends undefined ? PathValue<TState, Paths[I]> | undefined : NonNullable<PathValue<TState, Paths[I]>> | DefaultValue[NI] : PathValue<TState, Paths[I]> : never : NonNullable<PathValue<TState, Paths[I]>> | DefaultValue : never;
+export type PathValues<TState extends object, Paths extends ReadonlyArray<PathOf<TState>>> = {
+    [I in keyof Paths]: Paths[I] extends PathOf<TState> ? PathValue<TState, Paths[I]> : never;
 };
 export type PathSetters<TState extends object, Paths extends ReadonlyArray<PathOf<TState>>> = {
     [I in keyof Paths]: Paths[I] extends PathOf<TState> ? PathSetter<TState, Paths[I]> : never;
@@ -54,17 +50,55 @@ export type StoreMiddlewareHandlers<T> = {
     hydrate?: (api: StoreApi<T>) => void;
 };
 export type StoreMiddleware<T extends object> = (api: StoreApi<T>) => StoreMiddlewareHandlers<T> | void;
+export type MiddlewareOptions<T extends object> = {
+    enabled?: boolean | ((state: T) => boolean);
+};
 export type Listener = (changedPath?: Path) => void;
 export type SetState<T> = {
     (path: undefined, value: T | ((prev: T) => T), canPropagate?: boolean): void;
     <P extends PathOf<T>>(path: P, value: PathValue<T, P> | ((prev: PathValue<T, P>) => PathValue<T, P>), canPropagate?: boolean): void;
 };
 export type GetState<T> = () => T;
+export type BoundStore<TBase> = {
+    getState: {
+        (): TBase | undefined;
+        <D>(defaultValue: D): NonNullable<TBase> | D;
+    };
+    getPath: TBase extends object ? {
+        <SubP extends PathOf<TBase>>(subPath: SubP): PathValue<TBase, SubP> | undefined;
+        <SubP extends PathOf<TBase>, D>(subPath: SubP, defaultValue: D): NonNullable<PathValue<TBase, SubP>> | D;
+    } : {
+        (): TBase | undefined;
+        <D>(defaultValue: D): NonNullable<TBase> | D;
+    };
+    setState: SetFromBaseFn<TBase>;
+    subscribe: (listener: Listener) => () => void;
+    subscribePath: TBase extends object ? <SubP extends PathOf<TBase>>(subPath: SubP, listener: Listener) => () => void : (listener: Listener) => () => void;
+    get: TBase extends object ? {
+        (): TBase | undefined;
+        <SubP extends PathOf<TBase>>(subPath: SubP): PathValue<TBase, SubP> | undefined;
+    } : () => TBase | undefined;
+    set: SetFromBaseFn<TBase>;
+    watch: TBase extends object ? {
+        (listener: Listener): () => void;
+        <SubP extends PathOf<TBase>>(subPath: SubP, listener: Listener): () => void;
+    } : (listener: Listener) => () => void;
+};
 export type StoreApi<T> = {
     id?: string;
     getState: GetState<T>;
     getPath: <P extends PathOf<T>>(path: P) => PathValue<T, P> | undefined;
     setState: SetState<T>;
+    get: {
+        (): T;
+        <P extends PathOf<T>>(path: P): PathValue<T, P> | undefined;
+    };
+    set: SetState<T>;
+    watch: {
+        (listener: Listener): () => void;
+        <P extends PathOf<T>>(path: P, listener: Listener): () => void;
+    };
+    withBase: <P extends PathOf<T>>(basePath: P) => BoundStore<NonNullable<PathValue<T, P>>>;
     batch: <R>(fn: () => R) => R;
     subscribe: (listener: Listener) => () => void;
     subscribePath: <P extends PathOf<T>>(path: P, listener: Listener) => () => void;
@@ -80,6 +114,7 @@ export type StoreApiInternal<T> = StoreApi<T> & {
     changeListeners: Subscribers<ChangeListener<T>>;
     interceptors: WriteInterceptor<T>[];
     errorHandlers: StoreErrorHandler<T>[];
+    invalidateListeners: Subscribers<() => void>;
     getMergeCount?: () => number;
 };
 export type PathOrFn<TState extends object> = PathOf<TState> | ((state: TState) => PathOf<TState>);
@@ -91,15 +126,16 @@ export type PathOrFnSetter<TState extends object, Entry> = Entry extends PathOf<
 export type PathOrFnSetters<TState extends object, Entries extends ReadonlyArray<PathOrFn<TState>>> = {
     [I in keyof Entries]: PathOrFnSetter<TState, Entries[I]>;
 };
-export type MultiPathReturn<TState extends object, Paths extends ReadonlyArray<PathOf<TState>>, TDefaultValue = __NoDefault> = [PathValues<TState, Paths, TDefaultValue>, ...PathSetters<TState, Paths>];
+export type MultiPathReturn<TState extends object, Paths extends ReadonlyArray<PathOf<TState>>> = [
+    PathValues<TState, Paths>,
+    ...PathSetters<TState, Paths>
+];
 export type UseStoreReturn<TState extends object, TArg> = TArg extends PathOf<TState> ? [PathValue<TState, TArg>, PathSetter<TState, TArg>] : TArg extends (state: TState) => unknown ? [unknown, (value: unknown) => void] : [TState, StoreApi<TState>['setState']];
 export type UseStoreOptions<T, TState extends object = object> = StoreHookReactiveOptions<T, TState> & {
-    defaultValue?: NonNullable<T>;
     transformer?: (value: T) => unknown;
 };
-export type UseStoreMultiOptions<TState extends object, Paths extends ReadonlyArray<PathOf<TState>>, TDefaultValue extends readonly (PathValue<TState, Paths[number]> | undefined)[] | PathValue<TState, Paths[number]> | undefined = undefined> = Omit<StoreHookReactiveOptions<never, TState>, 'equalityFn'> & {
+export type UseStoreMultiOptions<TState extends object, Paths extends ReadonlyArray<PathOf<TState>>> = Omit<StoreHookReactiveOptions<never, TState>, 'equalityFn'> & {
     equalityFn?: (a: PathValues<TState, Paths>, b: PathValues<TState, Paths>) => boolean;
-    defaultValue?: TDefaultValue;
     transformer?: (values: PathValues<TState, Paths>) => unknown;
 };
 export type UseStoreSyncOptions<T, TState extends object = object> = StoreHookReactiveOptions<T, TState> & {
@@ -120,19 +156,11 @@ export type GetValueFromBaseFn<TBase> = TBase extends object ? {
     <SubP extends PathOf<TBase>, D>(path: SubP, defaultValue: D): NonNullable<PathValue<TBase, SubP>> | D;
     <D>(path: undefined, defaultValue: D): NonNullable<TBase> | D;
 } : () => TBase;
-export type GetValueFromBaseWithDefaultFn<TBase, D> = TBase extends object ? {
-    (): NonNullable<TBase> | D;
-    <SubP extends PathOf<NonNullable<TBase>>>(path: SubP): PathValue<NonNullable<TBase>, SubP>;
-    <SubP extends PathOf<NonNullable<TBase>>, D2>(path: SubP, defaultValue: D2): NonNullable<PathValue<NonNullable<TBase>, SubP>> | D2;
-    <D2>(path: undefined, defaultValue: D2): NonNullable<TBase> | D2;
-} : () => NonNullable<TBase> | D;
 type EntryGetter<TState extends object, Entry> = Entry extends PathOf<TState> ? GetValueFromBaseFn<PathValue<TState, Entry>> : Entry extends (state: TState) => infer R ? R extends object ? GetValueFromBaseFn<R> : () => R : never;
 export type GetterTuple<TState extends object, Entries extends ReadonlyArray<PathOf<TState> | ((state: TState) => unknown)>> = {
     [K in keyof Entries]: EntryGetter<TState, Entries[K]>;
 };
-export type UseStoreGetterOptions<TState extends object = object, D = __NoDefault> = StoreHookBaseOptions<TState> & {
-    defaultValue?: D;
-};
+export type UseStoreGetterOptions<TState extends object = object> = StoreHookBaseOptions<TState>;
 export type SetStateFn<TState extends object> = {
     (path: undefined, value: TState | ((prev: TState) => TState)): void;
     <P extends PathOf<TState>>(path: P, value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/nexus",
-  "version": "0.31.2",
+  "version": "0.32.1",
   "license": "Apache-2.0",
   "files": [
     "dist",
@@ -47,6 +47,14 @@
       "types": "./dist/StoreProvider.d.ts",
       "import": "./dist/StoreProvider.mjs"
     },
+    "./advanced": {
+      "types": "./dist/advanced/index.d.ts",
+      "import": "./dist/advanced/index.mjs"
+    },
+    "./advanced/index": {
+      "types": "./dist/advanced/index.d.ts",
+      "import": "./dist/advanced/index.mjs"
+    },
     "./async": {
       "types": "./dist/async/index.d.ts",
       "import": "./dist/async/index.mjs"
@@ -159,6 +167,10 @@
       "types": "./dist/entities/createEntityAdapter.d.ts",
       "import": "./dist/entities/createEntityAdapter.mjs"
     },
+    "./entities/createEntityStore": {
+      "types": "./dist/entities/createEntityStore.d.ts",
+      "import": "./dist/entities/createEntityStore.mjs"
+    },
     "./entities/index": {
       "types": "./dist/entities/index.d.ts",
       "import": "./dist/entities/index.mjs"
@@ -223,6 +235,10 @@
       "types": "./dist/middleware/index.d.ts",
       "import": "./dist/middleware/index.mjs"
     },
+    "./middleware/isDisabled": {
+      "types": "./dist/middleware/isDisabled.d.ts",
+      "import": "./dist/middleware/isDisabled.mjs"
+    },
     "./middleware/loggerMiddleware": {
       "types": "./dist/middleware/loggerMiddleware.d.ts",
       "import": "./dist/middleware/loggerMiddleware.mjs"