@pascal-app/nodes 1.0.1 → 1.0.4

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

@@ -0,0 +1,176 @@
+export function curtainGridPositions(length, grid) {
+    if (!Number.isFinite(length) || length <= 0)
+        return [0];
+    const count = grid.layout === 'count' ? grid.count : Math.ceil(length / grid.spacing);
+    const bounded = Math.max(1, Math.min(32, count));
+    if (grid.layout !== 'fixed-spacing' || count > 32) {
+        return Array.from({ length: bounded + 1 }, (_, index) => (length * index) / bounded);
+    }
+    const whole = Math.floor(length / grid.spacing);
+    const remainder = length - whole * grid.spacing;
+    const offset = grid.alignment === 'start' ? 0 : grid.alignment === 'end' ? remainder : remainder / 2;
+    const positions = [0];
+    for (let index = 0; index <= whole; index++) {
+        const value = offset + index * grid.spacing;
+        if (value > 1e-6 && value < length - 1e-6)
+            positions.push(value);
+    }
+    positions.push(length);
+    // A centered remainder can introduce two edge cells.
+    return positions.length <= 33
+        ? positions
+        : Array.from({ length: 33 }, (_, i) => (length * i) / 32);
+}
+export function curtainPanelType(config, column, row, rowCount) {
+    const override = config.panels.find((panel) => panel.column === column && panel.row === row);
+    if (override)
+        return override.type;
+    if ((config.spandrel === 'bottom' && row === 0) ||
+        (config.spandrel === 'top' && row === rowCount - 1))
+        return 'solid';
+    return config.panelType;
+}
+export function buildCurtainWallLayout(length, height, depth, config, openings = [], baseElevation = 0) {
+    if (length <= 1e-6 || height <= 1e-6 || depth <= 0)
+        return [];
+    const xs = curtainGridPositions(length, config.columns);
+    const ys = curtainGridPositions(height, config.rows);
+    const pieces = [];
+    const panelDepth = Math.min(config.glassThickness, depth * 0.45);
+    const panelFront = depth / 2 - Math.min(0.005, depth * 0.05);
+    const panelBack = panelFront - panelDepth;
+    const add = (left, right, bottom, top, front, role, back = -depth / 2) => {
+        if (right - left > 1e-6 && top - bottom > 1e-6 && front - back > 1e-6)
+            pieces.push({ left, right, bottom, top, front, back, role });
+    };
+    const verticalCap = config.framing === 'capped' || config.framing === 'vertical-caps';
+    const horizontalCap = config.framing === 'capped' || config.framing === 'horizontal-caps';
+    if (config.construction === 'stick') {
+        const verticalBounds = xs.map((x, index) => {
+            if (index === 0)
+                return [0, Math.min(config.perimeterWidth, (xs[1] - x) * 0.4)];
+            if (index === xs.length - 1)
+                return [length - Math.min(config.perimeterWidth, (x - xs[index - 1]) * 0.4), length];
+            return [
+                x - Math.min(config.mullionWidth / 2, (x - xs[index - 1]) * 0.4),
+                x + Math.min(config.mullionWidth / 2, (xs[index + 1] - x) * 0.4),
+            ];
+        });
+        const horizontalBounds = ys.map((y, index) => {
+            if (index === 0)
+                return [0, Math.min(config.perimeterWidth, (ys[1] - y) * 0.4)];
+            if (index === ys.length - 1)
+                return [height - Math.min(config.perimeterWidth, (y - ys[index - 1]) * 0.4), height];
+            return [
+                y - Math.min(config.transomWidth / 2, (y - ys[index - 1]) * 0.4),
+                y + Math.min(config.transomWidth / 2, (ys[index + 1] - y) * 0.4),
+            ];
+        });
+        for (const [left, right] of verticalBounds)
+            add(left, right, 0, height, verticalCap ? depth / 2 : panelBack, 'frame');
+        for (const [bottom, top] of horizontalBounds) {
+            for (let column = 0; column < xs.length - 1; column++) {
+                add(verticalBounds[column][1], verticalBounds[column + 1][0], bottom, top, horizontalCap ? depth / 2 : panelBack, 'frame');
+            }
+        }
+        for (let column = 0; column < xs.length - 1; column++) {
+            for (let row = 0; row < ys.length - 1; row++) {
+                const type = curtainPanelType(config, column, row, ys.length - 1);
+                if (type === 'empty')
+                    continue;
+                add(verticalBounds[column][1], verticalBounds[column + 1][0], horizontalBounds[row][1], horizontalBounds[row + 1][0], panelFront, type, panelBack);
+            }
+        }
+    }
+    else {
+        for (let column = 0; column < xs.length - 1; column++) {
+            for (let row = 0; row < ys.length - 1; row++) {
+                const x0 = xs[column], x1 = xs[column + 1], y0 = ys[row], y1 = ys[row + 1];
+                const gap = config.construction === 'unitized'
+                    ? Math.min(config.jointWidth / 2, (x1 - x0) / 10, (y1 - y0) / 10)
+                    : 0;
+                const left = x0 + (column === 0 ? 0 : gap), right = x1 - (column === xs.length - 2 ? 0 : gap);
+                const bottom = y0 + (row === 0 ? 0 : gap), top = y1 - (row === ys.length - 2 ? 0 : gap);
+                const lw = Math.min(column === 0 ? config.perimeterWidth : config.mullionWidth / 2, (right - left) * 0.4);
+                const rw = Math.min(column === xs.length - 2 ? config.perimeterWidth : config.mullionWidth / 2, (right - left) * 0.4);
+                const bw = Math.min(row === 0 ? config.perimeterWidth : config.transomWidth / 2, (top - bottom) * 0.4);
+                const tw = Math.min(row === ys.length - 2 ? config.perimeterWidth : config.transomWidth / 2, (top - bottom) * 0.4);
+                add(left, left + lw, bottom, top, verticalCap ? depth / 2 : panelBack, 'frame');
+                add(right - rw, right, bottom, top, verticalCap ? depth / 2 : panelBack, 'frame');
+                add(left + lw, right - rw, bottom, bottom + bw, horizontalCap ? depth / 2 : panelBack, 'frame');
+                add(left + lw, right - rw, top - tw, top, horizontalCap ? depth / 2 : panelBack, 'frame');
+                const type = curtainPanelType(config, column, row, ys.length - 1);
+                if (type === 'empty')
+                    continue;
+                const joint = Math.min(config.jointWidth / 2, (right - left) * 0.1, (top - bottom) * 0.1);
+                add(left + (verticalCap ? lw : joint), right - (verticalCap ? rw : joint), bottom + (horizontalCap ? bw : joint), top - (horizontalCap ? tw : joint), panelFront, type, panelBack);
+            }
+        }
+    }
+    let fitted = pieces;
+    for (const opening of openings) {
+        if (opening.openingShape !== 'rectangle')
+            continue;
+        const left = opening.position[0] - opening.width / 2;
+        const right = opening.position[0] + opening.width / 2;
+        const bottom = opening.position[1] - opening.height / 2 - baseElevation;
+        const top = bottom + opening.height;
+        if (right <= 0 || left >= length || top <= 0 || bottom >= height)
+            continue;
+        const outerLeft = Math.max(0, left - config.perimeterWidth);
+        const outerRight = Math.min(length, right + config.perimeterWidth);
+        const outerBottom = Math.max(0, bottom - (opening.type === 'window' ? config.perimeterWidth : 0));
+        const outerTop = Math.min(height, top + config.perimeterWidth);
+        // Replace intersecting infill and grid members with a continuous entrance subframe.
+        fitted = fitted.flatMap((piece) => {
+            const x0 = Math.max(piece.left, outerLeft);
+            const x1 = Math.min(piece.right, outerRight);
+            const y0 = Math.max(piece.bottom, outerBottom);
+            const y1 = Math.min(piece.top, outerTop);
+            if (x1 <= x0 || y1 <= y0)
+                return [piece];
+            return [
+                { ...piece, right: x0 },
+                { ...piece, left: x1 },
+                { ...piece, left: x0, right: x1, top: y0 },
+                { ...piece, left: x0, right: x1, bottom: y1 },
+            ].filter((part) => part.right - part.left > 1e-6 && part.top - part.bottom > 1e-6);
+        });
+        const frame = { front: depth / 2, back: -depth / 2, role: 'frame' };
+        fitted.push(...[
+            ...(opening.type === 'window'
+                ? [
+                    {
+                        ...frame,
+                        left: Math.max(0, left),
+                        right: Math.min(length, right),
+                        bottom: outerBottom,
+                        top: Math.min(height, bottom),
+                    },
+                ]
+                : []),
+            {
+                ...frame,
+                left: outerLeft,
+                right: Math.min(length, left),
+                bottom: outerBottom,
+                top: outerTop,
+            },
+            {
+                ...frame,
+                left: Math.max(0, right),
+                right: outerRight,
+                bottom: outerBottom,
+                top: outerTop,
+            },
+            {
+                ...frame,
+                left: Math.max(0, left),
+                right: Math.min(length, right),
+                bottom: Math.max(0, top),
+                top: outerTop,
+            },
+        ].filter((part) => part.right - part.left > 1e-6 && part.top - part.bottom > 1e-6));
+    }
+    return fitted;
+}

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

