@dxyl/utils 1.1.6 → 1.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxyl/utils",
-  "version": "1.1.6",
+  "version": "1.1.9",
   "description": "Collected many useful mathematical tools",
   "publishConfig": {
     "access": "public"
@@ -14,7 +14,12 @@
   "type": "module",
   "types": "./types/index.d.ts",
   "exports":{
-      "./lib/*":"./lib/*"
+    ".":{
+      "types":"./types/index.d.ts",
+      "import":"./dist/index.es.js",
+      "default":"./dist/index.umd.js"
+    },
+    "./lib/*":"./lib/*"
   },
   "files": [
     "package.json",

package/types/color/colord/src/index.d.ts

@@ -1,5 +1,5 @@
-export { colord, Colord } from './colord';
-export { extend, Plugin } from './extend';
+export { colord, type Colord } from './colord';
+export { extend, type Plugin } from './extend';
 export { getFormat } from './parse';
 export { random } from './random';
-export { HslColor, HslaColor, HsvColor, HsvaColor, HwbColor, HwbaColor, LabColor, LabaColor, LchColor, LchaColor, RgbColor, RgbaColor, XyzColor, XyzaColor, AnyColor, } from './types';
+export type { HslColor, HslaColor, HsvColor, HsvaColor, HwbColor, HwbaColor, LabColor, LabaColor, LchColor, LchaColor, RgbColor, RgbaColor, XyzColor, XyzaColor, AnyColor, } from './types';

package/types/compose.d.ts

@@ -0,0 +1,19 @@
+type Func<T extends any[], R> = (...a: T) => R;
+/**
+ * Composes single-argument functions from right to left. The rightmost
+ * function can take multiple arguments as it provides the signature for the
+ * resulting composite function.
+ *
+ * @param funcs The functions to compose.
+ * @returns A function obtained by composing the argument functions from right
+ *   to left. For example, `compose(f, g, h)` is identical to doing
+ *   `(...args) => f(g(h(...args)))`.
+ */
+export default function compose(): <R>(a: R) => R;
+export default function compose<F extends Function>(f: F): F;
+export default function compose<A, T extends any[], R>(f1: (a: A) => R, f2: Func<T, A>): Func<T, R>;
+export default function compose<A, B, T extends any[], R>(f1: (b: B) => R, f2: (a: A) => B, f3: Func<T, A>): Func<T, R>;
+export default function compose<A, B, C, T extends any[], R>(f1: (c: C) => R, f2: (b: B) => C, f3: (a: A) => B, f4: Func<T, A>): Func<T, R>;
+export default function compose<R>(f1: (a: any) => R, ...funcs: Function[]): (...args: any[]) => R;
+export default function compose<R>(...funcs: Function[]): (...args: any[]) => R;
+export {};

package/types/data/mobx.d.ts

@@ -1,154 +1,2 @@
-export var $mobx: symbol;
-export function FlowCancellationError(): void;
-export class FlowCancellationError {
-    message: string;
-}
-export var ObservableMap: any;
-export var ObservableSet: any;
-export var Reaction: any;
-declare function allowStateChanges(allowStateChanges: any, func: any): any;
-export function runInAction(fn: any): any;
-declare function allowStateReadsEnd(prev: any): void;
-declare function allowStateReadsStart(allowStateReads: any): any;
-declare function autoAction(arg1: any, arg2: any): any;
-declare namespace autoAction {
-    let bound: any;
-}
-export function _endAction(runInfo: any): void;
-declare function getAdministration(thing: any, property: any): any;
-declare function getGlobalState(): any;
-declare function interceptReads(thing: any, propOrHandler: any, handler: any): void | (() => void);
-declare function isComputingDerivation(): boolean;
-/**
- * For testing purposes only; this will break the internal state of existing observables,
- * but can be used to get back at a stable state after throwing errors
- */
-declare function resetGlobalState(): void;
-export function _startAction(actionName: any, canRunAsDerivation: any, scope: any, args: any): {
-    runAsAction_: boolean;
-    prevDerivation_: any;
-    prevAllowStateChanges_: any;
-    prevAllowStateReads_: any;
-    notifySpy_: boolean;
-    startTime_: number;
-    actionId_: number;
-    parentActionId_: number;
-};
-export function action(arg1: any, arg2: any): any;
-export namespace action {
-    let bound_1: any;
-    export { bound_1 as bound };
-}
-/**
- * Creates a named reactive view and keeps it alive, so that the view is always
- * updated if one of the dependencies changes, even when the view is not further used by something else.
- * @param view The reactive view
- * @returns disposer function, which can be used to stop the view from being updated in the future.
- */
-export function autorun(view: any, opts: any): any;
-export namespace comparer {
-    export { identityComparer as identity };
-    export { structuralComparer as structural };
-    export { defaultComparer as default };
-    export { shallowComparer as shallow };
-}
-/**
- * Decorator for class properties: @computed get value() { return expr; }.
- * For legacy purposes also invokable as ES5 observable created: `computed(() => expr)`;
- */
-export function computed(arg1: any, arg2: any): any;
-export namespace computed {
-    let struct: any;
-}
-export function configure(options: any): void;
-export function createAtom(name: any, onBecomeObservedHandler: any, onBecomeUnobservedHandler: any): any;
-declare function apiDefineProperty(obj: any, key: any, descriptor: any): any;
-export function entries(obj: any): any;
-export function extendObservable(target: any, properties: any, annotations: any, options: any, ...args: any[]): any;
-export var flow: ((arg1: any, arg2: any, ...args: any[]) => any) & {
-    annotationType_: any;
-    options_: any;
-    make_: typeof make_$2;
-    extend_: typeof extend_$2;
-    decorate_20223_: typeof decorate_20223_$2;
-};
-export function flowResult(result: any): any;
-export function get(obj: any, key: any): any;
-export function getAtom(thing: any, property: any): any;
-export function getDebugName(thing: any, property: any): any;
-export function getDependencyTree(thing: any, property: any): {
-    name: any;
-};
-export function getObserverTree(thing: any, property: any): {
-    name: any;
-};
-export function has(obj: any, key: any): any;
-export function intercept(thing: any, propOrHandler: any, handler: any): any;
-export function isAction(thing: any): boolean;
-declare function isObservableValue(x: any): boolean;
-export function isComputed(value: any, ...args: any[]): boolean | void;
-export function isComputedProp(value: any, propName: any): boolean | void;
-export function isFlow(fn: any): boolean;
-export function isFlowCancellationError(error: any): error is FlowCancellationError;
-export function isObservable(value: any, ...args: any[]): any;
-export function isObservableArray(thing: any): boolean;
-export function isObservableMap(x: any): boolean;
-export function isObservableObject(thing: any): boolean;
-export function isObservableProp(value: any, propName: any): any;
-export function isObservableSet(x: any): boolean;
-export function keys(obj: any): any;
-export function makeAutoObservable(target: any, overrides: any, options: any): any;
-export function makeObservable(target: any, annotations: any, options: any): any;
-export var observable: typeof createObservable & {
-    box: (value: any, options: any) => any;
-    array: (initialValues: any, options: any) => any;
-    map: (initialValues: any, options: any) => any;
-    set: (initialValues: any, options: any) => any;
-    object: (props: any, decorators: any, options: any) => any;
-    ref: any;
-    shallow: any;
-    deep: any;
-    struct: any;
-};
-export function observe(thing: any, propOrCb: any, cbOrFire: any, fireImmediately: any): any;
-export function onBecomeObserved(thing: any, arg2: any, arg3: any): () => void;
-export function onBecomeUnobserved(thing: any, arg2: any, arg3: any): () => void;
-export function onReactionError(handler: any): () => void;
-export var override: any;
-declare function apiOwnKeys(obj: any): any;
-export function reaction(expression: any, effect: any, opts: any): any;
-export function remove(obj: any, key: any): void;
-export function set(obj: any, key: any, value: any, ...args: any[]): void;
-export function spy(listener: any): (...args: any[]) => any;
-/**
- * Recursively converts an observable to it's non-observable native counterpart.
- * It does NOT recurse into non-observables, these are left as they are, even if they contain observables.
- * Computed and other non-enumerable properties are completely ignored.
- * Complex scenarios require custom solution, eg implementing `toJSON` or using `serializr` lib.
- */
-export function toJS(source: any, options: any): any;
-export function trace(...args: any[]): void;
-/**
- * During a transaction no views are updated until the end of the transaction.
- * The transaction will be run synchronously nonetheless.
- *
- * @param action a function that updates some reactive state
- * @returns any value that was returned by the 'action' parameter.
- */
-export function transaction(action: any, thisArg: any): any;
-export function untracked(action: any): any;
-export function values(obj: any): any;
-export function when(predicate: any, arg1: any, arg2: any, ...args: any[]): any;
-declare function identityComparer(a: any, b: any): boolean;
-declare function structuralComparer(a: any, b: any): boolean;
-declare function defaultComparer(a: any, b: any): boolean;
-declare function shallowComparer(a: any, b: any): boolean;
-declare function make_$2(adm: any, key: any, descriptor: any, source: any): 0 | 1 | 2;
-declare function extend_$2(adm: any, key: any, descriptor: any, proxyTrap: any): any;
-declare function decorate_20223_$2(mthd: any, context: any): any;
-/**
- * Turns an object, array or function into a reactive structure.
- * @param v the value which should become observable.
- */
-declare function createObservable(v: any, arg2: any, arg3: any): any;
-export { allowStateChanges as _allowStateChanges, runInAction as _allowStateChangesInsideComputed, allowStateReadsEnd as _allowStateReadsEnd, allowStateReadsStart as _allowStateReadsStart, autoAction as _autoAction, getAdministration as _getAdministration, getGlobalState as _getGlobalState, interceptReads as _interceptReads, isComputingDerivation as _isComputingDerivation, resetGlobalState as _resetGlobalState, apiDefineProperty as defineProperty, isObservableValue as isBoxedObservable, apiOwnKeys as ownKeys };
+export { IObservable, IDepTreeNode, Reaction, IReactionPublic, IReactionDisposer, untracked, IAtom, createAtom, spy, IComputedValue, IEqualsComparer, comparer, IEnhancer, IInterceptable, IInterceptor, IListenable, IObjectWillChange, IObjectDidChange, isObservableObject, IValueDidChange, IValueWillChange, IObservableValue, isObservableValue as isBoxedObservable, IObservableArray, IArrayWillChange, IArrayWillSplice, IArraySplice, IArrayUpdate, IArrayDidChange, isObservableArray, IKeyValueMap, ObservableMap, IMapEntries, IMapEntry, IMapWillChange, IMapDidChange, isObservableMap, IObservableMapInitialValues, ObservableSet, isObservableSet, ISetDidChange, ISetWillChange, IObservableSetInitialValues, transaction, observable, IObservableFactory, CreateObservableOptions, computed, IComputedFactory, isObservable, isObservableProp, isComputed, isComputedProp, extendObservable, observe, intercept, autorun, IAutorunOptions, reaction, IReactionOptions, when, IWhenOptions, action, isAction, runInAction, IActionFactory, keys, values, entries, set, remove, has, get, apiOwnKeys as ownKeys, apiDefineProperty as defineProperty, configure, onBecomeObserved, onBecomeUnobserved, flow, isFlow, flowResult, FlowCancellationError, isFlowCancellationError, toJS, trace, IObserverTree, IDependencyTree, getDependencyTree, getObserverTree, resetGlobalState as _resetGlobalState, getGlobalState as _getGlobalState, getDebugName, getAtom, getAdministration as _getAdministration, allowStateChanges as _allowStateChanges, runInAction as _allowStateChangesInsideComputed, // This has become the default behavior in Mobx 6
+Lambda, $mobx, isComputingDerivation as _isComputingDerivation, onReactionError, interceptReads as _interceptReads, IComputedValueOptions, IActionRunInfo, _startAction, _endAction, allowStateReadsStart as _allowStateReadsStart, allowStateReadsEnd as _allowStateReadsEnd, makeObservable, makeAutoObservable, autoAction as _autoAction, AnnotationsMap, AnnotationMapEntry, override } from './mobx/internal';

package/types/data/redux/applyMiddleware.d.ts

@@ -0,0 +1,40 @@
+import { Middleware } from './types/middleware';
+import { StoreEnhancer } from './types/store';
+/**
+ * Creates a store enhancer that applies middleware to the dispatch method
+ * of the Redux store. This is handy for a variety of tasks, such as expressing
+ * asynchronous actions in a concise manner, or logging every action payload.
+ *
+ * See `redux-thunk` package as an example of the Redux middleware.
+ *
+ * Because middleware is potentially asynchronous, this should be the first
+ * store enhancer in the composition chain.
+ *
+ * Note that each middleware will be given the `dispatch` and `getState` functions
+ * as named arguments.
+ *
+ * @param middlewares The middleware chain to be applied.
+ * @returns A store enhancer applying the middleware.
+ *
+ * @template Ext Dispatch signature added by a middleware.
+ * @template S The type of the state supported by a middleware.
+ */
+export default function applyMiddleware(): StoreEnhancer;
+export default function applyMiddleware<Ext1, S>(middleware1: Middleware<Ext1, S, any>): StoreEnhancer<{
+    dispatch: Ext1;
+}>;
+export default function applyMiddleware<Ext1, Ext2, S>(middleware1: Middleware<Ext1, S, any>, middleware2: Middleware<Ext2, S, any>): StoreEnhancer<{
+    dispatch: Ext1 & Ext2;
+}>;
+export default function applyMiddleware<Ext1, Ext2, Ext3, S>(middleware1: Middleware<Ext1, S, any>, middleware2: Middleware<Ext2, S, any>, middleware3: Middleware<Ext3, S, any>): StoreEnhancer<{
+    dispatch: Ext1 & Ext2 & Ext3;
+}>;
+export default function applyMiddleware<Ext1, Ext2, Ext3, Ext4, S>(middleware1: Middleware<Ext1, S, any>, middleware2: Middleware<Ext2, S, any>, middleware3: Middleware<Ext3, S, any>, middleware4: Middleware<Ext4, S, any>): StoreEnhancer<{
+    dispatch: Ext1 & Ext2 & Ext3 & Ext4;
+}>;
+export default function applyMiddleware<Ext1, Ext2, Ext3, Ext4, Ext5, S>(middleware1: Middleware<Ext1, S, any>, middleware2: Middleware<Ext2, S, any>, middleware3: Middleware<Ext3, S, any>, middleware4: Middleware<Ext4, S, any>, middleware5: Middleware<Ext5, S, any>): StoreEnhancer<{
+    dispatch: Ext1 & Ext2 & Ext3 & Ext4 & Ext5;
+}>;
+export default function applyMiddleware<Ext, S = any>(...middlewares: Middleware<any, S, any>[]): StoreEnhancer<{
+    dispatch: Ext;
+}>;

package/types/data/redux/bindActionCreators.d.ts

@@ -0,0 +1,27 @@
+import { Dispatch } from './types/store';
+import { ActionCreator, ActionCreatorsMapObject } from './types/actions';
+/**
+ * Turns an object whose values are action creators, into an object with the
+ * same keys, but with every function wrapped into a `dispatch` call so they
+ * may be invoked directly. This is just a convenience method, as you can call
+ * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.
+ *
+ * For convenience, you can also pass an action creator as the first argument,
+ * and get a dispatch wrapped function in return.
+ *
+ * @param actionCreators An object whose values are action
+ * creator functions. One handy way to obtain it is to use `import * as`
+ * syntax. You may also pass a single function.
+ *
+ * @param dispatch The `dispatch` function available on your Redux
+ * store.
+ *
+ * @returns The object mimicking the original object, but with
+ * every action creator wrapped into the `dispatch` call. If you passed a
+ * function as `actionCreators`, the return value will also be a single
+ * function.
+ */
+export default function bindActionCreators<A, C extends ActionCreator<A>>(actionCreator: C, dispatch: Dispatch): C;
+export default function bindActionCreators<A extends ActionCreator<any>, B extends ActionCreator<any>>(actionCreator: A, dispatch: Dispatch): B;
+export default function bindActionCreators<A, M extends ActionCreatorsMapObject<A>>(actionCreators: M, dispatch: Dispatch): M;
+export default function bindActionCreators<M extends ActionCreatorsMapObject, N extends ActionCreatorsMapObject>(actionCreators: M, dispatch: Dispatch): N;

package/types/data/redux/combineReducers.d.ts

@@ -0,0 +1,20 @@
+import { ActionFromReducersMapObject, PreloadedStateShapeFromReducersMapObject, Reducer, StateFromReducersMapObject } from './types/reducers';
+/**
+ * Turns an object whose values are different reducer functions, into a single
+ * reducer function. It will call every child reducer, and gather their results
+ * into a single state object, whose keys correspond to the keys of the passed
+ * reducer functions.
+ *
+ * @template S Combined state object type.
+ *
+ * @param reducers An object whose values correspond to different reducer
+ *   functions that need to be combined into one. One handy way to obtain it
+ *   is to use `import * as reducers` syntax. The reducers may never
+ *   return undefined for any action. Instead, they should return their
+ *   initial state if the state passed to them was undefined, and the current
+ *   state for any unrecognized action.
+ *
+ * @returns A reducer function that invokes every reducer inside the passed
+ *   object, and builds a state object with the same shape.
+ */
+export default function combineReducers<M>(reducers: M): M[keyof M] extends Reducer<any, any, any> | undefined ? Reducer<StateFromReducersMapObject<M>, ActionFromReducersMapObject<M>, Partial<PreloadedStateShapeFromReducersMapObject<M>>> : never;

package/types/data/redux/compose.d.ts

@@ -0,0 +1,19 @@
+type Func<T extends any[], R> = (...a: T) => R;
+/**
+ * Composes single-argument functions from right to left. The rightmost
+ * function can take multiple arguments as it provides the signature for the
+ * resulting composite function.
+ *
+ * @param funcs The functions to compose.
+ * @returns A function obtained by composing the argument functions from right
+ *   to left. For example, `compose(f, g, h)` is identical to doing
+ *   `(...args) => f(g(h(...args)))`.
+ */
+export default function compose(): <R>(a: R) => R;
+export default function compose<F extends Function>(f: F): F;
+export default function compose<A, T extends any[], R>(f1: (a: A) => R, f2: Func<T, A>): Func<T, R>;
+export default function compose<A, B, T extends any[], R>(f1: (b: B) => R, f2: (a: A) => B, f3: Func<T, A>): Func<T, R>;
+export default function compose<A, B, C, T extends any[], R>(f1: (c: C) => R, f2: (b: B) => C, f3: (a: A) => B, f4: Func<T, A>): Func<T, R>;
+export default function compose<R>(f1: (a: any) => R, ...funcs: Function[]): (...args: any[]) => R;
+export default function compose<R>(...funcs: Function[]): (...args: any[]) => R;
+export {};

package/types/data/redux/createStore.d.ts

@@ -0,0 +1,126 @@
+import { Store, StoreEnhancer, UnknownIfNonSpecific } from './types/store';
+import { Action } from './types/actions';
+import { Reducer } from './types/reducers';
+/**
+ * Prevents TypeScript from inferring a generic type parameter.
+ *
+ * @template T - The type to prevent inference for.
+ *
+ * @internal
+ */
+type NoInfer<T> = [T][T extends any ? 0 : never];
+/**
+ * @deprecated
+ *
+ * **We recommend using the `configureStore` method
+ * of the `@reduxjs/toolkit` package**, which replaces `createStore`.
+ *
+ * Redux Toolkit is our recommended approach for writing Redux logic today,
+ * including store setup, reducers, data fetching, and more.
+ *
+ * **For more details, please read this Redux docs page:**
+ * **https://redux.js.org/introduction/why-rtk-is-redux-today**
+ *
+ * `configureStore` from Redux Toolkit is an improved version of `createStore` that
+ * simplifies setup and helps avoid common bugs.
+ *
+ * You should not be using the `redux` core package by itself today, except for learning purposes.
+ * The `createStore` method from the core `redux` package will not be removed, but we encourage
+ * all users to migrate to using Redux Toolkit for all Redux code.
+ *
+ * If you want to use `createStore` without this visual deprecation warning, use
+ * the `legacy_createStore` import instead:
+ *
+ * `import { legacy_createStore as createStore} from 'redux'`
+ *
+ */
+export declare function createStore<S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}>(reducer: Reducer<S, A>, enhancer?: StoreEnhancer<Ext, StateExt>): Store<S, A, UnknownIfNonSpecific<StateExt>> & NoInfer<Ext>;
+/**
+ * @deprecated
+ *
+ * **We recommend using the `configureStore` method
+ * of the `@reduxjs/toolkit` package**, which replaces `createStore`.
+ *
+ * Redux Toolkit is our recommended approach for writing Redux logic today,
+ * including store setup, reducers, data fetching, and more.
+ *
+ * **For more details, please read this Redux docs page:**
+ * **https://redux.js.org/introduction/why-rtk-is-redux-today**
+ *
+ * `configureStore` from Redux Toolkit is an improved version of `createStore` that
+ * simplifies setup and helps avoid common bugs.
+ *
+ * You should not be using the `redux` core package by itself today, except for learning purposes.
+ * The `createStore` method from the core `redux` package will not be removed, but we encourage
+ * all users to migrate to using Redux Toolkit for all Redux code.
+ *
+ * If you want to use `createStore` without this visual deprecation warning, use
+ * the `legacy_createStore` import instead:
+ *
+ * `import { legacy_createStore as createStore} from 'redux'`
+ *
+ */
+export declare function createStore<S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}, PreloadedState = S>(reducer: Reducer<S, A, PreloadedState>, preloadedState?: PreloadedState | undefined, enhancer?: StoreEnhancer<Ext, StateExt>): Store<S, A, UnknownIfNonSpecific<StateExt>> & NoInfer<Ext>;
+/**
+ * Creates a Redux store that holds the state tree.
+ *
+ * **We recommend using `configureStore` from the
+ * `@reduxjs/toolkit` package**, which replaces `createStore`:
+ * **https://redux.js.org/introduction/why-rtk-is-redux-today**
+ *
+ * The only way to change the data in the store is to call `dispatch()` on it.
+ *
+ * There should only be a single store in your app. To specify how different
+ * parts of the state tree respond to actions, you may combine several reducers
+ * into a single reducer function by using `combineReducers`.
+ *
+ * @param {Function} reducer A function that returns the next state tree, given
+ * the current state tree and the action to handle.
+ *
+ * @param {any} [preloadedState] The initial state. You may optionally specify it
+ * to hydrate the state from the server in universal apps, or to restore a
+ * previously serialized user session.
+ * If you use `combineReducers` to produce the root reducer function, this must be
+ * an object with the same shape as `combineReducers` keys.
+ *
+ * @param {Function} [enhancer] The store enhancer. You may optionally specify it
+ * to enhance the store with third-party capabilities such as middleware,
+ * time travel, persistence, etc. The only store enhancer that ships with Redux
+ * is `applyMiddleware()`.
+ *
+ * @returns {Store} A Redux store that lets you read the state, dispatch actions
+ * and subscribe to changes.
+ */
+export declare function legacy_createStore<S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}>(reducer: Reducer<S, A>, enhancer?: StoreEnhancer<Ext, StateExt>): Store<S, A, UnknownIfNonSpecific<StateExt>> & Ext;
+/**
+ * Creates a Redux store that holds the state tree.
+ *
+ * **We recommend using `configureStore` from the
+ * `@reduxjs/toolkit` package**, which replaces `createStore`:
+ * **https://redux.js.org/introduction/why-rtk-is-redux-today**
+ *
+ * The only way to change the data in the store is to call `dispatch()` on it.
+ *
+ * There should only be a single store in your app. To specify how different
+ * parts of the state tree respond to actions, you may combine several reducers
+ * into a single reducer function by using `combineReducers`.
+ *
+ * @param {Function} reducer A function that returns the next state tree, given
+ * the current state tree and the action to handle.
+ *
+ * @param {any} [preloadedState] The initial state. You may optionally specify it
+ * to hydrate the state from the server in universal apps, or to restore a
+ * previously serialized user session.
+ * If you use `combineReducers` to produce the root reducer function, this must be
+ * an object with the same shape as `combineReducers` keys.
+ *
+ * @param {Function} [enhancer] The store enhancer. You may optionally specify it
+ * to enhance the store with third-party capabilities such as middleware,
+ * time travel, persistence, etc. The only store enhancer that ships with Redux
+ * is `applyMiddleware()`.
+ *
+ * @returns {Store} A Redux store that lets you read the state, dispatch actions
+ * and subscribe to changes.
+ */
+export declare function legacy_createStore<S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}, PreloadedState = S>(reducer: Reducer<S, A, PreloadedState>, preloadedState?: PreloadedState | undefined, enhancer?: StoreEnhancer<Ext, StateExt>): Store<S, A, UnknownIfNonSpecific<StateExt>> & Ext;
+export {};

