@itwin/components-react 3.5.0-dev.14 → 3.5.0-dev.18

package/lib/esm/components-react/tree/controlled/TreeActions.d.ts

@@ -1,21 +1,21 @@
-/** @packageDocumentation
- * @module Tree
- */
-/// <reference types="react" />
-import { CheckBoxState } from "@itwin/core-react";
-/**
- * Tree actions that can be performed on tree.
- * @public
- */
-export interface TreeActions {
-    onNodeCheckboxClicked: (nodeId: string, newState: CheckBoxState) => void;
-    onNodeExpanded: (nodeId: string) => void;
-    onNodeCollapsed: (nodeId: string) => void;
-    onNodeClicked: (nodeId: string, event: React.MouseEvent) => void;
-    onNodeMouseDown: (nodeId: string) => void;
-    onNodeMouseMove: (nodeId: string) => void;
-    onNodeEditorActivated: (nodeId: string) => void;
-    onTreeKeyDown: (event: React.KeyboardEvent) => void;
-    onTreeKeyUp: (event: React.KeyboardEvent) => void;
-}
+/** @packageDocumentation
+ * @module Tree
+ */
+/// <reference types="react" />
+import { CheckBoxState } from "@itwin/core-react";
+/**
+ * Tree actions that can be performed on tree.
+ * @public
+ */
+export interface TreeActions {
+    onNodeCheckboxClicked: (nodeId: string, newState: CheckBoxState) => void;
+    onNodeExpanded: (nodeId: string) => void;
+    onNodeCollapsed: (nodeId: string) => void;
+    onNodeClicked: (nodeId: string, event: React.MouseEvent) => void;
+    onNodeMouseDown: (nodeId: string) => void;
+    onNodeMouseMove: (nodeId: string) => void;
+    onNodeEditorActivated: (nodeId: string) => void;
+    onTreeKeyDown: (event: React.KeyboardEvent) => void;
+    onTreeKeyUp: (event: React.KeyboardEvent) => void;
+}
 //# sourceMappingURL=TreeActions.d.ts.map

package/lib/esm/components-react/tree/controlled/TreeActions.js

@@ -1,9 +1,9 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Tree
- */
-export {};
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Tree
+ */
+export {};
 //# sourceMappingURL=TreeActions.js.map

package/lib/esm/components-react/tree/controlled/TreeActions.js.map

@@ -1 +1 @@
-{"version":3,"file":"TreeActions.js","sourceRoot":"","sources":["../../../../../src/components-react/tree/controlled/TreeActions.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Tree\n */\n\nimport { CheckBoxState } from \"@itwin/core-react\";\n\n/**\n * Tree actions that can be performed on tree.\n * @public\n */\nexport interface TreeActions {\n  onNodeCheckboxClicked: (nodeId: string, newState: CheckBoxState) => void;\n  onNodeExpanded: (nodeId: string) => void;\n  onNodeCollapsed: (nodeId: string) => void;\n  onNodeClicked: (nodeId: string, event: React.MouseEvent) => void;\n  onNodeMouseDown: (nodeId: string) => void;\n  onNodeMouseMove: (nodeId: string) => void;\n  onNodeEditorActivated: (nodeId: string) => void;\n  onTreeKeyDown: (event: React.KeyboardEvent) => void;\n  onTreeKeyUp: (event: React.KeyboardEvent) => void;\n}\n"]}
+{"version":3,"file":"TreeActions.js","sourceRoot":"","sources":["../../../../../src/components-react/tree/controlled/TreeActions.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F;;GAEG","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Tree\r\n */\r\n\r\nimport { CheckBoxState } from \"@itwin/core-react\";\r\n\r\n/**\r\n * Tree actions that can be performed on tree.\r\n * @public\r\n */\r\nexport interface TreeActions {\r\n  onNodeCheckboxClicked: (nodeId: string, newState: CheckBoxState) => void;\r\n  onNodeExpanded: (nodeId: string) => void;\r\n  onNodeCollapsed: (nodeId: string) => void;\r\n  onNodeClicked: (nodeId: string, event: React.MouseEvent) => void;\r\n  onNodeMouseDown: (nodeId: string) => void;\r\n  onNodeMouseMove: (nodeId: string) => void;\r\n  onNodeEditorActivated: (nodeId: string) => void;\r\n  onTreeKeyDown: (event: React.KeyboardEvent) => void;\r\n  onTreeKeyUp: (event: React.KeyboardEvent) => void;\r\n}\r\n"]}

