@mapsight/lib-redux 2.1.0 → 2.2.0

package/README.md

@@ -1,20 +1,23 @@
 # @mapsight/lib-redux
 
-Library of redux helpers code to have them available from different projects and accessible by other internal libraries.
+Shared **Redux utilities** for Mapsight — immutable path reducers, controlled dispatch, async action middleware, state observation, and local-storage helpers. Used by [`@mapsight/core`](https://github.com/open-mapsight/mapsight/blob/main/packages/core/README.md) and [`@mapsight/ui`](https://github.com/open-mapsight/mapsight/blob/main/packages/ui/README.md) plugins; not intended as a general-purpose Redux toolkit for host apps.
 
-## Getting started
+See the [documentation hub](https://github.com/open-mapsight/mapsight/blob/main/docs/README.md) for architecture context. For GIS state patterns, start with [Mapsight Redux Architecture](https://github.com/open-mapsight/mapsight/blob/main/packages/core/docs/REDUX_ARCHITECTURE.md) (`@mapsight/core`).
 
-TODO
+## Common imports
 
-## How to publish
+| Module                                                       | Purpose                                                                  |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------ |
+| `@mapsight/lib-redux/reducers/immutable-path`                | Path-based `set`, `merge`, `add-to`, `remove-from` reducers              |
+| `@mapsight/lib-redux/reducers/immutable`                     | Immutable collection reducers                                            |
+| `@mapsight/lib-redux/observe-state`                          | Subscribe to derived store slices (`observeState`, `getAndObserveState`) |
+| `@mapsight/lib-redux/local-storage`                          | Persist slice to `localStorage`                                          |
+| `@mapsight/lib-redux/matchesPath`, `matchPath`               | Action path matching                                                     |
+| `@mapsight/lib-redux/enable-controlled-dispatch-and-observe` | Controlled vs uncontrolled store loop prevention                         |
 
-- Publish:
+## Related packages
 
-```
-git status
-git commit
-npm version x.x.x|major|minor|patch
-npm publish
-git push
-git push --tags
-```
+| Package                                                                                         | Role                                                       |
+| ----------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
+| [`@mapsight/core`](https://github.com/open-mapsight/mapsight/blob/main/packages/core/README.md) | Primary consumer — GIS store and controllers               |
+| [`@mapsight/ui`](https://github.com/open-mapsight/mapsight/blob/main/packages/ui/README.md)     | Browser plugins (share link, geolocation, analytics, etc.) |

package/dist/README.md

@@ -1,20 +1,23 @@
 # @mapsight/lib-redux
 
-Library of redux helpers code to have them available from different projects and accessible by other internal libraries.
+Shared **Redux utilities** for Mapsight — immutable path reducers, controlled dispatch, async action middleware, state observation, and local-storage helpers. Used by [`@mapsight/core`](https://github.com/open-mapsight/mapsight/blob/main/packages/core/README.md) and [`@mapsight/ui`](https://github.com/open-mapsight/mapsight/blob/main/packages/ui/README.md) plugins; not intended as a general-purpose Redux toolkit for host apps.
 
-## Getting started
+See the [documentation hub](https://github.com/open-mapsight/mapsight/blob/main/docs/README.md) for architecture context. For GIS state patterns, start with [Mapsight Redux Architecture](https://github.com/open-mapsight/mapsight/blob/main/packages/core/docs/REDUX_ARCHITECTURE.md) (`@mapsight/core`).
 
-TODO
+## Common imports
 
-## How to publish
+| Module                                                       | Purpose                                                                  |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------ |
+| `@mapsight/lib-redux/reducers/immutable-path`                | Path-based `set`, `merge`, `add-to`, `remove-from` reducers              |
+| `@mapsight/lib-redux/reducers/immutable`                     | Immutable collection reducers                                            |
+| `@mapsight/lib-redux/observe-state`                          | Subscribe to derived store slices (`observeState`, `getAndObserveState`) |
+| `@mapsight/lib-redux/local-storage`                          | Persist slice to `localStorage`                                          |
+| `@mapsight/lib-redux/matchesPath`, `matchPath`               | Action path matching                                                     |
+| `@mapsight/lib-redux/enable-controlled-dispatch-and-observe` | Controlled vs uncontrolled store loop prevention                         |
 
-- Publish:
+## Related packages
 
-```
-git status
-git commit
-npm version x.x.x|major|minor|patch
-npm publish
-git push
-git push --tags
-```
+| Package                                                                                         | Role                                                       |
+| ----------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
+| [`@mapsight/core`](https://github.com/open-mapsight/mapsight/blob/main/packages/core/README.md) | Primary consumer — GIS store and controllers               |
+| [`@mapsight/ui`](https://github.com/open-mapsight/mapsight/blob/main/packages/ui/README.md)     | Browser plugins (share link, geolocation, analytics, etc.) |

package/dist/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@mapsight/lib-redux",
 	"description": "Mapsight Redux Library",
-	"version": "2.1.0",
+	"version": "2.2.0",
 	"type": "module",
 	"dependencies": {
 		"@mapsight/lib-js": "workspace:^",
@@ -30,6 +30,9 @@
 			"import": "./dist/reducers/immutable-path/index.js"
 		}
 	},
+	"files": [
+		"dist"
+	],
 	"license": "UNLICENSED",
 	"main": "index.js",
 	"repository": {
@@ -43,8 +46,7 @@
 		"clean": "rimraf dist/*",
 		"clean-build": "run-s clean build",
 		"typecheck": "tsc --noEmit",
-		"watch": "run-p watch:*",
-		"watch:copy": "pnpm run build:copy --watch",
-		"watch:modules": "pnpm run build:modules --watch"
+		"watch": "run-s build:setup build:modules watch:build",
+		"watch:build": "tsc --watch"
 	}
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@mapsight/lib-redux",
   "description": "Mapsight Redux Library",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "type": "module",
   "dependencies": {
     "@reduxjs/toolkit": "^2.11.2",
     "@types/lodash": "^4.17.24",
     "lodash": "^4.18.1",
-    "@mapsight/lib-js": "^3.0.3"
+    "@mapsight/lib-js": "^3.0.4"
   },
   "devDependencies": {
     "cpx2": "^8.0.2"
@@ -30,6 +30,9 @@
       "import": "./dist/reducers/immutable-path/index.js"
     }
   },
+  "files": [
+    "dist"
+  ],
   "license": "UNLICENSED",
   "main": "index.js",
   "repository": {
@@ -43,8 +46,7 @@
     "clean": "rimraf dist/*",
     "clean-build": "run-s clean build",
     "typecheck": "tsc --noEmit",
-    "watch": "run-p watch:*",
-    "watch:copy": "pnpm run build:copy --watch",
-    "watch:modules": "pnpm run build:modules --watch"
+    "watch": "run-s build:setup build:modules watch:build",
+    "watch:build": "tsc --watch"
   }
 }

package/src/js/clone-action.ts

@@ -1,36 +0,0 @@
-import type {AnyAction} from "@reduxjs/toolkit";
-
-function shallowCloneObject<T>(o: T): T {
-	return {...o};
-}
-
-/**
- * Creates a new action (object or function) with the same content but new reference.
- *
- * @param action action
- * @returns cloned action
- */
-export default function cloneAction<T = AnyAction>(action: T): T {
-	// special case for redux-thunk where the action is a function
-	if (typeof action === "function") {
-		const newAction: T = action.bind({}) as T;
-
-		if ("meta" in action) {
-			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-			// @ts-ignore
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-			newAction.meta = shallowCloneObject(action.meta);
-		}
-
-		if (action.name) {
-			Object.defineProperty(newAction, "name", {
-				value: action.name + "__cloned",
-			});
-		}
-
-		return newAction;
-	}
-
-	// otherwise just make a shallow copy of the plan object action
-	return shallowCloneObject(action);
-}

package/src/js/combine-sub-path-reducers.ts

@@ -1,45 +0,0 @@
-import type {AnyAction, Reducer} from "@reduxjs/toolkit";
-import {combineReducers} from "@reduxjs/toolkit";
-
-import cloneAction from "./clone-action";
-
-/**
- * Combines the given reducers, so they only get actions without a path or
- * a path matching the map key.
- *
- * @param reducerMap a map of reducers and their keys representing their part of the store
- * @param pathKey key of the action parameter that contains the path array
- * @returns combined reducer
- */
-export default function combineSubPathReducers(
-	reducerMap: Record<string, Reducer>,
-	pathKey = "path",
-) {
-	const reducerEntries = Object.entries(reducerMap).map(([name, reducer]) => {
-		const wrapperReducer = <T>(state: T, action: AnyAction): any => {
-			if (typeof action.meta === "object") {
-				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
-				const path = action.meta[pathKey];
-
-				if (Array.isArray(path) && path.length) {
-					if (path[0] !== name) {
-						return state;
-					}
-
-					const controllerAction = cloneAction(action);
-					controllerAction[pathKey] = path.slice(1);
-
-					// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-					return reducer(state, controllerAction);
-				}
-			}
-
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-			return reducer(state, action);
-		};
-
-		return [name, wrapperReducer] as const;
-	});
-
-	return combineReducers(Object.fromEntries(reducerEntries));
-}

package/src/js/create-filtered-reducer-for-path.ts

@@ -1,52 +0,0 @@
-import type {AnyAction, Reducer} from "@reduxjs/toolkit";
-
-import cloneAction from "./clone-action";
-
-/**
- * Filters the actions, so the reducer only gets actions without a path or
- * a path matching the given key.
- *
- * @param reducer the base reducer that should get filtered actions only
- * @param key key of the action parameter that contains the path array
- * @param [statePathMetaKey] name of the meta field that contains the path array (action.meta.path), default: 'path'
- * @returns resulting reducer
- */
-function createFilteredReducerForPath(
-	reducer: Reducer,
-	key: string,
-	statePathMetaKey = "path",
-): Reducer {
-	const filteredReducer: Reducer = <T extends Record<string, unknown>>(
-		state: T,
-		action: AnyAction,
-	) => {
-		if (typeof action.meta === "object") {
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
-			const path = action.meta[statePathMetaKey];
-			if (Array.isArray(path) && path.length) {
-				if (path[0] !== key) {
-					return state;
-				}
-
-				const slicedAction = cloneAction(action);
-				slicedAction[statePathMetaKey] = path.slice(1);
-
-				// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-				return reducer(state, slicedAction);
-			}
-		}
-
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-		return reducer(state, action);
-	};
-
-	if (reducer.name) {
-		Object.defineProperty(filteredReducer, "name", {
-			value: reducer.name + "__filtered-by-path",
-		});
-	}
-
-	return filteredReducer;
-}
-
-export default createFilteredReducerForPath;

package/src/js/create-immutable-path-reducer.ts

@@ -1,41 +0,0 @@
-import type {AnyAction, Reducer} from "@reduxjs/toolkit";
-import get from "lodash/get";
-
-import deepChangeState from "./deep-change-state";
-
-/**
- * Creates a new reducer, that replaces an value at the given path using the given reducer,
- * replacing all parent objects, instead of mutating the existing object(s).
- *
- * The given reducer has to work immutable as well to get the full desired effect!
- *
- * @param reducer reducer to reduce the value at the path
- * @param [pathKey] path in the object to reduce, default: 'path'
- * @returns resulting immutable path reducer
- */
-export default function createImmutablePathReducer(
-	reducer: Reducer,
-	pathKey = "path",
-): Reducer {
-	// noinspection UnnecessaryLocalVariableJS
-	const immutablePathReducer: Reducer = <T>(
-		state: T,
-		action: AnyAction,
-	): T => {
-		const path = action[pathKey] as Array<string>;
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-call
-		const oldValue = (path?.length ? get(state, path) : state) as T;
-		const newValue = reducer(oldValue, action) as T;
-		if (newValue === oldValue) {
-			return state;
-		}
-
-		return deepChangeState(state, path, newValue);
-	};
-
-	//if (reducer.name) {
-	//	Object.defineProperty(aImmutablePathReducer, 'name', {value: reducer.name + '__immutable-path'});
-	//}
-
-	return immutablePathReducer;
-}

package/src/js/create-prefixed-async-action-middleware.ts

@@ -1,50 +0,0 @@
-import type {Middleware, MiddlewareAPI} from "@reduxjs/toolkit";
-
-/**
- * Creates a redux middleware that allows dispatching of functions as actions, when the action
- * exposes the defined actionFlag. If a prefix is provided, the action function will receive a
- * prefixed getState, meaning it will retrieve the sub store with the prefix key (store.getState()[prefix]).
- *
- * Works similar to thunk, but with additional flag and optional sub store getState.
- *
- * @param [actionFlag] action flag, default: 'isAsync'
- * @param [prefix] prefix state prefix
- * @param [extraArgument] extra argument to be passed to action function
- *
- * @returns {function(*=): function(*): Function} resulting middleware
- */
-export default function createPrefixedAsyncActionMiddleware<
-	Prefix extends string | undefined,
->(
-	actionFlag = "isAsync",
-	prefix?: Prefix,
-	extraArgument: unknown = undefined,
-): Middleware {
-	return function prefixedAsyncActionMiddleware(api: MiddlewareAPI) {
-		// eslint-disable-next-line @typescript-eslint/unbound-method
-		let getState = api.getState;
-		if (typeof prefix === "string") {
-			// eslint-disable-next-line @typescript-eslint/unbound-method
-			const baseGetState = api.getState as () => Record<string, unknown>;
-			getState = function getStateWithPrefix() {
-				return baseGetState()[prefix];
-			};
-		}
-
-		return function (next) {
-			return function prefixedAsyncActionMiddlewareWithAction(action) {
-				if (
-					typeof action === "function" &&
-					"meta" in action &&
-					typeof action.meta === "object" &&
-					(action.meta as Record<string, unknown>)[actionFlag]
-				) {
-					// eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-return
-					return action(api.dispatch, getState, extraArgument);
-				}
-
-				return next(action);
-			};
-		};
-	};
-}

package/src/js/createSelectorUsingOwnProps.ts

@@ -1,84 +0,0 @@
-function strictEqualityComparison<T>(a: T, b: T): boolean {
-	return a === b;
-}
-
-export type SelectorUsingPropsOptions = {
-	equals?: typeof strictEqualityComparison;
-};
-
-type OwnPropsSelector<OwnProps, T = unknown> = (ownProps: OwnProps) => T;
-
-type SelectorWithOwnProps<
-	OwnProps extends Array<unknown> = Array<unknown>,
-	State = unknown,
-	Value = unknown,
-> = (state: State, ownProps: OwnProps) => Value;
-type SelectorFactory<
-	OwnProps extends Array<unknown> = Array<unknown>,
-	State = unknown,
-	Value = unknown,
-> = (
-	...selectedValues: unknown[]
-) => SelectorWithOwnProps<OwnProps, State, Value>;
-
-/**
- * Create a selector whenever some (own) properties change. To be used with react-redux's connect() mapState.
- *
- * @param ownPropsSelectorOrSelectors one selector function or an array of selector functions that receive
- *                           the ownProps and should return one property value that will be used to determine changes
- * @param selectorFactory factory function receives the selected props as arguments followed by the state and
- *                           ownProps at the time of invalidation
- * @param [options] optional options
- * @param [options.equals] function that check equality, defaults to strict equality (===)
- * @returns selector function to be used as mapState in react-redux's connect() function.
- *                 May be combined with createSelector or any other function as
- *                 long as the selector is called with state as first and own props as second argument.
- */
-export default function createSelectorUsingOwnProps<
-	State = unknown,
-	Value = unknown,
-	OwnProps extends Array<unknown> = Array<unknown>,
->(
-	ownPropsSelectorOrSelectors:
-		| OwnPropsSelector<OwnProps>
-		| Array<OwnPropsSelector<OwnProps>>,
-	selectorFactory: SelectorFactory<OwnProps, State, Value>,
-	options: SelectorUsingPropsOptions = {},
-) {
-	const equals = options.equals || strictEqualityComparison;
-	let propsCache: Array<unknown>;
-	let cachedSelector: SelectorWithOwnProps<OwnProps, State, Value>;
-
-	const ownPropsSelectors = Array.isArray(ownPropsSelectorOrSelectors)
-		? ownPropsSelectorOrSelectors
-		: [ownPropsSelectorOrSelectors];
-
-	function updateSelector(state: State, ownProps: OwnProps) {
-		let hasChanged = false;
-
-		if (!propsCache) {
-			propsCache = new Array(ownPropsSelectorOrSelectors.length);
-			hasChanged = true;
-		}
-
-		ownPropsSelectors.forEach(function updateProps(ownPropsSelector, i) {
-			const prev = propsCache[i];
-			const next = ownPropsSelector(ownProps);
-
-			if (!hasChanged && !equals(prev, next)) {
-				hasChanged = true;
-			}
-
-			propsCache[i] = next;
-		});
-
-		if (hasChanged || !cachedSelector) {
-			cachedSelector = selectorFactory(...propsCache, state, ownProps);
-		}
-	}
-
-	return function selector(state: State, ownProps: OwnProps): Value {
-		updateSelector(state, ownProps);
-		return cachedSelector(state, ownProps);
-	};
-}

package/src/js/deep-change-state.ts

@@ -1,37 +0,0 @@
-import setWith from "lodash/setWith";
-
-function shallowCloneObject<T>(o: T): T {
-	return {...o};
-}
-
-/**
- * Creates a new state from {state} with the value at the {path} changed to the given {value} and
- * reassigns all objects down along the path of the change so they aren't strictly equal anymore
- * and can be easily observed as changed by redux/react.
- *
- * **Note:** Returns a new state object! Does NOT mutate the original state object!
- *
- * @param {object} state The original state
- * @param {*[]|string} [path] The path at which the change gets applied.
- * @param {*} [value] The new value to be set (or undefined).
- * @returns {*} The new state with changed value and new objects along the path.
- */
-export default function deepChangeState<State = unknown, Value = unknown>(
-	state: State,
-	path: Array<string>,
-	value: Value,
-) {
-	const hasPath = path?.length;
-	if (!hasPath) {
-		return value;
-	}
-
-	const newState = shallowCloneObject(state);
-
-	if (newState && typeof newState === "object") {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-call
-		setWith(newState, path, value, shallowCloneObject);
-	}
-
-	return newState;
-}

package/src/js/enable-async-dispatch.ts

@@ -1,61 +0,0 @@
-import type {AnyAction, Store} from "@reduxjs/toolkit";
-
-function runAsync(fn: () => void) {
-	return setTimeout(() => fn(), 10);
-}
-
-function isRecord(val: unknown): val is Record<keyof any, unknown> {
-	return typeof val === "object" && val !== null;
-}
-
-/**
- * Enhances the stores dispatch function, so you can dispatch actions flagged as async.
- * This allows "dispatching while dispatching" by queueing actions that are dispatched while dispatching is already
- * in progress and dispatching them after finishing with the current action.
- *
- * The action is guaranteed to be dispatched asynchronously in any case (even when dispatching is possible immediately).
- *
- * @param store redux store to be enhanced (having dispatch)
- * @param asyncActionFlag flag that async actions expose (action[actionFlag] == true)
- */
-export default function enableAsyncDispatch(
-	store: Store,
-	asyncActionFlag: string | symbol = "isAsync",
-) {
-	// This function will override the store.dispatch method, deferring the actual dispatch of actions flagged as
-	// async by queueing them and only dispatching them in the next microtask by scheduling them with setTimeout.
-	let isAsyncScheduled = false;
-	const actionQueue: Array<AnyAction> = [];
-
-	const baseDispatch = store.dispatch;
-
-	function isActionAsync(action: AnyAction) {
-		return isRecord(action.meta) && !!action.meta[asyncActionFlag];
-	}
-
-	function runScheduleAsyncDispatch() {
-		isAsyncScheduled = false;
-
-		while (actionQueue.length) {
-			const action = actionQueue.shift() as AnyAction;
-			baseDispatch(action);
-		}
-	}
-
-	function scheduleAsyncDispatch() {
-		if (!isAsyncScheduled) {
-			isAsyncScheduled = true;
-			runAsync(runScheduleAsyncDispatch);
-		}
-	}
-
-	store.dispatch = (action) => {
-		if (isActionAsync(action)) {
-			actionQueue.push(action);
-			scheduleAsyncDispatch();
-			return action;
-		}
-
-		return baseDispatch(action);
-	};
-}

package/src/js/enable-controlled-dispatch-and-observe.ts

@@ -1,128 +0,0 @@
-import type {AnyAction, Dispatch, Store} from "@reduxjs/toolkit";
-
-type CompareFunction = (a: unknown, b: unknown) => boolean;
-
-const strictEqualCompare: CompareFunction = (a, b) => a === b;
-
-type UncontrolledActionListener<State = unknown> = (
-	previousState: State,
-	state: State,
-) => void;
-type SubscribeUncontrolled<State = unknown> = (
-	listener: UncontrolledActionListener<State>,
-) => () => void;
-
-export type ObserveHandler<State = unknown, Value = unknown> = (
-	newValue?: Value,
-	previousValue?: Value,
-	state?: State,
-) => void;
-
-export type ObserveUncontrolled<State = unknown, Value = unknown> = (
-	selector: (state: State) => Value,
-	onChange: ObserveHandler<State, Value>,
-	compare?: CompareFunction,
-) => () => void;
-
-export type StoreExtControlledActions<TState = unknown> = {
-	subscribeUncontrolled: SubscribeUncontrolled<TState>;
-	observeUncontrolled: ObserveUncontrolled<TState>;
-};
-
-export type StoreWithControlledActions<
-	S extends Store = Store,
-	TState = unknown,
-> = S & StoreExtControlledActions<TState>;
-
-function isActionWithMeta(
-	action: AnyAction,
-): action is AnyAction & {meta: Record<string, unknown>} {
-	return "meta" in action;
-}
-
-function isControlledAction(
-	action: AnyAction,
-	controlledActionFlag: string,
-): boolean {
-	return (
-		isActionWithMeta(action) && action.meta?.[controlledActionFlag] === true
-	);
-}
-
-/**
- * Enhances the store. Allows actions to be flagged as controlled and adds a new function
- * store.observeUncontrolled(selector, onChange, compare) to the store.
- *
- * @param {object} store redux store
- * @param {string|symbol} controlledActionFlag flag that controlled actions expose (action[controlledActionFlag] == true)
- */
-export default function enableControlledDispatchAndObserve<State = unknown>(
-	store: Store<State>,
-	controlledActionFlag = "isControlled",
-) {
-	let listeners: Array<UncontrolledActionListener<State>> = [];
-
-	function removeListener(listener: UncontrolledActionListener<State>) {
-		listeners = listeners.filter((l) => l !== listener);
-	}
-
-	function addListener(listener: UncontrolledActionListener<State>) {
-		listeners.push(listener);
-	}
-
-	const subscribeUncontrolled: SubscribeUncontrolled<State> = (listener) => {
-		addListener(listener);
-
-		return function removeListenerBound() {
-			removeListener(listener);
-		};
-	};
-
-	const observeUncontrolled: ObserveUncontrolled<State> = (
-		selector,
-		onChange,
-		compare = strictEqualCompare,
-	) =>
-		subscribeUncontrolled(
-			function handleUncontrolledChange(previousState, state) {
-				const previousValue = selector(previousState);
-				const newValue = selector(state);
-
-				if (!compare(previousValue, newValue)) {
-					onChange(newValue, previousValue, state);
-				}
-			},
-		);
-
-	let wasControlled = false;
-	const baseDispatch = store.dispatch;
-
-	const enhancedDispatch: Dispatch = (action) => {
-		wasControlled = isControlledAction(action, controlledActionFlag);
-		return baseDispatch(action);
-	};
-
-	let previousState = store.getState();
-
-	function listenForUncontrolledActions() {
-		const state = store.getState();
-
-		if (!wasControlled) {
-			listeners.forEach(
-				function callUncontrolledChangeListener(listener) {
-					listener(previousState, state);
-				},
-			);
-		}
-
-		previousState = state;
-	}
-
-	store.subscribe(listenForUncontrolledActions);
-
-	Object.assign(store, {
-		dispatch: enhancedDispatch,
-		subscribeUncontrolled: subscribeUncontrolled,
-		observeUncontrolled: observeUncontrolled,
-	});
-}

package/src/js/enable-initialization.ts

@@ -1,36 +0,0 @@
-import type {AnyAction, Reducer} from "@reduxjs/toolkit";
-
-/**
- * Add initialization reducer to existing reducer
- *
- * @deprecated Use redux preloadedState or mergeAll actions instead.
- *
- * @param reducer base reducer to enhance
- * @param [actionName] name of action, default: 'INITIALIZE'
- * @returns enhanced reducer
- */
-
-export default function enableInitialization(
-	reducer: Reducer,
-	actionName = "INITIALIZE",
-) {
-	const aReducerWithInitialization: Reducer = <T>(
-		state: T,
-		action: AnyAction,
-	) => {
-		if (action.type === actionName) {
-			return action.value as T;
-		}
-
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-		return reducer(state, action);
-	};
-
-	if (reducer.name) {
-		Object.defineProperty(aReducerWithInitialization, "name", {
-			value: reducer.name + "__with-initialization",
-		});
-	}
-
-	return aReducerWithInitialization;
-}

package/src/js/flatten-actions.ts

@@ -1,22 +0,0 @@
-import type {AnyAction} from "@reduxjs/toolkit";
-
-/**
- * Flattens (deeply) batched actions into a flat array of actions
- *
- * @param {object} action the root action
- * @returns {Array<object>} flattened array of actions
- */
-export default function flattenActions(action: AnyAction): Array<AnyAction> {
-	if (
-		"meta" in action &&
-		"payload" in action &&
-		Array.isArray(action.payload) &&
-		typeof action.meta === "object" &&
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-		action.meta.batch === true
-	) {
-		return action.payload.flatMap(flattenActions);
-	}
-
-	return [action];
-}

package/src/js/index.ts

@@ -1 +0,0 @@
-//

package/src/js/local-storage.ts

@@ -1,96 +0,0 @@
-import type {Store} from "@reduxjs/toolkit";
-import get from "lodash/get";
-import set from "lodash/set";
-
-import {observeState} from "./observe-state";
-
-/**
- * Creates a storage object to access local storage.
- *
- * @param [storageKey=null] key to be used in local storage
- * @returns storage adapter
- */
-export function createStorage(storageKey: string | null = null) {
-	function setStorageKey(k: string | null) {
-		storageKey = k;
-	}
-
-	function getLocalStorageState(): unknown {
-		if (!storageKey) {
-			throw Error(
-				"@mapsight/lib-redux: Cannot access local storage without a key. Please set a storage key using the `string: storageKey` property on `createStorage(string?: storageKey)` or using the `setStorageKey(string: storageKey)` method on an existing storage object.",
-			);
-		}
-
-		if (typeof window !== "undefined") {
-			const value = window.localStorage.getItem(storageKey);
-			return window.localStorage && value ? JSON.parse(value) : null;
-		}
-
-		return null;
-	}
-
-	function setLocalStorageState(state: unknown) {
-		if (!storageKey) {
-			throw Error(
-				"@mapsight/lib-redux: Cannot access local storage without a key. Please set a storage key using the `string: storageKey` property on `createStorage(string?: storageKey)` or using the `setStorageKey(string: storageKey)` method on an existing storage object.",
-			);
-		}
-
-		if (window.localStorage) {
-			window.localStorage.setItem(storageKey, JSON.stringify(state));
-		}
-	}
-
-	function updateLocalStorageState(
-		path: Array<string> | string,
-		value: unknown,
-	) {
-		if (!storageKey) {
-			throw Error(
-				"@mapsight/lib-redux: Cannot access local storage without a key. Please set a storage key using the `string: storageKey` property on `createStorage(string?: storageKey)` or using the `setStorageKey(string: storageKey)` method on an existing storage object.",
-			);
-		}
-
-		setLocalStorageState(set<any>(getLocalStorageState(), path, value));
-	}
-
-	/**
-	 * Observes and synchronizes the state of the given store with local storage.
-	 *
-	 * @see lodash/get for path definition
-	 *
-	 * @param store the store to observe
-	 * @param paths array of path strings (string[]) or path arrays (string[][])
-	 */
-	function synchronizePathsToLocalStorage(
-		store: Store,
-		paths: Array<string | Array<string>>,
-	) {
-		if (!storageKey) {
-			throw Error(
-				"@mapsight/lib-redux: Cannot access local storage without a key. Please set a storage key using the `string: storageKey` property on `createStorage(string?: storageKey)` or using the `setStorageKey(string: storageKey)` method on an existing storage object.",
-			);
-		}
-
-		if (window.localStorage) {
-			paths.forEach(function synchronizePathToLocalStorage(path) {
-				observeState(
-					store,
-					(state): unknown =>
-						// eslint-disable-next-line @typescript-eslint/no-unsafe-call
-						get(state, path),
-					(value) => updateLocalStorageState(path, value),
-				);
-			});
-		}
-	}
-
-	return {
-		setStorageKey: setStorageKey,
-		getLocalStorageState: getLocalStorageState,
-		setLocalStorageState: setLocalStorageState,
-		updateLocalStorageState: updateLocalStorageState,
-		synchronizePathsToLocalStorage: synchronizePathsToLocalStorage,
-	};
-}

package/src/js/matchPath.ts

@@ -1,78 +0,0 @@
-import {zip} from "@mapsight/lib-js/array";
-
-type PatternSegment = {isParam: boolean; name: string};
-
-/**
- * Parses a pattern segment.
- *
- * @param patternSegment segment string
- * @returns parsed segment
- */
-function parsePatternSegment(patternSegment: string): PatternSegment {
-	if (patternSegment.startsWith(":")) {
-		return {
-			isParam: true,
-			name: patternSegment.slice(1),
-		};
-	} else {
-		return {
-			isParam: false,
-			name: patternSegment,
-		};
-	}
-}
-
-// TODO: lru/limit cache?
-const parsePathPatternCache: Record<string, Array<PatternSegment>> = {};
-
-/**
- * Parses a path pattern
- *
- * @param pattern path pattern
- * @returns parsed pattern
- */
-function parsePathPattern(pattern: string): Array<PatternSegment> {
-	const fromCache = parsePathPatternCache[pattern];
-	if (fromCache !== undefined) {
-		return fromCache;
-	}
-
-	const patternSegments = pattern.split("/").map(parsePatternSegment);
-	parsePathPatternCache[pattern] = patternSegments;
-	return patternSegments;
-}
-
-/**
- * This function matches the given path array to a path pattern. The pattern consists of / delimited names and/or
- * named parameters defined as `:name` where name may be any string which will be used in the returned object to
- * access the parameter value.
- *
- * If the path matches the pattern, the return value will be an object containing any present
- * named parameter values that may be in the pattern, otherwise it will return false if any path segment does not
- * match the specified pattern.
- *
- * @param pathArr path array
- * @param pattern pattern to match
- * @returns object containing matched named parameter values or false if the path did not patch the pattern
- */
-export default function matchPath(
-	pathArr: Array<string>,
-	pattern: string,
-): false | Record<string, string> {
-	const patternSegments = parsePathPattern(pattern);
-	if (patternSegments.length !== pathArr.length) {
-		return false;
-	}
-
-	const params: Record<string, string> = {};
-
-	for (const [pathValue, patternSegment] of zip(pathArr, patternSegments)) {
-		if (patternSegment.isParam) {
-			params[patternSegment.name] = pathValue;
-		} else if (pathValue !== patternSegment.name) {
-			return false;
-		}
-	}
-
-	return params;
-}

package/src/js/matchesPath.ts

@@ -1,23 +0,0 @@
-import matchPath from "./matchPath";
-
-const noMatch: Record<string, string> = {};
-
-/**
- * This function matches the given path array to a path pattern. The pattern consists of / delimited names and/or
- * named parameters defined as `:name` where name may be any string which will be used in the returned object to
- * access the parameter value.
- *
- * If the path matches the pattern it will return an object containing any present
- * named parameter values that may be in the pattern otherwise an empty object is returned.
- *
- * @param pathArr path array
- * @param pattern pattern to match
- * @returns 2-ary array with boolean that is true if the path did match the pattern and an object containing matched named parameter values
- */
-export default function matchesPath(
-	pathArr: Array<string>,
-	pattern: string,
-): [boolean, Record<string, string>] {
-	const match = matchPath(pathArr, pattern);
-	return match ? [true, match] : [false, noMatch];
-}

package/src/js/observe-state.ts

@@ -1,109 +0,0 @@
-import type {Store} from "@reduxjs/toolkit";
-
-function strictEqualCompare<T>(a: T, b: T): boolean {
-	return a === b;
-}
-
-//const jsonCompare = (a, b)  => JSON.stringify(a) !== JSON.stringify(b);
-
-export const AbortObserving = Symbol(); // TODO: Use Symbol()
-
-function internalObserveState<State = unknown, Value = unknown>(
-	store: Store<State>,
-	selector: (state: State) => Value,
-	listener: (
-		newValue: Value,
-		oldValue: Value | null,
-		state: State,
-	) => void | typeof AbortObserving,
-	compare = strictEqualCompare,
-	initialValue: Value | null = null,
-) {
-	let currentValue = initialValue;
-	const unsubscribe = store.subscribe(function onStateChange() {
-		const state = store.getState();
-		const newValue = selector(state);
-
-		if (!compare(currentValue, newValue)) {
-			const oldValue = currentValue;
-			currentValue = newValue;
-
-			const returnValue = listener(newValue, oldValue, state);
-			if (returnValue === AbortObserving) {
-				unsubscribe();
-			}
-		}
-	});
-
-	return unsubscribe;
-}
-
-export function observeState<State = unknown, Value = unknown>(
-	store: Store<State>,
-	selector: (state: State) => Value,
-	listener: (
-		newValue: Value,
-		oldValue: Value | null,
-		state: State,
-	) => void | typeof AbortObserving,
-	compare = strictEqualCompare,
-) {
-	const initialValue = selector(store.getState());
-	return internalObserveState(
-		store,
-		selector,
-		listener,
-		compare,
-		initialValue,
-	);
-}
-
-export function observeStateOnce<State = unknown, Value = unknown>(
-	store: Store,
-	selector: (state: State) => Value,
-	listener: (
-		newValue: Value,
-		oldValue: Value | null,
-		state: State,
-	) => void | typeof AbortObserving,
-	compare = strictEqualCompare,
-) {
-	const unsubscribe = observeState(
-		store,
-		selector,
-		function handleChange(newValue, oldValue, state: State) {
-			listener(newValue, oldValue, state);
-			unsubscribe();
-		},
-		compare,
-	);
-
-	return unsubscribe;
-}
-
-export function getAndObserveState<State = unknown, Value = unknown>(
-	store: Store<State>,
-	selector: (state: State) => Value,
-	listener: (
-		newValue: Value,
-		oldValue: Value | null,
-		state: State,
-	) => void | typeof AbortObserving,
-	compare = strictEqualCompare,
-) {
-	const initialState = store.getState();
-	const initialValue = selector(initialState);
-
-	const initialReturnValue = listener(initialValue, null, initialState);
-	if (initialReturnValue === AbortObserving) {
-		return () => undefined;
-	}
-
-	return internalObserveState(
-		store,
-		selector,
-		listener,
-		compare,
-		initialValue,
-	);
-}

package/src/js/reducers/immutable/add-to.ts

@@ -1,6 +0,0 @@
-import type {Reducer} from "@reduxjs/toolkit";
-
-const addTo: Reducer<Array<unknown>> = (state, action) =>
-	(state || []).concat([action.element]);
-
-export default addTo;

package/src/js/reducers/immutable/index.ts

@@ -1,17 +0,0 @@
-import type {Reducer} from "@reduxjs/toolkit";
-
-import addTo from "./add-to";
-import merge from "./merge";
-import noop from "./noop";
-import removeFrom from "./remove-from";
-import set from "./set";
-
-const reducers: Record<string, Reducer> = {
-	addTo: addTo,
-	merge: merge,
-	noop: noop,
-	removeFrom: removeFrom,
-	set: set,
-};
-
-export default reducers;

package/src/js/reducers/immutable/merge.ts

@@ -1,18 +0,0 @@
-import type {AnyAction, Reducer} from "@reduxjs/toolkit";
-import merge from "lodash/merge";
-
-const mergeReducer: Reducer = <
-	T extends Array<unknown> | Record<string | number | symbol, unknown>,
->(
-	state: T,
-	action: AnyAction,
-): T => {
-	const result: T = (Array.isArray(state) ? [] : {}) as T;
-
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-call
-	merge(result, state, action.value);
-
-	return result;
-};
-
-export default mergeReducer;

package/src/js/reducers/immutable/noop.ts

@@ -1,5 +0,0 @@
-import type {Reducer} from "@reduxjs/toolkit";
-
-const noopReducer: Reducer = <T>(state: T): T => state;
-
-export default noopReducer;

package/src/js/reducers/immutable/remove-from.ts

@@ -1,8 +0,0 @@
-import type {AnyAction, Reducer} from "@reduxjs/toolkit";
-
-const removeFromReducer: Reducer = <T extends Array<unknown>>(
-	state: T,
-	action: AnyAction,
-) => state.filter((element) => element !== action.element);
-
-export default removeFromReducer;

package/src/js/reducers/immutable/set.ts

@@ -1,5 +0,0 @@
-import type {AnyAction, Reducer} from "@reduxjs/toolkit";
-
-const setReducer: Reducer = (state, action: AnyAction): unknown => action.value;
-
-export default setReducer;

package/src/js/reducers/immutable-path/add-to.ts

@@ -1,4 +0,0 @@
-import createImmutablePathReducer from "../../create-immutable-path-reducer";
-import addTo from "../immutable/add-to";
-
-export default createImmutablePathReducer(addTo);

package/src/js/reducers/immutable-path/index.ts

@@ -1,17 +0,0 @@
-import type {Reducer} from "@reduxjs/toolkit";
-
-import addTo from "./add-to";
-import merge from "./merge";
-import noop from "./noop";
-import removeFrom from "./remove-from";
-import set from "./set";
-
-const reducers = {
-	addTo: addTo,
-	merge: merge,
-	noop: noop,
-	removeFrom: removeFrom,
-	set: set,
-} satisfies Record<string, Reducer>;
-
-export default reducers;

package/src/js/reducers/immutable-path/merge.ts

@@ -1,4 +0,0 @@
-import createImmutablePathReducer from "../../create-immutable-path-reducer";
-import merge from "../immutable/merge";
-
-export default createImmutablePathReducer(merge);

package/src/js/reducers/immutable-path/noop.ts

@@ -1,3 +0,0 @@
-export default function noopReducer<T>(state: T) {
-	return state;
-}

package/src/js/reducers/immutable-path/remove-from.ts

@@ -1,4 +0,0 @@
-import createImmutablePathReducer from "../../create-immutable-path-reducer";
-import removeFrom from "../immutable/remove-from";
-
-export default createImmutablePathReducer(removeFrom);

package/src/js/reducers/immutable-path/set.ts

@@ -1,4 +0,0 @@
-import createImmutablePathReducer from "../../create-immutable-path-reducer";
-import set from "../immutable/set";
-
-export default createImmutablePathReducer(set);

package/src/js/reducers/reduce-by-keys.ts

@@ -1,19 +0,0 @@
-import unique from "lodash/uniq";
-
-export default function reduceByKeys(
-	keys: Array<string>,
-	state: Record<string, unknown>,
-) {
-	if (keys && state) {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-call
-		const uniqueKeys: Array<string> = unique(keys);
-
-		return uniqueKeys.reduce(function reduceByKey(newState, key) {
-			return state[key] !== undefined
-				? {...newState, [key]: state[key]}
-				: newState;
-		}, {});
-	}
-
-	return state;
-}