@itwin/appui-react 3.5.0-dev.14 → 3.5.0-dev.18

package/lib/esm/appui-react/redux/redux-ts.d.ts

@@ -1,198 +1,198 @@
-/** @packageDocumentation
- * @module State
- */
-/** Shorthand for "any function".  TSLint doesn't like the built-in `Function` type for some reason.
- * @public
- */
-export declare type FunctionType = (...args: any[]) => any;
-/**
- * Similar to the built-in [Readonly](https://www.typescriptlang.org/docs/handbook/advanced-types.html#mapped-types), type alias but applied recursively.
- * This basically makes all nested properties/members of an object/array immutable.
- * @public
- */
-export declare type DeepReadonly<T> = T extends ReadonlyArray<infer R> ? (R extends object ? DeepReadonlyArray<R> : ReadonlyArray<R>) : T extends FunctionType ? T : T extends object ? DeepReadonlyObject<T> : T;
-/** TypeScript doesn't actually allow recursive type aliases, so these are just sort of a hack to make DeepReadonly work
- * @public
- */
-export interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> {
-}
-/** TypeScript doesn't actually allow recursive type aliases, so these are just sort of a hack to make DeepReadonly work
- * @public
- */
-export declare type DeepReadonlyObject<T> = {
-    readonly [P in keyof T]: DeepReadonly<T[P]>;
-};
-/**
- * A basic Redux [Action](https://redux.js.org/basics/actions).
- * Technically, redux only requires actions to have a `type` property.
- *
- * We use a TypeScript [Generic](https://www.typescriptlang.org/docs/handbook/generics.html) interface here to preserve the "literal-ness" of the `type` property.
- * In other words, `Action<"FOO">` will be of type `{ type: "FOO" }`; it won't be simplified to `{ type: string }`.
- *
- * See the [TS Handbook](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types) for more info on TypeScript string literal types.
- * @public
- */
-export interface Action<T extends string> {
-    type: T;
-}
-/**
- * A Redux [Action](https://redux.js.org/basics/actions), with additional "payload" information.
- * Technically, Redux allows actions to take any shape, provided they specify a `type` property.
- *
- * However, in order to simplify TypeScript typings, we follow this [Flux Standard Actions](https://github.com/redux-utilities/flux-standard-action)-like
- * convention, where all additional action information goes into a `payload` property.
- * @public
- */
-export interface ActionWithPayload<T extends string, P> extends Action<T> {
-    payload: P;
-}
-/**
- * Creates a basic Redux Redux [Action](https://redux.js.org/basics/actions) without a payload.
- * **This is meant to be used as a shortcut for defining Action Creators.**
- *
- * For example,
- * ```
- *   () => createAction("FOO", ids)
- * ```
- * defines an action creator of type:
- * ```
- *   () => { type: "FOO" }
- *   // which is equivalent to:
- *   () => Action<"FOO">
- * ```
- *
- * Note that the generic type parameters can always be omitted - TypeScript will be able to infer them.
- * @param type The string to use as the action's type property. Should have a [string literal type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types).
- * @public
- */
-export declare function createAction<T extends string>(type: T): Action<T>;
-/**
- * Creates a basic Redux Redux [Action](https://redux.js.org/basics/actions) _with_ a payload value.
- * **This is meant to be used as a shortcut for defining Action Creators.**
- *
- * For example,
- * ```
- *   (ids: number[]) => createAction("FOO", ids)
- * ```
- * defines an action creator of type:
- * ```
- *   (ids: number[]) => { type: "FOO", payload: ReadonlyArray<number> }
- *   // which is equivalent to:
- *   (ids: number[]) => ActionWithPayload<"FOO", ReadonlyArray<number>>
- * ```
- *
- * Note that the generic type parameters can always be omitted - TypeScript will be able to infer them.
- * @param type The string to use as the action's type property. Should have a [string literal type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types).
- * @param payload The value to use as the action's payload property. May be of any type.
- * @public
- */
-export declare function createAction<T extends string, P>(type: T, payload: P): ActionWithPayload<T, DeepReadonly<P>>;
-/**
- * Just an object where every property is a Redux [Action Creator](https://redux.js.org/basics/actions#action-creators).
- * @public
- */
-export declare type ActionCreatorsObject = {
-    [actionCreatorName: string]: FunctionType;
-};
-/**
- * A TypeScript type alias that represents the [Union Type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#union-types) of all actions
- * possibly created by _any_ of the action creators in a given `ActionCreatorsObject`.
- *
- * For example,
- * ```
- *   // given:
- *   const MyActionCreators = {
- *     createBanana: () => createAction("BANANA"),
- *     createApple:  () => createAction("APPLE", true),
- *     createOrange: (n: number) => createAction("BANANA", n),
- *   }
- *   // then:
- *   type X = ActionsUnion<typeof MyActionCreators>;
- *   // is equivalent to:
- *   type X = Action<"BANANA">
- *            | ActionWithPayload<"APPLE", boolean>
- *            | ActionWithPayload<"ORANGE", number>;
- * ```
- * @public
- */
-export declare type ActionsUnion<A extends ActionCreatorsObject> = ReturnType<A[keyof A]>;
-/**
- * A TypeScript type alias that uses [conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html) (read: magic)
- * to represent the _exact_ (literal) type of an action's `type` property.
- *
- * More importantly, this can be used to determine a union type which represents the `type` string literal types for _any_ action in a given `ActionsUnion`.
- *
- * For example,
- * ```
- *   // given:
- *   type MyActions = Action<"BANANA">
- *                    | ActionWithPayload<"APPLE", boolean>
- *                    | ActionWithPayload<"ORANGE", number>;
- *   // then:
- *   type X = ActionTypes<MyActions>;
- *   // is equivalent to:
- *   type X = "BANANA" | "APPLE" | "ORANGE";
- * ```
- * @public
- */
-export declare type ActionTypes<A extends Action<any>> = A["type"] extends infer X ? (X extends string ? X : never) : never;
-/**
- * A Redux [Reducer](https://redux.js.org/basics/reducers).
- * @public
- */
-export declare type Reducer<S, A> = (state: S, action: A) => S;
-/**
- * A TypeScript type alias that represents a union of all action types handled by a Redux [Reducer](https://redux.js.org/basics/reducers).
- *
- * If you have created a type-safe reducer function using `combineReducers`, you can use this to infer your actions union type instead of having to define it manually.
- * @public
- */
-export declare type ReducerActions<R> = R extends Reducer<any, infer X> ? (X extends ActionWithPayload<infer T, infer P> ? DeepReadonly<ActionWithPayload<T, P>> : X extends Action<infer T2> ? DeepReadonly<Action<T2>> : X) : R;
-/**
- * A TypeScript type alias that represents the return type of a Redux [Reducer](https://redux.js.org/basics/reducers).
- *
- * If you have created a type-safe reducer function using `combineReducers`, you can use this to infer your state type instead of having to define it manually.
- * @public
- */
-export declare type StateType<R extends Reducer<any, any>> = DeepReadonly<ReturnType<R>>;
-/**
- * So we don't actually need to implement our own version of combineReducers, but we are going to cast it
- * to this type, which will do a better job of preserving/deducing the Action and State types.
- * @public
- */
-export declare type CombineReducersFunction = <A>(reducers: A) => (state: CombinedReducerState<A>, action: ReducerMapActions<A>) => CombinedReducerState<A>;
-/**
- * A type alias which represents the state created by the reducer returned by combineReducers for a given `reducers` argument.
- * Used above by `CombineReducersFunction`, our custom type definition for combineReducers.
- * @public
- */
-export declare type CombinedReducerState<R> = {
-    readonly [K in keyof R]: R[K] extends FunctionType ? StateType<R[K]> : never;
-};
-/**
- * A type alias which represents the union type of all actions handled by the reducer returned by combineReducers for a given `reducers` argument.
- * Used above by `CombineReducersFunction`, our custom type definition for combineReducers.
- * @public
- */
-export declare type ReducerMapActions<R> = ReducerActions<R[keyof R]>;
-/**
- * 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 ES6 `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.
- * @public
- */
-export declare const combineReducers: CombineReducersFunction;
+/** @packageDocumentation
+ * @module State
+ */
+/** Shorthand for "any function".  TSLint doesn't like the built-in `Function` type for some reason.
+ * @public
+ */
+export declare type FunctionType = (...args: any[]) => any;
+/**
+ * Similar to the built-in [Readonly](https://www.typescriptlang.org/docs/handbook/advanced-types.html#mapped-types), type alias but applied recursively.
+ * This basically makes all nested properties/members of an object/array immutable.
+ * @public
+ */
+export declare type DeepReadonly<T> = T extends ReadonlyArray<infer R> ? (R extends object ? DeepReadonlyArray<R> : ReadonlyArray<R>) : T extends FunctionType ? T : T extends object ? DeepReadonlyObject<T> : T;
+/** TypeScript doesn't actually allow recursive type aliases, so these are just sort of a hack to make DeepReadonly work
+ * @public
+ */
+export interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> {
+}
+/** TypeScript doesn't actually allow recursive type aliases, so these are just sort of a hack to make DeepReadonly work
+ * @public
+ */
+export declare type DeepReadonlyObject<T> = {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+};
+/**
+ * A basic Redux [Action](https://redux.js.org/basics/actions).
+ * Technically, redux only requires actions to have a `type` property.
+ *
+ * We use a TypeScript [Generic](https://www.typescriptlang.org/docs/handbook/generics.html) interface here to preserve the "literal-ness" of the `type` property.
+ * In other words, `Action<"FOO">` will be of type `{ type: "FOO" }`; it won't be simplified to `{ type: string }`.
+ *
+ * See the [TS Handbook](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types) for more info on TypeScript string literal types.
+ * @public
+ */
+export interface Action<T extends string> {
+    type: T;
+}
+/**
+ * A Redux [Action](https://redux.js.org/basics/actions), with additional "payload" information.
+ * Technically, Redux allows actions to take any shape, provided they specify a `type` property.
+ *
+ * However, in order to simplify TypeScript typings, we follow this [Flux Standard Actions](https://github.com/redux-utilities/flux-standard-action)-like
+ * convention, where all additional action information goes into a `payload` property.
+ * @public
+ */
+export interface ActionWithPayload<T extends string, P> extends Action<T> {
+    payload: P;
+}
+/**
+ * Creates a basic Redux Redux [Action](https://redux.js.org/basics/actions) without a payload.
+ * **This is meant to be used as a shortcut for defining Action Creators.**
+ *
+ * For example,
+ * ```
+ *   () => createAction("FOO", ids)
+ * ```
+ * defines an action creator of type:
+ * ```
+ *   () => { type: "FOO" }
+ *   // which is equivalent to:
+ *   () => Action<"FOO">
+ * ```
+ *
+ * Note that the generic type parameters can always be omitted - TypeScript will be able to infer them.
+ * @param type The string to use as the action's type property. Should have a [string literal type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types).
+ * @public
+ */
+export declare function createAction<T extends string>(type: T): Action<T>;
+/**
+ * Creates a basic Redux Redux [Action](https://redux.js.org/basics/actions) _with_ a payload value.
+ * **This is meant to be used as a shortcut for defining Action Creators.**
+ *
+ * For example,
+ * ```
+ *   (ids: number[]) => createAction("FOO", ids)
+ * ```
+ * defines an action creator of type:
+ * ```
+ *   (ids: number[]) => { type: "FOO", payload: ReadonlyArray<number> }
+ *   // which is equivalent to:
+ *   (ids: number[]) => ActionWithPayload<"FOO", ReadonlyArray<number>>
+ * ```
+ *
+ * Note that the generic type parameters can always be omitted - TypeScript will be able to infer them.
+ * @param type The string to use as the action's type property. Should have a [string literal type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types).
+ * @param payload The value to use as the action's payload property. May be of any type.
+ * @public
+ */
+export declare function createAction<T extends string, P>(type: T, payload: P): ActionWithPayload<T, DeepReadonly<P>>;
+/**
+ * Just an object where every property is a Redux [Action Creator](https://redux.js.org/basics/actions#action-creators).
+ * @public
+ */
+export declare type ActionCreatorsObject = {
+    [actionCreatorName: string]: FunctionType;
+};
+/**
+ * A TypeScript type alias that represents the [Union Type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#union-types) of all actions
+ * possibly created by _any_ of the action creators in a given `ActionCreatorsObject`.
+ *
+ * For example,
+ * ```
+ *   // given:
+ *   const MyActionCreators = {
+ *     createBanana: () => createAction("BANANA"),
+ *     createApple:  () => createAction("APPLE", true),
+ *     createOrange: (n: number) => createAction("BANANA", n),
+ *   }
+ *   // then:
+ *   type X = ActionsUnion<typeof MyActionCreators>;
+ *   // is equivalent to:
+ *   type X = Action<"BANANA">
+ *            | ActionWithPayload<"APPLE", boolean>
+ *            | ActionWithPayload<"ORANGE", number>;
+ * ```
+ * @public
+ */
+export declare type ActionsUnion<A extends ActionCreatorsObject> = ReturnType<A[keyof A]>;
+/**
+ * A TypeScript type alias that uses [conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html) (read: magic)
+ * to represent the _exact_ (literal) type of an action's `type` property.
+ *
+ * More importantly, this can be used to determine a union type which represents the `type` string literal types for _any_ action in a given `ActionsUnion`.
+ *
+ * For example,
+ * ```
+ *   // given:
+ *   type MyActions = Action<"BANANA">
+ *                    | ActionWithPayload<"APPLE", boolean>
+ *                    | ActionWithPayload<"ORANGE", number>;
+ *   // then:
+ *   type X = ActionTypes<MyActions>;
+ *   // is equivalent to:
+ *   type X = "BANANA" | "APPLE" | "ORANGE";
+ * ```
+ * @public
+ */
+export declare type ActionTypes<A extends Action<any>> = A["type"] extends infer X ? (X extends string ? X : never) : never;
+/**
+ * A Redux [Reducer](https://redux.js.org/basics/reducers).
+ * @public
+ */
+export declare type Reducer<S, A> = (state: S, action: A) => S;
+/**
+ * A TypeScript type alias that represents a union of all action types handled by a Redux [Reducer](https://redux.js.org/basics/reducers).
+ *
+ * If you have created a type-safe reducer function using `combineReducers`, you can use this to infer your actions union type instead of having to define it manually.
+ * @public
+ */
+export declare type ReducerActions<R> = R extends Reducer<any, infer X> ? (X extends ActionWithPayload<infer T, infer P> ? DeepReadonly<ActionWithPayload<T, P>> : X extends Action<infer T2> ? DeepReadonly<Action<T2>> : X) : R;
+/**
+ * A TypeScript type alias that represents the return type of a Redux [Reducer](https://redux.js.org/basics/reducers).
+ *
+ * If you have created a type-safe reducer function using `combineReducers`, you can use this to infer your state type instead of having to define it manually.
+ * @public
+ */
+export declare type StateType<R extends Reducer<any, any>> = DeepReadonly<ReturnType<R>>;
+/**
+ * So we don't actually need to implement our own version of combineReducers, but we are going to cast it
+ * to this type, which will do a better job of preserving/deducing the Action and State types.
+ * @public
+ */
+export declare type CombineReducersFunction = <A>(reducers: A) => (state: CombinedReducerState<A>, action: ReducerMapActions<A>) => CombinedReducerState<A>;
+/**
+ * A type alias which represents the state created by the reducer returned by combineReducers for a given `reducers` argument.
+ * Used above by `CombineReducersFunction`, our custom type definition for combineReducers.
+ * @public
+ */
+export declare type CombinedReducerState<R> = {
+    readonly [K in keyof R]: R[K] extends FunctionType ? StateType<R[K]> : never;
+};
+/**
+ * A type alias which represents the union type of all actions handled by the reducer returned by combineReducers for a given `reducers` argument.
+ * Used above by `CombineReducersFunction`, our custom type definition for combineReducers.
+ * @public
+ */
+export declare type ReducerMapActions<R> = ReducerActions<R[keyof R]>;
+/**
+ * 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 ES6 `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.
+ * @public
+ */
+export declare const combineReducers: CombineReducersFunction;
 //# sourceMappingURL=redux-ts.d.ts.map

