@plitzi/nexus 0.31.1

package/dist/createStore/hooks/useStoreSync.mjs

@@ -0,0 +1,55 @@
+import { useResolvedStore as e } from "./shared.mjs";
+import t from "../../helpers/shallowEqual.mjs";
+import n from "../../helpers/useIsomorphicLayoutEffect.mjs";
+import { useRef as r } from "react";
+//#region src/createStore/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;
+	let f = r(void 0), p = s && (d || o === "sync" && i.some((e, t) => !Object.is(f.current?.[t], e))), m = () => {
+		f.current = i, e.batch(() => {
+			t.forEach((t, n) => {
+				let r = typeof t == "function" ? t(e.getState()) : t;
+				e.setState(r, i[n]);
+			});
+		});
+	};
+	c === "render" ? p && m() : (p && d && m(), n(() => {
+		p && !d && m();
+	}, [
+		p,
+		i,
+		l
+	]));
+}
+function a(e, i, a, o) {
+	let s = i === void 0, c = typeof i == "function", l = s ? t : Object.is, { mode: u = "sync", enabled: d = !0, equalityFn: f = l, syncStrategy: p = "afterRender" } = o, m = r(void 0), h = r(!1), g = !h.current;
+	h.current = !0;
+	let _ = m.current, v = d && (g || u === "sync" && (_ === void 0 || !f(_, a))), y = (t = !0) => {
+		if (m.current = a, s) e.setState(void 0, (e) => ({
+			...e,
+			...a
+		}), t);
+		else if (c) {
+			let n = i(e.getState());
+			e.setState(n, a, t);
+		} else e.setState(i, a, t);
+	};
+	p === "render" ? v && y() : (v && g && y(!1), n(() => {
+		v && !g && y();
+	}, [
+		v,
+		a,
+		i
+	]));
+}
+function o(t, n, r = {}) {
+	let o = r, s = e(o.store, "useStoreSync", o.storeId);
+	if (Array.isArray(t)) {
+		i(s, t, n, r);
+		return;
+	}
+	a(s, t, n, r);
+}
+//#endregion
+export { o as default };

package/dist/createStore/index.d.ts

@@ -0,0 +1,3 @@
+import { default as createStore } from './createStore';
+export * from './createStore';
+export default createStore;

package/dist/createStore/index.mjs

@@ -0,0 +1,5 @@
+import e, { createStoreHook as t } from "./createStore.mjs";
+//#region src/createStore/index.ts
+var n = e;
+//#endregion
+export { t as createStoreHook, n as default };

package/dist/derived/createDerived.d.ts

@@ -0,0 +1,10 @@
+import { PathOf, PathValues, StoreApi } from '../types';
+export type Derived<R> = {
+    get: () => R;
+    subscribe: (listener: () => void) => () => void;
+    destroy: () => void;
+};
+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>;

package/dist/derived/createDerived.mjs

@@ -0,0 +1,21 @@
+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();
+			return;
+		}
+		let e = o.get();
+		o.invalidate(), a(e, o.get()) || o.notify();
+	}, c = n.map((e) => t.subscribePath(e, s));
+	return {
+		get: o.get,
+		subscribe: (e) => (o.get(), o.subscribe(e)),
+		destroy: () => {
+			c.forEach((e) => e()), o.destroy();
+		}
+	};
+}
+//#endregion
+export { t as createDerived };

package/dist/derived/hooks/useDerived.d.ts

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

package/dist/derived/hooks/useDerived.mjs

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

package/dist/derived/index.d.ts

@@ -0,0 +1,3 @@
+export { createDerived } from './createDerived';
+export { useDerived } from './hooks/useDerived';
+export type { Derived, DerivedOptions } from './createDerived';

package/dist/derived/index.mjs

@@ -0,0 +1,3 @@
+import { createDerived as e } from "./createDerived.mjs";
+import { useDerived as t } from "./hooks/useDerived.mjs";
+export { e as createDerived, t as useDerived };

