@pascal-app/nodes 1.0.6 → 1.0.7

package/dist/roof/wall-catch.d.ts

@@ -0,0 +1,106 @@
+import { type AnyNode, type AnyNodeId, type RoofNode, type RoofSegmentNode, type WallNode } from '@pascal-app/core';
+type Pt = readonly [number, number];
+/** How near a roof's wall line comes to a wall's centre line before it catches on it (metres). */
+export declare const ROOF_WALL_CATCH_M = 0.25;
+/**
+ * A side drawn or picked this near a room's edge stands on it (metres): as near as a drawn corner
+ * sticks to a wall in grid (the wall snap's connect radius), so one drawn on a railing's centre
+ * line, a grid point, still takes its outside face.
+ */
+export declare const ROOF_EDGE_ON_M = 0.05;
+/**
+ * A segment's footprint at its wall centre lines, in its level's plan: its centre, the plan angle
+ * of its own x axis (the floor plan's `-(roof.rotation + segment.rotation)`), and its own walls'
+ * thickness, their outer faces half of it outside the line (absent, none).
+ */
+export type RoofWallLine = {
+    center: Pt;
+    angle: number;
+    hw: number;
+    hd: number;
+    wallThickness?: number;
+};
+/**
+ * A room's edge a roof lines up with but does not stand on: an invisible wall (its line, no
+ * thickness), or a railing (a guard round a deck or a porch, its faces half its thickness either
+ * side of its line). A wall takes a roof's wall line on its centre line, the roof's walls as thick
+ * as it, so their outer faces meet its outside face; an edge takes the roof's outer face itself,
+ * on the edge's face on the roof's outer side, so the roof reaches the room's edge as it reaches
+ * the house's walls' outside faces.
+ */
+export type RoofEdgeLine = {
+    type: 'roof-edge';
+    id: string;
+    start: Pt;
+    end: Pt;
+    thickness: number;
+};
+/** A line a roof catches on: a wall's centre line, or a room's edge (`RoofEdgeLine`). */
+export type RoofCatchLine = WallNode | RoofEdgeLine;
+/** Which axes of the dragged frame caught on a wall, and the plan shift that lays them there. */
+export type RoofWallCatch = {
+    shift: [number, number];
+    u: boolean;
+    v: boolean;
+};
+/** A segment's wall line with its roof at `roof`'s place, which a drag may be proposing. */
+export declare function segmentWallLine(roof: Pick<RoofNode, 'position' | 'rotation'>, segment: Pick<RoofSegmentNode, 'position' | 'rotation' | 'width' | 'depth'> & Partial<Pick<RoofSegmentNode, 'wallThickness'>>): RoofWallLine;
+/**
+ * What a roof on `levelId` catches on, on its own level and the storey below, which the roof plan
+ * draws dashed: the walls it sits on, and the rooms' edges there, their invisible walls and
+ * railings (`RoofEdgeLine`): a porch's, a deck's, a patio's. Curved walls have no straight line to
+ * catch on.
+ */
+export declare function roofCatchWalls(nodes: Readonly<Record<AnyNodeId, AnyNode>>, levelId: string | null | undefined): RoofCatchLine[];
+/**
+ * Where a dragged roof's wall lines catch on the walls under it. Along each axis of the frame at
+ * `angle` (the dragged segment's or roof's x and z), the edge nearest the centre line of a wall
+ * that runs alongside it, parallel and within `threshold`, sets the shift onto that wall; one
+ * nearest a room's edge (`RoofEdgeLine`) stands the outer face of the walls the segment takes
+ * there on it.
+ */
+export declare function catchRoofOnWalls(args: {
+    lines: readonly RoofWallLine[];
+    walls: readonly RoofCatchLine[];
+    angle: number;
+    threshold?: number;
+}): RoofWallCatch;
+/**
+ * A dragged roof's place: along an axis its wall line caught on, the raw place shifted onto the
+ * wall; along the other, the snapped place (the grid's, or the raw cursor's with no grid).
+ */
+export declare function placeRoofOnWalls(raw: Pt, snapped: Pt, caught: RoofWallCatch, angle: number): [number, number];
+/**
+ * A side dragged out from `line` (the segment's wall line before the drag), its opposite side held:
+ * the size along `axis` that lays the dragged side on the centre line of a wall alongside it, or
+ * stands its outer face on a room's edge there (`RoofEdgeLine`); null when neither is within
+ * `threshold` of `value`.
+ */
+export declare function catchRoofSideOnWalls(args: {
+    line: RoofWallLine;
+    axis: 'x' | 'z';
+    side: 1 | -1;
+    value: number;
+    walls: readonly RoofCatchLine[];
+    threshold?: number;
+}): number | null;
+/**
+ * The thickness a segment's walls take to stand flush on the walls under it: the thickest wall
+ * whose centre line runs along an edge of its wall line, within `threshold`. A room's edge (an
+ * invisible wall, a railing) carries no roof and gives none. Null when no wall does.
+ */
+export declare function bearingWallThickness(line: RoofWallLine, walls: readonly RoofCatchLine[], threshold?: number): number | null;
+/**
+ * A wall line drawn or picked out to a room's edges (`RoofEdgeLine`): each side lying on one,
+ * within `tolerance`, moved in so the outer face of its walls, `thickness` thick, stands there, as
+ * the house's roof stands its walls' outer faces on the walls' outside faces. A side on a wall's
+ * centre line, or on nothing, stays.
+ */
+export declare function settleRoofOnEdges(line: RoofWallLine, walls: readonly RoofCatchLine[], thickness: number, tolerance?: number): RoofWallLine;
+/**
+ * A segment drawn or picked out to a room's edges, in its roof at `roof`'s place: its size and
+ * place in its roof with its walls' outer faces on them (`settleRoofOnEdges`).
+ */
+export declare function settleSegmentOnEdges(roof: Pick<RoofNode, 'position' | 'rotation'>, segment: Pick<RoofSegmentNode, 'position' | 'rotation' | 'width' | 'depth' | 'wallThickness'>, walls: readonly RoofCatchLine[]): Pick<RoofSegmentNode, 'position' | 'width' | 'depth'>;
+export {};
+//# sourceMappingURL=wall-catch.d.ts.map

