@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/duct-segment/geometry.js

@@ -2,7 +2,7 @@ import { DUCT_BODY_SLOT_DEFAULT, DUCT_BODY_SLOT_ID } from '@pascal-app/core';
 import { createSurfaceRoleMaterial, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
 import { BoxGeometry, CatmullRomCurve3, CylinderGeometry, ExtrudeGeometry, Group, Matrix4, Mesh, MeshStandardMaterial, Quaternion, Shape, SphereGeometry, TubeGeometry, Vector3, } from 'three';
 import { buildRunHangers } from '../shared/run-hangers.js';
-export const INCHES_TO_METERS = 0.0254;
+import { INCHES_TO_METERS, rectSectionAxes } from './profile.js';
 // Insulation wraps the duct in a roughly uniform shell. A strictly physical
 // mapping (fiberglass ≈ R-3.2 per inch) makes low R-values nearly invisible
 // at screen scale — R-1 would add only ~8 mm over a 15 cm duct. So the shell
@@ -20,83 +20,8 @@ function pickInsulationThickness(r) {
 // body itself is plain white (see createDuctMaterial).
 const SUPPLY_COLOR = '#d4825a';
 const RETURN_COLOR = '#5a8ad4';
-const RADIAL_SEGMENTS = 24;
 const UP = new Vector3(0, 1, 0);
-/**
- * Area-equivalent round diameter (inches) for a rect cross-section —
- * what a rect trunk advertises on its ports so round fittings / branches
- * mate at a sensible size.
- */
-export function equivalentDiameterIn(widthIn, heightIn) {
-    return 2 * Math.sqrt((widthIn * heightIn) / Math.PI);
-}
-/**
- * Area-equivalent round diameter (inches) for a flat-oval cross-section:
- * a rectangle of (width − height) × height plus the two semicircular caps.
- */
-export function ovalEquivalentDiameterIn(widthIn, heightIn) {
-    const minor = Math.min(widthIn, heightIn);
-    const major = Math.max(widthIn, heightIn);
-    const area = (major - minor) * minor + Math.PI * (minor / 2) ** 2;
-    return 2 * Math.sqrt(area / Math.PI);
-}
-/** The diameter (inches) a duct segment presents at its ports. */
-export function ductPortDiameterIn(node) {
-    if (node.shape === 'rect' && node.width && node.height) {
-        return equivalentDiameterIn(node.width, node.height);
-    }
-    if (node.shape === 'oval' && node.width && node.height) {
-        return ovalEquivalentDiameterIn(node.width, node.height);
-    }
-    return node.diameter;
-}
-/**
- * Cross-section axes for a rect run along `dir`, rolled `roll` radians
- * about the run direction. At roll 0: width is the horizontal axis
- * (UP × dir) and height the vertical one — vertical runs, where that
- * cross product degenerates, fall back to world X/Z. `roll` rotates the
- * pair in the plane perpendicular to `dir`, letting a riser carry the
- * orientation of the run it turned off instead of the bare fallback.
- */
-export function rectSectionAxes(dir, roll = 0) {
-    const d = dir.clone().normalize();
-    const xBase = new Vector3().crossVectors(UP, d);
-    if (xBase.lengthSq() < 1e-8)
-        xBase.set(1, 0, 0);
-    xBase.normalize();
-    const zBase = new Vector3().crossVectors(xBase, d);
-    const c = Math.cos(roll);
-    const s = Math.sin(roll);
-    const width = xBase.clone().multiplyScalar(c).addScaledVector(zBase, s);
-    const height = xBase.clone().multiplyScalar(-s).addScaledVector(zBase, c);
-    return { width, height };
-}
-/**
- * Roll (radians) that keeps a rect cross-section continuous across an
- * elbow: the dimension lying along the joint's hinge — the bend-plane
- * normal `portDir × newDir`, perpendicular to both legs — must stay on
- * the same physical face on the new run as on the source run. Returns 0
- * for an in-plane (degenerate-normal) joint, so horizontal turns keep
- * the natural width-horizontal orientation.
- */
-export function rollToContinueAcrossElbow(sourceDir, sourceRoll, portDir, newDir) {
-    const n = new Vector3().crossVectors(portDir, newDir);
-    if (n.lengthSq() < 1e-8)
-        return 0;
-    n.normalize();
-    const src = rectSectionAxes(sourceDir, sourceRoll);
-    const carriesWidth = Math.abs(src.width.dot(n)) >= Math.abs(src.height.dot(n));
-    const d = newDir.clone().normalize();
-    const xBase = new Vector3().crossVectors(UP, d);
-    if (xBase.lengthSq() < 1e-8)
-        xBase.set(1, 0, 0);
-    xBase.normalize();
-    const zBase = new Vector3().crossVectors(xBase, d);
-    // Place the hinge-aligned face on the same axis the source carries it.
-    return carriesWidth
-        ? Math.atan2(n.dot(zBase), n.dot(xBase))
-        : Math.atan2(-n.dot(xBase), n.dot(zBase));
-}
+const RADIAL_SEGMENTS = 24;
 /**
  * Rect box spanning `start`→`end`. Orientation comes from `rectSectionAxes`
  * (width horizontal, height vertical by default; `roll` reorients a riser

package/dist/duct-segment/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/duct-segment/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAQb,MAAM,kBAAkB,CAAA;AAoFzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CA4T3D,CAAA;eA0Dc,mBAAmB"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/duct-segment/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAQb,MAAM,kBAAkB,CAAA;AAoFzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CA2T3D,CAAA;eA0Dc,mBAAmB"}

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

@@ -12,7 +12,7 @@ import { DUCT_PORT_SYSTEMS } from '../shared/port-systems.js';
 import { startRunMoveConnectivity } from '../shared/run-move-connectivity.js';
 import { planRunTranslationOffsets, } from '../shared/run-translation-offset.js';
 import { translateWallRun } from '../shared/wall-run-move.js';
-import { rectSectionAxes } from './geometry.js';
+import { rectSectionAxes } from './profile.js';
 const GHOST_COLOR = '#818cf8';
 const GHOST_OPACITY = 0.5;
 const IN_TO_M = 0.0254;
@@ -130,8 +130,18 @@ export const MoveDuctSegmentTool = ({ node }) => {
             width: duct.width,
             height: duct.height,
         };
-        let lastTranslationPlan = null;
+        const translationPlanFor = (path) => portConnectivity
+            ? planRunTranslationOffsets({
+                duct,
+                translatedPath: path,
+                profile,
+                connections: portConnectivity.connections,
+                scenePorts,
+                nodesById,
+            })
+            : null;
         const setPreview = (path) => {
+            hasMovedRef.current = true;
             previewPathRef.current = path;
             setPreviewPath(path);
         };
@@ -142,10 +152,11 @@ export const MoveDuctSegmentTool = ({ node }) => {
             if (duct.wallAttachment && attachedWall?.type === 'wall') {
                 const wallMove = translateWallRun(originalPath, duct.wallAttachment, attachedWall, event);
                 if (wallMove) {
-                    hasMovedRef.current = true;
+                    // Connected joints that cannot follow hold the last shown frame.
+                    if (connectivity && !connectivity.preview({ path: wallMove.path }))
+                        return;
                     previewAttachmentRef.current = wallMove.attachment;
                     setPreview(wallMove.path);
-                    connectivity?.preview({ path: wallMove.path });
                     setTranslationGhost(null);
                     return;
                 }
@@ -181,25 +192,14 @@ export const MoveDuctSegmentTool = ({ node }) => {
                 triggerSFX('sfx:grid-snap');
             }
             prevSnapRef.current = cur;
-            hasMovedRef.current = true;
             const nextPath = originalPath.map(([x, y, z]) => [x + dx, y, z + dz]);
-            setPreview(nextPath);
-            lastTranslationPlan =
-                existedAtStart && portConnectivity
-                    ? planRunTranslationOffsets({
-                        duct,
-                        translatedPath: nextPath,
-                        profile,
-                        connections: portConnectivity.connections,
-                        scenePorts,
-                        nodesById,
-                    })
-                    : null;
-            if (lastTranslationPlan)
+            const translationPlan = translationPlanFor(nextPath);
+            if (translationPlan)
                 connectivity?.clear();
-            else
-                connectivity?.preview({ path: nextPath });
-            setTranslationGhost(lastTranslationPlan);
+            else if (connectivity && !connectivity.preview({ path: nextPath }))
+                return;
+            setPreview(nextPath);
+            setTranslationGhost(translationPlan);
         };
         const commit = (event, fromDragRelease = false) => {
             if (committed)
@@ -215,11 +215,22 @@ export const MoveDuctSegmentTool = ({ node }) => {
                 event.nativeEvent?.stopPropagation?.();
                 return;
             }
-            committed = true;
             const finalPath = previewPathRef.current;
+            const creating = isNew && !useScene.getState().nodes[nodeId];
+            const translationPlan = creating ? null : translationPlanFor(finalPath);
+            // 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 = creating || translationPlan || !connectivity
+                ? []
+                : connectivity.commitUpdates({ path: finalPath });
+            if (!followUpdates) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            committed = true;
             useScene.temporal.getState().resume();
             let selectId = nodeId;
-            if (isNew && !useScene.getState().nodes[nodeId]) {
+            if (creating) {
                 const created = DuctSegmentNode.parse({
                     ...node,
                     path: finalPath,
@@ -237,15 +248,6 @@ export const MoveDuctSegmentTool = ({ node }) => {
                 selectId = created.id;
             }
             else {
-                const translationPlan = portConnectivity &&
-                    planRunTranslationOffsets({
-                        duct,
-                        translatedPath: finalPath,
-                        profile,
-                        connections: portConnectivity.connections,
-                        scenePorts,
-                        nodesById,
-                    });
                 if (translationPlan) {
                     useScene.getState().applyNodeChanges({
                         create: [...translationPlan.fittings, ...translationPlan.connectors].map((created) => ({
@@ -265,9 +267,6 @@ export const MoveDuctSegmentTool = ({ node }) => {
                     });
                 }
                 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,

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;AAM5F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA0E/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAiJxE,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;AAM5F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA0E/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAgHxE,CAAA"}

package/dist/duct-segment/parametrics.js

@@ -3,7 +3,7 @@ import { Vector3 } from 'three';
 import { getDuctFittingPorts } from '../duct-fitting/ports.js';
 import { findAutomaticRunEndCapIds } from '../shared/automatic-run-end-cap.js';
 import { fittingDeletionPlansForRun } from '../shared/fitting-deletion-cleanup.js';
-import { rollToContinueAcrossElbow } from './geometry.js';
+import { rollToContinueAcrossElbow } from './profile.js';
 /** A run endpoint sitting this close to a collar counts as mated. */
 const MATE_TOL_M = 0.03;
 function dist2(a, b) {
@@ -100,7 +100,7 @@ export const ductSegmentParametrics = {
         ...findAutomaticRunEndCapIds(duct.id, nodes, 'duct-fitting'),
         ...fittingDeletionPlansForRun(duct, nodes, requestedDeleteIds, false).flatMap((plan) => plan.deleteFitting ? [plan.fittingId, ...plan.cascadeDeleteIds] : []),
     ],
-    trailingSection: () => import('../shared/run-hanger-inspector.js'),
+    trailingSection: () => import('./edit-inspector.js'),
     groups: [
         {
             label: 'Hangers',
@@ -145,39 +145,6 @@ export const ductSegmentParametrics = {
                     options: ['supply', 'return'],
                     display: 'segmented',
                 },
-                {
-                    key: 'shape',
-                    kind: 'enum',
-                    options: ['round', 'rect', 'oval'],
-                    display: 'segmented',
-                },
-                {
-                    key: 'diameter',
-                    kind: 'number',
-                    unit: 'in',
-                    min: 4,
-                    max: 24,
-                    step: 1,
-                    visibleIf: (n) => n.shape === 'round',
-                },
-                {
-                    key: 'width',
-                    kind: 'number',
-                    unit: 'in',
-                    min: 4,
-                    max: 60,
-                    step: 1,
-                    visibleIf: (n) => n.shape !== 'round',
-                },
-                {
-                    key: 'height',
-                    kind: 'number',
-                    unit: 'in',
-                    min: 3,
-                    max: 40,
-                    step: 1,
-                    visibleIf: (n) => n.shape !== 'round',
-                },
             ],
         },
         {

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

@@ -0,0 +1,42 @@
+import { Vector3 } from 'three';
+export declare const INCHES_TO_METERS = 0.0254;
+/**
+ * Area-equivalent round diameter (inches) for a rect cross-section —
+ * what a rect trunk advertises on its ports so round fittings / branches
+ * mate at a sensible size.
+ */
+export declare function equivalentDiameterIn(widthIn: number, heightIn: number): number;
+/**
+ * Area-equivalent round diameter (inches) for a flat-oval cross-section:
+ * a rectangle of (width − height) × height plus the two semicircular caps.
+ */
+export declare function ovalEquivalentDiameterIn(widthIn: number, heightIn: number): number;
+/** The diameter (inches) a duct segment presents at its ports. */
+export declare function ductPortDiameterIn(node: {
+    shape?: 'round' | 'rect' | 'oval';
+    diameter: number;
+    width?: number;
+    height?: number;
+}): number;
+/**
+ * Cross-section axes for a rect run along `dir`, rolled `roll` radians
+ * about the run direction. At roll 0: width is the horizontal axis
+ * (UP × dir) and height the vertical one — vertical runs, where that
+ * cross product degenerates, fall back to world X/Z. `roll` rotates the
+ * pair in the plane perpendicular to `dir`, letting a riser carry the
+ * orientation of the run it turned off instead of the bare fallback.
+ */
+export declare function rectSectionAxes(dir: Vector3, roll?: number): {
+    width: Vector3;
+    height: Vector3;
+};
+/**
+ * Roll (radians) that keeps a rect cross-section continuous across an
+ * elbow: the dimension lying along the joint's hinge — the bend-plane
+ * normal `portDir × newDir`, perpendicular to both legs — must stay on
+ * the same physical face on the new run as on the source run. Returns 0
+ * for an in-plane (degenerate-normal) joint, so horizontal turns keep
+ * the natural width-horizontal orientation.
+ */
+export declare function rollToContinueAcrossElbow(sourceDir: Vector3, sourceRoll: number, portDir: Vector3, newDir: Vector3): number;
+//# sourceMappingURL=profile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/duct-segment/profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAE/B,eAAO,MAAM,gBAAgB,SAAS,CAAA;AAGtC;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,kEAAkE;AAClE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAA;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,MAAM,CAQT;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,SAAI,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAW3F;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,OAAO,EAClB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,OAAO,GACd,MAAM,CAeR"}

package/dist/duct-segment/profile.js

@@ -0,0 +1,78 @@
+import { Vector3 } from 'three';
+export const INCHES_TO_METERS = 0.0254;
+const UP = new Vector3(0, 1, 0);
+/**
+ * Area-equivalent round diameter (inches) for a rect cross-section —
+ * what a rect trunk advertises on its ports so round fittings / branches
+ * mate at a sensible size.
+ */
+export function equivalentDiameterIn(widthIn, heightIn) {
+    return 2 * Math.sqrt((widthIn * heightIn) / Math.PI);
+}
+/**
+ * Area-equivalent round diameter (inches) for a flat-oval cross-section:
+ * a rectangle of (width − height) × height plus the two semicircular caps.
+ */
+export function ovalEquivalentDiameterIn(widthIn, heightIn) {
+    const minor = Math.min(widthIn, heightIn);
+    const major = Math.max(widthIn, heightIn);
+    const area = (major - minor) * minor + Math.PI * (minor / 2) ** 2;
+    return 2 * Math.sqrt(area / Math.PI);
+}
+/** The diameter (inches) a duct segment presents at its ports. */
+export function ductPortDiameterIn(node) {
+    if (node.shape === 'rect' && node.width && node.height) {
+        return equivalentDiameterIn(node.width, node.height);
+    }
+    if (node.shape === 'oval' && node.width && node.height) {
+        return ovalEquivalentDiameterIn(node.width, node.height);
+    }
+    return node.diameter;
+}
+/**
+ * Cross-section axes for a rect run along `dir`, rolled `roll` radians
+ * about the run direction. At roll 0: width is the horizontal axis
+ * (UP × dir) and height the vertical one — vertical runs, where that
+ * cross product degenerates, fall back to world X/Z. `roll` rotates the
+ * pair in the plane perpendicular to `dir`, letting a riser carry the
+ * orientation of the run it turned off instead of the bare fallback.
+ */
+export function rectSectionAxes(dir, roll = 0) {
+    const d = dir.clone().normalize();
+    const xBase = new Vector3().crossVectors(UP, d);
+    if (xBase.lengthSq() < 1e-8)
+        xBase.set(1, 0, 0);
+    xBase.normalize();
+    const zBase = new Vector3().crossVectors(xBase, d);
+    const c = Math.cos(roll);
+    const s = Math.sin(roll);
+    const width = xBase.clone().multiplyScalar(c).addScaledVector(zBase, s);
+    const height = xBase.clone().multiplyScalar(-s).addScaledVector(zBase, c);
+    return { width, height };
+}
+/**
+ * Roll (radians) that keeps a rect cross-section continuous across an
+ * elbow: the dimension lying along the joint's hinge — the bend-plane
+ * normal `portDir × newDir`, perpendicular to both legs — must stay on
+ * the same physical face on the new run as on the source run. Returns 0
+ * for an in-plane (degenerate-normal) joint, so horizontal turns keep
+ * the natural width-horizontal orientation.
+ */
+export function rollToContinueAcrossElbow(sourceDir, sourceRoll, portDir, newDir) {
+    const n = new Vector3().crossVectors(portDir, newDir);
+    if (n.lengthSq() < 1e-8)
+        return 0;
+    n.normalize();
+    const src = rectSectionAxes(sourceDir, sourceRoll);
+    const carriesWidth = Math.abs(src.width.dot(n)) >= Math.abs(src.height.dot(n));
+    const d = newDir.clone().normalize();
+    const xBase = new Vector3().crossVectors(UP, d);
+    if (xBase.lengthSq() < 1e-8)
+        xBase.set(1, 0, 0);
+    xBase.normalize();
+    const zBase = new Vector3().crossVectors(xBase, d);
+    // Place the hinge-aligned face on the same axis the source carries it.
+    return carriesWidth
+        ? Math.atan2(n.dot(zBase), n.dot(xBase))
+        : Math.atan2(-n.dot(xBase), n.dot(zBase));
+}

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":"AAgJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,QAAA,MAAM,8BAA8B,0CAuCnC,CAAA;eA68Cc,8BAA8B"}
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/duct-segment/selection.tsx"],"names":[],"mappings":"AAkJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,QAAA,MAAM,8BAA8B,0CAuCnC,CAAA;eA4gDc,8BAA8B"}