@willcgage/module-schematic 0.48.0 → 0.49.1

package/dist/index.cjs

@@ -478,6 +478,9 @@ function moduleFootprint(input) {
     // endplate A's face (the far face would be a spurious plate at the throat).
     endplateFaces: input.loop ? endplateFaceSegments(centerline, widthA, widthB, offA, offB).slice(0, 1) : endplateFaceSegments(centerline, widthA, widthB, offA, offB),
     outline: sectionOutlines.length || !authored ? null : sampleBenchworkOutline(authored),
+    // The donut hole, arc-sampled — only when there's a solid outline to punch it
+    // out of (a sectioned module isn't a donut). Renderers cut it from `outline`.
+    outlineInner: sectionOutlines.length || !authored || !input.outlineInner || input.outlineInner.length < 3 ? null : sampleBenchworkOutline(input.outlineInner),
     sectionOutlines
   };
 }
@@ -559,6 +562,7 @@ function emptyEditorState(lengthInches) {
     endplateWidths: {},
     endplateTrackOffsets: {},
     outline: [],
+    outlineInner: [],
     sectionBreaks: [],
     sections: [],
     controlPoints: [],
@@ -795,6 +799,8 @@ function stateToDoc(state, recordNumber) {
     // Benchwork footprint outline (module-local inches); only when it's a real
     // ring (≥ 3 vertices).
     ...state.outline.length >= 3 ? { outline: state.outline } : {},
+    // Benchwork hole (donut inner boundary), when it's a real ring.
+    ...state.outlineInner.length >= 3 ? { outlineInner: state.outlineInner } : {},
     // Internal section joints (inches from A), when the module has more than one.
     ...state.sectionBreaks.length ? { sectionBreaks: state.sectionBreaks } : {},
     // Sections as objects — emitted only once the owner has some, so a module
@@ -886,6 +892,11 @@ function docToState(doc, fallbackLength, moduleTracks = []) {
     y: p.y,
     ...Number.isFinite(p.bulge) && p.bulge ? { bulge: p.bulge } : {}
   }));
+  const outlineInner = (d.outlineInner ?? []).filter((p) => p && Number.isFinite(p.x) && Number.isFinite(p.y)).map((p) => ({
+    x: p.x,
+    y: p.y,
+    ...Number.isFinite(p.bulge) && p.bulge ? { bulge: p.bulge } : {}
+  }));
   const mainPath = trackPath(d.mainPath) ?? [];
   const main2Track_ = (d.tracks ?? []).find((t) => t.id === MAIN2_TRACK_ID);
   const main2Path = trackPath(d.main2Path ?? main2Track_?.path) ?? [];
@@ -909,6 +920,7 @@ function docToState(doc, fallbackLength, moduleTracks = []) {
     endplateWidths,
     endplateTrackOffsets,
     outline,
+    outlineInner,
     sectionBreaks: (d.sectionBreaks ?? []).filter((n) => Number.isFinite(n)).map((n) => sc(n)),
     sections: moduleSections(d),
     mainPath,
@@ -1334,36 +1346,7 @@ function returnLoop(shape, opts) {
     for (let i = 0; i <= steps; i++) out.push({ x: cx + r * Math.cos(a0 + (a12 - a0) * i / steps), y: cy + r * Math.sin(a0 + (a12 - a0) * i / steps) });
     return out;
   };
-  if (shape === "square") {
-    const s = 2 * R;
-    const loop2 = [
-      { x: L, y: 0 },
-      { x: L, y: R },
-      { x: L + s, y: R },
-      { x: L + s, y: -R },
-      { x: L, y: -R },
-      { x: L, y: 0 }
-    ];
-    return {
-      throat: T,
-      loop: rd(loop2),
-      wyeLegs: [rd([T, { x: L, y: R }]), rd([T, { x: L, y: -R }])],
-      wyeHalfAngleDeg: 90,
-      outlineOuter: rd([
-        { x: 0, y: hw },
-        { x: L + s + hw, y: hw },
-        { x: L + s + hw, y: -R - hw },
-        { x: 0, y: -R - hw }
-      ]),
-      outlineInner: rd([
-        { x: L + hw, y: R - hw },
-        { x: L + s - hw, y: R - hw },
-        { x: L + s - hw, y: -R + hw },
-        { x: L + hw, y: -R + hw }
-      ])
-    };
-  }
-  const D = shape === "circle" ? R * 1.15 : R * 1.6;
+  const D = shape === "circle" || shape === "square" ? R * 1.15 : R * 1.6;
   const offY = shape === "offset-teardrop" ? R * 0.7 : 0;
   const C = { x: L + D, y: offY };
   const dist = Math.hypot(C.x - T.x, C.y - T.y);
@@ -1381,15 +1364,47 @@ function returnLoop(shape, opts) {
     const xBot = C.x - Math.sqrt(Math.max(0, rr * rr - (-hw - C.y) ** 2));
     const tTop = Math.atan2(hw - C.y, xTop - C.x);
     const tBot = Math.atan2(-hw - C.y, xBot - C.x);
+    let end = tBot;
+    while (end >= tTop) end -= 2 * Math.PI;
     return [
       { x: 0, y: hw },
       { x: xTop, y: hw },
-      ...arc(C.x, C.y, rr, tTop, tBot - 2 * Math.PI, 48).slice(1, -1),
+      ...arc(C.x, C.y, rr, tTop, end, 48).slice(1, -1),
       { x: xBot, y: -hw },
       { x: 0, y: -hw }
     ];
   };
   const Ri = R - hw;
+  if (shape === "square") {
+    const xL = C.x - R - hw;
+    const xR = C.x + R + hw;
+    const yT = R + hw;
+    const outerSquare = [
+      { x: 0, y: hw },
+      { x: xL, y: hw },
+      { x: xL, y: yT },
+      { x: xR, y: yT },
+      { x: xR, y: -yT },
+      { x: xL, y: -yT },
+      { x: xL, y: -hw },
+      { x: 0, y: -hw }
+    ];
+    const iHalf = (R - hw) / Math.SQRT2;
+    const holeSquare = iHalf > 2 ? [
+      { x: C.x - iHalf, y: iHalf },
+      { x: C.x + iHalf, y: iHalf },
+      { x: C.x + iHalf, y: -iHalf },
+      { x: C.x - iHalf, y: -iHalf }
+    ] : [];
+    return {
+      throat: T,
+      loop: rd(loop),
+      wyeLegs: [rd([T, P1]), rd([T, P2])],
+      wyeHalfAngleDeg: r2(half * 180 / Math.PI),
+      outlineOuter: rd(outerSquare),
+      outlineInner: rd(holeSquare)
+    };
+  }
   return {
     throat: T,
     loop: rd(loop),