@mapsight/lib-redux 2.0.3 → 2.2.0

package/src/js/clone-action.ts

@@ -1,36 +0,0 @@
-import {AnyAction} from "redux";
-
-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,44 +0,0 @@
-import {AnyAction, Reducer, combineReducers} from "redux";
-
-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 {AnyAction, Reducer} from "redux";
-
-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 get from "lodash/get";
-import {AnyAction, Reducer} from "redux";
-
-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,47 +0,0 @@
-/**
- * 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
- */
-import {Middleware, MiddlewareAPI} from "redux";
-
-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) {
-				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-				if (typeof action === "function" && action.meta?.[actionFlag]) {
-					// eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-return
-					return action(api.dispatch, getState, extraArgument);
-				}
-
-				// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-				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/createStructuredSelector 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 {AnyAction, Store} from "redux";
-
-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 {AnyAction, Dispatch, Store} from "redux";
-
-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 {AnyAction, Reducer} from "redux";
-
-/**
- * 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 {AnyAction} from "redux";
-
-/**
- * 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 get from "lodash/get";
-import set from "lodash/set";
-import {Store} from "redux";
-
-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,
-	};
-}