package/dist/roof/wall-catch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-catch.d.ts","sourceRoot":"","sources":["../../src/roof/wall-catch.ts"],"names":[],"mappings":"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"}

package/dist/roof/wall-catch.js

@@ -0,0 +1,267 @@
+import { getLevelBelow, getWallBodyLine, getWallThickness, isCurvedWall, isRailingWall, } from '@pascal-app/core';
+/** How near a roof's wall line comes to a wall's centre line before it catches on it (metres). */
+export const ROOF_WALL_CATCH_M = 0.25;
+/**
+ * A side drawn or picked this near a room's edge stands on it (metres): as near as a drawn corner
+ * sticks to a wall in grid (the wall snap's connect radius), so one drawn on a railing's centre
+ * line, a grid point, still takes its outside face.
+ */
+export const ROOF_EDGE_ON_M = 0.05;
+/** A wall within this of parallel (the sine of 1°) runs along a roof edge. */
+const PARALLEL = Math.sin(Math.PI / 180);
+const NO_CATCH = { shift: [0, 0], u: false, v: false };
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1];
+/**
+ * A catch line's ends: a wall's body centre line (a wall drawn by a face has it half its thickness
+ * off the middle), an edge's own.
+ */
+function lineEnds(line) {
+    if (line.type === 'roof-edge')
+        return [line.start, line.end];
+    const body = getWallBodyLine(line);
+    return [
+        [body.start.x, body.start.y],
+        [body.end.x, body.end.y],
+    ];
+}
+/** A railing as a room's edge: its body's centre line, its faces half its thickness off it. */
+function railingEdge(wall) {
+    const [start, end] = lineEnds(wall);
+    return { type: 'roof-edge', id: wall.id, start, end, thickness: getWallThickness(wall) };
+}
+/**
+ * The line nearest an edge through `mid`, and how far along `n` the edge moves onto it: lines
+ * parallel to the edge, within `threshold` of it, and overlapping its `half` length either side of
+ * `mid` along `t`. Null when none does. A wall takes the edge on its centre line; a room's edge
+ * takes the outer face of the roof's walls, `thickness` thick, on its face on the outer side.
+ */
+function nearestLine(mid, n, t, half, lines, threshold, thickness) {
+    let best = null;
+    for (const line of lines) {
+        const [from, to] = lineEnds(line);
+        const run = [to[0] - from[0], to[1] - from[1]];
+        const length = Math.hypot(run[0], run[1]);
+        if (length < 1e-6 || Math.abs(dot(run, n)) / length > PARALLEL)
+            continue;
+        const start = [from[0] - mid[0], from[1] - mid[1]];
+        const end = [to[0] - mid[0], to[1] - mid[1]];
+        const gap = dot(start, n) + (line.type === 'roof-edge' ? (line.thickness - thickness) / 2 : 0);
+        if (Math.abs(gap) > threshold)
+            continue;
+        const a = dot(start, t);
+        const b = dot(end, t);
+        if (Math.max(a, b) <= -half || Math.min(a, b) >= half)
+            continue;
+        if (best === null || Math.abs(gap) < Math.abs(best.gap))
+            best = { gap, line };
+    }
+    return best;
+}
+/** A wall line's four edges: outward normal, run, distance from the centre, half length. */
+function lineEdges(line) {
+    const ex = [Math.cos(line.angle), Math.sin(line.angle)];
+    const ez = [-ex[1], ex[0]];
+    return [
+        { n: ex, t: ez, offset: line.hw, half: line.hd },
+        { n: [-ex[0], -ex[1]], t: ez, offset: line.hw, half: line.hd },
+        { n: ez, t: ex, offset: line.hd, half: line.hw },
+        { n: [-ez[0], -ez[1]], t: ex, offset: line.hd, half: line.hw },
+    ];
+}
+/** A segment's wall line with its roof at `roof`'s place, which a drag may be proposing. */
+export function segmentWallLine(roof, segment) {
+    const cos = Math.cos(-roof.rotation);
+    const sin = Math.sin(-roof.rotation);
+    const [lx, , lz] = segment.position;
+    return {
+        center: [roof.position[0] + lx * cos - lz * sin, roof.position[2] + lx * sin + lz * cos],
+        angle: -(roof.rotation + segment.rotation),
+        hw: segment.width / 2,
+        hd: segment.depth / 2,
+        wallThickness: segment.wallThickness,
+    };
+}
+/**
+ * What a roof on `levelId` catches on, on its own level and the storey below, which the roof plan
+ * draws dashed: the walls it sits on, and the rooms' edges there, their invisible walls and
+ * railings (`RoofEdgeLine`): a porch's, a deck's, a patio's. Curved walls have no straight line to
+ * catch on.
+ */
+export function roofCatchWalls(nodes, levelId) {
+    if (!levelId)
+        return [];
+    const below = getLevelBelow(levelId, nodes);
+    const lines = [];
+    for (const id of [levelId, below?.id]) {
+        const level = id ? nodes[id] : undefined;
+        if (level?.type !== 'level')
+            continue;
+        for (const childId of level.children) {
+            const node = nodes[childId];
+            if (node?.type === 'separator')
+                lines.push({
+                    type: 'roof-edge',
+                    id: node.id,
+                    start: node.start,
+                    end: node.end,
+                    thickness: 0,
+                });
+            else if (node?.type === 'wall' && !isCurvedWall(node))
+                lines.push(isRailingWall(node) ? railingEdge(node) : node);
+        }
+    }
+    return lines;
+}
+/**
+ * Where a dragged roof's wall lines catch on the walls under it. Along each axis of the frame at
+ * `angle` (the dragged segment's or roof's x and z), the edge nearest the centre line of a wall
+ * that runs alongside it, parallel and within `threshold`, sets the shift onto that wall; one
+ * nearest a room's edge (`RoofEdgeLine`) stands the outer face of the walls the segment takes
+ * there on it.
+ */
+export function catchRoofOnWalls(args) {
+    const threshold = args.threshold ?? ROOF_WALL_CATCH_M;
+    const u = [Math.cos(args.angle), Math.sin(args.angle)];
+    const v = [-u[1], u[0]];
+    let bestU = null;
+    let bestV = null;
+    for (const line of args.lines) {
+        const thickness = landedWallThickness(line, args.walls, threshold);
+        for (const { n, t, offset, half } of lineEdges(line)) {
+            // An edge of a segment turned off the dragged frame moves along neither axis alone.
+            const alongU = dot(n, u);
+            const alongV = dot(n, v);
+            const axis = Math.abs(alongV) <= PARALLEL ? 'u' : Math.abs(alongU) <= PARALLEL ? 'v' : null;
+            if (!axis)
+                continue;
+            const mid = [line.center[0] + n[0] * offset, line.center[1] + n[1] * offset];
+            const gap = nearestLine(mid, n, t, half, args.walls, threshold, thickness)?.gap;
+            if (gap === undefined)
+                continue;
+            const amount = gap * (axis === 'u' ? alongU : alongV);
+            if (axis === 'u') {
+                if (bestU === null || Math.abs(amount) < Math.abs(bestU))
+                    bestU = amount;
+            }
+            else if (bestV === null || Math.abs(amount) < Math.abs(bestV))
+                bestV = amount;
+        }
+    }
+    if (bestU === null && bestV === null)
+        return NO_CATCH;
+    const du = bestU ?? 0;
+    const dv = bestV ?? 0;
+    return {
+        shift: [u[0] * du + v[0] * dv, u[1] * du + v[1] * dv],
+        u: bestU !== null,
+        v: bestV !== null,
+    };
+}
+/**
+ * A dragged roof's place: along an axis its wall line caught on, the raw place shifted onto the
+ * wall; along the other, the snapped place (the grid's, or the raw cursor's with no grid).
+ */
+export function placeRoofOnWalls(raw, snapped, caught, angle) {
+    const out = [snapped[0], snapped[1]];
+    const target = [raw[0] + caught.shift[0], raw[1] + caught.shift[1]];
+    const u = [Math.cos(angle), Math.sin(angle)];
+    const v = [-u[1], u[0]];
+    for (const [axis, on] of [
+        [u, caught.u],
+        [v, caught.v],
+    ]) {
+        if (!on)
+            continue;
+        const k = (target[0] - out[0]) * axis[0] + (target[1] - out[1]) * axis[1];
+        out[0] += axis[0] * k;
+        out[1] += axis[1] * k;
+    }
+    return out;
+}
+/**
+ * A side dragged out from `line` (the segment's wall line before the drag), its opposite side held:
+ * the size along `axis` that lays the dragged side on the centre line of a wall alongside it, or
+ * stands its outer face on a room's edge there (`RoofEdgeLine`); null when neither is within
+ * `threshold` of `value`.
+ */
+export function catchRoofSideOnWalls(args) {
+    const { line, axis, side, value } = args;
+    const threshold = args.threshold ?? ROOF_WALL_CATCH_M;
+    const ex = [Math.cos(line.angle), Math.sin(line.angle)];
+    const ez = [-ex[1], ex[0]];
+    const along = axis === 'x' ? ex : ez;
+    const n = [along[0] * side, along[1] * side];
+    const half = axis === 'x' ? line.hw : line.hd;
+    const reach = value - half;
+    const mid = [line.center[0] + n[0] * reach, line.center[1] + n[1] * reach];
+    // Sized to `value`, the opposite side held: the thickness its walls take there.
+    const shift = value / 2 - half;
+    const sized = {
+        ...line,
+        center: [line.center[0] + n[0] * shift, line.center[1] + n[1] * shift],
+        hw: axis === 'x' ? value / 2 : line.hw,
+        hd: axis === 'z' ? value / 2 : line.hd,
+    };
+    const caught = nearestLine(mid, n, axis === 'x' ? ez : ex, axis === 'x' ? line.hd : line.hw, args.walls, threshold, landedWallThickness(sized, args.walls, threshold));
+    return caught ? value + caught.gap : null;
+}
+/**
+ * The thickness a segment's walls take to stand flush on the walls under it: the thickest wall
+ * whose centre line runs along an edge of its wall line, within `threshold`. A room's edge (an
+ * invisible wall, a railing) carries no roof and gives none. Null when no wall does.
+ */
+export function bearingWallThickness(line, walls, threshold = ROOF_WALL_CATCH_M) {
+    const bearing = walls.filter((wall) => wall.type === 'wall');
+    let thickest = null;
+    for (const { n, t, offset, half } of lineEdges(line)) {
+        const mid = [line.center[0] + n[0] * offset, line.center[1] + n[1] * offset];
+        const wall = nearestLine(mid, n, t, half, bearing, threshold, 0)?.line;
+        if (wall?.type === 'wall' && (thickest === null || getWallThickness(wall) > thickest))
+            thickest = getWallThickness(wall);
+    }
+    return thickest;
+}
+/** The thickness a wall line's walls take where it stands: the walls' under it, else its own. */
+function landedWallThickness(line, walls, threshold) {
+    return bearingWallThickness(line, walls, threshold) ?? line.wallThickness ?? 0;
+}
+/**
+ * A wall line drawn or picked out to a room's edges (`RoofEdgeLine`): each side lying on one,
+ * within `tolerance`, moved in so the outer face of its walls, `thickness` thick, stands there, as
+ * the house's roof stands its walls' outer faces on the walls' outside faces. A side on a wall's
+ * centre line, or on nothing, stays.
+ */
+export function settleRoofOnEdges(line, walls, thickness, tolerance = ROOF_EDGE_ON_M) {
+    const ex = [Math.cos(line.angle), Math.sin(line.angle)];
+    const ez = [-ex[1], ex[0]];
+    // How far each side (+x, -x, +z, -z) moves out along its own normal.
+    const [px = 0, nx = 0, pz = 0, nz = 0] = lineEdges(line).map(({ n, t, offset, half }) => {
+        const mid = [line.center[0] + n[0] * offset, line.center[1] + n[1] * offset];
+        const on = nearestLine(mid, n, t, half, walls, tolerance, 0);
+        return on?.line.type === 'roof-edge' ? on.gap - thickness / 2 : 0;
+    });
+    const du = (px - nx) / 2;
+    const dv = (pz - nz) / 2;
+    return {
+        ...line,
+        center: [line.center[0] + ex[0] * du + ez[0] * dv, line.center[1] + ex[1] * du + ez[1] * dv],
+        hw: Math.max(1e-3, line.hw + (px + nx) / 2),
+        hd: Math.max(1e-3, line.hd + (pz + nz) / 2),
+    };
+}
+/**
+ * A segment drawn or picked out to a room's edges, in its roof at `roof`'s place: its size and
+ * place in its roof with its walls' outer faces on them (`settleRoofOnEdges`).
+ */
+export function settleSegmentOnEdges(roof, segment, walls) {
+    const settled = settleRoofOnEdges(segmentWallLine(roof, segment), walls, segment.wallThickness);
+    const dx = settled.center[0] - roof.position[0];
+    const dz = settled.center[1] - roof.position[2];
+    const cos = Math.cos(-roof.rotation);
+    const sin = Math.sin(-roof.rotation);
+    return {
+        position: [dx * cos + dz * sin, segment.position[1], -dx * sin + dz * cos],
+        width: settled.hw * 2,
+        depth: settled.hd * 2,
+    };
+}

