@plitzi/nexus 0.31.1

package/dist/middleware/persistMiddleware.d.ts

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

package/dist/middleware/persistMiddleware.mjs

@@ -0,0 +1,36 @@
+//#region src/middleware/persistMiddleware.ts
+var e = {
+	getItem: () => null,
+	setItem: () => {},
+	removeItem: () => {}
+}, t = () => typeof localStorage < "u" ? localStorage : e, n = (e) => {
+	let { key: n, storage: i = t(), partialize: a, version: o = 0, migrate: s, merge: c, debounce: l = 0 } = e, u = (e) => {
+		let t = e.getState(), r = {
+			version: o,
+			state: a ? a(t) : t
+		};
+		i.setItem(n, JSON.stringify(r));
+	};
+	return (e) => {
+		r(e, n, i, o, s, c);
+		let t;
+		return { onChange: () => {
+			if (l <= 0) {
+				u(e);
+				return;
+			}
+			clearTimeout(t), t = setTimeout(() => u(e), l);
+		} };
+	};
+};
+function r(e, t, n, r, i, a) {
+	let o = n.getItem(t);
+	if (o) try {
+		let t = JSON.parse(o), n = t.version !== r && i ? i(t.state, t.version) : t.state;
+		e.setState(void 0, a ? a(n, e.getState()) : n);
+	} catch {
+		n.removeItem(t);
+	}
+}
+//#endregion
+export { n as persistMiddleware };

package/dist/middleware/reduxDevToolsMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { StoreChange, StoreMiddleware } from '../types';
+export type ReduxDevToolsOptions<TState extends object> = {
+    name?: string;
+    action?: (change: StoreChange<TState>) => string;
+};
+export declare const reduxDevToolsMiddleware: <TState extends object>(options?: ReduxDevToolsOptions<TState>) => StoreMiddleware<TState>;

package/dist/middleware/reduxDevToolsMiddleware.mjs

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

package/dist/types/StoreTypes.d.ts

