@plitzi/nexus 0.31.2 → 0.32.1

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 };

package/dist/createStore/hooks/useStore.mjs

@@ -4,42 +4,34 @@ import { useCallback as c, useMemo as l, useRef as u, useSyncExternalStore as d
 //#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), [
+	let i = r.mode ?? "sync", a = r.enabled ?? !0, o = t === void 0, f = r.equalityFn ?? (o ? s : Object.is), p = r.transformer, m = u(p);
+	m.current = p;
+	let h = l(() => n(e, t), [e, t]), g = u(h()), _ = 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);
+	]), v = () => {
+		if (!a) return g.current;
+		if (i === "mount") return h();
+		let e = h();
+		return f(g.current, e) ? g.current : (g.current = e, e);
+	}, y = d(_, v, v);
+	return [l(() => m.current ? m.current(y) : y, [y]), c((n) => {
+		o ? 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
-	}), [
+	let c = s.mode ?? "sync", d = s.enabled ?? !0, f = s.equalityFn ?? e, p = s.transformer, m = u(p);
+	m.current = p;
+	let h = u(o);
+	h.current = o;
+	let g = o.map((e, t) => typeof e == "function" ? `fn_${t}` : e).join("|"), _ = u(null), v = l(() => t(n, h, _, { equalityFn: f }), [
 		n,
-		_,
-		p,
+		g,
 		f
-	]), b = r(a(n, g, _, d, c), y, d, v);
-	return [l(() => h.current ? h.current(b) : b, [b]), ...i(n, g, _)];
+	]), y = r(a(n, h, g, d, c), v, d, _);
+	return [l(() => m.current ? m.current(y) : y, [y]), ...i(n, h, 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 ? {

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

@@ -1,9 +1,6 @@
-import { GetterTuple, GetValueFromBaseWithDefaultFn, GetValueFromBaseFn, GetValueFn, PathOf, PathValue, UseStoreGetterOptions } from '../../types';
-export type { GetValueFn, GetValueFromBaseFn, GetValueFromBaseWithDefaultFn, GetterTuple, UseStoreGetterOptions };
+import { GetterTuple, GetValueFromBaseFn, GetValueFn, PathOf, PathValue, UseStoreGetterOptions } from '../../types';
+export type { GetValueFn, GetValueFromBaseFn, 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

@@ -3,34 +3,31 @@ 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();
+	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), l = o?.map((e) => typeof e == "function" ? e.toString() : e).join("|");
+	return n(() => {
+		if (o) return 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;
+		});
 		if (a !== void 0) {
-			let i = e(r, a);
+			let e = c.withBase(a);
+			return (t, n) => t === void 0 ? n === void 0 ? e.getState() : e.getState(n) : n === void 0 ? e.getPath(t) : e.getPath(t, n);
+		}
+		return (t, n) => {
+			let r = c.getState();
 			if (t !== void 0) {
-				let r = e(i, t);
-				return r === void 0 && n !== void 0 ? n : r;
+				let i = e(r, t);
+				return i === void 0 && n !== void 0 ? n : i;
 			}
-			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;
+			return r;
+		};
 	}, [
 		c,
 		a,
-		u,
 		l
 	]);
 }

package/dist/createStore/hooks/useStoreSetter.mjs

@@ -1,11 +1,9 @@
 import { useResolvedStore as e } from "./shared.mjs";
-import { useCallback as t } from "react";
+import { useMemo 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]);
+	return t(() => i === void 0 ? o.setState : o.withBase(i).setState, [o, i]);
 }
 //#endregion
 export { n as default };

package/dist/derived/createDerived.d.ts

