@itwin/components-react 4.17.6 → 5.0.0-dev.3

package/lib/cjs/components-react/tree/controlled/TreeModelSource.d.ts

@@ -1,35 +0,0 @@
-/** @packageDocumentation
- * @module Tree
- */
-import { BeUiEvent } from "@itwin/core-bentley";
-import type { TreeModel } from "./TreeModel";
-import { MutableTreeModel } from "./TreeModel";
-/**
- * Data structure that describes changes which happened to the tree model
- * @public
- */
-export interface TreeModelChanges {
-    addedNodeIds: string[];
-    modifiedNodeIds: string[];
-    removedNodeIds: string[];
-}
-/**
- * Controls tree model.
- * It is used to modify model and inform when tree model changes.
- * @public
- */
-export declare class TreeModelSource {
-    private _model;
-    /** Event that is emitted every time tree model is changed. */
-    onModelChanged: BeUiEvent<[TreeModel, TreeModelChanges]>;
-    constructor(_model?: MutableTreeModel);
-    /**
-     * Modifies tree model using provided callback.
-     * If changes to tree model is detected then onModelChanged event is emitted.
-     */
-    modifyModel(callback: (model: MutableTreeModel) => void): void;
-    /** Returns tree model. */
-    getModel(): TreeModel;
-    private collectModelChanges;
-}
-//# sourceMappingURL=TreeModelSource.d.ts.map

package/lib/cjs/components-react/tree/controlled/TreeModelSource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TreeModelSource.d.ts","sourceRoot":"","sources":["../../../../../src/components-react/tree/controlled/TreeModelSource.ts"],"names":[],"mappings":"AAIA;;GAEG;AAIH,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED;;;;GAIG;AACH,qBAAa,eAAe;IAId,OAAO,CAAC,MAAM;IAH1B,8DAA8D;IACvD,cAAc,2CAAkD;gBAEnD,MAAM,GAAE,gBAAyC;IAErE;;;OAGG;IACI,WAAW,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,GAAG,IAAI;IAoBrE,0BAA0B;IACnB,QAAQ,IAAI,SAAS;IAI5B,OAAO,CAAC,mBAAmB;CAyC5B"}

package/lib/cjs/components-react/tree/controlled/TreeModelSource.js

@@ -1,83 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- * 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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeModelSource = void 0;
-const immer_1 = require("immer");
-const core_bentley_1 = require("@itwin/core-bentley");
-const TreeModel_1 = require("./TreeModel");
-/**
- * Controls tree model.
- * It is used to modify model and inform when tree model changes.
- * @public
- */
-class TreeModelSource {
-    constructor(_model = new TreeModel_1.MutableTreeModel()) {
-        this._model = _model;
-        /** Event that is emitted every time tree model is changed. */
-        this.onModelChanged = new core_bentley_1.BeUiEvent();
-    }
-    /**
-     * Modifies tree model using provided callback.
-     * If changes to tree model is detected then onModelChanged event is emitted.
-     */
-    modifyModel(callback) {
-        let changes = {
-            addedNodeIds: [],
-            modifiedNodeIds: [],
-            removedNodeIds: [],
-        };
-        const newModel = (0, immer_1.produce)(this._model, (draft) => callback(draft), (patches) => {
-            changes = this.collectModelChanges(patches);
-        });
-        if (newModel !== this._model) {
-            this._model = newModel;
-            this.onModelChanged.emit([this._model, changes]);
-        }
-    }
-    /** Returns tree model. */
-    getModel() {
-        return this._model;
-    }
-    collectModelChanges(modelPatches) {
-        const addedNodeIds = [];
-        const modifiedNodeIds = new Set();
-        const removedNodeIds = [];
-        for (const patch of modelPatches) {
-            if (patch.path.length >= 3 &&
-                patch.path[0] === "_tree" &&
-                patch.path[1] === "_idToNode") {
-                const nodeId = patch.path[2];
-                if (patch.path.length > 3) {
-                    // Modification occured somewhere inside a node
-                    modifiedNodeIds.add(nodeId);
-                    continue;
-                }
-                // Modification occured directly on _idToNode object
-                switch (patch.op) {
-                    case "add":
-                        addedNodeIds.push(nodeId);
-                        break;
-                    case "remove":
-                        removedNodeIds.push(nodeId);
-                        break;
-                    case "replace":
-                        modifiedNodeIds.add(nodeId);
-                        break;
-                }
-            }
-        }
-        return {
-            addedNodeIds,
-            modifiedNodeIds: [...modifiedNodeIds],
-            removedNodeIds,
-        };
-    }
-}
-exports.TreeModelSource = TreeModelSource;
-//# sourceMappingURL=TreeModelSource.js.map

