@pascal-app/nodes 1.0.1 → 1.0.4

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/fence-feature/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AACzB,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,gBAAgB,EACvB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAI1B;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,SAAS,EACf,GAAG,EAAE,eAAe,EACpB,WAAW,UAAO,GACjB,iBAAiB,CAiHnB"}

package/dist/fence-feature/floorplan.js

@@ -0,0 +1,120 @@
+import { fenceFeatureData, getFenceCenterlineFrameAt, getFenceCenterlineLength, getFenceGateLeaves, } from '@pascal-app/core';
+export function buildFenceFeatureFloorplan(child, ctx) {
+    const node = ctx.parent;
+    if (node?.type !== 'fence')
+        return null;
+    return buildFenceFeatureSymbol(fenceFeatureData(child), node, ctx);
+}
+export function buildFenceFeatureSymbol(data, node, ctx, interactive = true) {
+    const length = Math.max(getFenceCenterlineLength(node), 0.001);
+    const feature = {
+        ...data,
+        startT: (data.center - data.width / 2) / length,
+        endT: (data.center + data.width / 2) / length,
+        centerT: data.center / length,
+    };
+    const features = [feature];
+    const isSelected = interactive && (ctx.viewState?.selected ?? false);
+    const accentStroke = isSelected
+        ? (ctx.viewState?.palette?.selectedStroke ?? '#8381ed')
+        : ctx.viewState?.hovered
+            ? '#8381ed'
+            : '#111827';
+    const markerSurface = '#ffffff';
+    const children = [];
+    for (const feature of features) {
+        const start = getFenceCenterlineFrameAt(node, feature.startT).point;
+        const end = getFenceCenterlineFrameAt(node, feature.endT).point;
+        if (feature.showPosts !== false)
+            for (const point of [start, end]) {
+                children.push({
+                    kind: 'circle',
+                    cx: point.x,
+                    cy: point.y,
+                    r: Math.max(node.postSize / 2, 0.04),
+                    fill: markerSurface,
+                    stroke: accentStroke,
+                    strokeWidth: 1.5,
+                    vectorEffect: 'non-scaling-stroke',
+                });
+            }
+        if (feature.kind === 'gate') {
+            for (const leaf of getFenceGateLeaves(node, feature)) {
+                children.push({
+                    kind: 'line',
+                    x1: leaf.hinge.x,
+                    y1: leaf.hinge.y,
+                    x2: leaf.end.x,
+                    y2: leaf.end.y,
+                    stroke: accentStroke,
+                    strokeWidth: 3,
+                    vectorEffect: 'non-scaling-stroke',
+                });
+                children.push({
+                    kind: 'hit-line',
+                    x1: leaf.hinge.x,
+                    y1: leaf.hinge.y,
+                    x2: leaf.end.x,
+                    y2: leaf.end.y,
+                    strokeWidthPx: 16,
+                    cursor: 'pointer',
+                });
+                const angle = leaf.rotation - leaf.closedAngle;
+                if (Math.abs(angle) > 0.001) {
+                    const x = leaf.hinge.x + Math.cos(leaf.closedAngle) * leaf.width;
+                    const y = leaf.hinge.y + Math.sin(leaf.closedAngle) * leaf.width;
+                    children.push({
+                        kind: 'path',
+                        d: `M ${x} ${y} A ${leaf.width} ${leaf.width} 0 0 ${angle > 0 ? 1 : 0} ${leaf.end.x} ${leaf.end.y}`,
+                        fill: 'none',
+                        stroke: accentStroke,
+                        strokeWidth: 1,
+                        strokeDasharray: '4 3',
+                        vectorEffect: 'non-scaling-stroke',
+                    });
+                }
+            }
+        }
+        if (isSelected) {
+            for (const [edge, point] of [
+                ['start', start],
+                ['center', getFenceCenterlineFrameAt(node, feature.centerT).point],
+                ['end', end],
+            ]) {
+                children.push({
+                    kind: 'endpoint-handle',
+                    point: [point.x, point.y],
+                    state: 'idle',
+                    variant: 'curve',
+                    affordance: 'move-feature',
+                    payload: { edge },
+                });
+            }
+        }
+    }
+    if (data.kind === 'opening') {
+        const a = getFenceCenterlineFrameAt(node, feature.startT).point;
+        const b = getFenceCenterlineFrameAt(node, feature.endT).point;
+        children.push({
+            kind: 'line',
+            x1: a.x,
+            y1: a.y,
+            x2: b.x,
+            y2: b.y,
+            stroke: accentStroke,
+            strokeWidth: 1.5,
+            strokeDasharray: '4 3',
+            vectorEffect: 'non-scaling-stroke',
+        });
+        children.push({
+            kind: 'hit-line',
+            x1: a.x,
+            y1: a.y,
+            x2: b.x,
+            y2: b.y,
+            strokeWidthPx: 18,
+            cursor: 'pointer',
+        });
+    }
+    return { kind: 'group', children };
+}

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

