eyzy-tree/dist/eyzy-tree.js

/*!
 * EyzyTree v0.0.19
 * (c) 2019 amsik
 * Released under the MIT License.
 */

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react')) :
    typeof define === 'function' && define.amd ? define(['react'], factory) :
    (global.EyzyTree = factory(global.React));
}(this, (function (React) { 'use strict';

    React = React && React.hasOwnProperty('default') ? React['default'] : React;

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */
    /* global Reflect, Promise */

    var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };

    function __extends(d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }

    var __assign = function() {
        __assign = Object.assign || function __assign(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };

    var hasOwn = {}.hasOwnProperty;
    function cn(args) {
        var result = [];
        for (var key in args) {
            if (hasOwn.call(args, key) && args[key]) {
                result.push(key);
            }
        }
        return result.join(' ');
    }
    //# sourceMappingURL=cn.js.map

    function shallowEqual(objA, objB, keys) {
        if (objA === objB) {
            return true;
        }
        for (var i = 0; i < keys.length; i++) {
            var key = keys[i];
            var valueA = objA[key];
            var valueB = objB[key];
            if (valueA !== valueB) {
                return false;
            }
        }
        return true;
    }
    //# sourceMappingURL=shallowEqual.js.map

    var hasChild = function (node) {
        return node.isBatch || Array.isArray(node.child) && node.child.length > 0;
    };
    var comparingKeys = [
        'id', 'checked', 'selected', 'child', 'checked', 'expanded', 'hash'
    ];
    var TreeNode = /** @class */ (function (_super) {
        __extends(TreeNode, _super);
        function TreeNode() {
            var _this = _super !== null && _super.apply(this, arguments) || this;
            _this.handleSelect = function (event) {
                if (_this.props.disabled) {
                    return;
                }
                if (_this.props.onSelect) {
                    _this.props.onSelect(_this.getNode(), event);
                }
            };
            _this.handleCheck = function () {
                if (_this.props.disabled || _this.props.disabledCheckbox) {
                    return;
                }
                if (_this.props.onCheck) {
                    _this.props.onCheck(_this.getNode());
                }
            };
            _this.handleExpand = function () {
                if (_this.props.onExpand) {
                    _this.props.onExpand(_this.getNode());
                }
            };
            _this.handleDoubleClick = function (e) {
                if (_this.props.onDoubleClick) {
                    _this.props.onDoubleClick(_this.getNode());
                }
            };
            _this.renderCheckbox = function () {
                if (!_this.props.checkable || _this.props.hidenCheckbox) {
                    return null;
                }
                var Checkbox = _this.props.checkboxRenderer;
                if (!Checkbox) {
                    return React.createElement("span", { className: "node-checkbox", onMouseUp: _this.handleCheck });
                }
                return (React.createElement("span", { className: "node-checkbox-overrided", onMouseUp: _this.handleCheck },
                    React.createElement(Checkbox, { node: _this.getNode() })));
            };
            _this.renderArrow = function () {
                var ArrowRenderer = _this.props.arrowRenderer;
                if (!hasChild(_this.props)) {
                    return React.createElement("span", { className: "node-noop" });
                }
                if (!ArrowRenderer) {
                    return React.createElement("span", { className: "node-arrow", onMouseUp: _this.handleExpand });
                }
                return (React.createElement("span", { className: "node-arrow-extended", onMouseUp: _this.handleExpand },
                    React.createElement(ArrowRenderer, { node: _this.getNode() })));
            };
            return _this;
        }
        TreeNode.prototype.shouldComponentUpdate = function (nextProps) {
            if (0 === nextProps.depth && this.props.hash !== nextProps.hash) {
                return true;
            }
            return !shallowEqual(this.props, nextProps, comparingKeys);
        };
        TreeNode.prototype.getNode = function () {
            var _a = this.props, id = _a.id, checked = _a.checked, selected = _a.selected, text = _a.text, child = _a.child, expanded = _a.expanded, disabled = _a.disabled, disabledCheckbox = _a.disabledCheckbox, parent = _a.parent, isBatch = _a.isBatch, depth = _a.depth;
            var node = {
                id: id,
                checked: checked,
                selected: selected,
                text: text,
                child: child,
                parent: parent,
                depth: depth
            };
            node.expanded = !!expanded;
            node.disabled = !!disabled;
            node.isBatch = !!isBatch;
            node.disabledCheckbox = !!disabledCheckbox;
            return node;
        };
        TreeNode.prototype.render = function () {
            var _a = this.props, loading = _a.loading, checked = _a.checked, selected = _a.selected, children = _a.children, expanded = _a.expanded, disabled = _a.disabled, disabledCheckbox = _a.disabledCheckbox, indeterminate = _a.indeterminate, useIndeterminateState = _a.useIndeterminateState, TextRenderer = _a.textRenderer;
            var text = this.props.text;
            var nodeContentClass = cn({
                'node-content': true,
                'has-child': hasChild(this.props),
                'selected': selected,
                'checked': checked,
                'expanded': expanded,
                'disabled': disabled,
                'loading': loading,
                'disabled-checkbox': disabledCheckbox,
                'indeterminate': !checked && indeterminate && false !== useIndeterminateState
            });
            return (React.createElement("li", { className: "tree-node" },
                React.createElement("div", { className: nodeContentClass },
                    this.renderArrow(),
                    this.renderCheckbox(),
                    React.createElement("span", { className: "node-text", onMouseUp: this.handleSelect, onDoubleClick: this.handleDoubleClick }, TextRenderer ? React.createElement(TextRenderer, { node: this.getNode() }) : text)),
                hasChild(this.props) && expanded &&
                    React.createElement("ul", { className: "node-child" }, children)));
        };
        return TreeNode;
    }(React.Component));
    //# sourceMappingURL=TreeNode.js.map

    var hasOwnProp = {}.hasOwnProperty;
    function grapObjProps(obj, props) {
        return props.reduce(function (result, name) {
            if (name in obj) {
                result[name] = obj[name];
            }
            return result;
        }, {});
    }
    function isArray(obj) {
        return Array.isArray(obj);
    }
    function isExpandable(node) {
        return !!(node.child && node.child.length) || !!node.isBatch;
    }
    function isNodeCheckable(node) {
        return !(!!node.disabled || !!node.disabledCheckbox);
    }
    function isFunction(value) {
        return 'function' === typeof value;
    }
    function has(targetArray, targetValue) {
        return !!~targetArray.indexOf(targetValue);
    }
    function copyArray(arr) {
        return arr.concat([]);
    }
    function copyObject(obj) {
        var newObj = {};
        for (var i in obj) {
            if (hasOwnProp.call(obj, i)) {
                newObj[i] = isArray(obj[i]) ? copyArray(obj[i]) : obj[i];
            }
        }
        return newObj;
    }
    function isRoot(node) {
        return node && !node.parent;
    }
    function isLeaf(node) {
        return !node.child || (0 === node.child.length && !node.isBatch);
    }
    function isNodeIndeterminate(node, treeCheckedNodes, indeterminateNodes) {
        if (!node.child.length) {
            return false;
        }
        var hasIndeterminate = node.child.some(function (child) {
            return !child.disabled && !child.disabledCheckbox && -1 !== indeterminateNodes.indexOf(child.id);
        });
        if (hasIndeterminate) {
            return true;
        }
        var uncheckedNodes = node.child.reduce(function (count, item) {
            if (true !== item.disabled && true !== item.disabledCheckbox && -1 === treeCheckedNodes.indexOf(item.id)) {
                count++;
            }
            return count;
        }, 0);
        return uncheckedNodes > 0 && uncheckedNodes < node.child.length;
    }
    //# sourceMappingURL=index.js.map

    var TreeAPI = /** @class */ (function () {
        function TreeAPI(tree, state) {
            this.tree = tree;
            this.state = state;
        }
        TreeAPI.prototype.selected = function () {
            var state = this.state;
            var selectedNodes = this.tree.selectedNodes
                .map(function (id) { return state.getNodeById(id); });
            return selectedNodes.filter(function (item) { return null !== item; });
        };
        TreeAPI.prototype.checked = function (valueConsistsOf, ignoreDisabled) {
            var state = this.state;
            var checkedNodes = [];
            this.tree.checkedNodes.forEach(function (id) {
                var node = state.getNodeById(id);
                if (node) {
                    checkedNodes.push(node);
                }
            });
            if ('WITH_INDETERMINATE' === valueConsistsOf) {
                this.tree.indeterminateNodes.forEach(function (id) {
                    var node = state.getNodeById(id);
                    if (node) {
                        checkedNodes.push(node);
                    }
                });
            }
            if (ignoreDisabled) {
                checkedNodes = checkedNodes.filter(isNodeCheckable);
            }
            switch (valueConsistsOf) {
                case 'LEAF': return checkedNodes.filter(function (node) { return isLeaf(node); });
                case 'BRANCH':
                    return checkedNodes.filter(function (node) {
                        if (node.parent && node.parent.checked) {
                            return false;
                        }
                        return true;
                    });
            }
            return checkedNodes;
        };
        return TreeAPI;
    }());
    //# sourceMappingURL=TreeAPI.js.map

    function recurseDown(obj, fn, excludeSelf, depth) {
        if (depth === void 0) { depth = 0; }
        var res;
        if (Array.isArray(obj)) {
            return obj.map(function (node) { return recurseDown(node, fn, false, depth); });
        }
        // TODO: get rid of it: create a State interface
        if (obj[0]) {
            return Object.keys(obj)
                .filter(function (key) { return isFinite(+key); })
                .map(function (key) { return recurseDown(obj[key], fn, false, depth); });
        }
        if (!excludeSelf) {
            res = fn(obj, depth);
        }
        if (res !== false && obj.child && obj.child.length) {
            res = recurseDown(obj.child, fn, false, depth + 1);
        }
        return res;
    }
    function rootElement(obj) {
        var node = obj.parent;
        while (node) {
            if (!node.parent) {
                return node;
            }
            node = node.parent;
        }
        return null;
    }
    function traverseUp(obj, fn) {
        var node = obj.parent;
        while (node) {
            if (false === fn(node) || !node.parent) {
                return;
            }
            node = node.parent;
        }
    }
    function getFirstChild(node, onlyEnabled) {
        if (onlyEnabled) {
            var enabledNode = node.child.filter(function (n) { return !n.disabled; });
            return enabledNode.length ? enabledNode[0] : null;
        }
        return node.child[0] || null;
    }
    function getLastChild(node, onlyEnabled) {
        var len = node.child ? node.child.length : 0;
        if (!len) {
            return null;
        }
        if (onlyEnabled) {
            var enabledNode = node.child.filter(function (n) { return !n.disabled; });
            var enabledNodeLen = enabledNode.length;
            return enabledNodeLen ? enabledNode[enabledNodeLen - 1] : null;
        }
        return node.child[len - 1];
    }
    function flatMap(collection, ignoreCollapsed) {
        var result = {
            nodes: [],
            ids: []
        };
        recurseDown(collection, function (node) {
            if (node.disabled) {
                return;
            }
            if (ignoreCollapsed && node.parent && !node.parent.expanded) {
                return;
            }
            result.nodes.push(node);
            result.ids.push(node.id);
        });
        return result;
    }
    //# sourceMappingURL=traveler.js.map

    function iterable(key, value) {
        if ('string' === typeof key) {
            return [[key, value]];
        }
        if (!value) {
            var res = [];
            for (var i in key) {
                if (hasOwnProp.call(key, i)) {
                    res.push([i, key[i]]);
                }
            }
            return res;
        }
        return [];
    }
    function replaceChild(node) {
        if (!node || !node.child) {
            return node;
        }
        node.child = copyArray(node.child);
        node.child.forEach(function (child) {
            var replaced = replaceChild(child);
            replaced.parent = node;
            return replaced;
        });
        return node;
    }
    function getItemById(id, targetState) {
        return Object.keys(targetState)
            .find(function (k) { return targetState[k].id === id; }) || null;
    }
    function getNodeIndex(nodeId, parent, nodesLength) {
        if (parent.child) {
            var childIndex_1 = null;
            parent.child.some(function (node, i) {
                if (nodeId === node.id) {
                    childIndex_1 = i;
                    return true;
                }
                return false;
            });
            return childIndex_1;
        }
        for (var i = 0; i < nodesLength; i++) {
            if (parent[i].id === nodeId) {
                return i;
            }
        }
        return null;
    }
    function updateChildNodes(parentNode) {
        parentNode.child.forEach(function (child) {
            child.parent = parentNode;
        });
        return parentNode;
    }
    var State = /** @class */ (function () {
        function State(state, stateLength) {
            this.length = stateLength;
            this.nodes = state;
        }
        State.prototype.updateRootNode = function (node, iterableValue) {
            var i = getItemById(node.id, this.nodes);
            var newObj = copyObject(node);
            if (iterableValue) {
                iterableValue.forEach(function (_a) {
                    var key = _a[0], value = _a[1];
                    node[key] = value;
                    newObj[key] = value;
                });
            }
            if (null !== i) {
                this.nodes[i] = updateChildNodes(newObj);
            }
        };
        State.prototype.updateLeafNode = function (node, iterableValue) {
            var root = rootElement(node);
            var parentNode = node.parent;
            if (!parentNode || !root || !parentNode.child) {
                return;
            }
            var index = getNodeIndex(node.id, parentNode, this.length);
            if (null === index) {
                return;
            }
            if (iterableValue) {
                iterableValue.forEach(function (_a) {
                    var key = _a[0], value = _a[1];
                    node[key] = value;
                    parentNode.child[index][key] = value;
                });
            }
            this.updateRootNode(replaceChild(root));
        };
        State.prototype.set = function (id, key, value) {
            var node = this.getNodeById(id);
            if (!node) {
                return this.nodes;
            }
            if (isRoot(node)) {
                this.updateRootNode(node, iterable(key, value));
            }
            else {
                this.updateLeafNode(node, iterable(key, value));
            }
            return this.nodes;
        };
        State.prototype.getNodeById = function (id) {
            var node = null;
            recurseDown(this.nodes, function (obj) {
                if (obj.id === id) {
                    node = obj;
                    return false;
                }
            });
            return node;
        };
        State.prototype.get = function () {
            return this.nodes;
        };
        State.prototype.toArray = function () {
            var result = [];
            var state = this.nodes;
            for (var i in state) {
                if (hasOwnProp.call(state, i)) {
                    result.push(state[i]);
                }
            }
            return result;
        };
        return State;
    }());
    //# sourceMappingURL=state.js.map

    function s4() {
        return Math.floor((1 + Math.random()) * 0x10000)
            .toString(16)
            .substring(1);
    }
    function uuid() {
        return s4() + '-' + s4();
    }
    //# sourceMappingURL=uuid.js.map

    function parseNode(data, parentNode) {
        if (!data || !Array.isArray(data)) {
            return [];
        }
        var parent = parentNode || null;
        if ('string' === typeof data) {
            return [
                { text: data, id: uuid(), parent: parent, child: [] }
            ];
        }
        return data.map(function (node) {
            if ('string' === typeof node) {
                return {
                    id: uuid(),
                    text: node,
                    parent: parent,
                    child: []
                };
            }
            node.id = node.id || uuid();
            node.child = Array.isArray(node.child)
                ? parseNode(node.child, node)
                : [];
            node.parent = parent;
            return node;
        });
    }
    //# sourceMappingURL=parser.js.map

    function linkedNode(node, state, ignoreExpanded) {
        var result = {
            current: node
        };
        var currentNodeId = node.id;
        var parent = node.parent;
        var neighborIds = (parent ? parent.child : state.toArray())
            .map(function (n) { return n.id; });
        var currentPos = neighborIds.indexOf(currentNodeId);
        var i = 0;
        if (node.expanded && node.child.length && true !== ignoreExpanded) {
            var firstChild = getFirstChild(node, true);
            if (firstChild) {
                result.next = state.getNodeById(firstChild.id);
            }
        }
        while (i++ < neighborIds.length) {
            if (!result.next) {
                var node_1 = state.getNodeById(neighborIds[currentPos + i]);
                if (node_1 && !node_1.disabled) {
                    result.next = node_1;
                }
            }
            if (!result.prev) {
                var node_2 = state.getNodeById(neighborIds[currentPos - i]);
                if (node_2 && !node_2.disabled) {
                    if (node_2.expanded) {
                        var lastChild = getLastChild(node_2, true);
                        if (lastChild) {
                            result.prev = state.getNodeById(lastChild.id);
                        }
                    }
                    else {
                        result.prev = node_2;
                    }
                }
            }
        }
        if (parent) {
            if (!result.prev) {
                result.prev = state.getNodeById(parent.id);
            }
            if (!result.next) {
                result.next = linkedNode(parent, state, true).next;
            }
        }
        return result;
    }
    //# sourceMappingURL=linkedNode.js.map

    var mutatingFields = [
        'checkable',
        'useIndeterminateState',
        'checkboxRenderer',
        'arrowRenderer',
        'textRenderer'
    ];
    var EyzyTree = /** @class */ (function (_super) {
        __extends(EyzyTree, _super);
        function EyzyTree(props) {
            var _this = _super.call(this, props) || this;
            _this.selectedNodes = [];
            _this.checkedNodes = [];
            _this.indeterminateNodes = [];
            _this.fireEvent = function (name, id) {
                var args = [];
                for (var _i = 2; _i < arguments.length; _i++) {
                    args[_i - 2] = arguments[_i];
                }
                var eventCb = _this.props[name];
                if (!eventCb) {
                    return;
                }
                var node = _this.getState().getNodeById(id);
                if (node) {
                    eventCb.call.apply(eventCb, [null, node].concat(args));
                }
            };
            _this.refreshIndeterminateState = function (id, willBeChecked, shouldRender) {
                var checkedNodes = copyArray(_this.checkedNodes);
                var indeterminateNodes = copyArray(_this.indeterminateNodes);
                var state = _this.getState();
                var childIds = [];
                var node = state.getNodeById(id);
                var nodesForEvent = [];
                if (!node) {
                    return;
                }
                recurseDown(node, function (child) {
                    if (!child.disabled && !child.disabledCheckbox) {
                        childIds.push(child.id);
                        if (child.checked !== willBeChecked) {
                            nodesForEvent.push(child.id);
                        }
                    }
                }, true);
                if (willBeChecked) {
                    checkedNodes.push.apply(checkedNodes, childIds.filter(function (id) { return !has(checkedNodes, id); }));
                }
                else {
                    checkedNodes = checkedNodes.filter(function (nodeId) { return !has(childIds, nodeId); });
                }
                traverseUp(node, function (parentNode) {
                    if (parentNode.disabledCheckbox || parentNode.disabled) {
                        return false;
                    }
                    var isIndeterminate = isNodeIndeterminate(parentNode, checkedNodes, indeterminateNodes);
                    var id = parentNode.id;
                    if (isIndeterminate) {
                        if (!has(indeterminateNodes, id)) {
                            indeterminateNodes.push(id);
                        }
                        checkedNodes = checkedNodes.filter(function (nodeId) { return nodeId !== id; });
                    }
                    else {
                        indeterminateNodes = indeterminateNodes.filter(function (nodeId) { return nodeId !== id; });
                        if (willBeChecked && !has(checkedNodes, id)) {
                            checkedNodes.push(id);
                        }
                        else {
                            checkedNodes = checkedNodes.filter(function (nodeId) { return nodeId !== id; });
                        }
                    }
                });
                indeterminateNodes = indeterminateNodes.filter(function (nodeId) { return !has(checkedNodes, nodeId); });
                if (willBeChecked) {
                    checkedNodes.forEach(function (id) {
                        if (!has(_this.checkedNodes, id)) {
                            state.set(id, 'checked', true);
                        }
                    });
                }
                else {
                    _this.checkedNodes.forEach(function (id) {
                        if (!has(checkedNodes, id)) {
                            state.set(id, 'checked', false);
                        }
                    });
                    childIds.forEach(function (id) {
                        state.set(id, 'checked', false);
                    });
                }
                _this.indeterminateNodes.forEach(function (id) {
                    state.set(id, 'indeterminate', false);
                });
                var useIndeterminateState = false !== _this.props.useIndeterminateState;
                if (useIndeterminateState) {
                    indeterminateNodes.forEach(function (id) { return state.set(id, 'indeterminate', true); });
                }
                _this.checkedNodes = checkedNodes;
                _this.indeterminateNodes = indeterminateNodes;
                if (false !== shouldRender) {
                    _this.updateState(state);
                }
                nodesForEvent.forEach(function (id) {
                    _this.fireEvent('onCheck', id, willBeChecked);
                });
            };
            _this.getState = function () {
                return _this._state;
            };
            _this.getSelectedNode = function () {
                var lastSelectedNode = _this.selectedNodes[_this.selectedNodes.length - 1];
                if (!lastSelectedNode) {
                    return null;
                }
                return _this.getState().getNodeById(lastSelectedNode);
            };
            _this.updateState = function (state) {
                _this.setState({ nodes: state.get() });
            };
            _this.unselectAll = function () {
                var state = _this.getState();
                _this.selectedNodes = _this.selectedNodes.filter(function (id) {
                    state.set(id, 'selected', false);
                    return false;
                });
                _this.updateState(state);
            };
            _this.unselect = function (node) {
                if (!node.selected) {
                    return;
                }
                var state = _this.getState();
                state.set(node.id, 'selected', false);
                _this.selectedNodes = _this.selectedNodes.filter(function (id) {
                    if (id !== node.id) {
                        return true;
                    }
                    if (state.getNodeById(id)) {
                        state.set(id, 'selected', false);
                        _this.fireEvent('onUnSelect', id);
                    }
                    return false;
                });
                _this.updateState(state);
            };
            _this.select = function (node, ignoreEvent, extendSelection) {
                var state = _this.getState();
                var id = node.id;
                var events = [];
                var multiple = _this.props.multiple;
                if (extendSelection && node.selected) {
                    return _this.unselect(node);
                }
                if (!multiple && node.selected) {
                    return;
                }
                if (!multiple || (multiple && !extendSelection)) {
                    _this.selectedNodes = _this.selectedNodes.filter(function (nodeId) {
                        var node = state.getNodeById(nodeId);
                        if (node) {
                            state.set(node.id, 'selected', false);
                            events.push(['onUnSelect', node.id]);
                        }
                        return false;
                    });
                }
                state.set(id, 'selected', true);
                if (!extendSelection) {
                    _this.focusedNode = id;
                }
                _this.selectedNodes.push(id);
                _this.updateState(state);
                if (true !== ignoreEvent) {
                    events.push(['onSelect', id]);
                    events.forEach(function (event) { return _this.fireEvent(event[0], event[1]); });
                }
            };
            _this.selectRange = function (focusedNode, targetNode) {
                var _a = flatMap(_this.state.nodes, true), ids = _a.ids, nodes = _a.nodes;
                var focusedIndex = ids.indexOf(focusedNode);
                var targetIndex = ids.indexOf(targetNode);
                if (!~focusedIndex || !~targetIndex) {
                    return;
                }
                var start = Math.min(focusedIndex, targetIndex);
                var end = Math.max(focusedIndex, targetIndex) + 1;
                var state = _this.getState();
                var willBeSelected = nodes.slice(start, end).map(function (node) { return node.id; });
                var fireEvents = [];
                _this.selectedNodes.forEach(function (id) {
                    if (!has(willBeSelected, id)) {
                        state.set(id, 'selected', false);
                        fireEvents.push(['onUnSelect', id]);
                    }
                });
                _this.selectedNodes = willBeSelected.map(function (id) {
                    if (!has(_this.selectedNodes, id)) {
                        state.set(id, 'selected', true);
                        fireEvents.push(['onSelect', id]);
                    }
                    return id;
                });
                _this.updateState(state);
                fireEvents.forEach(function (_a) {
                    var name = _a[0], id = _a[1];
                    _this.fireEvent(name, id);
                });
            };
            _this.check = function (node) {
                if (!_this.props.checkable) {
                    return;
                }
                var state = _this.getState();
                var willBeChecked = !node.checked;
                var id = node.id;
                state.set(id, 'checked', willBeChecked);
                if (willBeChecked) {
                    _this.checkedNodes = _this.checkedNodes.concat([id]);
                }
                else {
                    _this.checkedNodes = _this.checkedNodes.filter(function (checkedId) { return id !== checkedId; });
                }
                if (_this.props.selectOnCheck) {
                    _this.select(node);
                }
                if (_this.props.noCascade !== true) {
                    _this.refreshIndeterminateState(node.id, willBeChecked);
                    _this.fireEvent('onCheck', id, willBeChecked);
                }
                else {
                    _this.updateState(state);
                    _this.fireEvent('onCheck', id, willBeChecked);
                }
            };
            _this.expand = function (node) {
                if (node.isBatch) {
                    return _this.loadChild(node);
                }
                if (!node.child.length) {
                    return;
                }
                var state = _this.getState();
                var selectOnExpand = _this.props.selectOnExpand;
                state.set(node.id, 'expanded', !node.expanded);
                if (selectOnExpand && !node.selected) {
                    _this.select(node);
                }
                _this.updateState(state);
                _this.fireEvent('onExpand', node.id, !node.expanded);
            };
            _this.handleDoubleClick = function (node) {
                _this.fireEvent('onDoubleClick', node.id);
                if (node.disabled || isLeaf(node) || _this.props.expandOnSelect) {
                    return;
                }
                _this.expand(node);
            };
            _this.handleSelect = function (node, event) {
                if (node.disabled) {
                    return;
                }
                if (_this.props.preventSelectParent && isExpandable(node)) {
                    return _this.expand(node);
                }
                var _a = _this.props, multiple = _a.multiple, checkOnSelect = _a.checkOnSelect, expandOnSelect = _a.expandOnSelect, checkable = _a.checkable;
                if (event.shiftKey && multiple && _this.focusedNode) {
                    return _this.selectRange(_this.focusedNode, node.id);
                }
                _this.select(node, false, event.ctrlKey);
                if (event.ctrlKey) {
                    return;
                }
                if (checkable && checkOnSelect && !node.disabledCheckbox) {
                    _this.check(node);
                }
                else if (expandOnSelect) {
                    _this.expand(node);
                }
            };
            _this.handleKeyUp = function (event) {
                if (false === _this.props.keyboardNavigation) {
                    return;
                }
                var keyCode = event.keyCode;
                var selectedNode = _this.getSelectedNode();
                if (selectedNode) {
                    switch (keyCode) {
                        case 32: // space
                        case 13: // enter
                            if (_this.props.checkable && !selectedNode.disabled && !selectedNode.disabledCheckbox) {
                                _this.check(selectedNode);
                            }
                            else if (!isLeaf(selectedNode)) {
                                _this.expand(selectedNode);
                            }
                            break;
                        case 27: // esc
                            if (_this.props.multiple) {
                                _this.unselectAll();
                            }
                            else {
                                _this.unselect(selectedNode);
                            }
                            break;
                        case 39: // right arrow
                            if (!isLeaf(selectedNode)) {
                                if (!selectedNode.expanded) {
                                    _this.expand(selectedNode);
                                }
                                else {
                                    var firstChild = getFirstChild(selectedNode, true);
                                    if (firstChild) {
                                        _this.select(firstChild);
                                    }
                                }
                            }
                            break;
                        case 37: // left arrow 
                            if (isLeaf(selectedNode) || !selectedNode.expanded) {
                                var parentNode = selectedNode.parent;
                                if (parentNode) {
                                    _this.select(parentNode);
                                }
                            }
                            else if (selectedNode.expanded) {
                                _this.expand(selectedNode);
                            }
                            break;
                        case 40: // bottom arrow
                            var next = linkedNode(selectedNode, _this.getState()).next;
                            if (next) {
                                _this.select(next);
                            }
                            break;
                        case 38: // up arrow
                            var prev = linkedNode(selectedNode, _this.getState()).prev;
                            if (prev) {
                                _this.select(prev);
                            }
                            break;
                    }
                }
            };
            _this.appendChild = function (id, nodes) {
                var _a;
                var state = _this.getState();
                var node = state.getNodeById(id);
                if (!node) {
                    return null;
                }
                var parentDepth = node.depth || 0;
                var child = parseNode(nodes).map(function (obj) {
                    obj.parent = node;
                    return obj;
                });
                var cascadeCheck = true !== _this.props.noCascade;
                var checkedNodes = [];
                recurseDown(child, function (obj, depth) {
                    obj.depth = parentDepth + depth + 1;
                    if (cascadeCheck && obj.parent && obj.parent.checked) {
                        obj.checked = true;
                    }
                    if (obj.checked && !~_this.checkedNodes.indexOf(obj.id)) {
                        checkedNodes.push(obj.id);
                    }
                });
                (_a = _this.checkedNodes).push.apply(_a, checkedNodes);
                state.set(node.id, 'child', child);
                if (cascadeCheck) {
                    checkedNodes.forEach(function (id) {
                        var node = state.getNodeById(id);
                        if (node && isLeaf(node)) {
                            _this.refreshIndeterminateState(id, true, false);
                        }
                    });
                }
                return node;
            };
            _this.loadChild = function (node) {
                var _a = _this.props, fetchData = _a.fetchData, selectOnExpand = _a.selectOnExpand;
                if (!fetchData || !isFunction(fetchData)) {
                    return;
                }
                var result = fetchData(node);
                if (!result || !result.then) {
                    throw new Error('`fetchData` property must return a Promise');
                }
                var state = _this.getState();
                var id = node.id;
                state.set(id, 'loading', true);
                result.then(function (nodes) {
                    _this.appendChild(id, nodes);
                    var selected = selectOnExpand ? true : !!node.selected;
                    state.set(id, {
                        loading: false,
                        expanded: true,
                        isBatch: false,
                        selected: selected
                    });
                    _this.fireEvent('onExpand', id, true);
                    if (selectOnExpand) {
                        _this.fireEvent('onSelect', id);
                    }
                    _this.updateState(state);
                });
                _this.updateState(state);
            };
            _this.renderNode = function (node) {
                var treePropsKeys = [
                    'checkable', 'arrowRenderer', 'textRenderer', 'checkboxRenderer'
                ];
                var treeProps = treePropsKeys.reduce(function (props, key) {
                    if (_this.props[key]) {
                        props[key] = _this.props[key];
                    }
                    return props;
                }, {});
                treeProps.hash = _this.state.hash;
                treeProps.useIndeterminateState = _this.props.useIndeterminateState;
                return (React.createElement(TreeNode, __assign({ key: node.id, node: node, onSelect: _this.handleSelect, onDoubleClick: _this.handleDoubleClick, onCheck: _this.check, onExpand: _this.expand }, treeProps, node), node.expanded ? node.child.map(_this.renderNode) : null));
            };
            var data = parseNode(props.data || []);
            var stateObject = {};
            data.forEach(function (item, i) {
                stateObject[i] = item;
            });
            recurseDown(stateObject, function (obj, depth) {
                obj.depth = depth;
                if (obj.selected) {
                    _this.selectedNodes.push(obj.id);
                }
                if (obj.checked) {
                    _this.checkedNodes.push(obj.id);
                }
            });
            _this._state = new State(stateObject, data.length);
            _this.checkedNodes.forEach(function (id) {
                var node = _this._state.getNodeById(id);
                if (node && isLeaf(node) && _this.props.noCascade !== true) {
                    _this.refreshIndeterminateState(id, true, false);
                }
            });
            _this.state = {
                nodes: _this._state.get(),
                hash: uuid(),
                mutatingFields: grapObjProps(props, mutatingFields)
            };
            return _this;
        }
        EyzyTree.getDerivedStateFromProps = function (nextProps, state) {
            if (!shallowEqual(nextProps, state.mutatingFields, mutatingFields)) {
                return {
                    hash: uuid(),
                    mutatingFields: grapObjProps(nextProps, mutatingFields)
                };
            }
            return null;
        };
        EyzyTree.prototype.componentDidMount = function () {
            if (this.props.onReady) {
                this.props.onReady(new TreeAPI(this, this._state));
            }
        };
        EyzyTree.prototype.render = function () {
            var nodes = [];
            var props = this.props;
            var treeClass = 'theme' in props
                ? 'eyzy-tree ' + props.theme
                : 'eyzy-tree eyzy-theme';
            var stateNodes = this.state.nodes;
            for (var i = 0; i < this._state.length; i++) {
                nodes.push(this.renderNode(stateNodes[i]));
            }
            return (React.createElement("ul", { className: treeClass, tabIndex: -1, onKeyDown: this.handleKeyUp }, nodes));
        };
        EyzyTree.TreeNode = TreeNode;
        return EyzyTree;
    }(React.Component));

    //# sourceMappingURL=index.js.map

    return EyzyTree;

})));
//# sourceMappingURL=eyzy-tree.js.map