@itwin/presentation-hierarchies-react 2.0.0-alpha.6 → 2.0.0-alpha.61

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

@@ -0,0 +1,115 @@
+//#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) {
+	const node = !parentId ? model.rootNode : model.idToNode.get(parentId);
+	if (node) 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(\n    model: TreeModel,\n    nodeId: string,\n    isExpanded: boolean,\n  ): \"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(\n    model: TreeModel,\n    nodeId: string | undefined,\n    limit?: number | \"unbounded\",\n  ): boolean {\n    return updateForReload(model, nodeId, (node) => {\n      node.hierarchyLimit = limit;\n    });\n  }\n\n  export function setInstanceFilter(\n    model: TreeModel,\n    nodeId: string | undefined,\n    filter?: GenericInstanceFilter,\n  ): 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(\n    model: TreeModel,\n    nodeId: string | undefined,\n  ): 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(\n  model: TreeModel,\n  nodeId: string | undefined,\n  update: (node: TreeModelHierarchyNode | TreeModelRootNode) => void,\n) {\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  const node = !parentId ? model.rootNode : model.idToNode.get(parentId);\n  if (node) {\n    node.error = undefined;\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,35 @@
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"UseUnifiedSelection.d.ts","names":[],"sources":["../../../src/presentation-hierarchies-react/internal/UseUnifiedSelection.ts"],"mappings":";;;;;UAuBiB,4BAAA;EAuBV;;;EAnBL,UAAA;EAAA;;;;;;;;;;;;;;EAgBA,8BAAA,IACE,IAAA,EAAM,wBAAA;IAA6B,GAAA,EAAK,cAAA;EAAA,GACxC,eAAA,aACG,UAAA;;;;EAKL,gBAAA,EAAkB,gBAAA;AAAA"}

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