package/dist/roof-segment/build-up-section.d.ts

@@ -0,0 +1,9 @@
+import { type RoofSegmentNode } from '@pascal-app/core';
+export declare function RoofBuildUpSection({ node, onApplyToRoof, onUpdate, unit, }: {
+    node: RoofSegmentNode;
+    /** Present when the plane's roof has other planes to take the same layers. */
+    onApplyToRoof?: () => void;
+    onUpdate: (patch: Partial<RoofSegmentNode>) => void;
+    unit: 'metric' | 'imperial';
+}): import("react").JSX.Element;
+//# sourceMappingURL=build-up-section.d.ts.map

package/dist/roof-segment/build-up-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-up-section.d.ts","sourceRoot":"","sources":["../../src/roof-segment/build-up-section.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,eAAe,EAMrB,MAAM,kBAAkB,CAAA;AAuNzB,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EACJ,aAAa,EACb,QAAQ,EACR,IAAI,GACL,EAAE;IACD,IAAI,EAAE,eAAe,CAAA;IACrB,8EAA8E;IAC9E,aAAa,CAAC,EAAE,MAAM,IAAI,CAAA;IAC1B,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,eAAe,CAAC,KAAK,IAAI,CAAA;IACnD,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAA;CAC5B,+BAkLA"}

