@types/recompose

Version 0.30.15
Published 8 months ago
32.4 kB
2 dependencies
MIT license

Install

npm i @types/recompose

yarn add @types/recompose

pnpm add @types/recompose

Overview

TypeScript definitions for recompose

Index

Namespaces

recompose
recompose/baconObservableConfig
- baconConfig
recompose/branch
- branch()
recompose/componentFromProp
- componentFromProp()
recompose/componentFromStream
- componentFromStream()
- componentFromStreamWithConfig()
recompose/compose
- compose()
recompose/createEventHandler
- createEventHandler()
- createEventHandlerWithConfig()
recompose/createSink
- createSink()
recompose/defaultProps
- defaultProps()
recompose/flattenProp
- flattenProp()
recompose/fromRenderProps
- fromRenderProps()
recompose/getContext
- getContext()
recompose/getDisplayName
- getDisplayName()
recompose/hoistStatics
- hoistStatics()
recompose/isClassComponent
- isClassComponent()
recompose/kefirObservableConfig
- kefirConfig
recompose/lifecycle
- lifecycle()
recompose/mapProps
- mapProps()
recompose/mapPropsStream
- mapPropsStream()
- mapPropsStreamWithConfig()
recompose/mostObservableConfig
- mostConfig
recompose/nest
- nest()
recompose/onlyUpdateForKeys
- onlyUpdateForKeys()
recompose/onlyUpdateForPropTypes
- onlyUpdateForPropTypes
recompose/pure
- pure()
recompose/renameProp
- renameProp()
recompose/renameProps
- renameProps()
recompose/renderComponent
- renderComponent()
recompose/renderNothing
- renderNothing
recompose/rxjs4ObservableConfig
- rxjs4config
recompose/rxjsObservableConfig
- rxjsconfig
recompose/setDisplayName
- setDisplayName()
recompose/setObservableConfig
- setObservableConfig()
recompose/setPropTypes
- setPropTypes()
recompose/setStatic
- setStatic()
recompose/shallowEqual
- shallowEqual()
recompose/shouldUpdate
- shouldUpdate()
recompose/toClass
- toClass
recompose/toRenderProps
- toRenderProps()
recompose/withContext
- withContext()
recompose/withHandlers
- withHandlers()
recompose/withProps
- withProps()
recompose/withPropsOnChange
- withPropsOnChange()
recompose/withReducer
- withReducer()
recompose/withState
- withState()
recompose/withStateHandlers
- withStateHandlers()
recompose/wrapDisplayName
- wrapDisplayName()
recompose/xstreamObservableConfig
- xstreamConfig

Namespaces

namespace recompose

module 'recompose' {}

variable onlyUpdateForPropTypes

const onlyUpdateForPropTypes: InferableComponentEnhancer<{}>;

variable renderNothing

const renderNothing: InferableComponentEnhancer<{}>;

variable toClass

const toClass: InferableComponentEnhancer<{}>;

function branch

branch: <TOutter>(
    test: predicate<TOutter>,
    trueEnhancer: ComponentEnhancer<any, any> | InferableComponentEnhancer<{}>,
    falseEnhancer?: ComponentEnhancer<any, any> | InferableComponentEnhancer<{}>
) => ComponentEnhancer<any, TOutter>;

function componentFromProp

componentFromProp: (propName: string) => FunctionComponent<any>;

function componentFromStream

componentFromStream: <TProps>(
    propsToReactNode: mapper<Subscribable<TProps>, Subscribable<React.ReactNode>>
) => Component<TProps>;

function componentFromStreamWithConfig

componentFromStreamWithConfig: (
    config: ObservableConfig
) => <TProps>(
    propsToReactNode: mapper<Subscribable<TProps>, Subscribable<React.ReactNode>>
) => Component<TProps>;

function compose

compose: <TInner, TOutter>(
    ...functions: Function[]
) => ComponentEnhancer<TInner, TOutter>;

function createEagerElement

createEagerElement: (
    type: Component<any> | string,
    props?: Object,
    children?: React.ReactNode
) => React.ReactElement;

function createEagerFactory

createEagerFactory: (type: Component<any> | string) => componentFactory;

function createEventHandler

