@itwin/components-react 4.0.0-dev.12 → 4.0.0-dev.14

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

@@ -1,315 +1,313 @@
-"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 defer_1 = require("rxjs/internal/observable/defer");
-const from_1 = require("rxjs/internal/observable/from");
-const of_1 = require("rxjs/internal/observable/of");
-const concatAll_1 = require("rxjs/internal/operators/concatAll");
-const concatMap_1 = require("rxjs/internal/operators/concatMap");
-const finalize_1 = require("rxjs/internal/operators/finalize");
-const map_1 = require("rxjs/internal/operators/map");
-const publish_1 = require("rxjs/internal/operators/publish");
-const refCount_1 = require("rxjs/internal/operators/refCount");
-const toArray_1 = require("rxjs/internal/operators/toArray");
-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, map_1.map)((loadedHierarchy) => {
-            this.updateModel(loadedHierarchy);
-            return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
-        }), (0, SubscriptionScheduler_1.scheduleSubscription)(this._loadScheduler));
-    }
-    /**
-     * 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, defer_1.defer)(() => {
-            const parentItem = (0, TreeModel_1.isTreeModelNode)(parent) ? parent.item : undefined;
-            const parentId = parentItem === null || parentItem === void 0 ? void 0 : 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, map_1.map)((loadedHierarchy) => {
-                this.updateModel(loadedHierarchy);
-                return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
-            }), (0, SubscriptionScheduler_1.scheduleSubscription)(this._scheduler), (0, finalize_1.finalize)(() => this._activeRequests.delete(parentId)));
-            this._activeRequests.set(parentId, newRequest);
-            return newRequest;
-        });
-    }
-    // istanbul ignore next
-    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, defer_1.defer)(() => {
-            var _a;
-            const parentItem = (0, TreeModel_1.isTreeModelNode)(parent) ? parent.item : undefined;
-            const parentId = parentItem === null || parentItem === void 0 ? void 0 : parentItem.id;
-            const parentPageRequests = (_a = this._activePageRequests.get(parentId)) !== null && _a !== void 0 ? _a : 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, map_1.map)((loadedHierarchy) => {
-                this.updateModel(loadedHierarchy);
-                return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
-            }), (0, SubscriptionScheduler_1.scheduleSubscription)(this._scheduler), (0, finalize_1.finalize)(() => {
-                parentPageRequests.delete(page);
-                if (parentPageRequests.size === 0) {
-                    this._activePageRequests.delete(parentId);
-                }
-            }));
-            parentPageRequests.set(page, newRequest);
-            this._activePageRequests.set(parentId, parentPageRequests);
-            return newRequest;
-        });
-    }
-    // istanbul ignore next
-    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, concatMap_1.concatMap)(({ numChildren, loadedItems }) => loadHierarchy(loadedItems, dataSource, take)
-        .pipe((0, map_1.map)((hierarchyItems) => ({
-        parentId,
-        offset: start,
-        hierarchyItems,
-        numChildren,
-    })))));
-}
-function loadHierarchy(rootItems, dataSource, take) {
-    return (0, from_1.from)(rootItems)
-        .pipe((0, concatMap_1.concatMap)((item) => {
-        if (!item.autoExpand || item.children) {
-            return (0, of_1.of)(convertToLoadedNodeHierarchyItem(item));
-        }
-        return dataSource.requestItems(item, 0, take, true)
-            .pipe((0, concatMap_1.concatMap)(({ numChildren, loadedItems }) => loadHierarchy(loadedItems, dataSource, take)
-            .pipe((0, map_1.map)((children) => ({ item, children, numChildren })))));
-    }), (0, toArray_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
-            /* istanbul ignore if */
-            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);
-            /* istanbul ignore else */
-            if (parentNode && parentNode.isLoading && parentNode.numChildren !== undefined) {
-                parentNode.isLoading = false;
-            }
-        }
-    });
-}
-exports.handleLoadedNodeHierarchy = handleLoadedNodeHierarchy;
-function updateChildren(model, parentId, hierarchyItems, startIndex, numChildren) {
-    var _a;
-    // 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 = (_a = nodeInput.description) !== null && _a !== void 0 ? _a : "";
-            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, defer_1.defer)(async () => {
-            if ((0, TreeDataProvider_1.isTreeDataProviderInterface)(this._dataProvider)) {
-                const dataProvider = this._dataProvider;
-                return (0, from_1.from)(requestNumChildren ? dataProvider.getNodesCount(parent) : [undefined])
-                    .pipe((0, concatMap_1.concatMap)(async (numChildren) => {
-                    const pageOptions = numItems !== 0 ? { size: numItems, start: firstItemIndex } : undefined;
-                    return {
-                        loadedItems: await dataProvider.getNodes(parent, pageOptions),
-                        numChildren,
-                    };
-                }));
-            }
-            return (0, from_1.from)(this.getItems(parent))
-                .pipe((0, map_1.map)((loadedItems) => ({
-                loadedItems: numItems !== 0 ? loadedItems.slice(firstItemIndex, firstItemIndex + numItems) : loadedItems,
-                numChildren: loadedItems.length,
-            })));
-        })
-            .pipe((0, concatAll_1.concatAll)(), (0, publish_1.publish)(), (0, refCount_1.refCount)());
-    }
-    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);
-        }
-        throw new appui_abstract_1.UiError(UiComponents_1.UiComponents.loggerCategory(this), "Unsupported TreeDataProvider.");
-    }
-    getChildren(rawProvider, parent) {
-        var _a;
-        if (parent === undefined)
-            return rawProvider;
-        return (_a = parent.children) !== null && _a !== void 0 ? _a : [];
-    }
-}
-exports.TreeDataSource = TreeDataSource;
+"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 defer_1 = require("rxjs/internal/observable/defer");
+const from_1 = require("rxjs/internal/observable/from");
+const of_1 = require("rxjs/internal/observable/of");
+const concatAll_1 = require("rxjs/internal/operators/concatAll");
+const concatMap_1 = require("rxjs/internal/operators/concatMap");
+const finalize_1 = require("rxjs/internal/operators/finalize");
+const map_1 = require("rxjs/internal/operators/map");
+const publish_1 = require("rxjs/internal/operators/publish");
+const refCount_1 = require("rxjs/internal/operators/refCount");
+const toArray_1 = require("rxjs/internal/operators/toArray");
+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, map_1.map)((loadedHierarchy) => {
+            this.updateModel(loadedHierarchy);
+            return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
+        }), (0, SubscriptionScheduler_1.scheduleSubscription)(this._loadScheduler));
+    }
+    /**
+     * 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, defer_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, map_1.map)((loadedHierarchy) => {
+                this.updateModel(loadedHierarchy);
+                return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
+            }), (0, SubscriptionScheduler_1.scheduleSubscription)(this._scheduler), (0, finalize_1.finalize)(() => this._activeRequests.delete(parentId)));
+            this._activeRequests.set(parentId, newRequest);
+            return newRequest;
+        });
+    }
+    // istanbul ignore next
+    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, defer_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, map_1.map)((loadedHierarchy) => {
+                this.updateModel(loadedHierarchy);
+                return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
+            }), (0, SubscriptionScheduler_1.scheduleSubscription)(this._scheduler), (0, finalize_1.finalize)(() => {
+                parentPageRequests.delete(page);
+                if (parentPageRequests.size === 0) {
+                    this._activePageRequests.delete(parentId);
+                }
+            }));
+            parentPageRequests.set(page, newRequest);
+            this._activePageRequests.set(parentId, parentPageRequests);
+            return newRequest;
+        });
+    }
+    // istanbul ignore next
+    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, concatMap_1.concatMap)(({ numChildren, loadedItems }) => loadHierarchy(loadedItems, dataSource, take)
+        .pipe((0, map_1.map)((hierarchyItems) => ({
+        parentId,
+        offset: start,
+        hierarchyItems,
+        numChildren,
+    })))));
+}
+function loadHierarchy(rootItems, dataSource, take) {
+    return (0, from_1.from)(rootItems)
+        .pipe((0, concatMap_1.concatMap)((item) => {
+        if (!item.autoExpand || item.children) {
+            return (0, of_1.of)(convertToLoadedNodeHierarchyItem(item));
+        }
+        return dataSource.requestItems(item, 0, take, true)
+            .pipe((0, concatMap_1.concatMap)(({ numChildren, loadedItems }) => loadHierarchy(loadedItems, dataSource, take)
+            .pipe((0, map_1.map)((children) => ({ item, children, numChildren })))));
+    }), (0, toArray_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
+            /* istanbul ignore if */
+            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);
+            /* istanbul ignore else */
+            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, defer_1.defer)(async () => {
+            if ((0, TreeDataProvider_1.isTreeDataProviderInterface)(this._dataProvider)) {
+                const dataProvider = this._dataProvider;
+                return (0, from_1.from)(requestNumChildren ? dataProvider.getNodesCount(parent) : [undefined])
+                    .pipe((0, concatMap_1.concatMap)(async (numChildren) => {
+                    const pageOptions = numItems !== 0 ? { size: numItems, start: firstItemIndex } : undefined;
+                    return {
+                        loadedItems: await dataProvider.getNodes(parent, pageOptions),
+                        numChildren,
+                    };
+                }));
+            }
+            return (0, from_1.from)(this.getItems(parent))
+                .pipe((0, map_1.map)((loadedItems) => ({
+                loadedItems: numItems !== 0 ? loadedItems.slice(firstItemIndex, firstItemIndex + numItems) : loadedItems,
+                numChildren: loadedItems.length,
+            })));
+        })
+            .pipe((0, concatAll_1.concatAll)(), (0, publish_1.publish)(), (0, refCount_1.refCount)());
+    }
+    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);
+        }
+        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