@@ -0,0 +1,5 @@
+import { type FenceFeatureNode, type GeometryContext } from '@pascal-app/core';
+import type { ColorPreset, RenderShading } from '@pascal-app/viewer';
+import { Group } from 'three';
+export declare function buildFenceFeatureGeometry(node: FenceFeatureNode, ctx?: GeometryContext, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): Group;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/fence-feature/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EAErB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACpE,OAAO,EAA2B,KAAK,EAA2B,MAAM,OAAO,CAAA;AAI/E,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,gBAAgB,EACtB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CA4DP"}

package/dist/fence-feature/geometry.js

@@ -0,0 +1,43 @@
+import { fenceFeatureData, getFenceCenterlineFrameAt, getFenceCenterlineLength, getFenceGateLeaves, } from '@pascal-app/core';
+import { BoxGeometry, DoubleSide, Group, Mesh, MeshBasicMaterial } from 'three';
+import { buildFenceGeometry } from '../fence/geometry';
+import { getFenceFeatureDimensions } from '../fence/geometry-parts';
+export function buildFenceFeatureGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+    const host = ctx?.parent;
+    if (host?.type !== 'fence')
+        return new Group();
+    const group = buildFenceGeometry({ ...host, features: [fenceFeatureData(node)] }, ctx, shading, textures, colorPreset, sceneTheme, 'features');
+    const length = Math.max(getFenceCenterlineLength(host), 0.001);
+    const feature = {
+        ...fenceFeatureData(node),
+        startT: (node.center - node.width / 2) / length,
+        endT: (node.center + node.width / 2) / length,
+        centerT: node.center / length,
+    };
+    const a = getFenceCenterlineFrameAt(host, feature.startT).point;
+    const b = getFenceCenterlineFrameAt(host, feature.endT).point;
+    const followsSurface = (host.path?.length ?? 0) >= 2 || Math.abs(host.curveOffset ?? 0) > 1e-4;
+    const selectedHost = host.surfaceMode === 'selected'
+        ? (host.supportSurfaceNodeId ?? host.supportSlabId)
+        : undefined;
+    const relativeHeight = (x, z) => followsSurface && host.surfaceMode !== 'level'
+        ? (ctx?.supportHeightAt?.(x, z, selectedHost) ?? 0) -
+            (ctx?.supportHeightAt?.(...host.start, selectedHost) ?? 0)
+        : 0;
+    const support = Math.max(relativeHeight(a.x, a.y), relativeHeight(b.x, b.y));
+    const dimensions = getFenceFeatureDimensions(host, fenceFeatureData(node));
+    const bottom = Math.min(dimensions.bottom, dimensions.postBottom);
+    const height = Math.max(dimensions.bottom + dimensions.height, dimensions.postBottom + dimensions.postHeight) -
+        bottom;
+    const spans = node.type === 'fence-gate'
+        ? getFenceGateLeaves(host, feature).map((leaf) => ({ a: leaf.hinge, b: leaf.end }))
+        : [{ a, b }];
+    for (const span of spans) {
+        const pick = new Mesh(new BoxGeometry(Math.hypot(span.b.x - span.a.x, span.b.y - span.a.y), height, Math.max(host.thickness, 0.12)), new MeshBasicMaterial({ visible: false, side: DoubleSide }));
+        pick.position.set((span.a.x + span.b.x) / 2, support + bottom + height / 2, (span.a.y + span.b.y) / 2);
+        pick.rotation.y = -Math.atan2(span.b.y - span.a.y, span.b.x - span.a.x);
+        pick.userData.pascalExport = 'strip';
+        group.children[0]?.add(pick);
+    }
+    return group;
+}

package/dist/fence-feature/handles.d.ts

