@itwin/presentation-hierarchies 2.0.0-alpha.16 → 2.0.0-alpha.18

package/lib/cjs/hierarchies/HierarchyProvider.js

@@ -1,64 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
- * See LICENSE.md in the project root for license terms and full copyright notice.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHierarchyProvider = createHierarchyProvider;
-const core_bentley_1 = require("@itwin/core-bentley");
-/**
- * An utility to create a `HierarchyProvider` from a partial implementation.
- *
- * Creating a `HierarchyProvider` directly requires implementing all its methods:
- * ```ts
- * {
- *   hierarchyChanged: new BeEvent(),
- *   async *getNodes({ parentNode }) {
- *     // yield nodes...
- *   },
- *   async *getNodeInstanceKeys() {},
- *   setFormatter() {},
- *   setHierarchySearch() {},
- * }
- * ```
- *
- * However, in many cases you may only need to implement the `getNodes` method and
- * can rely on default implementations for other methods.
- *
- * With this utility you can implement only part of it, e.g. just the `getNodes` method:
- * ```ts
- * // provide implementation as a javascript object
- * createHierarchyProvider(({ hierarchyChanged }) => ({
- *   async *getNodes({ parentNode }) {
- *     // yield nodes...
- *   },
- * }));
- *
- * // or, provide implementation as a class instance:
- * createHierarchyProvider(
- *   ({ hierarchyChanged }) =>
- *     new (class implements Pick<HierarchyProvider, "getNodes"> {
- *       public async *getNodes({ parentNode }): ReturnType<HierarchyProvider["getNodes"]> {
- *         // yield nodes...
- *       }
- *     })(),
- * );
- * ```
- *
- * @public
- */
-function createHierarchyProvider(partialFactory) {
-    const hierarchyChanged = new core_bentley_1.BeEvent();
-    const impl = partialFactory({ hierarchyChanged });
-    return Object.assign(impl, {
-        hierarchyChanged,
-        ...(impl.getNodeInstanceKeys
-            ? { getNodeInstanceKeys: impl.getNodeInstanceKeys }
-            : /* v8 ignore next */ { async *getNodeInstanceKeys() { } }),
-        ...(impl.setFormatter ? { setFormatter: impl.setFormatter } : /* v8 ignore next */ { setFormatter() { } }),
-        ...(impl.setHierarchySearch
-            ? { setHierarchySearch: impl.setHierarchySearch }
-            : /* v8 ignore next */ { setHierarchySearch() { } }),
-    });
-}
-//# sourceMappingURL=HierarchyProvider.js.map

