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

package/lib/esm/components/trees/{stateless/imodel-content-tree → imodel-content-tree}/IModelContentTreeDefinition.js

@@ -4,9 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 import { createClassBasedHierarchyDefinition, createNodesQueryClauseFactory, HierarchyNode, NodeSelectClauseColumnNames, } from "@itwin/presentation-hierarchies";
 import { createBisInstanceLabelSelectClauseFactory, ECSql } from "@itwin/presentation-shared";
-import { createIdsSelector } from "../common/Utils";
+import { createIdsSelector, parseIdsSelectorResult } from "../common/Utils";
 export class IModelContentTreeDefinition {
     constructor(props) {
+        this._idsCache = props.idsCache;
         this._impl = createClassBasedHierarchyDefinition({
             classHierarchyInspector: props.imodelAccess,
             hierarchy: {
@@ -38,6 +39,7 @@ export class IModelContentTreeDefinition {
                     },
                     {
                         parentNodeClassName: "BisCore.Model",
+                        onlyIfNotHandled: true,
                         definitions: async (requestProps) => this.createModelChildrenQuery(requestProps),
                     },
                     {
@@ -54,6 +56,7 @@ export class IModelContentTreeDefinition {
                     },
                     {
                         parentNodeClassName: "BisCore.Element",
+                        onlyIfNotHandled: true,
                         definitions: async (requestProps) => this.createElementChildrenQuery(requestProps),
                     },
                 ],
@@ -94,7 +97,6 @@ export class IModelContentTreeDefinition {
                         },
                         extendedData: {
                             imageId: "icon-imodel-hollow-2",
-                            isSubject: true,
                         },
                         autoExpand: true,
                         supportsFiltering: true,
@@ -110,93 +112,66 @@ export class IModelContentTreeDefinition {
         ];
     }
     async createSubjectChildrenQuery({ parentNodeInstanceIds: subjectIds, instanceFilter, }) {
-        const selectColumnNames = Object.values(NodeSelectClauseColumnNames).join(", ");
-        const subjectFilterClauses = await this._selectQueryFactory.createFilterClauses({
-            filter: instanceFilter,
-            contentClass: { fullName: "BisCore.Subject", alias: "this" },
-        });
-        const modelFilterClauses = await this._selectQueryFactory.createFilterClauses({
-            filter: instanceFilter,
-            contentClass: { fullName: "BisCore.Model", alias: "this" },
-        });
-        const ctes = [
-            `
-        subjects(${selectColumnNames}, ParentId) AS (
-          SELECT
-            ${await this._selectQueryFactory.createSelectClause({
-                ecClassId: { selector: "this.ECClassId" },
-                ecInstanceId: { selector: "this.ECInstanceId" },
-                nodeLabel: {
-                    selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
-                        classAlias: "this",
-                        className: "BisCore.Subject",
-                    }),
-                },
-                hideNodeInHierarchy: {
-                    selector: `
-                  CASE
-                    WHEN (
-                      json_extract(this.JsonProperties, '$.Subject.Job.Bridge') IS NOT NULL
-                      OR json_extract(this.JsonProperties, '$.Subject.Model.Type') = 'Hierarchy'
-                    ) THEN 1
-                    ELSE 0
-                  END
-                `,
-                },
-                extendedData: {
-                    imageId: "icon-folder",
-                    isSubject: true,
-                },
-                supportsFiltering: true,
-            })},
-            this.Parent.Id
-          FROM BisCore.Subject this
-        )
-      `,
-            `
-        child_subjects(${selectColumnNames}, ParentId, RootId) AS (
-          SELECT *, s.ParentId RootId FROM subjects s
-          UNION ALL
-          SELECT s.*, p.RootId
-          FROM child_subjects p
-          JOIN subjects s ON s.ParentId = p.ECInstanceId
-          WHERE p.${NodeSelectClauseColumnNames.HideNodeInHierarchy} = 1
-        )
-      `,
-        ];
-        return [
-            {
+        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.Model", alias: "this" },
+            }),
+        ]);
+        const [childSubjectIds, childModelIds] = await Promise.all([
+            this._idsCache.getChildSubjectIds(subjectIds),
+            this._idsCache.getChildSubjectModelIds(subjectIds),
+        ]);
+        const defs = new Array();
+        childSubjectIds.length &&
+            defs.push({
                 fullClassName: "BisCore.Subject",
                 query: {
-                    ctes,
                     ecsql: `
             SELECT
-              ${Object.values(NodeSelectClauseColumnNames)
-                        .map((name) => `cs.${name} AS ${name}`)
-                        .join(", ")},
-              ParentId
-            FROM child_subjects cs
-            JOIN ${subjectFilterClauses.from} this ON this.ECInstanceId = cs.ECInstanceId
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: "BisCore.Subject",
+                            }),
+                        },
+                        hasChildren: { selector: `InVirtualSet(?, this.ECInstanceId)` },
+                        grouping: { byLabel: { action: "merge", groupId: "subject" } },
+                        extendedData: {
+                            imageId: "icon-folder",
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM ${subjectFilterClauses.from} this
             ${subjectFilterClauses.joins}
             WHERE
-              cs.RootId IN (${subjectIds.map(() => "?").join(",")})
-              AND NOT cs.${NodeSelectClauseColumnNames.HideNodeInHierarchy}
+              this.ECInstanceId IN (${childSubjectIds.map(() => "?").join(",")})
               ${subjectFilterClauses.where ? `AND ${subjectFilterClauses.where}` : ""}
           `,
-                    bindings: [...subjectIds.map((id) => ({ type: "id", value: id }))],
+                    bindings: [
+                        { type: "idset", value: await this._idsCache.getParentSubjectIds() },
+                        ...childSubjectIds.map((id) => ({ type: "id", value: id })),
+                    ],
                 },
-            },
-            {
+            });
+        childModelIds.length &&
+            defs.push({
                 fullClassName: "BisCore.Model",
                 query: {
-                    ctes,
                     ecsql: `
-            SELECT childModel.ECInstanceId AS ECInstanceId, childModel.*
+            SELECT model.ECInstanceId AS ECInstanceId, model.*
             FROM (
               SELECT
                 ${await this._selectQueryFactory.createSelectClause({
-                        ecClassId: { selector: "model.ECClassId" },
-                        ecInstanceId: { selector: "model.ECInstanceId" },
+                        ecClassId: { selector: "m.ECClassId" },
+                        ecInstanceId: { selector: "m.ECInstanceId" },
                         nodeLabel: {
                             selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
                                 classAlias: "partition",
@@ -219,31 +194,19 @@ export class IModelContentTreeDefinition {
                         },
                         supportsFiltering: true,
                     })}
-              FROM BisCore.Model model
-              JOIN bis.InformationPartitionElement [partition] ON [partition].ECInstanceId = model.ModeledElement.Id
-              JOIN bis.Subject [subject] ON [subject].ECInstanceId = [partition].Parent.Id OR json_extract([subject].JsonProperties,'$.Subject.Model.TargetPartition') = printf('0x%x', [partition].ECInstanceId)
+              FROM BisCore.Model m
+              JOIN BisCore.InformationPartitionElement [partition] ON [partition].ECInstanceId = m.ModeledElement.Id
               WHERE
-                NOT model.IsPrivate
-                AND (
-                  [subject].ECInstanceId IN (${subjectIds.map(() => "?").join(",")})
-                  OR [subject].ECInstanceId IN (
-                    SELECT s.ECInstanceId
-                    FROM child_subjects s
-                    WHERE s.RootId IN (${subjectIds.map(() => "?").join(",")}) AND s.${NodeSelectClauseColumnNames.HideNodeInHierarchy}
-                  )
-                )
-            ) childModel
-            JOIN ${modelFilterClauses.from} this ON this.ECInstanceId = childModel.ECInstanceId
+                m.ECInstanceId IN (${childModelIds.map(() => "?").join(",")})
+            ) model
+            JOIN ${modelFilterClauses.from} this ON this.ECInstanceId = model.ECInstanceId
             ${modelFilterClauses.joins}
-            ${modelFilterClauses.where ? `AND (childModel.${NodeSelectClauseColumnNames.HideNodeInHierarchy} OR ${modelFilterClauses.where})` : ""}
+            ${modelFilterClauses.where ? `WHERE (model.${NodeSelectClauseColumnNames.HideNodeInHierarchy} OR ${modelFilterClauses.where})` : ""}
           `,
-                    bindings: [
-                        ...subjectIds.map((id) => ({ type: "id", value: id })),
-                        ...subjectIds.map((id) => ({ type: "id", value: id })),
-                    ],
+                    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
@@ -271,7 +234,8 @@ export class IModelContentTreeDefinition {
         ];
     }
     async createGeometricModelChildrenQuery({ parentNodeInstanceIds: modelIds, instanceFilter, viewType, }) {
-        const { categoryClass, elementClass } = getClassNameByViewType(viewType);
+        const childCategoryIds = await this._idsCache.getModelCategories(modelIds);
+        const { categoryClass } = getClassNameByViewType(viewType);
         const categoryFilterClauses = await this._selectQueryFactory.createFilterClauses({
             filter: instanceFilter,
             contentClass: { fullName: categoryClass, alias: "this" },
@@ -280,8 +244,9 @@ export class IModelContentTreeDefinition {
             filter: instanceFilter,
             contentClass: { fullName: "BisCore.InformationContentElement", alias: "this" },
         });
-        return [
-            {
+        const defs = new Array();
+        childCategoryIds.length &&
+            defs.push({
                 fullClassName: categoryClass,
                 query: {
                     ecsql: `
@@ -295,82 +260,74 @@ export class IModelContentTreeDefinition {
                                 className: categoryClass,
                             }),
                         },
-                        hasChildren: true,
                         grouping: { byLabel: { action: "merge", groupId: "category" } },
                         extendedData: {
                             imageId: "icon-layers",
                             modelIds: { selector: createIdsSelector(modelIds) },
-                            isCategory: true,
                         },
+                        hasChildren: true,
                         supportsFiltering: true,
                     })}
             FROM ${categoryFilterClauses.from} this
-            JOIN ${elementClass} e ON e.Category.Id = this.ECInstanceId
             ${categoryFilterClauses.joins}
             WHERE
-              e.Model.Id IN (${modelIds.map(() => "?").join(",")})
+              this.ECInstanceId IN (${childCategoryIds.map(() => "?").join(",")})
               ${categoryFilterClauses.where ? `AND ${categoryFilterClauses.where}` : ""}
           `,
-                    bindings: modelIds.map((id) => ({ type: "id", value: id })),
+                    bindings: childCategoryIds.map((id) => ({ type: "id", value: id })),
                 },
-            },
-            {
-                fullClassName: "BisCore.InformationContentElement",
-                query: {
-                    ecsql: `
+            });
+        defs.push({
+            fullClassName: "BisCore.InformationContentElement",
+            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.InformationContentElement",
-                            }),
-                        },
-                        extendedData: {
-                            isInformationElement: true,
-                        },
-                        hasChildren: true,
-                        grouping: {
-                            byClass: true,
-                        },
-                        supportsFiltering: true,
-                    })}
+                    ecClassId: { selector: "this.ECClassId" },
+                    ecInstanceId: { selector: "this.ECInstanceId" },
+                    nodeLabel: {
+                        selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                            classAlias: "this",
+                            className: "BisCore.InformationContentElement",
+                        }),
+                    },
+                    hasChildren: true,
+                    grouping: {
+                        byClass: true,
+                    },
+                    supportsFiltering: true,
+                })}
             FROM ${informationContentElementFilterClauses.from} this
             ${informationContentElementFilterClauses.joins}
             WHERE
               this.Model.Id IN (${modelIds.map(() => "?").join(",")})
               ${informationContentElementFilterClauses.where ? `AND ${informationContentElementFilterClauses.where}` : ""}
           `,
-                    bindings: modelIds.map((id) => ({ type: "id", value: id })),
-                },
+                bindings: modelIds.map((id) => ({ type: "id", value: id })),
             },
-        ];
+        });
+        return defs;
     }
-    async createCategoryChildrenQuery({ parentNodeInstanceIds: categoryIds, parentNode, instanceFilter, viewType, }) {
+    async createCategoryChildrenQuery(props) {
+        const { parentNodeInstanceIds: categoryIds, parentNode, instanceFilter, viewType } = props;
+        const modelIds = parseIdsSelectorResult(parentNode.extendedData?.modelIds);
         // We only want to handle a category added as a child of `GeometricModel2d` or `GeometricModel3d`.
-        if (!parentNode.extendedData?.isCategory) {
-            return [];
-        }
-        const { elementClass, modelClass } = getClassNameByViewType(viewType);
-        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())
-            : [];
+        // ModelIds is not empty only if parent node is a geometric model.
         if (modelIds.length === 0) {
-            throw new Error(`Invalid category node "${parentNode.label}" - missing model information.`);
+            return this.createElementChildrenQuery(props);
         }
-        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
-            filter: instanceFilter,
-            contentClass: { fullName: elementClass, alias: "this" },
-        });
-        return [
-            {
+        const { elementClass, modelClass } = getClassNameByViewType(viewType);
+        return Promise.all(getElementsSelectProps({ modelClass, elementClass }).map(async ({ selectProps, whereClause }) => {
+            const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+                filter: instanceFilter,
+                contentClass: { fullName: elementClass, alias: "this" },
+            });
+            return {
                 fullClassName: elementClass,
                 query: {
                     ecsql: `
-            SELECT
-              ${await this._selectQueryFactory.createSelectClause({
+              SELECT
+                ${await this._selectQueryFactory.createSelectClause({
                         ecClassId: { selector: "this.ECClassId" },
                         ecInstanceId: { selector: "this.ECInstanceId" },
                         nodeLabel: {
@@ -379,49 +336,37 @@ export class IModelContentTreeDefinition {
                                 className: elementClass,
                             }),
                         },
-                        hasChildren: {
-                            selector: `
-                    IFNULL((
-                      SELECT 1
-                      FROM (
-                        SELECT Parent.Id ParentId FROM ${elementClass}
-                        UNION ALL
-                        SELECT ModeledElement.Id ParentId FROM ${modelClass}
-                      )
-                      WHERE ParentId = this.ECInstanceId
-                      LIMIT 1
-                    ), 0)
-                  `,
-                        },
                         grouping: {
                             byClass: true,
                         },
                         extendedData: {
                             imageId: "icon-item",
                         },
-                        supportsFiltering: true,
+                        hasChildren: selectProps.hasChildren,
+                        supportsFiltering: selectProps.supportsFiltering,
                     })}
-            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}` : ""}
-          `,
+              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
+                ${whereClause ? `AND ${whereClause}` : ""}
+                ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+            `,
                     bindings: [...categoryIds.map((id) => ({ type: "id", value: id })), ...modelIds.map((id) => ({ type: "id", value: id }))],
                 },
-            },
-        ];
+            };
+        }));
     }
     async createModelChildrenQuery({ parentNodeInstanceIds: modelIds, instanceFilter, }) {
-        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
-            filter: instanceFilter,
-            contentClass: { fullName: "BisCore.Element", alias: "this" },
-        });
-        return [
-            {
-                fullClassName: "BisCore.Element",
+        return Promise.all(getElementsSelectProps().map(async ({ classFullName, whereClause, selectProps }) => {
+            const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+                filter: instanceFilter,
+                contentClass: { fullName: classFullName, alias: "this" },
+            });
+            return {
+                fullClassName: classFullName,
                 query: {
                     ecsql: `
             SELECT
@@ -431,43 +376,30 @@ export class IModelContentTreeDefinition {
                         nodeLabel: {
                             selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
                                 classAlias: "this",
-                                className: "BisCore.Element",
+                                className: classFullName,
                             }),
                         },
-                        hasChildren: {
-                            selector: `
-                    IFNULL((
-                      SELECT 1
-                      FROM (
-                        SELECT Parent.Id ParentId FROM BisCore.Element
-                        UNION ALL
-                        SELECT ModeledElement.Id ParentId FROM BisCore.Model
-                      )
-                      WHERE ParentId = this.ECInstanceId
-                      LIMIT 1
-                    ), 0)
-                  `,
-                        },
                         grouping: {
                             byClass: true,
                         },
                         extendedData: {
                             imageId: "icon-item",
                         },
-                        supportsFiltering: true,
+                        hasChildren: selectProps?.hasChildren,
+                        supportsFiltering: selectProps?.supportsFiltering,
                     })}
             FROM ${instanceFilterClauses.from} this
-            JOIN BisCore.Model m ON m.ECInstanceId = this.Model.id
             ${instanceFilterClauses.joins}
             WHERE
-              m.ECClassId IS NOT (BisCore.GeometricModel) AND
-              this.Parent IS NULL AND this.Model.Id IN (${modelIds.map(() => "?").join(",")})
+              this.Parent IS NULL
+              AND this.Model.Id IN (${modelIds.map(() => "?").join(",")})
+              ${whereClause ? `AND ${whereClause}` : ""}
               ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
           `,
                     bindings: modelIds.map((id) => ({ type: "id", value: id })),
                 },
-            },
-        ];
+            };
+        }));
     }
     async createGroupInformationElementChildElementsQuery({ parentNodeInstanceIds: groupIds, }) {
         return [
@@ -503,127 +435,124 @@ export class IModelContentTreeDefinition {
     }
     async createChildrenNodeChildrenQuery({ parentNode, instanceFilter }) {
         const groupIds = parentNode.extendedData?.groupIds;
-        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
-            filter: instanceFilter,
-            contentClass: { fullName: "BisCore.Element", alias: "this" },
-        });
-        return [
-            {
-                fullClassName: "BisCore.Element",
+        return Promise.all(getElementsSelectProps().map(async ({ classFullName, whereClause, selectProps }) => {
+            const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+                filter: instanceFilter,
+                contentClass: { fullName: classFullName, alias: "this" },
+            });
+            return {
+                fullClassName: classFullName,
                 query: {
                     ecsql: `
-            SELECT
-              ${await this._selectQueryFactory.createSelectClause({
+              SELECT
+                ${await this._selectQueryFactory.createSelectClause({
                         ecClassId: { selector: "this.ECClassId" },
                         ecInstanceId: { selector: "this.ECInstanceId" },
                         nodeLabel: {
                             selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
                                 classAlias: "this",
-                                className: "BisCore.Element",
+                                className: classFullName,
                             }),
                         },
                         extendedData: {
                             imageId: "icon-item",
                         },
                         grouping: { byClass: true },
-                        hasChildren: false,
-                        supportsFiltering: true,
+                        hasChildren: selectProps.hasChildren,
+                        supportsFiltering: selectProps.supportsFiltering,
                     })}
-            FROM ${instanceFilterClauses.from} this
-            ${instanceFilterClauses.joins}
-            WHERE
-              this.Parent.Id IN (${groupIds.map(() => "?").join(",")})
-              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
-          `,
+              FROM ${instanceFilterClauses.from} this
+              ${instanceFilterClauses.joins}
+              WHERE
+                this.Parent.Id IN (${groupIds.map(() => "?").join(",")})
+                ${whereClause ? `AND ${whereClause}` : ""}
+                ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+            `,
                     bindings: groupIds.map((id) => ({ type: "id", value: id })),
                 },
-            },
-        ];
+            };
+        }));
     }
     async createGroupInformationElementMemberElementsQuery({ parentNode, instanceFilter, }) {
         const groupIds = parentNode.extendedData?.groupIds;
-        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
-            filter: instanceFilter,
-            contentClass: { fullName: "BisCore.Element", alias: "this" },
-        });
-        return [
-            {
-                fullClassName: "BisCore.Element",
+        return Promise.all(getElementsSelectProps().map(async ({ classFullName, whereClause, selectProps }) => {
+            const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+                filter: instanceFilter,
+                contentClass: { fullName: classFullName, alias: "this" },
+            });
+            return {
+                fullClassName: classFullName,
                 query: {
                     ecsql: `
-            SELECT
-              ${await this._selectQueryFactory.createSelectClause({
+              SELECT
+                ${await this._selectQueryFactory.createSelectClause({
                         ecClassId: { selector: "this.ECClassId" },
                         ecInstanceId: { selector: "this.ECInstanceId" },
                         nodeLabel: {
                             selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
                                 classAlias: "this",
-                                className: "BisCore.Element",
+                                className: classFullName,
                             }),
                         },
+                        grouping: { byClass: true },
                         extendedData: {
                             imageId: "icon-item",
                         },
-                        hasChildren: false,
-                        grouping: { byClass: true },
-                        supportsFiltering: true,
+                        hasChildren: selectProps.hasChildren,
+                        supportsFiltering: selectProps.supportsFiltering,
                     })}
-            FROM ${instanceFilterClauses.from} this
-            JOIN BisCore.ElementGroupsMembers egm ON egm.TargetECInstanceId = this.ECInstanceId
-            ${instanceFilterClauses.joins}
-            WHERE
-              egm.SourceECInstanceId IN (${groupIds.map(() => "?").join(",")})
-              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
-          `,
+              FROM ${instanceFilterClauses.from} this
+              JOIN BisCore.ElementGroupsMembers egm ON egm.TargetECInstanceId = this.ECInstanceId
+              ${instanceFilterClauses.joins}
+              WHERE
+                egm.SourceECInstanceId IN (${groupIds.map(() => "?").join(",")})
+                ${whereClause ? `AND ${whereClause}` : ""}
+                ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+            `,
                     bindings: groupIds.map((id) => ({ type: "id", value: id })),
                 },
-            },
-        ];
+            };
+        }));
     }