@@ -0,0 +1,5 @@
+import { type FenceFeatureNode, type FenceNode, type HandleDescriptor, type SceneApi } from '@pascal-app/core';
+export declare function featureHost(node: FenceFeatureNode, scene: SceneApi): FenceNode | undefined;
+export declare function featurePatch(node: FenceFeatureNode, patch: Partial<FenceFeatureNode>, scene: SceneApi): Partial<FenceFeatureNode>;
+export declare function fenceFeatureHandles(node: FenceFeatureNode, scene?: SceneApi): HandleDescriptor<FenceFeatureNode>[];
+//# sourceMappingURL=handles.d.ts.map

package/dist/fence-feature/handles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handles.d.ts","sourceRoot":"","sources":["../../src/fence-feature/handles.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,SAAS,EAKd,KAAK,gBAAgB,EAErB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAIzB,wBAAgB,WAAW,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,CAG1F;AACD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,gBAAgB,EACtB,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAChC,KAAK,EAAE,QAAQ,GACd,OAAO,CAAC,gBAAgB,CAAC,CAY3B;AACD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,gBAAgB,EACtB,KAAK,CAAC,EAAE,QAAQ,GACf,gBAAgB,CAAC,gBAAgB,CAAC,EAAE,CAiEtC"}

package/dist/fence-feature/handles.js

@@ -0,0 +1,84 @@
+import { canPlaceFenceFeature, fenceFeatureData, fenceWithFeatures, getFenceCenterlineFrameAt, getFenceCenterlineLength, projectPointToFence, } from '@pascal-app/core';
+import { fenceBaseElevation } from '../fence/definition';
+import { getFenceFeatureDimensions } from '../fence/geometry-parts';
+export function featureHost(node, scene) {
+    const parent = node.parentId ? scene.get(node.parentId) : undefined;
+    return parent?.type === 'fence' ? parent : undefined;
+}
+export function featurePatch(node, patch, scene) {
+    const host = featureHost(node, scene);
+    if (!host)
+        return {};
+    const fence = fenceWithFeatures(host, (host.children ?? [])
+        .map((id) => scene.get(id))
+        .filter((n) => !!n));
+    return canPlaceFenceFeature(fence, fenceFeatureData({ ...node, ...patch }))
+        ? patch
+        : {};
+}
+export function fenceFeatureHandles(node, scene) {
+    if (!scene)
+        return [];
+    const host = featureHost(node, scene);
+    if (!host)
+        return [];
+    const frame = (n) => getFenceCenterlineFrameAt(host, n.center / Math.max(getFenceCenterlineLength(host), 0.001));
+    const dimensions = (n) => getFenceFeatureDimensions(host, fenceFeatureData(n));
+    const height = (n) => dimensions(n).height;
+    const base = (n) => {
+        const p = frame(n).point;
+        return fenceBaseElevation(host, scene, [p.x, p.y]);
+    };
+    const handles = [
+        {
+            kind: 'translate',
+            placement: {
+                position: (n) => {
+                    const p = frame(n).point;
+                    return [p.x, base(n) + height(n) / 2, p.y];
+                },
+            },
+            apply: (n, point, api) => featurePatch(n, { center: projectPointToFence(host, [point[0], point[2]]).center }, api),
+        },
+        {
+            kind: 'linear-resize',
+            axis: 'x',
+            dragAxis: (n) => {
+                const tangent = frame(n).tangent;
+                return [tangent.x, 0, tangent.y];
+            },
+            anchor: 'center',
+            min: 0.35,
+            currentValue: (n) => n.width,
+            apply: (n, width, api) => featurePatch(n, { width }, api),
+            placement: {
+                position: (n) => {
+                    const f = frame(n);
+                    const d = n.width / 2 + 0.2;
+                    return [f.point.x + f.tangent.x * d, base(n) + 0.5, f.point.y + f.tangent.y * d];
+                },
+                rotationY: (n) => -Math.atan2(frame(n).tangent.y, frame(n).tangent.x),
+            },
+        },
+    ];
+    handles.push({
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: 0.3,
+        max: 6,
+        currentValue: height,
+        apply: (n, value) => ({
+            height: value,
+            matchFenceHeight: false,
+            ...(n.type === 'fence-gate' ? { clearance: dimensions(n).bottom } : {}),
+        }),
+        placement: {
+            position: (n) => {
+                const p = frame(n).point;
+                return [p.x, base(n) + height(n) + dimensions(n).bottom + 0.35, p.y];
+            },
+        },
+    });
+    return handles;
+}

package/dist/fence-feature/inspector.d.ts

