@pascal-app/nodes 1.0.4 → 1.0.6

package/dist/roof/definition.js

@@ -1,11 +1,11 @@
 import { RoofNode as RoofNodeSchema, } from '@pascal-app/core';
 import { DRAFTING_SURFACE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, } from '@pascal-app/editor';
-import { buildRoofFloorplan } from './floorplan';
-import { roofPanelModel } from './panel-model';
-import { roofParametrics } from './parametrics';
-import useRoofFootprintSource from './roof-footprint-source';
-import useRoofPlacementMode, { conicalRoofToolHintVisibility, standardRoofToolHintVisibility, } from './roof-placement-mode';
-import { RoofNode } from './schema';
+import { buildRoofFloorplan } from './floorplan.js';
+import { roofPanelModel } from './panel-model.js';
+import { roofParametrics } from './parametrics.js';
+import useRoofFootprintSource from './roof-footprint-source.js';
+import useRoofPlacementMode, { conicalRoofToolHintVisibility, standardRoofToolHintVisibility, } from './roof-placement-mode.js';
+import { RoofNode } from './schema.js';
 const MOVE_FRONT_OFFSET = 0.35;
 const MIN_ROOF_FOOTPRINT = 1;
 function getRoofFootprintBounds(node, sceneApi) {
@@ -102,6 +102,14 @@ export const roofDefinition = {
         return rest;
     },
     capabilities: {
+        exterior: true,
+        reveal: {
+            phase: 'roof',
+            style: 'assemble',
+            height: 4,
+            // The roof lifts out of the way while the furniture drops in, then seats again.
+            clears: { for: 'furnishing', height: 2.4 },
+        },
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,
@@ -165,9 +173,9 @@ export const roofDefinition = {
     // lookup — no hardcoded dispatcher arm. Shared with roof-segment / stair
     // / stair-segment via `shared/move-roof-tool`.
     affordanceTools: {
-        move: () => import('../shared/move-roof-tool'),
+        move: () => import('../shared/move-roof-tool.js'),
     },
-    tool: () => import('./tool'),
+    tool: () => import('./tool.js'),
     toolHints: [
         { key: 'Left click', label: 'Set roof footprint' },
         {
@@ -227,10 +235,10 @@ export const roofDefinition = {
     rendersChildren: false,
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
     system: {
-        module: () => import('./system'),
+        module: () => import('./system.js'),
         priority: 3,
     },
     presentation: {

package/dist/roof/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AA0BzB;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMvD;AA2LD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAsMjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAGpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AA2BzB;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMvD;AA8LD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA0MjG"}

package/dist/roof/floorplan.js

@@ -1,6 +1,6 @@
-import { getRoofSegmentVisibleTopBounds, roofPlanOverlapEntryOwns, subtractPolygonsFromPolygon, unionPolygons, } from '@pascal-app/core';
+import { getGlazedRoofPlanLines, getRoofSegmentVisibleTopBounds, roofPlanOverlapEntryOwns, subtractPolygonsFromPolygon, unionPolygons, } from '@pascal-app/core';
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
-import { getConicalRoofPlanFootprint, getRoofSegmentPlanLinework } from '../roof-segment/floorplan';
+import { getConicalRoofPlanFootprint, getRoofSegmentPlanLinework } from '../roof-segment/floorplan.js';
 /**
  * `roof-segment.pitch` is stored in DEGREES; a roof plan is annotated as the
  * rise over a 12 run. 30.256° → tan 0.5833 × 12 → 7.00 → '7:12'. Rounded to
@@ -41,6 +41,7 @@ function slopeArrows(node) {
         case 'shed':
             // Unchanged from the linework builder: the 3D shed falls −lz → +lz.
             return [{ tail: [0, -hd * 0.55], head: [0, hd * 0.55] }];
+        case 'barrel':
         case 'gable':
         case 'gambrel': {
             const z = along(hd);
@@ -103,6 +104,7 @@ function buildSegPlan(roof, seg, drafting) {
     const ridges = lw.ridges.map(mapSeg);
     const hips = lw.hips.map(mapSeg);
     const breaks = lw.breaks.map(mapSeg);
+    const glazing = getGlazedRoofPlanLines(seg).map(mapSeg);
     if (!drafting) {
         const slopes = lw.slope
             ? [
@@ -113,13 +115,13 @@ function buildSegPlan(roof, seg, drafting) {
                 },
             ]
             : [];
-        return { footprint, eave: footprint, ridges, hips, breaks, slopes };
+        return { footprint, eave: footprint, ridges, hips, breaks, glazing, slopes };
     }
     // The drip edge: core's own visible-top bounds, which add the horizontal
     // component of `overhang` (plus half the wall thickness and, on the sloped
     // faces, the shingle projection) to the footprint on each side.
     const edge = getRoofSegmentVisibleTopBounds(seg);
-    const pitch = roofPitchLabel(seg.pitch);
+    const pitch = seg.roofType === 'barrel' ? '' : roofPitchLabel(seg.pitch);
     return {
         footprint,
         eave: [
@@ -131,6 +133,7 @@ function buildSegPlan(roof, seg, drafting) {
         ridges,
         hips,
         breaks,
+        glazing,
         slopes: slopeArrows(seg).map((arrow) => ({
             tail: tp(arrow.tail[0], arrow.tail[1]),
             head: tp(arrow.head[0], arrow.head[1]),
@@ -315,6 +318,10 @@ export function buildRoofFloorplan(node, ctx) {
         });
     }
     for (const { plan, cutters } of visiblePlans) {
+        for (const line of plan.glazing) {
+            for (const visible of clipLineByCutters(line, cutters))
+                pushLine(visible[0], visible[1], hipWidth);
+        }
         for (const line of plan.breaks) {
             for (const visible of clipLineByCutters(line, cutters)) {
                 pushLine(visible[0], visible[1], hipWidth);

package/dist/roof/glazed-geometry.d.ts

@@ -0,0 +1,5 @@
+import type { RoofGeometryAdapter } from '@pascal-app/viewer';
+import type { Mesh } from 'three';
+export declare const glazedRoofGeometryAdapter: RoofGeometryAdapter;
+export declare function syncGlazedRoofShadow(mesh: Mesh, appearance?: import("three").Material<import("three").MaterialEventMap>[] | import("three").Material<import("three").MaterialEventMap>): void;
+//# sourceMappingURL=glazed-geometry.d.ts.map

package/dist/roof/glazed-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glazed-geometry.d.ts","sourceRoot":"","sources":["../../src/roof/glazed-geometry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAC7D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAEjC,eAAO,MAAM,yBAAyB,EAAE,mBAIvC,CAAA;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,4HAAgB,QAiB1E"}

package/dist/roof/glazed-geometry.js

@@ -0,0 +1,27 @@
+import { isGlazedRoofSegment } from '@pascal-app/core';
+export const glazedRoofGeometryAdapter = {
+    syncGeometry(node, mesh) {
+        if (isGlazedRoofSegment(node))
+            syncGlazedRoofShadow(mesh);
+    },
+};
+export function syncGlazedRoofShadow(mesh, appearance = mesh.material) {
+    const shadow = mesh.getObjectByName('glazed-roof-shadow');
+    if (!shadow)
+        return;
+    const materials = Array.isArray(appearance) ? appearance : [appearance];
+    const indices = [];
+    for (const group of mesh.geometry.groups) {
+        const material = materials[group.materialIndex ?? 0];
+        if (material?.transparent && material.opacity < 1)
+            continue;
+        for (let i = group.start; i < group.start + group.count; i++)
+            indices.push(mesh.geometry.index ? mesh.geometry.index.getX(i) : i);
+    }
+    const geometry = mesh.geometry.clone();
+    geometry.clearGroups();
+    geometry.setIndex(indices);
+    geometry.setDrawRange(0, indices.length);
+    shadow.geometry.dispose();
+    shadow.geometry = geometry;
+}

package/dist/roof/glazed-materials.d.ts

@@ -0,0 +1,14 @@
+import { type RoofSegmentNode, type SceneMaterial, type SceneMaterialId } from '@pascal-app/core';
+import { type ColorPreset, type RenderShading } from '@pascal-app/viewer';
+import { type Material } from 'three';
+export { GLAZED_ROOF_SLOTS } from '@pascal-app/core';
+export declare function createGlazedRoofMaterials(node: Pick<RoofSegmentNode, 'glazing' | 'slots'>, shading: RenderShading, materials?: Record<SceneMaterialId, SceneMaterial>, { textures, colorPreset, sceneTheme, debugColors, }?: {
+    textures?: boolean;
+    colorPreset?: ColorPreset;
+    sceneTheme?: string;
+    debugColors?: boolean;
+}): {
+    visible: Material<import("three").MaterialEventMap>[];
+    owned: Material<import("three").MaterialEventMap>[];
+};
+//# sourceMappingURL=glazed-materials.d.ts.map

package/dist/roof/glazed-materials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glazed-materials.d.ts","sourceRoot":"","sources":["../../src/roof/glazed-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAIhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEpD,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,OAAO,CAAC,EAChD,OAAO,EAAE,aAAa,EACtB,SAAS,GAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAM,EACtD,EACE,QAAe,EACf,WAAoB,EACpB,UAAU,EACV,WAAmB,GACpB,GAAE;IACD,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,OAAO,CAAA;CACjB;;;EAwCP"}

package/dist/roof/glazed-materials.js

@@ -0,0 +1,42 @@
+import { GLAZED_ROOF_SLOTS, getRoofGlazing, } from '@pascal-app/core';
+import { createSurfaceRoleMaterial, resolveMaterialRef, } from '@pascal-app/viewer';
+import { FrontSide } from 'three';
+import { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
+import { getRoofDebugMaterials } from './roof-materials.js';
+export { GLAZED_ROOF_SLOTS } from '@pascal-app/core';
+export function createGlazedRoofMaterials(node, shading, materials = {}, { textures = true, colorPreset = 'clay', sceneTheme, debugColors = false, } = {}) {
+    const config = getRoofGlazing(node);
+    const owned = [];
+    const visible = GLAZED_ROOF_SLOTS.map((slot, index) => {
+        if (debugColors || !textures) {
+            const source = debugColors
+                ? getRoofDebugMaterials(shading)[index]
+                : createSurfaceRoleMaterial(index === 1 ? 'glazing' : 'roof', colorPreset, FrontSide, sceneTheme);
+            const material = source.clone();
+            if (!debugColors && index === 1)
+                material.opacity = config.glassOpacity;
+            owned.push(material);
+            return material;
+        }
+        const override = resolveMaterialRef(node.slots?.[slot], materials, shading);
+        if (override)
+            return override;
+        const glass = index === 1;
+        const properties = {
+            color: glass ? config.glassColor : config.frameColor,
+            transparent: glass,
+            opacity: glass ? config.glassOpacity : 1,
+            depthWrite: !glass,
+        };
+        const material = shading === 'solid'
+            ? new MeshLambertNodeMaterial(properties)
+            : new MeshStandardNodeMaterial({
+                ...properties,
+                roughness: glass ? config.glassRoughness : 0.4,
+                metalness: index === 0 ? 0.65 : 0,
+            });
+        owned.push(material);
+        return material;
+    });
+    return { visible: [...visible, visible[0]], owned };
+}

package/dist/roof/glazing-controls.d.ts

@@ -0,0 +1,33 @@
+import type { CurtainGrid, RoofGlazing } from '@pascal-app/core';
+import type { createRoofGlazingPreview } from './glazing-preview.js';
+type Preview = ReturnType<typeof createRoofGlazingPreview>;
+type NumberField = 'frameWidth' | 'frameDepth' | 'glassThickness' | 'glassOpacity' | 'glassRoughness';
+export declare function GlazingNumber({ field, label, value, preview, fraction, mixed, }: {
+    field: NumberField;
+    label: string;
+    value: number;
+    preview: Preview;
+    fraction?: boolean;
+    mixed?: boolean;
+}): import("react").JSX.Element;
+export declare function GlazingGridControls({ axis, title, description, grid, grids, preview, }: {
+    axis: 'across' | 'along';
+    title: string;
+    description: string;
+    grid: CurtainGrid;
+    grids: readonly CurtainGrid[];
+    preview: Preview;
+}): import("react").JSX.Element;
+export declare function GlazingColor({ field, label, value, mixed, preview, }: {
+    field: 'glassColor' | 'frameColor';
+    label: string;
+    value: string;
+    mixed: boolean;
+    preview: Preview;
+}): import("react").JSX.Element;
+export declare const GLAZING_INFILL_OPTIONS: {
+    value: RoofGlazing['panelType'];
+    label: string;
+}[];
+export {};
+//# sourceMappingURL=glazing-controls.d.ts.map

package/dist/roof/glazing-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glazing-controls.d.ts","sourceRoot":"","sources":["../../src/roof/glazing-controls.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAYhE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AAEjE,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAC1D,KAAK,WAAW,GACZ,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,cAAc,GACd,gBAAgB,CAAA;AAEpB,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,QAAgB,EAChB,KAAa,GACd,EAAE;IACD,KAAK,EAAE,WAAW,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,+BAiCA;AAED,wBAAgB,mBAAmB,CAAC,EAClC,IAAI,EACJ,KAAK,EACL,WAAW,EACX,IAAI,EACJ,KAAK,EACL,OAAO,GACR,EAAE;IACD,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,WAAW,CAAA;IACjB,KAAK,EAAE,SAAS,WAAW,EAAE,CAAA;IAC7B,OAAO,EAAE,OAAO,CAAA;CACjB,+BA+EA;AAED,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,OAAO,GACR,EAAE;IACD,KAAK,EAAE,YAAY,GAAG,YAAY,CAAA;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;CACjB,+BAwBA;AAED,eAAO,MAAM,sBAAsB,EAAE;IAAE,KAAK,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAItF,CAAA"}

package/dist/roof/glazing-controls.js

@@ -0,0 +1,50 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, SegmentedControl, SelectControl, SliderControl, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useCallback } from 'react';
+export function GlazingNumber({ field, label, value, preview, fraction = false, mixed = false, }) {
+    const unit = useViewer((state) => state.unit);
+    const millimeters = !fraction && unit === 'metric';
+    const display = (meters) => millimeters ? meters * 1000 : metersToLinearUnit(meters, unit);
+    const onChange = useCallback((input) => {
+        const next = fraction
+            ? input / 100
+            : millimeters
+                ? Math.max(0.001, input / 1000)
+                : linearControlValueToMeters(input, unit, { minMeters: 0.001 });
+        preview.previewGlazing((config) => ({ ...config, [field]: next }));
+    }, [field, fraction, millimeters, preview, unit]);
+    return (_jsx(SliderControl, { label: label, value: fraction ? value * 100 : display(value), mixed: mixed, min: fraction ? (field === 'glassOpacity' ? 5 : 0) : display(0.001), max: fraction ? 100 : undefined, unit: fraction ? '%' : millimeters ? 'mm' : getLinearUnitLabel(unit), precision: fraction ? 0 : millimeters ? 1 : 3, step: fraction || millimeters ? 1 : 0.005, onChange: onChange, onCommit: preview.finish, onCancel: preview.cancel, restoreOnCommit: false, previewWhileTyping: true }));
+}
+export function GlazingGridControls({ axis, title, description, grid, grids, preview, }) {
+    const unit = useViewer((state) => state.unit);
+    const patch = useCallback((data, commit = false) => {
+        preview.previewGlazing((config) => ({ ...config, [axis]: { ...config[axis], ...data } }));
+        if (commit)
+            preview.commit();
+    }, [axis, preview]);
+    const mixedLayout = grids.some((value) => value.layout !== grid.layout);
+    return (_jsxs(PanelSection, { title: title, children: [_jsx(SelectControl, { label: "Layout", value: grid.layout, mixed: mixedLayout, options: [
+                    { value: 'maximum-spacing', label: 'Maximum spacing' },
+                    { value: 'count', label: 'Panel count' },
+                    { value: 'fixed-spacing', label: 'Fixed spacing' },
+                ], onChange: (layout) => patch({ layout }, true) }), mixedLayout ? (_jsx("p", { className: "pt-1 text-[11px] text-muted-foreground", children: "Choose a layout to edit the grid." })) : grid.layout === 'count' ? (_jsx(SliderControl, { label: "Panels", value: grid.count, mixed: grids.some((value) => value.count !== grid.count), min: 1, max: 32, step: 1, precision: 0, onChange: (count) => patch({ count: Math.round(count) }), onCommit: preview.finish, onCancel: preview.cancel, restoreOnCommit: false, previewWhileTyping: true })) : (_jsx(SliderControl, { label: grid.layout === 'maximum-spacing' ? 'Max spacing' : 'Spacing', value: metersToLinearUnit(grid.spacing, unit), mixed: grids.some((value) => value.spacing !== grid.spacing), min: metersToLinearUnit(0.2, unit), max: metersToLinearUnit(100, unit), unit: getLinearUnitLabel(unit), step: 0.05, precision: 2, onChange: (input) => patch({
+                    spacing: linearControlValueToMeters(input, unit, { minMeters: 0.2, maxMeters: 100 }),
+                }), onCommit: preview.finish, onCancel: preview.cancel, restoreOnCommit: false, previewWhileTyping: true })), !mixedLayout && grid.layout === 'fixed-spacing' && (_jsxs("div", { className: "flex flex-col gap-2 pt-1", role: "group", "aria-label": `${title} alignment`, children: [_jsx("span", { className: "text-xs text-muted-foreground", children: "Alignment" }), _jsx(SegmentedControl, { value: grid.alignment, mixed: grids.some((value) => value.alignment !== grid.alignment), options: [
+                            { value: 'start', label: 'Start' },
+                            { value: 'center', label: 'Center' },
+                            { value: 'end', label: 'End' },
+                        ], onChange: (alignment) => patch({ alignment }, true) })] })), _jsx("p", { className: "pt-1 text-[11px] leading-relaxed text-muted-foreground", children: description })] }));
+}
+export function GlazingColor({ field, label, value, mixed, preview, }) {
+    return (_jsxs("label", { className: "flex h-10 items-center justify-between gap-2 rounded-lg border border-border/50 bg-[#2C2C2E] px-3 text-xs", children: [_jsx("span", { className: "text-muted-foreground", children: label }), _jsxs("span", { className: "flex items-center gap-2", children: [_jsx("span", { className: "font-mono text-[11px] text-foreground", children: mixed ? 'Mixed' : value.toUpperCase() }), _jsx("input", { "aria-label": label, type: "color", value: value, className: "size-6 cursor-pointer overflow-hidden rounded border border-border/50 bg-transparent p-0 focus-visible:outline-2 focus-visible:outline-ring", onChange: (event) => preview.previewGlazing((config) => ({ ...config, [field]: event.target.value })), onBlur: preview.finish, onKeyDown: (event) => {
+                            if (event.key === 'Escape')
+                                preview.cancel();
+                        } })] })] }));
+}
+export const GLAZING_INFILL_OPTIONS = [
+    { value: 'glass', label: 'Glass' },
+    { value: 'solid', label: 'Solid' },
+    { value: 'empty', label: 'Empty' },
+];

package/dist/roof/glazing-panel-editor.d.ts

@@ -0,0 +1,6 @@
+import { type RoofGlazing, type RoofSegmentNode } from '@pascal-app/core';
+export declare function GlazingPanelEditor({ node, onUpdate, }: {
+    node: RoofSegmentNode;
+    onUpdate: (patch: Partial<RoofGlazing>) => void;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=glazing-panel-editor.d.ts.map

package/dist/roof/glazing-panel-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glazing-panel-editor.d.ts","sourceRoot":"","sources":["../../src/roof/glazing-panel-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAwBzB,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,eAAe,CAAA;IACrB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,IAAI,CAAA;CAChD,sCAmFA"}

package/dist/roof/glazing-panel-editor.js

@@ -0,0 +1,44 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getGlazedRoofLayout, getGlazedRoofPanelType, getRoofGlazing, } from '@pascal-app/core';
+import { ActionButton, PanelSection, SegmentedControl, SelectControl, SliderControl, } from '@pascal-app/editor';
+import { RotateCcw } from 'lucide-react';
+import { useState } from 'react';
+import { GLAZING_INFILL_OPTIONS } from './glazing-controls.js';
+function faceLabel(id) {
+    if (id.startsWith('barrel-'))
+        return `Arch bay ${Number(id.slice(7)) + 1}`;
+    const labels = {
+        front: 'Front slope',
+        back: 'Back slope',
+        slope: 'Shed slope',
+        'end-left': 'Left end',
+        'end-right': 'Right end',
+    };
+    return labels[id] ?? id;
+}
+export function GlazingPanelEditor({ node, onUpdate, }) {
+    const [faceId, setFaceId] = useState('front');
+    const [column, setColumn] = useState(0);
+    const [row, setRow] = useState(0);
+    const config = getRoofGlazing(node);
+    const layouts = getGlazedRoofLayout(node).filter(({ face, across, along }) => face.polygon.length >= 3 && across.length > 1 && along.length > 1);
+    const layout = layouts.find((entry) => entry.face.id === faceId) ?? layouts[0];
+    if (!layout)
+        return null;
+    const columns = layout.across.length - 1, rows = layout.along.length - 1;
+    const activeColumn = Math.max(0, Math.min(column, columns - 1)), activeRow = Math.max(0, Math.min(row, rows - 1));
+    const matches = (panel) => panel.face === layout.face.id && panel.column === activeColumn && panel.row === activeRow;
+    const overridden = config.panels.some(matches);
+    const update = (type) => onUpdate({
+        panels: [
+            ...config.panels.filter((panel) => !matches(panel)),
+            ...(type ? [{ face: layout.face.id, column: activeColumn, row: activeRow, type }] : []),
+        ],
+    });
+    return (_jsxs(PanelSection, { title: "Individual panels", defaultExpanded: false, children: [_jsx("p", { className: "pb-1 text-[11px] leading-relaxed text-muted-foreground", children: "Choose a panel to override its default infill." }), _jsx(SelectControl, { label: "Roof face", value: layout.face.id, options: layouts.map(({ face }) => ({ value: face.id, label: faceLabel(face.id) })), onChange: (value) => {
+                    setFaceId(value);
+                    setColumn(0);
+                    setRow(0);
+                } }), _jsxs("p", { className: "py-1 text-[11px] text-muted-foreground", children: [columns, " ", columns === 1 ? 'column' : 'columns', " \u00B7 ", rows, " ", rows === 1 ? 'row' : 'rows'] }), columns > 1 && (_jsx(SliderControl, { label: "Column", value: activeColumn + 1, min: 1, max: columns, step: 1, precision: 0, onChange: (value) => setColumn(Math.round(value) - 1) })), rows > 1 && (_jsx(SliderControl, { label: "Row", value: activeRow + 1, min: 1, max: rows, step: 1, precision: 0, onChange: (value) => setRow(Math.round(value) - 1) })), _jsxs("div", { className: "flex flex-col gap-2 pt-1", role: "group", "aria-label": "Selected panel infill", children: [_jsxs("span", { className: "flex items-center justify-between text-xs text-muted-foreground", children: ["Panel infill ", _jsx("span", { className: "text-[11px]", children: overridden ? 'Custom' : 'Default' })] }), _jsx(SegmentedControl, { value: getGlazedRoofPanelType(node, layout.face.id, activeColumn, activeRow), options: GLAZING_INFILL_OPTIONS, onChange: (type) => update(type) })] }), _jsx(ActionButton, { label: "Reset to default", icon: _jsx(RotateCcw, { className: "size-3.5" }), disabled: !overridden, className: "mt-1 disabled:cursor-not-allowed disabled:opacity-40 disabled:hover:bg-[#2C2C2E]", onClick: () => update() })] }));
+}

package/dist/roof/glazing-panel.d.ts

@@ -0,0 +1,5 @@
+import { type RoofSegmentNode } from '@pascal-app/core';
+export declare function RoofGlazingPanel({ segments }: {
+    segments: readonly RoofSegmentNode[];
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=glazing-panel.d.ts.map

package/dist/roof/glazing-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glazing-panel.d.ts","sourceRoot":"","sources":["../../src/roof/glazing-panel.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AAazB,wBAAgB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,sCAuKtF"}

package/dist/roof/glazing-panel.js

@@ -0,0 +1,41 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getEffectiveNode, getRoofGlazing, isGlazedRoofSegment, supportsRoofGlazing, useLiveNodeOverrides, } from '@pascal-app/core';
+import { PanelSection, SegmentedControl, ToggleControl } from '@pascal-app/editor';
+import { useEffect, useMemo } from 'react';
+import { useShallow } from 'zustand/react/shallow';
+import { GLAZING_INFILL_OPTIONS, GlazingColor, GlazingGridControls, GlazingNumber, } from './glazing-controls.js';
+import { GlazingPanelEditor } from './glazing-panel-editor.js';
+import { createRoofGlazingPreview } from './glazing-preview.js';
+export function RoofGlazingPanel({ segments }) {
+    useLiveNodeOverrides(useShallow((state) => segments.map((segment) => state.overrides.get(segment.id))));
+    const idKey = segments.map((segment) => segment.id).join(',');
+    const preview = useMemo(() => createRoofGlazingPreview(idKey ? idKey.split(',') : []), [idKey]);
+    useEffect(() => () => preview.cancel(), [preview]);
+    if (!segments.length)
+        return null;
+    const effectiveSegments = segments.map((segment) => getEffectiveNode(segment));
+    const node = effectiveSegments[0];
+    const config = getRoofGlazing(node);
+    const configs = effectiveSegments.map(getRoofGlazing);
+    const glazed = isGlazedRoofSegment(node);
+    const supported = effectiveSegments.every(supportsRoofGlazing);
+    const mixed = effectiveSegments.some((segment) => isGlazedRoofSegment(segment) !== glazed);
+    const allBarrel = effectiveSegments.every((segment) => segment.roofType === 'barrel');
+    const mixedField = (field) => configs.some((value) => value[field] !== config[field]);
+    const update = (patch) => {
+        preview.previewGlazing((current) => ({ ...current, ...patch }));
+        preview.commit();
+    };
+    return (_jsxs(_Fragment, { children: [_jsxs(PanelSection, { title: "Roof system", children: [_jsx(SegmentedControl, { value: glazed ? 'glazed' : 'standard', mixed: mixed, options: [
+                            { value: 'standard', label: 'Standard' },
+                            { value: 'glazed', label: 'Glazed', disabled: !supported },
+                        ], onChange: (roofSystem) => {
+                            if (roofSystem === 'standard' || supported)
+                                preview.commit({ roofSystem });
+                        } }), !supported && (_jsx("p", { className: "pt-1 text-[11px] leading-relaxed text-muted-foreground", children: "Glazing is available for gable, straight shed, and barrel roofs." })), mixed && (_jsx("p", { className: "pt-1 text-[11px] leading-relaxed text-muted-foreground", children: "Choose one roof system to edit settings for all selected segments." })), segments.length > 1 && (_jsxs("p", { className: "pt-1 text-[11px] text-muted-foreground", children: ["Changes apply to all ", segments.length, " roof segments."] }))] }), glazed && !mixed && (_jsxs(_Fragment, { children: [_jsx(GlazingGridControls, { axis: "across", title: allBarrel ? 'Grid along the length' : 'Grid across the roof', description: allBarrel
+                            ? 'Divides the length of each arch bay into columns.'
+                            : 'Divides each roof face into columns.', grid: config.across, grids: configs.map((value) => value.across), preview: preview }), _jsx(GlazingGridControls, { axis: "along", title: allBarrel ? 'Grid within each arch bay' : 'Grid along the slope', description: allBarrel
+                            ? 'Subdivides each flat arch bay. Arch bays controls the divisions around the curve.'
+                            : 'Spacing is measured on the slope, not its horizontal projection.', grid: config.along, grids: configs.map((value) => value.along), preview: preview }), _jsxs(PanelSection, { title: "Framing", children: [_jsx(GlazingNumber, { field: "frameWidth", label: "Frame width", value: config.frameWidth, mixed: mixedField('frameWidth'), preview: preview }), _jsx(GlazingNumber, { field: "frameDepth", label: "Frame depth", value: config.frameDepth, mixed: mixedField('frameDepth'), preview: preview }), _jsx(GlazingColor, { field: "frameColor", label: "Frame color", value: config.frameColor, mixed: mixedField('frameColor'), preview: preview })] }), _jsxs(PanelSection, { title: "Glass", children: [_jsx(GlazingNumber, { field: "glassThickness", label: "Pane thickness", value: config.glassThickness, mixed: mixedField('glassThickness'), preview: preview }), _jsx(GlazingColor, { field: "glassColor", label: "Glass tint", value: config.glassColor, mixed: mixedField('glassColor'), preview: preview }), _jsx(GlazingNumber, { field: "glassOpacity", label: "Opacity", value: config.glassOpacity, mixed: mixedField('glassOpacity'), preview: preview, fraction: true }), _jsx(GlazingNumber, { field: "glassRoughness", label: "Roughness", value: config.glassRoughness, mixed: mixedField('glassRoughness'), preview: preview, fraction: true })] }), _jsxs(PanelSection, { title: "Infill", children: [_jsxs("div", { className: "flex flex-col gap-2 pb-1", role: "group", "aria-label": "Default panel infill", children: [_jsx("span", { className: "text-xs text-muted-foreground", children: "Default panel infill" }), _jsx(SegmentedControl, { value: config.panelType, mixed: mixedField('panelType'), options: GLAZING_INFILL_OPTIONS, onChange: (panelType) => update({ panelType }) })] }), _jsx(ToggleControl, { label: "Close the roof ends", checked: config.glazedEnds, mixed: mixedField('glazedEnds'), onChange: (glazedEnds) => update({ glazedEnds }) }), _jsx("p", { className: "pt-1 text-[11px] leading-relaxed text-muted-foreground", children: "End infill fills the space above the walls. Edit room walls and ceilings separately." })] }), segments.length === 1 && (_jsx(GlazingPanelEditor, { node: node, onUpdate: update }, node.id))] }))] }));
+}

package/dist/roof/glazing-preview.d.ts

@@ -0,0 +1,10 @@
+import { type AnyNodeId, type RoofGlazing, type RoofSegmentNode } from '@pascal-app/core';
+/** A roof panel edits several segments as one gesture without writing the scene per tick. */
+export declare function createRoofGlazingPreview(ids: readonly AnyNodeId[]): {
+    previewFields(data: Partial<RoofSegmentNode>): void;
+    previewGlazing(update: (config: RoofGlazing) => RoofGlazing): void;
+    commit: (patch?: Partial<RoofSegmentNode>) => void;
+    finish: () => void;
+    cancel: () => void;
+};
+//# sourceMappingURL=glazing-preview.d.ts.map

package/dist/roof/glazing-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glazing-preview.d.ts","sourceRoot":"","sources":["../../src/roof/glazing-preview.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAGd,KAAK,WAAW,EAChB,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AAEzB,6FAA6F;AAC7F,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,SAAS,SAAS,EAAE;wBAmB1C,OAAO,CAAC,eAAe,CAAC;2BAQrB,CAAC,MAAM,EAAE,WAAW,KAAK,WAAW;qBAlBrC,OAAO,CAAC,eAAe,CAAC;;;EAgCjD"}

package/dist/roof/glazing-preview.js

@@ -0,0 +1,48 @@
+import { getEffectiveNode, getRoofGlazing, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+/** A roof panel edits several segments as one gesture without writing the scene per tick. */
+export function createRoofGlazingPreview(ids) {
+    const pending = new Map();
+    const clear = () => {
+        for (const [id, patch] of pending) {
+            useLiveNodeOverrides.getState().clearFields(id, Object.keys(patch));
+            useScene.getState().markDirty(id);
+        }
+        pending.clear();
+    };
+    const commit = (patch) => {
+        const updates = ids.flatMap((id) => {
+            if (useScene.getState().nodes[id]?.type !== 'roof-segment')
+                return [];
+            const data = { ...pending.get(id), ...patch };
+            return Object.keys(data).length ? [{ id, data }] : [];
+        });
+        if (updates.length)
+            useScene.getState().updateNodes(updates);
+        clear();
+    };
+    return {
+        previewFields(data) {
+            for (const id of ids) {
+                if (useScene.getState().nodes[id]?.type !== 'roof-segment')
+                    continue;
+                pending.set(id, { ...pending.get(id), ...data });
+                useLiveNodeOverrides.getState().set(id, data);
+                useScene.getState().markDirty(id);
+            }
+        },
+        previewGlazing(update) {
+            for (const id of ids) {
+                const stored = useScene.getState().nodes[id];
+                if (stored?.type !== 'roof-segment')
+                    continue;
+                const data = { glazing: update(getRoofGlazing(getEffectiveNode(stored))) };
+                pending.set(id, { ...pending.get(id), ...data });
+                useLiveNodeOverrides.getState().set(id, data);
+                useScene.getState().markDirty(id);
+            }
+        },
+        commit,
+        finish: () => commit(),
+        cancel: clear,
+    };
+}

package/dist/roof/index.d.ts

@@ -1,4 +1,4 @@
-export { type RoofSegmentHit, resolveRoofSegmentHit } from '../shared/roof-segment-hit';
-export { roofDefinition } from './definition';
-export { default as useRoofFootprintSource, type RoofFootprintSourceChoice, } from './roof-footprint-source';
+export { type RoofSegmentHit, resolveRoofSegmentHit } from '../shared/roof-segment-hit.js';
+export { roofDefinition } from './definition.js';
+export { default as useRoofFootprintSource, type RoofFootprintSourceChoice, } from './roof-footprint-source.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/roof/index.js

@@ -1,3 +1,3 @@
-export { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
-export { roofDefinition } from './definition';
-export { default as useRoofFootprintSource, } from './roof-footprint-source';
+export { resolveRoofSegmentHit } from '../shared/roof-segment-hit.js';
+export { roofDefinition } from './definition.js';
+export { default as useRoofFootprintSource, } from './roof-footprint-source.js';

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof/panel.tsx"],"names":[],"mappings":"AAmCA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAogBhC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof/panel.tsx"],"names":[],"mappings":"AA0CA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA8jBhC"}