@itwin/presentation-hierarchies-react 2.0.0-alpha.53 → 2.0.0-alpha.55

package/lib/presentation-hierarchies-react/internal/TreeActions.js

@@ -0,0 +1,295 @@
+import "./DisposePolyfill.js";
+import { createNodeId, sameNodes } from "./Utils.js";
+import { TreeLoader } from "./TreeLoader.js";
+import { TreeModel } from "./TreeModel.js";
+import { HierarchyNode } from "@itwin/presentation-hierarchies";
+import { enableMapSet, produce } from "immer";
+import { EMPTY, Subject, buffer, debounceTime, groupBy, map, mergeMap, reduce, switchMap, takeUntil, tap } from "rxjs";
+
+//#region src/presentation-hierarchies-react/internal/TreeActions.ts
+enableMapSet();
+/** @internal */
+var TreeActions = class {
+	_loader;
+	_nodeIdFactory;
+	_currentModel;
+	_reset = new Subject();
+	_nodeLoader;
+	constructor(_onModelChanged, _onLoad, _onHierarchyLimitExceeded, _onHierarchyLoadError, nodeIdFactory, seed) {
+		this._onModelChanged = _onModelChanged;
+		this._onLoad = _onLoad;
+		this._onHierarchyLimitExceeded = _onHierarchyLimitExceeded;
+		this._onHierarchyLoadError = _onHierarchyLoadError;
+		this._loader = new NoopTreeLoader();
+		this._nodeIdFactory = nodeIdFactory ?? createNodeId;
+		this._currentModel = seed ?? (		/* c8 ignore next */ {
+			idToNode: /* @__PURE__ */ new Map(),
+			parentChildMap: /* @__PURE__ */ new Map(),
+			rootNode: {
+				id: void 0,
+				nodeData: void 0
+			}
+		});
+		this._nodeLoader = this.createNodeLoader();
+	}
+	createNodeLoader() {
+		const subject = new Subject();
+		subject.pipe(groupBy((item) => item.parentId), mergeMap((group) => group.pipe(buffer(group.pipe(debounceTime(0))), map((groupArr) => {
+			let returnIndex = groupArr.length - 1;
+			groupArr.forEach((member, index) => {
+				if (member.discardState) returnIndex = index;
+			});
+			groupArr.forEach((member, index) => {
+				if (index === returnIndex) return;
+				member.timeTracker?.[Symbol.dispose];
+				member.onComplete();
+			});
+			return groupArr[returnIndex];
+		}), switchMap((props) => this._loader.loadNodes(props.loadOptions).pipe(collectTreePartsUntil(this._reset, props.initialRootNode), tap({
+			next: (newModel) => {
+				const parentNode = props.parentId ? newModel.idToNode.get(props.parentId) : newModel.rootNode;
+				this.handleLoadedHierarchy(props.parentId, newModel);
+				if (!(parentNode && parentNode.error)) props.timeTracker?.finish();
+			},
+			complete: () => {
+				this.onLoadingComplete(props.parentId);
+				props.timeTracker?.[Symbol.dispose]();
+				props.onComplete();
+			}
+		})))))).subscribe();
+		return subject;
+	}
+	updateTreeModel(updater) {
+		const newModel = produce(this._currentModel, updater);
+		if (this._currentModel === newModel) return;
+		this._currentModel = newModel;
+		this._onModelChanged(this._currentModel);
+	}
+	handleLoadedHierarchy(parentId, loadedHierarchy) {
+		this.updateTreeModel((model) => {
+			TreeModel.addHierarchyPart(model, parentId, loadedHierarchy);
+		});
+	}
+	onLoadingComplete(parentId) {
+		this.updateTreeModel((model) => {
+			TreeModel.setIsLoading(model, parentId, false);
+		});
+	}
+	getLoadAction(parentId) {
+		return this._currentModel.idToNode.size === 0 ? "initial-load" : parentId === void 0 ? "reload" : "hierarchy-level-load";
+	}
+	loadSubTree(options, initialRootNode, discardState) {
+		const loadAction = this.getLoadAction(options.parent.id);
+		const timeTracker = new TimeTracker((time) => this._onLoad(loadAction, time));
+		return { complete: new Promise((resolve) => {
+			this._nodeLoader.next({
+				loadOptions: options,
+				onComplete: resolve,
+				timeTracker,
+				parentId: options.parent.id,
+				initialRootNode,
+				discardState
+			});
+		}) };
+	}
+	loadNodes(parentId, ignoreCache) {
+		const parentNode = this._currentModel.idToNode.get(parentId);
+		/* c8 ignore next 3 */
+		if (!parentNode) return { complete: Promise.resolve() };
+		return this.loadSubTree({
+			parent: parentNode,
+			getHierarchyLevelOptions: (node) => createHierarchyLevelOptions(this._currentModel, getNonGroupedParentId(node, this._nodeIdFactory)),
+			shouldLoadChildren: (node) => !!node.nodeData.autoExpand,
+			ignoreCache
+		});
+	}
+	reloadSubTree(parentId, oldModel, options) {
+		const currModel = this._currentModel;
+		const expandedNodes = !!options?.discardState ? [] : collectNodes(parentId, oldModel, (node) => node.isExpanded === true);
+		const collapsedNodes = !!options?.discardState ? [] : collectNodes(parentId, oldModel, (node) => node.isExpanded === false);
+		const getHierarchyLevelOptions = (node) => {
+			if (!!options?.discardState) return {
+				instanceFilter: void 0,
+				hierarchyLevelSizeLimit: void 0
+			};
+			const filteredNodeId = getNonGroupedParentId(node, this._nodeIdFactory);
+			return createHierarchyLevelOptions(filteredNodeId === parentId ? currModel : oldModel, filteredNodeId);
+		};
+		const shouldLoadChildren = (node) => {
+			if (expandedNodes.findIndex((expandedNode) => sameNodes(expandedNode.nodeData, node.nodeData)) !== -1) return true;
+			if (collapsedNodes.findIndex((collapsedNode) => sameNodes(collapsedNode.nodeData, node.nodeData)) !== -1) return false;
+			return !!node.nodeData.autoExpand;
+		};
+		const buildNode = (node) => !!options?.discardState || node.id === parentId ? node : addAttributes(node, oldModel);
+		const rootNode = parentId !== void 0 ? this.getNode(parentId) : currModel.rootNode;
+		/* c8 ignore next 3 */
+		if (!rootNode) return { complete: Promise.resolve() };
+		if (parentId === void 0) this._reset.next();
+		return this.loadSubTree({
+			parent: rootNode,
+			getHierarchyLevelOptions,
+			shouldLoadChildren,
+			buildNode,
+			ignoreCache: options?.ignoreCache
+		}, !!options?.discardState ? void 0 : { ...currModel.rootNode }, options?.discardState);
+	}
+	reset() {
+		this._reset.next();
+	}
+	setHierarchyProvider(provider) {
+		this._loader = provider ? new TreeLoader(provider, this._onHierarchyLimitExceeded, ({ parentId, type, error }) => {
+			if (type === "timeout") {
+				const loadAction = this.getLoadAction(parentId);
+				this._onLoad(loadAction, Number.MAX_SAFE_INTEGER);
+			}
+			this._onHierarchyLoadError({
+				parentId,
+				type,
+				error
+			});
+		}, this._nodeIdFactory) : new NoopTreeLoader();
+	}
+	getNode(nodeId) {
+		return TreeModel.getNode(this._currentModel, nodeId);
+	}
+	selectNodes(nodeIds, changeType) {
+		this.updateTreeModel((model) => {
+			TreeModel.selectNodes(model, nodeIds, changeType);
+		});
+	}
+	expandNode(nodeId, isExpanded) {
+		let childrenAction = "none";
+		this.updateTreeModel((model) => {
+			childrenAction = TreeModel.expandNode(model, nodeId, isExpanded);
+		});
+		if (childrenAction === "none") return { complete: Promise.resolve() };
+		return this.loadNodes(nodeId, childrenAction === "reloadChildren");
+	}
+	setHierarchyLimit(nodeId, limit) {
+		const oldModel = this._currentModel;
+		let loadChildren = false;
+		this.updateTreeModel((model) => {
+			loadChildren = TreeModel.setHierarchyLimit(model, nodeId, limit);
+		});
+		if (!loadChildren) return { complete: Promise.resolve() };
+		return this.reloadSubTree(nodeId, oldModel);
+	}
+	setInstanceFilter(nodeId, filter) {
+		const oldModel = this._currentModel;
+		let loadChildren = false;
+		this.updateTreeModel((model) => {
+			loadChildren = TreeModel.setInstanceFilter(model, nodeId, filter);
+		});
+		if (!loadChildren) return { complete: Promise.resolve() };
+		return this.reloadSubTree(nodeId, oldModel);
+	}
+	reloadTree(options) {
+		const oldModel = this._currentModel;
+		this.updateTreeModel((model) => {
+			TreeModel.setIsLoading(model, options?.parentNodeId, true);
+			if (options?.state === "reset") TreeModel.removeSubTree(model, options.parentNodeId);
+		});
+		const discardState = options?.state === "discard" || options?.state === "reset";
+		const ignoreCache = options?.state === "reset";
+		return this.reloadSubTree(options?.parentNodeId, oldModel, {
+			discardState,
+			ignoreCache
+		});
+	}
+};
+function collectTreePartsUntil(untilNotifier, rootNode) {
+	return (source) => source.pipe(reduce((treeModel, loadedPart) => {
+		addTreePartToModel(treeModel, loadedPart);
+		return treeModel;
+	}, {
+		idToNode: /* @__PURE__ */ new Map(),
+		parentChildMap: /* @__PURE__ */ new Map(),
+		rootNode: rootNode ?? {
+			id: void 0,
+			nodeData: void 0
+		}
+	}), takeUntil(untilNotifier));
+}
+function addTreePartToModel(treeModel, loadedPart) {
+	if ("loadedNodes" in loadedPart) addNodesToModel(treeModel, loadedPart);
+	else addErrorToModel(treeModel, loadedPart);
+}
+function addErrorToModel(model, loadedPart) {
+	if (loadedPart.parent.id === void 0) model.rootNode.error = loadedPart.error;
+	else model.idToNode.set(loadedPart.parent.id, {
+		...loadedPart.parent,
+		error: loadedPart.error
+	});
+}
+function addNodesToModel(model, loadedPart) {
+	model.parentChildMap.set(loadedPart.parent.id, loadedPart.loadedNodes.map((node) => node.id));
+	for (const node of loadedPart.loadedNodes) model.idToNode.set(node.id, node);
+	const parentNode = loadedPart.parent.id ? model.idToNode.get(loadedPart.parent.id) : void 0;
+	if (parentNode && loadedPart.loadedNodes.length !== 0) parentNode.isExpanded = true;
+}
+function addAttributes(node, oldModel) {
+	const oldNode = oldModel.idToNode.get(node.id);
+	if (oldNode) {
+		node.hierarchyLimit = oldNode.hierarchyLimit;
+		node.instanceFilter = oldNode.instanceFilter;
+		node.isSelected = oldNode.isSelected;
+	}
+	return node;
+}
+function collectNodes(parentId, model, pred) {
+	const currentChildren = model.parentChildMap.get(parentId);
+	if (!currentChildren) return [];
+	if (parentId === void 0) return currentChildren.flatMap((child) => collectNodes(child, model, pred));
+	const currNode = model.idToNode.get(parentId);
+	if (!currNode || !pred(currNode)) return [];
+	return [currNode, ...currentChildren.flatMap((child) => collectNodes(child, model, pred))];
+}
+function getNonGroupedParentId(node, nodeIdFactory) {
+	if (!node.nodeData || !HierarchyNode.isGroupingNode(node.nodeData)) return node.id;
+	if (!node.nodeData.nonGroupingAncestor) return;
+	return nodeIdFactory(node.nodeData.nonGroupingAncestor);
+}
+function createHierarchyLevelOptions(model, nodeId) {
+	if (nodeId === void 0) return {
+		instanceFilter: model.rootNode.instanceFilter,
+		hierarchyLevelSizeLimit: model.rootNode.hierarchyLimit
+	};
+	const modelNode = model.idToNode.get(nodeId);
+	if (!modelNode) return {
+		instanceFilter: void 0,
+		hierarchyLevelSizeLimit: void 0
+	};
+	return {
+		instanceFilter: modelNode.instanceFilter,
+		hierarchyLevelSizeLimit: modelNode.hierarchyLimit
+	};
+}
+/* c8 ignore start */
+var NoopTreeLoader = class {
+	loadNodes() {
+		return EMPTY;
+	}
+};
+/* c8 ignore end */
+var TimeTracker = class {
+	_start;
+	_stopped = false;
+	constructor(_onFinish) {
+		this._onFinish = _onFinish;
+		this._start = Date.now();
+	}
+	[Symbol.dispose]() {
+		this._stopped = true;
+	}
+	finish() {
+		/* c8 ignore next 3 */
+		if (this._stopped) return;
+		this._stopped = true;
+		const elapsedTime = Date.now() - this._start;
+		this._onFinish(elapsedTime);
+	}
+};
+
+//#endregion
+export { TreeActions };
+//# sourceMappingURL=TreeActions.js.map