package/types/data/redux/index.d.ts

@@ -0,0 +1,14 @@
+import { createStore, legacy_createStore } from './createStore';
+import { default as combineReducers } from './combineReducers';
+import { default as bindActionCreators } from './bindActionCreators';
+import { default as applyMiddleware } from './applyMiddleware';
+import { default as compose } from './compose';
+import { default as isAction } from './utils/isAction';
+import { default as isPlainObject } from './utils/isPlainObject';
+import { default as ___DO_NOT_USE__ActionTypes } from './utils/actionTypes';
+export type { Dispatch, Unsubscribe, Observable, Observer, Store, StoreCreator, StoreEnhancer, StoreEnhancerStoreCreator } from './types/store';
+export type { Reducer, ReducersMapObject, StateFromReducersMapObject, ReducerFromReducersMapObject, ActionFromReducer, ActionFromReducersMapObject, PreloadedStateShapeFromReducersMapObject } from './types/reducers';
+export type { ActionCreator, ActionCreatorsMapObject } from './types/actions';
+export type { MiddlewareAPI, Middleware } from './types/middleware';
+export type { Action, UnknownAction, AnyAction } from './types/actions';
+export { createStore, legacy_createStore, combineReducers, bindActionCreators, applyMiddleware, compose, isAction, isPlainObject, __DO_NOT_USE__ActionTypes };

