updux/docs/typedoc/globals.md
2020-06-02 16:00:48 -04:00

20 KiB
Raw Blame History

updux - v1.2.0 Globals

updux - v1.2.0

Index

Classes

Type aliases

Variables

Functions

Type aliases

Action

Ƭ Action: object & MaybePayloadP


ActionPair

Ƭ ActionPair: [string, ActionCreator]


ActionPayloadGenerator

Ƭ ActionPayloadGenerator: function

Type declaration:

▸ (...args: any[]): any

Parameters:

Name Type
...args any[]

ActionsOf

Ƭ ActionsOf: U extends Updux ? U["actions"] : object


CoduxesOf

Ƭ CoduxesOf: U extends Updux<any, any, any, infer S> ? S : []


Dictionary

Ƭ Dictionary: object

Type declaration:

  •  **key**: *string*

Dux

Ƭ Dux: object

Type declaration:

  • actions: A

  • coduxes: Dux[]

  • initial: AggDuxStateS, C

  • subduxes: DictionaryDux


DuxActions

Ƭ DuxActions:


DuxActionsCoduxes

Ƭ DuxActionsCoduxes: C extends Array ? UnionToIntersection<ActionsOf> : object


DuxActionsSubduxes

Ƭ DuxActionsSubduxes: C extends object ? ActionsOf<C[keyof C]> : unknown


DuxSelectors

Ƭ DuxSelectors: unknown extends X ? object : X


DuxState

Ƭ DuxState: D extends object ? S : unknown


DuxStateCoduxes

Ƭ DuxStateCoduxes: C extends Array ? UnionToIntersection<StateOf> : unknown


DuxStateGlobSub

Ƭ DuxStateGlobSub: S extends object ? StateOf : unknown


DuxStateSubduxes

Ƭ DuxStateSubduxes: C extends object ? object : C extends object ? object : unknown


Effect

Ƭ Effect: [string, UpduxMiddleware | MwGen, undefined | false | true]


GenericActions

Ƭ GenericActions: DictionaryActionCreatorstring, function


ItemsOf

Ƭ ItemsOf: C extends object ? C[keyof C] : unknown


LocalDuxState

Ƭ LocalDuxState: S extends never[] ? unknown[] : S


MaybePayload

Ƭ MaybePayload: P extends object | string | boolean | number ? object : object


MaybeReturnType

Ƭ MaybeReturnType: X extends function ? ReturnType : unknown


Merge

Ƭ Merge: UnionToIntersectionT[keyof T]


Mutation

Ƭ Mutation: function

Type declaration:

▸ (payload: A["payload"], action: A): function

Parameters:

Name Type
payload A["payload"]
action A

▸ (state: S): S

Parameters:

Name Type
state S

MutationEntry

Ƭ MutationEntry: [ActionCreator | string, Mutationany, Actionstring, any, undefined | false | true]


MwGen

Ƭ MwGen: function

Type declaration:

▸ (): UpduxMiddleware


Next

Ƭ Next: function

Type declaration:

▸ (action: Action): any

Parameters:

Name Type
action Action

RebaseSelector

Ƭ RebaseSelector: object

Type declaration:


Selector

Ƭ Selector: function

Type declaration:

▸ (state: S): unknown

Parameters:

Name Type
state S

SelectorsOf

Ƭ SelectorsOf: C extends object ? S : unknown


StateOf

Ƭ StateOf: D extends object ? I : unknown


StoreWithDispatchActions

Ƭ StoreWithDispatchActions: StoreS & object


SubMutations

Ƭ SubMutations: object

Type declaration:

  •  **slice**: *string*

Submws

Ƭ Submws: DictionaryUpduxMiddleware


UnionToIntersection

Ƭ UnionToIntersection: U extends any ? function : never extends function ? I : never


UpduxActions

Ƭ UpduxActions: U extends Updux ? UnionToIntersection<UpduxLocalActions | ActionsOf<CoduxesOf[keyof CoduxesOf]>> : object


UpduxConfig

Ƭ UpduxConfig: Partialobject

Configuration object given to Updux's constructor.

arguments

initial

Default initial state of the reducer. If applicable, is merged with the subduxes initial states, with the parent having precedence.

If not provided, defaults to an empty object.

actions

Actions used by the updux.

import { dux } from 'updux';
import { action, payload } from 'ts-action';

const bar = action('BAR', payload<int>());
const foo = action('FOO');

const myDux = dux({
    actions: {
        bar
    },
    mutations: [
        [ foo, () => state => state ]
    ]
});

myDux.actions.foo({ x: 1, y: 2 }); // => { type: foo, x:1, y:2 }
myDux.actions.bar(2);              // => { type: bar, payload: 2 }

