@willcgage/module-schematic 0.97.0 → 0.98.0

package/dist/index.cjs

@@ -229,7 +229,7 @@ function moduleCenterline(input) {
   if (drawn) return samplePath(drawn);
   const chained = sectionedCenterline(input);
   if (chained.length >= 2) return chained;
-  if (!input.geometryType) return [];
+  if (!input.geometryType && !input.hasPlacedTrack) return [];
   const L = input.lengthInches > 0 ? input.lengthInches : 24;
   const gt = input.geometryType;
   if (gt === "dead_end") return [{ x: 0, y: 0 }];
@@ -2313,6 +2313,16 @@ function pieceRoutePaths(piece, library = BUILT_IN_TRACK_PARTS) {
     const len = part.overallLength?.inches ?? BUMPER_DRAWN_INCHES;
     return [{ route: ["a", "a"], points: [{ x: at2.x, y: at2.y }, place(len, 0)] }];
   }
+  if (part.kind === "curve") {
+    const a = joints.find((j) => j.joint === "a");
+    const b = joints.find((j) => j.joint === "b");
+    if (!a || !b) return out;
+    const pts = flexRunPoints(sectionalArcInches(part), part.radius.inches).map(
+      (q) => place(q.x, q.y)
+    );
+    pts[pts.length - 1] = { x: b.x, y: b.y };
+    return [{ route: ["a", "b"], points: pts }];
+  }
   for (const route of geo.routes) {
     const a = at(route[0]);
     const b = at(route[1]);
@@ -2543,6 +2553,83 @@ function fitFlexBetween(piece, others, library = BUILT_IN_TRACK_PARTS, withinInc
     lengthInches: Math.round(len * 1e3) / 1e3
   };
 }
+function insertIntoRun(pieces, fresh, at, library = BUILT_IN_TRACK_PARTS, withinInches = 1) {
+  let host = null;
+  let bestD = Infinity;
+  for (const piece of pieces) {
+    const part = library.find((x) => x.id === piece.partId);
+    if (part?.kind !== "flex") continue;
+    for (const { points } of pieceRoutePaths(piece, library))
+      for (let i = 1; i < points.length; i++) {
+        const d = distanceToSegment(at, points[i - 1], points[i]);
+        if (d < bestD) {
+          bestD = d;
+          host = piece;
+        }
+      }
+  }
+  if (!host || bestD > withinInches) return null;
+  const L = host.lengthInches ?? 0;
+  const R = host.radiusInches;
+  const steps = 200;
+  let s = 0;
+  let closest = Infinity;
+  for (let i = 0; i <= steps; i++) {
+    const t = L * i / steps;
+    const local = flexRunEnd(t, R);
+    const world = placeLocal(host, local.x, local.y);
+    const d = Math.hypot(world.x - at.x, world.y - at.y);
+    if (d < closest) {
+      closest = d;
+      s = t;
+    }
+  }
+  const cutLocal = flexRunEnd(s, R);
+  const cut = placeLocal(host, cutLocal.x, cutLocal.y);
+  const heading = norm360(host.rotationDeg + (host.flipped ? -cutLocal.headingDeg : cutLocal.headingDeg));
+  const placed = { ...fresh, x: cut.x, y: cut.y, rotationDeg: heading };
+  const js = placedJoints([placed], library);
+  const entry = js.find((j) => j.joint === "throat" || j.joint === "a");
+  const exit = js.find((j) => j.joint === "through" || j.joint === "b");
+  if (!entry || !exit) return null;
+  const body = Math.hypot(exit.x - entry.x, exit.y - entry.y);
+  const rest = L - s - body;
+  if (s < 0 || rest < 0) return null;
+  const ids = new Set(pieces.map((p) => p.id));
+  let n = 1;
+  while (ids.has(`${host.id}b${n}`)) n += 1;
+  const tail = {
+    ...host,
+    id: `${host.id}b${n}`,
+    x: exit.x,
+    y: exit.y,
+    rotationDeg: exit.headingDeg,
+    lengthInches: rest
+  };
+  const out = pieces.map((p) => p.id === host.id ? { ...p, lengthInches: s } : p);
+  const kept = out.filter((p) => p.id !== host.id || s > 0);
+  return {
+    pieces: [...kept, placed, ...rest > 0 ? [tail] : []],
+    hostId: host.id,
+    insertedId: placed.id
+  };
+}
+function placeLocal(piece, x, y) {
+  const rad = piece.rotationDeg * Math.PI / 180;
+  const ly = piece.flipped ? -y : y;
+  return {
+    x: piece.x + x * Math.cos(rad) - ly * Math.sin(rad),
+    y: piece.y + x * Math.sin(rad) + ly * Math.cos(rad)
+  };
+}
+function distanceToSegment(p, a, b) {
+  const vx = b.x - a.x;
+  const vy = b.y - a.y;
+  const len2 = vx * vx + vy * vy;
+  if (len2 === 0) return Math.hypot(p.x - a.x, p.y - a.y);
+  const t = Math.max(0, Math.min(1, ((p.x - a.x) * vx + (p.y - a.y) * vy) / len2));
+  return Math.hypot(p.x - (a.x + t * vx), p.y - (a.y + t * vy));
+}
 var danglingDivergeWarning = (id) => `the route diverging at ${id} is not connected to anything`;
 var unreachedWarning = (id) => `${id} is not reachable from the endplate \u2014 nothing connects it`;
 function walkTrackGraph(graph, pieces, startAt, library = BUILT_IN_TRACK_PARTS) {
@@ -3620,6 +3707,7 @@ exports.graphToDoc = graphToDoc;
 exports.hasNoFarEndplate = hasNoFarEndplate;
 exports.importedPartToTrackPart = importedPartToTrackPart;
 exports.inchesToScaleFeet = inchesToScaleFeet;
+exports.insertIntoRun = insertIntoRun;
 exports.isLoopDoc = isLoopDoc;
 exports.isTransitionTurnout = isTransitionTurnout;
 exports.laneOffsetAt = laneOffsetAt;