@plitzi/nexus 0.32.0 → 0.32.2

package/dist/index.d.ts

@@ -1,17 +1,25 @@
-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 './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 { default as createStore } from './createStore/createStore';
 export { setCodegenEnabled } from './createStore/helpers/writeByPath';
+export { createAsync } from './async/createAsync';
+export { createDerived } from './derived/createDerived';
+export { createEntityAdapter } from './entities/createEntityAdapter';
+export { createEntityStore } from './entities/createEntityStore';
+export { loggerMiddleware } from './middleware/loggerMiddleware';
+export { persistMiddleware } from './middleware/persistMiddleware';
+export { historyMiddleware } from './middleware/historyMiddleware';
+export { reduxDevToolsMiddleware } from './middleware/reduxDevToolsMiddleware';
+export { createRecorder } from './middleware/recorderMiddleware';
+export { cascade } from './middleware/cascade';
+export { getStoreHistory } from './middleware/historyMiddleware';
 export { createServerSnapshot, isServerSnapshot } from './rsc';
+export * from './types';
+export type { CreateStoreOptions } from './createStore/createStore';
+export type { AsyncOptions, AsyncResource, AsyncSnapshot, AsyncStatus } from './async/createAsync';
+export type { Derived, DerivedOptions } from './derived/createDerived';
+export type { EntityAdapter, EntityAdapterOptions, EntityId, EntityMap, EntityUpdate, EntityUpdater } from './entities/createEntityAdapter';
+export type { EntityStore, EntityStoreOptions, EntityChangeListener } from './entities/createEntityStore';
+export type { LoggerOptions } from './middleware/loggerMiddleware';
+export type { PersistOptions, PersistStorage, PersistTarget, PersistTargetOption } from './middleware/persistMiddleware';
+export type { ReduxDevToolsOptions } from './middleware/reduxDevToolsMiddleware';
+export type { Recorder, RecorderEntry, RecorderOptions } from './middleware/recorderMiddleware';
+export type { HistoryEntry, HistorySnapshot, StoreHistory, StoreHistoryOptions } from './middleware/historyMiddleware';

package/dist/index.mjs

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

package/dist/middleware/historyMiddleware.mjs

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

package/dist/middleware/persistMiddleware.mjs