@@ -0,0 +1,6 @@
+import { type FenceFeatureNode } from '@pascal-app/core';
+export declare function FenceFeatureEditor({ node: child, onUpdate, }: {
+    node: FenceFeatureNode;
+    onUpdate: (patch: Partial<FenceFeatureNode>) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=inspector.d.ts.map

package/dist/fence-feature/inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspector.d.ts","sourceRoot":"","sources":["../../src/fence-feature/inspector.tsx"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,gBAAgB,EAMtB,MAAM,kBAAkB,CAAA;AAMzB,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EAAE,KAAK,EACX,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,gBAAgB,CAAA;IACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAA;CACrD,+BAkTA"}

package/dist/fence-feature/inspector.js

@@ -0,0 +1,214 @@
+'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 { ActionButton, SliderControl, ToggleControl } from '@pascal-app/editor';
+import { useState } from 'react';
+import { useShallow } from 'zustand/react/shallow';
+import { getFenceFeatureDimensions } from '../fence/geometry-parts';
+export function FenceFeatureEditor({ node: child, onUpdate, }) {
+    const [error, setError] = useState('');
+    const parentId = child.parentId;
+    const parent = useScene((s) => (parentId ? s.nodes[parentId] : undefined));
+    const siblings = useScene(useShallow((s) => {
+        const fence = parentId ? s.nodes[parentId] : undefined;
+        return fence?.type === 'fence'
+            ? (fence.children ?? []).map((id) => s.nodes[id]).filter(Boolean)
+            : [];
+    }));
+    if (parent?.type !== 'fence')
+        return _jsx("p", { children: "Fence unavailable." });
+    const node = fenceWithFeatures(parent, siblings);
+    const features = [fenceFeatureData(child)];
+    const length = getFenceCenterlineLength(node);
+    const update = (id, patch) => {
+        const original = features.find((feature) => feature.id === id);
+        if (!original)
+            return;
+        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.');
+            return;
+        }
+        setError('');
+        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) => {
+                const gate = feature.kind === 'gate';
+                const { height, bottom } = getFenceFeatureDimensions(node, feature);
+                const selects = [
+                    ...(gate
+                        ? [
+                            {
+                                key: 'leafType',
+                                label: 'Leaves',
+                                value: feature.leafType ?? 'single',
+                                options: [
+                                    ['single', 'Single gate'],
+                                    ['double', 'Double gate'],
+                                ],
+                            },
+                            {
+                                key: 'hinge',
+                                label: 'Hinge side',
+                                value: feature.hinge ?? 'left',
+                                options: [
+                                    ['left', 'Left'],
+                                    ['right', 'Right'],
+                                ],
+                            },
+                            {
+                                key: 'swing',
+                                label: 'Swing direction',
+                                value: feature.swing ?? 'inward',
+                                options: [
+                                    ['inward', 'Inward'],
+                                    ['outward', 'Outward'],
+                                ],
+                            },
+                            {
+                                key: 'brace',
+                                label: 'Bracing',
+                                value: feature.brace ?? 'none',
+                                options: [
+                                    ['none', 'None'],
+                                    ['diagonal', 'Diagonal'],
+                                    ['cross', 'Cross'],
+                                ],
+                            },
+                        ]
+                        : []),
+                ];
+                const numbers = [
+                    {
+                        key: 'center',
+                        label: 'Distance from start',
+                        value: feature.center,
+                        min: 0,
+                        max: length,
+                        step: 0.05,
+                        unit: 'm',
+                    },
+                    {
+                        key: 'width',
+                        label: 'Opening width',
+                        value: feature.width,
+                        min: 0.35,
+                        max: length,
+                        step: 0.05,
+                        unit: 'm',
+                    },
+                    {
+                        key: 'height',
+                        label: gate ? 'Gate height' : 'Post height',
+                        value: height,
+                        min: 0.3,
+                        max: 1000,
+                        step: 0.05,
+                        unit: 'm',
+                    },
+                    ...(gate
+                        ? [
+                            {
+                                key: 'clearance',
+                                label: 'Ground clearance',
+                                value: bottom,
+                                min: 0,
+                                max: 1000,
+                                step: 0.01,
+                                unit: 'm',
+                            },
+                            {
+                                key: 'openAngle',
+                                label: 'Opening angle',
+                                value: feature.openAngle ?? 0,
+                                min: 0,
+                                max: 170,
+                                step: 1,
+                                unit: '°',
+                            },
+                            {
+                                key: 'thickness',
+                                label: 'Leaf thickness',
+                                value: feature.thickness ?? 0.06,
+                                min: 0.02,
+                                max: 0.3,
+                                step: 0.005,
+                                unit: 'm',
+                            },
+                            {
+                                key: 'frameWidth',
+                                label: 'Frame width',
+                                value: feature.frameWidth ?? 0.055,
+                                min: 0.025,
+                                max: 0.2,
+                                step: 0.005,
+                                unit: 'm',
+                            },
+                            {
+                                key: 'spacing',
+                                label: 'Infill spacing',
+                                value: feature.spacing ?? 0.15,
+                                min: 0.04,
+                                max: 1000,
+                                step: 0.01,
+                                unit: 'm',
+                            },
+                            {
+                                key: 'boardWidth',
+                                label: 'Board width',
+                                value: feature.boardWidth ?? 0.055,
+                                min: 0.02,
+                                max: 0.3,
+                                step: 0.005,
+                                unit: 'm',
+                            },
+                            ...(feature.leafType === 'double'
+                                ? [
+                                    {
+                                        key: 'leafSplit',
+                                        label: 'Left leaf proportion',
+                                        value: feature.leafSplit ?? 0.5,
+                                        min: 0.2,
+                                        max: 0.8,
+                                        step: 0.05,
+                                        unit: '',
+                                    },
+                                ]
+                                : []),
+                        ]
+                        : []),
+                ];
+                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, {
+                                    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, {
+                                    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-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors 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
+                                .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-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors 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 ||
+                                !['thickness', 'frameWidth', 'spacing', 'boardWidth'].includes(field.key))
+                                .map((field) => (_jsx(SliderControl, { label: field.label, value: field.value, min: field.min, max: field.max, step: field.step, precision: field.key === 'openAngle' ? 0 : 3, unit: field.unit, onChange: (value) => update(feature.id, {
+                                    [field.key]: value,
+                                    ...(['height', 'clearance'].includes(field.key)
+                                        ? {
+                                            matchFenceHeight: false,
+                                            ...(field.key === 'clearance'
+                                                ? { height }
+                                                : gate
+                                                    ? { clearance: bottom }
+                                                    : {}),
+                                        }
+                                        : {}),
+                                }) }, 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));
+            })] }));
+}