@@ -0,0 +1,143 @@
+import { default as PathTrie } from '../createStore/helpers/PathTrie';
+import { default as Subscribers } from '../createStore/helpers/Subscribers';
+export type Path = string;
+export type Primitive = string | number | boolean | null | undefined | symbol | bigint;
+export type PathOf<T, Seen = never> = T extends Primitive ? never : T extends Seen ? never : {
+    [K in keyof T & string]-?: T[K] extends Primitive ? K : T[K] extends Array<infer U> ? K | `${K}.${number}` | `${K}.${number}.${PathOf<U, Seen | T>}` : K | `${K}.${PathOf<T[K], Seen | T>}`;
+}[keyof T & string];
+export type PathValue<T, P> = T extends undefined ? undefined : P extends `${infer K}.${infer Rest}` ? K extends keyof NonNullable<T> ? NonNullable<T>[K] extends Array<infer U> ? Rest extends `${number}.${infer R}` ? PathValue<U, R> : Rest extends `${number}` ? U : never : PathValue<NonNullable<T>[K], Rest> : never : P extends keyof NonNullable<T> ? NonNullable<T>[P] : never;
+export type PathSetter<TState extends object, P extends PathOf<TState>> = (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void;
+export type __NoDefault = {
+    __noDefault: true;
+};
+type NumericIndex<I> = I extends `${infer N extends number}` ? N : I extends number ? I : never;
+export type PathValues<TState extends object, Paths extends ReadonlyArray<PathOf<TState>>, DefaultValue = __NoDefault> = {
+    [I in keyof Paths]: Paths[I] extends PathOf<TState> ? [DefaultValue] extends [__NoDefault] ? PathValue<TState, Paths[I]> : DefaultValue extends readonly any[] ? NumericIndex<I> extends infer NI ? NI extends keyof DefaultValue ? DefaultValue[NI] extends undefined ? PathValue<TState, Paths[I]> | undefined : NonNullable<PathValue<TState, Paths[I]>> | DefaultValue[NI] : PathValue<TState, Paths[I]> : never : NonNullable<PathValue<TState, Paths[I]>> | DefaultValue : never;
+};
+export type PathSetters<TState extends object, Paths extends ReadonlyArray<PathOf<TState>>> = {
+    [I in keyof Paths]: Paths[I] extends PathOf<TState> ? PathSetter<TState, Paths[I]> : never;
+};
+export type SyncMode = 'mount' | 'sync';
+export type StoreHookBaseOptions<TState extends object = object> = {
+    store?: StoreApi<TState>;
+    storeId?: string;
+};
+export type StoreHookReactiveOptions<T, TState extends object = object> = StoreHookBaseOptions<TState> & {
+    mode?: SyncMode;
+    enabled?: boolean;
+    equalityFn?: (a: T, b: T) => boolean;
+};
+export type StoreChange<T> = {
+    path: PathOf<T> | undefined;
+    prev: T;
+    next: T;
+};
+export type ChangeListener<T> = (change: StoreChange<T>) => void;
+export declare const CANCEL: unique symbol;
+export type WriteContext<T> = {
+    path: PathOf<T> | undefined;
+    value: unknown;
+    prev: unknown;
+};
+export type WriteInterceptor<T> = (context: WriteContext<T>) => unknown;
+export type StoreError<T> = {
+    error: unknown;
+    phase: 'beforeChange' | 'onChange' | 'notify';
+    path: PathOf<T> | undefined;
+};
+export type StoreErrorHandler<T> = (failure: StoreError<T>) => void;
+export type StoreErrorReporter<T> = (error: unknown, phase: StoreError<T>['phase'], path: PathOf<T> | undefined) => void;
+export type StoreMiddlewareHandlers<T> = {
+    beforeChange?: WriteInterceptor<T>;
+    onChange?: ChangeListener<T>;
+    onError?: StoreErrorHandler<T>;
+};
+export type StoreMiddleware<T extends object> = (api: StoreApi<T>) => StoreMiddlewareHandlers<T> | void;
+export type Listener = (changedPath?: Path) => void;
+export type SetState<T> = {
+    (path: undefined, value: T | ((prev: T) => T), canPropagate?: boolean): void;
+    <P extends PathOf<T>>(path: P, value: PathValue<T, P> | ((prev: PathValue<T, P>) => PathValue<T, P>), canPropagate?: boolean): void;
+};
+export type GetState<T> = () => T;
+export type StoreApi<T> = {
+    id?: string;
+    getState: GetState<T>;
+    getPath: <P extends PathOf<T>>(path: P) => PathValue<T, P> | undefined;
+    setState: SetState<T>;
+    batch: <R>(fn: () => R) => R;
+    subscribe: (listener: Listener) => () => void;
+    subscribePath: <P extends PathOf<T>>(path: P, listener: Listener) => () => void;
+    subscribeChange: (listener: ChangeListener<T>) => () => void;
+    destroy?: () => void;
+    reconnect?: () => void;
+    subscribeInvalidate?: (listener: () => void) => () => void;
+};
+export type StoreApiInternal<T> = StoreApi<T> & {
+    listeners: Subscribers<Listener>;
+    pathListeners: PathTrie;
+    changeListeners: Subscribers<ChangeListener<T>>;
+    interceptors: WriteInterceptor<T>[];
+    errorHandlers: StoreErrorHandler<T>[];
+    getMergeCount?: () => number;
+};
+export type PathOrFn<TState extends object> = PathOf<TState> | ((state: TState) => PathOf<TState>);
+export type PathOrFnValue<TState extends object, Entry> = Entry extends PathOf<TState> ? PathValue<TState, Entry> : Entry extends (state: TState) => infer P ? P extends PathOf<TState> ? PathValue<TState, P> : unknown : unknown;
+export type PathOrFnValues<TState extends object, Entries extends ReadonlyArray<PathOrFn<TState>>> = {
+    [I in keyof Entries]: PathOrFnValue<TState, Entries[I]>;
+};
+export type PathOrFnSetter<TState extends object, Entry> = Entry extends PathOf<TState> ? PathSetter<TState, Entry> : Entry extends (state: TState) => infer P ? P extends PathOf<TState> ? PathSetter<TState, P> : (value: unknown) => void : (value: unknown) => void;
+export type PathOrFnSetters<TState extends object, Entries extends ReadonlyArray<PathOrFn<TState>>> = {
+    [I in keyof Entries]: PathOrFnSetter<TState, Entries[I]>;
+};
+export type MultiPathReturn<TState extends object, Paths extends ReadonlyArray<PathOf<TState>>, TDefaultValue = __NoDefault> = [PathValues<TState, Paths, TDefaultValue>, ...PathSetters<TState, Paths>];
+export type UseStoreReturn<TState extends object, TArg> = TArg extends PathOf<TState> ? [PathValue<TState, TArg>, PathSetter<TState, TArg>] : TArg extends (state: TState) => unknown ? [unknown, (value: unknown) => void] : [TState, StoreApi<TState>['setState']];
+export type UseStoreOptions<T, TState extends object = object> = StoreHookReactiveOptions<T, TState> & {
+    defaultValue?: NonNullable<T>;
+    transformer?: (value: T) => unknown;
+};
+export type UseStoreMultiOptions<TState extends object, Paths extends ReadonlyArray<PathOf<TState>>, TDefaultValue extends readonly (PathValue<TState, Paths[number]> | undefined)[] | PathValue<TState, Paths[number]> | undefined = undefined> = Omit<StoreHookReactiveOptions<never, TState>, 'equalityFn'> & {
+    equalityFn?: (a: PathValues<TState, Paths>, b: PathValues<TState, Paths>) => boolean;
+    defaultValue?: TDefaultValue;
+    transformer?: (values: PathValues<TState, Paths>) => unknown;
+};
+export type UseStoreSyncOptions<T, TState extends object = object> = StoreHookReactiveOptions<T, TState> & {
+    syncStrategy?: 'render' | 'afterRender';
+};
+export type UseStoreSyncMultiOptions<TState extends object = object> = Omit<StoreHookReactiveOptions<never, TState>, 'equalityFn'> & {
+    syncStrategy?: 'render' | 'afterRender';
+};
+export type GetValueFn<TState extends object> = {
+    (): TState;
+    <P extends PathOf<TState>>(path: P): PathValue<TState, P>;
+    <P extends PathOf<TState>, D>(path: P, defaultValue: D): NonNullable<PathValue<TState, P>> | D;
+    <D>(path: undefined, defaultValue: D): NonNullable<TState> | D;
+};
+export type GetValueFromBaseFn<TBase> = TBase extends object ? {
+    (): TBase;
+    <SubP extends PathOf<TBase>>(path: SubP): PathValue<TBase, SubP>;
+    <SubP extends PathOf<TBase>, D>(path: SubP, defaultValue: D): NonNullable<PathValue<TBase, SubP>> | D;
+    <D>(path: undefined, defaultValue: D): NonNullable<TBase> | D;
+} : () => TBase;
+export type GetValueFromBaseWithDefaultFn<TBase, D> = TBase extends object ? {
+    (): NonNullable<TBase> | D;
+    <SubP extends PathOf<NonNullable<TBase>>>(path: SubP): PathValue<NonNullable<TBase>, SubP>;
+    <SubP extends PathOf<NonNullable<TBase>>, D2>(path: SubP, defaultValue: D2): NonNullable<PathValue<NonNullable<TBase>, SubP>> | D2;
+    <D2>(path: undefined, defaultValue: D2): NonNullable<TBase> | D2;
+} : () => NonNullable<TBase> | D;
+type EntryGetter<TState extends object, Entry> = Entry extends PathOf<TState> ? GetValueFromBaseFn<PathValue<TState, Entry>> : Entry extends (state: TState) => infer R ? R extends object ? GetValueFromBaseFn<R> : () => R : never;
+export type GetterTuple<TState extends object, Entries extends ReadonlyArray<PathOf<TState> | ((state: TState) => unknown)>> = {
+    [K in keyof Entries]: EntryGetter<TState, Entries[K]>;
+};
+export type UseStoreGetterOptions<TState extends object = object, D = __NoDefault> = StoreHookBaseOptions<TState> & {
+    defaultValue?: D;
+};
+export type SetStateFn<TState extends object> = {
+    (path: undefined, value: TState | ((prev: TState) => TState)): void;
+    <P extends PathOf<TState>>(path: P, value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)): void;
+};
+export type SetFromBaseFn<TBase> = TBase extends object ? {
+    (subPath: undefined, value: TBase | ((prev: TBase) => TBase)): void;
+    <SubP extends PathOf<TBase>>(subPath: SubP, value: PathValue<TBase, SubP> | ((prev: PathValue<TBase, SubP>) => PathValue<TBase, SubP>)): void;
+} : (subPath: undefined, value: TBase) => void;
+export type UseStoreSetterOptions<TState extends object = object> = StoreHookBaseOptions<TState>;
+export {};

