@itwin/presentation-hierarchies 2.0.0-alpha.12 → 2.0.0-alpha.13

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

@@ -1 +1 @@
-{"version":3,"file":"HierarchySearch.d.ts","sourceRoot":"","sources":["../../../src/hierarchies/HierarchySearch.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"HierarchySearch.d.ts","sourceRoot":"","sources":["../../../src/hierarchies/HierarchySearch.ts"],"names":[],"mappings":"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"}

package/lib/cjs/hierarchies/HierarchySearch.js

@@ -4,41 +4,13 @@
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HierarchySearchPath = void 0;
+exports.HierarchySearchTree = exports.HierarchySearchPath = void 0;
 exports.createHierarchySearchHelper = createHierarchySearchHelper;
-exports.shouldAutoExpandBasedOnReveal = shouldAutoExpandBasedOnReveal;
+const rxjs_1 = require("rxjs");
+const core_bentley_1 = require("@itwin/core-bentley");
 const HierarchyNodeIdentifier_js_1 = require("./HierarchyNodeIdentifier.js");
 const HierarchyNodeKey_js_1 = require("./HierarchyNodeKey.js");
-var HierarchySearchPathOptions;
-(function (HierarchySearchPathOptions) {
-    function mergeRevealOptions(lhs, rhs) {
-        if (rhs === true || lhs === true) {
-            return true;
-        }
-        if (!rhs || !lhs) {
-            return !!rhs ? rhs : lhs;
-        }
-        const lhsDepth = "depthInPath" in lhs ? lhs.depthInPath : lhs.depthInHierarchy;
-        const rhsDepth = "depthInPath" in rhs ? rhs.depthInPath : rhs.depthInHierarchy;
-        const isLhsDepthBasedOnPath = "depthInPath" in lhs;
-        const isRhsDepthBasedOnPath = "depthInPath" in rhs;
-        if (isLhsDepthBasedOnPath) {
-            if (isRhsDepthBasedOnPath) {
-                return lhsDepth > rhsDepth ? lhs : rhs;
-            }
-            return lhs;
-        }
-        if (isRhsDepthBasedOnPath) {
-            return rhs;
-        }
-        return lhsDepth > rhsDepth ? lhs : rhs;
-    }
-    HierarchySearchPathOptions.mergeRevealOptions = mergeRevealOptions;
-    function mergeAutoExpandOption(lhs, rhs) {
-        return lhs || rhs ? true : undefined;
-    }
-    HierarchySearchPathOptions.mergeAutoExpandOption = mergeAutoExpandOption;
-})(HierarchySearchPathOptions || (HierarchySearchPathOptions = {}));
+const ReleaseMainThread_js_1 = require("./internal/operators/ReleaseMainThread.js");
 /** @public */
 // eslint-disable-next-line @typescript-eslint/no-redeclare
 var HierarchySearchPath;
@@ -62,14 +34,14 @@ var HierarchySearchPath;
      * - 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 `depthInHierarchy` set, return the other one,
-     *    - else return the one with greater `depthInPath` or `depthInHierarchy`.
+     *    - if only one of the inputs has `groupingLevel` set, return that one,
+     *    - else compare by matching reveal type (`groupingLevel` or `depthInPath`) and return the deeper one.
      *
      * @public
      */
     function mergeOptions(lhs, rhs) {
-        const reveal = HierarchySearchPathOptions.mergeRevealOptions(lhs?.reveal, rhs?.reveal);
-        const autoExpand = HierarchySearchPathOptions.mergeAutoExpandOption(lhs?.autoExpand, rhs?.autoExpand);
+        const reveal = mergeRevealOptions(lhs?.reveal, rhs?.reveal);
+        const autoExpand = mergeAutoExpandOption(lhs?.autoExpand, rhs?.autoExpand);
         return reveal || autoExpand
             ? {
                 ...(reveal !== undefined ? { reveal } : undefined),
@@ -78,7 +50,254 @@ var HierarchySearchPath;
             : undefined;
     }
     HierarchySearchPath.mergeOptions = mergeOptions;
+    function mergeRevealOptions(lhs, rhs) {
+        if (rhs === true || lhs === true) {
+            return true;
+        }
+        if (!rhs || !lhs) {
+            return !!rhs ? rhs : lhs;
+        }
+        if ("groupingLevel" in lhs) {
+            if ("groupingLevel" in rhs) {
+                return lhs.groupingLevel > rhs.groupingLevel ? lhs : rhs;
+            }
+            return lhs;
+        }
+        else if ("groupingLevel" in rhs) {
+            return rhs;
+        }
+        return lhs.depthInPath > rhs.depthInPath ? lhs : rhs;
+    }
+    function mergeAutoExpandOption(lhs, rhs) {
+        return lhs || rhs ? true : undefined;
+    }
 })(HierarchySearchPath || (exports.HierarchySearchPath = HierarchySearchPath = {}));
+/** @public */
+var HierarchySearchTree;
+(function (HierarchySearchTree) {
+    /**
+     * Create a `HierarchySearchTree` builder utility that accepts hierarchy search paths or search trees one by one and builds
+     * a `HierarchySearchTree` structure based on them.
+     *
+     * Usage example:
+     *
+     * ```ts
+     * const builder = HierarchySearchTree.createBuilder();
+     * for (const path of searchPaths) {
+     *   builder.accept({ path });
+     * }
+     * const searchTree = builder.getTree();
+     * ```
+     *
+     * @public
+     */
+    function createBuilder() {
+        var _a;
+        return new (class Impl {
+            #rootsDictionary = new core_bentley_1.Dictionary(HierarchyNodeIdentifier_js_1.HierarchyNodeIdentifier.compare);
+            static #mapDictionaryToTree(dictionary) {
+                const list = [];
+                for (const { children, extras: _, ...entry } of dictionary.values()) {
+                    list.push({ ...entry, ...(children ? { children: Impl.#mapDictionaryToTree(children) } : undefined) });
+                }
+                return list;
+            }
+            static #assignAutoExpandOptionsBasedOnReveal(treePath, revealOption) {
+                if (revealOption === true) {
+                    Impl.#assignOptionsOnTreePath({
+                        treePath,
+                        targetEntryIndex: treePath.length - 1,
+                        getEntryOptions: (index, targetEntryIndex) => {
+                            if (index === targetEntryIndex) {
+                                // auto-expand all grouping nodes of the revealed node
+                                return { autoExpand: { groupingLevel: Number.MAX_SAFE_INTEGER } };
+                            }
+                            // auto-expand all parent nodes
+                            return { autoExpand: true };
+                        },
+                    });
+                }
+                else if (revealOption && "groupingLevel" in revealOption) {
+                    Impl.#assignOptionsOnTreePath({
+                        treePath,
+                        targetEntryIndex: treePath.length - 1,
+                        getEntryOptions: (index, targetEntryIndex) => {
+                            if (index === targetEntryIndex) {
+                                // the last entry should have `autoExpand` with `groupingLevel` set to the value based on `reveal.groupingLevel`
+                                return { autoExpand: { groupingLevel: Math.max(revealOption.groupingLevel - 1, 0) } };
+                            }
+                            // auto-expand all parent nodes
+                            return { autoExpand: true };
+                        },
+                    });
+                }
+                else if (revealOption && "depthInPath" in revealOption) {
+                    Impl.#assignOptionsOnTreePath({
+                        treePath,
+                        targetEntryIndex: Math.min(revealOption.depthInPath, treePath.length - 1),
+                        getEntryOptions: (index, targetEntryIndex) => {
+                            if (index === targetEntryIndex) {
+                                // auto-expand all grouping nodes of the revealed node
+                                return { autoExpand: { groupingLevel: Number.MAX_SAFE_INTEGER } };
+                            }
+                            // auto-expand all parent nodes
+                            return { autoExpand: true };
+                        },
+                    });
+                }
+            }
+            static #assignOptionsOnTreePath({ treePath, targetEntryIndex, getEntryOptions, }) {
+                // set all parent entries to auto-expand
+                for (let i = 0; i <= targetEntryIndex; i++) {
+                    const options = mergeOptions(treePath[i].options, getEntryOptions(i, targetEntryIndex));
+                    if (options) {
+                        treePath[i].options = options;
+                    }
+                }
+            }
+            #acceptNode({ parentEntries, level, node, handler, }) {
+                let entry = level.get(node.identifier);
+                if (!entry) {
+                    if (handler?.onNewEntry && !handler.onNewEntry({ parentEntries, inputEntry: node })) {
+                        return undefined;
+                    }
+                    entry = {
+                        identifier: node.identifier,
+                        children: node.hasChildren ? new core_bentley_1.Dictionary(HierarchyNodeIdentifier_js_1.HierarchyNodeIdentifier.compare) : undefined,
+                        extras: {},
+                    };
+                    level.set(node.identifier, entry);
+                }
+                const isNodeSearchTarget = node.isTarget || !node.hasChildren;
+                if (isNodeSearchTarget && entry.children) {
+                    entry.isTarget = true;
+                }
+                if (!entry.children && node.hasChildren) {
+                    // Existing leaf nodes are implied targets. Preserve that status when adding children.
+                    entry.isTarget = true;
+                    entry.children = new core_bentley_1.Dictionary(HierarchyNodeIdentifier_js_1.HierarchyNodeIdentifier.compare);
+                }
+                handler?.onEntryHandled?.({ parentEntries, treeEntry: entry, inputEntry: node });
+                return entry;
+            }
+            #acceptPath({ path, handler }) {
+                const normalized = HierarchySearchPath.normalize(path);
+                const treePath = [];
+                let currentLevel = this.#rootsDictionary;
+                for (let i = 0; i < normalized.path.length; i++) {
+                    const identifier = normalized.path[i];
+                    const acceptedNode = this.#acceptNode({
+                        parentEntries: treePath,
+                        node: { identifier, hasChildren: i < normalized.path.length - 1 },
+                        level: currentLevel,
+                        handler,
+                    });
+                    if (!acceptedNode) {
+                        break;
+                    }
+                    treePath.push(acceptedNode);
+                    if (!acceptedNode.children) {
+                        break;
+                    }
+                    currentLevel = acceptedNode.children;
+                }
+                if (treePath.length === 0) {
+                    return;
+                }
+                // handle auto-expand
+                const lastNode = treePath[treePath.length - 1];
+                if (normalized.options?.autoExpand) {
+                    (lastNode.options ??= {}).autoExpand = true;
+                }
+                // handle auto-reveal
+                Impl.#assignAutoExpandOptionsBasedOnReveal(treePath, normalized.options?.reveal);
+            }
+            #acceptTree({ tree, handler }) {
+                const acceptTreeNode = (parentEntries, parentInputs, level, node) => {
+                    const acceptedNode = this.#acceptNode({
+                        parentEntries,
+                        node: { ...node, hasChildren: node.children !== undefined },
+                        level,
+                        handler,
+                    });
+                    if (!acceptedNode) {
+                        // It was decided to reject this node and its children, if any
+                        return;
+                    }
+                    const treePath = [...parentEntries, acceptedNode];
+                    const inputsPath = [...parentInputs, node];
+                    if (!node.children || node.isTarget) {
+                        // Found an effective search target - merge options from its path
+                        Impl.#assignOptionsOnTreePath({
+                            treePath,
+                            targetEntryIndex: treePath.length - 1,
+                            getEntryOptions: (index) => inputsPath[index].options,
+                        });
+                    }
+                    const currentLevel = acceptedNode.children;
+                    if (currentLevel) {
+                        node.children?.forEach((child) => acceptTreeNode(treePath, inputsPath, currentLevel, child));
+                    }
+                };
+                acceptTreeNode([], [], this.#rootsDictionary, tree);
+            }
+            accept(props) {
+                if ("path" in props) {
+                    this.#acceptPath(props);
+                }
+                else {
+                    this.#acceptTree(props);
+                }
+                return this;
+            }
+            getTree() {
+                return Impl.#mapDictionaryToTree(this.#rootsDictionary);
+            }
+        })();
+    }
+    HierarchySearchTree.createBuilder = createBuilder;
+    /**
+     * Builds a list of `HierarchySearchTree` nodes from an iterable of search paths. Shared
+     * path prefixes are merged so that each unique hierarchy node identifier appears only once
+     * per level. The resulting trees carry `isTarget`, `options`, and `children` attributes
+     * derived from the paths and their options (`autoExpand`, `reveal`).
+     *
+     * @public
+     */
+    async function createFromPathsList(paths) {
+        return (0, rxjs_1.firstValueFrom)((0, rxjs_1.from)(paths).pipe((0, ReleaseMainThread_js_1.releaseMainThreadOnItemsCount)(1000), (0, rxjs_1.reduce)((builder, path) => builder.accept({ path }), createBuilder()), (0, rxjs_1.map)((builder) => builder.getTree())));
+    }
+    HierarchySearchTree.createFromPathsList = createFromPathsList;
+    /**
+     * Merges two `HierarchySearchTree` option objects. For the `autoExpand` attribute,
+     * `true` takes precedence over `{ groupingLevel }`, and when both sides are
+     * `{ groupingLevel }` objects the larger value wins.
+     * @public
+     */
+    function mergeOptions(lhs, rhs) {
+        if (!lhs) {
+            return rhs;
+        }
+        if (!rhs) {
+            return lhs;
+        }
+        const autoExpand = mergeSearchTreeAutoExpandOption(lhs.autoExpand, rhs.autoExpand);
+        const options = {
+            ...(autoExpand ? { autoExpand } : undefined),
+        };
+        return Object.keys(options).length > 0 ? options : undefined;
+    }
+    HierarchySearchTree.mergeOptions = mergeOptions;
+    function mergeSearchTreeAutoExpandOption(lhs, rhs) {
+        if (!lhs) {
+            return rhs;
+        }
+        if (!rhs) {
+            return lhs;
+        }
+        return lhs === true || rhs === true ? true : { groupingLevel: Math.max(lhs.groupingLevel, rhs.groupingLevel) };
+    }
+})(HierarchySearchTree || (exports.HierarchySearchTree = HierarchySearchTree = {}));
 function extractSearchPropsInternal(rootLevelSearchProps, parentNode) {
     if (!parentNode) {
         return rootLevelSearchProps ? { childrenTargetPaths: rootLevelSearchProps, hasSearchTargetAncestor: false } : undefined;
@@ -99,41 +318,37 @@ function createHierarchySearchHelper(rootLevelSearchProps, parentNode) {
     const searchProps = extractSearchPropsInternal(rootLevelSearchProps, parentNode);
     const hasSearch = !!searchProps;
     function saveSearchPropsFromPathsIntoReducer(extractionProps) {
-        // Passes down matching normalized paths to the reducer.
-        // It uses `nodeKey`, `pathMatcher` or `asyncPathMatcher` to check if `HierarchyNodeIdentifier` at the first position in search path matches the node
+        // Passes down matching hierarchy search trees to the reducer.
+        // It uses `nodeKey`, `pathMatcher` or `asyncPathMatcher` to check if `HierarchyNodeIdentifier` in the search tree item's identifier 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.
+        // This function returns a promise only if `asyncPathMatcher` returns a promise.
         if (!searchProps?.childrenTargetPaths) {
             return;
         }
-        const matchedPathPromises = new Array();
-        for (const childrenTargetPaths of searchProps.childrenTargetPaths) {
-            const normalizedPath = HierarchySearchPath.normalize(childrenTargetPaths);
-            /* 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);
+        const matchedTreePromises = new Array();
+        for (const childrenSearchTree of searchProps.childrenTargetPaths) {
+            if ("asyncPathMatcher" in extractionProps) {
+                const matchesPossiblyPromise = extractionProps.asyncPathMatcher(childrenSearchTree.identifier);
+                if (matchesPossiblyPromise instanceof Promise) {
+                    matchedTreePromises.push(matchesPossiblyPromise.then((matches) => (matches ? childrenSearchTree : undefined)));
+                }
+                else if (matchesPossiblyPromise) {
+                    extractionProps.pathsReducer.accept(childrenSearchTree);
                 }
-                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);
+            else {
+                const matches = "pathMatcher" in extractionProps
+                    ? extractionProps.pathMatcher(childrenSearchTree.identifier)
+                    : nodeKeyMatchesIdentifier(extractionProps.nodeKey, childrenSearchTree.identifier);
+                if (matches) {
+                    extractionProps.pathsReducer.accept(childrenSearchTree);
+                }
             }
         }
-        if (matchedPathPromises.length === 0) {
+        if (matchedTreePromises.length === 0) {
             return;
         }
-        return Promise.all(matchedPathPromises).then((matchedPath) => matchedPath.forEach((normalizedPath) => normalizedPath && extractionProps.pathsReducer.accept(normalizedPath)));
+        return Promise.all(matchedTreePromises).then((matchedTrees) => matchedTrees.forEach((matchedTree) => matchedTree && extractionProps.pathsReducer.accept(matchedTree)));
     }
     function createChildNodeProps(props) {
         if (!hasSearch) {
@@ -141,15 +356,15 @@ function createHierarchySearchHelper(rootLevelSearchProps, parentNode) {
         }
         const reducer = new MatchingSearchPathsReducer(searchProps.hasSearchTargetAncestor);
         if ("asyncPathMatcher" in props) {
-            const extractResult = saveSearchPropsFromPathsIntoReducer({ pathsReducer: reducer, asyncPathMatcher: props.asyncPathMatcher });
+            const extractResult = saveSearchPropsFromPathsIntoReducer({ pathsReducer: reducer, nodeKey: props.nodeKey, asyncPathMatcher: props.asyncPathMatcher });
             if (extractResult instanceof Promise) {
-                return extractResult.then(() => reducer.getNodeProps(props.parentKeys));
+                return extractResult.then(() => reducer.aggregatedOptions);
             }
         }
         else {
-            saveSearchPropsFromPathsIntoReducer({ ...props, pathsReducer: reducer });
+            saveSearchPropsFromPathsIntoReducer({ pathsReducer: reducer, ...props });
         }
-        return reducer.getNodeProps(props.parentKeys);
+        return reducer.aggregatedOptions;
     }
     return {
         /** Returns a flag indicating if the hierarchy level is filtered. */
@@ -169,10 +384,7 @@ function createHierarchySearchHelper(rootLevelSearchProps, parentNode) {
             if (!searchProps?.childrenTargetPaths) {
                 return undefined;
             }
-            return searchProps.childrenTargetPaths
-                .map(HierarchySearchPath.normalize)
-                .filter(({ path }) => path.length > 0)
-                .map(({ path }) => path[0]);
+            return searchProps.childrenTargetPaths.map(({ identifier }) => identifier);
         },
         /**
          * When a hierarchy node is created for a filtered hierarchy level, it needs some attributes (e.g. `search`
@@ -184,13 +396,16 @@ function createHierarchySearchHelper(rootLevelSearchProps, parentNode) {
          * `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** `search` 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.
+         * - `asyncPathMatcher` is provided - returns either Promise or the regular return value based on whether or not `asyncPathMatcher` returns a `Promise`.
+         * - `pathMatcher` or only `nodeKey` is provided - returns undefined **or** `search` and `autoExpand` prop from `HierarchyNode`;
          */
         createChildNodeProps,
     };
 }
+function nodeKeyMatchesIdentifier(nodeKey, identifier) {
+    return ((HierarchyNodeKey_js_1.HierarchyNodeKey.isGeneric(nodeKey) && HierarchyNodeIdentifier_js_1.HierarchyNodeIdentifier.equal(identifier, nodeKey)) ||
+        (HierarchyNodeKey_js_1.HierarchyNodeKey.isInstances(nodeKey) && nodeKey.instanceKeys.some((ik) => HierarchyNodeIdentifier_js_1.HierarchyNodeIdentifier.equal(identifier, ik))));
+}
 /**
  * Extracts information from search paths and later returns `search` and `autoExpand` values from `HierarchyNode`.
  *
@@ -204,56 +419,33 @@ class MatchingSearchPathsReducer {
     _hasSearchTargetAncestor;
     _childrenTargetPaths = new Array();
     _isSearchTarget = false;
-    _searchTargetOptions = undefined;
-    _revealOption = false;
+    _options = undefined;
     constructor(_hasSearchTargetAncestor) {
         this._hasSearchTargetAncestor = _hasSearchTargetAncestor;
     }
-    accept(normalizedPath) {
-        const { path, options } = normalizedPath;
-        if (path.length === 1) {
+    accept(tree) {
+        if (tree.isTarget || tree.children === undefined) {
             this._isSearchTarget = true;
-            this._searchTargetOptions = HierarchySearchPath.mergeOptions(this._searchTargetOptions, options);
         }
-        else if (path.length > 1) {
-            this._childrenTargetPaths.push({ path: path.slice(1), options });
-            this._revealOption = HierarchySearchPathOptions.mergeRevealOptions(options?.reveal, this._revealOption);
+        if (tree.children && tree.children.length > 0) {
+            this._childrenTargetPaths.push(...tree.children);
         }
+        this._options = HierarchySearchTree.mergeOptions(this._options, tree.options);
     }
-    getNodeProps(parentKeys) {
+    get aggregatedOptions() {
+        const search = this._hasSearchTargetAncestor || this._isSearchTarget || this._childrenTargetPaths.length > 0 || this._options
+            ? {
+                ...(this._hasSearchTargetAncestor ? { hasSearchTargetAncestor: true } : undefined),
+                ...(this._isSearchTarget ? { isSearchTarget: true } : undefined),
+                ...(this._childrenTargetPaths.length > 0 ? { childrenTargetPaths: this._childrenTargetPaths } : undefined),
+                ...(this._options ? { options: this._options } : undefined),
+            }
+            : undefined;
+        const autoExpand = this._options?.autoExpand === true;
         return {
-            ...(this._hasSearchTargetAncestor || this._isSearchTarget || this._childrenTargetPaths.length > 0
-                ? {
-                    search: {
-                        ...(this._hasSearchTargetAncestor ? { hasSearchTargetAncestor: true } : undefined),
-                        ...(this._isSearchTarget ? { isSearchTarget: true, searchTargetOptions: this._searchTargetOptions } : undefined),
-                        ...(this._childrenTargetPaths.length > 0 ? { childrenTargetPaths: this._childrenTargetPaths } : undefined),
-                    },
-                }
-                : undefined),
-            ...(parentKeys &&
-                (shouldAutoExpandBasedOnReveal({
-                    reveal: this._revealOption,
-                    nodePositionInHierarchy: parentKeys.length,
-                    nodePositionInPath: parentKeys.filter((key) => !HierarchyNodeKey_js_1.HierarchyNodeKey.isGrouping(key)).length,
-                }) ||
-                    !!this._searchTargetOptions?.autoExpand)
-                ? { autoExpand: true }
-                : undefined),
+            ...(search ? { search } : undefined),
+            ...(autoExpand ? { autoExpand } : 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=HierarchySearch.js.map