Interface DevToolsEnhancerOptions

interface DevToolsEnhancerOptions {
    actionCreators?:
        | ActionCreator<any, any[]>[]
        | { [key: string]: ActionCreator<any, any[]> };
    actionsAllowlist?: string | string[];
    actionSanitizer?: <A extends Action>(action: A, id: number) => A;
    actionsDenylist?: string | string[];
    autoPause?: boolean;
    features?: {
        dispatch?: boolean;
        export?: boolean | "custom";
        import?: boolean | "custom";
        jump?: boolean;
        lock?: boolean;
        pause?: boolean;
        persist?: boolean;
        reorder?: boolean;
        skip?: boolean;
        test?: boolean;
    };
    latency?: number;
    maxAge?: number;
    name?: string;
    pauseActionType?: string;
    predicate?: <S, A extends Action>(state: S, action: A) => boolean;
    serialize?:
        | boolean
        | {
            immutable?: any;
            options?: | boolean
            | {
                date?: true;
                error?: true;
                function?: true
                | ((fn: (...args: any[]) => any) => string);
                map?: true;
                regex?: true;
                set?: true;
                symbol?: true;
                undefined?: true;
            };
            refs?: any;
            replacer?: (key: string, value: unknown) => any;
            reviver?: (key: string, value: unknown) => any;
        };
    shouldCatchErrors?: boolean;
    shouldHotReload?: boolean;
    shouldRecordChanges?: boolean;
    shouldStartLocked?: boolean;
    stateSanitizer?: <S>(state: S, index: number) => S;
    trace?: boolean | (<A extends Action>(action: A) => string);
    traceLimit?: number;
}

Index

Properties

actionCreators? actionsAllowlist? actionSanitizer? actionsDenylist? autoPause? features? latency? maxAge? name? pauseActionType? predicate? serialize? shouldCatchErrors? shouldHotReload? shouldRecordChanges? shouldStartLocked? stateSanitizer? trace? traceLimit?

Properties

`Optional`actionCreators

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

action creators functions to be available in the Dispatcher.

`Optional`actionsAllowlist

actionsAllowlist?: string | string[]

string or array of strings as regex - actions types to be hidden / shown in the monitors (while passed to the reducers). If actionsAllowlist specified, actionsDenylist is ignored.

`Optional`actionSanitizer

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

function which takes action object and id number as arguments, and should return action object back.

`Optional`actionsDenylist

actionsDenylist?: string | string[]

string or array of strings as regex - actions types to be hidden / shown in the monitors (while passed to the reducers). If actionsAllowlist specified, actionsDenylist is ignored.

`Optional`autoPause

autoPause?: boolean

auto pauses when the extension’s window is not opened, and so has zero impact on your app when not in use. Not available for Redux enhancer (as it already does it but storing the data to be sent).

Default

false

`Optional`features

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

If you want to restrict the extension, specify the features you allow. If not specified, all of the features are enabled. When set as an object, only those included as true will be allowed. Note that except true/false, import and export can be set as custom (which is by default for Redux enhancer), meaning that the importing/exporting occurs on the client side. Otherwise, you'll get/set the data right from the monitor part.

Type declaration

Optionaldispatch?: boolean
dispatch custom actions or action creators
Optionalexport?: boolean | "custom"
export history of actions in a file
Optionalimport?: boolean | "custom"
import history of actions from a file
Optionaljump?: boolean
jump back and forth (time travelling)
Optionallock?: boolean
lock/unlock dispatching actions and side effects
Optionalpause?: boolean
start/pause recording of dispatched actions
Optionalpersist?: boolean
persist states on page reloading
Optionalreorder?: boolean
drag and drop actions in the history list
Optionalskip?: boolean
skip (cancel) actions
Optionaltest?: boolean
generate tests for the selected actions

`Optional`latency

latency?: number

if more than one action is dispatched in the indicated interval, all new actions will be collected and sent at once. It is the joint between performance and speed. When set to 0, all actions will be sent instantly. Set it to a higher value when experiencing perf issues (also maxAge to a lower value).

Default

500 ms.

`Optional`maxAge

maxAge?: number

(> 1) - maximum allowed actions to be stored in the history tree. The oldest actions are removed once maxAge is reached. It's critical for performance.

Default

`Optional`name

name?: string

the instance name to be showed on the monitor page. Default value is document.title. If not specified and there's no document title, it will consist of tabId and instanceId.

`Optional`pauseActionType

pauseActionType?: string

if specified, whenever clicking on Pause recording button and there are actions in the history log, will add this action type. If not specified, will commit when paused. Available only for Redux enhancer.

Default

"@@PAUSED""

`Optional`predicate

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

called for every action before sending, takes state and action object, and returns true in case it allows sending the current data to the monitor. Use it as a more advanced version of actionsDenylist/actionsAllowlist parameters.

`Optional`serialize

serialize?:
    | boolean
    | {
        immutable?: any;
        options?: | boolean
        | {
            date?: true;
            error?: true;
            function?: true
            | ((fn: (...args: any[]) => any) => string);
            map?: true;
            regex?: true;
            set?: true;
            symbol?: true;
            undefined?: true;
        };
        refs?: any;
        replacer?: (key: string, value: unknown) => any;
        reviver?: (key: string, value: unknown) => any;
    }

Customizes how actions and state are serialized and deserialized. Can be a boolean or object. If given a boolean, the behavior is the same as if you were to pass an object and specify options as a boolean. Giving an object allows fine-grained customization using the replacer and reviver functions.

Type declaration

