kapsule

Kapsule

A Simple Web Component library, inspired by the reusable charts pattern commonly found in D3 components.

Quick start

import Kapsule from 'kapsule';

or

var Kapsule = require('kapsule');

or even

<script src="//unpkg.com/kapsule/dist/kapsule.min.js"></script>

Usage example

Define the component

const ColoredText = Kapsule({
    
    props: {
        color: { default: 'red' },
        text: {}
    },
    
    init(domElement, state) {
        state.elem = document.createElement('span');
        domElement.appendChild(state.elem);
    },
    
    update(state) {
        state.elem.style.color = state.color;
        state.elem.textContent = state.text;
    }

});

Instantiate the component

let myText = ColoredText();

Render

myText(<myDOMElement>)
    .color('blue')
    .text('foo');

API Reference

Generation

Kapsule([config])

This returns a new closure component that can be instantiated by calling as a regular function, with an optional options object as argument. The options object gets passed verbatim to the init object for interpretation. The component's instance is an object of methods (defined by its config props and methods) that can be called for interacting with the component. Besides these methods, the instance also acts as an initialization function which should be called to attach the component to a DOM node, with the DOM element as sole argument. This triggers the internal init method as specified in the config.

Example:

const Comp = Kapsule(compConfig);

const myInstance = Comp({ /* options */ })
    (<myDOMElement>)
    .prop1('someVal')
    .prop2('anotherVal');

Component configuration

The config object passed to Kapsule supports 5 properties: props, methods, stateInit, init and update. All of these are optional and not required for the component to work, however calling Kapsule({}) generates a dumb component that has no functionality nor interaction.

Extended example:

const Comp = Kapsule({
    props: { 
        propName: propConfig, 
        ... 
    },
    methods: { 
        methodName: function(state, ...args) { ... },
        ... 
    },
    stateInit: {
        stateItem: initVal,
        ...
    },
    init(domNode, state, componentOptions) {
        ...
    },
    update(state) {
        ...
    }
});

props: { propName: propConfig, ... }

Each registered prop inside props will declare its own getter/setter method in the component's instance state. This method will have the signature: myInstance.propName([propVal]).

If called without an argument, the method will function as a getter, returning the current value of the prop. If called with a value it will act as a setter, setting the value in the component's internal state, and returning the component's instance for convenience of method chaining.

The propConfig object supports 3 properties: defaultVal, triggerUpdate and onChange.

Extended prop example:

{
    props: {
        propName: {
            defaultVal: 6,
            triggerUpdate: false,
            onChange: function(newVal, state) { ... }
        }
    }
}

#####defaultVal (default: null)

This defines the default value of the prop if it's not set by the instance consumer.

#####triggerUpdate (default: true)

This defines whether changes to this prop should trigger the component's update method. Generally, if the update method does not take this prop into account, you can save some performance by setting this to false.

#####onChange(newVal, state) (default: null)

Here you can specify an event handler that gets triggered whenever this property is modified by the instance consumer. In some circumstances it's useful to keep update changes here instead of in the update method to isolate prop-specific functionality.

The this context of this method is set to the component's instance.

methods: { methodName: function(state, ...args) { ... }, ... }

Each registered method inside methods will expose an additional method in the component's instance. These methods can be seen as a more generic version of the getter/setters in props, and allows the specification of more custom component interactions. The exposed method will have the signature: myInstance.methodName(...args)

The this context of each of this methods is set to the component's instance. If the method does not naturally return a value, it's advised to end the method with return this; so that it can be used in method chaining.

stateInit: { stateItem: initVal, ... }

Use this section for initializing the values of any internal state. This should only be used for state that is not exposed externally via props. This state initialization gets ran as soon as the component is instantiated, and before the init method is called.

init(domNode, state, componentOptions)

This method initializes the web component by attaching it to a DOM element. This method gets triggered only when the instance is called by the consumer as myInstance(<domElement>). This is generally only called once for the whole lifecycle of the component's instance.

This is where DOM operations should be performed for the static parts of the document that do not change throughout its lifecycle.

Example:

function init(domNode, state, { label: '' }) {
    state.elem = document.createElement('div'); // static scaffolding div
    domElement.appendChild(state.elem);
    
    const labelElem = document.createElement('span');
    labelElem.textContent = label; // static label from component options
    state.elem.appendChild(labelElem);
}

An internal state variable initialised indicates whether the instance has been through its init method or not. state.initialised is set to true right after the first init method call.

The this context of this method is set to the component's instance. Returning a value from this method has no effect.

update(state)

This method is triggered once right after the init method finishes, and afterwards whenever a prop changes. This method should contain the DOM operations for the dynamic parts of the document that change according to the component props.

Example:

function update(state) {
    state.elem.style.width = state.pxWidth + 'px';
}

Note that multiple calls to update() due to prop changes are internally debounced for performance optimization. This is so that the consumer can request multiple chained prop changes without each one triggering an update, but it instead being batched as one update.

The this context of this method is set to the component's instance. Returning a value from this method has no effect.

Other methods

resetProps()

Each instance will get automatically exposed a convenience function resetProps, which when called will reset the internal state of all the props to their defined default values. This will trigger an update call immediately after the props have been reset.

Example:

myInstance
    .propA('someVal')
    .resetProps(); // propA gets reset to its default value