createEventHandler: <T, TSubs extends Subscribable<T>>() => EventHandlerOf<
    T,
    TSubs
>;

function createEventHandlerWithConfig

createEventHandlerWithConfig: (
    config: ObservableConfig
) => <T, TSubs extends Subscribable<T>>() => EventHandlerOf<T, TSubs>;

function createSink

createSink: (callback: (props: Object) => void) => React.ComponentClass<any>;

function defaultProps

defaultProps: <T = {}>(props: T) => DefaultingInferableComponentEnhancer<T>;

function flattenProp

flattenProp: (propName: string) => ComponentEnhancer<any, any>;

function fromRenderProps

fromRenderProps: <TInner, TOutter, TRenderProps = {}>(
    RenderPropsComponent: Component<any>,
    propsMapper: (props: TRenderProps) => TInner,
    renderPropName?: string
) => ComponentEnhancer<TInner & TOutter, TOutter>;

function getContext

getContext: <TContext>(
    contextTypes: PropTypes.ValidationMap<TContext>
) => InferableComponentEnhancer<TContext>;

function getDisplayName

getDisplayName: (component: Component<any>) => string;

function hoistStatics

hoistStatics: <TProps>(
    hoc: InferableComponentEnhancer<TProps>,
    blacklist?: { [key: string]: boolean }
) => InferableComponentEnhancer<TProps>;

function isClassComponent

isClassComponent: (value: any) => boolean;

function lifecycle

lifecycle: <TProps, TState, TInstance = {}>(
    spec: ReactLifeCycleFunctions<TProps, TState, TInstance> & TInstance
) => InferableComponentEnhancer<{}>;

function mapProps

mapProps: <TInner, TOutter>(
    propsMapper: mapper<TOutter, TInner>
) => InferableComponentEnhancerWithProps<TInner, TOutter>;

function mapPropsStream

mapPropsStream: <TInner, TOutter>(
    transform: mapper<Subscribable<TOutter>, Subscribable<TInner>>
) => ComponentEnhancer<TInner, TOutter>;

function mapPropsStreamWithConfig

mapPropsStreamWithConfig: (
    config: ObservableConfig
) => <TInner, TOutter>(
    transform: mapper<Subscribable<TOutter>, Subscribable<TInner>>
) => ComponentEnhancer<TInner, TOutter>;

function nest

nest: (
    ...Components: Array<string | Component<any>>
) => React.ComponentClass<any>;

function onlyUpdateForKeys

onlyUpdateForKeys: {
    (propKeys: string[]): InferableComponentEnhancer<{}>;
    <T>(propKeys: (keyof T)[]): InferableComponentEnhancer<{}>;
};

function pure

pure: <TProps>(component: Component<TProps>) => Component<TProps>;

function renameProp

renameProp: (
    outterName: string,
    innerName: string
) => ComponentEnhancer<any, any>;

function renameProps

renameProps: (nameMap: NameMap) => ComponentEnhancer<any, any>;

function renderComponent

renderComponent: <TProps>(
    component: string | Component<TProps>
) => ComponentEnhancer<any, any>;

function setDisplayName

setDisplayName: (
    displayName: string
) => <T extends Component<any>>(component: T) => T;

function setObservableConfig

setObservableConfig: (config: ObservableConfig) => void;

function setPropTypes

setPropTypes: <P>(
    propTypes: PropTypes.ValidationMap<P>
) => <T extends Component<P>>(component: T) => T;

function setStatic

setStatic: (
    key: string,
    value: any
) => <T extends Component<any>>(component: T) => T;

function shallowEqual

shallowEqual: (a: Object, b: Object) => boolean;

function shouldUpdate

shouldUpdate: <TProps>(
    test: predicateDiff<TProps>
) => InferableComponentEnhancer<{}>;

function toRenderProps

toRenderProps: <TInner, TOutter>(
    hoc: InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>
) => FunctionComponent<
    TOutter & { children: (props: TInner) => React.ReactElement }
>;

function withContext

withContext: <TContext, TProps>(
    childContextTypes: PropTypes.ValidationMap<TContext>,
    getChildContext: mapper<TProps, any>
) => InferableComponentEnhancer<{}>;