package/lib/presentation-hierarchies-react/internal/TreeActions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeActions.js","names":["enableMapSet","produce","buffer","debounceTime","EMPTY","groupBy","map","mergeMap","reduce","Subject","switchMap","takeUntil","tap","HierarchyNode","TreeLoader","TreeModel","createNodeId","sameNodes","Draft","Observable","GenericInstanceFilter","HierarchyProvider","ErrorInfo","SelectionChangeType","HierarchyLevelOptions","ITreeLoader","LoadedTreePart","LoadNodesOptions","TreeModelHierarchyNode","TreeModelRootNode","LoadDebouncedNodesOptions","loadOptions","onComplete","timeTracker","TimeTracker","initialRootNode","parentId","discardState","TreeActions","_loader","_nodeIdFactory","node","Pick","_currentModel","_reset","_nodeLoader","constructor","_onModelChanged","model","_onLoad","actionType","duration","_onHierarchyLimitExceeded","props","filter","limit","_onHierarchyLoadError","type","error","nodeIdFactory","seed","NoopTreeLoader","idToNode","Map","parentChildMap","rootNode","id","undefined","nodeData","createNodeLoader","subject","pipe","item","group","groupArr","returnIndex","length","forEach","member","index","Symbol","dispose","loadNodes","collectTreePartsUntil","next","newModel","parentNode","get","handleLoadedHierarchy","finish","complete","onLoadingComplete","subscribe","updateTreeModel","updater","loadedHierarchy","addHierarchyPart","setIsLoading","getLoadAction","size","loadSubTree","options","loadAction","parent","time","Promise","resolve","ignoreCache","getHierarchyLevelOptions","createHierarchyLevelOptions","getNonGroupedParentId","shouldLoadChildren","autoExpand","reloadSubTree","oldModel","currModel","expandedNodes","collectNodes","isExpanded","collapsedNodes","instanceFilter","hierarchyLevelSizeLimit","filteredNodeId","findIndex","expandedNode","collapsedNode","buildNode","addAttributes","getNode","reset","setHierarchyProvider","provider","Number","MAX_SAFE_INTEGER","nodeId","selectNodes","nodeIds","Array","changeType","expandNode","childrenAction","ReturnType","setHierarchyLimit","loadChildren","setInstanceFilter","reloadTree","parentNodeId","state","removeSubTree","untilNotifier","source","treeModel","loadedPart","addTreePartToModel","addNodesToModel","addErrorToModel","set","loadedNodes","oldNode","hierarchyLimit","isSelected","pred","currentChildren","flatMap","child","currNode","isGroupingNode","nonGroupingAncestor","modelNode","_start","_stopped","_onFinish","Date","now","elapsedTime"],"sources":["../../../src/presentation-hierarchies-react/internal/TreeActions.ts"],"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\nimport \"./DisposePolyfill.js\";\n\nimport { enableMapSet, produce } from \"immer\";\nimport { buffer, debounceTime, EMPTY, groupBy, map, mergeMap, reduce, Subject, switchMap, takeUntil, tap } from \"rxjs\";\nimport { HierarchyNode } from \"@itwin/presentation-hierarchies\";\nimport { TreeLoader } from \"./TreeLoader.js\";\nimport { TreeModel } from \"./TreeModel.js\";\nimport { createNodeId, sameNodes } from \"./Utils.js\";\n\nimport type { Draft } from \"immer\";\nimport type { Observable } from \"rxjs\";\nimport type { GenericInstanceFilter, HierarchyProvider } from \"@itwin/presentation-hierarchies\";\nimport type { ErrorInfo } from \"../TreeNode.js\";\nimport type { SelectionChangeType } from \"../UseSelectionHandler.js\";\nimport type { HierarchyLevelOptions, ITreeLoader, LoadedTreePart, LoadNodesOptions } from \"./TreeLoader.js\";\nimport type { TreeModelHierarchyNode, TreeModelRootNode } from \"./TreeModel.js\";\n\nenableMapSet();\n\ninterface LoadDebouncedNodesOptions {\n  loadOptions: LoadNodesOptions;\n  onComplete: () => void;\n  timeTracker?: TimeTracker;\n  initialRootNode?: TreeModelRootNode;\n  parentId?: string;\n  discardState?: boolean;\n}\n\n/** @internal */\nexport class TreeActions {\n  private _loader: ITreeLoader;\n  private _nodeIdFactory: (node: Pick<HierarchyNode, \"key\" | \"parentKeys\">) => string;\n  private _currentModel: TreeModel;\n  private _reset = new Subject<void>();\n  private _nodeLoader: Subject<LoadDebouncedNodesOptions>;\n\n  constructor(\n    private _onModelChanged: (model: TreeModel) => void,\n    private _onLoad: (actionType: \"initial-load\" | \"hierarchy-level-load\" | \"reload\", duration: number) => void,\n    private _onHierarchyLimitExceeded: (props: { parentId?: string; filter?: GenericInstanceFilter; limit?: number | \"unbounded\" }) => void,\n    private _onHierarchyLoadError: (props: { parentId?: string; type: \"timeout\" | \"unknown\"; error: unknown }) => void,\n    nodeIdFactory?: (node: Pick<HierarchyNode, \"key\" | \"parentKeys\">) => string,\n    seed?: TreeModel,\n  ) {\n    this._loader = new NoopTreeLoader();\n    this._nodeIdFactory = nodeIdFactory ?? createNodeId;\n    this._currentModel = seed ?? /* c8 ignore next */ {\n      idToNode: new Map(),\n      parentChildMap: new Map(),\n      rootNode: { id: undefined, nodeData: undefined },\n    };\n\n    this._nodeLoader = this.createNodeLoader();\n  }\n\n  private createNodeLoader() {\n    const subject = new Subject<LoadDebouncedNodesOptions>();\n    subject\n      .pipe(\n        groupBy((item) => item.parentId),\n        mergeMap((group) =>\n          group.pipe(\n            buffer(group.pipe(debounceTime(0))),\n            map((groupArr) => {\n              let returnIndex = groupArr.length - 1;\n\n              groupArr.forEach((member, index) => {\n                if (member.discardState) {\n                  returnIndex = index;\n                }\n              });\n\n              groupArr.forEach((member, index) => {\n                if (index === returnIndex) {\n                  return;\n                }\n                member.timeTracker?.[Symbol.dispose];\n                member.onComplete();\n              });\n              return groupArr[returnIndex];\n            }),\n            switchMap((props) =>\n              this._loader.loadNodes(props.loadOptions).pipe(\n                collectTreePartsUntil(this._reset, props.initialRootNode),\n                tap({\n                  next: (newModel: TreeModel) => {\n                    const parentNode = props.parentId ? newModel.idToNode.get(props.parentId) : newModel.rootNode;\n                    this.handleLoadedHierarchy(props.parentId, newModel);\n                    // only report load duration if children were loaded\n                    if (!(parentNode && parentNode.error)) {\n                      props.timeTracker?.finish();\n                    }\n                  },\n                  complete: () => {\n                    this.onLoadingComplete(props.parentId);\n                    props.timeTracker?.[Symbol.dispose]();\n                    props.onComplete();\n                  },\n                }),\n              ),\n            ),\n          ),\n        ),\n      )\n      .subscribe();\n\n    return subject;\n  }\n\n  private updateTreeModel(updater: (model: Draft<TreeModel>) => void) {\n    const newModel = produce(this._currentModel, updater);\n    if (this._currentModel === newModel) {\n      return;\n    }\n\n    this._currentModel = newModel;\n    this._onModelChanged(this._currentModel);\n  }\n\n  private handleLoadedHierarchy(parentId: string | undefined, loadedHierarchy: TreeModel) {\n    this.updateTreeModel((model) => {\n      TreeModel.addHierarchyPart(model, parentId, loadedHierarchy);\n    });\n  }\n\n  private onLoadingComplete(parentId: string | undefined) {\n    this.updateTreeModel((model) => {\n      TreeModel.setIsLoading(model, parentId, false);\n    });\n  }\n\n  private getLoadAction(parentId: string | undefined) {\n    return this._currentModel.idToNode.size === 0 ? \"initial-load\" : parentId === undefined ? \"reload\" : \"hierarchy-level-load\";\n  }\n\n  private loadSubTree(options: LoadNodesOptions, initialRootNode?: TreeModelRootNode, discardState?: boolean) {\n    const loadAction = this.getLoadAction(options.parent.id);\n    const timeTracker = new TimeTracker((time) => this._onLoad(loadAction, time));\n\n    return {\n      complete: new Promise<void>((resolve) => {\n        this._nodeLoader.next({ loadOptions: options, onComplete: resolve, timeTracker, parentId: options.parent.id, initialRootNode, discardState });\n      }),\n    };\n  }\n\n  private loadNodes(parentId: string, ignoreCache?: boolean) {\n    const parentNode = this._currentModel.idToNode.get(parentId);\n    /* c8 ignore next 3 */\n    if (!parentNode) {\n      return { complete: Promise.resolve() };\n    }\n    return this.loadSubTree({\n      parent: parentNode,\n      getHierarchyLevelOptions: (node) => createHierarchyLevelOptions(this._currentModel, getNonGroupedParentId(node, this._nodeIdFactory)),\n      shouldLoadChildren: (node) => !!node.nodeData.autoExpand,\n      ignoreCache,\n    });\n  }\n\n  private reloadSubTree(parentId: string | undefined, oldModel: TreeModel, options?: { discardState?: boolean; ignoreCache?: boolean }) {\n    const currModel = this._currentModel;\n    const expandedNodes = !!options?.discardState ? [] : collectNodes(parentId, oldModel, (node) => node.isExpanded === true);\n    const collapsedNodes = !!options?.discardState ? [] : collectNodes(parentId, oldModel, (node) => node.isExpanded === false);\n    const getHierarchyLevelOptions = (node: TreeModelRootNode | TreeModelHierarchyNode) => {\n      if (!!options?.discardState) {\n        return { instanceFilter: undefined, hierarchyLevelSizeLimit: undefined };\n      }\n      const filteredNodeId = getNonGroupedParentId(node, this._nodeIdFactory);\n      return createHierarchyLevelOptions(filteredNodeId === parentId ? currModel : oldModel, filteredNodeId);\n    };\n    const shouldLoadChildren = (node: TreeModelHierarchyNode) => {\n      if (expandedNodes.findIndex((expandedNode) => sameNodes(expandedNode.nodeData, node.nodeData)) !== -1) {\n        return true;\n      }\n      if (collapsedNodes.findIndex((collapsedNode) => sameNodes(collapsedNode.nodeData, node.nodeData)) !== -1) {\n        return false;\n      }\n      return !!node.nodeData.autoExpand;\n    };\n    const buildNode = (node: TreeModelHierarchyNode) => (!!options?.discardState || node.id === parentId ? node : addAttributes(node, oldModel));\n\n    const rootNode = parentId !== undefined ? this.getNode(parentId) : currModel.rootNode;\n    /* c8 ignore next 3 */\n    if (!rootNode) {\n      return { complete: Promise.resolve() };\n    }\n\n    if (parentId === undefined) {\n      // cancel all ongoing requests\n      this._reset.next();\n    }\n\n    return this.loadSubTree(\n      { parent: rootNode, getHierarchyLevelOptions, shouldLoadChildren, buildNode, ignoreCache: options?.ignoreCache },\n      !!options?.discardState ? undefined : { ...currModel.rootNode },\n      options?.discardState,\n    );\n  }\n\n  public reset() {\n    this._reset.next();\n  }\n\n  public setHierarchyProvider(provider?: HierarchyProvider) {\n    this._loader = provider\n      ? new TreeLoader(\n          provider,\n          this._onHierarchyLimitExceeded,\n          ({ parentId, type, error }) => {\n            if (type === \"timeout\") {\n              const loadAction = this.getLoadAction(parentId);\n              this._onLoad(loadAction, Number.MAX_SAFE_INTEGER);\n            }\n            this._onHierarchyLoadError({ parentId, type, error });\n          },\n          this._nodeIdFactory,\n        )\n      : /* c8 ignore next */ new NoopTreeLoader();\n  }\n\n  public getNode(nodeId: string | undefined): TreeModelHierarchyNode | TreeModelRootNode | undefined {\n    return TreeModel.getNode(this._currentModel, nodeId);\n  }\n\n  public selectNodes(nodeIds: Array<string>, changeType: SelectionChangeType) {\n    this.updateTreeModel((model) => {\n      TreeModel.selectNodes(model, nodeIds, changeType);\n    });\n  }\n\n  public expandNode(nodeId: string, isExpanded: boolean) {\n    let childrenAction = \"none\" as ReturnType<typeof TreeModel.expandNode>;\n    this.updateTreeModel((model) => {\n      childrenAction = TreeModel.expandNode(model, nodeId, isExpanded);\n    });\n\n    if (childrenAction === \"none\") {\n      return { complete: Promise.resolve() };\n    }\n\n    return this.loadNodes(nodeId, childrenAction === \"reloadChildren\");\n  }\n\n  public setHierarchyLimit(nodeId: string | undefined, limit?: number | \"unbounded\") {\n    const oldModel = this._currentModel;\n    let loadChildren = false as boolean;\n    this.updateTreeModel((model) => {\n      loadChildren = TreeModel.setHierarchyLimit(model, nodeId, limit);\n    });\n\n    if (!loadChildren) {\n      return { complete: Promise.resolve() };\n    }\n\n    return this.reloadSubTree(nodeId, oldModel);\n  }\n\n  public setInstanceFilter(nodeId: string | undefined, filter?: GenericInstanceFilter) {\n    const oldModel = this._currentModel;\n    let loadChildren = false as boolean;\n    this.updateTreeModel((model) => {\n      loadChildren = TreeModel.setInstanceFilter(model, nodeId, filter);\n    });\n\n    if (!loadChildren) {\n      return { complete: Promise.resolve() };\n    }\n\n    return this.reloadSubTree(nodeId, oldModel);\n  }\n\n  public reloadTree(options?: { parentNodeId?: string; state?: \"keep\" | \"discard\" | \"reset\" }) {\n    const oldModel = this._currentModel;\n    this.updateTreeModel((model) => {\n      TreeModel.setIsLoading(model, options?.parentNodeId, true);\n      if (options?.state === \"reset\") {\n        TreeModel.removeSubTree(model, options.parentNodeId);\n      }\n    });\n\n    const discardState = options?.state === \"discard\" || options?.state === \"reset\";\n    const ignoreCache = options?.state === \"reset\";\n    return this.reloadSubTree(options?.parentNodeId, oldModel, { discardState, ignoreCache });\n  }\n}\n\nfunction collectTreePartsUntil(untilNotifier: Observable<void>, rootNode?: TreeModelRootNode) {\n  return (source: Observable<LoadedTreePart>) =>\n    source.pipe(\n      reduce<LoadedTreePart, TreeModel>(\n        (treeModel, loadedPart) => {\n          addTreePartToModel(treeModel, loadedPart);\n          return treeModel;\n        },\n        {\n          idToNode: new Map(),\n          parentChildMap: new Map(),\n          rootNode: rootNode ?? { id: undefined, nodeData: undefined },\n        },\n      ),\n      takeUntil(untilNotifier),\n    );\n}\n\nfunction addTreePartToModel(treeModel: TreeModel, loadedPart: LoadedTreePart) {\n  if (\"loadedNodes\" in loadedPart) {\n    addNodesToModel(treeModel, loadedPart);\n  } else {\n    addErrorToModel(treeModel, loadedPart);\n  }\n}\n\nfunction addErrorToModel(model: TreeModel, loadedPart: { parent: TreeModelHierarchyNode | TreeModelRootNode; error: ErrorInfo }) {\n  if (loadedPart.parent.id === undefined) {\n    model.rootNode.error = loadedPart.error;\n  } else {\n    model.idToNode.set(loadedPart.parent.id, { ...loadedPart.parent, error: loadedPart.error });\n  }\n}\n\nfunction addNodesToModel(model: TreeModel, loadedPart: { parent: TreeModelHierarchyNode | TreeModelRootNode; loadedNodes: TreeModelHierarchyNode[] }) {\n  model.parentChildMap.set(\n    loadedPart.parent.id,\n    loadedPart.loadedNodes.map((node) => node.id),\n  );\n  for (const node of loadedPart.loadedNodes) {\n    model.idToNode.set(node.id, node);\n  }\n  const parentNode = loadedPart.parent.id ? model.idToNode.get(loadedPart.parent.id) : undefined;\n  if (parentNode && loadedPart.loadedNodes.length !== 0) {\n    parentNode.isExpanded = true;\n  }\n}\n\nfunction addAttributes(node: TreeModelHierarchyNode, oldModel: TreeModel) {\n  const oldNode = oldModel.idToNode.get(node.id);\n  if (oldNode) {\n    node.hierarchyLimit = oldNode.hierarchyLimit;\n    node.instanceFilter = oldNode.instanceFilter;\n    node.isSelected = oldNode.isSelected;\n  }\n  return node;\n}\n\nfunction collectNodes(parentId: string | undefined, model: TreeModel, pred: (node: TreeModelHierarchyNode) => boolean): TreeModelHierarchyNode[] {\n  const currentChildren = model.parentChildMap.get(parentId);\n  if (!currentChildren) {\n    return [];\n  }\n\n  if (parentId === undefined) {\n    return currentChildren.flatMap((child) => collectNodes(child, model, pred));\n  }\n\n  const currNode = model.idToNode.get(parentId);\n  if (!currNode || !pred(currNode)) {\n    return [];\n  }\n\n  return [currNode, ...currentChildren.flatMap((child) => collectNodes(child, model, pred))];\n}\n\nfunction getNonGroupedParentId(node: TreeModelHierarchyNode | TreeModelRootNode, nodeIdFactory: (node: Pick<HierarchyNode, \"key\" | \"parentKeys\">) => string) {\n  if (!node.nodeData || !HierarchyNode.isGroupingNode(node.nodeData)) {\n    return node.id;\n  }\n\n  if (!node.nodeData.nonGroupingAncestor) {\n    return undefined;\n  }\n\n  return nodeIdFactory(node.nodeData.nonGroupingAncestor);\n}\n\nfunction createHierarchyLevelOptions(model: TreeModel, nodeId: string | undefined): HierarchyLevelOptions {\n  if (nodeId === undefined) {\n    return { instanceFilter: model.rootNode.instanceFilter, hierarchyLevelSizeLimit: model.rootNode.hierarchyLimit };\n  }\n\n  const modelNode = model.idToNode.get(nodeId);\n  if (!modelNode) {\n    return { instanceFilter: undefined, hierarchyLevelSizeLimit: undefined };\n  }\n  return { instanceFilter: modelNode.instanceFilter, hierarchyLevelSizeLimit: modelNode.hierarchyLimit };\n}\n\n/* c8 ignore start */\nclass NoopTreeLoader implements ITreeLoader {\n  public loadNodes(): Observable<LoadedTreePart> {\n    return EMPTY;\n  }\n}\n/* c8 ignore end */\n\nclass TimeTracker {\n  private _start: number;\n  private _stopped: boolean = false;\n\n  constructor(private _onFinish: (time: number) => void) {\n    this._start = Date.now();\n  }\n\n  public [Symbol.dispose]() {\n    this._stopped = true;\n  }\n\n  public finish() {\n    /* c8 ignore next 3 */\n    if (this._stopped) {\n      return;\n    }\n\n    this._stopped = true;\n    const elapsedTime = Date.now() - this._start;\n    this._onFinish(elapsedTime);\n  }\n}\n"],"mappings":"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"}

