@pascal-app/nodes 0.1.1

package/dist/pipe-segment/move-tool.js

@@ -0,0 +1,254 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, PipeSegmentNode, sceneRegistry, useScene, } from '@pascal-app/core';
+import { DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useRef, useState } from 'react';
+import { Vector3 } from 'three';
+import { collectGhostAlignmentCandidates, resolveGhostAlignment, } from '../shared/ghost-alignment';
+import { startRunMoveConnectivity } from '../shared/run-move-connectivity';
+const GHOST_COLOR = '#818cf8';
+const GHOST_OPACITY = 0.5;
+const IN_TO_M = 0.0254;
+/** Snap a coordinate to the editor's live grid step. */
+function snapToGridStep(value) {
+    const step = useEditor.getState().gridSnapStep;
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+function pathCenterXZ(path) {
+    let x = 0;
+    let z = 0;
+    for (const p of path) {
+        x += p[0];
+        z += p[2];
+    }
+    const n = path.length || 1;
+    return [x / n, z / n];
+}
+/** The pipe's radius (meters) — half the nominal diameter, used as the
+ *  box / footprint padding and the ghost cylinder radius. */
+function pipeRadiusM(pipe) {
+    return (pipe.diameter * IN_TO_M) / 2;
+}
+/** XZ bounds of a path padded by the pipe's radius. */
+function pathAabb(path, r) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const p of path) {
+        if (p[0] < minX)
+            minX = p[0];
+        if (p[0] > maxX)
+            maxX = p[0];
+        if (p[2] < minZ)
+            minZ = p[2];
+        if (p[2] > maxZ)
+            maxZ = p[2];
+    }
+    return { minX: minX - r, maxX: maxX + r, minZ: minZ - r, maxZ: maxZ + r };
+}
+/**
+ * Ghost-preview duplicate / move tool for DWV pipe runs — the plumbing
+ * sibling of `MoveDuctSegmentTool`. Pipes are always round, so the ghost
+ * is a translucent cylinder per section (no rect branch).
+ *
+ * **Duplicate** (`metadata.isNew`): pure drag-to-place — NOTHING is
+ * inserted into the scene until the commit click. A translucent ghost of
+ * the run rides the cursor inside a footprint bounding box — the same
+ * affordance other items get — and Figma-style alignment guides snap the
+ * box's edges to nearby geometry. The next grid click calls `createNode`;
+ * Esc discards. The run's Y coords (slope) ride along untouched: the move
+ * only shifts XZ.
+ *
+ * **Move** (existing run): the real node's mesh is hidden while the same
+ * ghost + box tracks the cursor; the commit click writes the translated
+ * `path` and reveals it, Esc reveals it unchanged.
+ *
+ * Wired via `def.affordanceTools.move`.
+ */
+export const MovePipeSegmentTool = ({ node }) => {
+    const pipe = node;
+    const originalPathRef = useRef(pipe.path.map((p) => [...p]));
+    const isNew = typeof node.metadata === 'object' &&
+        node.metadata !== null &&
+        !Array.isArray(node.metadata) &&
+        node.metadata.isNew === true;
+    const [previewPath, setPreviewPath] = useState(originalPathRef.current);
+    const previewPathRef = useRef(originalPathRef.current);
+    const hasMovedRef = useRef(false);
+    const activatedAtRef = useRef(Date.now());
+    const prevSnapRef = useRef(null);
+    useEffect(() => {
+        const nodeId = node.id;
+        const originalPath = originalPathRef.current;
+        const [centerX, centerZ] = pathCenterXZ(originalPath);
+        const r = pipeRadiusM(pipe);
+        const baseAabb = pathAabb(originalPath, r);
+        useScene.temporal.getState().pause();
+        let committed = false;
+        const candidates = collectGhostAlignmentCandidates(useScene.getState().nodes, nodeId, useViewer.getState().selection.levelId ?? node.parentId);
+        // Moving an existing run: hide its 3D MESH imperatively (NOT the store
+        // `visible` flag — the 2D floor plan skips `visible:false` nodes, so a
+        // store hide makes the run vanish in 2D / split view). The ghost stands
+        // in until commit; the real mesh is restored on cancel / unmount.
+        const existedAtStart = !isNew && !!useScene.getState().nodes[nodeId];
+        const setMeshHidden = (hidden) => {
+            const obj = sceneRegistry.nodes.get(nodeId);
+            if (obj)
+                obj.visible = !hidden;
+        };
+        if (existedAtStart)
+            setMeshHidden(true);
+        // Carry connected fittings (+ their other runs) as the whole run slides.
+        // Snapshot once at drag start; only existing runs are mated to anything.
+        const connectivity = existedAtStart
+            ? startRunMoveConnectivity(node)
+            : null;
+        const setPreview = (path) => {
+            previewPathRef.current = path;
+            setPreviewPath(path);
+        };
+        const onMove = (event) => {
+            const snap = isGridSnapActive() ? snapToGridStep : (v) => v;
+            let dx = snap(event.localPosition[0] - centerX);
+            let dz = snap(event.localPosition[2] - centerZ);
+            // Figma-style magnetic alignment: snap the run's footprint box edges onto
+            // nearby geometry and publish the guides. Grid follows the snapping mode;
+            // lines follow magnetic alignment — the two are independent.
+            if (isAlignmentGuideActive()) {
+                const proposed = {
+                    minX: baseAabb.minX + dx,
+                    maxX: baseAabb.maxX + dx,
+                    minZ: baseAabb.minZ + dz,
+                    maxZ: baseAabb.maxZ + dz,
+                };
+                const { dx: sdx, dz: sdz, guides } = resolveGhostAlignment(nodeId, proposed, candidates);
+                if (isMagneticSnapActive()) {
+                    dx += sdx;
+                    dz += sdz;
+                }
+                useAlignmentGuides.getState().set(guides);
+            }
+            else {
+                useAlignmentGuides.getState().clear();
+            }
+            const cur = [centerX + dx, centerZ + dz];
+            if ((isGridSnapActive() || isMagneticSnapActive()) &&
+                (!prevSnapRef.current ||
+                    prevSnapRef.current[0] !== cur[0] ||
+                    prevSnapRef.current[1] !== cur[1])) {
+                triggerSFX('sfx:grid-snap');
+            }
+            prevSnapRef.current = cur;
+            hasMovedRef.current = true;
+            const nextPath = originalPath.map(([x, y, z]) => [x + dx, y, z + dz]);
+            setPreview(nextPath);
+            connectivity?.preview({ path: nextPath });
+        };
+        const commit = (event) => {
+            if (committed)
+                return;
+            if (Date.now() - activatedAtRef.current < 150) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            if (!hasMovedRef.current) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            committed = true;
+            const finalPath = previewPathRef.current;
+            useScene.temporal.getState().resume();
+            let selectId = nodeId;
+            if (isNew && !useScene.getState().nodes[nodeId]) {
+                const created = PipeSegmentNode.parse({
+                    ...node,
+                    path: finalPath,
+                    metadata: stripPlacementMetadataFlags(node.metadata),
+                    visible: true,
+                });
+                useScene.getState().createNode(created, node.parentId);
+                selectId = created.id;
+            }
+            else {
+                // Fold connected-fitting / sibling-run follow-updates into the SAME
+                // batch as the moved run so the whole joint is one undo step.
+                const followUpdates = connectivity?.commitUpdates({ path: finalPath }) ?? [];
+                useScene
+                    .getState()
+                    .updateNodes([
+                    { id: nodeId, data: { path: finalPath } },
+                    ...followUpdates,
+                ]);
+                useScene.getState().markDirty(nodeId);
+            }
+            useScene.temporal.getState().pause();
+            // Followers are committed to the store — drop their live overrides so
+            // renderers read the canonical path/position.
+            connectivity?.clear();
+            setMeshHidden(false);
+            useAlignmentGuides.getState().clear();
+            triggerSFX('sfx:item-place');
+            useViewer.getState().setSelection({ selectedIds: [selectId] });
+            useEditor.getState().setMovingNodeOrigin('3d');
+            useEditor.getState().setMovingNode(null);
+            event.nativeEvent?.stopPropagation?.();
+        };
+        const onCancel = () => {
+            connectivity?.clear();
+            if (existedAtStart) {
+                setMeshHidden(false);
+                useViewer.getState().setSelection({ selectedIds: [nodeId] });
+            }
+            useAlignmentGuides.getState().clear();
+            useScene.temporal.getState().resume();
+            markToolCancelConsumed();
+            useEditor.getState().setMovingNodeOrigin('3d');
+            useEditor.getState().setMovingNode(null);
+        };
+        emitter.on('grid:move', onMove);
+        emitter.on('grid:click', commit);
+        emitter.on('tool:cancel', onCancel);
+        return () => {
+            emitter.off('grid:move', onMove);
+            emitter.off('grid:click', commit);
+            emitter.off('tool:cancel', onCancel);
+            connectivity?.clear();
+            useAlignmentGuides.getState().clear();
+            if (existedAtStart)
+                setMeshHidden(false);
+            useScene.temporal.getState().resume();
+        };
+    }, [pipe, isNew, node]);
+    const segments = [];
+    for (let i = 0; i < previewPath.length - 1; i++) {
+        segments.push({ a: previewPath[i], b: previewPath[i + 1] });
+    }
+    // Footprint box spanning the whole run (axis-aligned), drawn around the
+    // ghost the same way items get one. Recomputed from the live preview path.
+    const r = pipeRadiusM(pipe);
+    const box = pathAabb(previewPath, r);
+    const boxY = previewPath[0]?.[1] ?? 0;
+    return (_jsxs("group", { children: [segments.map((seg, i) => (_jsx(GhostSegment, { a: seg.a, b: seg.b, radius: r }, `ghost-${i}`))), _jsx(DragBoundingBox, { centerY: 0, nodeId: node.id, position: [(box.minX + box.maxX) / 2, boxY, (box.minZ + box.maxZ) / 2], size: [box.maxX - box.minX, pipe.diameter * IN_TO_M, box.maxZ - box.minZ] })] }));
+};
+/** Translucent stand-in for one pipe section — mirrors the draw tool's
+ *  `PreviewPipe` so the ghost matches what actually lands. */
+function GhostSegment({ a, b, radius }) {
+    const start = new Vector3(...a);
+    const end = new Vector3(...b);
+    const dir = new Vector3().subVectors(end, start);
+    const length = dir.length();
+    if (length < 1e-4)
+        return null;
+    dir.normalize();
+    const mid = new Vector3().addVectors(start, end).multiplyScalar(0.5);
+    return (_jsxs("mesh", { layers: EDITOR_LAYER, position: mid.toArray(), ref: (m) => {
+            if (!m)
+                return;
+            m.quaternion.setFromUnitVectors(new Vector3(0, 1, 0), dir);
+        }, children: [_jsx("cylinderGeometry", { args: [radius, radius, length, 24, 1, false] }), _jsx("meshBasicMaterial", { color: GHOST_COLOR, depthTest: false, opacity: GHOST_OPACITY, transparent: true })] }));
+}
+export default MovePipeSegmentTool;