@@ -0,0 +1,141 @@
+import { c } from "react-compiler-runtime";
+import { useEffect, useState } from "react";
+import { HierarchyNode } from "@itwin/presentation-hierarchies";
+import { assert } from "@itwin/core-bentley";
+import { Selectables } from "@itwin/unified-selection";
+//#region src/presentation-hierarchies-react/internal/UseUnifiedSelection.ts
+/** @internal */
+function useUnifiedTreeSelection(t0) {
+	const $ = c(6);
+	const { sourceName, selectionStorage, getTreeModelNode, createSelectableForGenericNode: t1 } = t0;
+	const createSelectableForGenericNode = t1 === void 0 ? defaultCreateSelectableForGenericNode : t1;
+	const [options, setOptions] = useState(_temp3);
+	let t2;
+	let t3;
+	if ($[0] !== createSelectableForGenericNode || $[1] !== getTreeModelNode || $[2] !== selectionStorage || $[3] !== sourceName) {
+		t2 = () => {
+			setOptions(createOptions(sourceName, selectionStorage, createSelectableForGenericNode, getTreeModelNode));
+			return selectionStorage.selectionChangeEvent.addListener((args) => {
+				if (args.level > 0) return;
+				setOptions(createOptions(sourceName, selectionStorage, createSelectableForGenericNode, getTreeModelNode));
+			});
+		};
+		t3 = [
+			selectionStorage,
+			createSelectableForGenericNode,
+			getTreeModelNode,
+			sourceName
+		];
+		$[0] = createSelectableForGenericNode;
+		$[1] = getTreeModelNode;
+		$[2] = selectionStorage;
+		$[3] = sourceName;
+		$[4] = t2;
+		$[5] = t3;
+	} else {
+		t2 = $[4];
+		t3 = $[5];
+	}
+	useEffect(t2, t3);
+	return options;
+}
+function _temp3() {
+	return {
+		isNodeSelected: _temp,
+		selectNodes: _temp2
+	};
+}
+function _temp2() {}
+function _temp() {
+	return false;
+}
+const defaultCreateSelectableForGenericNode = (node, treeModelNodeId) => ({
+	identifier: treeModelNodeId,
+	data: node,
+	async *loadInstanceKeys() {}
+});
+function createOptions(source, storage, createSelectableForGenericNode, getNode) {
+	return {
+		isNodeSelected: (nodeId) => {
+			const node = getNode(nodeId);
+			if (!node || node.id === void 0) return false;
+			for (const [imodelKey, nodeSelectables] of groupNodeSelectablesByIModelKey(node, createSelectableForGenericNode)) {
+				const storageSelectables = storage.getSelection({
+					imodelKey,
+					level: 0
+				});
+				if (Selectables.hasAny(storageSelectables, nodeSelectables)) return true;
+			}
+			return false;
+		},
+		selectNodes: (nodeIds, changeType) => {
+			const imodelSelectables = /* @__PURE__ */ new Map();
+			for (const nodeId of nodeIds) {
+				const node = getNode(nodeId);
+				if (!node || node.id === void 0) return;
+				for (const [imodelKey, nodeSelectables] of groupNodeSelectablesByIModelKey(node, createSelectableForGenericNode)) {
+					let selectablesList = imodelSelectables.get(imodelKey);
+					if (!selectablesList) {
+						selectablesList = [];
+						imodelSelectables.set(imodelKey, selectablesList);
+					}
+					nodeSelectables.forEach((selectable) => selectablesList.push(selectable));
+				}
+			}
+			imodelSelectables.forEach((selectables, imodelKey) => {
+				const actionProps = {
+					imodelKey,
+					source,
+					selectables,
+					level: 0
+				};
+				switch (changeType) {
+					case "add":
+						storage.addToSelection(actionProps);
+						return;
+					case "remove":
+						storage.removeFromSelection(actionProps);
+						return;
+					case "replace":
+						storage.replaceSelection(actionProps);
+						return;
+				}
+			});
+		}
+	};
+}
+function groupNodeSelectablesByIModelKey(modelNode, createSelectableForGenericNode) {
+	const hierarchyNode = modelNode.nodeData;
+	if (HierarchyNode.isInstancesNode(hierarchyNode)) return groupIModelInstanceKeys(hierarchyNode.key.instanceKeys);
+	if (HierarchyNode.isGroupingNode(hierarchyNode)) {
+		const groupingNodeSelectables = /* @__PURE__ */ new Map();
+		groupIModelInstanceKeys(hierarchyNode.groupedInstanceKeys).forEach((instanceKeys, imodelKey) => {
+			groupingNodeSelectables.set(imodelKey, [{
+				identifier: modelNode.id,
+				data: hierarchyNode,
+				async *loadInstanceKeys() {
+					for (const key of instanceKeys) yield key;
+				}
+			}]);
+		});
+		return groupingNodeSelectables;
+	}
+	assert(HierarchyNode.isGeneric(hierarchyNode));
+	return new Map([["", [createSelectableForGenericNode(hierarchyNode, modelNode.id)]]]);
+}
+function groupIModelInstanceKeys(instanceKeys) {
+	return instanceKeys.reduce((imodelSelectables, key) => {
+		const imodelKey = key.imodelKey ?? "";
+		let selectablesList = imodelSelectables.get(imodelKey);
+		if (!selectablesList) {
+			selectablesList = [];
+			imodelSelectables.set(imodelKey, selectablesList);
+		}
+		selectablesList.push(key);
+		return imodelSelectables;
+	}, /* @__PURE__ */ new Map());
+}
+//#endregion
+export { useUnifiedTreeSelection };
+
+//# sourceMappingURL=UseUnifiedSelection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UseUnifiedSelection.js","names":["useEffect","useState","assert","HierarchyNode","Selectables","GenericNodeKey","InstancesNodeKey","NonGroupingHierarchyNode","InstanceKey","Selectable","SelectionStorage","SelectionChangeType","TreeModelHierarchyNode","TreeModelRootNode","TreeSelectionOptions","isNodeSelected","nodeId","selectNodes","nodeIds","Array","changeType","UseUnifiedTreeSelectionProps","sourceName","createSelectableForGenericNode","node","key","treeModelNodeId","selectionStorage","useUnifiedTreeSelection","t0","$","_c","getTreeModelNode","t1","undefined","defaultCreateSelectableForGenericNode","options","setOptions","_temp3","t2","t3","createOptions","selectionChangeEvent","addListener","args","level","_temp","_temp2","NonNullable","identifier","data","loadInstanceKeys","source","storage","getNode","id","imodelKey","nodeSelectables","groupNodeSelectablesByIModelKey","storageSelectables","getSelection","hasAny","imodelSelectables","Map","selectablesList","get","set","forEach","selectable","push","selectables","actionProps","addToSelection","removeFromSelection","replaceSelection","modelNode","hierarchyNode","nodeData","isInstancesNode","groupIModelInstanceKeys","instanceKeys","isGroupingNode","groupingNodeSelectables","groupedInstanceKeys","isGeneric","reduce"],"sources":["../../../src/presentation-hierarchies-react/internal/UseUnifiedSelection.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 { useEffect, useState } from \"react\";\nimport { assert } from \"@itwin/core-bentley\";\nimport { HierarchyNode } from \"@itwin/presentation-hierarchies\";\nimport { Selectables } from \"@itwin/unified-selection\";\n\nimport type { GenericNodeKey, InstancesNodeKey, NonGroupingHierarchyNode } from \"@itwin/presentation-hierarchies\";\nimport type { InstanceKey } from \"@itwin/presentation-shared\";\nimport type { Selectable, SelectionStorage } from \"@itwin/unified-selection\";\nimport type { SelectionChangeType } from \"../UseSelectionHandler.js\";\nimport type { TreeModelHierarchyNode, TreeModelRootNode } from \"./TreeModel.js\";\n\n/** @internal */\nexport interface TreeSelectionOptions {\n  isNodeSelected: (nodeId: string) => boolean;\n  selectNodes: (nodeIds: Array<string>, changeType: SelectionChangeType) => void;\n}\n\n/** @public */\nexport interface UseUnifiedTreeSelectionProps {\n  /**\n   * Identifier to distinguish this source of changes to the unified selection from another ones in the application.\n   */\n  sourceName: string;\n\n  /**\n   * An optional function that allows customizing the `Selectable` object that gets created for generic hierarchy nodes. When\n   * not supplied, the `Selectable` is created using the following signature:\n   * ```ts\n   * {\n   *   identifier: treeModelNodeId,\n   *   data: node,\n   *   async *loadInstanceKeys() {},\n   * }\n   * ```\n   *\n   * @param node Hierarchy node to create a selectable for.\n   * @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.\n   */\n  createSelectableForGenericNode?: (\n    node: NonGroupingHierarchyNode & { key: GenericNodeKey },\n    treeModelNodeId: string,\n  ) => Selectable;\n\n  /**\n   * Unified selection storage to use for listening, getting and changing active selection.\n   */\n  selectionStorage: SelectionStorage;\n}\n\n/** @internal */\nexport function useUnifiedTreeSelection({\n  sourceName,\n  selectionStorage,\n  getTreeModelNode,\n  createSelectableForGenericNode = defaultCreateSelectableForGenericNode,\n}: UseUnifiedTreeSelectionProps & {\n  getTreeModelNode: (nodeId: string) => TreeModelHierarchyNode | TreeModelRootNode | undefined;\n}): TreeSelectionOptions {\n  const [options, setOptions] = useState<TreeSelectionOptions>(() => ({\n    isNodeSelected: /* c8 ignore next */ () => false,\n    selectNodes: /* c8 ignore next */ () => {},\n  }));\n\n  useEffect(() => {\n    // eslint-disable-next-line react-hooks/set-state-in-effect\n    setOptions(createOptions(sourceName, selectionStorage, createSelectableForGenericNode, getTreeModelNode));\n    return selectionStorage.selectionChangeEvent.addListener((args) => {\n      if (args.level > 0) {\n        return;\n      }\n      setOptions(createOptions(sourceName, selectionStorage, createSelectableForGenericNode, getTreeModelNode));\n    });\n  }, [selectionStorage, createSelectableForGenericNode, getTreeModelNode, sourceName]);\n\n  return options;\n}\n\nconst defaultCreateSelectableForGenericNode: NonNullable<\n  UseUnifiedTreeSelectionProps[\"createSelectableForGenericNode\"]\n> = (node, treeModelNodeId): Selectable => ({ identifier: treeModelNodeId, data: node, async *loadInstanceKeys() {} });\n\nfunction createOptions(\n  source: string,\n  storage: SelectionStorage,\n  createSelectableForGenericNode: NonNullable<UseUnifiedTreeSelectionProps[\"createSelectableForGenericNode\"]>,\n  getNode: (nodeId: string) => TreeModelHierarchyNode | TreeModelRootNode | undefined,\n): TreeSelectionOptions {\n  return {\n    isNodeSelected: (nodeId: string) => {\n      const node = getNode(nodeId);\n      if (!node || node.id === undefined) {\n        return false;\n      }\n      for (const [imodelKey, nodeSelectables] of groupNodeSelectablesByIModelKey(\n        node,\n        createSelectableForGenericNode,\n      )) {\n        const storageSelectables = storage.getSelection({ imodelKey, level: 0 });\n        if (Selectables.hasAny(storageSelectables, nodeSelectables)) {\n          return true;\n        }\n      }\n      return false;\n    },\n\n    selectNodes: (nodeIds: Array<string>, changeType: SelectionChangeType) => {\n      const imodelSelectables = new Map<string, Selectable[]>();\n      for (const nodeId of nodeIds) {\n        const node = getNode(nodeId);\n        if (!node || node.id === undefined) {\n          return;\n        }\n        for (const [imodelKey, nodeSelectables] of groupNodeSelectablesByIModelKey(\n          node,\n          createSelectableForGenericNode,\n        )) {\n          let selectablesList = imodelSelectables.get(imodelKey);\n          if (!selectablesList) {\n            selectablesList = [];\n            imodelSelectables.set(imodelKey, selectablesList);\n          }\n          nodeSelectables.forEach((selectable) => selectablesList.push(selectable));\n        }\n      }\n      imodelSelectables.forEach((selectables, imodelKey) => {\n        const actionProps = { imodelKey, source, selectables, level: 0 };\n        switch (changeType) {\n          case \"add\":\n            storage.addToSelection(actionProps);\n            return;\n          case \"remove\":\n            storage.removeFromSelection(actionProps);\n            return;\n          case \"replace\":\n            storage.replaceSelection(actionProps);\n            return;\n        }\n      });\n    },\n  };\n}\n\nfunction groupNodeSelectablesByIModelKey(\n  modelNode: TreeModelHierarchyNode,\n  createSelectableForGenericNode: NonNullable<UseUnifiedTreeSelectionProps[\"createSelectableForGenericNode\"]>,\n): Map<string, Selectable[]> {\n  const hierarchyNode = modelNode.nodeData;\n  if (HierarchyNode.isInstancesNode(hierarchyNode)) {\n    return groupIModelInstanceKeys(hierarchyNode.key.instanceKeys);\n  }\n  if (HierarchyNode.isGroupingNode(hierarchyNode)) {\n    const groupingNodeSelectables = new Map<string, Selectable[]>();\n    groupIModelInstanceKeys(hierarchyNode.groupedInstanceKeys).forEach((instanceKeys, imodelKey) => {\n      groupingNodeSelectables.set(imodelKey, [\n        {\n          identifier: modelNode.id,\n          data: hierarchyNode,\n          async *loadInstanceKeys() {\n            for (const key of instanceKeys) {\n              yield key;\n            }\n          },\n        },\n      ]);\n    });\n    return groupingNodeSelectables;\n  }\n  assert(HierarchyNode.isGeneric(hierarchyNode));\n  // note: generic nodes aren't associated with an imodel\n  return new Map([[\"\", [createSelectableForGenericNode(hierarchyNode, modelNode.id)]]]);\n}\n\nfunction groupIModelInstanceKeys(instanceKeys: InstancesNodeKey[\"instanceKeys\"]) {\n  return instanceKeys.reduce((imodelSelectables, key) => {\n    const imodelKey = key.imodelKey ?? \"\";\n    let selectablesList = imodelSelectables.get(imodelKey);\n    if (!selectablesList) {\n      selectablesList = [];\n      imodelSelectables.set(imodelKey, selectablesList);\n    }\n    selectablesList.push(key);\n    return imodelSelectables;\n  }, new Map<string, InstanceKey[]>());\n}\n"],"mappings":";;;;;;;AAuDA,SAAO4B,wBAAAC,IAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAAiC,MAAA,EAAAT,YAAAK,kBAAAK,kBAAAT,gCAAAU,OAAAJ;CAItC,MAAAN,iCAAAU,OAAAC,KAAAA,IAAAC,wCAAAF;CAIA,MAAA,CAAAG,SAAAC,cAA8BpC,SAA+BqC,OAG1D;CAAC,IAAAC;CAAA,IAAAC;AAAA,KAAAV,EAAA,OAAAP,kCAAAO,EAAA,OAAAE,oBAAAF,EAAA,OAAAH,oBAAAG,EAAA,OAAAR,YAAA;AAEMiB,aAAA;AAERF,cAAWI,cAAcnB,YAAYK,kBAAkBJ,gCAAgCS,iBAAiB,CAAC;AAAA,UAClGL,iBAAgBe,qBAAqBC,aAAaC,SAAA;AACvD,QAAIA,KAAIC,QAAS,EAAC;AAGlBR,eAAWI,cAAcnB,YAAYK,kBAAkBJ,gCAAgCS,iBAAiB,CAAC;KACzG;;AACDQ,OAAA;GAACb;GAAkBJ;GAAgCS;GAAkBV;GAAW;AAAAQ,IAAA,KAAAP;AAAAO,IAAA,KAAAE;AAAAF,IAAA,KAAAH;AAAAG,IAAA,KAAAR;AAAAQ,IAAA,KAAAS;AAAAT,IAAA,KAAAU;QAAA;AAAAD,OAAAT,EAAA;AAAAU,OAAAV,EAAA;;AATnF9B,WAAUuC,IASPC,GAAiF;AAAA,QAE7EJ;;AAxBF,SAAAE,SAAA;AAAA,QAQ+D;EAAAvB,gBAC7B+B;EAAW7B,aACd8B;EACnC;;AAXI,SAAAA,SAAA;AAAA,SAAAD,QAAA;AAAA,QASwC;;AAkB/C,MAAMX,yCAEDX,MAAME,qBAAiC;CAAEuB,YAAYvB;CAAiBwB,MAAM1B;CAAM,OAAO2B,mBAAmB;CAAI;AAErH,SAASV,cACPW,QACAC,SACA9B,gCACA+B,SACsB;AACtB,QAAO;EACLvC,iBAAiBC,WAAmB;GAClC,MAAMQ,OAAO8B,QAAQtC,OAAO;AAC5B,OAAI,CAACQ,QAAQA,KAAK+B,OAAOrB,KAAAA,EACvB,QAAO;AAET,QAAK,MAAM,CAACsB,WAAWC,oBAAoBC,gCACzClC,MACAD,+BACD,EAAE;IACD,MAAMoC,qBAAqBN,QAAQO,aAAa;KAAEJ;KAAWX,OAAO;KAAG,CAAC;AACxE,QAAIzC,YAAYyD,OAAOF,oBAAoBF,gBAAgB,CACzD,QAAO;;AAGX,UAAO;;EAGTxC,cAAcC,SAAwBE,eAAoC;GACxE,MAAM0C,oCAAoB,IAAIC,KAA2B;AACzD,QAAK,MAAM/C,UAAUE,SAAS;IAC5B,MAAMM,OAAO8B,QAAQtC,OAAO;AAC5B,QAAI,CAACQ,QAAQA,KAAK+B,OAAOrB,KAAAA,EACvB;AAEF,SAAK,MAAM,CAACsB,WAAWC,oBAAoBC,gCACzClC,MACAD,+BACD,EAAE;KACD,IAAIyC,kBAAkBF,kBAAkBG,IAAIT,UAAU;AACtD,SAAI,CAACQ,iBAAiB;AACpBA,wBAAkB,EAAE;AACpBF,wBAAkBI,IAAIV,WAAWQ,gBAAgB;;AAEnDP,qBAAgBU,SAASC,eAAeJ,gBAAgBK,KAAKD,WAAW,CAAC;;;AAG7EN,qBAAkBK,SAASG,aAAad,cAAc;IACpD,MAAMe,cAAc;KAAEf;KAAWJ;KAAQkB;KAAazB,OAAO;KAAG;AAChE,YAAQzB,YAAR;KACE,KAAK;AACHiC,cAAQmB,eAAeD,YAAY;AACnC;KACF,KAAK;AACHlB,cAAQoB,oBAAoBF,YAAY;AACxC;KACF,KAAK;AACHlB,cAAQqB,iBAAiBH,YAAY;AACrC;;KAEJ;;EAEL;;AAGH,SAASb,gCACPiB,WACApD,gCAC2B;CAC3B,MAAMqD,gBAAgBD,UAAUE;AAChC,KAAI1E,cAAc2E,gBAAgBF,cAAc,CAC9C,QAAOG,wBAAwBH,cAAcnD,IAAIuD,aAAa;AAEhE,KAAI7E,cAAc8E,eAAeL,cAAc,EAAE;EAC/C,MAAMM,0CAA0B,IAAInB,KAA2B;AAC/DgB,0BAAwBH,cAAcO,oBAAoB,CAAChB,SAASa,cAAcxB,cAAc;AAC9F0B,2BAAwBhB,IAAIV,WAAW,CACrC;IACEP,YAAY0B,UAAUpB;IACtBL,MAAM0B;IACN,OAAOzB,mBAAmB;AACxB,UAAK,MAAM1B,OAAOuD,aAChB,OAAMvD;;IAGX,CACF,CAAC;IACF;AACF,SAAOyD;;AAEThF,QAAOC,cAAciF,UAAUR,cAAc,CAAC;AAE9C,QAAO,IAAIb,IAAI,CAAC,CAAC,IAAI,CAACxC,+BAA+BqD,eAAeD,UAAUpB,GAAG,CAAC,CAAC,CAAC,CAAC;;AAGvF,SAASwB,wBAAwBC,cAAgD;AAC/E,QAAOA,aAAaK,QAAQvB,mBAAmBrC,QAAQ;EACrD,MAAM+B,YAAY/B,IAAI+B,aAAa;EACnC,IAAIQ,kBAAkBF,kBAAkBG,IAAIT,UAAU;AACtD,MAAI,CAACQ,iBAAiB;AACpBA,qBAAkB,EAAE;AACpBF,qBAAkBI,IAAIV,WAAWQ,gBAAgB;;AAEnDA,kBAAgBK,KAAK5C,IAAI;AACzB,SAAOqC;oBACN,IAAIC,KAA4B,CAAC"}

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

