@itwin/presentation-hierarchies 2.0.0-alpha.2 → 2.0.0-alpha.20

package/lib/esm/hierarchies/imodel/IModelHierarchyNode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"IModelHierarchyNode.js","sourceRoot":"","sources":["../../../../src/hierarchies/imodel/IModelHierarchyNode.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAIhG,OAAO,EAAkB,gBAAgB,EAAoB,MAAM,wBAAwB,CAAC;AAuN5F,cAAc;AACd,2DAA2D;AAC3D,MAAM,KAAW,sBAAsB,CAatC;AAbD,WAAiB,sBAAsB;IACrC,sDAAsD;IACtD,SAAgB,SAAS,CAAC,IAA4B;QACpD,OAAO,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC9C,CAAC;IAFe,gCAAS,YAExB,CAAA;IACD,iEAAiE;IACjE,SAAgB,eAAe,CAAC,IAA4B;QAC1D,OAAO,gBAAgB,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChD,CAAC;IAFe,sCAAe,kBAE9B,CAAA;IACD,uDAAuD;IACvD,SAAgB,cAAc,CAAC,IAA4B;QACzD,OAAO,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/C,CAAC;IAFe,qCAAc,iBAE7B,CAAA;AACH,CAAC,EAbgB,sBAAsB,KAAtB,sBAAsB,QAatC","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 { ConcatenatedValue, InstanceKey, OmitOverUnion, PrimitiveValue } from \"@itwin/presentation-shared\";\nimport { GroupingHierarchyNode, NonGroupingHierarchyNode } from \"../HierarchyNode.js\";\nimport { GenericNodeKey, HierarchyNodeKey, InstancesNodeKey } from \"../HierarchyNodeKey.js\";\n\n/**\n * Base processing parameters that apply to every node.\n * @public\n */\ninterface HierarchyNodeProcessingParamsBase {\n  /** Indicates if this node should be hidden if it has no child nodes. */\n  hideIfNoChildren?: boolean;\n  /** Indicates that this node should always be hidden and its children should be loaded in its place. */\n  hideInHierarchy?: boolean;\n}\n\n/**\n * A data structure for defining nodes' grouping requirements.\n * @public\n */\ninterface HierarchyNodeGroupingParams {\n  byLabel?: HierarchyNodeLabelGroupingParams;\n  byClass?: boolean | HierarchyNodeGroupingParamsBase;\n  byBaseClasses?: HierarchyNodeBaseClassGroupingParams;\n  byProperties?: HierarchyNodePropertiesGroupingParams;\n}\n\n/**\n * A data structure for defining params specifically used for label grouping.\n * @public\n */\ninterface HierarchyNodeLabelGroupingBaseParams {\n  /** Label grouping option that determines whether to group nodes or to merge them. Defaults to \"group\".*/\n  action?: \"group\" | \"merge\";\n  /** Value that needs to match in order for nodes to be grouped or merged.*/\n  groupId?: string;\n}\n\n/**\n * A data structure for defining label merging.\n * @public\n */\ninterface HierarchyNodeLabelGroupingMergeParams extends HierarchyNodeLabelGroupingBaseParams {\n  action: \"merge\";\n}\n\n/**\n * A data structure for defining label grouping with additional parameters.\n * @public\n */\ninterface HierarchyNodeLabelGroupingGroupParams extends HierarchyNodeLabelGroupingBaseParams, HierarchyNodeGroupingParamsBase {\n  action?: \"group\";\n}\n\n/**\n * A data structure for defining possible label grouping types.\n * @public\n */\nexport type HierarchyNodeLabelGroupingParams = boolean | HierarchyNodeLabelGroupingMergeParams | HierarchyNodeLabelGroupingGroupParams;\n\n/**\n * Grouping parameters that are shared across all types of groupings.\n * @public\n */\nexport interface HierarchyNodeGroupingParamsBase {\n  /** Hiding option that determines whether to hide group nodes which have no siblings at the same hierarchy level. */\n  hideIfNoSiblings?: boolean;\n  /** Hiding option that determines whether to hide group nodes which have only one node as its children. */\n  hideIfOneGroupedNode?: boolean;\n  /** Option which auto expands grouping nodes' children when it has single child or always. */\n  autoExpand?: HierarchyNodeAutoExpandProp;\n}\n\n/**\n * Defines possible values for `BaseGroupingParams.autoExpand` attribute:\n * - `single-child` - set the grouping node to auto-expand if it groups a single node.\n * - `always` - always set the grouping node to auto-expand.\n * @public\n */\nexport type HierarchyNodeAutoExpandProp = \"single-child\" | \"always\";\n\n/**\n * A data structure that represents base class grouping.\n * @public\n */\ninterface HierarchyNodeBaseClassGroupingParams extends HierarchyNodeGroupingParamsBase {\n  /**\n   * Full names of classes, which should be used to group the node. Only has effect if the node\n   * represents an instance of that class.\n   *\n   * Full class name format: `SchemaName.ClassName`.\n   */\n  fullClassNames: string[];\n}\n\n/**\n * A data structure that represents properties grouping.\n * @public\n */\nexport interface HierarchyNodePropertiesGroupingParams extends HierarchyNodeGroupingParamsBase {\n  /**\n   * Full name of a class whose properties are used to group the node. Only has effect if the node\n   * represents an instance of that class.\n   *\n   * Full class name format: `SchemaName.ClassName`.\n   */\n  propertiesClassName: string;\n  /**\n   * Property grouping option that determines whether to group nodes whose grouping value is not set or is set to an empty string.\n   *\n   * Label of the created grouping node will be `Not Specified`.\n   */\n  createGroupForUnspecifiedValues?: boolean;\n  /**\n   * Property grouping option that determines whether to group nodes whose grouping value doesn't fit within any of the provided\n   * ranges, or is not a numeric value.\n   *\n   * Label of the created grouping node will be `Other`.\n   */\n  createGroupForOutOfRangeValues?: boolean;\n  /**\n   * Properties of the specified class, by which the nodes should be grouped. Each provided group definition results in a\n   * grouping hierarchy level.\n   *\n   * Example usage:\n   * ```ts\n   * propertyGroups: [\n   *   {\n   *     propertyName: \"type\",\n   *     propertyValue: \"Wall\"\n   *   },\n   *   {\n   *     propertyName: \"length\",\n   *     propertyValue: 15,\n   *     ranges: [\n   *       { fromValue: 1, toValue: 10, rangeLabel: \"Small\" },\n   *       { fromValue: 11, toValue: 20, rangeLabel: \"Medium\" }\n   *     ]\n   *   },\n   * ]\n   * ```\n   */\n  propertyGroups: HierarchyNodePropertyGroup[];\n}\n\n/**\n * A data structure that represents specific properties' grouping params.\n * @public\n */\nexport interface HierarchyNodePropertyGroup {\n  /** A string indicating the name of the property to group by. */\n  propertyName: string;\n  /**  Value of the property, which will be used to group the node. */\n  propertyValue?: PrimitiveValue | ConcatenatedValue;\n  /** Ranges are used to group nodes by numeric properties which are within specified bounds. */\n  ranges?: HierarchyNodePropertyValueRange[];\n}\n\n/**\n * A data structure that represents boundaries for a value.\n * @public\n */\nexport interface HierarchyNodePropertyValueRange {\n  /** Defines the lower bound of the range. */\n  fromValue: number;\n  /** Defines the upper bound of the range. */\n  toValue: number;\n  /** Defines the range label. Will be used as `PropertyValueRangeGroupingNode` node's display label. */\n  rangeLabel?: string;\n}\n\n/**\n * Processing parameters that apply to instance nodes.\n * @public\n */\nexport interface InstanceHierarchyNodeProcessingParams extends HierarchyNodeProcessingParamsBase {\n  grouping?: HierarchyNodeGroupingParams;\n}\n\n/**\n * A generic (not based on data in an iModel) node that has processing parameters.\n * @public\n */\nexport type ProcessedGenericHierarchyNode = Omit<NonGroupingHierarchyNode, \"key\" | \"children\"> & {\n  key: GenericNodeKey;\n  children?: boolean;\n  processingParams?: HierarchyNodeProcessingParamsBase;\n};\n\n/**\n * An instances' (based on data in an iModel) node that has processing parameters.\n * @public\n */\nexport type ProcessedInstanceHierarchyNode = Omit<NonGroupingHierarchyNode, \"key\" | \"children\"> & {\n  key: InstancesNodeKey;\n  children?: boolean;\n  processingParams?: InstanceHierarchyNodeProcessingParams;\n};\n\n/**\n * A grouping node that groups either instance nodes or other grouping nodes.\n * @public\n */\nexport type ProcessedGroupingHierarchyNode = Omit<GroupingHierarchyNode, \"children\"> & {\n  children: Array<ProcessedGroupingHierarchyNode | ProcessedInstanceHierarchyNode>;\n};\n\n/**\n * A `HierarchyNode` that may have processing parameters defining whether it should be hidden under some conditions,\n * how it should be grouped, sorted, etc.\n *\n * Type guards under `HierarchyNode` namespace can be used to differentiate between different sub-types of\n * `ProcessedHierarchyNode`.\n *\n * @public\n */\nexport type ProcessedHierarchyNode = ProcessedGenericHierarchyNode | ProcessedInstanceHierarchyNode | ProcessedGroupingHierarchyNode;\n\n/** @public */\n// eslint-disable-next-line @typescript-eslint/no-redeclare\nexport namespace ProcessedHierarchyNode {\n  /** Checks whether the given node is a generic node */\n  export function isGeneric(node: ProcessedHierarchyNode): node is ProcessedGenericHierarchyNode {\n    return HierarchyNodeKey.isGeneric(node.key);\n  }\n  /** Checks whether the given node is an ECInstances-based node */\n  export function isInstancesNode(node: ProcessedHierarchyNode): node is ProcessedInstanceHierarchyNode {\n    return HierarchyNodeKey.isInstances(node.key);\n  }\n  /** Checks whether the given node is a grouping node */\n  export function isGroupingNode(node: ProcessedHierarchyNode): node is ProcessedGroupingHierarchyNode {\n    return HierarchyNodeKey.isGrouping(node.key);\n  }\n}\n\n/**\n * A `ProcessedHierarchyNode` that has an unformatted label in a form of `ConcatenatedValue`. Generally this is\n * returned by hierarchy definitions as a generic node or when the node is just parsed from query results.\n * @public\n */\nexport type SourceHierarchyNode<TBase = SourceGenericHierarchyNode | SourceInstanceHierarchyNode> = OmitOverUnion<TBase, \"label\" | \"parentKeys\"> & {\n  label: string | ConcatenatedValue;\n};\n\n/**\n * A kind of `ProcessedGenericHierarchyNode` that has unformatted label and doesn't know about its ancestors.\n * @public\n */\nexport type SourceGenericHierarchyNode = SourceHierarchyNode<Omit<ProcessedGenericHierarchyNode, \"key\"> & { key: string }>;\n\n/**\n * A kind of `ProcessedInstanceHierarchyNode` that has unformatted label and doesn't know about its ancestors.\n * @public\n */\nexport type SourceInstanceHierarchyNode = SourceHierarchyNode<\n  Omit<ProcessedInstanceHierarchyNode, \"key\"> & {\n    key: Omit<InstancesNodeKey, \"instanceKeys\"> & { instanceKeys: InstanceKey[] };\n  }\n>;\n"]}

