291 lines
9 KiB
Plaintext
291 lines
9 KiB
Plaintext
=== tests/cases/compiler/reactReduxLikeDeferredInferenceAllowsAssignment.ts ===
|
|
declare class Component<P> {
|
|
>Component : Component<P>
|
|
|
|
constructor(props: Readonly<P>);
|
|
>props : Readonly<P>
|
|
|
|
constructor(props: P, context?: any);
|
|
>props : P
|
|
>context : any
|
|
|
|
readonly props: Readonly<P> & Readonly<{ children?: {} }>;
|
|
>props : Readonly<P> & Readonly<{ children?: {} | undefined; }>
|
|
>children : {} | undefined
|
|
}
|
|
interface ComponentClass<P = {}> {
|
|
new (props: P, context?: any): Component<P>;
|
|
>props : P
|
|
>context : any
|
|
|
|
propTypes?: WeakValidationMap<P>;
|
|
>propTypes : WeakValidationMap<P> | undefined
|
|
|
|
defaultProps?: Partial<P>;
|
|
>defaultProps : Partial<P> | undefined
|
|
|
|
displayName?: string;
|
|
>displayName : string | undefined
|
|
}
|
|
interface FunctionComponent<P = {}> {
|
|
(props: P & { children?: {} }, context?: any): {} | null;
|
|
>props : P & { children?: {} | undefined; }
|
|
>children : {} | undefined
|
|
>context : any
|
|
>null : null
|
|
|
|
propTypes?: WeakValidationMap<P>;
|
|
>propTypes : WeakValidationMap<P> | undefined
|
|
|
|
defaultProps?: Partial<P>;
|
|
>defaultProps : Partial<P> | undefined
|
|
|
|
displayName?: string;
|
|
>displayName : string | undefined
|
|
}
|
|
|
|
declare const nominalTypeHack: unique symbol;
|
|
>nominalTypeHack : unique symbol
|
|
|
|
interface Validator<T> {
|
|
(
|
|
props: object,
|
|
>props : object
|
|
|
|
propName: string,
|
|
>propName : string
|
|
|
|
componentName: string,
|
|
>componentName : string
|
|
|
|
location: string,
|
|
>location : string
|
|
|
|
propFullName: string
|
|
>propFullName : string
|
|
|
|
): Error | null;
|
|
>null : null
|
|
|
|
[nominalTypeHack]?: T;
|
|
>[nominalTypeHack] : T | undefined
|
|
>nominalTypeHack : unique symbol
|
|
}
|
|
type WeakValidationMap<T> = {
|
|
>WeakValidationMap : WeakValidationMap<T>
|
|
|
|
[K in keyof T]?: null extends T[K]
|
|
>null : null
|
|
|
|
? Validator<T[K] | null | undefined>
|
|
>null : null
|
|
|
|
: undefined extends T[K]
|
|
? Validator<T[K] | null | undefined>
|
|
>null : null
|
|
|
|
: Validator<T[K]>
|
|
};
|
|
type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
|
|
>ComponentType : ComponentType<P>
|
|
|
|
type Shared<
|
|
>Shared : Shared<InjectedProps, DecorationTargetProps>
|
|
|
|
InjectedProps,
|
|
DecorationTargetProps extends Shared<InjectedProps, DecorationTargetProps>
|
|
> = {
|
|
[P in Extract<
|
|
keyof InjectedProps,
|
|
keyof DecorationTargetProps
|
|
>]?: InjectedProps[P] extends DecorationTargetProps[P]
|
|
? DecorationTargetProps[P]
|
|
: never
|
|
};
|
|
|
|
// Infers prop type from component C
|
|
type GetProps<C> = C extends ComponentType<infer P> ? P : never;
|
|
>GetProps : GetProps<C>
|
|
|
|
type ConnectedComponentClass<C extends ComponentType<any>, P> = ComponentClass<
|
|
>ConnectedComponentClass : ConnectedComponentClass<C, P>
|
|
|
|
P
|
|
> & {
|
|
WrappedComponent: C;
|
|
>WrappedComponent : C
|
|
|
|
};
|
|
|
|
type Matching<InjectedProps, DecorationTargetProps> = {
|
|
>Matching : Matching<InjectedProps, DecorationTargetProps>
|
|
|
|
[P in keyof DecorationTargetProps]: P extends keyof InjectedProps
|
|
? InjectedProps[P] extends DecorationTargetProps[P]
|
|
? DecorationTargetProps[P]
|
|
: InjectedProps[P]
|
|
: DecorationTargetProps[P]
|
|
};
|
|
|
|
type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
|
|
>Omit : Omit<T, K>
|
|
|
|
type InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> = <
|
|
>InferableComponentEnhancerWithProps : InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps>
|
|
|
|
C extends ComponentType<Matching<TInjectedProps, GetProps<C>>>
|
|
>(
|
|
component: C
|
|
>component : C
|
|
|
|
) => ConnectedComponentClass<
|
|
C,
|
|
Omit<GetProps<C>, keyof Shared<TInjectedProps, GetProps<C>>> & TNeedsProps
|
|
>;
|
|
|
|
declare const connect: {
|
|
>connect : <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: TDispatchProps) => InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps>, TOwnProps>
|
|
|
|
<no_state = {}, TDispatchProps = {}, TOwnProps = {}>(
|
|
mapStateToProps: null | undefined,
|
|
>mapStateToProps : null | undefined
|
|
>null : null
|
|
|
|
mapDispatchToProps: TDispatchProps
|
|
>mapDispatchToProps : TDispatchProps
|
|
|
|
): InferableComponentEnhancerWithProps<
|
|
ResolveThunks<TDispatchProps>,
|
|
TOwnProps
|
|
>;
|
|
};
|
|
|
|
type InferThunkActionCreatorType<
|
|
>InferThunkActionCreatorType : InferThunkActionCreatorType<TActionCreator>
|
|
|
|
TActionCreator extends (...args: any[]) => any
|
|
>args : any[]
|
|
|
|
> = TActionCreator extends (
|
|
...args: infer TParams
|
|
>args : TParams
|
|
|
|
) => (...args: any[]) => infer TReturn
|
|
>args : any[]
|
|
|
|
? (...args: TParams) => TReturn
|
|
>args : TParams
|
|
|
|
: TActionCreator;
|
|
|
|
type HandleThunkActionCreator<TActionCreator> = TActionCreator extends (
|
|
>HandleThunkActionCreator : HandleThunkActionCreator<TActionCreator>
|
|
|
|
...args: any[]
|
|
>args : any[]
|
|
|
|
) => any
|
|
? InferThunkActionCreatorType<TActionCreator>
|
|
: TActionCreator;
|
|
|
|
type ResolveThunks<TDispatchProps> = TDispatchProps extends {
|
|
>ResolveThunks : ResolveThunks<TDispatchProps>
|
|
|
|
[key: string]: any;
|
|
>key : string
|
|
}
|
|
? { [C in keyof TDispatchProps]: HandleThunkActionCreator<TDispatchProps[C]> }
|
|
: TDispatchProps;
|
|
|
|
interface Dispatch<A extends Action = AnyAction> {
|
|
<T extends A>(action: T): T;
|
|
>action : T
|
|
}
|
|
interface Action<T = any> {
|
|
type: T;
|
|
>type : T
|
|
}
|
|
interface AnyAction extends Action {
|
|
[extraProps: string]: any;
|
|
>extraProps : string
|
|
}
|
|
|
|
const simpleAction = (payload: boolean) => ({
|
|
>simpleAction : (payload: boolean) => { type: string; payload: boolean; }
|
|
>(payload: boolean) => ({ type: "SIMPLE_ACTION", payload}) : (payload: boolean) => { type: string; payload: boolean; }
|
|
>payload : boolean
|
|
>({ type: "SIMPLE_ACTION", payload}) : { type: string; payload: boolean; }
|
|
>{ type: "SIMPLE_ACTION", payload} : { type: string; payload: boolean; }
|
|
|
|
type: "SIMPLE_ACTION",
|
|
>type : string
|
|
>"SIMPLE_ACTION" : "SIMPLE_ACTION"
|
|
|
|
payload
|
|
>payload : boolean
|
|
|
|
});
|
|
const thunkAction = (param1: number, param2: string) => async (
|
|
>thunkAction : (param1: number, param2: string) => (dispatch: Dispatch, { foo }: OwnProps) => Promise<string>
|
|
>(param1: number, param2: string) => async ( dispatch: Dispatch, { foo }: OwnProps) => { return foo;} : (param1: number, param2: string) => (dispatch: Dispatch, { foo }: OwnProps) => Promise<string>
|
|
>param1 : number
|
|
>param2 : string
|
|
>async ( dispatch: Dispatch, { foo }: OwnProps) => { return foo;} : (dispatch: Dispatch, { foo }: OwnProps) => Promise<string>
|
|
|
|
dispatch: Dispatch,
|
|
>dispatch : Dispatch<AnyAction>
|
|
|
|
{ foo }: OwnProps
|
|
>foo : string
|
|
|
|
) => {
|
|
return foo;
|
|
>foo : string
|
|
|
|
};
|
|
interface OwnProps {
|
|
foo: string;
|
|
>foo : string
|
|
}
|
|
interface TestComponentProps extends OwnProps {
|
|
simpleAction: typeof simpleAction;
|
|
>simpleAction : (payload: boolean) => { type: string; payload: boolean; }
|
|
>simpleAction : (payload: boolean) => { type: string; payload: boolean; }
|
|
|
|
thunkAction(param1: number, param2: string): Promise<string>;
|
|
>thunkAction : (param1: number, param2: string) => Promise<string>
|
|
>param1 : number
|
|
>param2 : string
|
|
}
|
|
class TestComponent extends Component<TestComponentProps> {}
|
|
>TestComponent : TestComponent
|
|
>Component : Component<TestComponentProps>
|
|
|
|
const mapDispatchToProps = { simpleAction, thunkAction };
|
|
>mapDispatchToProps : { simpleAction: (payload: boolean) => { type: string; payload: boolean; }; thunkAction: (param1: number, param2: string) => (dispatch: Dispatch<AnyAction>, { foo }: OwnProps) => Promise<string>; }
|
|
>{ simpleAction, thunkAction } : { simpleAction: (payload: boolean) => { type: string; payload: boolean; }; thunkAction: (param1: number, param2: string) => (dispatch: Dispatch<AnyAction>, { foo }: OwnProps) => Promise<string>; }
|
|
>simpleAction : (payload: boolean) => { type: string; payload: boolean; }
|
|
>thunkAction : (param1: number, param2: string) => (dispatch: Dispatch<AnyAction>, { foo }: OwnProps) => Promise<string>
|
|
|
|
type Q = HandleThunkActionCreator<typeof simpleAction>;
|
|
>Q : (payload: boolean) => { type: string; payload: boolean; }
|
|
>simpleAction : (payload: boolean) => { type: string; payload: boolean; }
|
|
|
|
const Test1 = connect(
|
|
>Test1 : ConnectedComponentClass<typeof TestComponent, Omit<TestComponentProps, "simpleAction" | "thunkAction">>
|
|
>connect( null, mapDispatchToProps)(TestComponent) : ConnectedComponentClass<typeof TestComponent, Omit<TestComponentProps, "simpleAction" | "thunkAction">>
|
|
>connect( null, mapDispatchToProps) : InferableComponentEnhancerWithProps<{ simpleAction: (payload: boolean) => { type: string; payload: boolean; }; thunkAction: (param1: number, param2: string) => Promise<string>; }, {}>
|
|
>connect : <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: TDispatchProps) => InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps>, TOwnProps>
|
|
|
|
null,
|
|
>null : null
|
|
|
|
mapDispatchToProps
|
|
>mapDispatchToProps : { simpleAction: (payload: boolean) => { type: string; payload: boolean; }; thunkAction: (param1: number, param2: string) => (dispatch: Dispatch<AnyAction>, { foo }: OwnProps) => Promise<string>; }
|
|
|
|
)(TestComponent);
|
|
>TestComponent : typeof TestComponent
|
|
|
|
export {};
|
|
|