package/dist/roof-segment/build-up-section.js

@@ -0,0 +1,191 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { LUMBER_DEPTH, ROOFING_THICKNESS, roofBuildUpDepths, roofBuildUpPatch, UNDERLAYMENT_THICKNESS, usePascalI18n, } from '@pascal-app/core';
+import { ActionButton, PanelSection, SegmentedControl, SelectControl } from '@pascal-app/editor';
+import { useState } from 'react';
+import { BuildUpReadout, editedBuildUp, FinishFields, FramingSizeFields, formatSpacing, InsulationFields, LAYER_KIND_LABELS, NONE, PanelFields, } from '../shared/build-up-controls.js';
+import { formatLayerDepth, formatLayerThickness } from '../shared/layer-thickness.js';
+import { keptName, namedLayer, roofBuildUpOfDeck, roofBuildUpPresetOptions, roofBuildUpPresetPatch, roofBuildUpPresetValue, } from './panel-model.js';
+const ROOFING_OPTIONS = [
+    {
+        label: /* i18n */ {
+            id: 'node.roofSegment.buildUpSection.asphalt3Tab',
+            message: 'Asphalt 3-tab',
+        },
+        value: 'asphalt-3-tab',
+    },
+    {
+        label: /* i18n */ {
+            id: 'node.roofSegment.buildUpSection.architecturalShingle',
+            message: 'Architectural shingle',
+        },
+        value: 'architectural-shingle',
+    },
+    {
+        label: /* i18n */ {
+            id: 'node.roofSegment.buildUpSection.standingSeamMetal',
+            message: 'Standing-seam metal',
+        },
+        value: 'standing-seam-metal',
+    },
+    {
+        label: /* i18n */ {
+            id: 'node.roofSegment.buildUpSection.concreteTile',
+            message: 'Concrete tile',
+        },
+        value: 'concrete-tile',
+    },
+    {
+        label: /* i18n */ { id: 'node.roofSegment.buildUpSection.clayTile', message: 'Clay tile' },
+        value: 'clay-tile',
+    },
+    {
+        label: /* i18n */ { id: 'node.roofSegment.buildUpSection.woodShake', message: 'Wood shake' },
+        value: 'wood-shake',
+    },
+    {
+        label: /* i18n */ { id: 'node.roofSegment.buildUpSection.slate', message: 'Slate' },
+        value: 'slate',
+    },
+];
+const UNDERLAYMENT_OPTIONS = [
+    {
+        label: /* i18n */ { id: 'node.roofSegment.buildUpSection.none', message: 'None' },
+        value: NONE,
+    },
+    {
+        label: /* i18n */ { id: 'node.roofSegment.buildUpSection.n15Felt', message: '#15 felt' },
+        value: 'felt-15',
+    },
+    {
+        label: /* i18n */ { id: 'node.roofSegment.buildUpSection.n30Felt', message: '#30 felt' },
+        value: 'felt-30',
+    },
+    {
+        label: /* i18n */ { id: 'node.roofSegment.buildUpSection.synthetic', message: 'Synthetic' },
+        value: 'synthetic',
+    },
+    {
+        label: /* i18n */ {
+            id: 'node.roofSegment.buildUpSection.iceAndWaterShield',
+            message: 'Ice and water shield',
+        },
+        value: 'ice-and-water',
+    },
+];
+/** What each kind is called where the layer has no name of its own. */
+const KIND_LABELS = {
+    ...Object.fromEntries([...ROOFING_OPTIONS, ...UNDERLAYMENT_OPTIONS].map((o) => [o.value, o.label])),
+    ...LAYER_KIND_LABELS,
+};
+const kindLabel = (kind, i18n) => {
+    const label = KIND_LABELS[kind];
+    return label ? i18n._(label) : kind;
+};
+/**
+ * A layer's own name for its material ("GAF Timberline HDZ"), under its kind: the kind's name
+ * shows until one is typed, and emptied the name goes.
+ */
+function LayerNameField({ label, layer, onCommit, }) {
+    const i18n = usePascalI18n();
+    const [draft, setDraft] = useState(null);
+    return (_jsxs("label", { className: "flex h-10 w-full items-center justify-between gap-2 rounded-lg border border-border/50 bg-black/4 px-3 text-sm dark:bg-[#2C2C2E]", children: [_jsx("span", { className: "shrink-0 select-none text-muted-foreground", children: label }), _jsx("input", { className: "min-w-0 flex-1 bg-transparent text-right text-foreground outline-none placeholder:text-muted-foreground/60", maxLength: 60, onBlur: () => {
+                    if (draft !== null && draft.trim() !== (layer.name ?? ''))
+                        onCommit(draft);
+                    setDraft(null);
+                }, onChange: (event) => setDraft(event.target.value), onKeyDown: (event) => {
+                    if (event.key === 'Enter')
+                        event.currentTarget.blur();
+                    if (event.key === 'Escape') {
+                        setDraft(null);
+                        event.currentTarget.blur();
+                    }
+                }, placeholder: kindLabel(layer.kind, i18n), spellCheck: false, value: draft ?? layer.name ?? '' })] }));
+}
+/** A layer as a line of the readout: its name, else its kind's. */
+const layerLabel = (layer, i18n) => layer.name ?? kindLabel(layer.kind, i18n);
+/**
+ * A plane without layers draws its deck and shingle thicknesses as they are. The readout says
+ * which layers that deck is (`roofBuildUpOfDeck`: the default preset over the framing it holds),
+ * and "Edit layers" gives the plane those layers to edit.
+ */
+function DrawnLayers({ node, onUpdate, unit, }) {
+    const i18n = usePascalI18n();
+    const drawn = roofBuildUpOfDeck(node.deckThickness);
+    const { structure } = drawn;
+    return (_jsxs(_Fragment, { children: [_jsx(BuildUpReadout, { label: i18n._({ id: 'node.roofSegment.buildUpSection.roofing', message: 'Roofing' }), value: layerLabel(drawn.roofing, i18n) }), drawn.underlayment && (_jsx(BuildUpReadout, { label: i18n._({
+                    id: 'node.roofSegment.buildUpSection.underlayment',
+                    message: 'Underlayment',
+                }), value: layerLabel(drawn.underlayment, i18n) })), _jsx(BuildUpReadout, { label: i18n._({ id: 'node.roofSegment.buildUpSection.sheathing', message: 'Sheathing' }), value: `${layerLabel(drawn.sheathing, i18n)} ${formatLayerThickness(drawn.sheathing.thickness, unit)}` }), _jsx(BuildUpReadout, { label: structure.system === 'trusses'
+                    ? i18n._({ id: 'node.roofSegment.buildUpSection.trusses', message: 'Trusses' })
+                    : i18n._({ id: 'node.roofSegment.buildUpSection.rafters', message: 'Rafters' }), value: `${structure.size} @ ${formatSpacing(structure.spacing, unit, i18n)}` }), _jsx(BuildUpReadout, { label: i18n._({ id: 'node.roofSegment.buildUpSection.deck', message: 'Deck' }), value: formatLayerDepth(node.deckThickness, unit) }), _jsx(BuildUpReadout, { label: i18n._({ id: 'node.roofSegment.buildUpSection.covering', message: 'Covering' }), value: formatLayerDepth(node.shingleThickness, unit) }), _jsx(ActionButton, { className: "rounded-full", label: i18n._({ id: 'node.roofSegment.buildUpSection.editLayers', message: 'Edit layers' }), onClick: () => onUpdate(roofBuildUpPatch(drawn)) })] }));
+}
+export function RoofBuildUpSection({ node, onApplyToRoof, onUpdate, unit, }) {
+    const i18n = usePascalI18n();
+    const buildUp = node.buildUp;
+    const edit = (change) => {
+        if (buildUp)
+            onUpdate(roofBuildUpPatch(editedBuildUp(buildUp, change)));
+    };
+    // a name is no change of material: the preset the layers came from stays theirs
+    const rename = (key, name) => {
+        const layer = buildUp?.[key];
+        if (buildUp && layer)
+            onUpdate(roofBuildUpPatch({ ...buildUp, [key]: namedLayer(layer, name) }));
+    };
+    const depths = buildUp ? roofBuildUpDepths(buildUp) : null;
+    return (_jsxs(PanelSection, { title: i18n._({ id: 'node.roofSegment.buildUpSection.layers', message: 'Layers' }), children: [_jsx(SelectControl, { label: i18n._({ id: 'node.roofSegment.buildUpSection.preset', message: 'Preset' }), onChange: (id) => {
+                    const patch = roofBuildUpPresetPatch(id);
+                    if (patch)
+                        onUpdate(patch);
+                }, options: roofBuildUpPresetOptions(roofBuildUpPresetValue(buildUp)), value: roofBuildUpPresetValue(buildUp) }), !buildUp && _jsx(DrawnLayers, { node: node, onUpdate: onUpdate, unit: unit }), buildUp && depths && (_jsxs(_Fragment, { children: [_jsx(SelectControl, { label: i18n._({ id: 'node.roofSegment.buildUpSection.roofing', message: 'Roofing' }), onChange: (kind) => edit({ roofing: { kind, thickness: ROOFING_THICKNESS[kind] } }), options: ROOFING_OPTIONS.map((option) => ({ ...option, label: i18n._(option.label) })), value: buildUp.roofing.kind }), _jsx(LayerNameField, { label: i18n._({
+                            id: 'node.roofSegment.buildUpSection.roofingName',
+                            message: 'Roofing name',
+                        }), layer: buildUp.roofing, onCommit: (name) => rename('roofing', name) }), _jsx(SelectControl, { label: i18n._({
+                            id: 'node.roofSegment.buildUpSection.underlayment',
+                            message: 'Underlayment',
+                        }), onChange: (kind) => edit({
+                            underlayment: kind === NONE ? undefined : { kind, thickness: UNDERLAYMENT_THICKNESS[kind] },
+                        }), options: UNDERLAYMENT_OPTIONS.map((option) => ({
+                            ...option,
+                            label: i18n._(option.label),
+                        })), value: buildUp.underlayment?.kind ?? NONE }), buildUp.underlayment && (_jsx(LayerNameField, { label: i18n._({
+                            id: 'node.roofSegment.buildUpSection.underlaymentName',
+                            message: 'Underlayment name',
+                        }), layer: buildUp.underlayment, onCommit: (name) => rename('underlayment', name) })), _jsx(PanelFields, { label: i18n._({
+                            id: 'node.roofSegment.buildUpSection.sheathing',
+                            message: 'Sheathing',
+                        }), layer: buildUp.sheathing, onChange: (sheathing) => sheathing && edit({ sheathing: keptName(buildUp.sheathing, sheathing) }), unit: unit }), _jsx(LayerNameField, { label: i18n._({
+                            id: 'node.roofSegment.buildUpSection.sheathingName',
+                            message: 'Sheathing name',
+                        }), layer: buildUp.sheathing, onCommit: (name) => rename('sheathing', name) }), _jsx(SegmentedControl, { onChange: (system) => edit({ structure: { ...buildUp.structure, system } }), options: [
+                            {
+                                label: i18n._({
+                                    id: 'node.roofSegment.buildUpSection.rafters',
+                                    message: 'Rafters',
+                                }),
+                                value: 'rafters',
+                            },
+                            {
+                                label: i18n._({
+                                    id: 'node.roofSegment.buildUpSection.trusses',
+                                    message: 'Trusses',
+                                }),
+                                value: 'trusses',
+                            },
+                        ], value: buildUp.structure.system }), _jsx(FramingSizeFields, { framing: buildUp.structure, onChange: (change) => edit({ structure: { ...buildUp.structure, ...change } }), sizeLabel: buildUp.structure.system === 'trusses'
+                            ? i18n._({ id: 'node.roofSegment.buildUpSection.topChord', message: 'Top chord' })
+                            : i18n._({ id: 'node.roofSegment.buildUpSection.rafters', message: 'Rafters' }), unit: unit }), _jsx(InsulationFields, { framingDepth: LUMBER_DEPTH[buildUp.structure.size], layer: buildUp.insulation, onChange: (insulation) => edit({ insulation: keptName(buildUp.insulation, insulation) }), unit: unit }), buildUp.insulation && (_jsx(LayerNameField, { label: i18n._({
+                            id: 'node.roofSegment.buildUpSection.insulationName',
+                            message: 'Insulation name',
+                        }), layer: buildUp.insulation, onCommit: (name) => rename('insulation', name) })), _jsx(FinishFields, { label: i18n._({
+                            id: 'node.roofSegment.buildUpSection.interiorFinish',
+                            message: 'Interior finish',
+                        }), layer: buildUp.finish, onChange: (finish) => edit({ finish: keptName(buildUp.finish, finish) }), unit: unit }), buildUp.finish && (_jsx(LayerNameField, { label: i18n._({
+                            id: 'node.roofSegment.buildUpSection.finishName',
+                            message: 'Finish name',
+                        }), layer: buildUp.finish, onCommit: (name) => rename('finish', name) })), _jsx(BuildUpReadout, { label: i18n._({ id: 'node.roofSegment.buildUpSection.deck', message: 'Deck' }), value: formatLayerDepth(depths.deck, unit) }), _jsx(BuildUpReadout, { label: i18n._({ id: 'node.roofSegment.buildUpSection.covering', message: 'Covering' }), value: formatLayerDepth(depths.covering, unit) }), onApplyToRoof && (_jsx(ActionButton, { className: "rounded-full", label: i18n._({
+                            id: 'node.roofSegment.buildUpSection.applyToAllPlanesOfThis',
+                            message: 'Apply to all planes of this roof',
+                        }), onClick: onApplyToRoof }))] }))] }));
+}

package/dist/roof-segment/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAUzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAgP1C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA8FxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAMpB,MAAM,kBAAkB,CAAA;AAwBzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA6R1C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAmGxE,CAAA"}