khufu-runtime/lib/khufu-runtime/stores.js

A runtime support library for khufu template engine

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.CANCEL = exports.store_constructor = undefined;

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

exports.store_handler = store_handler;
exports.cleanup_stores = cleanup_stores;

var _incrementalDom = require('incremental-dom');

var store_constructor = exports.store_constructor = undefined;
var CANCEL = exports.CANCEL = '@@khufu/CANCEL';

function store_handler(params, unsubscriptions) {
    return function (element, name, defs) {
        var old = element.__stores || {};
        var value = {};
        for (var k in defs) {
            var store = old[k];
            if (store) {
                if (module.hot && module.hot.status() == 'apply') {
                    // Let's get state before cancel in case cancel destructs
                    // the state
                    var old_state = store.getState();
                    store.__redraw_unsubscr();
                    store.dispatch({ type: CANCEL, reason: 'hot-reload' });

                    var _defs$k = defs[k](),
                        _defs$k2 = _slicedToArray(_defs$k, 2),
                        reducer = _defs$k2[0],
                        middleware = _defs$k2[1];

                    store = params.store(reducer, middleware, old_state);
                    store.__redraw_unsubscr = store.subscribe(params.render);
                }
                delete old[k];
            } else {
                var _defs$k3 = defs[k](),
                    _defs$k4 = _slicedToArray(_defs$k3, 2),
                    _reducer = _defs$k4[0],
                    _middleware = _defs$k4[1];

                store = params.store(_reducer, _middleware);
                store.__redraw_unsubscr = store.subscribe(params.render);
            }
            value[k] = store;
        }
        for (var _k in old) {
            var _store = old[_k];
            _store.__redraw_unsubscr();
            _store.dispatch({ type: CANCEL, reason: 'store-removed' });
        }
        element.__stores = value;
    };
}

function cleanup_stores_from(node) {
    var stores = node.__stores;
    if (stores) {
        for (var k in stores) {
            var store = stores[k];
            store.__redraw_unsubscr();
            store.dispatch({ type: CANCEL, reason: 'element-removed' });
        }
    }
}

function cleanup_stores(nodes) {
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
        for (var _iterator = nodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
            var n = _step.value;

            if (n.nodeType == 1) {
                // The elements are in preorder, but we should do depth first
                // cleanup of stores. So we iterate in reverse order
                var children = n.getElementsByTagName('*');
                for (var i = children.length - 1; i >= 0; --i) {
                    cleanup_stores_from(children[i]);
                }
                cleanup_stores_from(n);
            }
        }
    } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
    } finally {
        try {
            if (!_iteratorNormalCompletion && _iterator.return) {
                _iterator.return();
            }
        } finally {
            if (_didIteratorError) {
                throw _iteratorError;
            }
        }
    }
}