@mapsight/lib-redux 2.0.0

package/dist/reducers/immutable-path/index.js

@@ -0,0 +1,14 @@
+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,
+};
+export default reducers;
+//# sourceMappingURL=index.js.map

package/dist/reducers/immutable-path/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/js/reducers/immutable-path/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,UAAU,CAAC;AAC7B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,UAAU,MAAM,eAAe,CAAC;AACvC,OAAO,GAAG,MAAM,OAAO,CAAC;AAExB,MAAM,QAAQ,GAAG;IAChB,KAAK,EAAE,KAAK;IACZ,KAAK,EAAE,KAAK;IACZ,IAAI,EAAE,IAAI;IACV,UAAU,EAAE,UAAU;IACtB,GAAG,EAAE,GAAG;CAC0B,CAAC;AAEpC,eAAe,QAAQ,CAAC"}

package/dist/reducers/immutable-path/merge.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("redux").Reducer;
+export default _default;
+//# sourceMappingURL=merge.d.ts.map

package/dist/reducers/immutable-path/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../src/js/reducers/immutable-path/merge.ts"],"names":[],"mappings":";AAGA,wBAAiD"}

package/dist/reducers/immutable-path/merge.js

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

package/dist/reducers/immutable-path/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.js","sourceRoot":"","sources":["../../../src/js/reducers/immutable-path/merge.ts"],"names":[],"mappings":"AAAA,OAAO,0BAA0B,MAAM,qCAAqC,CAAC;AAC7E,OAAO,KAAK,MAAM,oBAAoB,CAAC;AAEvC,eAAe,0BAA0B,CAAC,KAAK,CAAC,CAAC"}

package/dist/reducers/immutable-path/noop.d.ts

@@ -0,0 +1,2 @@
+export default function noopReducer<T>(state: T): T;
+//# sourceMappingURL=noop.d.ts.map

package/dist/reducers/immutable-path/noop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop.d.ts","sourceRoot":"","sources":["../../../src/js/reducers/immutable-path/noop.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAE9C"}

package/dist/reducers/immutable-path/noop.js

@@ -0,0 +1,4 @@
+export default function noopReducer(state) {
+    return state;
+}
+//# sourceMappingURL=noop.js.map

package/dist/reducers/immutable-path/noop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop.js","sourceRoot":"","sources":["../../../src/js/reducers/immutable-path/noop.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,WAAW,CAAI,KAAQ;IAC9C,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/reducers/immutable-path/remove-from.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("redux").Reducer;
+export default _default;
+//# sourceMappingURL=remove-from.d.ts.map

package/dist/reducers/immutable-path/remove-from.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-from.d.ts","sourceRoot":"","sources":["../../../src/js/reducers/immutable-path/remove-from.ts"],"names":[],"mappings":";AAGA,wBAAsD"}

package/dist/reducers/immutable-path/remove-from.js

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

package/dist/reducers/immutable-path/remove-from.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-from.js","sourceRoot":"","sources":["../../../src/js/reducers/immutable-path/remove-from.ts"],"names":[],"mappings":"AAAA,OAAO,0BAA0B,MAAM,qCAAqC,CAAC;AAC7E,OAAO,UAAU,MAAM,0BAA0B,CAAC;AAElD,eAAe,0BAA0B,CAAC,UAAU,CAAC,CAAC"}

package/dist/reducers/immutable-path/set.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("redux").Reducer;
+export default _default;
+//# sourceMappingURL=set.d.ts.map

package/dist/reducers/immutable-path/set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../../src/js/reducers/immutable-path/set.ts"],"names":[],"mappings":";AAGA,wBAA+C"}

package/dist/reducers/immutable-path/set.js

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

package/dist/reducers/immutable-path/set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.js","sourceRoot":"","sources":["../../../src/js/reducers/immutable-path/set.ts"],"names":[],"mappings":"AAAA,OAAO,0BAA0B,MAAM,qCAAqC,CAAC;AAC7E,OAAO,GAAG,MAAM,kBAAkB,CAAC;AAEnC,eAAe,0BAA0B,CAAC,GAAG,CAAC,CAAC"}

package/dist/reducers/reduce-by-keys.d.ts

@@ -0,0 +1,2 @@
+export default function reduceByKeys(keys: Array<string>, state: Record<string, unknown>): {};
+//# sourceMappingURL=reduce-by-keys.d.ts.map

package/dist/reducers/reduce-by-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce-by-keys.d.ts","sourceRoot":"","sources":["../../src/js/reducers/reduce-by-keys.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,YAAY,CACnC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,EACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,MAc9B"}

package/dist/reducers/reduce-by-keys.js

@@ -0,0 +1,14 @@
+import unique from "lodash/uniq";
+export default function reduceByKeys(keys, state) {
+    if (keys && state) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        const uniqueKeys = unique(keys);
+        return uniqueKeys.reduce(function reduceByKey(newState, key) {
+            return state[key] !== undefined
+                ? { ...newState, [key]: state[key] }
+                : newState;
+        }, {});
+    }
+    return state;
+}
+//# sourceMappingURL=reduce-by-keys.js.map

package/dist/reducers/reduce-by-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce-by-keys.js","sourceRoot":"","sources":["../../src/js/reducers/reduce-by-keys.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,aAAa,CAAC;AAEjC,MAAM,CAAC,OAAO,UAAU,YAAY,CACnC,IAAmB,EACnB,KAA8B;IAE9B,IAAI,IAAI,IAAI,KAAK,EAAE,CAAC;QACnB,6DAA6D;QAC7D,MAAM,UAAU,GAAkB,MAAM,CAAC,IAAI,CAAC,CAAC;QAE/C,OAAO,UAAU,CAAC,MAAM,CAAC,SAAS,WAAW,CAAC,QAAQ,EAAE,GAAG;YAC1D,OAAO,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS;gBAC9B,CAAC,CAAC,EAAC,GAAG,QAAQ,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,EAAC;gBAClC,CAAC,CAAC,QAAQ,CAAC;QACb,CAAC,EAAE,EAAE,CAAC,CAAC;IACR,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@mapsight/lib-redux",
+  "description": "Mapsight Redux Library",
+  "version": "2.0.0",
+  "type": "module",
+  "dependencies": {
+    "lodash": "^4.18.1",
+    "redux-thunk": "^2.4.2",
+    "@mapsight/lib-js": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.24",
+    "cpx2": "^8.0.2",
+    "redux": "^4.2.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js"
+    },
+    "./reducers/immutable": {
+      "types": "./dist/reducers/immutable/index.d.ts",
+      "import": "./dist/reducers/immutable/index.js"
+    },
+    "./reducers/immutable-path": {
+      "types": "./dist/reducers/immutable-path/index.d.ts",
+      "import": "./dist/reducers/immutable-path/index.js"
+    }
+  },
+  "license": "UNLICENSED",
+  "main": "index.js",
+  "peerDependencies": {
+    "redux": "^4.2.1"
+  },
+  "scripts": {
+    "build": "npm-run-all build:setup build:modules build:copy",
+    "build:copy": "cpx '{package.json,README.md}' dist/",
+    "build:modules": "tsc",
+    "build:setup": "mkdirp dist",
+    "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"
+  }
+}

package/src/js/clone-action.ts

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,47 @@
+/**
+ * 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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,61 @@
+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);
+	};
+}