architwin 1.14.10 → 1.14.11

package/lib/atwinui/components/toolbar/spacePartition/roomFormPane.js

@@ -54,7 +54,7 @@ export function renderRoomFormPane() {
         </div>
         <form class="at_form_container at_scrollable_container at_h-min-70" id="at-room-form" data-cy="at-room-form">
             <div class="at-field at_flex_row">
-                <label for="">${i18n.t('Name')}</label>
+                <label for="" style="font-size: 0.95rem;">${i18n.t('Name')}</label>
                 <input class="at_field_input at_w-full" type="text" name="room_name" id="at-room-name-input" data-cy="at-room-name-input" placeholder="Room 1">
             </div>
             <div class="at-field at_flex_column">
@@ -105,13 +105,13 @@ export function renderRoomFormPane() {
                     <span class="mdi mdi-chevron-left at_back_btn" id="at-back-floors"></span>
                     <label for="">
                         <span class="mdi mdi-vector-polygon"></span>
-                        ${i18n.t('WindowsDoors')}
+                        <span id="at-wall-name"></span>
                     </label>
                     <div> </div>
                 </div>
 
                 <div class="at_edit_name" id="at-edit-wall-material" style="display: none;">
-                    <input class="at_edit_name_input" type="text" id="at-edit-wall-input" data-cy="at-edit-wall-material-input" placeholder="${i18n.t('EnterWallMaterial')}" disabled>
+                    <input class="at_edit_name_input" type="text" id="at-edit-wall-input" data-cy="at-edit-wall-material-input" placeholder="${i18n.t('EnterWallMaterial')}" disabled style="font-size: 0.75rem !important;">
                     <span class="mdi mdi-pencil" style="display: none; cursor: pointer;" id="at-wall-edit-material-btn"></span>            
                     <span class="mdi mdi-check" id="at-confirm-edit-wall-btn" style="display: none;"></span>
                 </div>
@@ -247,6 +247,7 @@ export function toggleDrawWindowButton() {
                 targetUUID: currentWall.uuid
             }
         };
+        log.info("drawingConfig", drawingConfig);
         setDrawingConfig(drawingConfig);
         startDraw();
     }
@@ -733,43 +734,17 @@ function displayFaces(polygon) {
         floorMaterialEdit.style.display = "none";
         floorMaterialConfirm.style.display = "block";
     }));