package/dist/entities/createEntityAdapter.d.ts

@@ -0,0 +1,32 @@
+export type EntityId = string | number;
+export type EntityMap<T> = Record<string, T>;
+export type EntityUpdate<T> = {
+    id: EntityId;
+    changes: Partial<T>;
+};
+export type EntityUpdater<T> = (map: EntityMap<T>) => EntityMap<T>;
+export type EntityAdapter<T> = {
+    getInitialState: () => EntityMap<T>;
+    selectId: (entity: T) => EntityId;
+    addOne: (entity: T) => EntityUpdater<T>;
+    addMany: (entities: readonly T[]) => EntityUpdater<T>;
+    setOne: (entity: T) => EntityUpdater<T>;
+    setMany: (entities: readonly T[]) => EntityUpdater<T>;
+    setAll: (entities: readonly T[]) => EntityUpdater<T>;
+    updateOne: (update: EntityUpdate<T>) => EntityUpdater<T>;
+    updateMany: (updates: readonly EntityUpdate<T>[]) => EntityUpdater<T>;
+    upsertOne: (entity: T) => EntityUpdater<T>;
+    upsertMany: (entities: readonly T[]) => EntityUpdater<T>;
+    removeOne: (id: EntityId) => EntityUpdater<T>;
+    removeMany: (ids: readonly EntityId[]) => EntityUpdater<T>;
+    removeAll: () => EntityUpdater<T>;
+    selectIds: (map: EntityMap<T>) => string[];
+    selectAll: (map: EntityMap<T>) => T[];
+    selectById: (map: EntityMap<T>, id: EntityId) => T | undefined;
+    selectTotal: (map: EntityMap<T>) => number;
+};
+export type EntityAdapterOptions<T> = {
+    selectId?: (entity: T) => EntityId;
+    sortComparer?: (a: T, b: T) => number;
+};
+export declare function createEntityAdapter<T>(options?: EntityAdapterOptions<T>): EntityAdapter<T>;

package/dist/entities/createEntityAdapter.mjs

@@ -0,0 +1,73 @@
+//#region src/entities/createEntityAdapter.ts
+function e(e = {}) {
+	let t = e.selectId ?? ((e) => e.id), n = e.sortComparer, r = (e) => String(t(e)), i = (e, t) => (n) => {
+		if (e.length === 0) return n;
+		let i = { ...n }, a = !1;
+		for (let n of e) {
+			let e = r(n);
+			t && e in i || (i[e] = n, a = !0);
+		}
+		return a ? i : n;
+	}, a = (e) => (t) => {
+		let n = t;
+		for (let { id: r, changes: i } of e) {
+			let e = String(r), a = n[e];
+			a && (n === t && (n = { ...t }), n[e] = {
+				...a,
+				...i
+			});
+		}
+		return n;
+	}, o = (e) => {
+		let t = Object.values(e);
+		return n ? t.sort(n) : t;
+	};
+	return {
+		getInitialState: () => ({}),
+		selectId: t,
+		addOne: (e) => i([e], !0),
+		addMany: (e) => i(e, !0),
+		setOne: (e) => i([e], !1),
+		setMany: (e) => i(e, !1),
+		setAll: (e) => () => i(e, !1)({}),
+		updateOne: (e) => a([e]),
+		updateMany: (e) => a(e),
+		upsertOne: (e) => (t) => {
+			let n = r(e), i = t[n];
+			return {
+				...t,
+				[n]: i ? {
+					...i,
+					...e
+				} : e
+			};
+		},
+		upsertMany: (e) => (t) => {
+			if (e.length === 0) return t;
+			let n = { ...t };
+			for (let t of e) {
+				let e = r(t);
+				n[e] = n[e] ? {
+					...n[e],
+					...t
+				} : t;
+			}
+			return n;
+		},
+		removeOne: (e) => (t) => {
+			let n = String(e);
+			return n in t ? Object.fromEntries(Object.entries(t).filter(([e]) => e !== n)) : t;
+		},
+		removeMany: (e) => (t) => {
+			let n = new Set(e.map(String));
+			return Object.keys(t).some((e) => n.has(e)) ? Object.fromEntries(Object.entries(t).filter(([e]) => !n.has(e))) : t;
+		},
+		removeAll: () => () => ({}),
+		selectIds: (e) => n ? o(e).map(r) : Object.keys(e),
+		selectAll: o,
+		selectById: (e, t) => e[String(t)],
+		selectTotal: (e) => Object.keys(e).length
+	};
+}
+//#endregion
+export { e as createEntityAdapter };

