@pascal-app/nodes 1.0.6 → 1.0.7

package/dist/window/floorplan.js

@@ -1,5 +1,6 @@
-import { cornerPair, getWallBodyCenterOffset } from '@pascal-app/core';
+import { cornerPair, getWallBodyCenterOffset, openingExteriorFace, openingHostFacing, } from '@pascal-app/core';
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
+import { buildOpeningCasingPlan } from '../shared/opening-casing.js';
 import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation.js';
 import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions.js';
 import { resolveOpeningPlanPlane } from '../shared/opening-plane-offset.js';
@@ -70,6 +71,8 @@ function cornerMitre(node, wall, ctx) {
  *   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.
+ *   4. Casing legs standing proud of each cased wall face beside the
+ *      cutout (`buildOpeningCasingPlan`).
  *
  * Skipped vs the full legacy for now: arched / rounded opening shape
  * variants, multi-pane mullion grids.
@@ -237,6 +240,60 @@ export function buildWindowFloorplan(node, ctx) {
                 vectorEffect: 'non-scaling-stroke',
             },
         ];
+    // The mode uses its architectural symbol even while the sash is closed.
+    if (node.windowType === 'tilt-turn' && node.openingKind !== 'opening' && !node.source) {
+        const level = wall.parentId ? ctx.resolve(wall.parentId) : undefined;
+        const walls = [
+            wall,
+            ...(level?.type === 'level'
+                ? level.children.map((id) => ctx.resolve(id)).filter((entry) => !!entry)
+                : []),
+        ];
+        const nodes = Object.fromEntries(walls.map((entry) => [entry.id, entry]));
+        const inward = openingExteriorFace(node, nodes) === 'a' ? -1 : 1;
+        const ink = {
+            stroke: drafting ? '#1f2937' : accentColor,
+            strokeWidth: drafting ? 0.008 : 1.1,
+            ...(drafting ? {} : { vectorEffect: 'non-scaling-stroke' }),
+        };
+        if (node.tiltTurnMode === 'turn') {
+            const facing = openingHostFacing(node);
+            const hinge = (node.hingesSide === 'right' ? 1 : -1) * facing;
+            const radius = Math.max(width - 2 * node.frameThickness, 0.01);
+            const [hx, hz] = plan(distance + (hinge * radius) / 2, across);
+            const [closedX, closedZ] = plan(distance - (hinge * radius) / 2, across);
+            const [tipX, tipZ] = plan(distance + (hinge * radius) / 2, across + inward * radius);
+            children.push({
+                kind: 'path',
+                d: `M ${closedX} ${closedZ} A ${radius} ${radius} 0 0 ${hinge * inward < 0 ? 1 : 0} ${tipX} ${tipZ}`,
+                fill: 'none',
+                ...ink,
+            });
+            children.push({ kind: 'line', x1: hx, y1: hz, x2: tipX, y2: tipZ, ...ink });
+        }
+        else {
+            const left = plan(distance - width * 0.2, across);
+            const tip = plan(distance, across + inward * Math.max(depth, 0.15));
+            const right = plan(distance + width * 0.2, across);
+            children.push({
+                kind: 'path',
+                d: `M ${left[0]} ${left[1]} L ${tip[0]} ${tip[1]} L ${right[0]} ${right[1]}`,
+                fill: 'none',
+                ...ink,
+            });
+        }
+    }
+    // Casing legs on the wall faces beside the cutout, as the 3D window has them.
+    const casing = buildOpeningCasingPlan(node, wall, drafting
+        ? { fill: '#ffffff', stroke: '#1f2937', strokeWidth: 0.006 }
+        : {
+            fill: fillColor,
+            stroke: accentColor,
+            strokeWidth: showSelectedChrome || isHovered ? 1.3 : 1,
+            vectorEffect: 'non-scaling-stroke',
+        }, mitre?.end);
+    if (casing)
+        children.push(casing);
     // Move handle — orange dot at the window center. Only when selected.
     if (isSelected) {
         children.push({

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

@@ -1 +1 @@
-{"version":3,"file":"mechanism.d.ts","sourceRoot":"","sources":["../../src/window/mechanism.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAS3D,wFAAwF;AACxF,eAAO,MAAM,eAAe,EAAE,mBAiB7B,CAAA"}
+{"version":3,"file":"mechanism.d.ts","sourceRoot":"","sources":["../../src/window/mechanism.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAW3D,wFAAwF;AACxF,eAAO,MAAM,eAAe,EAAE,mBA4C7B,CAAA"}

package/dist/window/mechanism.js

@@ -1,7 +1,27 @@
-import { closeWindowOpenState, getDisplayedWindowValue, isOperableWindowType, openWindowOpenState, } from '@pascal-app/editor';
+import { closeWindowOpenState, getDisplayedWindowShutterValue, getDisplayedWindowValue, isOperableWindowType, openWindowOpenState, setWindowShuttersOpenState, } from '@pascal-app/editor';
 import { scriptedOpening } from '../shared/scripted-opening.js';
 /** A window's sash: Open and Close preview it without touching the saved open state. */
 export const windowMechanism = {
+    parts: [
+        {
+            id: 'shutters',
+            label: 'Shutters',
+            icon: 'shutters',
+            verb: 'open',
+            has: (node) => node.type === 'window' &&
+                !node.source &&
+                ((Boolean(node.shutters) && node.shutters !== 'none') ||
+                    node.rollerShutter === 'box' ||
+                    node.rollerShutter === 'concealed'),
+            isOn: (node, state) => node.type === 'window' &&
+                ((Boolean(node.shutters) &&
+                    node.shutters !== 'none' &&
+                    getDisplayedWindowShutterValue(node.id, 'shutterOpen', node.shutterOpen, state) > 0) ||
+                    ((node.rollerShutter === 'box' || node.rollerShutter === 'concealed') &&
+                        getDisplayedWindowShutterValue(node.id, 'rollerShutterOpen', node.rollerShutterOpen, state) > 0)),
+            set: (node, on) => setWindowShuttersOpenState(node.id, on, { persist: false }),
+        },
+    ],
     verb: 'open',
     icon: 'window',
     has: (node) => node.type === 'window' &&

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EA0BL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAsEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAi5ClD,CAAA;eAEc,cAAc"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EA6BL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAuEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAw5ClD,CAAA;eAEc,cAAc"}

package/dist/window/move-tool.js

@@ -1,11 +1,12 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { beginSceneHistoryDraft, collectionIdsOf, createSnapEaser, dormerWallFacePointToDormer, emitter, evaluateCorner, getOpeningWallPlacement, holdHiddenWallPointerEvents, isCurvedWall, prefersReducedMotion, runSceneHistoryDraftWrite, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, WindowNode, } from '@pascal-app/core';
+import { beginSceneHistoryDraft, collectionIdsOf, createSnapEaser, dormerWallFacePointToDormer, emitter, evaluateCorner, getOpeningWallPlacement, getWallThickness, holdHiddenWallPointerEvents, isCurvedWall, prefersReducedMotion, resolveHostedOpeningFrameDepth, resolveOpeningFrameDepth, runSceneHistoryDraftWrite, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, WindowNode, } from '@pascal-app/core';
 import { calculateItemRotation, clearPlacementSurface, consumePlacementDragRelease, EDITOR_LAYER, getSideFromNormal, isGridSnapActive, isMagneticSnapActive, isTypingTarget, isValidWallSideFace, publishPlacementSurface, snapToHalf, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, useRegistryToolContext, } from '@pascal-app/editor';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { BoxGeometry, EdgesGeometry, Vector3 } from 'three';
 import { LineBasicNodeMaterial } from 'three/webgpu';
 import { commitOpeningMove } from '../shared/commit-opening-move.js';
 import { dormerEventFromHostedWindow, getDormerWindowWorldNormal, getDormerWindowWorldYaw, resolveDormerWindowTarget, } from '../shared/dormer-wall-opening-placement.js';
+import { movedOpeningCasingFaces } from '../shared/opening-casing-move.js';
 import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, resolveSillSnap, } from '../shared/opening-guides-runtime.js';
 import { beginOpeningMoveHistorySession } from '../shared/opening-move-history.js';
 import { isWallMeshHidden, shouldIgnoreWallEventForOpeningMove, } from '../shared/opening-move-wall-gate.js';
@@ -113,6 +114,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         }
         // Same-wall moves keep the wall-local plane offset; another host resets it.
         const planeOffsetOn = (wallId) => openingPlaneOffsetOnWall(movingWindowNode, wallId);
+        // Another host may name its faces the other way round: the casing keeps to its side of it.
+        const casingOn = (hostId, rotation) => movedOpeningCasingFaces(movingWindowNode, hostId, rotation, useScene.getState().nodes);
         let currentHostId = movingWindowNode.parentId;
         let committed = false;
         // Off-wall free-follow: over empty floor the window is parented to the
@@ -445,7 +448,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     ghostWorldPos[2],
                 ],
                 rotationY: ghostYaw,
-                depth: movingWindowNode.frameDepth ?? 0.07,
+                depth: resolveOpeningFrameDepth(movingWindowNode, getWallThickness(target.wallNode)),
             });
             // Publish the wall surface so the snap grid tilts into the wall plane at
             // the opening (its outward normal is the window's facing, +Z by `ghostYaw`).
