@itwin/tree-widget-react 2.3.2 → 3.0.0-dev.1

package/lib/cjs/components/trees/imodel-content-tree/IModelContentTreeComponent.js.map

@@ -1 +1 @@
-{"version":3,"file":"IModelContentTreeComponent.js","sourceRoot":"","sources":["../../../../../src/components/trees/imodel-content-tree/IModelContentTreeComponent.tsx"],"names":[],"mappings":";;;;AAAA;;;gGAGgG;AAEhG,sCAAoC;AACpC,oDAA+D;AAC/D,oDAAiD;AACjD,qDAAkD;AAClD,2DAAwD;AAUxD;;;GAGG;AACI,MAAM,0BAA0B,GAAG,CAAC,KAAsC,EAAE,EAAE;IACnF,MAAM,MAAM,GAAG,IAAA,uCAAyB,GAAE,CAAC;IAE3C,IAAI,CAAC,MAAM,EAAE;QACX,OAAO,IAAI,CAAC;KACb;IAED,OAAO,uBAAC,qBAAS,cAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,uBAAC,qCAAiB,OAAK,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAI,GAAa,CAAC;AACxI,CAAC,CAAC;AARW,QAAA,0BAA0B,8BAQrC;AAEF;;;GAGG;AACH,kCAA0B,CAAC,EAAE,GAAG,qBAAqB,CAAC;AAEtD;;;GAGG;AACH,kCAA0B,CAAC,QAAQ,GAAG,GAAG,EAAE,CAAC,uBAAU,CAAC,SAAS,CAAC,eAAe,CAAC,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 \"../VisibilityTreeBase.scss\";\nimport { useActiveIModelConnection } from \"@itwin/appui-react\";\nimport { TreeWidget } from \"../../../TreeWidget\";\nimport { AutoSizer } from \"../../utils/AutoSizer\";\nimport { IModelContentTree } from \"./IModelContentTree\";\n\nimport type { IModelContentTreeProps } from \"./IModelContentTree\";\n\n/**\n * Props for [[IModelContentTreeComponent]].\n * @public\n */\nexport type IModelContentTreeComponentProps = Omit<IModelContentTreeProps, \"iModel\" | \"width\" | \"height\">;\n\n/**\n * A component that renders [[IModelContentTree]]\n * @public\n */\nexport const IModelContentTreeComponent = (props: IModelContentTreeComponentProps) => {\n  const iModel = useActiveIModelConnection();\n\n  if (!iModel) {\n    return null;\n  }\n\n  return <AutoSizer>{({ width, height }) => <IModelContentTree {...props} iModel={iModel} width={width} height={height} />}</AutoSizer>;\n};\n\n/**\n * Id of the component. May be used when a creating a [[TreeDefinition]] for [[SelectableTree]].\n * @public\n */\nIModelContentTreeComponent.id = \"imodel-content-tree\";\n\n/**\n * Label of the component. May be used when a creating a [[TreeDefinition]] for [[SelectableTree]].\n * @public\n */\nIModelContentTreeComponent.getLabel = () => TreeWidget.translate(\"imodelContent\");\n"]}
+{"version":3,"file":"IModelContentTreeComponent.js","sourceRoot":"","sources":["../../../../../src/components/trees/imodel-content-tree/IModelContentTreeComponent.tsx"],"names":[],"mappings":";;;;AAAA;;;gGAGgG;AAEhG,oDAA+D;AAC/D,0FAAiF;AACjF,oDAAiD;AACjD,qDAAkD;AAClD,2DAAwD;AAWxD;;;GAGG;AACI,MAAM,0BAA0B,GAAG,CAAC,KAAsC,EAAE,EAAE;IACnF,MAAM,MAAM,GAAG,IAAA,uCAAyB,GAAE,CAAC;IAE3C,IAAI,CAAC,MAAM,EAAE;QACX,OAAO,IAAI,CAAC;KACb;IAED,OAAO,CACL,uBAAC,yDAAwB,IAAC,OAAO,EAAE,KAAK,CAAC,gBAAgB,YACvD,uBAAC,qBAAS,cAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,uBAAC,qCAAiB,OAAK,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAI,GAAa,GACrG,CAC5B,CAAC;AACJ,CAAC,CAAC;AAZW,QAAA,0BAA0B,8BAYrC;AAEF;;;GAGG;AACH,kCAA0B,CAAC,EAAE,GAAG,wBAAwB,CAAC;AAEzD;;;GAGG;AACH,kCAA0B,CAAC,QAAQ,GAAG,GAAG,EAAE,CAAC,uBAAU,CAAC,SAAS,CAAC,yBAAyB,CAAC,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 { UnifiedSelectionProvider } from \"@itwin/presentation-hierarchies-react\";\nimport { TreeWidget } from \"../../../TreeWidget\";\nimport { AutoSizer } from \"../../utils/AutoSizer\";\nimport { IModelContentTree } from \"./IModelContentTree\";\n\nimport type { ComponentPropsWithoutRef } from \"react\";\nimport type { SelectionStorage } from \"@itwin/presentation-hierarchies-react\";\n\ntype IModelContentTreeProps = ComponentPropsWithoutRef<typeof IModelContentTree>;\ninterface IModelContentTreeComponentProps\n  extends Pick<IModelContentTreeProps, \"getSchemaContext\" | \"density\" | \"hierarchyLevelConfig\" | \"selectionMode\" | \"onPerformanceMeasured\" | \"onFeatureUsed\"> {\n  selectionStorage: SelectionStorage;\n}\n\n/**\n * A component that renders `IModelContentTree`.\n * @beta\n */\nexport const IModelContentTreeComponent = (props: IModelContentTreeComponentProps) => {\n  const imodel = useActiveIModelConnection();\n\n  if (!imodel) {\n    return null;\n  }\n\n  return (\n    <UnifiedSelectionProvider storage={props.selectionStorage}>\n      <AutoSizer>{({ width, height }) => <IModelContentTree {...props} imodel={imodel} width={width} height={height} />}</AutoSizer>\n    </UnifiedSelectionProvider>\n  );\n};\n\n/**\n * Id of the component. May be used when a creating a `TreeDefinition` for `SelectableTree`.\n * @beta\n */\nIModelContentTreeComponent.id = \"imodel-content-tree-v2\";\n\n/**\n * Label of the component. May be used when a creating a `TreeDefinition` for `SelectableTree`.\n * @beta\n */\nIModelContentTreeComponent.getLabel = () => TreeWidget.translate(\"imodelContentTree.label\");\n"]}