package/dist/fence-feature/interaction.d.ts

@@ -0,0 +1,3 @@
+import { type AnyNodeId } from '@pascal-app/core';
+export declare function toggleFenceGate(nodeId: AnyNodeId): void;
+//# sourceMappingURL=interaction.d.ts.map

package/dist/fence-feature/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../src/fence-feature/interaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAkC,MAAM,kBAAkB,CAAA;AAKjF,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,QA0ChD"}

package/dist/fence-feature/interaction.js

@@ -0,0 +1,41 @@
+import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
+const animations = new Map();
+export function toggleFenceGate(nodeId) {
+    const node = useScene.getState().nodes[nodeId];
+    if (node?.type !== 'fence-gate')
+        return;
+    const previous = animations.get(nodeId);
+    if (previous)
+        window.cancelAnimationFrame(previous.frame);
+    const overrides = useLiveNodeOverrides.getState();
+    const liveAngle = overrides.get(nodeId)?.openAngle;
+    const from = typeof liveAngle === 'number' ? liveAngle : (node.openAngle ?? 0);
+    const target = previous ? (previous.target === 0 ? 90 : 0) : from > 0.01 ? 0 : 90;
+    const startedAt = window.performance.now();
+    const duration = 520 * Math.max(0.15, Math.abs(target - from) / 90);
+    const animation = { frame: 0, target };
+    const step = (time) => {
+        const current = useScene.getState().nodes[nodeId];
+        // Deletion, scene replacement, or an inspector edit invalidates this animation.
+        if (current !== node) {
+            animations.delete(nodeId);
+            useLiveNodeOverrides.getState().clearFields(nodeId, ['openAngle']);
+            return;
+        }
+        const progress = Math.min(1, Math.max(0, (time - startedAt) / duration));
+        const eased = progress * progress * (3 - 2 * progress);
+        if (progress < 1) {
+            // Live poses keep intermediate frames out of undo history.
+            useLiveNodeOverrides.getState().set(nodeId, {
+                openAngle: from + (target - from) * eased,
+            });
+            animation.frame = window.requestAnimationFrame(step);
+            return;
+        }
+        animations.delete(nodeId);
+        useScene.getState().updateNode(nodeId, { openAngle: target });
+        useLiveNodeOverrides.getState().clearFields(nodeId, ['openAngle']);
+    };
+    animations.set(nodeId, animation);
+    animation.frame = window.requestAnimationFrame(step);
+}

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