package/dist/entities/index.d.ts

@@ -0,0 +1,2 @@
+export { createEntityAdapter } from './createEntityAdapter';
+export type { EntityAdapter, EntityAdapterOptions, EntityId, EntityMap, EntityUpdate, EntityUpdater } from './createEntityAdapter';

package/dist/entities/index.mjs

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

package/dist/helpers/createObservable.d.ts

@@ -0,0 +1,9 @@
+export type Observable<T> = {
+    get: () => T;
+    invalidate: () => void;
+    notify: () => void;
+    subscribe: (listener: () => void) => () => void;
+    hasListeners: () => boolean;
+    destroy: () => void;
+};
+export declare function createObservable<T>(compute: () => T): Observable<T>;

package/dist/helpers/createObservable.mjs

@@ -0,0 +1,18 @@
+//#region src/helpers/createObservable.ts
+function e(e) {
+	let t = /* @__PURE__ */ new Set(), n, r = !0;
+	return {
+		get: () => (r &&= (n = e(), !1), n),
+		invalidate: () => {
+			r = !0;
+		},
+		notify: () => {
+			t.forEach((e) => e());
+		},
+		subscribe: (e) => (t.add(e), () => t.delete(e)),
+		hasListeners: () => t.size > 0,
+		destroy: () => t.clear()
+	};
+}
+//#endregion
+export { e as createObservable };

package/dist/helpers/getByPath.d.ts

@@ -0,0 +1,4 @@
+import { PathOf, PathValue } from '../types';
+declare function getByPath<TState, P extends '' | undefined | []>(obj: TState, path: P): TState | undefined;
+declare function getByPath<TState, P extends PathOf<TState> | PathOf<TState>[]>(obj: TState, path: P): PathValue<TState, P> | undefined;
+export default getByPath;

package/dist/helpers/getByPath.mjs

@@ -0,0 +1,40 @@
+import e from "./parsePath.mjs";
+//#region src/helpers/getByPath.ts
+var t = /* @__PURE__ */ new Map(), n = 512, r = (e) => {
+	if (e.length === 1) {
+		let t = e[0];
+		return (e) => typeof e == "object" && e && t in e ? e[t] : void 0;
+	}
+	return (t) => {
+		let n = t;
+		for (let t = 0; t < e.length; t++) {
+			if (typeof n != "object" || !n) return;
+			n = n[e[t]];
+		}
+		return n;
+	};
+}, i = (i) => {
+	let a = t.get(i);
+	if (!a) {
+		if (a = r(e(i)), t.size >= n) {
+			let e = t.keys().next().value;
+			t.delete(e);
+		}
+		t.set(i, a);
+	}
+	return a;
+};
+function a(e, t) {
+	let n = Array.isArray(t);
+	if (typeof t != "string" && !n || n && !t.length || typeof t == "string" && !t) return e;
+	if (typeof t == "string" && t.indexOf(".") === -1) return typeof e == "object" && e && t in e ? e[t] : void 0;
+	if (typeof t == "string") return i(t)(e);
+	let r = e;
+	for (let e of t) {
+		if (typeof r != "object" || !r || !(e in r)) return;
+		r = r[e];
+	}
+	return r;
+}
+//#endregion
+export { a as default };

package/dist/helpers/isPathAffected.d.ts