package/lib/cjs/components/trees/imodel-content-tree/IModelContentTreeDefinition.d.ts

@@ -0,0 +1,28 @@
+import type { ECClassHierarchyInspector, ECSchemaProvider } from "@itwin/presentation-shared";
+import type { DefineHierarchyLevelProps, HierarchyDefinition, HierarchyLevelDefinition, ProcessedHierarchyNode } from "@itwin/presentation-hierarchies";
+import type { IModelContentTreeIdsCache } from "./internal/IModelContentTreeIdsCache";
+interface IModelContentTreeDefinitionProps {
+    imodelAccess: ECSchemaProvider & ECClassHierarchyInspector;
+    idsCache: IModelContentTreeIdsCache;
+}
+export declare class IModelContentTreeDefinition implements HierarchyDefinition {
+    private _impl;
+    private _idsCache;
+    private _selectQueryFactory;
+    private _nodeLabelSelectClauseFactory;
+    constructor(props: IModelContentTreeDefinitionProps);
+    postProcessNode(node: ProcessedHierarchyNode): Promise<ProcessedHierarchyNode>;
+    defineHierarchyLevel(props: DefineHierarchyLevelProps): Promise<HierarchyLevelDefinition>;
+    private createRootHierarchyLevelDefinition;
+    private createSubjectChildrenQuery;
+    private createISubModeledElementChildrenQuery;
+    private createGeometricModelChildrenQuery;
+    private createCategoryChildrenQuery;
+    private createModelChildrenQuery;
+    private createGroupInformationElementChildElementsQuery;
+    private createChildrenNodeChildrenQuery;
+    private createGroupInformationElementMemberElementsQuery;
+    private createElementChildrenQuery;
+}
+export {};
+//# sourceMappingURL=IModelContentTreeDefinition.d.ts.map

package/lib/cjs/components/trees/imodel-content-tree/IModelContentTreeDefinition.js