@@ -0,0 +1,5 @@
+import { type SceneMaterial, type SceneMaterialId, type WallNode } from '@pascal-app/core';
+import { getMaterialsForWall, type RenderShading, type WallMaterialOverride, type WallMaterials } from '@pascal-app/viewer';
+export declare function createCurtainWallMaterials(wall: WallNode, shading: RenderShading, materials?: Record<SceneMaterialId, SceneMaterial>): WallMaterialOverride;
+export declare function getCurtainAwareWallMaterials(wall: WallNode, shading?: RenderShading, textures?: boolean, colorPreset?: Parameters<typeof getMaterialsForWall>[3], sceneTheme?: string, materials?: Record<SceneMaterialId, SceneMaterial>, finishRefs?: readonly string[]): WallMaterials;
+//# sourceMappingURL=curtain-wall-materials.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-materials.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,mBAAmB,EACnB,KAAK,aAAa,EAElB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAA;AAI3B,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,SAAS,CAAC,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GACjD,oBAAoB,CA6CtB;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAU,EAC/D,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,EAClD,UAAU,GAAE,SAAS,MAAM,EAAO,GACjC,aAAa,CAef"}

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

@@ -0,0 +1,55 @@
+import { getCurtainWallConfig, } from '@pascal-app/core';
+import { getMaterialsForWall, resolveMaterialRef, } from '@pascal-app/viewer';
+import { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
+export function createCurtainWallMaterials(wall, shading, materials) {
+    const config = getCurtainWallConfig(wall);
+    return {
+        hash: JSON.stringify({
+            config,
+            slots: ['curtain-frame', 'curtain-glass', 'curtain-solid'].map((slot) => {
+                const ref = wall.slots?.[slot];
+                return [
+                    ref,
+                    ref?.startsWith('scene:') ? materials?.[ref.slice(6)] : null,
+                ];
+            }),
+        }),
+        create: () => {
+            const owned = [];
+            const visible = ['frame', 'glass', 'solid'].map((role) => {
+                const ref = wall.slots?.[`curtain-${role}`];
+                const override = ref ? resolveMaterialRef(ref, materials, shading) : undefined;
+                if (override)
+                    return override;
+                const glass = role === 'glass';
+                const color = glass
+                    ? config.glassColor
+                    : role === 'frame'
+                        ? config.frameColor
+                        : config.solidColor;
+                const properties = {
+                    color,
+                    transparent: glass,
+                    opacity: glass ? config.glassOpacity : 1,
+                    depthWrite: !glass,
+                };
+                const material = shading === 'solid'
+                    ? new MeshLambertNodeMaterial(properties)
+                    : new MeshStandardNodeMaterial({
+                        ...properties,
+                        metalness: role === 'frame' ? 0.65 : 0,
+                        roughness: glass ? config.glassRoughness : 0.4,
+                    });
+                owned.push(material);
+                return material;
+            });
+            return { visible, owned };
+        },
+    };
+}
+export function getCurtainAwareWallMaterials(wall, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme, materials, finishRefs = []) {
+    const override = textures && wall.wallType === 'curtain'
+        ? createCurtainWallMaterials(wall, shading, materials)
+        : undefined;
+    return getMaterialsForWall(wall, shading, textures, colorPreset, sceneTheme, materials, finishRefs, override);
+}

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

@@ -0,0 +1,14 @@
+import { type CurtainWallConfig, type WallNode } from '@pascal-app/core';
+type Props = {
+    node: WallNode;
+    height: number;
+    unit: 'metric' | 'imperial';
+    onUpdate: (patch: Partial<WallNode>) => void;
+    onPreview: (patch: Partial<WallNode>) => void;
+    onCommit: () => void;
+    onCancel: () => void;
+};
+export declare function getCurtainWallUpdate(node: WallNode, patch: Partial<CurtainWallConfig>): Pick<WallNode, 'curtainWall'>;
+export declare function CurtainWallPanel({ node, height, unit, onUpdate, onPreview, onCommit, onCancel, }: Props): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=curtain-wall-panel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-panel.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-panel.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,iBAAiB,EAKtB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAczB,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,QAAQ,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAA;IAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAA;IAC5C,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAA;IAC7C,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,QAAQ,EAAE,MAAM,IAAI,CAAA;CACrB,CAAA;AA6KD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAChC,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,CAI/B;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,QAAQ,GACT,EAAE,KAAK,+BAscP"}

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

@@ -0,0 +1,167 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { getCurtainWallConfig, getEffectiveNode, getWallCurveLength, getWallThickness, } from '@pascal-app/core';
+import { getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, SegmentedControl, SliderControl, ToggleControl, } from '@pascal-app/editor';
+import { useState } from 'react';
+import { useCurtainPanelHighlight } from './curtain-panel-highlight';
+import { curtainGridPositions, curtainPanelType } from './curtain-wall-layout';
+function Choice({ label, value, options, onChange, }) {
+    return (_jsxs("label", { className: "flex items-center justify-between gap-2 text-xs text-muted-foreground", children: [label, _jsx("select", { "aria-label": label, className: "max-w-[160px] rounded-md border border-border bg-background px-2 py-1.5 text-foreground", onChange: (event) => {
+                    const option = options.find((entry) => entry.value === event.target.value);
+                    if (option)
+                        onChange(option.value);
+                }, value: value, children: options.map((option) => (_jsx("option", { value: option.value, children: option.label }, option.value))) })] }));
+}
+function LengthControl({ label, value, min, max, unit, onChange, onCommit, onCancel, profile = false, }) {
+    const millimeters = profile && unit === 'metric';
+    const display = (meters) => millimeters ? meters * 1000 : metersToLinearUnit(meters, unit);
+    return (_jsx(SliderControl, { onCommit: onCommit, onCancel: onCancel, restoreOnCommit: false, previewWhileTyping: true, label: label, max: display(max), min: display(min), onChange: (next) => onChange(millimeters
+            ? Math.max(min, Math.min(max, next / 1000))
+            : linearControlValueToMeters(next, unit, { minMeters: min, maxMeters: max })), precision: millimeters ? 1 : 3, step: millimeters ? 1 : 0.005, unit: millimeters ? 'mm' : getLinearUnitLabel(unit), value: display(value) }));
+}
+function GridSection({ length, vertical = false, onPreview, title, value, unit, onChange, onCommit, onCancel, }) {
+    return (_jsxs(PanelSection, { title: title, children: [_jsx(Choice, { label: "Layout", onChange: (layout) => onChange({ ...value, layout }), options: [
+                    { label: 'Panel count', value: 'count' },
+                    { label: 'Maximum spacing', value: 'maximum-spacing' },
+                    { label: 'Fixed spacing', value: 'fixed-spacing' },
+                ], value: value.layout }), value.layout === 'count' ? (_jsx(SliderControl, { onCommit: onCommit, onCancel: onCancel, restoreOnCommit: false, previewWhileTyping: true, label: "Panels", max: 32, min: 1, onChange: (count) => onPreview({ ...value, count: Math.round(count) }), precision: 0, step: 1, value: value.count })) : (_jsx(LengthControl, { onCommit: onCommit, onCancel: onCancel, label: "Spacing", max: 100, min: 0.2, onChange: (spacing) => onPreview({ ...value, spacing }), unit: unit, value: value.spacing })), value.layout === 'fixed-spacing' && (_jsx(SegmentedControl, { onChange: (alignment) => onChange({ ...value, alignment }), options: [
+                    { label: vertical ? 'Bottom' : 'Start', value: 'start' },
+                    { label: 'Center', value: 'center' },
+                    { label: vertical ? 'Top' : 'End', value: 'end' },
+                ], value: value.alignment })), _jsx("p", { className: "text-[11px] text-muted-foreground", children: (() => {
+                    const positions = curtainGridPositions(length, value);
+                    const spans = positions.slice(1).map((position, i) => position - positions[i]);
+                    if (!spans.length)
+                        return 'No panels';
+                    const min = metersToLinearUnit(Math.min(...spans), unit);
+                    const max = metersToLinearUnit(Math.max(...spans), unit);
+                    return `${spans.length} ${vertical ? 'rows' : 'columns'} · ${min.toFixed(2)}${max - min > 0.005 ? `–${max.toFixed(2)}` : ''} ${getLinearUnitLabel(unit)} grid spacing`;
+                })() })] }));
+}
+const PANEL_OPTIONS = [
+    { label: 'Glass', value: 'glass' },
+    { label: 'Solid', value: 'solid' },
+    { label: 'Empty', value: 'empty' },
+];
+export function getCurtainWallUpdate(node, patch) {
+    return {
+        curtainWall: { ...getCurtainWallConfig(getEffectiveNode(node)), ...patch },
+    };
+}
+export function CurtainWallPanel({ node, height, unit, onUpdate, onPreview, onCommit, onCancel, }) {
+    const config = getCurtainWallConfig(node);
+    const update = (patch, preview = false) => {
+        ;
+        (preview ? onPreview : onUpdate)(getCurtainWallUpdate(node, patch));
+    };
+    const [tintEditing, setTintEditing] = useState(false);
+    const [panelEditing, setPanelEditing] = useState(false);
+    const [selectedColumn, setColumn] = useState(0);
+    const [selectedRow, setRow] = useState(0);
+    const columnCount = curtainGridPositions(getWallCurveLength(node), config.columns).length - 1;
+    const rowCount = curtainGridPositions(height, config.rows).length - 1;
+    const column = Math.max(0, Math.min(selectedColumn, columnCount - 1));
+    const row = Math.max(0, Math.min(selectedRow, rowCount - 1));
+    const selectedType = curtainPanelType(config, column, row, rowCount);
+    const changePanel = (type) => update({
+        panels: [
+            ...config.panels.filter((panel) => panel.column !== column || panel.row !== row),
+            ...(type ? [{ column, row, type }] : []),
+        ],
+    });
+    const hiddenOverrides = config.panels.filter((panel) => panel.column >= columnCount || panel.row >= rowCount);
+    const diagramWidth = Math.max(240, columnCount * 32);
+    const diagramHeight = Math.max(150, rowCount * 32);
+    const overridden = config.panels.some((panel) => panel.column === column && panel.row === row);
+    const xs = curtainGridPositions(getWallCurveLength(node), config.columns);
+    const ys = curtainGridPositions(height, config.rows);
+    useCurtainPanelHighlight(node, xs[column] ?? 0, xs[column + 1] ?? 0, ys[row] ?? 0, ys[row + 1] ?? 0, panelEditing);
+    const hasGlass = xs
+        .slice(1)
+        .some((_, c) => ys.slice(1).some((_, r) => curtainPanelType(config, c, r, rowCount) === 'glass'));
+    const paintedGlass = Boolean(node.slots?.['curtain-glass']);
+    const effectiveThickness = Math.min(config.glassThickness, getWallThickness(node) * 0.45);
+    return (_jsxs(_Fragment, { children: [_jsxs(PanelSection, { title: "Wall system", children: [_jsx(Choice, { label: "Construction", onChange: (construction) => update({ construction }), options: [
+                            { label: 'Stick-built', value: 'stick' },
+                            { label: 'Unitized', value: 'unitized' },
+                        ], value: config.construction }), _jsx(Choice, { label: "Framing", onChange: (framing) => update({ framing }), options: [
+                            { label: 'Fully capped', value: 'capped' },
+                            { label: 'Vertical caps', value: 'vertical-caps' },
+                            { label: 'Horizontal caps', value: 'horizontal-caps' },
+                            { label: 'Structural glazing', value: 'structural-glazing' },
+                        ], value: config.framing }), _jsx("p", { className: "text-[11px] text-muted-foreground", children: config.construction === 'unitized'
+                            ? 'Separate framed modules with joints between units.'
+                            : 'Continuous mullions and transoms assembled along the wall.' }), config.framing !== 'capped' && (_jsx("p", { className: "text-[11px] text-muted-foreground", children: "Uncapped members sit behind the glazing." }))] }), _jsx(GridSection, { onChange: (columns) => update({ columns }), onPreview: (columns) => update({ columns }, true), onCommit: onCommit, onCancel: onCancel, title: "Column layout", length: getWallCurveLength(node), unit: unit, value: config.columns }), _jsx(GridSection, { onChange: (rows) => update({ rows }), onPreview: (rows) => update({ rows }, true), onCommit: onCommit, onCancel: onCancel, title: "Row layout", length: height, vertical: true, unit: unit, value: config.rows }), ((getWallCurveLength(node) / config.columns.spacing > 32 &&
+                config.columns.layout !== 'count') ||
+                (height / config.rows.spacing > 32 && config.rows.layout !== 'count')) && (_jsx("p", { className: "px-3 text-[11px] text-muted-foreground", children: "Grid limited to 32 panels per axis. Spacing expands to fit this wall." })), _jsxs(PanelSection, { title: "Frame dimensions", children: [_jsx(LengthControl, { profile: true, onCommit: onCommit, onCancel: onCancel, label: "Vertical frame width", max: 0.3, min: 0.01, onChange: (mullionWidth) => update({ mullionWidth }, true), unit: unit, value: config.mullionWidth }), _jsx(LengthControl, { profile: true, onCommit: onCommit, onCancel: onCancel, label: "Horizontal frame width", max: 0.3, min: 0.01, onChange: (transomWidth) => update({ transomWidth }, true), unit: unit, value: config.transomWidth }), _jsx(LengthControl, { profile: true, onCommit: onCommit, onCancel: onCancel, label: "Border / opening frame", max: 0.3, min: 0.01, onChange: (perimeterWidth) => update({ perimeterWidth }, true), unit: unit, value: config.perimeterWidth }), (config.construction === 'unitized' || config.framing !== 'capped') && (_jsx(LengthControl, { profile: true, onCommit: onCommit, onCancel: onCancel, label: config.construction === 'unitized' ? 'Module joint width' : 'Glazing gap', max: 0.05, min: 0.002, onChange: (jointWidth) => update({ jointWidth }, true), unit: unit, value: config.jointWidth }))] }), _jsxs(PanelSection, { title: "Panel infill", children: [_jsx(Choice, { label: "Default panel", onChange: (panelType) => update({ panelType }), options: PANEL_OPTIONS, value: config.panelType }), _jsx(Choice, { label: "Opaque band", onChange: (spandrel) => update({ spandrel }), options: [
+                            { label: 'None', value: 'none' },
+                            { label: 'Bottom row', value: 'bottom' },
+                            { label: 'Top row', value: 'top' },
+                        ], value: config.spandrel }), _jsx("p", { className: "text-[11px] text-muted-foreground", children: "Opaque bands replace a full row with solid panels. Apply their finish with the paint tool." }), _jsx(LengthControl, { profile: true, onCommit: onCommit, onCancel: onCancel, label: "Panel thickness", max: 0.08, min: 0.004, onChange: (glassThickness) => update({ glassThickness }, true), unit: unit, value: config.glassThickness }), effectiveThickness < config.glassThickness - 1e-6 && (_jsxs("p", { className: "text-[11px] text-muted-foreground", children: ["Effective thickness:", ' ', unit === 'metric'
+                                ? `${(effectiveThickness * 1000).toFixed(1)} mm`
+                                : `${metersToLinearUnit(effectiveThickness, unit).toFixed(3)} ${getLinearUnitLabel(unit)}`, ", limited by frame depth."] }))] }), _jsxs(PanelSection, { title: "Edit individual panels", children: [_jsx(ToggleControl, { checked: panelEditing, label: "Enable panel editing", onChange: setPanelEditing }), panelEditing && (_jsxs(_Fragment, { children: [_jsx("p", { className: "text-[11px] text-muted-foreground", children: "Choose a cell or enter its column and row. Use arrow keys to move between cells. Columns run from the wall start; rows count upward." }), _jsx("div", { className: "max-h-64 overflow-auto rounded border border-border", children: _jsx("svg", { viewBox: `0 0 ${diagramWidth} ${diagramHeight}`, style: { width: diagramWidth, height: diagramHeight }, className: "block", role: "group", "aria-label": "Curtain wall panel selection", children: xs.slice(1).flatMap((_, c) => ys.slice(1).map((_, r) => {
+                                        const type = curtainPanelType(config, c, r, rowCount);
+                                        const selected = c === column && r === row;
+                                        return (_jsx("rect", { role: "button", tabIndex: selected ? 0 : -1, "aria-label": `Column ${c + 1}, row ${r + 1}: ${type}`, "aria-pressed": selected, "data-cell": `${c}-${r}`, x: (c / columnCount) * diagramWidth, y: diagramHeight - ((r + 1) / rowCount) * diagramHeight, width: diagramWidth / columnCount, height: diagramHeight / rowCount, fill: type === 'glass'
+                                                ? '#53788a'
+                                                : type === 'solid'
+                                                    ? '#64748b'
+                                                    : 'transparent', stroke: selected ? '#fb923c' : '#94a3b8', strokeWidth: selected ? 3 : 1, className: "cursor-pointer focus:stroke-orange-400 focus:stroke-[3]", onClick: () => {
+                                                setColumn(c);
+                                                setRow(r);
+                                            }, onKeyDown: (event) => {
+                                                const arrows = {
+                                                    ArrowLeft: [-1, 0],
+                                                    ArrowRight: [1, 0],
+                                                    ArrowUp: [0, 1],
+                                                    ArrowDown: [0, -1],
+                                                };
+                                                const delta = arrows[event.key];
+                                                if (delta) {
+                                                    event.preventDefault();
+                                                    const nextColumn = Math.max(0, Math.min(columnCount - 1, c + delta[0]));
+                                                    const nextRow = Math.max(0, Math.min(rowCount - 1, r + delta[1]));
+                                                    setColumn(nextColumn);
+                                                    setRow(nextRow);
+                                                    const target = event.currentTarget.parentElement?.querySelector(`[data-cell="${nextColumn}-${nextRow}"]`);
+                                                    target?.focus();
+                                                    target?.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+                                                }
+                                                if (event.key === 'Enter' || event.key === ' ') {
+                                                    event.preventDefault();
+                                                    setColumn(c);
+                                                    setRow(r);
+                                                }
+                                            } }, `${c}-${r}`));
+                                    })) }) }), hiddenOverrides.length > 0 && (_jsxs("div", { className: "space-y-2 text-[11px] text-muted-foreground", children: [_jsxs("p", { children: [hiddenOverrides.length, " custom panels are outside this grid. They return if the grid expands."] }), _jsx("button", { type: "button", className: "rounded border border-border px-2 py-1 text-xs", onClick: () => update({
+                                            panels: config.panels.filter((panel) => panel.column < columnCount && panel.row < rowCount),
+                                        }), children: "Clear hidden overrides" })] })), _jsxs("p", { className: "text-[11px] text-muted-foreground", children: ["Column ", column + 1, ", row ", row + 1, " \u00B7", ' ', overridden ? 'Custom infill' : 'Following wall defaults'] }), _jsx(SliderControl, { label: "Column", max: Math.max(1, columnCount), min: 1, onChange: (value) => setColumn(Math.round(value) - 1), precision: 0, step: 1, value: column + 1 }), _jsx(SliderControl, { label: "Row", max: Math.max(1, rowCount), min: 1, onChange: (value) => setRow(Math.round(value) - 1), precision: 0, step: 1, value: row + 1 }), _jsx(Choice, { label: "Panel infill", onChange: changePanel, options: PANEL_OPTIONS, value: selectedType }), _jsx("button", { className: "rounded border border-border px-2 py-1 text-xs disabled:cursor-default disabled:opacity-40", disabled: !overridden, onClick: () => changePanel(), type: "button", children: "Reset this panel" }), _jsx("p", { className: "text-[11px] text-muted-foreground", children: "Use the Door or Window tool to add an opening through the wall." })] }))] }), hasGlass && (_jsxs(PanelSection, { title: "Glass appearance", children: [paintedGlass && (_jsxs("div", { className: "space-y-2 text-xs text-muted-foreground", children: [_jsx("p", { children: "Glass appearance is controlled by the paint tool." }), _jsx("button", { type: "button", className: "rounded border border-border px-2 py-1", onClick: () => {
+                                    onCommit();
+                                    const slots = { ...node.slots };
+                                    delete slots['curtain-glass'];
+                                    onUpdate({ slots });
+                                }, children: "Use glass settings instead" })] })), !paintedGlass && (_jsxs("div", { className: "space-y-2", children: [_jsx(SliderControl, { onCommit: onCommit, onCancel: onCancel, restoreOnCommit: false, previewWhileTyping: true, label: "Opacity", max: 100, min: 5, onChange: (value) => update({ glassOpacity: value / 100 }, true), precision: 0, step: 5, unit: "%", value: Math.round(config.glassOpacity * 100) }), _jsx(SliderControl, { onCommit: onCommit, onCancel: onCancel, restoreOnCommit: false, previewWhileTyping: true, label: "Surface roughness", max: 1, min: 0, onChange: (glassRoughness) => update({ glassRoughness }, true), precision: 2, step: 0.05, value: config.glassRoughness }), _jsxs("label", { className: "flex items-center justify-between text-xs text-muted-foreground", children: ["Glass tint", _jsx("input", { "aria-label": "Glass tint", className: "h-7 w-10 cursor-pointer rounded border border-border bg-transparent", onKeyDown: (event) => {
+                                            if (event.key === 'Escape') {
+                                                event.preventDefault();
+                                                onCancel();
+                                                setTintEditing(false);
+                                            }
+                                        }, onChange: (event) => {
+                                            setTintEditing(true);
+                                            update({ glassColor: event.target.value }, true);
+                                        }, onBlur: () => {
+                                            if (!tintEditing)
+                                                return;
+                                            onCommit();
+                                            setTintEditing(false);
+                                        }, onInput: (event) => {
+                                            setTintEditing(true);
+                                            update({ glassColor: event.currentTarget.value }, true);
+                                        }, type: "color", value: config.glassColor })] }), tintEditing && (_jsxs("div", { className: "flex gap-2", children: [_jsx("button", { type: "button", className: "rounded border border-border px-2 py-1 text-xs", onClick: () => {
+                                            onCommit();
+                                            setTintEditing(false);
+                                        }, children: "Apply tint" }), _jsx("button", { type: "button", className: "rounded border border-border px-2 py-1 text-xs", onClick: () => {
+                                            onCancel();
+                                            setTintEditing(false);
+                                        }, children: "Cancel tint" })] })), _jsx("p", { className: "text-[11px] text-muted-foreground", children: "Low roughness is smooth; high roughness gives a matte surface in rendered shading." })] }))] }))] }));
+}

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

@@ -0,0 +1,5 @@
+import { BufferGeometry, Vector2 } from 'three';
+import type { CurtainWallPiece } from './curtain-wall-layout';
+export declare function buildStraightCurtainPiecesWithCutouts(pieces: readonly CurtainWallPiece[], base: number, cutouts: readonly (readonly Vector2[])[]): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+export declare function buildStraightCurtainPieces(pieces: readonly CurtainWallPiece[], base: number, cullSharedFaces?: boolean): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+//# sourceMappingURL=curtain-wall-piece-geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"curtain-wall-piece-geometry.d.ts","sourceRoot":"","sources":["../../src/wall/curtain-wall-piece-geometry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAsC,OAAO,EAAE,MAAM,OAAO,CAAA;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAI7D,wBAAgB,qCAAqC,CACnD,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,kGA+GzC;AAGD,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,IAAI,EAAE,MAAM,EACZ,eAAe,UAAO,kGA0HvB"}