@@ -537,6 +540,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     side: target.side,
                     wallId: target.wallId,
                     parentId: target.wallId,
+                    ...casingOn(target.wallId, [0, target.itemRotation, 0]),
                     roofSegmentId: undefined,
                     roofFace: undefined,
                     // Hidden during free-follow; the committed window must be visible.
@@ -575,6 +579,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         side: target.side,
                         parentId: target.wallId,
                         wallId: target.wallId,
+                        ...casingOn(target.wallId, [0, target.itemRotation, 0]),
                         roofSegmentId: undefined,
                         visible: true,
                     });
@@ -999,6 +1004,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     roofSegmentId: segmentId,
                     roofFace: target.face.id,
                     parentId: segmentId,
+                    ...casingOn(segmentId, [0, 0, 0]),
                     visible: true,
                 });
                 history.commitStep(() => {
@@ -1033,6 +1039,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         wallId: undefined,
                         roofSegmentId: segmentId,
                         roofFace: target.face.id,
+                        ...casingOn(segmentId, [0, 0, 0]),
                         visible: true,
                     });
                     settleMovedWindow(movingWindowNode.id, null);
@@ -1283,7 +1290,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         };
     }, [activeLevelId, exitMoveMode, isCameraDragging, movingWindowNode, selectNode]);
     const edgesGeo = useMemo(() => {
-        const boxGeo = new BoxGeometry(movingWindowNode.width, movingWindowNode.height, movingWindowNode.frameDepth ?? 0.07);
+        const boxGeo = new BoxGeometry(movingWindowNode.width, movingWindowNode.height, resolveHostedOpeningFrameDepth(movingWindowNode, useScene.getState().nodes));
         const geo = new EdgesGeometry(boxGeo);
         boxGeo.dispose();
         return geo;

package/dist/window/paint.d.ts

@@ -1,8 +1,3 @@
-/**
- * Window paint on the unified slot model. The window's opening proxy (a proud,
- * invisible cutout) wins the shared scene raycast over the wall in front of the
- * recessed window, so `resolveSlotByReRaycast` re-raycasts the window's own
- * subtree to find the part (frame / glass) under the cursor.
- */
-export declare const windowPaint: import("@pascal-app/core").PaintCapability;
+import { type PaintCapability } from '@pascal-app/core';
+export declare const windowPaint: PaintCapability;
 //# sourceMappingURL=paint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/window/paint.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,WAAW,4CAOtB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/window/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAA+C,MAAM,kBAAkB,CAAA;AAkCpG,eAAO,MAAM,WAAW,EAAE,eAezB,CAAA"}

package/dist/window/paint.js

@@ -1,14 +1,42 @@
-import { createSlotPaintCapability, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint.js';
+import { slotDefaultPaintMaterial, slotPaintMaterial } from '@pascal-app/core';
+import { openingCasingPaintLabel } from '../shared/opening-casing.js';
+import { createSlotPaintCapability, declaredSlotLook, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint.js';
 /**
  * Window paint on the unified slot model. The window's opening proxy (a proud,
  * invisible cutout) wins the shared scene raycast over the wall in front of the
  * recessed window, so `resolveSlotByReRaycast` re-raycasts the window's own
- * subtree to find the part (frame / glass) under the cursor.
+ * subtree to find the part (frame / glass / hardware / shutters) under the cursor.
  */
-export const windowPaint = createSlotPaintCapability({
+const base = createSlotPaintCapability({
     resolveRole: resolveSlotByReRaycast,
     applyPreview: previewSlotByUserData,
+    erasedLook: ({ node, role, materials = {} }) => {
+        if (role !== 'casing-a' && role !== 'casing-b' && role !== 'hardware' && role !== 'sill')
+            return declaredSlotLook(node, role);
+        if (node.type !== 'window' || node.source)
+            return null;
+        const frame = slotPaintMaterial(node.slots?.frame, materials) ?? slotDefaultPaintMaterial(node.slots?.frame);
+        if (frame)
+            return frame;
+        if (node.material)
+            return { material: node.material };
+        return declaredSlotLook(node, 'frame');
+    },
     legacyEffective: (node, role) => node.type === 'window' && !node.source && node.material && role === 'frame'
         ? { material: node.material, materialPreset: undefined }
         : null,
 });
+export const windowPaint = {
+    ...base,
+    roleLabel: (_node, role) => openingCasingPaintLabel(role),
+    getEffectiveMaterial: (args) => {
+        const own = base.getEffectiveMaterial?.(args);
+        if (own ||
+            (args.role !== 'casing-a' &&
+                args.role !== 'casing-b' &&
+                args.role !== 'hardware' &&
+                args.role !== 'sill'))
+            return own ?? null;
+        return base.getEffectiveMaterial?.({ ...args, role: 'frame' }) ?? null;
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AA0GA,MAAM,CAAC,OAAO,UAAU,WAAW,uCA68BlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AA+KA,MAAM,CAAC,OAAO,UAAU,WAAW,uCAm6ClC"}