Merge branch 'tree-widget/next' into mast/classifications-tree-rename-action

Author: MartynasStrazdas

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

@@ -56,7 +56,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect(await idsCache.getDirectChildDefinitionContainersAndCategories([keys.definitionContainer.id])).to.deep.eq({
+      expect(await idsCache.getDirectChildDefinitionContainersAndCategories(keys.definitionContainer.id)).to.deep.eq({
         categories: [],
         definitionContainers: [],
       });
@@ -73,7 +73,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect(await idsCache.getDirectChildDefinitionContainersAndCategories([keys.definitionContainerRoot.id])).to.deep.eq({
+      expect(await idsCache.getDirectChildDefinitionContainersAndCategories(keys.definitionContainerRoot.id)).to.deep.eq({
         categories: [],
         definitionContainers: [],
       });
@@ -93,7 +93,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect(await idsCache.getDirectChildDefinitionContainersAndCategories([keys.definitionContainerRoot.id])).to.deep.eq({
+      expect(await idsCache.getDirectChildDefinitionContainersAndCategories(keys.definitionContainerRoot.id)).to.deep.eq({
         categories: [],
         definitionContainers: [keys.definitionContainerChild.id],
       });
@@ -111,7 +111,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect(await idsCache.getDirectChildDefinitionContainersAndCategories([keys.definitionContainerRoot.id])).to.deep.eq({
+      expect(await idsCache.getDirectChildDefinitionContainersAndCategories(keys.definitionContainerRoot.id)).to.deep.eq({
         categories: [{ id: keys.category.id, subCategoryChildCount: 1 }],
         definitionContainers: [],
       });
@@ -131,7 +131,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect(await idsCache.getDirectChildDefinitionContainersAndCategories([keys.definitionContainerRoot.id])).to.deep.eq({
+      expect(await idsCache.getDirectChildDefinitionContainersAndCategories(keys.definitionContainerRoot.id)).to.deep.eq({
         categories: [{ id: keys.category.id, subCategoryChildCount: 1 }],
         definitionContainers: [],
       });
@@ -154,7 +154,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect(await idsCache.getDirectChildDefinitionContainersAndCategories([keys.definitionContainerRoot.id])).to.deep.eq({
+      expect(await idsCache.getDirectChildDefinitionContainersAndCategories(keys.definitionContainerRoot.id)).to.deep.eq({
         categories: [{ id: keys.directCategory.id, subCategoryChildCount: 1 }],
         definitionContainers: [keys.definitionModelChild.id],
       });
@@ -175,7 +175,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect(await idsCache.getDirectChildDefinitionContainersAndCategories([keys.definitionModelChild.id])).to.deep.eq({
+      expect(await idsCache.getDirectChildDefinitionContainersAndCategories(keys.definitionModelChild.id)).to.deep.eq({
         categories: [{ id: keys.indirectCategory.id, subCategoryChildCount: 1 }],
         definitionContainers: [],
       });
@@ -193,7 +193,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect(await idsCache.getAllContainedCategories([keys.definitionContainer.id])).to.deep.eq([]);
+      expect(await idsCache.getAllContainedCategories(keys.definitionContainer.id)).to.deep.eq([]);
     });
 
     it("returns indirectly contained categories when definition container contains definition container that has categories", async function () {
@@ -210,7 +210,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect(await idsCache.getAllContainedCategories([keys.definitionContainerRoot.id])).to.deep.eq([keys.category.id]);
+      expect(await idsCache.getAllContainedCategories(keys.definitionContainerRoot.id)).to.deep.eq([keys.category.id]);
     });
 
     it("returns child categories when definition container contains categories", async function () {
@@ -225,7 +225,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect(await idsCache.getAllContainedCategories([keys.definitionContainer.id])).to.deep.eq([keys.category.id]);
+      expect(await idsCache.getAllContainedCategories(keys.definitionContainer.id)).to.deep.eq([keys.category.id]);
     });
 
     it("returns direct and indirect categories when definition container contains categories and definition containers that contain categories", async function () {
@@ -245,7 +245,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      const result = await idsCache.getAllContainedCategories([keys.definitionContainerRoot.id]);
+      const result = await idsCache.getAllContainedCategories(keys.definitionContainerRoot.id);
       const expectedResult = [keys.indirectCategory.id, keys.directCategory.id];
       expect(expectedResult.every((id) => result.includes(id))).to.be.true;
     });
@@ -708,7 +708,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect([...getDistinctMapValues(await idsCache.getSubCategories(["0x123"]))]).to.deep.eq([]);
+      expect([...getDistinctMapValues(await idsCache.getSubCategories("0x123"))]).to.deep.eq([]);
     });
 
     it("returns empty list when category has one subCategory", async function () {
@@ -720,7 +720,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      expect([...getDistinctMapValues(await idsCache.getSubCategories([keys.category.id]))]).to.deep.eq([]);
+      expect([...getDistinctMapValues(await idsCache.getSubCategories(keys.category.id))]).to.deep.eq([]);
     });
 
     it("returns subCategories when category has multiple subCategories", async function () {
@@ -734,7 +734,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      const result = [...getDistinctMapValues(await idsCache.getSubCategories([keys.category.id]))];
+      const result = [...getDistinctMapValues(await idsCache.getSubCategories(keys.category.id))];
       expect(result.includes(keys.subCategory.id)).to.be.true;
       expect(result.length).to.be.eq(2);
     });
@@ -754,7 +754,7 @@ describe("CategoriesTreeIdsCache", () => {
       });
       const { imodel, ...keys } = buildIModelResult;
       using idsCache = new CategoriesTreeIdsCache(createIModelAccess(imodel), "3d");
-      const result = [...getDistinctMapValues(await idsCache.getSubCategories([keys.category2.id]))];
+      const result = [...getDistinctMapValues(await idsCache.getSubCategories(keys.category2.id))];
       expect(result.includes(keys.subCategory2.id)).to.be.true;
       expect(result.length).to.be.eq(2);
     });

packages/itwin/tree-widget/src/test/trees/models-tree/Utils.ts

@@ -5,6 +5,7 @@
 
 import { concatMap, EMPTY, expand, firstValueFrom, from, toArray } from "rxjs";
 import sinon from "sinon";
+import { Id64 } from "@itwin/core-bentley";
 import { createIModelHierarchyProvider } from "@itwin/presentation-hierarchies";
 import {
   CLASS_NAME_Element,
@@ -87,17 +88,17 @@ interface IdsCacheMockProps {
 
 export function createFakeIdsCache(props?: IdsCacheMockProps): ModelsTreeIdsCache {
   return sinon.createStubInstance(ModelsTreeIdsCache, {
-    getChildSubjectIds: sinon.stub<[Id64Array], Promise<Id64Array>>().callsFake(async (subjectIds) => {
-      const obs = from(subjectIds).pipe(
+    getChildSubjectIds: sinon.stub<[Id64Arg], Promise<Id64Array>>().callsFake(async (subjectIds) => {
+      const obs = from(Id64.iterable(subjectIds)).pipe(
         concatMap((id) => props?.subjectsHierarchy?.get(id) ?? EMPTY),
         expand((id) => props?.subjectsHierarchy?.get(id) ?? EMPTY),
         toArray(),
       );
       return firstValueFrom(obs);
     }),
     getChildSubjectModelIds: sinon.stub(),
-    getSubjectModelIds: sinon.stub<[Id64Array], Promise<Id64Array>>().callsFake(async (subjectIds) => {
-      const obs = from(subjectIds).pipe(
+    getSubjectModelIds: sinon.stub<[Id64Arg], Promise<Id64Array>>().callsFake(async (subjectIds) => {
+      const obs = from(Id64.iterable(subjectIds)).pipe(
         expand((id) => props?.subjectsHierarchy?.get(id) ?? EMPTY),
         concatMap((id) => props?.subjectModels?.get(id) ?? EMPTY),
         toArray(),

packages/itwin/tree-widget/src/tree-widget-react/components/trees/categories-tree/internal/CategoriesTreeIdsCache.ts

@@ -3,12 +3,13 @@
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
 
+import { Id64 } from "@itwin/core-bentley";
 import { CLASS_NAME_DefinitionContainer, CLASS_NAME_Model, CLASS_NAME_SubCategory } from "../../common/internal/ClassNameDefinitions.js";
 import { ModelCategoryElementsCountCache } from "../../common/internal/ModelCategoryElementsCountCache.js";
-import { getClassesByView, getDistinctMapValues } from "../../common/internal/Utils.js";
+import { getClassesByView, getDistinctMapValues, joinId64Arg } from "../../common/internal/Utils.js";
 
+import type { Id64Arg, Id64Array, Id64Set, Id64String } from "@itwin/core-bentley";
 import type { CategoryId, DefinitionContainerId, ElementId, ModelId, SubCategoryId } from "../../common/internal/Types.js";
-import type { Id64Array, Id64Set, Id64String } from "@itwin/core-bentley";
 import type { LimitingECSqlQueryExecutor } from "@itwin/presentation-hierarchies";
 import type { InstanceKey } from "@itwin/presentation-shared";
 
@@ -65,22 +66,22 @@ export class CategoriesTreeIdsCache implements Disposable {
     this._categoryElementCounts[Symbol.dispose]();
   }
 
-  private async *queryFilteredElementsModels(filteredElementIds: Id64Array): AsyncIterableIterator<{
+  private async *queryFilteredElementsModels(filteredElementIds: Id64Arg): AsyncIterableIterator<{
     modelId: Id64String;
     id: ElementId;
   }> {
     const query = `
       SELECT Model.Id modelId, ECInstanceId id
       FROM ${this._categoryElementClass}
-      WHERE ECInstanceId IN (${filteredElementIds.join(", ")})
+      WHERE ECInstanceId IN (${joinId64Arg(filteredElementIds, ",")})
     `;
     for await (const row of this._queryExecutor.createQueryReader({ ecsql: query }, { rowFormat: "ECSqlPropertyNames", limit: "unbounded" })) {
       yield { modelId: row.modelId, id: row.id };
     }
   }
 
-  public async getFilteredElementsModels(filteredElementIds: Id64Array) {
-    if (filteredElementIds.length === 0) {
+  public async getFilteredElementsModels(filteredElementIds: Id64Arg) {
+    if (Id64.sizeOf(filteredElementIds) === 0) {
       return new Map<ElementId, ModelId>();
     }
 
@@ -329,10 +330,10 @@ export class CategoriesTreeIdsCache implements Disposable {
     return this._modelWithCategoryModeledElements;
   }
 
-  public async getCategoriesModeledElements(modelId: Id64String, categoryIds: Id64Array): Promise<Id64Array> {
+  public async getCategoriesModeledElements(modelId: Id64String, categoryIds: Id64Arg): Promise<Id64Array> {
     const modelWithCategoryModeledElements = await this.getModelWithCategoryModeledElements();
     const result = new Array<ElementId>();
-    for (const categoryId of categoryIds) {
+    for (const categoryId of Id64.iterable(categoryIds)) {
       const entry = modelWithCategoryModeledElements.get(`${modelId}-${categoryId}`);
       if (entry !== undefined) {
         result.push(...entry);
@@ -400,26 +401,26 @@ export class CategoriesTreeIdsCache implements Disposable {
   }
 
   public async getDirectChildDefinitionContainersAndCategories(
-    parentDefinitionContainerIds: Id64Array,
+    parentDefinitionContainerIds: Id64Arg,
   ): Promise<{ categories: CategoryInfo[]; definitionContainers: Array<DefinitionContainerId> }> {
     const definitionContainersInfo = await this.getDefinitionContainersInfo();
 
     const result = { definitionContainers: new Array<DefinitionContainerId>(), categories: new Array<CategoryInfo>() };
-
-    parentDefinitionContainerIds.forEach((parentDefinitionContainerId) => {
+    for (const parentDefinitionContainerId of Id64.iterable(parentDefinitionContainerIds)) {
       const parentDefinitionContainerInfo = definitionContainersInfo.get(parentDefinitionContainerId);
-      if (parentDefinitionContainerInfo !== undefined) {
-        result.definitionContainers.push(...parentDefinitionContainerInfo.childDefinitionContainerIds);
-        result.categories.push(...parentDefinitionContainerInfo.childCategories);
+      if (!parentDefinitionContainerInfo) {
+        continue;
       }
-    });
+      result.definitionContainers.push(...parentDefinitionContainerInfo.childDefinitionContainerIds);
+      result.categories.push(...parentDefinitionContainerInfo.childCategories);
+    }
     return result;
   }
 
-  public async getCategoriesElementModels(categoryIds: Id64Array, includeSubModels?: boolean): Promise<Map<CategoryId, Set<ModelId>>> {
+  public async getCategoriesElementModels(categoryIds: Id64Arg, includeSubModels?: boolean): Promise<Map<CategoryId, Set<ModelId>>> {
     const elementModelsCategories = await this.getElementModelsCategories();
     const result = new Map<CategoryId, Set<ModelId>>();
-    for (const categoryId of categoryIds) {
+    for (const categoryId of Id64.iterable(categoryIds)) {
       for (const [modelId, { categoryIds: categories, isSubModel }] of elementModelsCategories) {
         if ((includeSubModels || !isSubModel) && categories.has(categoryId)) {
           let categoryModels = result.get(categoryId);
@@ -444,20 +445,21 @@ export class CategoriesTreeIdsCache implements Disposable {
     return elementModelsCategories.has(elementId);
   }
 
-  public async getAllContainedCategories(definitionContainerIds: Id64Array): Promise<Id64Array> {
+  public async getAllContainedCategories(definitionContainerIds: Id64Arg): Promise<Id64Array> {
     const result = new Array<CategoryId>();
 
     const definitionContainersInfo = await this.getDefinitionContainersInfo();
-    const indirectCategories = await Promise.all(
-      definitionContainerIds.map(async (definitionContainerId) => {
-        const definitionContainerInfo = definitionContainersInfo.get(definitionContainerId);
-        if (definitionContainerInfo === undefined) {
-          return [];
-        }
-        result.push(...definitionContainerInfo.childCategories.map((category) => category.id));
-        return this.getAllContainedCategories(definitionContainerInfo.childDefinitionContainerIds);
-      }),
-    );
+    const indirectCategoryPromises = new Array<Promise<Id64Array>>();
+    for (const definitionContainerId of Id64.iterable(definitionContainerIds)) {
+      const definitionContainerInfo = definitionContainersInfo.get(definitionContainerId);
+      if (definitionContainerInfo === undefined) {
+        continue;
+      }
+      result.push(...definitionContainerInfo.childCategories.map((category) => category.id));
+      indirectCategoryPromises.push(this.getAllContainedCategories(definitionContainerInfo.childDefinitionContainerIds));
+    }
+
+    const indirectCategories = await Promise.all(indirectCategoryPromises);
     for (const categories of indirectCategories) {
       result.push(...categories);
     }
@@ -538,10 +540,10 @@ export class CategoriesTreeIdsCache implements Disposable {
     return result;
   }
 
-  public async getSubCategories(categoryIds: Id64Array): Promise<Map<CategoryId, Array<SubCategoryId>>> {
+  public async getSubCategories(categoryIds: Id64Arg): Promise<Map<CategoryId, Array<SubCategoryId>>> {
     const subCategoriesInfo = await this.getSubCategoriesInfo();
     const result = new Map<CategoryId, Array<SubCategoryId>>();
-    for (const categoryId of categoryIds) {
+    for (const categoryId of Id64.iterable(categoryIds)) {
       for (const [subCategoryId, subCategoryInfo] of subCategoriesInfo) {
         if (subCategoryInfo.categoryId === categoryId) {
           let categoryEntry = result.get(categoryId);