@@ -1,5 +1,5 @@
-import e from "../helpers/getByPath.mjs";
-import { isDisabled as t } from "./isDisabled.mjs";
+import { isDisabled as e } from "./isDisabled.mjs";
+import t from "../helpers/getByPath.mjs";
 import n from "../helpers/isPathAffected.mjs";
 //#region src/middleware/persistMiddleware.ts
 var r = (e = "local") => {
@@ -16,13 +16,13 @@ var r = (e = "local") => {
 		if (!m) return h;
 		let t = m(e);
 		return t ? r(t) : void 0;
-	}, _ = (t) => {
+	}, _ = (e) => {
 		if (c) {
 			let n = {};
-			for (let r of c) n[r] = e(t, r);
+			for (let r of c) n[r] = t(e, r);
 			return n;
 		}
-		return l ? l(t) : t;
+		return l ? l(e) : e;
 	}, v = (e) => {
 		let t = e.getState(), n = g(t);
 		if (!n) return;
@@ -32,17 +32,17 @@ var r = (e = "local") => {
 		};
 		n.setItem(o, JSON.stringify(r));
 	}, y = (e) => !c || c.some((t) => n(e, t));
-	return (e) => {
-		if (t(p, e.getState())) return;
+	return (t) => {
+		if (e(p, t.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));
+			let e = g(t.getState());
+			e && (n = !0, a(t, o, e, u, c, d, f));
 		};
 		return {
 			hydrate: r,
-			onChange: (t) => {
-				r(), y(t.path) && v(e);
+			onChange: (e) => {
+				r(), y(e.path) && v(t);
 			}
 		};
 	};

package/dist/middleware/recorderMiddleware.d.ts

@@ -0,0 +1,21 @@
+import { MiddlewareOptions, StoreChange, StoreMiddleware } from '../types';
+export type RecorderEntry = {
+    seq: number;
+    time: number;
+    path: string | undefined;
+    prevValue: unknown;
+    nextValue: unknown;
+};
+export type RecorderOptions<TState extends object> = MiddlewareOptions<TState> & {
+    max?: number;
+};
+export type Recorder<TState extends object> = {
+    middleware: StoreMiddleware<TState>;
+    record: (change: Pick<StoreChange<TState>, 'path' | 'prevValue' | 'nextValue'>) => void;
+    getEntries: () => readonly RecorderEntry[];
+    entriesSince: (seq: number) => RecorderEntry[];
+    lastSeq: () => number;
+    subscribe: (listener: () => void) => () => void;
+    clear: () => void;
+};
+export declare const createRecorder: <TState extends object>(options?: RecorderOptions<TState>) => Recorder<TState>;

package/dist/middleware/recorderMiddleware.mjs

@@ -0,0 +1,33 @@
+import e from "../createStore/helpers/Subscribers.mjs";
+import { isDisabled as t } from "./isDisabled.mjs";
+//#region src/middleware/recorderMiddleware.ts
+var n = () => typeof performance < "u" ? performance.now() : Date.now(), r = (r = {}) => {
+	let { max: i = 100, enabled: a } = r, o = new e(), s = [], c = 0, l = () => {
+		o.forEach((e) => e());
+	}, u = (e) => {
+		c += 1;
+		let t = {
+			seq: c,
+			time: n(),
+			path: e.path,
+			prevValue: e.prevValue,
+			nextValue: e.nextValue
+		}, r = s.length >= i ? s.slice(s.length - i + 1) : s.slice();
+		r.push(t), s = r, l();
+	};
+	return {
+		middleware: (e) => {
+			if (!t(a, e.getState())) return { onChange: u };
+		},
+		record: u,
+		getEntries: () => s,
+		entriesSince: (e) => s.filter((t) => t.seq > e),
+		lastSeq: () => c,
+		subscribe: (e) => o.add(e),
+		clear: () => {
+			s = [], l();
+		}
+	};
+};
+//#endregion
+export { r as createRecorder };

package/dist/{StoreContext.d.ts → react/StoreContext.d.ts}

@@ -1,4 +1,4 @@
-import { StoreApi } from './types';
+import { StoreApi } from '../types';
 declare const StoreContext: import('react').Context<StoreApi<any> | undefined>;
 export type StoreRegistry = {
     readonly id: string;

package/dist/{StoreContext.mjs → react/StoreContext.mjs}

@@ -1,5 +1,5 @@
 import { createContext as e } from "react";
-//#region src/StoreContext.ts
+//#region src/react/StoreContext.ts
 var t = e(void 0);
 t.displayName = "StoreContext";
 var n = e(void 0);

package/dist/{StoreProvider.d.ts → react/StoreProvider.d.ts}

@@ -1,9 +1,11 @@
 import { StoreContext, StoreRegistryContext } from './StoreContext';
-import { StoreApi, StoreMiddleware } from './types';
+import { StoreApi, StoreMiddleware } from '../types';
 import { ReactNode } from 'react';
 export type StoreProviderProps<TState extends object = any> = {
     store?: StoreApi<TState>;
     id?: string;
+    segment?: string;
+    isolate?: ReadonlyArray<string>;
     path?: string;
     value?: Partial<TState> | ((state: TState) => TState);
     /**
@@ -19,6 +21,6 @@ export type StoreProviderProps<TState extends object = any> = {
     middlewares?: StoreMiddleware<TState>[];
     children?: ReactNode;
 };
-declare const StoreProvider: <TState extends object = any>({ store, id, path, value, inherit, autoSync, middlewares, children }: StoreProviderProps<TState>) => import("react/jsx-runtime").JSX.Element;
+declare const StoreProvider: <TState extends object = any>({ store, id, segment, isolate, path, value, inherit, autoSync, middlewares, children }: StoreProviderProps<TState>) => import("react").JSX.Element;
 export { StoreContext, StoreRegistryContext };
 export default StoreProvider;

package/dist/react/StoreProvider.mjs

@@ -0,0 +1,62 @@
+import { isDev as e } from "../env.mjs";
+import t from "../createStore/index.mjs";
+import { isServerSnapshot as n, stripServerFlag as r } from "../rsc/index.mjs";
+import { StoreContext as i, StoreRegistryContext as a, findStoreInRegistry as o } from "./StoreContext.mjs";
+import s from "./hooks/useStoreSync.mjs";
+import { createContext as c, useContext as l, useEffect as u, useMemo as d, useRef as f } from "react";
+import { jsx as p } from "react/jsx-runtime";
+//#region src/react/StoreProvider.tsx
+var m = c(void 0), h = (e) => e.cascade === !0, g = ({ store: c, id: g, segment: _, isolate: v, path: y, value: b, inherit: x, autoSync: S = !0, middlewares: C, children: w }) => {
+	let T = l(i), E = l(m), D = l(a), O = T?.scopePath ?? "", k = d(() => _ === void 0 ? O : O ? `${O}/${_}` : _, [O, _]), A = f(void 0), j = x === "live", M = d(() => {
+		let e = x === "snapshot" && T ? T.getState() : {}, t = typeof b == "function" ? b(e) : {
+			...e,
+			...b
+		};
+		return n(t) ? r(t) : t;
+	}, [
+		x,
+		T,
+		b
+	]), N = C ?? [], P = E ? [...E, ...N] : N, F = d(() => {
+		let e = N.filter(h);
+		return e.length === 0 ? E : [...E ?? [], ...e];
+	}, [E, C]);
+	A.current ||= c ?? t(() => M, {
+		id: g,
+		scopePath: k,
+		exclusive: j ? v : void 0,
+		parent: j ? T : void 0,
+		middlewares: P.length > 0 ? P : void 0,
+		deferHydrate: !0
+	});
+	let I = d(() => g ? {
+		id: g,
+		store: A.current,
+		parent: D
+	} : D, [g, D]), L = f(!1);
+	u(() => {
+		e && g && !L.current && o(D, g) && (L.current = !0, console.warn(`@plitzi/nexus: duplicate StoreProvider id "${g}" — it shadows an ancestor provider with the same id, so a descendant's { storeId: "${g}" } or useStoreById("${g}") resolves to this (nearer) store. Use a distinct id, or remove one of the providers.`));
+	}, [g, D]), u(() => (j && !c && A.current?.reconnect?.(), () => {
+		j && !c && A.current?.destroy?.();
+	}), [j, c]);
+	let R = f(!1);
+	u(() => {
+		!R.current && A.current?.hydrate && (A.current.hydrate(), R.current = !0);
+	}, []), s(y, y ? b : M, {
+		enabled: !!b && S,
+		store: A.current
+	});
+	let z = /* @__PURE__ */ p(i, {
+		value: A.current,
+		children: w
+	});
+	return I !== D && (z = /* @__PURE__ */ p(a, {
+		value: I,
+		children: z
+	})), F !== E && (z = /* @__PURE__ */ p(m, {
+		value: F,
+		children: z
+	})), z;
+};
+//#endregion
+export { i as StoreContext, a as StoreRegistryContext, g as default };

package/dist/react/createStoreHook.d.ts

@@ -0,0 +1,44 @@
+import { GetterTuple, GetValueFn, GetValueFromBaseFn, MultiPathReturn, PathOf, PathOrFn, PathOrFnSetters, PathOrFnValues, PathSetters, PathSetter, PathValue, PathValues, SetFromBaseFn, SetStateFn, StoreApi, UseStoreGetterOptions, UseStoreMultiOptions, UseStoreOptions, UseStoreSetterOptions, UseStoreSyncMultiOptions, UseStoreSyncOptions } from '../types';
+export declare const createStoreHook: <TState extends object>() => {
+    useStore: {
+        (options?: UseStoreOptions<TState, TState>): [TState, StoreApi<TState>["setState"]];
+        <P extends PathOf<TState>>(path: P, options?: UseStoreOptions<PathValue<TState, P>, TState> & {
+            transformer?: never;
+        }): [PathValue<TState, P>, (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?: UseStoreOptions<PathValue<TState, P>, TState> & {
+            transformer?: never;
+        }): [PathValue<TState, P>, 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>, "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>, "transformer"> & {
+            transformer?: never;
+        }): [PathOrFnValues<TState, Entries>, ...PathOrFnSetters<TState, Entries>];
+        <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>];
+    };
+    useStoreSync: {
+        (path: undefined, value: TState | Partial<TState>, options?: UseStoreSyncOptions<TState, TState>): void;
+        <P extends PathOf<TState>>(path: P | ((state: TState) => P), value: PathValue<TState, P>, options?: UseStoreSyncOptions<PathValue<TState, P>, TState>): void;
+        <const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, values: PathValues<TState, Paths>, options?: UseStoreSyncMultiOptions<TState>): void;
+        (paths: ReadonlyArray<PathOrFn<TState>>, values: readonly unknown[], options?: UseStoreSyncMultiOptions<TState>): void;
+    };
+    useStoreGetter: {
+        (options?: UseStoreGetterOptions<TState>): GetValueFn<TState>;
+        <P extends PathOf<TState>>(basePath: P, options?: UseStoreGetterOptions<TState>): GetValueFromBaseFn<PathValue<TState, P>>;
+        <const Entries extends ReadonlyArray<PathOf<TState> | ((state: TState) => unknown)>>(entries: Entries, options?: UseStoreGetterOptions<TState>): GetterTuple<TState, Entries>;
+    };
+    useStoreSetter: {
+        (options?: UseStoreSetterOptions<TState>): SetStateFn<TState>;
+        <P extends PathOf<TState>>(basePath: P, options?: UseStoreSetterOptions<TState>): SetFromBaseFn<PathValue<TState, P>>;
+    };
+};
+export default createStoreHook;

package/dist/react/createStoreHook.mjs

@@ -0,0 +1,27 @@
+import e from "./hooks/useStoreSync.mjs";
+import t from "./hooks/useStore.mjs";
+import n from "./hooks/useStoreGetter.mjs";
+import r from "./hooks/useStoreSetter.mjs";
+//#region src/react/createStoreHook.ts
+var i = () => {
+	function i(e, n) {
+		return t(e, n);
+	}
+	function a(t, n, r) {
+		e(t, n, r);
+	}
+	function o(e, t) {
+		return n(e, t);
+	}
+	function s(e, t) {
+		return r(e, t);
+	}
+	return {
+		useStore: i,
+		useStoreSync: a,
+		useStoreGetter: o,
+		useStoreSetter: s
+	};
+};
+//#endregion
+export { i as createStoreHook, i as default };

package/dist/{createStore → react}/hooks/shared.mjs

@@ -1,7 +1,7 @@
 import e from "../../helpers/getByPath.mjs";
-import { StoreContext as t, StoreRegistryContext as n, findStoreInRegistry as r } from "../../StoreContext.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
+//#region src/react/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;

package/dist/{async → react}/hooks/useAsync.d.ts

@@ -1,2 +1,2 @@
-import { AsyncResource, AsyncSnapshot } from '../createAsync';
+import { AsyncResource, AsyncSnapshot } from '../../async/createAsync';
 export declare function useAsync<T, Args extends readonly unknown[]>(resource: AsyncResource<T, Args>): AsyncSnapshot<T>;

package/dist/{async → react}/hooks/useAsync.mjs

@@ -1,5 +1,5 @@
 import { useSyncExternalStore as e } from "react";
-//#region src/async/hooks/useAsync.ts
+//#region src/react/hooks/useAsync.ts
 function t(t) {
 	return e(t.subscribe, t.get, t.get);
 }

package/dist/{async → react}/hooks/useAsyncValue.d.ts

@@ -1,2 +1,2 @@
-import { AsyncResource } from '../createAsync';
+import { AsyncResource } from '../../async/createAsync';
 export declare function useAsyncValue<T, Args extends readonly unknown[]>(resource: AsyncResource<T, Args>): T;

package/dist/{async → react}/hooks/useAsyncValue.mjs

@@ -1,5 +1,5 @@
 import { useAsync as e } from "./useAsync.mjs";
-//#region src/async/hooks/useAsyncValue.ts
+//#region src/react/hooks/useAsyncValue.ts
 function t(t) {
 	let n = e(t);
 	if (n.status === "error") throw n.error;

package/dist/{derived → react}/hooks/useDerived.d.ts

@@ -1,2 +1,2 @@
-import { Derived } from '../createDerived';
+import { Derived } from '../../derived/createDerived';
 export declare function useDerived<R>(derived: Derived<R>): R;

package/dist/{derived → react}/hooks/useDerived.mjs

@@ -1,5 +1,5 @@
 import { useSyncExternalStore as e } from "react";
-//#region src/derived/hooks/useDerived.ts
+//#region src/react/hooks/useDerived.ts
 function t(t) {
 	return e(t.subscribe, t.get, t.get);
 }

package/dist/react/hooks/useEntity.d.ts

@@ -0,0 +1,10 @@
+import { EntityId } from '../../entities/createEntityAdapter';
+import { EntityStore } from '../../entities/createEntityStore';
+export declare function useEntityOne<T>(store: EntityStore<T>, id: EntityId): T | undefined;
+export declare function useEntityIds<T>(store: EntityStore<T>): string[];
+export declare function useEntityAll<T>(store: EntityStore<T>): T[];
+export declare function useEntity<T>(store: EntityStore<T>): {
+    useOne: (id: EntityId) => T | undefined;
+    useIds: () => string[];
+    useAll: () => T[];
+};

package/dist/react/hooks/useEntity.mjs

@@ -0,0 +1,23 @@
+import { useCallback as e, useSyncExternalStore as t } from "react";
+//#region src/react/hooks/useEntity.ts
+function n(n, r) {
+	let i = String(r), a = e((e) => n.subscribeOne(i, e), [n, i]), o = e(() => n.getOne(i), [n, i]);
+	return t(a, o, o);
+}
+function r(n) {
+	let r = e((e) => n.subscribeIds(e), [n]), i = e(() => n.getIds(), [n]);
+	return t(r, i, i);
+}
+function i(n) {
+	let r = e((e) => n.subscribeAll(e), [n]), i = e(() => n.getAll(), [n]);
+	return t(r, i, i);
+}
+function a(e) {
+	return {
+		useOne: (t) => n(e, t),
+		useIds: () => r(e),
+		useAll: () => i(e)
+	};
+}
+//#endregion
+export { a as useEntity, i as useEntityAll, r as useEntityIds, n as useEntityOne };

package/dist/{createStore → react}/hooks/useStore.mjs

@@ -1,7 +1,7 @@
 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
+//#region src/react/hooks/useStore.ts
 var f = [];
 function p(e, t, r) {
 	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);
@@ -46,4 +46,4 @@ function h(e, t = {}) {
 	return r ? a : i;
 }
 //#endregion
-export { h as default };
+export { h as default, e as defaultMultiEqualityFn };

package/dist/{createStore → react}/hooks/useStoreById.mjs

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

package/dist/{createStore → react}/hooks/useStoreGetter.mjs

@@ -1,7 +1,7 @@
 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
+//#region src/react/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), l = o?.map((e) => typeof e == "function" ? e.toString() : e).join("|");
 	return n(() => {

package/dist/react/hooks/useStoreHistory.mjs

@@ -0,0 +1,29 @@
+import { getStoreHistory as e } from "../../middleware/historyMiddleware.mjs";
+import { isProd as t } from "../../env.mjs";
+import { useResolvedStore as n } from "./shared.mjs";
+import { useEffect as r, useSyncExternalStore as i } from "react";
+//#region src/react/hooks/useStoreHistory.ts
+var a = {
+	entries: [],
+	index: -1,
+	canUndo: !1,
+	canRedo: !1
+}, o = () => {}, s = () => o, c = () => a, l = /* @__PURE__ */ new WeakSet(), u = (e) => {
+	t || l.has(e) || (l.add(e), console.warn("[nexus] useStoreHistory: this store has no history. Add `historyMiddleware()` to its middlewares to record an action log — until then the hook returns an empty, no-op view."));
+};
+function d() {
+	let t = n(void 0, "useStoreHistory"), a = e(t);
+	r(() => {
+		a || u(t);
+	}, [a, t]);
+	let l = a?.getSnapshot ?? c;
+	return {
+		...i(a?.subscribe ?? s, l, l),
+		undo: a?.undo ?? o,
+		redo: a?.redo ?? o,
+		travelTo: a?.travelTo ?? o,
+		clear: a?.clear ?? o
+	};
+}
+//#endregion
+export { d as useStoreHistory };

package/dist/{createStore → react}/hooks/useStoreSetter.mjs

@@ -1,6 +1,6 @@
 import { useResolvedStore as e } from "./shared.mjs";
 import { useMemo as t } from "react";
-//#region src/createStore/hooks/useStoreSetter.ts
+//#region src/react/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(() => i === void 0 ? o.setState : o.withBase(i).setState, [o, i]);

package/dist/{createStore → react}/hooks/useStoreSync.mjs

@@ -1,8 +1,8 @@
 import { useResolvedStore as e } from "./shared.mjs";
 import t from "../../helpers/shallowEqual.mjs";
-import n from "../../helpers/useIsomorphicLayoutEffect.mjs";
+import n from "../useIsomorphicLayoutEffect.mjs";
 import { useRef as r } from "react";
-//#region src/createStore/hooks/useStoreSync.ts
+//#region src/react/hooks/useStoreSync.ts
 function i(e, t, i, a) {
 	let { mode: o = "sync", enabled: s = !0, syncStrategy: c = "afterRender" } = a, l = t.map((e, t) => typeof e == "function" ? `fn_${t}` : e).join("|"), u = r(!1), d = !u.current;
 	u.current = !0;