@itwin/components-react 4.0.0-dev.11 → 4.0.0-dev.13

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

@@ -1,306 +1,304 @@
-/*---------------------------------------------------------------------------------------------
-* 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 { defer } from "rxjs/internal/observable/defer";
-import { from } from "rxjs/internal/observable/from";
-import { of } from "rxjs/internal/observable/of";
-import { concatAll } from "rxjs/internal/operators/concatAll";
-import { concatMap } from "rxjs/internal/operators/concatMap";
-import { finalize } from "rxjs/internal/operators/finalize";
-import { map } from "rxjs/internal/operators/map";
-import { publish } from "rxjs/internal/operators/publish";
-import { refCount } from "rxjs/internal/operators/refCount";
-import { toArray } from "rxjs/internal/operators/toArray";
-import { UiError } from "@itwin/appui-abstract";
-import { scheduleSubscription, SubscriptionScheduler } from "../../common/SubscriptionScheduler";
-import { UiComponents } from "../../UiComponents";
-import { isTreeDataProviderInterface, isTreeDataProviderMethod, isTreeDataProviderPromise, isTreeDataProviderRaw, } from "../TreeDataProvider";
-import { toRxjsObservable } from "./Observable";
-import { isTreeModelNode } from "./TreeModel";
-/**
- * Abstract node loader implementation which loads nodes into provided model source.
- * @public
- */
-export class AbstractTreeNodeLoader {
-    constructor(modelSource) {
-        this._loadScheduler = new SubscriptionScheduler();
-        this._treeModelSource = modelSource;
-    }
-    get modelSource() { return this._treeModelSource; }
-    /** Do not override this method. @see `load` */
-    loadNode(parent, childIndex) {
-        return toRxjsObservable(this.load(parent, childIndex)).pipe(map((loadedHierarchy) => {
-            this.updateModel(loadedHierarchy);
-            return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
-        }), 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);
-    }
-}
-/**
- * Abstract node loader with tree data provider which loads nodes into provided model source.
- * @public
- */
-export class AbstractTreeNodeLoaderWithProvider extends AbstractTreeNodeLoader {
-    constructor(modelSource, dataProvider) {
-        super(modelSource);
-        this._dataProvider = dataProvider;
-    }
-    get dataProvider() { return this._dataProvider; }
-}
-/**
- * Default tree node loader with `TreeDataProvider` implementation.
- * @public
- */
-export class TreeNodeLoader extends AbstractTreeNodeLoaderWithProvider {
-    constructor(dataProvider, modelSource) {
-        super(modelSource, dataProvider);
-        this._activeRequests = new Map();
-        this._scheduler = new 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 defer(() => {
-            const parentItem = 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(map((loadedHierarchy) => {
-                this.updateModel(loadedHierarchy);
-                return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
-            }), scheduleSubscription(this._scheduler), finalize(() => this._activeRequests.delete(parentId)));
-            this._activeRequests.set(parentId, newRequest);
-            return newRequest;
-        });
-    }
-    // istanbul ignore next
-    load() {
-        throw new Error("Method not implemented.");
-    }
-}
-/**
- * Default paged tree node loader with `TreeDataProvider` implementation.
- * @public
- */
-export 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();
-    }
-    /** 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 defer(() => {
-            var _a;
-            const parentItem = 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(map((loadedHierarchy) => {
-                this.updateModel(loadedHierarchy);
-                return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
-            }), scheduleSubscription(this._scheduler), 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.");
-    }
-}
-function requestLoadedHierarchy(parentItem, dataSource, start, take, requestNumChildren) {
-    const parentId = parentItem && parentItem.id;
-    return dataSource.requestItems(parentItem, start, take, requestNumChildren)
-        .pipe(concatMap(({ numChildren, loadedItems }) => loadHierarchy(loadedItems, dataSource, take)
-        .pipe(map((hierarchyItems) => ({
-        parentId,
-        offset: start,
-        hierarchyItems,
-        numChildren,
-    })))));
-}
-function loadHierarchy(rootItems, dataSource, take) {
-    return from(rootItems)
-        .pipe(concatMap((item) => {
-        if (!item.autoExpand || item.children) {
-            return of(convertToLoadedNodeHierarchyItem(item));
-        }
-        return dataSource.requestItems(item, 0, take, true)
-            .pipe(concatMap(({ numChildren, loadedItems }) => loadHierarchy(loadedItems, dataSource, take)
-            .pipe(map((children) => ({ item, children, numChildren })))));
-    }), 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 */
-export 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;
-            }
-        }
-    });
-}
-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
- */
-export 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 defer(async () => {
-            if (isTreeDataProviderInterface(this._dataProvider)) {
-                const dataProvider = this._dataProvider;
-                return from(requestNumChildren ? dataProvider.getNodesCount(parent) : [undefined])
-                    .pipe(concatMap(async (numChildren) => {
-                    const pageOptions = numItems !== 0 ? { size: numItems, start: firstItemIndex } : undefined;
-                    return {
-                        loadedItems: await dataProvider.getNodes(parent, pageOptions),
-                        numChildren,
-                    };
-                }));
-            }
-            return from(this.getItems(parent))
-                .pipe(map((loadedItems) => ({
-                loadedItems: numItems !== 0 ? loadedItems.slice(firstItemIndex, firstItemIndex + numItems) : loadedItems,
-                numChildren: loadedItems.length,
-            })));
-        })
-            .pipe(concatAll(), publish(), refCount());
-    }
-    async getItems(parent) {
-        if (isTreeDataProviderRaw(this._dataProvider)) {
-            return this.getChildren(this._dataProvider, parent);
-        }
-        if (isTreeDataProviderMethod(this._dataProvider)) {
-            return this._dataProvider(parent);
-        }
-        if (isTreeDataProviderPromise(this._dataProvider)) {
-            this._dataProvider = await this._dataProvider;
-            return this.getChildren(this._dataProvider, parent);
-        }
-        throw new UiError(UiComponents.loggerCategory(this), "Unsupported TreeDataProvider.");
-    }
-    getChildren(rawProvider, parent) {
-        var _a;
-        if (parent === undefined)
-            return rawProvider;
-        return (_a = parent.children) !== null && _a !== void 0 ? _a : [];
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* 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 { defer } from "rxjs/internal/observable/defer";
+import { from } from "rxjs/internal/observable/from";
+import { of } from "rxjs/internal/observable/of";
+import { concatAll } from "rxjs/internal/operators/concatAll";
+import { concatMap } from "rxjs/internal/operators/concatMap";
+import { finalize } from "rxjs/internal/operators/finalize";
+import { map } from "rxjs/internal/operators/map";
+import { publish } from "rxjs/internal/operators/publish";
+import { refCount } from "rxjs/internal/operators/refCount";
+import { toArray } from "rxjs/internal/operators/toArray";
+import { UiError } from "@itwin/appui-abstract";
+import { scheduleSubscription, SubscriptionScheduler } from "../../common/SubscriptionScheduler";
+import { UiComponents } from "../../UiComponents";
+import { isTreeDataProviderInterface, isTreeDataProviderMethod, isTreeDataProviderPromise, isTreeDataProviderRaw, } from "../TreeDataProvider";
+import { toRxjsObservable } from "./Observable";
+import { isTreeModelNode } from "./TreeModel";
+/**
+ * Abstract node loader implementation which loads nodes into provided model source.
+ * @public
+ */
+export class AbstractTreeNodeLoader {
+    constructor(modelSource) {
+        this._loadScheduler = new SubscriptionScheduler();
+        this._treeModelSource = modelSource;
+    }
+    get modelSource() { return this._treeModelSource; }
+    /** Do not override this method. @see `load` */
+    loadNode(parent, childIndex) {
+        return toRxjsObservable(this.load(parent, childIndex)).pipe(map((loadedHierarchy) => {
+            this.updateModel(loadedHierarchy);
+            return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
+        }), 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);
+    }
+}
+/**
+ * Abstract node loader with tree data provider which loads nodes into provided model source.
+ * @public
+ */
+export class AbstractTreeNodeLoaderWithProvider extends AbstractTreeNodeLoader {
+    constructor(modelSource, dataProvider) {
+        super(modelSource);
+        this._dataProvider = dataProvider;
+    }
+    get dataProvider() { return this._dataProvider; }
+}
+/**
+ * Default tree node loader with `TreeDataProvider` implementation.
+ * @public
+ */
+export class TreeNodeLoader extends AbstractTreeNodeLoaderWithProvider {
+    constructor(dataProvider, modelSource) {
+        super(modelSource, dataProvider);
+        this._activeRequests = new Map();
+        this._scheduler = new 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 defer(() => {
+            const parentItem = 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(map((loadedHierarchy) => {
+                this.updateModel(loadedHierarchy);
+                return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
+            }), scheduleSubscription(this._scheduler), finalize(() => this._activeRequests.delete(parentId)));
+            this._activeRequests.set(parentId, newRequest);
+            return newRequest;
+        });
+    }
+    // istanbul ignore next
+    load() {
+        throw new Error("Method not implemented.");
+    }
+}
+/**
+ * Default paged tree node loader with `TreeDataProvider` implementation.
+ * @public
+ */
+export 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();
+    }
+    /** 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 defer(() => {
+            const parentItem = 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(map((loadedHierarchy) => {
+                this.updateModel(loadedHierarchy);
+                return { loadedNodes: collectTreeNodeItems(loadedHierarchy.hierarchyItems) };
+            }), scheduleSubscription(this._scheduler), 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.");
+    }
+}
+function requestLoadedHierarchy(parentItem, dataSource, start, take, requestNumChildren) {
+    const parentId = parentItem && parentItem.id;
+    return dataSource.requestItems(parentItem, start, take, requestNumChildren)
+        .pipe(concatMap(({ numChildren, loadedItems }) => loadHierarchy(loadedItems, dataSource, take)
+        .pipe(map((hierarchyItems) => ({
+        parentId,
+        offset: start,
+        hierarchyItems,
+        numChildren,
+    })))));
+}
+function loadHierarchy(rootItems, dataSource, take) {
+    return from(rootItems)
+        .pipe(concatMap((item) => {
+        if (!item.autoExpand || item.children) {
+            return of(convertToLoadedNodeHierarchyItem(item));
+        }
+        return dataSource.requestItems(item, 0, take, true)
+            .pipe(concatMap(({ numChildren, loadedItems }) => loadHierarchy(loadedItems, dataSource, take)
+            .pipe(map((children) => ({ item, children, numChildren })))));
+    }), 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 */
+export 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;
+            }
+        }
+    });
+}
+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
+ */
+export 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 defer(async () => {
+            if (isTreeDataProviderInterface(this._dataProvider)) {
+                const dataProvider = this._dataProvider;
+                return from(requestNumChildren ? dataProvider.getNodesCount(parent) : [undefined])
+                    .pipe(concatMap(async (numChildren) => {
+                    const pageOptions = numItems !== 0 ? { size: numItems, start: firstItemIndex } : undefined;
+                    return {
+                        loadedItems: await dataProvider.getNodes(parent, pageOptions),
+                        numChildren,
+                    };
+                }));
+            }
+            return from(this.getItems(parent))
+                .pipe(map((loadedItems) => ({
+                loadedItems: numItems !== 0 ? loadedItems.slice(firstItemIndex, firstItemIndex + numItems) : loadedItems,
+                numChildren: loadedItems.length,
+            })));
+        })
+            .pipe(concatAll(), publish(), refCount());
+    }
+    async getItems(parent) {
+        if (isTreeDataProviderRaw(this._dataProvider)) {
+            return this.getChildren(this._dataProvider, parent);
+        }
+        if (isTreeDataProviderMethod(this._dataProvider)) {
+            return this._dataProvider(parent);
+        }
+        if (isTreeDataProviderPromise(this._dataProvider)) {
+            this._dataProvider = await this._dataProvider;
+            return this.getChildren(this._dataProvider, parent);
+        }
+        throw new UiError(UiComponents.loggerCategory(this), "Unsupported TreeDataProvider.");
+    }
+    getChildren(rawProvider, parent) {
+        if (parent === undefined)
+            return rawProvider;
+        return parent.children ?? [];
+    }
+}
 //# sourceMappingURL=TreeNodeLoader.js.map