@itwin/tree-widget-react 4.0.0-alpha.2 → 4.0.0-alpha.20

package/lib/esm/tree-widget-react/components/trees/classifications-tree/ClassificationsTreeComponent.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+import { useActiveIModelConnection } from "@itwin/appui-react";
+import { SchemaKey, SchemaMatchType } from "@itwin/ecschema-metadata";
+import { TreeWidget } from "../../../TreeWidget.js";
+import { SelectableTree } from "../../tree-header/SelectableTree.js";
+import { useActiveTreeWidgetViewport } from "../common/internal/UseActiveTreeWidgetViewport.js";
+import { TelemetryContextProvider } from "../common/UseTelemetryContext.js";
+import { ClassificationsTree } from "./ClassificationsTree.js";
+/**
+ * A component that renders `ClassificationsTree` with active iModel and viewport.
+ * @alpha
+ */
+export const ClassificationsTreeComponent = (props) => {
+    const iModel = useActiveIModelConnection();
+    const viewport = useActiveTreeWidgetViewport({ treeWidgetViewport: props.viewport });
+    if (!iModel || !viewport) {
+        return null;
+    }
+    return _jsx(ClassificationsTreeComponentImpl, { ...props, iModel: iModel, viewport: viewport });
+};
+/**
+ * Id of the component. May be used when a creating a `TreeDefinition`.
+ * @alpha
+ */
+ClassificationsTreeComponent.id = "classifications-tree";
+/**
+ * Label of the component. May be used when a creating a `TreeDefinition`.
+ * @alpha
+ */
+ClassificationsTreeComponent.getLabel = () => TreeWidget.translate("classificationsTree.label");
+/** @alpha */
+ClassificationsTreeComponent.isSupportedByIModel = async (imodel) => {
+    try {
+        return !!(await imodel.schemaContext.getSchemaInfo(new SchemaKey("ClassificationSystems"), SchemaMatchType.Latest));
+    }
+    catch {
+        return false;
+    }
+};
+function ClassificationsTreeComponentImpl({ iModel, viewport, onPerformanceMeasured, onFeatureUsed, filter, treeLabel, ...treeProps }) {
+    return (_jsx(TelemetryContextProvider, { componentIdentifier: ClassificationsTreeComponent.id, onFeatureUsed: onFeatureUsed, onPerformanceMeasured: onPerformanceMeasured, children: _jsx(SelectableTree, { children: _jsx(ClassificationsTree, { ...treeProps, imodel: iModel, activeView: viewport, filter: filter, treeLabel: treeLabel }) }) }));
+}
+//# sourceMappingURL=ClassificationsTreeComponent.js.map

