bimatter-viewer-react 0.11.0 → 0.11.2

package/lib/{IFCLoader-D_jyTADr.js → IFCLoader-N1C1bJ4O.js}

@@ -191330,39 +191330,39 @@ var y_ = class {
 	constructor(e) {
 		this.parser = e;
 	}
-	async serializeAllProperties(e, t, n) {
-		return this.clearPropertyCaches(), await this.getPropertiesAsBlobs(e, t, n);
+	async serializeAllProperties(e, t, n, r) {
+		return this.clearPropertyCaches(), await this.getPropertiesAsBlobs(e, t, n, r);
 	}
 	resetCaches() {
 		this.clearPropertyCaches(), this.spatialLinesCache.clear(), this.spatialTreeChunksCache.clear();
 	}
-	async getPropertiesAsBlobs(e, t, n) {
-		let r = await this.getAllRelDefinesByProps(e), i = r.size, a = t.size, o = {}, s = this.parser.GetLineIDsWithType(e, Sd).get(0);
-		if (s === void 0) return o;
-		let c = await this.getItemPropertiesBatch(e, r), l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set();
-		for (let e of c.values()) {
+	async getPropertiesAsBlobs(e, t, n, r) {
+		let i = await this.getAllRelDefinesByProps(e), a = i.size, o = t.size, s = {}, c = this.parser.GetLineIDsWithType(e, Sd).get(0);
+		if (c === void 0) return s;
+		let l = await this.getItemPropertiesBatch(e, i), u = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set();
+		for (let e of l.values()) {
 			if (!e) continue;
 			let t = __(e.RelatingPropertyDefinition);
-			t !== null && l.add(t);
-			for (let t of v_(e.RelatedObjects)) u.add(t);
-		}
-		let d = await this.getItemPropertiesBatch(e, l), f = /* @__PURE__ */ new Set();
-		for (let e of d.values()) if (e) {
-			for (let t of v_(e.HasProperties)) f.add(t);
-			for (let t of v_(e.Quantities)) f.add(t);
-		}
-		await this.getItemPropertiesBatch(e, f);
-		let p = new Set(t);
-		for (let e of u) p.add(e);
-		p.add(s), await this.getItemPropertiesBatch(e, p);
-		let m = await this.getItemProperty(e, s) ?? {
-			id: s,
+			t !== null && u.add(t);
+			for (let t of v_(e.RelatedObjects)) d.add(t);
+		}
+		let f = await this.getItemPropertiesBatch(e, u), p = /* @__PURE__ */ new Set();
+		for (let e of f.values()) if (e) {
+			for (let t of v_(e.HasProperties)) p.add(t);
+			for (let t of v_(e.Quantities)) p.add(t);
+		}
+		await this.getItemPropertiesBatch(e, p);
+		let m = new Set(t);
+		for (let e of d) m.add(e);
+		m.add(c), await this.getItemPropertiesBatch(e, m);
+		let ee = await this.getItemProperty(e, c) ?? {
+			id: c,
 			props: {},
 			sets: []
 		};
-		m.sets = [], o[s] = m;
-		let ee = 0;
-		for (let t of r) {
+		ee.sets = [], s[c] = ee;
+		let te = 0;
+		for (let t of i) {
 			let r = await this.getItemProperty(e, t);
 			if (r) {
 				let t = __(r.RelatingPropertyDefinition);
@@ -191382,24 +191382,24 @@ var y_ = class {
 					isQuantities: !!n.Quantities
 				});
 				let a = v_(r.RelatedObjects);
-				for (let t of a) if (o[t]) o[t].sets ??= [], o[t].sets.push(i);
+				for (let t of a) if (s[t]) s[t].sets ??= [], s[t].sets.push(i);
 				else {
 					let n = await this.getItemProperty(e, t);
 					if (n) {
-						let e = this.getStringValue(n.GlobalId), r = n.Name, a = n.ObjectType, s = n.LongName, c = this.getStringValue(n.type), l = {
+						let e = this.getStringValue(n.GlobalId), r = n.Name, a = n.ObjectType, o = n.LongName, c = this.getStringValue(n.type), l = {
 							name: r,
 							typeName: a,
-							longName: s,
+							longName: o,
 							type: c,
 							elevation: void 0
 						};
-						o[t] = {
+						s[t] = {
 							id: t,
 							guid: e,
 							props: l,
 							sets: [i]
 						}, c === "IfcBuildingStorey" && (l.elevation = n.Elevation);
-					} else o[t] = {
+					} else s[t] = {
 						id: t,
 						guid: "null",
 						props: {
@@ -191413,24 +191413,35 @@ var y_ = class {
 					};
 				}
 			}
-			ee += 1, this.shouldEmitProgress(ee, i) && n?.({
-				loaded: ee,
+			te += 1, this.shouldEmitProgress(te, a) && n?.({
+				loaded: te,
 				phase: "propertySets",
-				total: i
+				total: a
 			});
 		}
-		let te = 0;
+		let ne = 0, re = /* @__PURE__ */ new Set(), h = (e) => {
+			if (re.has(e)) return;
+			let t = s[e];
+			t && (re.add(e), r?.({
+				elementID: e,
+				props: t
+			}));
+		};
+		Object.keys(s).forEach((e) => {
+			let t = Number(e);
+			Number.isFinite(t) && h(t);
+		});
 		for (let r of t) {
-			if (o[r]) {
-				te += 1, this.shouldEmitProgress(te, a) && n?.({
-					loaded: te,
+			if (s[r]) {
+				h(r), ne += 1, this.shouldEmitProgress(ne, o) && n?.({
+					loaded: ne,
 					phase: "elements",
-					total: a
+					total: o
 				});
 				continue;
 			}
 			let t = await this.getItemProperty(e, r);
-			t ? o[r] = {
+			t ? s[r] = {
 				id: r,
 				guid: this.getStringValue(t.GlobalId),
 				props: {
@@ -191441,7 +191452,7 @@ var y_ = class {
 					elevation: void 0
 				},
 				sets: []
-			} : o[r] = {
+			} : s[r] = {
 				id: r,
 				guid: "null",
 				props: {
@@ -191452,13 +191463,13 @@ var y_ = class {
 					elevation: void 0
 				},
 				sets: []
-			}, te += 1, this.shouldEmitProgress(te, a) && n?.({
-				loaded: te,
+			}, h(r), ne += 1, this.shouldEmitProgress(ne, o) && n?.({
+				loaded: ne,
 				phase: "elements",
-				total: a
+				total: o
 			});
 		}
-		return o;
+		return s;
 	}
 	async getItemProperty(e, t, n = !1) {
 		let r = this.getItemPropertyCacheKey(e, t, n), i = this.itemPropertyCache.get(r);
@@ -191939,40 +191950,40 @@ var S_ = class {
 	set _parser(e) {
 		this.parser = e, this.propertySerializer = new y_(this.parser), this.parserReady = null;
 	}
-	async loadModel(e, t) {
+	async loadModel(e, t, n) {
 		await this.initParser(this.getPath), this.setCoordinationMatrix(t);
-		let n = Array.isArray(e) ? e : [e], r = {};
-		for (let e = 0; e < n.length; e++) {
+		let r = Array.isArray(e) ? e : [e], i = {};
+		for (let e = 0; e < r.length; e++) {
 			let t = Date.now();
-			r[e] = await this.loadSingleModel(n[e]), r[e].coordinationMatrix ??= this.coordinationMatrixData, console.log(`Loaded by ${Date.now() - t} ms`);
+			i[e] = await this.loadSingleModel(r[e], n), i[e].coordinationMatrix ??= this.coordinationMatrixData, console.log(`Loaded by ${Date.now() - t} ms`);
 		}
-		return r;
+		return i;
 	}
 	async parseBinaryFile(e, t, n) {
 		return await this.initParser(this.getPath), this.setCoordinationMatrix(t), this.parseInitializedBuffer(e, n);
 	}
-	async loadSingleModel(e) {
+	async loadSingleModel(e, t) {
 		if (typeof e == "string") {
-			let { data: t } = await this.getModelData(e);
-			return t;
+			let { data: n } = await this.getModelData(e, t);
+			return n;
 		}
-		return this.parseInitializedBuffer(await e.arrayBuffer());
+		return this.parseInitializedBuffer(await e.arrayBuffer(), t);
 	}
 	async parseInitializedBuffer(e, t) {
 		let n = await this.getModelDataFromBuffer(e, void 0, t);
 		if (!n) throw Error("model loading error");
 		return n.data;
 	}
-	getModelData(e) {
-		return new Promise((t, n) => {
+	getModelData(e, t) {
+		return new Promise((n, r) => {
 			fetch(e).then((e) => e.arrayBuffer()).then(async (e) => {
 				if (this.parser) {
-					let r = await this.getModelDataFromBuffer(e);
-					r ? t(r) : n("model loading error");
+					let i = await this.getModelDataFromBuffer(e, void 0, t);
+					i ? n(i) : r("model loading error");
 				}
-				n("model loading error");
+				r("model loading error");
 			}).catch((e) => {
-				console.log(e), n("model loading error");
+				console.log(e), r("model loading error");
 			});
 		});
 	}
@@ -192030,8 +192041,8 @@ var S_ = class {
 				n && (p[t] = this.transformGridData(n, d));
 			}
 			n?.onPhase?.("properties");
-			let m = await this.propertySerializer.serializeAllProperties(a, c, n?.onPropertiesProgress), ee = await this.propertySerializer.getSpatialStructure(a, !1);
-			return u.coordinationMatrix ??= this.coordinationMatrixData, u.props = m, u.structure = ee, u.grids = p, typeof s == "number" && (u.trueNorthAngle = s), console.log("spend to load ifc data: ", Date.now() - r, "ms"), {
+			let m = await this.propertySerializer.serializeAllProperties(a, c, n?.onPropertiesProgress, n?.onElementPropertiesSerialized), ee = await this.propertySerializer.getSpatialStructure(a, !1);
+			return n?.onStructureSerialized?.(ee), u.coordinationMatrix ??= this.coordinationMatrixData, u.props = m, u.structure = ee, u.grids = p, typeof s == "number" && (u.trueNorthAngle = s), console.log("spend to load ifc data: ", Date.now() - r, "ms"), {
 				structure: ee,
 				propsData: m,
 				data: u,

package/lib/Loaders/BmtConverter.d.ts

@@ -64,6 +64,7 @@ export declare class BmtConverter {
     private getModelFileBaseName;
     private normalizeBaseName;
     private createModelFiles;
+    private createConvertedModelResult;
     private createBmtBytes;
     private writeProps;
     private writeMeshes;
@@ -98,7 +99,6 @@ export declare class BmtConverter {
     private deflateTypedArray;
     private deflateBytes;
     private encodeText;
-    private encodePrettyJson;
     private shouldEmitItemProgress;
     private clampProgress;
     private isRecord;

package/lib/Loaders/BmtExternalMetadataWriter.d.ts

@@ -0,0 +1,17 @@
+import type { BmtElementProps, BmtModelProps, BmtModelStructure } from "./BmtLoader";
+export declare class BmtExternalMetadataWriter {
+    private readonly chunks;
+    private readonly textEncoder;
+    private closed;
+    private length;
+    private propsClosed;
+    private wroteProperty;
+    constructor();
+    writeProperty(elementID: number | string, props: BmtElementProps): void;
+    finish(structure: BmtModelStructure): void;
+    get isClosed(): boolean;
+    toUint8Array(): Uint8Array<ArrayBuffer>;
+    private writeJsonValue;
+    private writeText;
+}
+export declare function createBmtExternalMetadataBytes(props: BmtModelProps, structure: BmtModelStructure): Uint8Array<ArrayBuffer>;

package/lib/Loaders/BmtLoader.d.ts

@@ -61,6 +61,7 @@ export interface BmtModelData {
     coordinationMatrix?: string;
     data: BmtModelGeometryData;
     grids?: ModelGridsData;
+    minVersionMetadataBytes?: Uint8Array;
     name?: string;
     props: BmtModelProps;
     renderSettings?: BmtModelRenderSettings;
@@ -69,6 +70,7 @@ export interface BmtModelData {
 }
 export type BmtGeometryChunkData = {
     chunkIndex: number;
+    coordinationMatrix?: string;
     geometry: BmtGeomData;
     geometryID: number;
     isIfcSpace: boolean;
@@ -119,6 +121,7 @@ export declare class BMTLoader {
     parseMesh(data: Uint8Array): BmtMeshData;
     private getExternalMetadataPath;
     private loadExternalMetadata;
+    private getCoordinationMatrixFromBinary;
     private getModelNameFromPath;
     loadModel(path: string, callbacks?: BmtParseCallbacks): Promise<BmtModelData>;
     parseBinaryFile(data: ArrayBuffer, callbacks?: BmtParseCallbacks): BmtModelData;

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

@@ -1,4 +1,4 @@
-import { type IfcElementsAssembly, type IfcPropertiesProgressData } from "./PropertySerializer";
+import { type IfcElementsAssembly, type IfcPropertiesProgressData, type IfcSerializedElementPropertiesCallback } from "./PropertySerializer";
 import { Matrix4 } from "three";
 import { IfcAPI, type LocateFileHandlerFn } from "web-ifc";
 import { type GridData } from "./IfcGrid";
@@ -21,6 +21,7 @@ export type IfcLoadedModels = Record<number, BmtModelData>;
 export type IfcCoordinationMatrixSource = Matrix4 | number[] | string | null | undefined;
 export type IfcGeometryChunkData = {
     chunkIndex: number;
+    coordinationMatrix?: string;
     geometry: BmtGeomData;
     geometryID: number;
     isIfcSpace: boolean;
@@ -34,10 +35,12 @@ export type IfcGeometryProgressData = {
 export type IfcPropertyProgressData = IfcPropertiesProgressData;
 export type IfcParsePhase = "opening" | "opened" | "streaming" | "properties" | "metadata";
 export type IfcParseCallbacks = {
+    onElementPropertiesSerialized?: IfcSerializedElementPropertiesCallback;
     onGeometryChunk?: (chunk: IfcGeometryChunkData) => void;
     onGeometryProgress?: (progress: IfcGeometryProgressData) => void;
     onPhase?: (phase: IfcParsePhase) => void;
     onPropertiesProgress?: (progress: IfcPropertyProgressData) => void;
+    onStructureSerialized?: (structure: BmtModelStructure) => void;
     streamGeometryChunks?: boolean;
 };
 export declare class IFCLoader {
@@ -59,11 +62,11 @@ export declare class IFCLoader {
     set wasmPath(path: string);
     get _parser(): IfcAPI;
     set _parser(parser: IfcAPI);
-    loadModel(sources: IfcModelSource | IfcModelSource[], coordinationMatrix?: IfcCoordinationMatrixSource): Promise<IfcLoadedModels>;
+    loadModel(sources: IfcModelSource | IfcModelSource[], coordinationMatrix?: IfcCoordinationMatrixSource, callbacks?: IfcParseCallbacks): Promise<IfcLoadedModels>;
     parseBinaryFile(file: ArrayBuffer, coordinationMatrix?: IfcCoordinationMatrixSource, callbacks?: IfcParseCallbacks): Promise<BmtModelData>;
     private loadSingleModel;
     private parseInitializedBuffer;
-    getModelData(path: string): Promise<IfcModelDataResult>;
+    getModelData(path: string, callbacks?: IfcParseCallbacks): Promise<IfcModelDataResult>;
     setCoordinationMatrix(matrix: IfcCoordinationMatrixSource): void;
     resetCoordinationMatrix(): void;
     get coordinationMatrixData(): string | undefined;

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

@@ -1,5 +1,5 @@
 import { IfcAPI } from "web-ifc";
-import type { BmtModelProps, BmtModelStructureNode, BmtPropertyRecord, BmtPropertyValue } from "../BmtLoader";
+import type { BmtElementProps, BmtModelProps, BmtModelStructureNode, BmtPropertyRecord, BmtPropertyValue } from "../BmtLoader";
 type IfcValueRef = {
     value: IfcRawValue;
 };
@@ -36,6 +36,11 @@ export type IfcPropertiesProgressData = {
     total: number;
 };
 export type IfcPropertiesProgressCallback = (progress: IfcPropertiesProgressData) => void;
+export type IfcSerializedElementPropertiesData = {
+    elementID: number;
+    props: BmtElementProps;
+};
+export type IfcSerializedElementPropertiesCallback = (data: IfcSerializedElementPropertiesData) => void;
 export declare class PropertySerializer {
     private PropsNames;
     readonly parser: IfcAPI;
@@ -44,9 +49,9 @@ export declare class PropertySerializer {
     private spatialTreeChunksCache;
     private typeNameCache;
     constructor(parser: IfcAPI);
-    serializeAllProperties(modelID: number, ids: Set<number>, onProgress?: IfcPropertiesProgressCallback): Promise<BmtModelProps>;
+    serializeAllProperties(modelID: number, ids: Set<number>, onProgress?: IfcPropertiesProgressCallback, onElementSerialized?: IfcSerializedElementPropertiesCallback): Promise<BmtModelProps>;
     resetCaches(): void;
-    getPropertiesAsBlobs(modelID: number, ids: Set<number>, onProgress?: IfcPropertiesProgressCallback): Promise<BmtModelProps>;
+    getPropertiesAsBlobs(modelID: number, ids: Set<number>, onProgress?: IfcPropertiesProgressCallback, onElementSerialized?: IfcSerializedElementPropertiesCallback): Promise<BmtModelProps>;
     getItemProperty(modelID: number, id: number, flatten?: boolean): Promise<IfcLineData | null>;
     private getItemPropertiesBatch;
     private readItemProperty;

package/lib/Viewer.d.ts

@@ -1,10 +1,9 @@
 import { type ComponentProps } from "react";
-import type { BmtModelData } from "./Loaders/BmtLoader";
 import { Canvas } from "@react-three/fiber";
 import type { ViewerMaterialMode } from "./types";
 import { type ViewerApi, type ViewerSelection } from "./api/ViewerApi";
 import { type ViewerModelSource } from "./api/loader";
-type ModelsData = Record<number, BmtModelData>;
+import { type ModelsData } from "./ViewerComponents/ViewerScene";
 export type ViewerModelsData = ModelsData;
 export type ViewerProps = {
     autoFitCamera?: boolean;

package/lib/ViewerComponents/ApiHolders.d.ts

@@ -0,0 +1,17 @@
+import type { ViewerModelsApi, ViewerSceneApi } from "../api/ViewerApi";
+import type { ViewerPlansContainerFactory } from "../api/ViewerPlansApi";
+export declare class ViewerSceneApiHolder {
+    private sceneApi;
+    get: () => ViewerSceneApi | null;
+    set: (sceneApi: ViewerSceneApi | null) => void;
+}
+export declare class ViewerModelsApiHolder {
+    private modelsApi;
+    get: () => ViewerModelsApi | null;
+    set: (modelsApi: ViewerModelsApi | null) => void;
+}
+export declare class ViewerPlansContainerFactoryHolder {
+    private factory;
+    get: () => ViewerPlansContainerFactory | null;
+    set: (factory: ViewerPlansContainerFactory | null) => void;
+}

package/lib/ViewerComponents/Layout.d.ts

@@ -0,0 +1,35 @@
+export declare const NAV_CUBE_CONTAINER_STYLE: {
+    bottom: number;
+    height: number;
+    pointerEvents: "auto";
+    position: "absolute";
+    right: number;
+    touchAction: "none";
+    width: number;
+    zIndex: number;
+};
+export declare const VIEWER_CANVAS_CONTAINER_STYLE: {
+    height: string;
+    position: "relative";
+    width: string;
+};
+export declare const NAV_CUBE_CAMERA: {
+    far: number;
+    near: number;
+    position: [number, number, number];
+    zoom: number;
+};
+export declare const NAV_CUBE_GL: {
+    alpha: boolean;
+    antialias: boolean;
+};
+export declare const NAV_CUBE_PERFORMANCE_GL: {
+    alpha: boolean;
+    antialias: boolean;
+    powerPreference: "high-performance";
+};
+export declare const PERFORMANCE_CANVAS_GL: {
+    antialias: boolean;
+    powerPreference: "high-performance";
+};
+export declare const NAV_CUBE_MIN_DPR = 2;

package/lib/ViewerComponents/Postproduction.d.ts

@@ -0,0 +1,6 @@
+export declare function ViewerPostproduction({ enabled }: {
+    enabled: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function ViewerWebGpuPostproduction({ enabled, }: {
+    enabled: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

package/lib/ViewerComponents/SharedPlanScene.d.ts

@@ -0,0 +1,41 @@
+import { type ComponentProps } from "react";
+import { Canvas } from "@react-three/fiber";
+import { Object3D, OrthographicCamera, PerspectiveCamera, Plane, Vector3 } from "three";
+import type { ViewerControlsRef } from "../types";
+import type { ViewerPlanLocalPlaneSource } from "../api/ViewerPlansApi";
+import { type ViewerNotesApi } from "../utils/NotesUtils";
+export declare const CAMERA_MOTION_VISIBILITY_HIDDEN_KEY = "__bimatterCameraMotionHidden";
+export declare function applyPlanViewToCamera({ camera, controls, invalidate, model, plane, size, viewNormal, }: {
+    camera: PerspectiveCamera | OrthographicCamera;
+    controls?: ViewerControlsRef["current"];
+    invalidate?: () => void;
+    model: Object3D | null;
+    plane: Plane;
+    size: {
+        height: number;
+        width: number;
+    };
+    viewNormal?: Vector3;
+}): {
+    position: Vector3;
+    target: Vector3;
+    zoom: number;
+} | null;
+export declare function getPlaneCoplanarPoint(plane: Plane): Vector3;
+export declare function createPlanOnlyPlane(sourceModel: Object3D | null, source: ViewerPlanLocalPlaneSource): Plane;
+export declare function SharedPlanCanvas({ dpr, getExtraObjects, onPreselectionChange, performanceMode, plane, registerInvalidate, registerNotesApi, sourceModel, useLocalClippingVisuals, useWebGPU, viewNormal, }: {
+    dpr: ComponentProps<typeof Canvas>["dpr"];
+    getExtraObjects: () => Object3D[];
+    onPreselectionChange?: (preselection: {
+        elementID: number;
+        modelID: number;
+    } | null) => void;
+    performanceMode: boolean;
+    plane: Plane;
+    registerInvalidate?: (invalidate: () => void) => () => void;
+    registerNotesApi?: (api: ViewerNotesApi) => () => void;
+    sourceModel: Object3D;
+    useLocalClippingVisuals?: boolean;
+    useWebGPU: boolean;
+    viewNormal?: Vector3;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/ViewerComponents/ViewerScene.d.ts

@@ -0,0 +1,37 @@
+import { Object3D, Plane } from "three";
+import type { BmtModelData } from "../Loaders/BmtLoader";
+import type { ViewerCameraRef, ViewerControlsRef, ViewerLightRef, ViewerMaterialMode, ViewerModelRef } from "../types";
+import { type ViewerNotesApi } from "../utils/NotesUtils";
+import { type ViewerApi, type ViewerSceneApi } from "../api/ViewerApi";
+export type ModelsData = Record<number, BmtModelData>;
+export type CameraDprMode = "wake" | "move" | "sleep";
+export declare function ViewerScene({ autoFitCamera, cameraRef, controlRef, fitToView, loadGeneration, lightRef, materialMode, modelRef, modelsData, modelsLoading, initialPlanPlane, createPlanComment, createPlanMarkupCloud, deleteAllPlanNotes, onReady, onModelsReady, onCameraDprModeChange, publicApi, invalidatePlanViews, setPlanPreselectionHandler, setPlanVisualObjectsGetter, setSceneApi, setPlanNotesModeActive, usePerformanceMoving, useWebGPU, }: {
+    autoFitCamera: boolean;
+    cameraRef: ViewerCameraRef;
+    controlRef: ViewerControlsRef;
+    fitToView: boolean;
+    loadGeneration: number;
+    lightRef: ViewerLightRef;
+    materialMode?: ViewerMaterialMode;
+    modelRef: ViewerModelRef;
+    modelsData: ModelsData;
+    modelsLoading: boolean;
+    initialPlanPlane?: Plane | null;
+    deleteAllPlanNotes: () => void;
+    onReady?: (api: ViewerApi) => void;
+    onModelsReady: (loadGeneration: number) => void;
+    onCameraDprModeChange: (mode: CameraDprMode) => void;
+    publicApi: ViewerApi;
+    invalidatePlanViews: () => void;
+    createPlanComment: ViewerNotesApi["createComment"];
+    createPlanMarkupCloud: ViewerNotesApi["createMarkupCloud"];
+    setPlanPreselectionHandler: (handler: ((preselection: {
+        elementID: number;
+        modelID: number;
+    } | null) => void) | null) => void;
+    setPlanVisualObjectsGetter: (getter: (() => Object3D[]) | null) => void;
+    setSceneApi: (sceneApi: ViewerSceneApi | null) => void;
+    setPlanNotesModeActive: (active: boolean) => void;
+    usePerformanceMoving: boolean;
+    useWebGPU: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/ViewerComponents/WebGpuRendererUtils.d.ts

@@ -0,0 +1,35 @@
+import { type ComponentProps } from "react";
+import { Canvas, type Renderer } from "@react-three/fiber";
+import { Camera, Object3D, type ColorRepresentation } from "three";
+import type { ViewerLightRef } from "../types";
+export type WebGpuRenderer = Renderer & {
+    compileAsync?: (scene: Object3D, camera: Camera, targetScene?: Object3D | null) => Promise<unknown>;
+    domElement: HTMLCanvasElement;
+    getPixelRatio?: () => number;
+    init?: () => Promise<void>;
+    setClearColor: (color: ColorRepresentation, alpha?: number) => void;
+    setPixelRatio?: (value: number) => void;
+    setSize?: (width: number, height: number, updateStyle?: boolean) => void;
+};
+type CanvasGlFactory = Extract<NonNullable<ComponentProps<typeof Canvas>["gl"]>, (...args: never[]) => unknown>;
+type WebGpuRendererDefaultProps = Parameters<CanvasGlFactory>[0];
+export declare function createWebGpuRendererFactory({ alpha, performanceMode, }: {
+    alpha?: boolean;
+    performanceMode: boolean;
+}): ({ canvas, }: WebGpuRendererDefaultProps) => Promise<Renderer>;
+export declare function WebGpuRendererResizeGuard({ active }: {
+    active: boolean;
+}): null;
+export declare function RendererReadySignal({ active, onReady, }: {
+    active: boolean;
+    onReady: () => void;
+}): null;
+export declare function WebGpuSceneLights({ ambientColor, ambientIntensity, directionalColor, directionalIntensity, lightRef, }: {
+    ambientColor: ColorRepresentation;
+    ambientIntensity: number;
+    directionalColor: ColorRepresentation;
+    directionalIntensity: number;
+    lightRef: ViewerLightRef;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ViewerHardwareDetector(): null;
+export {};