@pascal-app/viewer 0.7.0 → 0.9.1

package/dist/components/renderers/wall/wall-renderer.js

@@ -1,16 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useRegistry, useScene } from '@pascal-app/core';
-import { useLayoutEffect, useRef } from 'react';
-import { useNodeEvents } from '../../../hooks/use-node-events';
-import { getVisibleWallMaterials } from '../../../systems/wall/wall-materials';
-import { NodeRenderer } from '../node-renderer';
-export const WallRenderer = ({ node }) => {
-    const ref = useRef(null);
-    useRegistry(node.id, 'wall', ref);
-    useLayoutEffect(() => {
-        useScene.getState().markDirty(node.id);
-    }, [node.id]);
-    const handlers = useNodeEvents(node, 'wall');
-    const material = getVisibleWallMaterials(node);
-    return (_jsxs("mesh", { castShadow: true, material: material, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("mesh", { name: "collision-mesh", visible: false, ...handlers, children: _jsx("boxGeometry", { args: [0, 0, 0] }) }), node.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`)))] }));
-};

package/dist/components/renderers/window/window-renderer.d.ts

@@ -1,5 +0,0 @@
-import { type WindowNode } from '@pascal-app/core';
-export declare const WindowRenderer: ({ node }: {
-    node: WindowNode;
-}) => import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=window-renderer.d.ts.map

package/dist/components/renderers/window/window-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"window-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/window/window-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAMzE,eAAO,MAAM,cAAc,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,4CA8B5D,CAAA"}

package/dist/components/renderers/window/window-renderer.js

@@ -1,21 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useRegistry, useScene } from '@pascal-app/core';
-import { useLayoutEffect, useMemo, useRef } from 'react';
-import { useNodeEvents } from '../../../hooks/use-node-events';
-import { createMaterial, DEFAULT_WINDOW_MATERIAL } from '../../../lib/materials';
-export const WindowRenderer = ({ node }) => {
-    const ref = useRef(null);
-    useRegistry(node.id, 'window', ref);
-    useLayoutEffect(() => {
-        useScene.getState().markDirty(node.id);
-    }, [node.id]);
-    const handlers = useNodeEvents(node, 'window');
-    const isTransient = !!node.metadata?.isTransient;
-    const material = useMemo(() => {
-        const mat = node.material;
-        if (!mat)
-            return DEFAULT_WINDOW_MATERIAL;
-        return createMaterial(mat);
-    }, [node.material, node.material?.preset, node.material?.properties, node.material?.texture]);
-    return (_jsx("mesh", { castShadow: true, material: material, position: node.position, receiveShadow: true, ref: ref, rotation: node.rotation, visible: node.visible, ...(isTransient ? {} : handlers), children: _jsx("boxGeometry", { args: [0, 0, 0] }) }));
-};

package/dist/components/renderers/zone/zone-renderer.d.ts

@@ -1,5 +0,0 @@
-import { type ZoneNode } from '@pascal-app/core';
-export declare const ZoneRenderer: ({ node }: {
-    node: ZoneNode;
-}) => import("react/jsx-runtime").JSX.Element | null;
-//# sourceMappingURL=zone-renderer.d.ts.map

package/dist/components/renderers/zone/zone-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zone-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/zone/zone-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAyG7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,mDAqJxD,CAAA"}

package/dist/components/renderers/zone/zone-renderer.js

@@ -1,181 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useRegistry } from '@pascal-app/core';
-import { Html } from '@react-three/drei';
-import { useMemo, useRef } from 'react';
-import { BufferGeometry, Color, DoubleSide, Float32BufferAttribute, Shape } from 'three';
-import { color, float, uniform, uv } from 'three/tsl';
-import { MeshBasicNodeMaterial } from 'three/webgpu';
-import { useNodeEvents } from '../../../hooks/use-node-events';
-import { ZONE_LAYER } from '../../../lib/layers';
-const Y_OFFSET = 0.01;
-const WALL_HEIGHT = 2.3;
-/**
- * Creates a gradient material for zone walls using TSL
- * Gradient goes from zone color at bottom to transparent at top
- */
-const createWallGradientMaterial = (zoneColor) => {
-    const baseColor = color(new Color(zoneColor));
-    // Use UV y coordinate for vertical gradient (0 at bottom, 1 at top)
-    const gradientT = uv().y;
-    const opacity = uniform(0);
-    // Fade opacity from 0.6 at bottom to 0 at top
-    const finalOpacity = float(0.6).mul(float(1).sub(gradientT)).mul(opacity);
-    return new MeshBasicNodeMaterial({
-        transparent: true,
-        colorNode: baseColor,
-        opacityNode: finalOpacity,
-        side: DoubleSide,
-        depthWrite: true,
-        depthTest: false,
-        userData: {
-            uOpacity: opacity,
-        },
-    });
-};
-/**
- * Creates a floor material for zones using TSL
- */
-const createFloorMaterial = (zoneColor) => {
-    const baseColor = color(new Color(zoneColor));
-    const opacity = uniform(0);
-    return new MeshBasicNodeMaterial({
-        transparent: true,
-        colorNode: baseColor,
-        opacityNode: float(0.25).mul(opacity),
-        side: DoubleSide,
-        depthWrite: false,
-        depthTest: false,
-        userData: { uOpacity: opacity },
-    });
-};
-/**
- * Creates wall geometry for zone borders
- * Each wall segment is a vertical quad from one polygon point to the next
- */
-const createWallGeometry = (polygon) => {
-    const geometry = new BufferGeometry();
-    if (polygon.length < 2)
-        return geometry;
-    const positions = [];
-    const uvs = [];
-    const indices = [];
-    // Create a wall segment for each edge of the polygon
-    for (let i = 0; i < polygon.length; i++) {
-        const current = polygon[i];
-        const next = polygon[(i + 1) % polygon.length];
-        const baseIndex = i * 4;
-        // Four vertices per wall segment (two triangles forming a quad)
-        // Bottom-left
-        positions.push(current[0], Y_OFFSET, current[1]);
-        uvs.push(0, 0);
-        // Bottom-right
-        positions.push(next[0], Y_OFFSET, next[1]);
-        uvs.push(1, 0);
-        // Top-right
-        positions.push(next[0], Y_OFFSET + WALL_HEIGHT, next[1]);
-        uvs.push(1, 1);
-        // Top-left
-        positions.push(current[0], Y_OFFSET + WALL_HEIGHT, current[1]);
-        uvs.push(0, 1);
-        // Two triangles for the quad
-        indices.push(baseIndex, baseIndex + 1, baseIndex + 2, baseIndex, baseIndex + 2, baseIndex + 3);
-    }
-    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
-    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
-    geometry.setIndex(indices);
-    geometry.computeVertexNormals();
-    return geometry;
-};
-export const ZoneRenderer = ({ node }) => {
-    const ref = useRef(null);
-    useRegistry(node.id, 'zone', ref);
-    // Create floor shape from polygon
-    const floorShape = useMemo(() => {
-        if (!node?.polygon || node.polygon.length < 3)
-            return null;
-        const shape = new Shape();
-        const firstPt = node.polygon[0];
-        // Shape is in X-Y plane, we rotate it to X-Z plane
-        // Negate Y (which becomes Z) to get correct orientation
-        shape.moveTo(firstPt[0], -firstPt[1]);
-        for (let i = 1; i < node.polygon.length; i++) {
-            const pt = node.polygon[i];
-            shape.lineTo(pt[0], -pt[1]);
-        }
-        shape.closePath();
-        return shape;
-    }, [node?.polygon]);
-    // Create wall geometry from polygon
-    const wallGeometry = useMemo(() => {
-        if (!node?.polygon || node.polygon.length < 2)
-            return null;
-        return createWallGeometry(node.polygon);
-    }, [node?.polygon]);
-    // Calculate polygon centroid for label positioning using the geometric centroid formula
-    // This correctly handles polygons regardless of vertex distribution along edges
-    const centroid = useMemo(() => {
-        if (!node?.polygon || node.polygon.length < 3)
-            return [0, 0];
-        const polygon = node.polygon;
-        let signedArea = 0;
-        let cx = 0;
-        let cz = 0;
-        for (let i = 0; i < polygon.length; i++) {
-            const [x0, z0] = polygon[i];
-            const [x1, z1] = polygon[(i + 1) % polygon.length];
-            // Cross product for signed area
-            const cross = x0 * z1 - x1 * z0;
-            signedArea += cross;
-            cx += (x0 + x1) * cross;
-            cz += (z0 + z1) * cross;
-        }
-        signedArea /= 2;
-        const factor = 1 / (6 * signedArea);
-        return [cx * factor, cz * factor];
-    }, [node?.polygon]);
-    // Create materials
-    const floorMaterial = useMemo(() => {
-        if (!node?.color)
-            return null;
-        return createFloorMaterial(node.color);
-    }, [node?.color]);
-    const wallMaterial = useMemo(() => {
-        if (!node?.color)
-            return null;
-        return createWallGradientMaterial(node.color);
-    }, [node?.color]);
-    const handlers = useNodeEvents(node, 'zone');
-    if (!(node && floorShape && wallGeometry && floorMaterial && wallMaterial)) {
-        return null;
-    }
-    return (_jsxs("group", { ref: ref, ...handlers, userData: { labelPosition: [centroid[0], 1, centroid[1]] }, children: [_jsx(Html, { name: "label", position: [centroid[0], 1, centroid[1]], style: { pointerEvents: 'none' }, zIndexRange: [10, 0], children: _jsxs("div", { id: `${node.id}-label`, style: {
-                        display: 'flex',
-                        flexDirection: 'column',
-                        alignItems: 'center',
-                        transform: 'translate3d(-50%, -50%, 0)',
-                        opacity: 0,
-                        transition: 'opacity 0.3s ease-in-out',
-                    }, children: [_jsx("div", { style: {
-                                width: 'max-content',
-                                color: 'white',
-                                textShadow: `-1px -1px 0 ${node.color}, 1px -1px 0 ${node.color}, -1px 1px 0 ${node.color}, 1px 1px 0 ${node.color}`,
-                                textAlign: 'center',
-                            }, children: _jsx("span", { children: node.name }) }), _jsxs("div", { className: "label-pin", style: {
-                                display: 'flex',
-                                flexDirection: 'column',
-                                alignItems: 'center',
-                                marginTop: '2px',
-                                opacity: 0,
-                                transition: 'opacity 0.5s ease-in-out',
-                            }, children: [_jsx("div", { style: {
-                                        width: '2px',
-                                        height: '40px',
-                                        backgroundColor: node.color,
-                                    } }), _jsx("div", { style: {
-                                        width: '10px',
-                                        height: '10px',
-                                        borderRadius: '50%',
-                                        backgroundColor: node.color,
-                                        border: '1px solid white',
-                                    } })] })] }) }), _jsx("mesh", { layers: ZONE_LAYER, material: floorMaterial, name: "floor", position: [0, Y_OFFSET, 0], rotation: [-Math.PI / 2, 0, 0], children: _jsx("shapeGeometry", { args: [floorShape] }) }), _jsx("mesh", { geometry: wallGeometry, layers: ZONE_LAYER, material: wallMaterial, name: "walls" })] }));
-};

package/dist/lib/suppress-three-clock-warning.d.ts

@@ -1,25 +0,0 @@
-/**
- * Suppresses the `THREE.Clock: This module has been deprecated` warning
- * emitted by three.js r183+ on every `new THREE.Clock()` call.
- *
- * We don't instantiate `Clock` ourselves — `@react-three/fiber` 9.x
- * (current stable) creates one internally per `<Canvas>` mount. The
- * migration to `THREE.Timer` lands in R3F 10.x (still alpha).
- *
- * Uses three's `setConsoleFunction` hook so we don't touch `console.warn`
- * globally. Only the exact Clock deprecation message is suppressed; all
- * other three.js logs (including TSL stack-trace warnings) pass through
- * untouched.
- *
- * Runs in production as well as dev — the suppressed message is a pure
- * deprecation notice with no user-actionable content.
- *
- * REMOVAL: safe to delete once `@react-three/fiber` no longer constructs
- * `new THREE.Clock()`. To verify after an R3F upgrade:
- *   grep -n "new THREE.Clock" node_modules/@react-three/fiber/dist/*.js
- * No hits → delete this file and its import in components/viewer/index.tsx.
- *
- * @see https://github.com/pascalorg/editor/issues/213
- */
-export {};
-//# sourceMappingURL=suppress-three-clock-warning.d.ts.map

package/dist/lib/suppress-three-clock-warning.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"suppress-three-clock-warning.d.ts","sourceRoot":"","sources":["../../src/lib/suppress-three-clock-warning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG"}

package/dist/lib/suppress-three-clock-warning.js

@@ -1,51 +0,0 @@
-/**
- * Suppresses the `THREE.Clock: This module has been deprecated` warning
- * emitted by three.js r183+ on every `new THREE.Clock()` call.
- *
- * We don't instantiate `Clock` ourselves — `@react-three/fiber` 9.x
- * (current stable) creates one internally per `<Canvas>` mount. The
- * migration to `THREE.Timer` lands in R3F 10.x (still alpha).
- *
- * Uses three's `setConsoleFunction` hook so we don't touch `console.warn`
- * globally. Only the exact Clock deprecation message is suppressed; all
- * other three.js logs (including TSL stack-trace warnings) pass through
- * untouched.
- *
- * Runs in production as well as dev — the suppressed message is a pure
- * deprecation notice with no user-actionable content.
- *
- * REMOVAL: safe to delete once `@react-three/fiber` no longer constructs
- * `new THREE.Clock()`. To verify after an R3F upgrade:
- *   grep -n "new THREE.Clock" node_modules/@react-three/fiber/dist/*.js
- * No hits → delete this file and its import in components/viewer/index.tsx.
- *
- * @see https://github.com/pascalorg/editor/issues/213
- */
-import { setConsoleFunction } from 'three';
-// three's warn() prepends 'THREE.' to its first argument, and the Clock
-// constructor passes 'THREE.Clock: ...', producing a double-prefixed
-// string. Exact equality keeps the suppression surgical — if three ever
-// rewords this, the filter stops matching and the message resurfaces.
-const CLOCK_DEPRECATION_MESSAGE = 'THREE.THREE.Clock: This module has been deprecated. Please use THREE.Timer instead.';
-// HMR-idempotent install guard. setConsoleFunction is a single-slot global
-// in three, so re-evaluating this module on HMR would reinstall the hook.
-const INSTALLED = Symbol.for('@pascal-app/viewer/suppress-three-clock-warning');
-if (!globalThis[INSTALLED]) {
-    ;
-    globalThis[INSTALLED] = true;
-    setConsoleFunction((method, message, ...params) => {
-        if (method === 'warn' && message === CLOCK_DEPRECATION_MESSAGE) {
-            return;
-        }
-        // Mirror three's default stack-trace handling so TSL warnings/errors
-        // keep their clickable stack frames.
-        if (method !== 'log') {
-            const first = params[0];
-            if (first?.isStackTrace && typeof first.getError === 'function') {
-                console[method](first.getError(message));
-                return;
-            }
-        }
-        console[method](message, ...params);
-    });
-}

package/dist/systems/export/export-system.d.ts

@@ -1,2 +0,0 @@
-export declare const ExportSystem: () => null;
-//# sourceMappingURL=export-system.d.ts.map

package/dist/systems/export/export-system.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"export-system.d.ts","sourceRoot":"","sources":["../../../src/systems/export/export-system.tsx"],"names":[],"mappings":"AAwBA,eAAO,MAAM,YAAY,YAgDxB,CAAA"}

package/dist/systems/export/export-system.js

@@ -1,60 +0,0 @@
-'use client';
-import { useThree } from '@react-three/fiber';
-import { useEffect } from 'react';
-import * as THREE from 'three';
-import { STLExporter } from 'three/examples/jsm/exporters/STLExporter.js';
-import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
-import { OBJExporter } from 'three/examples/jsm/exporters/OBJExporter.js';
-import useViewer from '../../store/use-viewer';
-const EDITOR_LAYER = 1; // same constant used across the editor
-function downloadBlob(blob, filename) {
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
-    a.href = url;
-    a.download = filename;
-    document.body.appendChild(a);
-    a.click();
-    document.body.removeChild(a);
-    URL.revokeObjectURL(url);
-}
-export const ExportSystem = () => {
-    const { scene } = useThree();
-    const setExportScene = useViewer((state) => state.setExportScene);
-    useEffect(() => {
-        const exportFn = async (format = 'glb') => {
-            const date = new Date().toISOString().split('T')[0];
-            const filename = `pascal-export-${date}`;
-            // Clone scene and strip editor-only objects (layer 1 = EDITOR_LAYER)
-            const exportRoot = scene.clone(true);
-            const toRemove = [];
-            exportRoot.traverse((obj) => {
-                if (obj.layers.isEnabled(EDITOR_LAYER)) {
-                    toRemove.push(obj);
-                }
-            });
-            for (const obj of toRemove) {
-                obj.parent?.remove(obj);
-            }
-            if (format === 'glb') {
-                const exporter = new GLTFExporter();
-                const result = await new Promise((resolve, reject) => {
-                    exporter.parse(exportRoot, (output) => resolve(output), (err) => reject(err), { binary: true });
-                });
-                downloadBlob(new Blob([result], { type: 'model/gltf-binary' }), `${filename}.glb`);
-            }
-            else if (format === 'stl') {
-                const exporter = new STLExporter();
-                const result = exporter.parse(exportRoot, { binary: true });
-                downloadBlob(new Blob([result.buffer], { type: 'model/stl' }), `${filename}.stl`);
-            }
-            else if (format === 'obj') {
-                const exporter = new OBJExporter();
-                const result = exporter.parse(exportRoot);
-                downloadBlob(new Blob([result], { type: 'model/obj' }), `${filename}.obj`);
-            }
-        };
-        setExportScene(exportFn);
-        return () => setExportScene(null);
-    }, [scene, setExportScene]);
-    return null;
-};

package/dist/systems/item-mesh-metadata/compute-item-mesh-metadata.d.ts

@@ -1,14 +0,0 @@
-import type { Object3D } from 'three';
-type Point = {
-    x: number;
-    y: number;
-};
-export type MeshLocalBounds = {
-    min: [number, number, number];
-    max: [number, number, number];
-};
-/** Plan footprint in the item root's horizontal (x, z) plane — stored as floorplan polygon. */
-export declare function computePlanFootprintPolygonLocal(object: Object3D): Point[];
-export declare function computeMeshLocalBoundsFromObject(object: Object3D): MeshLocalBounds | null;
-export {};
-//# sourceMappingURL=compute-item-mesh-metadata.d.ts.map

package/dist/systems/item-mesh-metadata/compute-item-mesh-metadata.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compute-item-mesh-metadata.d.ts","sourceRoot":"","sources":["../../../src/systems/item-mesh-metadata/compute-item-mesh-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAGrC,KAAK,KAAK,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAErC,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9B,CAAA;AAED,+FAA+F;AAC/F,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,QAAQ,GAAG,KAAK,EAAE,CA0E1E;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,QAAQ,GAAG,eAAe,GAAG,IAAI,CAmDzF"}

package/dist/systems/item-mesh-metadata/compute-item-mesh-metadata.js

@@ -1,155 +0,0 @@
-import { Box3, Matrix4, Vector3 } from 'three';
-/** Plan footprint in the item root's horizontal (x, z) plane — stored as floorplan polygon. */
-export function computePlanFootprintPolygonLocal(object) {
-    object.updateWorldMatrix(true, true);
-    const inverseRootMatrix = new Matrix4().copy(object.matrixWorld).invert();
-    const localMatrix = new Matrix4();
-    const scratchBounds = new Box3();
-    const scratchPosition = new Vector3();
-    const footprintPoints = [];
-    const collectPoints = (child) => {
-        const mesh = child;
-        if (mesh.isMesh && mesh.name !== 'cutout' && mesh.geometry) {
-            if (!mesh.geometry.boundingBox && mesh.geometry.computeBoundingBox) {
-                mesh.geometry.computeBoundingBox();
-            }
-            localMatrix.copy(inverseRootMatrix).multiply(mesh.matrixWorld);
-            const vertexPositions = mesh.geometry.attributes?.position;
-            if (vertexPositions && vertexPositions.count > 0) {
-                for (let index = 0; index < vertexPositions.count; index += 1) {
-                    scratchPosition
-                        .set(vertexPositions.getX(index), vertexPositions.getY(index), vertexPositions.getZ(index))
-                        .applyMatrix4(localMatrix);
-                    if (Number.isFinite(scratchPosition.x) && Number.isFinite(scratchPosition.z)) {
-                        footprintPoints.push({ x: scratchPosition.x, y: scratchPosition.z });
-                    }
-                }
-            }
-            else if (mesh.geometry.boundingBox) {
-                scratchBounds.copy(mesh.geometry.boundingBox);
-                scratchBounds.applyMatrix4(localMatrix);
-                if (Number.isFinite(scratchBounds.min.x) && Number.isFinite(scratchBounds.max.x)) {
-                    footprintPoints.push({ x: scratchBounds.min.x, y: scratchBounds.min.z }, { x: scratchBounds.max.x, y: scratchBounds.min.z }, { x: scratchBounds.max.x, y: scratchBounds.max.z }, { x: scratchBounds.min.x, y: scratchBounds.max.z });
-                }
-            }
-        }
-        for (const grandchild of child.children) {
-            collectPoints(grandchild);
-        }
-    };
-    for (const child of object.children) {
-        collectPoints(child);
-    }
-    return getMinimumAreaBoundingRect(footprintPoints) ?? [];
-}
-export function computeMeshLocalBoundsFromObject(object) {
-    object.updateWorldMatrix(true, true);
-    const inverseRootMatrix = new Matrix4().copy(object.matrixWorld).invert();
-    const localMatrix = new Matrix4();
-    const localBounds = new Box3();
-    const scratchBounds = new Box3();
-    let hasBounds = false;
-    const expandBounds = (child) => {
-        const mesh = child;
-        if (mesh.isMesh && mesh.name !== 'cutout' && mesh.geometry) {
-            if (!mesh.geometry.boundingBox && mesh.geometry.computeBoundingBox) {
-                mesh.geometry.computeBoundingBox();
-            }
-            if (mesh.geometry.boundingBox) {
-                localMatrix.copy(inverseRootMatrix).multiply(mesh.matrixWorld);
-                scratchBounds.copy(mesh.geometry.boundingBox).applyMatrix4(localMatrix);
-                if (!hasBounds) {
-                    localBounds.copy(scratchBounds);
-                    hasBounds = true;
-                }
-                else {
-                    localBounds.union(scratchBounds);
-                }
-            }
-        }
-        for (const grandchild of child.children) {
-            expandBounds(grandchild);
-        }
-    };
-    for (const child of object.children) {
-        expandBounds(child);
-    }
-    if (!hasBounds)
-        return null;
-    return {
-        min: [localBounds.min.x, localBounds.min.y, localBounds.min.z],
-        max: [localBounds.max.x, localBounds.max.y, localBounds.max.z],
-    };
-}
-function getMinimumAreaBoundingRect(points) {
-    if (points.length === 0)
-        return null;
-    if (points.length < 3)
-        return points;
-    const hull = getConvexHull(points);
-    if (hull.length < 3)
-        return hull;
-    let bestArea = Number.POSITIVE_INFINITY;
-    let bestRect = null;
-    for (let index = 0; index < hull.length; index += 1) {
-        const nextIndex = (index + 1) % hull.length;
-        const current = hull[index];
-        const next = hull[nextIndex];
-        const angle = Math.atan2(next.y - current.y, next.x - current.x);
-        const cos = Math.cos(-angle);
-        const sin = Math.sin(-angle);
-        let minX = Number.POSITIVE_INFINITY;
-        let maxX = Number.NEGATIVE_INFINITY;
-        let minY = Number.POSITIVE_INFINITY;
-        let maxY = Number.NEGATIVE_INFINITY;
-        for (const point of hull) {
-            const rx = point.x * cos - point.y * sin;
-            const ry = point.x * sin + point.y * cos;
-            minX = Math.min(minX, rx);
-            maxX = Math.max(maxX, rx);
-            minY = Math.min(minY, ry);
-            maxY = Math.max(maxY, ry);
-        }
-        const area = (maxX - minX) * (maxY - minY);
-        if (area >= bestArea)
-            continue;
-        bestArea = area;
-        const unrotate = (x, y) => ({
-            x: x * Math.cos(angle) - y * Math.sin(angle),
-            y: x * Math.sin(angle) + y * Math.cos(angle),
-        });
-        bestRect = [
-            unrotate(minX, minY),
-            unrotate(maxX, minY),
-            unrotate(maxX, maxY),
-            unrotate(minX, maxY),
-        ];
-    }
-    return bestRect;
-}
-function getConvexHull(points) {
-    if (points.length <= 1)
-        return points;
-    const sorted = [...points].sort((a, b) => (a.x === b.x ? a.y - b.y : a.x - b.x));
-    const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
-    const lower = [];
-    for (const point of sorted) {
-        while (lower.length >= 2 &&
-            cross(lower[lower.length - 2], lower[lower.length - 1], point) <= 0) {
-            lower.pop();
-        }
-        lower.push(point);
-    }
-    const upper = [];
-    for (let index = sorted.length - 1; index >= 0; index -= 1) {
-        const point = sorted[index];
-        while (upper.length >= 2 &&
-            cross(upper[upper.length - 2], upper[upper.length - 1], point) <= 0) {
-            upper.pop();
-        }
-        upper.push(point);
-    }
-    lower.pop();
-    upper.pop();
-    return [...lower, ...upper];
-}

package/dist/systems/item-mesh-metadata/item-mesh-metadata-system.d.ts

@@ -1,6 +0,0 @@
-/**
- * Writes `meshLocalPlanPolygon` / `meshLocalBounds` from loaded item meshes.
- * ModelRenderer requests sync via `requestItemMeshMetadataSync` when GLTF is ready.
- */
-export declare function ItemMeshMetadataSystem(): null;
-//# sourceMappingURL=item-mesh-metadata-system.d.ts.map

package/dist/systems/item-mesh-metadata/item-mesh-metadata-system.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"item-mesh-metadata-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item-mesh-metadata/item-mesh-metadata-system.tsx"],"names":[],"mappings":"AAoFA;;;GAGG;AACH,wBAAgB,sBAAsB,SAYrC"}

package/dist/systems/item-mesh-metadata/item-mesh-metadata-system.js

@@ -1,75 +0,0 @@
-'use client';
-import { sceneRegistry, useScene } from '@pascal-app/core';
-import { useFrame } from '@react-three/fiber';
-import { computeMeshLocalBoundsFromObject, computePlanFootprintPolygonLocal, } from './compute-item-mesh-metadata';
-import { drainItemMeshMetadataSyncRequests, getItemMeshMetadataSourceRoot } from './sync-request';
-function isMetadataUnchanged(nextPolygon, nextBounds, metadata) {
-    const currentPolygon = metadata.meshLocalPlanPolygon;
-    const currentBounds = typeof metadata.meshLocalBounds === 'object' &&
-        metadata.meshLocalBounds !== null &&
-        !Array.isArray(metadata.meshLocalBounds)
-        ? metadata.meshLocalBounds
-        : null;
-    const polygonUnchanged = (nextPolygon === null &&
-        (currentPolygon === undefined || currentPolygon === null || currentPolygon === false)) ||
-        (Array.isArray(currentPolygon) &&
-            nextPolygon !== null &&
-            currentPolygon.length === nextPolygon.length &&
-            currentPolygon.every((point, index) => Array.isArray(point) &&
-                point[0] === nextPolygon[index]?.[0] &&
-                point[1] === nextPolygon[index]?.[1]));
-    const boundsUnchanged = (nextBounds === null && (currentBounds === undefined || currentBounds === null)) ||
-        (nextBounds !== null &&
-            Array.isArray(currentBounds?.min) &&
-            Array.isArray(currentBounds?.max) &&
-            currentBounds.min[0] === nextBounds.min[0] &&
-            currentBounds.min[1] === nextBounds.min[1] &&
-            currentBounds.min[2] === nextBounds.min[2] &&
-            currentBounds.max[0] === nextBounds.max[0] &&
-            currentBounds.max[1] === nextBounds.max[1] &&
-            currentBounds.max[2] === nextBounds.max[2]);
-    return polygonUnchanged && boundsUnchanged;
-}
-function trySyncItemMeshMetadata(itemId, nodes) {
-    const node = nodes[itemId];
-    if (!node || node.type !== 'item')
-        return;
-    const root = getItemMeshMetadataSourceRoot(itemId) ??
-        sceneRegistry.nodes.get(itemId);
-    if (!root)
-        return;
-    const polygon = computePlanFootprintPolygonLocal(root);
-    const bounds = computeMeshLocalBoundsFromObject(root);
-    if (polygon.length < 3 && !bounds)
-        return;
-    const nextPolygon = polygon.length >= 3 ? polygon.map(({ x, y }) => [x, y]) : null;
-    const nextBounds = bounds ? { min: bounds.min, max: bounds.max } : null;
-    const metadata = typeof node.metadata === 'object' && node.metadata !== null && !Array.isArray(node.metadata)
-        ? node.metadata
-        : {};
-    if (isMetadataUnchanged(nextPolygon, nextBounds, metadata))
-        return;
-    useScene.getState().updateNode(itemId, {
-        metadata: {
-            ...metadata,
-            ...(nextPolygon ? { meshLocalPlanPolygon: nextPolygon } : {}),
-            ...(nextBounds ? { meshLocalBounds: nextBounds } : {}),
-        },
-    });
-}
-/**
- * Writes `meshLocalPlanPolygon` / `meshLocalBounds` from loaded item meshes.
- * ModelRenderer requests sync via `requestItemMeshMetadataSync` when GLTF is ready.
- */
-export function ItemMeshMetadataSystem() {
-    useFrame(() => {
-        const ids = drainItemMeshMetadataSyncRequests();
-        if (ids.length === 0)
-            return;
-        const nodes = useScene.getState().nodes;
-        for (const id of ids) {
-            trySyncItemMeshMetadata(id, nodes);
-        }
-    });
-    return null;
-}

package/dist/systems/item-mesh-metadata/sync-request.d.ts

@@ -1,7 +0,0 @@
-import type { Object3D } from 'three';
-/** Called when an item's loaded GLTF (or metadata driving footprint) may need re-syncing. */
-export declare function requestItemMeshMetadataSync(itemId: string): void;
-export declare function setItemMeshMetadataSourceRoot(itemId: string, root: Object3D | null): void;
-export declare function getItemMeshMetadataSourceRoot(itemId: string): Object3D | undefined;
-export declare function drainItemMeshMetadataSyncRequests(): string[];
-//# sourceMappingURL=sync-request.d.ts.map