package/lib/cjs/components-react/tree/controlled/TreeModelSource.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TreeModelSource.js","sourceRoot":"","sources":["../../../../../src/components-react/tree/controlled/TreeModelSource.ts"],"names":[],"mappings":";AAAA;;;gGAGgG;AAChG;;GAEG;;;AAGH,iCAAgC;AAChC,sDAAgD;AAEhD,2CAA+C;AAY/C;;;;GAIG;AACH,MAAa,eAAe;IAI1B,YAAoB,SAA2B,IAAI,4BAAgB,EAAE;QAAjD,WAAM,GAAN,MAAM,CAA2C;QAHrE,8DAA8D;QACvD,mBAAc,GAAG,IAAI,wBAAS,EAAiC,CAAC;IAEC,CAAC;IAEzE;;;OAGG;IACI,WAAW,CAAC,QAA2C;QAC5D,IAAI,OAAO,GAAqB;YAC9B,YAAY,EAAE,EAAE;YAChB,eAAe,EAAE,EAAE;YACnB,cAAc,EAAE,EAAE;SACnB,CAAC;QACF,MAAM,QAAQ,GAAG,IAAA,eAAO,EACtB,IAAI,CAAC,MAAM,EACX,CAAC,KAAuB,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,EAC5C,CAAC,OAAgB,EAAE,EAAE;YACnB,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;QAC9C,CAAC,CACF,CAAC;QAEF,IAAI,QAAQ,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;YAC7B,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC;YACvB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;IAED,0BAA0B;IACnB,QAAQ;QACb,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAEO,mBAAmB,CAAC,YAAqB;QAC/C,MAAM,YAAY,GAAa,EAAE,CAAC;QAClC,MAAM,eAAe,GAAG,IAAI,GAAG,EAAU,CAAC;QAC1C,MAAM,cAAc,GAAa,EAAE,CAAC;QACpC,KAAK,MAAM,KAAK,IAAI,YAAY,EAAE,CAAC;YACjC,IACE,KAAK,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC;gBACtB,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,OAAO;gBACzB,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,WAAW,EAC7B,CAAC;gBACD,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAW,CAAC;gBAEvC,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC1B,+CAA+C;oBAC/C,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBAC5B,SAAS;gBACX,CAAC;gBAED,oDAAoD;gBACpD,QAAQ,KAAK,CAAC,EAAE,EAAE,CAAC;oBACjB,KAAK,KAAK;wBACR,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;wBAC1B,MAAM;oBAER,KAAK,QAAQ;wBACX,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;wBAC5B,MAAM;oBAER,KAAK,SAAS;wBACZ,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;wBAC5B,MAAM;gBACV,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO;YACL,YAAY;YACZ,eAAe,EAAE,CAAC,GAAG,eAAe,CAAC;YACrC,cAAc;SACf,CAAC;IACJ,CAAC;CACF;AA5ED,0CA4EC","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 type { Patch } from \"immer\";\nimport { produce } from \"immer\";\nimport { BeUiEvent } from \"@itwin/core-bentley\";\nimport type { TreeModel } from \"./TreeModel\";\nimport { MutableTreeModel } from \"./TreeModel\";\n\n/**\n * Data structure that describes changes which happened to the tree model\n * @public\n */\nexport interface TreeModelChanges {\n  addedNodeIds: string[];\n  modifiedNodeIds: string[];\n  removedNodeIds: string[];\n}\n\n/**\n * Controls tree model.\n * It is used to modify model and inform when tree model changes.\n * @public\n */\nexport class TreeModelSource {\n  /** Event that is emitted every time tree model is changed. */\n  public onModelChanged = new BeUiEvent<[TreeModel, TreeModelChanges]>();\n\n  constructor(private _model: MutableTreeModel = new MutableTreeModel()) {}\n\n  /**\n   * Modifies tree model using provided callback.\n   * If changes to tree model is detected then onModelChanged event is emitted.\n   */\n  public modifyModel(callback: (model: MutableTreeModel) => void): void {\n    let changes: TreeModelChanges = {\n      addedNodeIds: [],\n      modifiedNodeIds: [],\n      removedNodeIds: [],\n    };\n    const newModel = produce(\n      this._model,\n      (draft: MutableTreeModel) => callback(draft),\n      (patches: Patch[]) => {\n        changes = this.collectModelChanges(patches);\n      }\n    );\n\n    if (newModel !== this._model) {\n      this._model = newModel;\n      this.onModelChanged.emit([this._model, changes]);\n    }\n  }\n\n  /** Returns tree model. */\n  public getModel(): TreeModel {\n    return this._model;\n  }\n\n  private collectModelChanges(modelPatches: Patch[]): TreeModelChanges {\n    const addedNodeIds: string[] = [];\n    const modifiedNodeIds = new Set<string>();\n    const removedNodeIds: string[] = [];\n    for (const patch of modelPatches) {\n      if (\n        patch.path.length >= 3 &&\n        patch.path[0] === \"_tree\" &&\n        patch.path[1] === \"_idToNode\"\n      ) {\n        const nodeId = patch.path[2] as string;\n\n        if (patch.path.length > 3) {\n          // Modification occured somewhere inside a node\n          modifiedNodeIds.add(nodeId);\n          continue;\n        }\n\n        // Modification occured directly on _idToNode object\n        switch (patch.op) {\n          case \"add\":\n            addedNodeIds.push(nodeId);\n            break;\n\n          case \"remove\":\n            removedNodeIds.push(nodeId);\n            break;\n\n          case \"replace\":\n            modifiedNodeIds.add(nodeId);\n            break;\n        }\n      }\n    }\n\n    return {\n      addedNodeIds,\n      modifiedNodeIds: [...modifiedNodeIds],\n      removedNodeIds,\n    };\n  }\n}\n"]}

