@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/fence/parametrics.js

@@ -1,17 +1,5 @@
-import { isSplineFence } from '@pascal-app/core';
-import { FenceCurveEditor, FenceLengthEditor } from './inspector-editors';
-/**
- * Inspector descriptor for fence. Mirrors the legacy `FencePanel`
- * layout 1:1:
- *  - **Style** (segmented controls): style, baseStyle, showInfill toggle.
- *  - **Dimensions**: Length (derived from start/end), Curve (sagitta
- *    with dynamic bounds), Height, Thickness.
- *  - **Structure**: Base Height, Top Rail, Post Spacing, Post Size,
- *    Post Cap + Slat Gap (horizontal-only), Ground Clear, Edge Inset.
- *
- * Length + Curve use the `custom` field kind because they don't map
- * to single number fields with static bounds — see `inspector-editors.tsx`.
- */
+import { clampFencePicketRailProjection, isSplineFence, } from '@pascal-app/core';
+import { FenceCurveEditor, FenceLengthEditor, FencePathEditor, FencePatternInfo, FencePicketRailProjectionEditor, FenceSurfaceEditor, } from './inspector-editors';
 export const fenceParametrics = {
     groups: [
         {
@@ -20,16 +8,139 @@ export const fenceParametrics = {
                 {
                     key: 'style',
                     kind: 'enum',
-                    options: ['slat', 'rail', 'privacy', 'horizontal'],
+                    options: ['slat', 'rail', 'privacy', 'horizontal', 'guard', 'picket'],
                     display: 'segmented',
                 },
+                {
+                    key: 'guardInfill',
+                    kind: 'enum',
+                    options: ['balusters', 'cable', 'boards'],
+                    display: 'segmented',
+                    visibleIf: (n) => n.style === 'guard',
+                },
+                { key: 'startPost', kind: 'boolean', default: true, visibleIf: (n) => n.style === 'guard' },
+                { key: 'endPost', kind: 'boolean', default: true, visibleIf: (n) => n.style === 'guard' },
+                { key: 'postThrough', kind: 'boolean', visibleIf: (n) => n.style === 'guard' },
                 {
                     key: 'baseStyle',
                     kind: 'enum',
-                    options: ['grounded', 'floating'],
+                    options: ['grounded', 'floating', 'raised'],
                     display: 'segmented',
                 },
                 { key: 'showInfill', kind: 'boolean' },
+                {
+                    key: 'infillPlacement',
+                    kind: 'enum',
+                    options: ['center', 'front', 'back'],
+                    visibleIf: (n) => n.showInfill,
+                },
+            ],
+        },
+        {
+            label: 'Surface',
+            fields: [
+                {
+                    key: 'surfaceMode',
+                    kind: 'custom',
+                    component: FenceSurfaceEditor,
+                    visibleIf: (n) => isSplineFence(n) || Math.abs(n.curveOffset ?? 0) > 1e-4,
+                },
+                {
+                    key: 'transitionMode',
+                    label: 'Height transitions',
+                    kind: 'enum',
+                    options: ['slope', 'step', 'break'],
+                    visibleIf: (n) => isSplineFence(n) || Math.abs(n.curveOffset ?? 0) > 1e-4,
+                },
+                {
+                    key: 'transitionWidth',
+                    label: 'Transition length',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.2,
+                    max: 1000,
+                    step: 0.05,
+                    visibleIf: (n) => (isSplineFence(n) || Math.abs(n.curveOffset ?? 0) > 1e-4) &&
+                        n.transitionMode === 'slope' &&
+                        n.surfaceMode !== 'level',
+                },
+                {
+                    key: 'supportOffset',
+                    label: 'Vertical offset',
+                    kind: 'number',
+                    unit: 'm',
+                    step: 0.01,
+                },
+            ],
+        },
+        {
+            label: 'Pattern distribution',
+            fields: [
+                {
+                    key: 'postSpacing',
+                    label: 'Post / infill spacing',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.05,
+                    max: 1000,
+                    step: 0.01,
+                },
+                {
+                    key: 'picketSpacing',
+                    label: 'Picket spacing',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.06,
+                    max: 1000,
+                    step: 0.01,
+                    visibleIf: (n) => n.style === 'picket',
+                },
+                {
+                    key: 'patternDistribution',
+                    label: 'Placement',
+                    kind: 'enum',
+                    options: ['automatic', 'fixed-spacing', 'fixed-count', 'maximum-spacing', 'equal-fit'],
+                },
+                {
+                    key: 'patternAlignment',
+                    label: 'Align from',
+                    kind: 'enum',
+                    options: ['start', 'center', 'end'],
+                    visibleIf: (n) => n.patternDistribution === 'fixed-spacing' && n.patternRemainder === 'leave',
+                },
+                {
+                    key: 'patternRemainder',
+                    label: 'Extra length',
+                    kind: 'enum',
+                    options: ['leave', 'spread'],
+                    visibleIf: (n) => n.patternDistribution === 'fixed-spacing',
+                },
+                {
+                    key: 'patternCount',
+                    label: 'Items per span',
+                    kind: 'number',
+                    min: 1,
+                    max: 500,
+                    step: 1,
+                    visibleIf: (n) => n.patternDistribution === 'fixed-count',
+                },
+                {
+                    key: 'patternInfo',
+                    kind: 'custom',
+                    component: FencePatternInfo,
+                    visibleIf: (n) => n.patternDistribution !== 'automatic',
+                },
+            ],
+        },
+        {
+            label: 'Curve points',
+            fields: [
+                {
+                    key: 'path',
+                    kind: 'custom',
+                    component: FencePathEditor,
+                    visibleIf: (n) => isSplineFence(n),
+                },
             ],
         },
         {
@@ -58,7 +169,50 @@ export const fenceParametrics = {
             fields: [
                 { key: 'baseHeight', kind: 'number', unit: 'm', min: 0.04, max: 1, step: 0.01 },
                 { key: 'topRailHeight', kind: 'number', unit: 'm', min: 0.01, max: 0.25, step: 0.005 },
-                { key: 'postSpacing', kind: 'number', unit: 'm', min: 0.05, max: 1000, step: 0.01 },
+                {
+                    key: 'picketTop',
+                    kind: 'enum',
+                    options: ['flat', 'pointed', 'rounded', 'dog-ear'],
+                    visibleIf: (n) => n.style === 'picket',
+                },
+                {
+                    key: 'picketWidth',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.02,
+                    max: 1000,
+                    step: 0.005,
+                    visibleIf: (n) => n.style === 'picket',
+                },
+                {
+                    key: 'picketRailCount',
+                    kind: 'number',
+                    min: 2,
+                    max: 3,
+                    step: 1,
+                    visibleIf: (n) => n.style === 'picket',
+                },
+                {
+                    key: 'picketProfile',
+                    kind: 'enum',
+                    options: ['level', 'arched', 'scalloped', 'alternating'],
+                    visibleIf: (n) => n.style === 'picket',
+                },
+                {
+                    key: 'picketVariation',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0,
+                    max: 1000,
+                    step: 0.01,
+                    visibleIf: (n) => n.style === 'picket' && n.picketProfile !== 'level',
+                },
+                {
+                    key: 'picketRailProjection',
+                    kind: 'custom',
+                    component: FencePicketRailProjectionEditor,
+                    visibleIf: (n) => n.style === 'picket',
+                },
                 { key: 'postSize', kind: 'number', unit: 'm', min: 0.01, max: 0.4, step: 0.005 },
                 {
                     // Dropdown (not segmented) so the inspector renders its "Post Cap"
@@ -67,7 +221,7 @@ export const fenceParametrics = {
                     key: 'postCap',
                     kind: 'enum',
                     options: ['none', 'flat', 'pyramid'],
-                    visibleIf: (n) => n.style === 'horizontal',
+                    visibleIf: (n) => n.style === 'horizontal' || n.style === 'guard' || n.style === 'picket',
                 },
                 {
                     key: 'slatGap',
@@ -79,8 +233,21 @@ export const fenceParametrics = {
                     visibleIf: (n) => n.style === 'horizontal',
                 },
                 { key: 'groundClearance', kind: 'number', unit: 'm', min: 0, max: 0.6, step: 0.005 },
+                {
+                    key: 'picketTopClearance',
+                    label: 'Top clearance',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0,
+                    max: 1000,
+                    step: 0.01,
+                    visibleIf: (n) => n.style === 'picket',
+                },
                 { key: 'edgeInset', kind: 'number', unit: 'm', min: 0.005, max: 0.25, step: 0.005 },
             ],
         },
     ],
+    derive: (next) => ({
+        picketRailProjection: clampFencePicketRailProjection(next.picketRailProjection, next.postSize),
+    }),
 };

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/fence/system.tsx"],"names":[],"mappings":"AAiCA,QAAA,MAAM,YAAY,YAgBjB,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/fence/system.tsx"],"names":[],"mappings":"AA+CA,QAAA,MAAM,YAAY,YAwHjB,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/fence/system.js

@@ -1,46 +1,156 @@
 'use client';
-import { useScene } from '@pascal-app/core';
-import { useEffect } from 'react';
+import { findLevelAncestorId, isFenceFeatureNode, nodeRegistry, sceneRegistry, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
 import { resolveFenceLiftElevationForNodes } from './lift';
-/**
- * Hosted-railing dependency tracker. A fence with `supportSlabId` renders at
- * its host slab's elevation, but a store update only dirties the node that
- * changed — editing the slab's elevation (or restoring a deleted host) would
- * leave the railing floating at the stale height. Watch each hosted fence's
- * resolved lift and dirty the fence when it moves; `GeometrySystem` rebuilds
- * through `def.geometry` as usual. (Deleting the host needs no help here:
- * `deleteNodesAction` strips `supportSlabId` and dirties the fence itself.)
- */
-function fenceLiftSignatures(nodes) {
-    const signatures = new Map();
+function followsSurfaces(fence) {
+    return (fence.path?.length ?? 0) >= 2 || Math.abs(fence.curveOffset ?? 0) > 1e-4;
+}
+function isSupport(node) {
+    return (node.type === 'slab' ||
+        (node.type !== 'fence' && !!nodeRegistry.get(node.type)?.capabilities.surfaces?.top));
+}
+function supportLevels(nodes) {
+    const levels = new Map();
     for (const node of Object.values(nodes)) {
-        if (node.type !== 'fence')
-            continue;
-        const fence = node;
-        // Unhosted fences are covered too, and by a different mechanism: their lift
-        // is the ground, which only a sculpt moves, and `markTerrainSupportDependents`
-        // dirties them from the terrain change itself. Tracking them here would
-        // resolve every fence in the scene on every store update to catch an event
-        // this subscription never sees.
-        if (!fence.supportSlabId)
+        if (!isSupport(node))
             continue;
-        signatures.set(fence.id, resolveFenceLiftElevationForNodes(fence, nodes));
+        const level = findLevelAncestorId(node.id, nodes);
+        if (level)
+            levels.set(node.id, level);
     }
-    return signatures;
+    return levels;
+}
+function markFenceAndChildren(id) {
+    const state = useScene.getState();
+    state.markDirty(id);
+    const node = state.nodes[id];
+    if (node?.type === 'fence')
+        for (const childId of node.children ?? [])
+            state.markDirty(childId);
 }
 const FenceSystems = () => {
+    const outputs = useRef(new Map());
+    const levels = useRef(supportLevels(useScene.getState().nodes));
     useEffect(() => {
-        let previous = fenceLiftSignatures(useScene.getState().nodes);
-        return useScene.subscribe((state) => {
-            const current = fenceLiftSignatures(state.nodes);
-            for (const [fenceId, lift] of current.entries()) {
-                if (previous.get(fenceId) !== lift) {
-                    state.markDirty(fenceId);
+        let previousNodes = useScene.getState().nodes;
+        const unsubscribe = useScene.subscribe((state) => {
+            if (state.nodes === previousNodes)
+                return;
+            const currentNodes = state.nodes;
+            const previousLevels = levels.current;
+            const currentLevels = supportLevels(currentNodes);
+            const changedLevels = new Set();
+            for (const id of new Set([...previousLevels.keys(), ...currentLevels.keys()])) {
+                if (previousNodes[id] === currentNodes[id] &&
+                    previousLevels.get(id) === currentLevels.get(id))
+                    continue;
+                const oldLevel = previousLevels.get(id);
+                const newLevel = currentLevels.get(id);
+                if (oldLevel)
+                    changedLevels.add(oldLevel);
+                if (newLevel)
+                    changedLevels.add(newLevel);
+            }
+            for (const id of new Set([...Object.keys(previousNodes), ...Object.keys(currentNodes)])) {
+                const before = previousNodes[id];
+                const after = currentNodes[id];
+                if (before === after)
+                    continue;
+                if (after?.type === 'fence')
+                    markFenceAndChildren(after.id);
+                if (before?.type === 'fence' || after?.type === 'fence') {
+                    for (const neighbor of Object.values(currentNodes)) {
+                        if (neighbor.type !== 'fence' || neighbor.id === id)
+                            continue;
+                        for (const changed of [before, after]) {
+                            if (changed?.type !== 'fence' || changed.parentId !== neighbor.parentId)
+                                continue;
+                            if ([changed.start, changed.end].some((point) => [neighbor.start, neighbor.end].some((other) => Math.hypot(point[0] - other[0], point[1] - other[1]) < 0.001))) {
+                                markFenceAndChildren(neighbor.id);
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (isFenceFeatureNode(before) && before.parentId)
+                    markFenceAndChildren(before.parentId);
+                if (isFenceFeatureNode(after) && after.parentId)
+                    markFenceAndChildren(after.parentId);
+            }
+            levels.current = currentLevels;
+            for (const node of Object.values(currentNodes)) {
+                if (node.type !== 'fence')
+                    continue;
+                const fence = node;
+                if (followsSurfaces(fence)) {
+                    const level = findLevelAncestorId(fence.id, currentNodes);
+                    if (level && changedLevels.has(level))
+                        markFenceAndChildren(fence.id);
+                }
+                else if (fence.supportSlabId || fence.supportSurfaceNodeId) {
+                    const previous = previousNodes[fence.id];
+                    if (previous?.supportSurfaceNodeId !== fence.supportSurfaceNodeId ||
+                        (fence.supportSurfaceNodeId &&
+                            previousNodes[fence.supportSurfaceNodeId] !==
+                                currentNodes[fence.supportSurfaceNodeId]) ||
+                        resolveFenceLiftElevationForNodes(fence, currentNodes) !==
+                            resolveFenceLiftElevationForNodes(fence, previousNodes))
+                        markFenceAndChildren(fence.id);
+                }
+            }
+            previousNodes = currentNodes;
+        });
+        const unsubscribeLive = useLiveNodeOverrides.subscribe((state, previous) => {
+            for (const id of new Set([...state.overrides.keys(), ...previous.overrides.keys()])) {
+                if (state.overrides.get(id) === previous.overrides.get(id))
+                    continue;
+                const node = useScene.getState().nodes[id];
+                if (node?.type === 'fence')
+                    markFenceAndChildren(node.id);
+                if (isFenceFeatureNode(node) && node.parentId) {
+                    const before = previous.overrides.get(id) ?? {};
+                    const after = state.overrides.get(id) ?? {};
+                    const changedFields = new Set([...Object.keys(before), ...Object.keys(after)]);
+                    const onlyGateAngle = node.type === 'fence-gate' &&
+                        [...changedFields].every((key) => key === 'openAngle' || before[key] === after[key]);
+                    // Swinging a leaf does not change the opening cut or its sibling gates.
+                    if (!onlyGateAngle)
+                        markFenceAndChildren(node.parentId);
                 }
             }
-            previous = current;
         });
+        return () => {
+            unsubscribeLive();
+            unsubscribe();
+            outputs.current.clear();
+        };
     }, []);
+    useFrame(() => {
+        const nodes = useScene.getState().nodes;
+        const changedLevels = new Set();
+        for (const [id, level] of levels.current) {
+            const root = sceneRegistry.nodes.get(id);
+            const output = root?.children.find((child) => child.userData.__fromGeometry) ?? null;
+            if (outputs.current.get(id) !== output) {
+                outputs.current.set(id, output);
+                changedLevels.add(level);
+            }
+        }
+        for (const id of outputs.current.keys()) {
+            if (!levels.current.has(id))
+                outputs.current.delete(id);
+        }
+        if (changedLevels.size === 0)
+            return;
+        for (const node of Object.values(nodes)) {
+            if (node.type !== 'fence' || !followsSurfaces(node))
+                continue;
+            const level = findLevelAncestorId(node.id, nodes);
+            if (level && changedLevels.has(level))
+                markFenceAndChildren(node.id);
+        }
+    }, 3);
     return null;
 };
 export default FenceSystems;

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/fence/tool.tsx"],"names":[],"mappings":"AA8bA,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAM7B,CAAA;AA8gBD,eAAe,SAAS,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/fence/tool.tsx"],"names":[],"mappings":"AAkeA,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAS7B,CAAA;AA6vBD,eAAe,SAAS,CAAA"}