function withHandlers

withHandlers: <TOutter, THandlers>(
    handlerCreators:
        | HandleCreators<TOutter, THandlers>
        | HandleCreatorsFactory<TOutter, THandlers>
) => InferableComponentEnhancerWithProps<THandlers & TOutter, TOutter>;

function withProps

withProps: <TInner, TOutter>(
    createProps: TInner | mapper<TOutter, TInner>
) => InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>;

function withPropsOnChange

withPropsOnChange: <TInner, TOutter>(
    shouldMapOrKeys: string[] | predicateDiff<TOutter>,
    createProps: mapper<TOutter, TInner>
) => InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>;

function withReducer

withReducer: <
    TOutter,
    TState,
    TAction,
    TStateName extends string,
    TDispatchName extends string
>(
    stateName: TStateName,
    dispatchName: TDispatchName,
    reducer: reducer<TState, TAction>,
    initialState: TState | mapper<TOutter, TState>
) => InferableComponentEnhancerWithProps<
    reducerProps<TState, TAction, TStateName, TDispatchName>,
    TOutter
>;

function withState

withState: <
    TOutter,
    TState,
    TStateName extends string,
    TStateUpdaterName extends string
>(
    stateName: TStateName,
    stateUpdaterName: TStateUpdaterName,
    initialState: TState | mapper<TOutter, TState>
) => InferableComponentEnhancerWithProps<
    stateProps<TState, TStateName, TStateUpdaterName>,
    TOutter
>;

function withStateHandlers

withStateHandlers: <
    TState,
    TUpdaters extends StateHandlerMap<TState>,
    TOutter = {}
>(
    createProps: TState | mapper<TOutter, TState>,
    stateUpdaters: StateUpdaters<TOutter, TState, TUpdaters>
) => InferableComponentEnhancerWithProps<TOutter & TState & TUpdaters, TOutter>;

function wrapDisplayName

wrapDisplayName: (component: Component<any>, wrapperName: string) => string;

interface ComponentEnhancer

interface ComponentEnhancer<TInner, TOutter> {}

call signature

(component: Component<TInner>): ComponentClass<TOutter>;

interface InferableComponentEnhancerWithProps

interface InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> {}

call signature

<P extends TInjectedProps>(component: Component<P>): React.ComponentClass<
    Omit<P, keyof TInjectedProps> & TNeedsProps
>;

interface Observer

interface Observer<T> {}

method complete

complete: () => void;

method next

next: (props: T) => void;

interface ReactLifeCycleFunctions

interface ReactLifeCycleFunctions<TProps, TState, TInstance = {}> {}

property componentDidCatch

componentDidCatch?:
    | ((
          this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
          error: Error,
          info: React.ErrorInfo
      ) => void)
    | undefined;

property componentDidMount

componentDidMount?:
    | ((
          this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>
      ) => void)
    | undefined;

property componentDidUpdate

componentDidUpdate?:
    | ((
          this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
          prevProps: TProps,
          prevState: TState
      ) => void)
    | undefined;

property componentWillMount

componentWillMount?:
    | ((
          this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>
      ) => void)
    | undefined;

property componentWillReceiveProps

componentWillReceiveProps?:
    | ((
          this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
          nextProps: TProps
      ) => void)
    | undefined;

property componentWillUnmount

componentWillUnmount?:
    | ((
          this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>
      ) => void)
    | undefined;

property componentWillUpdate

componentWillUpdate?:
    | ((
          this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
          nextProps: TProps,
          nextState: TState
      ) => void)
    | undefined;

property shouldComponentUpdate

shouldComponentUpdate?:
    | ((
          this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
          nextProps: TProps,
          nextState: TState
      ) => boolean)
    | undefined;

method UNSAFE_componentWillMount

UNSAFE_componentWillMount: (
    this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>
) => void;

method UNSAFE_componentWillReceiveProps

UNSAFE_componentWillReceiveProps: (
    this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
    nextProps: TProps
) => void;

method UNSAFE_componentWillUpdate

UNSAFE_componentWillUpdate: (
    this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
    nextProps: TProps,
    nextState: TState
) => void;

interface Subscribable

interface Subscribable<T> {}