package/lib/cjs/components-react/tree/controlled/TreeNodeLoader.d.ts

@@ -1,148 +0,0 @@
-/** @packageDocumentation
- * @module Tree
- */
-import type { Observable as RxjsObservable } from "rxjs";
-import type { TreeDataProvider, TreeNodeItem } from "../TreeDataProvider";
-import type { Observable } from "./Observable";
-import type { TreeModelNode, TreeModelRootNode, TreeNodeItemData } from "./TreeModel";
-import type { TreeModelSource } from "./TreeModelSource";
-/**
- * Data structure that describes node load result
- * @public
- */
-export interface TreeNodeLoadResult {
-    loadedNodes: TreeNodeItem[];
-}
-/**
- * Tree node loader which is used to load tree nodes.
- * @public
- */
-export interface ITreeNodeLoader {
-    /**
-     * Loads node at specified place in tree.
-     * @param parentId specifies tree branch
-     * @param childIndex specifies offset in the branch.
-     */
-    loadNode(parentId: TreeModelNode | TreeModelRootNode, childIndex: number): Observable<TreeNodeLoadResult>;
-}
-/**
- * Tree node loader which uses `TreeDataProvider` to load nodes.
- * @public
- */
-export interface ITreeNodeLoaderWithProvider<TDataProvider extends TreeDataProvider> extends ITreeNodeLoader {
-    /** Returns `TreeDataProvider` used to load nodes. */
-    readonly dataProvider: TDataProvider;
-}
-/**
- * Abstract node loader implementation which loads nodes into provided model source.
- * @public
- */
-export declare abstract class AbstractTreeNodeLoader implements ITreeNodeLoader {
-    private _treeModelSource;
-    private _loadScheduler;
-    protected constructor(modelSource: TreeModelSource);
-    get modelSource(): TreeModelSource;
-    /** Do not override this method. @see `load` */
-    loadNode(parent: TreeModelNode | TreeModelRootNode, childIndex: number): Observable<TreeNodeLoadResult>;
-    /**
-     * A method that's called when `load` loads some nodes and we need to put them into model source. The
-     * default implementation simply puts loaded child nodes under their parent at correct positions. Concrete
-     * implementation may override this method to handle loaded nodes in a a custom way (put them at custom locations
-     * in the hierarchy, etc.)
-     */
-    protected updateModel(loadedHierarchy: LoadedNodeHierarchy): void;
-    /** An abstract method to load a node at the specific index for the specified parent. */
-    protected abstract load(parent: TreeModelNode | TreeModelRootNode, childIndex: number): Observable<LoadedNodeHierarchy>;
-}
-/**
- * Abstract node loader with tree data provider which loads nodes into provided model source.
- * @public
- */
-export declare abstract class AbstractTreeNodeLoaderWithProvider<TDataProvider extends TreeDataProvider> extends AbstractTreeNodeLoader implements ITreeNodeLoaderWithProvider<TDataProvider> {
-    private _dataProvider;
-    protected constructor(modelSource: TreeModelSource, dataProvider: TDataProvider);
-    get dataProvider(): TDataProvider;
-}
-/**
- * Default tree node loader with `TreeDataProvider` implementation.
- * @public
- */
-export declare class TreeNodeLoader<TDataProvider extends TreeDataProvider> extends AbstractTreeNodeLoaderWithProvider<TDataProvider> {
-    private _treeDataSource;
-    private _activeRequests;
-    private _scheduler;
-    constructor(dataProvider: TDataProvider, modelSource: TreeModelSource);
-    /**
-     * Schedules to load children of node and returns an Observable.
-     * @note It does not start loading node until '.subscribe()' is called on returned Observable.
-     */
-    loadNode(parent: TreeModelNode | TreeModelRootNode, _childIndex?: number): Observable<TreeNodeLoadResult>;
-    protected load(): Observable<LoadedNodeHierarchy>;
-}
-/**
- * Default paged tree node loader with `TreeDataProvider` implementation.
- * @public
- */
-export declare class PagedTreeNodeLoader<TDataProvider extends TreeDataProvider> extends AbstractTreeNodeLoaderWithProvider<TDataProvider> {
-    private _treeDataSource;
-    private _pageSize;
-    private _activePageRequests;
-    private _scheduler;
-    constructor(dataProvider: TDataProvider, modelSource: TreeModelSource, pageSize: number);
-    /** Returns page size used by tree node loader. */
-    get pageSize(): number;
-    /**
-     * Schedules to load one page of node children and returns an Observable.
-     * @note It does not start loading node page until '.subscribe()' is called on returned Observable.
-     */
-    loadNode(parent: TreeModelNode | TreeModelRootNode, childIndex: number): Observable<TreeNodeLoadResult>;
-    protected load(): Observable<LoadedNodeHierarchy>;
-}
-/**
- * Data structure that describes hierarchy loaded for parent node.
- * @public
- */
-export interface LoadedNodeHierarchy {
-    /** Node id of the parent node for loaded hierarchy. */
-    parentId: string | undefined;
-    /** Hierarchy items offset in parent node children array. */
-    offset: number;
-    /** Loaded hierarchy items. */
-    hierarchyItems: LoadedNodeHierarchyItem[];
-    /** Number of children parent node has. */
-    numChildren?: number;
-}
-/**
- * Data structure that describes one loaded hierarchy item.
- * @public
- */
-export interface LoadedNodeHierarchyItem {
-    /** Loaded tree node item. */
-    item: TreeNodeItemData;
-    /** Children of loaded tree node item. */
-    children?: LoadedNodeHierarchyItem[];
-    /** Number of children tree node item has. */
-    numChildren?: number;
-}
-/** @internal */
-export declare function handleLoadedNodeHierarchy(modelSource: TreeModelSource, loadedHierarchy: LoadedNodeHierarchy): void;
-interface TreeDataSourceResult {
-    loadedItems: TreeNodeItemData[];
-    numChildren?: number;
-}
-/**
- * Wrapper to handle different types of `TreeDataProvider`. Provides one method
- * to request items from `TreeDataProviderRaw`, `TreeDataProviderMethod`,
- * `TreeDataProviderPromise` or `TreeDataProviderInterface`.
- *
- * @internal
- */
-export declare class TreeDataSource {
-    private _dataProvider;
-    constructor(dataProvider: TreeDataProvider);
-    requestItems(parent: TreeNodeItem | undefined, firstItemIndex: number, numItems: number, requestNumChildren: boolean): RxjsObservable<TreeDataSourceResult>;
-    private getItems;
-    private getChildren;
-}
-export {};
-//# sourceMappingURL=TreeNodeLoader.d.ts.map