package/lib/esm/hierarchies/imodel/IModelHierarchyProvider.d.ts

@@ -1,80 +0,0 @@
-import "../internal/DisposePolyfill.js";
-import { ECClassHierarchyInspector, ECSchemaProvider, Event, IPrimitiveValueFormatter } from "@itwin/presentation-shared";
-import { HierarchyFilteringPath } from "../HierarchyFiltering.js";
-import { HierarchyProvider } from "../HierarchyProvider.js";
-import { HierarchyDefinition } from "./IModelHierarchyDefinition.js";
-import { LimitingECSqlQueryExecutor } from "./LimitingECSqlQueryExecutor.js";
-/**
- * Defines the strings used by hierarchy provider.
- * @public
- */
-interface IModelHierarchyProviderLocalizedStrings {
-    /**
-     * A string for "Unspecified". Used for labels of property grouping nodes
-     * that group by an empty value.
-     */
-    unspecified: string;
-    /**
-     * A string for "Other". Used for label of a range property grouping node that
-     * groups values which don't fit into any other range.
-     */
-    other: string;
-}
-/** @public */
-type IModelAccess = ECSchemaProvider & LimitingECSqlQueryExecutor & ECClassHierarchyInspector & {
-    imodelKey: string;
-};
-/**
- * Props for `createIModelHierarchyProvider`.
- * @public
- */
-interface IModelHierarchyProviderProps {
-    /**
-     * An object that provides access to iModel's data and metadata.
-     *
-     * @see `ECSchemaProvider`
-     * @see `LimitingECSqlQueryExecutor`
-     * @see `ECClassHierarchyInspector`
-     */
-    imodelAccess: IModelAccess;
-    /** An event that is raised when iModel data, that may affect the hierarchy, changes. */
-    imodelChanged?: Event<() => void>;
-    /**
-     * A function that returns a hierarchy definition, describing how the hierarchy that the provider should be create. The
-     * function is called once during the provider's construction.
-     */
-    hierarchyDefinition: HierarchyDefinition;
-    /** Maximum number of queries that the provider attempts to execute in parallel. Defaults to `10`. */
-    queryConcurrency?: number;
-    /**
-     * The amount of queries whose results are stored in-memory for quick retrieval. Defaults to `1`,
-     * which means only results of the last run query are cached.
-     */
-    queryCacheSize?: number;
-    /** A set of localized strings to use. Defaults to English strings. */
-    localizedStrings?: Partial<IModelHierarchyProviderLocalizedStrings>;
-    /**
-     * A values formatter for formatting node labels. Defaults to the
-     * result of `createDefaultValueFormatter` called with default parameters. May be overridden
-     * by calling `setFormatter` on the provider instance.
-     */
-    formatter?: IPrimitiveValueFormatter;
-    /** Props for filtering the hierarchy. */
-    filtering?: {
-        /** A list of node identifiers from root to target node. */
-        paths: HierarchyFilteringPath[];
-    };
-}
-/**
- * Creates an instance of `HierarchyProvider` that creates a hierarchy based on given iModel and
- * a hierarchy definition, which defines each hierarchy level through ECSQL queries.
- *
- * @public
- */
-export declare function createIModelHierarchyProvider(props: IModelHierarchyProviderProps): HierarchyProvider & {
-    /** @deprecated in 1.4. Use `[Symbol.dispose]` instead. */
-    dispose: () => void;
-    [Symbol.dispose]: () => void;
-};
-export {};
-//# sourceMappingURL=IModelHierarchyProvider.d.ts.map