boolean
{
    immutable?: any;
    options?:
        | boolean
        | {
            date?: true;
            error?: true;
            function?: true
            | ((fn: (...args: any[]) => any) => string);
            map?: true;
            regex?: true;
            set?: true;
            symbol?: true;
            undefined?: true;
        };
    refs?: any;
    replacer?: (key: string, value: unknown) => any;
    reviver?: (key: string, value: unknown) => any;
}
- Optionalimmutable?: any
  Automatically serialize/deserialize immutablejs via remotedev-serialize. Just pass the Immutable library. It will support all ImmutableJS structures. You can even export them into a file and get them back. The only exception is Record class, for which you should pass this in addition the references to your classes in refs.
- Optionaloptions?:
      | boolean
      | {
          date?: true;
          error?: true;
          function?: true
          | ((fn: (...args: any[]) => any) => string);
          map?: true;
          regex?: true;
          set?: true;
          symbol?: true;
          undefined?: true;
      }
  - undefined - will use regular JSON.stringify to send data (it's the fast mode).
  - false - will handle also circular references.
  - true - will handle also date, regex, undefined, error objects, symbols, maps, sets and functions.
  - object, which contains date, regex, undefined, error, symbol, map, set and function keys. For each of them you can indicate if to include (by setting as true). For function key you can also specify a custom function which handles serialization. See jsan for more details.
- Optionalrefs?: any
  ImmutableJS Record classes used to make possible restore its instances back when importing, persisting...
- Optionalreplacer?: (key: string, value: unknown) => any
  JSON replacer function used for both actions and states stringify. In addition, you can specify a data type by adding a __serializedType__ key. So you can deserialize it back while importing or persisting data. Moreover, it will also show a nice preview showing the provided custom type:
- Optionalreviver?: (key: string, value: unknown) => any
  JSON reviver function used for parsing the imported actions and states. See remotedev-serialize as an example on how to serialize special data types and get them back.

`Optional`shouldCatchErrors

shouldCatchErrors?: boolean

if specified as true, whenever there's an exception in reducers, the monitors will show the error message, and next actions will not be dispatched.

Default

false

`Optional`shouldHotReload

shouldHotReload?: boolean

if set to false, will not recompute the states on hot reloading (or on replacing the reducers). Available only for Redux enhancer.

Default

true

`Optional`shouldRecordChanges

shouldRecordChanges?: boolean

if specified as false, it will not record the changes till clicking on Start recording button. Available only for Redux enhancer, for others use autoPause.

Default

true

`Optional`shouldStartLocked

shouldStartLocked?: boolean

if specified as true, it will not allow any non-monitor actions to be dispatched till clicking on Unlock changes button. Available only for Redux enhancer.

Default

false

`Optional`stateSanitizer

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

function which takes state object and index as arguments, and should return state object back.

`Optional`trace

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

Set to true or a stacktrace-returning function to record call stack traces for dispatched actions. Defaults to false.

`Optional`traceLimit

traceLimit?: number

The maximum number of stack trace entries to record per action. Defaults to 10.

Interface DevToolsEnhancerOptions

Index

Properties

Properties

OptionalactionCreators

OptionalactionsAllowlist

OptionalactionSanitizer

OptionalactionsDenylist

OptionalautoPause

Default

Optionalfeatures

Type declaration

Optionaldispatch?: boolean

Optionalexport?: boolean | "custom"

Optionalimport?: boolean | "custom"

Optionaljump?: boolean

Optionallock?: boolean

Optionalpause?: boolean

Optionalpersist?: boolean

Optionalreorder?: boolean

Optionalskip?: boolean

Optionaltest?: boolean

Optionallatency

Default

OptionalmaxAge

Default

Optionalname

OptionalpauseActionType

Default

Optionalpredicate

Optionalserialize

Type declaration

Optionalimmutable?: any

Optionaloptions?: | boolean | { date?: true; error?: true; function?: true | ((fn: (...args: any[]) => any) => string); map?: true; regex?: true; set?: true; symbol?: true; undefined?: true; }

Optionalrefs?: any

Optionalreplacer?: (key: string, value: unknown) => any

Optionalreviver?: (key: string, value: unknown) => any

OptionalshouldCatchErrors

Default

OptionalshouldHotReload

Default

OptionalshouldRecordChanges

Default

OptionalshouldStartLocked

Default

OptionalstateSanitizer

Optionaltrace

OptionaltraceLimit

Settings

On This Page

`Optional`actionCreators

`Optional`actionsAllowlist

`Optional`actionSanitizer

`Optional`actionsDenylist

`Optional`autoPause

`Optional`features

`Optional`dispatch?: boolean

`Optional`export?: boolean | "custom"

`Optional`import?: boolean | "custom"

`Optional`jump?: boolean

`Optional`lock?: boolean

`Optional`pause?: boolean

`Optional`persist?: boolean

`Optional`reorder?: boolean

`Optional`skip?: boolean

`Optional`test?: boolean

`Optional`latency

`Optional`maxAge

`Optional`name

`Optional`pauseActionType

`Optional`predicate

`Optional`serialize

`Optional`immutable?: any

`Optional`options?:
| boolean
| {
date?: true;
error?: true;
function?: true
| ((fn: (...args: any[]) => any) => string);
map?: true;
regex?: true;
set?: true;
symbol?: true;
undefined?: true;
}

`Optional`refs?: any

`Optional`replacer?: (key: string, value: unknown) => any

`Optional`reviver?: (key: string, value: unknown) => any

`Optional`shouldCatchErrors

`Optional`shouldHotReload

`Optional`shouldRecordChanges

`Optional`shouldStartLocked

`Optional`stateSanitizer

`Optional`trace

`Optional`traceLimit