@@ -0,0 +1,3 @@
+import { Path } from '../types';
+declare const isPathAffected: (changed: Path | undefined, candidate: Path) => boolean;
+export default isPathAffected;

package/dist/helpers/isPathAffected.mjs

@@ -0,0 +1,4 @@
+//#region src/helpers/isPathAffected.ts
+var e = (e, t) => typeof e != "string" || e === t || e.length > t.length && e.startsWith(t) && e[t.length] === "." || t.length > e.length && t.startsWith(e) && t[e.length] === ".";
+//#endregion
+export { e as default };

package/dist/helpers/parsePath.d.ts

@@ -0,0 +1,2 @@
+declare const parsePath: (path: string) => string[];
+export default parsePath;

package/dist/helpers/parsePath.mjs

@@ -0,0 +1,7 @@
+//#region src/helpers/parsePath.ts
+var e = /* @__PURE__ */ new Map(), t = 512, n = (n) => {
+	let r = e.get(n);
+	return r === void 0 && (r = n.split("."), e.size >= t && e.delete(e.keys().next().value), e.set(n, r)), r;
+};
+//#endregion
+export { n as default };

package/dist/helpers/setByPath.d.ts

@@ -0,0 +1,3 @@
+type AnyObject = Record<string | number, any>;
+declare const setByPath: <T extends AnyObject>(obj: T, path: string | (string | number)[], value: any) => T;
+export default setByPath;

package/dist/helpers/setByPath.mjs

@@ -0,0 +1,19 @@
+import e from "./parsePath.mjs";
+//#region src/helpers/setByPath.ts
+var t = (e) => typeof e == "number" ? e : e !== "" && !isNaN(Number(e)) ? Number(e) : e, n = (e) => Array.isArray(e) ? e.slice() : { ...e }, r = (e, i, a, o) => {
+	let s = t(i[a]), c = n(e);
+	return c[s] = a === i.length - 1 ? o : r(e[s] ?? {}, i, a + 1, o), c;
+}, i = (i, a, o) => {
+	if (typeof a == "string") {
+		if (!a) return o;
+		let s = e(a);
+		if (s.length === 1) {
+			let e = n(i);
+			return e[t(s[0])] = o, e;
+		}
+		return r(i, s, 0, o);
+	}
+	return !Array.isArray(a) || !a.length ? o : r(i, a, 0, o);
+};
+//#endregion
+export { i as default };

package/dist/helpers/shallowEqual.d.ts

@@ -0,0 +1,2 @@
+declare const shallowEqual: (a: unknown, b: unknown) => boolean;
+export default shallowEqual;

package/dist/helpers/shallowEqual.mjs

@@ -0,0 +1,11 @@
+//#region src/helpers/shallowEqual.ts
+var e = (e, t) => {
+	if (Object.is(e, t)) return !0;
+	if (typeof e != "object" || !e || typeof t != "object" || !t) return !1;
+	let n = Object.keys(e), r = Object.keys(t);
+	if (n.length !== r.length) return !1;
+	for (let r of n) if (!Object.is(e[r], t[r])) return !1;
+	return !0;
+};
+//#endregion
+export { e as default };

package/dist/helpers/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,3 @@
+import { useLayoutEffect } from 'react';
+declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;
+export default useIsomorphicLayoutEffect;

package/dist/helpers/useIsomorphicLayoutEffect.mjs

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

package/dist/history/hooks/useStoreHistory.d.ts

@@ -0,0 +1,8 @@
+import { HistorySnapshot } from '../../middleware/historyMiddleware';
+export type UseStoreHistoryReturn<TState> = HistorySnapshot<TState> & {
+    undo: () => void;
+    redo: () => void;
+    travelTo: (index: number) => void;
+    clear: () => void;
+};
+export declare function useStoreHistory<TState extends object>(): UseStoreHistoryReturn<TState>;

package/dist/history/hooks/useStoreHistory.mjs

