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

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

@@ -0,0 +1,92 @@
+import { ErrorInfo, TreeNode } from "./TreeNode.js";
+import { SelectionChangeType } from "./UseSelectionHandler.js";
+import { GenericInstanceFilter, HierarchyNode } from "@itwin/presentation-hierarchies";
+import { InstanceKey } from "@itwin/presentation-shared";
+
+//#region src/presentation-hierarchies-react/Renderers.d.ts
+/**
+ * Type definition used to render tree rendering UI component.
+ * @alpha
+ */
+type TreeRendererProps = {
+  /**
+   * Array containing root tree nodes.
+   */
+  rootNodes: TreeNode[];
+  /**
+   * A function that should be called to either expand or collapse the given node.
+   */
+  expandNode: (nodeId: string, isExpanded: boolean) => void;
+  /**
+   * A function that should be called to select nodes in the tree.
+   * @param nodeIds Ids of the nodes that are selected.
+   * @param changeType Type of change that occurred for the selection.
+   */
+  selectNodes: (nodeIds: Array<string>, changeType: SelectionChangeType) => void;
+  /**
+   * Determines whether a given node is selected.
+   */
+  isNodeSelected: (nodeId: string) => boolean;
+} & CommonRendererProps;
+/**
+ * Type definition used to render root error handling UI component.
+ * @alpha
+ */
+type RootErrorRendererProps = {
+  /**
+   * Object containing root error information
+   */
+  error: ErrorInfo;
+} & CommonRendererProps;
+/**
+ * @alpha
+ */
+interface CommonRendererProps {
+  /**
+   * A function that should be called to reload the tree.
+   */
+  reloadTree: (options?: ReloadTreeOptions) => void;
+  /** Returns hierarchy level details for a given node ID. */
+  getHierarchyLevelDetails: (nodeId: string | undefined) => HierarchyLevelDetails | undefined;
+}
+/**
+ * Options for doing either full or a sub tree reload.
+ * @public
+ */
+interface ReloadTreeOptions {
+  /** Specifies parent node under which sub tree should be reloaded. */
+  parentNodeId: string | undefined;
+  /**
+   * Specifies how current tree state should be handled:
+   * - `keep` - try to keep current tree state (expanded/collapsed nodes, instance filters, etc.).
+   * - `discard` - do not try to keep current tree state. Tree model will be update after nodes are reloaded.
+   * - `reset` - remove subtree from the model before reloading and reload nodes ignoring cache.
+   *
+   * Defaults to `"keep"`.
+   */
+  state?: "keep" | "discard" | "reset";
+}
+/**
+ * A data structure that contains information about a single hierarchy level.
+ * @public
+ */
+interface HierarchyLevelDetails {
+  /** The parent node whose hierarchy level's information is contained in this data structure */
+  hierarchyNode: HierarchyNode | undefined;
+  /** A function to get instance keys of the hierarchy level. */
+  getInstanceKeysIterator: (props?: {
+    instanceFilter?: GenericInstanceFilter;
+    hierarchyLevelSizeLimit?: number | "unbounded";
+  }) => AsyncIterableIterator<InstanceKey>;
+  /** Get the limit of how many nodes can be loaded in this hierarchy level. */
+  sizeLimit?: number | "unbounded";
+  /** Set the limit of how many nodes can be loaded in this hierarchy level. */
+  setSizeLimit: (value: undefined | number | "unbounded") => void;
+  /** Get the active instance filter applied to this hierarchy level. */
+  instanceFilter?: GenericInstanceFilter;
+  /** Set the instance filter to apply to this hierarchy level */
+  setInstanceFilter: (filter: GenericInstanceFilter | undefined) => void;
+}
+//#endregion
+export { HierarchyLevelDetails, RootErrorRendererProps, TreeRendererProps };
+//# sourceMappingURL=Renderers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Renderers.d.ts","names":[],"sources":["../../src/presentation-hierarchies-react/Renderers.ts"],"mappings":";;;;;;;;AAcA;;KAAY,iBAAA;EAIC;;;EAAX,SAAA,EAAW,QAAA;EAeU;;;EAXrB,UAAA,GAAa,MAAA,UAAgB,UAAA;EAA7B;;;;;EAMA,WAAA,GAAc,OAAA,EAAS,KAAA,UAAe,UAAA,EAAY,mBAAA;EAAA;;;EAIlD,cAAA,GAAiB,MAAA;AAAA,IACf,mBAAA;;;AAMJ;;KAAY,sBAAA;EAKW;;;EADrB,KAAA,EAAO,SAAA;AAAA,IACL,mBAAA;;AAAoB;;UAKd,mBAAA;EAMuE;;;EAF/E,UAAA,GAAa,OAAA,GAAU,iBAAA;EAEvB;EAAA,wBAAA,GAA2B,MAAA,yBAA+B,qBAAA;AAAA;;;AAAqB;;UAOvE,iBAAA;EAER;EAAA,YAAA;EAiBe;;;;;;;;EAPf,KAAA;AAAA;;;;;UAOe,qBAAA;EAMI;EAJnB,aAAA,EAAe,aAAA;EAGW;EAA1B,uBAAA,GAA0B,KAAA;IACxB,cAAA,GAAiB,qBAAA;IACjB,uBAAA;EAAA,MACI,qBAAA,CAAsB,WAAA;EAKb;EAFf,SAAA;EAKiB;EAHjB,YAAA,GAAe,KAAA;EAKa;EAF5B,cAAA,GAAiB,qBAAA;EAE4C;EAA7D,iBAAA,GAAoB,MAAA,EAAQ,qBAAA;AAAA"}

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