@@ -0,0 +1,9 @@
+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: (`roof_${string}` | `rseg_${string}` | `site_${string}` | `building_${string}` | `level_${string}` | `elevator_${string}` | `unit_${string}` | `zone_${string}` | `block_${string}` | `ceiling_${string}` | `item_${string}` | `procedural-item_${string}` | `column_${string}` | `construction-dimension_${string}` | `wall_${string}` | `slab_${string}` | `separator_${string}` | `floor-opening_${string}` | `fence_${string}` | `structural-grid_${string}` | `imesh_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}` | `leanto_${string}` | `door_${string}` | `window_${string}` | `fence-gate_${string}` | `fence-opening_${string}` | `cabinet_${string}` | `cabinet-module_${string}` | `sseg_${string}` | `bvent_${string}` | `rvent_${string}` | `tvent_${string}` | `cupola_${string}` | `eyebrow-vent_${string}` | `gutter_${string}` | `chimney_${string}` | `solarpanel_${string}` | `skylight_${string}` | `dormer_${string}` | `downspout_${string}`)[];
+    clear: () => void;
+    update(point: readonly [number, number], host?: FenceNode, ray?: GridEvent["localRay"]): void;
+    canCommit: () => boolean;
+    commit(): void;
+};
+//# sourceMappingURL=move-session.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"move-session.d.ts","sourceRoot":"","sources":["../../src/fence-feature/move-session.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,gBAAgB,EACrB,KAAK,SAAS,EAGd,KAAK,SAAS,EACd,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAGzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,gBAAgB,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,SAAS,GAAG,IAAI,EACzB,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI;;;kBAenB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,SAAS,SAAS,QAAQ,SAAS,CAAC,UAAU,CAAC;;;EA6BzF"}

package/dist/fence-feature/move-session.js

@@ -0,0 +1,48 @@
+import { canPlaceFenceFeature, fenceFeatureData, fenceWithFeatures, useLiveNodeOverrides, } from '@pascal-app/core';
+import { pickFenceTarget } from './pick-target';
+export function createFenceFeatureMoveSession(node, sceneApi, levelId, selectNode) {
+    const affectedIds = [node.id];
+    if (node.parentId)
+        affectedIds.push(node.parentId);
+    let target = null;
+    const clear = () => {
+        const overrides = useLiveNodeOverrides.getState();
+        for (const id of affectedIds) {
+            overrides.clearFields(id, id === node.id ? ['visible'] : ['features']);
+            sceneApi.markDirty(id);
+        }
+    };
+    return {
+        affectedIds,
+        clear,
+        update(point, host, ray) {
+            clear();
+            target = pickFenceTarget(point, host, ray, sceneApi, levelId);
+            if (!target)
+                return;
+            const nodes = sceneApi.nodes();
+            const data = { ...fenceFeatureData(node), center: target.center };
+            const fence = fenceWithFeatures(target.fence, (target.fence.children ?? []).map((id) => nodes[id]));
+            if (!canPlaceFenceFeature(fence, data)) {
+                target = null;
+                return;
+            }
+            if (!affectedIds.includes(target.fence.id))
+                affectedIds.push(target.fence.id);
+            useLiveNodeOverrides.getState().set(node.id, { visible: false });
+            useLiveNodeOverrides.getState().set(target.fence.id, { features: [data] });
+            sceneApi.markDirty(node.id);
+            for (const id of affectedIds)
+                sceneApi.markDirty(id);
+        },
+        canCommit: () => target !== null,
+        commit() {
+            if (!target)
+                return;
+            const destination = target;
+            clear();
+            sceneApi.update(node.id, { parentId: destination.fence.id, center: destination.center });
+            selectNode(node.id);
+        },
+    };
+}

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

@@ -0,0 +1,5 @@
+import { type FenceFeatureNode } from '@pascal-app/core';
+export default function MoveFenceFeatureTool({ node }: {
+    node: FenceFeatureNode;
+}): null;
+//# sourceMappingURL=move-tool.d.ts.map

package/dist/fence-feature/move-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/fence-feature/move-tool.tsx"],"names":[],"mappings":"AACA,OAAO,EAA4B,KAAK,gBAAgB,EAAkB,MAAM,kBAAkB,CAAA;AAWlG,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,QAoDhF"}