package/dist/pipe-segment/parametrics.d.ts

@@ -0,0 +1,4 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { PipeSegmentNode } from './schema';
+export declare const pipeSegmentParametrics: ParametricDescriptor<PipeSegmentNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/pipe-segment/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAgCxE,CAAA"}

package/dist/pipe-segment/parametrics.js

@@ -0,0 +1,33 @@
+export const pipeSegmentParametrics = {
+    groups: [
+        {
+            label: 'Drainage',
+            fields: [
+                {
+                    key: 'system',
+                    kind: 'enum',
+                    options: ['waste', 'vent'],
+                    display: 'segmented',
+                },
+                {
+                    key: 'diameter',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 1.25,
+                    max: 6,
+                    step: 0.25,
+                },
+            ],
+        },
+        {
+            label: 'Construction',
+            fields: [
+                {
+                    key: 'pipeMaterial',
+                    kind: 'enum',
+                    options: ['pvc', 'abs', 'cast-iron'],
+                },
+            ],
+        },
+    ],
+};

package/dist/pipe-segment/schema.d.ts

@@ -0,0 +1,2 @@
+export { PipeSegmentNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/pipe-segment/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/pipe-segment/schema.js

@@ -0,0 +1 @@
+export { PipeSegmentNode } from '@pascal-app/core';

package/dist/pipe-segment/selection.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Selection-time editing for committed DWV pipe runs: every path point gets
+ * the same click-to-open directional cube used by duct runs, with DWV port
+ * snapping and pipe elbow re-aim.
+ *
+ * Handles are PORTALED into the pipe's registered scene group so they
+ * share its exact frame — path coords are node-local, and the level /
+ * building transform above the group applies to the handles for free.
+ * Drag raycasts run in world space and convert hits back into the
+ * group's local frame before writing the path.
+ *
+ * Drag model: along-run arrows lengthen / shorten; across-run and vertical
+ * arrows swing endpoint vertices around their neighbour at a fixed radius,
+ * matching duct corner UX. Dragged endpoints still snap onto nearby typed DWV
+ * ports, and a straight run whose other end sits on a pipe elbow collar
+ * re-aims that elbow to follow the drag.
+ *
+ * Modifiers (mirroring the duct corner drag):
+ * - **Alt** detaches: the joint breaks for this drag — the elbow does NOT
+ *   re-aim and mated fittings / runs do NOT follow; the endpoint moves on its
+ *   own (port re-mate still allowed so it can be reattached elsewhere).
+ * - **Shift** bypasses grid snapping for a perfectly smooth precision drag.
+ *
+ * History does the single-undo dance: paused during the drag (the live
+ * `updateNode` ticks are untracked), then on release the path is
+ * reverted, history resumed, and the final path applied as one tracked
+ * change.
+ */
+declare const PipeSegmentSelectionAffordance: () => import("react").JSX.Element | null;
+export default PipeSegmentSelectionAffordance;
+//# sourceMappingURL=selection.d.ts.map

package/dist/pipe-segment/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/selection.tsx"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,QAAA,MAAM,8BAA8B,0CA+BnC,CAAA;AAg2BD,eAAe,8BAA8B,CAAA"}