subscribe: (observer: Observer<T>) => Subscription;

interface Subscription

interface Subscription {}

method unsubscribe

unsubscribe: () => void;

type componentFactory

type componentFactory = (
    props?: Object,
    children?: React.ReactNode
) => React.ReactElement;

type DefaultingInferableComponentEnhancer

type DefaultingInferableComponentEnhancer<TInjectedProps> =
    InferableComponentEnhancerWithProps<TInjectedProps, Partial<TInjectedProps>>;

type EventHandler

type EventHandler = Function;

type EventHandlerOf

type EventHandlerOf<T, TSubs extends Subscribable<T>> = {
    handler: (value: T) => void;
    stream: TSubs;
};

type HandleCreators

type HandleCreators<TOutter, THandlers> = HandleCreatorsStructure<TOutter> &
    HandleCreatorsHandlers<TOutter, THandlers>;

type HandleCreatorsFactory

type HandleCreatorsFactory<TOutter, THandlers> = (
    initialProps: TOutter
) => HandleCreators<TOutter, THandlers>;

type HandleCreatorsHandlers

type HandleCreatorsHandlers<TOutter, THandlers> = {
    [P in keyof THandlers]: (props: TOutter) => THandlers[P];
};

type HandleCreatorsStructure

type HandleCreatorsStructure<TOutter> = {
    [handlerName: string]: mapper<TOutter, EventHandler>;
};

type InferableComponentEnhancer

type InferableComponentEnhancer<TInjectedProps> =
    InferableComponentEnhancerWithProps<TInjectedProps, {}>;

type mapper

type mapper<TInner, TOutter> = (input: TInner) => TOutter;

type NameMap

type NameMap = {
    [outterName: string]: string;
};

type ObservableConfig

type ObservableConfig = {
    fromESObservable?: (<T>(observable: Subscribable<T>) => any) | undefined;
    toESObservable?: (<T>(stream: any) => Subscribable<T>) | undefined;
};

type Omit

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

type predicate

type predicate<T> = mapper<T, boolean>;

type predicateDiff

type predicateDiff<T> = (current: T, next: T) => boolean;

type ReactLifeCycleFunctionsThisArguments

type ReactLifeCycleFunctionsThisArguments<
    TProps,
    TState,
    TInstance = {}
> = _ReactLifeCycleFunctionsThisArguments<TProps, TState> & TInstance;

type reducer

type reducer<TState, TAction> = (s: TState, a: TAction) => TState;

type reducerProps

type reducerProps<
    TState,
    TAction,
    TStateName extends string,
    TDispatchName extends string
> = { [stateName in TStateName]: TState } & {
    [dispatchName in TDispatchName]: (a: TAction) => void;
};

type StateHandler

type StateHandler<TState> = (...payload: any[]) => Partial<TState> | undefined;

type StateHandlerMap

type StateHandlerMap<TState> = {
    [updaterName: string]: StateHandler<TState>;
};

type stateProps

type stateProps<
    TState,
    TStateName extends string,
    TStateUpdaterName extends string
> = { [stateName in TStateName]: TState } & {
    [stateUpdateName in TStateUpdaterName]: (state: TState) => TState;
};

type StateUpdaters

type StateUpdaters<TOutter, TState, TUpdaters> = {
    [updaterName in keyof TUpdaters]: (
        state: TState,
        props: TOutter
    ) => TUpdaters[updaterName];
};

namespace recompose/baconObservableConfig

module 'recompose/baconObservableConfig' {}

variable baconConfig

const baconConfig: ObservableConfig;

namespace recompose/branch

module 'recompose/branch' {}

function branch

branch: <TOutter>(
    test: predicate<TOutter>,
    trueEnhancer: ComponentEnhancer<any, any> | InferableComponentEnhancer<{}>,
    falseEnhancer?: ComponentEnhancer<any, any> | InferableComponentEnhancer<{}>
) => ComponentEnhancer<any, TOutter>;

namespace recompose/componentFromProp

module 'recompose/componentFromProp' {}

function componentFromProp

componentFromProp: (propName: string) => FunctionComponent<any>;

namespace recompose/componentFromStream

module 'recompose/componentFromStream' {}

function componentFromStream

