bimatter-viewer-react 0.5.11 → 0.5.13

package/README.md

@@ -268,6 +268,32 @@ Use `viewerRef.current.colors` to apply temporary color overrides to model eleme
 
 ```tsx
 viewerRef.current?.colors.setColor(0, [10, 20, 30], "#ff3355");
+viewerRef.current?.colors.rebuildByColors({
+    0: {
+        "#ff3355": [10, 20, 30],
+        "#3b82f6": [40, 50],
+    },
+    1: {
+        "#22c55e": [10, 20],
+    },
+});
+viewerRef.current?.colors.rebuildByColors(
+    {
+        0: {
+            "#ff3355": [10, 20, 30],
+            "#3b82f6": [40, 50],
+        },
+    },
+    "#d1d5db",
+);
+viewerRef.current?.colors.rebuildModelByColors(
+    0,
+    {
+        "#ff3355": [10, 20, 30],
+        "#3b82f6": [40, 50],
+    },
+    "#d1d5db",
+);
 viewerRef.current?.colors.clearColor(0, [10, 20]);
 viewerRef.current?.colors.clearModelColors(0);
 viewerRef.current?.colors.clearAllColors();
@@ -455,6 +481,56 @@ With `ofLevel(level)`, `toElements()` returns `{ elementID, props }[]` and `toEl
 
 `ofType()` accepts `IfcClass | string`, so TypeScript suggests IFC classes like `"IfcWall"` while still allowing custom type strings.
 
+## Using Colorize With Collectors
+
+Collectors can be used directly as color inputs. This is useful when you want to highlight elements by IFC type, level, or property value:
+
+```tsx
+const viewer = viewerRef.current;
+
+viewer?.colors.rebuildModelByColors(
+    0,
+    {
+        "#ff3355":
+            viewer.selector
+                .collector()
+                .ofModel(0)
+                .Where((element) => {
+                    return (
+                        viewer.properties.getParamValueByName(
+                            element.props,
+                            "System Name",
+                            "Mechanical",
+                        ) === "Mechanical Supply Air 2"
+                    );
+                })
+                .toElementsIds() ?? [],
+    },
+    "#d1d5db",
+);
+```
+
+You can also combine level filters with type filters:
+
+```tsx
+const viewer = viewerRef.current;
+const firstLevel = viewer?.properties.getAllModelLevels(0, true)[0];
+
+if (viewer && firstLevel) {
+    viewer.colors.rebuildModelByColors(
+        0,
+        {
+            "#3b82f6": viewer.selector
+                .collector()
+                .ofLevel(firstLevel)
+                .ofType("IfcWall")
+                .toElementsIds(),
+        },
+        "#d1d5db",
+    );
+}
+```
+
 ## Stats And Profiling
 
 Enable FPS stats and console timing logs:

package/lib/{IFCLoader-B_gBDDmN.js → IFCLoader-RIJas-B5.js}