package/types/data/redux/types/actions.d.ts

@@ -0,0 +1,64 @@
+/**
+ * An *action* is a plain object that represents an intention to change the
+ * state. Actions are the only way to get data into the store. Any data,
+ * whether from UI events, network callbacks, or other sources such as
+ * WebSockets needs to eventually be dispatched as actions.
+ *
+ * Actions must have a `type` field that indicates the type of action being
+ * performed. Types can be defined as constants and imported from another
+ * module. These must be strings, as strings are serializable.
+ *
+ * Other than `type`, the structure of an action object is really up to you.
+ * If you're interested, check out Flux Standard Action for recommendations on
+ * how actions should be constructed.
+ *
+ * @template T the type of the action's `type` tag.
+ */
+export type Action<T extends string = string> = {
+    type: T;
+};
+/**
+ * An Action type which accepts any other properties.
+ * This is mainly for the use of the `Reducer` type.
+ * This is not part of `Action` itself to prevent types that extend `Action` from
+ * having an index signature.
+ */
+export interface UnknownAction extends Action {
+    [extraProps: string]: unknown;
+}
+/**
+ * An Action type which accepts any other properties.
+ * This is mainly for the use of the `Reducer` type.
+ * This is not part of `Action` itself to prevent types that extend `Action` from
+ * having an index signature.
+ * @deprecated use Action or UnknownAction instead
+ */
+export interface AnyAction extends Action {
+    [extraProps: string]: any;
+}
+/**
+ * An *action creator* is, quite simply, a function that creates an action. Do
+ * not confuse the two terms—again, an action is a payload of information, and
+ * an action creator is a factory that creates an action.
+ *
+ * Calling an action creator only produces an action, but does not dispatch
+ * it. You need to call the store's `dispatch` function to actually cause the
+ * mutation. Sometimes we say *bound action creators* to mean functions that
+ * call an action creator and immediately dispatch its result to a specific
+ * store instance.
+ *
+ * If an action creator needs to read the current state, perform an API call,
+ * or cause a side effect, like a routing transition, it should return an
+ * async action instead of an action.
+ *
+ * @template A Returned action type.
+ */
+export interface ActionCreator<A, P extends any[] = any[]> {
+    (...args: P): A;
+}
+/**
+ * Object whose values are action creator functions.
+ */
+export interface ActionCreatorsMapObject<A = any, P extends any[] = any[]> {
+    [key: string]: ActionCreator<A, P>;
+}