@@ -0,0 +1,80 @@
+import { HierarchyNode } from "@itwin/presentation-hierarchies";
+
+//#region src/presentation-hierarchies-react/TreeNode.d.ts
+/**
+ * A type that defines an node in a UI tree component, built with `useTree` hook.
+ * @public
+ */
+interface TreeNode {
+  id: string;
+  label: string;
+  children: true | Array<TreeNode>;
+  isExpanded: boolean;
+  isLoading: boolean;
+  isFilterable: boolean;
+  isFiltered: boolean;
+  /** UI-agnostic source of this node object. */
+  nodeData: HierarchyNode;
+  /** Errors associated with this tree node. */
+  errors: ErrorInfo[];
+}
+/**
+ * A type of `ErrorInfo` that is returned,
+ * when none of the child nodes match the filter.
+ *
+ * @public
+ */
+interface NoFilterMatchesErrorInfo {
+  id: string;
+  type: "NoFilterMatches";
+}
+/**
+ * A type of `ErrorInfo` that is returned, when the
+ * number of child nodes exceeds the limit set on the tree nodes loader. The limit is also included
+ * on this error as `resultSetSizeLimit` attribute.
+ *
+ * @public
+ */
+interface ResultSetTooLargeErrorInfo {
+  id: string;
+  type: "ResultSetTooLarge";
+  resultSetSizeLimit: number;
+}
+/**
+ * A type of `ErrorInfo` that contains a user-friendly message to be displayed in the UI.
+ * Created in cases like an error loading children. The
+ * renderer may offer users to re-load the children or the whole component in such cases.
+ *
+ * @public
+ */
+interface ChildrenLoadErrorInfo {
+  id: string;
+  type: "ChildrenLoad";
+  message: string;
+}
+/**
+ * A type of `ErrorInfo` that can be used to show/handle generic errors,
+ * that might not be directly caused by the tree components. (e.g. tree components
+ * shows hierarchy of connections to external systems and an error is show in the
+ * tree when some connections are unreachable).
+ *
+ * @public
+ */
+interface GenericErrorInfo {
+  id: string;
+  type: "Unknown";
+  message: string;
+  /** Allows node expansion even when this error is present. */
+  isNodeExpandable?: boolean;
+  additionalData?: unknown;
+}
+/**
+ * A collection of types that defines an error state for `TreeNode` node in a UI tree component, built
+ * with `useTree` hook.
+ *
+ * @public
+ */
+type ErrorInfo = GenericErrorInfo | ResultSetTooLargeErrorInfo | NoFilterMatchesErrorInfo | ChildrenLoadErrorInfo;
+//#endregion
+export { ErrorInfo, GenericErrorInfo, ResultSetTooLargeErrorInfo, TreeNode };
+//# sourceMappingURL=TreeNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TreeNode.d.ts","names":[],"sources":["../../src/presentation-hierarchies-react/TreeNode.ts"],"mappings":";;;;;AAWA;;UAAiB,QAAA;EACf,EAAA;EACA,KAAA;EACA,QAAA,SAAiB,KAAA,CAAM,QAAA;EACvB,UAAA;EACA,SAAA;EACA,YAAA;EACA,UAAA;EALA;EAOA,QAAA,EAAU,aAAA;EANO;EAQjB,MAAA,EAAQ,SAAA;AAAA;;;;;;;UASO,wBAAA;EACf,EAAA;EACA,IAAA;AAAA;;;;;AAUF;;;UAAiB,0BAAA;EACf,EAAA;EACA,IAAA;EACA,kBAAA;AAAA;;AAUF;;;;;;UAAiB,qBAAA;EACf,EAAA;EACA,IAAA;EACA,OAAA;AAAA;;;;;;;;;UAWe,gBAAA;EACf,EAAA;EACA,IAAA;EACA,OAAA;EAaE;EAXF,gBAAA;EACA,cAAA;AAAA;;;;;;;KASU,SAAA,GACR,gBAAA,GACA,0BAAA,GACA,wBAAA,GACA,qBAAA"}

