@pascal-app/nodes 1.0.6 → 1.0.7

package/dist/fence-feature/inspector.js

@@ -1,12 +1,13 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { canPlaceFenceFeature, FenceStyle, fenceFeatureData, fenceWithFeatures, getFenceCenterlineLength, useScene, } from '@pascal-app/core';
+import { canPlaceFenceFeature, FenceStyle, fenceFeatureData, fenceWithFeatures, getFenceCenterlineLength, usePascalI18n, useScene, } from '@pascal-app/core';
 import { ActionButton, SliderControl, ToggleControl } from '@pascal-app/editor';
 import { useState } from 'react';
 import { useShallow } from 'zustand/react/shallow';
 import { getFenceFeatureDimensions } from '../fence/geometry-parts.js';
 export function FenceFeatureEditor({ node: child, onUpdate, }) {
-    const [error, setError] = useState('');
+    const i18n = usePascalI18n();
+    const [blocked, setBlocked] = useState(false);
     const parentId = child.parentId;
     const parent = useScene((s) => (parentId ? s.nodes[parentId] : undefined));
     const siblings = useScene(useShallow((s) => {
@@ -16,7 +17,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
             : [];
     }));
     if (parent?.type !== 'fence')
-        return _jsx("p", { children: "Fence unavailable." });
+        return (_jsx("p", { children: i18n._({
+                id: 'node.fenceFeature.inspector.fenceUnavailable',
+                message: 'Fence unavailable.',
+            }) }));
     const node = fenceWithFeatures(parent, siblings);
     const features = [fenceFeatureData(child)];
     const length = getFenceCenterlineLength(node);
@@ -27,13 +31,16 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
         const next = { ...original, ...patch };
         if ((patch.width !== undefined || patch.center !== undefined) &&
             !canPlaceFenceFeature(node, next)) {
-            setError('Keep the opening inside the fence and clear of other gates or passages.');
+            setBlocked(true);
             return;
         }
-        setError('');
+        setBlocked(false);
         onUpdate(patch);
     };
