@ali-hm/angular-tree-component 12.0.6 → 16.0.1

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

@@ -0,0 +1,150 @@
+import { KEYS } from '../constants/keys';
+export const TREE_ACTIONS = {
+    TOGGLE_ACTIVE: (tree, node, $event) => node && node.toggleActivated(),
+    TOGGLE_ACTIVE_MULTI: (tree, node, $event) => node && node.toggleActivated(true),
+    TOGGLE_SELECTED: (tree, node, $event) => node && node.toggleSelected(),
+    ACTIVATE: (tree, node, $event) => node.setIsActive(true),
+    DEACTIVATE: (tree, node, $event) => node.setIsActive(false),
+    SELECT: (tree, node, $event) => node.setIsSelected(true),
+    DESELECT: (tree, node, $event) => node.setIsSelected(false),
+    FOCUS: (tree, node, $event) => node.focus(),
+    TOGGLE_EXPANDED: (tree, node, $event) => node.hasChildren && node.toggleExpanded(),
+    EXPAND: (tree, node, $event) => node.expand(),
+    COLLAPSE: (tree, node, $event) => node.collapse(),
+    DRILL_DOWN: (tree, node, $event) => tree.focusDrillDown(),
+    DRILL_UP: (tree, node, $event) => tree.focusDrillUp(),
+    NEXT_NODE: (tree, node, $event) => tree.focusNextNode(),
+    PREVIOUS_NODE: (tree, node, $event) => tree.focusPreviousNode(),
+    MOVE_NODE: (tree, node, $event, { from, to }) => {
+        // default action assumes from = node, to = {parent, index}
+        if ($event.ctrlKey) {
+            tree.copyNode(from, to);
+        }
+        else {
+            tree.moveNode(from, to);
+        }
+    }
+};
+const defaultActionMapping = {
+    mouse: {
+        click: TREE_ACTIONS.TOGGLE_ACTIVE,
+        dblClick: null,
+        contextMenu: null,
+        expanderClick: TREE_ACTIONS.TOGGLE_EXPANDED,
+        checkboxClick: TREE_ACTIONS.TOGGLE_SELECTED,
+        drop: TREE_ACTIONS.MOVE_NODE
+    },
+    keys: {
+        [KEYS.RIGHT]: TREE_ACTIONS.DRILL_DOWN,
+        [KEYS.LEFT]: TREE_ACTIONS.DRILL_UP,
+        [KEYS.DOWN]: TREE_ACTIONS.NEXT_NODE,
+        [KEYS.UP]: TREE_ACTIONS.PREVIOUS_NODE,
+        [KEYS.SPACE]: TREE_ACTIONS.TOGGLE_ACTIVE,
+        [KEYS.ENTER]: TREE_ACTIONS.TOGGLE_ACTIVE
+    }
+};
+export class TreeOptions {
+    get hasChildrenField() { return this.options.hasChildrenField || 'hasChildren'; }
+    get childrenField() { return this.options.childrenField || 'children'; }
+    get displayField() { return this.options.displayField || 'name'; }
+    get idField() { return this.options.idField || 'id'; }
+    get isExpandedField() { return this.options.isExpandedField || 'isExpanded'; }
+    get getChildren() { return this.options.getChildren; }
+    get levelPadding() { return this.options.levelPadding || 0; }
+    get useVirtualScroll() { return this.options.useVirtualScroll; }
+    get animateExpand() { return this.options.animateExpand; }
+    get animateSpeed() { return this.options.animateSpeed || 1; }
+    get animateAcceleration() { return this.options.animateAcceleration || 1.2; }
+    get scrollOnActivate() { return this.options.scrollOnActivate === undefined ? true : this.options.scrollOnActivate; }
+    get rtl() { return !!this.options.rtl; }
+    get rootId() { return this.options.rootId; }
+    get useCheckbox() { return this.options.useCheckbox; }
+    get useTriState() { return this.options.useTriState === undefined ? true : this.options.useTriState; }
+    get scrollContainer() { return this.options.scrollContainer; }
+    get allowDragoverStyling() { return this.options.allowDragoverStyling === undefined ? true : this.options.allowDragoverStyling; }
+    constructor(options = {}) {
+        this.options = options;
+        this.actionMapping = {
+            mouse: {
+                click: this.options?.actionMapping?.mouse?.click ?? defaultActionMapping.mouse.click,
+                dblClick: this.options?.actionMapping?.mouse?.dblClick ?? defaultActionMapping.mouse.dblClick,
+                contextMenu: this.options?.actionMapping?.mouse?.contextMenu ?? defaultActionMapping.mouse.contextMenu,
+                expanderClick: this.options?.actionMapping?.mouse?.expanderClick ?? defaultActionMapping.mouse.expanderClick,
+                checkboxClick: this.options?.actionMapping?.mouse?.checkboxClick ?? defaultActionMapping.mouse.checkboxClick,
+                drop: this.options?.actionMapping?.mouse?.drop ?? defaultActionMapping.mouse.drop,
+                dragStart: this.options?.actionMapping?.mouse?.dragStart ?? undefined,
+                drag: this.options?.actionMapping?.mouse?.drag ?? undefined,
+                dragEnd: this.options?.actionMapping?.mouse?.dragEnd ?? undefined,
+                dragOver: this.options?.actionMapping?.mouse?.dragOver ?? undefined,
+                dragLeave: this.options?.actionMapping?.mouse?.dragLeave ?? undefined,
+                dragEnter: this.options?.actionMapping?.mouse?.dragEnter ?? undefined,
+                mouseOver: this.options?.actionMapping?.mouse?.mouseOver ?? undefined,
+                mouseOut: this.options?.actionMapping?.mouse?.mouseOut ?? undefined,
+            },
+            keys: {
+                [KEYS.RIGHT]: TREE_ACTIONS.DRILL_DOWN,
+                [KEYS.LEFT]: TREE_ACTIONS.DRILL_UP,
+                [KEYS.DOWN]: TREE_ACTIONS.NEXT_NODE,
+                [KEYS.UP]: TREE_ACTIONS.PREVIOUS_NODE,
+                [KEYS.SPACE]: TREE_ACTIONS.TOGGLE_ACTIVE,
+                [KEYS.ENTER]: TREE_ACTIONS.TOGGLE_ACTIVE
+            }
+        };
+        if (this.options?.actionMapping?.keys) {
+            this.actionMapping.keys = {
+                ...this.actionMapping.keys,
+                ...this.options.actionMapping.keys
+            };
+        }
+        if (options.rtl) {
+            this.actionMapping.keys[KEYS.RIGHT] = options.actionMapping?.keys[KEYS.RIGHT] || TREE_ACTIONS.DRILL_UP;
+            this.actionMapping.keys[KEYS.LEFT] = options.actionMapping?.keys[KEYS.LEFT] || TREE_ACTIONS.DRILL_DOWN;
+        }
+    }
+    getNodeClone(node) {
+        if (this.options.getNodeClone) {
+            return this.options.getNodeClone(node);
+        }
+        // remove id from clone
+        // keeping ie11 compatibility
+        const nodeClone = Object.assign({}, node.data);
+        if (nodeClone.id) {
+            delete nodeClone.id;
+        }
+        return nodeClone;
+    }
+    allowDrop(element, to, $event) {
+        if (this.options.allowDrop instanceof Function) {
+            return this.options.allowDrop(element, to, $event);
+        }
+        else {
+            return this.options.allowDrop === undefined ? true : this.options.allowDrop;
+        }
+    }
+    allowDrag(node) {
+        if (this.options.allowDrag instanceof Function) {
+            return this.options.allowDrag(node);
+        }
+        else {
+            return this.options.allowDrag;
+        }
+    }
+    nodeClass(node) {
+        return this.options.nodeClass ? this.options.nodeClass(node) : '';
+    }
+    nodeHeight(node) {
+        if (node.data.virtual) {
+            return 0;
+        }
+        let nodeHeight = this.options.nodeHeight || 22;
+        if (typeof nodeHeight === 'function') {
+            nodeHeight = nodeHeight(node);
+        }
+        // account for drop slots:
+        return nodeHeight + (node.index === 0 ? 2 : 1) * this.dropSlotHeight;
+    }
+    get dropSlotHeight() {
+        return typeof this.options.dropSlotHeight === 'number' ? this.options.dropSlotHeight : 2;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-options.model.js","sourceRoot":"","sources":["../../../../../projects/angular-tree-component/src/lib/models/tree-options.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { TreeNode } from './tree-node.model';\r\nimport { TreeModel } from './tree.model';\r\nimport { KEYS } from '../constants/keys';\r\nimport { ITreeOptions } from '../defs/api';\r\n\r\nexport interface IActionHandler {\r\n  (tree: TreeModel, node: TreeNode, $event: any, ...rest);\r\n}\r\n\r\nexport const TREE_ACTIONS = {\r\n  TOGGLE_ACTIVE: (tree: TreeModel, node: TreeNode, $event: any) => node && node.toggleActivated(),\r\n  TOGGLE_ACTIVE_MULTI: (tree: TreeModel, node: TreeNode, $event: any) => node && node.toggleActivated(true),\r\n  TOGGLE_SELECTED: (tree: TreeModel, node: TreeNode, $event: any) => node && node.toggleSelected(),\r\n  ACTIVATE: (tree: TreeModel, node: TreeNode, $event: any) => node.setIsActive(true),\r\n  DEACTIVATE: (tree: TreeModel, node: TreeNode, $event: any) => node.setIsActive(false),\r\n  SELECT: (tree: TreeModel, node: TreeNode, $event: any) => node.setIsSelected(true),\r\n  DESELECT: (tree: TreeModel, node: TreeNode, $event: any) => node.setIsSelected(false),\r\n  FOCUS: (tree: TreeModel, node: TreeNode, $event: any) => node.focus(),\r\n  TOGGLE_EXPANDED: (tree: TreeModel, node: TreeNode, $event: any) => node.hasChildren && node.toggleExpanded(),\r\n  EXPAND: (tree: TreeModel, node: TreeNode, $event: any) => node.expand(),\r\n  COLLAPSE: (tree: TreeModel, node: TreeNode, $event: any) => node.collapse(),\r\n  DRILL_DOWN: (tree: TreeModel, node: TreeNode, $event: any) => tree.focusDrillDown(),\r\n  DRILL_UP: (tree: TreeModel, node: TreeNode, $event: any) => tree.focusDrillUp(),\r\n  NEXT_NODE: (tree: TreeModel, node: TreeNode, $event: any) =>  tree.focusNextNode(),\r\n  PREVIOUS_NODE: (tree: TreeModel, node: TreeNode, $event: any) =>  tree.focusPreviousNode(),\r\n  MOVE_NODE: (tree: TreeModel, node: TreeNode, $event: any, {from , to}: {from: any, to: any}) => {\r\n    // default action assumes from = node, to = {parent, index}\r\n    if ($event.ctrlKey) {\r\n      tree.copyNode(from, to);\r\n    } else {\r\n      tree.moveNode(from, to);\r\n    }\r\n  }\r\n};\r\n\r\nconst defaultActionMapping: IActionMapping = {\r\n  mouse: {\r\n    click: TREE_ACTIONS.TOGGLE_ACTIVE,\r\n    dblClick: null,\r\n    contextMenu: null,\r\n    expanderClick: TREE_ACTIONS.TOGGLE_EXPANDED,\r\n    checkboxClick: TREE_ACTIONS.TOGGLE_SELECTED,\r\n    drop: TREE_ACTIONS.MOVE_NODE\r\n  },\r\n  keys: {\r\n    [KEYS.RIGHT]: TREE_ACTIONS.DRILL_DOWN,\r\n    [KEYS.LEFT]: TREE_ACTIONS.DRILL_UP,\r\n    [KEYS.DOWN]: TREE_ACTIONS.NEXT_NODE,\r\n    [KEYS.UP]: TREE_ACTIONS.PREVIOUS_NODE,\r\n    [KEYS.SPACE]: TREE_ACTIONS.TOGGLE_ACTIVE,\r\n    [KEYS.ENTER]: TREE_ACTIONS.TOGGLE_ACTIVE\r\n  }\r\n};\r\n\r\nexport interface IActionMapping {\r\n  mouse?: {\r\n    click?: IActionHandler,\r\n    dblClick?: IActionHandler,\r\n    contextMenu?: IActionHandler,\r\n    expanderClick?: IActionHandler,\r\n    checkboxClick?: IActionHandler,\r\n    dragStart?: IActionHandler,\r\n    drag?: IActionHandler,\r\n    dragEnd?: IActionHandler,\r\n    dragOver?: IActionHandler,\r\n    dragLeave?: IActionHandler,\r\n    dragEnter?: IActionHandler,\r\n    drop?: IActionHandler,\r\n    mouseOver?: IActionHandler,\r\n    mouseOut?: IActionHandler\r\n  };\r\n  keys?: {\r\n    [key: number]: IActionHandler\r\n  };\r\n}\r\n\r\nexport class TreeOptions {\r\n  get hasChildrenField(): string { return this.options.hasChildrenField || 'hasChildren'; }\r\n  get childrenField(): string { return this.options.childrenField || 'children'; }\r\n  get displayField(): string { return this.options.displayField || 'name'; }\r\n  get idField(): string { return this.options.idField || 'id'; }\r\n  get isExpandedField(): string { return this.options.isExpandedField || 'isExpanded'; }\r\n  get getChildren(): any { return this.options.getChildren; }\r\n  get levelPadding(): number { return this.options.levelPadding || 0; }\r\n  get useVirtualScroll(): boolean { return this.options.useVirtualScroll; }\r\n  get animateExpand(): boolean { return this.options.animateExpand; }\r\n  get animateSpeed(): number { return this.options.animateSpeed || 1; }\r\n  get animateAcceleration(): number { return this.options.animateAcceleration || 1.2; }\r\n  get scrollOnActivate(): boolean { return this.options.scrollOnActivate === undefined ? true : this.options.scrollOnActivate; }\r\n  get rtl(): boolean { return !!this.options.rtl; }\r\n  get rootId(): any {return this.options.rootId; }\r\n  get useCheckbox(): boolean { return this.options.useCheckbox; }\r\n  get useTriState(): boolean { return this.options.useTriState === undefined ? true : this.options.useTriState; }\r\n  get scrollContainer(): HTMLElement { return this.options.scrollContainer; }\r\n  get allowDragoverStyling(): boolean { return this.options.allowDragoverStyling === undefined ? true : this.options.allowDragoverStyling; }\r\n  actionMapping: IActionMapping;\r\n\r\n  constructor(private options: ITreeOptions = {}) {\r\n    this.actionMapping = {\r\n      mouse: {\r\n        click: this.options?.actionMapping?.mouse?.click ?? defaultActionMapping.mouse.click,\r\n        dblClick: this.options?.actionMapping?.mouse?.dblClick ?? defaultActionMapping.mouse.dblClick,\r\n        contextMenu: this.options?.actionMapping?.mouse?.contextMenu ?? defaultActionMapping.mouse.contextMenu,\r\n        expanderClick: this.options?.actionMapping?.mouse?.expanderClick ?? defaultActionMapping.mouse.expanderClick,\r\n        checkboxClick: this.options?.actionMapping?.mouse?.checkboxClick ?? defaultActionMapping.mouse.checkboxClick,\r\n        drop: this.options?.actionMapping?.mouse?.drop ?? defaultActionMapping.mouse.drop,\r\n        dragStart: this.options?.actionMapping?.mouse?.dragStart ?? undefined,\r\n        drag: this.options?.actionMapping?.mouse?.drag ?? undefined,\r\n        dragEnd: this.options?.actionMapping?.mouse?.dragEnd ?? undefined,\r\n        dragOver: this.options?.actionMapping?.mouse?.dragOver ?? undefined,\r\n        dragLeave: this.options?.actionMapping?.mouse?.dragLeave ?? undefined,\r\n        dragEnter: this.options?.actionMapping?.mouse?.dragEnter ?? undefined,\r\n        mouseOver: this.options?.actionMapping?.mouse?.mouseOver ?? undefined,\r\n        mouseOut: this.options?.actionMapping?.mouse?.mouseOut ?? undefined,\r\n      },\r\n      keys: {\r\n        [KEYS.RIGHT]: TREE_ACTIONS.DRILL_DOWN,\r\n        [KEYS.LEFT]: TREE_ACTIONS.DRILL_UP,\r\n        [KEYS.DOWN]: TREE_ACTIONS.NEXT_NODE,\r\n        [KEYS.UP]: TREE_ACTIONS.PREVIOUS_NODE,\r\n        [KEYS.SPACE]: TREE_ACTIONS.TOGGLE_ACTIVE,\r\n        [KEYS.ENTER]: TREE_ACTIONS.TOGGLE_ACTIVE\r\n      }\r\n    }\r\n\r\n    if (this.options?.actionMapping?.keys) {\r\n      this.actionMapping.keys = {\r\n        ...this.actionMapping.keys,\r\n        ...this.options.actionMapping.keys\r\n      }\r\n    }\r\n\r\n    if (options.rtl) {\r\n      this.actionMapping.keys[KEYS.RIGHT] = <IActionHandler>options.actionMapping?.keys[KEYS.RIGHT] || TREE_ACTIONS.DRILL_UP;\r\n      this.actionMapping.keys[KEYS.LEFT] = <IActionHandler>options.actionMapping?.keys[KEYS.LEFT] || TREE_ACTIONS.DRILL_DOWN;\r\n    }\r\n  }\r\n\r\n  getNodeClone(node: TreeNode): any {\r\n    if (this.options.getNodeClone) {\r\n      return this.options.getNodeClone(node);\r\n    }\r\n\r\n    // remove id from clone\r\n    // keeping ie11 compatibility\r\n    const nodeClone = Object.assign({}, node.data);\r\n    if (nodeClone.id) {\r\n      delete nodeClone.id;\r\n    }\r\n    return nodeClone;\r\n  }\r\n\r\n  allowDrop(element, to, $event?): boolean {\r\n    if (this.options.allowDrop instanceof Function) {\r\n      return this.options.allowDrop(element, to, $event);\r\n    }\r\n    else {\r\n      return this.options.allowDrop === undefined ? true : this.options.allowDrop;\r\n    }\r\n  }\r\n\r\n  allowDrag(node: TreeNode): boolean {\r\n    if (this.options.allowDrag instanceof Function) {\r\n      return this.options.allowDrag(node);\r\n    } else {\r\n      return this.options.allowDrag;\r\n    }\r\n  }\r\n\r\n  nodeClass(node: TreeNode): string {\r\n    return this.options.nodeClass ? this.options.nodeClass(node) : '';\r\n  }\r\n\r\n  nodeHeight(node: TreeNode): number {\r\n    if (node.data.virtual) {\r\n      return 0;\r\n    }\r\n\r\n    let nodeHeight = this.options.nodeHeight || 22;\r\n\r\n    if (typeof nodeHeight === 'function') {\r\n      nodeHeight = nodeHeight(node);\r\n    }\r\n\r\n    // account for drop slots:\r\n    return nodeHeight + (node.index === 0 ?  2 : 1) * this.dropSlotHeight;\r\n  }\r\n\r\n  get dropSlotHeight(): number {\r\n    return typeof this.options.dropSlotHeight === 'number' ? this.options.dropSlotHeight : 2;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/models/tree-virtual-scroll.model.mjs

@@ -0,0 +1,197 @@
+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, reaction } from 'mobx';
+import { TREE_EVENTS } from '../constants/events';
+import * as i0 from "@angular/core";
+import * as i1 from "./tree.model";
+const Y_OFFSET = 500; // Extra pixels outside the viewport, in each direction, to render nodes in
+const Y_EPSILON = 150; // Minimum pixel change required to recalculate the rendered nodes
+export class TreeVirtualScroll {
+    get y() {
+        return this.yBlocks * Y_EPSILON;
+    }
+    get totalHeight() {
+        return this.treeModel.virtualRoot ? this.treeModel.virtualRoot.height : 0;
+    }
+    constructor(treeModel) {
+        this.treeModel = treeModel;
+        this.yBlocks = 0;
+        this.x = 0;
+        this.viewportHeight = null;
+        this.viewport = null;
+        treeModel.virtualScroll = this;
+        this._dispose = [autorun(() => this.fixScroll())];
+    }
+    fireEvent(event) {
+        this.treeModel.fireEvent(event);
+    }
+    init() {
+        const fn = this.recalcPositions.bind(this);
+        fn();
+        this._dispose = [
+            ...this._dispose,
+            reaction(() => this.treeModel.roots, fn),
+            reaction(() => this.treeModel.expandedNodeIds, fn),
+            reaction(() => this.treeModel.hiddenNodeIds, fn)
+        ];
+        this.treeModel.subscribe(TREE_EVENTS.loadNodeChildren, fn);
+    }
+    isEnabled() {
+        return this.treeModel.options.useVirtualScroll;
+    }
+    _setYBlocks(value) {
+        this.yBlocks = value;
+    }
+    recalcPositions() {
+        this.treeModel.virtualRoot.height = this._getPositionAfter(this.treeModel.getVisibleRoots(), 0);
+    }
+    _getPositionAfter(nodes, startPos) {
+        let position = startPos;
+        nodes.forEach((node) => {
+            node.position = position;
+            position = this._getPositionAfterNode(node, position);
+        });
+        return position;
+    }
+    _getPositionAfterNode(node, startPos) {
+        let position = node.getSelfHeight() + startPos;
+        if (node.children && node.isExpanded) { // TBD: consider loading component as well
+            position = this._getPositionAfter(node.visibleChildren, position);
+        }
+        node.height = position - startPos;
+        return position;
+    }
+    clear() {
+        this._dispose.forEach((d) => d());
+    }
+    setViewport(viewport) {
+        Object.assign(this, {
+            viewport,
+            x: viewport.scrollLeft,
+            yBlocks: Math.round(viewport.scrollTop / Y_EPSILON),
+            viewportHeight: viewport.getBoundingClientRect ? viewport.getBoundingClientRect().height : 0
+        });
+    }
+    scrollIntoView(node, force, scrollToMiddle = true) {
+        if (node.options.scrollContainer) {
+            const scrollContainer = node.options.scrollContainer;
+            const scrollContainerHeight = scrollContainer.getBoundingClientRect().height;
+            const scrollContainerTop = scrollContainer.getBoundingClientRect().top;
+            const nodeTop = this.viewport.getBoundingClientRect().top + node.position - scrollContainerTop;
+            if (force || // force scroll to node
+                nodeTop < scrollContainer.scrollTop || // node is above scroll container
+                nodeTop + node.getSelfHeight() > scrollContainer.scrollTop + scrollContainerHeight) { // node is below container
+                scrollContainer.scrollTop = scrollToMiddle ?
+                    nodeTop - scrollContainerHeight / 2 : // scroll to middle
+                    nodeTop; // scroll to start
+            }
+        }
+        else {
+            if (force || // force scroll to node
+                node.position < this.y || // node is above viewport
+                node.position + node.getSelfHeight() > this.y + this.viewportHeight) { // node is below viewport
+                if (this.viewport) {
+                    this.viewport.scrollTop = scrollToMiddle ?
+                        node.position - this.viewportHeight / 2 : // scroll to middle
+                        node.position; // scroll to start
+                    this._setYBlocks(Math.floor(this.viewport.scrollTop / Y_EPSILON));
+                }
+            }
+        }
+    }
+    getViewportNodes(nodes) {
+        if (!nodes)
+            return [];
+        const visibleNodes = nodes.filter((node) => !node.isHidden);
+        if (!this.isEnabled())
+            return visibleNodes;
+        if (!this.viewportHeight || !visibleNodes.length)
+            return [];
+        // When loading children async this method is called before their height and position is calculated.
+        // In that case firstIndex === 0 and lastIndex === visibleNodes.length - 1 (e.g. 1000),
+        // which means that it loops through every visibleNodes item and push them into viewportNodes array.
+        // We can prevent nodes from being pushed to the array and wait for the appropriate calculations to take place
+        const lastVisibleNode = visibleNodes.slice(-1)[0];
+        if (!lastVisibleNode.height && lastVisibleNode.position === 0)
+            return [];
+        // Search for first node in the viewport using binary search
+        // Look for first node that starts after the beginning of the viewport (with buffer)
+        // Or that ends after the beginning of the viewport
+        const firstIndex = binarySearch(visibleNodes, (node) => {
+            return (node.position + Y_OFFSET > this.y) ||
+                (node.position + node.height > this.y);
+        });
+        // Search for last node in the viewport using binary search
+        // Look for first node that starts after the end of the viewport (with buffer)
+        const lastIndex = binarySearch(visibleNodes, (node) => {
+            return node.position - Y_OFFSET > this.y + this.viewportHeight;
+        }, firstIndex);
+        const viewportNodes = [];
+        for (let i = firstIndex; i <= lastIndex; i++) {
+            viewportNodes.push(visibleNodes[i]);
+        }
+        return viewportNodes;
+    }
+    fixScroll() {
+        const maxY = Math.max(0, this.totalHeight - this.viewportHeight);
+        if (this.y < 0)
+            this._setYBlocks(0);
+        if (this.y > maxY)
+            this._setYBlocks(maxY / Y_EPSILON);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TreeVirtualScroll, deps: [{ token: i1.TreeModel }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TreeVirtualScroll }); }
+}
+__decorate([
+    observable
+], TreeVirtualScroll.prototype, "yBlocks", void 0);
+__decorate([
+    observable
+], TreeVirtualScroll.prototype, "x", void 0);
+__decorate([
+    observable
+], TreeVirtualScroll.prototype, "viewportHeight", void 0);
+__decorate([
+    computed
+], TreeVirtualScroll.prototype, "y", null);
+__decorate([
+    computed
+], TreeVirtualScroll.prototype, "totalHeight", null);
+__decorate([
+    action
+], TreeVirtualScroll.prototype, "_setYBlocks", null);
+__decorate([
+    action
+], TreeVirtualScroll.prototype, "recalcPositions", null);
+__decorate([
+    action
+], TreeVirtualScroll.prototype, "setViewport", null);
+__decorate([
+    action
+], TreeVirtualScroll.prototype, "scrollIntoView", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TreeVirtualScroll, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.TreeModel }]; }, propDecorators: { yBlocks: [], x: [], viewportHeight: [], y: [], totalHeight: [], _setYBlocks: [], recalcPositions: [], setViewport: [], scrollIntoView: [] } });
+function binarySearch(nodes, condition, firstIndex = 0) {
+    let index = firstIndex;
+    let toIndex = nodes.length - 1;
+    while (index !== toIndex) {
+        let midIndex = Math.floor((index + toIndex) / 2);
+        if (condition(nodes[midIndex])) {
+            toIndex = midIndex;
+        }
+        else {
+            if (index === midIndex)
+                index = toIndex;
+            else
+                index = midIndex;
+        }
+    }
+    return index;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-virtual-scroll.model.js","sourceRoot":"","sources":["../../../../../projects/angular-tree-component/src/lib/models/tree-virtual-scroll.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { observable, computed, action, autorun, reaction } from 'mobx';\r\nimport { TreeModel } from './tree.model';\r\nimport { TREE_EVENTS } from '../constants/events';\r\n\r\nconst Y_OFFSET = 500; // Extra pixels outside the viewport, in each direction, to render nodes in\r\nconst Y_EPSILON = 150; // Minimum pixel change required to recalculate the rendered nodes\r\n\r\n@Injectable()\r\nexport class TreeVirtualScroll {\r\n  private _dispose: any;\r\n\r\n  @observable yBlocks = 0;\r\n  @observable x = 0;\r\n  @observable viewportHeight = null;\r\n  viewport = null;\r\n\r\n  @computed get y() {\r\n    return this.yBlocks * Y_EPSILON;\r\n  }\r\n\r\n  @computed get totalHeight() {\r\n    return this.treeModel.virtualRoot ? this.treeModel.virtualRoot.height : 0;\r\n  }\r\n\r\n  constructor(private treeModel: TreeModel) {\r\n    treeModel.virtualScroll = this;\r\n    this._dispose = [autorun(() => this.fixScroll())];\r\n  }\r\n\r\n  fireEvent(event) {\r\n    this.treeModel.fireEvent(event);\r\n  }\r\n\r\n  init() {\r\n    const fn = this.recalcPositions.bind(this);\r\n\r\n    fn();\r\n    this._dispose = [\r\n      ...this._dispose,\r\n      reaction(() => this.treeModel.roots, fn),\r\n      reaction(() => this.treeModel.expandedNodeIds, fn),\r\n      reaction(() => this.treeModel.hiddenNodeIds, fn)\r\n    ];\r\n    this.treeModel.subscribe(TREE_EVENTS.loadNodeChildren, fn);\r\n  }\r\n\r\n  isEnabled() {\r\n    return this.treeModel.options.useVirtualScroll;\r\n  }\r\n\r\n  @action private _setYBlocks(value) {\r\n    this.yBlocks = value;\r\n  }\r\n\r\n  @action recalcPositions() {\r\n    this.treeModel.virtualRoot.height = this._getPositionAfter(this.treeModel.getVisibleRoots(), 0);\r\n  }\r\n\r\n  private _getPositionAfter(nodes, startPos) {\r\n    let position = startPos;\r\n\r\n    nodes.forEach((node) => {\r\n      node.position = position;\r\n      position = this._getPositionAfterNode(node, position);\r\n    });\r\n    return position;\r\n  }\r\n\r\n  private _getPositionAfterNode(node, startPos) {\r\n    let position = node.getSelfHeight() + startPos;\r\n\r\n    if (node.children && node.isExpanded) { // TBD: consider loading component as well\r\n      position = this._getPositionAfter(node.visibleChildren, position);\r\n    }\r\n    node.height = position - startPos;\r\n    return position;\r\n  }\r\n\r\n\r\n  clear() {\r\n    this._dispose.forEach((d) => d());\r\n  }\r\n\r\n  @action setViewport(viewport) {\r\n    Object.assign(this, {\r\n      viewport,\r\n      x: viewport.scrollLeft,\r\n      yBlocks: Math.round(viewport.scrollTop / Y_EPSILON),\r\n      viewportHeight: viewport.getBoundingClientRect ? viewport.getBoundingClientRect().height : 0\r\n    });\r\n  }\r\n\r\n  @action scrollIntoView(node, force, scrollToMiddle = true) {\r\n    if (node.options.scrollContainer) {\r\n      const scrollContainer = node.options.scrollContainer;\r\n      const scrollContainerHeight = scrollContainer.getBoundingClientRect().height;\r\n      const scrollContainerTop = scrollContainer.getBoundingClientRect().top;\r\n      const nodeTop = this.viewport.getBoundingClientRect().top + node.position - scrollContainerTop;\r\n\r\n      if (force || // force scroll to node\r\n        nodeTop < scrollContainer.scrollTop || // node is above scroll container\r\n        nodeTop + node.getSelfHeight() > scrollContainer.scrollTop + scrollContainerHeight) { // node is below container\r\n        scrollContainer.scrollTop = scrollToMiddle ?\r\n          nodeTop - scrollContainerHeight / 2 : // scroll to middle\r\n          nodeTop; // scroll to start\r\n      }\r\n    } else {\r\n      if (force || // force scroll to node\r\n        node.position < this.y || // node is above viewport\r\n        node.position + node.getSelfHeight() > this.y + this.viewportHeight) { // node is below viewport\r\n        if (this.viewport) {\r\n          this.viewport.scrollTop = scrollToMiddle ?\r\n          node.position - this.viewportHeight / 2 : // scroll to middle\r\n          node.position; // scroll to start\r\n\r\n          this._setYBlocks(Math.floor(this.viewport.scrollTop / Y_EPSILON));\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  getViewportNodes(nodes) {\r\n    if (!nodes) return [];\r\n\r\n    const visibleNodes = nodes.filter((node) => !node.isHidden);\r\n\r\n    if (!this.isEnabled()) return visibleNodes;\r\n\r\n    if (!this.viewportHeight || !visibleNodes.length) return [];\r\n\r\n    // When loading children async this method is called before their height and position is calculated.\r\n    // In that case firstIndex === 0 and lastIndex === visibleNodes.length - 1 (e.g. 1000),\r\n    // which means that it loops through every visibleNodes item and push them into viewportNodes array.\r\n    // We can prevent nodes from being pushed to the array and wait for the appropriate calculations to take place\r\n    const lastVisibleNode = visibleNodes.slice(-1)[0]\r\n    if (!lastVisibleNode.height && lastVisibleNode.position === 0) return [];\r\n\r\n    // Search for first node in the viewport using binary search\r\n    // Look for first node that starts after the beginning of the viewport (with buffer)\r\n    // Or that ends after the beginning of the viewport\r\n    const firstIndex = binarySearch(visibleNodes, (node) => {\r\n      return (node.position + Y_OFFSET > this.y) ||\r\n             (node.position + node.height > this.y);\r\n    });\r\n\r\n    // Search for last node in the viewport using binary search\r\n    // Look for first node that starts after the end of the viewport (with buffer)\r\n    const lastIndex = binarySearch(visibleNodes, (node) => {\r\n      return node.position - Y_OFFSET > this.y + this.viewportHeight;\r\n    }, firstIndex);\r\n\r\n    const viewportNodes = [];\r\n\r\n    for (let i = firstIndex; i <= lastIndex; i++) {\r\n      viewportNodes.push(visibleNodes[i]);\r\n    }\r\n\r\n    return viewportNodes;\r\n  }\r\n\r\n  fixScroll() {\r\n    const maxY = Math.max(0, this.totalHeight - this.viewportHeight);\r\n\r\n    if (this.y < 0) this._setYBlocks(0);\r\n    if (this.y > maxY) this._setYBlocks(maxY / Y_EPSILON);\r\n  }\r\n}\r\n\r\nfunction binarySearch(nodes, condition, firstIndex = 0) {\r\n  let index = firstIndex;\r\n  let toIndex = nodes.length - 1;\r\n\r\n  while (index !== toIndex) {\r\n    let midIndex = Math.floor((index + toIndex) / 2);\r\n\r\n    if (condition(nodes[midIndex])) {\r\n      toIndex = midIndex;\r\n    }\r\n    else {\r\n      if (index === midIndex) index = toIndex;\r\n      else index = midIndex;\r\n    }\r\n  }\r\n  return index;\r\n}\r\n"]}