package/lib/cjs/hierarchies/HierarchyProvider.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HierarchyProvider.js","sourceRoot":"","sources":["../../../src/hierarchies/HierarchyProvider.ts"],"names":[],"mappings":";AAAA;;;gGAGgG;;AAwJhG,0DAmBC;AAzKD,sDAA8C;AA6G9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,SAAgB,uBAAuB,CAGrC,cAEsB;IAEtB,MAAM,gBAAgB,GAAqD,IAAI,sBAAO,EAAE,CAAC;IACzF,MAAM,IAAI,GAAG,cAAc,CAAC,EAAE,gBAAgB,EAAE,CAAC,CAAC;IAClD,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE;QACzB,gBAAgB;QAChB,GAAG,CAAC,IAAI,CAAC,mBAAmB;YAC1B,CAAC,CAAC,EAAE,mBAAmB,EAAE,IAAI,CAAC,mBAAmB,EAAE;YACnD,CAAC,CAAC,oBAAoB,CAAC,EAAE,KAAK,CAAC,CAAC,mBAAmB,KAAI,CAAC,EAAE,CAAC;QAC7D,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,oBAAoB,CAAC,EAAE,YAAY,KAAI,CAAC,EAAE,CAAC;QACzG,GAAG,CAAC,IAAI,CAAC,kBAAkB;YACzB,CAAC,CAAC,EAAE,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,EAAE;YACjD,CAAC,CAAC,oBAAoB,CAAC,EAAE,kBAAkB,KAAI,CAAC,EAAE,CAAC;KACtD,CAAC,CAAC;AACL,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n * See LICENSE.md in the project root for license terms and full copyright notice.\n *--------------------------------------------------------------------------------------------*/\n\nimport { BeEvent } from \"@itwin/core-bentley\";\n\nimport type { GenericInstanceFilter } from \"@itwin/core-common\";\nimport type {\n  Event,\n  EventListener,\n  InstanceKey,\n  IPrimitiveValueFormatter,\n  Props,\n  RaisableEvent,\n} from \"@itwin/presentation-shared\";\nimport type { HierarchyNode, ParentHierarchyNode } from \"./HierarchyNode.js\";\nimport type { HierarchySearchTree } from \"./HierarchySearch.js\";\n\n/**\n * Props for the `HierarchyProvider.getNodes` call.\n * @public\n */\nexport interface GetHierarchyNodesProps {\n  /** Parent node to get children for. Pass `undefined` to get root nodes. */\n  parentNode: ParentHierarchyNode | undefined;\n\n  /** Optional hierarchy level filter. Has no effect if `parentNode` is a `GroupingNode`. */\n  instanceFilter?: GenericInstanceFilter;\n\n  /**\n   * Optional hierarchy level size limit override. This value is passed to `LimitingECSqlQueryExecutor` used\n   * by this provider to override query rows limit per hierarchy level. If not provided, defaults to whatever\n   * is used by the limiting query executor.\n   *\n   * Has no effect if `parentNode` is a `GroupingNode`.\n   */\n  hierarchyLevelSizeLimit?: number | \"unbounded\";\n\n  /** When set to `true` ignores the cache and fetches the nodes again. */\n  ignoreCache?: boolean;\n}\n\n/**\n * Event arguments for `HierarchyProvider.hierarchyChanged` event.\n * @public\n */\ninterface HierarchyChangedEventArgs {\n  /** Set when the hierarchy change was caused by a formatter change. */\n  formatterChange?: { newFormatter: IPrimitiveValueFormatter | undefined };\n\n  /** Set when the hierarchy change was caused by a hierarchy search change. */\n  searchChange?: { newSearch: Props<HierarchyProvider[\"setHierarchySearch\"]> };\n}\n\n/**\n * An interface for a hierarchy provider that knows how to create child nodes for a given parent node.\n * @public\n */\nexport interface HierarchyProvider {\n  /**\n   * An event that provider raises due to a hierarchy change that requires a reload.\n   *\n   * Consumers are expected to subscribe to this event and reload the hierarchy when it's raised.\n   * Implementations may provide additional details on what caused the change through the\n   * event arguments.\n   */\n  readonly hierarchyChanged: Event<(args: HierarchyChangedEventArgs) => void>;\n\n  /**\n   * Gets nodes for the specified parent node. This is **the method to implement**, otherwise\n   * the provider doesn't return any nodes.\n   */\n  getNodes(props: GetHierarchyNodesProps): AsyncIterableIterator<HierarchyNode>;\n\n  /**\n   * Gets instance keys for the specified parent node.\n   *\n   * The result of this method may be used to determine instances whose nodes would be displayed as children\n   * of the specified parent node. For such use cases calling this method should be more efficient compared\n   * to calling `getNodes`.\n   */\n  getNodeInstanceKeys(props: Omit<GetHierarchyNodesProps, \"ignoreCache\">): AsyncIterableIterator<InstanceKey>;\n\n  /**\n   * Overrides the property value formatter used by the hierarchy provider. Setting to `undefined`\n   * resets the formatter, but what that means depends on the provider implementation - it could just\n   * use unformatted values, or use some default formatter, e.g. the on created by `createDefaultValueFormatter`\n   * from `@itwin/presentation-shared` package.\n   *\n   * @note Changing formatter is expected to trigger the `hierarchyChanged` event with `formatterChange` arg.\n   */\n  setFormatter(formatter: IPrimitiveValueFormatter | undefined): void;\n\n  /**\n   * Sets the hierarchy search used by this hierarchy provider. Setting to `undefined`\n   * removes the search.\n   *\n   * @note There's a difference between `undefined` search and search with empty paths list. The\n   * former means no search is applied, while the latter means the search is applied and it filters-out\n   * all hierarchy.\n   *\n   * @note Changing search is expected to trigger the `hierarchyChanged` event with `searchChange` arg.\n   */\n  setHierarchySearch(\n    props:\n      | {\n          /** A list of search trees that define paths from root to search target nodes. */\n          paths: HierarchySearchTree[];\n        }\n      | undefined,\n  ): void;\n}\n\n/**\n * An utility to create a `HierarchyProvider` from a partial implementation.\n *\n * Creating a `HierarchyProvider` directly requires implementing all its methods:\n * ```ts\n * {\n *   hierarchyChanged: new BeEvent(),\n *   async *getNodes({ parentNode }) {\n *     // yield nodes...\n *   },\n *   async *getNodeInstanceKeys() {},\n *   setFormatter() {},\n *   setHierarchySearch() {},\n * }\n * ```\n *\n * However, in many cases you may only need to implement the `getNodes` method and\n * can rely on default implementations for other methods.\n *\n * With this utility you can implement only part of it, e.g. just the `getNodes` method:\n * ```ts\n * // provide implementation as a javascript object\n * createHierarchyProvider(({ hierarchyChanged }) => ({\n *   async *getNodes({ parentNode }) {\n *     // yield nodes...\n *   },\n * }));\n *\n * // or, provide implementation as a class instance:\n * createHierarchyProvider(\n *   ({ hierarchyChanged }) =>\n *     new (class implements Pick<HierarchyProvider, \"getNodes\"> {\n *       public async *getNodes({ parentNode }): ReturnType<HierarchyProvider[\"getNodes\"]> {\n *         // yield nodes...\n *       }\n *     })(),\n * );\n * ```\n *\n * @public\n */\nexport function createHierarchyProvider<\n  TPartialProvider extends Partial<Omit<HierarchyProvider, \"hierarchyChanged\">> & Pick<HierarchyProvider, \"getNodes\">,\n>(\n  partialFactory: (props: {\n    hierarchyChanged: RaisableEvent<EventListener<HierarchyProvider[\"hierarchyChanged\"]>>;\n  }) => TPartialProvider,\n): TPartialProvider & HierarchyProvider {\n  const hierarchyChanged: Props<typeof partialFactory>[\"hierarchyChanged\"] = new BeEvent();\n  const impl = partialFactory({ hierarchyChanged });\n  return Object.assign(impl, {\n    hierarchyChanged,\n    ...(impl.getNodeInstanceKeys\n      ? { getNodeInstanceKeys: impl.getNodeInstanceKeys }\n      : /* v8 ignore next */ { async *getNodeInstanceKeys() {} }),\n    ...(impl.setFormatter ? { setFormatter: impl.setFormatter } : /* v8 ignore next */ { setFormatter() {} }),\n    ...(impl.setHierarchySearch\n      ? { setHierarchySearch: impl.setHierarchySearch }\n      : /* v8 ignore next */ { setHierarchySearch() {} }),\n  });\n}\n"]}

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

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

