@willcgage/module-schematic 0.47.0 → 0.49.0

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,
@@ -1322,6 +1334,84 @@ function moduleFeatures(doc) {
     laneMax: Math.max(...allLanes)
   };
 }
+function returnLoop(shape, opts) {
+  const L = Math.max(1, opts.leadInches);
+  const R = Math.max(1, opts.radius);
+  const hw = Math.min(opts.boardHalfWidth ?? 6, R - 1);
+  const T = { x: L, y: 0 };
+  const r2 = (v) => Math.round(v * 100) / 100;
+  const rd = (pts) => pts.map((p) => ({ x: r2(p.x), y: r2(p.y) }));
+  const arc = (cx, cy, r, a0, a12, steps) => {
+    const out = [];
+    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;
+  };
+  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);
+  const ac = Math.acos(Math.min(1, R / dist));
+  const base = Math.atan2(T.y - C.y, T.x - C.x);
+  const a1 = base + ac;
+  const a2 = base - ac;
+  const P1 = { x: C.x + R * Math.cos(a1), y: C.y + R * Math.sin(a1) };
+  const P2 = { x: C.x + R * Math.cos(a2), y: C.y + R * Math.sin(a2) };
+  const loop = [T, P1, ...arc(C.x, C.y, R, a1, a2 + 2 * Math.PI, 64).slice(1), T];
+  const legDir = (P) => Math.atan2(P.y - T.y, P.x - T.x);
+  const half = Math.abs((legDir(P1) - legDir(P2) + Math.PI) % (2 * Math.PI) - Math.PI) / 2;
+  const ringOuter = (rr) => {
+    const xTop = C.x - Math.sqrt(Math.max(0, rr * rr - (hw - C.y) ** 2));
+    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);
+    return [
+      { x: 0, y: hw },
+      { x: xTop, y: hw },
+      ...arc(C.x, C.y, rr, tTop, tBot - 2 * Math.PI, 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),
+    wyeLegs: [rd([T, P1]), rd([T, P2])],
+    wyeHalfAngleDeg: r2(half * 180 / Math.PI),
+    outlineOuter: rd(ringOuter(R + hw)),
+    outlineInner: Ri > 2 ? rd(arc(C.x, C.y, Ri, 0, 2 * Math.PI, 40)) : []
+  };
+}
 function geometryTurnDegrees(geometryType, geometryDegrees) {
   switch (geometryType) {
     case "corner_45":
@@ -1535,6 +1625,7 @@ exports.nextId = nextId;
 exports.poseNeedsManual = poseNeedsManual;
 exports.poseOverridesFromDoc = poseOverridesFromDoc;
 exports.remapPos = remapPos;
+exports.returnLoop = returnLoop;
 exports.sampleBenchworkOutline = sampleBenchworkOutline;
 exports.samplePath = samplePath;
 exports.scaleFeetToInches = scaleFeetToInches;