componentFromStream: <TProps>(
    propsToReactNode: mapper<Subscribable<TProps>, Subscribable<React.ReactNode>>
) => Component<TProps>;

function componentFromStreamWithConfig

componentFromStreamWithConfig: (
    config: ObservableConfig
) => <TProps>(
    propsToReactNode: mapper<Subscribable<TProps>, Subscribable<React.ReactNode>>
) => Component<TProps>;

namespace recompose/compose

module 'recompose/compose' {}

function compose

compose: <TInner, TOutter>(
    ...functions: Function[]
) => ComponentEnhancer<TInner, TOutter>;

namespace recompose/createEventHandler

module 'recompose/createEventHandler' {}

function createEventHandler

createEventHandler: <T, TSubs extends Subscribable<T>>() => EventHandlerOf<
    T,
    TSubs
>;

function createEventHandlerWithConfig

createEventHandlerWithConfig: (
    config: ObservableConfig
) => <T, TSubs extends Subscribable<T>>() => EventHandlerOf<T, TSubs>;

namespace recompose/createSink

module 'recompose/createSink' {}

function createSink

createSink: (callback: (props: Object) => void) => React.ComponentClass<any>;

namespace recompose/defaultProps

module 'recompose/defaultProps' {}

function defaultProps

defaultProps: <T = {}>(props: T) => DefaultingInferableComponentEnhancer<T>;

namespace recompose/flattenProp

module 'recompose/flattenProp' {}

function flattenProp

flattenProp: (propName: string) => ComponentEnhancer<any, any>;

namespace recompose/fromRenderProps

module 'recompose/fromRenderProps' {}

function fromRenderProps

fromRenderProps: <TInner, TOutter, TRenderProps = {}>(
    RenderPropsComponent: Component<any>,
    propsMapper: (props: TRenderProps) => TInner,
    renderPropName?: string
) => ComponentEnhancer<TInner & TOutter, TOutter>;

namespace recompose/getContext

module 'recompose/getContext' {}

function getContext

getContext: <TContext>(
    contextTypes: PropTypes.ValidationMap<TContext>
) => InferableComponentEnhancer<TContext>;

namespace recompose/getDisplayName

module 'recompose/getDisplayName' {}

function getDisplayName

getDisplayName: (component: Component<any>) => string;

namespace recompose/hoistStatics

module 'recompose/hoistStatics' {}

function hoistStatics

hoistStatics: <TProps>(
    hoc: InferableComponentEnhancer<TProps>,
    blacklist?: { [key: string]: boolean }
) => InferableComponentEnhancer<TProps>;

namespace recompose/isClassComponent

module 'recompose/isClassComponent' {}

function isClassComponent

isClassComponent: (value: any) => boolean;

namespace recompose/kefirObservableConfig

module 'recompose/kefirObservableConfig' {}

variable kefirConfig

const kefirConfig: ObservableConfig;

namespace recompose/lifecycle

module 'recompose/lifecycle' {}

function lifecycle

lifecycle: <TProps, TState, TInstance = {}>(
    spec: ReactLifeCycleFunctions<TProps, TState, TInstance> & TInstance
) => InferableComponentEnhancer<{}>;

namespace recompose/mapProps

module 'recompose/mapProps' {}

function mapProps

mapProps: <TInner, TOutter>(
    propsMapper: mapper<TOutter, TInner>
) => InferableComponentEnhancerWithProps<TInner, TOutter>;

namespace recompose/mapPropsStream

module 'recompose/mapPropsStream' {}

function mapPropsStream

mapPropsStream: <TInner, TOutter>(
    transform: mapper<Subscribable<TOutter>, Subscribable<TInner>>
) => ComponentEnhancer<TInner, TOutter>;

function mapPropsStreamWithConfig

mapPropsStreamWithConfig: (
    config: ObservableConfig
) => <TInner, TOutter>(
    transform: mapper<Subscribable<TOutter>, Subscribable<TInner>>
) => ComponentEnhancer<TInner, TOutter>;

namespace recompose/mostObservableConfig

module 'recompose/mostObservableConfig' {}

variable mostConfig

const mostConfig: ObservableConfig;

namespace recompose/nest