package/lib/presentation-hierarchies-react/internal/TreeLoader.js

@@ -0,0 +1,99 @@
+import { createNodeId } from "./Utils.js";
+import { EMPTY, catchError, expand, filter, from, map, mergeMap, of, toArray } from "rxjs";
+
+//#region src/presentation-hierarchies-react/internal/TreeLoader.ts
+/** @internal */
+var TreeLoader = class {
+	_treeNodeIdFactory;
+	constructor(_hierarchyProvider, _onHierarchyLimitExceeded, _onHierarchyLoadError, treeNodeIdFactory) {
+		this._hierarchyProvider = _hierarchyProvider;
+		this._onHierarchyLimitExceeded = _onHierarchyLimitExceeded;
+		this._onHierarchyLoadError = _onHierarchyLoadError;
+		this._treeNodeIdFactory = treeNodeIdFactory ?? createNodeId;
+	}
+	loadChildren({ parent, getHierarchyLevelOptions, buildNode, ignoreCache }) {
+		const { instanceFilter, hierarchyLevelSizeLimit } = getHierarchyLevelOptions(parent);
+		const infoNodeIdBase = `${parent.id ?? "<root>"}`;
+		const treeModelNodesFactory = createTreeModelNodesFactory({
+			buildNode,
+			treeNodeIdFactory: this._treeNodeIdFactory
+		});
+		return from(this._hierarchyProvider.getNodes({
+			parentNode: parent.nodeData,
+			hierarchyLevelSizeLimit,
+			instanceFilter,
+			ignoreCache
+		})).pipe(toArray(), map((childNodes) => {
+			return instanceFilter && childNodes.length === 0 ? {
+				parent,
+				error: {
+					id: `${infoNodeIdBase}-no-filter-matches`,
+					type: "NoFilterMatches"
+				}
+			} : {
+				parent,
+				loadedNodes: childNodes.map(treeModelNodesFactory)
+			};
+		}), catchError((err) => {
+			let hierarchyLoadErrorType = "unknown";
+			if (err instanceof Error) {
+				if (isRowsLimitError(err)) {
+					this._onHierarchyLimitExceeded({
+						parentId: parent.id,
+						filter: instanceFilter,
+						limit: err.limit
+					});
+					return of({
+						parent,
+						error: {
+							id: `${infoNodeIdBase}-${err.message}`,
+							type: "ResultSetTooLarge",
+							resultSetSizeLimit: err.limit
+						}
+					});
+				}
+				if (isTimeoutError(err)) hierarchyLoadErrorType = "timeout";
+			}
+			this._onHierarchyLoadError({
+				parentId: parent.id,
+				type: hierarchyLoadErrorType,
+				error: err
+			});
+			return of({
+				parent,
+				error: {
+					id: `${infoNodeIdBase}-ChildrenLoad`,
+					type: "ChildrenLoad",
+					message: "Failed to create hierarchy level"
+				}
+			});
+		}));
+	}
+	loadNodes({ shouldLoadChildren, ...options }) {
+		return this.loadChildren(options).pipe(expand((loadedPart) => "loadedNodes" in loadedPart ? from(loadedPart.loadedNodes).pipe(filter((node) => shouldLoadChildren(node)), mergeMap((node) => this.loadChildren({
+			...options,
+			parent: node
+		}))) : EMPTY));
+	}
+};
+function createTreeModelNodesFactory({ buildNode, treeNodeIdFactory }) {
+	return (node) => {
+		const modelNode = {
+			id: treeNodeIdFactory(node),
+			children: node.children,
+			label: node.label,
+			nodeData: node
+		};
+		return buildNode ? buildNode(modelNode) : modelNode;
+	};
+}
+function isRowsLimitError(error) {
+	return "limit" in error && error.message.includes("Query rows limit of");
+}
+function isTimeoutError(error) {
+	return error.message.includes("query too long to execute or server is too busy");
+}
+
+//#endregion
+export { TreeLoader };
+//# sourceMappingURL=TreeLoader.js.map