package/lib/esm/hierarchies/imodel/IModelHierarchyProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IModelHierarchyProvider.d.ts","sourceRoot":"","sources":["../../../../src/hierarchies/imodel/IModelHierarchyProvider.ts"],"names":[],"mappings":"AAKA,OAAO,gCAAgC,CAAC;AAuBxC,OAAO,EAGL,yBAAyB,EACzB,gBAAgB,EAGhB,KAAK,EAIL,wBAAwB,EAEzB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,OAAO,EAA0B,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAkBpF,OAAO,EAA6B,mBAAmB,EAA4B,MAAM,gCAAgC,CAAC;AAE1H,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAe7E;;;GAGG;AACH,UAAU,uCAAuC;IAC/C;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,cAAc;AACd,KAAK,YAAY,GAAG,gBAAgB,GAAG,0BAA0B,GAAG,yBAAyB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtH;;;GAGG;AACH,UAAU,4BAA4B;IACpC;;;;;;OAMG;IACH,YAAY,EAAE,YAAY,CAAC;IAE3B,wFAAwF;IACxF,aAAa,CAAC,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAElC;;;OAGG;IACH,mBAAmB,EAAE,mBAAmB,CAAC;IAEzC,qGAAqG;IACrG,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,sEAAsE;IACtE,gBAAgB,CAAC,EAAE,OAAO,CAAC,uCAAuC,CAAC,CAAC;IAEpE;;;;OAIG;IACH,SAAS,CAAC,EAAE,wBAAwB,CAAC;IACrC,yCAAyC;IACzC,SAAS,CAAC,EAAE;QACV,2DAA2D;QAC3D,KAAK,EAAE,sBAAsB,EAAE,CAAC;KACjC,CAAC;CACH;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,4BAA4B,GAAG,iBAAiB,GAAG;IACtG,0DAA0D;IAC1D,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CAC9B,CAEA"}