-    async createElementChildrenQuery({ parentNodeInstanceIds: elementIds, instanceFilter, parentNode, }) {
-        const data = parentNode.extendedData;
-        if (data?.isCategory || data?.isSubject || data?.isInformationElement) {
-            return [];
-        }
-        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
-            filter: instanceFilter,
-            contentClass: { fullName: "BisCore.Element", alias: "this" },
-        });
-        return [
-            {
-                fullClassName: "BisCore.Element",
+    async createElementChildrenQuery({ parentNodeInstanceIds: elementIds, instanceFilter, }) {
+        return Promise.all(getElementsSelectProps().map(async ({ classFullName, whereClause, selectProps }) => {
+            const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+                filter: instanceFilter,
+                contentClass: { fullName: classFullName, alias: "this" },
+            });
+            return {
+                fullClassName: classFullName,
                 query: {
                     ecsql: `
-            SELECT
-              ${await this._selectQueryFactory.createSelectClause({
+              SELECT
+                ${await this._selectQueryFactory.createSelectClause({
                         ecClassId: { selector: "this.ECClassId" },
                         ecInstanceId: { selector: "this.ECInstanceId" },
                         nodeLabel: {
                             selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
                                 classAlias: "this",
-                                className: "BisCore.Element",
+                                className: classFullName,
                             }),
                         },
-                        grouping: {
-                            byClass: true,
-                        },
+                        grouping: { byClass: true },
                         extendedData: {
                             imageId: "icon-item",
                         },
-                        supportsFiltering: true,
+                        hasChildren: selectProps.hasChildren,
+                        supportsFiltering: selectProps.supportsFiltering,
                     })}
-            FROM ${instanceFilterClauses.from} this
-            JOIN BisCore.Element p ON p.ECInstanceId = this.Parent.Id
-            ${instanceFilterClauses.joins}
-            WHERE
-              p.ECInstanceId IN (${elementIds.map(() => "?").join(",")}) AND
-              p.ECClassId IS NOT (BisCore.ISubModeledElement)
-              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
-          `,
+              FROM ${instanceFilterClauses.from} this
+              JOIN BisCore.Element p ON p.ECInstanceId = this.Parent.Id
+              ${instanceFilterClauses.joins}
+              WHERE
+                p.ECInstanceId IN (${elementIds.map(() => "?").join(",")})
+                ${whereClause ? `AND ${whereClause}` : ""}
+                ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+            `,
                     bindings: elementIds.map((id) => ({ type: "id", value: id })),
                 },
-            },
-        ];
+            };
+        }));
     }
 }
 function getClassNameByViewType(view) {
@@ -632,4 +561,55 @@ function getClassNameByViewType(view) {
     }
     return { categoryClass: "BisCore.SpatialCategory", elementClass: "BisCore.GeometricElement3d", modelClass: "BisCore.GeometricModel3d" };
 }
+function getElementsSelectProps(props) {
+    const modelClassFullName = props?.modelClass ?? "BisCore.Model";
+    const elementClassFullName = props?.elementClass ?? "BisCore.Element";
+    const result = [
+        {
+            classFullName: elementClassFullName,
+            whereClause: "this.ECClassId IS NOT (BisCore.GroupInformationElement)",
+            selectProps: {
+                hasChildren: {
+                    selector: `
+          IFNULL((
+            SELECT 1
+            FROM (
+              SELECT Parent.Id ParentId FROM ${elementClassFullName}
+              UNION ALL
+              SELECT sm.ModeledElement.Id ParentId FROM ${modelClassFullName} sm WHERE EXISTS (SELECT 1 FROM ${elementClassFullName} WHERE Model.Id = sm.ECInstanceId)
+            )
+            WHERE ParentId = this.ECInstanceId
+            LIMIT 1
+          ), 0)
+        `,
+                },
+                supportsFiltering: true,
+            },
+        },
+    ];
+    if (!props?.elementClass) {
+        result.push({
+            classFullName: "BisCore.GroupInformationElement",
+            whereClause: "",
+            selectProps: {
+                hasChildren: {
+                    selector: `
+            IFNULL((
+              SELECT 1
+              FROM (
+                SELECT Parent.Id ParentId FROM BisCore.Element
+                UNION ALL
+                SELECT SourceECInstanceId ParentId FROM BisCore.ElementGroupsMembers
+              )
+              WHERE ParentId = this.ECInstanceId
+              LIMIT 1
+            ), 0)
+          `,
+                },
+                supportsFiltering: false,
+            },
+        });
+    }
+    return result;
+}
 //# sourceMappingURL=IModelContentTreeDefinition.js.map