package/lib/{esm/presentation-hierarchies-react → presentation-hierarchies-react}/UseIModelTree.d.ts

@@ -1,7 +1,9 @@
-import { createIModelHierarchyProvider, HierarchyDefinition, HierarchyFilteringPath } from "@itwin/presentation-hierarchies";
-import { Props } from "@itwin/presentation-shared";
 import { UseUnifiedTreeSelectionProps } from "./internal/UseUnifiedSelection.js";
 import { UseTreeProps, UseTreeResult } from "./UseTree.js";
+import { HierarchyDefinition, HierarchySearchTree, createIModelHierarchyProvider } from "@itwin/presentation-hierarchies";
+import { Props } from "@itwin/presentation-shared";
+
+//#region src/presentation-hierarchies-react/UseIModelTree.d.ts
 /** @public */
 type IModelHierarchyProviderProps = Props<typeof createIModelHierarchyProvider>;
 /** @public */
@@ -10,16 +12,26 @@ type IModelAccess = IModelHierarchyProviderProps["imodelAccess"];
  * Props for `useIModelTree` and `useIModelUnifiedSelectionTree` hooks.
  * @public
  */
-type UseIModelTreeProps = Omit<UseTreeProps, "getHierarchyProvider" | "getFilteredPaths"> & Pick<IModelHierarchyProviderProps, "localizedStrings" | "imodelAccess" | "imodelChanged"> & {
-    /** Provides the hierarchy definition for the tree. */
-    getHierarchyDefinition: (props: {
-        imodelAccess: IModelAccess;
-    }) => HierarchyDefinition;
-    /** Provides paths to filtered nodes. */
-    getFilteredPaths?: (props: {
-        /** Object that provides access to the iModel schema and can run queries against the iModel. */
-        imodelAccess: IModelAccess;
-    }) => Promise<HierarchyFilteringPath[] | undefined>;
+type UseIModelTreeProps = Omit<UseTreeProps, "getHierarchyProvider" | "getSearchPaths"> & Pick<IModelHierarchyProviderProps, "imodelAccess" | "imodelChanged"> & {
+  /**
+   * Provides the hierarchy definition for the tree.
+   */
+  getHierarchyDefinition: (props: {
+    imodelAccess: IModelAccess;
+  }) => HierarchyDefinition;
+  /**
+   * Provides paths to target nodes.
+   */
+  getSearchPaths?: (props: {
+    /**
+     * Object that provides access to the iModel schema and can run queries against the iModel.
+     */
+    imodelAccess: IModelAccess;
+    /**
+     * Signal indicating that that the request was canceled
+     */
+    abortSignal: AbortSignal;
+  }) => Promise<HierarchySearchTree[] | undefined>;
 };
 /**
  * A React hook that creates state for a tree component whose displayed hierarchy is based on
@@ -34,7 +46,7 @@ type UseIModelTreeProps = Omit<UseTreeProps, "getHierarchyProvider" | "getFilter
  * @see `useIModelUnifiedSelectionTree`
  * @public
  */
-export declare function useIModelTree(props: UseIModelTreeProps): UseTreeResult;
+declare function useIModelTree(props: UseIModelTreeProps): UseTreeResult;
 /**
  * A React hook that creates state for a tree component whose displayed hierarchy is based on
  * iModel data and that is integrated with unified selection through the given selection
@@ -50,6 +62,7 @@ export declare function useIModelTree(props: UseIModelTreeProps): UseTreeResult;
  * @see `UnifiedSelectionProvider`
  * @public
  */
-export declare function useIModelUnifiedSelectionTree(props: UseIModelTreeProps & UseUnifiedTreeSelectionProps): UseTreeResult;
-export {};
+declare function useIModelUnifiedSelectionTree(props: UseIModelTreeProps & UseUnifiedTreeSelectionProps): UseTreeResult;
+//#endregion
+export { useIModelTree, useIModelUnifiedSelectionTree };
 //# sourceMappingURL=UseIModelTree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UseIModelTree.d.ts","names":[],"sources":["../../src/presentation-hierarchies-react/UseIModelTree.ts"],"mappings":";;;;;;;KAgBK,4BAAA,GAA+B,KAAA,QAAa,6BAAA;;KAG5C,YAAA,GAAe,4BAAA;;;AAH0D;;KASzE,kBAAA,GAAqB,IAAA,CAAK,YAAA,+CAC7B,IAAA,CAAK,4BAAA;EAPa;;AAA4B;EAW5C,sBAAA,GAAyB,KAAA;IAAS,YAAA,EAAc,YAAA;EAAA,MAAmB,mBAAA;EAL7C;;;EAUtB,cAAA,IAAkB,KAAA;IALiD;;;IASjE,YAAA,EAAc,YAAA;IAKV;;;IADJ,WAAA,EAAa,WAAA;EAAA,MACT,OAAA,CAAQ,mBAAA;AAAA;;;;;;;;;;;;;;iBAgBF,aAAA,CAAc,KAAA,EAAO,kBAAA,GAAqB,aAAA;;;AAA1D;;;;;;;;;AAuBA;;;;iBAAgB,6BAAA,CAA8B,KAAA,EAAO,kBAAA,GAAqB,4BAAA,GAA+B,aAAA"}

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

@@ -0,0 +1,183 @@
+import { useTree, useUnifiedSelectionTree } from "./UseTree.js";
+import { useTranslation } from "./LocalizationContext.js";
+import { c } from "react-compiler-runtime";
+import { createIModelHierarchyProvider } from "@itwin/presentation-hierarchies";
+//#region src/presentation-hierarchies-react/UseIModelTree.ts
+/**
+* A React hook that creates state for a tree component whose displayed hierarchy is based on
+* iModel data.
+*
+* 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`
+* @public
+*/
+function useIModelTree(props) {
+	const $ = c(14);
+	let getHierarchyDefinition;
+	let getSearchPaths;
+	let imodelAccess;
+	let imodelChanged;
+	let rest;
+	if ($[0] !== props) {
+		({imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, ...rest} = props);
+		$[0] = props;
+		$[1] = getHierarchyDefinition;
+		$[2] = getSearchPaths;
+		$[3] = imodelAccess;
+		$[4] = imodelChanged;
+		$[5] = rest;
+	} else {
+		getHierarchyDefinition = $[1];
+		getSearchPaths = $[2];
+		imodelAccess = $[3];
+		imodelChanged = $[4];
+		rest = $[5];
+	}
+	let t0;
+	if ($[6] !== getHierarchyDefinition || $[7] !== getSearchPaths || $[8] !== imodelAccess || $[9] !== imodelChanged) {
+		t0 = {
+			imodelAccess,
+			imodelChanged,
+			getHierarchyDefinition,
+			getSearchPaths
+		};
+		$[6] = getHierarchyDefinition;
+		$[7] = getSearchPaths;
+		$[8] = imodelAccess;
+		$[9] = imodelChanged;
+		$[10] = t0;
+	} else t0 = $[10];
+	const t1 = useIModelTreeProps(t0);
+	let t2;
+	if ($[11] !== rest || $[12] !== t1) {
+		t2 = {
+			...rest,
+			...t1
+		};
+		$[11] = rest;
+		$[12] = t1;
+		$[13] = t2;
+	} else t2 = $[13];
+	return useTree(t2);
+}
+/**
+* A React hook that creates state for a tree component whose displayed hierarchy is based on
+* iModel data and 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 `useIModelTree`
+* @see `useUnifiedSelectionTree`
+* @see `UnifiedSelectionProvider`
+* @public
+*/
+function useIModelUnifiedSelectionTree(props) {
+	const $ = c(14);
+	let getHierarchyDefinition;
+	let getSearchPaths;
+	let imodelAccess;
+	let imodelChanged;
+	let rest;
+	if ($[0] !== props) {
+		({imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, ...rest} = props);
+		$[0] = props;
+		$[1] = getHierarchyDefinition;
+		$[2] = getSearchPaths;
+		$[3] = imodelAccess;
+		$[4] = imodelChanged;
+		$[5] = rest;
+	} else {
+		getHierarchyDefinition = $[1];
+		getSearchPaths = $[2];
+		imodelAccess = $[3];
+		imodelChanged = $[4];
+		rest = $[5];
+	}
+	let t0;
+	if ($[6] !== getHierarchyDefinition || $[7] !== getSearchPaths || $[8] !== imodelAccess || $[9] !== imodelChanged) {
+		t0 = {
+			imodelAccess,
+			imodelChanged,
+			getHierarchyDefinition,
+			getSearchPaths
+		};
+		$[6] = getHierarchyDefinition;
+		$[7] = getSearchPaths;
+		$[8] = imodelAccess;
+		$[9] = imodelChanged;
+		$[10] = t0;
+	} else t0 = $[10];
+	const t1 = useIModelTreeProps(t0);
+	let t2;
+	if ($[11] !== rest || $[12] !== t1) {
+		t2 = {
+			...rest,
+			...t1
+		};
+		$[11] = rest;
+		$[12] = t1;
+		$[13] = t2;
+	} else t2 = $[13];
+	return useUnifiedSelectionTree(t2);
+}
+function useIModelTreeProps(props) {
+	const $ = c(11);
+	const { imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths } = props;
+	const translate = useTranslation();
+	let t0;
+	if ($[0] !== getHierarchyDefinition || $[1] !== imodelAccess || $[2] !== imodelChanged || $[3] !== translate) {
+		t0 = () => createIModelHierarchyProvider({
+			imodelAccess,
+			imodelChanged,
+			hierarchyDefinition: getHierarchyDefinition({ imodelAccess }),
+			localizedStrings: {
+				other: translate("other"),
+				unspecified: translate("unspecified")
+			}
+		});
+		$[0] = getHierarchyDefinition;
+		$[1] = imodelAccess;
+		$[2] = imodelChanged;
+		$[3] = translate;
+		$[4] = t0;
+	} else t0 = $[4];
+	const t1 = t0;
+	let t2;
+	if ($[5] !== getSearchPaths || $[6] !== imodelAccess) {
+		t2 = async (t3) => {
+			const { abortSignal } = t3;
+			return getSearchPaths?.({
+				imodelAccess,
+				abortSignal
+			});
+		};
+		$[5] = getSearchPaths;
+		$[6] = imodelAccess;
+		$[7] = t2;
+	} else t2 = $[7];
+	const t3 = t2;
+	let t4;
+	if ($[8] !== t1 || $[9] !== t3) {
+		t4 = {
+			getHierarchyProvider: t1,
+			getSearchPaths: t3
+		};
+		$[8] = t1;
+		$[9] = t3;
+		$[10] = t4;
+	} else t4 = $[10];
+	return t4;
+}
+//#endregion
+export { useIModelTree, useIModelUnifiedSelectionTree };
+
+//# sourceMappingURL=UseIModelTree.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UseIModelTree.js","names":["useCallback","createIModelHierarchyProvider","useTranslation","useTree","useUnifiedSelectionTree","HierarchyDefinition","HierarchySearchTree","Props","UseUnifiedTreeSelectionProps","UseTreeProps","UseTreeResult","IModelHierarchyProviderProps","IModelAccess","UseIModelTreeProps","Omit","Pick","getHierarchyDefinition","props","imodelAccess","getSearchPaths","abortSignal","AbortSignal","Promise","useIModelTree","$","_c","imodelChanged","rest","t0","t1","useIModelTreeProps","t2","useIModelUnifiedSelectionTree","translate","hierarchyDefinition","localizedStrings","other","unspecified","t3","t4","getHierarchyProvider"],"sources":["../../src/presentation-hierarchies-react/UseIModelTree.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 } from \"react\";\nimport { createIModelHierarchyProvider } from \"@itwin/presentation-hierarchies\";\nimport { useTranslation } from \"./LocalizationContext.js\";\nimport { useTree, useUnifiedSelectionTree } from \"./UseTree.js\";\n\nimport type { HierarchyDefinition, HierarchySearchTree } from \"@itwin/presentation-hierarchies\";\nimport type { Props } from \"@itwin/presentation-shared\";\nimport type { UseUnifiedTreeSelectionProps } from \"./internal/UseUnifiedSelection.js\";\nimport type { UseTreeProps, UseTreeResult } from \"./UseTree.js\";\n\n/** @public */\ntype IModelHierarchyProviderProps = Props<typeof createIModelHierarchyProvider>;\n\n/** @public */\ntype IModelAccess = IModelHierarchyProviderProps[\"imodelAccess\"];\n\n/**\n * Props for `useIModelTree` and `useIModelUnifiedSelectionTree` hooks.\n * @public\n */\ntype UseIModelTreeProps = Omit<UseTreeProps, \"getHierarchyProvider\" | \"getSearchPaths\"> &\n  Pick<IModelHierarchyProviderProps, \"imodelAccess\" | \"imodelChanged\"> & {\n    /**\n     * Provides the hierarchy definition for the tree.\n     */\n    getHierarchyDefinition: (props: { imodelAccess: IModelAccess }) => HierarchyDefinition;\n\n    /**\n     * Provides paths to target nodes.\n     */\n    getSearchPaths?: (props: {\n      /**\n       * Object that provides access to the iModel schema and can run queries against the iModel.\n       */\n      imodelAccess: IModelAccess;\n      /**\n       * Signal indicating that that the request was canceled\n       */\n      abortSignal: AbortSignal;\n    }) => Promise<HierarchySearchTree[] | undefined>;\n  };\n\n/**\n * A React hook that creates state for a tree component whose displayed hierarchy is based on\n * iModel data.\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 * @public\n */\nexport function useIModelTree(props: UseIModelTreeProps): UseTreeResult {\n  const { imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, ...rest } = props;\n  return useTree({\n    ...rest,\n    ...useIModelTreeProps({ imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths }),\n  });\n}\n\n/**\n * A React hook that creates state for a tree component whose displayed hierarchy is based on\n * iModel data and that is integrated with unified selection through the given selection\n * storage (previously the storage was provided through the, now 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 `useIModelTree`\n * @see `useUnifiedSelectionTree`\n * @see `UnifiedSelectionProvider`\n * @public\n */\nexport function useIModelUnifiedSelectionTree(props: UseIModelTreeProps & UseUnifiedTreeSelectionProps): UseTreeResult {\n  const { imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, ...rest } = props;\n  return useUnifiedSelectionTree({\n    ...rest,\n    ...useIModelTreeProps({ imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths }),\n  });\n}\n\nfunction useIModelTreeProps(\n  props: Pick<UseIModelTreeProps, \"imodelAccess\" | \"imodelChanged\" | \"getHierarchyDefinition\" | \"getSearchPaths\">,\n): Pick<UseTreeProps, \"getHierarchyProvider\" | \"getSearchPaths\"> {\n  const { imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths } = props;\n  const translate = useTranslation();\n  return {\n    getHierarchyProvider: useCallback(\n      () =>\n        createIModelHierarchyProvider({\n          imodelAccess,\n          imodelChanged,\n          hierarchyDefinition: getHierarchyDefinition({ imodelAccess }),\n          localizedStrings: { other: translate(\"other\"), unspecified: translate(\"unspecified\") },\n        }),\n      [imodelAccess, imodelChanged, translate, getHierarchyDefinition],\n    ),\n    getSearchPaths: useCallback(\n      async ({ abortSignal }: { abortSignal: AbortSignal }) => getSearchPaths?.({ imodelAccess, abortSignal }),\n      [imodelAccess, getSearchPaths],\n    ),\n  };\n}\n"],"mappings":"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"}

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,57 @@
+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(\n          <span key={`normal-${matchedIndexes.length + 1}`}>{node.label.substring(lastAddedPosition)}</span>,\n        );\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,QAAA,EAAA,UAAOT,KAAIU,OAAc,CAAA;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,QAAA,EAAA,UAAOpB,KAAIU,OAAc,CAAA;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,QAAA,EAAA,UAA2BnB,KAAIU,MAAMe,UAAWH,mBAAmBE,aAAY,EAAS,EAA7E,UAAUD,IAAmE,CAAC;AACzGD,yBAAoBE;;IAEtB,MAAAE,cAAoBF,eAAe3B,cAAauB;AAChDC,eAAUF,KAAM,oBAAA,QAAA,EAAA,UAA2BnB,KAAIU,MAAMe,UAAWH,mBAAmBI,YAAW,EAAS,EAA5E,UAAUH,IAAkE,CAAC;AACxGD,wBAAoBI;;AAEtB,OAAIJ,oBAAoBtB,KAAIU,MAAMU,OAChCC,YAAUF,KACR,oBAAA,QAAA,EAAA,UAAmDnB,KAAIU,MAAMe,UAAWH,kBAAiB,EAC3F,EADa,UAAUX,eAAcS,SAAU,IAC/C,CAAC;AACF,UAEM,oBAAA,UAAA,EAAA,UAAGC,YAAc,CAAA;;AACzBlB,IAAA,KAAAN;AAAAM,IAAA,KAAAE;OAAAA,MAAAF,EAAA;CA5CH,MAAAJ,WAAiBM;CA8Cf,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,23 @@
+//#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"}