-    return (_jsxs("div", { className: "space-y-2 text-xs", children: [error && (_jsx("p", { role: "status", className: "text-amber-500", children: error })), features.map((feature) => {
+    return (_jsxs("div", { className: "space-y-2 text-xs", children: [blocked && (_jsx("p", { role: "status", className: "text-amber-500", children: i18n._({
+                    id: 'node.fenceFeature.inspector.keepTheOpeningInsideTheFence',
+                    message: 'Keep the opening inside the fence and clear of other gates or passages.',
+                }) })), features.map((feature) => {
                 const gate = feature.kind === 'gate';
                 const { height, bottom } = getFenceFeatureDimensions(node, feature);
                 const selects = [
@@ -41,39 +48,87 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                         ? [
                             {
                                 key: 'leafType',
-                                label: 'Leaves',
+                                label: i18n._({ id: 'node.fenceFeature.inspector.leaves', message: 'Leaves' }),
                                 value: feature.leafType ?? 'single',
                                 options: [
-                                    ['single', 'Single gate'],
-                                    ['double', 'Double gate'],
+                                    [
+                                        'single',
+                                        i18n._({
+                                            id: 'node.fenceFeature.inspector.option.singleGate',
+                                            message: 'Single gate',
+                                        }),
+                                    ],
+                                    [
+                                        'double',
+                                        i18n._({
+                                            id: 'node.fenceFeature.inspector.option.doubleGate',
+                                            message: 'Double gate',
+                                        }),
+                                    ],
                                 ],
                             },
                             {
                                 key: 'hinge',
-                                label: 'Hinge side',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.hingeSide',
+                                    message: 'Hinge side',
+                                }),
                                 value: feature.hinge ?? 'left',
                                 options: [
-                                    ['left', 'Left'],
-                                    ['right', 'Right'],
+                                    [
+                                        'left',
+                                        i18n._({ id: 'node.fenceFeature.inspector.option.left', message: 'Left' }),
+                                    ],
+                                    [
+                                        'right',
+                                        i18n._({ id: 'node.fenceFeature.inspector.option.right', message: 'Right' }),
+                                    ],
                                 ],
                             },
                             {
                                 key: 'swing',
-                                label: 'Swing direction',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.swingDirection',
+                                    message: 'Swing direction',
+                                }),
                                 value: feature.swing ?? 'inward',
                                 options: [
-                                    ['inward', 'Inward'],
-                                    ['outward', 'Outward'],
+                                    [
+                                        'inward',
+                                        i18n._({
+                                            id: 'node.fenceFeature.inspector.option.inward',
+                                            message: 'Inward',
+                                        }),
+                                    ],
+                                    [
+                                        'outward',
+                                        i18n._({
+                                            id: 'node.fenceFeature.inspector.option.outward',
+                                            message: 'Outward',
+                                        }),
+                                    ],
                                 ],
                             },
                             {
                                 key: 'brace',
-                                label: 'Bracing',
+                                label: i18n._({ id: 'node.fenceFeature.inspector.bracing', message: 'Bracing' }),
                                 value: feature.brace ?? 'none',
                                 options: [
-                                    ['none', 'None'],
-                                    ['diagonal', 'Diagonal'],
-                                    ['cross', 'Cross'],
+                                    [
+                                        'none',
+                                        i18n._({ id: 'node.fenceFeature.inspector.option.none', message: 'None' }),
+                                    ],
+                                    [
+                                        'diagonal',
+                                        i18n._({
+                                            id: 'node.fenceFeature.inspector.option.diagonal',
+                                            message: 'Diagonal',
+                                        }),
+                                    ],
+                                    [
+                                        'cross',
+                                        i18n._({ id: 'node.fenceFeature.inspector.option.cross', message: 'Cross' }),
+                                    ],
                                 ],
                             },
                         ]
@@ -82,7 +137,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                 const numbers = [
                     {
                         key: 'center',
-                        label: 'Distance from start',
+                        label: i18n._({
+                            id: 'node.fenceFeature.inspector.distanceFromStart',
+                            message: 'Distance from start',
+                        }),
                         value: feature.center,
                         min: 0,
                         max: length,
@@ -91,7 +149,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                     },
                     {
                         key: 'width',
-                        label: 'Opening width',
+                        label: i18n._({
+                            id: 'node.fenceFeature.inspector.openingWidth',
+                            message: 'Opening width',
+                        }),
                         value: feature.width,
                         min: 0.35,
                         max: length,
@@ -100,7 +161,9 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                     },
                     {
                         key: 'height',
-                        label: gate ? 'Gate height' : 'Post height',
+                        label: gate
+                            ? i18n._({ id: 'node.fenceFeature.inspector.gateHeight', message: 'Gate height' })
+                            : i18n._({ id: 'node.fenceFeature.inspector.postHeight', message: 'Post height' }),
                         value: height,
                         min: 0.3,
                         max: 1000,
@@ -111,7 +174,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                         ? [
                             {
                                 key: 'clearance',
-                                label: 'Ground clearance',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.groundClearance',
+                                    message: 'Ground clearance',
+                                }),
                                 value: bottom,
                                 min: 0,
                                 max: 1000,
@@ -120,7 +186,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                             },
                             {
                                 key: 'openAngle',
-                                label: 'Opening angle',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.openingAngle',
+                                    message: 'Opening angle',
+                                }),
                                 value: feature.openAngle ?? 0,
                                 min: 0,
                                 max: 170,
@@ -129,7 +198,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                             },
                             {
                                 key: 'thickness',
-                                label: 'Leaf thickness',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.leafThickness',
+                                    message: 'Leaf thickness',
+                                }),
                                 value: feature.thickness ?? 0.06,
                                 min: 0.02,
                                 max: 0.3,
@@ -138,7 +210,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                             },
                             {
                                 key: 'frameWidth',
-                                label: 'Frame width',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.frameWidth',
+                                    message: 'Frame width',
+                                }),
                                 value: feature.frameWidth ?? 0.055,
                                 min: 0.025,
                                 max: 0.2,
@@ -147,7 +222,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                             },
                             {
                                 key: 'spacing',
-                                label: 'Infill spacing',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.infillSpacing',
+                                    message: 'Infill spacing',
+                                }),
                                 value: feature.spacing ?? 0.15,
                                 min: 0.04,
                                 max: 1000,
@@ -156,7 +234,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                             },
                             {
                                 key: 'boardWidth',
-                                label: 'Board width',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.boardWidth',
+                                    message: 'Board width',
+                                }),
                                 value: feature.boardWidth ?? 0.055,
                                 min: 0.02,
                                 max: 0.3,
@@ -167,7 +248,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                                 ? [
                                     {
                                         key: 'leafSplit',
-                                        label: 'Left leaf proportion',
+                                        label: i18n._({
+                                            id: 'node.fenceFeature.inspector.leftLeafProportion',
+                                            message: 'Left leaf proportion',
+                                        }),
                                         value: feature.leafSplit ?? 0.5,
                                         min: 0.2,
                                         max: 0.8,
@@ -179,20 +263,38 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                         ]
                         : []),
                 ];
