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

package/lib/presentation-hierarchies-react/UseSelectionHandler.js

@@ -0,0 +1,124 @@
+import { c } from "react-compiler-runtime";
+import { useEffect, useRef } from "react";
+//#region src/presentation-hierarchies-react/UseSelectionHandler.ts
+/**
+* A react hook that helps implement different selection modes in a tree component created using `useTree` hook.
+* @internal
+*/
+function useSelectionHandler(props) {
+	const $ = c(10);
+	const { rootNodes, selectionMode, selectNodes } = props;
+	const previousSelectionRef = useRef(void 0);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = {
+			flatNodeList: [],
+			nodeIdToIndexMap: /* @__PURE__ */ new Map()
+		};
+		$[0] = t0;
+	} else t0 = $[0];
+	const state = useRef(t0);
+	let t1;
+	let t2;
+	if ($[1] !== rootNodes) {
+		t1 = () => {
+			state.current = computeFlatNodeList(rootNodes);
+		};
+		t2 = [rootNodes];
+		$[1] = rootNodes;
+		$[2] = t1;
+		$[3] = t2;
+	} else {
+		t1 = $[2];
+		t2 = $[3];
+	}
+	useEffect(t1, t2);
+	let t3;
+	if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+		t3 = (firstId, secondId) => {
+			const getIndex = (nodeId) => nodeId ? state.current.nodeIdToIndexMap.get(nodeId) : 0;
+			const firstIndex = getIndex(firstId);
+			const secondIndex = getIndex(secondId);
+			if (firstIndex === void 0 || secondIndex === void 0) return [];
+			const startingIndex = Math.min(firstIndex, secondIndex);
+			const endIndex = Math.max(firstIndex, secondIndex);
+			return state.current.flatNodeList.slice(startingIndex, endIndex + 1);
+		};
+		$[4] = t3;
+	} else t3 = $[4];
+	const getNodeRange = t3;
+	let t4;
+	if ($[5] !== selectNodes || $[6] !== selectionMode) {
+		t4 = (t5) => {
+			const { nodeId: nodeId_0, isSelected, shiftDown, ctrlDown } = t5;
+			const selection = getSelectionAction(selectionMode, isSelected, shiftDown, ctrlDown);
+			if (selection.type === "disabled") return;
+			const nodes = selection.select === "range" ? getNodeRange(previousSelectionRef.current, nodeId_0) : [nodeId_0];
+			if (!nodes.length) return;
+			selection.select !== "range" && (previousSelectionRef.current = nodeId_0);
+			selectNodes(nodes, selection.type);
+		};
+		$[5] = selectNodes;
+		$[6] = selectionMode;
+		$[7] = t4;
+	} else t4 = $[7];
+	const handleNodeSelect = t4;
+	let t5;
+	if ($[8] !== handleNodeSelect) {
+		t5 = { handleNodeSelect };
+		$[8] = handleNodeSelect;
+		$[9] = t5;
+	} else t5 = $[9];
+	return t5;
+}
+function getSelectionAction(selectionMode, isSelected, shiftDown, ctrlDown) {
+	switch (selectionMode) {
+		case "none": return {
+			select: "node",
+			type: "disabled"
+		};
+		case "single": return {
+			select: "node",
+			type: isSelected ? "remove" : "replace"
+		};
+		case "multiple": return {
+			select: "node",
+			type: isSelected ? "remove" : "add"
+		};
+		case "extended": return getExtendedSelectionAction(isSelected, shiftDown, ctrlDown);
+	}
+}
+function getExtendedSelectionAction(isSelected, shiftDown, ctrlDown) {
+	if (shiftDown) return {
+		select: "range",
+		type: "replace"
+	};
+	if (ctrlDown) return {
+		select: "node",
+		type: isSelected ? "remove" : "add"
+	};
+	return {
+		select: "node",
+		type: "replace"
+	};
+}
+function computeFlatNodeList(rootNodes) {
+	const flatNodeList = [];
+	const nodeIdToIndexMap = /* @__PURE__ */ new Map();
+	const flattenNodeRecursively = (nodes) => {
+		nodes.forEach((node) => {
+			nodeIdToIndexMap.set(node.id, flatNodeList.length);
+			flatNodeList.push(node.id);
+			if (node.isExpanded && typeof node.children !== "boolean") flattenNodeRecursively(node.children);
+		});
+	};
+	flattenNodeRecursively(rootNodes);
+	return {
+		flatNodeList,
+		nodeIdToIndexMap
+	};
+}
+//#endregion
+export { useSelectionHandler };
+
+//# sourceMappingURL=UseSelectionHandler.js.map