package/lib/esm/hierarchies/imodel/IModelHierarchyProvider.js

@@ -1,446 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
- * See LICENSE.md in the project root for license terms and full copyright notice.
- *--------------------------------------------------------------------------------------------*/
-import "../internal/DisposePolyfill.js";
-import { catchError, concat, defaultIfEmpty, EMPTY, filter, finalize, from, identity, map, merge, mergeAll, mergeMap, of, Subject, take, takeUntil, tap, } from "rxjs";
-import { assert, BeEvent, Guid, StopWatch } from "@itwin/core-bentley";
-import { createDefaultValueFormatter, formatConcatenatedValue, normalizeFullClassName, } from "@itwin/presentation-shared";
-import { RowsLimitExceededError } from "../HierarchyErrors.js";
-import { HierarchyNode } from "../HierarchyNode.js";
-import { HierarchyNodeKey } from "../HierarchyNodeKey.js";
-import { LOGGING_NAMESPACE as BASE_LOGGING_NAMESPACE, LOGGING_NAMESPACE_INTERNAL as BASE_LOGGING_NAMESPACE_INTERNAL, LOGGING_NAMESPACE_PERFORMANCE as BASE_LOGGING_NAMESPACE_PERFORMANCE, createNodeIdentifierForLogging, hasChildren, } from "../internal/Common.js";
-import { eachValueFrom } from "../internal/EachValueFrom.js";
-import { doLog, log } from "../internal/LoggingUtils.js";
-import { partition } from "../internal/operators/Partition.js";
-import { reduceToMergeMapList } from "../internal/operators/ReduceToMergeMap.js";
-import { shareReplayWithErrors } from "../internal/operators/ShareReplayWithErrors.js";
-import { sortNodesByLabelOperator } from "../internal/operators/Sorting.js";
-import { getRxjsHierarchyDefinition } from "../internal/RxjsHierarchyDefinition.js";
-import { SubscriptionScheduler } from "../internal/SubscriptionScheduler.js";
-import { FilteringHierarchyDefinition } from "./FilteringHierarchyDefinition.js";
-import { HierarchyCache } from "./HierarchyCache.js";
-import { HierarchyNodesDefinition } from "./IModelHierarchyDefinition.js";
-import { NodeSelectClauseColumnNames } from "./NodeSelectQueryFactory.js";
-import { createDetermineChildrenOperator } from "./operators/DetermineChildren.js";
-import { createGroupingOperator } from "./operators/Grouping.js";
-import { createHideIfNoChildrenOperator } from "./operators/HideIfNoChildren.js";
-import { createHideNodesInHierarchyOperator } from "./operators/HideNodesInHierarchy.js";
-import { readNodes } from "./TreeNodesReader.js";
-const LOGGING_NAMESPACE = `${BASE_LOGGING_NAMESPACE}.IModelHierarchyProvider`;
-const LOGGING_NAMESPACE_INTERNAL = `${BASE_LOGGING_NAMESPACE_INTERNAL}.IModelHierarchyProvider`;
-const LOGGING_NAMESPACE_PERFORMANCE = `${BASE_LOGGING_NAMESPACE_PERFORMANCE}.IModelHierarchyProvider`;
-const DEFAULT_QUERY_CONCURRENCY = 10;
-const DEFAULT_QUERY_CACHE_SIZE = 1;
-/**
- * Creates an instance of `HierarchyProvider` that creates a hierarchy based on given iModel and
- * a hierarchy definition, which defines each hierarchy level through ECSQL queries.
- *
- * @public
- */
-export function createIModelHierarchyProvider(props) {
-    return new IModelHierarchyProviderImpl(props);
-}
-class IModelHierarchyProviderImpl {
-    _imodelAccess;
-    _hierarchyChanged;
-    _valuesFormatter;
-    _sourceHierarchyDefinition;
-    _activeHierarchyDefinition;
-    _localizedStrings;
-    _queryScheduler;
-    _nodesCache;
-    _unsubscribe;
-    _dispose = new Subject();
-    constructor(props) {
-        this._imodelAccess = props.imodelAccess;
-        this._hierarchyChanged = new BeEvent();
-        this._activeHierarchyDefinition = this._sourceHierarchyDefinition = getRxjsHierarchyDefinition(props.hierarchyDefinition);
-        this._valuesFormatter = props?.formatter ?? createDefaultValueFormatter();
-        this._localizedStrings = { other: "Other", unspecified: "Not specified", ...props?.localizedStrings };
-        this._queryScheduler = new SubscriptionScheduler(props.queryConcurrency ?? DEFAULT_QUERY_CONCURRENCY);
-        this.setHierarchyFilter(props.filtering);
-        const queryCacheSize = props.queryCacheSize ?? DEFAULT_QUERY_CACHE_SIZE;
-        if (queryCacheSize !== 0) {
-            this._nodesCache = new HierarchyCache({
-                // we divide the size by 2, because each variation also counts as a query that we cache
-                size: Math.ceil(queryCacheSize / 2),
-                variationsCount: 1,
-            });
-        }
-        this._unsubscribe = props.imodelChanged?.addListener(() => {
-            this.invalidateHierarchyCache("Data source changed");
-            this._dispose.next();
-            this._hierarchyChanged.raiseEvent();
-        });
-    }
-    [Symbol.dispose]() {
-        this._dispose.next();
-        this._unsubscribe?.();
-    }
-    /* c8 ignore next 3 */
-    dispose() {
-        this[Symbol.dispose]();
-    }
-    get hierarchyChanged() {
-        return this._hierarchyChanged;
-    }
-    invalidateHierarchyCache(reason) {
-        doLog({
-            category: `${LOGGING_NAMESPACE}.Events`,
-            message: /* c8 ignore next */ () => (reason ? `${reason}: clear hierarchy cache` : `Clear hierarchy cache`),
-        });
-        this._nodesCache?.clear();
-    }
-    /**
-     * Sets `HierarchyProvider` values formatter that formats nodes' labels. If provided `undefined`, then defaults to the
-     * result of `createDefaultValueFormatter` called with default parameters.
-     */
-    setFormatter(formatter) {
-        this._valuesFormatter = formatter ?? createDefaultValueFormatter();
-        this._hierarchyChanged.raiseEvent({ formatterChange: { newFormatter: this._valuesFormatter } });
-    }
-    setHierarchyFilter(props) {
-        if (!props) {
-            if (this._sourceHierarchyDefinition !== this._activeHierarchyDefinition) {
-                this._activeHierarchyDefinition = this._sourceHierarchyDefinition;
-                this.invalidateHierarchyCache("Hierarchy filter reset");
-            }
-            this._hierarchyChanged.raiseEvent({ filterChange: { newFilter: undefined } });
-            return;
-        }
-        this._activeHierarchyDefinition = new FilteringHierarchyDefinition({
-            imodelAccess: this._imodelAccess,
-            source: this._sourceHierarchyDefinition,
-            nodeIdentifierPaths: props.paths,
-        });
-        this.invalidateHierarchyCache("Hierarchy filter set");
-        this._dispose.next();
-        this._hierarchyChanged.raiseEvent({ filterChange: { newFilter: props } });
-    }
-    onGroupingNodeCreated(groupingNode, props) {
-        this._nodesCache?.set({ ...props, parentNode: groupingNode }, { observable: from(groupingNode.children), processingStatus: "pre-processed" });
-    }
-    createHierarchyLevelDefinitionsObservable(props) {
-        const { requestContext, ...defineHierarchyLevelProps } = props;
-        doLog({
-            category: LOGGING_NAMESPACE_PERFORMANCE,
-            message: /* c8 ignore next */ () => `[${requestContext.requestId}] Requesting hierarchy level definitions for ${createNodeIdentifierForLogging(props.parentNode)}`,
-        });
-        let parentNode = props.parentNode;
-        if (parentNode && HierarchyNode.isGeneric(parentNode) && parentNode.key.source && parentNode.key.source !== this._imodelAccess.imodelKey) {
-            return EMPTY;
-        }
-        if (parentNode && HierarchyNode.isInstancesNode(parentNode)) {
-            parentNode = {
-                ...parentNode,
-                key: {
-                    ...parentNode.key,
-                    instanceKeys: parentNode.key.instanceKeys.filter((ik) => !ik.imodelKey || ik.imodelKey === this._imodelAccess.imodelKey),
-                },
-            };
-            assert(HierarchyNodeKey.isInstances(parentNode.key));
-            if (parentNode.key.instanceKeys.length === 0) {
-                return EMPTY;
-            }
-        }
-        return this._activeHierarchyDefinition.defineHierarchyLevel({ ...defineHierarchyLevelProps, parentNode }).pipe(mergeAll(), finalize(() => doLog({
-            category: LOGGING_NAMESPACE_PERFORMANCE,
-            message: /* c8 ignore next */ () => `[${requestContext.requestId}] Received all hierarchy level definitions for ${createNodeIdentifierForLogging(props.parentNode)}`,
-        })));
-    }
-    createSourceNodesObservable(props) {
-        // pipe definitions to nodes and put "share replay" on it
-        return this.createHierarchyLevelDefinitionsObservable(props).pipe(mergeMap((def) => {
-            if (HierarchyNodesDefinition.isGenericNode(def)) {
-                return of({ ...def.node, key: { type: "generic", id: def.node.key, source: this._imodelAccess.imodelKey } });
-            }
-            return this._queryScheduler.scheduleSubscription(of(def.query).pipe(map((query) => filterQueryByInstanceKeys(query, props.filteredInstanceKeys)), mergeMap((query) => readNodes({
-                queryExecutor: this._imodelAccess,
-                query,
-                limit: props.hierarchyLevelSizeLimit,
-                parser: this._activeHierarchyDefinition.parseNode ? (row) => this._activeHierarchyDefinition.parseNode(row, props.parentNode) : undefined,
-            })), map((node) => ({
-                ...node,
-                key: { ...node.key, instanceKeys: node.key.instanceKeys.map((key) => ({ ...key, imodelKey: this._imodelAccess.imodelKey })) },
-            }))));
-        }), finalize(() => doLog({
-            category: LOGGING_NAMESPACE_PERFORMANCE,
-            message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Read all child nodes ${createNodeIdentifierForLogging(props.parentNode)}`,
-        })), shareReplayWithErrors());
-    }
-    createPreProcessedNodesObservable(queryNodesObservable, props) {
-        return queryNodesObservable.pipe(
-        // we're going to be mutating the nodes, but don't want to mutate the original one, so just clone it here once
-        map((node) => ({ ...node })), 
-        // set parent node keys on the source node
-        map((node) => Object.assign(node, { parentKeys: createParentNodeKeysList(props.parentNode) })), 
-        // format `ConcatenatedValue` labels into string labels
-        mergeMap((node) => applyLabelsFormatting(node, this._valuesFormatter)), 
-        // we have `ProcessedHierarchyNode` from here
-        preProcessNodes(this._activeHierarchyDefinition), 
-        // process hiding
-        createHideIfNoChildrenOperator((n) => this.getChildNodesObservables({ parentNode: n, requestContext: props.requestContext }).hasNodes), createHideNodesInHierarchyOperator(
-        // note: for child nodes created because of hidden parent, we want to use parent's request props (instance filter, limit)
-        (n) => this.getChildNodesObservables({ ...props, parentNode: n }).processedNodes, false), finalize(() => doLog({
-            category: LOGGING_NAMESPACE_PERFORMANCE,
-            message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Finished pre-processing child nodes for ${createNodeIdentifierForLogging(props.parentNode)}`,
-        })));
-    }
-    createProcessedNodesObservable(preprocessedNodesObservable, props) {
-        return preprocessedNodesObservable.pipe(createGroupingOperator(this._imodelAccess, props.parentNode, this._valuesFormatter, this._localizedStrings, undefined, (gn) => this.onGroupingNodeCreated(gn, props)), finalize(() => doLog({
-            category: LOGGING_NAMESPACE_PERFORMANCE,
-            message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Finished grouping child nodes for ${createNodeIdentifierForLogging(props.parentNode)}`,
-        })));
-    }
-    createFinalizedNodesObservable(processedNodesObservable, props) {
-        return processedNodesObservable.pipe(createDetermineChildrenOperator((n) => this.getChildNodesObservables({ parentNode: n, requestContext: props.requestContext }).hasNodes), postProcessNodes(this._activeHierarchyDefinition), sortNodesByLabelOperator, map((n) => {
-            if ("processingParams" in n) {
-                delete n.processingParams;
-            }
-            return Object.assign(n, {
-                children: hasChildren(n),
-            });
-        }), takeUntil(this._dispose), finalize(() => doLog({
-            category: LOGGING_NAMESPACE_PERFORMANCE,
-            message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Finished finalizing child nodes for ${createNodeIdentifierForLogging(props.parentNode)}`,
-        })));
-    }
-    createHasNodesObservable(preprocessedNodesObservable, possiblyKnownChildrenObservable, props) {
-        const loggingCategory = `${LOGGING_NAMESPACE_INTERNAL}.HasNodes`;
-        return concat((possiblyKnownChildrenObservable ?? EMPTY).pipe(filter((n) => hasChildren(n))), preprocessedNodesObservable).pipe(log({
-            category: loggingCategory,
-            message: /* c8 ignore next */ (n) => `[${props.requestContext.requestId}] Node before mapping to 'true': ${createNodeIdentifierForLogging(n)}`,
-        }), take(1), map(() => true), defaultIfEmpty(false), catchError((e) => {
-            doLog({
-                category: loggingCategory,
-                message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Error while determining children: ${e.message}`,
-            });
-            if (e instanceof RowsLimitExceededError) {
-                return of(true);
-            }
-            throw e;
-        }), log({ category: loggingCategory, message: /* c8 ignore next */ (r) => `[${props.requestContext.requestId}] Result: ${r}` }));
-    }
-    getCachedObservableEntry(props) {
-        const loggingCategory = `${LOGGING_NAMESPACE}.QueryResultsCache`;
-        const { parentNode, ...restProps } = props;
-        const cached = props.ignoreCache || !this._nodesCache ? undefined : this._nodesCache.get(props);
-        if (cached) {
-            doLog({
-                category: loggingCategory,
-                message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Found query nodes observable for ${createNodeIdentifierForLogging(parentNode)}`,
-            });
-            return cached;
-        }
-        // if we don't find an entry for a grouping node, we load its instances by getting a query and applying
-        // a filter based on grouped instance keys
-        let filteredInstanceKeys;
-        let parentNonGroupingNode;
-        if (parentNode) {
-            if (HierarchyNode.isGroupingNode(parentNode)) {
-                parentNonGroupingNode = parentNode.nonGroupingAncestor;
-                filteredInstanceKeys = parentNode.groupedInstanceKeys;
-            }
-            else {
-                // not sure why type checker doesn't pick this up
-                assert(HierarchyNode.isGeneric(parentNode) || HierarchyNode.isInstancesNode(parentNode));
-                parentNonGroupingNode = parentNode;
-            }
-        }
-        const nonGroupingNodeChildrenRequestProps = {
-            ...restProps,
-            parentNode: parentNonGroupingNode,
-            ...(filteredInstanceKeys ? { filteredInstanceKeys } : undefined),
-        };
-        const value = { observable: this.createSourceNodesObservable(nonGroupingNodeChildrenRequestProps), processingStatus: "none" };
-        this._nodesCache?.set(nonGroupingNodeChildrenRequestProps, value);
-        doLog({
-            category: loggingCategory,
-            message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Saved query nodes observable for ${createNodeIdentifierForLogging(parentNode)}`,
-        });
-        return value;
-    }
-    getChildNodesObservables(props) {
-        const entry = this.getCachedObservableEntry(props);
-        switch (entry.processingStatus) {
-            case "none": {
-                const pre = this.createPreProcessedNodesObservable(entry.observable, props);
-                const post = this.createProcessedNodesObservable(pre, props);
-                return {
-                    processedNodes: post,
-                    hasNodes: this.createHasNodesObservable(pre, entry.observable, props),
-                    finalizedNodes: this.createFinalizedNodesObservable(post, props),
-                };
-            }
-            case "pre-processed": {
-                const post = this.createProcessedNodesObservable(entry.observable, props);
-                return {
-                    processedNodes: post,
-                    hasNodes: this.createHasNodesObservable(entry.observable, undefined, props),
-                    finalizedNodes: this.createFinalizedNodesObservable(post, props),
-                };
-            }
-        }
-    }
-    /**
-     * Creates and runs a query based on provided props, then processes retrieved nodes and returns them.
-     */
-    getNodes(props) {
-        const requestContext = { requestId: Guid.createValue() };
-        const loggingCategory = `${LOGGING_NAMESPACE}.GetNodes`;
-        const timer = new StopWatch(undefined, true);
-        let error;
-        let nodesCount = 0;
-        doLog({
-            category: loggingCategory,
-            message: /* c8 ignore next */ () => `[${requestContext.requestId}] Requesting child nodes for ${createNodeIdentifierForLogging(props.parentNode)}`,
-        });
-        return eachValueFrom(this.getChildNodesObservables({ ...props, requestContext }).finalizedNodes.pipe(tap(() => ++nodesCount), catchError((e) => {
-            error = e;
-            throw e;
-        }), finalize(() => {
-            doLog({
-                category: loggingCategory,
-                message: /* c8 ignore next */ () => 
-                /* c8 ignore next 3 */ error
-                    ? `[${requestContext.requestId}] Error creating child nodes for ${createNodeIdentifierForLogging(props.parentNode)}: ${error instanceof Error ? error.message : error.toString()}`
-                    : `[${requestContext.requestId}] Returned ${nodesCount} child nodes for ${createNodeIdentifierForLogging(props.parentNode)} in ${timer.currentSeconds.toFixed(2)} s.`,
-            });
-        })));
-    }
-    getNodeInstanceKeysObs(props) {
-        const { parentNode, instanceFilter, hierarchyLevelSizeLimit = "unbounded", requestContext } = props;
-        if (parentNode && HierarchyNode.isGroupingNode(parentNode)) {
-            return from(parentNode.groupedInstanceKeys);
-        }
-        assert(!parentNode || HierarchyNode.isGeneric(parentNode) || HierarchyNode.isInstancesNode(parentNode));
-        const hierarchyLevelDefinitions = this.createHierarchyLevelDefinitionsObservable({ parentNode, instanceFilter, requestContext });
-        // split the definitions based on whether they're for generic nodes or for instance nodes
-        const [genericDefs, instanceDefs] = partition(hierarchyLevelDefinitions, HierarchyNodesDefinition.isGenericNode);
-        // query instance keys and a flag whether they should be hidden
-        const instanceKeys = instanceDefs.pipe(mergeMap((def) => this._queryScheduler.scheduleSubscription(of(def.query).pipe(mergeMap(async (query) => {
-            const ecsql = `
-                SELECT
-                  ${NodeSelectClauseColumnNames.FullClassName},
-                  ${NodeSelectClauseColumnNames.ECInstanceId},
-                  ${NodeSelectClauseColumnNames.HideNodeInHierarchy}
-                FROM (
-                  ${query.ecsql}
-                )
-              `;
-            const reader = this._imodelAccess.createQueryReader({ ...query, ecsql }, { rowFormat: "Indexes", limit: hierarchyLevelSizeLimit });
-            return from(reader).pipe(map((row) => ({
-                key: {
-                    className: normalizeFullClassName(row[0]),
-                    id: row[1],
-                    imodelKey: this._imodelAccess.imodelKey,
-                },
-                hide: !!row[2],
-            })));
-        }), mergeAll()))));
-        // split the instance keys observable based on whether they should be hidden or not
-        const [visibleNodeInstanceKeys, hiddenNodeInstanceKeys] = partition(instanceKeys, ({ hide }) => !hide);
-        // hidden items' handling:
-        // - if a generic node is hidden, we'll want to retrieve instance keys of its children, otherwise we don't care about it,
-        // - if an instance key is hidden, we want to create a merged node similar to what we do in `createHideNodesInHierarchyOperator`
-        const hiddenParentNodes = merge(genericDefs.pipe(filter((def) => !!def.node.processingParams?.hideInHierarchy), map((def) => ({
-            type: "generic",
-            id: def.node.key,
-            source: this._imodelAccess.imodelKey,
-        }))), hiddenNodeInstanceKeys.pipe(
-        // first merge all keys by class
-        reduceToMergeMapList(({ key }) => key.className, ({ key }) => key.id), 
-        // then, for each class, create an instance key
-        mergeMap((mergedMap) => [...mergedMap.entries()].map(([className, ids]) => ({
-            type: "instances",
-            instanceKeys: ids.map((id) => ({ className, id, imodelKey: this._imodelAccess.imodelKey })),
-        }))))).pipe(map((key) => ({
-            key,
-            parentKeys: [],
-            label: "",
-        })));
-        // merge visible instance keys from this level & the ones we get recursively requesting from deeper levels
-        return merge(visibleNodeInstanceKeys.pipe(map(({ key }) => key)), hiddenParentNodes.pipe(mergeMap((hiddenNode) => this.getNodeInstanceKeysObs({ parentNode: hiddenNode, requestContext })))).pipe(takeUntil(this._dispose));
-    }
-    /**
-     * Creates an iterator for all child hierarchy level instance keys, taking into account any hidden hierarchy levels
-     * that there may be under the given parent node.
-     */
-    getNodeInstanceKeys(props) {
-        const requestContext = { requestId: Guid.createValue() };
-        const loggingCategory = `${LOGGING_NAMESPACE}.GetNodeInstanceKeys`;
-        const timer = new StopWatch(undefined, true);
-        doLog({
-            category: loggingCategory,
-            message: /* c8 ignore next */ () => `[${requestContext.requestId}] Requesting keys for ${createNodeIdentifierForLogging(props.parentNode)}`,
-        });
-        let error;
-        let keysCount = 0;
-        return eachValueFrom(this.getNodeInstanceKeysObs({ ...props, requestContext }).pipe(tap(() => ++keysCount), catchError((e) => {
-            error = e;
-            throw e;
-        }), finalize(() => {
-            doLog({
-                category: loggingCategory,
-                message: /* c8 ignore next */ () => 
-                /* c8 ignore next 3 */ error
-                    ? `[${requestContext.requestId}] Error creating node instance keys for ${createNodeIdentifierForLogging(props.parentNode)}: ${error instanceof Error ? error.message : error.toString()}`
-                    : `[${requestContext.requestId}] Returned ${keysCount} instance keys for ${createNodeIdentifierForLogging(props.parentNode)} in ${timer.currentSeconds.toFixed(2)} s.`,
-            });
-        })));
-    }
-}
-function preProcessNodes(hierarchyFactory) {
-    return hierarchyFactory.preProcessNode ? processNodes(hierarchyFactory.preProcessNode) : identity;
-}
-function postProcessNodes(hierarchyFactory) {
-    return hierarchyFactory.postProcessNode ? processNodes(hierarchyFactory.postProcessNode) : identity;
-}
-function processNodes(processor) {
-    return (nodes) => nodes.pipe(mergeMap(processor));
-}
-function applyLabelsFormatting(node, valueFormatter) {
-    return from(formatConcatenatedValue({
-        value: node.label,
-        valueFormatter,
-    })).pipe(map((label) => ({
-        ...node,
-        label,
-    })));
-}
-function createParentNodeKeysList(parentNode) {
-    if (!parentNode) {
-        return [];
-    }
-    return [...parentNode.parentKeys, parentNode.key];
-}
-function filterQueryByInstanceKeys(query, filteredInstanceKeys) {
-    if (!filteredInstanceKeys || !filteredInstanceKeys.length) {
-        return query;
-    }
-    const MAX_ALLOWED_BINDINGS = 1000;
-    if (filteredInstanceKeys.length < MAX_ALLOWED_BINDINGS) {
-        return {
-            ...query,
-            ecsql: `
-        SELECT *
-        FROM (${query.ecsql}) q
-        WHERE q.ECInstanceId IN (${filteredInstanceKeys.map(() => "?").join(",")})
-      `,
-            bindings: [...(query.bindings ?? []), ...filteredInstanceKeys.map((k) => ({ type: "id", value: k.id }))],
-        };
-    }
-    /* c8 ignore start */
-    return {
-        ...query,
-        ecsql: `
-      SELECT *
-      FROM (${query.ecsql}) q
-      WHERE InVirtualSet(?, q.ECInstanceId)
-    `,
-        bindings: [...(query.bindings ?? []), { type: "idset", value: filteredInstanceKeys.map((k) => k.id) }],
-    };
-    /* c8 ignore end */
-}
-//# sourceMappingURL=IModelHierarchyProvider.js.map