@@ -0,0 +1,24 @@
+import { useResolvedStore as e } from "../../createStore/hooks/shared.mjs";
+import { getStoreHistory as t } from "../../middleware/historyMiddleware.mjs";
+import { useEffect as n, useSyncExternalStore as r } from "react";
+//#region src/history/hooks/useStoreHistory.ts
+var i = {
+	entries: [],
+	index: -1,
+	canUndo: !1,
+	canRedo: !1
+}, a = () => {}, o = () => a, s = () => i;
+function c() {
+	let i = e(void 0, "useStoreHistory"), c = t(i);
+	n(() => {}, [c, i]);
+	let l = c?.getSnapshot ?? s;
+	return {
+		...r(c?.subscribe ?? o, l, l),
+		undo: c?.undo ?? a,
+		redo: c?.redo ?? a,
+		travelTo: c?.travelTo ?? a,
+		clear: c?.clear ?? a
+	};
+}
+//#endregion
+export { c as useStoreHistory };

package/dist/history/index.d.ts

@@ -0,0 +1,4 @@
+export { getStoreHistory } from '../middleware/historyMiddleware';
+export { useStoreHistory } from './hooks/useStoreHistory';
+export type { HistoryEntry, HistorySnapshot, StoreHistory, StoreHistoryOptions } from '../middleware/historyMiddleware';
+export type { UseStoreHistoryReturn } from './hooks/useStoreHistory';

package/dist/history/index.mjs

@@ -0,0 +1,3 @@
+import { getStoreHistory as e } from "../middleware/historyMiddleware.mjs";
+import { useStoreHistory as t } from "./hooks/useStoreHistory.mjs";
+export { e as getStoreHistory, t as useStoreHistory };

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+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 { setCodegenEnabled } from './createStore/helpers/writeByPath';

package/dist/index.mjs

@@ -0,0 +1,21 @@
+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 _ from "./StoreProvider.mjs";
+import { loggerMiddleware as v } from "./middleware/loggerMiddleware.mjs";
+import { persistMiddleware as y } from "./middleware/persistMiddleware.mjs";
+import { reduxDevToolsMiddleware as b } from "./middleware/reduxDevToolsMiddleware.mjs";
+import { cascade as x } from "./middleware/cascade.mjs";
+export { i as CANCEL, a as StoreContext, _ as StoreProvider, o as StoreRegistryContext, x as cascade, e as createAsync, u as createDerived, f as createEntityAdapter, l as createStore, c as createStoreHook, p as getStoreHistory, m as historyMiddleware, v as loggerMiddleware, y as persistMiddleware, b as reduxDevToolsMiddleware, r as setCodegenEnabled, t as useAsync, n as useAsyncValue, d as useDerived, g as useStoreById, h as useStoreHistory, s as useStoreSetter };

package/dist/middleware/cascade.d.ts

@@ -0,0 +1,2 @@
+import { StoreMiddleware } from '../types';
+export declare const cascade: <T extends object>(middleware: StoreMiddleware<T>) => StoreMiddleware<T>;

package/dist/middleware/cascade.mjs

@@ -0,0 +1,4 @@
+//#region src/middleware/cascade.ts
+var e = (e) => Object.assign(e, { cascade: !0 });
+//#endregion
+export { e as cascade };

package/dist/middleware/historyMiddleware.d.ts