package/lib/cjs/components-react/tree/controlled/TreeNodeLoader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TreeNodeLoader.d.ts","sourceRoot":"","sources":["../../../../../src/components-react/tree/controlled/TreeNodeLoader.ts"],"names":[],"mappings":"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"}

package/lib/cjs/components-react/tree/controlled/TreeNodeLoader.js

@@ -1,323 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- * 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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeDataSource = exports.handleLoadedNodeHierarchy = exports.PagedTreeNodeLoader = exports.TreeNodeLoader = exports.AbstractTreeNodeLoaderWithProvider = exports.AbstractTreeNodeLoader = void 0;
-const rxjs_1 = require("rxjs");
-const appui_abstract_1 = require("@itwin/appui-abstract");
-const SubscriptionScheduler_1 = require("../../common/SubscriptionScheduler");
-const UiComponents_1 = require("../../UiComponents");
-const TreeDataProvider_1 = require("../TreeDataProvider");
-const Observable_1 = require("./Observable");
-const TreeModel_1 = require("./TreeModel");
-/**
- * Abstract node loader implementation which loads nodes into provided model source.
- * @public
- */
-class AbstractTreeNodeLoader {
-    constructor(modelSource) {
-        this._loadScheduler = new SubscriptionScheduler_1.SubscriptionScheduler();
-        this._treeModelSource = modelSource;
-    }
-    get modelSource() {
-        return this._treeModelSource;
-    }
-    /** Do not override this method. @see `load` */
-    loadNode(parent, childIndex) {
-        return (0, Observable_1.toRxjsObservable)(this.load(parent, childIndex)).pipe((0, SubscriptionScheduler_1.scheduleSubscription)(this._loadScheduler), (0, rxjs_1.map)((loadedHierarchy) => {
-            this.updateModel(loadedHierarchy);
-            return {
-                loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems),
-            };
-        }));
-    }
-    /**
-     * A method that's called when `load` loads some nodes and we need to put them into model source. The
-     * default implementation simply puts loaded child nodes under their parent at correct positions. Concrete
-     * implementation may override this method to handle loaded nodes in a a custom way (put them at custom locations
-     * in the hierarchy, etc.)
-     */
-    updateModel(loadedHierarchy) {
-        handleLoadedNodeHierarchy(this._treeModelSource, loadedHierarchy);
-    }
-}
-exports.AbstractTreeNodeLoader = AbstractTreeNodeLoader;
-/**
- * Abstract node loader with tree data provider which loads nodes into provided model source.
- * @public
- */
-class AbstractTreeNodeLoaderWithProvider extends AbstractTreeNodeLoader {
-    constructor(modelSource, dataProvider) {
-        super(modelSource);
-        this._dataProvider = dataProvider;
-    }
-    get dataProvider() {
-        return this._dataProvider;
-    }
-}
-exports.AbstractTreeNodeLoaderWithProvider = AbstractTreeNodeLoaderWithProvider;
-/**
- * Default tree node loader with `TreeDataProvider` implementation.
- * @public
- */
-class TreeNodeLoader extends AbstractTreeNodeLoaderWithProvider {
-    constructor(dataProvider, modelSource) {
-        super(modelSource, dataProvider);
-        this._activeRequests = new Map();
-        this._scheduler = new SubscriptionScheduler_1.SubscriptionScheduler();
-        this._treeDataSource = new TreeDataSource(dataProvider);
-    }
-    /**
-     * Schedules to load children of node and returns an Observable.
-     * @note It does not start loading node until '.subscribe()' is called on returned Observable.
-     */
-    loadNode(parent, _childIndex) {
-        return (0, rxjs_1.defer)(() => {
-            const parentItem = (0, TreeModel_1.isTreeModelNode)(parent) ? parent.item : undefined;
-            const parentId = parentItem?.id;
-            const activeRequest = this._activeRequests.get(parentId);
-            if (activeRequest) {
-                return activeRequest;
-            }
-            const newRequest = requestLoadedHierarchy(parentItem, this._treeDataSource, 0, 0, parent.numChildren === undefined).pipe((0, SubscriptionScheduler_1.scheduleSubscription)(this._scheduler), (0, rxjs_1.map)((loadedHierarchy) => {
-                this.updateModel(loadedHierarchy);
-                return {
-                    loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems),
-                };
-            }), (0, rxjs_1.finalize)(() => this._activeRequests.delete(parentId)));
-            this._activeRequests.set(parentId, newRequest);
-            return newRequest;
-        });
-    }
-    load() {
-        throw new Error("Method not implemented.");
-    }
-}
-exports.TreeNodeLoader = TreeNodeLoader;
-/**
- * Default paged tree node loader with `TreeDataProvider` implementation.
- * @public
- */
-class PagedTreeNodeLoader extends AbstractTreeNodeLoaderWithProvider {
-    constructor(dataProvider, modelSource, pageSize) {
-        super(modelSource, dataProvider);
-        this._treeDataSource = new TreeDataSource(dataProvider);
-        this._pageSize = pageSize;
-        this._activePageRequests = new Map();
-        this._scheduler = new SubscriptionScheduler_1.SubscriptionScheduler();
-    }
-    /** Returns page size used by tree node loader. */
-    get pageSize() {
-        return this._pageSize;
-    }
-    /**
-     * Schedules to load one page of node children and returns an Observable.
-     * @note It does not start loading node page until '.subscribe()' is called on returned Observable.
-     */
-    loadNode(parent, childIndex) {
-        return (0, rxjs_1.defer)(() => {
-            const parentItem = (0, TreeModel_1.isTreeModelNode)(parent) ? parent.item : undefined;
-            const parentId = parentItem?.id;
-            const parentPageRequests = this._activePageRequests.get(parentId) ??
-                new Map();
-            const page = Math.trunc(childIndex / this._pageSize);
-            const activeRequest = parentPageRequests.get(page);
-            if (activeRequest) {
-                return activeRequest;
-            }
-            const startIndex = page * this._pageSize;
-            const newRequest = requestLoadedHierarchy(parentItem, this._treeDataSource, startIndex, this._pageSize, parent.numChildren === undefined).pipe((0, SubscriptionScheduler_1.scheduleSubscription)(this._scheduler), (0, rxjs_1.map)((loadedHierarchy) => {
-                this.updateModel(loadedHierarchy);
-                return {
-                    loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems),
-                };
-            }), (0, rxjs_1.finalize)(() => {
-                parentPageRequests.delete(page);
-                if (parentPageRequests.size === 0) {
-                    this._activePageRequests.delete(parentId);
-                }
-            }));
-            parentPageRequests.set(page, newRequest);
-            this._activePageRequests.set(parentId, parentPageRequests);
-            return newRequest;
-        });
-    }
-    load() {
-        throw new Error("Method not implemented.");
-    }
-}
-exports.PagedTreeNodeLoader = PagedTreeNodeLoader;
-function requestLoadedHierarchy(parentItem, dataSource, start, take, requestNumChildren) {
-    const parentId = parentItem && parentItem.id;
-    return dataSource
-        .requestItems(parentItem, start, take, requestNumChildren)
-        .pipe((0, rxjs_1.concatMap)(({ numChildren, loadedItems }) => loadHierarchy(loadedItems, dataSource, take).pipe((0, rxjs_1.map)((hierarchyItems) => ({
-        parentId,
-        offset: start,
-        hierarchyItems,
-        numChildren,
-    })))));
-}
-function loadHierarchy(rootItems, dataSource, take) {
-    return (0, rxjs_1.from)(rootItems).pipe((0, rxjs_1.concatMap)((item) => {
-        if (!item.autoExpand || item.children) {
-            return (0, rxjs_1.of)(convertToLoadedNodeHierarchyItem(item));
-        }
-        return dataSource
-            .requestItems(item, 0, take, true)
-            .pipe((0, rxjs_1.concatMap)(({ numChildren, loadedItems }) => loadHierarchy(loadedItems, dataSource, take).pipe((0, rxjs_1.map)((children) => ({ item, children, numChildren })))));
-    }), (0, rxjs_1.toArray)());
-}
-function convertToLoadedNodeHierarchyItem(item) {
-    return {
-        item,
-        children: item.children
-            ? item.children.map((child) => convertToLoadedNodeHierarchyItem(child))
-            : undefined,
-        numChildren: item.children ? item.children.length : undefined,
-    };
-}
-function collectTreeNodeItems(hierarchyItems, result = []) {
-    for (const hierarchyItem of hierarchyItems) {
-        result.push(hierarchyItem.item);
-        if (hierarchyItem.children)
-            collectTreeNodeItems(hierarchyItem.children, result);
-    }
-    return result;
-}
-/** @internal */
-function handleLoadedNodeHierarchy(modelSource, loadedHierarchy) {
-    modelSource.modifyModel((model) => {
-        if (loadedHierarchy.parentId !== undefined) {
-            // Make sure the model sill contains the parent node
-            if (model.getNode(loadedHierarchy.parentId) === undefined)
-                return;
-        }
-        updateChildren(model, loadedHierarchy.parentId, loadedHierarchy.hierarchyItems, loadedHierarchy.offset, loadedHierarchy.numChildren);
-        if (loadedHierarchy.parentId !== undefined) {
-            const parentNode = model.getNode(loadedHierarchy.parentId);
-            if (parentNode &&
-                parentNode.isLoading &&
-                parentNode.numChildren !== undefined) {
-                parentNode.isLoading = false;
-            }
-        }
-    });
-}
-exports.handleLoadedNodeHierarchy = handleLoadedNodeHierarchy;
-function updateChildren(model, parentId, hierarchyItems, startIndex, numChildren) {
-    // numChildren set to undefined indicates that this is not the first request for children
-    if (numChildren !== undefined) {
-        model.setNumChildren(parentId, numChildren);
-    }
-    // if children array is undefined do not add children as they should be disposed
-    if (model.getChildren(parentId) === undefined) {
-        return;
-    }
-    let offset = startIndex;
-    for (const hierarchyItem of hierarchyItems) {
-        const nodeInput = convertToTreeModelNodeInput(hierarchyItem.item);
-        const existingNode = model.getNode(hierarchyItem.item.id);
-        // if same item exists in the same position and is expanded update it without removing it's subtree
-        if (!existingNode ||
-            !existingNode.isExpanded ||
-            model.getChildOffset(parentId, existingNode.id) !== offset ||
-            nodeInput.numChildren === 0) {
-            model.setChildren(parentId, [nodeInput], offset);
-        }
-        else {
-            existingNode.label = nodeInput.label;
-            existingNode.description = nodeInput.description ?? "";
-            existingNode.item = nodeInput.item;
-        }
-        if (hierarchyItem.children) {
-            updateChildren(model, hierarchyItem.item.id, hierarchyItem.children, 0, hierarchyItem.numChildren);
-        }
-        offset++;
-    }
-}
-function convertToTreeModelNodeInput(item) {
-    let numChildren;
-    if (item.children) {
-        numChildren = item.children.length;
-    }
-    else if (!item.hasChildren) {
-        numChildren = 0;
-    }
-    return {
-        description: item.description,
-        isExpanded: !!item.autoExpand,
-        id: item.id,
-        item,
-        label: item.label,
-        isLoading: false,
-        numChildren,
-        isSelected: false,
-    };
-}
-/**
- * Wrapper to handle different types of `TreeDataProvider`. Provides one method
- * to request items from `TreeDataProviderRaw`, `TreeDataProviderMethod`,
- * `TreeDataProviderPromise` or `TreeDataProviderInterface`.
- *
- * @internal
- */
-class TreeDataSource {
-    constructor(dataProvider) {
-        this._dataProvider = dataProvider;
-    }
-    requestItems(parent, firstItemIndex, numItems, requestNumChildren) {
-        // During each async operation there is a chance that data provider will become stale. Create an opportunity to
-        // unsubscribe after each async operation so that we stop interacting with the stale data provider immediately.
-        return (0, rxjs_1.defer)(async () => {
-            if ((0, TreeDataProvider_1.isTreeDataProviderInterface)(this._dataProvider)) {
-                const dataProvider = this._dataProvider;
-                return (0, rxjs_1.from)(requestNumChildren ? dataProvider.getNodesCount(parent) : [undefined]).pipe((0, rxjs_1.concatMap)(async (numChildren) => {
-                    const pageOptions = numItems !== 0
-                        ? { size: numItems, start: firstItemIndex }
-                        : undefined;
-                    return {
-                        loadedItems: await dataProvider.getNodes(parent, pageOptions),
-                        numChildren,
-                    };
-                }));
-            }
-            return (0, rxjs_1.from)(this.getItems(parent)).pipe((0, rxjs_1.map)((loadedItems) => ({
-                loadedItems: numItems !== 0
-                    ? loadedItems.slice(firstItemIndex, firstItemIndex + numItems)
-                    : loadedItems,
-                numChildren: loadedItems.length,
-            })));
-        }).pipe((0, rxjs_1.concatAll)(), (0, rxjs_1.share)({
-            resetOnError: false,
-            resetOnComplete: false,
-            resetOnRefCountZero: true,
-        }));
-    }
-    async getItems(parent) {
-        if ((0, TreeDataProvider_1.isTreeDataProviderRaw)(this._dataProvider)) {
-            return this.getChildren(this._dataProvider, parent);
-        }
-        if ((0, TreeDataProvider_1.isTreeDataProviderMethod)(this._dataProvider)) {
-            return this._dataProvider(parent);
-        }
-        if ((0, TreeDataProvider_1.isTreeDataProviderPromise)(this._dataProvider)) {
-            this._dataProvider = await this._dataProvider;
-            return this.getChildren(this._dataProvider, parent);
-        }
-        // eslint-disable-next-line deprecation/deprecation
-        throw new appui_abstract_1.UiError(UiComponents_1.UiComponents.loggerCategory(this), "Unsupported TreeDataProvider.");
-    }
-    getChildren(rawProvider, parent) {
-        if (parent === undefined)
-            return rawProvider;
-        return parent.children ?? [];
-    }
-}
-exports.TreeDataSource = TreeDataSource;
-//# sourceMappingURL=TreeNodeLoader.js.map