package/lib/esm/tree-widget-react/components/trees/classifications-tree/ClassificationsTreeComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassificationsTreeComponent.js","sourceRoot":"","sources":["../../../../../../src/tree-widget-react/components/trees/classifications-tree/ClassificationsTreeComponent.tsx"],"names":[],"mappings":";AAAA;;;gGAGgG;AAEhG,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,EAAE,2BAA2B,EAAE,MAAM,mDAAmD,CAAC;AAChG,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAiC/D;;;GAGG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,KAAwC,EAAE,EAAE;IACvF,MAAM,MAAM,GAAG,yBAAyB,EAAE,CAAC;IAC3C,MAAM,QAAQ,GAAG,2BAA2B,CAAC,EAAE,kBAAkB,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IAErF,IAAI,CAAC,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,KAAC,gCAAgC,OAAK,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAI,CAAC;AAC7F,CAAC,CAAC;AAEF;;;GAGG;AACH,4BAA4B,CAAC,EAAE,GAAG,sBAAsB,CAAC;AAEzD;;;GAGG;AACH,4BAA4B,CAAC,QAAQ,GAAG,GAAG,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,2BAA2B,CAAC,CAAC;AAEhG,aAAa;AACb,4BAA4B,CAAC,mBAAmB,GAAG,KAAK,EAAE,MAAwB,EAAE,EAAE;IACpF,IAAI,CAAC;QACH,OAAO,CAAC,CAAC,CAAC,MAAM,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,IAAI,SAAS,CAAC,uBAAuB,CAAC,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;IACtH,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC;AAEF,SAAS,gCAAgC,CAAC,EACxC,MAAM,EACN,QAAQ,EACR,qBAAqB,EACrB,aAAa,EACb,MAAM,EACN,SAAS,EACT,GAAG,SAAS,EACmF;IAC/F,OAAO,CACL,KAAC,wBAAwB,IAAC,mBAAmB,EAAE,4BAA4B,CAAC,EAAE,EAAE,aAAa,EAAE,aAAa,EAAE,qBAAqB,EAAE,qBAAqB,YACxJ,KAAC,cAAc,cACb,KAAC,mBAAmB,OAAK,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,GAAI,GACnG,GACQ,CAC5B,CAAC;AACJ,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 { useActiveIModelConnection } from \"@itwin/appui-react\";\nimport { SchemaKey, SchemaMatchType } from \"@itwin/ecschema-metadata\";\nimport { TreeWidget } from \"../../../TreeWidget.js\";\nimport { SelectableTree } from \"../../tree-header/SelectableTree.js\";\nimport { useActiveTreeWidgetViewport } from \"../common/internal/UseActiveTreeWidgetViewport.js\";\nimport { TelemetryContextProvider } from \"../common/UseTelemetryContext.js\";\nimport { ClassificationsTree } from \"./ClassificationsTree.js\";\n\nimport type { IModelConnection } from \"@itwin/core-frontend\";\nimport type { TreeWidgetViewport } from \"../common/TreeWidgetViewport.js\";\nimport type { ClassificationsTreeProps } from \"./ClassificationsTree.js\";\n\n/** @alpha */\ninterface ClassificationsTreeComponentProps\n  extends Pick<\n    ClassificationsTreeProps,\n    | \"selectionStorage\"\n    | \"hierarchyLevelConfig\"\n    | \"selectionMode\"\n    | \"filter\"\n    | \"emptyTreeContent\"\n    | \"getInlineActions\"\n    | \"getMenuActions\"\n    | \"getContextMenuActions\"\n    | \"getDecorations\"\n    | \"hierarchyConfig\"\n    | \"getEditingProps\"\n    | \"treeLabel\"\n  > {\n  /**\n   * Viewport used for visibility controls.\n   *\n   * When viewport is not provided, `IModelApp.viewManager.selectedView` will be used.\n   */\n  viewport?: TreeWidgetViewport;\n  onPerformanceMeasured?: (featureId: string, duration: number) => void;\n  onFeatureUsed?: (feature: string) => void;\n}\n\n/**\n * A component that renders `ClassificationsTree` with active iModel and viewport.\n * @alpha\n */\nexport const ClassificationsTreeComponent = (props: ClassificationsTreeComponentProps) => {\n  const iModel = useActiveIModelConnection();\n  const viewport = useActiveTreeWidgetViewport({ treeWidgetViewport: props.viewport });\n\n  if (!iModel || !viewport) {\n    return null;\n  }\n\n  return <ClassificationsTreeComponentImpl {...props} iModel={iModel} viewport={viewport} />;\n};\n\n/**\n * Id of the component. May be used when a creating a `TreeDefinition`.\n * @alpha\n */\nClassificationsTreeComponent.id = \"classifications-tree\";\n\n/**\n * Label of the component. May be used when a creating a `TreeDefinition`.\n * @alpha\n */\nClassificationsTreeComponent.getLabel = () => TreeWidget.translate(\"classificationsTree.label\");\n\n/** @alpha */\nClassificationsTreeComponent.isSupportedByIModel = async (imodel: IModelConnection) => {\n  try {\n    return !!(await imodel.schemaContext.getSchemaInfo(new SchemaKey(\"ClassificationSystems\"), SchemaMatchType.Latest));\n  } catch {\n    return false;\n  }\n};\n\nfunction ClassificationsTreeComponentImpl({\n  iModel,\n  viewport,\n  onPerformanceMeasured,\n  onFeatureUsed,\n  filter,\n  treeLabel,\n  ...treeProps\n}: ClassificationsTreeComponentProps & { iModel: IModelConnection; viewport: TreeWidgetViewport }) {\n  return (\n    <TelemetryContextProvider componentIdentifier={ClassificationsTreeComponent.id} onFeatureUsed={onFeatureUsed} onPerformanceMeasured={onPerformanceMeasured}>\n      <SelectableTree>\n        <ClassificationsTree {...treeProps} imodel={iModel} activeView={viewport} filter={filter} treeLabel={treeLabel} />\n      </SelectableTree>\n    </TelemetryContextProvider>\n  );\n}\n"]}

package/lib/esm/tree-widget-react/components/trees/classifications-tree/ClassificationsTreeDefinition.d.ts

