@itwin/presentation-hierarchies-react 2.0.0-alpha.52 → 2.0.0-alpha.54

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @itwin/presentation-hierarchies-react
 
+## 2.0.0-alpha.54
+
+### Patch Changes
+
+- [#1198](https://github.com/iTwin/presentation/pull/1198): Change `HierarchyProvider.hierarchyChanged` argument to be required.
+
+  This simplifies the API for users of `HierarchyProvider`, as they no longer need to check for `undefined` when handling hierarchy changes.
+
+  For implementors of custom `HierarchyProvider`, this change means that they must always provide an even argument when raising the `hierarchyChanged` event. Since all members of the argument type are optional, it's okay to raise the even with an empty object, e.g.: `this.hierarchyChanged.raiseEvent({})`.
+
+- [#1200](https://github.com/iTwin/presentation/pull/1200): Removed unnecessary, always-truthy condition checks.
+- [#1193](https://github.com/iTwin/presentation/pull/1193): Process package output with [React Compiler](https://react.dev/reference/react-compiler/compiling-libraries).
+- Updated dependencies:
+  - @itwin/presentation-shared@2.0.0-alpha.7
+  - @itwin/presentation-hierarchies@2.0.0-alpha.11
+
+## 2.0.0-alpha.53
+
+### Patch Changes
+
+- [#1192](https://github.com/iTwin/presentation/pull/1192): Fix situations where expander was rendered for leaf nodes.
+- [#1196](https://github.com/iTwin/presentation/pull/1196): Added accessible name for tree node rename input.
+
 ## 2.0.0-alpha.52
 
 ### Patch Changes
@@ -763,6 +786,16 @@
 
 - [#847](https://github.com/iTwin/presentation/pull/847): Moving tree rendering components to a new design systems.
 
+## 1.9.11
+
+### Patch Changes
+
+- [#1208](https://github.com/iTwin/presentation/pull/1208): Bump dependencies.
+- Updated dependencies:
+  - @itwin/presentation-hierarchies@1.7.9
+  - @itwin/presentation-shared@1.2.8
+  - @itwin/unified-selection@1.6.6
+
 ## 1.9.10
 
 ### Patch Changes

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

@@ -1,85 +1,92 @@
-import { GenericInstanceFilter, HierarchyNode } from "@itwin/presentation-hierarchies";
-import { InstanceKey } from "@itwin/presentation-shared";
 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
  */
-export 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;
+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
  */
-export type RootErrorRendererProps = {
-    /** Object containing root error information */
-    error: ErrorInfo;
+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;
+  /**
+   * 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";
+  /** 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. */
+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;
-    /** Set the instance filter to apply to this hierarchy level */
-    setInstanceFilter: (filter: GenericInstanceFilter | undefined) => void;
+    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 {};
+//#endregion
+export { HierarchyLevelDetails, RootErrorRendererProps, TreeRendererProps };
 //# sourceMappingURL=Renderers.d.ts.map

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

@@ -1 +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,QAAQ,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAE/D;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;OAEG;IACH,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB;;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"}
+{"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/esm/presentation-hierarchies-react/TreeNode.d.ts

@@ -1,20 +1,22 @@
 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
  */
-export 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;
-    /** Contains error encountered from expanding the node */
-    error?: ErrorInfo;
+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;
+  /** Contains error encountered from expanding the node */
+  error?: ErrorInfo;
 }
 /**
  * A type of `ErrorInfo` that is returned,
@@ -22,9 +24,9 @@ export interface TreeNode {
  *
  * @public
  */
-export interface NoFilterMatchesErrorInfo {
-    id: string;
-    type: "NoFilterMatches";
+interface NoFilterMatchesErrorInfo {
+  id: string;
+  type: "NoFilterMatches";
 }
 /**
  * A type of `ErrorInfo` that is returned, when the
@@ -33,10 +35,10 @@ export interface NoFilterMatchesErrorInfo {
  *
  * @public
  */
-export interface ResultSetTooLargeErrorInfo {
-    id: string;
-    type: "ResultSetTooLarge";
-    resultSetSizeLimit: number;
+interface ResultSetTooLargeErrorInfo {
+  id: string;
+  type: "ResultSetTooLarge";
+  resultSetSizeLimit: number;
 }
 /**
  * A type of `ErrorInfo` that contains a user-friendly message to be displayed in the UI.
@@ -45,10 +47,10 @@ export interface ResultSetTooLargeErrorInfo {
  *
  * @public
  */
-export interface ChildrenLoadErrorInfo {
-    id: string;
-    type: "ChildrenLoad";
-    message: string;
+interface ChildrenLoadErrorInfo {
+  id: string;
+  type: "ChildrenLoad";
+  message: string;
 }
 /**
  * A type of `ErrorInfo` that can be used to show/handle generic errors,
@@ -58,11 +60,11 @@ export interface ChildrenLoadErrorInfo {
  *
  * @public
  */
-export interface GenericErrorInfo {
-    id: string;
-    type: "Unknown";
-    message: string;
-    additionalData?: unknown;
+interface GenericErrorInfo {
+  id: string;
+  type: "Unknown";
+  message: string;
+  additionalData?: unknown;
 }
 /**
  * A collection of types that defines an error state for `TreeNode` node in a UI tree component, built
@@ -70,5 +72,7 @@ export interface GenericErrorInfo {
  *
  * @public
  */
-export type ErrorInfo = GenericErrorInfo | ResultSetTooLargeErrorInfo | NoFilterMatchesErrorInfo | ChildrenLoadErrorInfo;
+type ErrorInfo = GenericErrorInfo | ResultSetTooLargeErrorInfo | NoFilterMatchesErrorInfo | ChildrenLoadErrorInfo;
+//#endregion
+export { ErrorInfo, GenericErrorInfo, ResultSetTooLargeErrorInfo, TreeNode };
 //# 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,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC;IACjC,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"}
+{"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,KAAA,GAAQ,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;EACA,cAAA;AAAA;;;;;;;KASU,SAAA,GAAY,gBAAA,GAAmB,0BAAA,GAA6B,wBAAA,GAA2B,qBAAA"}

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

@@ -1,7 +1,9 @@
-import { createIModelHierarchyProvider, HierarchyDefinition, HierarchySearchPath } from "@itwin/presentation-hierarchies";
-import { Props } from "@itwin/presentation-shared";
 import { UseUnifiedTreeSelectionProps } from "./internal/UseUnifiedSelection.js";
 import { UseTreeProps, UseTreeResult } from "./UseTree.js";
+import { HierarchyDefinition, HierarchySearchPath, 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 */
@@ -11,17 +13,25 @@ type IModelAccess = IModelHierarchyProviderProps["imodelAccess"];
  * @public
  */
 type UseIModelTreeProps = Omit<UseTreeProps, "getHierarchyProvider" | "getSearchPaths"> & Pick<IModelHierarchyProviderProps, "localizedStrings" | "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<HierarchySearchPath[] | undefined>;
+  /**
+   * 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<HierarchySearchPath[] | undefined>;
 };
 /**
  * A React hook that creates state for a tree component whose displayed hierarchy is based on
@@ -36,7 +46,7 @@ type UseIModelTreeProps = Omit<UseTreeProps, "getHierarchyProvider" | "getSearch
  * @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
@@ -52,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/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,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC1H,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,gBAAgB,CAAC,GACrF,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,sCAAsC;IACtC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE;QACvB,+FAA+F;QAC/F,YAAY,EAAE,YAAY,CAAC;QAC3B,2DAA2D;QAC3D,WAAW,EAAE,WAAW,CAAC;KAC1B,KAAK,OAAO,CAAC,mBAAmB,EAAE,GAAG,SAAS,CAAC,CAAC;CAClD,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","names":[],"sources":["../../../src/presentation-hierarchies-react/UseIModelTree.ts"],"mappings":";;;;;;;KAeK,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/esm/presentation-hierarchies-react/UseIModelTree.js

@@ -1,62 +1,189 @@
-/*---------------------------------------------------------------------------------------------
- * 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";
-import { createIModelHierarchyProvider } from "@itwin/presentation-hierarchies";
 import { useTree, useUnifiedSelectionTree } from "./UseTree.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
- */
-export function useIModelTree(props) {
-    const { imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, localizedStrings, ...rest } = props;
-    return useTree({
-        ...rest,
-        ...useIModelTreeProps({ imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, localizedStrings }),
-    });
+* 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(16);
+	let getHierarchyDefinition;
+	let getSearchPaths;
+	let imodelAccess;
+	let imodelChanged;
+	let localizedStrings;
+	let rest;
+	if ($[0] !== props) {
+		({imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, localizedStrings, ...rest} = props);
+		$[0] = props;
+		$[1] = getHierarchyDefinition;
+		$[2] = getSearchPaths;
+		$[3] = imodelAccess;
+		$[4] = imodelChanged;
+		$[5] = localizedStrings;
+		$[6] = rest;
+	} else {
+		getHierarchyDefinition = $[1];
+		getSearchPaths = $[2];
+		imodelAccess = $[3];
+		imodelChanged = $[4];
+		localizedStrings = $[5];
+		rest = $[6];
+	}
+	let t0;
+	if ($[7] !== getHierarchyDefinition || $[8] !== getSearchPaths || $[9] !== imodelAccess || $[10] !== imodelChanged || $[11] !== localizedStrings) {
+		t0 = {
+			imodelAccess,
+			imodelChanged,
+			getHierarchyDefinition,
+			getSearchPaths,
+			localizedStrings
+		};
+		$[7] = getHierarchyDefinition;
+		$[8] = getSearchPaths;
+		$[9] = imodelAccess;
+		$[10] = imodelChanged;
+		$[11] = localizedStrings;
+		$[12] = t0;
+	} else t0 = $[12];
+	const t1 = useIModelTreeProps(t0);
+	let t2;
+	if ($[13] !== rest || $[14] !== t1) {
+		t2 = {
+			...rest,
+			...t1
+		};
+		$[13] = rest;
+		$[14] = t1;
+		$[15] = t2;
+	} else t2 = $[15];
+	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
- */
-export function useIModelUnifiedSelectionTree(props) {
-    const { imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, localizedStrings, ...rest } = props;
-    return useUnifiedSelectionTree({
-        ...rest,
-        ...useIModelTreeProps({ imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, localizedStrings }),
-    });
+* 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(16);
+	let getHierarchyDefinition;
+	let getSearchPaths;
+	let imodelAccess;
+	let imodelChanged;
+	let localizedStrings;
+	let rest;
+	if ($[0] !== props) {
+		({imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, localizedStrings, ...rest} = props);
+		$[0] = props;
+		$[1] = getHierarchyDefinition;
+		$[2] = getSearchPaths;
+		$[3] = imodelAccess;
+		$[4] = imodelChanged;
+		$[5] = localizedStrings;
+		$[6] = rest;
+	} else {
+		getHierarchyDefinition = $[1];
+		getSearchPaths = $[2];
+		imodelAccess = $[3];
+		imodelChanged = $[4];
+		localizedStrings = $[5];
+		rest = $[6];
+	}
+	let t0;
+	if ($[7] !== getHierarchyDefinition || $[8] !== getSearchPaths || $[9] !== imodelAccess || $[10] !== imodelChanged || $[11] !== localizedStrings) {
+		t0 = {
+			imodelAccess,
+			imodelChanged,
+			getHierarchyDefinition,
+			getSearchPaths,
+			localizedStrings
+		};
+		$[7] = getHierarchyDefinition;
+		$[8] = getSearchPaths;
+		$[9] = imodelAccess;
+		$[10] = imodelChanged;
+		$[11] = localizedStrings;
+		$[12] = t0;
+	} else t0 = $[12];
+	const t1 = useIModelTreeProps(t0);
+	let t2;
+	if ($[13] !== rest || $[14] !== t1) {
+		t2 = {
+			...rest,
+			...t1
+		};
+		$[13] = rest;
+		$[14] = t1;
+		$[15] = t2;
+	} else t2 = $[15];
+	return useUnifiedSelectionTree(t2);
 }
 function useIModelTreeProps(props) {
-    const { imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, localizedStrings } = props;
-    return {
-        getHierarchyProvider: useCallback(() => createIModelHierarchyProvider({
-            imodelAccess,
-            imodelChanged,
-            hierarchyDefinition: getHierarchyDefinition({ imodelAccess }),
-            localizedStrings,
-        }), [imodelAccess, imodelChanged, getHierarchyDefinition, localizedStrings]),
-        getSearchPaths: useCallback(async ({ abortSignal }) => getSearchPaths?.({ imodelAccess, abortSignal }), [imodelAccess, getSearchPaths]),
-    };
+	const $ = c(11);
+	const { imodelAccess, imodelChanged, getHierarchyDefinition, getSearchPaths, localizedStrings } = props;
+	let t0;
+	if ($[0] !== getHierarchyDefinition || $[1] !== imodelAccess || $[2] !== imodelChanged || $[3] !== localizedStrings) {
+		t0 = () => createIModelHierarchyProvider({
+			imodelAccess,
+			imodelChanged,
+			hierarchyDefinition: getHierarchyDefinition({ imodelAccess }),
+			localizedStrings
+		});
+		$[0] = getHierarchyDefinition;
+		$[1] = imodelAccess;
+		$[2] = imodelChanged;
+		$[3] = localizedStrings;
+		$[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