@pascal-app/nodes 0.1.1

package/dist/window/floorplan-move.js

@@ -0,0 +1,223 @@
+import { useLiveNodeOverrides, useLiveTransforms, useScene, WallNode as WallNodeSchema, } from '@pascal-app/core';
+import { isGridSnapActive, isMagneticSnapActive, snapToHalf, triggerSFX, useEditor, usePlacementPreview, } from '@pascal-app/editor';
+import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+import { getOpeningHostLevelId, getRoofHostedOpeningPlanPoint } from '../shared/roof-opening-host';
+import { findClosestWallInPlan, projectWallLocalPointToPlan, resolveOpeningPlacement, snapLocalXToNeighbors, } from '../shared/wall-attach-target';
+import { clampToWall, DEFAULT_WINDOW_SILL_M, hasWallChildOverlap } from './window-math';
+/**
+ * 2D floor-plan move handler for window. Same shape as door (see
+ * `nodes/src/door/floorplan-move.ts`) — pointer in plan space → snap
+ * to nearest wall → project onto wall axis → snap local-X to 0.5m →
+ * clamp inside wall bounds → commit.
+ *
+ * Window-specific: local Y (vertical position on the wall) is preserved
+ * from the source node — we don't try to reposition the sill from a 2D
+ * pointer (there's no Y signal in plan view). The 3D move tool handles
+ * vertical motion; the 2D move is a horizontal-only re-anchor.
+ */
+export const windowFloorplanMoveTarget = ({ node }) => {
+    const nodeId = node.id;
+    // The level that owns the wall-snap candidates — resolves the wall-hosted,
+    // roof-hosted, and fresh-placement parentings (see `getOpeningHostLevelId`).
+    const startLevelId = getOpeningHostLevelId(node, useScene.getState().nodes);
+    const originalWall = node.parentId
+        ? useScene.getState().nodes[node.parentId]
+        : undefined;
+    const resolveCursor = createFloorplanCursorResolver({
+        original: originalWall?.type === 'wall'
+            ? projectWallLocalPointToPlan(originalWall, node.position[0])
+            : (getRoofHostedOpeningPlanPoint(node, useScene.getState().nodes) ?? [node.position[0], 0]),
+        metadata: node.metadata,
+        // Absolute: query the wall snap with the TRUE cursor (see the matching
+        // comment in `doorFloorplanMoveTarget`). Relative mode anchored the search
+        // to the original wall, which let the window snap to a farther wall across
+        // a thin gap instead of the one under the cursor.
+        mode: 'absolute',
+    });
+    // Preserve the source window's local Y — 2D move doesn't have a way
+    // to express vertical motion, so we keep whatever vertical position
+    // the window had when the move started. A fresh preset/catalog clone is
+    // created at y=0, which would sit the window's centre on the floor (half
+    // below ground); default those to a realistic sill so it floats above
+    // the floor in 2D too. Same rule as the 3D `MoveWindowTool` (`getSillCenterY`).
+    const startLocalY = node.position[1] > 0.1 ? node.position[1] : DEFAULT_WINDOW_SILL_M + node.height / 2;
+    // Track the last successful placement so `commit()` can write it
+    // atomically — same deterministic-commit fix as `doorFloorplanMoveTarget`.
+    let lastValid = null;
+    // R flips the window's facing (front ↔ back) mid-placement — see
+    // `doorFloorplanMoveTarget`. `apply` re-derives the side each move, so the
+    // flip is a persistent XOR plus a π rotation offset.
+    let flipped = false;
+    let lastApply = null;
+    // See `doorFloorplanMoveTarget`: off-wall the window free-follows the cursor
+    // as a ghost and isn't committable (it needs a wall). Starts true.
+    let onWall = true;
+    // Alt force-place (last apply's modifier) — lets `canCommit` allow an
+    // overlapping placement, matching the 3D move.
+    let forcePlace = false;
+    let liveTransformActive = useLiveTransforms.getState().transforms.has(nodeId);
+    let liveOverrideKey = null;
+    let placementPreviewActive = usePlacementPreview.getState().node?.id === nodeId;
+    const setLiveOverride = (key, values) => {
+        if (liveOverrideKey === key)
+            return;
+        liveOverrideKey = key;
+        useLiveNodeOverrides.getState().set(nodeId, values);
+    };
+    // Move SFX — parity with the 3D `MoveWindowTool` (see `doorFloorplanMoveTarget`):
+    // ONE soft `sfx:grid-snap` click each time the window's PLACED position crosses
+    // a step. Keyed on the SNAPPED value, quantized by the live grid step in grid
+    // mode else a gentle fixed cadence — grid mode ticks once per cell, lines/off
+    // tick as the window moves.
+    const FREE_STEP_M = 0.1;
+    let lastStepKey = null;
+    const tickGridStep = (...coords) => {
+        const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : FREE_STEP_M;
+        const key = coords.map((c) => Math.round(c / step)).join(',');
+        if (key !== lastStepKey) {
+            lastStepKey = key;
+            triggerSFX('sfx:grid-snap');
+        }
+    };
+    const freeFollow = (planPoint) => {
+        onWall = false;
+        lastValid = null;
+        if (liveTransformActive) {
+            useLiveTransforms.getState().clear(nodeId);
+            liveTransformActive = false;
+        }
+        setLiveOverride('free-follow', { visible: false });
+        const half = node.width / 2 + 0.5;
+        const wall = WallNodeSchema.parse({
+            start: [planPoint[0] - half, planPoint[1]],
+            end: [planPoint[0] + half, planPoint[1]],
+            thickness: 0.1,
+        });
+        // Reflect the R-flip on the floating ghost so it faces the side that will
+        // be committed (see `doorFloorplanMoveTarget.freeFollow`).
+        const ghostSide = flipped
+            ? node.side === 'front'
+                ? 'back'
+                : 'front'
+            : node.side;
+        const ghost = {
+            ...node,
+            side: ghostSide,
+            parentId: wall.id,
+            wallId: wall.id,
+            roofSegmentId: undefined,
+            roofFace: undefined,
+            position: [half, startLocalY, 0],
+            rotation: [0, flipped ? Math.PI : 0, 0],
+            visible: true,
+        };
+        usePlacementPreview.getState().set(ghost, wall);
+        placementPreviewActive = true;
+    };
+    const session = {
+        affectedIds: [nodeId],
+        flipSide() {
+            flipped = !flipped;
+            if (lastApply)
+                this.apply(lastApply);
+        },
+        apply({ planPoint, modifiers }) {
+            lastApply = { planPoint, modifiers };
+            forcePlace = modifiers.altKey === true;
+            const nodes = useScene.getState().nodes;
+            const resolvedPlanPoint = resolveCursor(planPoint);
+            const hit = findClosestWallInPlan(resolvedPlanPoint, nodes, startLevelId);
+            if (!hit) {
+                // Off any wall — free-follow. Click per grid cell over open floor.
+                tickGridStep(resolvedPlanPoint[0], resolvedPlanPoint[1]);
+                freeFollow(resolvedPlanPoint);
+                return;
+            }
+            onWall = true;
+            if (placementPreviewActive) {
+                usePlacementPreview.getState().clear();
+                placementPreviewActive = false;
+            }
+            // Figma-style along-wall alignment first (edge-to-edge with other
+            // openings / wall ends), winning over the grid snap; falls back to grid
+            // when nothing aligns. Follows the magnetic ("lines") mode; the grid
+            // component lives in `snapToHalf` (mode-aware → raw when grid is off).
+            const neighborX = !isMagneticSnapActive()
+                ? null
+                : snapLocalXToNeighbors({
+                    wall: hit.wall,
+                    localX: hit.localX,
+                    width: node.width,
+                    selfId: nodeId,
+                    nodes,
+                });
+            const snappedLocalX = neighborX ?? snapToHalf(hit.localX);
+            const { clampedX, clampedY } = clampToWall(hit.wall, snappedLocalX, startLocalY, node.width, node.height);
+            // One click per real position step, keyed on the SNAPPED along-wall value
+            // so it ticks only when the window actually moves to a new cell.
+            tickGridStep(clampedX);
+            const side = flipped
+                ? hit.side === 'front'
+                    ? 'back'
+                    : 'front'
+                : hit.side;
+            const itemRotation = hit.itemRotation + (flipped ? Math.PI : 0);
+            lastValid = {
+                position: [clampedX, clampedY, 0],
+                rotation: [0, itemRotation, 0],
+                side,
+                parentId: hit.wall.id,
+                wallId: hit.wall.id,
+                // Re-anchoring to a wall ends any roof-segment hosting; the
+                // overlay's snapshot restores it if the move is reverted.
+                roofSegmentId: undefined,
+                roofFace: undefined,
+                visible: true,
+            };
+            setLiveOverride(`wall:${hit.wall.id}:${side}`, {
+                parentId: hit.wall.id,
+                wallId: hit.wall.id,
+                side,
+                roofSegmentId: undefined,
+                roofFace: undefined,
+                visible: true,
+            });
+            useLiveTransforms.getState().set(nodeId, {
+                position: lastValid.position,
+                rotation: itemRotation,
+            });
+            liveTransformActive = true;
+        },
+        canCommit() {
+            // Off-wall the window is free-following — not placeable; the overlay
+            // reverts to the pre-move snapshot. Matches the 3D move.
+            if (!onWall || !lastValid)
+                return false;
+            const live = useScene.getState().nodes[nodeId];
+            if (live?.type !== 'window')
+                return false;
+            // Block on overlap UNLESS Alt force-places — same `placeable` rule as
+            // the 3D move + the shared `resolveOpeningPlacement`.
+            const collides = hasWallChildOverlap(lastValid.parentId, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
+            return resolveOpeningPlacement({ collides, forcePlace }).placeable;
+        },
+        commit() {
+            // Own the atomic write so the overlay takes the deterministic
+            // commit-path (revert → resume → session.commit()). The dispatcher's
+            // diff path would otherwise re-derive the final state by comparing
+            // the post-apply scene to the snapshot — that works most of the
+            // time but produces an empty diff (and silent revert) when the
+            // committed move lands on the same `parentId` with identical data.
+            // See `doorFloorplanMoveTarget.commit` for the original fix.
+            if (!lastValid)
+                return;
+            useScene.getState().updateNodes([
+                {
+                    id: nodeId,
+                    data: lastValid,
+                },
+            ]);
+        },
+    };
+    return session;
+};

package/dist/window/floorplan.d.ts

@@ -0,0 +1,16 @@
+import type { FloorplanGeometry, GeometryContext, WindowNode } from '@pascal-app/core';
+/**
+ * Stage C floor-plan builder for window. Mirrors the legacy
+ * floorplan-panel window rendering:
+ *
+ *   1. Window footprint rectangle in the wall cutout (themed accent
+ *      stroke when selected).
+ *   2. Inset inner outline — the "glass pane" frame inside the cutout.
+ *   3. Center mullion line down the middle of the opening, along the
+ *      wall direction — the legacy's standard glass divider.
+ *
+ * Skipped vs the full legacy for now: arched / rounded opening shape
+ * variants, multi-pane mullion grids.
+ */
+export declare function buildWindowFloorplan(node: WindowNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/window/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EAEf,UAAU,EACX,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAmJ1B"}

package/dist/window/floorplan.js

@@ -0,0 +1,151 @@
+import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions';
+/**
+ * Stage C floor-plan builder for window. Mirrors the legacy
+ * floorplan-panel window rendering:
+ *
+ *   1. Window footprint rectangle in the wall cutout (themed accent
+ *      stroke when selected).
+ *   2. Inset inner outline — the "glass pane" frame inside the cutout.
+ *   3. Center mullion line down the middle of the opening, along the
+ *      wall direction — the legacy's standard glass divider.
+ *
+ * Skipped vs the full legacy for now: arched / rounded opening shape
+ * variants, multi-pane mullion grids.
+ */
+export function buildWindowFloorplan(node, ctx) {
+    const wall = ctx.parent;
+    if (wall?.type !== 'wall')
+        return null;
+    const [x1, z1] = wall.start;
+    const [x2, z2] = wall.end;
+    const dx = x2 - x1;
+    const dz = z2 - z1;
+    const length = Math.sqrt(dx * dx + dz * dz);
+    if (length < 1e-9)
+        return null;
+    const dirX = dx / length;
+    const dirZ = dz / length;
+    const perpX = -dirZ;
+    const perpZ = dirX;
+    const distance = node.position[0];
+    const width = node.width;
+    const depth = wall.thickness ?? 0.1;
+    const cx = x1 + dirX * distance;
+    const cz = z1 + dirZ * distance;
+    const halfWidth = width / 2;
+    const halfDepth = depth / 2;
+    const points = [
+        [cx - dirX * halfWidth + perpX * halfDepth, cz - dirZ * halfWidth + perpZ * halfDepth],
+        [cx + dirX * halfWidth + perpX * halfDepth, cz + dirZ * halfWidth + perpZ * halfDepth],
+        [cx + dirX * halfWidth - perpX * halfDepth, cz + dirZ * halfWidth - perpZ * halfDepth],
+        [cx - dirX * halfWidth - perpX * halfDepth, cz - dirZ * halfWidth - perpZ * halfDepth],
+    ];
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    // Same selection treatment as door — selected windows get a full
+    // orange body + outline so they read as the active target.
+    const accentColor = showSelectedChrome ? '#f97316' : 'rgba(31, 41, 55, 0.92)';
+    const fillColor = showSelectedChrome ? '#fed7aa' : 'rgba(255, 255, 255, 0.96)';
+    // Inner inset rectangle (the glass pane outline). Tangent inset
+    // pulls the long sides in slightly; normal inset reduces the depth.
+    const tangentInset = Math.min(width * 0.08, 0.12);
+    const normalInset = Math.min(depth * 0.22, 0.07);
+    const innerStartA = [
+        cx - dirX * (halfWidth - tangentInset) + perpX * (halfDepth - normalInset),
+        cz - dirZ * (halfWidth - tangentInset) + perpZ * (halfDepth - normalInset),
+    ];
+    const innerEndA = [
+        cx + dirX * (halfWidth - tangentInset) + perpX * (halfDepth - normalInset),
+        cz + dirZ * (halfWidth - tangentInset) + perpZ * (halfDepth - normalInset),
+    ];
+    const innerEndB = [
+        cx + dirX * (halfWidth - tangentInset) - perpX * (halfDepth - normalInset),
+        cz + dirZ * (halfWidth - tangentInset) - perpZ * (halfDepth - normalInset),
+    ];
+    const innerStartB = [
+        cx - dirX * (halfWidth - tangentInset) - perpX * (halfDepth - normalInset),
+        cz - dirZ * (halfWidth - tangentInset) - perpZ * (halfDepth - normalInset),
+    ];
+    // Center mullion — from the midpoint of the left edge to the
+    // midpoint of the right edge of the cutout.
+    const mullionStart = [cx - dirX * halfWidth, cz - dirZ * halfWidth];
+    const mullionEnd = [cx + dirX * halfWidth, cz + dirZ * halfWidth];
+    const children = [
+        // Outer footprint — white fill so the wall hatch underneath
+        // doesn't bleed through.
+        {
+            kind: 'polygon',
+            points,
+            fill: fillColor,
+            stroke: accentColor,
+            strokeWidth: showSelectedChrome ? 1.9 : 1.25,
+            vectorEffect: 'non-scaling-stroke',
+            strokeLinejoin: 'round',
+        },
+        // Inset glass-pane outline.
+        {
+            kind: 'polygon',
+            points: [innerStartA, innerEndA, innerEndB, innerStartB],
+            fill: 'none',
+            stroke: accentColor,
+            strokeOpacity: 0.6,
+            strokeWidth: showSelectedChrome ? 1.3 : 0.9,
+            vectorEffect: 'non-scaling-stroke',
+            strokeLinejoin: 'round',
+        },
+        // Center mullion.
+        {
+            kind: 'line',
+            x1: mullionStart[0],
+            y1: mullionStart[1],
+            x2: mullionEnd[0],
+            y2: mullionEnd[1],
+            stroke: accentColor,
+            strokeWidth: showSelectedChrome ? 1.6 : 1.1,
+            strokeOpacity: 0.85,
+            strokeLinecap: 'round',
+            vectorEffect: 'non-scaling-stroke',
+        },
+    ];
+    // Move handle — orange dot at the window center. Only when selected.
+    if (isSelected) {
+        children.push({
+            kind: 'move-handle',
+            point: [cx, cz],
+        });
+        // Width-resize arrows at each side of the window (along the wall
+        // direction). Pointer-down on either routes through the window's
+        // `resize-width` affordance — anchored at the opposite edge, clamped
+        // to wall bounds. Mirrors the 3D `WindowSideArrow` width drag and the
+        // door's 2D pattern.
+        const startEdgeX = cx - dirX * halfWidth;
+        const startEdgeZ = cz - dirZ * halfWidth;
+        const endEdgeX = cx + dirX * halfWidth;
+        const endEdgeZ = cz + dirZ * halfWidth;
+        children.push({
+            kind: 'move-arrow',
+            point: [startEdgeX, startEdgeZ],
+            angle: Math.atan2(-dirZ, -dirX),
+            affordance: 'resize-width',
+            payload: { side: 'start' },
+        });
+        children.push({
+            kind: 'move-arrow',
+            point: [endEdgeX, endEdgeZ],
+            angle: Math.atan2(dirZ, dirX),
+            affordance: 'resize-width',
+            payload: { side: 'end' },
+        });
+    }
+    // Placement-measurement dimensions when actively moving — same
+    // contract as door (see `nodes/src/door/floorplan.ts`).
+    if (view?.moving) {
+        for (const dim of buildOpeningPlacementDimensions(node, ctx)) {
+            children.push(dim);
+        }
+    }
+    return { kind: 'group', children };
+}

package/dist/window/index.d.ts

@@ -0,0 +1,3 @@
+export { windowDefinition } from './definition';
+export { WindowNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/window/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/window/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA"}

package/dist/window/index.js

@@ -0,0 +1,2 @@
+export { windowDefinition } from './definition';
+export { WindowNode } from './schema';

package/dist/window/move-tool.d.ts

@@ -0,0 +1,18 @@
+import { WindowNode } from '@pascal-app/core';
+/**
+ * Move/duplicate tool for WindowNodes — wall-only, same guardrails as WindowTool.
+ *
+ * Move mode (metadata.isNew falsy):
+ *   Adopts the existing window, pauses temporal. On commit: restores original state
+ *   (clean undo baseline) then resumes + updateNode (undo reverts to original position).
+ *   On cancel: restores original state.
+ *
+ * Duplicate mode (metadata.isNew = true):
+ *   The node is a freshly created transient copy. On commit: deletes transient + resumes
+ *   + createNode (undo removes the new window entirely). On cancel: deletes the node.
+ */
+declare const MoveWindowTool: React.FC<{
+    node: WindowNode;
+}>;
+export default MoveWindowTool;
+//# sourceMappingURL=move-tool.d.ts.map

package/dist/window/move-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAYL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAqDzB;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CA0/BlD,CAAA;AAED,eAAe,cAAc,CAAA"}