package/lib/esm/components-react/tree/controlled/TreeEventDispatcher.d.ts

@@ -1,39 +1,39 @@
-/** @packageDocumentation
- * @module Tree
- */
-/// <reference types="react" />
-import { CheckBoxState } from "@itwin/core-react";
-import { SelectionMode } from "../../common/selection/SelectionModes";
-import { TreeActions } from "./TreeActions";
-import { TreeEvents } from "./TreeEvents";
-import { VisibleTreeNodes } from "./TreeModel";
-import { ITreeNodeLoader } from "./TreeNodeLoader";
-/**
- * Default event dispatcher that emits tree events according performed actions.
- * It converts low level tree events into TreeEvents.
- * @internal
- */
-export declare class TreeEventDispatcher implements TreeActions {
-    private _treeEvents;
-    private _nodeLoader;
-    private _getVisibleNodes;
-    private _selectionManager;
-    private _activeSelections;
-    constructor(treeEvents: TreeEvents, nodeLoader: ITreeNodeLoader, selectionMode: SelectionMode, getVisibleNodes?: () => VisibleTreeNodes);
-    setVisibleNodes(visibleNodes: () => VisibleTreeNodes): void;
-    onNodeCheckboxClicked(nodeId: string, newState: CheckBoxState): void;
-    onNodeExpanded(nodeId: string): void;
-    onNodeCollapsed(nodeId: string): void;
-    onNodeClicked(nodeId: string, event: React.MouseEvent<Element, MouseEvent>): void;
-    onNodeMouseDown(nodeId: string): void;
-    onNodeMouseMove(nodeId: string): void;
-    onNodeEditorActivated(nodeId: string): void;
-    onTreeKeyDown(event: React.KeyboardEvent): void;
-    onTreeKeyUp(event: React.KeyboardEvent): void;
-    private collectSelectionChanges;
-    private collectNodesBetween;
-    private iterateNodesBetween;
-    private collectNodeItems;
-    private static groupNodesByLoadingState;
-}
+/** @packageDocumentation
+ * @module Tree
+ */
+/// <reference types="react" />
+import { CheckBoxState } from "@itwin/core-react";
+import { SelectionMode } from "../../common/selection/SelectionModes";
+import { TreeActions } from "./TreeActions";
+import { TreeEvents } from "./TreeEvents";
+import { VisibleTreeNodes } from "./TreeModel";
+import { ITreeNodeLoader } from "./TreeNodeLoader";
+/**
+ * Default event dispatcher that emits tree events according performed actions.
+ * It converts low level tree events into TreeEvents.
+ * @internal
+ */
+export declare class TreeEventDispatcher implements TreeActions {
+    private _treeEvents;
+    private _nodeLoader;
+    private _getVisibleNodes;
+    private _selectionManager;
+    private _activeSelections;
+    constructor(treeEvents: TreeEvents, nodeLoader: ITreeNodeLoader, selectionMode: SelectionMode, getVisibleNodes?: () => VisibleTreeNodes);
+    setVisibleNodes(visibleNodes: () => VisibleTreeNodes): void;
+    onNodeCheckboxClicked(nodeId: string, newState: CheckBoxState): void;
+    onNodeExpanded(nodeId: string): void;
+    onNodeCollapsed(nodeId: string): void;
+    onNodeClicked(nodeId: string, event: React.MouseEvent<Element, MouseEvent>): void;
+    onNodeMouseDown(nodeId: string): void;
+    onNodeMouseMove(nodeId: string): void;
+    onNodeEditorActivated(nodeId: string): void;
+    onTreeKeyDown(event: React.KeyboardEvent): void;
+    onTreeKeyUp(event: React.KeyboardEvent): void;
+    private collectSelectionChanges;
+    private collectNodesBetween;
+    private iterateNodesBetween;
+    private collectNodeItems;
+    private static groupNodesByLoadingState;
+}
 //# sourceMappingURL=TreeEventDispatcher.d.ts.map

package/lib/esm/components-react/tree/controlled/TreeEventDispatcher.js

