@willcgage/module-schematic 0.97.1 → 0.101.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 }];
@@ -1799,8 +1799,8 @@ function turnoutFacing(input) {
 function turnoutOccupiedSpan(input) {
   const e = input.extent;
   if (!e) return null;
-  const a = input.pos - input.facing * e.behindPoints;
-  const b = input.pos + input.facing * e.aheadOfPoints;
+  const a = input.pos - input.facing * e.behindFrog;
+  const b = input.pos + input.facing * e.pastFrog;
   return { fromPos: Math.min(a, b), toPos: Math.max(a, b) };
 }
 function resizeFlexPiece(pieces, index, nextLengthInches) {
@@ -1833,10 +1833,12 @@ function partExtent(part) {
   if (pts.source !== "measured" || overall.source !== "measured") return null;
   const frog = part?.frogOffset;
   const aheadOfPoints = overall.inches - pts.inches;
+  const frogMeasured = frog && frog.source === "measured";
   return {
     behindPoints: pts.inches,
     aheadOfPoints,
-    pastFrog: frog && frog.source === "measured" ? overall.inches - frog.inches : aheadOfPoints
+    pastFrog: frogMeasured ? overall.inches - frog.inches : aheadOfPoints,
+    behindFrog: frogMeasured ? frog.inches : pts.inches
   };
 }
 function partExtentForSize(size, library = BUILT_IN_TRACK_PARTS) {
@@ -2553,6 +2555,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) {
@@ -2623,12 +2702,13 @@ function walkTrackGraph(graph, pieces, startAt, library = BUILT_IN_TRACK_PARTS)
         const through = byKey.get(`${here.piece}.through`) ?? byKey.get(`${here.piece}.legA`);
         const body = gap(throat, through);
         const lead = part.lead?.inches ?? body / 2;
+        const frogAxial = part.frogOffset?.inches ?? (part.pointsOffset?.inches ?? 0) + lead;
         const dvj = byKey.get(`${here.piece}.diverge`) ?? byKey.get(`${here.piece}.legB`);
         const frogPt = throat && body > 0 && dvj ? {
-          x: throat.x + (dvj.x - throat.x) * lead / body,
-          y: throat.y + (dvj.y - throat.y) * lead / body
+          x: throat.x + (dvj.x - throat.x) * frogAxial / body,
+          y: throat.y + (dvj.y - throat.y) * frogAxial / body
         } : null;
-        const toFrog = here.joint === "throat" ? lead : here.joint === "diverge" || here.joint === "legB" ? frogPt && dvj ? Math.hypot(dvj.x - frogPt.x, dvj.y - frogPt.y) : Math.max(0, body - lead) : Math.max(0, body - lead);
+        const toFrog = here.joint === "throat" ? frogAxial : here.joint === "diverge" || here.joint === "legB" ? frogPt && dvj ? Math.hypot(dvj.x - frogPt.x, dvj.y - frogPt.y) : Math.max(0, body - frogAxial) : Math.max(0, body - frogAxial);
         const frogPos = pos + toFrog;
         if (here.joint === "diverge" || here.joint === "legB") {
           route.endsAt = here.piece;
@@ -2643,8 +2723,8 @@ function walkTrackGraph(graph, pieces, startAt, library = BUILT_IN_TRACK_PARTS)
           if (!d || queued.has(dk)) continue;
           queued.add(dk);
           const fp = throat && body > 0 ? {
-            x: throat.x + (d.x - throat.x) * lead / body,
-            y: throat.y + (d.y - throat.y) * lead / body
+            x: throat.x + (d.x - throat.x) * frogAxial / body,
+            y: throat.y + (d.y - throat.y) * frogAxial / body
           } : null;
           pending.push({
             from: here.piece,
@@ -2930,6 +3010,323 @@ function deriveGraphDoc(doc, library = BUILT_IN_TRACK_PARTS) {
   });
   return { doc: out.doc, warnings: out.warnings };
 }
+function placeableTurnoutParts(library, kind) {
+  return library.filter((p) => kind.includes(p.kind) && partGeometryGap(p) == null);
+}
+function moduleConversionReport(doc, library = BUILT_IN_TRACK_PARTS) {
+  if (doc.graph?.pieces?.length) {
+    return {
+      alreadyGraph: true,
+      offerable: false,
+      readyWithoutAsking: false,
+      turnouts: [],
+      unanswered: [],
+      orphanTracks: [],
+      blockers: []
+    };
+  }
+  const straight = placeableTurnoutParts(library, ["turnout"]);
+  const curved = placeableTurnoutParts(library, ["curved-turnout"]);
+  const blockers = [];
+  const turnouts = (doc.turnouts ?? []).map((t) => {
+    const wantCurved = t.curved === true;
+    const pool = wantCurved ? curved : straight;
+    const base = {
+      id: t.id,
+      name: t.name,
+      pos: t.pos,
+      size: t.size,
+      statedPartId: t.partId
+    };
+    const exact = t.size == null ? [] : pool.filter((p) => p.frogNumber === t.size);
+    const candidates = [...exact, ...pool.filter((p) => !exact.includes(p))].map((p) => p.id);
+    const resolve = (part, from) => ({
+      ...base,
+      partId: part.id,
+      from,
+      source: partGeometry(part, library)?.source ?? null,
+      why: null,
+      candidates
+    });
+    if (t.partId) {
+      const named = library.find((p) => p.id === t.partId);
+      if (named && partGeometryGap(named) == null) return resolve(named, "named");
+      return {
+        ...base,
+        partId: null,
+        from: "unresolved",
+        source: null,
+        why: named ? `this turnout names ${named.id}, which cannot be placed yet \u2014 ${partGeometryGap(named)}` : `this turnout names a part the library does not have (${t.partId})`,
+        candidates
+      };
+    }
+    if (t.size != null && exact.length) return resolve(exact[0], "frog-number");
+    return {
+      ...base,
+      partId: null,
+      from: "unresolved",
+      source: null,
+      why: t.size == null ? "the document never says what this turnout is \u2014 no part, no frog number" : wantCurved ? `no curved turnout is placeable yet, so a curved #${t.size} cannot be converted` : `no measured #${t.size} in the parts library yet`,
+      candidates
+    };
+  });
+  for (const c of doc.crossings ?? [])
+    blockers.push({
+      kind: "crossing",
+      ref: c.id,
+      why: "crossing geometry is not modelled yet, so a diamond has no piece to become"
+    });
+  if (doc.loop)
+    blockers.push({
+      kind: "loop",
+      why: "a balloon's curve radii were never recorded, and laying the loop would mean inventing them \u2014 the one thing ADR 0001 forbids"
+    });
+  const reached = new Set((doc.turnouts ?? []).map((t) => t.divergeTrack));
+  const orphanTracks = (doc.tracks ?? []).filter((t) => t.role !== "main" && !reached.has(t.id)).map((t) => ({
+    id: t.id,
+    ...t.trackName ? { trackName: t.trackName } : {},
+    role: t.role,
+    why: "no turnout in the document diverges onto this track, so there is nothing to join it to"
+  }));
+  const unanswered = turnouts.filter((t) => !t.partId).map((t) => t.id);
+  return {
+    alreadyGraph: false,
+    offerable: blockers.length === 0,
+    readyWithoutAsking: blockers.length === 0 && unanswered.length === 0 && orphanTracks.length === 0,
+    turnouts,
+    unanswered,
+    orphanTracks,
+    blockers
+  };
+}
+var CONVERSION_TIGHT_RADIUS_INCHES = 12;
+function docToGraph(doc, answers = {}, library = BUILT_IN_TRACK_PARTS) {
+  const refuse = (why) => ({
+    graph: null,
+    refused: why,
+    notLaid: [],
+    warnings: []
+  });
+  const report = moduleConversionReport(doc, library);
+  if (report.alreadyGraph) return refuse("this module is already authored as pieces");
+  if (!report.offerable) return refuse(report.blockers.map((b) => b.why).join("; "));
+  if ((doc.mainPath?.length ?? 0) > 2)
+    return refuse(
+      "this module's mainline is drawn with bends, and laying it as pieces would need each bend's radius \u2014 convert it once curved runs are supported"
+    );
+  const partById = new Map(library.map((p) => [p.id, p]));
+  const chosen = /* @__PURE__ */ new Map();
+  const unknown = [];
+  for (const t of report.turnouts) {
+    const id = answers.overrides?.[t.id] ?? (t.partId ? t.partId : answers.turnoutPartId) ?? null;
+    const part = id ? partById.get(id) : void 0;
+    if (!part || partGeometryGap(part)) unknown.push(t.id);
+    else chosen.set(t.id, part);
+  }
+  if (unknown.length)
+    return refuse(
+      `${unknown.length} turnout${unknown.length === 1 ? "" : "s"} still need identifying: ${unknown.join(", ")}`
+    );
+  const flexId = DEFAULT_FLEX_PART_ID;
+  if (!partById.get(flexId)) return refuse("the parts library has no flex track to lay plain track with");
+  const maxPiece = maxFlexPieceInches(flexId, library);
+  const tracks = doc.tracks ?? [];
+  const trackById = new Map(tracks.map((t) => [t.id, t]));
+  const turnouts = doc.turnouts ?? [];
+  const mainLen = doc.lengthInches ?? Math.max(0, ...tracks.map((t) => t.toPos ?? 0), ...turnouts.map((t) => t.pos));
+  if (!(mainLen > 0)) return refuse("this module has no length to lay track along");
+  const pieces = [];
+  const notLaid = [];
+  const warnings = [];
+  const rad = (d) => d * Math.PI / 180;
+  const norm180 = (d) => ((d + 180) % 360 + 360) % 360 - 180;
+  const r3 = (n) => Math.round(n * 1e3) / 1e3;
+  const jointsOf = (p) => placedJoints([p], library);
+  const jointAt = (p, id) => jointsOf(p).find((j) => j.joint === id) ?? null;
+  const transition = (id, from, toY, dirSign = 1) => {
+    const theta = rad(norm180(from.headingDeg - (dirSign > 0 ? 0 : 180)));
+    const dy = (toY - from.y) * dirSign;
+    if (Math.abs(theta) < 1e-9 || Math.abs(dy) < 1e-9) return null;
+    const R = dy / (1 - Math.cos(theta));
+    if (!Number.isFinite(R) || R === 0) return null;
+    const mag = Math.abs(R);
+    if (mag < CONVERSION_TIGHT_RADIUS_INCHES)
+      warnings.push(
+        `the curve bringing ${id} back parallel works out at ${mag.toFixed(1)}\u2033 radius \u2014 tighter than anyone lays by hand, which usually means the document's lane and its turnout disagree`
+      );
+    return {
+      id,
+      partId: flexId,
+      x: from.x,
+      y: from.y,
+      rotationDeg: from.headingDeg,
+      // Curving BACK toward the host: opposite the way we are already heading.
+      // `radiusInches` is signed and the sign IS the side.
+      radiusInches: r3(-Math.sign(theta) * mag),
+      lengthInches: r3(mag * Math.abs(theta))
+    };
+  };
+  const layTurnout = (t, hostY) => {
+    const part = chosen.get(t.id);
+    const geom = partGeometry(part, library);
+    const branch = trackById.get(t.divergeTrack);
+    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 facing = turnoutFacing({
+      pos: t.pos,
+      divergeFarPos,
+      flipped: t.flipped ?? false
+    });
+    const body = part.overallLength.inches;
+    const lead = part.lead?.inches ?? body / 2;
+    const frogAxial = part.frogOffset?.inches ?? (part.pointsOffset?.inches ?? 0) + lead;
+    const throatPos = facing > 0 ? t.pos - frogAxial : t.pos + frogAxial;
+    const hostLane = trackById.get(t.onTrack)?.lane ?? 0;
+    const want = Math.sign((branch?.lane ?? hostLane) - hostLane) || 1;
+    const unflipped = facing > 0 ? 1 : -1;
+    const piece = {
+      id: `t-${t.id}`,
+      partId: part.id,
+      x: throatPos,
+      y: hostY,
+      rotationDeg: facing > 0 ? 0 : 180,
+      ...unflipped !== want ? { flipped: true } : {},
+      ...t.name ? { name: t.name } : {}
+    };
+    const bodyEnds = [throatPos, facing > 0 ? throatPos + body : throatPos - body];
+    const span = { fromPos: Math.min(...bodyEnds), toPos: Math.max(...bodyEnds) };
+    const divergeId = geom.joints.find((j) => j.role === "diverge")?.id ?? "diverge";
+    return { t, piece, span, divergeId };
+  };
+  const layFlex = (label, hostY, fromPos, toPos, occupied, cuts) => {
+    const out = flexPieces({ fromPos, toPos, maxPieceInches: maxPiece, occupied, cuts: cuts ?? null });
+    out.forEach(
+      (f, i) => pieces.push({
+        id: `f-${label}-${i}`,
+        partId: flexId,
+        x: f.fromPos,
+        y: hostY,
+        rotationDeg: 0,
+        lengthInches: r3(f.lengthInches)
+      })
+    );
+    return out;
+  };
+  const turnoutsOn = (trackId, hostY) => turnouts.filter((t) => t.onTrack === trackId && chosen.has(t.id)).sort((a, b) => a.pos - b.pos).map((t) => layTurnout(t, hostY));
+  const main = trackById.get(MAIN_TRACK_ID) ?? tracks.find((t) => t.role === "main");
+  if (!main) return refuse("this module's document has no mainline to convert");
+  const mains = [main, ...tracks.filter((t) => t.role === "main" && t.id !== main.id)];
+  const laidTurnouts = /* @__PURE__ */ new Map();
+  const done = /* @__PURE__ */ new Set();
+  for (const m of mains) {
+    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);
+    }
+    layFlex(m.id, y, m.fromPos ?? 0, m.toPos ?? mainLen, on.map((l) => l.span), m.flexCuts);
+    done.add(m.id);
+  }
+  let progressed = true;
+  while (progressed) {
+    progressed = false;
+    for (const t of turnouts) {
+      if (!done.has(t.onTrack)) continue;
+      const branch = trackById.get(t.divergeTrack);
+      if (!branch || done.has(branch.id)) continue;
+      const near = laidTurnouts.get(t.id);
+      if (!near) continue;
+      done.add(branch.id);
+      progressed = true;
+      const dj = jointAt(near.piece, near.divergeId);
+      if (!dj) {
+        notLaid.push({ id: branch.id, why: `turnout ${t.id} has no diverging end to leave from` });
+        continue;
+      }
+      const branchY = laneOffsetAt(branch.lane ?? 0, 0);
+      const curve = transition(branch.id, { x: dj.x, y: dj.y, headingDeg: dj.headingDeg }, branchY);
+      let start = { x: dj.x, y: dj.y, headingDeg: dj.headingDeg };
+      if (curve) {
+        pieces.push(curve);
+        const e = jointAt(curve, "b");
+        if (e) start = { x: e.x, y: e.y, headingDeg: e.headingDeg };
+      }
+      const farSw = turnouts.find(
+        (o) => o.id !== t.id && o.divergeTrack === branch.id && laidTurnouts.has(o.id)
+      );
+      const farJoint = farSw ? (() => {
+        const f = laidTurnouts.get(farSw.id);
+        return jointAt(f.piece, f.divergeId);
+      })() : null;
+      let endX = farJoint != null ? farJoint.x : Math.max(branch.fromPos ?? t.pos, branch.toPos ?? t.pos);
+      let farCurve = null;
+      if (farJoint) {
+        farCurve = transition(
+          `${branch.id}-far`,
+          { x: farJoint.x, y: farJoint.y, headingDeg: farJoint.headingDeg },
+          branchY,
+          -1
+        );
+        if (farCurve) {
+          pieces.push(farCurve);
+          const e = jointAt(farCurve, "b");
+          if (e) endX = e.x;
+        }
+      }
+      if (endX - start.x <= 1e-6) {
+        notLaid.push({
+          id: branch.id,
+          why: `the turnout and the curve bringing this track parallel already reach ${start.x.toFixed(1)}\u2033, past where it has to end at ${endX.toFixed(1)}\u2033 \u2014 with the turnout chosen there is no room for this track where the document places it`
+        });
+        continue;
+      }
+      const on = turnoutsOn(branch.id, branchY).filter((l) => {
+        if (l.span.fromPos >= start.x - 1e-6) return true;
+        notLaid.push({
+          id: l.t.divergeTrack,
+          why: `turnout ${l.t.id} sits at ${l.t.pos}\u2033 but this track has only reached ${start.x.toFixed(1)}\u2033 by then \u2014 the ladder is pitched tighter than the chosen turnout allows`
+        });
+        return false;
+      });
+      for (const l of on) {
+        pieces.push(l.piece);
+        laidTurnouts.set(l.t.id, l);
+      }
+      layFlex(branch.id, branchY, start.x, endX, on.map((l) => l.span), branch.flexCuts);
+    }
+  }
+  const orphanWhy = new Map(report.orphanTracks.map((o) => [o.id, o.why]));
+  const alreadySaid = new Set(notLaid.map((n) => n.id));
+  for (const t of tracks) {
+    if (t.role === "main" || done.has(t.id) || alreadySaid.has(t.id)) continue;
+    notLaid.push({
+      id: t.id,
+      why: orphanWhy.get(t.id) ?? "the track it branches from could not be laid, so there is nothing to join it to"
+    });
+  }
+  const startOf = (t) => {
+    const y = laneOffsetAt(t.lane ?? 0, 0);
+    let best = null;
+    for (const p of pieces)
+      for (const j of jointsOf(p)) {
+        if (Math.abs(j.y - y) > 0.05) continue;
+        if (!best || j.x < best.x) best = { piece: p.id, joint: j.joint, x: j.x };
+      }
+    return best ? { piece: best.piece, joint: best.joint } : null;
+  };
+  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
+  };
+}
 function frogCasting(cl, opts = {}) {
   const g = opts.gaugeInches ?? RAIL_GAUGE_INCHES;
   const w = opts.reachInches ?? g * 1.5;
@@ -3608,6 +4005,7 @@ exports.crossoverPinches = crossoverPinches;
 exports.deriveEndplatePoses = deriveEndplatePoses;
 exports.deriveGraphDoc = deriveGraphDoc;
 exports.divergeSideForHand = divergeSideForHand;
+exports.docToGraph = docToGraph;
 exports.docToState = docToState;
 exports.emptyEditorState = emptyEditorState;
 exports.endplateCentreOffsetInches = endplateCentreOffsetInches;
@@ -3630,6 +4028,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;
@@ -3638,6 +4037,7 @@ exports.maxFlexPieceInches = maxFlexPieceInches;
 exports.mergeImportedParts = mergeImportedParts;
 exports.mergeStoredParts = mergeStoredParts;
 exports.moduleCenterline = moduleCenterline;
+exports.moduleConversionReport = moduleConversionReport;
 exports.moduleFeatures = moduleFeatures;
 exports.moduleFootprint = moduleFootprint;
 exports.moduleLengthFromSections = moduleLengthFromSections;