New actions used directly in mutations and effects will be added to the dux actions -- that is, they will be accessible via dux.actions -- but will not appear as part of its Typescript type.

selectors

Dictionary of selectors for the current updux. The updux also inherit its subduxes' selectors.

The selectors are available via the class' getter.

mutations
mutations: [
    [ action, mutation, isSink ],
    ...
]

or

mutations: {
    action: mutation,
    ...
}

List of mutations for assign to the dux. If you want Typescript goodness, you probably want to use addMutation() instead.

In its generic array-of-array form, each mutation tuple contains: the action, the mutation, and boolean indicating if this is a sink mutation.

The action can be an action creator function or a string. If it's a string, it's considered to be the action type and a generic action( actionName, payload() ) creator will be generated for it. If an action is not already defined in the actions parameter, it'll be automatically added.

The pseudo-action type * can be used to match any action not explicitly matched by other mutations.

const todosUpdux = updux({
    mutations: {
        add: todo => state => [ ...state, todo ],
        done: done_id => u.map( u.if( ({id} => id === done_id), {done: true} ) ),
        '*' (payload,action) => state => {
            console.warn( "unexpected action ", action.type );
            return state;
        },
    }
});

The signature of the mutations is (payload,action) => state => newState. It is designed to play well with Updeep (and Immer). This way, instead of doing

    mutation: {
        renameTodo: newName => state => { ...state, name: newName }
    }

we can do

    mutation: {
        renameTodo: newName => u({ name: newName })
    }

The final argument is the optional boolean isSink. If it is true, it'll prevent subduxes' mutations on the same action. It defaults to false.

The object version of the argument can be used as a shortcut when all actions are strings. In that case, isSink is false for all mutations.

groomMutations

Function that can be provided to alter all local mutations of the updux (the mutations of subduxes are left untouched).

Can be used, for example, for Immer integration:

import Updux from 'updux';
import { produce } from 'Immer';

const updux = new Updux({
    initial: { counter: 0 },
    groomMutations: mutation => (...args) => produce( mutation(...args) ),
    mutations: {
        add: (inc=1) => draft => draft.counter += inc
    }
});

Or perhaps for debugging:

import Updux from 'updux';

const updux = new Updux({
    initial: { counter: 0 },
    groomMutations: mutation => (...args) => state => {
        console.log( "got action ", args[1] );
        return mutation(...args)(state);
    }
});
subduxes

Object mapping slices of the state to sub-upduxes. In addition to creating sub-reducers for those slices, it'll make the parend updux inherit all the actions and middleware from its subduxes.

For example, if in plain Redux you would do

import { combineReducers } from 'redux';
import todosReducer from './todos';
import statisticsReducer from './statistics';

const rootReducer = combineReducers({
    todos: todosReducer,
    stats: statisticsReducer,
});

then with Updux you'd do

import { updux } from 'updux';
import todos from './todos';
import statistics from './statistics';

const rootUpdux = updux({
    subduxes: {
        todos,
        statistics
    }
});
effects

Array of arrays or plain object defining asynchronous actions and side-effects triggered by actions. The effects themselves are Redux middleware, with the dispatch property of the first argument augmented with all the available actions.

updux({
    effects: {
        fetch: ({dispatch}) => next => async (action) => {
            next(action);

            let result = await fetch(action.payload.url).then( result => result.json() );
            dispatch.fetchSuccess(result);
        }
    }
});

example

import Updux from 'updux';
import { actions, payload } from 'ts-action';
import u from 'updeep';

const todoUpdux = new Updux({
    initial: {
        done: false,
        note: "",
    },
    actions: {
        finish: action('FINISH', payload()),
        edit: action('EDIT', payload()),
    },
    mutations: [
        [ edit, note => u({note}) ]
    ],
    selectors: {
        getNote: state => state.note
    },
    groomMutations: mutation => transform(mutation),
    subduxes: {
        foo
    },
    effects: {
        finish: () => next => action => {
            console.log( "Woo! one more bites the dust" );
        }
    }
})

UpduxLocalActions

Ƭ UpduxLocalActions: S extends Updux<any, null> ? object : S extends Updux<any, infer A> ? A : object


UpduxMiddleware

Ƭ UpduxMiddleware: function

Type declaration:

▸ (api: UpduxMiddlewareAPIS, X): function

Parameters:

Name Type
api UpduxMiddlewareAPIS, X

▸ (next: Function): function

Parameters:

Name Type
next Function

▸ (action: A): any

Parameters:

Name Type
action A

Upreducer