package/dist/types/StoreTypes.mjs

@@ -0,0 +1,4 @@
+//#region src/types/StoreTypes.ts
+var e = Symbol("@plitzi/nexus/cancel");
+//#endregion
+export { e as CANCEL };

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './StoreTypes';

package/dist/types/index.mjs

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

package/package.json

@@ -0,0 +1,257 @@
+{
+  "name": "@plitzi/nexus",
+  "version": "0.31.1",
+  "license": "Apache-2.0",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "lint": "eslint ./src",
+    "typecheck": "tsc -p tsconfig.app.json --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest --coverage",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "build:dev": "vite build --mode development --minify false && node ../sdk-shared/scripts/generate-exports.mjs",
+    "build:dev-watch": "vite build --mode development --watch --minify false",
+    "build:prod": "vite build && node ../sdk-shared/scripts/generate-exports.mjs"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "devDependencies": {
+    "eslint": "^9.39.4",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.14",
+    "vitest": "^4.1.7"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./StoreContext": {
+      "types": "./dist/StoreContext.d.ts",
+      "import": "./dist/StoreContext.mjs"
+    },
+    "./StoreProvider": {
+      "types": "./dist/StoreProvider.d.ts",
+      "import": "./dist/StoreProvider.mjs"
+    },
+    "./async": {
+      "types": "./dist/async/index.d.ts",
+      "import": "./dist/async/index.mjs"
+    },
+    "./async/createAsync": {
+      "types": "./dist/async/createAsync.d.ts",
+      "import": "./dist/async/createAsync.mjs"
+    },
+    "./async/hooks/useAsync": {
+      "types": "./dist/async/hooks/useAsync.d.ts",
+      "import": "./dist/async/hooks/useAsync.mjs"
+    },
+    "./async/hooks/useAsyncValue": {
+      "types": "./dist/async/hooks/useAsyncValue.d.ts",
+      "import": "./dist/async/hooks/useAsyncValue.mjs"
+    },
+    "./async/index": {
+      "types": "./dist/async/index.d.ts",
+      "import": "./dist/async/index.mjs"
+    },
+    "./createStore": {
+      "types": "./dist/createStore/index.d.ts",
+      "import": "./dist/createStore/index.mjs"
+    },
+    "./createStore/createStore": {
+      "types": "./dist/createStore/createStore.d.ts",
+      "import": "./dist/createStore/createStore.mjs"
+    },
+    "./createStore/helpers/PathTrie": {
+      "types": "./dist/createStore/helpers/PathTrie.d.ts",
+      "import": "./dist/createStore/helpers/PathTrie.mjs"
+    },
+    "./createStore/helpers/Subscribers": {
+      "types": "./dist/createStore/helpers/Subscribers.d.ts",
+      "import": "./dist/createStore/helpers/Subscribers.mjs"
+    },
+    "./createStore/helpers/createChainReads": {
+      "types": "./dist/createStore/helpers/createChainReads.d.ts",
+      "import": "./dist/createStore/helpers/createChainReads.mjs"
+    },
+    "./createStore/helpers/createGetPath": {
+      "types": "./dist/createStore/helpers/createGetPath.d.ts",
+      "import": "./dist/createStore/helpers/createGetPath.mjs"
+    },
+    "./createStore/helpers/createGetState": {
+      "types": "./dist/createStore/helpers/createGetState.d.ts",
+      "import": "./dist/createStore/helpers/createGetState.mjs"
+    },
+    "./createStore/helpers/createSetState": {
+      "types": "./dist/createStore/helpers/createSetState.d.ts",
+      "import": "./dist/createStore/helpers/createSetState.mjs"
+    },
+    "./createStore/helpers/deepMerge": {
+      "types": "./dist/createStore/helpers/deepMerge.d.ts",
+      "import": "./dist/createStore/helpers/deepMerge.mjs"
+    },
+    "./createStore/helpers/forwardParentChanges": {
+      "types": "./dist/createStore/helpers/forwardParentChanges.d.ts",
+      "import": "./dist/createStore/helpers/forwardParentChanges.mjs"
+    },
+    "./createStore/helpers/scopeCollisions": {
+      "types": "./dist/createStore/helpers/scopeCollisions.d.ts",
+      "import": "./dist/createStore/helpers/scopeCollisions.mjs"
+    },
+    "./createStore/helpers/writeByPath": {
+      "types": "./dist/createStore/helpers/writeByPath.d.ts",
+      "import": "./dist/createStore/helpers/writeByPath.mjs"
+    },
+    "./createStore/hooks/shared": {
+      "types": "./dist/createStore/hooks/shared.d.ts",
+      "import": "./dist/createStore/hooks/shared.mjs"
+    },
+    "./createStore/hooks/useStore": {
+      "types": "./dist/createStore/hooks/useStore.d.ts",
+      "import": "./dist/createStore/hooks/useStore.mjs"
+    },
+    "./createStore/hooks/useStoreById": {
+      "types": "./dist/createStore/hooks/useStoreById.d.ts",
+      "import": "./dist/createStore/hooks/useStoreById.mjs"
+    },
+    "./createStore/hooks/useStoreGetter": {
+      "types": "./dist/createStore/hooks/useStoreGetter.d.ts",
+      "import": "./dist/createStore/hooks/useStoreGetter.mjs"
+    },
+    "./createStore/hooks/useStoreSetter": {
+      "types": "./dist/createStore/hooks/useStoreSetter.d.ts",
+      "import": "./dist/createStore/hooks/useStoreSetter.mjs"
+    },
+    "./createStore/hooks/useStoreSync": {
+      "types": "./dist/createStore/hooks/useStoreSync.d.ts",
+      "import": "./dist/createStore/hooks/useStoreSync.mjs"
+    },
+    "./createStore/index": {
+      "types": "./dist/createStore/index.d.ts",
+      "import": "./dist/createStore/index.mjs"
+    },
+    "./derived": {
+      "types": "./dist/derived/index.d.ts",
+      "import": "./dist/derived/index.mjs"
+    },
+    "./derived/createDerived": {
+      "types": "./dist/derived/createDerived.d.ts",
+      "import": "./dist/derived/createDerived.mjs"
+    },
+    "./derived/hooks/useDerived": {
+      "types": "./dist/derived/hooks/useDerived.d.ts",
+      "import": "./dist/derived/hooks/useDerived.mjs"
+    },
+    "./derived/index": {
+      "types": "./dist/derived/index.d.ts",
+      "import": "./dist/derived/index.mjs"
+    },
+    "./entities": {
+      "types": "./dist/entities/index.d.ts",
+      "import": "./dist/entities/index.mjs"
+    },
+    "./entities/createEntityAdapter": {
+      "types": "./dist/entities/createEntityAdapter.d.ts",
+      "import": "./dist/entities/createEntityAdapter.mjs"
+    },
+    "./entities/index": {
+      "types": "./dist/entities/index.d.ts",
+      "import": "./dist/entities/index.mjs"
+    },
+    "./helpers/createObservable": {
+      "types": "./dist/helpers/createObservable.d.ts",
+      "import": "./dist/helpers/createObservable.mjs"
+    },
+    "./helpers/getByPath": {
+      "types": "./dist/helpers/getByPath.d.ts",
+      "import": "./dist/helpers/getByPath.mjs"
+    },
+    "./helpers/isPathAffected": {
+      "types": "./dist/helpers/isPathAffected.d.ts",
+      "import": "./dist/helpers/isPathAffected.mjs"
+    },
+    "./helpers/parsePath": {
+      "types": "./dist/helpers/parsePath.d.ts",
+      "import": "./dist/helpers/parsePath.mjs"
+    },
+    "./helpers/setByPath": {
+      "types": "./dist/helpers/setByPath.d.ts",
+      "import": "./dist/helpers/setByPath.mjs"
+    },
+    "./helpers/shallowEqual": {
+      "types": "./dist/helpers/shallowEqual.d.ts",
+      "import": "./dist/helpers/shallowEqual.mjs"
+    },
+    "./helpers/useIsomorphicLayoutEffect": {
+      "types": "./dist/helpers/useIsomorphicLayoutEffect.d.ts",
+      "import": "./dist/helpers/useIsomorphicLayoutEffect.mjs"
+    },
+    "./history": {
+      "types": "./dist/history/index.d.ts",
+      "import": "./dist/history/index.mjs"
+    },
+    "./history/hooks/useStoreHistory": {
+      "types": "./dist/history/hooks/useStoreHistory.d.ts",
+      "import": "./dist/history/hooks/useStoreHistory.mjs"
+    },
+    "./history/index": {
+      "types": "./dist/history/index.d.ts",
+      "import": "./dist/history/index.mjs"
+    },
+    "./index": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./middleware": {
+      "types": "./dist/middleware/index.d.ts",
+      "import": "./dist/middleware/index.mjs"
+    },
+    "./middleware/cascade": {
+      "types": "./dist/middleware/cascade.d.ts",
+      "import": "./dist/middleware/cascade.mjs"
+    },
+    "./middleware/historyMiddleware": {
+      "types": "./dist/middleware/historyMiddleware.d.ts",
+      "import": "./dist/middleware/historyMiddleware.mjs"
+    },
+    "./middleware/index": {
+      "types": "./dist/middleware/index.d.ts",
+      "import": "./dist/middleware/index.mjs"
+    },
+    "./middleware/loggerMiddleware": {
+      "types": "./dist/middleware/loggerMiddleware.d.ts",
+      "import": "./dist/middleware/loggerMiddleware.mjs"
+    },
+    "./middleware/persistMiddleware": {
+      "types": "./dist/middleware/persistMiddleware.d.ts",
+      "import": "./dist/middleware/persistMiddleware.mjs"
+    },
+    "./middleware/reduxDevToolsMiddleware": {
+      "types": "./dist/middleware/reduxDevToolsMiddleware.d.ts",
+      "import": "./dist/middleware/reduxDevToolsMiddleware.mjs"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.mjs"
+    },
+    "./types/StoreTypes": {
+      "import": "./dist/types/StoreTypes.mjs"
+    },
+    "./types/index": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.mjs"
+    }
+  }
+}