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

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

@@ -0,0 +1,30 @@
+import { TreeNode } from "./TreeNode.js";
+import { ReactElement } from "react";
+
+//#region src/presentation-hierarchies-react/UseNodeHighlighting.d.ts
+/**
+ * Props for `useNodeHighlighting` hook.
+ * @alpha
+ */
+interface UseNodeHighlightingProps {
+  /** Text that should be highlighted */
+  highlightText?: string;
+}
+/**
+ * Result of `useNodeHighlighting` hook.
+ * @alpha
+ */
+interface UseNodeHighlightingResult {
+  /** Function that creates highlighted node labels. */
+  getLabel: (node: TreeNode) => ReactElement;
+}
+/**
+ * A react hook that helps create highlighted node labels based on provided highlight.
+ * @alpha
+ */
+declare function useNodeHighlighting({
+  highlightText
+}: UseNodeHighlightingProps): UseNodeHighlightingResult;
+//#endregion
+export { useNodeHighlighting };
+//# sourceMappingURL=UseNodeHighlighting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UseNodeHighlighting.d.ts","names":[],"sources":["../../src/presentation-hierarchies-react/UseNodeHighlighting.tsx"],"mappings":";;;;;;AAS8C;;UAMpC,wBAAA;EAER;EAAA,aAAA;AAAA;;;;;UAOQ,yBAAA;EAEG;EAAX,QAAA,GAAW,IAAA,EAAM,QAAA,KAAa,YAAA;AAAA;;AAOhC;;;iBAAgB,mBAAA,CAAA;EAAsB;AAAA,GAAiB,wBAAA,GAA2B,yBAAA"}

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