-                return (_jsx("div", { children: _jsxs("div", { className: "mt-2 space-y-2", children: [_jsx(ToggleControl, { label: "Match fence style", checked: feature.matchFenceStyle !== false, onChange: (checked) => update(feature.id, {
+                return (_jsx("div", { children: _jsxs("div", { className: "mt-2 space-y-2", children: [_jsx(ToggleControl, { label: i18n._({
+                                    id: 'node.fenceFeature.inspector.matchFenceStyle',
+                                    message: 'Match fence style',
+                                }), checked: feature.matchFenceStyle !== false, onChange: (checked) => update(feature.id, {
                                     matchFenceStyle: checked,
                                     ...(checked
                                         ? { matchFenceHeight: true }
                                         : { style: feature.style === 'match' ? 'picket' : feature.style }),
-                                }) }), _jsx(ToggleControl, { label: "Match fence height", checked: feature.matchFenceHeight ?? feature.matchFenceStyle !== false, onChange: (checked) => update(feature.id, {
+                                }) }), _jsx(ToggleControl, { label: i18n._({
+                                    id: 'node.fenceFeature.inspector.matchFenceHeight',
+                                    message: 'Match fence height',
+                                }), checked: feature.matchFenceHeight ?? feature.matchFenceStyle !== false, onChange: (checked) => update(feature.id, {
                                     matchFenceHeight: checked,
                                     height,
                                     ...(gate ? { clearance: bottom } : {}),
-                                }) }), gate && feature.matchFenceStyle === false && (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: ["Gate style", _jsxs("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-black/4 dark:bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-black/8 dark:hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: feature.style && feature.style !== 'match' ? feature.style : 'picket', onChange: (event) => {
+                                }) }), gate && feature.matchFenceStyle === false && (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: [i18n._({ id: 'node.fenceFeature.inspector.gateStyle', message: 'Gate style' }), _jsxs("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-black/4 dark:bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-black/8 dark:hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: feature.style && feature.style !== 'match' ? feature.style : 'picket', onChange: (event) => {
                                             const style = FenceStyle.safeParse(event.currentTarget.value);
                                             if (style.success)
                                                 update(feature.id, { style: style.data });
-                                        }, children: [_jsx("option", { value: "picket", children: "Picket" }), _jsx("option", { value: "slat", children: "Vertical slats" }), _jsx("option", { value: "horizontal", children: "Horizontal boards" }), _jsx("option", { value: "privacy", children: "Solid privacy" }), _jsx("option", { value: "rail", children: "Open rails" })] })] })), selects
+                                        }, children: [_jsx("option", { value: "picket", children: i18n._({ id: 'node.fenceFeature.inspector.picket', message: 'Picket' }) }), _jsx("option", { value: "slat", children: i18n._({
+                                                    id: 'node.fenceFeature.inspector.verticalSlats',
+                                                    message: 'Vertical slats',
+                                                }) }), _jsx("option", { value: "horizontal", children: i18n._({
+                                                    id: 'node.fenceFeature.inspector.horizontalBoards',
+                                                    message: 'Horizontal boards',
+                                                }) }), _jsx("option", { value: "privacy", children: i18n._({
+                                                    id: 'node.fenceFeature.inspector.solidPrivacy',
+                                                    message: 'Solid privacy',
+                                                }) }), _jsx("option", { value: "rail", children: i18n._({
+                                                    id: 'node.fenceFeature.inspector.openRails',
+                                                    message: 'Open rails',
+                                                }) })] })] })), selects
                                 .filter((field) => field.key !== 'hinge' || feature.leafType !== 'double')
                                 .map((field) => (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: [field.label, _jsx("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-black/4 dark:bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-black/8 dark:hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: field.value, onChange: (event) => update(feature.id, { [field.key]: event.target.value }), children: field.options.map(([value, label]) => (_jsx("option", { value: value, children: label }, value))) })] }, field.key))), numbers
                                 .filter((field) => feature.matchFenceStyle === false ||
@@ -209,6 +311,20 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                                                     : {}),
                                         }
                                         : {}),
-                                }) }, field.key))), _jsx(ToggleControl, { label: "Jamb posts", checked: feature.showPosts !== false, onChange: (checked) => update(feature.id, { showPosts: checked }) }), gate && (_jsx(ToggleControl, { label: "Hinges and latch", checked: feature.showHardware !== false, onChange: (checked) => update(feature.id, { showHardware: checked }) })), _jsx(ActionButton, { type: "button", label: gate ? 'Remove gate' : 'Remove opening', className: "w-full text-destructive hover:text-destructive", onClick: () => useScene.getState().deleteNode(child.id) })] }) }, feature.id));
+                                }) }, field.key))), _jsx(ToggleControl, { label: i18n._({
+                                    id: 'node.fenceFeature.inspector.jambPosts',
+                                    message: 'Jamb posts',
+                                }), checked: feature.showPosts !== false, onChange: (checked) => update(feature.id, { showPosts: checked }) }), gate && (_jsx(ToggleControl, { label: i18n._({
+                                    id: 'node.fenceFeature.inspector.hingesAndLatch',
+                                    message: 'Hinges and latch',
+                                }), checked: feature.showHardware !== false, onChange: (checked) => update(feature.id, { showHardware: checked }) })), _jsx(ActionButton, { type: "button", label: gate
+                                    ? i18n._({
+                                        id: 'node.fenceFeature.inspector.removeGate',
+                                        message: 'Remove gate',
+                                    })
+                                    : i18n._({
+                                        id: 'node.fenceFeature.inspector.removeOpening',
+                                        message: 'Remove opening',
+                                    }), className: "w-full text-destructive hover:text-destructive", onClick: () => useScene.getState().deleteNode(child.id) })] }) }, feature.id));
             })] }));
 }