package/lib/presentation-hierarchies-react/UseSelectionHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseSelectionHandler.js","names":["useCallback","useEffect","useRef","TreeRendererProps","TreeNode","SelectionMode","SelectionChangeType","UseSelectionHandlerProps","Pick","selectionMode","UseSelectionHandlerResult","handleNodeSelect","props","nodeId","isSelected","shiftDown","ctrlDown","FlatTreeState","flatNodeList","Array","nodeIdToIndexMap","Map","useSelectionHandler","$","_c","rootNodes","selectNodes","previousSelectionRef","undefined","t0","Symbol","for","state","t1","t2","current","computeFlatNodeList","t3","firstId","secondId","getIndex","get","firstIndex","secondIndex","startingIndex","Math","min","endIndex","max","slice","getNodeRange","t4","t5","nodeId_0","selection","getSelectionAction","type","nodes","select","length","SelectionAction","getExtendedSelectionAction","flattenNodeRecursively","forEach","node","set","id","push","isExpanded","children"],"sources":["../../src/presentation-hierarchies-react/UseSelectionHandler.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 { useCallback, useEffect, useRef } from \"react\";\n\nimport type { TreeRendererProps } from \"./Renderers.js\";\nimport type { TreeNode } from \"./TreeNode.js\";\n\n/**\n * A union of different supported selection modes in a tree component:\n * - `none` - no selection is allowed,\n * - `single` - only one node can be selected at a time,\n * - `extended` - multiple nodes can be selected using shift and ctrl keys,\n * - `multiple` - multiple nodes can be selected without using shift or ctrl keys.\n *\n * @public\n */\nexport type SelectionMode = \"none\" | \"single\" | \"extended\" | \"multiple\";\n\n/**\n * Type of selection change.\n * - `add` - a node was added to the selection,\n * - `replace` - a selected node was replaced with a different one,\n * - `remove` - a node was removed from the selection.\n *\n * @public\n */\nexport type SelectionChangeType = \"add\" | \"replace\" | \"remove\";\n\n/**\n * Props for `useSelectionHandler` hook.\n * @alpha\n */\ntype UseSelectionHandlerProps = Pick<TreeRendererProps, \"selectNodes\" | \"rootNodes\"> & {\n  /**\n   * Selection mode that the component is working in.\n   */\n  selectionMode: SelectionMode;\n};\n\n/**\n * Result of `useSelectionHandler` hook.\n * @internal\n */\ninterface UseSelectionHandlerResult {\n  /** Updates nodes selection based on current node state and modifier keys used. */\n  handleNodeSelect: (props: { nodeId: string; isSelected: boolean; shiftDown: boolean; ctrlDown: boolean }) => void;\n}\n\ninterface FlatTreeState {\n  flatNodeList: Array<string>;\n  nodeIdToIndexMap: Map<string, number>;\n}\n\n/**\n * A react hook that helps implement different selection modes in a tree component created using `useTree` hook.\n * @internal\n */\nexport function useSelectionHandler(props: UseSelectionHandlerProps): UseSelectionHandlerResult {\n  const { rootNodes, selectionMode, selectNodes } = props;\n  const previousSelectionRef = useRef<string | undefined>(undefined);\n  const state = useRef<FlatTreeState>({ flatNodeList: [], nodeIdToIndexMap: new Map() });\n\n  useEffect(() => {\n    state.current = computeFlatNodeList(rootNodes);\n  }, [rootNodes]);\n\n  const getNodeRange = (firstId?: string, secondId?: string) => {\n    const getIndex = (nodeId?: string) => {\n      return nodeId ? state.current.nodeIdToIndexMap.get(nodeId) : 0;\n    };\n    const firstIndex = getIndex(firstId);\n    const secondIndex = getIndex(secondId);\n    if (firstIndex === undefined || secondIndex === undefined) {\n      return [];\n    }\n\n    const startingIndex = Math.min(firstIndex, secondIndex);\n    const endIndex = Math.max(firstIndex, secondIndex);\n    return state.current.flatNodeList.slice(startingIndex, endIndex + 1);\n  };\n\n  const handleNodeSelect = useCallback<UseSelectionHandlerResult[\"handleNodeSelect\"]>(\n    ({ nodeId, isSelected, shiftDown, ctrlDown }) => {\n      const selection = getSelectionAction(selectionMode, isSelected, shiftDown, ctrlDown);\n      if (selection.type === \"disabled\") {\n        return;\n      }\n\n      const nodes = selection.select === \"range\" ? getNodeRange(previousSelectionRef.current, nodeId) : [nodeId];\n      if (!nodes.length) {\n        return;\n      }\n\n      selection.select !== \"range\" && (previousSelectionRef.current = nodeId);\n      selectNodes(nodes, selection.type);\n    },\n    [selectionMode, selectNodes],\n  );\n\n  return { handleNodeSelect };\n}\n\ninterface SelectionAction {\n  select: \"node\" | \"range\";\n  type: SelectionChangeType | \"disabled\";\n}\n\nfunction getSelectionAction(\n  selectionMode: SelectionMode,\n  isSelected: boolean,\n  shiftDown: boolean,\n  ctrlDown: boolean,\n): SelectionAction {\n  switch (selectionMode) {\n    case \"none\":\n      return { select: \"node\", type: \"disabled\" };\n    case \"single\":\n      return { select: \"node\", type: isSelected ? \"remove\" : \"replace\" };\n    case \"multiple\":\n      return { select: \"node\", type: isSelected ? \"remove\" : \"add\" };\n    case \"extended\":\n      return getExtendedSelectionAction(isSelected, shiftDown, ctrlDown);\n  }\n}\n\nfunction getExtendedSelectionAction(isSelected: boolean, shiftDown: boolean, ctrlDown: boolean): SelectionAction {\n  if (shiftDown) {\n    return { select: \"range\", type: \"replace\" };\n  }\n  if (ctrlDown) {\n    return { select: \"node\", type: isSelected ? \"remove\" : \"add\" };\n  }\n  return { select: \"node\", type: \"replace\" };\n}\n\nfunction computeFlatNodeList(rootNodes: Array<TreeNode>): FlatTreeState {\n  const flatNodeList: Array<string> = [];\n  const nodeIdToIndexMap: Map<string, number> = new Map();\n\n  const flattenNodeRecursively = (nodes: Array<TreeNode>) => {\n    nodes.forEach((node) => {\n      nodeIdToIndexMap.set(node.id, flatNodeList.length);\n      flatNodeList.push(node.id);\n      if (node.isExpanded && typeof node.children !== \"boolean\") {\n        flattenNodeRecursively(node.children);\n      }\n    });\n  };\n\n  flattenNodeRecursively(rootNodes);\n  return { flatNodeList, nodeIdToIndexMap };\n}\n"],"mappings":"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"}

package/lib/presentation-hierarchies-react/UseTree.d.ts