@@ -191328,60 +191328,61 @@ var h_ = class {
 	constructor(e) {
 		this.parser = e;
 	}
-	async serializeAllProperties(e, t) {
-		return await this.getPropertiesAsBlobs(e, t);
-	}
-	async getPropertiesAsBlobs(e, t) {
-		let n = await this.getAllRelDefinesByProps(e), r = {}, i = this.parser.GetLineIDsWithType(e, yd).get(0);
-		if (i === void 0) return r;
-		let a = await this.getItemProperty(e, i) ?? {
-			id: i,
+	async serializeAllProperties(e, t, n) {
+		return await this.getPropertiesAsBlobs(e, t, n);
+	}
+	async getPropertiesAsBlobs(e, t, n) {
+		let r = await this.getAllRelDefinesByProps(e), i = r.size, a = t.size, o = {}, s = this.parser.GetLineIDsWithType(e, yd).get(0);
+		if (s === void 0) return o;
+		let c = await this.getItemProperty(e, s) ?? {
+			id: s,
 			props: {},
 			sets: []
 		};
-		a.sets = [], r[i] = a;
-		for (let t of n) {
-			let n = await this.getItemProperty(e, t);
-			if (n) {
-				let t = p_(n.RelatingPropertyDefinition);
+		c.sets = [], o[s] = c;
+		let l = 0;
+		for (let t of r) {
+			let r = await this.getItemProperty(e, t);
+			if (r) {
+				let t = p_(r.RelatingPropertyDefinition);
 				if (t === null) continue;
-				let i = await this.getItemProperty(e, t, !0), a = {
+				let n = await this.getItemProperty(e, t, !0), i = {
 					id: t,
 					guid: "null",
 					name: "null",
 					props: [],
 					isQuantities: !1
 				};
-				if (i && (i.HasProperties || i.Quantities)) {
-					if (i.Quantities) for (let e of i.Quantities) this.formatItemProperties(e);
-					if (i.HasProperties) for (let e of i.HasProperties) this.formatItemProperties(e);
-					a = {
+				if (n && (n.HasProperties || n.Quantities)) {
+					if (n.Quantities) for (let e of n.Quantities) this.formatItemProperties(e);
+					if (n.HasProperties) for (let e of n.HasProperties) this.formatItemProperties(e);
+					i = {
 						id: t,
-						guid: this.getStringValue(i.GlobalId) ?? "null",
-						name: this.getStringValue(i.Name) ?? "null",
-						props: i.HasProperties ? i.HasProperties : i.Quantities ? i.Quantities : [],
-						isQuantities: !!i.Quantities
+						guid: this.getStringValue(n.GlobalId) ?? "null",
+						name: this.getStringValue(n.Name) ?? "null",
+						props: n.HasProperties ? n.HasProperties : n.Quantities ? n.Quantities : [],
+						isQuantities: !!n.Quantities
 					};
 				}
-				let o = m_(n.RelatedObjects);
-				for (let t of o) if (r[t]) r[t].sets ??= [], r[t].sets.push(a);
+				let a = m_(r.RelatedObjects);
+				for (let t of a) if (o[t]) o[t].sets ??= [], o[t].sets.push(i);
 				else {
 					let n = await this.getItemProperty(e, t);
 					if (n) {
-						let e = this.getStringValue(n.GlobalId), i = n.Name, o = n.ObjectType, s = n.LongName, c = this.getStringValue(n.type), l = {
-							name: i,
-							typeName: o,
+						let e = this.getStringValue(n.GlobalId), r = n.Name, a = n.ObjectType, s = n.LongName, c = this.getStringValue(n.type), l = {
+							name: r,
+							typeName: a,
 							longName: s,
 							type: c,
 							elevation: void 0
 						};
-						r[t] = {
+						o[t] = {
 							id: t,
 							guid: e,
 							props: l,
-							sets: [a]
+							sets: [i]
 						}, c === "IfcBuildingStorey" && (l.elevation = n.Elevation);
-					} else r[t] = {
+					} else o[t] = {
 						id: t,
 						guid: "null",
 						props: {
@@ -191391,16 +191392,29 @@ var h_ = class {
 							type: "null",
 							elevation: void 0
 						},
-						sets: [a]
+						sets: [i]
 					};
 				}
 			}
+			l += 1, this.shouldEmitProgress(l, i) && n?.({
+				loaded: l,
+				phase: "propertySets",
+				total: i
+			});
 		}
-		for (let n of t) {
-			if (r[n]) continue;
-			let t = await this.getItemProperty(e, n);
-			t ? r[n] = {
-				id: n,
+		let u = 0;
+		for (let r of t) {
+			if (o[r]) {
+				u += 1, this.shouldEmitProgress(u, a) && n?.({
+					loaded: u,
+					phase: "elements",
+					total: a
+				});
+				continue;
+			}
+			let t = await this.getItemProperty(e, r);
+			t ? o[r] = {
+				id: r,
 				guid: this.getStringValue(t.GlobalId),
 				props: {
 					name: t.Name,
@@ -191410,8 +191424,8 @@ var h_ = class {
 					elevation: void 0
 				},
 				sets: []
-			} : r[n] = {
-				id: n,
+			} : o[r] = {
+				id: r,
 				guid: "null",
 				props: {
 					name: "null",
@@ -191421,9 +191435,13 @@ var h_ = class {
 					elevation: void 0
 				},
 				sets: []
-			};
+			}, u += 1, this.shouldEmitProgress(u, a) && n?.({
+				loaded: u,
+				phase: "elements",
+				total: a
+			});
 		}
-		return r;
+		return o;
 	}
 	async getItemProperty(e, t, n = !1) {
 		try {
@@ -191585,6 +191603,9 @@ var h_ = class {
 		let i = m_(n[t.related]);
 		e[r] == null ? e[r] = i : e[r] = e[r].concat(i);
 	}
+	shouldEmitProgress(e, t) {
+		return t <= 0 || e <= 0 || e >= t ? !0 : e % Math.max(1, Math.floor(t / 100)) === 0;
+	}
 };
 //#endregion
 //#region src/viewer/Loaders/IFCLoader/IfcGrid.ts
@@ -191820,7 +191841,7 @@ var __ = class {
 				n && (d[t] = this.transformGridData(n, l));
 			}
 			r?.onPhase?.("properties");
-			let f = await this.propertySerializer.serializeAllProperties(a, o), p = await this.propertySerializer.getSpatialStructure(a, !1);
+			let f = await this.propertySerializer.serializeAllProperties(a, o, r?.onPropertiesProgress), p = await this.propertySerializer.getSpatialStructure(a, !1);
 			return c.coordinationMatrix ??= this.coordinationMatrixData, c.props = f, c.structure = p, c.grids = d, {
 				structure: p,
 				propsData: f,

package/lib/Loaders/BmtConverter.d.ts

@@ -11,6 +11,16 @@ export type BmtActiveViewFilterParams = {
     modelID: number;
 };
 export type BmtActiveViewFilter = (params: BmtActiveViewFilterParams) => boolean;
+export type BmtConverterProgressPhase = "preparing" | "filtering" | "properties" | "geometry" | "metadata" | "writing" | "complete";
+export type BmtConverterProgressEvent = {
+    loaded?: number;
+    message?: string;
+    modelID: number;
+    modelIndex: number;
+    phase: BmtConverterProgressPhase;
+    progress: number;
+    total?: number;
+};
 export type BmtConverterOptions = {
     activeView?: boolean;
     activeViewRoot?: Object3D | Object3D[] | null;
@@ -20,6 +30,7 @@ export type BmtConverterOptions = {
     fileNames?: Record<string | number, string>;
     filterElement?: BmtActiveViewFilter;
     maxMeshBytes?: number;
+    onProgress?: (progress: BmtConverterProgressEvent) => void;
     useIfcColors?: boolean;
     useIfcElementAssembly?: boolean;
     useIfcSpace?: boolean;
@@ -89,6 +100,8 @@ export declare class BmtConverter {
     private deflateBytes;
     private encodeText;
     private encodePrettyJson;
+    private shouldEmitItemProgress;
+    private clampProgress;
     private isRecord;
 }
 export declare const bmtConverter: BmtConverter;

package/lib/Loaders/IFCLoader/IFCLoader.d.ts

@@ -1,4 +1,4 @@
-import { type IfcElementsAssembly } from "./PropertySerializer";
+import { type IfcElementsAssembly, type IfcPropertiesProgressData } from "./PropertySerializer";
 import { Matrix4 } from "three";
 import { IfcAPI, type LocateFileHandlerFn } from "web-ifc";
 import { type GridData } from "./IfcGrid";
@@ -30,11 +30,13 @@ export type IfcGeometryProgressData = {
     processed: number;
     total: number;
 };
+export type IfcPropertyProgressData = IfcPropertiesProgressData;
 export type IfcParsePhase = "opening" | "opened" | "streaming" | "properties" | "metadata";
 export type IfcParseCallbacks = {
     onGeometryChunk?: (chunk: IfcGeometryChunkData) => void;
     onGeometryProgress?: (progress: IfcGeometryProgressData) => void;
     onPhase?: (phase: IfcParsePhase) => void;
+    onPropertiesProgress?: (progress: IfcPropertyProgressData) => void;
     streamGeometryChunks?: boolean;
 };
 export declare class IFCLoader {

package/lib/Loaders/IFCLoader/PropertySerializer.d.ts

@@ -30,12 +30,18 @@ export type IfcElementsAssembly = {
     dict: Record<number, number>;
     ids: number[];
 };
+export type IfcPropertiesProgressData = {
+    loaded: number;
+    phase: "propertySets" | "elements";
+    total: number;
+};
+export type IfcPropertiesProgressCallback = (progress: IfcPropertiesProgressData) => void;
 export declare class PropertySerializer {
     private PropsNames;
     readonly parser: IfcAPI;
     constructor(parser: IfcAPI);
-    serializeAllProperties(modelID: number, ids: Set<number>): Promise<BmtModelProps>;
-    getPropertiesAsBlobs(modelID: number, ids: Set<number>): Promise<BmtModelProps>;
+    serializeAllProperties(modelID: number, ids: Set<number>, onProgress?: IfcPropertiesProgressCallback): Promise<BmtModelProps>;
+    getPropertiesAsBlobs(modelID: number, ids: Set<number>, onProgress?: IfcPropertiesProgressCallback): Promise<BmtModelProps>;
     getItemProperty(modelID: number, id: number, flatten?: boolean): Promise<IfcLineData | null>;
     getElementsAssembly(modelID: number): Promise<IfcElementsAssembly>;
     private formatItemProperties;
@@ -53,5 +59,6 @@ export declare class PropertySerializer {
     newNode(id: number, data: IfcLineData): BmtModelStructureNode;
     getSpatialTreeChunks(modelID: number): Promise<SpatialTreeChunks>;
     saveChunk(chunks: SpatialTreeChunks, propNames: PropertyRelationConfig, rel: IfcLineData): void;
+    private shouldEmitProgress;
 }
 export {};

package/lib/Selector/useSelector.d.ts

@@ -1,3 +1,4 @@
+import { type Vector3 } from "three";
 import type { CameraUtilsApi } from "../Camera/useCameraUtils";
 import type { ViewerControlsRef, ViewerModelRef } from "../types";
-export default function useSelector(modelRef: ViewerModelRef, controlRef: ViewerControlsRef, cameraUtils: CameraUtilsApi): void;
+export default function useSelector(modelRef: ViewerModelRef, controlRef: ViewerControlsRef, cameraUtils: CameraUtilsApi, setSelectionOrbitPoint?: (point: Vector3) => void): void;

package/lib/api/ViewerApi.d.ts

@@ -2,11 +2,13 @@ import type { ColorRepresentation } from "three";
 import type { SelectedStore, UserDevice, ViewerGridAxesVisibility, ViewerGridAxisSide, ViewerStoreApi } from "../store/ViewerStore";
 import { type ViewerPropertiesApi } from "./ViewerPropertiesApi";
 import type { ViewerClippingApi } from "../utils/ClippingUtils";
+import type { ViewerColorConfigByModel, ViewerModelColorConfig } from "../utils/ColorsUtils/useElementColors";
 import type { ViewerDimensionsApi } from "../utils/DimentionsUtils";
 import type { ViewerCameraGetIntersection } from "../Camera/useCameraUtils";
 import type { BmtConversionResult, BmtConverterOptions, BmtConverterSource } from "../Loaders/BmtConverter";
 import { FilteredElementsCollector } from "../Selector/FilteredElementsCollector";
 export type { ViewerClippingApi } from "../utils/ClippingUtils";
+export type { ViewerColorConfigByModel, ViewerModelColorConfig, } from "../utils/ColorsUtils/useElementColors";
 export type { ViewerDimensionsApi } from "../utils/DimentionsUtils";
 export type { ViewerCameraGetIntersection } from "../Camera/useCameraUtils";
 export type ViewerSelection = Record<number, number[]>;
@@ -42,6 +44,8 @@ export type ViewerColorsApi = {
     clearAllColors: () => void;
     clearColor: (modelID: number, ids: number[]) => void;
     clearModelColors: (modelID: number) => void;
+    rebuildByColors: (colorsByModel: ViewerColorConfigByModel, defaultColor?: ColorRepresentation) => void;
+    rebuildModelByColors: (modelID: number, colorsByIds: ViewerModelColorConfig, defaultColor?: ColorRepresentation) => void;
     setColor: (modelID: number, ids: number[], color: ColorRepresentation) => void;
 };
 export type ViewerUtilsApi = {

package/lib/api/ViewerPropertiesApi.d.ts

@@ -1,6 +1,6 @@
 import type { ViewerModelPropsStore, ViewerModelStructureStore, ViewerStoreApi } from "../store/ViewerStore";
 import { type ExportedExcelFile, type ModelPropertiesExcelOptions } from "../utils/ExportUtils";
-import type { BmtModelStructureNode, BmtPropertyRecord, BmtPropertySet, BmtPropertyValue } from "../Loaders/BmtLoader";
+import type { BmtElementProps, BmtModelStructureNode, BmtPropertyRecord, BmtPropertySet, BmtPropertyValue } from "../Loaders/BmtLoader";
 export type ViewerPropertiesExcelOptions = ModelPropertiesExcelOptions;
 type ViewerModelLevelValue = BmtModelStructureNode[] | BmtPropertyRecord | BmtPropertySet[] | BmtPropertyValue;
 export type ViewerModelLevel = Record<string, ViewerModelLevelValue | undefined> & {
@@ -15,6 +15,9 @@ export type ViewerPropertiesApi = {
     getAllModelLevels: (modelID: number, recursive?: boolean) => ViewerModelLevel[];
     getModelProps: () => ViewerModelPropsStore;
     getModelStructure: () => ViewerModelStructureStore;
+    getParamsByElement: (modelID: number, elementID: number) => BmtElementProps | undefined;
+    getParamValueByName: (elementParams: BmtElementProps | null | undefined, paramName: string, setName?: string) => BmtPropertyValue | undefined;
+    getParamValueByElement: (modelID: number, elementID: number, paramName: string, setName?: string) => BmtPropertyValue | undefined;
 };
 export declare function createViewerPropertiesApi(viewerStore: ViewerStoreApi): ViewerPropertiesApi;
 export {};