package/lib/cjs/hierarchies/HierarchySearch.js

@@ -1,468 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
- * See LICENSE.md in the project root for license terms and full copyright notice.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HierarchySearchTree = exports.HierarchySearchPath = void 0;
-exports.createHierarchySearchHelper = createHierarchySearchHelper;
-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");
-const ReleaseMainThread_js_1 = require("./internal/operators/ReleaseMainThread.js");
-/** @public */
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-var HierarchySearchPath;
-(function (HierarchySearchPath) {
-    /**
-     * Normalizes the hierarchy search path to the object form.
-     * @public
-     */
-    function normalize(source) {
-        if (Array.isArray(source)) {
-            return { path: source };
-        }
-        return source;
-    }
-    HierarchySearchPath.normalize = normalize;
-    /**
-     * Merges two given `HierarchySearchPathOptions` objects.
-     *
-     * 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 `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 = mergeRevealOptions(lhs?.reveal, rhs?.reveal);
-        const autoExpand = mergeAutoExpandOption(lhs?.autoExpand, rhs?.autoExpand);
-        return reveal || autoExpand
-            ? {
-                ...(reveal !== undefined ? { reveal } : undefined),
-                ...(autoExpand !== undefined ? { autoExpand } : undefined),
-            }
-            : 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, parentEntries, props) {
-                const list = [];
-                for (const { children, ...entry } of dictionary.values()) {
-                    let processedEntry = entry;
-                    if (props?.processEntry) {
-                        processedEntry = props.processEntry({ treeEntry: entry, parentEntries });
-                    }
-                    if (!processedEntry) {
-                        continue;
-                    }
-                    const { extras: _, ...entryWithoutExtras } = processedEntry;
-                    parentEntries.push(processedEntry);
-                    list.push({
-                        ...entryWithoutExtras,
-                        ...(children ? { children: Impl.#mapDictionaryToTree(children, parentEntries, props) } : undefined),
-                    });
-                    parentEntries.pop();
-                }
-                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(props) {
-                return Impl.#mapDictionaryToTree(this.#rootsDictionary, [], props);
-            }
-        })();
-    }
-    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;
-    }
-    const searchProps = {
-        ...(parentNode.search?.childrenTargetPaths
-            ? { childrenTargetPaths: parentNode.search.childrenTargetPaths }
-            : undefined),
-        hasSearchTargetAncestor: !!parentNode.search?.hasSearchTargetAncestor || !!parentNode.search?.isSearchTarget,
-    };
-    return searchProps.childrenTargetPaths || searchProps.hasSearchTargetAncestor ? searchProps : undefined;
-}
-/**
- * Creates a set of utilities for making it easier to search the given hierarchy
- * level.
- *
- * @public
- */
-function createHierarchySearchHelper(rootLevelSearchProps, parentNode) {
-    const searchProps = extractSearchPropsInternal(rootLevelSearchProps, parentNode);
-    const hasSearch = !!searchProps;
-    function saveSearchPropsFromPathsIntoReducer(extractionProps) {
-        // 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.
-        if (!searchProps?.childrenTargetPaths) {
-            return;
-        }
-        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);
-                }
-            }
-            else {
-                const matches = "pathMatcher" in extractionProps
-                    ? extractionProps.pathMatcher(childrenSearchTree.identifier)
-                    : nodeKeyMatchesIdentifier(extractionProps.nodeKey, childrenSearchTree.identifier);
-                if (matches) {
-                    extractionProps.pathsReducer.accept(childrenSearchTree);
-                }
-            }
-        }
-        if (matchedTreePromises.length === 0) {
-            return;
-        }
-        return Promise.all(matchedTreePromises).then((matchedTrees) => matchedTrees.forEach((matchedTree) => matchedTree && extractionProps.pathsReducer.accept(matchedTree)));
-    }
-    function createChildNodeProps(props) {
-        if (!hasSearch) {
-            return undefined;
-        }
-        const reducer = new MatchingSearchPathsReducer(searchProps.hasSearchTargetAncestor);
-        if ("asyncPathMatcher" in props) {
-            const extractResult = saveSearchPropsFromPathsIntoReducer({
-                pathsReducer: reducer,
-                nodeKey: props.nodeKey,
-                asyncPathMatcher: props.asyncPathMatcher,
-            });
-            if (extractResult instanceof Promise) {
-                return extractResult.then(() => reducer.aggregatedOptions);
-            }
-        }
-        else {
-            saveSearchPropsFromPathsIntoReducer({ pathsReducer: reducer, ...props });
-        }
-        return reducer.aggregatedOptions;
-    }
-    return {
-        /** Returns a flag indicating if the hierarchy level is filtered. */
-        hasSearch,
-        /**
-         * Returns a flag indicating whether this hierarchy level has an ancestor node
-         * that is a search target. That generally means that this and all downstream hierarchy
-         * levels should be displayed without search being applied to them, even if search paths
-         * say otherwise.
-         */
-        hasSearchTargetAncestor: searchProps?.hasSearchTargetAncestor ?? false,
-        /**
-         * Returns a list of hierarchy node identifiers that apply specifically for this
-         * hierarchy level. Returns `undefined` if search is not applied to this level.
-         */
-        getChildNodeSearchIdentifiers: () => {
-            if (!searchProps?.childrenTargetPaths) {
-                return undefined;
-            }
-            return searchProps.childrenTargetPaths.map(({ identifier }) => identifier);
-        },
-        /**
-         * When a hierarchy node is created for a filtered hierarchy level, it needs some attributes (e.g. `search`
-         * and `autoExpand`) to be set based on the search paths and search options. This function calculates
-         * these props for a child node based on its key or path matcher.
-         *
-         * 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:
-         * - `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`.
- *
- * 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 search target, and if it is saves the options as `searchTargetOptions`
- * - Saves `HierarchySearchPathOptions` and `childrenTargetPaths`
- */
-class MatchingSearchPathsReducer {
-    _hasSearchTargetAncestor;
-    _childrenTargetPaths = new Array();
-    _isSearchTarget = false;
-    _options = undefined;
-    constructor(_hasSearchTargetAncestor) {
-        this._hasSearchTargetAncestor = _hasSearchTargetAncestor;
-    }
-    accept(tree) {
-        if (tree.isTarget || tree.children === undefined) {
-            this._isSearchTarget = true;
-        }
-        if (tree.children && tree.children.length > 0) {
-            this._childrenTargetPaths.push(...tree.children);
-        }
-        this._options = HierarchySearchTree.mergeOptions(this._options, tree.options);
-    }
-    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 { ...(search ? { search } : undefined), ...(autoExpand ? { autoExpand } : undefined) };
-    }
-}
-//# sourceMappingURL=HierarchySearch.js.map