@@ -0,0 +1,112 @@
+import { ErrorInfo, TreeNode } from "./TreeNode.js";
+import { RootErrorRendererProps, TreeRendererProps } from "./Renderers.js";
+import { UseUnifiedTreeSelectionProps } from "./internal/UseUnifiedSelection.js";
+import { GenericInstanceFilter, HierarchyNode, HierarchyProvider, HierarchySearchTree } from "@itwin/presentation-hierarchies";
+import { IPrimitiveValueFormatter } from "@itwin/presentation-shared";
+
+//#region src/presentation-hierarchies-react/UseTree.d.ts
+/**
+ * A React hook that creates state for a tree component.
+ *
+ * The hook uses `@itwin/presentation-hierarchies` package to load the hierarchy data and returns a
+ * component-agnostic result which may be used to render the hierarchy using any UI framework.
+ *
+ * See `README.md` for an example
+ *
+ * @see `useUnifiedSelectionTree`
+ * @see `useIModelTree`
+ * @public
+ */
+declare function useTree(props: UseTreeProps): UseTreeResult;
+/**
+ * A React hook that creates state for a tree component, that is integrated with unified selection
+ * through the given selection storage (previously the storage was provided through the, now
+ * deprecated, `UnifiedSelectionProvider`).
+ *
+ * The hook uses `@itwin/presentation-hierarchies` package to load the hierarchy data and returns a
+ * component-agnostic result which may be used to render the hierarchy using any UI framework.
+ *
+ * See `README.md` for an example
+ *
+ * @see `useTree`
+ * @see `useIModelUnifiedSelectionTree`
+ * @see `UnifiedSelectionProvider`
+ * @public
+ */
+declare function useUnifiedSelectionTree({
+  sourceName,
+  selectionStorage,
+  createSelectableForGenericNode,
+  ...props
+}: UseTreeProps & UseUnifiedTreeSelectionProps): UseTreeResult;
+/** @public */
+interface UseTreeProps {
+  /** Provides the hierarchy provider for the tree. */
+  getHierarchyProvider: () => HierarchyProvider;
+  /** Provides paths to search nodes. */
+  getSearchPaths?: ({
+    abortSignal
+  }: {
+    abortSignal: AbortSignal;
+  }) => Promise<HierarchySearchTree[] | undefined>;
+  /**
+   * Callback that is called just after a certain action is finished.
+   * Can be used for performance tracking.
+   */
+  onPerformanceMeasured?: (action: "initial-load" | "hierarchy-level-load" | "reload", duration: number) => void;
+  /** Action to perform when hierarchy level contains more items that the specified limit. */
+  onHierarchyLimitExceeded?: (props: {
+    parentId?: string;
+    filter?: GenericInstanceFilter;
+    limit?: number | "unbounded";
+  }) => void;
+  /** Action to perform when an error occurs while loading hierarchy. */
+  onHierarchyLoadError?: (props: {
+    parentId?: string;
+    type: "timeout" | "unknown";
+    error: unknown;
+  }) => void;
+  /**
+   * Callback to set custom TreeNode errors.
+   * Errors returned from this callback are combined with internal errors when populating `TreeNode.errors`.
+   */
+  getTreeNodeErrors?: (node: HierarchyNode) => ErrorInfo[];
+}
+/** @public */
+type UseTreeResult = {
+  /**
+   * Specifies whether tree is reloading or not. It is set to `false` when initial tree load is in progress to check if
+   * or tree is reloading.
+   */
+  isReloading: boolean;
+  /**
+   * Get a tree node by id
+   */
+  getNode: (nodeId: string) => TreeNode | undefined;
+  /**
+   * Sets a formatter for the primitive values that are displayed in the hierarchy.
+   */
+  setFormatter: (formatter: IPrimitiveValueFormatter | undefined) => void;
+} & RendererProps;
+/**.
+ * @alpha
+ */
+type RendererProps = {
+  /**
+   * An object containing information used to render root error handling UI.
+   * Use in combination with `RootErrorRenderer` or your custom implementation.
+   * Defined when root nodes fail to load.
+   */
+  rootErrorRendererProps: RootErrorRendererProps;
+} | {
+  /** Is undefined when rootNodes were successfully loaded or are in initial loading process. */rootErrorRendererProps: undefined;
+  /**
+   * An object containing information used to render tree.
+   * Use with `TreeRenderer` or your custom implementation.
+   * Is undefined on initial loading process.
+   */
+  treeRendererProps?: TreeRendererProps;
+};
+//#endregion
+export { UseTreeProps, UseTreeResult, useTree, useUnifiedSelectionTree };
+//# sourceMappingURL=UseTree.d.ts.map

package/lib/presentation-hierarchies-react/UseTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseTree.d.ts","names":[],"sources":["../../src/presentation-hierarchies-react/UseTree.ts"],"mappings":";;;;;;;;AAiCA;;;;;;;;;AAoBA;;iBApBgB,OAAA,CAAQ,KAAA,EAAO,YAAA,GAAe,aAAA;;;;;;;;;;;;;;;;iBAoB9B,uBAAA,CAAA;EACd,UAAA;EACA,gBAAA;EACA,8BAAA;EAAA,GACG;AAAA,GACF,YAAA,GAAe,4BAAA,GAA+B,aAAA;;UAehC,YAAA;EAf6C;EAiB5D,oBAAA,QAA4B,iBAAA;EAFb;EAIf,cAAA;IAAoB;EAAA;IAAiB,WAAA,EAAa,WAAA;EAAA,MAAkB,OAAA,CAAQ,mBAAA;EAAxD;;;;EAKpB,qBAAA,IAAyB,MAAA,sDAA4D,QAAA;EAa1D;EAX3B,wBAAA,IAA4B,KAAA;IAC1B,QAAA;IACA,MAAA,GAAS,qBAAA;IACT,KAAA;EAAA;EAVF;EAaA,oBAAA,IAAwB,KAAA;IAAS,QAAA;IAAmB,IAAA;IAA6B,KAAA;EAAA;EAbL;;;;EAkB5E,iBAAA,IAAqB,IAAA,EAAM,aAAA,KAAkB,SAAA;AAAA;;KAInC,aAAA;EAZR;;;;EAiBF,WAAA;EAdiF;;;EAkBjF,OAAA,GAAU,MAAA,aAAmB,QAAA;EAbR;;;EAiBrB,YAAA,GAAe,SAAA,EAAW,wBAAA;AAAA,IACxB,aAAA;;;;KAKC,aAAA;EALD;;;;;EAYE,sBAAA,EAAwB,sBAAA;AAAA;EAb5B,8FAiBI,sBAAA;EAjBW;;;;AACC;EAsBZ,iBAAA,GAAoB,iBAAA;AAAA"}

package/lib/presentation-hierarchies-react/UseTree.js