package/lib/esm/appui-react/redux/redux-ts.js

@@ -1,33 +1,33 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module State
- */
-import { combineReducers as baseCombineReducers } from "redux";
-export function createAction(type, payload) {
-    return (payload === undefined) ? /* istanbul ignore next */ { type } : { type, payload };
-}
-// Since the implementation is copied from redux, we'll copy the docs as well:
-/**
- * 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 ES6 `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.
- * @public
- */
-export const combineReducers = baseCombineReducers;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module State
+ */
+import { combineReducers as baseCombineReducers } from "redux";
+export function createAction(type, payload) {
+    return (payload === undefined) ? /* istanbul ignore next */ { type } : { type, payload };
+}
+// Since the implementation is copied from redux, we'll copy the docs as well:
+/**
+ * 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 ES6 `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.
+ * @public
+ */
+export const combineReducers = baseCombineReducers;
 //# sourceMappingURL=redux-ts.js.map

package/lib/esm/appui-react/redux/redux-ts.js.map

@@ -1 +1 @@
-{"version":3,"file":"redux-ts.js","sourceRoot":"","sources":["../../../../src/appui-react/redux/redux-ts.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG;AAEH,OAAO,EAAE,eAAe,IAAI,mBAAmB,EAAE,MAAM,OAAO,CAAC;AAkG/D,MAAM,UAAU,YAAY,CAAsB,IAAO,EAAE,OAAW;IACpE,OAAO,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,0BAA0B,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AAC3F,CAAC;AAuGD,8EAA8E;AAC9E;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,eAAe,GAA4B,mBAA0B,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module State\n */\n\nimport { combineReducers as baseCombineReducers } from \"redux\";\n\n/* eslint-disable */\n\n/** Shorthand for \"any function\".  TSLint doesn't like the built-in `Function` type for some reason.\n * @public\n */\nexport type FunctionType = (...args: any[]) => any;\n\n/**\n * Similar to the built-in [Readonly](https://www.typescriptlang.org/docs/handbook/advanced-types.html#mapped-types), type alias but applied recursively.\n * This basically makes all nested properties/members of an object/array immutable.\n * @public\n */\nexport type DeepReadonly<T> =\n  T extends ReadonlyArray<infer R> ? (R extends object ? DeepReadonlyArray<R> : ReadonlyArray<R>) :\n  T extends FunctionType ? T :\n  T extends object ? DeepReadonlyObject<T> :\n  T;\n\n/** TypeScript doesn't actually allow recursive type aliases, so these are just sort of a hack to make DeepReadonly work\n * @public\n */\nexport interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> { }\n/** TypeScript doesn't actually allow recursive type aliases, so these are just sort of a hack to make DeepReadonly work\n * @public\n */\nexport type DeepReadonlyObject<T> = {\n  readonly [P in keyof T]: DeepReadonly<T[P]>;\n};\n\n/**\n * A basic Redux [Action](https://redux.js.org/basics/actions).\n * Technically, redux only requires actions to have a `type` property.\n *\n * We use a TypeScript [Generic](https://www.typescriptlang.org/docs/handbook/generics.html) interface here to preserve the \"literal-ness\" of the `type` property.\n * In other words, `Action<\"FOO\">` will be of type `{ type: \"FOO\" }`; it won't be simplified to `{ type: string }`.\n *\n * See the [TS Handbook](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types) for more info on TypeScript string literal types.\n * @public\n */\nexport interface Action<T extends string> {\n  type: T;\n}\n\n/**\n * A Redux [Action](https://redux.js.org/basics/actions), with additional \"payload\" information.\n * Technically, Redux allows actions to take any shape, provided they specify a `type` property.\n *\n * However, in order to simplify TypeScript typings, we follow this [Flux Standard Actions](https://github.com/redux-utilities/flux-standard-action)-like\n * convention, where all additional action information goes into a `payload` property.\n * @public\n */\nexport interface ActionWithPayload<T extends string, P> extends Action<T> {\n  payload: P;\n}\n\n/**\n * Creates a basic Redux Redux [Action](https://redux.js.org/basics/actions) without a payload.\n * **This is meant to be used as a shortcut for defining Action Creators.**\n *\n * For example,\n * ```\n *   () => createAction(\"FOO\", ids)\n * ```\n * defines an action creator of type:\n * ```\n *   () => { type: \"FOO\" }\n *   // which is equivalent to:\n *   () => Action<\"FOO\">\n * ```\n *\n * Note that the generic type parameters can always be omitted - TypeScript will be able to infer them.\n * @param type The string to use as the action's type property. Should have a [string literal type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types).\n * @public\n */\nexport function createAction<T extends string>(type: T): Action<T>;\n/**\n * Creates a basic Redux Redux [Action](https://redux.js.org/basics/actions) _with_ a payload value.\n * **This is meant to be used as a shortcut for defining Action Creators.**\n *\n * For example,\n * ```\n *   (ids: number[]) => createAction(\"FOO\", ids)\n * ```\n * defines an action creator of type:\n * ```\n *   (ids: number[]) => { type: \"FOO\", payload: ReadonlyArray<number> }\n *   // which is equivalent to:\n *   (ids: number[]) => ActionWithPayload<\"FOO\", ReadonlyArray<number>>\n * ```\n *\n * Note that the generic type parameters can always be omitted - TypeScript will be able to infer them.\n * @param type The string to use as the action's type property. Should have a [string literal type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types).\n * @param payload The value to use as the action's payload property. May be of any type.\n * @public\n */\nexport function createAction<T extends string, P>(type: T, payload: P): ActionWithPayload<T, DeepReadonly<P>>;\nexport function createAction<T extends string, P>(type: T, payload?: P) {\n  return (payload === undefined) ? /* istanbul ignore next */ { type } : { type, payload };\n}\n\n/**\n * Just an object where every property is a Redux [Action Creator](https://redux.js.org/basics/actions#action-creators).\n * @public\n */\nexport type ActionCreatorsObject = { [actionCreatorName: string]: FunctionType; };\n\n/**\n * A TypeScript type alias that represents the [Union Type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#union-types) of all actions\n * possibly created by _any_ of the action creators in a given `ActionCreatorsObject`.\n *\n * For example,\n * ```\n *   // given:\n *   const MyActionCreators = {\n *     createBanana: () => createAction(\"BANANA\"),\n *     createApple:  () => createAction(\"APPLE\", true),\n *     createOrange: (n: number) => createAction(\"BANANA\", n),\n *   }\n *   // then:\n *   type X = ActionsUnion<typeof MyActionCreators>;\n *   // is equivalent to:\n *   type X = Action<\"BANANA\">\n *            | ActionWithPayload<\"APPLE\", boolean>\n *            | ActionWithPayload<\"ORANGE\", number>;\n * ```\n * @public\n */\nexport type ActionsUnion<A extends ActionCreatorsObject> = ReturnType<A[keyof A]>;\n\n/**\n * A TypeScript type alias that uses [conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html) (read: magic)\n * to represent the _exact_ (literal) type of an action's `type` property.\n *\n * More importantly, this can be used to determine a union type which represents the `type` string literal types for _any_ action in a given `ActionsUnion`.\n *\n * For example,\n * ```\n *   // given:\n *   type MyActions = Action<\"BANANA\">\n *                    | ActionWithPayload<\"APPLE\", boolean>\n *                    | ActionWithPayload<\"ORANGE\", number>;\n *   // then:\n *   type X = ActionTypes<MyActions>;\n *   // is equivalent to:\n *   type X = \"BANANA\" | \"APPLE\" | \"ORANGE\";\n * ```\n * @public\n */\nexport type ActionTypes<A extends Action<any>> = A[\"type\"] extends infer X ? (X extends string ? X : never) : never;\n\n/**\n * A Redux [Reducer](https://redux.js.org/basics/reducers).\n * @public\n */\nexport type Reducer<S, A> = (state: S, action: A) => S;\n\n/**\n * A TypeScript type alias that represents a union of all action types handled by a Redux [Reducer](https://redux.js.org/basics/reducers).\n *\n * If you have created a type-safe reducer function using `combineReducers`, you can use this to infer your actions union type instead of having to define it manually.\n * @public\n */\nexport type ReducerActions<R> =\n  R extends Reducer<any, infer X> ? (\n    X extends ActionWithPayload<infer T, infer P> ? DeepReadonly<ActionWithPayload<T, P>> :\n    X extends Action<infer T2> ? DeepReadonly<Action<T2>> :\n    X\n  ) : R;\n\n/**\n * A TypeScript type alias that represents the return type of a Redux [Reducer](https://redux.js.org/basics/reducers).\n *\n * If you have created a type-safe reducer function using `combineReducers`, you can use this to infer your state type instead of having to define it manually.\n * @public\n */\nexport type StateType<R extends Reducer<any, any>> = DeepReadonly<ReturnType<R>>;\n\n\n/**\n * So we don't actually need to implement our own version of combineReducers, but we are going to cast it\n * to this type, which will do a better job of preserving/deducing the Action and State types.\n * @public\n */\nexport type CombineReducersFunction = <A>(reducers: A) =>\n  (state: CombinedReducerState<A>, action: ReducerMapActions<A>) => CombinedReducerState<A>;\n\n/**\n * A type alias which represents the state created by the reducer returned by combineReducers for a given `reducers` argument.\n * Used above by `CombineReducersFunction`, our custom type definition for combineReducers.\n * @public\n */\nexport type CombinedReducerState<R> = { readonly [K in keyof R]: R[K] extends FunctionType ? StateType<R[K]> : never };\n\n/**\n * A type alias which represents the union type of all actions handled by the reducer returned by combineReducers for a given `reducers` argument.\n * Used above by `CombineReducersFunction`, our custom type definition for combineReducers.\n * @public\n */\nexport type ReducerMapActions<R> = ReducerActions<R[keyof R]>;\n\n\n// Since the implementation is copied from redux, we'll copy the docs as well:\n/**\n * Turns an object whose values are different reducer functions, into a single\n * reducer function. It will call every child reducer, and gather their results\n * into a single state object, whose keys correspond to the keys of the passed\n * reducer functions.\n *\n * //@template S Combined state object type.\n *\n * @param reducers An object whose values correspond to different reducer\n *   functions that need to be combined into one. One handy way to obtain it\n *   is to use ES6 `import * as reducers` syntax. The reducers may never\n *   return undefined for any action. Instead, they should return their\n *   initial state if the state passed to them was undefined, and the current\n *   state for any unrecognized action.\n *\n * Returns: A reducer function that invokes every reducer inside the passed\n *   object, and builds a state object with the same shape.\n * @public\n */\nexport const combineReducers: CombineReducersFunction = baseCombineReducers as any;\n"]}
+{"version":3,"file":"redux-ts.js","sourceRoot":"","sources":["../../../../src/appui-react/redux/redux-ts.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG;AAEH,OAAO,EAAE,eAAe,IAAI,mBAAmB,EAAE,MAAM,OAAO,CAAC;AAkG/D,MAAM,UAAU,YAAY,CAAsB,IAAO,EAAE,OAAW;IACpE,OAAO,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,0BAA0B,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AAC3F,CAAC;AAuGD,8EAA8E;AAC9E;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,eAAe,GAA4B,mBAA0B,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module State\r\n */\r\n\r\nimport { combineReducers as baseCombineReducers } from \"redux\";\r\n\r\n/* eslint-disable */\r\n\r\n/** Shorthand for \"any function\".  TSLint doesn't like the built-in `Function` type for some reason.\r\n * @public\r\n */\r\nexport type FunctionType = (...args: any[]) => any;\r\n\r\n/**\r\n * Similar to the built-in [Readonly](https://www.typescriptlang.org/docs/handbook/advanced-types.html#mapped-types), type alias but applied recursively.\r\n * This basically makes all nested properties/members of an object/array immutable.\r\n * @public\r\n */\r\nexport type DeepReadonly<T> =\r\n  T extends ReadonlyArray<infer R> ? (R extends object ? DeepReadonlyArray<R> : ReadonlyArray<R>) :\r\n  T extends FunctionType ? T :\r\n  T extends object ? DeepReadonlyObject<T> :\r\n  T;\r\n\r\n/** TypeScript doesn't actually allow recursive type aliases, so these are just sort of a hack to make DeepReadonly work\r\n * @public\r\n */\r\nexport interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> { }\r\n/** TypeScript doesn't actually allow recursive type aliases, so these are just sort of a hack to make DeepReadonly work\r\n * @public\r\n */\r\nexport type DeepReadonlyObject<T> = {\r\n  readonly [P in keyof T]: DeepReadonly<T[P]>;\r\n};\r\n\r\n/**\r\n * A basic Redux [Action](https://redux.js.org/basics/actions).\r\n * Technically, redux only requires actions to have a `type` property.\r\n *\r\n * We use a TypeScript [Generic](https://www.typescriptlang.org/docs/handbook/generics.html) interface here to preserve the \"literal-ness\" of the `type` property.\r\n * In other words, `Action<\"FOO\">` will be of type `{ type: \"FOO\" }`; it won't be simplified to `{ type: string }`.\r\n *\r\n * See the [TS Handbook](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types) for more info on TypeScript string literal types.\r\n * @public\r\n */\r\nexport interface Action<T extends string> {\r\n  type: T;\r\n}\r\n\r\n/**\r\n * A Redux [Action](https://redux.js.org/basics/actions), with additional \"payload\" information.\r\n * Technically, Redux allows actions to take any shape, provided they specify a `type` property.\r\n *\r\n * However, in order to simplify TypeScript typings, we follow this [Flux Standard Actions](https://github.com/redux-utilities/flux-standard-action)-like\r\n * convention, where all additional action information goes into a `payload` property.\r\n * @public\r\n */\r\nexport interface ActionWithPayload<T extends string, P> extends Action<T> {\r\n  payload: P;\r\n}\r\n\r\n/**\r\n * Creates a basic Redux Redux [Action](https://redux.js.org/basics/actions) without a payload.\r\n * **This is meant to be used as a shortcut for defining Action Creators.**\r\n *\r\n * For example,\r\n * ```\r\n *   () => createAction(\"FOO\", ids)\r\n * ```\r\n * defines an action creator of type:\r\n * ```\r\n *   () => { type: \"FOO\" }\r\n *   // which is equivalent to:\r\n *   () => Action<\"FOO\">\r\n * ```\r\n *\r\n * Note that the generic type parameters can always be omitted - TypeScript will be able to infer them.\r\n * @param type The string to use as the action's type property. Should have a [string literal type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types).\r\n * @public\r\n */\r\nexport function createAction<T extends string>(type: T): Action<T>;\r\n/**\r\n * Creates a basic Redux Redux [Action](https://redux.js.org/basics/actions) _with_ a payload value.\r\n * **This is meant to be used as a shortcut for defining Action Creators.**\r\n *\r\n * For example,\r\n * ```\r\n *   (ids: number[]) => createAction(\"FOO\", ids)\r\n * ```\r\n * defines an action creator of type:\r\n * ```\r\n *   (ids: number[]) => { type: \"FOO\", payload: ReadonlyArray<number> }\r\n *   // which is equivalent to:\r\n *   (ids: number[]) => ActionWithPayload<\"FOO\", ReadonlyArray<number>>\r\n * ```\r\n *\r\n * Note that the generic type parameters can always be omitted - TypeScript will be able to infer them.\r\n * @param type The string to use as the action's type property. Should have a [string literal type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types).\r\n * @param payload The value to use as the action's payload property. May be of any type.\r\n * @public\r\n */\r\nexport function createAction<T extends string, P>(type: T, payload: P): ActionWithPayload<T, DeepReadonly<P>>;\r\nexport function createAction<T extends string, P>(type: T, payload?: P) {\r\n  return (payload === undefined) ? /* istanbul ignore next */ { type } : { type, payload };\r\n}\r\n\r\n/**\r\n * Just an object where every property is a Redux [Action Creator](https://redux.js.org/basics/actions#action-creators).\r\n * @public\r\n */\r\nexport type ActionCreatorsObject = { [actionCreatorName: string]: FunctionType; };\r\n\r\n/**\r\n * A TypeScript type alias that represents the [Union Type](https://www.typescriptlang.org/docs/handbook/advanced-types.html#union-types) of all actions\r\n * possibly created by _any_ of the action creators in a given `ActionCreatorsObject`.\r\n *\r\n * For example,\r\n * ```\r\n *   // given:\r\n *   const MyActionCreators = {\r\n *     createBanana: () => createAction(\"BANANA\"),\r\n *     createApple:  () => createAction(\"APPLE\", true),\r\n *     createOrange: (n: number) => createAction(\"BANANA\", n),\r\n *   }\r\n *   // then:\r\n *   type X = ActionsUnion<typeof MyActionCreators>;\r\n *   // is equivalent to:\r\n *   type X = Action<\"BANANA\">\r\n *            | ActionWithPayload<\"APPLE\", boolean>\r\n *            | ActionWithPayload<\"ORANGE\", number>;\r\n * ```\r\n * @public\r\n */\r\nexport type ActionsUnion<A extends ActionCreatorsObject> = ReturnType<A[keyof A]>;\r\n\r\n/**\r\n * A TypeScript type alias that uses [conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html) (read: magic)\r\n * to represent the _exact_ (literal) type of an action's `type` property.\r\n *\r\n * More importantly, this can be used to determine a union type which represents the `type` string literal types for _any_ action in a given `ActionsUnion`.\r\n *\r\n * For example,\r\n * ```\r\n *   // given:\r\n *   type MyActions = Action<\"BANANA\">\r\n *                    | ActionWithPayload<\"APPLE\", boolean>\r\n *                    | ActionWithPayload<\"ORANGE\", number>;\r\n *   // then:\r\n *   type X = ActionTypes<MyActions>;\r\n *   // is equivalent to:\r\n *   type X = \"BANANA\" | \"APPLE\" | \"ORANGE\";\r\n * ```\r\n * @public\r\n */\r\nexport type ActionTypes<A extends Action<any>> = A[\"type\"] extends infer X ? (X extends string ? X : never) : never;\r\n\r\n/**\r\n * A Redux [Reducer](https://redux.js.org/basics/reducers).\r\n * @public\r\n */\r\nexport type Reducer<S, A> = (state: S, action: A) => S;\r\n\r\n/**\r\n * A TypeScript type alias that represents a union of all action types handled by a Redux [Reducer](https://redux.js.org/basics/reducers).\r\n *\r\n * If you have created a type-safe reducer function using `combineReducers`, you can use this to infer your actions union type instead of having to define it manually.\r\n * @public\r\n */\r\nexport type ReducerActions<R> =\r\n  R extends Reducer<any, infer X> ? (\r\n    X extends ActionWithPayload<infer T, infer P> ? DeepReadonly<ActionWithPayload<T, P>> :\r\n    X extends Action<infer T2> ? DeepReadonly<Action<T2>> :\r\n    X\r\n  ) : R;\r\n\r\n/**\r\n * A TypeScript type alias that represents the return type of a Redux [Reducer](https://redux.js.org/basics/reducers).\r\n *\r\n * If you have created a type-safe reducer function using `combineReducers`, you can use this to infer your state type instead of having to define it manually.\r\n * @public\r\n */\r\nexport type StateType<R extends Reducer<any, any>> = DeepReadonly<ReturnType<R>>;\r\n\r\n\r\n/**\r\n * So we don't actually need to implement our own version of combineReducers, but we are going to cast it\r\n * to this type, which will do a better job of preserving/deducing the Action and State types.\r\n * @public\r\n */\r\nexport type CombineReducersFunction = <A>(reducers: A) =>\r\n  (state: CombinedReducerState<A>, action: ReducerMapActions<A>) => CombinedReducerState<A>;\r\n\r\n/**\r\n * A type alias which represents the state created by the reducer returned by combineReducers for a given `reducers` argument.\r\n * Used above by `CombineReducersFunction`, our custom type definition for combineReducers.\r\n * @public\r\n */\r\nexport type CombinedReducerState<R> = { readonly [K in keyof R]: R[K] extends FunctionType ? StateType<R[K]> : never };\r\n\r\n/**\r\n * A type alias which represents the union type of all actions handled by the reducer returned by combineReducers for a given `reducers` argument.\r\n * Used above by `CombineReducersFunction`, our custom type definition for combineReducers.\r\n * @public\r\n */\r\nexport type ReducerMapActions<R> = ReducerActions<R[keyof R]>;\r\n\r\n\r\n// Since the implementation is copied from redux, we'll copy the docs as well:\r\n/**\r\n * Turns an object whose values are different reducer functions, into a single\r\n * reducer function. It will call every child reducer, and gather their results\r\n * into a single state object, whose keys correspond to the keys of the passed\r\n * reducer functions.\r\n *\r\n * //@template S Combined state object type.\r\n *\r\n * @param reducers An object whose values correspond to different reducer\r\n *   functions that need to be combined into one. One handy way to obtain it\r\n *   is to use ES6 `import * as reducers` syntax. The reducers may never\r\n *   return undefined for any action. Instead, they should return their\r\n *   initial state if the state passed to them was undefined, and the current\r\n *   state for any unrecognized action.\r\n *\r\n * Returns: A reducer function that invokes every reducer inside the passed\r\n *   object, and builds a state object with the same shape.\r\n * @public\r\n */\r\nexport const combineReducers: CombineReducersFunction = baseCombineReducers as any;\r\n"]}