@pascal-app/nodes 0.1.1

package/dist/cupola/geometry.js

@@ -0,0 +1,262 @@
+import * as THREE from 'three';
+/**
+ * Pure builder for the cupola mesh — a small louvered roof lantern:
+ *
+ *        ✦            ← finial (post + ball)
+ *       /\
+ *      /  \           ← roof (dome or pyramid)
+ *     /____\
+ *    |‖‖‖‖‖‖|          ← louvered body (angled slats on 4 faces)
+ *    |‖‖‖‖‖‖|
+ *   _|______|_
+ *  |__________|        ← base plinth, seats on the roof
+ *
+ * Built bottom → top from primitive revolves / boxes. Every face is placed
+ * through a winding-safe oriented quad/tri, so the whole thing is lit
+ * correctly from outside without hand-traced winding.
+ *
+ * Pure: no React, no scene access, no store mutation. Safe for unit tests,
+ * the placement preview, and the move-tool ghost.
+ */
+export function buildCupolaGeometry(node) {
+    const w = Math.max(0.2, node.width);
+    const d = Math.max(0.2, node.depth);
+    const h = Math.max(0.3, node.height);
+    const hw = w / 2;
+    const hd = d / 2;
+    // Vertical budget.
+    const baseH = h * 0.05;
+    const bodyH = h * 0.42;
+    const corniceH = h * 0.06;
+    const roofH = h * 0.32;
+    const baseTop = baseH;
+    const bodyTop = baseTop + bodyH;
+    const corniceTop = bodyTop + corniceH;
+    const apexY = corniceTop + roofH;
+    // Footprints.
+    const baseOvh = Math.min(hw, hd) * 0.12;
+    const cornOvh = Math.min(hw, hd) * 0.22;
+    const p = [];
+    const n = [];
+    const uv = [];
+    // Base plinth (slightly wider than the body) — closed box.
+    addBox(p, n, uv, hw + baseOvh, hd + baseOvh, 0, baseTop);
+    // Body — closed box; the louvers are applied as relief on its walls.
+    addBox(p, n, uv, hw, hd, baseTop, bodyTop);
+    // Cornice — overhanging slab the roof sits on.
+    addBox(p, n, uv, hw + cornOvh, hd + cornOvh, bodyTop, corniceTop);
+    // Louvered slats on all four body faces.
+    addLouvers(p, n, uv, hw, hd, baseTop, bodyTop);
+    // Roof.
+    const rhw = hw + cornOvh;
+    const rhd = hd + cornOvh;
+    if (node.roofStyle === 'pyramid') {
+        addPyramidRoof(p, n, uv, rhw, rhd, corniceTop, apexY);
+    }
+    else {
+        addDomeRoof(p, n, uv, rhw, rhd, corniceTop, roofH);
+    }
+    // Finial: a short post topped by a ball.
+    if (node.finial) {
+        const ballR = Math.min(w, d) * 0.05;
+        const postR = ballR * 0.45;
+        const postTop = apexY + roofH * 0.18;
+        addCylinder(p, n, uv, postR, apexY, postTop);
+        addSphere(p, n, uv, ballR, postTop + ballR * 0.7);
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(p, 3));
+    geo.setAttribute('normal', new THREE.Float32BufferAttribute(n, 3));
+    geo.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
+    geo.computeBoundingSphere();
+    return geo;
+}
+// ─── Body / cornice / base ───────────────────────────────────────────
+// Closed axis-aligned box centred on the Y axis in X/Z, spanning y0..y1.
+function addBox(p, n, uv, hw, hd, y0, y1) {
+    // Walls.
+    pushQuad(p, n, uv, [hw, y0, -hd], [hw, y0, hd], [hw, y1, hd], [hw, y1, -hd], [1, 0, 0]);
+    pushQuad(p, n, uv, [-hw, y0, hd], [-hw, y0, -hd], [-hw, y1, -hd], [-hw, y1, hd], [-1, 0, 0]);
+    pushQuad(p, n, uv, [hw, y0, hd], [-hw, y0, hd], [-hw, y1, hd], [hw, y1, hd], [0, 0, 1]);
+    pushQuad(p, n, uv, [-hw, y0, -hd], [hw, y0, -hd], [hw, y1, -hd], [-hw, y1, -hd], [0, 0, -1]);
+    // Top + bottom.
+    pushQuad(p, n, uv, [-hw, y1, -hd], [-hw, y1, hd], [hw, y1, hd], [hw, y1, -hd], [0, 1, 0]);
+    pushQuad(p, n, uv, [-hw, y0, -hd], [hw, y0, -hd], [hw, y0, hd], [-hw, y0, hd], [0, -1, 0]);
+}
+// ─── Louvers ─────────────────────────────────────────────────────────
+// Angled slats standing proud of each body face. Each slat is a double-
+// sided angled quad (emitted twice with opposite hints) so it reads from
+// both above and below. The solid body wall behind them blocks see-through.
+const SLAT_COUNT = 5;
+function addLouvers(p, n, uv, hw, hd, y0, y1) {
+    // Each face: a local→world mapper map(u, y, out) and the slat half-width.
+    const faces = [
+        { map: (u, y, out) => [u, y, hd + out], halfU: hw * 0.82 }, // +Z
+        { map: (u, y, out) => [u, y, -(hd + out)], halfU: hw * 0.82 }, // -Z
+        { map: (u, y, out) => [hw + out, y, u], halfU: hd * 0.82 }, // +X
+        { map: (u, y, out) => [-(hw + out), y, u], halfU: hd * 0.82 }, // -X
+    ];
+    const margin = (y1 - y0) * 0.12;
+    const top = y1 - margin;
+    const bottom = y0 + margin;
+    const span = top - bottom;
+    const drop = span / (SLAT_COUNT + 1);
+    const proj = drop * 0.9;
+    for (const { map, halfU } of faces) {
+        const outDir = sub(map(0, 0, 1), map(0, 0, 0));
+        const upOut = [outDir[0], 1, outDir[2]];
+        const downOut = [outDir[0], -1, outDir[2]];
+        for (let k = 1; k <= SLAT_COUNT; k++) {
+            const yTop = bottom + (span * k) / SLAT_COUNT;
+            const a = map(-halfU, yTop, 0);
+            const b = map(halfU, yTop, 0);
+            const c = map(halfU, yTop - drop, proj);
+            const dd = map(-halfU, yTop - drop, proj);
+            // Top + underside of the slat.
+            pushQuad(p, n, uv, a, b, c, dd, upOut);
+            pushQuad(p, n, uv, a, b, c, dd, downOut);
+        }
+    }
+}
+// ─── Roofs ───────────────────────────────────────────────────────────
+function addPyramidRoof(p, n, uv, hw, hd, y0, apexY) {
+    const apex = [0, apexY, 0];
+    const corners = [
+        [hw, y0, -hd],
+        [hw, y0, hd],
+        [-hw, y0, hd],
+        [-hw, y0, -hd],
+    ];
+    for (let i = 0; i < 4; i++) {
+        const a = corners[i];
+        const b = corners[(i + 1) % 4];
+        // Outward + up hint from the edge midpoint.
+        const mx = (a[0] + b[0]) / 2;
+        const mz = (a[2] + b[2]) / 2;
+        pushTri(p, n, uv, a, b, apex, [mx, Math.max(hw, hd), mz]);
+    }
+}
+function addDomeRoof(p, n, uv, rx, rz, y0, domeH) {
+    const lng = 20;
+    const lat = 6;
+    let prev = ringAt(rx, rz, y0, lng);
+    for (let i = 1; i <= lat; i++) {
+        const phi = (Math.PI / 2) * (i / lat);
+        const rf = Math.cos(phi);
+        const y = y0 + domeH * Math.sin(phi);
+        const ring = ringAt(rx * rf, rz * rf, y, lng);
+        addBand(p, n, uv, prev, ring, lng, (a, _b, c) => {
+            const x = (a[0] + c[0]) / 2;
+            const yy = (a[1] + c[1]) / 2 - y0;
+            const z = (a[2] + c[2]) / 2;
+            return [x, yy, z];
+        });
+        prev = ring;
+    }
+}
+// ─── Finial primitives ───────────────────────────────────────────────
+function addCylinder(p, n, uv, r, y0, y1) {
+    const lng = 12;
+    const bottom = ringAt(r, r, y0, lng);
+    const top = ringAt(r, r, y1, lng);
+    addBand(p, n, uv, bottom, top, lng, (a, _b, c) => {
+        const x = (a[0] + c[0]) / 2;
+        const z = (a[2] + c[2]) / 2;
+        return [x, 0, z];
+    });
+}
+function addSphere(p, n, uv, r, cy) {
+    const lng = 14;
+    const lat = 8;
+    let prev = ringAt(0, 0, cy - r, lng);
+    for (let i = 1; i <= lat; i++) {
+        const theta = Math.PI * (i / lat) - Math.PI / 2;
+        const ry = r * Math.sin(theta);
+        const rr = r * Math.cos(theta);
+        const ring = ringAt(rr, rr, cy + ry, lng);
+        addBand(p, n, uv, prev, ring, lng, (a, _b, c) => {
+            const x = (a[0] + c[0]) / 2;
+            const yy = (a[1] + c[1]) / 2 - cy;
+            const z = (a[2] + c[2]) / 2;
+            return [x, yy, z];
+        });
+        prev = ring;
+    }
+}
+// ─── Revolve plumbing ────────────────────────────────────────────────
+function ringAt(ax, az, y, lng) {
+    const row = [];
+    for (let j = 0; j <= lng; j++) {
+        const t = (Math.PI * 2 * j) / lng;
+        row.push([ax * Math.cos(t), y, az * Math.sin(t)]);
+    }
+    return row;
+}
+function addBand(p, n, uv, rA, rB, lng, hintFn) {
+    for (let j = 0; j < lng; j++) {
+        const a = rA[j];
+        const b = rA[j + 1];
+        const c = rB[j + 1];
+        const d = rB[j];
+        pushQuad(p, n, uv, a, b, c, d, hintFn(a, b, c, d));
+    }
+}
+function sub(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+// ─── Winding-safe primitives ─────────────────────────────────────────
+function pushQuad(positions, normals, uvs, a, b, c, d, hint) {
+    let nx = (c[1] - a[1]) * (b[2] - a[2]) - (c[2] - a[2]) * (b[1] - a[1]);
+    let ny = (c[2] - a[2]) * (b[0] - a[0]) - (c[0] - a[0]) * (b[2] - a[2]);
+    let nz = (c[0] - a[0]) * (b[1] - a[1]) - (c[1] - a[1]) * (b[0] - a[0]);
+    const flip = nx * hint[0] + ny * hint[1] + nz * hint[2] < 0;
+    if (flip) {
+        nx = -nx;
+        ny = -ny;
+        nz = -nz;
+    }
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+    nx /= len;
+    ny /= len;
+    nz /= len;
+    const u = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    const v = Math.hypot(d[0] - a[0], d[1] - a[1], d[2] - a[2]);
+    if (flip) {
+        positions.push(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
+        uvs.push(0, 0, u, 0, u, v);
+        positions.push(a[0], a[1], a[2], c[0], c[1], c[2], d[0], d[1], d[2]);
+        uvs.push(0, 0, u, v, 0, v);
+    }
+    else {
+        positions.push(a[0], a[1], a[2], c[0], c[1], c[2], b[0], b[1], b[2]);
+        uvs.push(0, 0, u, v, u, 0);
+        positions.push(a[0], a[1], a[2], d[0], d[1], d[2], c[0], c[1], c[2]);
+        uvs.push(0, 0, 0, v, u, v);
+    }
+    for (let i = 0; i < 6; i++)
+        normals.push(nx, ny, nz);
+}
+function pushTri(positions, normals, uvs, a, b, c, hint) {
+    let nx = (b[1] - a[1]) * (c[2] - a[2]) - (b[2] - a[2]) * (c[1] - a[1]);
+    let ny = (b[2] - a[2]) * (c[0] - a[0]) - (b[0] - a[0]) * (c[2] - a[2]);
+    let nz = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+    const flip = nx * hint[0] + ny * hint[1] + nz * hint[2] < 0;
+    if (flip) {
+        nx = -nx;
+        ny = -ny;
+        nz = -nz;
+    }
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+    nx /= len;
+    ny /= len;
+    nz /= len;
+    if (flip) {
+        positions.push(a[0], a[1], a[2], c[0], c[1], c[2], b[0], b[1], b[2]);
+    }
+    else {
+        positions.push(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
+    }
+    uvs.push(0, 0, 1, 0, 0, 1);
+    for (let i = 0; i < 3; i++)
+        normals.push(nx, ny, nz);
+}

package/dist/cupola/index.d.ts

@@ -0,0 +1,4 @@
+export { cupolaDefinition } from './definition';
+export { buildCupolaGeometry } from './geometry';
+export { CupolaNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/cupola/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cupola/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA"}

package/dist/cupola/index.js

@@ -0,0 +1,3 @@
+export { cupolaDefinition } from './definition';
+export { buildCupolaGeometry } from './geometry';
+export { CupolaNode } from './schema';

package/dist/cupola/move-tool.d.ts

@@ -0,0 +1,12 @@
+import { type CupolaNode } from '@pascal-app/core';
+/**
+ * Cupola move tool. Mirrors the box-vent move flow: the original mesh hides
+ * during the drag, a ghost tracks the cursor with the correct slope tilt +
+ * segment yaw, and the click updates the node's position + parent segment in
+ * one undoable step (reparenting between segments when needed). Cancel
+ * restores the original transform, or deletes a freshly-cloned cupola.
+ */
+export default function MoveCupolaTool({ node }: {
+    node: CupolaNode;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=move-tool.d.ts.map

package/dist/cupola/move-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/cupola/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAOhB,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,sCAwNpE"}

package/dist/cupola/move-tool.js

@@ -0,0 +1,206 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { emitter, sceneRegistry, useScene, } from '@pascal-app/core';
+import { consumePlacementDragRelease, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useCallback, useEffect, useState } from 'react';
+import * as THREE from 'three';
+import { createRelativeRoofDrag, roofSegmentLocalToBuildingLocal, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag';
+import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfaceNodePlacementGuides, snapRoofSurfaceNodeTarget, } from '../shared/roof-surface-placement-guides';
+import CupolaPreview from './preview';
+/**
+ * Cupola move tool. Mirrors the box-vent move flow: the original mesh hides
+ * during the drag, a ghost tracks the cursor with the correct slope tilt +
+ * segment yaw, and the click updates the node's position + parent segment in
+ * one undoable step (reparenting between segments when needed). Cancel
+ * restores the original transform, or deletes a freshly-cloned cupola.
+ */
+export default function MoveCupolaTool({ node }) {
+    const exitMoveMode = useCallback(() => {
+        useEditor.getState().setMovingNode(null);
+    }, []);
+    const [previewPos, setPreviewPos] = useState(null);
+    const [previewSurfaceQuat, setPreviewSurfaceQuat] = useState(null);
+    const [previewYaw, setPreviewYaw] = useState(0);
+    useEffect(() => {
+        useScene.temporal.getState().pause();
+        const original = {
+            position: [...node.position],
+            rotation: node.rotation ?? 0,
+            roofSegmentId: node.roofSegmentId,
+            parentId: node.parentId,
+            metadata: node.metadata,
+        };
+        const meta = typeof node.metadata === 'object' && node.metadata !== null
+            ? node.metadata
+            : {};
+        const isNew = !!meta.isNew;
+        const cupolaObj = sceneRegistry.nodes.get(node.id);
+        if (cupolaObj)
+            cupolaObj.visible = false;
+        let lastSnap = null;
+        let lastTarget = null;
+        let committed = false;
+        const roofDrag = createRelativeRoofDrag(original);
+        const clearTarget = () => {
+            lastTarget = null;
+            lastSnap = null;
+            setPreviewPos(null);
+            setPreviewSurfaceQuat(null);
+            clearRoofSurfacePlacementGuides();
+        };
+        const resolveSnappedTarget = (event) => {
+            const rawTarget = roofDrag.resolve(event);
+            if (!rawTarget)
+                return null;
+            return snapRoofSurfaceNodeTarget({
+                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true),
+                node,
+                bypass: event.nativeEvent?.shiftKey === true,
+            });
+        };
+        const updatePreview = (event) => {
+            const target = resolveSnappedTarget(event);
+            if (!target) {
+                clearTarget();
+                return;
+            }
+            lastTarget = target;
+            const sx = Math.round(target.localX * 20) / 20;
+            const sz = Math.round(target.localZ * 20) / 20;
+            if (event.nativeEvent?.shiftKey !== true &&
+                (!lastSnap || lastSnap[0] !== sx || lastSnap[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnap = [sx, sz];
+            }
+            const normal = getAnalyticalNormal(target.localX, target.localZ, target.segment);
+            setPreviewSurfaceQuat(surfaceQuatFromNormal(normal, new THREE.Quaternion()));
+            setPreviewYaw((event.node.rotation ?? 0) + (target.segment.rotation ?? 0));
+            setPreviewPos(roofSegmentLocalToBuildingLocal(target.segment.id, [
+                target.localX,
+                target.localY,
+                target.localZ,
+            ]));
+            publishRoofSurfaceNodePlacementGuides({
+                roof: event.node,
+                segment: target.segment,
+                center: [target.localX, target.localY, target.localZ],
+                node,
+            });
+            event.stopPropagation();
+        };
+        const onRoofClick = (event) => {
+            if (committed)
+                return;
+            const target = lastTarget ?? resolveSnappedTarget(event);
+            if (!target)
+                return;
+            committed = true;
+            const targetSegmentId = target.segment.id;
+            const st = useScene.getState();
+            const prevSegmentId = original.roofSegmentId;
+            if (prevSegmentId && prevSegmentId !== targetSegmentId) {
+                const oldSeg = st.nodes[prevSegmentId];
+                if (oldSeg) {
+                    st.updateNode(prevSegmentId, {
+                        children: (oldSeg.children ?? []).filter((id) => id !== node.id),
+                    });
+                }
+                const newSeg = st.nodes[targetSegmentId];
+                if (newSeg && !(newSeg.children ?? []).includes(node.id)) {
+                    st.updateNode(targetSegmentId, {
+                        children: [...(newSeg.children ?? []), node.id],
+                    });
+                }
+                st.dirtyNodes.add(prevSegmentId);
+            }
+            useScene.temporal.getState().resume();
+            st.updateNode(node.id, {
+                roofSegmentId: targetSegmentId,
+                parentId: targetSegmentId,
+                position: [target.localX, target.localY, target.localZ],
+                rotation: original.rotation,
+                visible: true,
+                metadata: {},
+            });
+            useScene.temporal.getState().pause();
+            st.dirtyNodes.add(targetSegmentId);
+            st.dirtyNodes.add(node.id);
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            exitMoveMode();
+            event.stopPropagation();
+        };
+        const onCancel = () => {
+            if (isNew) {
+                const parentId = original.roofSegmentId;
+                if (parentId) {
+                    const parent = useScene.getState().nodes[parentId];
+                    if (parent) {
+                        useScene.getState().updateNode(parentId, {
+                            children: (parent.children ?? []).filter((id) => id !== node.id),
+                        });
+                    }
+                }
+                useScene.getState().deleteNode(node.id);
+                useScene.temporal.getState().resume();
+                markToolCancelConsumed();
+                clearRoofSurfacePlacementGuides();
+                exitMoveMode();
+                return;
+            }
+            useScene.getState().updateNode(node.id, {
+                position: original.position,
+                rotation: original.rotation,
+                roofSegmentId: original.roofSegmentId,
+                parentId: original.parentId,
+                metadata: original.metadata,
+            });
+            if (original.roofSegmentId) {
+                useScene.getState().dirtyNodes.add(original.roofSegmentId);
+            }
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            useScene.temporal.getState().resume();
+            markToolCancelConsumed();
+            clearRoofSurfacePlacementGuides();
+            exitMoveMode();
+        };
+        const onPlacementDragPointerUp = (event) => {
+            if (!consumePlacementDragRelease(event))
+                return;
+            if (!lastTarget)
+                return;
+            onRoofClick({
+                nativeEvent: event,
+                stopPropagation: () => event.stopPropagation(),
+            });
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onRoofClick);
+        emitter.on('roof:leave', clearTarget);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('pointerup', onPlacementDragPointerUp);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onRoofClick);
+            emitter.off('roof:leave', clearTarget);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            clearRoofSurfacePlacementGuides();
+            useScene.temporal.getState().resume();
+        };
+    }, [exitMoveMode, node]);
+    if (!(previewPos && previewSurfaceQuat))
+        return null;
+    return (_jsx("group", { position: previewPos, children: _jsx("group", { "rotation-y": previewYaw, children: _jsx("group", { quaternion: previewSurfaceQuat, children: _jsx(CupolaPreview, { node: node }) }) }) }));
+}

package/dist/cupola/panel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Inspector panel for a placed cupola. Roof style + finial + dimensions
+ * plus Move / Duplicate / Delete wired into the same ghost-preview drag
+ * flow the placement tool uses. Mirrors the box-vent panel.
+ */
+export default function CupolaPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

package/dist/cupola/panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cupola/panel.tsx"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,uCAgQlC"}

package/dist/cupola/panel.js

@@ -0,0 +1,106 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CupolaNode as CupolaSchema, getActiveRoofHeight, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Copy, Move, Trash2 } from 'lucide-react';
+import { useCallback } from 'react';
+/**
+ * Inspector panel for a placed cupola. Roof style + finial + dimensions
+ * plus Move / Duplicate / Delete wired into the same ghost-preview drag
+ * flow the placement tool uses. Mirrors the box-vent panel.
+ */
+export default function CupolaPanel() {
+    const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    const setSelection = useViewer((s) => s.setSelection);
+    const updateNode = useScene((s) => s.updateNode);
+    const deleteNode = useScene((s) => s.deleteNode);
+    const setMovingNode = useEditor((s) => s.setMovingNode);
+    const storeNode = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    const overrides = useLiveNodeOverrides((s) => selectedId ? s.get(selectedId) : undefined);
+    const node = storeNode && overrides ? { ...storeNode, ...overrides } : storeNode;
+    const segment = useScene((s) => node?.roofSegmentId
+        ? s.nodes[node.roofSegmentId]
+        : undefined);
+    const previewProp = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        useLiveNodeOverrides.getState().set(selectedId, updates);
+    }, [selectedId]);
+    const commitProp = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        updateNode(selectedId, updates);
+        useLiveNodeOverrides.getState().clear(selectedId);
+    }, [selectedId, updateNode]);
+    const handleUpdate = commitProp;
+    const handleClose = useCallback(() => {
+        setSelection({ selectedIds: [] });
+    }, [setSelection]);
+    const handleBack = useCallback(() => {
+        if (node?.roofSegmentId) {
+            setSelection({ selectedIds: [node.roofSegmentId] });
+        }
+    }, [node?.roofSegmentId, setSelection]);
+    const handleMove = useCallback(() => {
+        if (!node)
+            return;
+        triggerSFX('sfx:item-pick');
+        setMovingNode(node);
+        setSelection({ selectedIds: [] });
+    }, [node, setMovingNode, setSelection]);
+    const handleDuplicate = useCallback(() => {
+        if (!node)
+            return;
+        triggerSFX('sfx:item-pick');
+        const parentId = node.roofSegmentId;
+        if (!parentId)
+            return;
+        const state = useScene.getState();
+        const meta = typeof node.metadata === 'object' && node.metadata !== null
+            ? node.metadata
+            : {};
+        const cloneInput = {
+            ...node,
+            id: undefined,
+            metadata: { ...meta, isNew: true },
+        };
+        const cloned = CupolaSchema.parse(cloneInput);
+        state.createNode(cloned, parentId);
+        state.dirtyNodes.add(parentId);
+        setMovingNode(cloned);
+        setSelection({ selectedIds: [] });
+    }, [node, setMovingNode, setSelection]);
+    const handleDelete = useCallback(() => {
+        if (!(selectedId && node))
+            return;
+        triggerSFX('sfx:item-delete');
+        const segmentId = node.roofSegmentId;
+        if (segmentId) {
+            const state = useScene.getState();
+            const seg = state.nodes[segmentId];
+            if (seg) {
+                state.updateNode(segmentId, {
+                    children: (seg.children ?? []).filter((id) => id !== selectedId),
+                });
+            }
+        }
+        deleteNode(selectedId);
+        if (segmentId) {
+            useScene.getState().dirtyNodes.add(segmentId);
+            setSelection({ selectedIds: [segmentId] });
+        }
+        else {
+            setSelection({ selectedIds: [] });
+        }
+    }, [selectedId, node, deleteNode, setSelection]);
+    if (!(node && node.type === 'cupola' && selectedId))
+        return null;
+    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || 'Cupola', width: 300, children: [_jsxs(PanelSection, { title: "Style", children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ roofStyle: v }), options: [
+                            { label: 'Dome', value: 'dome' },
+                            { label: 'Pyramid', value: 'pyramid' },
+                        ], value: node.roofStyle ?? 'dome' }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ finial: v === 'on' }), options: [
+                            { label: 'Finial', value: 'on' },
+                            { label: 'No Finial', value: 'off' },
+                        ], value: (node.finial ?? true) ? 'on' : 'off' })] }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Width", max: 2, min: 0.3, onChange: (v) => previewProp({ width: v }), onCommit: (v) => handleUpdate({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.width * 100) / 100 }), _jsx(SliderControl, { label: "Depth", max: 2, min: 0.3, onChange: (v) => previewProp({ depth: v }), onCommit: (v) => handleUpdate({ depth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.depth * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: 2.5, min: 0.4, onChange: (v) => previewProp({ height: v }), onCommit: (v) => handleUpdate({ height: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.height * 100) / 100 })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(((segment?.width ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.width ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[0] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Y", max: Math.max((segment?.wallHeight ?? 3) + (segment ? getActiveRoofHeight(segment) : 3) + 2, (node.position[1] ?? 0) + 0.1), min: Math.min(0, (node.position[1] ?? 0) - 0.5), onChange: (v) => previewProp({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[1] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Z", max: Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[2] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (deg) => previewProp({ rotation: (deg * Math.PI) / 180 }), onCommit: (deg) => handleUpdate({ rotation: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.rotation ?? 0) * 180) / Math.PI) })] }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
+}

package/dist/cupola/parametrics.d.ts

@@ -0,0 +1,9 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { CupolaNode } from './schema';
+/**
+ * Inspector descriptor for the cupola. Move / Duplicate use the kind-owned
+ * ghost-preview flow (see `./move-tool.tsx`), so the panel hosts those
+ * actions itself — same pattern as box-vent.
+ */
+export declare const cupolaParametrics: ParametricDescriptor<CupolaNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/cupola/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/cupola/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,oBAAoB,CAAC,UAAU,CAwB9D,CAAA"}

package/dist/cupola/parametrics.js

@@ -0,0 +1,30 @@
+/**
+ * Inspector descriptor for the cupola. Move / Duplicate use the kind-owned
+ * ghost-preview flow (see `./move-tool.tsx`), so the panel hosts those
+ * actions itself — same pattern as box-vent.
+ */
+export const cupolaParametrics = {
+    customPanel: () => import('./panel'),
+    groups: [
+        {
+            label: 'Style',
+            fields: [
+                {
+                    key: 'roofStyle',
+                    kind: 'enum',
+                    options: ['dome', 'pyramid'],
+                    display: 'segmented',
+                },
+                { key: 'finial', kind: 'boolean' },
+            ],
+        },
+        {
+            label: 'Dimensions',
+            fields: [
+                { key: 'width', kind: 'number', unit: 'm', min: 0.3, max: 2, step: 0.05 },
+                { key: 'depth', kind: 'number', unit: 'm', min: 0.3, max: 2, step: 0.05 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.4, max: 2.5, step: 0.05 },
+            ],
+        },
+    ],
+};