package/lib/presentation-hierarchies-react/internal/TreeLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeLoader.js","names":["catchError","EMPTY","expand","filter","from","map","mergeMap","of","toArray","createNodeId","Observable","GenericInstanceFilter","HierarchyNode","HierarchyProvider","RowsLimitExceededError","ErrorInfo","TreeModelHierarchyNode","TreeModelRootNode","LoadedTreePart","parent","loadedNodes","error","HierarchyLevelOptions","instanceFilter","hierarchyLevelSizeLimit","LoadNodesOptions","getHierarchyLevelOptions","node","shouldLoadChildren","buildNode","ignoreCache","ITreeLoader","loadNodes","options","TreeLoader","_treeNodeIdFactory","Pick","constructor","_hierarchyProvider","_onHierarchyLimitExceeded","props","parentId","limit","_onHierarchyLoadError","type","treeNodeIdFactory","loadChildren","Omit","infoNodeIdBase","id","treeModelNodesFactory","createTreeModelNodesFactory","getNodes","parentNode","nodeData","pipe","childNodes","length","const","err","hierarchyLoadErrorType","Error","isRowsLimitError","message","resultSetSizeLimit","isTimeoutError","loadedPart","modelNode","children","label","includes"],"sources":["../../../src/presentation-hierarchies-react/internal/TreeLoader.ts"],"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\nimport { catchError, EMPTY, expand, filter, from, map, mergeMap, of, toArray } from \"rxjs\";\nimport { createNodeId } from \"./Utils.js\";\n\nimport type { Observable } from \"rxjs\";\nimport type { GenericInstanceFilter, HierarchyNode, HierarchyProvider, RowsLimitExceededError } from \"@itwin/presentation-hierarchies\";\nimport type { ErrorInfo } from \"../TreeNode.js\";\nimport type { TreeModelHierarchyNode, TreeModelRootNode } from \"./TreeModel.js\";\n\n/** @internal */\nexport type LoadedTreePart = {\n  parent: TreeModelHierarchyNode | TreeModelRootNode;\n} & (\n  | {\n      loadedNodes: TreeModelHierarchyNode[];\n    }\n  | {\n      error: ErrorInfo;\n    }\n);\n\n/** @internal */\nexport interface HierarchyLevelOptions {\n  instanceFilter?: GenericInstanceFilter;\n  hierarchyLevelSizeLimit?: number | \"unbounded\";\n}\n\n/** @internal */\nexport interface LoadNodesOptions {\n  parent: TreeModelHierarchyNode | TreeModelRootNode;\n  getHierarchyLevelOptions: (node: TreeModelRootNode | TreeModelHierarchyNode) => HierarchyLevelOptions;\n  shouldLoadChildren: (node: TreeModelHierarchyNode) => boolean;\n  buildNode?: (node: TreeModelHierarchyNode) => TreeModelHierarchyNode;\n  ignoreCache?: boolean;\n}\n\n/** @internal */\nexport interface ITreeLoader {\n  loadNodes(options: LoadNodesOptions): Observable<LoadedTreePart>;\n}\n\n/** @internal */\nexport class TreeLoader implements ITreeLoader {\n  private _treeNodeIdFactory: (node: Pick<HierarchyNode, \"key\" | \"parentKeys\">) => string;\n\n  constructor(\n    private _hierarchyProvider: HierarchyProvider,\n    private _onHierarchyLimitExceeded: (props: { parentId?: string; filter?: GenericInstanceFilter; limit?: number | \"unbounded\" }) => void,\n    private _onHierarchyLoadError: (props: { parentId?: string; type: \"timeout\" | \"unknown\"; error: unknown }) => void,\n    treeNodeIdFactory?: (node: Pick<HierarchyNode, \"key\" | \"parentKeys\">) => string,\n  ) {\n    this._treeNodeIdFactory = treeNodeIdFactory ?? /* c8 ignore next */ createNodeId;\n  }\n\n  private loadChildren({ parent, getHierarchyLevelOptions, buildNode, ignoreCache }: Omit<LoadNodesOptions, \"shouldLoadChildren\">) {\n    const { instanceFilter, hierarchyLevelSizeLimit } = getHierarchyLevelOptions(parent);\n    const infoNodeIdBase = `${parent.id ?? \"<root>\"}`;\n    const treeModelNodesFactory = createTreeModelNodesFactory({ buildNode, treeNodeIdFactory: this._treeNodeIdFactory });\n    return from(\n      this._hierarchyProvider.getNodes({\n        parentNode: parent.nodeData,\n        hierarchyLevelSizeLimit,\n        instanceFilter,\n        ignoreCache,\n      }),\n    ).pipe(\n      toArray(),\n      map((childNodes): LoadedTreePart => {\n        return instanceFilter && childNodes.length === 0\n          ? {\n              parent,\n              error: {\n                id: `${infoNodeIdBase}-no-filter-matches`,\n                type: \"NoFilterMatches\" as const,\n              },\n            }\n          : {\n              parent,\n              loadedNodes: childNodes.map(treeModelNodesFactory),\n            };\n      }),\n      catchError((err) => {\n        let hierarchyLoadErrorType: \"unknown\" | \"timeout\" = \"unknown\";\n        if (err instanceof Error) {\n          if (isRowsLimitError(err)) {\n            this._onHierarchyLimitExceeded({ parentId: parent.id, filter: instanceFilter, limit: err.limit });\n            return of({\n              parent,\n              error: { id: `${infoNodeIdBase}-${err.message}`, type: \"ResultSetTooLarge\" as const, resultSetSizeLimit: err.limit },\n            });\n          }\n          if (isTimeoutError(err)) {\n            hierarchyLoadErrorType = \"timeout\";\n          }\n        }\n\n        this._onHierarchyLoadError({ parentId: parent.id, type: hierarchyLoadErrorType, error: err });\n        return of({\n          parent,\n          error: {\n            id: `${infoNodeIdBase}-ChildrenLoad`,\n            type: \"ChildrenLoad\" as const,\n            message: \"Failed to create hierarchy level\",\n          },\n        });\n      }),\n    );\n  }\n\n  public loadNodes({ shouldLoadChildren, ...options }: LoadNodesOptions) {\n    return this.loadChildren(options).pipe(\n      expand((loadedPart) =>\n        \"loadedNodes\" in loadedPart\n          ? from(loadedPart.loadedNodes).pipe(\n              filter((node) => shouldLoadChildren(node)),\n              mergeMap((node) => this.loadChildren({ ...options, parent: node })),\n            )\n          : EMPTY,\n      ),\n    );\n  }\n}\n\nfunction createTreeModelNodesFactory({\n  buildNode,\n  treeNodeIdFactory,\n}: {\n  buildNode?: (node: TreeModelHierarchyNode) => TreeModelHierarchyNode;\n  treeNodeIdFactory: (node: Pick<HierarchyNode, \"key\" | \"parentKeys\">) => string;\n}): (node: HierarchyNode) => TreeModelHierarchyNode {\n  return (node: HierarchyNode) => {\n    const modelNode: TreeModelHierarchyNode = {\n      id: treeNodeIdFactory(node),\n      children: node.children,\n      label: node.label,\n      nodeData: node,\n    };\n    return buildNode ? buildNode(modelNode) : modelNode;\n  };\n}\n\nfunction isRowsLimitError(error: Error): error is RowsLimitExceededError {\n  return \"limit\" in error && error.message.includes(\"Query rows limit of\");\n}\n\nfunction isTimeoutError(error: Error) {\n  return error.message.includes(\"query too long to execute or server is too busy\");\n}\n"],"mappings":";;;;;AA8CA,IAAakC,aAAb,MAA+C;CAC7C,AAAQC;CAERE,YACE,AAAQC,oBACR,AAAQC,2BACR,AAAQI,uBACRE,mBACA;EAJQP;EACAC;EACAI;AAGR,OAAKR,qBAAqBU,qBAA0CpC;;CAGtE,AAAQqC,aAAa,EAAE3B,QAAQO,0BAA0BG,WAAWC,eAA6D;EAC/H,MAAM,EAAEP,gBAAgBC,4BAA4BE,yBAAyBP,OAAO;EACpF,MAAM6B,iBAAiB,GAAG7B,OAAO8B,MAAM;EACvC,MAAMC,wBAAwBC,4BAA4B;GAAEtB;GAAWgB,mBAAmB,KAAKV;GAAoB,CAAC;AACpH,SAAO/B,KACL,KAAKkC,mBAAmBc,SAAS;GAC/BC,YAAYlC,OAAOmC;GACnB9B;GACAD;GACAO;GACD,CACH,CAAC,CAACyB,KACA/C,SAAS,EACTH,KAAKmD,eAA+B;AAClC,UAAOjC,kBAAkBiC,WAAWC,WAAW,IAC3C;IACEtC;IACAE,OAAO;KACL4B,IAAI,GAAGD,eAAc;KACrBJ,MAAM;KACR;IACD,GACD;IACEzB;IACAC,aAAaoC,WAAWnD,IAAI6C,sBAAqB;IAClD;IACL,EACFlD,YAAY2D,QAAQ;GAClB,IAAIC,yBAAgD;AACpD,OAAID,eAAeE,OAAO;AACxB,QAAIC,iBAAiBH,IAAI,EAAE;AACzB,UAAKpB,0BAA0B;MAAEE,UAAUtB,OAAO8B;MAAI9C,QAAQoB;MAAgBmB,OAAOiB,IAAIjB;MAAO,CAAC;AACjG,YAAOnC,GAAG;MACRY;MACAE,OAAO;OAAE4B,IAAI,GAAGD,eAAc,GAAIW,IAAII;OAAWnB,MAAM;OAA8BoB,oBAAoBL,IAAIjB;OAAM;MACpH,CAAC;;AAEJ,QAAIuB,eAAeN,IAAI,CACrBC,0BAAyB;;AAI7B,QAAKjB,sBAAsB;IAAEF,UAAUtB,OAAO8B;IAAIL,MAAMgB;IAAwBvC,OAAOsC;IAAK,CAAC;AAC7F,UAAOpD,GAAG;IACRY;IACAE,OAAO;KACL4B,IAAI,GAAGD,eAAc;KACrBJ,MAAM;KACNmB,SAAS;KACX;IACD,CAAC;IAEN,CAAC;;CAGH,AAAO/B,UAAU,EAAEJ,oBAAoB,GAAGK,WAA6B;AACrE,SAAO,KAAKa,aAAab,QAAQ,CAACsB,KAChCrD,QAAQgE,eACN,iBAAiBA,aACb9D,KAAK8D,WAAW9C,YAAY,CAACmC,KAC3BpD,QAAQwB,SAASC,mBAAmBD,KAAK,CAAC,EAC1CrB,UAAUqB,SAAS,KAAKmB,aAAa;GAAE,GAAGb;GAASd,QAAQQ;GAAM,CAAC,CACpE,CAAC,GACD1B,MAER,CAAC;;;AAIL,SAASkD,4BAA4B,EACnCtB,WACAgB,qBAIkD;AAClD,SAAQlB,SAAwB;EAC9B,MAAMwC,YAAoC;GACxClB,IAAIJ,kBAAkBlB,KAAK;GAC3ByC,UAAUzC,KAAKyC;GACfC,OAAO1C,KAAK0C;GACZf,UAAU3B;GACX;AACD,SAAOE,YAAYA,UAAUsC,UAAU,GAAGA;;;AAI9C,SAASL,iBAAiBzC,OAA+C;AACvE,QAAO,WAAWA,SAASA,MAAM0C,QAAQO,SAAS,sBAAsB;;AAG1E,SAASL,eAAe5C,OAAc;AACpC,QAAOA,MAAM0C,QAAQO,SAAS,kDAAkD"}

