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

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @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
@@ -59,6 +87,14 @@
 - 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

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