Function

assert context type

import t from 'tcomb'

checkContextType(t.struct({
    someProp: t.String
}))(model => { ... })

creates a choke that throttle fuction calls

The returned choke function will throttle calls with the same path argument for delta milliseconds.

combiner scope factory represents map of (sub)scopes.

apply multiple decorators on component

component(
    someDeoraotor(),
    someOther()
)(model => { ... })

controller decorator.

controller({
    click: (model) => { ... }
})(({ dispatch }) => (
    <input type='button' onClick={event => dispatch('click', event)} />
    // or
    <input type='button' onClick='click' />
))

You can dispatch actions to handlers in your controller when you call model.dispatch with the property name as first argument and an optional event as second argument.

If the property is a function, then the function will be called with model as the only argument. The model object has an additional property 'event', which contains the second argument from dispatch. Otherwise the property will just be dispatched.

pipes a to b and b to a -> cycle a and b

dispatch change sets

Usage:

dispatchChangeSets()(function({ dispatch }) {
        // some code...
        dispatch(['/count', v => v + 1])
})

A change set is an array of strings on even positions and some values on odd positions. The strings acts as path selector on the context object and the next element as value for the previous path. If the value element is a function, this function will be called with the value in the given path as argument. If the path string ends with '-' the operator in the resulting patch will be 'add' (info).

Example:

const changeSet = [
    '/foo/bar' : 42,
    '/someNumber' : n => n + 3,
    '/someList/-' : {name: 'baz'}
];

The function will be called with n = model.context.get('/someNumber'). The resulting patch set with n = 4:

const patchSet = [
    {
        op: 'replace',
        path: '/foo/bar',
        value: 42
    },
    {
        op: 'replace',
        path: '/someNumber',
        value: 7
    },
    {
        op: 'add',
        path: '/someList/-',
        value: { name: 'baz' }
    }
];

This function is used to create the render part of your app. If the view receives a context object, it will pass the context through your component. All actions dispatched inside component, will be emitted from the view.

fragment scope factory represents value of fragment identifier. Json structure: { value: String }

log component lifecycle

memoize component

transform ctx of component

mount({
    foo: '/some/value'
    bar: '/here/is/another/val'
})(component)

add name to component - for debug messages

add css styles as Object

styler()(() => (<div style={{ color: 'green'}}>))

value scope factory Scope will update and emit value on every patch action.