@itwin/presentation-hierarchies-react 2.0.0-alpha.4 → 2.0.0-alpha.40

package/README.md

@@ -2,7 +2,7 @@
 
 Copyright © Bentley Systems, Incorporated. All rights reserved. See LICENSE.md for license terms and full copyright notice.
 
-The `@itwin/presentation-hierarchies-react` package provides APIs for building a headless UI for rendering tree components based on data in an [iTwin.js iModel](https://www.itwinjs.org/learning/imodels/#imodel-overview). In addition, it delivers a set of [iTwinUI](https://itwinui.bentley.com/)-based components for rendering the tree.
+The `@itwin/presentation-hierarchies-react` package provides APIs for building a headless UI for rendering tree components based on data in an [iTwin.js iModel](https://www.itwinjs.org/learning/imodels/#imodel-overview). In addition, it delivers a set of [StrataKit](https://www.npmjs.com/package/@stratakit/bricks)-based components for rendering the tree.
 
 ## Headless UI
 
@@ -20,7 +20,6 @@ All these hooks return the same state object, which contains properties and func
 - `isLoading` is a boolean indicating whether the root tree nodes are being loaded. Set to `true` on initial load and on reload (e.g. when iModel data changes).
 
 - `rootNodes` is an array of root tree nodes and is what the component should render. There are several types of nodes:
-
   - A `PresentationHierarchyNode` is the primary type of node, created based on the hierarchy definition. The `isPresentationHierarchyNode` type guard utility may be used to check if a node is of this type.
   - A `PresentationInfoNode` is a non-expandable, non-selectable informational type of node, generally created when for some reason we don't have any real nodes to show. There may be different reasons like filtered-out nodes, too large result set, a network error, etc. The `type` attribute of the node indicates that.
 
@@ -31,7 +30,6 @@ All these hooks return the same state object, which contains properties and func
 - `getNode` function to get node by its id.
 
 - `getHierarchyLevelDetails` function to access details of a specific hierarchy level. The returned object provides access to:
-
   - hierarchy level size limit,
   - hierarchy level instance filter,
   - instance keys of the nodes in the hierarchy level.
@@ -125,21 +123,18 @@ The returned object contains 2 functions, that should be called by the node rend
 
 Our [tree renderer implementation](#treerenderer) calls this hook and passes the callbacks to the [node renderer](#treenoderenderer), so there's no need to use it unless implementing a custom tree renderer.
 
-## iTwinUI components
+## StrataKit components
 
-While the package provides a headless UI, it also delivers a set of [iTwinUI](https://itwinui.bentley.com/)-based components for rendering the tree, which should cover majority of use cases. Consumers using the below components are required to provide a compatible `@itwin/itwinui-react` package, which is an optional peer dependency to this package.
+While the package provides a headless UI, it also delivers a set of [StrataKit](https://www.npmjs.com/package/@stratakit/bricks)-based components for rendering the tree, which should cover majority of use cases. Consumers using the below components are required to provide compatible `@stratakit/bricks`/`@stratakit/icons`/`@stratakit/foundations` packages, which are optional peer dependencies to this package.
 
 ### `TreeRenderer`
 
-The component is based on [iTwinUI Tree component](https://itwinui.bentley.com/docs/tree) and uses our [`TreeNodeRenderer`](#treenoderenderer) to render the nodes. In addition, it makes use of the [`useSelectionHandler` hook](#useselectionhandler-hook) to add selection modes' support.
-
-The iTwinUI Tree component requires a `getNode` function that maps nodes to `NodeData<TNode>` objects. Our `TreeRenderer` uses `createRenderedTreeNodeData` function for this purpose, and it's available for consumers as well, in case a custom iTwinUI Tree component implementation is being written.
+The component is based on StrataKit `Tree` component and uses our [`TreeNodeRenderer`](#treenoderenderer) to render the nodes. In addition, it makes use of the [`useSelectionHandler` hook](#useselectionhandler-hook) to add selection modes' support.
 
 ### `TreeNodeRenderer`
 
-The component is based on `TreeNode` component from iTwinUI library and supports the following features:
+The component is based on `Tree.Item` component from StrataKit library and supports the following features:
 
-- Rendering informational type of nodes (e.g. "No filter matches", "Too many nodes in a hierarchy level", etc.).
 - Reporting click and key down events for use with [`useSelectionHandler` hook](#useselectionhandler-hook).
 - Icons, selection, expand / collapse.
 - Action buttons to clear / set hierarchy level instance filter.
@@ -275,7 +270,7 @@ const localizedStrings = {
   unspecified: "Unspecified",
   other: "Other",
 
-  // strings for `TreeRenderer` and `TreeNodeRenderPresentation.HierarchiesReact.iModelAccesser`
+  // strings for `TreeRenderer` and `TreeNodeRenderer`
   loading: "Loading...",
   filterHierarchyLevel: "Apply hierarchy filter",
   clearHierarchyLevelFilter: "Clear active filter",
@@ -306,28 +301,31 @@ In case the `TreeNodeRenderer` component is used within a custom tree renderer,
 import { Props } from "@itwin/presentation-shared";
 
 import { ComponentPropsWithoutRef, useCallback } from "react";
-import { Tree } from "@itwin/itwinui-react";
-import {
-  createRenderedTreeNodeData,
-  LocalizationContextProvider,
-  RenderedTreeNode,
-  TreeNodeRenderer,
-  TreeRenderer,
-} from "@itwin/presentation-hierarchies-react";
-
-type TreeProps = ComponentPropsWithoutRef<typeof Tree<RenderedTreeNode>>;
+import { Tree } from "@stratakit/bricks";
+import { LocalizationContextProvider, TreeRenderer, useFlatTreeNodeList } from "@itwin/presentation-hierarchies-react";
+
 type TreeRendererProps = Props<typeof TreeRenderer>;
 
 function MyTreeRenderer({ rootNodes }: TreeRendererProps) {
-  const nodeRenderer = useCallback<TreeProps["nodeRenderer"]>((nodeProps) => {
-    return <TreeNodeRenderer {...nodeProps} onFilterClick={() => {}} expandNode={() => {}} />;
-  }, []);
-
-  const getNode = useCallback<TreeProps["getNode"]>((node) => createRenderedTreeNodeData(node, () => false), []);
+  const flatNodes = useFlatTreeNodeList(rootNodes);
 
   return (
     <LocalizationContextProvider localizedStrings={localizedStrings}>
-      <Tree<RenderedTreeNode> data={rootNodes} nodeRenderer={nodeRenderer} getNode={getNode} enableVirtualization={true} />
+      <Tree.Root>
+        {flatNodes.map((flatNode) =>
+          isPlaceholderNode(flatNode) ? (
+            <Tree.Item key={flatNode.id} aria-level={flatNode.level} aria-posinset={1} aria-setsize={1} label="Loading" />
+          ) : (
+            <Tree.Item
+              key={flatNode.id}
+              aria-level={flatNode.level}
+              aria-posinset={flatNode.posInLevel}
+              aria-setsize={flatNode.levelSize}
+              label={flatNode.label}
+            />
+          ),
+        )}
+      </Tree.Root>
     </LocalizationContextProvider>
   );
 }

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

@@ -0,0 +1,85 @@
+import { GenericInstanceFilter, HierarchyNode } from "@itwin/presentation-hierarchies";
+import { InstanceKey } from "@itwin/presentation-shared";
+import { ErrorInfo, PresentationHierarchyNode } from "./TreeNode.js";
+import { SelectionChangeType } from "./UseSelectionHandler.js";
+/**
+ * Type definition used to render tree rendering UI component.
+ * @alpha
+ */
+export type TreeRendererProps = {
+    /**
+     * Array containing root tree nodes.
+     */
+    rootNodes: PresentationHierarchyNode[];
+    /**
+     * 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
+ */
+export 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
+ */
+export 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;
+}
+export {};
+//# sourceMappingURL=Renderers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Renderers.d.ts","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/Renderers.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACvF,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAE/D;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;OAEG;IACH,SAAS,EAAE,yBAAyB,EAAE,CAAC;IACvC;;OAEG;IACH,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1D;;;;OAIG;IACH,WAAW,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,mBAAmB,KAAK,IAAI,CAAC;IAC/E,mDAAmD;IACnD,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;CAC7C,GAAG,mBAAmB,CAAC;AAExB;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,+CAA+C;IAC/C,KAAK,EAAE,SAAS,CAAC;CAClB,GAAG,mBAAmB,CAAC;AAExB;;GAEG;AACH,UAAU,mBAAmB;IAC3B;;OAEG;IACH,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAClD,2DAA2D;IAC3D,wBAAwB,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,qBAAqB,GAAG,SAAS,CAAC;CAC7F;AAED;;;GAGG;AACH,UAAU,iBAAiB;IACzB,qEAAqE;IACrE,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IAEjC;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;CACtC;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,8FAA8F;IAC9F,aAAa,EAAE,aAAa,GAAG,SAAS,CAAC;IAEzC,8DAA8D;IAC9D,uBAAuB,EAAE,CAAC,KAAK,CAAC,EAAE;QAChC,cAAc,CAAC,EAAE,qBAAqB,CAAC;QACvC,uBAAuB,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;KAChD,KAAK,qBAAqB,CAAC,WAAW,CAAC,CAAC;IAEzC,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IACjC,6EAA6E;IAC7E,YAAY,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,WAAW,KAAK,IAAI,CAAC;IAEhE,sEAAsE;IACtE,cAAc,CAAC,EAAE,qBAAqB,CAAC;IACvC,+DAA+D;IAC/D,iBAAiB,EAAE,CAAC,MAAM,EAAE,qBAAqB,GAAG,SAAS,KAAK,IAAI,CAAC;CACxE"}

package/lib/esm/presentation-hierarchies-react/Renderers.js

@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+export {};
+//# sourceMappingURL=Renderers.js.map

package/lib/esm/presentation-hierarchies-react/Renderers.js.map

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

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

@@ -1,75 +1,74 @@
 import { HierarchyNode } from "@itwin/presentation-hierarchies";
 /**
- * A type that defines an actual expandable node in a UI tree component, built with `useTree` hook.
+ * A type that defines an node in a UI tree component, built with `useTree` hook.
  * @public
  */
 export interface PresentationHierarchyNode {
     id: string;
     label: string;
-    children: true | Array<PresentationTreeNode>;
+    children: true | Array<PresentationHierarchyNode>;
     isExpanded: boolean;
     isLoading: boolean;
     isFilterable: boolean;
     isFiltered: boolean;
     /** UI-agnostic source of this node object. */
     nodeData: HierarchyNode;
-    /** Additional data that may be assigned to this node. */
-    extendedData?: {
-        [key: string]: any;
-    };
+    /** Contains error encountered from expanding the node */
+    error?: ErrorInfo;
 }
 /**
- * A type of `PresentationInfoNode` that is returned as the single child of a filtered parent node,
+ * A type of `ErrorInfo` that is returned,
  * when none of the child nodes match the filter.
  *
  * @public
  */
-export interface PresentationNoFilterMatchesInfoNode {
+export interface NoFilterMatchesErrorInfo {
     id: string;
-    parentNodeId: string | undefined;
     type: "NoFilterMatches";
 }
 /**
- * A type of `PresentationInfoNode` that is returned as the single child of a parent node, when the
+ * 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 node as `resultSetSizeLimit` attribute.
+ * on this error as `resultSetSizeLimit` attribute.
  *
  * @public
  */
-export interface PresentationResultSetTooLargeInfoNode {
+export interface ResultSetTooLargeErrorInfo {
     id: string;
-    parentNodeId: string | undefined;
     type: "ResultSetTooLarge";
     resultSetSizeLimit: number;
 }
 /**
- * A type of `PresentationInfoNode` that contains a user-friendly message to be displayed in the UI.
- * Generally, this is the only child of a parent node, created in cases like an error loading children. The
+ * 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
  */
-export interface PresentationGenericInfoNode {
+export interface ChildrenLoadErrorInfo {
     id: string;
-    parentNodeId: string | undefined;
-    type: "Unknown";
+    type: "ChildrenLoad";
     message: string;
 }
 /**
- * A type that defines a non-expandable, non-selectable informational node in a UI tree component, built
- * with `useTree` hook.
+ * 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
  */
-export type PresentationInfoNode = PresentationGenericInfoNode | PresentationResultSetTooLargeInfoNode | PresentationNoFilterMatchesInfoNode;
-/**
- * A type that defines a node in a UI tree component, built with `useTree` hook.
- * @public
- */
-export type PresentationTreeNode = PresentationHierarchyNode | PresentationInfoNode;
+export interface GenericErrorInfo {
+    id: string;
+    type: "Unknown";
+    message: string;
+    additionalData?: unknown;
+}
 /**
- * An utility function to check if a node is a `PresentationHierarchyNode`.
+ * A collection of types that defines an error state for `PresentationHierarchyNode` node in a UI tree component, built
+ * with `useTree` hook.
+ *
  * @public
  */
-export declare function isPresentationHierarchyNode(node: PresentationTreeNode): node is PresentationHierarchyNode;
+export type ErrorInfo = GenericErrorInfo | ResultSetTooLargeErrorInfo | NoFilterMatchesErrorInfo | ChildrenLoadErrorInfo;
 //# sourceMappingURL=TreeNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TreeNode.d.ts","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/TreeNode.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAEhE;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,IAAI,GAAG,KAAK,CAAC,oBAAoB,CAAC,CAAC;IAC7C,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,8CAA8C;IAC9C,QAAQ,EAAE,aAAa,CAAC;IACxB,yDAAyD;IACzD,YAAY,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC;CACvC;AAED;;;;;GAKG;AACH,MAAM,WAAW,mCAAmC;IAClD,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,IAAI,EAAE,iBAAiB,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,qCAAqC;IACpD,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,IAAI,EAAE,mBAAmB,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,2BAA2B;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,2BAA2B,GAAG,qCAAqC,GAAG,mCAAmC,CAAC;AAE7I;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,yBAAyB,GAAG,oBAAoB,CAAC;AAEpF;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI,IAAI,yBAAyB,CAEzG"}
+{"version":3,"file":"TreeNode.d.ts","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/TreeNode.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAEhE;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,IAAI,GAAG,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAClD,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,8CAA8C;IAC9C,QAAQ,EAAE,aAAa,CAAC;IACxB,yDAAyD;IACzD,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,iBAAiB,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,mBAAmB,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,gBAAgB,GAAG,0BAA0B,GAAG,wBAAwB,GAAG,qBAAqB,CAAC"}

package/lib/esm/presentation-hierarchies-react/TreeNode.js

@@ -2,11 +2,5 @@
  * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
-/**
- * An utility function to check if a node is a `PresentationHierarchyNode`.
- * @public
- */
-export function isPresentationHierarchyNode(node) {
-    return "children" in node;
-}
+export {};
 //# sourceMappingURL=TreeNode.js.map

package/lib/esm/presentation-hierarchies-react/TreeNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"TreeNode.js","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/TreeNode.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AA4EhG;;;GAGG;AACH,MAAM,UAAU,2BAA2B,CAAC,IAA0B;IACpE,OAAO,UAAU,IAAI,IAAI,CAAC;AAC5B,CAAC","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 { HierarchyNode } from \"@itwin/presentation-hierarchies\";\n\n/**\n * A type that defines an actual expandable node in a UI tree component, built with `useTree` hook.\n * @public\n */\nexport interface PresentationHierarchyNode {\n  id: string;\n  label: string;\n  children: true | Array<PresentationTreeNode>;\n  isExpanded: boolean;\n  isLoading: boolean;\n  isFilterable: boolean;\n  isFiltered: boolean;\n  /** UI-agnostic source of this node object. */\n  nodeData: HierarchyNode;\n  /** Additional data that may be assigned to this node. */\n  extendedData?: { [key: string]: any };\n}\n\n/**\n * A type of `PresentationInfoNode` that is returned as the single child of a filtered parent node,\n * when none of the child nodes match the filter.\n *\n * @public\n */\nexport interface PresentationNoFilterMatchesInfoNode {\n  id: string;\n  parentNodeId: string | undefined;\n  type: \"NoFilterMatches\";\n}\n\n/**\n * A type of `PresentationInfoNode` that is returned as the single child of a parent node, when the\n * number of child nodes exceeds the limit set on the tree nodes loader. The limit is also included\n * on this node as `resultSetSizeLimit` attribute.\n *\n * @public\n */\nexport interface PresentationResultSetTooLargeInfoNode {\n  id: string;\n  parentNodeId: string | undefined;\n  type: \"ResultSetTooLarge\";\n  resultSetSizeLimit: number;\n}\n\n/**\n * A type of `PresentationInfoNode` that contains a user-friendly message to be displayed in the UI.\n * Generally, this is the only child of a parent node, created in cases like an error loading children. The\n * renderer may offer users to re-load the children or the whole component in such cases.\n *\n * @public\n */\nexport interface PresentationGenericInfoNode {\n  id: string;\n  parentNodeId: string | undefined;\n  type: \"Unknown\";\n  message: string;\n}\n\n/**\n * A type that defines a non-expandable, non-selectable informational node in a UI tree component, built\n * with `useTree` hook.\n *\n * @public\n */\nexport type PresentationInfoNode = PresentationGenericInfoNode | PresentationResultSetTooLargeInfoNode | PresentationNoFilterMatchesInfoNode;\n\n/**\n * A type that defines a node in a UI tree component, built with `useTree` hook.\n * @public\n */\nexport type PresentationTreeNode = PresentationHierarchyNode | PresentationInfoNode;\n\n/**\n * An utility function to check if a node is a `PresentationHierarchyNode`.\n * @public\n */\nexport function isPresentationHierarchyNode(node: PresentationTreeNode): node is PresentationHierarchyNode {\n  return \"children\" in node;\n}\n"]}
+{"version":3,"file":"TreeNode.js","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/TreeNode.ts"],"names":[],"mappings":"AAAA;;;gGAGgG","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 { HierarchyNode } from \"@itwin/presentation-hierarchies\";\n\n/**\n * A type that defines an node in a UI tree component, built with `useTree` hook.\n * @public\n */\nexport interface PresentationHierarchyNode {\n  id: string;\n  label: string;\n  children: true | Array<PresentationHierarchyNode>;\n  isExpanded: boolean;\n  isLoading: boolean;\n  isFilterable: boolean;\n  isFiltered: boolean;\n  /** UI-agnostic source of this node object. */\n  nodeData: HierarchyNode;\n  /** Contains error encountered from expanding the node */\n  error?: ErrorInfo;\n}\n\n/**\n * A type of `ErrorInfo` that is returned,\n * when none of the child nodes match the filter.\n *\n * @public\n */\nexport interface NoFilterMatchesErrorInfo {\n  id: string;\n  type: \"NoFilterMatches\";\n}\n\n/**\n * A type of `ErrorInfo` that is returned, when the\n * number of child nodes exceeds the limit set on the tree nodes loader. The limit is also included\n * on this error as `resultSetSizeLimit` attribute.\n *\n * @public\n */\nexport interface ResultSetTooLargeErrorInfo {\n  id: string;\n  type: \"ResultSetTooLarge\";\n  resultSetSizeLimit: number;\n}\n\n/**\n * A type of `ErrorInfo` that contains a user-friendly message to be displayed in the UI.\n * Created in cases like an error loading children. The\n * renderer may offer users to re-load the children or the whole component in such cases.\n *\n * @public\n */\nexport interface ChildrenLoadErrorInfo {\n  id: string;\n  type: \"ChildrenLoad\";\n  message: string;\n}\n\n/**\n * A type of `ErrorInfo` that can be used to show/handle generic errors,\n * that might not be directly caused by the tree components. (e.g. tree components\n * shows hierarchy of connections to external systems and an error is show in the\n * tree when some connections are unreachable).\n *\n * @public\n */\nexport interface GenericErrorInfo {\n  id: string;\n  type: \"Unknown\";\n  message: string;\n  additionalData?: unknown;\n}\n\n/**\n * A collection of types that defines an error state for `PresentationHierarchyNode` node in a UI tree component, built\n * with `useTree` hook.\n *\n * @public\n */\nexport type ErrorInfo = GenericErrorInfo | ResultSetTooLargeErrorInfo | NoFilterMatchesErrorInfo | ChildrenLoadErrorInfo;\n"]}

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

@@ -19,6 +19,8 @@ type UseIModelTreeProps = Omit<UseTreeProps, "getHierarchyProvider" | "getFilter
     getFilteredPaths?: (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<HierarchyFilteringPath[] | undefined>;
 };
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"UseIModelTree.d.ts","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/UseIModelTree.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,6BAA6B,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC7H,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACnD,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AACjF,OAAO,EAAW,YAAY,EAAE,aAAa,EAA2B,MAAM,cAAc,CAAC;AAE7F,cAAc;AACd,KAAK,4BAA4B,GAAG,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEhF,cAAc;AACd,KAAK,YAAY,GAAG,4BAA4B,CAAC,cAAc,CAAC,CAAC;AAEjE;;;GAGG;AACH,KAAK,kBAAkB,GAAG,IAAI,CAAC,YAAY,EAAE,sBAAsB,GAAG,kBAAkB,CAAC,GACvF,IAAI,CAAC,4BAA4B,EAAE,kBAAkB,GAAG,cAAc,GAAG,eAAe,CAAC,GAAG;IAC1F,sDAAsD;IACtD,sBAAsB,EAAE,CAAC,KAAK,EAAE;QAAE,YAAY,EAAE,YAAY,CAAA;KAAE,KAAK,mBAAmB,CAAC;IAEvF,wCAAwC;IACxC,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE;QACzB,+FAA+F;QAC/F,YAAY,EAAE,YAAY,CAAC;KAC5B,KAAK,OAAO,CAAC,sBAAsB,EAAE,GAAG,SAAS,CAAC,CAAC;CACrD,CAAC;AAEJ;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,aAAa,CAMtE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,kBAAkB,GAAG,4BAA4B,GAAG,aAAa,CAMrH"}
+{"version":3,"file":"UseIModelTree.d.ts","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/UseIModelTree.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,6BAA6B,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC7H,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACnD,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AACjF,OAAO,EAAW,YAAY,EAAE,aAAa,EAA2B,MAAM,cAAc,CAAC;AAE7F,cAAc;AACd,KAAK,4BAA4B,GAAG,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEhF,cAAc;AACd,KAAK,YAAY,GAAG,4BAA4B,CAAC,cAAc,CAAC,CAAC;AAEjE;;;GAGG;AACH,KAAK,kBAAkB,GAAG,IAAI,CAAC,YAAY,EAAE,sBAAsB,GAAG,kBAAkB,CAAC,GACvF,IAAI,CAAC,4BAA4B,EAAE,kBAAkB,GAAG,cAAc,GAAG,eAAe,CAAC,GAAG;IAC1F,sDAAsD;IACtD,sBAAsB,EAAE,CAAC,KAAK,EAAE;QAAE,YAAY,EAAE,YAAY,CAAA;KAAE,KAAK,mBAAmB,CAAC;IAEvF,wCAAwC;IACxC,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE;QACzB,+FAA+F;QAC/F,YAAY,EAAE,YAAY,CAAC;QAC3B,2DAA2D;QAC3D,WAAW,EAAE,WAAW,CAAC;KAC1B,KAAK,OAAO,CAAC,sBAAsB,EAAE,GAAG,SAAS,CAAC,CAAC;CACrD,CAAC;AAEJ;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,aAAa,CAMtE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,kBAAkB,GAAG,4BAA4B,GAAG,aAAa,CAMrH"}

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

@@ -56,7 +56,7 @@ function useIModelTreeProps(props) {
             hierarchyDefinition: getHierarchyDefinition({ imodelAccess }),
             localizedStrings,
         }), [imodelAccess, imodelChanged, getHierarchyDefinition, localizedStrings]),
-        getFilteredPaths: useCallback(async () => getFilteredPaths?.({ imodelAccess }), [imodelAccess, getFilteredPaths]),
+        getFilteredPaths: useCallback(async ({ abortSignal }) => getFilteredPaths?.({ imodelAccess, abortSignal }), [imodelAccess, getFilteredPaths]),
     };
 }
 //# sourceMappingURL=UseIModelTree.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"UseIModelTree.js","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/UseIModelTree.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAEhG,OAAO,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AACpC,OAAO,EAAE,6BAA6B,EAA+C,MAAM,iCAAiC,CAAC;AAG7H,OAAO,EAAE,OAAO,EAA+B,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAwB7F;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAAC,KAAyB;IACrD,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC;IACnH,OAAO,OAAO,CAAC;QACb,GAAG,IAAI;QACP,GAAG,kBAAkB,CAAC,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;KACnH,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,6BAA6B,CAAC,KAAwD;IACpG,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC;IACnH,OAAO,uBAAuB,CAAC;QAC7B,GAAG,IAAI;QACP,GAAG,kBAAkB,CAAC,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;KACnH,CAAC,CAAC;AACL,CAAC;AAED,SAAS,kBAAkB,CACzB,KAAsI;IAEtI,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,GAAG,KAAK,CAAC;IAC1G,OAAO;QACL,oBAAoB,EAAE,WAAW,CAC/B,GAAG,EAAE,CACH,6BAA6B,CAAC;YAC5B,YAAY;YACZ,aAAa;YACb,mBAAmB,EAAE,sBAAsB,CAAC,EAAE,YAAY,EAAE,CAAC;YAC7D,gBAAgB;SACjB,CAAC,EACJ,CAAC,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,CAAC,CACxE;QACD,gBAAgB,EAAE,WAAW,CAAC,KAAK,IAAI,EAAE,CAAC,gBAAgB,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAAC;KAClH,CAAC;AACJ,CAAC","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, HierarchyDefinition, HierarchyFilteringPath } from \"@itwin/presentation-hierarchies\";\nimport { Props } from \"@itwin/presentation-shared\";\nimport { UseUnifiedTreeSelectionProps } from \"./internal/UseUnifiedSelection.js\";\nimport { useTree, UseTreeProps, UseTreeResult, useUnifiedSelectionTree } 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\" | \"getFilteredPaths\"> &\n  Pick<IModelHierarchyProviderProps, \"localizedStrings\" | \"imodelAccess\" | \"imodelChanged\"> & {\n    /** Provides the hierarchy definition for the tree. */\n    getHierarchyDefinition: (props: { imodelAccess: IModelAccess }) => HierarchyDefinition;\n\n    /** Provides paths to filtered nodes. */\n    getFilteredPaths?: (props: {\n      /** Object that provides access to the iModel schema and can run queries against the iModel. */\n      imodelAccess: IModelAccess;\n    }) => Promise<HierarchyFilteringPath[] | 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, getFilteredPaths, localizedStrings, ...rest } = props;\n  return useTree({\n    ...rest,\n    ...useIModelTreeProps({ imodelAccess, imodelChanged, getHierarchyDefinition, getFilteredPaths, localizedStrings }),\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, getFilteredPaths, localizedStrings, ...rest } = props;\n  return useUnifiedSelectionTree({\n    ...rest,\n    ...useIModelTreeProps({ imodelAccess, imodelChanged, getHierarchyDefinition, getFilteredPaths, localizedStrings }),\n  });\n}\n\nfunction useIModelTreeProps(\n  props: Pick<UseIModelTreeProps, \"imodelAccess\" | \"imodelChanged\" | \"getHierarchyDefinition\" | \"getFilteredPaths\" | \"localizedStrings\">,\n): Pick<UseTreeProps, \"getHierarchyProvider\" | \"getFilteredPaths\"> {\n  const { imodelAccess, imodelChanged, getHierarchyDefinition, getFilteredPaths, localizedStrings } = props;\n  return {\n    getHierarchyProvider: useCallback(\n      () =>\n        createIModelHierarchyProvider({\n          imodelAccess,\n          imodelChanged,\n          hierarchyDefinition: getHierarchyDefinition({ imodelAccess }),\n          localizedStrings,\n        }),\n      [imodelAccess, imodelChanged, getHierarchyDefinition, localizedStrings],\n    ),\n    getFilteredPaths: useCallback(async () => getFilteredPaths?.({ imodelAccess }), [imodelAccess, getFilteredPaths]),\n  };\n}\n"]}
+{"version":3,"file":"UseIModelTree.js","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/UseIModelTree.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAEhG,OAAO,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AACpC,OAAO,EAAE,6BAA6B,EAA+C,MAAM,iCAAiC,CAAC;AAG7H,OAAO,EAAE,OAAO,EAA+B,uBAAuB,EAAE,MAAM,cAAc,CAAC;AA0B7F;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAAC,KAAyB;IACrD,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC;IACnH,OAAO,OAAO,CAAC;QACb,GAAG,IAAI;QACP,GAAG,kBAAkB,CAAC,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;KACnH,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,6BAA6B,CAAC,KAAwD;IACpG,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC;IACnH,OAAO,uBAAuB,CAAC;QAC7B,GAAG,IAAI;QACP,GAAG,kBAAkB,CAAC,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;KACnH,CAAC,CAAC;AACL,CAAC;AAED,SAAS,kBAAkB,CACzB,KAAsI;IAEtI,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,GAAG,KAAK,CAAC;IAC1G,OAAO;QACL,oBAAoB,EAAE,WAAW,CAC/B,GAAG,EAAE,CACH,6BAA6B,CAAC;YAC5B,YAAY;YACZ,aAAa;YACb,mBAAmB,EAAE,sBAAsB,CAAC,EAAE,YAAY,EAAE,CAAC;YAC7D,gBAAgB;SACjB,CAAC,EACJ,CAAC,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,gBAAgB,CAAC,CACxE;QACD,gBAAgB,EAAE,WAAW,CAC3B,KAAK,EAAE,EAAE,WAAW,EAAgC,EAAE,EAAE,CAAC,gBAAgB,EAAE,CAAC,EAAE,YAAY,EAAE,WAAW,EAAE,CAAC,EAC1G,CAAC,YAAY,EAAE,gBAAgB,CAAC,CACjC;KACF,CAAC;AACJ,CAAC","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, HierarchyDefinition, HierarchyFilteringPath } from \"@itwin/presentation-hierarchies\";\nimport { Props } from \"@itwin/presentation-shared\";\nimport { UseUnifiedTreeSelectionProps } from \"./internal/UseUnifiedSelection.js\";\nimport { useTree, UseTreeProps, UseTreeResult, useUnifiedSelectionTree } 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\" | \"getFilteredPaths\"> &\n  Pick<IModelHierarchyProviderProps, \"localizedStrings\" | \"imodelAccess\" | \"imodelChanged\"> & {\n    /** Provides the hierarchy definition for the tree. */\n    getHierarchyDefinition: (props: { imodelAccess: IModelAccess }) => HierarchyDefinition;\n\n    /** Provides paths to filtered nodes. */\n    getFilteredPaths?: (props: {\n      /** Object that provides access to the iModel schema and can run queries against the iModel. */\n      imodelAccess: IModelAccess;\n      /** Signal indicating that that the request was canceled */\n      abortSignal: AbortSignal;\n    }) => Promise<HierarchyFilteringPath[] | 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, getFilteredPaths, localizedStrings, ...rest } = props;\n  return useTree({\n    ...rest,\n    ...useIModelTreeProps({ imodelAccess, imodelChanged, getHierarchyDefinition, getFilteredPaths, localizedStrings }),\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, getFilteredPaths, localizedStrings, ...rest } = props;\n  return useUnifiedSelectionTree({\n    ...rest,\n    ...useIModelTreeProps({ imodelAccess, imodelChanged, getHierarchyDefinition, getFilteredPaths, localizedStrings }),\n  });\n}\n\nfunction useIModelTreeProps(\n  props: Pick<UseIModelTreeProps, \"imodelAccess\" | \"imodelChanged\" | \"getHierarchyDefinition\" | \"getFilteredPaths\" | \"localizedStrings\">,\n): Pick<UseTreeProps, \"getHierarchyProvider\" | \"getFilteredPaths\"> {\n  const { imodelAccess, imodelChanged, getHierarchyDefinition, getFilteredPaths, localizedStrings } = props;\n  return {\n    getHierarchyProvider: useCallback(\n      () =>\n        createIModelHierarchyProvider({\n          imodelAccess,\n          imodelChanged,\n          hierarchyDefinition: getHierarchyDefinition({ imodelAccess }),\n          localizedStrings,\n        }),\n      [imodelAccess, imodelChanged, getHierarchyDefinition, localizedStrings],\n    ),\n    getFilteredPaths: useCallback(\n      async ({ abortSignal }: { abortSignal: AbortSignal }) => getFilteredPaths?.({ imodelAccess, abortSignal }),\n      [imodelAccess, getFilteredPaths],\n    ),\n  };\n}\n"]}

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

@@ -0,0 +1,24 @@
+import { PresentationHierarchyNode } from "./TreeNode.js";
+/**
+ * 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: PresentationHierarchyNode) => React.ReactElement;
+}
+/**
+ * A react hook that helps create highlighted node labels based on provided highlight.
+ * @alpha
+ */
+export declare function useNodeHighlighting({ highlightText }: UseNodeHighlightingProps): UseNodeHighlightingResult;
+export {};
+//# sourceMappingURL=UseNodeHighlighting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UseNodeHighlighting.d.ts","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/UseNodeHighlighting.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE1D;;;GAGG;AACH,UAAU,wBAAwB;IAChC,sCAAsC;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,UAAU,yBAAyB;IACjC,qDAAqD;IACrD,QAAQ,EAAE,CAAC,IAAI,EAAE,yBAAyB,KAAK,KAAK,CAAC,YAAY,CAAC;CACnE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,aAAa,EAAE,EAAE,wBAAwB,GAAG,yBAAyB,CAgD1G"}

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

@@ -0,0 +1,52 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+import { useCallback } from "react";
+/**
+ * A react hook that helps create highlighted node labels based on provided highlight.
+ * @alpha
+ */
+export function useNodeHighlighting({ highlightText }) {
+    const getLabel = useCallback((node) => {
+        if (!highlightText || !node.nodeData.filtering?.isFilterTarget) {
+            return _jsx("span", { children: node.label });
+        }
+        const matchedIndexes = new Array();
+        const nodeLabel = node.label.toLocaleLowerCase();
+        const searchText = highlightText.toLocaleLowerCase();
+        let fromPosition = 0;
+        // Find all occurrences of the search text in the node label
+        while (true) {
+            const foundIndex = nodeLabel.indexOf(searchText, fromPosition);
+            if (foundIndex === -1) {
+                break;
+            }
+            matchedIndexes.push(foundIndex);
+            fromPosition = foundIndex + searchText.length;
+        }
+        if (matchedIndexes.length === 0) {
+            return _jsx("span", { children: node.label });
+        }
+        // Create the final label with highlighted parts
+        const finalLabel = new Array();
+        let lastAddedPosition = 0;
+        for (let i = 0; i < matchedIndexes.length; ++i) {
+            const matchedIndex = matchedIndexes[i];
+            if (matchedIndex > lastAddedPosition) {
+                finalLabel.push(_jsx("span", { children: node.label.substring(lastAddedPosition, matchedIndex) }, `normal-${i}`));
+                lastAddedPosition = matchedIndex;
+            }
+            const endingPlace = matchedIndex + highlightText.length;
+            finalLabel.push(_jsx("mark", { children: node.label.substring(lastAddedPosition, endingPlace) }, `marked-${i}`));
+            lastAddedPosition = endingPlace;
+        }
+        if (lastAddedPosition < node.label.length) {
+            finalLabel.push(_jsx("span", { children: node.label.substring(lastAddedPosition) }, `normal-${matchedIndexes.length + 1}`));
+        }
+        return _jsx(_Fragment, { children: finalLabel });
+    }, [highlightText]);
+    return { getLabel };
+}
+//# sourceMappingURL=UseNodeHighlighting.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UseNodeHighlighting.js","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/UseNodeHighlighting.tsx"],"names":[],"mappings":";AAAA;;;gGAGgG;AAEhG,OAAO,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAqBpC;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAAE,aAAa,EAA4B;IAC7E,MAAM,QAAQ,GAAG,WAAW,CAC1B,CAAC,IAA+B,EAAE,EAAE;QAClC,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,cAAc,EAAE,CAAC;YAC/D,OAAO,yBAAO,IAAI,CAAC,KAAK,GAAQ,CAAC;QACnC,CAAC;QAED,MAAM,cAAc,GAAG,IAAI,KAAK,EAAU,CAAC;QAC3C,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,iBAAiB,EAAE,CAAC;QACjD,MAAM,UAAU,GAAG,aAAa,CAAC,iBAAiB,EAAE,CAAC;QACrD,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,4DAA4D;QAC5D,OAAO,IAAI,EAAE,CAAC;YACZ,MAAM,UAAU,GAAG,SAAS,CAAC,OAAO,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;YAC/D,IAAI,UAAU,KAAK,CAAC,CAAC,EAAE,CAAC;gBACtB,MAAM;YACR,CAAC;YACD,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAChC,YAAY,GAAG,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC;QAChD,CAAC;QAED,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChC,OAAO,yBAAO,IAAI,CAAC,KAAK,GAAQ,CAAC;QACnC,CAAC;QAED,gDAAgD;QAChD,MAAM,UAAU,GAAG,IAAI,KAAK,EAAqB,CAAC;QAClD,IAAI,iBAAiB,GAAG,CAAC,CAAC;QAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YAC/C,MAAM,YAAY,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;YACvC,IAAI,YAAY,GAAG,iBAAiB,EAAE,CAAC;gBACrC,UAAU,CAAC,IAAI,CAAC,yBAA2B,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,iBAAiB,EAAE,YAAY,CAAC,IAArE,UAAU,CAAC,EAAE,CAAgE,CAAC,CAAC;gBAC1G,iBAAiB,GAAG,YAAY,CAAC;YACnC,CAAC;YACD,MAAM,WAAW,GAAG,YAAY,GAAG,aAAa,CAAC,MAAM,CAAC;YACxD,UAAU,CAAC,IAAI,CAAC,yBAA2B,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,iBAAiB,EAAE,WAAW,CAAC,IAApE,UAAU,CAAC,EAAE,CAA+D,CAAC,CAAC;YACzG,iBAAiB,GAAG,WAAW,CAAC;QAClC,CAAC;QACD,IAAI,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YAC1C,UAAU,CAAC,IAAI,CAAC,yBAAmD,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,iBAAiB,CAAC,IAA/E,UAAU,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAkD,CAAC,CAAC;QACtH,CAAC;QAED,OAAO,4BAAG,UAAU,GAAI,CAAC;IAC3B,CAAC,EACD,CAAC,aAAa,CAAC,CAChB,CAAC;IAEF,OAAO,EAAE,QAAQ,EAAE,CAAC;AACtB,CAAC","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 { PresentationHierarchyNode } 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: PresentationHierarchyNode) => React.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: PresentationHierarchyNode) => {\n      if (!highlightText || !node.nodeData.filtering?.isFilterTarget) {\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<React.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"]}

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

@@ -1,5 +1,5 @@
+import { TreeRendererProps } from "./Renderers.js";
 import { PresentationHierarchyNode } from "./TreeNode.js";
-import { useTree } from "./UseTree.js";
 /**
  * A union of different supported selection modes in a tree component:
  * - `none` - no selection is allowed,
@@ -21,9 +21,9 @@ export type SelectionMode = "none" | "single" | "extended" | "multiple";
 export type SelectionChangeType = "add" | "replace" | "remove";
 /**
  * Props for `useSelectionHandler` hook.
- * @public
+ * @alpha
  */
-type UseSelectionHandlerProps = Pick<ReturnType<typeof useTree>, "rootNodes" | "selectNodes"> & {
+type UseSelectionHandlerProps = Pick<TreeRendererProps, "selectNodes" | "rootNodes"> & {
     /** Selection mode that the component is working in. */
     selectionMode: SelectionMode;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"UseSelectionHandler.d.ts","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/UseSelectionHandler.ts"],"names":[],"mappings":"AAMA,OAAO,EAA+B,yBAAyB,EAAwB,MAAM,eAAe,CAAC;AAC7G,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAC;AAExE;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE/D;;;GAGG;AACH,KAAK,wBAAwB,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,OAAO,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC,GAAG;IAC9F,uDAAuD;IACvD,aAAa,EAAE,aAAa,CAAC;CAC9B,CAAC;AAEF;;;GAGG;AACH,UAAU,yBAAyB;IACjC,0EAA0E;IAC1E,WAAW,EAAE,CAAC,IAAI,EAAE,yBAAyB,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE,UAAU,CAAC,KAAK,IAAI,CAAC;IAC9H,iFAAiF;IACjF,aAAa,EAAE,CAAC,IAAI,EAAE,yBAAyB,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;CACxH;AAOD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,GAAG,yBAAyB,CAiE9F"}
+{"version":3,"file":"UseSelectionHandler.d.ts","sourceRoot":"","sources":["../../../src/presentation-hierarchies-react/UseSelectionHandler.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE1D;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAC;AAExE;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE/D;;;GAGG;AACH,KAAK,wBAAwB,GAAG,IAAI,CAAC,iBAAiB,EAAE,aAAa,GAAG,WAAW,CAAC,GAAG;IACrF,uDAAuD;IACvD,aAAa,EAAE,aAAa,CAAC;CAC9B,CAAC;AAEF;;;GAGG;AACH,UAAU,yBAAyB;IACjC,0EAA0E;IAC1E,WAAW,EAAE,CAAC,IAAI,EAAE,yBAAyB,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE,UAAU,CAAC,KAAK,IAAI,CAAC;IAC9H,iFAAiF;IACjF,aAAa,EAAE,CAAC,IAAI,EAAE,yBAAyB,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;CACxH;AAOD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,GAAG,yBAAyB,CA8D9F"}

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

@@ -3,7 +3,6 @@
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
 import { useCallback, useEffect, useRef } from "react";
-import { isPresentationHierarchyNode } from "./TreeNode.js";
 /**
  * A react hook that helps implement different selection modes in a tree component created using `useTree` hook.
  * @public
@@ -16,9 +15,6 @@ export function useSelectionHandler(props) {
         nodeIdToIndexMap: new Map(),
     });
     useEffect(() => {
-        if (!rootNodes) {
-            return;
-        }
         state.current = computeFlatNodeList(rootNodes);
     }, [rootNodes]);
     const getNodeRange = (firstId, secondId) => {
@@ -75,16 +71,13 @@ function getExtendedSelectionAction(isSelected, shiftDown, ctrlDown) {
     if (ctrlDown) {
         return { select: "node", type: isSelected ? "add" : "remove" };
     }
-    return { select: "node", type: isSelected ? "replace" : "disabled" };
+    return { select: "node", type: "replace" };
 }
 function computeFlatNodeList(rootNodes) {
     const flatNodeList = [];
     const nodeIdToIndexMap = new Map();
     const flattenNodeRecursively = (nodes) => {
         nodes.forEach((node) => {
-            if (!isPresentationHierarchyNode(node)) {
-                return;
-            }
             nodeIdToIndexMap.set(node.id, flatNodeList.length);
             flatNodeList.push(node.id);
             if (node.isExpanded && typeof node.children !== "boolean") {