@ali-hm/angular-tree-component 18.0.1 → 18.0.4

package/esm2022/lib/models/tree.model.mjs

@@ -0,0 +1,546 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from '@angular/core';
+import { observable, computed, action, autorun } from 'mobx';
+import { TreeNode } from './tree-node.model';
+import { TreeOptions } from './tree-options.model';
+import { TREE_EVENTS } from '../constants/events';
+import * as i0 from "@angular/core";
+export class TreeModel {
+    constructor() {
+        this.options = new TreeOptions();
+        this.eventNames = Object.keys(TREE_EVENTS);
+        this.expandedNodeIds = {};
+        this.selectedLeafNodeIds = {};
+        this.activeNodeIds = {};
+        this.hiddenNodeIds = {};
+        this.focusedNodeId = null;
+        this.firstUpdate = true;
+        this.subscriptions = [];
+    }
+    static { this.focusedTree = null; }
+    // events
+    fireEvent(event) {
+        event.treeModel = this;
+        this.events[event.eventName].emit(event);
+        this.events.event.emit(event);
+    }
+    subscribe(eventName, fn) {
+        const subscription = this.events[eventName].subscribe(fn);
+        this.subscriptions.push(subscription);
+    }
+    // getters
+    getFocusedNode() {
+        return this.focusedNode;
+    }
+    getActiveNode() {
+        return this.activeNodes[0];
+    }
+    getActiveNodes() {
+        return this.activeNodes;
+    }
+    getVisibleRoots() {
+        return this.virtualRoot.visibleChildren;
+    }
+    getFirstRoot(skipHidden = false) {
+        const root = skipHidden ? this.getVisibleRoots() : this.roots;
+        return root != null && root.length ? root[0] : null;
+    }
+    getLastRoot(skipHidden = false) {
+        const root = skipHidden ? this.getVisibleRoots() : this.roots;
+        return root != null && root.length ? root[root.length - 1] : null;
+    }
+    get isFocused() {
+        return TreeModel.focusedTree === this;
+    }
+    isNodeFocused(node) {
+        return this.focusedNode === node;
+    }
+    isEmptyTree() {
+        return this.roots && this.roots.length === 0;
+    }
+    get focusedNode() {
+        return this.focusedNodeId ? this.getNodeById(this.focusedNodeId) : null;
+    }
+    get expandedNodes() {
+        const nodes = Object.keys(this.expandedNodeIds)
+            .filter((id) => this.expandedNodeIds[id])
+            .map((id) => this.getNodeById(id));
+        return nodes.filter(Boolean);
+    }
+    get activeNodes() {
+        const nodes = Object.keys(this.activeNodeIds)
+            .filter((id) => this.activeNodeIds[id])
+            .map((id) => this.getNodeById(id));
+        return nodes.filter(Boolean);
+    }
+    get hiddenNodes() {
+        const nodes = Object.keys(this.hiddenNodeIds)
+            .filter((id) => this.hiddenNodeIds[id])
+            .map((id) => this.getNodeById(id));
+        return nodes.filter(Boolean);
+    }
+    get selectedLeafNodes() {
+        const nodes = Object.keys(this.selectedLeafNodeIds)
+            .filter((id) => this.selectedLeafNodeIds[id])
+            .map((id) => this.getNodeById(id));
+        return nodes.filter(Boolean);
+    }
+    // locating nodes
+    getNodeByPath(path, startNode = null) {
+        if (!path)
+            return null;
+        startNode = startNode || this.virtualRoot;
+        if (path.length === 0)
+            return startNode;
+        if (!startNode.children)
+            return null;
+        const childId = path.shift();
+        const childNode = startNode.children.find(c => c.id === childId);
+        if (!childNode)
+            return null;
+        return this.getNodeByPath(path, childNode);
+    }
+    getNodeById(id) {
+        const idStr = id.toString();
+        return this.getNodeBy((node) => node.id.toString() === idStr);
+    }
+    getNodeBy(predicate, startNode = null) {
+        startNode = startNode || this.virtualRoot;
+        if (!startNode.children)
+            return null;
+        const found = startNode.children.find(predicate);
+        if (found) { // found in children
+            return found;
+        }
+        else { // look in children's children
+            for (let child of startNode.children) {
+                const foundInChildren = this.getNodeBy(predicate, child);
+                if (foundInChildren)
+                    return foundInChildren;
+            }
+        }
+    }
+    isExpanded(node) {
+        return this.expandedNodeIds[node.id];
+    }
+    isHidden(node) {
+        return this.hiddenNodeIds[node.id];
+    }
+    isActive(node) {
+        return this.activeNodeIds[node.id];
+    }
+    isSelected(node) {
+        return this.selectedLeafNodeIds[node.id];
+    }
+    ngOnDestroy() {
+        this.dispose();
+        this.unsubscribeAll();
+    }
+    dispose() {
+        // Dispose reactions of the replaced nodes
+        if (this.virtualRoot) {
+            this.virtualRoot.dispose();
+        }
+    }
+    unsubscribeAll() {
+        this.subscriptions.forEach(subscription => subscription.unsubscribe());
+        this.subscriptions = [];
+    }
+    // actions
+    setData({ nodes, options = null, events = null }) {
+        if (options) {
+            this.options = new TreeOptions(options);
+        }
+        if (events) {
+            this.events = events;
+        }
+        if (nodes) {
+            this.nodes = nodes;
+        }
+        this.update();
+    }
+    update() {
+        // Rebuild tree:
+        let virtualRootConfig = {
+            id: this.options.rootId,
+            virtual: true,
+            [this.options.childrenField]: this.nodes
+        };
+        this.dispose();
+        this.virtualRoot = new TreeNode(virtualRootConfig, null, this, 0);
+        this.roots = this.virtualRoot.children;
+        // Fire event:
+        if (this.firstUpdate) {
+            if (this.roots) {
+                this.firstUpdate = false;
+                this._calculateExpandedNodes();
+            }
+        }
+        else {
+            this.fireEvent({ eventName: TREE_EVENTS.updateData });
+        }
+    }
+    setFocusedNode(node) {
+        this.focusedNodeId = node ? node.id : null;
+    }
+    setFocus(value) {
+        TreeModel.focusedTree = value ? this : null;
+    }
+    doForAll(fn) {
+        this.roots.forEach((root) => root.doForAll(fn));
+    }
+    focusNextNode() {
+        let previousNode = this.getFocusedNode();
+        let nextNode = previousNode ? previousNode.findNextNode(true, true) : this.getFirstRoot(true);
+        if (nextNode)
+            nextNode.focus();
+    }
+    focusPreviousNode() {
+        let previousNode = this.getFocusedNode();
+        let nextNode = previousNode ? previousNode.findPreviousNode(true) : this.getLastRoot(true);
+        if (nextNode)
+            nextNode.focus();
+    }
+    focusDrillDown() {
+        let previousNode = this.getFocusedNode();
+        if (previousNode && previousNode.isCollapsed && previousNode.hasChildren) {
+            previousNode.toggleExpanded();
+        }
+        else {
+            let nextNode = previousNode ? previousNode.getFirstChild(true) : this.getFirstRoot(true);
+            if (nextNode)
+                nextNode.focus();
+        }
+    }
+    focusDrillUp() {
+        let previousNode = this.getFocusedNode();
+        if (!previousNode)
+            return;
+        if (previousNode.isExpanded) {
+            previousNode.toggleExpanded();
+        }
+        else {
+            let nextNode = previousNode.realParent;
+            if (nextNode)
+                nextNode.focus();
+        }
+    }
+    setActiveNode(node, value, multi = false) {
+        if (multi) {
+            this._setActiveNodeMulti(node, value);
+        }
+        else {
+            this._setActiveNodeSingle(node, value);
+        }
+        if (value) {
+            node.focus(this.options.scrollOnActivate);
+            this.fireEvent({ eventName: TREE_EVENTS.activate, node });
+            this.fireEvent({ eventName: TREE_EVENTS.nodeActivate, node }); // For IE11
+        }
+        else {
+            this.fireEvent({ eventName: TREE_EVENTS.deactivate, node });
+            this.fireEvent({ eventName: TREE_EVENTS.nodeDeactivate, node }); // For IE11
+        }
+    }
+    setSelectedNode(node, value) {
+        this.selectedLeafNodeIds = Object.assign({}, this.selectedLeafNodeIds, { [node.id]: value });
+        if (value) {
+            node.focus();
+            this.fireEvent({ eventName: TREE_EVENTS.select, node });
+        }
+        else {
+            this.fireEvent({ eventName: TREE_EVENTS.deselect, node });
+        }
+    }
+    setExpandedNode(node, value) {
+        this.expandedNodeIds = Object.assign({}, this.expandedNodeIds, { [node.id]: value });
+        this.fireEvent({ eventName: TREE_EVENTS.toggleExpanded, node, isExpanded: value });
+    }
+    expandAll() {
+        this.roots.forEach((root) => root.expandAll());
+    }
+    collapseAll() {
+        this.roots.forEach((root) => root.collapseAll());
+    }
+    setIsHidden(node, value) {
+        this.hiddenNodeIds = Object.assign({}, this.hiddenNodeIds, { [node.id]: value });
+    }
+    setHiddenNodeIds(nodeIds) {
+        this.hiddenNodeIds = nodeIds.reduce((hiddenNodeIds, id) => Object.assign(hiddenNodeIds, {
+            [id]: true
+        }), {});
+    }
+    performKeyAction(node, $event) {
+        const keyAction = this.options.actionMapping.keys[$event.keyCode];
+        if (keyAction) {
+            $event.preventDefault();
+            keyAction(this, node, $event);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    filterNodes(filter, autoShow = true) {
+        let filterFn;
+        if (!filter) {
+            return this.clearFilter();
+        }
+        // support function and string filter
+        if (filter && typeof filter.valueOf() === 'string') {
+            filterFn = (node) => node.displayField.toLowerCase().indexOf(filter.toLowerCase()) !== -1;
+        }
+        else if (filter && typeof filter === 'function') {
+            filterFn = filter;
+        }
+        else {
+            console.error('Don\'t know what to do with filter', filter);
+            console.error('Should be either a string or function');
+            return;
+        }
+        const ids = {};
+        this.roots.forEach((node) => this._filterNode(ids, node, filterFn, autoShow));
+        this.hiddenNodeIds = ids;
+        this.fireEvent({ eventName: TREE_EVENTS.changeFilter });
+    }
+    clearFilter() {
+        this.hiddenNodeIds = {};
+        this.fireEvent({ eventName: TREE_EVENTS.changeFilter });
+    }
+    moveNode(node, to) {
+        const fromIndex = node.getIndexInParent();
+        const fromParent = node.parent;
+        if (!this.canMoveNode(node, to, fromIndex))
+            return;
+        const fromChildren = fromParent.getField('children');
+        // If node doesn't have children - create children array
+        if (!to.parent.getField('children')) {
+            to.parent.setField('children', []);
+        }
+        const toChildren = to.parent.getField('children');
+        const originalNode = fromChildren.splice(fromIndex, 1)[0];
+        // Compensate for index if already removed from parent:
+        let toIndex = (fromParent === to.parent && to.index > fromIndex) ? to.index - 1 : to.index;
+        toChildren.splice(toIndex, 0, originalNode);
+        fromParent.treeModel.update();
+        if (to.parent.treeModel !== fromParent.treeModel) {
+            to.parent.treeModel.update();
+        }
+        this.fireEvent({
+            eventName: TREE_EVENTS.moveNode,
+            node: originalNode,
+            to: { parent: to.parent.data, index: toIndex },
+            from: { parent: fromParent.data, index: fromIndex }
+        });
+    }
+    copyNode(node, to) {
+        const fromIndex = node.getIndexInParent();
+        if (!this.canMoveNode(node, to, fromIndex))
+            return;
+        // If node doesn't have children - create children array
+        if (!to.parent.getField('children')) {
+            to.parent.setField('children', []);
+        }
+        const toChildren = to.parent.getField('children');
+        const nodeCopy = this.options.getNodeClone(node);
+        toChildren.splice(to.index, 0, nodeCopy);
+        node.treeModel.update();
+        if (to.parent.treeModel !== node.treeModel) {
+            to.parent.treeModel.update();
+        }
+        this.fireEvent({ eventName: TREE_EVENTS.copyNode, node: nodeCopy, to: { parent: to.parent.data, index: to.index } });
+    }
+    getState() {
+        return {
+            expandedNodeIds: this.expandedNodeIds,
+            selectedLeafNodeIds: this.selectedLeafNodeIds,
+            activeNodeIds: this.activeNodeIds,
+            hiddenNodeIds: this.hiddenNodeIds,
+            focusedNodeId: this.focusedNodeId
+        };
+    }
+    setState(state) {
+        if (!state)
+            return;
+        Object.assign(this, {
+            expandedNodeIds: state.expandedNodeIds || {},
+            selectedLeafNodeIds: state.selectedLeafNodeIds || {},
+            activeNodeIds: state.activeNodeIds || {},
+            hiddenNodeIds: state.hiddenNodeIds || {},
+            focusedNodeId: state.focusedNodeId
+        });
+    }
+    subscribeToState(fn) {
+        autorun(() => fn(this.getState()));
+    }
+    canMoveNode(node, to, fromIndex = undefined) {
+        const fromNodeIndex = fromIndex || node.getIndexInParent();
+        // same node:
+        if (node.parent === to.parent && fromIndex === to.index) {
+            return false;
+        }
+        return !to.parent.isDescendantOf(node);
+    }
+    calculateExpandedNodes() {
+        this._calculateExpandedNodes();
+    }
+    // private methods
+    _filterNode(ids, node, filterFn, autoShow) {
+        // if node passes function then it's visible
+        let isVisible = filterFn(node);
+        if (node.children) {
+            // if one of node's children passes filter then this node is also visible
+            node.children.forEach((child) => {
+                if (this._filterNode(ids, child, filterFn, autoShow)) {
+                    isVisible = true;
+                }
+            });
+        }
+        // mark node as hidden
+        if (!isVisible) {
+            ids[node.id] = true;
+        }
+        // auto expand parents to make sure the filtered nodes are visible
+        if (autoShow && isVisible) {
+            node.ensureVisible();
+        }
+        return isVisible;
+    }
+    _calculateExpandedNodes(startNode = null) {
+        startNode = startNode || this.virtualRoot;
+        if (startNode.data[this.options.isExpandedField]) {
+            this.expandedNodeIds = Object.assign({}, this.expandedNodeIds, { [startNode.id]: true });
+        }
+        if (startNode.children) {
+            startNode.children.forEach((child) => this._calculateExpandedNodes(child));
+        }
+    }
+    _setActiveNodeSingle(node, value) {
+        // Deactivate all other nodes:
+        this.activeNodes
+            .filter((activeNode) => activeNode !== node)
+            .forEach((activeNode) => {
+            this.fireEvent({ eventName: TREE_EVENTS.deactivate, node: activeNode });
+            this.fireEvent({ eventName: TREE_EVENTS.nodeDeactivate, node: activeNode }); // For IE11
+        });
+        if (value) {
+            this.activeNodeIds = { [node.id]: true };
+        }
+        else {
+            this.activeNodeIds = {};
+        }
+    }
+    _setActiveNodeMulti(node, value) {
+        this.activeNodeIds = Object.assign({}, this.activeNodeIds, { [node.id]: value });
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: TreeModel, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: TreeModel }); }
+}
+__decorate([
+    observable
+], TreeModel.prototype, "roots", void 0);
+__decorate([
+    observable
+], TreeModel.prototype, "expandedNodeIds", void 0);
+__decorate([
+    observable
+], TreeModel.prototype, "selectedLeafNodeIds", void 0);
+__decorate([
+    observable
+], TreeModel.prototype, "activeNodeIds", void 0);
+__decorate([
+    observable
+], TreeModel.prototype, "hiddenNodeIds", void 0);
+__decorate([
+    observable
+], TreeModel.prototype, "focusedNodeId", void 0);
+__decorate([
+    observable
+], TreeModel.prototype, "virtualRoot", void 0);
+__decorate([
+    computed
+], TreeModel.prototype, "focusedNode", null);
+__decorate([
+    computed
+], TreeModel.prototype, "expandedNodes", null);
+__decorate([
+    computed
+], TreeModel.prototype, "activeNodes", null);
+__decorate([
+    computed
+], TreeModel.prototype, "hiddenNodes", null);
+__decorate([
+    computed
+], TreeModel.prototype, "selectedLeafNodes", null);
+__decorate([
+    action
+], TreeModel.prototype, "setData", null);
+__decorate([
+    action
+], TreeModel.prototype, "update", null);
+__decorate([
+    action
+], TreeModel.prototype, "setFocusedNode", null);
+__decorate([
+    action
+], TreeModel.prototype, "setFocus", null);
+__decorate([
+    action
+], TreeModel.prototype, "doForAll", null);
+__decorate([
+    action
+], TreeModel.prototype, "focusNextNode", null);
+__decorate([
+    action
+], TreeModel.prototype, "focusPreviousNode", null);
+__decorate([
+    action
+], TreeModel.prototype, "focusDrillDown", null);
+__decorate([
+    action
+], TreeModel.prototype, "focusDrillUp", null);
+__decorate([
+    action
+], TreeModel.prototype, "setActiveNode", null);
+__decorate([
+    action
+], TreeModel.prototype, "setSelectedNode", null);
+__decorate([
+    action
+], TreeModel.prototype, "setExpandedNode", null);
+__decorate([
+    action
+], TreeModel.prototype, "expandAll", null);
+__decorate([
+    action
+], TreeModel.prototype, "collapseAll", null);
+__decorate([
+    action
+], TreeModel.prototype, "setIsHidden", null);
+__decorate([
+    action
+], TreeModel.prototype, "setHiddenNodeIds", null);
+__decorate([
+    action
+], TreeModel.prototype, "filterNodes", null);
+__decorate([
+    action
+], TreeModel.prototype, "clearFilter", null);
+__decorate([
+    action
+], TreeModel.prototype, "moveNode", null);
+__decorate([
+    action
+], TreeModel.prototype, "copyNode", null);
+__decorate([
+    action
+], TreeModel.prototype, "setState", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: TreeModel, decorators: [{
+            type: Injectable
+        }], propDecorators: { roots: [], expandedNodeIds: [], selectedLeafNodeIds: [], activeNodeIds: [], hiddenNodeIds: [], focusedNodeId: [], virtualRoot: [], focusedNode: [], expandedNodes: [], activeNodes: [], hiddenNodes: [], selectedLeafNodes: [], setData: [], update: [], setFocusedNode: [], setFocus: [], doForAll: [], focusNextNode: [], focusPreviousNode: [], focusDrillDown: [], focusDrillUp: [], setActiveNode: [], setSelectedNode: [], setExpandedNode: [], expandAll: [], collapseAll: [], setIsHidden: [], setHiddenNodeIds: [], filterNodes: [], clearFilter: [], moveNode: [], copyNode: [], setState: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.model.js","sourceRoot":"","sources":["../../../../../projects/angular-tree-component/src/lib/models/tree.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\r\nimport { observable, computed, action, autorun } from 'mobx';\r\nimport { Subscription } from 'rxjs';\r\nimport { TreeNode } from './tree-node.model';\r\nimport { TreeOptions } from './tree-options.model';\r\nimport { TreeVirtualScroll } from './tree-virtual-scroll.model';\r\nimport { ITreeModel, IDType, IDTypeDictionary } from '../defs/api';\r\nimport { TREE_EVENTS } from '../constants/events';\r\n\r\n@Injectable()\r\nexport class TreeModel implements ITreeModel, OnDestroy {\r\n  static focusedTree = null;\r\n\r\n  options: TreeOptions = new TreeOptions();\r\n  nodes: any[];\r\n  eventNames = Object.keys(TREE_EVENTS);\r\n  virtualScroll: TreeVirtualScroll;\r\n\r\n  @observable roots: TreeNode[];\r\n  @observable expandedNodeIds: IDTypeDictionary = {};\r\n  @observable selectedLeafNodeIds: IDTypeDictionary = {};\r\n  @observable activeNodeIds: IDTypeDictionary = {};\r\n  @observable hiddenNodeIds: IDTypeDictionary = {};\r\n  @observable focusedNodeId: IDType = null;\r\n  @observable virtualRoot: TreeNode;\r\n\r\n  private firstUpdate = true;\r\n  private events: any;\r\n  private subscriptions: Subscription[] = [];\r\n\r\n  // events\r\n  fireEvent(event) {\r\n    event.treeModel = this;\r\n    this.events[event.eventName].emit(event);\r\n    this.events.event.emit(event);\r\n  }\r\n\r\n  subscribe(eventName, fn) {\r\n    const subscription = this.events[eventName].subscribe(fn);\r\n    this.subscriptions.push(subscription);\r\n  }\r\n\r\n\r\n  // getters\r\n  getFocusedNode(): TreeNode {\r\n    return this.focusedNode;\r\n  }\r\n\r\n\r\n  getActiveNode(): TreeNode {\r\n    return this.activeNodes[0];\r\n  }\r\n\r\n  getActiveNodes(): TreeNode[] {\r\n    return this.activeNodes;\r\n  }\r\n\r\n  getVisibleRoots() {\r\n    return this.virtualRoot.visibleChildren;\r\n  }\r\n\r\n  getFirstRoot(skipHidden = false) {\r\n    const root = skipHidden ? this.getVisibleRoots() : this.roots;\r\n    return root != null && root.length ? root[0] : null;\r\n  }\r\n\r\n  getLastRoot(skipHidden = false) {\r\n    const root = skipHidden ? this.getVisibleRoots() : this.roots;\r\n    return root != null && root.length ? root[root.length - 1] : null;\r\n  }\r\n\r\n  get isFocused() {\r\n    return TreeModel.focusedTree === this;\r\n  }\r\n\r\n  isNodeFocused(node) {\r\n    return this.focusedNode === node;\r\n  }\r\n\r\n  isEmptyTree(): boolean {\r\n    return this.roots && this.roots.length === 0;\r\n  }\r\n\r\n  @computed get focusedNode() {\r\n    return this.focusedNodeId ? this.getNodeById(this.focusedNodeId) : null;\r\n  }\r\n\r\n  @computed get expandedNodes() {\r\n    const nodes = Object.keys(this.expandedNodeIds)\r\n      .filter((id) => this.expandedNodeIds[id])\r\n      .map((id) => this.getNodeById(id));\r\n\r\n    return nodes.filter(Boolean);\r\n  }\r\n\r\n  @computed get activeNodes() {\r\n    const nodes = Object.keys(this.activeNodeIds)\r\n      .filter((id) => this.activeNodeIds[id])\r\n      .map((id) => this.getNodeById(id));\r\n\r\n    return nodes.filter(Boolean);\r\n  }\r\n\r\n  @computed get hiddenNodes() {\r\n    const nodes = Object.keys(this.hiddenNodeIds)\r\n        .filter((id) => this.hiddenNodeIds[id])\r\n        .map((id) => this.getNodeById(id));\r\n\r\n    return nodes.filter(Boolean);\r\n  }\r\n\r\n  @computed get selectedLeafNodes() {\r\n    const nodes = Object.keys(this.selectedLeafNodeIds)\r\n        .filter((id) => this.selectedLeafNodeIds[id])\r\n        .map((id) => this.getNodeById(id));\r\n\r\n    return nodes.filter(Boolean);\r\n  }\r\n\r\n  // locating nodes\r\n  getNodeByPath(path: any[], startNode= null): TreeNode {\r\n    if (!path) return null;\r\n\r\n    startNode = startNode || this.virtualRoot;\r\n    if (path.length === 0) return startNode;\r\n\r\n    if (!startNode.children) return null;\r\n\r\n    const childId = path.shift();\r\n    const childNode = startNode.children.find(c => c.id === childId);\r\n\r\n    if (!childNode) return null;\r\n\r\n    return this.getNodeByPath(path, childNode);\r\n  }\r\n\r\n  getNodeById(id) {\r\n    const idStr = id.toString();\r\n\r\n    return this.getNodeBy((node) => node.id.toString() === idStr);\r\n  }\r\n\r\n  getNodeBy(predicate, startNode = null) {\r\n    startNode = startNode || this.virtualRoot;\r\n\r\n    if (!startNode.children) return null;\r\n\r\n    const found = startNode.children.find(predicate);\r\n\r\n    if (found) { // found in children\r\n      return found;\r\n    } else { // look in children's children\r\n      for (let child of startNode.children) {\r\n        const foundInChildren = this.getNodeBy(predicate, child);\r\n        if (foundInChildren) return foundInChildren;\r\n      }\r\n    }\r\n  }\r\n\r\n  isExpanded(node) {\r\n    return this.expandedNodeIds[node.id];\r\n  }\r\n\r\n  isHidden(node) {\r\n    return this.hiddenNodeIds[node.id];\r\n  }\r\n\r\n  isActive(node) {\r\n    return this.activeNodeIds[node.id];\r\n  }\r\n\r\n  isSelected(node) {\r\n    return this.selectedLeafNodeIds[node.id];\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.dispose();\r\n    this.unsubscribeAll();\r\n  }\r\n\r\n  dispose() {\r\n    // Dispose reactions of the replaced nodes\r\n    if (this.virtualRoot) {\r\n      this.virtualRoot.dispose();\r\n    }\r\n  }\r\n\r\n  unsubscribeAll() {\r\n    this.subscriptions.forEach(subscription => subscription.unsubscribe());\r\n    this.subscriptions = [];\r\n  }\r\n\r\n  // actions\r\n  @action setData({ nodes, options = null, events = null }: {nodes: any, options: any, events: any}) {\r\n    if (options) {\r\n      this.options = new TreeOptions(options);\r\n    }\r\n    if (events) {\r\n      this.events = events;\r\n    }\r\n    if (nodes) {\r\n      this.nodes = nodes;\r\n    }\r\n\r\n    this.update();\r\n  }\r\n\r\n  @action update() {\r\n    // Rebuild tree:\r\n    let virtualRootConfig = {\r\n      id: this.options.rootId,\r\n      virtual: true,\r\n      [this.options.childrenField]: this.nodes\r\n    };\r\n\r\n    this.dispose();\r\n\r\n    this.virtualRoot = new TreeNode(virtualRootConfig, null, this, 0);\r\n\r\n    this.roots = this.virtualRoot.children;\r\n\r\n    // Fire event:\r\n    if (this.firstUpdate) {\r\n      if (this.roots) {\r\n        this.firstUpdate = false;\r\n        this._calculateExpandedNodes();\r\n      }\r\n    } else {\r\n      this.fireEvent({ eventName: TREE_EVENTS.updateData });\r\n    }\r\n  }\r\n\r\n\r\n  @action setFocusedNode(node) {\r\n    this.focusedNodeId = node ? node.id : null;\r\n  }\r\n\r\n  @action setFocus(value) {\r\n    TreeModel.focusedTree = value ? this : null;\r\n  }\r\n\r\n  @action doForAll(fn) {\r\n    this.roots.forEach((root) => root.doForAll(fn));\r\n  }\r\n\r\n  @action focusNextNode() {\r\n    let previousNode = this.getFocusedNode();\r\n    let nextNode = previousNode ? previousNode.findNextNode(true, true) : this.getFirstRoot(true);\r\n    if (nextNode) nextNode.focus();\r\n  }\r\n\r\n  @action focusPreviousNode() {\r\n    let previousNode = this.getFocusedNode();\r\n    let nextNode = previousNode ? previousNode.findPreviousNode(true) : this.getLastRoot(true);\r\n    if (nextNode) nextNode.focus();\r\n  }\r\n\r\n  @action focusDrillDown() {\r\n    let previousNode = this.getFocusedNode();\r\n    if (previousNode && previousNode.isCollapsed && previousNode.hasChildren) {\r\n      previousNode.toggleExpanded();\r\n    }\r\n    else {\r\n      let nextNode = previousNode ? previousNode.getFirstChild(true) : this.getFirstRoot(true);\r\n      if (nextNode) nextNode.focus();\r\n    }\r\n  }\r\n\r\n  @action focusDrillUp() {\r\n    let previousNode = this.getFocusedNode();\r\n    if (!previousNode) return;\r\n    if (previousNode.isExpanded) {\r\n      previousNode.toggleExpanded();\r\n    }\r\n    else {\r\n      let nextNode = previousNode.realParent;\r\n      if (nextNode) nextNode.focus();\r\n    }\r\n  }\r\n\r\n  @action setActiveNode(node, value, multi = false) {\r\n    if (multi) {\r\n      this._setActiveNodeMulti(node, value);\r\n    }\r\n    else {\r\n      this._setActiveNodeSingle(node, value);\r\n    }\r\n\r\n    if (value) {\r\n      node.focus(this.options.scrollOnActivate);\r\n      this.fireEvent({ eventName: TREE_EVENTS.activate, node });\r\n      this.fireEvent({ eventName: TREE_EVENTS.nodeActivate, node }); // For IE11\r\n    } else {\r\n      this.fireEvent({ eventName: TREE_EVENTS.deactivate, node });\r\n      this.fireEvent({ eventName: TREE_EVENTS.nodeDeactivate, node }); // For IE11\r\n    }\r\n  }\r\n\r\n  @action setSelectedNode(node, value) {\r\n    this.selectedLeafNodeIds = Object.assign({}, this.selectedLeafNodeIds, {[node.id]: value});\r\n\r\n    if (value) {\r\n      node.focus();\r\n      this.fireEvent({ eventName: TREE_EVENTS.select, node });\r\n    } else {\r\n      this.fireEvent({ eventName: TREE_EVENTS.deselect, node });\r\n    }\r\n  }\r\n\r\n  @action setExpandedNode(node, value) {\r\n    this.expandedNodeIds = Object.assign({}, this.expandedNodeIds, {[node.id]: value});\r\n    this.fireEvent({ eventName: TREE_EVENTS.toggleExpanded, node, isExpanded: value });\r\n  }\r\n\r\n  @action expandAll() {\r\n    this.roots.forEach((root) => root.expandAll());\r\n  }\r\n\r\n  @action collapseAll() {\r\n    this.roots.forEach((root) => root.collapseAll());\r\n  }\r\n\r\n  @action setIsHidden(node, value) {\r\n    this.hiddenNodeIds = Object.assign({}, this.hiddenNodeIds, {[node.id]: value});\r\n  }\r\n\r\n  @action setHiddenNodeIds(nodeIds) {\r\n    this.hiddenNodeIds = nodeIds.reduce((hiddenNodeIds, id) => Object.assign(hiddenNodeIds, {\r\n      [id]: true\r\n    }), {});\r\n  }\r\n\r\n  performKeyAction(node, $event) {\r\n    const keyAction = this.options.actionMapping.keys[$event.keyCode];\r\n    if (keyAction) {\r\n      $event.preventDefault();\r\n      keyAction(this, node, $event);\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  @action filterNodes(filter, autoShow = true) {\r\n    let filterFn;\r\n\r\n    if (!filter) {\r\n      return this.clearFilter();\r\n    }\r\n\r\n    // support function and string filter\r\n    if (filter && typeof filter.valueOf() === 'string') {\r\n      filterFn = (node) => node.displayField.toLowerCase().indexOf(filter.toLowerCase()) !== -1;\r\n    }\r\n    else if (filter && typeof filter === 'function') {\r\n       filterFn = filter;\r\n    }\r\n    else {\r\n      console.error('Don\\'t know what to do with filter', filter);\r\n      console.error('Should be either a string or function');\r\n      return;\r\n    }\r\n\r\n    const ids = {};\r\n    this.roots.forEach((node) => this._filterNode(ids, node, filterFn, autoShow));\r\n    this.hiddenNodeIds = ids;\r\n    this.fireEvent({ eventName: TREE_EVENTS.changeFilter });\r\n  }\r\n\r\n  @action clearFilter() {\r\n    this.hiddenNodeIds = {};\r\n    this.fireEvent({ eventName: TREE_EVENTS.changeFilter });\r\n  }\r\n\r\n  @action moveNode(node, to) {\r\n    const fromIndex = node.getIndexInParent();\r\n    const fromParent = node.parent;\r\n\r\n    if (!this.canMoveNode(node, to, fromIndex)) return;\r\n\r\n    const fromChildren = fromParent.getField('children');\r\n\r\n    // If node doesn't have children - create children array\r\n    if (!to.parent.getField('children')) {\r\n      to.parent.setField('children', []);\r\n    }\r\n    const toChildren = to.parent.getField('children');\r\n\r\n    const originalNode = fromChildren.splice(fromIndex, 1)[0];\r\n\r\n    // Compensate for index if already removed from parent:\r\n    let toIndex = (fromParent === to.parent && to.index > fromIndex) ? to.index - 1 : to.index;\r\n\r\n    toChildren.splice(toIndex, 0, originalNode);\r\n\r\n    fromParent.treeModel.update();\r\n    if (to.parent.treeModel !== fromParent.treeModel) {\r\n      to.parent.treeModel.update();\r\n    }\r\n\r\n    this.fireEvent({\r\n      eventName: TREE_EVENTS.moveNode,\r\n      node: originalNode,\r\n      to: { parent: to.parent.data, index: toIndex },\r\n      from: { parent: fromParent.data, index: fromIndex}\r\n    });\r\n  }\r\n\r\n  @action copyNode(node, to) {\r\n    const fromIndex = node.getIndexInParent();\r\n\r\n    if (!this.canMoveNode(node, to, fromIndex)) return;\r\n\r\n    // If node doesn't have children - create children array\r\n    if (!to.parent.getField('children')) {\r\n      to.parent.setField('children', []);\r\n    }\r\n    const toChildren = to.parent.getField('children');\r\n\r\n    const nodeCopy = this.options.getNodeClone(node);\r\n\r\n    toChildren.splice(to.index, 0, nodeCopy);\r\n\r\n    node.treeModel.update();\r\n    if (to.parent.treeModel !== node.treeModel) {\r\n      to.parent.treeModel.update();\r\n    }\r\n\r\n    this.fireEvent({ eventName: TREE_EVENTS.copyNode, node: nodeCopy, to: { parent: to.parent.data, index: to.index } });\r\n  }\r\n\r\n  getState() {\r\n    return {\r\n      expandedNodeIds: this.expandedNodeIds,\r\n      selectedLeafNodeIds: this.selectedLeafNodeIds,\r\n      activeNodeIds: this.activeNodeIds,\r\n      hiddenNodeIds: this.hiddenNodeIds,\r\n      focusedNodeId: this.focusedNodeId\r\n    };\r\n  }\r\n\r\n  @action setState(state) {\r\n    if (!state) return;\r\n\r\n    Object.assign(this, {\r\n      expandedNodeIds: state.expandedNodeIds || {},\r\n      selectedLeafNodeIds: state.selectedLeafNodeIds || {},\r\n      activeNodeIds: state.activeNodeIds || {},\r\n      hiddenNodeIds: state.hiddenNodeIds || {},\r\n      focusedNodeId: state.focusedNodeId\r\n    });\r\n  }\r\n\r\n  subscribeToState(fn) {\r\n    autorun(() => fn(this.getState()));\r\n  }\r\n\r\n  canMoveNode(node, to, fromIndex = undefined) {\r\n    const fromNodeIndex = fromIndex || node.getIndexInParent();\r\n\r\n    // same node:\r\n    if (node.parent === to.parent && fromIndex === to.index) {\r\n      return false;\r\n    }\r\n\r\n    return !to.parent.isDescendantOf(node);\r\n  }\r\n\r\n  calculateExpandedNodes() {\r\n      this._calculateExpandedNodes();\r\n  }\r\n\r\n  // private methods\r\n  private _filterNode(ids, node, filterFn, autoShow) {\r\n    // if node passes function then it's visible\r\n    let isVisible = filterFn(node);\r\n\r\n    if (node.children) {\r\n      // if one of node's children passes filter then this node is also visible\r\n      node.children.forEach((child) => {\r\n        if (this._filterNode(ids, child, filterFn, autoShow)) {\r\n          isVisible = true;\r\n        }\r\n      });\r\n    }\r\n\r\n    // mark node as hidden\r\n    if (!isVisible) {\r\n      ids[node.id] = true;\r\n    }\r\n    // auto expand parents to make sure the filtered nodes are visible\r\n    if (autoShow && isVisible) {\r\n      node.ensureVisible();\r\n    }\r\n    return isVisible;\r\n  }\r\n\r\n  private _calculateExpandedNodes(startNode = null) {\r\n    startNode = startNode || this.virtualRoot;\r\n\r\n    if (startNode.data[this.options.isExpandedField]) {\r\n      this.expandedNodeIds = Object.assign({}, this.expandedNodeIds, {[startNode.id]: true});\r\n    }\r\n    if (startNode.children) {\r\n      startNode.children.forEach((child) => this._calculateExpandedNodes(child));\r\n    }\r\n  }\r\n\r\n  private _setActiveNodeSingle(node, value) {\r\n    // Deactivate all other nodes:\r\n    this.activeNodes\r\n      .filter((activeNode) => activeNode !== node)\r\n      .forEach((activeNode) => {\r\n        this.fireEvent({ eventName: TREE_EVENTS.deactivate, node: activeNode });\r\n        this.fireEvent({ eventName: TREE_EVENTS.nodeDeactivate, node: activeNode }); // For IE11\r\n      });\r\n\r\n    if (value) {\r\n      this.activeNodeIds = {[node.id]: true};\r\n    }\r\n    else {\r\n      this.activeNodeIds = {};\r\n    }\r\n  }\r\n\r\n  private _setActiveNodeMulti(node, value) {\r\n    this.activeNodeIds = Object.assign({}, this.activeNodeIds, {[node.id]: value});\r\n  }\r\n\r\n}\r\n"]}

package/{esm2020 → esm2022}/public-api.mjs

@@ -1,5 +1,5 @@
-/*
- * Public API Surface of angular-tree-component
- */
-export * from './lib/angular-tree-component.module';
+/*
+ * Public API Surface of angular-tree-component
+ */
+export * from './lib/angular-tree-component.module';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdHJlZS1jb21wb25lbnQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHFDQUFxQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcclxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGFuZ3VsYXItdHJlZS1jb21wb25lbnRcclxuICovXHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9hbmd1bGFyLXRyZWUtY29tcG9uZW50Lm1vZHVsZSc7XHJcbiJdfQ==