@itwin/presentation-hierarchies 2.0.0-alpha.4 → 2.0.0-alpha.6

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @itwin/presentation-hierarchies
 
+## 2.0.0-alpha.6
+
+### Major Changes
+
+- 6a00754233e6d1b8956a5fc7680829562156d659: Fixed a bug causing `HierarchyNode.autoExpand` flag to be set on non-grouping nodes, when `HierarchyFilteringPathOptions.autoExpand.depthInHierarchy` points to a grouping node whose child non-grouping node is not a filter target.
+
+  **Breaking changes:**
+  - `GroupingHierarchyNode` no longer contains `filtering` attribute. This was always the case, but now the types have been updated to match it.
+  - Changed return type of `createHierarchyFilteringHelper`:
+    - Removed `createChildNodePropsAsync` - it became an overload of `createChildNodeProps`, whose path matching is done through `asyncPathMatcher` callback.
+    - `createChildNodeProps` now has multiple overloads and returns different types based on provided props. `autoExpand` flag is only returned when `parentKeys` are provided.
+  - Renamed `HierarchyFilteringPathOptions.autoExpand` -> `HierarchyFilteringPathOptions.reveal` to match intent.
+  - Changed `HierarchyFilteringPathOptions.reveal.depthInHierarchy` and `depthInPath` to use 0-based indexing instead of 1-based indexing.
+  - Changed `HierarchyFilteringPathOptions.reveal.depthInHierarchy` to not set `autoExpand` flag on the node that is at the `depthInHierarchy` position.
+
+- e9ef80880c776522ce3b2632c8c3c461e62d6444: The hierarchy provider returned by `mergeProviders` doesn't have the deprecated `dispose` method anymore. Use `[Symbol.dispose]` instead.
+
+### Minor Changes
+
+- e9e42c3a513cb7d594351ee2244c7efe67cc4385: Added `HierarchyFilteringPathOptions.autoExpand` option to enable auto-expanding of filter target nodes.
+- e9ef80880c776522ce3b2632c8c3c461e62d6444: Add an experimental (`@alpha`) function `createMergedIModelHierarchyProvider` for creating a hierarchy from multiple versions of the same iModel.
+
+### Patch Changes
+
+- e9ef80880c776522ce3b2632c8c3c461e62d6444: Fix `HierarchyNodeKey` methods `equals` and `compare` not handling different schema-class separators and casing.
+- Updated dependencies:
+  - @itwin/presentation-shared@2.0.0-alpha.4
+
+## 2.0.0-alpha.5
+
+### Patch Changes
+
+- [#1112](https://github.com/iTwin/presentation/pull/1112): Version bump
+- Updated dependencies:
+  - @itwin/presentation-shared@2.0.0-alpha.3
+
 ## 2.0.0-alpha.4
 
 ### Patch Changes
@@ -33,7 +69,6 @@
 ### Major Changes
 
 - [#954](https://github.com/iTwin/presentation/pull/954): Add additional requirements for types in `EC` metadata namespace, whose objects are returned by `ECSchemaProvider`.
-
   - `EC.Schema`, `EC.Class` and `EC.Property` now all have an async `getCustomAttributes()` method that returns an `EC.CustomAttributeSet`, allowing consumers to access custom attributes of these schema items.
   - `EC.Class` now additionally has these members:
     - `baseClass: Promise<Class | undefined>`
@@ -52,6 +87,26 @@
 - Updated dependencies:
   - @itwin/presentation-shared@2.0.0-alpha.0
 
+## 1.7.5
+
+### Patch Changes
+
+- [#1124](https://github.com/iTwin/presentation/pull/1124): Bump dependencies.
+- Updated dependencies:
+  - @itwin/presentation-shared@1.2.4
+
+## 1.7.4
+
+### Patch Changes
+
+- [#1088](https://github.com/iTwin/presentation/pull/1088): Fix restart tokens not being unique when they need to, causing queries to be cancelled.
+
+## 1.7.3
+
+### Patch Changes
+
+- [#1083](https://github.com/iTwin/presentation/pull/1083): Add unique guid to existing restart tokens, and add restart tokens to executed queries.
+
 ## 1.7.2
 
 ### Patch Changes
@@ -71,7 +126,6 @@
 ### Minor Changes
 
 - 8f7d200926b93e862276e1f978f6c891691e0dae: Refactored specifying the depth / level to which filtering path should be auto-expanded.
-
   - Deprecated `FilteringPathAutoExpandOption` and `FilterTargetGroupingNodeInfo`.
   - Added `FilteringPathAutoExpandDepthInPath` and `FilteringPathAutoExpandDepthInHierarchy` which should be used instead.
 
@@ -144,7 +198,6 @@
   ```
 
   **After:**
-
   - **Option A:** check if it's a Promise before awaiting:
 
     Use this when you want to get slightly better performance by avoiding unnecessary `await`.
@@ -229,7 +282,6 @@
 - [#783](https://github.com/iTwin/presentation/pull/783): Added hierarchy filtering helper to make hierarchy filtering easier to implement.
 
   The helper can be created using the `createHierarchyFilteringHelper` function and supplying it the root level filtering paths and parent node. From there, filtering information for specific hierarchy level is determined and an object with the following attributes is returned:
-
   - `hasFilter` tells if the hierarchy level has a filter applied.
   - `hasFilterTargetAncestor` tells if there's a filter target ancestor node up in the hierarchy.
   - `getChildNodeFilteringIdentifiers()` returns an array of hierarchy node identifiers that apply specifically for this hierarchy level.
@@ -238,7 +290,6 @@
   See the [Implementing hierarchy filtering support](./learning/CustomHierarchyProviders.md#implementing-hierarchy-filtering-support) learning page for a usage example.
 
   In addition, deprecated a few APIs that are replaced by filtering helper:
-
   - `extractFilteringProps` function,
   - `HierarchyNodeFilteringProps.create` function.
 
@@ -284,7 +335,6 @@
   | 50k             | not tested        | 13.45 s          |
 
   In addition, changed `NodeParser` (return type of `HierarchyDefinition.parseNode`):
-
   - It now can return a promise, so instead of just `SourceInstanceHierarchyNode` it can now also return `Promise<SourceInstanceHierarchyNode>`.
   - Additionally, it now accepts an optional `parentNode` argument of `HierarchyDefinitionParentNode` type.
 
@@ -316,7 +366,6 @@
 ### Minor Changes
 
 - [#708](https://github.com/iTwin/presentation/pull/708): **BREAKING:** Added support for creating hierarchies from multiple data sources.
-
   - `InstancesNodeKey.instanceKeys` array items now have an optional `imodelKey` attribute to allow for the identification of the iModel that the instance belongs to. This is useful when working with sets of instance keys representing instances from different iModels. In addition, the same `imodelKey` attribute is also available on `HierarchyNodeIdentifier` to allow for filtering nodes based on the iModel they belong to.
   - `HierarchyNode` terminology and related changes:
     - "Standard" nodes were renamed to "IModel" nodes to signify the fact that they're based on iModel data:
@@ -344,7 +393,6 @@
     - The returned provider now has a `dispose` method to clean up resources - make sure to call it when the provider is no longer needed.
   - Added `mergeProviders` function, which, given a number of hierarchy providers, creates a new provider that merges the hierarchies of the input providers. The returned provider has a `dispose` method that needs to be called when the provider is no longer needed.
   - Renamed `createClassBasedHierarchyDefinition` to `createPredicateBasedHierarchyDefinition` to signify its props changes:
-
     - When specifying `childNodes` definition for instances parent node, the `parentNodeClassName` attribute was changed to `parentInstancesNodePredicate`. In addition to accepting a full class name, identifying the class of parent instances to return children for, it now also accepts an async function predicate.
     - When specifying `childNodes` definition for generic parent node, the `customParentNodeKey` attribute was changed to `parentGenericNodePredicate`. The type changed from `string`, identifying the key of the parent node, to an async function predicate.
 
@@ -397,7 +445,6 @@
     ```
 
 - [#708](https://github.com/iTwin/presentation/pull/708): Added utilities for custom hierarchy filtering handling:
-
   - `extractFilteringProps` function, given root level hierarchy filtering paths and a parent node, returns props required to filter particular hierarchy level.
   - `HierarchyFilteringPath` interface is now public and there's also a similarly-named namespace with the following utilities:
     - `mergeOptions` merges filtering options of two paths. This is useful for cases when there are multiple paths targeting the same node, but with different options.

package/lib/cjs/hierarchies/HierarchyFiltering.d.ts

@@ -1,37 +1,49 @@
-import { HierarchyNode, NonGroupingHierarchyNode } from "./HierarchyNode.js";
+import { NonGroupingHierarchyNode } from "./HierarchyNode.js";
 import { HierarchyNodeIdentifier, HierarchyNodeIdentifiersPath } from "./HierarchyNodeIdentifier.js";
-import { GenericNodeKey, InstancesNodeKey } from "./HierarchyNodeKey.js";
+import { GenericNodeKey, HierarchyNodeKey, InstancesNodeKey } from "./HierarchyNodeKey.js";
 /** @public */
-export interface FilteringPathAutoExpandDepthInPath {
+export interface FilteringPathRevealDepthInPath {
     /**
-     * Depth that tells which nodes in the filtering path should be expanded.
+     * Index of the node in filtering path should be revealed in hierarchy by auto-expanding its ancestors.
      *
      * Use when you want to expand up to specific instance node and don't care about grouping nodes.
      *
-     * **NOTE**: All nodes that are up to `depthInPath` will be expanded. Node at the `depthInPath` position won't be expanded.
+     * **Use case example:**
+     *
+     * All nodes up to `Element1` should be expanded in the following hierarchy:
+     * - Node1
+     *   - GroupingNode1
+     *     - GroupingNode2
+     *       - Element1
+     *       - Element2
+     *
+     * Provide `{ path: [Node1, Element1], reveal: { depthInPath: 1 } }`
+     *
+     * **NOTE**: All nodes that are up to `depthInPath` will be expanded **except** filter targets.
      */
     depthInPath: number;
 }
 /** @public */
-export interface FilteringPathAutoExpandDepthInHierarchy {
+export interface FilteringPathRevealDepthInHierarchy {
     /**
-     * Depth that tells which nodes in the hierarchy should be expanded.
+     * Considering the list of nodes from root to the target node, this is an index in that list, identifying the node that should be revealed in hierarchy by auto-expanding its ancestors.
      *
      * This should take into account the number of grouping nodes in hierarchy.
      *
-     * * **Use case example:**
+     * **Use case example:**
      *
-     * You want to `autoExpand` only `Node1` and `GroupingNode1` in the following hierarchy:
+     * Only `Node1` and `GroupingNode1` should have `autoExpand` flag in the following hierarchy:
      * - Node1
      *   - GroupingNode1
      *     - GroupingNode2
      *       - Element1
      *       - Element2
-     * Then you provide `autoExpand: { depthInHierarchy: 2 }`
+     *
+     * Provide `{ path: [Node1, Element1], reveal: { depthInHierarchy: 2 } }`
      *
      * To get the correct depth use `HierarchyNode.parentKeys.length`.
      *
-     * **NOTE**: All nodes that are up to and including `depthInHierarchy` will be expanded.
+     * **NOTE**: All nodes that are up to `depthInHierarchy` will be expanded **except** filter targets.
      */
     depthInHierarchy: number;
 }
@@ -41,10 +53,18 @@ export interface HierarchyFilteringPathOptions {
      * This option specifies the way `autoExpand` flag should be assigned to nodes in the filtered hierarchy.
      * - If it's `false` or `undefined`, nodes have no 'autoExpand' flag.
      * - If it's `true`, then all nodes up to the filter target will have `autoExpand` flag.
-     * - If it's an instance of `FilteringPathAutoExpandDepthInPath`, then all nodes up to `depthInPath` will have `autoExpand` flag.
-     * - If it's an instance of `FilteringPathAutoExpandDepthInHierarchy`, then all nodes up to and including `depthInHierarchy` will have `autoExpand` flag.
+     * - If it's an instance of `FilteringPathRevealDepthInPath`, then all nodes up to `depthInPath` will have `autoExpand` flag.
+     * - If it's an instance of `FilteringPathRevealDepthInHierarchy`, then all nodes up to `depthInHierarchy` will have `autoExpand` flag.
      */
-    autoExpand?: boolean | FilteringPathAutoExpandDepthInHierarchy | FilteringPathAutoExpandDepthInPath;
+    reveal?: boolean | FilteringPathRevealDepthInHierarchy | FilteringPathRevealDepthInPath;
+    /**
+     * This option specifies whether or not filter target should be expanded.
+     * - If it's `false` or `undefined`, filter target won't have 'autoExpand' flag.
+     * - If it's `true`, filter target will have `autoExpand` flag.
+     *
+     * **NOTE**: this attribute does not set `autoExpand` flag on nodes up to the filter target. For that use `reveal`.
+     */
+    autoExpand?: boolean;
 }
 /**
  * A path of hierarchy node identifiers for filtering the hierarchy with additional options.
@@ -63,17 +83,14 @@ export declare namespace HierarchyFilteringPath {
     function normalize(source: HierarchyFilteringPath): Exclude<HierarchyFilteringPath, HierarchyNodeIdentifiersPath>;
     /**
      * Merges two given `HierarchyFilteringPathOptions` objects.
-     * - if both inputs are `undefined`, `undefined` is returned,
-     * - else if one of the inputs is `undefined`, the other one is returned.
-     * - else, merge each option individually.
      *
-     * For the `autoExpand` attribute, the merge chooses to auto-expand as deep as the deepest input:
+     * For the `reveal` attribute, the merge chooses to `reveal` as deep as the deepest input:
      * - if any one of the inputs is `true`, return `true`,
      * - else if only one of the inputs is an object, return it,
      * - else if both inputs are falsy, return `false` or `undefined`,
      * - else:
-     *    - if only one of the inputs has `includeGroupingNodes` set to `true` or `key` defined or `depthInHierarchy` set, return the other one,
-     *    - else return the one with greater `depth`, `depthInPath` or `depthInHierarchy`.
+     *    - if only one of the inputs has `depthInHierarchy` set, return the other one,
+     *    - else return the one with greater `depthInPath` or `depthInHierarchy`.
      *
      * @public
      */
@@ -95,10 +112,8 @@ export declare function extractFilteringProps(rootLevelFilteringProps: Hierarchy
  *
  * @public
  */
-export declare function createHierarchyFilteringHelper(rootLevelFilteringProps: HierarchyFilteringPath[] | undefined, parentNode: Pick<NonGroupingHierarchyNode, "filtering" | "parentKeys"> | undefined): {
-    /**
-     * Returns a flag indicating if the hierarchy level is filtered.
-     */
+export declare function createHierarchyFilteringHelper(rootLevelFilteringProps: HierarchyFilteringPath[] | undefined, parentNode: Pick<NonGroupingHierarchyNode, "filtering"> | undefined): {
+    /** Returns a flag indicating if the hierarchy level is filtered. */
     hasFilter: boolean;
     /**
      * Returns a flag indicating whether this hierarchy level has an ancestor node
@@ -117,20 +132,46 @@ export declare function createHierarchyFilteringHelper(rootLevelFilteringProps:
      * and `autoExpand`) to be set based on the filter paths and filtering options. This function calculates
      * these props for a child node based on its key or path matcher.
      *
-     * When using `pathMatcher` prop, callers have more flexibility to decide whether the given `HierarchyNodeIdentifier` applies
+     * When using `pathMatcher` or `asyncPathMatcher` prop, callers have more flexibility to decide whether the given `HierarchyNodeIdentifier` applies
      * to their node. For example, only some parts of the identifier can be checked for improved performance. Otherwise, the
      * `nodeKey` prop can be used to check the whole identifier.
+     *
+     * There are multiple overloads of `createChildNodeProps`: depending on props type it returns different values:
+     * - `parentKeys` is defined and `pathMatcher` or `nodeKey` is provided - returns undefined **or** `filtering` and `autoExpand` prop from `HierarchyNode`;
+     * - `parentKeys` is undefined - does not return `HierarchyNode.autoExpand` option;
+     * - props have `asyncPathMatcher` - returns either Promise or the regular return value based on whether or not `asyncPathMatcher` returns a promise.
      */
-    createChildNodeProps: (props: {
-        nodeKey: InstancesNodeKey | GenericNodeKey;
-    } | {
-        pathMatcher: (identifier: HierarchyNodeIdentifier) => boolean;
-    }) => Pick<HierarchyNode, "autoExpand" | "filtering"> | undefined;
-    /**
-     * Similar to `createChildNodeProps`, but takes an async `pathMatcher` prop.
-     */
-    createChildNodePropsAsync: (props: {
-        pathMatcher: (identifier: HierarchyNodeIdentifier) => boolean | Promise<boolean>;
-    }) => Promise<Pick<HierarchyNode, "autoExpand" | "filtering"> | undefined> | Pick<HierarchyNode, "autoExpand" | "filtering"> | undefined;
+    createChildNodeProps: {
+        (props: {
+            parentKeys?: undefined;
+            nodeKey: InstancesNodeKey | GenericNodeKey;
+        }): Pick<NonGroupingHierarchyNode, "filtering"> | undefined;
+        (props: {
+            parentKeys?: undefined;
+            pathMatcher: (identifier: HierarchyNodeIdentifier) => boolean;
+        }): Pick<NonGroupingHierarchyNode, "filtering"> | undefined;
+        (props: {
+            parentKeys?: undefined;
+            asyncPathMatcher: (identifier: HierarchyNodeIdentifier) => boolean | Promise<boolean>;
+        }): Promise<Pick<NonGroupingHierarchyNode, "filtering"> | undefined> | Pick<NonGroupingHierarchyNode, "filtering"> | undefined;
+        (props: {
+            parentKeys: HierarchyNodeKey[];
+            nodeKey: InstancesNodeKey | GenericNodeKey;
+        }): Pick<NonGroupingHierarchyNode, "filtering" | "autoExpand"> | undefined;
+        (props: {
+            parentKeys: HierarchyNodeKey[];
+            pathMatcher: (identifier: HierarchyNodeIdentifier) => boolean;
+        }): Pick<NonGroupingHierarchyNode, "filtering" | "autoExpand"> | undefined;
+        (props: {
+            parentKeys: HierarchyNodeKey[];
+            asyncPathMatcher: (identifier: HierarchyNodeIdentifier) => boolean | Promise<boolean>;
+        }): Promise<Pick<NonGroupingHierarchyNode, "filtering" | "autoExpand"> | undefined> | Pick<NonGroupingHierarchyNode, "filtering" | "autoExpand"> | undefined;
+    };
 };
+/** @internal */
+export declare function shouldAutoExpandBasedOnReveal({ reveal, nodePositionInPath, nodePositionInHierarchy, }: {
+    reveal: HierarchyFilteringPathOptions["reveal"];
+    nodePositionInPath: number;
+    nodePositionInHierarchy: number;
+}): boolean;
 //# sourceMappingURL=HierarchyFiltering.d.ts.map

package/lib/cjs/hierarchies/HierarchyFiltering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HierarchyFiltering.d.ts","sourceRoot":"","sources":["../../../src/hierarchies/HierarchyFiltering.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,MAAM,8BAA8B,CAAC;AACrG,OAAO,EAAE,cAAc,EAAoB,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE3F,cAAc;AACd,MAAM,WAAW,kCAAkC;IACjD;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,cAAc;AACd,MAAM,WAAW,uCAAuC;IACtD;;;;;;;;;;;;;;;;;;OAkBG;IACH,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,cAAc;AACd,MAAM,WAAW,6BAA6B;IAC5C;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,GAAG,uCAAuC,GAAG,kCAAkC,CAAC;CACrG;AAgCD;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,4BAA4B,GAAG;IAAE,IAAI,EAAE,4BAA4B,CAAC;IAAC,OAAO,CAAC,EAAE,6BAA6B,CAAA;CAAE,CAAC;AACpJ,cAAc;AAEd,yBAAiB,sBAAsB,CAAC;IACtC;;;OAGG;IACH,SAAgB,SAAS,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,EAAE,4BAA4B,CAAC,CAKvH;IAED;;;;;;;;;;;;;;;OAeG;IACH,SAAgB,YAAY,CAC1B,GAAG,EAAE,6BAA6B,GAAG,SAAS,EAC9C,GAAG,EAAE,6BAA6B,GAAG,SAAS,GAC7C,6BAA6B,GAAG,SAAS,CAQ3C;CACF;AAED;;;;;GAKG;AAEH,wBAAgB,qBAAqB,CACnC,uBAAuB,EAAE,sBAAsB,EAAE,EACjD,UAAU,EAAE,IAAI,CAAC,wBAAwB,EAAE,WAAW,CAAC,GAAG,SAAS,GAEjE;IACE,iBAAiB,EAAE,sBAAsB,EAAE,CAAC;IAC5C,uBAAuB,EAAE,OAAO,CAAC;CAClC,GACD,SAAS,CAEZ;AAuBD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,uBAAuB,EAAE,sBAAsB,EAAE,GAAG,SAAS,EAC7D,UAAU,EAAE,IAAI,CAAC,wBAAwB,EAAE,WAAW,GAAG,YAAY,CAAC,GAAG,SAAS;IAKhF;;OAEG;;IAGH;;;;;OAKG;;IAGH;;;OAGG;;IAWH;;;;;;;;OAQG;kCAGG;QACE,OAAO,EAAE,gBAAgB,GAAG,cAAc,CAAC;KAC5C,GACD;QACE,WAAW,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,OAAO,CAAC;KAC/D,KACJ,IAAI,CAAC,aAAa,EAAE,YAAY,GAAG,WAAW,CAAC,GAAG,SAAS;IAoB9D;;OAEG;uCACgC;QACjC,WAAW,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;KAClF,KAAG,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,YAAY,GAAG,WAAW,CAAC,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC,aAAa,EAAE,YAAY,GAAG,WAAW,CAAC,GAAG,SAAS;EAgCzI"}
+{"version":3,"file":"HierarchyFiltering.d.ts","sourceRoot":"","sources":["../../../src/hierarchies/HierarchyFiltering.ts"],"names":[],"mappings":"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"}

package/lib/cjs/hierarchies/HierarchyFiltering.js

@@ -7,11 +7,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HierarchyFilteringPath = void 0;
 exports.extractFilteringProps = extractFilteringProps;
 exports.createHierarchyFilteringHelper = createHierarchyFilteringHelper;
+exports.shouldAutoExpandBasedOnReveal = shouldAutoExpandBasedOnReveal;
 const HierarchyNodeIdentifier_js_1 = require("./HierarchyNodeIdentifier.js");
 const HierarchyNodeKey_js_1 = require("./HierarchyNodeKey.js");
 var HierarchyFilteringPathOptions;
 (function (HierarchyFilteringPathOptions) {
-    function mergeAutoExpandOptions(lhs, rhs) {
+    function mergeRevealOptions(lhs, rhs) {
         if (rhs === true || lhs === true) {
             return true;
         }
@@ -33,7 +34,11 @@ var HierarchyFilteringPathOptions;
         }
         return lhsDepth > rhsDepth ? lhs : rhs;
     }
-    HierarchyFilteringPathOptions.mergeAutoExpandOptions = mergeAutoExpandOptions;
+    HierarchyFilteringPathOptions.mergeRevealOptions = mergeRevealOptions;
+    function mergeAutoExpandOption(lhs, rhs) {
+        return lhs || rhs ? true : undefined;
+    }
+    HierarchyFilteringPathOptions.mergeAutoExpandOption = mergeAutoExpandOption;
 })(HierarchyFilteringPathOptions || (HierarchyFilteringPathOptions = {}));
 /** @public */
 // eslint-disable-next-line @typescript-eslint/no-redeclare
@@ -52,27 +57,26 @@ var HierarchyFilteringPath;
     HierarchyFilteringPath.normalize = normalize;
     /**
      * Merges two given `HierarchyFilteringPathOptions` objects.
-     * - if both inputs are `undefined`, `undefined` is returned,
-     * - else if one of the inputs is `undefined`, the other one is returned.
-     * - else, merge each option individually.
      *
-     * For the `autoExpand` attribute, the merge chooses to auto-expand as deep as the deepest input:
+     * For the `reveal` attribute, the merge chooses to `reveal` as deep as the deepest input:
      * - if any one of the inputs is `true`, return `true`,
      * - else if only one of the inputs is an object, return it,
      * - else if both inputs are falsy, return `false` or `undefined`,
      * - else:
-     *    - if only one of the inputs has `includeGroupingNodes` set to `true` or `key` defined or `depthInHierarchy` set, return the other one,
-     *    - else return the one with greater `depth`, `depthInPath` or `depthInHierarchy`.
+     *    - if only one of the inputs has `depthInHierarchy` set, return the other one,
+     *    - else return the one with greater `depthInPath` or `depthInHierarchy`.
      *
      * @public
      */
     function mergeOptions(lhs, rhs) {
-        if (!lhs || !rhs) {
-            return lhs ?? rhs;
-        }
-        return {
-            autoExpand: HierarchyFilteringPathOptions.mergeAutoExpandOptions(lhs.autoExpand, rhs.autoExpand),
-        };
+        const reveal = HierarchyFilteringPathOptions.mergeRevealOptions(lhs?.reveal, rhs?.reveal);
+        const autoExpand = HierarchyFilteringPathOptions.mergeAutoExpandOption(lhs?.autoExpand, rhs?.autoExpand);
+        return reveal || autoExpand
+            ? {
+                ...(reveal !== undefined ? { reveal } : undefined),
+                ...(autoExpand !== undefined ? { autoExpand } : undefined),
+            }
+            : undefined;
     }
     HierarchyFilteringPath.mergeOptions = mergeOptions;
 })(HierarchyFilteringPath || (exports.HierarchyFilteringPath = HierarchyFilteringPath = {}));
@@ -84,19 +88,24 @@ var HierarchyFilteringPath;
  */
 /* c8 ignore start */
 function extractFilteringProps(rootLevelFilteringProps, parentNode) {
-    return extractFilteringPropsInternal(rootLevelFilteringProps, parentNode);
+    const filteringProps = extractFilteringPropsInternal(rootLevelFilteringProps, parentNode);
+    return filteringProps?.filteredNodePaths !== undefined
+        ? {
+            filteredNodePaths: filteringProps.filteredNodePaths,
+            hasFilterTargetAncestor: filteringProps.hasFilterTargetAncestor,
+        }
+        : undefined;
 }
 /* c8 ignore end */
 function extractFilteringPropsInternal(rootLevelFilteringProps, parentNode) {
     if (!parentNode) {
         return rootLevelFilteringProps ? { filteredNodePaths: rootLevelFilteringProps, hasFilterTargetAncestor: false } : undefined;
     }
-    return parentNode.filtering?.filteredChildrenIdentifierPaths
-        ? {
-            filteredNodePaths: parentNode.filtering.filteredChildrenIdentifierPaths,
-            hasFilterTargetAncestor: !!parentNode.filtering.hasFilterTargetAncestor || !!parentNode.filtering.isFilterTarget,
-        }
-        : undefined;
+    const filteringProps = {
+        ...(parentNode.filtering?.filteredChildrenIdentifierPaths ? { filteredNodePaths: parentNode.filtering.filteredChildrenIdentifierPaths } : undefined),
+        hasFilterTargetAncestor: !!parentNode.filtering?.hasFilterTargetAncestor || !!parentNode.filtering?.isFilterTarget,
+    };
+    return filteringProps.filteredNodePaths || filteringProps.hasFilterTargetAncestor ? filteringProps : undefined;
 }
 /**
  * Creates a set of utilities for making it easier to filter the given hierarchy
@@ -107,10 +116,61 @@ function extractFilteringPropsInternal(rootLevelFilteringProps, parentNode) {
 function createHierarchyFilteringHelper(rootLevelFilteringProps, parentNode) {
     const filteringProps = extractFilteringPropsInternal(rootLevelFilteringProps, parentNode);
     const hasFilter = !!filteringProps;
+    function saveFilteringPropsFromPathsIntoReducer(extractionProps) {
+        // Passes down matching normalized paths to the reducer.
+        // It uses `nodeKey`, `pathMatcher` or `asyncPathMatcher` to check if `HierarchyNodeIdentifier` at the first position in filtering path matches the node
+        // and if it does, the path is passed down to the reducer.
+        // This function returns a promise only if asyncPathMatcher returns a promise.
+        if (!filteringProps?.filteredNodePaths) {
+            return;
+        }
+        const matchedPathPromises = new Array();
+        for (const filteredChildrenNodeIdentifierPath of filteringProps.filteredNodePaths) {
+            const normalizedPath = HierarchyFilteringPath.normalize(filteredChildrenNodeIdentifierPath);
+            /* c8 ignore next 3 */
+            if (normalizedPath.path.length === 0) {
+                continue;
+            }
+            if ("nodeKey" in extractionProps) {
+                if ((HierarchyNodeKey_js_1.HierarchyNodeKey.isGeneric(extractionProps.nodeKey) && HierarchyNodeIdentifier_js_1.HierarchyNodeIdentifier.equal(normalizedPath.path[0], extractionProps.nodeKey)) ||
+                    (HierarchyNodeKey_js_1.HierarchyNodeKey.isInstances(extractionProps.nodeKey) &&
+                        extractionProps.nodeKey.instanceKeys.some((ik) => HierarchyNodeIdentifier_js_1.HierarchyNodeIdentifier.equal(normalizedPath.path[0], ik)))) {
+                    extractionProps.pathsReducer.accept(normalizedPath);
+                }
+                continue;
+            }
+            const matchesPossiblyPromise = "pathMatcher" in extractionProps ? extractionProps.pathMatcher(normalizedPath.path[0]) : extractionProps.asyncPathMatcher(normalizedPath.path[0]);
+            if (matchesPossiblyPromise instanceof Promise) {
+                matchedPathPromises.push(matchesPossiblyPromise.then((matches) => (matches ? normalizedPath : undefined)));
+                continue;
+            }
+            if (matchesPossiblyPromise) {
+                extractionProps.pathsReducer.accept(normalizedPath);
+            }
+        }
+        if (matchedPathPromises.length === 0) {
+            return;
+        }
+        return Promise.all(matchedPathPromises).then((matchedPath) => matchedPath.forEach((normalizedPath) => normalizedPath && extractionProps.pathsReducer.accept(normalizedPath)));
+    }
+    function createChildNodeProps(props) {
+        if (!hasFilter) {
+            return undefined;
+        }
+        const reducer = new MatchingFilteringPathsReducer(filteringProps.hasFilterTargetAncestor);
+        if ("asyncPathMatcher" in props) {
+            const extractResult = saveFilteringPropsFromPathsIntoReducer({ pathsReducer: reducer, asyncPathMatcher: props.asyncPathMatcher });
+            if (extractResult instanceof Promise) {
+                return extractResult.then(() => reducer.getNodeProps(props.parentKeys));
+            }
+        }
+        else {
+            saveFilteringPropsFromPathsIntoReducer({ ...props, pathsReducer: reducer });
+        }
+        return reducer.getNodeProps(props.parentKeys);
+    }
     return {
-        /**
-         * Returns a flag indicating if the hierarchy level is filtered.
-         */
+        /** Returns a flag indicating if the hierarchy level is filtered. */
         hasFilter,
         /**
          * Returns a flag indicating whether this hierarchy level has an ancestor node
@@ -124,7 +184,7 @@ function createHierarchyFilteringHelper(rootLevelFilteringProps, parentNode) {
          * hierarchy level. Returns `undefined` if filtering is not applied to this level.
          */
         getChildNodeFilteringIdentifiers: () => {
-            if (!hasFilter) {
+            if (!filteringProps?.filteredNodePaths) {
                 return undefined;
             }
             return filteringProps.filteredNodePaths
@@ -137,68 +197,33 @@ function createHierarchyFilteringHelper(rootLevelFilteringProps, parentNode) {
          * and `autoExpand`) to be set based on the filter paths and filtering options. This function calculates
          * these props for a child node based on its key or path matcher.
          *
-         * When using `pathMatcher` prop, callers have more flexibility to decide whether the given `HierarchyNodeIdentifier` applies
+         * When using `pathMatcher` or `asyncPathMatcher` prop, callers have more flexibility to decide whether the given `HierarchyNodeIdentifier` applies
          * to their node. For example, only some parts of the identifier can be checked for improved performance. Otherwise, the
          * `nodeKey` prop can be used to check the whole identifier.
+         *
+         * There are multiple overloads of `createChildNodeProps`: depending on props type it returns different values:
+         * - `parentKeys` is defined and `pathMatcher` or `nodeKey` is provided - returns undefined **or** `filtering` and `autoExpand` prop from `HierarchyNode`;
+         * - `parentKeys` is undefined - does not return `HierarchyNode.autoExpand` option;
+         * - props have `asyncPathMatcher` - returns either Promise or the regular return value based on whether or not `asyncPathMatcher` returns a promise.
          */
-        createChildNodeProps: (props) => {
-            if (!hasFilter) {
-                return undefined;
-            }
-            const reducer = new MatchingFilteringPathsReducer(filteringProps?.hasFilterTargetAncestor);
-            filteringProps.filteredNodePaths.forEach((filteredPath) => {
-                const normalizedPath = HierarchyFilteringPath.normalize(filteredPath);
-                if ("nodeKey" in props &&
-                    ((HierarchyNodeKey_js_1.HierarchyNodeKey.isGeneric(props.nodeKey) && HierarchyNodeIdentifier_js_1.HierarchyNodeIdentifier.equal(normalizedPath.path[0], props.nodeKey)) ||
-                        (HierarchyNodeKey_js_1.HierarchyNodeKey.isInstances(props.nodeKey) && props.nodeKey.instanceKeys.some((ik) => HierarchyNodeIdentifier_js_1.HierarchyNodeIdentifier.equal(normalizedPath.path[0], ik))))) {
-                    reducer.accept(normalizedPath);
-                }
-                else if ("pathMatcher" in props && props.pathMatcher(normalizedPath.path[0])) {
-                    reducer.accept(normalizedPath);
-                }
-            });
-            return reducer.getNodeProps(parentNode);
-        },
-        /**
-         * Similar to `createChildNodeProps`, but takes an async `pathMatcher` prop.
-         */
-        createChildNodePropsAsync: (props) => {
-            if (!hasFilter) {
-                return undefined;
-            }
-            const reducer = new MatchingFilteringPathsReducer(filteringProps?.hasFilterTargetAncestor);
-            const matchedPathPromises = new Array();
-            for (const filteredChildrenNodeIdentifierPath of filteringProps.filteredNodePaths) {
-                const normalizedPath = HierarchyFilteringPath.normalize(filteredChildrenNodeIdentifierPath);
-                /* c8 ignore next 3 */
-                if (normalizedPath.path.length === 0) {
-                    continue;
-                }
-                const matchesPossiblyPromise = props.pathMatcher(normalizedPath.path[0]);
-                if (matchesPossiblyPromise instanceof Promise) {
-                    matchedPathPromises.push(matchesPossiblyPromise.then((matches) => (matches ? normalizedPath : undefined)));
-                    continue;
-                }
-                if (!matchesPossiblyPromise) {
-                    continue;
-                }
-                reducer.accept(normalizedPath);
-            }
-            if (matchedPathPromises.length === 0) {
-                return reducer.getNodeProps(parentNode);
-            }
-            return Promise.all(matchedPathPromises)
-                .then((matchedPath) => matchedPath.forEach((normalizedPath) => normalizedPath && reducer.accept(normalizedPath)))
-                .then(() => reducer.getNodeProps(parentNode));
-        },
+        createChildNodeProps,
     };
 }
+/**
+ * Extracts information from filtering paths and later returns `filtering` and `autoExpand` values from `HierarchyNode`.
+ *
+ * Saved values can be applied to a single `HierarchyNode` - this means that a new reducer should be created every time these props are requested for a `HierarchyNode`.
+ *
+ * Extracts information using `accept` function:
+ * - Determines if node is filter target, and if it is saves the options as `filterTargetOptions`
+ * - Saves `HierarchyFilteringPathOptions` and `filteredChildrenIdentifierPaths`
+ */
 class MatchingFilteringPathsReducer {
     _hasFilterTargetAncestor;
     _filteredChildrenIdentifierPaths = new Array();
     _isFilterTarget = false;
     _filterTargetOptions = undefined;
-    _autoExpandOption = false;
+    _revealOption = false;
     constructor(_hasFilterTargetAncestor) {
         this._hasFilterTargetAncestor = _hasFilterTargetAncestor;
     }
@@ -210,28 +235,10 @@ class MatchingFilteringPathsReducer {
         }
         else if (path.length > 1) {
             this._filteredChildrenIdentifierPaths.push({ path: path.slice(1), options });
-            this._autoExpandOption = HierarchyFilteringPathOptions.mergeAutoExpandOptions(options?.autoExpand, this._autoExpandOption);
+            this._revealOption = HierarchyFilteringPathOptions.mergeRevealOptions(options?.reveal, this._revealOption);
         }
     }
-    getNeedsAutoExpand(parentNode) {
-        if (this._autoExpandOption === true) {
-            return true;
-        }
-        if (typeof this._autoExpandOption === "object") {
-            const parentLength = !parentNode
-                ? 0
-                : "depthInHierarchy" in this._autoExpandOption
-                    ? 1 + parentNode.parentKeys.length
-                    : 1 + parentNode.parentKeys.filter((key) => !HierarchyNodeKey_js_1.HierarchyNodeKey.isGrouping(key)).length;
-            const depth = "depthInHierarchy" in this._autoExpandOption
-                ? this._autoExpandOption.depthInHierarchy
-                : // With `depthInPath` option we don't want to expand node that is at the `depthInPath` position
-                    this._autoExpandOption.depthInPath - 1;
-            return parentLength < depth;
-        }
-        return false;
-    }
-    getNodeProps(parentNode) {
+    getNodeProps(parentKeys) {
         return {
             ...(this._hasFilterTargetAncestor || this._isFilterTarget || this._filteredChildrenIdentifierPaths.length > 0
                 ? {
@@ -242,8 +249,29 @@ class MatchingFilteringPathsReducer {
                     },
                 }
                 : undefined),
-            ...(this.getNeedsAutoExpand(parentNode) ? { autoExpand: true } : undefined),
+            ...(parentKeys &&
+                (shouldAutoExpandBasedOnReveal({
+                    reveal: this._revealOption,
+                    nodePositionInHierarchy: parentKeys.length,
+                    nodePositionInPath: parentKeys.filter((key) => !HierarchyNodeKey_js_1.HierarchyNodeKey.isGrouping(key)).length,
+                }) ||
+                    !!this._filterTargetOptions?.autoExpand)
+                ? { autoExpand: true }
+                : undefined),
         };
     }
 }
+/** @internal */
+function shouldAutoExpandBasedOnReveal({ reveal, nodePositionInPath, nodePositionInHierarchy, }) {
+    if (!reveal) {
+        return false;
+    }
+    if (reveal === true) {
+        return true;
+    }
+    if ("depthInHierarchy" in reveal) {
+        return nodePositionInHierarchy < reveal.depthInHierarchy;
+    }
+    return nodePositionInPath < reveal.depthInPath;
+}
 //# sourceMappingURL=HierarchyFiltering.js.map