@@ -7,4 +7,4 @@ export type Derived<R> = {
 export type DerivedOptions<R> = {
     equalityFn?: (a: R, b: R) => boolean;
 };
-export declare function createDerived<TState extends object, const Paths extends readonly PathOf<TState>[], R>(store: StoreApi<TState>, deps: Paths, compute: (values: PathValues<TState, Paths>) => R, options?: DerivedOptions<R>): Derived<R>;
+export declare function createDerived<TState extends object, const Paths extends readonly PathOf<TState>[], R>(store: StoreApi<TState>, deps: Paths, compute: (values: PathValues<TState, Paths>, changedPath?: string) => R, options?: DerivedOptions<R>): Derived<R>;

package/dist/derived/createDerived.mjs

@@ -1,19 +1,22 @@
 import { createObservable as e } from "../helpers/createObservable.mjs";
 //#region src/derived/createDerived.ts
 function t(t, n, r, i = {}) {
-	let a = i.equalityFn ?? Object.is, o = e(() => r(n.map((e) => t.getPath(e)))), s = () => {
-		if (!o.hasListeners()) {
-			o.invalidate();
+	let a = i.equalityFn ?? Object.is, o, s = e(() => {
+		let e = o;
+		return o = void 0, r(n.map((e) => t.getPath(e)), e);
+	}), c = (e) => {
+		if (o = e, !s.hasListeners()) {
+			s.invalidate();
 			return;
 		}
-		let e = o.get();
-		o.invalidate(), a(e, o.get()) || o.notify();
-	}, c = n.map((e) => t.subscribePath(e, s));
+		let t = s.get();
+		s.invalidate(), a(t, s.get()) || s.notify();
+	}, l = n.map((e) => t.subscribePath(e, c));
 	return {
-		get: o.get,
-		subscribe: (e) => (o.get(), o.subscribe(e)),
+		get: s.get,
+		subscribe: (e) => (s.get(), s.subscribe(e)),
 		destroy: () => {
-			c.forEach((e) => e()), o.destroy();
+			l.forEach((e) => e()), s.destroy();
 		}
 	};
 }

package/dist/entities/createEntityStore.d.ts

@@ -0,0 +1,38 @@
+import { EntityId } from './createEntityAdapter';
+export type EntityChangeListener = () => void;
+export type EntityStoreOptions<T> = {
+    selectId?: (entity: T) => EntityId;
+    sortComparer?: (a: T, b: T) => number;
+};
+export type EntityStore<T> = {
+    selectId: (entity: T) => EntityId;
+    getOne: (id: EntityId) => T | undefined;
+    getAll: () => T[];
+    getIds: () => string[];
+    has: (id: EntityId) => boolean;
+    size: () => number;
+    setOne: (entity: T) => void;
+    setMany: (entities: readonly T[]) => void;
+    setAll: (entities: readonly T[]) => void;
+    addOne: (entity: T) => void;
+    addMany: (entities: readonly T[]) => void;
+    upsertOne: (entity: T) => void;
+    upsertMany: (entities: readonly T[]) => void;
+    updateOne: (id: EntityId, changes: Partial<T>) => void;
+    updateMany: (updates: readonly {
+        id: EntityId;
+        changes: Partial<T>;
+    }[]) => void;
+    removeOne: (id: EntityId) => void;
+    removeMany: (ids: readonly EntityId[]) => void;
+    removeAll: () => void;
+    batch: (fn: () => void) => void;
+    subscribeOne: (id: EntityId, listener: EntityChangeListener) => () => void;
+    subscribeIds: (listener: EntityChangeListener) => () => void;
+    subscribeAll: (listener: EntityChangeListener) => () => void;
+    useOne: (id: EntityId) => T | undefined;
+    useIds: () => string[];
+    useAll: () => T[];
+    destroy: () => void;
+};
+export declare function createEntityStore<T>(initialEntities?: readonly T[], options?: EntityStoreOptions<T>): EntityStore<T>;

package/dist/entities/createEntityStore.mjs

@@ -0,0 +1,102 @@
+import e from "../createStore/helpers/Subscribers.mjs";
+import { useCallback as t, useSyncExternalStore as n } from "react";
+//#region src/entities/createEntityStore.ts
+function r(r = [], i = {}) {
+	let a = i.selectId ?? ((e) => e.id), o = i.sortComparer, s = (e) => String(a(e)), c = /* @__PURE__ */ new Map();
+	for (let e of r) c.set(s(e), e);
+	let l = /* @__PURE__ */ new Map(), u = new e(), d = new e(), f, p, m = 0, h = /* @__PURE__ */ new Set(), g = !1, _ = !1, v = (e) => {
+		e && e.length > 0 && e.forEach((e) => e());
+	}, y = (e, t) => {
+		if (t && (f = void 0), p = void 0, m > 0) {
+			h.add(e), g ||= t, _ = !0;
+			return;
+		}
+		v(l.get(e)), t && v(u), v(d);
+	}, b = () => {
+		let e = [...h], t = g, n = _;
+		h.clear(), g = !1, _ = !1;
+		for (let t of e) v(l.get(t));
+		t && v(u), n && v(d);
+	}, x = (e) => {
+		m++;
+		try {
+			e();
+		} finally {
+			m--, m === 0 && _ && b();
+		}
+	}, S = (e, t, n) => {
+		let r = s(e), i = c.get(r), a = i === void 0;
+		if (t && !a) return;
+		let o = n && !a ? {
+			...i,
+			...e
+		} : e;
+		o !== i && (c.set(r, o), y(r, a));
+	}, C = (e) => {
+		S(e, !1, !1);
+	}, w = (e) => {
+		S(e, !0, !1);
+	}, T = (e) => {
+		S(e, !1, !0);
+	}, E = (e, t) => {
+		let n = String(e), r = c.get(n);
+		r !== void 0 && (c.set(n, {
+			...r,
+			...t
+		}), y(n, !1));
+	}, D = (e) => {
+		let t = String(e);
+		c.has(t) && (c.delete(t), y(t, !0));
+	}, O = (e) => c.get(String(e)), k = () => f ??= [...c.keys()], A = () => {
+		if (p === void 0) {
+			let e = [...c.values()];
+			p = o ? e.sort(o) : e;
+		}
+		return p;
+	}, j = (t, n) => {
+		let r = String(t), i = l.get(r);
+		i || (i = new e(), l.set(r, i));
+		let a = i, o = a.add(n);
+		return () => {
+			o(), a.length === 0 && l.get(r) === a && l.delete(r);
+		};
+	}, M = (e) => u.add(e), N = (e) => d.add(e);
+	return {
+		selectId: a,
+		getOne: O,
+		getIds: k,
+		getAll: A,
+		has: (e) => c.has(String(e)),
+		size: () => c.size,
+		setOne: C,
+		setMany: (e) => x(() => e.forEach(C)),
+		setAll: (e) => x(() => {
+			for (let e of [...c.keys()]) D(e);
+			e.forEach(C);
+		}),
+		addOne: w,
+		addMany: (e) => x(() => e.forEach(w)),
+		upsertOne: T,
+		upsertMany: (e) => x(() => e.forEach(T)),
+		updateOne: E,
+		updateMany: (e) => x(() => e.forEach(({ id: e, changes: t }) => E(e, t))),
+		removeOne: D,
+		removeMany: (e) => x(() => e.forEach(D)),
+		removeAll: () => x(() => [...c.keys()].forEach(D)),
+		batch: x,
+		subscribeOne: j,
+		subscribeIds: M,
+		subscribeAll: N,
+		useOne: (e) => {
+			let r = String(e), i = t((e) => j(r, e), [r]), a = t(() => c.get(r), [r]);
+			return n(i, a, a);
+		},
+		useIds: () => n(M, k, k),
+		useAll: () => n(N, A, A),
+		destroy: () => {
+			c.clear(), l.clear(), u.clear(), d.clear(), f = void 0, p = void 0;
+		}
+	};
+}
+//#endregion
+export { r as createEntityStore };

package/dist/entities/index.d.ts

@@ -1,2 +1,4 @@
 export { createEntityAdapter } from './createEntityAdapter';
+export { createEntityStore } from './createEntityStore';
 export type { EntityAdapter, EntityAdapterOptions, EntityId, EntityMap, EntityUpdate, EntityUpdater } from './createEntityAdapter';
+export type { EntityStore, EntityStoreOptions, EntityChangeListener } from './createEntityStore';

package/dist/entities/index.mjs

@@ -1,2 +1,3 @@
 import { createEntityAdapter as e } from "./createEntityAdapter.mjs";
-export { e as createEntityAdapter };
+import { createEntityStore as t } from "./createEntityStore.mjs";
+export { e as createEntityAdapter, t as createEntityStore };

package/dist/index.d.ts

@@ -2,16 +2,17 @@ import { default as createStore } from './createStore';
 import { default as useStoreById } from './createStore/hooks/useStoreById';
 import { default as useStoreSetter } from './createStore/hooks/useStoreSetter';
 import { default as StoreProvider } from './StoreProvider';
-export * from './async';
 export * from './createStore';
+export * from './StoreProvider';
+export * from './types';
+export { createStore, StoreProvider };
+export * from './async';
 export * from './derived';
 export * from './entities';
 export * from './history';
 export * from './middleware';
-export * from './StoreProvider';
 export * from './createStore/hooks/useStoreSetter';
 export * from './createStore/hooks/useStoreById';
-export * from './types';
-export { createStore, StoreProvider, useStoreById, useStoreSetter };
+export { useStoreById, useStoreSetter };
 export { setCodegenEnabled } from './createStore/helpers/writeByPath';
 export { createServerSnapshot, isServerSnapshot } from './rsc';

package/dist/index.mjs

@@ -1,22 +1,23 @@
-import { createAsync as e } from "./async/createAsync.mjs";
-import { useAsync as t } from "./async/hooks/useAsync.mjs";
-import { useAsyncValue as n } from "./async/hooks/useAsyncValue.mjs";
-import { setCodegenEnabled as r } from "./createStore/helpers/writeByPath.mjs";
-import { CANCEL as i } from "./types/StoreTypes.mjs";
-import { StoreContext as a, StoreRegistryContext as o } from "./StoreContext.mjs";
-import s from "./createStore/hooks/useStoreSetter.mjs";
-import { createStoreHook as c } from "./createStore/createStore.mjs";
-import l from "./createStore/index.mjs";
-import { createDerived as u } from "./derived/createDerived.mjs";
-import { useDerived as d } from "./derived/hooks/useDerived.mjs";
-import { createEntityAdapter as f } from "./entities/createEntityAdapter.mjs";
-import { getStoreHistory as p, historyMiddleware as m } from "./middleware/historyMiddleware.mjs";
-import { useStoreHistory as h } from "./history/hooks/useStoreHistory.mjs";
-import g from "./createStore/hooks/useStoreById.mjs";
-import { createServerSnapshot as _, isServerSnapshot as v } from "./rsc/index.mjs";
-import y from "./StoreProvider.mjs";
-import { loggerMiddleware as b } from "./middleware/loggerMiddleware.mjs";
-import { persistMiddleware as x } from "./middleware/persistMiddleware.mjs";
-import { reduxDevToolsMiddleware as S } from "./middleware/reduxDevToolsMiddleware.mjs";
-import { cascade as C } from "./middleware/cascade.mjs";
-export { i as CANCEL, a as StoreContext, y as StoreProvider, o as StoreRegistryContext, C as cascade, e as createAsync, u as createDerived, f as createEntityAdapter, _ as createServerSnapshot, l as createStore, c as createStoreHook, p as getStoreHistory, m as historyMiddleware, v as isServerSnapshot, b as loggerMiddleware, x as persistMiddleware, S as reduxDevToolsMiddleware, r as setCodegenEnabled, t as useAsync, n as useAsyncValue, d as useDerived, g as useStoreById, h as useStoreHistory, s as useStoreSetter };
+import { StoreContext as e, StoreRegistryContext as t } from "./StoreContext.mjs";
+import n from "./createStore/hooks/useStoreById.mjs";
+import r from "./createStore/hooks/useStoreSetter.mjs";
+import { createAsync as i } from "./async/createAsync.mjs";
+import { useAsync as a } from "./async/hooks/useAsync.mjs";
+import { useAsyncValue as o } from "./async/hooks/useAsyncValue.mjs";
+import { createDerived as s } from "./derived/createDerived.mjs";
+import { useDerived as c } from "./derived/hooks/useDerived.mjs";
+import { createEntityAdapter as l } from "./entities/createEntityAdapter.mjs";
+import { createEntityStore as u } from "./entities/createEntityStore.mjs";
+import { getStoreHistory as d, historyMiddleware as f } from "./middleware/historyMiddleware.mjs";
+import { useStoreHistory as p } from "./history/hooks/useStoreHistory.mjs";
+import { loggerMiddleware as m } from "./middleware/loggerMiddleware.mjs";
+import { persistMiddleware as h } from "./middleware/persistMiddleware.mjs";
+import { reduxDevToolsMiddleware as g } from "./middleware/reduxDevToolsMiddleware.mjs";
+import { cascade as _ } from "./middleware/cascade.mjs";
+import { setCodegenEnabled as v } from "./createStore/helpers/writeByPath.mjs";
+import { CANCEL as y } from "./types/StoreTypes.mjs";
+import { createStoreHook as b } from "./createStore/createStore.mjs";
+import x from "./createStore/index.mjs";
+import { createServerSnapshot as S, isServerSnapshot as C } from "./rsc/index.mjs";
+import w from "./StoreProvider.mjs";
+export { y as CANCEL, e as StoreContext, w as StoreProvider, t as StoreRegistryContext, _ as cascade, i as createAsync, s as createDerived, l as createEntityAdapter, u as createEntityStore, S as createServerSnapshot, x as createStore, b as createStoreHook, d as getStoreHistory, f as historyMiddleware, C as isServerSnapshot, m as loggerMiddleware, h as persistMiddleware, g as reduxDevToolsMiddleware, v as setCodegenEnabled, a as useAsync, o as useAsyncValue, c as useDerived, n as useStoreById, p as useStoreHistory, r as useStoreSetter };

package/dist/middleware/historyMiddleware.d.ts

@@ -1,4 +1,4 @@
-import { Path, StoreApi, StoreMiddleware } from '../types';
+import { MiddlewareOptions, Path, StoreApi, StoreMiddleware } from '../types';
 export type HistoryEntry<TState> = {
     path?: Path;
     value?: unknown;
@@ -19,10 +19,10 @@ export type StoreHistory<TState> = {
     travelTo: (index: number) => void;
     clear: () => void;
 };
-export type StoreHistoryOptions = {
+export type StoreHistoryOptions<TState extends object = object> = MiddlewareOptions<TState> & {
     limit?: number;
     path?: Path;
     shouldRecord?: (changedPath: Path | undefined) => boolean;
 };
 export declare function getStoreHistory<TState extends object>(store: StoreApi<TState>): StoreHistory<TState> | undefined;
-export declare const historyMiddleware: <TState extends object>(options?: StoreHistoryOptions) => StoreMiddleware<TState>;
+export declare const historyMiddleware: <TState extends object>(options?: StoreHistoryOptions<TState>) => StoreMiddleware<TState>;