@@ -1,221 +1,221 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Tree
- */
-import { concat } from "rxjs/internal/observable/concat";
-import { defer } from "rxjs/internal/observable/defer";
-import { EMPTY } from "rxjs/internal/observable/empty";
-import { from } from "rxjs/internal/observable/from";
-import { generate } from "rxjs/internal/observable/generate";
-import { merge } from "rxjs/internal/observable/merge";
-import { of } from "rxjs/internal/observable/of";
-import { zip } from "rxjs/internal/observable/zip";
-import { concatAll } from "rxjs/internal/operators/concatAll";
-import { concatMap } from "rxjs/internal/operators/concatMap";
-import { defaultIfEmpty } from "rxjs/internal/operators/defaultIfEmpty";
-import { distinctUntilChanged } from "rxjs/internal/operators/distinctUntilChanged";
-import { filter } from "rxjs/internal/operators/filter";
-import { finalize } from "rxjs/internal/operators/finalize";
-import { map } from "rxjs/internal/operators/map";
-import { mergeAll } from "rxjs/internal/operators/mergeAll";
-import { publishReplay } from "rxjs/internal/operators/publishReplay";
-import { refCount } from "rxjs/internal/operators/refCount";
-import { subscribeOn } from "rxjs/internal/operators/subscribeOn";
-import { toArray } from "rxjs/internal/operators/toArray";
-import { asapScheduler } from "rxjs/internal/scheduler/asap";
-import { isRangeSelection, TreeSelectionManager } from "./internal/TreeSelectionManager";
-import { isTreeModelNode } from "./TreeModel";
-/**
- * Default event dispatcher that emits tree events according performed actions.
- * It converts low level tree events into TreeEvents.
- * @internal
- */
-export class TreeEventDispatcher {
-    constructor(treeEvents, nodeLoader, selectionMode, getVisibleNodes) {
-        this._activeSelections = new Set();
-        this._treeEvents = treeEvents;
-        this._nodeLoader = nodeLoader;
-        this._getVisibleNodes = getVisibleNodes;
-        this._selectionManager = new TreeSelectionManager(selectionMode, this._getVisibleNodes);
-        this._selectionManager.onDragSelection.addListener(({ selectionChanges }) => {
-            const modifications = from(selectionChanges)
-                .pipe(map(({ selectedNodes, deselectedNodes }) => from(this.collectSelectionChanges(selectedNodes, []))
-                .pipe(concatMap(({ selectedNodeItems }) => from(selectedNodeItems)), toArray(), map((collectedIds) => ({ selectedNodeItems: collectedIds, deselectedNodeItems: this.collectNodeItems(deselectedNodes) })))), concatAll(), publishReplay(), refCount());
-            /* istanbul ignore else */
-            if (this._treeEvents.onSelectionModified !== undefined)
-                this._treeEvents.onSelectionModified({ modifications });
-        });
-        this._selectionManager.onSelectionChanged.addListener(({ selectedNodes, deselectedNodes }) => {
-            const modifications = merge(defer(() => {
-                this._activeSelections.add(modifications);
-                return EMPTY;
-            }), this.collectSelectionChanges(selectedNodes, deselectedNodes))
-                .pipe(finalize(() => {
-                this._activeSelections.delete(modifications);
-            }), publishReplay(), refCount());
-            /* istanbul ignore else */
-            if (this._treeEvents.onSelectionModified !== undefined)
-                this._treeEvents.onSelectionModified({ modifications });
-        });
-        this._selectionManager.onSelectionReplaced.addListener(({ selectedNodeIds }) => {
-            const replacements = merge(defer(() => {
-                this._activeSelections.add(replacements);
-                return EMPTY;
-            }), this.collectSelectionChanges(selectedNodeIds, []))
-                .pipe(finalize(() => {
-                this._activeSelections.delete(replacements);
-            }), publishReplay(), refCount());
-            /* istanbul ignore else */
-            if (this._treeEvents.onSelectionReplaced !== undefined)
-                this._treeEvents.onSelectionReplaced({ replacements });
-        });
-    }
-    setVisibleNodes(visibleNodes) {
-        this._getVisibleNodes = visibleNodes;
-        this._selectionManager.setVisibleNodes(visibleNodes);
-    }
-    onNodeCheckboxClicked(nodeId, newState) {
-        if (this._getVisibleNodes === undefined)
-            return;
-        const visibleNodes = this._getVisibleNodes();
-        const clickedNode = visibleNodes.getModel().getNode(nodeId);
-        if (clickedNode === undefined)
-            return;
-        const immediateStateChanges = [{ nodeItem: clickedNode.item, newState }];
-        if (clickedNode.isSelected) {
-            for (const node of visibleNodes) {
-                if (isTreeModelNode(node) && node.id !== clickedNode.id && node.isSelected && node.checkbox.state !== newState) {
-                    immediateStateChanges.push({ nodeItem: node.item, newState });
-                }
-            }
-        }
-        const stateChanges = concat(of(immediateStateChanges), from(this._activeSelections)
-            .pipe(mergeAll(), map(({ selectedNodeItems }) => selectedNodeItems.map((item) => ({ nodeItem: item, newState })))))
-            .pipe(publishReplay(), refCount());
-        /* istanbul ignore else */
-        if (this._treeEvents.onCheckboxStateChanged !== undefined)
-            this._treeEvents.onCheckboxStateChanged({ stateChanges });
-    }
-    onNodeExpanded(nodeId) {
-        /* istanbul ignore else */
-        if (this._treeEvents.onNodeExpanded !== undefined)
-            this._treeEvents.onNodeExpanded({ nodeId });
-    }
-    onNodeCollapsed(nodeId) {
-        /* istanbul ignore else */
-        if (this._treeEvents.onNodeCollapsed !== undefined)
-            this._treeEvents.onNodeCollapsed({ nodeId });
-    }
-    onNodeClicked(nodeId, event) {
-        const node = this._getVisibleNodes ? this._getVisibleNodes().getModel().getNode(nodeId) : undefined;
-        const isNodeSelected = node ? node.isSelected : false;
-        this._selectionManager.onNodeClicked(nodeId, event);
-        // if clicked node was already selected fire delayed click event
-        if (isNodeSelected && this._treeEvents.onDelayedNodeClick !== undefined) {
-            this._treeEvents.onDelayedNodeClick({ nodeId });
-        }
-    }
-    onNodeMouseDown(nodeId) {
-        this._selectionManager.onNodeMouseDown(nodeId);
-    }
-    onNodeMouseMove(nodeId) {
-        this._selectionManager.onNodeMouseMove(nodeId);
-    }
-    onNodeEditorActivated(nodeId) {
-        const node = this._getVisibleNodes ? this._getVisibleNodes().getModel().getNode(nodeId) : /* istanbul ignore next */ undefined;
-        const isNodeSelected = node ? node.isSelected : false;
-        // if node was already selected, fire onNodeEditorActivated event
-        if (isNodeSelected && this._treeEvents.onNodeEditorActivated !== undefined) {
-            this._treeEvents.onNodeEditorActivated({ nodeId });
-        }
-    }
-    onTreeKeyDown(event) {
-        this._selectionManager.onTreeKeyDown(event, this);
-    }
-    onTreeKeyUp(event) {
-        this._selectionManager.onTreeKeyUp(event, this);
-    }
-    collectSelectionChanges(selection, deselection) {
-        const deselectedItems = this.collectNodeItems(deselection);
-        if (isRangeSelection(selection)) {
-            return zip(this.collectNodesBetween(selection.from, selection.to).pipe(defaultIfEmpty([])), 
-            // Without a scheduler `generate` would block the main thread indefinitely
-            generate({ initialState: deselectedItems, iterate: () => [], scheduler: asapScheduler })).pipe(map(([selectedNodeItems, deselectedNodeItems]) => ({ selectedNodeItems, deselectedNodeItems })));
-        }
-        const selectedItems = this.collectNodeItems(selection);
-        return of({ selectedNodeItems: selectedItems, deselectedNodeItems: deselectedItems });
-    }
-    collectNodesBetween(nodeId1, nodeId2) {
-        const [readyNodes, nodesToLoad] = TreeEventDispatcher.groupNodesByLoadingState(this.iterateNodesBetween(nodeId1, nodeId2));
-        const loadedSelectedNodes = from(nodesToLoad.map((node) => {
-            const parentNode = node.parentId
-                ? this._getVisibleNodes().getModel().getNode(node.parentId)
-                : this._getVisibleNodes().getModel().getRootNode();
-            return parentNode ? this._nodeLoader.loadNode(parentNode, node.childIndex) : /* istanbul ignore next */ EMPTY;
-        }))
-            .pipe(
-        // We have requested multiple nodes that may belong to the same page.
-        // When the page loads we only want to process the loaded nodes once.
-        // Making assumption that loaded nodes from the same page will be emitted without interruptions.
-        // Maybe we could simplify this to `this._nodeLoader.loadNodes(nodesToLoad)`?
-        mergeAll(), distinctUntilChanged());
-        return concat(of(readyNodes.filter((node) => !node.isSelectionDisabled).map((node) => node.item)), loadedSelectedNodes.pipe(map(({ loadedNodes }) => loadedNodes.filter((item) => !item.isSelectionDisabled)))).pipe(filter((nodeItems) => nodeItems.length > 0), 
-        // Give enough time for multiple subscribers to subscribe before any emissions begin
-        subscribeOn(asapScheduler));
-    }
-    *iterateNodesBetween(nodeId1, nodeId2) {
-        let firstNodeFound = false;
-        if (this._getVisibleNodes === undefined) {
-            return;
-        }
-        for (const node of this._getVisibleNodes()) {
-            if (firstNodeFound) {
-                yield node;
-            }
-            if (isTreeModelNode(node)) {
-                if (nodeId1 === nodeId2 && node.id === nodeId1) {
-                    yield node;
-                    return;
-                }
-                if (node.id === nodeId1 || node.id === nodeId2) {
-                    if (firstNodeFound) {
-                        return;
-                    }
-                    firstNodeFound = true;
-                    yield node;
-                }
-            }
-        }
-    }
-    collectNodeItems(nodeIds) {
-        const items = [];
-        if (this._getVisibleNodes === undefined) {
-            return items;
-        }
-        for (const nodeId of nodeIds) {
-            const node = this._getVisibleNodes().getModel().getNode(nodeId);
-            // istanbul ignore else
-            if (node !== undefined && !node.isSelectionDisabled) {
-                items.push(node.item);
-            }
-        }
-        return items;
-    }
-    static groupNodesByLoadingState(nodes) {
-        const loadedNodeItems = [];
-        const nodesToLoad = [];
-        for (const node of nodes) {
-            if (isTreeModelNode(node)) {
-                loadedNodeItems.push(node);
-            }
-            else {
-                nodesToLoad.push(node);
-            }
-        }
-        return [loadedNodeItems, nodesToLoad];
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Tree
+ */
+import { concat } from "rxjs/internal/observable/concat";
+import { defer } from "rxjs/internal/observable/defer";
+import { EMPTY } from "rxjs/internal/observable/empty";
+import { from } from "rxjs/internal/observable/from";
+import { generate } from "rxjs/internal/observable/generate";
+import { merge } from "rxjs/internal/observable/merge";
+import { of } from "rxjs/internal/observable/of";
+import { zip } from "rxjs/internal/observable/zip";
+import { concatAll } from "rxjs/internal/operators/concatAll";
+import { concatMap } from "rxjs/internal/operators/concatMap";
+import { defaultIfEmpty } from "rxjs/internal/operators/defaultIfEmpty";
+import { distinctUntilChanged } from "rxjs/internal/operators/distinctUntilChanged";
+import { filter } from "rxjs/internal/operators/filter";
+import { finalize } from "rxjs/internal/operators/finalize";
+import { map } from "rxjs/internal/operators/map";
+import { mergeAll } from "rxjs/internal/operators/mergeAll";
+import { publishReplay } from "rxjs/internal/operators/publishReplay";
+import { refCount } from "rxjs/internal/operators/refCount";
+import { subscribeOn } from "rxjs/internal/operators/subscribeOn";
+import { toArray } from "rxjs/internal/operators/toArray";
+import { asapScheduler } from "rxjs/internal/scheduler/asap";
+import { isRangeSelection, TreeSelectionManager } from "./internal/TreeSelectionManager";
+import { isTreeModelNode } from "./TreeModel";
+/**
+ * Default event dispatcher that emits tree events according performed actions.
+ * It converts low level tree events into TreeEvents.
+ * @internal
+ */
+export class TreeEventDispatcher {
+    constructor(treeEvents, nodeLoader, selectionMode, getVisibleNodes) {
+        this._activeSelections = new Set();
+        this._treeEvents = treeEvents;
+        this._nodeLoader = nodeLoader;
+        this._getVisibleNodes = getVisibleNodes;
+        this._selectionManager = new TreeSelectionManager(selectionMode, this._getVisibleNodes);
+        this._selectionManager.onDragSelection.addListener(({ selectionChanges }) => {
+            const modifications = from(selectionChanges)
+                .pipe(map(({ selectedNodes, deselectedNodes }) => from(this.collectSelectionChanges(selectedNodes, []))
+                .pipe(concatMap(({ selectedNodeItems }) => from(selectedNodeItems)), toArray(), map((collectedIds) => ({ selectedNodeItems: collectedIds, deselectedNodeItems: this.collectNodeItems(deselectedNodes) })))), concatAll(), publishReplay(), refCount());
+            /* istanbul ignore else */
+            if (this._treeEvents.onSelectionModified !== undefined)
+                this._treeEvents.onSelectionModified({ modifications });
+        });
+        this._selectionManager.onSelectionChanged.addListener(({ selectedNodes, deselectedNodes }) => {
+            const modifications = merge(defer(() => {
+                this._activeSelections.add(modifications);
+                return EMPTY;
+            }), this.collectSelectionChanges(selectedNodes, deselectedNodes))
+                .pipe(finalize(() => {
+                this._activeSelections.delete(modifications);
+            }), publishReplay(), refCount());
+            /* istanbul ignore else */
+            if (this._treeEvents.onSelectionModified !== undefined)
+                this._treeEvents.onSelectionModified({ modifications });
+        });
+        this._selectionManager.onSelectionReplaced.addListener(({ selectedNodeIds }) => {
+            const replacements = merge(defer(() => {
+                this._activeSelections.add(replacements);
+                return EMPTY;
+            }), this.collectSelectionChanges(selectedNodeIds, []))
+                .pipe(finalize(() => {
+                this._activeSelections.delete(replacements);
+            }), publishReplay(), refCount());
+            /* istanbul ignore else */
+            if (this._treeEvents.onSelectionReplaced !== undefined)
+                this._treeEvents.onSelectionReplaced({ replacements });
+        });
+    }
+    setVisibleNodes(visibleNodes) {
+        this._getVisibleNodes = visibleNodes;
+        this._selectionManager.setVisibleNodes(visibleNodes);
+    }
+    onNodeCheckboxClicked(nodeId, newState) {
+        if (this._getVisibleNodes === undefined)
+            return;
+        const visibleNodes = this._getVisibleNodes();
+        const clickedNode = visibleNodes.getModel().getNode(nodeId);
+        if (clickedNode === undefined)
+            return;
+        const immediateStateChanges = [{ nodeItem: clickedNode.item, newState }];
+        if (clickedNode.isSelected) {
+            for (const node of visibleNodes) {
+                if (isTreeModelNode(node) && node.id !== clickedNode.id && node.isSelected && node.checkbox.state !== newState) {
+                    immediateStateChanges.push({ nodeItem: node.item, newState });
+                }
+            }
+        }
+        const stateChanges = concat(of(immediateStateChanges), from(this._activeSelections)
+            .pipe(mergeAll(), map(({ selectedNodeItems }) => selectedNodeItems.map((item) => ({ nodeItem: item, newState })))))
+            .pipe(publishReplay(), refCount());
+        /* istanbul ignore else */
+        if (this._treeEvents.onCheckboxStateChanged !== undefined)
+            this._treeEvents.onCheckboxStateChanged({ stateChanges });
+    }
+    onNodeExpanded(nodeId) {
+        /* istanbul ignore else */
+        if (this._treeEvents.onNodeExpanded !== undefined)
+            this._treeEvents.onNodeExpanded({ nodeId });
+    }
+    onNodeCollapsed(nodeId) {
+        /* istanbul ignore else */
+        if (this._treeEvents.onNodeCollapsed !== undefined)
+            this._treeEvents.onNodeCollapsed({ nodeId });
+    }
+    onNodeClicked(nodeId, event) {
+        const node = this._getVisibleNodes ? this._getVisibleNodes().getModel().getNode(nodeId) : undefined;
+        const isNodeSelected = node ? node.isSelected : false;
+        this._selectionManager.onNodeClicked(nodeId, event);
+        // if clicked node was already selected fire delayed click event
+        if (isNodeSelected && this._treeEvents.onDelayedNodeClick !== undefined) {
+            this._treeEvents.onDelayedNodeClick({ nodeId });
+        }
+    }
+    onNodeMouseDown(nodeId) {
+        this._selectionManager.onNodeMouseDown(nodeId);
+    }
+    onNodeMouseMove(nodeId) {
+        this._selectionManager.onNodeMouseMove(nodeId);
+    }
+    onNodeEditorActivated(nodeId) {
+        const node = this._getVisibleNodes ? this._getVisibleNodes().getModel().getNode(nodeId) : /* istanbul ignore next */ undefined;
+        const isNodeSelected = node ? node.isSelected : false;
+        // if node was already selected, fire onNodeEditorActivated event
+        if (isNodeSelected && this._treeEvents.onNodeEditorActivated !== undefined) {
+            this._treeEvents.onNodeEditorActivated({ nodeId });
+        }
+    }
+    onTreeKeyDown(event) {
+        this._selectionManager.onTreeKeyDown(event, this);
+    }
+    onTreeKeyUp(event) {
+        this._selectionManager.onTreeKeyUp(event, this);
+    }
+    collectSelectionChanges(selection, deselection) {
+        const deselectedItems = this.collectNodeItems(deselection);
+        if (isRangeSelection(selection)) {
+            return zip(this.collectNodesBetween(selection.from, selection.to).pipe(defaultIfEmpty([])), 
+            // Without a scheduler `generate` would block the main thread indefinitely
+            generate({ initialState: deselectedItems, iterate: () => [], scheduler: asapScheduler })).pipe(map(([selectedNodeItems, deselectedNodeItems]) => ({ selectedNodeItems, deselectedNodeItems })));
+        }
+        const selectedItems = this.collectNodeItems(selection);
+        return of({ selectedNodeItems: selectedItems, deselectedNodeItems: deselectedItems });
+    }
+    collectNodesBetween(nodeId1, nodeId2) {
+        const [readyNodes, nodesToLoad] = TreeEventDispatcher.groupNodesByLoadingState(this.iterateNodesBetween(nodeId1, nodeId2));
+        const loadedSelectedNodes = from(nodesToLoad.map((node) => {
+            const parentNode = node.parentId
+                ? this._getVisibleNodes().getModel().getNode(node.parentId)
+                : this._getVisibleNodes().getModel().getRootNode();
+            return parentNode ? this._nodeLoader.loadNode(parentNode, node.childIndex) : /* istanbul ignore next */ EMPTY;
+        }))
+            .pipe(
+        // We have requested multiple nodes that may belong to the same page.
+        // When the page loads we only want to process the loaded nodes once.
+        // Making assumption that loaded nodes from the same page will be emitted without interruptions.
+        // Maybe we could simplify this to `this._nodeLoader.loadNodes(nodesToLoad)`?
+        mergeAll(), distinctUntilChanged());
+        return concat(of(readyNodes.filter((node) => !node.isSelectionDisabled).map((node) => node.item)), loadedSelectedNodes.pipe(map(({ loadedNodes }) => loadedNodes.filter((item) => !item.isSelectionDisabled)))).pipe(filter((nodeItems) => nodeItems.length > 0), 
+        // Give enough time for multiple subscribers to subscribe before any emissions begin
+        subscribeOn(asapScheduler));
+    }
+    *iterateNodesBetween(nodeId1, nodeId2) {
+        let firstNodeFound = false;
+        if (this._getVisibleNodes === undefined) {
+            return;
+        }
+        for (const node of this._getVisibleNodes()) {
+            if (firstNodeFound) {
+                yield node;
+            }
+            if (isTreeModelNode(node)) {
+                if (nodeId1 === nodeId2 && node.id === nodeId1) {
+                    yield node;
+                    return;
+                }
+                if (node.id === nodeId1 || node.id === nodeId2) {
+                    if (firstNodeFound) {
+                        return;
+                    }
+                    firstNodeFound = true;
+                    yield node;
+                }
+            }
+        }
+    }
+    collectNodeItems(nodeIds) {
+        const items = [];
+        if (this._getVisibleNodes === undefined) {
+            return items;
+        }
+        for (const nodeId of nodeIds) {
+            const node = this._getVisibleNodes().getModel().getNode(nodeId);
+            // istanbul ignore else
+            if (node !== undefined && !node.isSelectionDisabled) {
+                items.push(node.item);
+            }
+        }
+        return items;
+    }
+    static groupNodesByLoadingState(nodes) {
+        const loadedNodeItems = [];
+        const nodesToLoad = [];
+        for (const node of nodes) {
+            if (isTreeModelNode(node)) {
+                loadedNodeItems.push(node);
+            }
+            else {
+                nodesToLoad.push(node);
+            }
+        }
+        return [loadedNodeItems, nodesToLoad];
+    }
+}
 //# sourceMappingURL=TreeEventDispatcher.js.map