@@ -0,0 +1,58 @@
+import { c } from "react-compiler-runtime";
+import { HierarchyNode } from "@itwin/presentation-hierarchies";
+import { Fragment, jsx } from "react/jsx-runtime";
+
+//#region src/presentation-hierarchies-react/UseNodeHighlighting.tsx
+/**
+* A react hook that helps create highlighted node labels based on provided highlight.
+* @alpha
+*/
+function useNodeHighlighting(t0) {
+	const $ = c(4);
+	const { highlightText } = t0;
+	let t1;
+	if ($[0] !== highlightText) {
+		t1 = (node) => {
+			if (!highlightText || HierarchyNode.isGroupingNode(node.nodeData) || !node.nodeData.search?.isSearchTarget) return /* @__PURE__ */ jsx("span", { children: node.label });
+			const matchedIndexes = new Array();
+			const nodeLabel = node.label.toLocaleLowerCase();
+			const searchText = highlightText.toLocaleLowerCase();
+			let fromPosition = 0;
+			while (true) {
+				const foundIndex = nodeLabel.indexOf(searchText, fromPosition);
+				if (foundIndex === -1) break;
+				matchedIndexes.push(foundIndex);
+				fromPosition = foundIndex + searchText.length;
+			}
+			if (matchedIndexes.length === 0) return /* @__PURE__ */ jsx("span", { children: node.label });
+			const finalLabel = new Array();
+			let lastAddedPosition = 0;
+			for (let i = 0; i < matchedIndexes.length; ++i) {
+				const matchedIndex = matchedIndexes[i];
+				if (matchedIndex > lastAddedPosition) {
+					finalLabel.push(/* @__PURE__ */ jsx("span", { children: node.label.substring(lastAddedPosition, matchedIndex) }, `normal-${i}`));
+					lastAddedPosition = matchedIndex;
+				}
+				const endingPlace = matchedIndex + highlightText.length;
+				finalLabel.push(/* @__PURE__ */ jsx("mark", { children: node.label.substring(lastAddedPosition, endingPlace) }, `marked-${i}`));
+				lastAddedPosition = endingPlace;
+			}
+			if (lastAddedPosition < node.label.length) finalLabel.push(/* @__PURE__ */ jsx("span", { children: node.label.substring(lastAddedPosition) }, `normal-${matchedIndexes.length + 1}`));
+			return /* @__PURE__ */ jsx(Fragment, { children: finalLabel });
+		};
+		$[0] = highlightText;
+		$[1] = t1;
+	} else t1 = $[1];
+	const getLabel = t1;
+	let t2;
+	if ($[2] !== getLabel) {
+		t2 = { getLabel };
+		$[2] = getLabel;
+		$[3] = t2;
+	} else t2 = $[3];
+	return t2;
+}
+
+//#endregion
+export { useNodeHighlighting };
+//# sourceMappingURL=UseNodeHighlighting.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UseNodeHighlighting.js","names":["useCallback","HierarchyNode","JSX","ReactElement","TreeNode","UseNodeHighlightingProps","highlightText","UseNodeHighlightingResult","getLabel","node","useNodeHighlighting","t0","$","_c","t1","isGroupingNode","nodeData","search","isSearchTarget","label","matchedIndexes","Array","nodeLabel","toLocaleLowerCase","searchText","fromPosition","foundIndex","indexOf","push","length","finalLabel","lastAddedPosition","i","matchedIndex","substring","endingPlace","t2"],"sources":["../../src/presentation-hierarchies-react/UseNodeHighlighting.tsx"],"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 } from \"react\";\nimport { HierarchyNode } from \"@itwin/presentation-hierarchies\";\n\nimport type { JSX, ReactElement } from \"react\";\nimport type { TreeNode } from \"./TreeNode.js\";\n\n/**\n * Props for `useNodeHighlighting` hook.\n * @alpha\n */\ninterface UseNodeHighlightingProps {\n  /** Text that should be highlighted */\n  highlightText?: string;\n}\n\n/**\n * Result of `useNodeHighlighting` hook.\n * @alpha\n */\ninterface UseNodeHighlightingResult {\n  /** Function that creates highlighted node labels. */\n  getLabel: (node: TreeNode) => ReactElement;\n}\n\n/**\n * A react hook that helps create highlighted node labels based on provided highlight.\n * @alpha\n */\nexport function useNodeHighlighting({ highlightText }: UseNodeHighlightingProps): UseNodeHighlightingResult {\n  const getLabel = useCallback(\n    (node: TreeNode) => {\n      if (!highlightText || HierarchyNode.isGroupingNode(node.nodeData) || !node.nodeData.search?.isSearchTarget) {\n        return <span>{node.label}</span>;\n      }\n\n      const matchedIndexes = new Array<number>();\n      const nodeLabel = node.label.toLocaleLowerCase();\n      const searchText = highlightText.toLocaleLowerCase();\n      let fromPosition = 0;\n      // Find all occurrences of the search text in the node label\n      while (true) {\n        const foundIndex = nodeLabel.indexOf(searchText, fromPosition);\n        if (foundIndex === -1) {\n          break;\n        }\n        matchedIndexes.push(foundIndex);\n        fromPosition = foundIndex + searchText.length;\n      }\n\n      if (matchedIndexes.length === 0) {\n        return <span>{node.label}</span>;\n      }\n\n      // Create the final label with highlighted parts\n      const finalLabel = new Array<JSX.Element>();\n      let lastAddedPosition = 0;\n      for (let i = 0; i < matchedIndexes.length; ++i) {\n        const matchedIndex = matchedIndexes[i];\n        if (matchedIndex > lastAddedPosition) {\n          finalLabel.push(<span key={`normal-${i}`}>{node.label.substring(lastAddedPosition, matchedIndex)}</span>);\n          lastAddedPosition = matchedIndex;\n        }\n        const endingPlace = matchedIndex + highlightText.length;\n        finalLabel.push(<mark key={`marked-${i}`}>{node.label.substring(lastAddedPosition, endingPlace)}</mark>);\n        lastAddedPosition = endingPlace;\n      }\n      if (lastAddedPosition < node.label.length) {\n        finalLabel.push(<span key={`normal-${matchedIndexes.length + 1}`}>{node.label.substring(lastAddedPosition)}</span>);\n      }\n\n      return <>{finalLabel}</>;\n    },\n    [highlightText],\n  );\n\n  return { getLabel };\n}\n"],"mappings":";;;;;;;;;AAiCA,SAAOU,oBAAAC,IAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAA6B,MAAA,EAAAP,kBAAAK;CAA2C,IAAAG;AAAA,KAAAF,EAAA,OAAAN,eAAA;AAE3EQ,QAAAL,SAAA;AACE,OAAI,CAACH,iBAAiBL,cAAac,eAAgBN,KAAIO,SAAmD,IAAtG,CAAkEP,KAAIO,SAASC,QAAuBC,eAAA,QACjG,oBAAA,oBAAOT,KAAIU,QAAc;GAGlC,MAAAC,iBAAuB,IAAIC,OAAe;GAC1C,MAAAC,YAAkBb,KAAIU,MAAMI,mBAAoB;GAChD,MAAAC,aAAmBlB,cAAaiB,mBAAoB;GACpD,IAAAE,eAAmB;AAEnB,UAAO,MAAI;IACT,MAAAC,aAAmBJ,UAASK,QAASH,YAAYC,aAAa;AAC9D,QAAIC,eAAe,GACjB;AAEFN,mBAAcQ,KAAMF,WAAW;AAC/BD,mBAAeC,aAAaF,WAAUK;;AAGxC,OAAIT,eAAcS,WAAY,EAAC,QACtB,oBAAA,oBAAOpB,KAAIU,QAAc;GAIlC,MAAAW,aAAmB,IAAIT,OAAoB;GAC3C,IAAAU,oBAAwB;AACxB,QAAA,IAAAC,IAAa,GAAGA,IAAIZ,eAAcS,QAAS,EAAEG,GAAC;IAC5C,MAAAC,eAAqBb,eAAeY;AACpC,QAAIC,eAAeF,mBAAiB;AAClCD,gBAAUF,KAAM,oBAAA,oBAA2BnB,KAAIU,MAAMe,UAAWH,mBAAmBE,aAAY,IAApE,UAAUD,IAAmE,CAAC;AACzGD,yBAAoBE;;IAEtB,MAAAE,cAAoBF,eAAe3B,cAAauB;AAChDC,eAAUF,KAAM,oBAAA,oBAA2BnB,KAAIU,MAAMe,UAAWH,mBAAmBI,YAAW,IAAnE,UAAUH,IAAkE,CAAC;AACxGD,wBAAoBI;;AAEtB,OAAIJ,oBAAoBtB,KAAIU,MAAMU,OAChCC,YAAUF,KAAM,oBAAA,oBAAmDnB,KAAIU,MAAMe,UAAWH,kBAAiB,IAA9E,UAAUX,eAAcS,SAAU,IAAqD,CAAC;AACpH,UAEM,0CAAGC,aAAc;;AACzBlB,IAAA,KAAAN;AAAAM,IAAA,KAAAE;OAAAA,MAAAF,EAAA;CA1CH,MAAAJ,WAAiBM;CA4Cf,IAAAsB;AAAA,KAAAxB,EAAA,OAAAJ,UAAA;AAEK4B,OAAA,EAAA5B,UAAY;AAAAI,IAAA,KAAAJ;AAAAI,IAAA,KAAAwB;OAAAA,MAAAxB,EAAA;AAAA,QAAZwB"}

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