@@ -0,0 +1,42 @@
+import "./DisposePolyfill.js";
+import { HierarchyNodeKey } from "@itwin/presentation-hierarchies";
+//#region src/presentation-hierarchies-react/internal/Utils.ts
+/** @internal */
+function createNodeId(node) {
+	return [...node.parentKeys.map(serializeNodeKey), serializeNodeKey(node.key)].join(";");
+}
+function serializeNodeKey(key) {
+	return convertObjectValuesToString(key);
+}
+function convertObjectValuesToString(obj) {
+	return Object.entries(obj).map(([, value]) => {
+		if (typeof value === "object") return convertObjectValuesToString(value);
+		return String(value);
+	}).join(",");
+}
+/** @internal */
+function sameNodes(lhs, rhs) {
+	if (HierarchyNodeKey.compare(lhs.key, rhs.key) !== 0) return false;
+	if (lhs.parentKeys.length !== rhs.parentKeys.length) return false;
+	for (let i = lhs.parentKeys.length - 1; i >= 0; --i) if (HierarchyNodeKey.compare(lhs.parentKeys[i], rhs.parentKeys[i]) !== 0) return false;
+	return true;
+}
+/** @internal */
+const MAX_LIMIT_OVERRIDE = 1e4;
+/**
+* A helper that disposes the given object, if it's disposable.
+*
+* The first option is to dispose using the deprecated `dispose` method if it exists on the object.
+* If not, we use the new `Symbol.dispose` method. If that doesn't exist either, the object is
+* considered as non-disposable and nothing is done with it.
+*
+* @internal
+*/
+function safeDispose(disposable) {
+	if ("dispose" in disposable) disposable.dispose();
+	else if (Symbol.dispose in disposable) disposable[Symbol.dispose]();
+}
+//#endregion
+export { MAX_LIMIT_OVERRIDE, createNodeId, safeDispose, sameNodes };
+
+//# sourceMappingURL=Utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Utils.js","names":["HierarchyNodeKey","HierarchyNode","createNodeId","node","Pick","parentKeys","map","serializeNodeKey","key","join","convertObjectValuesToString","obj","Object","entries","value","String","sameNodes","lhs","rhs","compare","length","i","MAX_LIMIT_OVERRIDE","safeDispose","disposable","Symbol","dispose"],"sources":["../../../src/presentation-hierarchies-react/internal/Utils.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 { HierarchyNodeKey } from \"@itwin/presentation-hierarchies\";\n\nimport type { HierarchyNode } from \"@itwin/presentation-hierarchies\";\n\n/** @internal */\nexport function createNodeId(node: Pick<HierarchyNode, \"key\" | \"parentKeys\">) {\n  return [...node.parentKeys.map(serializeNodeKey), serializeNodeKey(node.key)].join(\";\");\n}\n\nfunction serializeNodeKey(key: HierarchyNodeKey): string {\n  return convertObjectValuesToString(key);\n}\n\nfunction convertObjectValuesToString(obj: object): string {\n  return Object.entries(obj)\n    .map(([, value]) => {\n      if (typeof value === \"object\") {\n        return convertObjectValuesToString(value);\n      }\n      return String(value);\n    })\n    .join(\",\");\n}\n\n/** @internal */\nexport function sameNodes(lhs: HierarchyNode, rhs: HierarchyNode): boolean {\n  if (HierarchyNodeKey.compare(lhs.key, rhs.key) !== 0) {\n    return false;\n  }\n\n  if (lhs.parentKeys.length !== rhs.parentKeys.length) {\n    return false;\n  }\n\n  for (let i = lhs.parentKeys.length - 1; i >= 0; --i) {\n    if (HierarchyNodeKey.compare(lhs.parentKeys[i], rhs.parentKeys[i]) !== 0) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/** @internal */\nexport const MAX_LIMIT_OVERRIDE = 10000;\n\n/**\n * A helper that disposes the given object, if it's disposable.\n *\n * The first option is to dispose using the deprecated `dispose` method if it exists on the object.\n * If not, we use the new `Symbol.dispose` method. If that doesn't exist either, the object is\n * considered as non-disposable and nothing is done with it.\n *\n * @internal\n */\nexport function safeDispose(disposable: {} | { [Symbol.dispose]: () => void } | { dispose: () => void }) {\n  if (\"dispose\" in disposable) {\n    disposable.dispose();\n  } else if (Symbol.dispose in disposable) {\n    disposable[Symbol.dispose]();\n  }\n}\n"],"mappings":";;;;AAYA,SAAgBE,aAAaC,MAAiD;AAC5E,QAAO,CAAC,GAAGA,KAAKE,WAAWC,IAAIC,iBAAiB,EAAEA,iBAAiBJ,KAAKK,IAAI,CAAC,CAACC,KAAK,IAAI;;AAGzF,SAASF,iBAAiBC,KAA+B;AACvD,QAAOE,4BAA4BF,IAAI;;AAGzC,SAASE,4BAA4BC,KAAqB;AACxD,QAAOC,OAAOC,QAAQF,IAAI,CACvBL,KAAK,GAAGQ,WAAW;AAClB,MAAI,OAAOA,UAAU,SACnB,QAAOJ,4BAA4BI,MAAM;AAE3C,SAAOC,OAAOD,MAAM;GACpB,CACDL,KAAK,IAAI;;;AAId,SAAgBO,UAAUC,KAAoBC,KAA6B;AACzE,KAAIlB,iBAAiBmB,QAAQF,IAAIT,KAAKU,IAAIV,IAAI,KAAK,EACjD,QAAO;AAGT,KAAIS,IAAIZ,WAAWe,WAAWF,IAAIb,WAAWe,OAC3C,QAAO;AAGT,MAAK,IAAIC,IAAIJ,IAAIZ,WAAWe,SAAS,GAAGC,KAAK,GAAG,EAAEA,EAChD,KAAIrB,iBAAiBmB,QAAQF,IAAIZ,WAAWgB,IAAIH,IAAIb,WAAWgB,GAAG,KAAK,EACrE,QAAO;AAGX,QAAO;;;AAIT,MAAaC,qBAAqB;;;;;;;;;;AAWlC,SAAgBC,YAAYC,YAA6E;AACvG,KAAI,aAAaA,WACfA,YAAWE,SAAS;UACXD,OAAOC,WAAWF,WAC3BA,YAAWC,OAAOC,UAAU"}

