@rematch/core

@rematch/core

Version 2.2.0
Published 2 years ago
312 kB
No dependencies
MIT license

Install

npm i @rematch/core

yarn add @rematch/core

pnpm add @rematch/core

Overview

A Redux Framework

Index

Variables

_default
createModel

Functions

init()

Variables

variable _default

const _default: {
    init: <
        TModels extends Models<TModels>,
        TExtraModels extends Models<TModels> = Record<string, never>
    >(
        initConfig?: InitConfig<TModels, TExtraModels>
    ) => RematchStore<TModels, TExtraModels>;
    createModel: ModelCreator;
};

variable createModel

const createModel: ModelCreator;

Functions

function init

init: <
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels> = Record<string, never>
>(
    initConfig?: InitConfig<TModels, TExtraModels>
) => RematchStore<TModels, TExtraModels>;

Interfaces

interface Action

interface Action<TPayload = any, TMeta = any> extends ReduxAction<string> {}

property meta

meta?: TMeta;

property payload

payload?: TPayload;

interface Config

interface Config<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> extends InitConfig<TModels, TExtraModels> {}

property models

models: TModels | Partial<TModels>;

property name

name: string;

property plugins

plugins: Plugin<TModels, TExtraModels>[];

property redux

redux: ConfigRedux;

interface ConfigRedux

interface ConfigRedux<TRootState = any> extends InitConfigRedux<TRootState> {}

property enhancers

enhancers: StoreEnhancer[];

property middlewares

middlewares: Middleware[];

property reducers

reducers: ModelReducers<TRootState>;

property rootReducers

rootReducers: ReducersMapObject<TRootState, Action>;

interface DevtoolOptions

interface DevtoolOptions {}

property actionCreators

actionCreators?:
    | ActionCreator<any>[]
    | {
          [key: string]: ActionCreator<any>;
      };

property actionSanitizer

actionSanitizer?: <A extends Action>(action: A, id: number) => A;

property actionsBlacklist

actionsBlacklist?: string | string[];

property actionsWhitelist

actionsWhitelist?: string | string[];

property autoPause

autoPause?: boolean;

property disabled

disabled?: boolean;

property features

features?: {
    pause?: boolean;
    lock?: boolean;
    persist?: boolean;
    export?: boolean | 'custom';
    import?: boolean | 'custom';
    jump?: boolean;
    skip?: boolean;
    reorder?: boolean;
    dispatch?: boolean;
    test?: boolean;
};

property latency

latency?: number;

property maxAge

maxAge?: number;

property name

name?: string;

property pauseActionType

pauseActionType?: string;

property predicate

predicate?: <S, A extends Action>(state: S, action: A) => boolean;

property serialize

serialize?:
    | boolean
    | {
          date?: boolean;
          regex?: boolean;
          undefined?: boolean;
          error?: boolean;
          symbol?: boolean;
          map?: boolean;
          set?: boolean;
          function?: boolean | Function;
      };

property shouldCatchErrors

shouldCatchErrors?: boolean;

property shouldHotReload

shouldHotReload?: boolean;

property shouldRecordChanges

shouldRecordChanges?: boolean;

property shouldStartLocked

shouldStartLocked?: boolean;

property stateSanitizer

stateSanitizer?: <S>(state: S, index: number) => S;

property trace

trace?: boolean | (<A extends Action>(action: A) => string);

property traceLimit

traceLimit?: number;

index signature

[key: string]: any;

interface InitConfig

interface InitConfig<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> {}

property models

models?: TModels | Partial<TModels>;

property name

name?: string;

property plugins

plugins?: Plugin<TModels, TExtraModels>[];

property redux

redux?: InitConfigRedux;

interface InitConfigRedux

interface InitConfigRedux<TRootState = any, DevtoolComposerGeneric = any> {}

property combineReducers

combineReducers?:
    | ((
          reducers: ReducersMapObject<TRootState, Action>
      ) => ReduxReducer<TRootState>)
    | undefined;

property createStore

createStore?: StoreCreator | undefined;

property devtoolComposer

devtoolComposer?: DevtoolComposerGeneric;

property devtoolOptions

devtoolOptions?: DevtoolOptions;

property enhancers

enhancers?: StoreEnhancer[];

