Add definitionContainers to categories tree

change/@itwin-tree-widget-react-944faa0b-268a-40c9-9ae5-49d45b91b7c7.json

@@ -0,0 +1,7 @@
+{
+  "type": "minor",
+  "comment": "`CategoriesTree` component rendered `Categories` as a flat list, where each `Category` had zero or more child `SubCategories`. Some iTwin.js applications started to group `Categories` under `DefinitionContainers` and wanted to see them displayed in `CategoriesTree` component. Added `DefinitionContainers` to `CategoriesTree` component. This change doesn't affect applications that don't have `DefinitionContainers`.",
+  "packageName": "@itwin/tree-widget-react",
+  "email": "[email protected]",
+  "dependentChangeType": "patch"
+}

packages/itwin/tree-widget/src/test/IModelUtils.ts

@@ -265,6 +265,24 @@ export function insertSpatialCategory(
   return { className, id };
 }
 
+export function insertDefinitionContainer(
+  props: BaseInstanceInsertProps & { codeValue: string; modelId?: Id64String; isPrivate?: boolean } & Partial<
+      Omit<ElementProps, "id" | "model" | "parent" | "code">
+    >,
+) {
+  const { builder, classFullName, modelId, codeValue, ...elementProps } = props;
+  const defaultClassName = `BisCore${props.fullClassNameSeparator ?? "."}DefinitionContainer`;
+  const className = classFullName ?? defaultClassName;
+  const model = modelId ?? IModel.dictionaryId;
+  const id = builder.insertElement({
+    classFullName: className,
+    model,
+    code: builder.createCode(model, BisCodeSpec.nullCodeSpec, codeValue),
+    ...elementProps,
+  });
+  return { className, id };
+}
+
 export function insertDrawingCategory(
   props: BaseInstanceInsertProps & { codeValue: string; modelId?: Id64String } & Partial<Omit<CategoryProps, "id" | "model" | "parent" | "code">>,
 ) {

packages/itwin/tree-widget/src/test/trees/categories-tree/CategoriesTreeDefinition.test.ts

@@ -8,13 +8,20 @@ import { ECSchemaRpcInterface } from "@itwin/ecschema-rpcinterface-common";
 import { ECSchemaRpcImpl } from "@itwin/ecschema-rpcinterface-impl";
 import { PresentationRpcInterface } from "@itwin/presentation-common";
 import { createIModelHierarchyProvider } from "@itwin/presentation-hierarchies";
-import {
-  HierarchyCacheMode, initialize as initializePresentationTesting, terminate as terminatePresentationTesting,
-} from "@itwin/presentation-testing";
+import { HierarchyCacheMode, initialize as initializePresentationTesting, terminate as terminatePresentationTesting } from "@itwin/presentation-testing";
 import { CategoriesTreeDefinition } from "../../../tree-widget-react/components/trees/categories-tree/CategoriesTreeDefinition.js";
+import { CategoriesTreeIdsCache } from "../../../tree-widget-react/components/trees/categories-tree/internal/CategoriesTreeIdsCache.js";
 import {
-  buildIModel, insertDrawingCategory, insertDrawingGraphic, insertDrawingModelWithPartition, insertPhysicalElement, insertPhysicalModelWithPartition,
-  insertSpatialCategory, insertSubCategory,
+  buildIModel,
+  insertDefinitionContainer,
+  insertDrawingCategory,
+  insertDrawingGraphic,
+  insertDrawingModelWithPartition,
+  insertPhysicalElement,
+  insertPhysicalModelWithPartition,
+  insertSpatialCategory,
+  insertSubCategory,
+  insertSubModel,
 } from "../../IModelUtils.js";
 import { createIModelAccess } from "../Common.js";
 import { NodeValidators, validateHierarchy } from "../HierarchyValidation.js";
@@ -66,6 +73,204 @@ describe("Categories tree", () => {
       });
     });
 
