@itwin/components-react 3.5.0-dev.16 → 3.5.0-dev.19

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

@@ -1,156 +1,156 @@
-/** @packageDocumentation
- * @module Tree
- */
-import { Observable as RxjsObservable } from "rxjs/internal/Observable";
-import { BeEvent, IDisposable } from "@itwin/core-bentley";
-import { TreeDataChangesListener, TreeDataProvider, TreeNodeItem } from "../TreeDataProvider";
-import { Observable } from "./Observable";
-import { TreeModelNode, TreeModelRootNode, TreeNodeItemData } from "./TreeModel";
-import { 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> implements IDisposable {
-    private _treeDataSource;
-    private _activeRequests;
-    private _scheduler;
-    constructor(dataProvider: TDataProvider, modelSource: TreeModelSource);
-    /** Disposes data source */
-    dispose(): void;
-    /**
-     * 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> implements IDisposable {
-    private _treeDataSource;
-    private _pageSize;
-    private _activePageRequests;
-    private _scheduler;
-    constructor(dataProvider: TDataProvider, modelSource: TreeModelSource, pageSize: number);
-    /** Disposes data source */
-    dispose(): void;
-    /** 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 implements IDisposable {
-    private _dataProvider;
-    private _disposeTreeNodesChangedListener?;
-    readonly onItemsChanged: BeEvent<TreeDataChangesListener>;
-    constructor(dataProvider: TreeDataProvider);
-    dispose(): void;
-    requestItems(parent: TreeNodeItem | undefined, firstItemIndex: number, numItems: number, requestNumChildren: boolean): RxjsObservable<TreeDataSourceResult>;
-    private getItems;
-    private getChildren;
-}
-export {};
+/** @packageDocumentation
+ * @module Tree
+ */
+import { Observable as RxjsObservable } from "rxjs/internal/Observable";
+import { BeEvent, IDisposable } from "@itwin/core-bentley";
+import { TreeDataChangesListener, TreeDataProvider, TreeNodeItem } from "../TreeDataProvider";
+import { Observable } from "./Observable";
+import { TreeModelNode, TreeModelRootNode, TreeNodeItemData } from "./TreeModel";
+import { 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> implements IDisposable {
+    private _treeDataSource;
+    private _activeRequests;
+    private _scheduler;
+    constructor(dataProvider: TDataProvider, modelSource: TreeModelSource);
+    /** Disposes data source */
+    dispose(): void;
+    /**
+     * 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> implements IDisposable {
+    private _treeDataSource;
+    private _pageSize;
+    private _activePageRequests;
+    private _scheduler;
+    constructor(dataProvider: TDataProvider, modelSource: TreeModelSource, pageSize: number);
+    /** Disposes data source */
+    dispose(): void;
+    /** 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 implements IDisposable {
+    private _dataProvider;
+    private _disposeTreeNodesChangedListener?;
+    readonly onItemsChanged: BeEvent<TreeDataChangesListener>;
+    constructor(dataProvider: TreeDataProvider);
+    dispose(): void;
+    requestItems(parent: TreeNodeItem | undefined, firstItemIndex: number, numItems: number, requestNumChildren: boolean): RxjsObservable<TreeDataSourceResult>;
+    private getItems;
+    private getChildren;
+}
+export {};
 //# sourceMappingURL=TreeNodeLoader.d.ts.map