package/types/data/redux/types/middleware.d.ts

@@ -0,0 +1,23 @@
+import { Dispatch } from './store';
+export interface MiddlewareAPI<D extends Dispatch = Dispatch, S = any> {
+    dispatch: D;
+    getState: () => S;
+}
+/**
+ * A middleware is a higher-order function that composes a dispatch function
+ * to return a new dispatch function. It often turns async actions into
+ * actions.
+ *
+ * Middleware is composable using function composition. It is useful for
+ * logging actions, performing side effects like routing, or turning an
+ * asynchronous API call into a series of synchronous actions.
+ *
+ * @template DispatchExt Extra Dispatch signature added by this middleware.
+ * @template S The type of the state supported by this middleware.
+ * @template D The type of Dispatch of the store where this middleware is
+ *   installed.
+ */
+export interface Middleware<_DispatchExt = {}, // TODO: see if this can be used in type definition somehow (can't be removed, as is used to get final dispatch type)
+S = any, D extends Dispatch = Dispatch> {
+    (api: MiddlewareAPI<D, S>): (next: (action: unknown) => unknown) => (action: unknown) => unknown;
+}

package/types/data/redux/types/reducers.d.ts

@@ -0,0 +1,71 @@
+import { Action, UnknownAction } from './actions';
+/**
+ * A *reducer* is a function that accepts
+ * an accumulation and a value and returns a new accumulation. They are used
+ * to reduce a collection of values down to a single value
+ *
+ * Reducers are not unique to Redux—they are a fundamental concept in
+ * functional programming.  Even most non-functional languages, like
+ * JavaScript, have a built-in API for reducing. In JavaScript, it's
+ * `Array.prototype.reduce()`.
+ *
+ * In Redux, the accumulated value is the state object, and the values being
+ * accumulated are actions. Reducers calculate a new state given the previous
+ * state and an action. They must be *pure functions*—functions that return
+ * the exact same output for given inputs. They should also be free of
+ * side-effects. This is what enables exciting features like hot reloading and
+ * time travel.
+ *
+ * Reducers are the most important concept in Redux.
+ *
+ * *Do not put API calls into reducers.*
+ *
+ * @template S The type of state consumed and produced by this reducer.
+ * @template A The type of actions the reducer can potentially respond to.
+ * @template PreloadedState The type of state consumed by this reducer the first time it's called.
+ */
+export type Reducer<S = any, A extends Action = UnknownAction, PreloadedState = S> = (state: S | PreloadedState | undefined, action: A) => S;
+/**
+ * Object whose values correspond to different reducer functions.
+ *
+ * @template S The combined state of the reducers.
+ * @template A The type of actions the reducers can potentially respond to.
+ * @template PreloadedState The combined preloaded state of the reducers.
+ */
+export type ReducersMapObject<S = any, A extends Action = UnknownAction, PreloadedState = S> = keyof PreloadedState extends keyof S ? {
+    [K in keyof S]: Reducer<S[K], A, K extends keyof PreloadedState ? PreloadedState[K] : never>;
+} : never;
+/**
+ * Infer a combined state shape from a `ReducersMapObject`.
+ *
+ * @template M Object map of reducers as provided to `combineReducers(map: M)`.
+ */
+export type StateFromReducersMapObject<M> = M[keyof M] extends Reducer<any, any, any> | undefined ? {
+    [P in keyof M]: M[P] extends Reducer<infer S, any, any> ? S : never;
+} : never;
+/**
+ * Infer reducer union type from a `ReducersMapObject`.
+ *
+ * @template M Object map of reducers as provided to `combineReducers(map: M)`.
+ */
+export type ReducerFromReducersMapObject<M> = M[keyof M] extends Reducer<any, any, any> | undefined ? M[keyof M] : never;
+/**
+ * Infer action type from a reducer function.
+ *
+ * @template R Type of reducer.
+ */
+export type ActionFromReducer<R> = R extends Reducer<any, infer A, any> ? A : never;
+/**
+ * Infer action union type from a `ReducersMapObject`.
+ *
+ * @template M Object map of reducers as provided to `combineReducers(map: M)`.
+ */
+export type ActionFromReducersMapObject<M> = ActionFromReducer<ReducerFromReducersMapObject<M>>;
+/**
+ * Infer a combined preloaded state shape from a `ReducersMapObject`.
+ *
+ * @template M Object map of reducers as provided to `combineReducers(map: M)`.
+ */
+export type PreloadedStateShapeFromReducersMapObject<M> = M[keyof M] extends Reducer<any, any, any> | undefined ? {
+    [P in keyof M]: M[P] extends (inputState: infer InputState, action: ActionFromReducersMapObject<M>) => any ? InputState : never;
+} : never;