module 'recompose/nest' {}

function nest

nest: (
    ...Components: Array<string | Component<any>>
) => React.ComponentClass<any>;

namespace recompose/onlyUpdateForKeys

module 'recompose/onlyUpdateForKeys' {}

function onlyUpdateForKeys

onlyUpdateForKeys: {
    (propKeys: string[]): InferableComponentEnhancer<{}>;
    <T>(propKeys: (keyof T)[]): InferableComponentEnhancer<{}>;
};

namespace recompose/onlyUpdateForPropTypes

module 'recompose/onlyUpdateForPropTypes' {}

variable onlyUpdateForPropTypes

const onlyUpdateForPropTypes: InferableComponentEnhancer<{}>;

namespace recompose/pure

module 'recompose/pure' {}

function pure

pure: <TProps>(component: Component<TProps>) => Component<TProps>;

namespace recompose/renameProp

module 'recompose/renameProp' {}

function renameProp

renameProp: (
    outterName: string,
    innerName: string
) => ComponentEnhancer<any, any>;

namespace recompose/renameProps

module 'recompose/renameProps' {}

function renameProps

renameProps: (nameMap: NameMap) => ComponentEnhancer<any, any>;

namespace recompose/renderComponent

module 'recompose/renderComponent' {}

function renderComponent

renderComponent: <TProps>(
    component: string | Component<TProps>
) => ComponentEnhancer<any, any>;

namespace recompose/renderNothing

module 'recompose/renderNothing' {}

variable renderNothing

const renderNothing: InferableComponentEnhancer<{}>;

namespace recompose/rxjs4ObservableConfig

module 'recompose/rxjs4ObservableConfig' {}

variable rxjs4config

const rxjs4config: ObservableConfig;

namespace recompose/rxjsObservableConfig

module 'recompose/rxjsObservableConfig' {}

variable rxjsconfig

const rxjsconfig: ObservableConfig;

namespace recompose/setDisplayName

module 'recompose/setDisplayName' {}

function setDisplayName

setDisplayName: (
    displayName: string
) => <T extends Component<any>>(component: T) => T;

namespace recompose/setObservableConfig

module 'recompose/setObservableConfig' {}

function setObservableConfig

setObservableConfig: (config: ObservableConfig) => void;

namespace recompose/setPropTypes

module 'recompose/setPropTypes' {}

function setPropTypes

setPropTypes: <P>(
    propTypes: PropTypes.ValidationMap<P>
) => <T extends Component<P>>(component: T) => T;

namespace recompose/setStatic

module 'recompose/setStatic' {}

function setStatic

setStatic: (
    key: string,
    value: any
) => <T extends Component<any>>(component: T) => T;

namespace recompose/shallowEqual

module 'recompose/shallowEqual' {}

function shallowEqual

shallowEqual: (a: Object, b: Object) => boolean;

namespace recompose/shouldUpdate

module 'recompose/shouldUpdate' {}

function shouldUpdate

shouldUpdate: <TProps>(
    test: predicateDiff<TProps>
) => InferableComponentEnhancer<{}>;

namespace recompose/toClass

module 'recompose/toClass' {}

variable toClass

const toClass: InferableComponentEnhancer<{}>;

namespace recompose/toRenderProps

module 'recompose/toRenderProps' {}

function toRenderProps

toRenderProps: <TInner, TOutter>(
    hoc: InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>
) => FunctionComponent<
    TOutter & { children: (props: TInner) => React.ReactElement }
>;

namespace recompose/withContext

module 'recompose/withContext' {}

function withContext

withContext: <TContext, TProps>(
    childContextTypes: PropTypes.ValidationMap<TContext>,
    getChildContext: mapper<TProps, any>
) => InferableComponentEnhancer<{}>;

namespace recompose/withHandlers

module 'recompose/withHandlers' {}

function withHandlers

withHandlers: <TOutter, THandlers>(
    handlerCreators:
        | HandleCreators<TOutter, THandlers>
        | HandleCreatorsFactory<TOutter, THandlers>
) => InferableComponentEnhancerWithProps<THandlers & TOutter, TOutter>;

namespace recompose/withProps

module 'recompose/withProps' {}