+    it("does not show definition container when it doesn't contain category", async function () {
+      const { imodel, ...keys } = await buildIModel(this, async (builder) => {
+        const physicalModel = insertPhysicalModelWithPartition({ builder, codeValue: "TestPhysicalModel" });
+        const definitionContainer = insertDefinitionContainer({ builder, codeValue: "DefinitionContainer" });
+        insertSubModel({ builder, classFullName: "BisCore.DefinitionModel", modeledElementId: definitionContainer.id });
+
+        const category = insertSpatialCategory({ builder, codeValue: "SpatialCategory" });
+
+        insertPhysicalElement({ builder, modelId: physicalModel.id, categoryId: category.id });
+
+        return { category };
+      });
+      await validateHierarchy({
+        provider: createCategoryTreeProvider(imodel, "3d"),
+        expect: [
+          NodeValidators.createForInstanceNode({
+            instanceKeys: [keys.category],
+            supportsFiltering: true,
+            children: false,
+          }),
+        ],
+      });
+    });
+
+    it("does not show definition container when it contains definition container without categories", async function () {
+      const { imodel } = await buildIModel(this, async (builder) => {
+        insertPhysicalModelWithPartition({ builder, codeValue: "TestPhysicalModel" });
+        const definitionContainer = insertDefinitionContainer({ builder, codeValue: "DefinitionContainer" });
+        const definitionModel = insertSubModel({ builder, classFullName: "BisCore.DefinitionModel", modeledElementId: definitionContainer.id });
+        const definitionContainerChild = insertDefinitionContainer({ builder, codeValue: "DefinitionContainerChild", modelId: definitionModel.id });
+        insertSubModel({ builder, classFullName: "BisCore.DefinitionModel", modeledElementId: definitionContainerChild.id });
+      });
+      await validateHierarchy({
+        provider: createCategoryTreeProvider(imodel, "3d"),
+        expect: [],
+      });
+    });
+
+    it("does not show definition container or category when category is private", async function () {
+      const { imodel } = await buildIModel(this, async (builder) => {
+        const physicalModel = insertPhysicalModelWithPartition({ builder, codeValue: "TestPhysicalModel" });
+        const definitionContainer = insertDefinitionContainer({ builder, codeValue: "DefinitionContainer" });
+        const definitionModel = insertSubModel({ builder, classFullName: "BisCore.DefinitionModel", modeledElementId: definitionContainer.id });
+
+        const category = insertSpatialCategory({ builder, codeValue: "SpatialCategory", modelId: definitionModel.id, isPrivate: true });
+
+        insertPhysicalElement({ builder, modelId: physicalModel.id, categoryId: category.id });
+      });
+      await validateHierarchy({
+        provider: createCategoryTreeProvider(imodel, "3d"),
+        expect: [],
+      });
+    });
+
+    it("does not show definition container or category when definition container is private", async function () {
+      const { imodel } = await buildIModel(this, async (builder) => {
+        const physicalModel = insertPhysicalModelWithPartition({ builder, codeValue: "TestPhysicalModel" });
+        const definitionContainer = insertDefinitionContainer({ builder, codeValue: "DefinitionContainer", isPrivate: true });
+        const definitionModel = insertSubModel({ builder, classFullName: "BisCore.DefinitionModel", modeledElementId: definitionContainer.id });
+
+        const category = insertSpatialCategory({ builder, codeValue: "SpatialCategory", modelId: definitionModel.id });
+
+        insertPhysicalElement({ builder, modelId: physicalModel.id, categoryId: category.id });
+      });
+      await validateHierarchy({
+        provider: createCategoryTreeProvider(imodel, "3d"),
+        expect: [],
+      });
+    });
+
+    it("does not show definition containers or categories when definition container contains another definition container that is private", async function () {
+      const { imodel } = await buildIModel(this, async (builder) => {
+        const physicalModel = insertPhysicalModelWithPartition({ builder, codeValue: "TestPhysicalModel" });
+        const definitionContainer = insertDefinitionContainer({ builder, codeValue: "DefinitionContainer" });
+        const definitionModel = insertSubModel({ builder, classFullName: "BisCore.DefinitionModel", modeledElementId: definitionContainer.id });
+        const definitionContainerChild = insertDefinitionContainer({
+          builder,
+          codeValue: "DefinitionContainerChild",
+          isPrivate: true,
+          modelId: definitionModel.id,
+        });
+        const defintionModelChild = insertSubModel({ builder, classFullName: "BisCore.DefinitionModel", modeledElementId: definitionContainerChild.id });
+
+        const category = insertSpatialCategory({ builder, codeValue: "SpatialCategory", modelId: defintionModelChild.id });
+
+        insertPhysicalElement({ builder, modelId: physicalModel.id, categoryId: category.id });
+      });
+      await validateHierarchy({
+        provider: createCategoryTreeProvider(imodel, "3d"),
+        expect: [],
+      });
+    });
+
+    it("shows definition container when it contains category", async function () {
+      const { imodel, ...keys } = await buildIModel(this, async (builder) => {
+        const physicalModel = insertPhysicalModelWithPartition({ builder, codeValue: "TestPhysicalModel" });
+        const definitionContainer = insertDefinitionContainer({ builder, codeValue: "DefinitionContainer" });
+        const definitionModel = insertSubModel({ builder, classFullName: "BisCore.DefinitionModel", modeledElementId: definitionContainer.id });
+
+        const category = insertSpatialCategory({ builder, codeValue: "SpatialCategory", modelId: definitionModel.id });
+
+        insertPhysicalElement({ builder, modelId: physicalModel.id, categoryId: category.id });
+
+        return { definitionContainer, category };
+      });
+      await validateHierarchy({
+        provider: createCategoryTreeProvider(imodel, "3d"),
+        expect: [
+          NodeValidators.createForInstanceNode({
+            instanceKeys: [keys.definitionContainer],
+            supportsFiltering: true,
+            children: [
+              NodeValidators.createForInstanceNode({
+                instanceKeys: [keys.category],
+                label: "SpatialCategory",
+                children: false,
+              }),
+            ],
+          }),
+        ],
+      });
+    });
+
+    it("shows all definition containers when they contain category directly or indirectly", async function () {
+      const { imodel, ...keys } = await buildIModel(this, async (builder) => {
+        const physicalModel = insertPhysicalModelWithPartition({ builder, codeValue: "TestPhysicalModel" });
+        const definitionContainer = insertDefinitionContainer({ builder, codeValue: "DefinitionContainer" });
+        const definitionModel = insertSubModel({ builder, classFullName: "BisCore.DefinitionModel", modeledElementId: definitionContainer.id });
+        const definitionContainerChild = insertDefinitionContainer({ builder, codeValue: "DefinitionContainerChild", modelId: definitionModel.id });
+        const definitionModelChild = insertSubModel({ builder, classFullName: "BisCore.DefinitionModel", modeledElementId: definitionContainerChild.id });
+
+        const category = insertSpatialCategory({ builder, codeValue: "SpatialCategory", modelId: definitionModelChild.id });
+
+        insertPhysicalElement({ builder, modelId: physicalModel.id, categoryId: category.id });
+
+        return { definitionContainer, definitionContainerChild, category };
+      });
+      await validateHierarchy({
+        provider: createCategoryTreeProvider(imodel, "3d"),
+        expect: [
+          NodeValidators.createForInstanceNode({
+            instanceKeys: [keys.definitionContainer],
+            supportsFiltering: true,
+            children: [
+              NodeValidators.createForInstanceNode({
+                instanceKeys: [keys.definitionContainerChild],
+                label: "DefinitionContainerChild",
+                children: [
+                  NodeValidators.createForInstanceNode({
+                    instanceKeys: [keys.category],
+                    label: "SpatialCategory",
+                    children: false,
+                  }),
+                ],
+              }),
+            ],
+          }),
+        ],
+      });
+    });
+
+    it("shows root categories and definition container", async function () {
+      const { imodel, ...keys } = await buildIModel(this, async (builder) => {
+        const physicalModel = insertPhysicalModelWithPartition({ builder, codeValue: "TestPhysicalModel" });
+        const definitionContainer = insertDefinitionContainer({ builder, codeValue: "DefinitionContainer" });
+        const definitionModel = insertSubModel({ builder, classFullName: "BisCore.DefinitionModel", modeledElementId: definitionContainer.id });
+
+        const category = insertSpatialCategory({ builder, codeValue: "SpatialCategory" });
+        const childCategory = insertSpatialCategory({ builder, codeValue: "ScChild", modelId: definitionModel.id });
+
+        insertPhysicalElement({ builder, modelId: physicalModel.id, categoryId: category.id });
+        insertPhysicalElement({ builder, modelId: physicalModel.id, categoryId: childCategory.id });
+
+        return { category, definitionContainer, childCategory };
+      });
+      await validateHierarchy({
+        provider: createCategoryTreeProvider(imodel, "3d"),
+        expect: [
+          NodeValidators.createForInstanceNode({
+            instanceKeys: [keys.definitionContainer],
+            supportsFiltering: true,
+            children: [
+              NodeValidators.createForInstanceNode({
+                instanceKeys: [keys.childCategory],
+                label: "ScChild",
+                children: false,
+              }),
+            ],
+          }),
+          NodeValidators.createForInstanceNode({
+            instanceKeys: [keys.category],
+            supportsFiltering: true,
+            children: false,
+          }),
+        ],
+      });
+    });
+
     it("does not show private 3d subCategories", async function () {
       const { imodel, ...keys } = await buildIModel(this, async (builder) => {
         const physicalModel = insertPhysicalModelWithPartition({ builder, codeValue: "TestPhysicalModel" });
@@ -162,6 +367,6 @@ function createCategoryTreeProvider(imodel: IModelConnection, viewType: "2d" | "
   const imodelAccess = createIModelAccess(imodel);
   return createIModelHierarchyProvider({
     imodelAccess,
-    hierarchyDefinition: new CategoriesTreeDefinition({ imodelAccess, viewType }),
+    hierarchyDefinition: new CategoriesTreeDefinition({ imodelAccess, viewType, idsCache: new CategoriesTreeIdsCache(imodelAccess, viewType) }),
   });
 }