@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/fence/floorplan.d.ts

@@ -1,4 +1,3 @@
-import { type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
-import type { FenceNode } from './schema';
-export declare function buildFenceFloorplan(node: FenceNode, ctx: GeometryContext): FloorplanGeometry;
+import { type FenceWithFeatures, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
+export declare function buildFenceFloorplan(node: FenceWithFeatures, ctx: GeometryContext): FloorplanGeometry;
 //# sourceMappingURL=floorplan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAQrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAiNzC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,CAyT5F"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAUrB,MAAM,kBAAkB,CAAA;AAkPzB,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,iBAAiB,EACvB,GAAG,EAAE,eAAe,GACnB,iBAAiB,CA8VnB"}

package/dist/fence/floorplan.js

@@ -1,4 +1,5 @@
-import { getFenceCenterlineFrameAt, getFenceCenterlineLength, getFenceControlHandle, getWallMidpointHandlePoint, isCurvedWall, isSplineFence, sampleFenceCenterline, } from '@pascal-app/core';
+import { fenceWithFeatures, getFenceCenterlineFrameAt, getFenceCenterlineLength, getFenceControlHandle, getFenceSpanMode, getWallMidpointHandlePoint, isCurvedWall, isSplineFence, resolveFenceFeatures, sampleFenceCenterline, } from '@pascal-app/core';
+import { buildFenceFeatureSymbol } from '../fence-feature/floorplan';
 /**
  * Stage C floor-plan builder for fence. 1:1 visual port of the legacy
  * `FloorplanFenceLayer` from `floorplan-panel.tsx`:
@@ -64,6 +65,36 @@ function buildCenterlinePathD(points) {
 }
 function buildMarker(fence, point, angleRadians, accentColor, surfaceColor, isActive) {
     const markerStrokeWidth = isActive ? 1.65 : 1.35;
+    if (fence.style === 'picket') {
+        const w = clamp(fence.postSize * 0.55, 0.035, 0.065);
+        const h = clamp(fence.baseHeight * 0.55, 0.08, 0.14);
+        return {
+            kind: 'group',
+            transform: { translate: [point.x, point.y], rotate: angleRadians },
+            children: [
+                {
+                    kind: 'rect',
+                    x: -(w + 0.026) / 2,
+                    y: -(h + 0.026) / 2,
+                    width: w + 0.026,
+                    height: h + 0.026,
+                    rx: 0.012,
+                    ry: 0.012,
+                    fill: surfaceColor,
+                },
+                {
+                    kind: 'rect',
+                    x: -w / 2,
+                    y: -h / 2,
+                    width: w,
+                    height: h,
+                    rx: 0.008,
+                    ry: 0.008,
+                    fill: accentColor,
+                },
+            ],
+        };
+    }
     if (fence.style === 'privacy' || fence.style === 'horizontal') {
         const w = clamp(fence.postSize * 0.58, 0.038, 0.068);
         const h = clamp(Math.max(fence.baseHeight * 0.5, fence.postSize * 1.4), 0.1, 0.17);
@@ -181,6 +212,8 @@ function buildMarker(fence, point, angleRadians, accentColor, surfaceColor, isAc
     };
 }
 export function buildFenceFloorplan(node, ctx) {
+    const drafts = node.features ?? [];
+    node = fenceWithFeatures(node, ctx.children);
     const view = ctx.viewState;
     const palette = view?.palette;
     const isSelected = view?.selected ?? false;
@@ -196,7 +229,22 @@ export function buildFenceFloorplan(node, ctx) {
             { x: node.start[0], y: node.start[1] },
             { x: node.end[0], y: node.end[1] },
         ];
-    const pathD = buildCenterlinePathD(centerlinePoints);
+    const features = resolveFenceFeatures(node);
+    const visibleRanges = [];
+    let rangeStart = 0;
+    for (const feature of features) {
+        if (feature.startT > rangeStart)
+            visibleRanges.push([rangeStart, feature.startT]);
+        rangeStart = feature.endT;
+    }
+    if (rangeStart < 1)
+        visibleRanges.push([rangeStart, 1]);
+    const strokePaths = features.length === 0
+        ? [centerlinePoints]
+        : visibleRanges.map(([start, end]) => {
+            const count = Math.max(2, Math.ceil(((end - start) * getFenceCenterlineLength(node)) / 0.2) + 1);
+            return Array.from({ length: count }, (_, index) => getFenceCenterlineFrameAt(node, start + ((end - start) * index) / (count - 1)).point);
+        });
     // Stroke shifts: selected wins; hover (not selected) → `wallHoverStroke`
     // (light blue from the legacy palette, same as walls); otherwise dark
     // accent. Mirrors the `fenceStroke` ternary in the legacy panel.
@@ -223,7 +271,7 @@ export function buildFenceFloorplan(node, ctx) {
     const glowOpacity = isActive ? 0.22 : isHovered ? 0.14 : 0;
     // Marker frames. Filter to first+last when infill is off so the user
     // still sees end posts (matches legacy).
-    const markerTs = getFloorplanFenceMarkerTs(node);
+    const markerTs = getFloorplanFenceMarkerTs(node).filter((t) => !features.some((feature) => t > feature.startT && t < feature.endT));
     const markerFrames = markerTs.map((t) => {
         const frame = getFenceCenterlineFrameAt(node, t);
         return {
@@ -239,41 +287,44 @@ export function buildFenceFloorplan(node, ctx) {
     // low-opacity ring. Width steps with the interaction level so hover
     // is subtler than active.
     if (glowOpacity > 0) {
+        for (const points of strokePaths)
+            children.push({
+                kind: 'path',
+                d: buildCenterlinePathD(points),
+                fill: 'none',
+                stroke: glowStroke,
+                strokeWidth: isActive ? 9.5 : isHovered ? 8.8 : 8.2,
+                strokeOpacity: glowOpacity,
+                strokeLinecap: 'round',
+                strokeLinejoin: 'round',
+                vectorEffect: 'non-scaling-stroke',
+            });
+    }
+    // 2. White underlay — visible fence body base layer.
+    for (const points of strokePaths)
         children.push({
             kind: 'path',
-            d: pathD,
+            d: buildCenterlinePathD(points),
             fill: 'none',
-            stroke: glowStroke,
-            strokeWidth: isActive ? 9.5 : isHovered ? 8.8 : 8.2,
-            strokeOpacity: glowOpacity,
+            stroke: underlayStroke,
+            strokeOpacity: 0.98,
+            strokeWidth: underlayWidth,
             strokeLinecap: 'round',
             strokeLinejoin: 'round',
             vectorEffect: 'non-scaling-stroke',
         });
-    }
-    // 2. White underlay — visible fence body base layer.
-    children.push({
-        kind: 'path',
-        d: pathD,
-        fill: 'none',
-        stroke: underlayStroke,
-        strokeOpacity: 0.98,
-        strokeWidth: underlayWidth,
-        strokeLinecap: 'round',
-        strokeLinejoin: 'round',
-        vectorEffect: 'non-scaling-stroke',
-    });
     // 3. Dark accent on top.
-    children.push({
-        kind: 'path',
-        d: pathD,
-        fill: 'none',
-        stroke: accentStroke,
-        strokeWidth: accentWidth,
-        strokeLinecap: 'round',
-        strokeLinejoin: 'round',
-        vectorEffect: 'non-scaling-stroke',
-    });
+    for (const points of strokePaths)
+        children.push({
+            kind: 'path',
+            d: buildCenterlinePathD(points),
+            fill: 'none',
+            stroke: accentStroke,
+            strokeWidth: accentWidth,
+            strokeLinecap: 'round',
+            strokeLinejoin: 'round',
+            vectorEffect: 'non-scaling-stroke',
+        });
     // 4. Style-aware markers. Pass `showInteractiveChrome` so hover also
     // bumps marker stroke widths slightly (legacy panel does the same).
     for (const marker of visibleMarkers) {
@@ -283,20 +334,21 @@ export function buildFenceFloorplan(node, ctx) {
     // chord-spanning line; a spline fence emits one short hit-line per sampled
     // span so the clickable region follows the curve instead of cutting the
     // chord (there's no curved `hit-path` primitive yet).
-    if (isSplineFence(node)) {
-        for (let i = 1; i < centerlinePoints.length; i += 1) {
-            const a = centerlinePoints[i - 1];
-            const b = centerlinePoints[i];
-            children.push({
-                kind: 'hit-line',
-                x1: a.x,
-                y1: a.y,
-                x2: b.x,
-                y2: b.y,
-                strokeWidthPx: 18,
-                cursor: 'pointer',
-            });
-        }
+    if (isSplineFence(node) || features.length > 0) {
+        for (const points of strokePaths)
+            for (let i = 1; i < points.length; i += 1) {
+                const a = points[i - 1];
+                const b = points[i];
+                children.push({
+                    kind: 'hit-line',
+                    x1: a.x,
+                    y1: a.y,
+                    x2: b.x,
+                    y2: b.y,
+                    strokeWidthPx: 18,
+                    cursor: 'pointer',
+                });
+            }
     }
     else {
         children.push({
@@ -328,38 +380,44 @@ export function buildFenceFloorplan(node, ctx) {
                 const armY = handle.y * TANGENT_HANDLE_ARM_SCALE;
                 const out = [point[0] + armX, point[1] + armY];
                 const inn = [point[0] - armX, point[1] - armY];
+                const showOut = i < node.path.length - 1 &&
+                    getFenceSpanMode(node.path, node.tangents, node.spanModes, i) === 'curve';
+                const showIn = i > 0 && getFenceSpanMode(node.path, node.tangents, node.spanModes, i - 1) === 'curve';
                 // Connecting line (the "tangent" through the point). Violet to match
                 // the 3D tangent line + the handle dots.
-                children.push({
-                    kind: 'line',
-                    x1: inn[0],
-                    y1: inn[1],
-                    x2: out[0],
-                    y2: out[1],
-                    stroke: '#8381ed',
-                    strokeWidth: 1.25,
-                    strokeOpacity: 0.85,
-                    vectorEffect: 'non-scaling-stroke',
-                });
+                if (showOut || showIn)
+                    children.push({
+                        kind: 'line',
+                        x1: showIn ? inn[0] : point[0],
+                        y1: showIn ? inn[1] : point[1],
+                        x2: showOut ? out[0] : point[0],
+                        y2: showOut ? out[1] : point[1],
+                        stroke: '#8381ed',
+                        strokeWidth: 1.25,
+                        strokeOpacity: 0.85,
+                        vectorEffect: 'non-scaling-stroke',
+                    });
                 // Handle dot on each end. Both drive the same `move-tangent`
                 // affordance; `side` tells it which end is being dragged so the
                 // stored OUT vector gets the correct sign.
-                children.push({
-                    kind: 'endpoint-handle',
-                    point: out,
-                    state: 'idle',
-                    variant: 'curve',
-                    affordance: 'move-tangent',
-                    payload: { fenceId: node.id, index: i, side: 'out' },
-                });
-                children.push({
-                    kind: 'endpoint-handle',
-                    point: inn,
-                    state: 'idle',
-                    variant: 'curve',
-                    affordance: 'move-tangent',
-                    payload: { fenceId: node.id, index: i, side: 'in' },
-                });
+                if (showOut)
+                    children.push({
+                        kind: 'endpoint-handle',
+                        point: out,
+                        state: 'idle',
+                        variant: 'curve',
+                        affordance: 'move-tangent',
+                        payload: { fenceId: node.id, index: i, side: 'out' },
+                    });
+                if (showIn)
+                    children.push({
+                        kind: 'endpoint-handle',
+                        point: inn,
+                        state: 'idle',
+                        variant: 'curve',
+                        affordance: 'move-tangent',
+                        payload: { fenceId: node.id, index: i, side: 'in' },
+                    });
                 // The control-point dot last so it sits on top of the tangent line.
                 children.push({
                     kind: 'endpoint-handle',
@@ -462,5 +520,7 @@ export function buildFenceFloorplan(node, ctx) {
             });
         }
     }
+    for (const feature of drafts)
+        children.push(buildFenceFeatureSymbol(feature, node, ctx, false));
     return { kind: 'group', children };
 }

package/dist/fence/geometry-parts.d.ts

@@ -0,0 +1,50 @@
+import { type FenceFeatureData, type FenceNode, type FenceWithFeatures } from '@pascal-app/core';
+import * as THREE from 'three';
+type FencePart = {
+    geometry?: THREE.BufferGeometry;
+    position: [number, number, number];
+    rotationY?: number;
+    rotationZ?: number;
+    scale: [number, number, number];
+    shape?: 'box' | 'pyramid' | 'picket';
+    picketTop?: FenceNode['picketTop'];
+    startT?: number;
+    endT?: number;
+    heightOverride?: number;
+    curveBlock?: {
+        centerY: number;
+        height: number;
+        depth: number;
+        lateralOffset: number;
+    };
+    endpoint?: 'start' | 'end';
+};
+export type FenceGateLeafGeometry = {
+    geometry: THREE.BufferGeometry;
+    hinge: {
+        x: number;
+        z: number;
+    };
+    rotationY: number;
+    openRotationY: number;
+};
+export declare function getFenceFeatureDimensions(fence: FenceNode, feature: FenceFeatureData): {
+    bottom: number;
+    height: number;
+    postBottom: number;
+    postHeight: number;
+};
+export type FenceSlotId = 'posts' | 'infill' | 'base' | 'rail';
+export type FenceSlotParts = Record<FenceSlotId, FencePart[]>;
+export type FenceCornerNeighbors = Partial<Record<'start' | 'end', FenceNode>>;
+export declare function createFenceRailHeightSampler(fence: FenceNode, heightAt: (x: number, z: number) => number): (x: number, z: number) => number;
+/**
+ * Geometry split by paint slot — posts, infill, base, rail — each a separate
+ * merged BufferGeometry (empty ones included) so the fence renderer can give
+ * each its own material + `userData.slotId`. Slots match the panel's build
+ * options 1:1.
+ */
+export declare function generateFenceSlotGeometries(fence: FenceWithFeatures, heightAt?: (x: number, z: number) => number, mode?: 'all' | 'body' | 'features', omitEndpointPosts?: ReadonlySet<'start' | 'end'>, cornerNeighbors?: FenceCornerNeighbors, gateLeafGeometries?: FenceGateLeafGeometry[]): Record<FenceSlotId, THREE.BufferGeometry>;
+export declare function generateFenceGeometry(fence: FenceNode, heightAt?: (x: number, z: number) => number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+export {};
+//# sourceMappingURL=geometry-parts.d.ts.map

package/dist/fence/geometry-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-parts.d.ts","sourceRoot":"","sources":["../../src/fence/geometry-parts.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,iBAAiB,EAMvB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,KAAK,SAAS,GAAG;IACf,QAAQ,CAAC,EAAE,KAAK,CAAC,cAAc,CAAA;IAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAG/B,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAA;IACpC,SAAS,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAA;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,UAAU,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAA;IACtF,QAAQ,CAAC,EAAE,OAAO,GAAG,KAAK,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC/B,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAoUD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB;;;;;EAkCpF;AAmDD,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;AAE9D,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,WAAW,EAAE,SAAS,EAAE,CAAC,CAAA;AAE7D,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,GAAG,KAAK,EAAE,SAAS,CAAC,CAAC,CAAA;AA6vB9E,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,OAhB/B,MAAM,KAAK,MAAM,YAqB7B;AAyWD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,iBAAiB,EACxB,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,EAC3C,IAAI,GAAE,KAAK,GAAG,MAAM,GAAG,UAAkB,EACzC,iBAAiB,CAAC,EAAE,WAAW,CAAC,OAAO,GAAG,KAAK,CAAC,EAChD,eAAe,CAAC,EAAE,oBAAoB,EACtC,kBAAkB,CAAC,EAAE,qBAAqB,EAAE,GAC3C,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,cAAc,CAAC,CA4C3C;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,EAChB,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,oFAO5C"}