-    addEventListenerById('at-confirm-edit-wall-btn', (event) => __awaiter(this, void 0, void 0, function* () {
+    addEventListenerById('at-confirm-edit-wall-btn', () => __awaiter(this, void 0, void 0, function* () {
         console.log('@caroline wall check', wallMaterial, currentWall.material, currentWall);
         const wallEditMaterial = document.getElementById('at-wall-edit-material-btn');
         const wallConfirmMaterial = document.getElementById('at-confirm-edit-wall-btn');
         const wallMaterialInput = document.getElementById('at-edit-wall-input');
-        const partitionData = JSON.parse(currentPartitionData.polygon_json);
-        const currentPartition = _3DXObjects.find(obj => obj.object.object_data.uuid === currentPartitionData.uuid);
-        if (partitionData) {
-            const wallIndex = partitionData.walls.findIndex(wall => wall.uuid == currentWall.uuid);
-            if (wallIndex != undefined) {
-                partitionData.walls[wallIndex].material = wallMaterial;
-            }
-            currentPartitionData.polygon_json = JSON.stringify(partitionData);
-            console.log('@caroline partition data: ', currentPartitionData);
-        }
-        currentPartitionDataArray.some(partition => {
-            const parsed = JSON.parse(partition.polygon_json);
-            parsed.walls.find(wall => {
-                if (wall.uuid == currentWall.uuid) {
-                    wall.material = wallMaterial;
-                }
-            });
-        });
-        console.log('[wall] currentPartition: ', currentPartition);
-        if (currentPartition) {
-            const wall = currentPartition.object.object_data.json_data.walls.find(wall => wall.uuid == currentWall.uuid);
-            wall.material = wallMaterial;
-        }
-        currentWall.material = wallMaterial;
-        //rerender to display material value in space
-        const polyData = {
-            uuid: currentPartition.object.object_data.uuid,
-            polygon_json: partitionData
-        };
-        //  renderPolygon(polyData)
-        console.log('[wall] Partition to be saved: ', currentPartitionData, JSON.parse(currentPartitionData.polygon_json));
-        dispatchSpaceEvent(SPACE_EVENTS.PARTITION_EDITED, { data: currentPartitionData });
+        const newMaterial = wallMaterialInput.value.trim();
+        log.info("newMaterial", newMaterial);
+        currentWall.material = newMaterial;
+        log.info("currentWall", currentWall);
+        log.info("currentObject", currentObject);
+        saveWallChanges();
         wallMaterialInput.disabled = true;
         wallEditMaterial.style.display = "block";
         wallConfirmMaterial.style.display = "none";
@@ -804,8 +779,8 @@ function displayWall(wall) {
             <div class="at_subitem_left">
                 <span class="mdi mdi-vector-line"></span>
             </div>
-            <div class="at_subitem_center" id="at-expand-btn-${wall.uuid}" data-cy="at-expand-btn-${wall.uuid}">
-                ${wallName}
+            <div class="at_subitem_center" id="at-expand-btn-${wall.uuid}" data-cy="at-expand-btn-${wall.uuid}" style="width: 150px !important;">
+                ${i18n.t('WindowsDoors')}
                 <span class="mdi mdi-chevron-up" id="at-chevron-${wall.uuid}"></span>
             </div>
             <div class="at_subitem_right at_invisible">
@@ -932,10 +907,10 @@ function setupEditWindow(element, window) {
         confirmBtn.style.display = "none";
         const windowTooltip = document.getElementById(`at-window-name-tooltip-${window.index}`);
         windowTooltip.innerText = `${window.name}`;
-        saveWindowChanges();
+        saveWallChanges();
     });
 }
-function saveWindowChanges() {
+function saveWallChanges() {
     updateWallInPolygon(currentWall);
     updatePartitionData();
     setCurrentPolygon(currentObject);
@@ -995,7 +970,7 @@ function setupDeleteWindow(element, window) {
             });
             // Save + rerender window
             currentObject.object.object_data.json_data = currentPolygonData;
-            saveWindowChanges();
+            saveWallChanges();
             notify.success(`${i18n.t('SuccessWindowDelete')}`);
             log.info("currentPartition polygonJson", JSON.parse(currentPartitionData.polygon_json));
             log.info("currentObject", currentObject);
@@ -1076,7 +1051,7 @@ function displayFloor(floor, walls, floorModel) {
         </div>
     
         <div class="at_edit_name" id="at-edit-floor-material">
-            <input class="at_edit_name_input at_ml_1" type="text" id="at-edit-floor-material-input" data-cy="at-edit-floor-material-input" value="${floor.material ? floor.material : ''}" placeholder="${i18n.t('EnterFloorMaterial')}">
+            <input class="at_edit_name_input at_ml_1" type="text" id="at-edit-floor-material-input" data-cy="at-edit-floor-material-input" value="${floor.material ? floor.material : ''}" placeholder="${i18n.t('EnterFloorMaterial')}" style="font-size: 0.75rem !important;">
             <span class="mdi mdi-pencil at_mr-1" style="display: none; cursor: pointer;" id="at-floor-edit-material-btn"></span>            
             <span class="mdi mdi-check at_mr-1" id="at-confirm-edit-floor-name" style="display: none;"></span>
         </div>
@@ -1431,6 +1406,7 @@ export function setCurrentPartitionData() {
                 }
                 if (drawingMode === 'partition') {
                     displayFaceLists();
+                    currentObject = currentObjectData;
                 }
             }, 50); // Check every 50ms
         });
@@ -1495,7 +1471,7 @@ function updatePartitionDataArray(payload, currentPartitionDataArray) {
         if (existingIndex === -1) {
             if (payload.name == null)
                 payload.name = partitionName.value || `${i18n.t('Partition')} ${currentPartitionDataArray.length + 1}`;
-            log.info("@@ payload", payload.name);
+            log.info("payload", payload.name);
             // Add the new partition
             currentPartitionDataArray.push(payload);
             newlyAddedPartition.push(payload);
@@ -1640,7 +1616,6 @@ export function handlePartitionWallEditBtn(wallUuid) {
         log.info("currentPartitionData", currentPartitionData);
         log.info("polygonJson", JSON.parse(currentPartitionData.polygon_json));
         log.info("getCurrentPolygon()", getCurrentPolygon());
-        setDrawingMode(false);
         const elements = {
             'at-face-title': 'none',
             'at-window-door-title': 'flex',
@@ -1654,6 +1629,7 @@ export function handlePartitionWallEditBtn(wallUuid) {
         });
         const faceVertexContainer = document.getElementById('at-face-vertex-container');
         faceVertexContainer.innerHTML = '';
+        const wallName = document.getElementById('at-wall-name');
         currentWall = JSON.parse(currentPartitionData.polygon_json).walls.find((wall) => wall.uuid == wallUuid);
         log.info("currenWall", currentWall);
         const wallBottomMidPoint = {
@@ -1665,10 +1641,18 @@ export function handlePartitionWallEditBtn(wallUuid) {
             z: ((currentWall.edges[0].start.z + currentWall.edges[1].start.z + currentWall.edges[2].start.z + currentWall.edges[3].start.z) / 4),
         };
         yield goToPosition(wallBottomMidPoint);
+        const match = currentWall.name.match(/wall-(\d+)$/);
+        if (match) {
+            console.log('@caroline wall test display: ', match);
+            const wallNumber = parseInt(match[1]) + 1;
+            wallName.innerText = `${i18n.t('Wall')} ${wallNumber}`;
+        }
         faceVertexContainer.append(displayWall(currentWall));
         //sets material and icon
         setWallMaterial(currentWall.material);
         setWallMaterialIcon(currentWall.material);
+        currentPolygonData = JSON.parse(currentPartitionData.polygon_json);
+        setDrawingMode(false);
         cancelDrawing();
     });
 }

package/lib/atwinui/components/toolbar/spacePartition/roomTreePane.js

@@ -404,7 +404,7 @@ function toggleSelectedPartition() {
                 handlePartitionRowEditBtnClickEvent(currentEditRoomData.children, partitionRowEdit);
                 if (isWall) {
                     const polygonId = target.getAttribute('polygon-item-id');
-                    handlePartitionWallEditBtn(polygonId);
+                    yield handlePartitionWallEditBtn(polygonId);
                 }
             }
             else {

package/lib/atwinui/events.js

@@ -1530,6 +1530,7 @@ function handleVertexPlace(payload) {
     if (isToolbarFeatureEnabled('roomCreation')) {
         log.info("getDrawingMode()", getDrawingMode());
         if (getDrawingMode() === 'window') {
+            log.info("current polygon", getCurrentPolygon());
         }
         if (getDrawingMode() === 'partition') {
             // setCurrentPartitionData()

package/lib/loaders/polydrawerLoader.d.ts

@@ -137,6 +137,8 @@ export declare class BufferGeometry {
         windowData: any;
         targetIndex: any;
         targetUUID: any;
+        deductWindowFromWallArea: boolean;
+        windowOutlineColor: number;
     };
     outputs: Record<string, unknown> & MpSdk.Scene.PredefinedOutputs;
     context: MpSdk.Scene.IComponentContext;
@@ -157,6 +159,20 @@ export declare class BufferGeometry {
     onTick: (delta: any) => void;
     onDestroy(): void;
     createLabelCanvas(text: string): HTMLCanvasElement;
+    /**
+     * Projects 3D window coordinates to 2D for accurate area calculation
+     * @param path3D Array of 3D coordinates
+     * @returns Object with area and perimeter calculated from projected 2D coordinates
+     */
+    calculateWindowDimensions(path3D: Array<{
+        x: number;
+        y: number;
+        z: number;
+    }>): {
+        area: number;
+        perimeter: number;
+    };
+    calculateWallNormal(wallIndex: number, startPoint: any, endPoint: any): THREE.Vector3;
     renderWindow(WALL_HEIGHT: number): void;
     renderWalls(WALL_HEIGHT: number, metadata?: PolygonData): (WallPolyData[] | EdgePolyData[])[];
     renderWindows(windows: WindowPolyData[]): void;

package/lib/loaders/polydrawerLoader.js

@@ -511,6 +511,8 @@ export class BufferGeometry {
             windowData: undefined,
             targetIndex: undefined,
             targetUUID: undefined,
+            deductWindowFromWallArea: true,
+            windowOutlineColor: 0x253D5B
         };
         this.emits = {
             changed: true,
@@ -693,6 +695,17 @@ export class BufferGeometry {
                             if (wall.windows && wall.windows.length > 0) {
                                 acc = [...acc, ...wall.windows];
                                 wallDataArray[index].windows = wall.windows;
+                                // if (this.inputs.deductWindowFromWallArea) {
+                                //   // Calculate total window area for this wall
+                                //   let totalWindowArea = 0;
+                                //   if (wall.windows && wall.windows.length > 0) {
+                                //     totalWindowArea = wall.windows.reduce((sum, window) => {
+                                //       return sum + (window.area || 0);
+                                //     }, 0);
+                                //   }
+                                //   // Subtract window area from wall area
+                                //   wallDataArray[index].area = Math.max(0, wallDataArray[index].area - totalWindowArea);
+                                // }
                             }
                             return acc;
                         }, []);
@@ -728,7 +741,8 @@ export class BufferGeometry {
                     if (!polyData.walls[targetWallIndex].windows)
                         polyData.walls[targetWallIndex].windows = [];
                     const currentWindowCount = polyData.walls[targetWallIndex].windows ? polyData.walls[targetWallIndex].windows.length + 1 : 0;
-                    const windowDimension = PolygonCalculator.calculatePolygonProperties(this.inputs.path, true);
+                    // Calculate window dimensions using proper 3D to 2D projection
+                    const windowDimension = this.calculateWindowDimensions(this.inputs.path);
                     let windowDataArray = [];
                     for (let i = 0; i < this.inputs.path.length; i++) {
                         const startPoint = this.inputs.path[i];
@@ -771,6 +785,15 @@ export class BufferGeometry {
                         log.error("Error rendering windows ", error);
                     }
                     polyData.walls[targetWallIndex].windows[this.inputs.targetIndex] = (windowData);
+                    if (this.inputs.deductWindowFromWallArea) {
+                        let totalWindowArea = 0;
+                        if (polyData.walls[targetWallIndex].windows && polyData.walls[targetWallIndex].windows.length > 0) {
+                            totalWindowArea = polyData.walls[targetWallIndex].windows.reduce((sum, window) => {
+                                return sum + (window.area || 0);
+                            }, 0);
+                        }
+                        polyData.walls[targetWallIndex].area = Math.max(0, polyData.walls[targetWallIndex].area - totalWindowArea);
+                    }
                     partitionData = polyData;
                 }
             }
@@ -817,6 +840,83 @@ export class BufferGeometry {
         return canvas;
     }
     ;
+    /**
+     * Projects 3D window coordinates to 2D for accurate area calculation
+     * @param path3D Array of 3D coordinates
+     * @returns Object with area and perimeter calculated from projected 2D coordinates
+     */
+    calculateWindowDimensions(path3D) {
+        const THREE = this.context.three;
+        if (!path3D || path3D.length < 3) {
+            return PolygonCalculator.calculatePolygonProperties(path3D, true);
+        }
+        const p0 = new THREE.Vector3(path3D[0].x, path3D[0].y, path3D[0].z);
+        const p1 = new THREE.Vector3(path3D[1].x, path3D[1].y, path3D[1].z);
+        const p2 = new THREE.Vector3(path3D[2].x, path3D[2].y, path3D[2].z);
+        const v1 = new THREE.Vector3().subVectors(p1, p0);
+        const v2 = new THREE.Vector3().subVectors(p2, p0);
+        const normal = new THREE.Vector3().crossVectors(v1, v2);
+        const normalLen = normal.length();
+        if (normalLen > 0) {
+            normal.divideScalar(normalLen);
+            const uAxis = v1.clone().normalize();
+            const vAxis = new THREE.Vector3().crossVectors(normal, uAxis).normalize();
+            const shapePoints2D = [];
+            for (let j = 0; j < path3D.length; j++) {
+                const pj = new THREE.Vector3(path3D[j].x, path3D[j].y, path3D[j].z);
+                const rel = new THREE.Vector3().subVectors(pj, p0);
+                const x = rel.dot(uAxis);
+                const y = rel.dot(vAxis);
+                shapePoints2D.push(new THREE.Vector2(x, y));
+            }
+            let twiceSignedArea = 0;
+            let perimeter = 0;
+            console.log('Window projection debug:');
+            console.log('Original 3D points:', path3D);
+            console.log('Projected 2D points:', shapePoints2D);
+            for (let j = 0; j < shapePoints2D.length; j++) {
+                const p1 = shapePoints2D[j];
+                const p2 = shapePoints2D[(j + 1) % shapePoints2D.length];
+                const cross = p1.x * p2.y - p2.x * p1.y;
+                twiceSignedArea += cross;
+                const distance = Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+                perimeter += distance;
+                console.log(`Edge ${j}: p1(${p1.x.toFixed(3)}, ${p1.y.toFixed(3)}) -> p2(${p2.x.toFixed(3)}, ${p2.y.toFixed(3)}), cross=${cross.toFixed(3)}, distance=${distance.toFixed(3)}`);
+            }
+            const area = Math.abs(twiceSignedArea * 0.5);
+            console.log(`Final calculation: twiceSignedArea=${twiceSignedArea.toFixed(3)}, area=${area.toFixed(3)}, perimeter=${perimeter.toFixed(3)}`);
+            return { area, perimeter };
+        }
+        else {
+            return PolygonCalculator.calculatePolygonProperties(path3D, true);
+        }
+    }
+    calculateWallNormal(wallIndex, startPoint, endPoint) {
+        const THREE = this.context.three;
+        const wallDirection = new THREE.Vector3(endPoint.x - startPoint.x, endPoint.y - startPoint.y, endPoint.z - startPoint.z).normalize();
+        if (this.inputs.path.length >= 3) {
+            const p0 = new THREE.Vector3(this.inputs.path[0].x, this.inputs.path[0].y, this.inputs.path[0].z);
+            const p1 = new THREE.Vector3(this.inputs.path[1].x, this.inputs.path[1].y, this.inputs.path[1].z);
+            const p2 = new THREE.Vector3(this.inputs.path[2].x, this.inputs.path[2].y, this.inputs.path[2].z);
+            const v1 = new THREE.Vector3().subVectors(p1, p0);
+            const v2 = new THREE.Vector3().subVectors(p2, p0);
+            const polygonNormal = new THREE.Vector3().crossVectors(v1, v2).normalize();
+            const wallNormal = new THREE.Vector3().crossVectors(wallDirection, polygonNormal).normalize();
+            // If the normal is too small (wall is parallel to polygon normal), use a fallback
+            if (wallNormal.lengthSq() < 0.001) {
+                // Use the wall direction rotated 90 degrees around the Y axis
+                wallNormal.set(-wallDirection.z, 0, wallDirection.x).normalize();
+            }
+            return wallNormal;
+        }
+        // Fallback: use the original method if we don't have enough points
+        const up = new THREE.Vector3(0, 1, 0);
+        const wallNormal = new THREE.Vector3().crossVectors(wallDirection, up).normalize();
+        if (wallNormal.lengthSq() < 0.001) {
+            wallNormal.set(1, 0, 0);
+        }
+        return wallNormal;
+    }
     renderWindow(WALL_HEIGHT) {
         // const THREE = this.context.three
         // const windowData:WindowPolyData = this.inputs.windowData
@@ -864,7 +964,19 @@ export class BufferGeometry {
             wallMesh.add(outlineMesh);
             wallMesh.name = this.inputs.uuid != '' ? `${this.inputs.uuid}_wall-${i}` : `wall-${i}`;
             const wallLength = new THREE.Vector3(endPoint.x - startPoint.x, endPoint.y - startPoint.y, endPoint.z - startPoint.z).length();
-            const wallArea = wallLength * WALL_HEIGHT;
+            let wallArea = wallLength * WALL_HEIGHT;
+            if (this.inputs.deductWindowFromWallArea && metadata) {
+                const currentWallIndex = wallDataArray.length == 0 ? wallDataArray.length : wallDataArray.length - 1;
+                let totalWindowArea = 0;
+                if (metadata.walls[currentWallIndex].windows && metadata.walls[currentWallIndex].windows.length > 0) {
+                    totalWindowArea = metadata.walls[currentWallIndex].windows.reduce((sum, window) => {
+                        const dimension = this.calculateWindowDimensions(window.path);
+                        return sum + (dimension.area || 0);
+                    }, 0);
+                }
+                // Subtract window area from wall area
+                wallArea = Math.max(0, wallArea - totalWindowArea);
+            }
             // Create wall label
             let wallMaterial;
             if (metadata && metadata.walls[i] && metadata.walls[i].material)
@@ -879,14 +991,9 @@ export class BufferGeometry {
                 z: (startPoint.z + endPoint.z) / 2
             };
             const direction = new THREE.Vector3(endPoint.x - startPoint.x, endPoint.y - startPoint.y, endPoint.z - startPoint.z).normalize();
-            // Calculate the normal vector to the wall
-            const up = new THREE.Vector3(0, 1, 0);
-            const wallNormal = new THREE.Vector3().crossVectors(direction, up).normalize();
-            // For flat walls, if the normal is close to zero (wall is vertical along Y),
-            if (wallNormal.lengthSq() < 0.001) {
-                // Wall is perfectly vertical, use a default normal
-                wallNormal.set(1, 0, 0);
-            }
+            // Calculate the normal vector to the wall based on polygon winding order
+            // Negate to keep labels inside, remove the negate to render all labels outside
+            const wallNormal = this.calculateWallNormal(i, startPoint, endPoint).negate();
             // Negation to position labels on the original side of the wall
             // wallNormal.negate();
             const edgeLength = direction.length();
@@ -975,7 +1082,7 @@ export class BufferGeometry {
                     is_deleted: wallDeleted
                 },
                 index: i,
-                area: wallDimensions.area,
+                area: wallArea,
                 width: wallDimensions.width,
                 perimeter: wallDimensions.perimeter,
                 wall_height: WALL_HEIGHT,
@@ -1045,8 +1152,12 @@ export class BufferGeometry {
                     depthWrite: false
                 }));
                 windowMesh.name = windows[i].uuid ? `${windows[i].uuid}_window` : `window-${i}`;
+                const outlineGeometry = new THREE.EdgesGeometry(windowGeometry);
+                const outlineMaterial = new THREE.LineBasicMaterial({ color: this.inputs.windowOutlineColor, linewidth: 3 });
+                const outlineMesh = new THREE.LineSegments(outlineGeometry, outlineMaterial);
+                windowMesh.add(outlineMesh);
                 // Add window center label if material is defined
-                if (windows[i].material) {
+                if (windows[i].material || windows[i].name) {
                     try {
                         let twiceSignedArea = 0;
                         let centroidU = 0;
@@ -1071,9 +1182,13 @@ export class BufferGeometry {
                             centerU = sum.x / shapePoints2D.length;
                             centerV = sum.y / shapePoints2D.length;
                         }
-                        // Create window label canvas
-                        const windowLabel = windows[i].name ? `${windows[i].name}_${windows[i].material}` : `Window ${i}_${windows[i].material}`;
-                        const windowCanvas = this.createLabelCanvas(windowLabel);
+                        // Calculate window area using the projected 2D coordinates
+                        const windowDimension = this.calculateWindowDimensions(windows[i].path);
+                        let windowLabelText = windows[i].name ? `${windows[i].name}` : windowMesh.name;
+                        windowLabelText = windows[i].material ? `${windowLabelText}_${windows[i].material}: ${windowDimension.area.toFixed(2)}m²` : `${windowLabelText}: ${windowDimension.area.toFixed(2)}m²`;
+                        log.info("windowLabelText ", windowLabelText);
+                        //const windowLabel = windows[i].name ? `${windows[i].name}_${windows[i].material}` : `Window ${i}_${windows[i].material}`
+                        const windowCanvas = this.createLabelCanvas(windowLabelText);
                         const windowArea = Math.abs(twiceSignedArea * 0.5);
                         const labelWidth = Math.max(0.5, Math.min(2, Math.sqrt(Math.max(0.0001, windowArea))));
                         const labelHeight = labelWidth / 4;

package/lib/types.d.ts

@@ -461,6 +461,7 @@ export interface ComponentOptions {
     drawingMode?: string | undefined;
     targetIndex?: number | undefined;
     targetUUID?: string | undefined;
+    deductWindowFromWallArea?: boolean | undefined;
 }
 export interface VectorCoords {
     object_position: Vector3;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "architwin",
-  "version": "1.14.10",
+  "version": "1.14.11",
   "description": "ArchiTwin Library for Matterport",
   "main": "./lib/architwin.js",
   "types": "./lib/architwin.d.ts",