package/lib/presentation-hierarchies-react/internal/TreeModel.d.ts

@@ -0,0 +1,3 @@
+import "../TreeNode.js";
+import "../UseSelectionHandler.js";
+import { GenericInstanceFilter, HierarchyNode } from "@itwin/presentation-hierarchies";

package/lib/presentation-hierarchies-react/internal/TreeModel.js

@@ -0,0 +1,120 @@
+//#region src/presentation-hierarchies-react/internal/TreeModel.ts
+let TreeModel;
+(function(_TreeModel) {
+	function expandNode(model, nodeId, isExpanded) {
+		const node = model.idToNode.get(nodeId);
+		if (!node) return "none";
+		node.isExpanded = isExpanded;
+		if (!isExpanded) return "none";
+		if (node.error?.type === "ChildrenLoad") {
+			node.isLoading = true;
+			TreeModel.removeSubTree(model, nodeId);
+			return "reloadChildren";
+		}
+		if (!node.children) return "none";
+		if (!model.parentChildMap.get(node.id)) {
+			node.isLoading = true;
+			return "loadChildren";
+		}
+		return "none";
+	}
+	_TreeModel.expandNode = expandNode;
+	function addHierarchyPart(model, rootId, hierarchyPart) {
+		removeSubTree(model, rootId);
+		model.rootNode.error = hierarchyPart.rootNode.error;
+		for (const [parentId, children] of hierarchyPart.parentChildMap) model.parentChildMap.set(parentId, children);
+		for (const [nodeId, node] of hierarchyPart.idToNode) model.idToNode.set(nodeId, node);
+		const parentNode = rootId !== void 0 ? model.idToNode.get(rootId) : model.rootNode;
+		/* c8 ignore next 3*/
+		if (!parentNode) return;
+		parentNode.isLoading = false;
+	}
+	_TreeModel.addHierarchyPart = addHierarchyPart;
+	function removeSubTree(model, parentId) {
+		clearNodeError(model, parentId);
+		const currentChildren = model.parentChildMap.get(parentId);
+		if (!currentChildren) return;
+		model.parentChildMap.delete(parentId);
+		for (const childId of currentChildren) {
+			const childNode = model.idToNode.get(childId);
+			if (childNode) removeSubTree(model, childNode.id);
+			model.idToNode.delete(childId);
+		}
+	}
+	_TreeModel.removeSubTree = removeSubTree;
+	function setHierarchyLimit(model, nodeId, limit) {
+		return updateForReload(model, nodeId, (node) => {
+			node.hierarchyLimit = limit;
+		});
+	}
+	_TreeModel.setHierarchyLimit = setHierarchyLimit;
+	function setInstanceFilter(model, nodeId, filter) {
+		return updateForReload(model, nodeId, (node) => {
+			if (filter && node.id !== void 0) node.isExpanded = true;
+			node.instanceFilter = filter;
+		});
+	}
+	_TreeModel.setInstanceFilter = setInstanceFilter;
+	function selectNodes(model, nodeIds, changeType) {
+		if (changeType === "replace") {
+			for (const [nodeId, node] of model.idToNode) node.isSelected = !!nodeIds.find((id) => id === nodeId);
+			return;
+		}
+		for (const nodeId of nodeIds) {
+			const modelNode = model.idToNode.get(nodeId);
+			if (!modelNode) return;
+			modelNode.isSelected = changeType === "add";
+		}
+	}
+	_TreeModel.selectNodes = selectNodes;
+	function isNodeSelected(model, nodeId) {
+		const currentNode = model.idToNode.get(nodeId);
+		return !!currentNode && !!currentNode.isSelected;
+	}
+	_TreeModel.isNodeSelected = isNodeSelected;
+	function getNode(model, nodeId) {
+		if (!nodeId) return model.rootNode;
+		return model.idToNode.get(nodeId);
+	}
+	_TreeModel.getNode = getNode;
+	function setIsLoading(model, nodeId, isLoading) {
+		if (nodeId === void 0) {
+			model.rootNode.isLoading = isLoading;
+			return;
+		}
+		const modelNode = model.idToNode.get(nodeId);
+		/* c8 ignore next 3*/
+		if (!modelNode) return;
+		modelNode.isLoading = isLoading;
+	}
+	_TreeModel.setIsLoading = setIsLoading;
+})(TreeModel || (TreeModel = {}));
+function updateForReload(model, nodeId, update) {
+	TreeModel.removeSubTree(model, nodeId);
+	if (nodeId === void 0) {
+		update(model.rootNode);
+		model.rootNode.isLoading = true;
+		return true;
+	}
+	const modelNode = model.idToNode.get(nodeId);
+	if (!modelNode) return false;
+	update(modelNode);
+	if (modelNode.isExpanded) {
+		modelNode.isLoading = true;
+		return true;
+	}
+	return false;
+}
+function clearNodeError(model, parentId) {
+	if (!parentId) {
+		model.rootNode.error = void 0;
+		return;
+	}
+	const node = model.idToNode.get(parentId);
+	if (!node) return;
+	node.error = void 0;
+}
+
+//#endregion
+export { TreeModel };
+//# sourceMappingURL=TreeModel.js.map