package/dist/fence-feature/move-session.d.ts

@@ -1,6 +1,6 @@
 import { type AnyNodeId, type FenceFeatureNode, type FenceNode, type GridEvent, type SceneApi } from '@pascal-app/core';
 export declare function createFenceFeatureMoveSession(node: FenceFeatureNode, sceneApi: SceneApi, levelId: AnyNodeId | null, selectNode: (id: AnyNodeId) => void): {
-    affectedIds: (`block_${string}` | `building_${string}` | `bvent_${string}` | `cabinet-module_${string}` | `cabinet_${string}` | `ceiling_${string}` | `chimney_${string}` | `column_${string}` | `construction-dimension_${string}` | `cupola_${string}` | `door_${string}` | `dormer_${string}` | `downspout_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `elevator_${string}` | `eyebrow-vent_${string}` | `fence-gate_${string}` | `fence-opening_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `gutter_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `leanto_${string}` | `level_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `rseg_${string}` | `rvent_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `site_${string}` | `skylight_${string}` | `slab_${string}` | `solarpanel_${string}` | `spawn_${string}` | `sseg_${string}` | `stair_${string}` | `structural-grid_${string}` | `tvent_${string}` | `unit_${string}` | `wall_${string}` | `window_${string}` | `zone_${string}`)[];
+    affectedIds: (`beam_${string}` | `block_${string}` | `building_${string}` | `bvent_${string}` | `cabinet-module_${string}` | `cabinet_${string}` | `ceiling_${string}` | `chimney_${string}` | `column_${string}` | `construction-dimension_${string}` | `cupola_${string}` | `door_${string}` | `dormer_${string}` | `downspout_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `elevator_${string}` | `eyebrow-vent_${string}` | `fence-gate_${string}` | `fence-opening_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `gutter_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `leanto_${string}` | `level_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `rseg_${string}` | `rvent_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `site_${string}` | `skylight_${string}` | `slab_${string}` | `solarpanel_${string}` | `spawn_${string}` | `sseg_${string}` | `stair_${string}` | `structural-grid_${string}` | `tvent_${string}` | `unit_${string}` | `wall_${string}` | `window_${string}` | `zone_${string}`)[];
     clear: () => void;
     update(point: readonly [number, number], host?: FenceNode, ray?: GridEvent['localRay']): void;
     canCommit: () => boolean;

package/dist/floor-opening/floorplan.d.ts

@@ -1,11 +1,33 @@
-import type { FloorOpeningNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import { type FloorOpeningNode, type FloorplanAffordance, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
+type Ring = [number, number][];
+/**
+ * A stair's opening: a box its stair cut, resized as a box. An elevator's opening keeps the free
+ * polygon handles: its cut comes from the car, so a drawn shape would not stick.
+ */
+export declare function isOwnedOpening(node: FloorOpeningNode): boolean;
+/**
+ * The square-cornered rectangle an owned opening is edited as: the ring itself when it already is
+ * one, otherwise (an opening cut with rounded corners before they were square) the box around it,
+ * aligned with its longest side.
+ */
+export declare function openingRectangle(polygon: ReadonlyArray<readonly [number, number]>): Ring;
+/**
+ * `rectangle` with corner `index` dragged to `point`: the opposite corner stays, the two sides
+ * through the dragged corner keep their directions, so the box stays a box.
+ */
+export declare function resizeRectangleCorner(rectangle: Ring, index: number, point: readonly [number, number]): Ring;
+/** `rectangle` with side `edgeIndex` moved parallel by `distance` along its outward normal. */
+export declare function moveRectangleEdge(rectangle: Ring, edgeIndex: number, distance: number): Ring;
 /**
  * A floor opening on the plan: a dashed amber outline (the void the surfaces
  * around it show), and — while selected — the same corner, midpoint and edge
- * handles slabs and zones use.
+ * handles slabs and zones use. A stair's opening is a box: its
+ * selected outline is solid, its sides carry a grip each to move them
+ * parallel and its corners resize it, all at a fixed screen size; it has no
+ * midpoint handles to add a vertex.
  */
 export declare function buildFloorOpeningFloorplan(node: FloorOpeningNode, ctx: GeometryContext): FloorplanGeometry | null;
-export declare const floorOpeningMoveVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+export declare const floorOpeningMoveVertexAffordance: FloorplanAffordance<{
     object: "node";
     name?: string | undefined;
     parentId: string | null;
@@ -42,7 +64,7 @@ export declare const floorOpeningMoveVertexAffordance: import("@pascal-app/core"
     cutsPrimary: boolean;
     cutsAdjacent: boolean;
 }>;
-export declare const floorOpeningAddVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+export declare const floorOpeningAddVertexAffordance: FloorplanAffordance<{
     object: "node";
     name?: string | undefined;
     parentId: string | null;
@@ -79,7 +101,7 @@ export declare const floorOpeningAddVertexAffordance: import("@pascal-app/core")
     cutsPrimary: boolean;
     cutsAdjacent: boolean;
 }>;
-export declare const floorOpeningMoveEdgeAffordance: import("@pascal-app/core").FloorplanAffordance<{
+export declare const floorOpeningMoveEdgeAffordance: FloorplanAffordance<{
     object: "node";
     name?: string | undefined;
     parentId: string | null;
@@ -116,7 +138,7 @@ export declare const floorOpeningMoveEdgeAffordance: import("@pascal-app/core").
     cutsPrimary: boolean;
     cutsAdjacent: boolean;
 }>;
-export declare const floorOpeningDeleteVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+export declare const floorOpeningDeleteVertexAffordance: FloorplanAffordance<{
     object: "node";
     name?: string | undefined;
     parentId: string | null;
@@ -153,4 +175,5 @@ export declare const floorOpeningDeleteVertexAffordance: import("@pascal-app/cor
     cutsPrimary: boolean;
     cutsAdjacent: boolean;
 }>;
+export {};
 //# sourceMappingURL=floorplan.d.ts.map

package/dist/floor-opening/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/floor-opening/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAU5F;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAkD1B;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACqB,CAAA;AAClE,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACyB,CAAA;AACrE,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACyB,CAAA;AACpE,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACyB,CAAA"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/floor-opening/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EAExB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AAazB,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;AAE9B;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAE9D;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CA0BxF;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,IAAI,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,IAAI,CAoBN;AAED,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAgB5F;AA2DD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAgE1B;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASuB,CAAA;AACpE,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG3C,CAAA;AACD,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiB2B,CAAA;AACtE,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG9C,CAAA"}

package/dist/floor-opening/floorplan.js

@@ -1,12 +1,142 @@
+import { authorStairOpeningPatches, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getSegmentGridStep, snapPointToGrid, snapScalarToGrid } from '@pascal-app/editor';
 import { createPolygonAddVertexAffordance, createPolygonDeleteVertexAffordance, createPolygonMoveEdgeAffordance, createPolygonVertexAffordance, } from '../shared/polygon-vertex-affordance.js';
 const COLOR = '#f59e0b';
+/** A side of a stair opening never shrinks below this (metres). */
+const MIN_OPENING_SIDE = 0.2;
+/**
+ * A stair's opening: a box its stair cut, resized as a box. An elevator's opening keeps the free
+ * polygon handles: its cut comes from the car, so a drawn shape would not stick.
+ */
+export function isOwnedOpening(node) {
+    return node.source === 'stair' && !!node.ownerId;
+}
+/**
+ * The square-cornered rectangle an owned opening is edited as: the ring itself when it already is
+ * one, otherwise (an opening cut with rounded corners before they were square) the box around it,
+ * aligned with its longest side.
+ */
+export function openingRectangle(polygon) {
+    const ring = polygon.map(([x, z]) => [x, z]);
+    let longest = 0;
+    let axis = [1, 0];
+    for (const [i, a] of ring.entries()) {
+        const b = ring[(i + 1) % ring.length];
+        const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        if (length > longest) {
+            longest = length;
+            axis = [(b[0] - a[0]) / length, (b[1] - a[1]) / length];
+        }
+    }
+    const normal = [-axis[1], axis[0]];
+    const along = ring.map(([x, z]) => x * axis[0] + z * axis[1]);
+    const across = ring.map(([x, z]) => x * normal[0] + z * normal[1]);
+    const [u0, u1, v0, v1] = [
+        Math.min(...along),
+        Math.max(...along),
+        Math.min(...across),
+        Math.max(...across),
+    ];
+    const at = (u, v) => [
+        u * axis[0] + v * normal[0],
+        u * axis[1] + v * normal[1],
+    ];
+    return [at(u0, v0), at(u1, v0), at(u1, v1), at(u0, v1)];
+}
+/**
+ * `rectangle` with corner `index` dragged to `point`: the opposite corner stays, the two sides
+ * through the dragged corner keep their directions, so the box stays a box.
+ */
+export function resizeRectangleCorner(rectangle, index, point) {
+    const at = (offset) => rectangle[(index + offset) % 4];
+    const origin = at(2);
+    const unit = (to) => {
+        const dx = to[0] - origin[0];
+        const dz = to[1] - origin[1];
+        const length = Math.hypot(dx, dz) || 1;
+        return [dx / length, dz / length];
+    };
+    const a = unit(at(1));
+    const b = unit(at(3));
+    const dx = point[0] - origin[0];
+    const dz = point[1] - origin[1];
+    const sideA = Math.max(MIN_OPENING_SIDE, dx * a[0] + dz * a[1]);
+    const sideB = Math.max(MIN_OPENING_SIDE, dx * b[0] + dz * b[1]);
+    const next = [...rectangle];
+    next[(index + 1) % 4] = [origin[0] + a[0] * sideA, origin[1] + a[1] * sideA];
+    next[(index + 3) % 4] = [origin[0] + b[0] * sideB, origin[1] + b[1] * sideB];
+    next[index] = [origin[0] + a[0] * sideA + b[0] * sideB, origin[1] + a[1] * sideA + b[1] * sideB];
+    return next;
+}
+/** `rectangle` with side `edgeIndex` moved parallel by `distance` along its outward normal. */
+export function moveRectangleEdge(rectangle, edgeIndex, distance) {
+    const start = rectangle[edgeIndex];
+    const end = rectangle[(edgeIndex + 1) % 4];
+    const opposite = rectangle[(edgeIndex + 2) % 4];
+    const length = Math.hypot(end[0] - start[0], end[1] - start[1]) || 1;
+    let normal = [-(end[1] - start[1]) / length, (end[0] - start[0]) / length];
+    // Point the normal away from the box, whichever way the ring winds.
+    if ((opposite[0] - start[0]) * normal[0] + (opposite[1] - start[1]) * normal[1] > 0)
+        normal = [-normal[0], -normal[1]];
+    const depth = (opposite[0] - start[0]) * -normal[0] + (opposite[1] - start[1]) * -normal[1];
+    const travel = Math.max(MIN_OPENING_SIDE - depth, distance);
+    return rectangle.map((point, i) => i === edgeIndex || i === (edgeIndex + 1) % 4
+        ? [point[0] + normal[0] * travel, point[1] + normal[1] * travel]
+        : point);
+}
+/** Every write for `ring` on a stair's opening: its floor and ceiling cuts take it as drawn. */
+function ownedOpeningUpdates(id, ring) {
+    const authored = authorStairOpeningPatches(useScene.getState().nodes, id, ring);
+    return authored.length ? authored : [{ id, data: { polygon: ring } }];
+}
+function ownedOpeningSession(node, next) {
+    const rectangle = openingRectangle(node.polygon);
+    const affectedIds = [
+        ...new Set([
+            node.id,
+            ...authorStairOpeningPatches(useScene.getState().nodes, node.id, rectangle).map((patch) => patch.id),
+        ]),
+    ];
+    let ring = null;
+    // The drag previews through live overrides; the scene is written once, on release.
+    return {
+        affectedIds,
+        apply({ planPoint }) {
+            ring = next(rectangle, planPoint);
+            useLiveNodeOverrides
+                .getState()
+                .setMany(ownedOpeningUpdates(node.id, ring).map(({ id, data }) => [id, data]));
+        },
+        canCommit: () => ring !== null,
+        commit() {
+            const overrides = useLiveNodeOverrides.getState();
+            if (ring)
+                useScene.getState().updateNodes(ownedOpeningUpdates(node.id, ring));
+            for (const id of affectedIds)
+                overrides.clear(id);
+        },
+    };
+}
+/** Owned openings resize as a box; every other opening keeps the free polygon handles. */
+function ownedOr(owned, free) {
+    return { start: (args) => (isOwnedOpening(args.node) ? owned(args) : free.start(args)) };
+}
+const inert = (node) => ({
+    affectedIds: [node.id],
+    apply() { },
+    canCommit: () => false,
+});
 /**
  * A floor opening on the plan: a dashed amber outline (the void the surfaces
  * around it show), and — while selected — the same corner, midpoint and edge
- * handles slabs and zones use.
+ * handles slabs and zones use. A stair's opening is a box: its
+ * selected outline is solid, its sides carry a grip each to move them
+ * parallel and its corners resize it, all at a fixed screen size; it has no
+ * midpoint handles to add a vertex.
  */
 export function buildFloorOpeningFloorplan(node, ctx) {
-    const polygon = node.polygon;
+    const owned = isOwnedOpening(node);
+    const polygon = owned && ctx.viewState?.selected ? openingRectangle(node.polygon) : node.polygon;
     if (polygon.length < 3)
         return null;
     const selected = ctx.viewState?.selected ?? false;
@@ -18,9 +148,9 @@ export function buildFloorOpeningFloorplan(node, ctx) {
             fill: COLOR,
             fillOpacity: selected ? 0.22 : 0.1,
             stroke: COLOR,
-            strokeWidth: selected ? 0.04 : 0.03,
+            strokeWidth: selected ? (owned ? 0.06 : 0.04) : 0.03,
             strokeOpacity: 0.95,
-            strokeDasharray: '0.12 0.08',
+            ...(selected && owned ? {} : { strokeDasharray: '0.12 0.08' }),
         },
     ];
     if (selected) {
@@ -38,18 +168,29 @@ export function buildFloorOpeningFloorplan(node, ctx) {
         });
         polygon.forEach((a, i) => {
             const b = polygon[(i + 1) % polygon.length];
-            children.push({
-                kind: 'midpoint-handle',
-                point: [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2],
-                affordance: 'add-vertex',
-                payload: { edgeIndex: i },
-            });
+            const point = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+            children.push(owned
+                ? {
+                    kind: 'endpoint-handle',
+                    point,
+                    state: 'idle',
+                    screenSized: true,
+                    affordance: 'move-edge',
+                    payload: { edgeIndex: i },
+                }
+                : {
+                    kind: 'midpoint-handle',
+                    point,
+                    affordance: 'add-vertex',
+                    payload: { edgeIndex: i },
+                });
         });
         polygon.forEach(([x, z], i) => {
             children.push({
                 kind: 'endpoint-handle',
                 point: [x, z],
                 state: 'idle',
+                ...(owned ? { screenSized: true } : {}),
                 affordance: 'move-vertex',
                 payload: { vertexIndex: i },
             });
@@ -57,7 +198,24 @@ export function buildFloorOpeningFloorplan(node, ctx) {
     }
     return { kind: 'group', children };
 }
-export const floorOpeningMoveVertexAffordance = createPolygonVertexAffordance('floor-opening');
-export const floorOpeningAddVertexAffordance = createPolygonAddVertexAffordance('floor-opening');
-export const floorOpeningMoveEdgeAffordance = createPolygonMoveEdgeAffordance('floor-opening');
-export const floorOpeningDeleteVertexAffordance = createPolygonDeleteVertexAffordance('floor-opening');
+export const floorOpeningMoveVertexAffordance = ownedOr(({ node, payload }) => {
+    const { vertexIndex } = payload;
+    return ownedOpeningSession(node, (rectangle, planPoint) => resizeRectangleCorner(rectangle, vertexIndex % 4, snapPointToGrid([planPoint[0], planPoint[1]], getSegmentGridStep())));
+}, createPolygonVertexAffordance('floor-opening'));
+export const floorOpeningAddVertexAffordance = ownedOr(({ node }) => inert(node), createPolygonAddVertexAffordance('floor-opening'));
+export const floorOpeningMoveEdgeAffordance = ownedOr(({ node, payload, initialPlanPoint }) => {
+    const { edgeIndex } = payload;
+    return ownedOpeningSession(node, (rectangle, planPoint) => {
+        const start = rectangle[edgeIndex % 4];
+        const end = rectangle[(edgeIndex + 1) % 4];
+        const opposite = rectangle[(edgeIndex + 2) % 4];
+        const length = Math.hypot(end[0] - start[0], end[1] - start[1]) || 1;
+        let normal = [-(end[1] - start[1]) / length, (end[0] - start[0]) / length];
+        if ((opposite[0] - start[0]) * normal[0] + (opposite[1] - start[1]) * normal[1] > 0)
+            normal = [-normal[0], -normal[1]];
+        const distance = snapScalarToGrid((planPoint[0] - initialPlanPoint[0]) * normal[0] +
+            (planPoint[1] - initialPlanPoint[1]) * normal[1], getSegmentGridStep());
+        return moveRectangleEdge(rectangle, edgeIndex % 4, distance);
+    });
+}, createPolygonMoveEdgeAffordance('floor-opening'));
+export const floorOpeningDeleteVertexAffordance = ownedOr(({ node }) => inert(node), createPolygonDeleteVertexAffordance('floor-opening'));

package/dist/gutter/downspouts-panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"downspouts-panel.d.ts","sourceRoot":"","sources":["../../src/gutter/downspouts-panel.tsx"],"names":[],"mappings":"AAmDA;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,uCAuGtC"}
+{"version":3,"file":"downspouts-panel.d.ts","sourceRoot":"","sources":["../../src/gutter/downspouts-panel.tsx"],"names":[],"mappings":"AAoDA;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,uCAwHtC"}