@@ -0,0 +1,25 @@
+import "./Renderers.js";
+
+//#region src/presentation-hierarchies-react/UseSelectionHandler.d.ts
+/**
+ * A union of different supported selection modes in a tree component:
+ * - `none` - no selection is allowed,
+ * - `single` - only one node can be selected at a time,
+ * - `extended` - multiple nodes can be selected using shift and ctrl keys,
+ * - `multiple` - multiple nodes can be selected without using shift or ctrl keys.
+ *
+ * @public
+ */
+type SelectionMode = "none" | "single" | "extended" | "multiple";
+/**
+ * Type of selection change.
+ * - `add` - a node was added to the selection,
+ * - `replace` - a selected node was replaced with a different one,
+ * - `remove` - a node was removed from the selection.
+ *
+ * @public
+ */
+type SelectionChangeType = "add" | "replace" | "remove";
+//#endregion
+export { SelectionChangeType, SelectionMode };
+//# sourceMappingURL=UseSelectionHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UseSelectionHandler.d.ts","names":[],"sources":["../../src/presentation-hierarchies-react/UseSelectionHandler.ts"],"mappings":";;;;;AAmBA;;;;;AAUA;;KAVY,aAAA;;;;;;;;;KAUA,mBAAA"}

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

@@ -0,0 +1,125 @@
+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>({\n    flatNodeList: [],\n    nodeIdToIndexMap: new Map(),\n  });\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(selectionMode: SelectionMode, isSelected: boolean, shiftDown: boolean, ctrlDown: boolean): 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, HierarchySearchPath } 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<HierarchySearchPath[] | 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.
+   *
+   * **Note:** Internal errors take precedence over custom ones.
+   */
+  getTreeNodeError?: (node: HierarchyNode) => ErrorInfo | undefined;
+}
+/** @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;;UAgBhC,YAAA;EAhB6C;EAkB5D,oBAAA,QAA4B,iBAAA;EAFb;EAIf,cAAA;IAAoB;EAAA;IAAiB,WAAA,EAAa,WAAA;EAAA,MAAkB,OAAA,CAAQ,mBAAA;EAAxD;;;;EAKpB,qBAAA,IAAyB,MAAA,sDAA4D,QAAA;EAS3D;EAP1B,wBAAA,IAA4B,KAAA;IAAS,QAAA;IAAmB,MAAA,GAAS,qBAAA;IAAuB,KAAA;EAAA;EAPxF;EASA,oBAAA,IAAwB,KAAA;IAAS,QAAA;IAAmB,IAAA;IAA6B,KAAA;EAAA;EATL;;;;EAc5E,gBAAA,IAAoB,IAAA,EAAM,aAAA,KAAkB,SAAA;AAAA;;KAIlC,aAAA;EAX8E;;;;EAgBxF,WAAA;EAdiF;;;EAkBjF,OAAA,GAAU,MAAA,aAAmB,QAAA;EAbT;;;EAiBpB,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"}