package/lib/presentation-hierarchies-react/stratakit/ErrorItemRenderer.d.ts

@@ -0,0 +1,40 @@
+import { ErrorInfo, TreeNode } from "../TreeNode.js";
+import { HierarchyLevelDetails, TreeRendererProps } from "../Renderers.js";
+import { JSX } from "react";
+
+//#region src/presentation-hierarchies-react/stratakit/ErrorItemRenderer.d.ts
+/** @alpha */
+interface ErrorItemRendererProps extends Pick<TreeRendererProps, "getHierarchyLevelDetails"> {
+  /** The tree node associated with the error. Used for displaying the node label in error messages and for scrolling to the node. */
+  treeNode: Omit<TreeNode, "errors">;
+  /** The error to render. */
+  error: ErrorInfo;
+  /** A callback to reload a hierarchy level when an error occurs and `retry` button is clicked. */
+  reloadTree: (options: {
+    parentNodeId: string | undefined;
+  }) => void;
+  /** A callback to scroll to the node associated with the error. */
+  scrollToNode: (treeNode: Omit<TreeNode, "errors">) => void;
+  /** A callback to initiate filtering of the given hierarchy level. */
+  filterHierarchyLevel?: (hierarchyLevelDetails: HierarchyLevelDetails) => void;
+}
+/**
+ * Renders StrataKit `<ErrorRegion.Item />` for all supported error types:
+ * - `ResultSetTooLarge` - renders `resultLimitExceeded` message with actions to increase limit or apply filtering
+ * - `NoFilterMatches` - renders `noFilteredChildren` message with action to change filter
+ * - `ChildrenLoad` - renders `failedToCreateHierarchy` message with action to retry loading
+ * - `Unknown` - renders message set on error object.
+ *
+ * @alpha
+ */
+declare function ErrorItemRenderer({
+  treeNode,
+  error,
+  getHierarchyLevelDetails,
+  filterHierarchyLevel,
+  reloadTree,
+  scrollToNode
+}: ErrorItemRendererProps): JSX.Element;
+//#endregion
+export { ErrorItemRenderer, ErrorItemRendererProps };
+//# sourceMappingURL=ErrorItemRenderer.d.ts.map

package/lib/presentation-hierarchies-react/stratakit/ErrorItemRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorItemRenderer.d.ts","names":[],"sources":["../../../src/presentation-hierarchies-react/stratakit/ErrorItemRenderer.tsx"],"mappings":";;;;;;UAeiB,sBAAA,SAA+B,IAAA,CAAK,iBAAA;EAApC;EAEf,QAAA,EAAU,IAAA,CAAK,QAAA;;EAEf,KAAA,EAAO,SAAA;EAFQ;EAIf,UAAA,GAAa,OAAA;IAAW,YAAA;EAAA;EAEC;EAAzB,YAAA,GAAe,QAAA,EAAU,IAAA,CAAK,QAAA;EARgB;EAU9C,oBAAA,IAAwB,qBAAA,EAAuB,qBAAA;AAAA;;;;;;;;;;iBAYjC,iBAAA,CAAA;EACd,QAAA;EACA,KAAA;EACA,wBAAA;EACA,oBAAA;EACA,UAAA;EACA;AAAA,GACC,sBAAA,GAAyB,GAAA,CAAI,OAAA"}