@@ -0,0 +1,45 @@
+import type { GuidString } from "@itwin/core-bentley";
+import type { DefineHierarchyLevelProps, HierarchyDefinition, HierarchyLevelDefinition, LimitingECSqlQueryExecutor } from "@itwin/presentation-hierarchies";
+import type { ECClassHierarchyInspector, ECSchemaProvider, InstanceKey } from "@itwin/presentation-shared";
+import type { NormalizedHierarchyFilteringPath } from "../common/Utils.js";
+import type { ClassificationsTreeIdsCache } from "./internal/ClassificationsTreeIdsCache.js";
+interface ClassificationsTreeDefinitionProps {
+    imodelAccess: ECSchemaProvider & ECClassHierarchyInspector & LimitingECSqlQueryExecutor & {
+        imodelKey: string;
+    };
+    getIdsCache: (imodelKey: string) => ClassificationsTreeIdsCache;
+    hierarchyConfig: ClassificationsTreeHierarchyConfiguration;
+}
+/** @alpha */
+export interface ClassificationsTreeHierarchyConfiguration {
+    /**
+     * The classifications' hierarchy starts at the root `ClassificationSystem` element. This attribute identifiers that
+     * root `ClassificationSystem`.
+     */
+    rootClassificationSystemCode: string;
+}
+interface ClassificationsTreeInstanceKeyPathsBaseProps {
+    imodelAccess: ECClassHierarchyInspector & LimitingECSqlQueryExecutor;
+    limit?: number | "unbounded";
+    idsCache: ClassificationsTreeIdsCache;
+    hierarchyConfig: ClassificationsTreeHierarchyConfiguration;
+    componentId?: GuidString;
+    abortSignal?: AbortSignal;
+}
+/** @internal */
+export interface ClassificationsTreeInstanceKeyPathsFromInstanceLabelProps extends ClassificationsTreeInstanceKeyPathsBaseProps {
+    label: string;
+}
+/** @internal */
+export interface ClassificationsTreeInstanceKeyPathsFromInstanceKeysProps extends ClassificationsTreeInstanceKeyPathsBaseProps {
+    targetItems: Array<InstanceKey>;
+}
+/** @internal */
+export declare class ClassificationsTreeDefinition implements HierarchyDefinition {
+    #private;
+    constructor(props: ClassificationsTreeDefinitionProps);
+    defineHierarchyLevel(props: DefineHierarchyLevelProps): Promise<HierarchyLevelDefinition>;
+    static createInstanceKeyPaths(props: ClassificationsTreeInstanceKeyPathsFromInstanceLabelProps | ClassificationsTreeInstanceKeyPathsFromInstanceKeysProps): Promise<NormalizedHierarchyFilteringPath[]>;
+}
+export {};
+//# sourceMappingURL=ClassificationsTreeDefinition.d.ts.map

package/lib/esm/tree-widget-react/components/trees/classifications-tree/ClassificationsTreeDefinition.js

