@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/pipe-segment/selection.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { analyzePortConnectivity, PipeSegmentNode, pauseSceneHistory, resolveConnectivityUpdates, resumeSceneHistory, sceneRegistry, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { clearPlacementSurface, DimensionPill, isGridSnapActive, swallowNextClick, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { analyzePortConnectivity, findLevelAncestorId, pauseSceneHistory, resolveConnectivityUpdates, resumeSceneHistory, sceneRegistry, useLiveNodeOverrides, usePascalI18n, useScene, } from '@pascal-app/core';
+import { AXIS_MOVE_DRAG_LABEL, clearPlacementSurface, DimensionPill, isGridSnapActive, PATH_POINT_DRAG_LABEL, swallowNextClick, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { collectScenePorts, findNearestPortXZ } from '@pascal-app/editor/distribution';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
@@ -10,13 +10,17 @@ import { useEffect, useMemo, useRef, useState } from 'react';
 import { Plane, Raycaster, Vector2, Vector3 } from 'three';
 import { planRunEndCapFollowUpdates } from '../shared/automatic-run-end-cap.js';
 import { detectFittingEndpoint, planFittingEndpointReaim, } from '../shared/fitting-endpoint-reaim.js';
+import { useHandleDragScope } from '../shared/handle-drag-scope.js';
 import { PipeFittingGhost, PipeSegmentGhost } from '../shared/mep-ghost.js';
-import { planPipeRunTranslationOffsets } from '../shared/pipe-run-translation-offset.js';
-import { planVerticalOffsets } from '../shared/pipe-vertical-offset.js';
 import { DWV_PORT_SYSTEMS } from '../shared/port-systems.js';
 import { ContinuePlusHandle, HandleCube, MoveChevron } from '../shared/selection-handles.js';
 import { refreshWallRunAttachment } from '../shared/wall-run-move.js';
-import { activatePipeContinuation, pipeContinuationHandlePlan, } from './continuation.js';
+import { activatePipeContinuation } from './continuation.js';
+import { pipeContinuationHandlePlan } from './continuation-handle.js';
+import { pipeGradeBlockedNotice } from './grade-affordance.js';
+import { pipeUpdatesPreserveGrades } from './grade-operation.js';
+import { startPipeRunMove } from './run-move.js';
+import { pipeGradesMatch, preservePipeGrades } from './slope.js';
 /** Port-snap radius for dragged run endpoints (meters, XZ). */
 const PORT_SNAP_RADIUS_M = 0.4;
 const CENTER_ARROW_GAP = 0.28;
@@ -92,6 +96,7 @@ const PipeSegmentSelectionAffordance = () => {
     return createPortal(_jsx(PipePointHandles, { pipe: pipe, target: target }), mount, undefined);
 };
 const PipePointHandles = ({ pipe, target }) => {
+    const i18n = usePascalI18n();
     const { camera, gl } = useThree();
     const liveOverride = useLiveNodeOverrides((state) => state.overrides.get(pipe.id));
     const displayPipe = liveOverride ? { ...pipe, ...liveOverride } : pipe;
@@ -106,8 +111,10 @@ const PipePointHandles = ({ pipe, target }) => {
     });
     const unit = useViewer((s) => s.unit);
     const [draggingIndex, setDraggingIndex] = useState(null);
+    const claimHandleDrag = useHandleDragScope();
+    const [gradeNotice, setGradeNotice] = useState('');
     const [runMoving, setRunMoving] = useState(false);
-    const [verticalGhost, setVerticalGhost] = useState(null);
+    const [moveGhost, setMoveGhost] = useState(null);
     const [openCluster, setOpenCluster] = useState(null);
     const toggleCluster = (key) => setOpenCluster((cur) => (cur === key ? null : key));
     // Set while a drag is live; null otherwise. Holds everything the window
@@ -195,6 +202,11 @@ const PipePointHandles = ({ pipe, target }) => {
     // collar and the elbow swings to fit. Otherwise: the dragged point moves
     // and any mated fittings / runs translate via connectivity.
     const buildDragBatch = (drag, next, detached) => {
+        const constrained = preservePipeGrades(drag.initialPath, drag.initialPath.map((point, index) => (index === drag.index ? next : point)), drag.index);
+        if (!constrained)
+            return null;
+        next = constrained[drag.index];
+        const checked = (updates) => pipeUpdatesPreserveGrades(useScene.getState().nodes, updates) ? updates : null;
         const wall = pipe.wallAttachment
             ? useScene.getState().nodes[pipe.wallAttachment.wallId]
             : undefined;
@@ -202,20 +214,17 @@ const PipePointHandles = ({ pipe, target }) => {
             ? refreshWallRunAttachment(path, pipe.wallAttachment, wall)
             : pipe.wallAttachment;
         const withEndCapFollow = (path, updates) => {
-            if (drag.index !== 0 && drag.index !== drag.initialPath.length - 1)
-                return updates;
-            const endpoint = drag.index === 0 ? 'start' : 'end';
             const nextPipe = { ...pipe, path };
-            const capUpdates = planRunEndCapFollowUpdates(pipe, nextPipe, endpoint, useScene.getState().nodes);
+            const capUpdates = ['start', 'end'].flatMap((endpoint) => planRunEndCapFollowUpdates(pipe, nextPipe, endpoint, useScene.getState().nodes));
             const capIds = new Set(capUpdates.map((update) => update.id));
             return [...updates.filter((update) => !capIds.has(update.id)), ...capUpdates];
         };
         if (!detached && drag.fittingEndpoint) {
             const plan = planFittingEndpointReaim(drag.fittingEndpoint, drag.index, next);
             // Out of the elbow's buildable turn range — hold this frame.
-            if (!plan)
+            if (!plan || !pipeGradesMatch(drag.initialPath, plan.path))
                 return null;
-            return withEndCapFollow(plan.path, [
+            return checked(withEndCapFollow(plan.path, [
                 {
                     id: pipe.id,
                     data: { path: plan.path, wallAttachment: attachmentFor(plan.path) },
@@ -235,14 +244,17 @@ const PipePointHandles = ({ pipe, target }) => {
                         },
                     ]
                     : []),
-            ]);
+            ]));
         }
-        const path = drag.initialPath.map((p, i) => (i === drag.index ? next : p));
+        const path = constrained;
+        const followers = detached ? [] : connectivityUpdatesForPath(drag.connectivity, path);
+        if (!followers)
+            return null;
         const updates = [
             { id: pipe.id, data: { path, wallAttachment: attachmentFor(path) } },
-            ...(detached ? [] : connectivityUpdatesForPath(drag.connectivity, path)),
+            ...followers,
         ];
-        return detached ? updates : withEndCapFollow(path, updates);
+        return checked(detached ? updates : withEndCapFollow(path, updates));
     };
     /** World-space position of a local path point. */
     const toWorld = (p) => target.localToWorld(new Vector3(p[0], p[1], p[2]));
@@ -253,12 +265,13 @@ const PipePointHandles = ({ pipe, target }) => {
     };
     // Follow-updates for fittings / pipes mated to this run's endpoints, given
     // the run's live path. Endpoints whose position didn't change resolve to a
-    // zero delta, so only the dragged endpoint's partner actually moves.
+    // zero delta, so only the dragged endpoint's partner actually moves. Null
+    // when the mated joints cannot follow the path.
     const connectivityUpdatesForPath = (connectivity, path) => {
         if (!connectivity)
             return [];
         const preview = { ...pipe, path };
-        return resolveConnectivityUpdates(connectivity, preview).filter((u) => useScene.getState().nodes[u.id]);
+        return (resolveConnectivityUpdates(connectivity, preview)?.filter((u) => useScene.getState().nodes[u.id]) ?? null);
     };
     const onHandleDown = (index, kind) => (e) => {
         e.stopPropagation();
@@ -269,10 +282,20 @@ const PipePointHandles = ({ pipe, target }) => {
         const livePreviewIds = new Set();
         const publishLivePreview = (updates) => {
             const scene = useScene.getState();
+            const overrides = useLiveNodeOverrides.getState();
             const entries = updates
                 .filter((update) => scene.nodes[update.id])
                 .map((update) => [update.id, update.data]);
-            useLiveNodeOverrides.getState().setMany(entries);
+            const previewed = new Set(entries.map(([id]) => id));
+            for (const id of livePreviewIds) {
+                if (previewed.has(id))
+                    continue;
+                overrides.clear(id);
+                if (scene.nodes[id])
+                    scene.markDirty(id);
+                livePreviewIds.delete(id);
+            }
+            overrides.setMany(entries);
             for (const [id] of entries) {
                 livePreviewIds.add(id);
                 scene.markDirty(id);
@@ -290,6 +313,10 @@ const PipePointHandles = ({ pipe, target }) => {
         useViewer.getState().setInputDragging(true);
         document.body.style.cursor = kind.axis === 'y' ? 'ns-resize' : 'grabbing';
         setDraggingIndex(index);
+        const releaseScope = claimHandleDrag(pipe.id, PATH_POINT_DRAG_LABEL, () => {
+            swallowNextClick();
+            finish(false);
+        });
         const isEndpoint = index === 0 || index === initialPath.length - 1;
         const swings = kind.axis === 'y' ? kind.along !== true : kind.axis === 'horizontal' && !kind.along;
         const neighborIndex = index === 0 ? 1 : index === initialPath.length - 1 ? index - 1 : null;
@@ -353,6 +380,7 @@ const PipePointHandles = ({ pipe, target }) => {
             if (isEndpoint && (detached || !drag.fittingEndpoint)) {
                 const port = findNearestPortXZ([next[0], next[1], next[2]], collectScenePorts({
                     excludeNodeId: pipe.id,
+                    levelId: (findLevelAncestorId(pipe.id, useScene.getState().nodes) ?? undefined),
                     systems: DWV_PORT_SYSTEMS,
                 }), PORT_SNAP_RADIUS_M);
                 if (port)
@@ -361,22 +389,25 @@ const PipePointHandles = ({ pipe, target }) => {
             if (next[0] === drag.current[0] && next[1] === drag.current[1] && next[2] === drag.current[2])
                 return;
             const batch = buildDragBatch(drag, next, detached);
-            if (!batch)
+            if (!batch) {
+                setGradeNotice(i18n._(pipeGradeBlockedNotice));
                 return;
+            }
+            setGradeNotice('');
             drag.current = next;
             drag.detached = detached;
             if (step > 0)
                 triggerSFX('sfx:grid-snap');
             publishLivePreview(batch);
         };
-        const onUp = () => {
+        const finish = (commit) => {
             const drag = dragRef.current;
             if (!drag)
                 return;
-            swallowNextClick();
             drag.cleanup();
             dragRef.current = null;
             setDraggingIndex(null);
+            setGradeNotice('');
             clearLivePreview();
             // Resume history and apply the final batch as one tracked change. The
             // final batch is built the same way as
@@ -384,16 +415,24 @@ const PipePointHandles = ({ pipe, target }) => {
             // detached — just the pipe path).
             const detached = drag.detached;
             const moved = drag.current.some((v, axis) => v !== drag.initialPath[drag.index][axis]);
-            const finalBatch = buildDragBatch(drag, drag.current, detached);
+            const finalBatch = commit ? buildDragBatch(drag, drag.current, detached) : null;
             resumeSceneHistory(useScene);
             if (moved && finalBatch) {
                 useScene.getState().updateNodes(finalBatch);
             }
         };
+        const onUp = () => {
+            if (!dragRef.current)
+                return;
+            swallowNextClick();
+            finish(true);
+        };
+        const onCancel = () => finish(false);
         const cleanup = () => {
             window.removeEventListener('pointermove', onMove);
             window.removeEventListener('pointerup', onUp);
-            window.removeEventListener('pointercancel', onUp);
+            window.removeEventListener('pointercancel', onCancel);
+            releaseScope();
             useViewer.getState().setInputDragging(false);
             document.body.style.cursor = '';
         };
@@ -411,25 +450,25 @@ const PipePointHandles = ({ pipe, target }) => {
         };
         window.addEventListener('pointermove', onMove);
         window.addEventListener('pointerup', onUp);
-        window.addEventListener('pointercancel', onUp);
+        window.addEventListener('pointercancel', onCancel);
     };
     const onRunMoveDown = (kind) => (e) => {
         e.stopPropagation();
         const parentId = (pipe.parentId ?? undefined);
-        const initialPath = pipe.path.map((p) => [...p]);
-        const center = runAxisAndCenter(pipe)?.center ?? initialPath[0];
+        const center = runAxisAndCenter(pipe)?.center ?? pipe.path[0];
         const anchorWorld = toWorld(center);
-        const profile = {
-            diameter: pipe.diameter,
-            pipeMaterial: pipe.pipeMaterial,
-        };
         const nodesById = {
             ...useScene.getState().nodes,
         };
-        const connectivity = analyzePortConnectivity(pipe, nodesById);
-        const scenePorts = collectScenePorts({
-            excludeNodeId: pipe.id,
-            systems: DWV_PORT_SYSTEMS,
+        const move = startPipeRunMove({
+            pipe,
+            kind,
+            connectivity: analyzePortConnectivity(pipe, nodesById),
+            scenePorts: collectScenePorts({
+                excludeNodeId: pipe.id,
+                systems: DWV_PORT_SYSTEMS,
+            }),
+            nodesById,
         });
         const previewHiddenIds = new Set();
         pauseSceneHistory(useScene);
@@ -450,12 +489,21 @@ const PipePointHandles = ({ pipe, target }) => {
         const livePreviewIds = new Set();
         const publishLivePreview = (updates) => {
             const scene = useScene.getState();
+            const overrides = useLiveNodeOverrides.getState();
             const entries = updates
                 .filter((update) => scene.nodes[update.id])
                 .map((update) => [update.id, update.data]);
+            const previewed = new Set(entries.map(([id]) => id));
+            for (const id of livePreviewIds) {
+                if (previewed.has(id))
+                    continue;
+                overrides.clear(id);
+                scene.markDirty(id);
+                livePreviewIds.delete(id);
+            }
             if (entries.length === 0)
                 return;
-            useLiveNodeOverrides.getState().setMany(entries);
+            overrides.setMany(entries);
             for (const [id] of entries) {
                 livePreviewIds.add(id);
                 scene.markDirty(id);
@@ -502,183 +550,80 @@ const PipePointHandles = ({ pipe, target }) => {
         useViewer.getState().setInputDragging(true);
         document.body.style.cursor = kind.axis === 'y' ? 'ns-resize' : 'grabbing';
         setRunMoving(true);
-        let delta = 0;
-        let offsetResult = null;
-        const shiftedPath = (d) => initialPath.map((p) => {
-            const next = [...p];
-            if (kind.axis === 'y') {
-                next[1] = p[1] + d;
-            }
-            else {
-                next[0] = p[0] + d * kind.dir[0];
-                next[2] = p[2] + d * kind.dir[1];
-            }
-            return next;
+        const releaseScope = claimHandleDrag(pipe.id, AXIS_MOVE_DRAG_LABEL, () => {
+            swallowNextClick();
+            finish(false);
         });
-        const batchFor = (path) => [
-            { id: pipe.id, data: { path } },
-            ...connectivityUpdatesForPath(connectivity, path),
-        ];
-        const partnerReverts = () => (connectivity?.connections ?? [])
-            .map((conn) => {
-            if (conn.kind !== 'rigid-node') {
-                return {
-                    id: conn.nodeId,
-                    data: { path: conn.startPath },
-                };
-            }
-            const start = nodesById[conn.nodeId];
-            const data = {
-                position: conn.startPosition,
-            };
-            if (start?.rotation !== undefined)
-                data.rotation = start.rotation;
-            if (start?.angle !== undefined)
-                data.angle = start.angle;
-            return { id: conn.nodeId, data: data };
-        })
-            .filter((u) => useScene.getState().nodes[u.id]);
+        let delta = 0;
         const onMove = (event) => {
             if (startSample === null)
                 return;
             const s = sample(event.clientX, event.clientY);
             if (s === null)
                 return;
-            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+            const step = !event.altKey && isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
             const next = snap(s - startSample, step);
             if (next === delta)
                 return;
             delta = next;
             if (step > 0)
                 triggerSFX('sfx:grid-snap');
-            offsetResult =
-                kind.axis === 'y' && next !== 0
-                    ? planVerticalOffsets({
-                        pipe,
-                        dy: next,
-                        profile,
-                        connections: connectivity?.connections ?? [],
-                        scenePorts,
-                        nodesById,
-                    })
-                    : null;
-            if (offsetResult?.status === 'valid') {
-                const plan = offsetResult.plan;
-                const scene = useScene.getState();
-                const deletePreview = (plan.delete ?? []).filter((id) => scene.nodes[id]);
-                setPreviewHidden(deletePreview);
-                const followUpdates = connectivityUpdatesForPath(connectivity, plan.followPath);
-                const updates = [
-                    { id: pipe.id, data: { path: plan.pipePath } },
-                    ...plan.updates.filter((u) => scene.nodes[u.id]),
-                    ...followUpdates,
-                ];
-                publishLivePreview(updates);
-                setVerticalGhost({
-                    tint: 'valid',
-                    fittings: plan.fittings,
-                    risers: plan.risers,
-                });
-            }
-            else if (offsetResult?.status === 'invalid') {
-                setPreviewHidden([]);
-                const updates = [
-                    { id: pipe.id, data: { path: pipe.path } },
-                    ...partnerReverts(),
-                ];
-                publishLivePreview(updates);
-                const lifted = PipeSegmentNode.parse({
-                    ...pipe,
-                    path: shiftedPath(next),
-                });
-                setVerticalGhost({ tint: 'invalid', fittings: [], risers: [lifted] });
+            const frame = move.update(next);
+            if (frame.status === 'blocked') {
+                setGradeNotice(i18n._(pipeGradeBlockedNotice));
+                return;
             }
-            else {
+            setGradeNotice('');
+            setMoveGhost(frame.ghost);
+            if (frame.status === 'invalid') {
                 setPreviewHidden([]);
-                setVerticalGhost(null);
-                const updates = batchFor(shiftedPath(next));
-                publishLivePreview(updates);
+                clearLivePreview();
+                return;
             }
+            setPreviewHidden(frame.hidden);
+            publishLivePreview(frame.preview);
         };
-        const onUp = () => {
-            swallowNextClick();
+        const finish = (commit) => {
             window.removeEventListener('pointermove', onMove);
             window.removeEventListener('pointerup', onUp);
-            window.removeEventListener('pointercancel', onUp);
+            window.removeEventListener('pointercancel', onCancel);
+            releaseScope();
             useViewer.getState().setInputDragging(false);
             clearPlacementSurface();
             document.body.style.cursor = '';
             setRunMoving(false);
-            setVerticalGhost(null);
+            setMoveGhost(null);
+            setGradeNotice('');
             clearLivePreview();
             setPreviewHidden([]);
             resumeSceneHistory(useScene);
-            if (delta === 0)
-                return;
-            const result = offsetResult;
-            if (result?.status === 'invalid')
+            const change = commit ? move.release() : null;
+            if (!change)
                 return;
             const scene = useScene.getState();
-            if (result?.status === 'valid') {
-                const plan = result.plan;
-                const minted = [...plan.fittings, ...plan.risers];
-                const followUpdates = connectivityUpdatesForPath(connectivity, plan.followPath);
-                const updates = [
-                    { id: pipe.id, data: { path: plan.pipePath } },
-                    ...plan.updates.filter((u) => scene.nodes[u.id]),
-                    ...followUpdates,
-                ];
+            if (change.create.length > 0 || change.delete.length > 0) {
                 scene.applyNodeChanges({
-                    create: minted.map((node) => ({ node: node, parentId })),
-                    delete: (plan.delete ?? []).filter((id) => scene.nodes[id]),
-                    update: updates,
+                    create: change.create.map((node) => ({ node, parentId })),
+                    delete: change.delete.filter((id) => scene.nodes[id]),
+                    update: change.update,
                 });
-                ensureSceneObjectsVisible([
-                    ...minted.map((node) => node.id),
-                    ...updates.map((update) => update.id),
-                ]);
-                return;
             }
-            const finalPath = shiftedPath(delta);
-            const translationPlan = kind.axis !== 'y' && connectivity
-                ? planPipeRunTranslationOffsets({
-                    pipe,
-                    translatedPath: finalPath,
-                    profile,
-                    connections: connectivity.connections,
-                    scenePorts,
-                    nodesById,
-                })
-                : null;
-            if (translationPlan) {
-                const created = [...translationPlan.fittings, ...translationPlan.connectors];
-                const updates = [
-                    {
-                        id: pipe.id,
-                        data: { path: translationPlan.pipePath },
-                    },
-                    ...translationPlan.updates,
-                ];
-                scene.applyNodeChanges({
-                    create: created.map((node) => ({
-                        node: node,
-                        parentId,
-                    })),
-                    update: updates,
-                });
-                ensureSceneObjectsVisible([
-                    ...created.map((node) => node.id),
-                    ...updates.map((update) => update.id),
-                ]);
-                return;
+            else {
+                scene.updateNodes(change.update);
             }
-            const updates = batchFor(finalPath);
-            useScene.getState().updateNodes(updates);
-            ensureSceneObjectsVisible(updates.map((update) => update.id));
+            ensureSceneObjectsVisible([
+                ...change.create.map((node) => node.id),
+                ...change.update.map((update) => update.id),
+            ]);
+        };
+        const onUp = () => {
+            swallowNextClick();
+            finish(true);
         };
+        const onCancel = () => finish(false);
         window.addEventListener('pointermove', onMove);
         window.addEventListener('pointerup', onUp);
-        window.addEventListener('pointercancel', onUp);
+        window.addEventListener('pointercancel', onCancel);
     };
     const cornerArrows = useMemo(() => getCornerArrows(displayPipe), [displayPipe]);
     const runCenter = useMemo(() => runAxisAndCenter(displayPipe)?.center ?? null, [displayPipe]);
@@ -730,7 +675,7 @@ const PipePointHandles = ({ pipe, target }) => {
         });
         return arrows;
     }, [displayPipe, runCenter]);
-    return (_jsxs("group", { ref: outerRef, children: [verticalGhost?.fittings.map((f) => (_jsx(PipeFittingGhost, { fitting: f, tint: verticalGhost.tint }, `pipe-vghost-fit-${f.id}`))), verticalGhost?.risers.map((r) => (_jsx(PipeSegmentGhost, { pipe: r, tint: verticalGhost.tint }, `pipe-vghost-riser-${r.id}`))), draggingIndex === null &&
+    return (_jsxs("group", { ref: outerRef, children: [gradeNotice && runCenter && (_jsx(Html, { center: true, position: runCenter, style: { pointerEvents: 'none' }, children: _jsx("div", { role: "status", className: "pointer-events-none w-64 rounded border bg-background p-2 text-xs", children: gradeNotice }) })), moveGhost?.fittings.map((f) => (_jsx(PipeFittingGhost, { fitting: f, tint: moveGhost.tint }, `pipe-vghost-fit-${f.id}`))), moveGhost?.risers.map((r) => (_jsx(PipeSegmentGhost, { pipe: r, tint: moveGhost.tint }, `pipe-vghost-riser-${r.id}`))), draggingIndex === null &&
                 !runMoving &&
                 openCluster === null &&
                 ['start', 'end'].map((endpoint) => (_jsx(PipeContinuationHandle, { endpoint: endpoint, pipe: displayPipe }, endpoint))), draggingIndex === null &&

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

@@ -1,5 +1,8 @@
 type Point = readonly [number, number, number];
 export declare function pipeGrade(start: Point, end: Point): number | null;
 export declare function applyPipeGrade(start: Point, end: Point, grade: number): [number, number, number];
+/** Preserve each leg's grade, including vertical rises, while anchoring one endpoint. */
+export declare function preservePipeGrades(initial: readonly Point[], proposed: readonly Point[], movedIndex: number): [number, number, number][] | null;
+export declare function pipeGradesMatch(initial: readonly Point[], next: readonly Point[]): boolean;
 export {};
 //# sourceMappingURL=slope.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"slope.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/slope.ts"],"names":[],"mappings":"AAAA,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAE9C,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAGjE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAIhG"}
+{"version":3,"file":"slope.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/slope.ts"],"names":[],"mappings":"AAAA,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAE9C,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAGjE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAIhG;AAED,yFAAyF;AACzF,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,KAAK,EAAE,EACzB,QAAQ,EAAE,SAAS,KAAK,EAAE,EAC1B,UAAU,EAAE,MAAM,GACjB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,CA0BnC;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAa1F"}

package/dist/pipe-segment/slope.js

@@ -8,3 +8,50 @@ export function applyPipeGrade(start, end, grade) {
         return [...end];
     return [end[0], start[1] - horizontal * grade, end[2]];
 }
+/** Preserve each leg's grade, including vertical rises, while anchoring one endpoint. */
+export function preservePipeGrades(initial, proposed, movedIndex) {
+    if (initial.length !== proposed.length || initial.length < 2)
+        return null;
+    const path = proposed.map((p) => [...p]);
+    const original = initial[movedIndex];
+    const moved = path[movedIndex];
+    if (!original || !moved || path.some((p) => p.some((v) => !Number.isFinite(v))))
+        return null;
+    if (Math.hypot(moved[0] - original[0], moved[2] - original[2]) < 1e-8) {
+        const dy = moved[1] - original[1];
+        return initial.map((p) => [p[0], p[1] + dy, p[2]]);
+    }
+    const drops = [];
+    for (let i = 1; i < path.length; i++) {
+        const grade = pipeGrade(initial[i - 1], initial[i]);
+        const length = Math.hypot(path[i][0] - path[i - 1][0], path[i][2] - path[i - 1][2]);
+        if (grade === null && length > 1e-6)
+            return null;
+        if (grade !== null && length < 0.001)
+            return null;
+        drops.push(grade === null ? initial[i - 1][1] - initial[i][1] : grade * length);
+    }
+    if (movedIndex === 0) {
+        path.at(-1)[1] = initial.at(-1)[1];
+        for (let i = path.length - 2; i >= 0; i--)
+            path[i][1] = path[i + 1][1] + drops[i];
+    }
+    else {
+        path[0][1] = initial[0][1];
+        for (let i = 1; i < path.length; i++)
+            path[i][1] = path[i - 1][1] - drops[i - 1];
+    }
+    return path;
+}
+export function pipeGradesMatch(initial, next) {
+    if (initial.length !== next.length ||
+        next.some((point) => point.some((value) => !Number.isFinite(value))))
+        return false;
+    for (let i = 1; i < initial.length; i++) {
+        const before = pipeGrade(initial[i - 1], initial[i]);
+        const after = pipeGrade(next[i - 1], next[i]);
+        if (before === null ? after !== null : after === null || Math.abs(before - after) > 1e-6)
+            return false;
+    }
+    return true;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/tool.tsx"],"names":[],"mappings":"AA6DA,QAAA,MAAM,eAAe,0CAucpB,CAAA;eA8Bc,eAAe"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/tool.tsx"],"names":[],"mappings":"AAuEA,QAAA,MAAM,eAAe,0CAukBpB,CAAA;eA8Bc,eAAe"}