@plitzi/nexus 0.32.1 → 0.32.3

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;

package/dist/react/index.d.ts

@@ -0,0 +1,17 @@
+export { default as StoreProvider, StoreContext, StoreRegistryContext } from './StoreProvider';
+export { findStoreInRegistry } from './StoreContext';
+export { createStoreHook } from './createStoreHook';
+export { default as useStore, defaultMultiEqualityFn } from './hooks/useStore';
+export { default as useStoreById } from './hooks/useStoreById';
+export { default as useStoreGetter } from './hooks/useStoreGetter';
+export { default as useStoreSetter } from './hooks/useStoreSetter';
+export { default as useStoreSync } from './hooks/useStoreSync';
+export { useAsync } from './hooks/useAsync';
+export { useAsyncValue } from './hooks/useAsyncValue';
+export { useDerived } from './hooks/useDerived';
+export { useStoreHistory } from './hooks/useStoreHistory';
+export { useEntity, useEntityOne, useEntityIds, useEntityAll } from './hooks/useEntity';
+export { default as useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';
+export type { StoreProviderProps } from './StoreProvider';
+export type { StoreRegistry } from './StoreContext';
+export type { UseStoreHistoryReturn } from './hooks/useStoreHistory';

package/dist/react/index.mjs

@@ -0,0 +1,16 @@
+import { StoreContext as e, StoreRegistryContext as t, findStoreInRegistry as n } from "./StoreContext.mjs";
+import { defaultMultiEqualityFn as r } from "./hooks/shared.mjs";
+import i from "./useIsomorphicLayoutEffect.mjs";
+import a from "./hooks/useStoreSync.mjs";
+import o from "./StoreProvider.mjs";
+import s from "./hooks/useStore.mjs";
+import c from "./hooks/useStoreGetter.mjs";
+import l from "./hooks/useStoreSetter.mjs";
+import { createStoreHook as u } from "./createStoreHook.mjs";
+import d from "./hooks/useStoreById.mjs";
+import { useAsync as f } from "./hooks/useAsync.mjs";
+import { useAsyncValue as p } from "./hooks/useAsyncValue.mjs";
+import { useDerived as m } from "./hooks/useDerived.mjs";
+import { useStoreHistory as h } from "./hooks/useStoreHistory.mjs";
+import { useEntity as g, useEntityAll as _, useEntityIds as v, useEntityOne as y } from "./hooks/useEntity.mjs";
+export { e as StoreContext, o as StoreProvider, t as StoreRegistryContext, u as createStoreHook, r as defaultMultiEqualityFn, n as findStoreInRegistry, f as useAsync, p as useAsyncValue, m as useDerived, g as useEntity, _ as useEntityAll, v as useEntityIds, y as useEntityOne, i as useIsomorphicLayoutEffect, s as useStore, d as useStoreById, c as useStoreGetter, h as useStoreHistory, l as useStoreSetter, a as useStoreSync };

package/dist/{helpers → react}/useIsomorphicLayoutEffect.mjs

@@ -1,5 +1,5 @@
 import { useEffect as e, useLayoutEffect as t } from "react";
-//#region src/helpers/useIsomorphicLayoutEffect.ts
+//#region src/react/useIsomorphicLayoutEffect.ts
 var n = typeof window < "u" ? t : e;
 //#endregion
 export { n as default };

package/dist/types/StoreTypes.d.ts

@@ -27,6 +27,8 @@ export type StoreChange<T> = {
     path: PathOf<T> | undefined;
     prev: T;
     next: T;
+    prevValue: unknown;
+    nextValue: unknown;
 };
 export type ChangeListener<T> = (change: StoreChange<T>) => void;
 export declare const CANCEL: unique symbol;
@@ -86,6 +88,7 @@ export type BoundStore<TBase> = {
 };
 export type StoreApi<T> = {
     id?: string;
+    scopePath?: string;
     getState: GetState<T>;
     getPath: <P extends PathOf<T>>(path: P) => PathValue<T, P> | undefined;
     setState: SetState<T>;

package/dist/vue/index.d.ts

@@ -0,0 +1,8 @@
+export { provideStore, injectStore } from './injection';
+export { useStore, useStoreValue, createStoreComposable } from './useStore';
+export { useEntity, useEntityOne, useEntityIds, useEntityAll } from './useEntity';
+export { useDerived } from './useDerived';
+export { useAsync } from './useAsync';
+export { useStoreHistory } from './useStoreHistory';
+export type { UseStoreOptions } from './useStore';
+export type { UseStoreHistoryReturn } from './useStoreHistory';

package/dist/vue/index.mjs

@@ -0,0 +1,7 @@
+import { injectStore as e, provideStore as t } from "./injection.mjs";
+import { createStoreComposable as n, useStore as r, useStoreValue as i } from "./useStore.mjs";
+import { useEntity as a, useEntityAll as o, useEntityIds as s, useEntityOne as c } from "./useEntity.mjs";
+import { useDerived as l } from "./useDerived.mjs";
+import { useAsync as u } from "./useAsync.mjs";
+import { useStoreHistory as d } from "./useStoreHistory.mjs";
+export { n as createStoreComposable, e as injectStore, t as provideStore, u as useAsync, l as useDerived, a as useEntity, o as useEntityAll, s as useEntityIds, c as useEntityOne, r as useStore, d as useStoreHistory, i as useStoreValue };

package/dist/vue/injection.d.ts

@@ -0,0 +1,3 @@
+import { StoreApi } from '../types';
+export declare function provideStore<TState extends object>(store: StoreApi<TState>): void;
+export declare function injectStore<TState extends object>(): StoreApi<TState>;

package/dist/vue/injection.mjs

@@ -0,0 +1,13 @@
+import { inject as e, provide as t } from "vue";
+//#region src/vue/injection.ts
+var n = Symbol("@plitzi/nexus/vue/store");
+function r(e) {
+	t(n, e);
+}
+function i() {
+	let t = e(n);
+	if (!t) throw Error("@plitzi/nexus/vue: no store provided. Call provideStore(store) in a parent component, or pass { store } to the composable.");
+	return t;
+}
+//#endregion
+export { i as injectStore, r as provideStore };

package/dist/vue/useAsync.d.ts

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

package/dist/vue/useAsync.mjs

@@ -0,0 +1,10 @@
+import { onScopeDispose as e, shallowRef as t } from "vue";
+//#region src/vue/useAsync.ts
+function n(n) {
+	let r = t(n.get());
+	return e(n.subscribe(() => {
+		r.value = n.get();
+	})), r;
+}
+//#endregion
+export { n as useAsync };

package/dist/vue/useDerived.d.ts

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

package/dist/vue/useDerived.mjs

@@ -0,0 +1,10 @@
+import { onScopeDispose as e, shallowRef as t } from "vue";
+//#region src/vue/useDerived.ts
+function n(n) {
+	let r = t(n.get());
+	return e(n.subscribe(() => {
+		r.value = n.get();
+	})), r;
+}
+//#endregion
+export { n as useDerived };

package/dist/vue/useEntity.d.ts

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

package/dist/vue/useEntity.mjs

@@ -0,0 +1,29 @@
+import { onScopeDispose as e, shallowRef as t } from "vue";
+//#region src/vue/useEntity.ts
+function n(n, r) {
+	let i = String(r), a = t(n.getOne(i));
+	return e(n.subscribeOne(i, () => {
+		a.value = n.getOne(i);
+	})), a;
+}
+function r(n) {
+	let r = t(n.getIds());
+	return e(n.subscribeIds(() => {
+		r.value = n.getIds();
+	})), r;
+}
+function i(n) {
+	let r = t(n.getAll());
+	return e(n.subscribeAll(() => {
+		r.value = n.getAll();
+	})), r;
+}
+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 };