@codeparticle/rdx
Version:
RDX is a module based redux framework that generates boilerplate for you.
524 lines (511 loc) • 26.6 kB
TypeScript
import { EnhancerOptions } from '@redux-devtools/extension';
import { DeepPartial, ReducersMapObject, ReducerFromReducersMapObject, Middleware, Dispatch, Store } from 'redux';
import { SagaMiddlewareOptions, Saga } from 'redux-saga';
import { E as Extends$1, I as Iteration$1, a as IterationMap$1, L as List, b as Literal, C as Cast$1, O as Object$1, S as Split } from './_Internal.d-b77d7bab';
import { P as Path } from './Path.d-b1ed7658';
declare type IsStringLiteral<T> = T extends string ? (string extends T ? false : true) : false;
declare type WordInPascalCase<T> = Capitalize<WordInCamelCase<Uncapitalize<T & string>>>;
declare type WordInCamelCase<T, Ch extends string = ""> = T extends `${Ch}${infer NextCh}${infer _}` ? NextCh extends Capitalize<NextCh> ? Ch : WordInCamelCase<T, `${Ch}${NextCh}`> : Ch;
declare type Separator = "_" | "-";
declare type IncludesSeparator<T> = T extends `${string}${Separator}${string}` ? true : false;
declare type IsOneWord<T> = T extends Lowercase<T & string> ? true : T extends Uppercase<T & string> ? true : false;
declare type IsCamelCase<T> = T extends Uncapitalize<T & string> ? true : false;
declare type IsPascalCase<T> = T extends Capitalize<T & string> ? true : false;
/** snake_case, CONSTANT_CASE, kebab-case or COBOL-CASE */
declare type SeparatorCaseParser<T, Result extends readonly any[] = []> = T extends `${infer Word}${Separator}${infer Tail}` ? SeparatorCaseParser<Tail, [...Result, Lowercase<Word>]> : T extends `${infer Word}` ? [...Result, Lowercase<Word>] : Result;
declare type CamelCaseParser<T, Result extends readonly any[] = []> = T extends "" ? Result : T extends `${WordInCamelCase<T & string>}${infer Tail}` ? T extends `${infer Word}${Tail}` ? CamelCaseParser<Uncapitalize<Tail>, [...Result, Lowercase<Word>]> : never : never;
declare type PascalCaseParser<T, Result extends readonly any[] = []> = T extends "" ? Result : T extends `${WordInPascalCase<T & string>}${infer Tail}` ? T extends `${infer Word}${Tail}` ? PascalCaseParser<Tail, [...Result, Lowercase<Word>]> : never : never;
declare type SplitAnyCase<T> = IncludesSeparator<T> extends true ? SeparatorCaseParser<T> : IsOneWord<T> extends true ? [Lowercase<T & string>] : IsCamelCase<T> extends true ? CamelCaseParser<T> : IsPascalCase<T> extends true ? PascalCaseParser<T> : [];
declare type PascalCapitalizer<T, Result extends readonly any[] = []> = T extends [infer Head, ...infer Tail] ? Head extends string ? PascalCapitalizer<Tail, [...Result, Capitalize<Head>]> : PascalCapitalizer<Tail, Result> : Result;
declare type CamelCapitalizer<T> = T extends [infer First, ...infer Tail] ? PascalCapitalizer<Tail, [First]> : [];
declare type Join$1<T, Result extends string = ""> = T extends [infer Head, ...infer Tail] ? Head extends string ? Join$1<Tail, `${Result}${Head}`> : Join$1<Tail> : Result;
declare type CamelCase<T> = IsStringLiteral<T> extends true ? Join$1<CamelCapitalizer<SplitAnyCase<T>>> : T;
/**
* Ask TS to re-check that `A1` extends `A2`.
* And if it fails, `A2` will be enforced anyway.
* Can also be used to add constraints on parameters.
* @param A1 to check against
* @param A2 to cast to
* @returns `A1 | A2`
* @example
* ```ts
* import {A} from 'ts-toolbelt'
*
* type test0 = A.Cast<'42', string> // '42'
* type test1 = A.Cast<'42', number> // number
* ```
*/
declare type Cast<A1 extends any, A2 extends any> = A1 extends A2 ? A1 : A2;
/**
* Check whether `A1` is part of `A2` or not. It works like
* [[Extends]] but [[Boolean]] results are narrowed to [[False]].
* @param A1
* @param A2
* @returns [[Boolean]]
* @example
* ```ts
* type test0 = A.Contains<'a' | 'b', 'b'> // False
* type test1 = A.Contains<'a', 'a' | 'b'> // True
*
* type test2 = A.Contains<{a: string}, {a: string, b: number}> // False
* type test3 = A.Contains<{a: string, b: number}, {a: string}> // True
*
* type test4 = A.Contains<never, never> // False
* /// Nothing cannot contain nothing, use `A.Equals`
* ```
*/
declare type Contains<A1 extends any, A2 extends any> = Extends$1<A1, A2> extends 1 ? 1 : 0;
/**
* Check whether `A1` is equal to `A2` or not.
* @param A1
* @param A2
* @returns [[Boolean]]
* @example
* ```ts
* import {A} from 'ts-toolbelt'
*
* type test0 = A.Equals<42 | 0, 42 | 0> // true
* type test1 = A.Equals<{a: string}, {b: string}> // false
* type test3 = A.Equals<{a: string}, {readonly a: string}> // false
* ```
*/
declare type Equals<A1 extends any, A2 extends any> = (<A>() => A extends A2 ? 1 : 0) extends (<A>() => A extends A1 ? 1 : 0) ? 1 : 0;
/**
* Check whether `A1` is part of `A2` or not. The difference with
* `extends` is that it forces a [[Boolean]] return.
* @param A1
* @param A2
* @returns [[Boolean]]
* @example
* ```ts
* import {A} from 'ts-toolbelt'
*
* type test0 = A.Extends<'a' | 'b', 'b'> // Boolean
* type test1 = A.Extends<'a', 'a' | 'b'> // True
*
* type test2 = A.Extends<{a: string}, {a: any}> // True
* type test3 = A.Extends<{a: any}, {a: any, b: any}> // False
*
* type test4 = A.Extends<never, never> // False
* /// Nothing cannot extend nothing, use `A.Equals`
* ```
*/
declare type Extends<A1 extends any, A2 extends any> = [
A1
] extends [never] ? 0 : A1 extends A2 ? 1 : 0;
/**
* Get the position of `I` (**number**)
* @param I to query
* @returns `number`
* @example
* ```ts
* import {I} from 'ts-toolbelt'
*
* type i = I.IterationOf<'20'>
*
* type test0 = I.Pos<i> // 20
* type test1 = I.Pos<I.Next<i>> // 21
* ```
*/
declare type Pos<I extends Iteration$1> = I[0];
/**
* An entry of `IterationMap`
*/
declare type Iteration = [
value: number,
sign: '-' | '0' | '+',
prev: keyof IterationMap,
next: keyof IterationMap,
oppo: keyof IterationMap
];
declare type IterationMap = {
'__': [number, '-' | '0' | '+', '__', '__', '__'];
'-100': [-100, '-', '__', '-99', '100'];
'-99': [-99, '-', '-100', '-98', '99'];
'-98': [-98, '-', '-99', '-97', '98'];
'-97': [-97, '-', '-98', '-96', '97'];
'-96': [-96, '-', '-97', '-95', '96'];
'-95': [-95, '-', '-96', '-94', '95'];
'-94': [-94, '-', '-95', '-93', '94'];
'-93': [-93, '-', '-94', '-92', '93'];
'-92': [-92, '-', '-93', '-91', '92'];
'-91': [-91, '-', '-92', '-90', '91'];
'-90': [-90, '-', '-91', '-89', '90'];
'-89': [-89, '-', '-90', '-88', '89'];
'-88': [-88, '-', '-89', '-87', '88'];
'-87': [-87, '-', '-88', '-86', '87'];
'-86': [-86, '-', '-87', '-85', '86'];
'-85': [-85, '-', '-86', '-84', '85'];
'-84': [-84, '-', '-85', '-83', '84'];
'-83': [-83, '-', '-84', '-82', '83'];
'-82': [-82, '-', '-83', '-81', '82'];
'-81': [-81, '-', '-82', '-80', '81'];
'-80': [-80, '-', '-81', '-79', '80'];
'-79': [-79, '-', '-80', '-78', '79'];
'-78': [-78, '-', '-79', '-77', '78'];
'-77': [-77, '-', '-78', '-76', '77'];
'-76': [-76, '-', '-77', '-75', '76'];
'-75': [-75, '-', '-76', '-74', '75'];
'-74': [-74, '-', '-75', '-73', '74'];
'-73': [-73, '-', '-74', '-72', '73'];
'-72': [-72, '-', '-73', '-71', '72'];
'-71': [-71, '-', '-72', '-70', '71'];
'-70': [-70, '-', '-71', '-69', '70'];
'-69': [-69, '-', '-70', '-68', '69'];
'-68': [-68, '-', '-69', '-67', '68'];
'-67': [-67, '-', '-68', '-66', '67'];
'-66': [-66, '-', '-67', '-65', '66'];
'-65': [-65, '-', '-66', '-64', '65'];
'-64': [-64, '-', '-65', '-63', '64'];
'-63': [-63, '-', '-64', '-62', '63'];
'-62': [-62, '-', '-63', '-61', '62'];
'-61': [-61, '-', '-62', '-60', '61'];
'-60': [-60, '-', '-61', '-59', '60'];
'-59': [-59, '-', '-60', '-58', '59'];
'-58': [-58, '-', '-59', '-57', '58'];
'-57': [-57, '-', '-58', '-56', '57'];
'-56': [-56, '-', '-57', '-55', '56'];
'-55': [-55, '-', '-56', '-54', '55'];
'-54': [-54, '-', '-55', '-53', '54'];
'-53': [-53, '-', '-54', '-52', '53'];
'-52': [-52, '-', '-53', '-51', '52'];
'-51': [-51, '-', '-52', '-50', '51'];
'-50': [-50, '-', '-51', '-49', '50'];
'-49': [-49, '-', '-50', '-48', '49'];
'-48': [-48, '-', '-49', '-47', '48'];
'-47': [-47, '-', '-48', '-46', '47'];
'-46': [-46, '-', '-47', '-45', '46'];
'-45': [-45, '-', '-46', '-44', '45'];
'-44': [-44, '-', '-45', '-43', '44'];
'-43': [-43, '-', '-44', '-42', '43'];
'-42': [-42, '-', '-43', '-41', '42'];
'-41': [-41, '-', '-42', '-40', '41'];
'-40': [-40, '-', '-41', '-39', '40'];
'-39': [-39, '-', '-40', '-38', '39'];
'-38': [-38, '-', '-39', '-37', '38'];
'-37': [-37, '-', '-38', '-36', '37'];
'-36': [-36, '-', '-37', '-35', '36'];
'-35': [-35, '-', '-36', '-34', '35'];
'-34': [-34, '-', '-35', '-33', '34'];
'-33': [-33, '-', '-34', '-32', '33'];
'-32': [-32, '-', '-33', '-31', '32'];
'-31': [-31, '-', '-32', '-30', '31'];
'-30': [-30, '-', '-31', '-29', '30'];
'-29': [-29, '-', '-30', '-28', '29'];
'-28': [-28, '-', '-29', '-27', '28'];
'-27': [-27, '-', '-28', '-26', '27'];
'-26': [-26, '-', '-27', '-25', '26'];
'-25': [-25, '-', '-26', '-24', '25'];
'-24': [-24, '-', '-25', '-23', '24'];
'-23': [-23, '-', '-24', '-22', '23'];
'-22': [-22, '-', '-23', '-21', '22'];
'-21': [-21, '-', '-22', '-20', '21'];
'-20': [-20, '-', '-21', '-19', '20'];
'-19': [-19, '-', '-20', '-18', '19'];
'-18': [-18, '-', '-19', '-17', '18'];
'-17': [-17, '-', '-18', '-16', '17'];
'-16': [-16, '-', '-17', '-15', '16'];
'-15': [-15, '-', '-16', '-14', '15'];
'-14': [-14, '-', '-15', '-13', '14'];
'-13': [-13, '-', '-14', '-12', '13'];
'-12': [-12, '-', '-13', '-11', '12'];
'-11': [-11, '-', '-12', '-10', '11'];
'-10': [-10, '-', '-11', '-9', '10'];
'-9': [-9, '-', '-10', '-8', '9'];
'-8': [-8, '-', '-9', '-7', '8'];
'-7': [-7, '-', '-8', '-6', '7'];
'-6': [-6, '-', '-7', '-5', '6'];
'-5': [-5, '-', '-6', '-4', '5'];
'-4': [-4, '-', '-5', '-3', '4'];
'-3': [-3, '-', '-4', '-2', '3'];
'-2': [-2, '-', '-3', '-1', '2'];
'-1': [-1, '-', '-2', '0', '1'];
'0': [0, '0', '-1', '1', '0'];
'1': [1, '+', '0', '2', '-1'];
'2': [2, '+', '1', '3', '-2'];
'3': [3, '+', '2', '4', '-3'];
'4': [4, '+', '3', '5', '-4'];
'5': [5, '+', '4', '6', '-5'];
'6': [6, '+', '5', '7', '-6'];
'7': [7, '+', '6', '8', '-7'];
'8': [8, '+', '7', '9', '-8'];
'9': [9, '+', '8', '10', '-9'];
'10': [10, '+', '9', '11', '-10'];
'11': [11, '+', '10', '12', '-11'];
'12': [12, '+', '11', '13', '-12'];
'13': [13, '+', '12', '14', '-13'];
'14': [14, '+', '13', '15', '-14'];
'15': [15, '+', '14', '16', '-15'];
'16': [16, '+', '15', '17', '-16'];
'17': [17, '+', '16', '18', '-17'];
'18': [18, '+', '17', '19', '-18'];
'19': [19, '+', '18', '20', '-19'];
'20': [20, '+', '19', '21', '-20'];
'21': [21, '+', '20', '22', '-21'];
'22': [22, '+', '21', '23', '-22'];
'23': [23, '+', '22', '24', '-23'];
'24': [24, '+', '23', '25', '-24'];
'25': [25, '+', '24', '26', '-25'];
'26': [26, '+', '25', '27', '-26'];
'27': [27, '+', '26', '28', '-27'];
'28': [28, '+', '27', '29', '-28'];
'29': [29, '+', '28', '30', '-29'];
'30': [30, '+', '29', '31', '-30'];
'31': [31, '+', '30', '32', '-31'];
'32': [32, '+', '31', '33', '-32'];
'33': [33, '+', '32', '34', '-33'];
'34': [34, '+', '33', '35', '-34'];
'35': [35, '+', '34', '36', '-35'];
'36': [36, '+', '35', '37', '-36'];
'37': [37, '+', '36', '38', '-37'];
'38': [38, '+', '37', '39', '-38'];
'39': [39, '+', '38', '40', '-39'];
'40': [40, '+', '39', '41', '-40'];
'41': [41, '+', '40', '42', '-41'];
'42': [42, '+', '41', '43', '-42'];
'43': [43, '+', '42', '44', '-43'];
'44': [44, '+', '43', '45', '-44'];
'45': [45, '+', '44', '46', '-45'];
'46': [46, '+', '45', '47', '-46'];
'47': [47, '+', '46', '48', '-47'];
'48': [48, '+', '47', '49', '-48'];
'49': [49, '+', '48', '50', '-49'];
'50': [50, '+', '49', '51', '-50'];
'51': [51, '+', '50', '52', '-51'];
'52': [52, '+', '51', '53', '-52'];
'53': [53, '+', '52', '54', '-53'];
'54': [54, '+', '53', '55', '-54'];
'55': [55, '+', '54', '56', '-55'];
'56': [56, '+', '55', '57', '-56'];
'57': [57, '+', '56', '58', '-57'];
'58': [58, '+', '57', '59', '-58'];
'59': [59, '+', '58', '60', '-59'];
'60': [60, '+', '59', '61', '-60'];
'61': [61, '+', '60', '62', '-61'];
'62': [62, '+', '61', '63', '-62'];
'63': [63, '+', '62', '64', '-63'];
'64': [64, '+', '63', '65', '-64'];
'65': [65, '+', '64', '66', '-65'];
'66': [66, '+', '65', '67', '-66'];
'67': [67, '+', '66', '68', '-67'];
'68': [68, '+', '67', '69', '-68'];
'69': [69, '+', '68', '70', '-69'];
'70': [70, '+', '69', '71', '-70'];
'71': [71, '+', '70', '72', '-71'];
'72': [72, '+', '71', '73', '-72'];
'73': [73, '+', '72', '74', '-73'];
'74': [74, '+', '73', '75', '-74'];
'75': [75, '+', '74', '76', '-75'];
'76': [76, '+', '75', '77', '-76'];
'77': [77, '+', '76', '78', '-77'];
'78': [78, '+', '77', '79', '-78'];
'79': [79, '+', '78', '80', '-79'];
'80': [80, '+', '79', '81', '-80'];
'81': [81, '+', '80', '82', '-81'];
'82': [82, '+', '81', '83', '-82'];
'83': [83, '+', '82', '84', '-83'];
'84': [84, '+', '83', '85', '-84'];
'85': [85, '+', '84', '86', '-85'];
'86': [86, '+', '85', '87', '-86'];
'87': [87, '+', '86', '88', '-87'];
'88': [88, '+', '87', '89', '-88'];
'89': [89, '+', '88', '90', '-89'];
'90': [90, '+', '89', '91', '-90'];
'91': [91, '+', '90', '92', '-91'];
'92': [92, '+', '91', '93', '-92'];
'93': [93, '+', '92', '94', '-93'];
'94': [94, '+', '93', '95', '-94'];
'95': [95, '+', '94', '96', '-95'];
'96': [96, '+', '95', '97', '-96'];
'97': [97, '+', '96', '98', '-97'];
'98': [98, '+', '97', '99', '-98'];
'99': [99, '+', '98', '100', '-99'];
'100': [100, '+', '99', '__', '-100'];
};
/**
* Transform a number into an [[Iteration]]
* (to use [[Prev]], [[Next]], & [[Pos]])
* @param N to transform
* @returns [[Iteration]]
* @example
* ```ts
* import {I} from 'ts-toolbelt'
*
* type i = I.IterationOf<0> // ["-1", "1", "0", 0, "0"]
*
* type next = I.Next<i> // ["0", "2", "1", 1, "+"]
* type prev = I.Prev<i> // ["-2", "0", "-1", -1, "-"]
*
* type nnext = I.Pos<next> // +1
* type nprev = I.Pos<prev> // -1
* ```
*/
declare type IterationOf<N extends number> = `${N}` extends keyof IterationMap$1 ? IterationMap$1[`${N}`] : IterationMap$1['__'];
/**
* Move `I`'s position forward
* @param I to move
* @returns [[Iteration]]
* @example
* ```ts
* import {I} from 'ts-toolbelt'
*
* type i = I.IterationOf<'20'>
*
* type test0 = I.Pos<i> // 20
* type test1 = I.Pos<I.Next<i>> // 21
* ```
*/
declare type Next<I extends Iteration$1> = IterationMap$1[I[3]];
/**
* @hidden
*/
declare type _Join<T extends List, D extends string> = T extends [] ? '' : T extends [Literal] ? `${T[0]}` : T extends [Literal, ...infer R] ? `${T[0]}${D}${_Join<R, D>}` : string;
/**
* Concat many literals together
* @param T to concat
* @param D to delimit
*/
declare type Join<T extends List<Literal>, D extends string = ''> = _Join<T, D> extends infer X ? Cast$1<X, string> : never;
declare type ObjectPaths<O extends Object$1, Limit extends Iteration = IterationOf<0>, Paths extends string = ''> = 11 extends Pos<Limit> ? Paths : O extends Object$1 ? Paths | {
[K in keyof O]: ObjectPaths<O[K], Next<Limit>, `${Paths}.${K & string}`>;
}[keyof O] : Paths;
declare type DotSeparatedPaths<O extends Object$1, Limit extends number = 6> = ObjectPaths<O, IterationOf<Limit>> extends `.${infer P}` | infer _ ? P : '';
declare type PathsOf<O extends Object$1, Limit extends number = 6> = DotSeparatedPaths<O, Limit>;
declare type FunctionPathOf<O> = PathsOf<O> extends infer V ? V extends string ? CamelCase<Join<Split<V, '.'>, '_'>> : never : never;
declare type PascalCase<Value extends string> = Capitalize<CamelCase<Value>>;
interface HandlerType {
string: `string`;
number: `number`;
boolean: `boolean`;
array: `array`;
object: `object`;
api: `api`;
default: `default`;
}
declare type KeyMirroredObject<Ts extends string[] | readonly string[]> = Contains<Ts, string | readonly string[]> extends 0 ? Record<string, never> : {
[K in Ts[number]]: K;
};
declare type PayloadObject<Payload = never> = Extends<Payload, NonNullable<Payload>> extends 0 ? Record<string, unknown> : {
payload: Payload;
};
declare type AdditionalKeysObject<AdditionalKeys = never> = Extends<AdditionalKeys, NonNullable<AdditionalKeys>> extends 0 ? Record<string, never> : AdditionalKeys extends Object$1 ? AdditionalKeys : Record<string, never>;
declare type RdxAction<Payload = any, AdditionalKeys = any> = {
type: string;
} & PayloadObject<Payload> & AdditionalKeysObject<AdditionalKeys>;
declare type GeneratedActionName<State extends Object$1, Prefix extends string = ''> = RdxActionName<Capitalized<FunctionPathOf<State>>, Prefix>;
declare type ActionObject<State extends Object$1, Prefix extends string = '', CustomActions extends Record<string, ActionCreator> = Record<string, never>> = Equals<CustomActions, Record<string, never>> extends 1 ? Record<GeneratedActionName<State, Prefix> | 'batchActions', ActionCreator> : Record<GeneratedActionName<State, Prefix> | 'batchActions', ActionCreator> & CustomActions;
declare type ActionCreator<Payload = any, AdditionalKeys = any> = (payload?: Payload, additionalKeys?: AdditionalKeys extends Object$1 ? Object$1 : never) => RdxAction<Payload, AdditionalKeys>;
interface TypeDef<InitialState = NonNullable<any>> {
actionName: RdxActionName<string, string>;
handlerType: HandlerType[keyof HandlerType];
initialState: InitialState;
isApiReducer: boolean;
path: string;
reducerKey: string;
resetActionName: RdxActionName<string, string>;
resetType: RdxResetActionType<string, string>;
setType: RdxSetActionType<string, string>;
children: InitialState extends Object$1 ? ReducersMapObjectDefinition<InitialState> : Record<string, never>;
}
declare type Capitalized<Name extends string> = [Name] extends [''] ? never : Name extends `${infer FirstCharacter}${infer _}` ? FirstCharacter extends Capitalize<FirstCharacter> ? FunctionPathOf<Name> : FunctionPathOf<Name> : Name;
declare type RdxSetActionType<Name extends string = string, Prefix extends string = string> = `@@rdx/${Uppercase<`set_${Prefix}${Prefix extends '' ? '' : '_'}${Name}`>}`;
declare type RdxResetActionType<Name extends string = string, Prefix extends string = string> = `@@rdx/${Uppercase<`reset_${Prefix}${Prefix extends '' ? '' : '_'}${Name}`>}`;
declare type RdxSetActionName<Name extends string = string, Prefix extends string = string> = Prefix extends '' ? `set${PascalCase<Name>}` : `set${PascalCase<Prefix>}${PascalCase<Name>}`;
declare type RdxResetActionName<Name extends string = string, Prefix extends string = string> = Prefix extends '' ? `reset${PascalCase<Name>}` : `reset${PascalCase<Prefix>}${PascalCase<Name>}`;
declare type RdxSetOrResetActionType<Name extends string = string, Prefix extends string = string, IsResetActionType extends boolean | never = never> = IsResetActionType extends false | never ? RdxSetActionType<Name, Prefix> : RdxResetActionType<Name, Prefix>;
declare type RdxApiActionTypeSuffix = `_SUCCESS` | `_FAILURE` | `_REQUEST`;
declare type RdxApiActionNameSuffix = `Success` | `Failure` | `Request`;
declare type RdxApiActionType<Name extends string = string, Prefix extends string = ''> = `${RdxSetActionType<Name, Prefix>}${RdxApiActionTypeSuffix}`;
declare type RdxApiActionName<Name extends string = string, Prefix extends string = ''> = `${RdxSetActionName<Name, Prefix>}${RdxApiActionNameSuffix}`;
declare type RdxActionType<Name extends string = string, Prefix extends string = string> = RdxSetActionType<Name, Prefix> | RdxResetActionType<Name, Prefix> | RdxApiActionType<Name, Prefix>;
declare type RdxActionName<Name extends string = string, Prefix extends string = ''> = RdxSetActionName<Name, Prefix> | RdxResetActionName<Name, Prefix> | RdxApiActionName<Name, Prefix>;
declare type RdxSelectorName<Name extends string> = `get${Capitalized<FunctionPathOf<Name>>}`;
declare type RdxTypesObject<Prefix extends string = string> = KeyMirroredObject<Array<RdxActionType<string, Prefix>>>;
declare type ReflectedStatePath<State, Depth extends number = 6> = DotSeparatedPaths<State, Depth>;
declare type SelectorPath<State> = RdxSelectorName<FunctionPathOf<State>>;
declare type RdxSelector<State, P extends ReflectedStatePath<State> = ReflectedStatePath<State>> = (state: State) => Path<State, Split<P, '.'>>;
declare type RdxSelectorValue<State extends Object$1, P extends ReflectedStatePath<State> = ReflectedStatePath<State>> = ReturnType<RdxSelector<State, P>>;
declare type SelectorsObject<State extends Object$1> = Record<SelectorPath<State>, (s: State) => DeepPartial<State>>;
interface GeneratedReducerNames<BaseName extends string = string, Prefix extends string = string> {
actionName: RdxActionName<BaseName, Prefix>;
reducerKey: CamelCase<BaseName | Prefix>;
resetActionName: RdxActionName<BaseName, Prefix>;
resetType: RdxResetActionType<BaseName, Prefix>;
setType: RdxSetActionType<BaseName, Prefix>;
}
declare type RdxReducer<State = any, Payload = Cast<State, any>> = (state: State, action: RdxAction<Payload, any>) => Extends<Payload, NonNullable<Payload>> extends 0 ? State : Extends<Payload, State> extends 1 ? State : Equals<State, Payload> extends 1 ? State : Payload;
declare type ReducersMapObjectDefinition<Value extends Object$1> = Record<string, TypeDef<Value[number]>>;
interface RdxOutput<State extends Object$1, Prefix extends string, CustomActions extends Record<string, ActionCreator> = Record<string, never>, CustomReducers extends ReducersMapObject<any, RdxAction> = Record<string, never>> {
prefix: Prefix;
actions: ActionObject<State, Prefix, CustomActions>;
reducers: ReducerFromReducersMapObject<ReducersMapObject<State> & CustomReducers>;
selectors: SelectorsObject<State>;
types: RdxTypesObject<Prefix>;
state: State;
}
declare type RdxModule<State extends Object$1, Prefix extends string> = RdxOutput<State, Prefix> & {
'@@rdx/prefix': Prefix;
};
interface ApiReducerKeys {
failure: string;
request: string;
reset: string;
set: string;
success: string;
}
interface ApiRequestState<DataType = any, ErrorType = boolean | null> {
dataLoaded: boolean;
fetching: boolean;
error: ErrorType;
data: DataType;
}
interface ConfiguredSagasObject {
latest?: DefaultSagasObject;
every?: DefaultSagasObject;
}
declare type ReducerHandlers<State = any, Payload = any, AdditionalKeys = any> = Record<string, RdxReducer<State, RdxAction<Payload, AdditionalKeys>>>;
declare type NotLatestOrEvery = Exclude<string, keyof ConfiguredSagasObject>;
declare type DefaultSagasObject = {
[key in NotLatestOrEvery]: <ActionType = any>(action?: RdxAction<ActionType>) => Generator;
};
declare type SagasObject = ConfiguredSagasObject | DefaultSagasObject;
interface RdxSagasConfig {
enabled: boolean;
options?: SagaMiddlewareOptions;
}
interface RdxModuleConfiguration<Prefix extends string> {
prefix: Prefix;
}
declare type ModuleCombination<State extends Object$1> = RdxOutput<State, ''>;
interface RdxRootConfiguration<State extends Object$1, CustomActions extends Record<string, ActionCreator> = Record<string, never>, CustomReducers extends ReducersMapObject = Record<string, never>> {
modules: RdxOutput<State, '', CustomActions, CustomReducers>;
config?: {
middleware?: Middleware[];
devtools?: RdxDevToolsConfig;
sagas?: RdxSagasConfig;
wrapReducersWith?: (vs: any) => any;
};
}
declare type ActionMapper<State, Actions extends ActionObject<State, ''>> = (actions: Actions) => (dispatch: Dispatch) => (...vs: Array<keyof Actions>) => Record<Extract<keyof Actions, string>, ActionCreator>;
declare type SelectionMapper<State extends Object$1> = (selectors: SelectorsObject<State>) => (vs: Record<string, SelectorPath<State>>) => (state: State) => Record<string, ReturnType<RdxSelector<State>>>;
interface ConfiguredStore<State extends Object$1, CustomActions extends Record<string, ActionCreator> = Record<string, never>, CustomReducers extends ReducersMapObject = Record<string, never>> {
actions: ActionObject<State, '', CustomActions>;
reducers: ReducersMapObject<State, RdxAction> & CustomReducers;
selectors: SelectorsObject<State>;
types: RdxTypesObject<''>;
state: State;
store: Store<State>;
mapState: ReturnType<SelectionMapper<State>>;
mapActions: ReturnType<ReturnType<ActionMapper<State, ActionObject<State, '', CustomActions>>>>;
runSagas: (sagas: Saga[]) => void;
}
interface RdxMappers<S extends Object$1, CustomActions extends Record<string, ActionCreator> = Record<string, never>> {
mapActions: ReturnType<ActionMapper<S, ActionObject<S, '', CustomActions>>>;
mapState: ReturnType<SelectionMapper<S>>;
}
interface RdxDevToolsConfig {
enabled: boolean;
options?: EnhancerOptions;
}
declare type RdxPrefixed<Str extends string> = `@@rdx/${Str}`;
export { ActionCreator as A, RdxSetActionName as B, ConfiguredSagasObject as C, DefaultSagasObject as D, RdxSetOrResetActionType as E, RdxTypesObject as F, GeneratedReducerNames as G, HandlerType as H, ReducerHandlers as I, ReducersMapObjectDefinition as J, KeyMirroredObject as K, SelectionMapper as L, ModuleCombination as M, NotLatestOrEvery as N, SelectorPath as O, PathsOf as P, SelectorsObject as Q, RdxAction as R, SagasObject as S, TypeDef as T, PascalCase as U, Cast as V, CamelCase as W, ActionMapper as a, ActionObject as b, AdditionalKeysObject as c, ApiReducerKeys as d, ApiRequestState as e, ConfiguredStore as f, DotSeparatedPaths as g, PayloadObject as h, RdxActionName as i, RdxActionType as j, RdxApiActionName as k, RdxApiActionType as l, RdxDevToolsConfig as m, RdxMappers as n, RdxModule as o, RdxModuleConfiguration as p, RdxOutput as q, RdxPrefixed as r, RdxReducer as s, RdxResetActionName as t, RdxResetActionType as u, RdxRootConfiguration as v, RdxSagasConfig as w, RdxSelector as x, RdxSelectorName as y, RdxSelectorValue as z };