@willcgage/module-schematic 0.108.0 → 0.110.0

package/dist/index.js

@@ -2927,27 +2927,49 @@ function graphToDoc(pieces, input) {
   const epA = endplates[0];
   const epB = endplates[1];
   const main = walk.routes.find((r) => r.id === "main");
-  const walk2 = input.start2 ? walkTrackGraph(graph, pieces, input.start2, library) : null;
-  const main2 = walk2?.routes.find((r) => r.id === "main") ?? null;
+  const start2Key = input.start2 ? `${input.start2.piece}.${input.start2.joint}` : null;
+  const start2IsOpenEnd = !!start2Key && graph.open.includes(start2Key);
+  const walk2 = input.start2 && start2IsOpenEnd ? walkTrackGraph(graph, pieces, input.start2, library) : null;
+  const main2FromBranch = (() => {
+    if (!start2Key || start2IsOpenEnd) return null;
+    const conn = graph.connections.find((c) => c.a === start2Key || c.b === start2Key);
+    if (!conn) return null;
+    const otherKey = conn.a === start2Key ? conn.b : conn.a;
+    const piece = graph.joints.find((j) => j.key === otherKey)?.piece;
+    return walk.routes.find((r) => r.id !== "main" && r.pieces[0] === piece) ?? null;
+  })();
+  const main2 = walk2?.routes.find((r) => r.id === "main") ?? main2FromBranch;
   const sharedByDesign = (id) => {
     const piece = pieces.find((p) => p.id === id);
     return library.find((p) => p.id === piece?.partId)?.kind === "crossover";
   };
-  const claimed = new Set(walk.routes.flatMap((r) => r.pieces).filter((p) => !sharedByDesign(p)));
-  if (main2 && main2.pieces.some((p) => claimed.has(p))) {
+  const mainPieces = new Set(main.pieces.filter((p) => !sharedByDesign(p)));
+  if (!main2FromBranch && main2 && main2.pieces.some((p) => mainPieces.has(p))) {
     warnings.push(
       "Main 2 starts on track that Main 1 already runs along \u2014 they are one run, not two"
     );
   }
-  const twoMains = !!main2 && !main2.pieces.some((p) => claimed.has(p));
-  const main2Lane = twoMains ? (graph.joints.find((j) => j.key === `${input.start2.piece}.${input.start2.joint}`)?.y ?? 1) >= 0 ? 1 : -1 : 0;
+  const twoMains = !!main2 && (!!main2FromBranch || !main2.pieces.some((p) => mainPieces.has(p)));
+  const main2AsBranch = walk2 && main2 && twoMains ? walk.routes.find(
+    (r) => r.id !== "main" && r.pieces.some((p) => main2.pieces.includes(p))
+  ) ?? null : null;
+  const main2Lane = twoMains ? (
+    // A branch-born main reaches its lane after an easement, so its SIDE is
+    // how far the run gets laterally, not where its first joint sits.
+    (main2FromBranch ? main2FromBranch.lateral : graph.joints.find((j) => j.key === start2Key)?.y ?? 1) >= 0 ? 1 : -1
+  ) : 0;
   const lengthInches = round(Math.max(main.toPos, twoMains ? main2.toPos : 0));
   const branches = [
-    ...walk.routes.filter((r) => r.id !== "main" && r.pieces.length),
-    ...twoMains ? walk2.routes.filter((r) => r.id !== "main" && r.pieces.length).map((r) => ({ ...r, id: `main2:${r.id}`, bornAt: r.bornAt })) : []
+    ...walk.routes.filter(
+      (r) => r.id !== "main" && r.pieces.length && r.id !== main2FromBranch?.id && r.id !== main2AsBranch?.id
+    ),
+    ...walk2 ? walk2.routes.filter((r) => r.id !== "main" && r.pieces.length).map((r) => ({ ...r, id: `main2:${r.id}`, bornAt: r.bornAt })) : []
   ];
   const trackIdOf = /* @__PURE__ */ new Map([["main", MAIN_TRACK_ID]]);
-  if (twoMains) trackIdOf.set("main2:main", MAIN2_TRACK_ID);
+  if (twoMains) {
+    trackIdOf.set(main2FromBranch ? main2FromBranch.id : "main2:main", MAIN2_TRACK_ID);
+    if (main2AsBranch) trackIdOf.set(main2AsBranch.id, MAIN2_TRACK_ID);
+  }
   for (const r of branches) trackIdOf.set(r.id, r.pieces[0]);
   const emitted = /* @__PURE__ */ new Set();
   const uniqueBranches = branches.filter((r) => {
@@ -2978,8 +3000,11 @@ function graphToDoc(pieces, input) {
         id: MAIN2_TRACK_ID,
         role: "main",
         lane: main2Lane,
-        from: epA?.id ?? "A",
-        ...epB ? { to: epB.id } : {},
+        // ⚠️ Only a main that CROSSES the endplates says so. A transition
+        // module's second main begins at a turnout partway along and ends
+        // at one endplate or neither; claiming A→B would tell the catalogue
+        // it presents two tracks at an end where it presents one.
+        ...main2FromBranch ? {} : { from: epA?.id ?? "A", ...epB ? { to: epB.id } : {} },
         // ⚠️ Its own extent, because a second main need not run the whole
         // module: on a transition module it starts or stops partway.
         fromPos: round(Math.min(main2.fromPos, main2.toPos)),
@@ -3024,7 +3049,7 @@ function graphToDoc(pieces, input) {
   const turnouts = [];
   const allTurnouts = [
     ...walk.turnouts,
-    ...twoMains ? walk2.turnouts.map((t) => ({
+    ...walk2 ? walk2.turnouts.map((t) => ({
       ...t,
       onRoute: t.onRoute === "main" ? "main2:main" : `main2:${t.onRoute}`,
       divergeRoute: t.divergeRoute ? `main2:${t.divergeRoute}` : null
@@ -3054,7 +3079,7 @@ function graphToDoc(pieces, input) {
     const found = [];
     const routesAll = [
       ...walk.routes.map((r) => ({ r, prefix: "" })),
-      ...twoMains ? walk2.routes.map((r) => ({ r, prefix: "main2:" })) : []
+      ...walk2 ? walk2.routes.map((r) => ({ r, prefix: "main2:" })) : []
     ];
     const seen = /* @__PURE__ */ new Map();
     for (const { r, prefix } of routesAll) {
@@ -3122,8 +3147,12 @@ function graphToDoc(pieces, input) {
   for (const t of tracks) {
     if (t.role === "main") continue;
     const ends = turnouts.filter((sw) => sw.divergeTrack === t.id);
-    if (ends.length >= 2 && new Set(ends.map((sw) => sw.onTrack)).size >= 2)
-      t.role = "crossover";
+    if (!(ends.length >= 2 && new Set(ends.map((sw) => sw.onTrack)).size >= 2)) continue;
+    t.role = "crossover";
+    const at = ends.map((sw) => sw.pos);
+    t.fromPos = round(Math.min(...at));
+    t.toPos = round(Math.max(...at));
+    t.lane = main2Lane || 1;
   }
   const place = (a, what) => {
     if (!a) return null;
@@ -3279,15 +3308,6 @@ function moduleConversionReport(doc, library = BUILT_IN_TRACK_PARTS) {
       candidates
     };
   });
-  const mainIds = new Set((doc.tracks ?? []).filter((t) => t.role === "main").map((t) => t.id));
-  for (const t of doc.turnouts ?? []) {
-    if (!mainIds.has(t.divergeTrack)) continue;
-    blockers.push({
-      kind: "turnout-opens-a-main",
-      ref: t.id,
-      why: `${t.name || t.id} opens ${t.divergeTrack}, which is a main \u2014 a main that begins at a turnout cannot be laid as pieces yet, and converting anyway would drop both it and the turnout`
-    });
-  }
   for (const c of doc.crossings ?? [])
     blockers.push({
       kind: "crossing",
@@ -3399,7 +3419,12 @@ function docToGraph(doc, answers = {}, library = BUILT_IN_TRACK_PARTS) {
     const ends = [branch?.fromPos, branch?.toPos].filter(
       (n) => typeof n === "number" && Number.isFinite(n)
     );
-    const divergeFarPos = ends.length ? ends.reduce((a, b) => Math.abs(b - t.pos) > Math.abs(a - t.pos) ? b : a) : void 0;
+    const divergeFarPos = (
+      // ⭐ A crossover half diverges TOWARD its partner. Its diverging track is a
+      // MAIN, whose ends are the whole module, so the ordinary rule has nothing
+      // useful to sign and would point it away from the turnout it feeds.
+      divergeFarOverride.get(t.id) ?? (ends.length ? ends.reduce((a, b) => Math.abs(b - t.pos) > Math.abs(a - t.pos) ? b : a) : void 0)
+    );
     const facing = turnoutFacing({
       pos: t.pos,
       divergeFarPos,
@@ -3516,18 +3541,69 @@ function docToGraph(doc, answers = {}, library = BUILT_IN_TRACK_PARTS) {
     fromPos: a.x0,
     toPos: a.x0 + a.geom.lengthInches
   }));
+  const mainIdsAll = new Set(mains.map((m) => m.id));
+  const attachment = /* @__PURE__ */ new Map();
+  for (const t of turnouts) {
+    const m = mains.find((x) => x.id === t.divergeTrack && x.id !== main.id);
+    if (!m) continue;
+    const from = m.fromPos ?? 0;
+    const to = m.toPos ?? mainLen;
+    if (from > 0 && Math.abs(t.pos - from) < 0.01) attachment.set(m.id, { sw: t, at: "from" });
+    else if (Math.abs(t.pos - to) < 0.01) attachment.set(m.id, { sw: t, at: "to" });
+  }
+  const mainToMainPairs = [];
+  {
+    const isMain = (id) => mainIdsAll.has(id);
+    const used = /* @__PURE__ */ new Set();
+    for (const t of turnouts) {
+      if (used.has(t.id) || !isMain(t.onTrack) || !isMain(t.divergeTrack)) continue;
+      if (t.onTrack === t.divergeTrack) continue;
+      const partner = turnouts.filter(
+        (u) => !used.has(u.id) && u.id !== t.id && u.onTrack === t.divergeTrack && u.divergeTrack === t.onTrack
+      ).sort((x, y) => Math.abs(x.pos - t.pos) - Math.abs(y.pos - t.pos))[0];
+      if (!partner) continue;
+      used.add(t.id);
+      used.add(partner.id);
+      mainToMainPairs.push({ a: t, b: partner });
+    }
+  }
+  const divergeFarOverride = /* @__PURE__ */ new Map();
+  for (const { a, b } of mainToMainPairs) {
+    divergeFarOverride.set(a.id, b.pos);
+    divergeFarOverride.set(b.id, a.pos);
+  }
   for (const m of mains) {
+    if (attachment.get(m.id)?.at === "from") continue;
     const y = laneOffsetAt(m.lane ?? 0, 0);
     const on = turnoutsOn(m.id, y);
     for (const l of on) {
       pieces.push(l.piece);
       laidTurnouts.set(l.t.id, l);
     }
+    let endPos = m.toPos ?? mainLen;
+    const closeAt = attachment.get(m.id);
+    if (closeAt?.at === "to") {
+      const l = laidTurnouts.get(closeAt.sw.id);
+      const fj = l ? jointAt(l.piece, l.divergeId) : null;
+      if (fj) {
+        const closing = transition(
+          `${m.id}-close`,
+          { x: fj.x, y: fj.y, headingDeg: fj.headingDeg },
+          y,
+          -1
+        );
+        if (closing) {
+          pieces.push(closing);
+          const e = jointAt(closing, "b");
+          if (e) endPos = e.x;
+        } else endPos = fj.x;
+      }
+    }
     const laidFlex = layFlex(
       m.id,
       y,
       m.fromPos ?? 0,
-      m.toPos ?? mainLen,
+      endPos,
       [...on.map((l) => l.span), ...assemblySpans],
       m.flexCuts
     );
@@ -3549,6 +3625,35 @@ function docToGraph(doc, answers = {}, library = BUILT_IN_TRACK_PARTS) {
     done.add(m.id);
   }
   for (const id of assemblyTracks) done.add(id);
+  for (const [i, pair] of mainToMainPairs.entries()) {
+    const la = laidTurnouts.get(pair.a.id);
+    const lb = laidTurnouts.get(pair.b.id);
+    if (!la || !lb) continue;
+    const ja = jointAt(la.piece, la.divergeId);
+    const jb = jointAt(lb.piece, lb.divergeId);
+    if (!ja || !jb) continue;
+    const dx = jb.x - ja.x;
+    const dy = jb.y - ja.y;
+    const len = Math.hypot(dx, dy);
+    if (!(len > 1e-6)) {
+      notLaid.push({
+        id: pair.a.divergeTrack,
+        why: `${pair.a.name || pair.a.id} and ${pair.b.name || pair.b.id} meet at the same point, so there is no track between them to lay`
+      });
+      continue;
+    }
+    pieces.push({
+      id: `xc-${i}`,
+      partId: flexId,
+      x: ja.x,
+      y: ja.y,
+      rotationDeg: Math.atan2(dy, dx) * 180 / Math.PI,
+      lengthInches: r3(len)
+    });
+    warnings.push(
+      `${pair.a.name || pair.a.id} and ${pair.b.name || pair.b.id} are laid as two separate turnouts with a ${len.toFixed(1)}\u2033 piece of track between them, which is what the document describes. If they are really one crossover assembly, name the product on a connector track and it will be laid as the single piece it is.`
+    );
+  }
   let progressed = true;
   while (progressed) {
     progressed = false;
@@ -3661,13 +3766,19 @@ function docToGraph(doc, answers = {}, library = BUILT_IN_TRACK_PARTS) {
   };
   const startAt = startOf(main);
   if (!startAt) return refuse("nothing was laid on the mainline, so the module has no starting point");
-  const second = mains[1] ? startOf(mains[1]) : null;
-  return {
-    graph: { pieces, startAt, ...second ? { start2: second } : {} },
-    refused: null,
-    notLaid,
-    warnings
-  };
+  const second = mains[1] ? attachment.get(mains[1].id)?.at === "from" ? (() => {
+    const l = laidTurnouts.get(attachment.get(mains[1].id).sw.id);
+    return l ? { piece: l.piece.id, joint: l.divergeId } : null;
+  })() : startOf(mains[1]) : null;
+  const graph = { pieces, startAt, ...second ? { start2: second } : {} };
+  const derived = graphToDoc(pieces, {
+    startAt,
+    start2: second ?? null,
+    base: doc,
+    library
+  });
+  warnings.push(...derived.warnings);
+  return { graph, refused: null, notLaid, warnings };
 }
 function frogCasting(cl, opts = {}) {
   const g = opts.gaugeInches ?? RAIL_GAUGE_INCHES;