@@ -0,0 +1,298 @@
+import { safeDispose } from "./internal/Utils.js";
+import { TreeModel } from "./internal/TreeModel.js";
+import { TreeActions } from "./internal/TreeActions.js";
+import { useUnifiedTreeSelection } from "./internal/UseUnifiedSelection.js";
+import { useLatest } from "./Utils.js";
+import { c } from "react-compiler-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { HierarchyNode } from "@itwin/presentation-hierarchies";
+//#region src/presentation-hierarchies-react/UseTree.ts
+/**
+* A React hook that creates state for a tree component.
+*
+* The hook uses `@itwin/presentation-hierarchies` package to load the hierarchy data and returns a
+* component-agnostic result which may be used to render the hierarchy using any UI framework.
+*
+* See `README.md` for an example
+*
+* @see `useUnifiedSelectionTree`
+* @see `useIModelTree`
+* @public
+*/
+function useTree(props) {
+	const $ = c(2);
+	const t0 = useTreeInternal(props);
+	let rest;
+	if ($[0] !== t0) {
+		const { getTreeModelNode: _, ...t1 } = t0;
+		rest = t1;
+		$[0] = t0;
+		$[1] = rest;
+	} else rest = $[1];
+	return rest;
+}
+/**
+* A React hook that creates state for a tree component, that is integrated with unified selection
+* through the given selection storage (previously the storage was provided through the, now
+* deprecated, `UnifiedSelectionProvider`).
+*
+* The hook uses `@itwin/presentation-hierarchies` package to load the hierarchy data and returns a
+* component-agnostic result which may be used to render the hierarchy using any UI framework.
+*
+* See `README.md` for an example
+*
+* @see `useTree`
+* @see `useIModelUnifiedSelectionTree`
+* @see `UnifiedSelectionProvider`
+* @public
+*/
+function useUnifiedSelectionTree(t0) {
+	const $ = c(19);
+	let createSelectableForGenericNode;
+	let props;
+	let selectionStorage;
+	let sourceName;
+	if ($[0] !== t0) {
+		({sourceName, selectionStorage, createSelectableForGenericNode, ...props} = t0);
+		$[0] = t0;
+		$[1] = createSelectableForGenericNode;
+		$[2] = props;
+		$[3] = selectionStorage;
+		$[4] = sourceName;
+	} else {
+		createSelectableForGenericNode = $[1];
+		props = $[2];
+		selectionStorage = $[3];
+		sourceName = $[4];
+	}
+	const t1 = useTreeInternal(props);
+	let getTreeModelNode;
+	let rest;
+	if ($[5] !== t1) {
+		({getTreeModelNode, ...rest} = t1);
+		$[5] = t1;
+		$[6] = getTreeModelNode;
+		$[7] = rest;
+	} else {
+		getTreeModelNode = $[6];
+		rest = $[7];
+	}
+	let t2;
+	if ($[8] !== createSelectableForGenericNode || $[9] !== getTreeModelNode || $[10] !== selectionStorage || $[11] !== sourceName) {
+		t2 = {
+			sourceName,
+			selectionStorage,
+			getTreeModelNode,
+			createSelectableForGenericNode
+		};
+		$[8] = createSelectableForGenericNode;
+		$[9] = getTreeModelNode;
+		$[10] = selectionStorage;
+		$[11] = sourceName;
+		$[12] = t2;
+	} else t2 = $[12];
+	const selectionProps = useUnifiedTreeSelection(t2);
+	if (rest.rootErrorRendererProps === void 0 && rest.treeRendererProps?.rootNodes) {
+		let t3;
+		if ($[13] !== rest.treeRendererProps || $[14] !== selectionProps) {
+			t3 = {
+				...rest.treeRendererProps,
+				...selectionProps
+			};
+			$[13] = rest.treeRendererProps;
+			$[14] = selectionProps;
+			$[15] = t3;
+		} else t3 = $[15];
+		let t4;
+		if ($[16] !== rest || $[17] !== t3) {
+			t4 = {
+				...rest,
+				treeRendererProps: t3
+			};
+			$[16] = rest;
+			$[17] = t3;
+			$[18] = t4;
+		} else t4 = $[18];
+		return t4;
+	}
+	return rest;
+}
+function useTreeInternal({ getHierarchyProvider, getSearchPaths, onPerformanceMeasured, onHierarchyLimitExceeded, onHierarchyLoadError, getTreeNodeErrors }) {
+	const [state, setState] = useState({
+		model: {
+			idToNode: /* @__PURE__ */ new Map(),
+			parentChildMap: /* @__PURE__ */ new Map(),
+			rootNode: {
+				id: void 0,
+				nodeData: void 0
+			}
+		},
+		rootNodes: void 0
+	});
+	const onPerformanceMeasuredRef = useLatest(onPerformanceMeasured);
+	const onHierarchyLimitExceededRef = useLatest(onHierarchyLimitExceeded);
+	const onHierarchyLoadErrorRef = useLatest(onHierarchyLoadError);
+	const getTreeNodeErrorsRef = useLatest(getTreeNodeErrors);
+	const [actions] = useState(() => new TreeActions((model) => {
+		setState({
+			model,
+			rootNodes: model.parentChildMap.get(void 0) !== void 0 ? generateTreeStructure(void 0, model, getTreeNodeErrorsRef.current) : void 0
+		});
+	}, (actionType, duration) => onPerformanceMeasuredRef.current?.(actionType, duration), (props) => onHierarchyLimitExceededRef.current?.(props), (props_0) => onHierarchyLoadErrorRef.current?.(props_0)));
+	const currentFormatter = useRef();
+	const [hierarchyProvider, setHierarchyProvider] = useState();
+	useEffect(() => {
+		const provider = getHierarchyProvider();
+		provider.setFormatter(currentFormatter.current);
+		const removeHierarchyChangedListener = provider.hierarchyChanged.addListener((hierarchyChangeArgs) => {
+			const shouldDiscardState = hierarchyChangeArgs.searchChange?.newSearch !== void 0;
+			actions.reloadTree({ state: shouldDiscardState ? "discard" : "keep" });
+		});
+		actions.setHierarchyProvider(provider);
+		setHierarchyProvider(provider);
+		return () => {
+			removeHierarchyChangedListener();
+			actions.reset();
+			safeDispose(provider);
+		};
+	}, [actions, getHierarchyProvider]);
+	const [isSearching, setIsSearching] = useState(false);
+	useEffect(() => {
+		let disposed = false;
+		const controller = new AbortController();
+		(async () => {
+			if (!hierarchyProvider) return;
+			if (!getSearchPaths) {
+				hierarchyProvider.setHierarchySearch(void 0);
+				actions.reloadTree({ state: "keep" });
+				setIsSearching(false);
+				return;
+			}
+			setIsSearching(true);
+			let paths;
+			try {
+				paths = await getSearchPaths({ abortSignal: controller.signal });
+			} catch {} finally {
+				if (!disposed) {
+					hierarchyProvider.setHierarchySearch(paths ? { paths } : void 0);
+					setIsSearching(false);
+				}
+			}
+		})();
+		return () => {
+			controller.abort();
+			disposed = true;
+		};
+	}, [
+		hierarchyProvider,
+		getSearchPaths,
+		actions
+	]);
+	const getTreeModelNode = useCallback((nodeId) => {
+		return actions.getNode(nodeId);
+	}, [actions]);
+	const getNode = useCallback((nodeId_0) => {
+		const node = actions.getNode(nodeId_0);
+		if (!node || node.id === void 0) return;
+		return createTreeNode(node, state.model, getTreeNodeErrorsRef.current);
+	}, [
+		actions,
+		getTreeNodeErrorsRef,
+		state.model
+	]);
+	const expandNode = useCallback((nodeId_1, isExpanded) => {
+		actions.expandNode(nodeId_1, isExpanded);
+	}, [actions]);
+	const reloadTree = useCallback((options) => {
+		actions.reloadTree(options);
+	}, [actions]);
+	const selectNodes = useCallback((nodeIds, changeType) => {
+		actions.selectNodes(nodeIds, changeType);
+	}, [actions]);
+	const isNodeSelected = useCallback((nodeId_2) => TreeModel.isNodeSelected(state.model, nodeId_2), [state]);
+	const setFormatter = useCallback((formatter) => {
+		currentFormatter.current = formatter;
+		/* c8 ignore next 3 */
+		if (!hierarchyProvider) return;
+		hierarchyProvider.setFormatter(formatter);
+	}, [hierarchyProvider]);
+	const getHierarchyLevelDetails = useCallback((nodeId_3) => {
+		const node_0 = actions.getNode(nodeId_3);
+		if (!hierarchyProvider || !node_0) return;
+		const hierarchyNode = node_0.nodeData;
+		if (hierarchyNode && HierarchyNode.isGroupingNode(hierarchyNode)) return;
+		return {
+			hierarchyNode,
+			getInstanceKeysIterator: (props_1) => hierarchyProvider.getNodeInstanceKeys({
+				parentNode: hierarchyNode,
+				instanceFilter: props_1?.instanceFilter,
+				hierarchyLevelSizeLimit: props_1?.hierarchyLevelSizeLimit
+			}),
+			instanceFilter: node_0.instanceFilter,
+			setInstanceFilter: (filter) => actions.setInstanceFilter(nodeId_3, filter),
+			sizeLimit: node_0.hierarchyLimit,
+			setSizeLimit: (value) => actions.setHierarchyLimit(nodeId_3, value)
+		};
+	}, [actions, hierarchyProvider]);
+	return {
+		...useMemo(() => {
+			if (state.model.rootNode.error) return { rootErrorRendererProps: {
+				error: state.model.rootNode.error,
+				reloadTree,
+				getHierarchyLevelDetails
+			} };
+			return {
+				rootErrorRendererProps: void 0,
+				treeRendererProps: state.rootNodes ? {
+					rootNodes: state.rootNodes,
+					expandNode,
+					selectNodes,
+					isNodeSelected,
+					reloadTree,
+					getHierarchyLevelDetails
+				} : void 0
+			};
+		}, [
+			expandNode,
+			getHierarchyLevelDetails,
+			isNodeSelected,
+			reloadTree,
+			selectNodes,
+			state.model.rootNode.error,
+			state.rootNodes
+		]),
+		isReloading: !!state.model.rootNode.isLoading || isSearching,
+		getTreeModelNode,
+		getNode,
+		setFormatter
+	};
+}
+function generateTreeStructure(parentNodeId, model, getTreeNodeErrors) {
+	const currentChildren = model.parentChildMap.get(parentNodeId);
+	if (!currentChildren) return;
+	return currentChildren.map((childId) => model.idToNode.get(childId)).filter((node) => !!node).map((node) => {
+		return createTreeNode(node, model, getTreeNodeErrors);
+	});
+}
+function createTreeNode(modelNode, model, getTreeNodeErrors) {
+	const allErrors = [...modelNode.error ? [modelNode.error] : [], ...getTreeNodeErrors?.(modelNode.nodeData) ?? []];
+	let children;
+	return {
+		id: modelNode.id,
+		label: modelNode.label,
+		nodeData: modelNode.nodeData,
+		isLoading: !!modelNode.isLoading,
+		isExpanded: !!modelNode.isExpanded,
+		isFilterable: !HierarchyNode.isGroupingNode(modelNode.nodeData) && !!modelNode.nodeData.supportsFiltering && modelNode.children,
+		isFiltered: !!modelNode.instanceFilter,
+		errors: allErrors,
+		get children() {
+			if (!children) children = generateTreeStructure(modelNode.id, model, getTreeNodeErrors);
+			return children ? children : modelNode.children === true ? true : [];
+		}
+	};
+}
+//#endregion
+export { useTree, useUnifiedSelectionTree };
+
+//# sourceMappingURL=UseTree.js.map