package/lib/presentation-hierarchies-react/internal/TreeModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeModel.js","names":["GenericInstanceFilter","HierarchyNode","ErrorInfo","SelectionChangeType","TreeModelRootNode","id","nodeData","hierarchyLimit","instanceFilter","isLoading","error","TreeModelHierarchyNode","label","children","isExpanded","isSelected","TreeModel","parentChildMap","Map","idToNode","rootNode","expandNode","model","nodeId","node","get","type","removeSubTree","addHierarchyPart","rootId","hierarchyPart","parentId","set","parentNode","undefined","clearNodeError","currentChildren","delete","childId","childNode","setHierarchyLimit","limit","updateForReload","setInstanceFilter","filter","selectNodes","nodeIds","Array","changeType","find","modelNode","isNodeSelected","currentNode","getNode","setIsLoading","update"],"sources":["../../../src/presentation-hierarchies-react/internal/TreeModel.ts"],"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\nimport type { GenericInstanceFilter, HierarchyNode } from \"@itwin/presentation-hierarchies\";\nimport type { ErrorInfo } from \"../TreeNode.js\";\nimport type { SelectionChangeType } from \"../UseSelectionHandler.js\";\n\n/** @internal */\nexport interface TreeModelRootNode {\n  id: undefined;\n  nodeData: undefined;\n  hierarchyLimit?: number | \"unbounded\";\n  instanceFilter?: GenericInstanceFilter;\n  isLoading?: boolean;\n  error?: ErrorInfo;\n}\n\n/** @internal */\nexport interface TreeModelHierarchyNode {\n  id: string;\n  nodeData: HierarchyNode;\n  label: string;\n  children: boolean;\n  isLoading?: boolean;\n  isExpanded?: boolean;\n  isSelected?: boolean;\n  hierarchyLimit?: number | \"unbounded\";\n  instanceFilter?: GenericInstanceFilter;\n  error?: ErrorInfo;\n}\n\n/** @internal */\nexport interface TreeModel {\n  parentChildMap: Map<string | undefined, string[]>;\n  idToNode: Map<string, TreeModelHierarchyNode>;\n  rootNode: TreeModelRootNode;\n}\n\n/** @internal */\nexport namespace TreeModel {\n  export function expandNode(model: TreeModel, nodeId: string, isExpanded: boolean): \"none\" | \"loadChildren\" | \"reloadChildren\" {\n    const node = model.idToNode.get(nodeId);\n    if (!node) {\n      return \"none\";\n    }\n\n    node.isExpanded = isExpanded;\n    if (!isExpanded) {\n      return \"none\";\n    }\n\n    if (node.error?.type === \"ChildrenLoad\") {\n      node.isLoading = true;\n      // remove subtree if there `ChildrenLoad` error info in order to attempt reloading children\n      TreeModel.removeSubTree(model, nodeId);\n      return \"reloadChildren\";\n    }\n\n    if (!node.children) {\n      return \"none\";\n    }\n\n    const children = model.parentChildMap.get(node.id);\n    if (!children) {\n      node.isLoading = true;\n      return \"loadChildren\";\n    }\n\n    return \"none\";\n  }\n\n  /** @internal */\n  export function addHierarchyPart(model: TreeModel, rootId: string | undefined, hierarchyPart: TreeModel): void {\n    removeSubTree(model, rootId);\n    model.rootNode.error = hierarchyPart.rootNode.error;\n\n    for (const [parentId, children] of hierarchyPart.parentChildMap) {\n      model.parentChildMap.set(parentId, children);\n    }\n\n    for (const [nodeId, node] of hierarchyPart.idToNode) {\n      model.idToNode.set(nodeId, node);\n    }\n\n    const parentNode = rootId !== undefined ? model.idToNode.get(rootId) : model.rootNode;\n    /* c8 ignore next 3*/\n    if (!parentNode) {\n      return;\n    }\n    parentNode.isLoading = false;\n  }\n\n  export function removeSubTree(model: TreeModel, parentId: string | undefined): void {\n    clearNodeError(model, parentId);\n    const currentChildren = model.parentChildMap.get(parentId);\n    if (!currentChildren) {\n      return;\n    }\n    model.parentChildMap.delete(parentId);\n\n    for (const childId of currentChildren) {\n      const childNode = model.idToNode.get(childId);\n      if (childNode) {\n        removeSubTree(model, childNode.id);\n      }\n      model.idToNode.delete(childId);\n    }\n  }\n\n  export function setHierarchyLimit(model: TreeModel, nodeId: string | undefined, limit?: number | \"unbounded\"): boolean {\n    return updateForReload(model, nodeId, (node) => {\n      node.hierarchyLimit = limit;\n    });\n  }\n\n  export function setInstanceFilter(model: TreeModel, nodeId: string | undefined, filter?: GenericInstanceFilter): boolean {\n    return updateForReload(model, nodeId, (node) => {\n      if (filter && node.id !== undefined) {\n        node.isExpanded = true;\n      }\n      node.instanceFilter = filter;\n    });\n  }\n\n  export function selectNodes(model: TreeModel, nodeIds: Array<string>, changeType: SelectionChangeType) {\n    if (changeType === \"replace\") {\n      for (const [nodeId, node] of model.idToNode) {\n        node.isSelected = !!nodeIds.find((id) => id === nodeId);\n      }\n      return;\n    }\n    for (const nodeId of nodeIds) {\n      const modelNode = model.idToNode.get(nodeId);\n      if (!modelNode) {\n        return;\n      }\n      modelNode.isSelected = changeType === \"add\";\n    }\n  }\n\n  export function isNodeSelected(model: TreeModel, nodeId: string): boolean {\n    const currentNode = model.idToNode.get(nodeId);\n    return !!currentNode && !!currentNode.isSelected;\n  }\n\n  export function getNode(model: TreeModel, nodeId: string | undefined): TreeModelHierarchyNode | TreeModelRootNode | undefined {\n    if (!nodeId) {\n      return model.rootNode;\n    }\n    return model.idToNode.get(nodeId);\n  }\n\n  export function setIsLoading(model: TreeModel, nodeId: string | undefined, isLoading: boolean) {\n    if (nodeId === undefined) {\n      model.rootNode.isLoading = isLoading;\n      return;\n    }\n    const modelNode = model.idToNode.get(nodeId);\n    /* c8 ignore next 3*/\n    if (!modelNode) {\n      return;\n    }\n    modelNode.isLoading = isLoading;\n  }\n}\n\nfunction updateForReload(model: TreeModel, nodeId: string | undefined, update: (node: TreeModelHierarchyNode | TreeModelRootNode) => void) {\n  TreeModel.removeSubTree(model, nodeId);\n  if (nodeId === undefined) {\n    update(model.rootNode);\n    model.rootNode.isLoading = true;\n    return true;\n  }\n\n  const modelNode = model.idToNode.get(nodeId);\n  if (!modelNode) {\n    return false;\n  }\n\n  update(modelNode);\n  if (modelNode.isExpanded) {\n    modelNode.isLoading = true;\n    return true;\n  }\n  return false;\n}\n\nfunction clearNodeError(model: TreeModel, parentId: string | undefined) {\n  if (!parentId) {\n    return (model.rootNode.error = undefined);\n  }\n  const node = model.idToNode.get(parentId);\n  if (!node) {\n    return;\n  }\n  node.error = undefined;\n}\n"],"mappings":"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"}

