@itwin/tree-widget-react 2.3.0 → 3.0.0-dev.0

package/lib/esm/components/trees/stateless/models-tree/ModelsTreeDefinition.js

@@ -0,0 +1,852 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+import { createClassBasedHierarchyDefinition, createNodesQueryClauseFactory, HierarchyNode, NodeSelectClauseColumnNames, } from "@itwin/presentation-hierarchies";
+import { createBisInstanceLabelSelectClauseFactory, ECSql } from "@itwin/presentation-shared";
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export var ModelsTreeInstanceKeyPathsProps;
+(function (ModelsTreeInstanceKeyPathsProps) {
+    function isLabelProps(props) {
+        return !!props.label;
+    }
+    ModelsTreeInstanceKeyPathsProps.isLabelProps = isLabelProps;
+})(ModelsTreeInstanceKeyPathsProps || (ModelsTreeInstanceKeyPathsProps = {}));
+export class ModelsTreeDefinition {
+    constructor(props) {
+        this._impl = createClassBasedHierarchyDefinition({
+            classHierarchyInspector: props.imodelAccess,
+            hierarchy: {
+                rootNodes: async (requestProps) => this.createRootHierarchyLevelDefinition(requestProps),
+                childNodes: [
+                    {
+                        parentNodeClassName: "BisCore.Subject",
+                        definitions: async (requestProps) => this.createSubjectChildrenQuery(requestProps),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.ISubModeledElement",
+                        definitions: async (requestProps) => this.createISubModeledElementChildrenQuery(requestProps),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.GeometricModel3d",
+                        definitions: async (requestProps) => this.createGeometricModel3dChildrenQuery(requestProps),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.SpatialCategory",
+                        definitions: async (requestProps) => this.createSpatialCategoryChildrenQuery(requestProps),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.GeometricElement3d",
+                        definitions: async (requestProps) => this.createGeometricElement3dChildrenQuery(requestProps),
+                    },
+                ],
+            },
+        });
+        this._subjectModelIdsCache = new SubjectModelIdsCache(props.imodelAccess);
+        this._selectQueryFactory = createNodesQueryClauseFactory({ imodelAccess: props.imodelAccess });
+        this._nodeLabelSelectClauseFactory = createBisInstanceLabelSelectClauseFactory({ classHierarchyInspector: props.imodelAccess });
+    }
+    async postProcessNode(node) {
+        if (HierarchyNode.isClassGroupingNode(node)) {
+            // `imageId` is assigned to instance nodes at query time, but grouping ones need to
+            // be handled during post-processing
+            // Add `modelId` and `categoryId` from the first grouped element.
+            const childExtendedData = node.children[0].extendedData;
+            return { ...node, extendedData: { ...node.extendedData, ...childExtendedData, imageId: "icon-ec-class" } };
+        }
+        return node;
+    }
+    async defineHierarchyLevel(props) {
+        return this._impl.defineHierarchyLevel(props);
+    }
+    async createRootHierarchyLevelDefinition(props) {
+        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: props.instanceFilter,
+            contentClass: { fullName: "BisCore.Subject", alias: "this" },
+        });
+        return [
+            {
+                fullClassName: "BisCore.Subject",
+                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: "BisCore.Subject",
+                            }),
+                        },
+                        extendedData: {
+                            imageId: "icon-imodel-hollow-2",
+                            isSubject: true,
+                        },
+                        autoExpand: true,
+                        supportsFiltering: true,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            ${instanceFilterClauses.joins}
+            WHERE
+              this.Parent IS NULL
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                },
+            },
+        ];
+    }
+    async createSubjectChildrenQuery({ parentNodeInstanceIds: subjectIds, instanceFilter, }) {
+        const [subjectFilterClauses, modelFilterClauses] = await Promise.all([
+            this._selectQueryFactory.createFilterClauses({
+                filter: instanceFilter,
+                contentClass: { fullName: "BisCore.Subject", alias: "this" },
+            }),
+            this._selectQueryFactory.createFilterClauses({
+                filter: instanceFilter,
+                contentClass: { fullName: "BisCore.GeometricModel3d", alias: "this" },
+            }),
+        ]);
+        const [childSubjectIds, childModelIds] = await Promise.all([
+            this._subjectModelIdsCache.getChildSubjectIds(subjectIds),
+            this._subjectModelIdsCache.getSubjectModelIds(subjectIds),
+        ]);
+        const defs = new Array();
+        childSubjectIds.length &&
+            defs.push({
+                fullClassName: "BisCore.Subject",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: "BisCore.Subject",
+                            }),
+                        },
+                        hideIfNoChildren: true,
+                        hasChildren: { selector: `InVirtualSet(?, this.ECInstanceId)` },
+                        grouping: { byLabel: { action: "merge", groupId: "subject" } },
+                        extendedData: {
+                            imageId: "icon-folder",
+                            isSubject: true,
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM ${subjectFilterClauses.from} this
+            ${subjectFilterClauses.joins}
+            WHERE
+              this.ECInstanceId IN (${childSubjectIds.map(() => "?").join(",")})
+              ${subjectFilterClauses.where ? `AND ${subjectFilterClauses.where}` : ""}
+          `,
+                    bindings: [
+                        { type: "idset", value: await this._subjectModelIdsCache.getParentSubjectIds() },
+                        ...childSubjectIds.map((id) => ({ type: "id", value: id })),
+                    ],
+                },
+            });
+        childModelIds.length &&
+            defs.push({
+                fullClassName: "BisCore.GeometricModel3d",
+                query: {
+                    ecsql: `
+            SELECT model.ECInstanceId AS ECInstanceId, model.*
+            FROM (
+              SELECT
+                ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "model.ECClassId" },
+                        ecInstanceId: { selector: "model.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "partition",
+                                className: "BisCore.InformationPartitionElement",
+                            }),
+                        },
+                        hideNodeInHierarchy: {
+                            selector: `
+                      CASE
+                        WHEN (
+                          json_extract([partition].JsonProperties, '$.PhysicalPartition.Model.Content') IS NOT NULL
+                          OR json_extract([partition].JsonProperties, '$.GraphicalPartition3d.Model.Content') IS NOT NULL
+                        ) THEN 1
+                        ELSE 0
+                      END
+                    `,
+                        },
+                        hasChildren: true,
+                        extendedData: {
+                            imageId: "icon-model",
+                            isModel: true,
+                        },
+                        supportsFiltering: true,
+                    })}
+              FROM Bis.GeometricModel3d model
+              JOIN bis.InformationPartitionElement [partition] ON [partition].ECInstanceId = model.ModeledElement.Id
+              WHERE
+                model.ECInstanceId IN (${childModelIds.map(() => "?").join(",")})
+            ) model
+            JOIN ${modelFilterClauses.from} this ON this.ECInstanceId = model.ECInstanceId
+            ${modelFilterClauses.joins}
+            ${modelFilterClauses.where ? `AND (model.${NodeSelectClauseColumnNames.HideNodeInHierarchy} OR ${modelFilterClauses.where})` : ""}
+          `,
+                    bindings: childModelIds.map((id) => ({ type: "id", value: id })),
+                },
+            });
+        return defs;
+    }
+    async createISubModeledElementChildrenQuery({ parentNodeInstanceIds: elementIds, }) {
+        // note: we do not apply hierarchy level filtering on this hierarchy level, because it's always
+        // hidden - the filter will get applied on the child hierarchy levels
+        return [
+            {
+                fullClassName: "BisCore.GeometricModel3d",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: "",
+                        hideNodeInHierarchy: true,
+                    })}
+            FROM BisCore.GeometricModel3d this
+            WHERE
+              this.ModeledElement.Id IN (${elementIds.map(() => "?").join(",")})
+              AND NOT this.IsPrivate
+              AND this.ECInstanceId IN (SELECT Model.Id FROM bis.GeometricElement3d)
+          `,
+                    bindings: [...elementIds.map((id) => ({ type: "id", value: id }))],
+                },
+            },
+        ];
+    }
+    async createGeometricModel3dChildrenQuery({ parentNodeInstanceIds: modelIds, instanceFilter, }) {
+        function createModelIdsSelector() {
+            // Note: `json_array` function only accepts up to 127 arguments and we may have more `modelIds` than that. As a workaround,
+            // we're creating an array of arrays
+            const slices = new Array();
+            for (let sliceStartIndex = 0; sliceStartIndex < modelIds.length; sliceStartIndex += 127) {
+                let sliceEndIndex = sliceStartIndex + 127;
+                if (sliceEndIndex > modelIds.length) {
+                    sliceEndIndex = undefined;
+                }
+                slices.push(modelIds.slice(sliceStartIndex, sliceEndIndex));
+            }
+            return `json_array(${slices.map((sliceIds) => `json_array(${sliceIds.map((id) => `'${id}'`).join(",")})`).join(",")})`;
+        }
+        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: "BisCore.SpatialCategory", alias: "this" },
+        });
+        return [
+            {
+                fullClassName: "BisCore.SpatialCategory",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: "BisCore.SpatialCategory",
+                            }),
+                        },
+                        grouping: { byLabel: { action: "merge", groupId: "category" } },
+                        hasChildren: true,
+                        extendedData: {
+                            imageId: "icon-layers",
+                            isCategory: true,
+                            modelIds: { selector: createModelIdsSelector() },
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            ${instanceFilterClauses.joins}
+            WHERE
+              EXISTS (
+                SELECT 1
+                FROM bis.GeometricElement3d element
+                WHERE
+                  element.Model.Id IN (${modelIds.map(() => "?").join(",")})
+                  AND element.Category.Id = +this.ECInstanceId
+                  AND element.Parent IS NULL
+              )
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                    bindings: modelIds.map((id) => ({ type: "id", value: id })),
+                },
+            },
+        ];
+    }
+    async createSpatialCategoryChildrenQuery({ parentNodeInstanceIds: categoryIds, parentNode, instanceFilter, }) {
+        const modelIds = parentNode.extendedData && parentNode.extendedData.hasOwnProperty("modelIds") && Array.isArray(parentNode.extendedData.modelIds)
+            ? parentNode.extendedData.modelIds.reduce((arr, ids) => [...arr, ...(Array.isArray(ids) ? ids : [ids])], new Array())
+            : [];
+        if (modelIds.length === 0) {
+            throw new Error(`Invalid category node "${parentNode.label}" - missing model information.`);
+        }
+        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: "BisCore.GeometricElement3d", alias: "this" },
+        });
+        return [
+            {
+                fullClassName: "BisCore.GeometricElement3d",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: "BisCore.GeometricElement3d",
+                            }),
+                        },
+                        grouping: {
+                            byClass: true,
+                        },
+                        hasChildren: {
+                            selector: `
+                    IFNULL((
+                      SELECT 1
+                      FROM (
+                        SELECT Parent.Id ParentId FROM bis.GeometricElement3d
+                        UNION ALL
+                        SELECT ModeledElement.Id ParentId FROM bis.GeometricModel3d
+                      )
+                      WHERE ParentId = this.ECInstanceId
+                      LIMIT 1
+                    ), 0)
+                  `,
+                        },
+                        extendedData: {
+                            modelId: { selector: "printf('0x%x', this.Model.Id)" },
+                            categoryId: { selector: "printf('0x%x', this.Category.Id)" },
+                            imageId: "icon-item",
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            ${instanceFilterClauses.joins}
+            WHERE
+              this.Category.Id IN (${categoryIds.map(() => "?").join(",")})
+              AND this.Model.Id IN (${modelIds.map(() => "?").join(",")})
+              AND this.Parent IS NULL
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                    bindings: [...categoryIds.map((id) => ({ type: "id", value: id })), ...modelIds.map((id) => ({ type: "id", value: id }))],
+                },
+            },
+        ];
+    }
+    async createGeometricElement3dChildrenQuery({ parentNodeInstanceIds: elementIds, instanceFilter, }) {
+        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: "BisCore.GeometricElement3d", alias: "this" },
+        });
+        return [
+            {
+                fullClassName: "BisCore.GeometricElement3d",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: "BisCore.GeometricElement3d",
+                            }),
+                        },
+                        grouping: {
+                            byClass: true,
+                        },
+                        hasChildren: {
+                            selector: `
+                    IFNULL((
+                      SELECT 1
+                      FROM (
+                        SELECT Parent.Id ParentId FROM bis.GeometricElement3d
+                        UNION ALL
+                        SELECT ModeledElement.Id ParentId FROM bis.GeometricModel3d
+                      )
+                      WHERE ParentId = this.ECInstanceId
+                      LIMIT 1
+                    ), 0)
+                  `,
+                        },
+                        extendedData: {
+                            modelId: { selector: "printf('0x%x', this.Model.Id)" },
+                            categoryId: { selector: "printf('0x%x', this.Category.Id)" },
+                            imageId: "icon-item",
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            ${instanceFilterClauses.joins}
+            WHERE
+              this.Parent.Id IN (${elementIds.map(() => "?").join(",")})
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                    bindings: elementIds.map((id) => ({ type: "id", value: id })),
+                },
+            },
+        ];
+    }
+    static async createInstanceKeyPaths(props) {
+        if (ModelsTreeInstanceKeyPathsProps.isLabelProps(props)) {
+            const labelsFactory = createBisInstanceLabelSelectClauseFactory({ classHierarchyInspector: props.imodelAccess });
+            return createInstanceKeyPathsFromInstanceLabel({ ...props, labelsFactory });
+        }
+        return createInstanceKeyPathsFromInstanceKeys(props);
+    }
+}
+class SubjectModelIdsCache {
+    constructor(_queryExecutor) {
+        this._queryExecutor = _queryExecutor;
+    }
+    async *querySubjects() {
+        const subjectsQuery = `
+      SELECT
+        ECInstanceId id,
+        Parent.Id parentId,
+        json_extract(JsonProperties, '$.Subject.Model.TargetPartition') targetPartitionId,
+        CASE
+          WHEN (
+            json_extract(JsonProperties, '$.Subject.Job.Bridge') IS NOT NULL
+            OR json_extract(JsonProperties, '$.Subject.Model.Type') = 'Hierarchy'
+          ) THEN 1
+          ELSE 0
+        END hideInHierarchy
+      FROM bis.Subject
+    `;
+        for await (const row of this._queryExecutor.createQueryReader({ ecsql: subjectsQuery }, { rowFormat: "ECSqlPropertyNames" })) {
+            yield { id: row.id, parentId: row.parentId, targetPartitionId: row.targetPartitionId, hideInHierarchy: !!row.hideInHierarchy };
+        }
+    }
+    async *queryModels() {
+        const modelsQuery = `
+      SELECT p.ECInstanceId id, p.Parent.Id parentId
+      FROM bis.InformationPartitionElement p
+      INNER JOIN bis.GeometricModel3d m ON m.ModeledElement.Id = p.ECInstanceId
+      WHERE NOT m.IsPrivate AND EXISTS (SELECT 1 FROM bis.GeometricElement3d WHERE Model.Id = m.ECInstanceId)
+    `;
+        for await (const row of this._queryExecutor.createQueryReader({ ecsql: modelsQuery }, { rowFormat: "ECSqlPropertyNames" })) {
+            yield { id: row.id, parentId: row.parentId };
+        }
+    }
+    async initSubjectModels() {
+        this._subjectsHierarchy = new Map();
+        this._subjectModels = new Map();
+        this._subjectInfos = new Map();
+        const targetPartitionSubjects = new Map();
+        await Promise.all([
+            (async () => {
+                for await (const subject of this.querySubjects()) {
+                    this._subjectInfos.set(subject.id, { hideInHierarchy: subject.hideInHierarchy });
+                    if (subject.parentId) {
+                        pushToMap(this._subjectsHierarchy, subject.parentId, subject.id);
+                    }
+                    if (subject.targetPartitionId) {
+                        pushToMap(targetPartitionSubjects, subject.targetPartitionId, subject.id);
+                    }
+                }
+            })(),
+            (async () => {
+                for await (const model of this.queryModels()) {
+                    pushToMap(targetPartitionSubjects, model.id, model.parentId);
+                }
+            })(),
+        ]);
+        for (const [partitionId, subjectIds] of targetPartitionSubjects) {
+            subjectIds.forEach((subjectId) => {
+                pushToMap(this._subjectModels, subjectId, partitionId);
+            });
+        }
+    }
+    async initCache() {
+        if (!this._init) {
+            this._init = this.initSubjectModels();
+        }
+        return this._init;
+    }
+    forEachChildSubject(parentSubjectId, cb) {
+        const childSubjectIds = this._subjectsHierarchy.get(parentSubjectId);
+        childSubjectIds &&
+            childSubjectIds.forEach((childSubjectId) => {
+                if (cb(childSubjectId) === "break") {
+                    return;
+                }
+                this.forEachChildSubject(childSubjectId, cb);
+            });
+    }
+    async getParentSubjectIds() {
+        this._parentSubjectIds ??= (async () => {
+            await this.initCache();
+            const hasChildModels = (subjectId) => {
+                if ((this._subjectModels.get(subjectId)?.size ?? 0) > 0) {
+                    return true;
+                }
+                const childSubjectIds = this._subjectsHierarchy.get(subjectId);
+                return childSubjectIds && [...childSubjectIds].some(hasChildModels);
+            };
+            const parentSubjectIds = new Set();
+            const addIfHasChildren = (subjectId) => {
+                if (hasChildModels(subjectId)) {
+                    parentSubjectIds.add(subjectId);
+                }
+            };
+            this._subjectsHierarchy.forEach((childSubjectIds, parentSubjectId) => {
+                addIfHasChildren(parentSubjectId);
+                childSubjectIds.forEach(addIfHasChildren);
+            });
+            return [...parentSubjectIds];
+        })();
+        return this._parentSubjectIds;
+    }
+    async getChildSubjectIds(parentSubjectIds) {
+        await this.initCache();
+        const childSubjectIds = new Array();
+        parentSubjectIds.forEach((subjectId) => {
+            this.forEachChildSubject(subjectId, (childSubjectId) => {
+                const { hideInHierarchy } = this._subjectInfos.get(childSubjectId);
+                if (!hideInHierarchy) {
+                    childSubjectIds.push(childSubjectId);
+                    return "break";
+                }
+                return "continue";
+            });
+        });
+        return childSubjectIds;
+    }
+    async getSubjectModelIds(parentSubjectIds) {
+        await this.initCache();
+        const hiddenSubjectIds = new Array();
+        parentSubjectIds.forEach((subjectId) => {
+            this.forEachChildSubject(subjectId, (childSubjectId) => {
+                const { hideInHierarchy } = this._subjectInfos.get(childSubjectId);
+                if (hideInHierarchy) {
+                    hiddenSubjectIds.push(childSubjectId);
+                    return "continue";
+                }
+                return "break";
+            });
+        });
+        const modelIds = new Array();
+        [...parentSubjectIds, ...hiddenSubjectIds].forEach((subjectId) => {
+            const subjectModelIds = this._subjectModels.get(subjectId);
+            subjectModelIds && modelIds.push(...subjectModelIds);
+        });
+        return modelIds;
+    }
+}
+function pushToMap(map, key, value) {
+    let list = map.get(key);
+    if (!list) {
+        list = new Set();
+        map.set(key, list);
+    }
+    list.add(value);
+}
+function createECInstanceKeySelectClause(props) {
+    const classIdSelector = props.classIdSelector ?? `[${props.classIdAlias ?? props.alias}].[ECClassId]`;
+    const instanceHexIdSelector = props.instanceHexIdSelector ?? `printf('0x%x', [${props.instanceIdAlias ?? props.alias}].[ECInstanceId])`;
+    return `json_object('className', ec_classname(${classIdSelector}, 's.c'), 'id', ${instanceHexIdSelector})`;
+}
+async function createSubjectModelsInstanceKeysPathsCTEs(labelsFactory) {
+    return [
+        `Models(ECClassId, ECInstanceId, HexId, ModeledElementParentId, Label) AS (
+      SELECT
+        m.ECClassId,
+        m.ECInstanceId,
+        printf('0x%x', m.ECInstanceId) HexId,
+        p.Parent.Id,
+        ${await labelsFactory.createSelectClause({
+            classAlias: "p",
+            className: "BisCore.Element",
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            selectorsConcatenator: ECSql.createConcatenatedValueStringSelector,
+        })}
+      FROM bis.GeometricModel3d m
+      JOIN bis.Element p on p.ECInstanceId = m.ModeledElement.Id
+    )`,
+        `SubjectsHierarchy(TargetId, TargetLabel, ECClassId, ECInstanceId, ParentId, JsonProperties, Path) AS (
+      SELECT
+        s.ECInstanceId,
+        ${await labelsFactory.createSelectClause({
+            classAlias: "s",
+            className: "BisCore.Subject",
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            selectorsConcatenator: ECSql.createConcatenatedValueStringSelector,
+        })},
+        s.ECClassId,
+        s.ECInstanceId,
+        s.Parent.Id,
+        s.JsonProperties,
+        CASE
+          WHEN (
+            json_extract(s.JsonProperties, '$.Subject.Job.Bridge') IS NOT NULL
+            OR json_extract(s.JsonProperties, '$.Subject.Model.Type') = 'Hierarchy'
+          )
+          THEN
+            json_array()
+          ELSE
+            json_array(${createECInstanceKeySelectClause({ alias: "s" })})
+        END
+      FROM bis.Subject s
+      UNION ALL
+      SELECT
+        c.TargetId,
+        c.TargetLabel,
+        p.ECClassId,
+        p.ECInstanceId,
+        p.Parent.Id,
+        p.JsonProperties,
+        CASE
+          WHEN (
+            json_extract(p.JsonProperties, '$.Subject.Job.Bridge') IS NOT NULL
+            OR json_extract(p.JsonProperties, '$.Subject.Model.Type') = 'Hierarchy'
+          )
+          THEN
+            c.Path
+          ELSE
+            json_insert(c.Path, '$[#]', ${createECInstanceKeySelectClause({ alias: "p" })})
+        END
+      FROM SubjectsHierarchy c
+      JOIN bis.Element p on p.ECInstanceId = c.ParentId
+    )`,
+        `Subjects(TargetId, TargetLabel, ECClassId, ECInstanceId, JsonProperties, Path) AS (
+      SELECT s.TargetId, s.TargetLabel, s.ECClassId, s.ECInstanceId, s.JsonProperties, s.Path
+      FROM SubjectsHierarchy s
+      WHERE s.ParentId IS NULL
+    )`,
+    ];
+}
+async function createInstanceKeyPathsCTEs(labelsFactory) {
+    return [
+        `GeometricElementsHierarchy(TargetId, TargetLabel, ECClassId, ECInstanceId, ParentId, ModelId, CategoryId, Path) AS (
+      SELECT
+        e.ECInstanceId,
+        ${await labelsFactory.createSelectClause({
+            classAlias: "e",
+            className: "BisCore.GeometricElement3d",
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            selectorsConcatenator: ECSql.createConcatenatedValueStringSelector,
+        })},
+        e.ECClassId,
+        e.ECInstanceId,
+        e.Parent.Id,
+        e.Model.Id,
+        e.Category.Id,
+        json_array(${createECInstanceKeySelectClause({ alias: "e" })})
+      FROM bis.GeometricElement3d e
+      UNION ALL
+      SELECT
+        c.TargetId,
+        c.TargetLabel,
+        p.ECClassId,
+        p.ECInstanceId,
+        p.Parent.Id,
+        p.Model.Id,
+        p.Category.Id,
+        json_insert(c.Path, '$[#]', ${createECInstanceKeySelectClause({ alias: "p" })})
+      FROM GeometricElementsHierarchy c
+      JOIN bis.GeometricElement3d p on p.ECInstanceId = c.ParentId
+    )`,
+        `GeometricElements(TargetId, TargetLabel, ECClassId, ECInstanceId, ModelId, CategoryId, Path) AS (
+      SELECT e.TargetId, e.TargetLabel, e.ECClassId, e.ECInstanceId, e.ModelId, e.CategoryId, e.Path
+      FROM GeometricElementsHierarchy e
+      WHERE e.ParentId IS NULL
+    )`,
+        `Categories(ECClassId, ECInstanceId, HexId, Label) AS (
+      SELECT
+        c.ECClassId,
+        c.ECInstanceId,
+        printf('0x%x', c.ECInstanceId) HexId,
+        ${await labelsFactory.createSelectClause({
+            classAlias: "c",
+            className: "BisCore.SpatialCategory",
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            selectorsConcatenator: ECSql.createConcatenatedValueStringSelector,
+        })}
+      FROM bis.SpatialCategory c
+    )`,
+        `ModelsCategoriesElementsHierarchy(TargetElementId, TargetElementLabel, ModelId, ModelHexId, ModelParentId, Path) AS (
+      SELECT
+        e.TargetId,
+        e.TargetLabel,
+        m.ECInstanceId,
+        m.HexId,
+        m.ModeledElementParentId,
+        json_insert(
+          e.Path,
+          '$[#]', ${createECInstanceKeySelectClause({
+            classIdAlias: "c",
+            instanceHexIdSelector: "c.HexId",
+        })},
+          '$[#]', ${createECInstanceKeySelectClause({
+            classIdAlias: "m",
+            instanceHexIdSelector: "m.HexId",
+        })}
+        )
+      FROM GeometricElements e
+      JOIN Categories c ON c.ECInstanceId = e.CategoryId
+      JOIN Models m ON m.ECInstanceId = e.ModelId
+      UNION ALL
+      SELECT
+        mce.TargetElementId,
+        mce.TargetElementLabel,
+        m.ECInstanceId,
+        m.HexId,
+        m.ModeledElementParentId,
+        json_insert(
+          mce.Path,
+          '$[#]', json(e.Path),
+          '$[#]', ${createECInstanceKeySelectClause({
+            classIdAlias: "c",
+            instanceHexIdSelector: "c.HexId",
+        })},
+          '$[#]', ${createECInstanceKeySelectClause({
+            classIdAlias: "m",
+            instanceHexIdSelector: "m.HexId",
+        })}
+        )
+      FROM ModelsCategoriesElementsHierarchy mce
+      JOIN GeometricElements e on e.TargetId = mce.ModelId
+      JOIN Categories c ON c.ECInstanceId = e.CategoryId
+      JOIN Models m ON m.ECInstanceId = e.ModelId
+    )`,
+        ...(await createSubjectModelsInstanceKeysPathsCTEs(labelsFactory)),
+    ];
+}
+async function createInstanceKeyPathsFromInstanceKeys(props) {
+    const ids = {
+        models: new Array(),
+        categories: new Array(),
+        subjects: new Array(),
+        elements: new Array(),
+    };
+    await Promise.all(props.keys.map(async (key) => {
+        if (await props.imodelAccess.classDerivesFrom(key.className, "BisCore.Subject")) {
+            ids.subjects.push(key.id);
+        }
+        else if (await props.imodelAccess.classDerivesFrom(key.className, "BisCore.Model")) {
+            ids.models.push(key.id);
+        }
+        else if (await props.imodelAccess.classDerivesFrom(key.className, "BisCore.SpatialCategory")) {
+            ids.categories.push(key.id);
+        }
+        else {
+            ids.elements.push(key.id);
+        }
+    }));
+    const queries = [];
+    if (ids.elements.length > 0) {
+        queries.push(`
+      SELECT json_insert(mce.Path, '$[#]', json(s.Path))
+      FROM ModelsCategoriesElementsHierarchy mce
+      JOIN Subjects s ON s.TargetId = mce.ModelParentId OR json_extract(s.JsonProperties,'$.Subject.Model.TargetPartition') = mce.ModelHexId
+      WHERE mce.TargetElementId IN (${ids.elements.map(() => "?").join(",")})
+    `);
+    }
+    if (ids.categories.length > 0) {
+        queries.push(`
+      SELECT
+        json_array(
+          ${createECInstanceKeySelectClause({ classIdAlias: "c", instanceHexIdSelector: "c.HexId" })},
+          ${createECInstanceKeySelectClause({ classIdAlias: "m", instanceHexIdSelector: "m.HexId" })},
+          json(s.Path)
+        )
+      FROM Categories c,
+           Models m
+      JOIN Subjects s ON s.TargetId = m.ModeledElementParentId OR json_extract(s.JsonProperties,'$.Subject.Model.TargetPartition') = m.HexId
+      WHERE
+        m.ECInstanceId IN (SELECT e.Model.Id FROM bis.GeometricElement3d e WHERE e.Category.Id = c.ECInstanceId)
+        AND c.ECInstanceId IN (${ids.categories.map(() => "?").join(",")})
+    `);
+    }
+    if (ids.models.length > 0) {
+        queries.push(`
+      SELECT
+        json_array(
+          ${createECInstanceKeySelectClause({ classIdAlias: "m", instanceHexIdSelector: "m.HexId" })},
+          json(s.Path)
+        )
+      FROM Models m
+      JOIN Subjects s ON s.TargetId = m.ModeledElementParentId OR json_extract(s.JsonProperties,'$.Subject.Model.TargetPartition') = m.HexId
+      WHERE m.ECInstanceId IN (${ids.models.map(() => "?").join(",")})
+    `);
+    }
+    if (ids.subjects.length > 0) {
+        queries.push(`
+      SELECT s.Path
+      FROM Subjects s
+      WHERE s.TargetId IN (${ids.subjects.map(() => "?").join(",")})
+    `);
+    }
+    if (queries.length === 0) {
+        return [];
+    }
+    const bindings = [];
+    ids.elements.forEach((id) => bindings.push({ type: "id", value: id }));
+    ids.categories.forEach((id) => bindings.push({ type: "id", value: id }));
+    ids.models.forEach((id) => bindings.push({ type: "id", value: id }));
+    ids.subjects.forEach((id) => bindings.push({ type: "id", value: id }));
+    const reader = props.imodelAccess.createQueryReader({
+        ctes: await createInstanceKeyPathsCTEs({ createSelectClause: async () => "''" }),
+        ecsql: queries.join(" UNION ALL "),
+        bindings,
+    }, { rowFormat: "Indexes", restartToken: "tree-widget/models-tree/filter-by-keys-query" });
+    const paths = new Array();
+    for await (const row of reader) {
+        paths.push(flatten(JSON.parse(row[0])).reverse());
+    }
+    return paths;
+}
+async function createInstanceKeyPathsFromInstanceLabel(props) {
+    const queries = [];
+    queries.push(`
+    SELECT
+      m.Label AS Label,
+      json_array(
+        ${createECInstanceKeySelectClause({ classIdAlias: "m", instanceHexIdSelector: "m.HexId" })},
+        json(s.Path)
+      ) AS Path
+    FROM Models m
+    JOIN Subjects s ON s.TargetId = m.ModeledElementParentId OR json_extract(s.JsonProperties,'$.Subject.Model.TargetPartition') = m.HexId
+  `);
+    queries.push(`
+    SELECT s.TargetLabel AS Label, s.Path AS Path
+    FROM Subjects s
+  `);
+    const reader = props.imodelAccess.createQueryReader({
+        ctes: await createSubjectModelsInstanceKeysPathsCTEs(props.labelsFactory),
+        ecsql: `
+        SELECT DISTINCT Path
+        FROM (
+          ${queries.join(" UNION ALL ")}
+        )
+        WHERE Label LIKE '%' || ? || '%'
+      `,
+        bindings: [{ type: "string", value: props.label }],
+    }, { rowFormat: "Indexes", restartToken: "tree-widget/models-tree/filter-by-label-query" });
+    const paths = new Array();
+    for await (const row of reader) {
+        paths.push(flatten(JSON.parse(row[0])).reverse());
+    }
+    return paths;
+}
+function flatten(source) {
+    return source.reduce((flat, item) => {
+        return [...flat, ...(Array.isArray(item) ? flatten(item) : [item])];
+    }, new Array());
+}
+//# sourceMappingURL=ModelsTreeDefinition.js.map