package/lib/presentation-hierarchies-react/UseTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseTree.js","names":["useCallback","useEffect","useMemo","useRef","useState","HierarchyNode","TreeActions","TreeModel","useUnifiedTreeSelection","safeDispose","useLatest","GenericInstanceFilter","HierarchyProvider","HierarchySearchTree","IPrimitiveValueFormatter","TreeModelHierarchyNode","TreeModelRootNode","UseUnifiedTreeSelectionProps","RootErrorRendererProps","TreeRendererProps","ErrorInfo","TreeNode","SelectionChangeType","useTree","props","$","_c","t0","useTreeInternal","rest","getTreeModelNode","_","t1","useUnifiedSelectionTree","createSelectableForGenericNode","selectionStorage","sourceName","t2","selectionProps","rootErrorRendererProps","undefined","treeRendererProps","rootNodes","t3","t4","UseTreeProps","getHierarchyProvider","getSearchPaths","abortSignal","AbortSignal","Promise","onPerformanceMeasured","action","duration","onHierarchyLimitExceeded","parentId","filter","limit","onHierarchyLoadError","type","error","getTreeNodeErrors","node","UseTreeResult","isReloading","getNode","nodeId","setFormatter","formatter","RendererProps","TreeState","model","Array","state","setState","idToNode","Map","parentChildMap","rootNode","id","nodeData","onPerformanceMeasuredRef","onHierarchyLimitExceededRef","onHierarchyLoadErrorRef","getTreeNodeErrorsRef","actions","get","generateTreeStructure","current","actionType","currentFormatter","hierarchyProvider","setHierarchyProvider","provider","removeHierarchyChangedListener","hierarchyChanged","addListener","hierarchyChangeArgs","shouldDiscardState","searchChange","newSearch","reloadTree","reset","isSearching","setIsSearching","disposed","controller","AbortController","setHierarchySearch","paths","signal","abort","createTreeNode","expandNode","isExpanded","options","selectNodes","nodeIds","changeType","isNodeSelected","getHierarchyLevelDetails","hierarchyNode","isGroupingNode","getInstanceKeysIterator","getNodeInstanceKeys","parentNode","instanceFilter","hierarchyLevelSizeLimit","setInstanceFilter","sizeLimit","hierarchyLimit","setSizeLimit","value","setHierarchyLimit","renderProps","isLoading","parentNodeId","currentChildren","map","childId","modelNode","allErrors","children","label","isFilterable","supportsFiltering","isFiltered","errors"],"sources":["../../src/presentation-hierarchies-react/UseTree.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 { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\nimport { HierarchyNode } from \"@itwin/presentation-hierarchies\";\nimport { TreeActions } from \"./internal/TreeActions.js\";\nimport { TreeModel } from \"./internal/TreeModel.js\";\nimport { useUnifiedTreeSelection } from \"./internal/UseUnifiedSelection.js\";\nimport { safeDispose } from \"./internal/Utils.js\";\nimport { useLatest } from \"./Utils.js\";\n\nimport type { GenericInstanceFilter, HierarchyProvider, HierarchySearchTree } from \"@itwin/presentation-hierarchies\";\nimport type { IPrimitiveValueFormatter } from \"@itwin/presentation-shared\";\nimport type { TreeModelHierarchyNode, TreeModelRootNode } from \"./internal/TreeModel.js\";\nimport type { UseUnifiedTreeSelectionProps } from \"./internal/UseUnifiedSelection.js\";\nimport type { RootErrorRendererProps, TreeRendererProps } from \"./Renderers.js\";\nimport type { ErrorInfo, TreeNode } from \"./TreeNode.js\";\nimport type { SelectionChangeType } from \"./UseSelectionHandler.js\";\n\n/**\n * A React hook that creates state for a tree component.\n *\n * The hook uses `@itwin/presentation-hierarchies` package to load the hierarchy data and returns a\n * component-agnostic result which may be used to render the hierarchy using any UI framework.\n *\n * See `README.md` for an example\n *\n * @see `useUnifiedSelectionTree`\n * @see `useIModelTree`\n * @public\n */\nexport function useTree(props: UseTreeProps): UseTreeResult {\n  const { getTreeModelNode: _, ...rest } = useTreeInternal(props);\n  return rest;\n}\n\n/**\n * A React hook that creates state for a tree component, that is integrated with unified selection\n * through the given selection storage (previously the storage was provided through the, now\n * deprecated, `UnifiedSelectionProvider`).\n *\n * The hook uses `@itwin/presentation-hierarchies` package to load the hierarchy data and returns a\n * component-agnostic result which may be used to render the hierarchy using any UI framework.\n *\n * See `README.md` for an example\n *\n * @see `useTree`\n * @see `useIModelUnifiedSelectionTree`\n * @see `UnifiedSelectionProvider`\n * @public\n */\nexport function useUnifiedSelectionTree({\n  sourceName,\n  selectionStorage,\n  createSelectableForGenericNode,\n  ...props\n}: UseTreeProps & UseUnifiedTreeSelectionProps): UseTreeResult {\n  const { getTreeModelNode, ...rest } = useTreeInternal(props);\n  const selectionProps = useUnifiedTreeSelection({\n    sourceName,\n    selectionStorage,\n    getTreeModelNode,\n    createSelectableForGenericNode,\n  });\n  if (rest.rootErrorRendererProps === undefined && rest.treeRendererProps?.rootNodes) {\n    return { ...rest, treeRendererProps: { ...rest.treeRendererProps, ...selectionProps } };\n  }\n  return rest;\n}\n\n/** @public */\nexport interface UseTreeProps {\n  /** Provides the hierarchy provider for the tree. */\n  getHierarchyProvider: () => HierarchyProvider;\n  /** Provides paths to search nodes. */\n  getSearchPaths?: ({ abortSignal }: { abortSignal: AbortSignal }) => Promise<HierarchySearchTree[] | undefined>;\n  /**\n   * Callback that is called just after a certain action is finished.\n   * Can be used for performance tracking.\n   */\n  onPerformanceMeasured?: (action: \"initial-load\" | \"hierarchy-level-load\" | \"reload\", duration: number) => void;\n  /** Action to perform when hierarchy level contains more items that the specified limit. */\n  onHierarchyLimitExceeded?: (props: {\n    parentId?: string;\n    filter?: GenericInstanceFilter;\n    limit?: number | \"unbounded\";\n  }) => void;\n  /** Action to perform when an error occurs while loading hierarchy. */\n  onHierarchyLoadError?: (props: { parentId?: string; type: \"timeout\" | \"unknown\"; error: unknown }) => void;\n  /**\n   * Callback to set custom TreeNode errors.\n   * Errors returned from this callback are combined with internal errors when populating `TreeNode.errors`.\n   */\n  getTreeNodeErrors?: (node: HierarchyNode) => ErrorInfo[];\n}\n\n/** @public */\nexport type UseTreeResult = {\n  /**\n   * Specifies whether tree is reloading or not. It is set to `false` when initial tree load is in progress to check if\n   * or tree is reloading.\n   */\n  isReloading: boolean;\n  /**\n   * Get a tree node by id\n   */\n  getNode: (nodeId: string) => TreeNode | undefined;\n  /**\n   * Sets a formatter for the primitive values that are displayed in the hierarchy.\n   */\n  setFormatter: (formatter: IPrimitiveValueFormatter | undefined) => void;\n} & RendererProps;\n\n/**.\n * @alpha\n */\ntype RendererProps =\n  | {\n      /**\n       * An object containing information used to render root error handling UI.\n       * Use in combination with `RootErrorRenderer` or your custom implementation.\n       * Defined when root nodes fail to load.\n       */\n      rootErrorRendererProps: RootErrorRendererProps;\n    }\n  | {\n      /** Is undefined when rootNodes were successfully loaded or are in initial loading process. */\n      rootErrorRendererProps: undefined;\n      /**\n       * An object containing information used to render tree.\n       * Use with `TreeRenderer` or your custom implementation.\n       * Is undefined on initial loading process.\n       */\n      treeRendererProps?: TreeRendererProps;\n    };\n\ninterface TreeState {\n  model: TreeModel;\n  rootNodes: Array<TreeNode> | undefined;\n}\n\nfunction useTreeInternal({\n  getHierarchyProvider,\n  getSearchPaths,\n  onPerformanceMeasured,\n  onHierarchyLimitExceeded,\n  onHierarchyLoadError,\n  getTreeNodeErrors,\n}: UseTreeProps): UseTreeResult & {\n  getTreeModelNode: (nodeId: string) => TreeModelRootNode | TreeModelHierarchyNode | undefined;\n} {\n  const [state, setState] = useState<TreeState>({\n    model: { idToNode: new Map(), parentChildMap: new Map(), rootNode: { id: undefined, nodeData: undefined } },\n    rootNodes: undefined,\n  });\n  const onPerformanceMeasuredRef = useLatest(onPerformanceMeasured);\n  const onHierarchyLimitExceededRef = useLatest(onHierarchyLimitExceeded);\n  const onHierarchyLoadErrorRef = useLatest(onHierarchyLoadError);\n  const getTreeNodeErrorsRef = useLatest(getTreeNodeErrors);\n\n  const [actions] = useState<TreeActions>(\n    () =>\n      new TreeActions(\n        (model) => {\n          const rootNodes =\n            model.parentChildMap.get(undefined) !== undefined\n              ? generateTreeStructure(undefined, model, getTreeNodeErrorsRef.current)\n              : undefined;\n          setState({ model, rootNodes });\n        },\n        (actionType, duration) => onPerformanceMeasuredRef.current?.(actionType, duration),\n        (props) => onHierarchyLimitExceededRef.current?.(props),\n        (props) => onHierarchyLoadErrorRef.current?.(props),\n      ),\n  );\n  const currentFormatter = useRef<IPrimitiveValueFormatter>();\n\n  const [hierarchyProvider, setHierarchyProvider] = useState<HierarchyProvider | undefined>();\n  useEffect(() => {\n    const provider = getHierarchyProvider();\n    provider.setFormatter(currentFormatter.current);\n    const removeHierarchyChangedListener = provider.hierarchyChanged.addListener((hierarchyChangeArgs) => {\n      const shouldDiscardState = hierarchyChangeArgs.searchChange?.newSearch !== undefined;\n      actions.reloadTree({ state: shouldDiscardState ? \"discard\" : \"keep\" });\n    });\n    actions.setHierarchyProvider(provider);\n    setHierarchyProvider(provider);\n    return () => {\n      removeHierarchyChangedListener();\n      actions.reset();\n      safeDispose(provider);\n    };\n  }, [actions, getHierarchyProvider]);\n\n  const [isSearching, setIsSearching] = useState(false);\n  useEffect(() => {\n    let disposed = false as boolean;\n    const controller = new AbortController();\n    void (async () => {\n      if (!hierarchyProvider) {\n        return;\n      }\n\n      if (!getSearchPaths) {\n        hierarchyProvider.setHierarchySearch(undefined);\n        // reload tree in case hierarchy provider does not use hierarchy search to load initial nodes\n        actions.reloadTree({ state: \"keep\" });\n        setIsSearching(false);\n        return;\n      }\n\n      setIsSearching(true);\n      let paths: HierarchySearchTree[] | undefined;\n      try {\n        paths = await getSearchPaths({ abortSignal: controller.signal });\n      } catch {\n      } finally {\n        if (!disposed) {\n          hierarchyProvider.setHierarchySearch(paths ? { paths } : undefined);\n          setIsSearching(false);\n        }\n      }\n    })();\n    return () => {\n      controller.abort();\n      disposed = true;\n    };\n  }, [hierarchyProvider, getSearchPaths, actions]);\n\n  const getTreeModelNode = useCallback<(nodeId: string) => TreeModelRootNode | TreeModelHierarchyNode | undefined>(\n    (nodeId: string) => {\n      return actions.getNode(nodeId);\n    },\n    [actions],\n  );\n\n  const getNode = useCallback(\n    (nodeId: string): TreeNode | undefined => {\n      const node = actions.getNode(nodeId);\n      if (!node || node.id === undefined) {\n        return undefined;\n      }\n      return createTreeNode(node, state.model, getTreeNodeErrorsRef.current);\n    },\n    [actions, getTreeNodeErrorsRef, state.model],\n  );\n\n  const expandNode = useCallback<TreeRendererProps[\"expandNode\"]>(\n    (nodeId: string, isExpanded: boolean) => {\n      actions.expandNode(nodeId, isExpanded);\n    },\n    [actions],\n  );\n\n  const reloadTree = useCallback<TreeRendererProps[\"reloadTree\"]>(\n    (options) => {\n      actions.reloadTree(options);\n    },\n    [actions],\n  );\n\n  const selectNodes = useCallback<TreeRendererProps[\"selectNodes\"]>(\n    (nodeIds: Array<string>, changeType: SelectionChangeType) => {\n      actions.selectNodes(nodeIds, changeType);\n    },\n    [actions],\n  );\n\n  const isNodeSelected = useCallback<TreeRendererProps[\"isNodeSelected\"]>(\n    (nodeId: string) => TreeModel.isNodeSelected(state.model, nodeId),\n    [state],\n  );\n\n  const setFormatter = useCallback<UseTreeResult[\"setFormatter\"]>(\n    (formatter: IPrimitiveValueFormatter | undefined) => {\n      currentFormatter.current = formatter;\n      /* c8 ignore next 3 */\n      if (!hierarchyProvider) {\n        return;\n      }\n\n      hierarchyProvider.setFormatter(formatter);\n    },\n    [hierarchyProvider],\n  );\n\n  const getHierarchyLevelDetails = useCallback<TreeRendererProps[\"getHierarchyLevelDetails\"]>(\n    (nodeId) => {\n      const node = actions.getNode(nodeId);\n      if (!hierarchyProvider || !node) {\n        return undefined;\n      }\n      const hierarchyNode = node.nodeData;\n      if (hierarchyNode && HierarchyNode.isGroupingNode(hierarchyNode)) {\n        return undefined;\n      }\n\n      return {\n        hierarchyNode,\n        getInstanceKeysIterator: (props) =>\n          hierarchyProvider.getNodeInstanceKeys({\n            parentNode: hierarchyNode,\n            instanceFilter: props?.instanceFilter,\n            hierarchyLevelSizeLimit: props?.hierarchyLevelSizeLimit,\n          }),\n        instanceFilter: node.instanceFilter,\n        setInstanceFilter: (filter) => actions.setInstanceFilter(nodeId, filter),\n        sizeLimit: node.hierarchyLimit,\n        setSizeLimit: (value) => actions.setHierarchyLimit(nodeId, value),\n      };\n    },\n    [actions, hierarchyProvider],\n  );\n\n  const renderProps: RendererProps = useMemo(() => {\n    if (state.model.rootNode.error) {\n      return { rootErrorRendererProps: { error: state.model.rootNode.error, reloadTree, getHierarchyLevelDetails } };\n    }\n    return {\n      rootErrorRendererProps: undefined,\n      treeRendererProps: state.rootNodes\n        ? { rootNodes: state.rootNodes, expandNode, selectNodes, isNodeSelected, reloadTree, getHierarchyLevelDetails }\n        : undefined,\n    };\n  }, [\n    expandNode,\n    getHierarchyLevelDetails,\n    isNodeSelected,\n    reloadTree,\n    selectNodes,\n    state.model.rootNode.error,\n    state.rootNodes,\n  ]);\n\n  return {\n    ...renderProps,\n    isReloading: !!state.model.rootNode.isLoading || isSearching,\n    getTreeModelNode,\n    getNode,\n    setFormatter,\n  };\n}\n\nfunction generateTreeStructure(\n  parentNodeId: string | undefined,\n  model: TreeModel,\n  getTreeNodeErrors?: (node: HierarchyNode) => ErrorInfo[],\n): Array<TreeNode> | undefined {\n  const currentChildren = model.parentChildMap.get(parentNodeId);\n  if (!currentChildren) {\n    return undefined;\n  }\n\n  return currentChildren\n    .map((childId) => model.idToNode.get(childId))\n    .filter((node): node is TreeModelHierarchyNode => !!node)\n    .map<TreeNode>((node) => {\n      return createTreeNode(node, model, getTreeNodeErrors);\n    });\n}\n\nfunction createTreeNode(\n  modelNode: TreeModelHierarchyNode,\n  model: TreeModel,\n  getTreeNodeErrors?: (node: HierarchyNode) => ErrorInfo[],\n): TreeNode {\n  const allErrors = [\n    // internal errors\n    ...(modelNode.error ? [modelNode.error] : []),\n    // external errors\n    ...(getTreeNodeErrors?.(modelNode.nodeData) ?? []),\n  ];\n\n  let children: Array<TreeNode> | undefined;\n  return {\n    id: modelNode.id,\n    label: modelNode.label,\n    nodeData: modelNode.nodeData,\n    isLoading: !!modelNode.isLoading,\n    isExpanded: !!modelNode.isExpanded,\n    isFilterable:\n      !HierarchyNode.isGroupingNode(modelNode.nodeData) && !!modelNode.nodeData.supportsFiltering && modelNode.children,\n    isFiltered: !!modelNode.instanceFilter,\n    errors: allErrors,\n    get children() {\n      if (!children) {\n        children = generateTreeStructure(modelNode.id, model, getTreeNodeErrors);\n      }\n      return children ? children : modelNode.children === true ? true : [];\n    },\n  };\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,56 @@
+import { c } from "react-compiler-runtime";
+import { useCallback, useInsertionEffect, useRef } from "react";
+//#region src/presentation-hierarchies-react/Utils.ts
+/** @internal */
+function useLatest(value) {
+	const $ = c(3);
+	const ref = useRef(value);
+	let t0;
+	let t1;
+	if ($[0] !== value) {
+		t0 = () => {
+			ref.current = value;
+		};
+		t1 = [value];
+		$[0] = value;
+		$[1] = t0;
+		$[2] = t1;
+	} else {
+		t0 = $[1];
+		t1 = $[2];
+	}
+	useInsertionEffect(t0, t1);
+	return ref;
+}
+/* c8 ignore start */
+/** @internal */
+function useEvent(callback) {
+	const $ = c(2);
+	const latestCallback = useLatest(callback);
+	let t0;
+	if ($[0] !== latestCallback) {
+		t0 = (...t1) => {
+			const args = t1;
+			latestCallback.current(...args);
+		};
+		$[0] = latestCallback;
+		$[1] = t0;
+	} else t0 = $[1];
+	return t0;
+}
+/* c8 ignore end */
+/* c8 ignore start */
+/** @internal */
+function useMergedRefs(...refs) {
+	return useCallback((instance) => {
+		refs.forEach((ref) => {
+			if (typeof ref === "function") ref(instance);
+			else if (ref) ref.current = instance;
+		});
+	}, [...refs]);
+}
+/* c8 ignore end */
+//#endregion
+export { useEvent, useLatest, useMergedRefs };
+
+//# sourceMappingURL=Utils.js.map