package/lib/presentation-hierarchies-react/internal/UseUnifiedSelection.d.ts

@@ -0,0 +1,37 @@
+import "../UseSelectionHandler.js";
+import "./TreeModel.js";
+import { GenericNodeKey, NonGroupingHierarchyNode } from "@itwin/presentation-hierarchies";
+import { Selectable, SelectionStorage } from "@itwin/unified-selection";
+
+//#region src/presentation-hierarchies-react/internal/UseUnifiedSelection.d.ts
+/** @public */
+interface UseUnifiedTreeSelectionProps {
+  /**
+   * Identifier to distinguish this source of changes to the unified selection from another ones in the application.
+   */
+  sourceName: string;
+  /**
+   * An optional function that allows customizing the `Selectable` object that gets created for generic hierarchy nodes. When
+   * not supplied, the `Selectable` is created using the following signature:
+   * ```ts
+   * {
+   *   identifier: treeModelNodeId,
+   *   data: node,
+   *   async *loadInstanceKeys() {},
+   * }
+   * ```
+   *
+   * @param node Hierarchy node to create a selectable for.
+   * @param treeModelNodeId ID of the hierarchy node in the internal tree model. This ID uniquely identifies the node in the whole hierarchy, as opposed to `GenericNodeKey.id` contained within the `node`, which may not be unique.
+   */
+  createSelectableForGenericNode?: (node: NonGroupingHierarchyNode & {
+    key: GenericNodeKey;
+  }, treeModelNodeId: string) => Selectable;
+  /**
+   * Unified selection storage to use for listening, getting and changing active selection.
+   */
+  selectionStorage: SelectionStorage;
+}
+//#endregion
+export { UseUnifiedTreeSelectionProps };
+//# sourceMappingURL=UseUnifiedSelection.d.ts.map