Ƭ Upreducer: function

Type declaration:

▸ (action: Action): function

Parameters:

Name Type
action Action

▸ (state: S): S

Parameters:

Name Type
state S

Variables

Const subEffects

subEffects: Effect = [ '*', subMiddleware ] as any


Const updux

updux: Upduxunknown, null, unknown, object = new Updux({ subduxes: { foo: dux({ initial: "banana" }) } })

Functions

Const MiddlewareFor

MiddlewareFor(type: any, mw: Middleware): Middleware

Parameters:

Name Type
type any
mw Middleware

Returns: Middleware


buildActions

buildActions(actions: ActionPair[]): DictionaryActionCreatorstring, function

Parameters:

Name Type Default
actions ActionPair[] []

Returns: DictionaryActionCreatorstring, function


buildCreateStore

buildCreateStore<S, A>(reducer: ReducerS, middleware: Middleware, actions: A): function

Type parameters:

S

A

Parameters:

Name Type Default
reducer ReducerS -
middleware Middleware -
actions A {} as A

Returns: function

▸ (initial?: S, injectEnhancer?: Function): StoreS & object

Parameters:

Name Type
initial? S
injectEnhancer? Function

buildInitial

buildInitial(initial: any, coduxes: any, subduxes: any): any

Parameters:

Name Type Default
initial any -
coduxes any []
subduxes any {}

Returns: any


buildMiddleware

buildMiddleware<S>(local: UpduxMiddleware[], co: UpduxMiddleware[], sub: Submws): UpduxMiddlewareS

Type parameters:

S

Parameters:

Name Type Default
local UpduxMiddleware[] []
co UpduxMiddleware[] []
sub Submws {}

Returns: UpduxMiddlewareS


buildMutations

buildMutations(mutations: DictionaryMutation | [Mutation, boolean | undefined], subduxes: object, coduxes: Upreducer[]): object

Parameters:

Name Type Default
mutations DictionaryMutation | [Mutation, boolean | undefined] {}
subduxes object {}
coduxes Upreducer[] []

Returns: object


buildSelectors

buildSelectors(localSelectors: DictionarySelector, coduxes: DictionarySelector[], subduxes: DictionarySelector): object

Parameters:

Name Type Default
localSelectors DictionarySelector {}
coduxes DictionarySelector[] []
subduxes DictionarySelector {}

Returns: object


buildUpreducer

buildUpreducer<S>(initial: S, mutations: DictionaryMutationS): UpreducerS

Type parameters:

S

Parameters:

Name Type
initial S
mutations DictionaryMutationS

Returns: UpreducerS


Const coduxes

coduxes<C, U>(...coduxes: U): object

Type parameters:

C: Dux

U: [C]

Parameters:

Name Type
...coduxes U

Returns: object

  • coduxes: U

Const composeMutations

composeMutations(mutations: Mutation[]): function | (Anonymous function)

Parameters:

Name Type
mutations Mutation[]

Returns: function | (Anonymous function)


Const composeMw

composeMw(mws: UpduxMiddleware[]): (Anonymous function)

Parameters:

Name Type
mws UpduxMiddleware[]

Returns: (Anonymous function)


Const dux

dux<S, A, X, C>(config: C): object

Type parameters:

S

A

X

C: UpduxConfig

Parameters:

Name Type
config C

Returns: object

  • actions: = this.actions

  • coduxes: object[] = this.coduxes

  • createStore(): function

    • (initial?: S, injectEnhancer?: Function): StoreS & object
  • initial: = this.initial

  • middleware(): function

    • (api: UpduxMiddlewareAPIS, X): function

      • (next: Function): function

        • (action: A): any
  • mutations(): object

  • reducer(): function

    • (state: S | undefined, action: Action): S
  • selectors: = this.selectors

  • subduxes(): object

  • upreducer(): function

    • (action: Action): function

      • (state: S): S

Const effectToMw

effectToMw(effect: Effect, actions: DictionaryActionCreator, selectors: DictionarySelector): subMiddleware | augmented

Parameters:

Name Type
effect Effect
actions DictionaryActionCreator
selectors DictionarySelector

Returns: subMiddleware | augmented


sliceMw

sliceMw(slice: string, mw: UpduxMiddleware): UpduxMiddleware

Parameters:

Name Type
slice string
mw UpduxMiddleware

Returns: UpduxMiddleware


Const subMiddleware

subMiddleware(): (Anonymous function)

Returns: (Anonymous function)


subSelectors

subSelectors(__namedParameters: [string, Function]): [string, Selector][]

Parameters:

Name Type
__namedParameters [string, Function]

Returns: [string, Selector][]