@@ -0,0 +1,619 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IModelContentTreeDefinition = void 0;
+const presentation_hierarchies_1 = require("@itwin/presentation-hierarchies");
+const presentation_shared_1 = require("@itwin/presentation-shared");
+const Utils_1 = require("../common/Utils");
+class IModelContentTreeDefinition {
+    constructor(props) {
+        this._idsCache = props.idsCache;
+        this._impl = (0, presentation_hierarchies_1.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.createGeometricModelChildrenQuery({ ...requestProps, viewType: "3d" }),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.GeometricModel2d",
+                        definitions: async (requestProps) => this.createGeometricModelChildrenQuery({ ...requestProps, viewType: "2d" }),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.SpatialCategory",
+                        definitions: async (requestProps) => this.createCategoryChildrenQuery({ ...requestProps, viewType: "3d" }),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.DrawingCategory",
+                        definitions: async (requestProps) => this.createCategoryChildrenQuery({ ...requestProps, viewType: "2d" }),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.Model",
+                        onlyIfNotHandled: true,
+                        definitions: async (requestProps) => this.createModelChildrenQuery(requestProps),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.GroupInformationElement",
+                        definitions: async (requestProps) => this.createGroupInformationElementChildElementsQuery(requestProps),
+                    },
+                    {
+                        customParentNodeKey: "ChildrenNode",
+                        definitions: async (requestProps) => this.createChildrenNodeChildrenQuery(requestProps),
+                    },
+                    {
+                        customParentNodeKey: "MembersNode",
+                        definitions: async (requestProps) => this.createGroupInformationElementMemberElementsQuery(requestProps),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.Element",
+                        onlyIfNotHandled: true,
+                        definitions: async (requestProps) => this.createElementChildrenQuery(requestProps),
+                    },
+                ],
+            },
+        });
+        this._selectQueryFactory = (0, presentation_hierarchies_1.createNodesQueryClauseFactory)({ imodelAccess: props.imodelAccess });
+        this._nodeLabelSelectClauseFactory = (0, presentation_shared_1.createBisInstanceLabelSelectClauseFactory)({ classHierarchyInspector: props.imodelAccess });
+    }
+    async postProcessNode(node) {
+        if (presentation_hierarchies_1.HierarchyNode.isClassGroupingNode(node)) {
+            const label = node.children.length ? `${node.label} (${node.children.length})` : node.label;
+            return { ...node, label, extendedData: { ...node.extendedData, 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: presentation_shared_1.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",
+                        },
+                        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.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: {
+                    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",
+                            }),
+                        },
+                        hasChildren: { selector: `InVirtualSet(?, this.ECInstanceId)` },
+                        grouping: { byLabel: { action: "merge", groupId: "subject" } },
+                        extendedData: {
+                            imageId: "icon-folder",
+                        },
+                        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._idsCache.getParentSubjectIds() },
+                        ...childSubjectIds.map((id) => ({ type: "id", value: id })),
+                    ],
+                },
+            });
+        childModelIds.length &&
+            defs.push({
+                fullClassName: "BisCore.Model",
+                query: {
+                    ecsql: `
+            SELECT model.ECInstanceId AS ECInstanceId, model.*
+            FROM (
+              SELECT
+                ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "m.ECClassId" },
+                        ecInstanceId: { selector: "m.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
+                    `,
+                        },
+                        extendedData: {
+                            imageId: "icon-model",
+                        },
+                        supportsFiltering: true,
+                    })}
+              FROM BisCore.Model m
+              JOIN BisCore.InformationPartitionElement [partition] ON [partition].ECInstanceId = m.ModeledElement.Id
+              WHERE
+                m.ECInstanceId IN (${childModelIds.map(() => "?").join(",")})
+            ) model
+            JOIN ${modelFilterClauses.from} this ON this.ECInstanceId = model.ECInstanceId
+            ${modelFilterClauses.joins}
+            ${modelFilterClauses.where ? `WHERE (model.${presentation_hierarchies_1.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.Model",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: "",
+                        hideNodeInHierarchy: true,
+                    })}
+            FROM BisCore.Model this
+            WHERE
+              this.ModeledElement.Id IN (${elementIds.map(() => "?").join(",")})
+              AND NOT this.IsPrivate
+          `,
+                    bindings: [...elementIds.map((id) => ({ type: "id", value: id }))],
+                },
+            },
+        ];
+    }
+    async createGeometricModelChildrenQuery({ parentNodeInstanceIds: modelIds, instanceFilter, 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" },
+        });
+        const informationContentElementFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: "BisCore.InformationContentElement", alias: "this" },
+        });
+        const defs = new Array();
+        childCategoryIds.length &&
+            defs.push({
+                fullClassName: categoryClass,
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: categoryClass,
+                            }),
+                        },
+                        grouping: { byLabel: { action: "merge", groupId: "category" } },
+                        extendedData: {
+                            imageId: "icon-layers",
+                            modelIds: { selector: (0, Utils_1.createIdsSelector)(modelIds) },
+                        },
+                        hasChildren: true,
+                        supportsFiltering: true,
+                    })}
+            FROM ${categoryFilterClauses.from} this
+            ${categoryFilterClauses.joins}
+            WHERE
+              this.ECInstanceId IN (${childCategoryIds.map(() => "?").join(",")})
+              ${categoryFilterClauses.where ? `AND ${categoryFilterClauses.where}` : ""}
+          `,
+                    bindings: childCategoryIds.map((id) => ({ type: "id", value: id })),
+                },
+            });
+        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",
+                        }),
+                    },
+                    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 })),
+            },
+        });
+        return defs;
+    }
+    async createCategoryChildrenQuery(props) {
+        const { parentNodeInstanceIds: categoryIds, parentNode, instanceFilter, viewType } = props;
+        const modelIds = (0, Utils_1.parseIdsSelectorResult)(parentNode.extendedData?.modelIds);
+        // We only want to handle a category added as a child of `GeometricModel2d` or `GeometricModel3d`.
+        // ModelIds is not empty only if parent node is a geometric model.
+        if (modelIds.length === 0) {
+            return this.createElementChildrenQuery(props);
+        }
+        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({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: elementClass,
+                            }),
+                        },
+                        grouping: {
+                            byClass: true,
+                        },
+                        extendedData: {
+                            imageId: "icon-item",
+                        },
+                        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
+                ${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, }) {
+        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({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: classFullName,
+                            }),
+                        },
+                        grouping: {
+                            byClass: true,
+                        },
+                        extendedData: {
+                            imageId: "icon-item",
+                        },
+                        hasChildren: selectProps?.hasChildren,
+                        supportsFiltering: selectProps?.supportsFiltering,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            ${instanceFilterClauses.joins}
+            WHERE
+              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 [
+            {
+                node: {
+                    key: "ChildrenNode",
+                    label: "Children",
+                    extendedData: {
+                        groupIds,
+                        imageId: "icon-hierarchy-tree",
+                    },
+                    supportsFiltering: true,
+                    processingParams: {
+                        hideIfNoChildren: true,
+                    },
+                },
+            },
+            {
+                node: {
+                    key: "MembersNode",
+                    label: "Members",
+                    extendedData: {
+                        groupIds,
+                        imageId: "icon-group",
+                    },
+                    supportsFiltering: true,
+                    processingParams: {
+                        hideIfNoChildren: true,
+                    },
+                },
+            },
+        ];
+    }
+    async createChildrenNodeChildrenQuery({ parentNode, instanceFilter }) {
+        const groupIds = parentNode.extendedData?.groupIds;
+        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({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: classFullName,
+                            }),
+                        },
+                        extendedData: {
+                            imageId: "icon-item",
+                        },
+                        grouping: { byClass: true },
+                        hasChildren: selectProps.hasChildren,
+                        supportsFiltering: selectProps.supportsFiltering,
+                    })}
+              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;
+        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({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: classFullName,
+                            }),
+                        },
+                        grouping: { byClass: true },
+                        extendedData: {
+                            imageId: "icon-item",
+                        },
+                        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(",")})
+                ${whereClause ? `AND ${whereClause}` : ""}
+                ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+            `,
+                    bindings: groupIds.map((id) => ({ type: "id", value: id })),
+                },
+            };
+        }));
+    }
+    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({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: classFullName,
+                            }),
+                        },
+                        grouping: { byClass: true },
+                        extendedData: {
+                            imageId: "icon-item",
+                        },
+                        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(",")})
+                ${whereClause ? `AND ${whereClause}` : ""}
+                ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+            `,
+                    bindings: elementIds.map((id) => ({ type: "id", value: id })),
+                },
+            };
+        }));
+    }
+}
+exports.IModelContentTreeDefinition = IModelContentTreeDefinition;
+function getClassNameByViewType(view) {
+    if (view === "2d") {
+        return { categoryClass: "BisCore.DrawingCategory", elementClass: "BisCore.GeometricElement2d", modelClass: "BisCore.GeometricModel2d" };
+    }
+    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