function withProps

withProps: <TInner, TOutter>(
    createProps: TInner | mapper<TOutter, TInner>
) => InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>;

namespace recompose/withPropsOnChange

module 'recompose/withPropsOnChange' {}

function withPropsOnChange

withPropsOnChange: <TInner, TOutter>(
    shouldMapOrKeys: string[] | predicateDiff<TOutter>,
    createProps: mapper<TOutter, TInner>
) => InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>;

namespace recompose/withReducer

module 'recompose/withReducer' {}

function withReducer

withReducer: <
    TOutter,
    TState,
    TAction,
    TStateName extends string,
    TDispatchName extends string
>(
    stateName: TStateName,
    dispatchName: TDispatchName,
    reducer: reducer<TState, TAction>,
    initialState: TState | mapper<TOutter, TState>
) => InferableComponentEnhancerWithProps<
    reducerProps<TState, TAction, TStateName, TDispatchName>,
    TOutter
>;

namespace recompose/withState

module 'recompose/withState' {}

function withState

withState: <
    TOutter,
    TState,
    TStateName extends string,
    TStateUpdaterName extends string
>(
    stateName: TStateName,
    stateUpdaterName: TStateUpdaterName,
    initialState: TState | mapper<TOutter, TState>
) => InferableComponentEnhancerWithProps<
    stateProps<TState, TStateName, TStateUpdaterName>,
    TOutter
>;

namespace recompose/withStateHandlers

module 'recompose/withStateHandlers' {}

function withStateHandlers

withStateHandlers: <
    TState,
    TUpdaters extends StateHandlerMap<TState>,
    TOutter = {}
>(
    createProps: TState | mapper<TOutter, TState>,
    stateUpdaters: StateUpdaters<TOutter, TState, TUpdaters>
) => InferableComponentEnhancerWithProps<TOutter & TState & TUpdaters, TOutter>;

namespace recompose/wrapDisplayName

module 'recompose/wrapDisplayName' {}

function wrapDisplayName

wrapDisplayName: (component: Component<any>, wrapperName: string) => string;

namespace recompose/xstreamObservableConfig

module 'recompose/xstreamObservableConfig' {}

variable xstreamConfig

const xstreamConfig: ObservableConfig;

Package Files (1)

index.d.ts

Dependencies (2)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/recompose.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/recompose)

HTML

<a href="https://www.jsdocs.io/package/@types/recompose"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 8 months ago.
Package analyzed in 5730 ms.
Missing or incorrect documentation? Open an issue for this package.

@types/recompose

Install

Overview

Index

Namespaces

Namespaces

namespace recompose

variable onlyUpdateForPropTypes

variable renderNothing

variable toClass

function branch

function componentFromProp

function componentFromStream

function componentFromStreamWithConfig

function compose

function createEagerElement

function createEagerFactory

function createEventHandler

function createEventHandlerWithConfig

function createSink

function defaultProps

function flattenProp

function fromRenderProps

function getContext

function getDisplayName

function hoistStatics

function isClassComponent

function lifecycle

function mapProps

function mapPropsStream

function mapPropsStreamWithConfig

function nest

function onlyUpdateForKeys

function pure

function renameProp

function renameProps

function renderComponent

function setDisplayName

function setObservableConfig

function setPropTypes

function setStatic

function shallowEqual

function shouldUpdate

function toRenderProps

function withContext

function withHandlers

function withProps

function withPropsOnChange

function withReducer

function withState

function withStateHandlers

function wrapDisplayName

interface ComponentEnhancer

call signature

interface InferableComponentEnhancerWithProps

call signature

interface Observer

method complete

method next

interface ReactLifeCycleFunctions

property componentDidCatch

property componentDidMount

property componentDidUpdate

property componentWillMount

property componentWillReceiveProps

property componentWillUnmount

property componentWillUpdate

property shouldComponentUpdate

method UNSAFE_componentWillMount

method UNSAFE_componentWillReceiveProps

method UNSAFE_componentWillUpdate

interface Subscribable

method subscribe

interface Subscription

method unsubscribe

type componentFactory

type DefaultingInferableComponentEnhancer

type EventHandler

type EventHandlerOf

type HandleCreators