@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

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

@@ -10,13 +10,14 @@ import { DuctSegmentGhost, FittingGhost } from '../shared/mep-ghost';
 import { collectScenePorts, DUCT_PORT_SYSTEMS } from '../shared/ports';
 import { startRunMoveConnectivity } from '../shared/run-move-connectivity';
 import { planRunTranslationOffsets, } from '../shared/run-translation-offset';
+import { translateWallRun } from '../shared/wall-run-move';
 import { rectSectionAxes } from './geometry';
 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;
+    const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
     if (step <= 0)
         return value;
     return Math.round(value / step) * step;
@@ -88,6 +89,7 @@ export const MoveDuctSegmentTool = ({ node }) => {
     const hasMovedRef = useRef(false);
     const activatedAtRef = useRef(Date.now());
     const prevSnapRef = useRef(null);
+    const previewAttachmentRef = useRef(duct.wallAttachment);
     useEffect(() => {
         const nodeId = node.id;
         const originalPath = originalPathRef.current;
@@ -133,6 +135,20 @@ export const MoveDuctSegmentTool = ({ node }) => {
             setPreviewPath(path);
         };
         const onMove = (event) => {
+            const attachedWall = duct.wallAttachment
+                ? useScene.getState().nodes[duct.wallAttachment.wallId]
+                : undefined;
+            if (duct.wallAttachment && attachedWall?.type === 'wall') {
+                const wallMove = translateWallRun(originalPath, duct.wallAttachment, attachedWall, event);
+                if (wallMove) {
+                    hasMovedRef.current = true;
+                    previewAttachmentRef.current = wallMove.attachment;
+                    setPreview(wallMove.path);
+                    connectivity?.preview({ path: wallMove.path });
+                    setTranslationGhost(null);
+                    return;
+                }
+            }
             const snap = isGridSnapActive() ? snapToGridStep : (v) => v;
             let dx = snap(event.localPosition[0] - centerX);
             let dz = snap(event.localPosition[2] - centerZ);
@@ -206,6 +222,7 @@ export const MoveDuctSegmentTool = ({ node }) => {
                 const created = DuctSegmentNode.parse({
                     ...node,
                     path: finalPath,
+                    wallAttachment: previewAttachmentRef.current,
                     metadata: stripPlacementMetadataFlags(node.metadata),
                     visible: true,
                 });
@@ -229,7 +246,13 @@ export const MoveDuctSegmentTool = ({ node }) => {
                             parentId: node.parentId,
                         })),
                         update: [
-                            { id: nodeId, data: { path: translationPlan.ductPath } },
+                            {
+                                id: nodeId,
+                                data: {
+                                    path: translationPlan.ductPath,
+                                    wallAttachment: previewAttachmentRef.current,
+                                },
+                            },
                             ...translationPlan.updates,
                         ],
                     });
@@ -238,10 +261,14 @@ export const MoveDuctSegmentTool = ({ node }) => {
                     // 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 } },
+                    useScene.getState().updateNodes([
+                        {
+                            id: nodeId,
+                            data: {
+                                path: finalPath,
+                                wallAttachment: previewAttachmentRef.current,
+                            },
+                        },
                         ...followUpdates,
                     ]);
                 }

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

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/duct-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,oBAAoB,EAAY,MAAM,kBAAkB,CAAA;AAI5F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA0E/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CA8FxE,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/duct-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,oBAAoB,EAAY,MAAM,kBAAkB,CAAA;AAK5F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA0E/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CA+IxE,CAAA"}

package/dist/duct-segment/parametrics.js

@@ -1,6 +1,7 @@
 import { useScene } from '@pascal-app/core';
 import { Vector3 } from 'three';
 import { getDuctFittingPorts } from '../duct-fitting/ports';
+import { fittingDeletionPlansForRun } from '../shared/fitting-deletion-cleanup';
 import { rollToContinueAcrossElbow } from './geometry';
 /** A run endpoint sitting this close to a collar counts as mated. */
 const MATE_TOL_M = 0.03;
@@ -76,7 +77,13 @@ export const ductSegmentParametrics = {
     // non-round run can never hold it: leaving round (or picking spiral on
     // a rect / oval run) falls back to plain sheet metal.
     derive: (next, patch) => {
-        const out = {};
+        const out = next.autoHangers
+            ? {
+                hangerStyle: next.hangerStyle ?? 'single',
+                hangerSpacing: next.hangerSpacing ?? 1.5,
+                hangerMaxReach: next.hangerMaxReach ?? 2,
+            }
+            : {};
         if (next.ductMaterial === 'spiral' && next.shape !== 'round') {
             out.ductMaterial = 'sheet-metal';
         }
@@ -87,7 +94,44 @@ export const ductSegmentParametrics = {
         }
         return out;
     },
+    onDelete: (duct, nodes, _pendingDeleteIds, requestedDeleteIds) => fittingDeletionPlansForRun(duct, nodes, requestedDeleteIds, true).flatMap((plan) => plan.updates),
+    onDeleteCascade: (duct, nodes, _pendingDeleteIds, requestedDeleteIds) => fittingDeletionPlansForRun(duct, nodes, requestedDeleteIds, false).flatMap((plan) => plan.deleteFitting ? [plan.fittingId, ...plan.cascadeDeleteIds] : []),
+    trailingSection: () => import('../shared/run-hanger-inspector'),
     groups: [
+        {
+            label: 'Hangers',
+            fields: [
+                { key: 'autoHangers', label: 'Auto hangers', kind: 'boolean' },
+                {
+                    key: 'hangerStyle',
+                    label: 'Hanger lines',
+                    kind: 'enum',
+                    options: ['single', 'double'],
+                    display: 'segmented',
+                    visibleIf: (n) => !!n.autoHangers,
+                },
+                {
+                    key: 'hangerSpacing',
+                    label: 'Spacing',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.05,
+                    max: 1000,
+                    step: 0.1,
+                    visibleIf: (n) => !!n.autoHangers,
+                },
+                {
+                    key: 'hangerMaxReach',
+                    label: 'Maximum reach',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.01,
+                    max: 1000,
+                    step: 0.1,
+                    visibleIf: (n) => !!n.autoHangers,
+                },
+            ],
+        },
         {
             label: 'Air',
             fields: [

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

@@ -22,11 +22,10 @@
  * - **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.
+ * - Snapping follows the active editor snapping mode.
  *
- * 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
+ * History is paused during the drag while live overrides drive the preview.
+ * On release, history resumes and the final path is applied as one tracked
  * change.
  */
 declare const DuctSegmentSelectionAffordance: () => import("react").JSX.Element | null;

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

@@ -1 +1 @@
-{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/duct-segment/selection.tsx"],"names":[],"mappings":"AAgIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,QAAA,MAAM,8BAA8B,0CAuCnC,CAAA;AAo5CD,eAAe,8BAA8B,CAAA"}
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/duct-segment/selection.tsx"],"names":[],"mappings":"AA+IA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,QAAA,MAAM,8BAA8B,0CAuCnC,CAAA;AA68CD,eAAe,8BAA8B,CAAA"}