@pascal-app/nodes 1.0.0 → 1.0.3

package/dist/unit/unit-panel.js

@@ -0,0 +1,61 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { buildUnitReport, getLevelDisplayName, UNIT_KINDS, unitWarnings, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, formatAreaLabel, PanelSection, PanelWrapper, triggerSFX, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Trash2, X } from 'lucide-react';
+import { useCallback, useMemo } from 'react';
+import { PanelSelect, PanelTextField } from '../shared/panel-fields';
+const UNIT_KIND_LABELS = {
+    apartment: 'Apartment',
+    'hotel-room': 'Hotel room',
+    commercial: 'Commercial',
+    common: 'Common',
+};
+const UNIT_KIND_OPTIONS = UNIT_KINDS.map((value) => ({ label: UNIT_KIND_LABELS[value], value }));
+function ReportRow({ label, value }) {
+    return (_jsxs("div", { className: "flex items-baseline gap-2 rounded-md border border-border/50 bg-background/35 px-2.5 py-2 text-xs", children: [_jsx("span", { className: "text-muted-foreground", children: label }), _jsx("span", { className: "ml-auto font-mono font-medium text-foreground tabular-nums", children: value })] }));
+}
+export default function UnitPanel({ node }) {
+    const nodes = useScene((state) => state.nodes);
+    const updateNode = useScene((state) => state.updateNode);
+    const setSelection = useViewer((state) => state.setSelection);
+    const areaUnit = useViewer((state) => state.unit);
+    const focusedUnitId = useViewer((state) => state.focusedUnitId);
+    const report = useMemo(() => buildUnitReport(node, nodes), [node, nodes]);
+    const warnings = useMemo(() => unitWarnings(node, nodes), [node, nodes]);
+    const memberLevels = useMemo(() => {
+        const ordinals = new Map();
+        for (const member of report.members) {
+            if (member.levelId && member.levelOrdinal !== null) {
+                ordinals.set(member.levelId, member.levelOrdinal);
+            }
+        }
+        return [...ordinals.entries()]
+            .sort((a, b) => a[1] - b[1])
+            .map(([levelId]) => {
+            const level = nodes[levelId];
+            return { levelId, name: level?.type === 'level' ? getLevelDisplayName(level) : '' };
+        });
+    }, [nodes, report]);
+    const levelNameById = useMemo(() => new Map(memberLevels.map((level) => [level.levelId, level.name])), [memberLevels]);
+    const levelSpanLabel = useMemo(() => {
+        const names = memberLevels.map((level) => level.name).filter(Boolean);
+        return names.length > 0 ? names.join(', ') : '—';
+    }, [memberLevels]);
+    const update = useCallback((patch) => updateNode(node.id, patch), [node.id, updateNode]);
+    const removeMember = useCallback((zoneId) => update({ members: node.members.filter((id) => id !== zoneId) }), [node.members, update]);
+    const handleClose = useCallback(() => setSelection({ selectedIds: [] }), [setSelection]);
+    const handleDelete = useCallback(() => {
+        triggerSFX('sfx:structure-delete');
+        useScene.getState().deleteNode(node.id);
+        setSelection({ selectedIds: [] });
+    }, [node.id, setSelection]);
+    const warningMessages = warnings.map((warning) => {
+        if (warning.code === 'non-adjacent-levels') {
+            return 'Members sit on levels that are not adjacent.';
+        }
+        return 'No zones assigned yet.';
+    });
+    return (_jsxs(PanelWrapper, { icon: "/icons/zone.webp", onClose: handleClose, title: node.name || 'Unit', width: 320, children: [_jsxs(PanelSection, { title: "Unit", children: [_jsx(PanelTextField, { label: "Name", onCommit: (name) => update({ name }), value: node.name }), _jsx(PanelSelect, { label: "Kind", onChange: (kind) => update({ kind: kind }), options: UNIT_KIND_OPTIONS, value: node.kind }), _jsxs("label", { className: "flex h-10 items-center justify-between gap-3 rounded-lg border border-border/50 bg-[#2C2C2E] px-3 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: "Color" }), _jsxs("span", { className: "flex items-center gap-2", children: [_jsx("span", { className: "font-mono text-muted-foreground text-xs", children: node.color }), _jsx("input", { className: "h-6 w-8 cursor-pointer rounded border border-border/50 bg-transparent", onChange: (event) => update({ color: event.target.value }), type: "color", value: node.color })] })] })] }), _jsxs(PanelSection, { title: "Members", children: [report.members.length === 0 ? (_jsx("p", { className: "text-muted-foreground text-xs leading-snug", children: "No zones yet. Draw zones while this unit is focused, or pick it from a zone's inspector." })) : (report.members.map((member) => (_jsxs("div", { className: "flex h-9 items-center gap-2 rounded-lg border border-border/50 bg-[#2C2C2E] px-3 text-xs", children: [_jsx("span", { className: "min-w-0 flex-1 truncate text-foreground", children: member.name || 'Zone' }), _jsx("span", { className: "shrink-0 truncate text-muted-foreground", children: member.levelId ? levelNameById.get(member.levelId) : '' }), _jsx("span", { className: "shrink-0 font-mono text-muted-foreground tabular-nums", children: formatAreaLabel(member.areaM2, areaUnit, 1) }), _jsx("button", { "aria-label": `Remove ${member.name || 'zone'} from unit`, className: "shrink-0 rounded-full p-1 text-muted-foreground transition-colors hover:bg-[#3e3e3e] hover:text-foreground", onClick: () => removeMember(member.zoneId), type: "button", children: _jsx(X, { className: "h-3.5 w-3.5" }) })] }, member.zoneId)))), warningMessages.length > 0 ? (_jsx("ul", { className: "flex flex-col gap-1 text-amber-300 text-xs leading-snug", children: warningMessages.map((message, index) => (_jsx("li", { children: message }, warnings[index]?.code))) })) : null] }), _jsxs(PanelSection, { title: "Report", children: [_jsx(ReportRow, { label: "Members", value: String(report.memberCount) }), _jsx(ReportRow, { label: "Levels", value: levelSpanLabel }), _jsx(ReportRow, { label: "Gross area", value: formatAreaLabel(report.grossAreaM2, areaUnit, 2) })] }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [focusedUnitId !== node.id && (_jsx(ActionButton, { className: "rounded-full", label: "Focus", onClick: () => useViewer.getState().setFocusedUnit(node.id) })), _jsx(ActionButton, { className: "text-destructive hover:text-destructive", icon: _jsx(Trash2, { className: "h-3.5 w-3.5" }), label: "Delete", onClick: handleDelete })] }) })] }));
+}

package/dist/wall/actions.d.ts

@@ -0,0 +1,3 @@
+/** The wall's action-menu contributions: Split (one wall) and Merge (several). */
+export default function WallActions(): import("react").JSX.Element;
+//# sourceMappingURL=actions.d.ts.map

package/dist/wall/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/wall/actions.tsx"],"names":[],"mappings":"AAgBA,kFAAkF;AAClF,MAAM,CAAC,OAAO,UAAU,WAAW,gCAOlC"}

package/dist/wall/actions.js

@@ -0,0 +1,56 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { planWallMerge, runAsSingleSceneHistoryStep, useScene, } from '@pascal-app/core';
+import { Tooltip, TooltipContent, TooltipTrigger, triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { FoldHorizontal, Scissors } from 'lucide-react';
+import { useMemo } from 'react';
+import { openWallSplit } from './split-session';
+const BUTTON = 'tooltip-trigger rounded-md p-1.5 text-muted-foreground hover:bg-accent hover:text-foreground disabled:pointer-events-none disabled:opacity-50';
+/** The wall's action-menu contributions: Split (one wall) and Merge (several). */
+export default function WallActions() {
+    return (_jsxs(_Fragment, { children: [_jsx(SplitWallAction, {}), _jsx(MergeWallsAction, {})] }));
+}
+function SplitWallAction() {
+    const selected = useViewer((s) => s.selection.selectedIds);
+    const wall = useScene((s) => selected.length === 1 ? s.nodes[selected[0]] : undefined);
+    const readOnly = useScene((s) => s.readOnly);
+    if (wall?.type !== 'wall')
+        return null;
+    return (_jsx("button", { type: "button", "aria-label": "Split wall", title: "Split wall", disabled: readOnly, className: BUTTON, onClick: (event) => {
+            event.stopPropagation();
+            openWallSplit(wall);
+        }, children: _jsx(Scissors, { className: "size-4" }) }));
+}
+/** Joins selected walls that continue each other into one — the inverse of Split. */
+function MergeWallsAction() {
+    const selected = useViewer((s) => s.selection.selectedIds);
+    const nodes = useScene((s) => s.nodes);
+    const readOnly = useScene((s) => s.readOnly);
+    // null: not a wall selection (render nothing); otherwise why it can't merge, or null.
+    const merge = useMemo(() => {
+        if (selected.length < 2 || selected.some((id) => nodes[id]?.type !== 'wall'))
+            return null;
+        try {
+            planWallMerge(nodes, selected);
+            return { reason: null };
+        }
+        catch (error) {
+            return { reason: error instanceof Error ? error.message : 'These walls cannot be merged.' };
+        }
+    }, [nodes, selected]);
+    if (!merge)
+        return null;
+    const { reason } = merge;
+    const button = (_jsx("button", { type: "button", "aria-label": "Merge walls", title: reason ? undefined : 'Merge walls', disabled: readOnly || reason !== null, className: BUTTON, onClick: (event) => {
+            event.stopPropagation();
+            const plan = planWallMerge(useScene.getState().nodes, selected);
+            runAsSingleSceneHistoryStep(useScene, () => useScene.getState().applyNodeChanges(plan.changes));
+            useViewer.getState().setSelection({ selectedIds: [plan.wallId] });
+            triggerSFX('sfx:structure-build');
+        }, children: _jsx(FoldHorizontal, { className: "size-4" }) }));
+    if (!reason)
+        return button;
+    // A disabled button gets no hover events, so the reason hangs off a wrapper.
+    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsx("span", { className: "inline-flex", children: button }) }), _jsx(TooltipContent, { side: "top", children: reason })] }));
+}

package/dist/wall/curtain-opening-frame.d.ts

@@ -0,0 +1,14 @@
+import { type DoorNode, type WallNode, type WindowNode } from '@pascal-app/core';
+import { type BufferGeometry, Vector2 } from 'three';
+export declare function mapCurtainOpeningGeometryToWall(geometry: BufferGeometry, wall: WallNode): void;
+export declare function curtainOpeningProfile(opening: DoorNode | WindowNode, width: number): {
+    inner: Vector2[];
+    outer: Vector2[];
+};
+export declare function buildCurtainOpeningFrame(opening: DoorNode | WindowNode, width: number, depth: number): {
+    frame: BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+    cutter: BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+    cutout: Vector2[];
+};
+export declare function curtainProfileSpan(points: readonly Vector2[], height: number): [number, number] | null;
+//# sourceMappingURL=curtain-opening-frame.d.ts.map

package/dist/wall/curtain-opening-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-opening-frame.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-opening-frame.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAIb,KAAK,QAAQ,EACb,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,KAAK,cAAc,EAAgC,OAAO,EAAE,MAAM,OAAO,CAAA;AAElF,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,QAsBvF;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,QAAQ,GAAG,UAAU,EAAE,KAAK,EAAE,MAAM;;;EAqClF;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM;;;;EA+Bd;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,MAAM,EAAE,MAAM,GACb,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CASzB"}

package/dist/wall/curtain-opening-frame.js

@@ -0,0 +1,111 @@
+import { getWallCurveFrameAt, getWallCurveLength, isCurvedWall, } from '@pascal-app/core';
+import { buildOpeningCutoutShape, ensureRenderableGeometryAttributes } from '@pascal-app/viewer';
+import { ExtrudeGeometry, Path, Shape, Vector2 } from 'three';
+export function mapCurtainOpeningGeometryToWall(geometry, wall) {
+    if (!isCurvedWall(wall))
+        return;
+    const length = getWallCurveLength(wall);
+    if (length <= 1e-6)
+        return;
+    const angle = Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const position = geometry.getAttribute('position');
+    for (let index = 0; index < position.count; index++) {
+        const along = position.getX(index);
+        const depth = position.getZ(index);
+        const clampedAlong = Math.max(0, Math.min(length, along));
+        const frame = getWallCurveFrameAt(wall, clampedAlong / length);
+        const extension = along - clampedAlong;
+        const x = frame.point.x + frame.tangent.x * extension + frame.normal.x * depth - wall.start[0];
+        const z = frame.point.y + frame.tangent.y * extension + frame.normal.y * depth - wall.start[1];
+        position.setXYZ(index, x * cos + z * sin, position.getY(index), -x * sin + z * cos);
+    }
+    position.needsUpdate = true;
+    geometry.boundingBox = null;
+    geometry.boundingSphere = null;
+    geometry.computeVertexNormals();
+}
+export function curtainOpeningProfile(opening, width) {
+    const bottom = opening.position[1] - opening.height / 2;
+    if (Math.cos(opening.rotation[1]) < 0 && opening.openingRadiusMode === 'individual') {
+        if (opening.type === 'window') {
+            const [topLeft, topRight, bottomRight, bottomLeft] = opening.openingCornerRadii;
+            opening = {
+                ...opening,
+                openingCornerRadii: [topRight, topLeft, bottomLeft, bottomRight],
+            };
+        }
+        else {
+            const [topLeft, topRight] = opening.openingTopRadii;
+            opening = { ...opening, openingTopRadii: [topRight, topLeft] };
+        }
+    }
+    const points = buildOpeningCutoutShape(opening, {
+        left: opening.position[0] - opening.width / 2,
+        right: opening.position[0] + opening.width / 2,
+        bottom,
+        top: bottom + opening.height,
+    })
+        .getPoints(4)
+        .filter((point, index, all) => index === 0 || point.distanceToSquared(all[index - 1]) > 1e-14);
+    if (points[0].distanceToSquared(points.at(-1)) < 1e-14)
+        points.pop();
+    const outer = points.map((point, index) => {
+        const previous = points[(index + points.length - 1) % points.length];
+        const next = points[(index + 1) % points.length];
+        const before = point.clone().sub(previous).normalize();
+        const after = next.clone().sub(point).normalize();
+        const n1 = new Vector2(before.y, -before.x);
+        const n2 = new Vector2(after.y, -after.x);
+        const result = point
+            .clone()
+            .addScaledVector(n1.clone().add(n2), width / Math.max(1e-6, 1 + n1.dot(n2)));
+        if (opening.type === 'door' && Math.abs(point.y - bottom) < 1e-7)
+            result.y = bottom;
+        return result;
+    });
+    return { inner: points, outer };
+}
+export function buildCurtainOpeningFrame(opening, width, depth) {
+    const { inner, outer } = curtainOpeningProfile(opening, width);
+    const outline = new Shape(outer);
+    outline.closePath();
+    let ring;
+    if (opening.type === 'door') {
+        // The door has jambs and a head; its threshold remains owned by the door.
+        ring = new Shape([...outer.slice(1), outer[0], inner[0], ...inner.slice(1).reverse()]);
+        ring.closePath();
+    }
+    else {
+        ring = new Shape(outer);
+        ring.closePath();
+        const hole = new Path([...inner].reverse());
+        hole.closePath();
+        ring.holes.push(hole);
+    }
+    const extrude = (shape, thickness) => {
+        const indexed = new ExtrudeGeometry(shape, {
+            depth: thickness,
+            bevelEnabled: false,
+            steps: 1,
+        });
+        indexed.translate(0, 0, -thickness / 2);
+        ensureRenderableGeometryAttributes(indexed);
+        if (!indexed.index)
+            return indexed;
+        const geometry = indexed.toNonIndexed();
+        indexed.dispose();
+        return geometry;
+    };
+    return { frame: extrude(ring, depth), cutter: extrude(outline, depth * 3), cutout: outer };
+}
+export function curtainProfileSpan(points, height) {
+    const xs = [];
+    for (let i = 0; i < points.length; i++) {
+        const a = points[i], b = points[(i + 1) % points.length];
+        if ((a.y <= height && b.y > height) || (b.y <= height && a.y > height))
+            xs.push(a.x + ((b.x - a.x) * (height - a.y)) / (b.y - a.y));
+    }
+    return xs.length >= 2 ? [Math.min(...xs), Math.max(...xs)] : null;
+}

package/dist/wall/curtain-panel-highlight.d.ts

@@ -0,0 +1,3 @@
+import { type WallNode } from '@pascal-app/core';
+export declare function useCurtainPanelHighlight(wall: WallNode, left: number, right: number, bottom: number, top: number, enabled: boolean): void;
+//# sourceMappingURL=curtain-panel-highlight.d.ts.map

package/dist/wall/curtain-panel-highlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-panel-highlight.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-panel-highlight.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAezB,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,QA2GjB"}

package/dist/wall/curtain-panel-highlight.js

@@ -0,0 +1,113 @@
+import { getWallCurveFrameAt, getWallCurveLength, getWallThickness, sceneRegistry, } from '@pascal-app/core';
+import { EDITOR_LAYER } from '@pascal-app/editor';
+import { useEffect } from 'react';
+import { BufferGeometry, DoubleSide, Float32BufferAttribute, Line, LineBasicMaterial, Mesh, MeshBasicMaterial, Vector3, } from 'three';
+export function useCurtainPanelHighlight(wall, left, right, bottom, top, enabled) {
+    const wallId = wall.id;
+    const startX = wall.start[0];
+    const startZ = wall.start[1];
+    const endX = wall.end[0];
+    const endZ = wall.end[1];
+    const curveOffset = wall.curveOffset;
+    const thickness = getWallThickness(wall);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const curveWall = {
+            start: [startX, startZ],
+            end: [endX, endZ],
+            curveOffset,
+        };
+        const host = sceneRegistry.nodes.get(wallId);
+        if (!host)
+            return;
+        const length = getWallCurveLength(curveWall);
+        if (length <= 0)
+            return;
+        const angle = Math.atan2(endZ - startZ, endX - startX);
+        const cos = Math.cos(angle), sin = Math.sin(angle);
+        const points = [];
+        for (const y of [bottom, top]) {
+            const edge = [];
+            for (let i = 0; i <= 24; i++) {
+                const frame = getWallCurveFrameAt(curveWall, (left + ((right - left) * i) / 24) / length);
+                const offset = thickness / 2 + 0.005;
+                const x = frame.point.x + frame.normal.x * offset - startX;
+                const z = frame.point.y + frame.normal.y * offset - startZ;
+                edge.push(new Vector3(x * cos + z * sin, y, -x * sin + z * cos));
+            }
+            points.push(...(y === bottom ? edge : edge.reverse()));
+        }
+        points.push(points[0].clone());
+        const geometry = new BufferGeometry().setFromPoints(points);
+        const material = new LineBasicMaterial({
+            color: '#fb923c',
+            depthTest: false,
+            depthWrite: false,
+        });
+        const outline = new Line(geometry, material);
+        outline.layers.set(EDITOR_LAYER);
+        outline.raycast = () => { };
+        const vertices = [];
+        for (let i = 0; i < 24; i++) {
+            for (const index of [i, i + 1, 49 - i, i + 1, 48 - i, 49 - i]) {
+                vertices.push(...points[index].toArray());
+            }
+        }
+        const fillGeometry = new BufferGeometry();
+        fillGeometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
+        const fillMaterial = new MeshBasicMaterial({
+            color: '#fb923c',
+            transparent: true,
+            opacity: 0.6,
+            side: DoubleSide,
+            depthTest: false,
+            depthWrite: false,
+        });
+        const fill = new Mesh(fillGeometry, fillMaterial);
+        fill.layers.set(EDITOR_LAYER);
+        fill.raycast = () => { };
+        let scene = host;
+        while (scene.parent)
+            scene = scene.parent;
+        outline.matrixAutoUpdate = false;
+        fill.matrixAutoUpdate = false;
+        scene.add(outline, fill);
+        let frameId = 0;
+        const sync = () => {
+            const current = sceneRegistry.nodes.get(wallId);
+            outline.visible = fill.visible = Boolean(current?.visible);
+            if (current) {
+                current.updateWorldMatrix(true, false);
+                outline.matrix.copy(current.matrixWorld);
+                fill.matrix.copy(current.matrixWorld);
+                outline.matrixWorld.copy(current.matrixWorld);
+                fill.matrixWorld.copy(current.matrixWorld);
+            }
+            frameId = requestAnimationFrame(sync);
+        };
+        sync();
+        return () => {
+            cancelAnimationFrame(frameId);
+            outline.removeFromParent();
+            fill.removeFromParent();
+            fillGeometry.dispose();
+            fillMaterial.dispose();
+            geometry.dispose();
+            material.dispose();
+        };
+    }, [
+        enabled,
+        wallId,
+        startX,
+        startZ,
+        endX,
+        endZ,
+        curveOffset,
+        thickness,
+        left,
+        right,
+        bottom,
+        top,
+    ]);
+}

package/dist/wall/curtain-wall-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { WallGeometryAdapter } from '@pascal-app/viewer';
+export declare const curtainWallGeometryAdapter: WallGeometryAdapter;
+//# sourceMappingURL=curtain-wall-adapter.d.ts.map

package/dist/wall/curtain-wall-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-adapter.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAW7D,eAAO,MAAM,0BAA0B,EAAE,mBAgDxC,CAAA"}

package/dist/wall/curtain-wall-adapter.js

@@ -0,0 +1,55 @@
+import { useLiveNodeOverrides } from '@pascal-app/core';
+import { buildCurtainWallGeometry } from './curtain-wall-geometry';
+import { buildCurtainWallShadowGeometry, CURTAIN_WALL_SHADOW_NAME } from './curtain-wall-shadow';
+function isOpaque(material) {
+    return material !== undefined && (!material.transparent || material.opacity >= 1);
+}
+const deferredShadowWalls = new Set();
+export const curtainWallGeometryAdapter = {
+    prepareChildren(wall, children, context) {
+        if (wall.wallType !== 'curtain') {
+            return { envelopeChildren: [...children], renderChildren: [...children] };
+        }
+        const renderChildren = children.map((child) => {
+            if ((child.type !== 'door' && child.type !== 'window') || child.openingShape === 'rectangle')
+                return child;
+            const override = useLiveNodeOverrides.getState().get(child.id);
+            const liveBounds = context.isLive(child.id) &&
+                (!override || 'position' in override || 'width' in override || 'height' in override);
+            return liveBounds ? { ...child, openingShape: 'rectangle' } : child;
+        });
+        return {
+            envelopeChildren: renderChildren.filter((child) => child.type !== 'door' && child.type !== 'window'),
+            renderChildren,
+        };
+    },
+    buildGeometry(wall, envelope, children) {
+        if (wall.wallType !== 'curtain')
+            return envelope;
+        const livePreview = children.some((child) => (child.type === 'door' || child.type === 'window') &&
+            useLiveNodeOverrides.getState().get(child.id) !== undefined);
+        const deferShadow = children.some((child) => {
+            if (child.type !== 'door' && child.type !== 'window')
+                return false;
+            const metadata = useLiveNodeOverrides.getState().get(child.id)?.metadata;
+            return metadata?.deferParentRebuild === true;
+        });
+        if (deferShadow)
+            deferredShadowWalls.add(wall.id);
+        else
+            deferredShadowWalls.delete(wall.id);
+        return buildCurtainWallGeometry(wall, envelope, children, livePreview);
+    },
+    syncAuxiliaryGeometry(wall, mesh, geometry) {
+        if (wall.wallType !== 'curtain')
+            return;
+        if (deferredShadowWalls.has(wall.id))
+            return;
+        const shadowMesh = mesh.getObjectByName(CURTAIN_WALL_SHADOW_NAME);
+        if (!shadowMesh)
+            return;
+        const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+        shadowMesh.geometry.dispose();
+        shadowMesh.geometry = buildCurtainWallShadowGeometry(geometry, isOpaque(materials[1]));
+    },
+};

package/dist/wall/curtain-wall-floorplan.d.ts

@@ -0,0 +1,3 @@
+import { type AnyNode, type FloorplanGeometry, type WallNode } from '@pascal-app/core';
+export declare function buildCurtainWallFloorplan(wall: WallNode, height: number, stroke: string, children?: readonly AnyNode[]): FloorplanGeometry[];
+//# sourceMappingURL=curtain-wall-floorplan.d.ts.map

package/dist/wall/curtain-wall-floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,iBAAiB,EAKtB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAIzB,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,SAAS,OAAO,EAAO,GAChC,iBAAiB,EAAE,CAwFrB"}

package/dist/wall/curtain-wall-floorplan.js

@@ -0,0 +1,91 @@
+import { getCurtainWallConfig, getWallCurveFrameAt, getWallCurveLength, getWallThickness, } from '@pascal-app/core';
+import { curtainOpeningProfile, curtainProfileSpan } from './curtain-opening-frame';
+import { buildCurtainWallLayout } from './curtain-wall-layout';
+export function buildCurtainWallFloorplan(wall, height, stroke, children = []) {
+    const length = getWallCurveLength(wall);
+    if (length <= 1e-6)
+        return [];
+    const config = getCurtainWallConfig(wall);
+    const cutHeight = Math.min(1.2, height * 0.5);
+    const openings = children
+        .filter((child) => child.type === 'door' || child.type === 'window')
+        .map((opening) => ({
+        opening,
+        profile: curtainOpeningProfile(opening, config.perimeterWidth),
+        framed: opening.openingShape !== 'rectangle',
+    }));
+    const pieces = buildCurtainWallLayout(length, height, getWallThickness(wall), config, children.filter((child) => child.type === 'door' || child.type === 'window'))
+        .filter((piece) => piece.bottom <= cutHeight && piece.top > cutHeight)
+        .flatMap((piece) => {
+        let runs = [piece];
+        for (const { profile, framed } of openings) {
+            const span = curtainProfileSpan(framed ? profile.outer : profile.inner, cutHeight);
+            if (!span)
+                continue;
+            const [left, right] = span;
+            runs = runs.flatMap((run) => {
+                if (right <= run.left || left >= run.right)
+                    return [run];
+                return [
+                    ...(left > run.left ? [{ ...run, right: left }] : []),
+                    ...(right < run.right ? [{ ...run, left: right }] : []),
+                ];
+            });
+        }
+        return runs;
+    });
+    for (const { profile, framed } of openings) {
+        if (!framed)
+            continue;
+        const outer = curtainProfileSpan(profile.outer, cutHeight);
+        const inner = curtainProfileSpan(profile.inner, cutHeight);
+        if (!outer)
+            continue;
+        const spans = inner
+            ? [
+                [outer[0], inner[0]],
+                [inner[1], outer[1]],
+            ]
+            : [outer];
+        for (const [left, right] of spans) {
+            if (right - left <= 1e-6)
+                continue;
+            pieces.push({
+                left: Math.max(0, left),
+                right: Math.min(length, right),
+                bottom: 0,
+                top: height,
+                front: getWallThickness(wall) / 2,
+                back: -getWallThickness(wall) / 2,
+                role: 'frame',
+            });
+        }
+    }
+    return pieces.map((piece) => {
+        const points = [];
+        for (const offset of [piece.front, piece.back]) {
+            const side = [];
+            for (let i = 0; i <= 8; i++) {
+                const along = piece.left + ((piece.right - piece.left) * i) / 8;
+                const frame = getWallCurveFrameAt(wall, along / length);
+                side.push([
+                    frame.point.x + frame.normal.x * offset,
+                    frame.point.y + frame.normal.y * offset,
+                ]);
+            }
+            points.push(...(offset === piece.front ? side : side.reverse()));
+        }
+        return {
+            kind: 'polygon',
+            points,
+            fill: piece.role === 'glass'
+                ? config.glassColor
+                : piece.role === 'frame'
+                    ? config.frameColor
+                    : config.solidColor,
+            stroke,
+            strokeWidth: 0.008,
+            pointerEvents: 'none',
+        };
+    });
+}

package/dist/wall/curtain-wall-geometry.d.ts

@@ -0,0 +1,4 @@
+import { type AnyNode, type WallNode } from '@pascal-app/core';
+import { BufferGeometry } from 'three';
+export declare function buildCurtainWallGeometry(wall: WallNode, envelope: BufferGeometry, children?: readonly AnyNode[], livePreview?: boolean): BufferGeometry;
+//# sourceMappingURL=curtain-wall-geometry.d.ts.map

package/dist/wall/curtain-wall-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-geometry.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAMZ,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,cAAc,EAA0B,MAAM,OAAO,CAAA;AAkD9D,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,cAAc,EACxB,QAAQ,GAAE,SAAS,OAAO,EAAO,EACjC,WAAW,UAAQ,GAClB,cAAc,CA+MhB"}