property initialState

initialState?: TRootState;

property middlewares

middlewares?: Middleware[];

property reducers

reducers?: ModelReducers<TRootState>;

property rootReducers

rootReducers?: ReducersMapObject<TRootState, Action>;

interface Model

interface Model<
    TModels extends Models<TModels>,
    TState = any,
    TBaseState = TState
> {}

property baseReducer

baseReducer?: ReduxReducer<TBaseState>;

property effects

effects?: ModelEffects<TModels> | ModelEffectsCreator<TModels>;

property name

name?: string;

property reducers

reducers?: ModelReducers<TState>;

property state

state: TState;

interface ModelCreator

interface ModelCreator {}

call signature

<RM extends Models<RM>>(): <
    R extends ModelReducers<S> | undefined,
    BR extends ReduxReducer<BS> | undefined,
    E extends ModelEffects<RM> | ModelEffectsCreator<RM> | undefined,
    S,
    BS = S
>(mo: {
    name?: string;
    state: S;
    reducers?: R;
    baseReducer?: BR;
    effects?: E;
}) => {
    name?: string;
    state: S;
} & (E extends undefined
    ? {}
    : {
          effects: E;
      }) &
    (R extends undefined
        ? {}
        : {
              reducers: R;
          }) &
    (BR extends undefined
        ? {}
        : {
              baseReducer: BR;
          });

interface ModelEffects

interface ModelEffects<TModels extends Models<TModels>> {}

index signature

[key: string]: ModelEffect<TModels>;

interface Models

interface Models<TModels extends Models<TModels>> {}

index signature

[key: string]: Model<TModels>;

interface NamedModel

interface NamedModel<
    TModels extends Models<TModels>,
    TState = any,
    TBaseState = TState
> extends Model<TModels, TState, TBaseState> {}

property name

name: string;

property reducers

reducers: ModelReducers<TState>;

interface Plugin

interface Plugin<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels> = Record<string, never>,
    TExposedModels = Partial<TExtraModels>
> extends PluginHooks<TModels, TExtraModels> {}

property config

config?: PluginConfig<TModels, TExtraModels, TExposedModels>;

property exposed

exposed?: PluginExposed<TModels, TExtraModels>;

interface PluginConfig

interface PluginConfig<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>,
    TExposedModels = Partial<TExtraModels>
> {}

property models

models?: TExposedModels;

property redux

redux?: InitConfigRedux;

interface PluginHooks

interface PluginHooks<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> {}

property createMiddleware

createMiddleware?: MiddlewareCreator<TModels, TExtraModels>;

property onModel

onModel?: ModelHook<TModels, TExtraModels>;

property onReducer

onReducer?: ReducerHook<TModels, TExtraModels>;

property onRootReducer

onRootReducer?: RootReducerHook<TModels, TExtraModels>;

property onStoreCreated

onStoreCreated?: StoreCreatedHook<TModels, TExtraModels>;

interface RematchBag

interface RematchBag<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> {}

property effects

effects: ModelEffects<TModels>;

property forEachPlugin

forEachPlugin: <Hook extends keyof PluginHooks<TModels, TExtraModels>>(
    method: Hook,
    fn: (content: NonNullable<PluginHooks<TModels, TExtraModels>[Hook]>) => void
) => void;

property models

models: NamedModel<TModels>[];

property reduxConfig

reduxConfig: ConfigRedux;

interface RematchStore

interface RematchStore<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> extends ReduxStore<RematchRootState<TModels, TExtraModels>, Action> {}

property addModel

addModel: (model: NamedModel<TModels>) => void;

property dispatch

dispatch: RematchDispatch<TModels>;

property name

name: string;

index signature

[index: string]:
    | ExposedFunction<TModels, TExtraModels>
    | Record<string, any>
    | string;

Type Aliases

type ExposedFunction

type ExposedFunction<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> = (rematch: RematchStore<TModels, TExtraModels>, ...args: any) => any;

type ExtractRematchDispatcherFromEffect

type ExtractRematchDispatcherFromEffect<
    TEffect extends ModelEffect<TModels>,
    TModels extends Models<TModels>