@@ -0,0 +1,28 @@
+import { Path, StoreApi, StoreMiddleware } from '../types';
+export type HistoryEntry<TState> = {
+    path?: Path;
+    value?: unknown;
+    state: TState;
+    timestamp: number;
+};
+export type HistorySnapshot<TState> = {
+    entries: ReadonlyArray<HistoryEntry<TState>>;
+    index: number;
+    canUndo: boolean;
+    canRedo: boolean;
+};
+export type StoreHistory<TState> = {
+    getSnapshot: () => HistorySnapshot<TState>;
+    subscribe: (listener: () => void) => () => void;
+    undo: () => void;
+    redo: () => void;
+    travelTo: (index: number) => void;
+    clear: () => void;
+};
+export type StoreHistoryOptions = {
+    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>;

package/dist/middleware/historyMiddleware.mjs

@@ -0,0 +1,81 @@
+import { isPlainObject as e } from "../createStore/helpers/deepMerge.mjs";
+import t from "../helpers/getByPath.mjs";
+import n 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 {
+			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 = r(t[e], n[e], i - 1);
+			if (a) return {
+				path: a.path ? `${e}.${a.path}` : e,
+				value: a.value
+			};
+		}
+	}
+};
+function i(e, i = {}) {
+	let a = i.limit ?? 100, o = i.path, s = i.shouldRecord, c = [{
+		state: e.getState(),
+		timestamp: Date.now()
+	}], l = 0, u = !1, d = () => ({
+		entries: c,
+		index: l,
+		canUndo: l > 0,
+		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;
+		if (_) try {
+			let e = r(t(f, _), t(p, _));
+			e && (h = e.path ? `${_}.${e.path}` : _, g = e.value);
+		} catch {}
+		let v = [...d, {
+			path: h,
+			value: g,
+			state: p,
+			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;
+		if (u = !0, o) {
+			let n = t(r, o);
+			e.setState(o, () => n);
+		} else e.setState(void 0, () => r);
+		u = !1, l = n, m();
+	};
+	return {
+		handle: {
+			getSnapshot: () => f,
+			subscribe: (e) => (p.add(e), () => p.delete(e)),
+			undo: () => g(l - 1),
+			redo: () => g(l + 1),
+			travelTo: g,
+			clear: () => {
+				c = [{
+					state: e.getState(),
+					timestamp: Date.now()
+				}], l = 0, m();
+			}
+		},
+		record: h
+	};
+}
+var a = /* @__PURE__ */ new WeakMap();
+function o(e) {
+	return a.get(e);
+}
+var s = (e) => (t) => {
+	let { handle: n, record: r } = i(t, e);
+	return a.set(t, n), { onChange: r };
+};
+//#endregion
+export { o as getStoreHistory, s as historyMiddleware };

package/dist/middleware/index.d.ts

@@ -0,0 +1,8 @@
+export { loggerMiddleware } from './loggerMiddleware';
+export { persistMiddleware } from './persistMiddleware';
+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 { ReduxDevToolsOptions } from './reduxDevToolsMiddleware';

package/dist/middleware/index.mjs

@@ -0,0 +1,6 @@
+import { historyMiddleware as e } from "./historyMiddleware.mjs";
+import { loggerMiddleware as t } from "./loggerMiddleware.mjs";
+import { persistMiddleware as n } from "./persistMiddleware.mjs";
+import { reduxDevToolsMiddleware as r } from "./reduxDevToolsMiddleware.mjs";
+import { cascade as i } from "./cascade.mjs";
+export { i as cascade, e as historyMiddleware, t as loggerMiddleware, n as persistMiddleware, r as reduxDevToolsMiddleware };

package/dist/middleware/loggerMiddleware.d.ts

@@ -0,0 +1,7 @@
+import { StoreChange, StoreError, StoreMiddleware } from '../types';
+export type LoggerOptions<TState extends object> = {
+    filter?: (change: StoreChange<TState>) => boolean;
+    sink?: (change: StoreChange<TState>) => void;
+    errorSink?: (failure: StoreError<TState>) => void;
+};
+export declare const loggerMiddleware: <TState extends object>(options?: LoggerOptions<TState> | ((change: StoreChange<TState>) => void)) => StoreMiddleware<TState>;

package/dist/middleware/loggerMiddleware.mjs

@@ -0,0 +1,20 @@
+//#region src/middleware/loggerMiddleware.ts
+var e = (e) => {
+	console.log("[store]", e.path ?? "(root)", e.next);
+}, t = (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
+	});
+};
+//#endregion
+export { n as loggerMiddleware };