@@ -0,0 +1,569 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+import { bufferCount, defaultIfEmpty, defer, EMPTY, firstValueFrom, from, fromEvent, identity, lastValueFrom, map, merge, mergeMap, of, reduce, takeUntil, toArray, } from "rxjs";
+import { Guid } from "@itwin/core-bentley";
+import { createNodesQueryClauseFactory, createPredicateBasedHierarchyDefinition } from "@itwin/presentation-hierarchies";
+import { createBisInstanceLabelSelectClauseFactory, ECSql, parseFullClassName } from "@itwin/presentation-shared";
+import { CLASS_NAME_Classification, CLASS_NAME_ClassificationSystem, CLASS_NAME_ClassificationTable, CLASS_NAME_Element, CLASS_NAME_ElementHasClassifications, CLASS_NAME_GeometricElement, CLASS_NAME_GeometricElement2d, CLASS_NAME_GeometricElement3d, } from "../common/internal/ClassNameDefinitions.js";
+import { getOptimalBatchSize, releaseMainThreadOnItemsCount } from "../common/internal/Utils.js";
+import { FilterLimitExceededError } from "../common/TreeErrors.js";
+const MAX_FILTERING_INSTANCE_KEY_COUNT = 100;
+/** @internal */
+export class ClassificationsTreeDefinition {
+    #impl;
+    #selectQueryFactory;
+    #nodeLabelSelectClauseFactory;
+    #props;
+    static #componentName = "ClassificationsTreeDefinition";
+    constructor(props) {
+        this.#props = props;
+        this.#nodeLabelSelectClauseFactory = createBisInstanceLabelSelectClauseFactory({ classHierarchyInspector: this.#props.imodelAccess });
+        this.#selectQueryFactory = createNodesQueryClauseFactory({
+            imodelAccess: props.imodelAccess,
+            instanceLabelSelectClauseFactory: this.#nodeLabelSelectClauseFactory,
+        });
+        this.#impl = createPredicateBasedHierarchyDefinition({
+            classHierarchyInspector: props.imodelAccess,
+            hierarchy: {
+                rootNodes: async (requestProps) => this.#createClassificationTablesQuery(requestProps),
+                childNodes: [
+                    {
+                        parentInstancesNodePredicate: CLASS_NAME_ClassificationTable,
+                        definitions: async (requestProps) => this.#createClassificationTableChildrenQuery(requestProps),
+                    },
+                    {
+                        parentInstancesNodePredicate: CLASS_NAME_Classification,
+                        definitions: async (requestProps) => this.#createClassificationChildrenQuery(requestProps),
+                    },
+                    {
+                        parentInstancesNodePredicate: CLASS_NAME_GeometricElement,
+                        definitions: async (requestProps) => this.#createGeometricElementChildrenQuery(requestProps),
+                    },
+                ],
+            },
+        });
+    }
+    async defineHierarchyLevel(props) {
+        return this.#impl.defineHierarchyLevel(props);
+    }
+    async #createClassificationTablesQuery(props) {
+        const { instanceFilter } = props;
+        const instanceFilterClauses = await this.#selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: CLASS_NAME_ClassificationTable, alias: "this" },
+        });
+        return [
+            {
+                fullClassName: CLASS_NAME_ClassificationTable,
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this.#selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: ECSql.createRawPropertyValueSelector("this", "ECClassId") },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this.#nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: CLASS_NAME_ClassificationTable,
+                            }),
+                        },
+                        hasChildren: {
+                            selector: `
+                    IFNULL((
+                      SELECT 1
+                      FROM ${CLASS_NAME_Classification} classification
+                      WHERE classification.Model.Id = this.ECInstanceId
+                      LIMIT 1
+                    ), 0)
+                  `,
+                        },
+                        extendedData: {
+                            type: "ClassificationTable",
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM
+              ${instanceFilterClauses.from} this
+            JOIN ${CLASS_NAME_ClassificationSystem} system ON system.ECInstanceId = this.Parent.Id
+            ${instanceFilterClauses.joins}
+            WHERE
+              system.CodeValue = '${this.#props.hierarchyConfig.rootClassificationSystemCode}'
+              AND NOT this.IsPrivate
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                },
+            },
+        ];
+    }
+    async #createClassificationTableChildrenQuery(props) {
+        const { parentNodeInstanceIds: classificationTableIds, instanceFilter, parentNode } = props;
+        const imodelKey = getParentNodeIModelKey(parentNode.key);
+        if (!imodelKey) {
+            return [];
+        }
+        const instanceFilterClauses = await this.#selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: CLASS_NAME_Classification, alias: "this" },
+        });
+        const classificationIds = await firstValueFrom(this.#props.getIdsCache(imodelKey).getDirectChildClassifications(classificationTableIds));
+        return classificationIds.length
+            ? [
+                {
+                    fullClassName: CLASS_NAME_Classification,
+                    query: {
+                        ecsql: `
+                SELECT
+                  ${await this.#selectQueryFactory.createSelectClause({
+                            ecClassId: { selector: ECSql.createRawPropertyValueSelector("this", "ECClassId") },
+                            ecInstanceId: { selector: "this.ECInstanceId" },
+                            nodeLabel: {
+                                selector: await this.#nodeLabelSelectClauseFactory.createSelectClause({
+                                    classAlias: "this",
+                                    className: CLASS_NAME_Classification,
+                                }),
+                            },
+                            hasChildren: {
+                                selector: createClassificationHasChildrenSelector("this"),
+                            },
+                            extendedData: {
+                                type: "Classification",
+                            },
+                            supportsFiltering: true,
+                        })}
+                FROM
+                  ${instanceFilterClauses.from} this
+                ${instanceFilterClauses.joins}
+                WHERE
+                  this.ECInstanceId IN (${classificationIds.join(",")})
+                  ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+              `,
+                    },
+                },
+            ]
+            : [];
+    }
+    async #createClassificationChildrenQuery(props) {
+        const { parentNodeInstanceIds: parentClassificationIds, instanceFilter, parentNode } = props;
+        const parentImodelKey = getParentNodeIModelKey(parentNode.key);
+        if (!parentImodelKey) {
+            return [];
+        }
+        const classificationIds = await firstValueFrom(this.#props.getIdsCache(parentImodelKey).getDirectChildClassifications(parentClassificationIds));
+        return [
+            // load child classifications
+            ...(classificationIds.length
+                ? [
+                    await (async () => {
+                        const instanceFilterClauses = await this.#selectQueryFactory.createFilterClauses({
+                            filter: instanceFilter,
+                            contentClass: { fullName: CLASS_NAME_Classification, alias: "this" },
+                        });
+                        return {
+                            fullClassName: CLASS_NAME_Classification,
+                            query: {
+                                ecsql: `
+                    SELECT
+                      ${await this.#selectQueryFactory.createSelectClause({
+                                    ecClassId: { selector: ECSql.createRawPropertyValueSelector("this", "ECClassId") },
+                                    ecInstanceId: { selector: "this.ECInstanceId" },
+                                    nodeLabel: {
+                                        selector: await this.#nodeLabelSelectClauseFactory.createSelectClause({
+                                            classAlias: "this",
+                                            className: CLASS_NAME_Classification,
+                                        }),
+                                    },
+                                    hasChildren: {
+                                        selector: createClassificationHasChildrenSelector("this"),
+                                    },
+                                    extendedData: {
+                                        type: "Classification",
+                                    },
+                                    supportsFiltering: true,
+                                })}
+                    FROM
+                      ${instanceFilterClauses.from} this
+                    ${instanceFilterClauses.joins}
+                    WHERE
+                      this.ECInstanceId IN (${classificationIds.join(",")})
+                      ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+                  `,
+                            },
+                        };
+                    })(),
+                ]
+                : []),
+            // load classification elements
+            ...(await Promise.all([CLASS_NAME_GeometricElement2d, CLASS_NAME_GeometricElement3d].map(async (elementClassName) => {
+                const instanceFilterClauses = await this.#selectQueryFactory.createFilterClauses({
+                    filter: instanceFilter,
+                    contentClass: { fullName: elementClassName, alias: "this" },
+                });
+                return {
+                    fullClassName: elementClassName,
+                    query: {
+                        ecsql: `
+                SELECT ${await this.#createElementSelectClause(elementClassName)}
+                FROM ${instanceFilterClauses.from} this
+                JOIN ${CLASS_NAME_ElementHasClassifications} ehc ON ehc.SourceECInstanceId = this.ECInstanceId
+                ${instanceFilterClauses.joins}
+                WHERE
+                  ehc.TargetECInstanceId IN (${parentClassificationIds.join(",")})
+                  AND this.Parent.Id IS NULL
+                  ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+              `,
+                    },
+                };
+            }))),
+        ];
+    }
+    async #createGeometricElementChildrenQuery({ parentNodeInstanceIds: parentElementIds, instanceFilter, }) {
+        return Promise.all([CLASS_NAME_GeometricElement2d, CLASS_NAME_GeometricElement3d].map(async (elementClassName) => {
+            const instanceFilterClauses = await this.#selectQueryFactory.createFilterClauses({
+                filter: instanceFilter,
+                contentClass: { fullName: elementClassName, alias: "this" },
+            });
+            return {
+                fullClassName: elementClassName,
+                query: {
+                    ecsql: `
+              SELECT ${await this.#createElementSelectClause(elementClassName)}
+              FROM ${instanceFilterClauses.from} this
+              ${instanceFilterClauses.joins}
+              WHERE
+                this.Parent.Id IN (${parentElementIds.join(",")})
+                ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+            `,
+                },
+            };
+        }));
+    }
+    async #createElementSelectClause(elementFullClassName) {
+        const { className: elementClassName } = parseFullClassName(elementFullClassName);
+        return this.#selectQueryFactory.createSelectClause({
+            ecClassId: { selector: "this.ECClassId" },
+            ecInstanceId: { selector: "this.ECInstanceId" },
+            nodeLabel: {
+                selector: await this.#nodeLabelSelectClauseFactory.createSelectClause({
+                    classAlias: "this",
+                    className: elementFullClassName,
+                }),
+            },
+            hasChildren: {
+                selector: `
+          IFNULL((
+            SELECT 1
+            FROM ${CLASS_NAME_Element} ce
+            WHERE ce.Parent.Id = this.ECInstanceId
+            LIMIT 1
+          ), 0)
+        `,
+            },
+            extendedData: {
+                type: elementClassName,
+                modelId: { selector: "IdToHex(this.Model.Id)" },
+                categoryId: { selector: "IdToHex(this.Category.Id)" },
+            },
+            supportsFiltering: true,
+        });
+    }
+    static async createInstanceKeyPaths(props) {
+        return lastValueFrom(defer(() => {
+            const componentInfo = { componentId: props.componentId ?? Guid.createValue(), componentName: this.#componentName };
+            if ("label" in props) {
+                const labelsFactory = createBisInstanceLabelSelectClauseFactory({ classHierarchyInspector: props.imodelAccess });
+                return createInstanceKeyPathsFromInstanceLabelObs({ ...props, ...componentInfo, labelsFactory });
+            }
+            return createInstanceKeyPathsFromTargetItemsObs({ ...props, ...componentInfo });
+        }).pipe(props.abortSignal ? takeUntil(fromEvent(props.abortSignal, "abort")) : identity, defaultIfEmpty([])));
+    }
+}
+function getParentNodeIModelKey(instanceKey) {
+    return instanceKey.instanceKeys[0]?.imodelKey;
+}
+function createClassificationHasChildrenSelector(classificationAlias) {
+    return `
+    COALESCE((
+        SELECT 1
+        FROM ${CLASS_NAME_Classification} classification
+        WHERE classification.Parent.Id = ${classificationAlias}.ECInstanceId
+        LIMIT 1
+      ), (
+        SELECT 1
+        FROM ${CLASS_NAME_ElementHasClassifications} ehc
+        WHERE ehc.TargetECInstanceId = ${classificationAlias}.ECInstanceId
+        LIMIT 1
+      ),
+      0
+    )
+  `;
+}
+function createInstanceKeyPathsFromInstanceLabelObs({ label, ...props }) {
+    const adjustedLabel = label.replace(/[%_\\]/g, "\\$&");
+    const CLASSIFICATION_TABLES_WITH_LABELS_CTE = "ClassificationTablesWithLabels";
+    const CLASSIFICATIONS_WITH_LABELS_CTE = "ClassificationsWithLabels";
+    const ELEMENTS_2D_WITH_LABELS_CTE = "Elements2dWithLabels";
+    const ELEMENTS_3D_WITH_LABELS_CTE = "Elements3dWithLabels";
+    return defer(async () => {
+        const [classificationTableLabelSelectClause, classificationLabelSelectClause, element2dLabelSelectClause, element3dLabelSelectClause] = await Promise.all([CLASS_NAME_ClassificationTable, CLASS_NAME_Classification, CLASS_NAME_GeometricElement2d, CLASS_NAME_GeometricElement3d].map(async (className) => props.labelsFactory.createSelectClause({ classAlias: "this", className })));
+        const classificationIds = await firstValueFrom(props.idsCache.getAllClassifications());
+        const ctes = [
+            `
+          ${CLASSIFICATION_TABLES_WITH_LABELS_CTE}(ClassName, ECInstanceId, DisplayLabel) AS (
+            SELECT
+              'ct',
+              this.ECInstanceId,
+              ${classificationTableLabelSelectClause}
+            FROM
+              ${CLASS_NAME_ClassificationTable} this
+            JOIN ${CLASS_NAME_ClassificationSystem} system ON system.ECInstanceId = this.Parent.Id
+            WHERE
+              system.CodeValue = '${props.hierarchyConfig.rootClassificationSystemCode}'
+              AND NOT this.IsPrivate
+          )
+        `,
+            ...(classificationIds.length > 0
+                ? [
+                    `${CLASSIFICATIONS_WITH_LABELS_CTE}(ClassName, ECInstanceId, DisplayLabel) AS (
+            SELECT
+              'c',
+              this.ECInstanceId,
+              ${classificationLabelSelectClause}
+            FROM
+              ${CLASS_NAME_Classification} this
+            WHERE
+              this.ECInstanceId IN (${classificationIds.join(",")})
+          )`,
+                    `${ELEMENTS_2D_WITH_LABELS_CTE}(ClassName, ECInstanceId, DisplayLabel) AS (
+            SELECT
+              'e2d',
+              this.ECInstanceId,
+              ${element2dLabelSelectClause}
+            FROM
+              ${CLASS_NAME_GeometricElement2d} this
+              JOIN ${CLASS_NAME_ElementHasClassifications} ehc ON ehc.SourceECInstanceId = this.ECInstanceId
+            WHERE
+              ehc.TargetECInstanceId IN (${classificationIds.join(",")})
+              AND this.Parent.Id IS NULL
+
+            UNION ALL
+
+            SELECT
+              'e2d',
+              this.ECInstanceId,
+              ${element2dLabelSelectClause}
+            FROM
+              ${CLASS_NAME_GeometricElement2d} this
+              JOIN ${ELEMENTS_2D_WITH_LABELS_CTE} pe ON pe.ECInstanceId = this.Parent.Id
+          )`,
+                    `${ELEMENTS_3D_WITH_LABELS_CTE}(ClassName, ECInstanceId, DisplayLabel) AS (
+            SELECT
+              'e3d',
+              this.ECInstanceId,
+              ${element3dLabelSelectClause}
+            FROM
+              ${CLASS_NAME_GeometricElement3d} this
+              JOIN ${CLASS_NAME_ElementHasClassifications} ehc ON ehc.SourceECInstanceId = this.ECInstanceId
+            WHERE
+              ehc.TargetECInstanceId IN (${classificationIds.join(",")})
+              AND this.Parent.Id IS NULL
+
+            UNION ALL
+
+            SELECT
+              'e3d',
+              this.ECInstanceId,
+              ${element3dLabelSelectClause}
+            FROM
+              ${CLASS_NAME_GeometricElement3d} this
+              JOIN ${ELEMENTS_3D_WITH_LABELS_CTE} pe ON pe.ECInstanceId = this.Parent.Id
+          )`,
+                ]
+                : []),
+        ];
+        const ecsql = `
+        SELECT * FROM (
+          SELECT
+            ct.ClassName AS ClassName,
+            ct.ECInstanceId AS ECInstanceId
+          FROM
+            ${CLASSIFICATION_TABLES_WITH_LABELS_CTE} ct
+          WHERE
+            ct.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
+
+          ${classificationIds.length > 0
+            ? `
+                UNION ALL
+
+                SELECT
+                  c.ClassName AS ClassName,
+                  c.ECInstanceId AS ECInstanceId
+                FROM
+                  ${CLASSIFICATIONS_WITH_LABELS_CTE} c
+                WHERE
+                  c.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
+
+                UNION ALL
+
+                SELECT
+                  e2d.ClassName AS ClassName,
+                  e2d.ECInstanceId AS ECInstanceId
+                FROM
+                  ${ELEMENTS_2D_WITH_LABELS_CTE} e2d
+                WHERE
+                  e2d.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
+
+                UNION ALL
+
+                SELECT
+                  e3d.ClassName AS ClassName,
+                  e3d.ECInstanceId AS ECInstanceId
+                FROM
+                  ${ELEMENTS_3D_WITH_LABELS_CTE} e3d
+                WHERE
+                  e3d.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
+              `
+            : ""}
+        )
+        ${props.limit === undefined ? `LIMIT ${MAX_FILTERING_INSTANCE_KEY_COUNT + 1}` : props.limit !== "unbounded" ? `LIMIT ${props.limit}` : ""}
+      `;
+        const bindings = [
+            { type: "string", value: adjustedLabel },
+            ...(classificationIds.length > 0
+                ? [
+                    { type: "string", value: adjustedLabel },
+                    { type: "string", value: adjustedLabel },
+                    { type: "string", value: adjustedLabel },
+                ]
+                : []),
+        ];
+        return { ctes, ecsql, bindings };
+    }).pipe(mergeMap((queryProps) => props.imodelAccess.createQueryReader(queryProps, { restartToken: `${props.componentName}/${props.componentId}/filter-by-label`, limit: props.limit })), map((row) => {
+        let className;
+        switch (row.ClassName) {
+            case "ct":
+                className = CLASS_NAME_ClassificationTable;
+                break;
+            case "c":
+                className = CLASS_NAME_Classification;
+                break;
+            case "e2d":
+                className = CLASS_NAME_GeometricElement2d;
+                break;
+            default:
+                className = CLASS_NAME_GeometricElement3d;
+                break;
+        }
+        return {
+            className,
+            id: row.ECInstanceId,
+        };
+    }), toArray(), mergeMap((targetKeys) => createInstanceKeyPathsFromTargetItemsObs({ ...props, targetItems: targetKeys })));
+}
+function createInstanceKeyPathsFromTargetItemsObs({ idsCache, imodelAccess, limit, componentId, targetItems, componentName, }) {
+    const actualLimit = limit ?? MAX_FILTERING_INSTANCE_KEY_COUNT;
+    if (actualLimit !== "unbounded" && targetItems.length > actualLimit) {
+        throw new FilterLimitExceededError(actualLimit);
+    }
+    return from(targetItems).pipe(releaseMainThreadOnItemsCount(2000), mergeMap(async (key) => {
+        if (await imodelAccess.classDerivesFrom(key.className, CLASS_NAME_ClassificationTable)) {
+            return { id: key.id, type: 0 };
+        }
+        if (await imodelAccess.classDerivesFrom(key.className, CLASS_NAME_Classification)) {
+            return { id: key.id, type: 1 };
+        }
+        if (await imodelAccess.classDerivesFrom(key.className, CLASS_NAME_GeometricElement2d)) {
+            return { id: key.id, type: 2 };
+        }
+        return { id: key.id, type: 3 };
+    }, 2), reduce((acc, { id, type }) => {
+        switch (type) {
+            case 0:
+                acc.classificationTableIds.push(id);
+                break;
+            case 1:
+                acc.classificationIds.push(id);
+                break;
+            case 2:
+                acc.element2dIds.push(id);
+                break;
+            case 3:
+                acc.element3dIds.push(id);
+                break;
+        }
+        return acc;
+    }, {
+        classificationTableIds: new Array(),
+        classificationIds: new Array(),
+        element2dIds: new Array(),
+        element3dIds: new Array(),
+    }), mergeMap((ids) => {
+        const elements2dLength = ids.element2dIds.length;
+        const elements3dLength = ids.element3dIds.length;
+        const getElementsPathsObs = (elementType) => from(elementType === "2d" ? ids.element2dIds : ids.element3dIds).pipe(bufferCount(getOptimalBatchSize({ totalSize: elementType === "2d" ? elements2dLength : elements3dLength, maximumBatchSize: 5000 })), releaseMainThreadOnItemsCount(1), mergeMap((block, chunkIndex) => createGeometricElementInstanceKeyPaths({ idsCache, imodelAccess, targetItems: block, type: elementType, chunkIndex, componentId, componentName }), 10));
+        return merge(from(ids.classificationTableIds).pipe(map((id) => ({ path: [{ id, className: CLASS_NAME_ClassificationTable }], options: { reveal: true } }))), idsCache.getClassificationsPathObs(ids.classificationIds).pipe(map((path) => ({ path, options: { reveal: true } }))), getElementsPathsObs("2d"), getElementsPathsObs("3d"));
+    }), toArray());
+}
+function createGeometricElementInstanceKeyPaths(props) {
+    const { targetItems, imodelAccess, type, idsCache, componentId, componentName, chunkIndex } = props;
+    if (targetItems.length === 0) {
+        return EMPTY;
+    }
+    const separator = ";";
+    return defer(() => {
+        const ctes = [
+            `ElementsHierarchy(ECInstanceId, ParentId, Path) AS (
+        SELECT
+          e.ECInstanceId,
+          e.Parent.Id,
+          'e${type}${separator}' || CAST(IdToHex([e].[ECInstanceId]) AS TEXT)
+        FROM  ${CLASS_NAME_Element} e
+        WHERE e.ECInstanceId IN (${targetItems.join(",")})
+
+        UNION ALL
+
+        SELECT
+          pe.ECInstanceId,
+          pe.Parent.Id,
+          'e${type}${separator}' || CAST(IdToHex([pe].[ECInstanceId]) AS TEXT) || '${separator}' || ce.Path
+        FROM ElementsHierarchy ce
+        JOIN ${CLASS_NAME_Element} pe ON pe.ECInstanceId = ce.ParentId
+      )`,
+        ];
+        const ecsql = `
+      SELECT
+        e.Path path,
+        c.ECInstanceId classificationId
+      FROM
+        ${CLASS_NAME_Classification} c
+        JOIN ${CLASS_NAME_ElementHasClassifications} ehc ON ehc.TargetECInstanceId = c.ECInstanceId
+        JOIN ElementsHierarchy e ON ehc.SourceECInstanceId = e.ECInstanceId
+      WHERE e.ParentId IS NULL
+    `;
+        return imodelAccess.createQueryReader({ ctes, ecsql }, { rowFormat: "ECSqlPropertyNames", limit: "unbounded", restartToken: `${componentName}/${componentId}/elements${type}-filter-paths/${chunkIndex}` });
+    }).pipe(releaseMainThreadOnItemsCount(300), map((row) => parseQueryRow(row, separator)), mergeMap(({ path, parentClassificationId }) => {
+        if (parentClassificationId) {
+            return idsCache
+                .getClassificationsPathObs(parentClassificationId)
+                .pipe(map((parentClassificationPath) => ({ path: parentClassificationPath.concat(path), options: { reveal: true } })));
+        }
+        return of({ path, options: { reveal: true } });
+    }));
+}
+function parseQueryRow(row, separator) {
+    const rowElements = row.path.split(separator);
+    const path = [];
+    for (let i = 0; i < rowElements.length; i += 2) {
+        switch (rowElements[i]) {
+            case "e2d":
+                path.push({ className: CLASS_NAME_GeometricElement2d, id: rowElements[i + 1] });
+                break;
+            case "e3d":
+                path.push({ className: CLASS_NAME_GeometricElement3d, id: rowElements[i + 1] });
+                break;
+        }
+    }
+    return { path, parentClassificationId: row.classificationId };
+}
+//# sourceMappingURL=ClassificationsTreeDefinition.js.map