> = TEffect extends (...args: infer TRest) => infer TReturn
    ? TRest extends []
        ? RematchDispatcher<true, never, never, TReturn>
        : TRest[1] extends undefined
        ? RematchDispatcher<
              true,
              ExtractParameterFromEffect<TRest, 'payload'>,
              never,
              TReturn
          >
        : TRest[2] extends undefined
        ? RematchDispatcher<
              true,
              ExtractParameterFromEffect<TRest, 'payload'>,
              never,
              TReturn
          >
        : RematchDispatcher<
              true,
              ExtractParameterFromEffect<TRest, 'payload'>,
              ExtractParameterFromEffect<TRest, 'meta'>,
              TReturn
          >
    : never;

type ExtractRematchDispatcherFromReducer

type ExtractRematchDispatcherFromReducer<TState, TReducer> =
    TReducer extends () => any
        ? RematchDispatcher<false>
        : TReducer extends (state: TState, ...args: infer TRest) => TState | void
        ? TRest extends []
            ? RematchDispatcher<false>
            : TRest[1] extends undefined
            ? RematchDispatcher<false, ExtractParameterFromReducer<TRest, 'payload'>>
            : RematchDispatcher<
                  false,
                  ExtractParameterFromReducer<TRest, 'payload'>,
                  ExtractParameterFromReducer<TRest, 'meta'>
              >
        : never;

type ExtractRematchDispatchersFromEffects

type ExtractRematchDispatchersFromEffects<
    TEffects extends Model<TModels>['effects'],
    TModels extends Models<TModels>
> = TEffects extends (...args: any[]) => infer R
    ? R extends ModelEffects<TModels>
        ? ExtractRematchDispatchersFromEffectsObject<R, TModels>
        : never
    : TEffects extends ModelEffects<TModels>
    ? ExtractRematchDispatchersFromEffectsObject<TEffects, TModels>
    : never;

type ExtractRematchDispatchersFromEffectsObject

type ExtractRematchDispatchersFromEffectsObject<
    TEffects extends ModelEffects<TModels>,
    TModels extends Models<TModels>
> = {
    [effectKey in keyof TEffects]: ExtractRematchDispatcherFromEffect<
        TEffects[effectKey],
        TModels
    >;
};

type ExtractRematchDispatchersFromModels

type ExtractRematchDispatchersFromModels<TModels extends Models<TModels>> = {
    [modelKey in keyof TModels]: TModels[modelKey] extends Model<TModels>
        ? ModelDispatcher<TModels[modelKey], TModels>
        : never;
};

type ExtractRematchDispatchersFromReducers

type ExtractRematchDispatchersFromReducers<
    TState,
    TReducers extends Model<TModels, TState>['reducers'],
    TModels extends Models<TModels>
> = {
    [reducerKey in keyof TReducers]: ExtractRematchDispatcherFromReducer<
        TState,
        TReducers[reducerKey]
    >;
};

type ExtractRematchStateFromModels

type ExtractRematchStateFromModels<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> = {
    [modelKey in keyof TModels]: TModels[modelKey]['state'];
} & {
    [modelKey in keyof TExtraModels]: TExtraModels[modelKey]['state'];
};

type MergeExclusive

type MergeExclusive<FirstType, SecondType> = FirstType | SecondType extends object
    ?
          | (Without<FirstType, SecondType> & SecondType)
          | (Without<SecondType, FirstType> & FirstType)
    : FirstType | SecondType;

type MiddlewareCreator

type MiddlewareCreator<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels> = Record<string, never>
> = (rematch: RematchBag<TModels, TExtraModels>) => Middleware;

type ModelDispatcher

type ModelDispatcher<
    TModel extends Model<TModels>,
    TModels extends Models<TModels>
> = MergeExclusive<
    ExtractRematchDispatchersFromEffects<TModel['effects'], TModels>,
    ExtractRematchDispatchersFromReducers<
        TModel['state'],
        TModel['reducers'],
        TModels
    >
>;

type ModelEffect

type ModelEffect<TModels extends Models<TModels>> = (
    this: ModelEffectThisTyped,
    payload: Action['payload'],
    rootState: RematchRootState<TModels>,
    meta: Action['meta']
) => any;

type ModelEffectsCreator

type ModelEffectsCreator<TModels extends Models<TModels>> = (
    dispatch: RematchDispatch<TModels>
) => ModelEffects<TModels>;

type ModelEffectThisTyped

type ModelEffectThisTyped = {
    [key: string]: (payload?: any, meta?: any) => Action<any, any>;
};

type ModelHook

type ModelHook<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> = (
    model: NamedModel<TModels>,
    rematch: RematchStore<TModels, TExtraModels>
) => void;

type ModelReducers

type ModelReducers<TState = any> = {
    [key: string]: Reducer<TState>;
};

type ObjectNotAFunction

type ObjectNotAFunction = {
    [k: string]: any;
} & (
    | {
          bind?: never;
      }
    | {
          call?: never;
      }
);

type PluginExposed

type PluginExposed<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> = {
    [key: string]: ExposedFunction<TModels, TExtraModels> | ObjectNotAFunction;
};

type Reducer

type Reducer<TState = any> = (
    state: TState,
    payload?: Action['payload'],
    meta?: Action['meta']
) => TState | void;

type ReducerHook

type ReducerHook<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> = (
    reducer: ReduxReducer,
    modelName: string,
    rematch: RematchBag<TModels, TExtraModels>
) => ReduxReducer | void;

type RematchDispatch

type RematchDispatch<TModels extends Models<TModels>> = ReduxDispatch &
    ExtractRematchDispatchersFromModels<TModels>;

type RematchDispatcher

type RematchDispatcher<
    IsEffect extends boolean,
    TPayload extends [p?: unknown] = never,
    TMeta extends [m?: unknown] = never,
    TReturn = any
> = [TPayload, TMeta] extends [never, never]
    ? (() => ReturnOfDispatcher<IsEffect, TReturn>) & {
          isEffect: IsEffect;
      }
    : [TMeta] extends [never]
    ? CheckIfParameterOptional<TPayload> extends true
        ? ((
              payload?: TPayload[0]
          ) => ReturnOfDispatcher<IsEffect, TReturn, TPayload[0]>) & {
              isEffect: IsEffect;
          }
        : ((
              payload: TPayload[0]
          ) => ReturnOfDispatcher<IsEffect, TReturn, TPayload[0]>) & {
              isEffect: IsEffect;
          }
    : CheckIfParameterOptional<TMeta> extends true
    ? CheckIfParameterOptional<TPayload> extends true
        ? ((
              payload?: TPayload[0],
              meta?: TMeta[0]
          ) => ReturnOfDispatcher<IsEffect, TReturn, TPayload[0], TMeta[0]>) & {
              isEffect: IsEffect;
          }
        : ((
              payload: TPayload[0],
              meta?: TMeta[0]
          ) => ReturnOfDispatcher<IsEffect, TReturn, TPayload[0], TMeta[0]>) & {
              isEffect: IsEffect;
          }
    : ((
          payload: TPayload[0],
          meta: TMeta[0]
      ) => ReturnOfDispatcher<IsEffect, TReturn, TPayload[0], TMeta[0]>) & {
          isEffect: IsEffect;
      };

type RematchRootState

type RematchRootState<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels> = Record<string, never>
> = ExtractRematchStateFromModels<TModels, TExtraModels>;

type ReturnOfDispatcher

type ReturnOfDispatcher<
    IsEffect extends boolean,
    TReturn = any,
    TPayload = void,
    TMeta = void
> = IsEffect extends true ? TReturn : Action<TPayload, TMeta>;

type RootReducerHook

type RootReducerHook<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> = (
    reducer: ReduxReducer,
    rematch: RematchBag<TModels, TExtraModels>
) => ReduxReducer | void;

type StoreCreatedHook

type StoreCreatedHook<
    TModels extends Models<TModels>,
    TExtraModels extends Models<TModels>
> = (
    store: RematchStore<TModels, TExtraModels>,
    rematch: RematchBag<TModels, TExtraModels>
) => RematchStore<TModels, TExtraModels> | void;

Package Files (2)

Dependencies (0)

No dependencies.

Dev Dependencies (2)

Peer Dependencies (1)

redux

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/@rematch/core.

Markdown

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

HTML

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

Updated 1 year ago.
Package analyzed in 4516 ms.
Missing or incorrect documentation? Open an issue for this package.