@willcgage/module-schematic 0.84.0 → 0.86.0

package/dist/index.cjs

@@ -871,6 +871,10 @@ function withPoses(endplates, overrides) {
     (e) => overrides[e.id] ? { ...e, pose: overrides[e.id], poseAuthored: true } : e
   );
 }
+function withEdges(endplates, edges) {
+  if (!edges) return endplates;
+  return endplates.map((e) => edges[e.id] ? { ...e, edge: edges[e.id] } : e);
+}
 function withWidths(endplates, widths, offsets = {}) {
   return endplates.map((e) => {
     const w = widths[e.id];
@@ -902,46 +906,49 @@ function stateToDoc(state, recordNumber) {
     ...state.loop && state.loopReturn === "main2" ? { loopReturn: "main2" } : {},
     ...state.mainsSwapped ? { mainsSwapped: true } : {},
     endplates: withWidths(
-      withPoses(
-        [
-          ...state.loop ? (
-            // Balloon loop: A is the entry. A standard endplate B on the balloon
-            // makes it an INTERCHANGE (second route connects at the loop, e.g.
-            // Seaford); configB "none" makes it a pure turnback.
-            [
-              { id: "A", label: "Entry", tracks: [{ trackId: MAIN_TRACK_ID, lane: 0, config: state.configA }] },
-              ...state.configB !== "none" ? [{ id: "B", label: "Interchange", tracks: [{ trackId: MAIN_TRACK_ID, lane: 0, config: state.configB }] }] : []
-            ]
-          ) : [
-            { id: "A", label: "West", tracks: [{ trackId: MAIN_TRACK_ID, lane: 0, config: state.configA }] },
-            // ⚠️ `configB: "none"` means the module HAS NO FAR ENDPLATE, and
-            // that is not loop-only (#184). An *end of the line* or a *pocket*
-            // presents one conforming face and the track simply stops. The
-            // standard governs the ends a module offers for joining; it never
-            // required a module to offer two. This used to coerce "none" to
-            // "single" and emit a B regardless, so a single-ended module was
-            // impossible to author.
-            ...state.configB !== "none" ? [
-              {
-                id: "B",
-                label: "East",
-                tracks: [{ trackId: MAIN_TRACK_ID, lane: 0, config: state.configB }]
-              }
-            ] : []
+      withEdges(
+        withPoses(
+          [
+            ...state.loop ? (
+              // Balloon loop: A is the entry. A standard endplate B on the balloon
+              // makes it an INTERCHANGE (second route connects at the loop, e.g.
+              // Seaford); configB "none" makes it a pure turnback.
+              [
+                { id: "A", label: "Entry", tracks: [{ trackId: MAIN_TRACK_ID, lane: 0, config: state.configA }] },
+                ...state.configB !== "none" ? [{ id: "B", label: "Interchange", tracks: [{ trackId: MAIN_TRACK_ID, lane: 0, config: state.configB }] }] : []
+              ]
+            ) : [
+              { id: "A", label: "West", tracks: [{ trackId: MAIN_TRACK_ID, lane: 0, config: state.configA }] },
+              // ⚠️ `configB: "none"` means the module HAS NO FAR ENDPLATE, and
+              // that is not loop-only (#184). An *end of the line* or a *pocket*
+              // presents one conforming face and the track simply stops. The
+              // standard governs the ends a module offers for joining; it never
+              // required a module to offer two. This used to coerce "none" to
+              // "single" and emit a B regardless, so a single-ended module was
+              // impossible to author.
+              ...state.configB !== "none" ? [
+                {
+                  id: "B",
+                  label: "East",
+                  tracks: [{ trackId: MAIN_TRACK_ID, lane: 0, config: state.configB }]
+                }
+              ] : []
+            ],
+            // Branch endplates C, D, … — junction connections at pos, off one side
+            // (#170). A set can carry several (e.g. a second railroad through).
+            ...state.branches.map((b, i) => ({
+              id: String.fromCharCode(67 + i),
+              // C, D, E…
+              label: b.label || `Branch ${i + 1}`,
+              tracks: [{ trackId: MAIN_TRACK_ID, lane: 0, config: b.config }],
+              at: { pos: b.pos, side: b.side },
+              kind: b.kind ?? "branch",
+              ...b.trackId ? { trackId: b.trackId } : {}
+            }))
           ],
-          // Branch endplates C, D, … — junction connections at pos, off one side
-          // (#170). A set can carry several (e.g. a second railroad through).
-          ...state.branches.map((b, i) => ({
-            id: String.fromCharCode(67 + i),
-            // C, D, E…
-            label: b.label || `Branch ${i + 1}`,
-            tracks: [{ trackId: MAIN_TRACK_ID, lane: 0, config: b.config }],
-            at: { pos: b.pos, side: b.side },
-            kind: b.kind ?? "branch",
-            ...b.trackId ? { trackId: b.trackId } : {}
-          }))
-        ],
-        state.poseOverrides
+          state.poseOverrides
+        ),
+        state.endplateEdges
       ),
       state.endplateWidths,
       state.endplateTrackOffsets
@@ -1137,7 +1144,15 @@ function docToState(doc, fallbackLength, moduleTracks = []) {
   const poseOverrides = poseOverridesFromDoc(d);
   const endplateWidths = {};
   const endplateTrackOffsets = {};
+  const endplateEdges = {};
   for (const e of d.endplates ?? []) {
+    if (e.edge && Number.isFinite(e.edge.index) && e.edge.index >= 0)
+      endplateEdges[e.id] = {
+        index: Math.trunc(e.edge.index),
+        ...e.edge.section ? { section: e.edge.section } : {},
+        ...Number.isFinite(e.edge.fromT) ? { fromT: e.edge.fromT } : {},
+        ...Number.isFinite(e.edge.toT) ? { toT: e.edge.toT } : {}
+      };
     if (typeof e.widthInches === "number" && e.widthInches > 0)
       endplateWidths[e.id] = e.widthInches;
     if (typeof e.trackOffsetInches === "number" && Number.isFinite(e.trackOffsetInches))
@@ -1188,6 +1203,7 @@ function docToState(doc, fallbackLength, moduleTracks = []) {
     flexByTrack,
     endplateWidths,
     endplateTrackOffsets,
+    endplateEdges,
     outline,
     outlineInner,
     sectionBreaks: (d.sectionBreaks ?? []).filter((n) => Number.isFinite(n)).map((n) => sc(n)),
@@ -2229,6 +2245,197 @@ function partsPlaceable(library = BUILT_IN_TRACK_PARTS) {
   }
   return { placeable, blocked };
 }
+var JOINT_SNAP_INCHES = 0.01;
+function placedJoints(pieces, library = BUILT_IN_TRACK_PARTS) {
+  const out = [];
+  const RAD = Math.PI / 180;
+  for (const p of pieces) {
+    const part = library.find((x) => x.id === p.partId);
+    if (!part) continue;
+    const geo = partGeometry(part, library);
+    if (!geo) continue;
+    const c = Math.cos(p.rotationDeg * RAD);
+    const s = Math.sin(p.rotationDeg * RAD);
+    for (const j of geo.joints) {
+      const lx = part.kind === "flex" && j.id === "b" ? p.lengthInches ?? 0 : j.x;
+      const ly = p.flipped ? -j.y : j.y;
+      const h = (p.flipped ? -j.angleDeg : j.angleDeg) + p.rotationDeg;
+      out.push({
+        key: `${p.id}.${j.id}`,
+        piece: p.id,
+        joint: j.id,
+        role: j.role,
+        x: p.x + lx * c - ly * s,
+        y: p.y + lx * s + ly * c,
+        headingDeg: norm360(h)
+      });
+    }
+  }
+  return out;
+}
+function buildTrackGraph(pieces, library = BUILT_IN_TRACK_PARTS, snapInches = JOINT_SNAP_INCHES) {
+  const joints = placedJoints(pieces, library);
+  const unplaceable = [];
+  for (const p of pieces) {
+    const part = library.find((x) => x.id === p.partId);
+    if (!part) {
+      unplaceable.push({ piece: p.id, partId: p.partId, why: "no such part in the library" });
+      continue;
+    }
+    const why = partGeometryGap(part);
+    if (why) unplaceable.push({ piece: p.id, partId: p.partId, why });
+  }
+  const groups = [];
+  const taken = /* @__PURE__ */ new Set();
+  for (const j of joints) {
+    if (taken.has(j.key)) continue;
+    const g = [j];
+    taken.add(j.key);
+    for (const k of joints) {
+      if (taken.has(k.key) || k.piece === j.piece) continue;
+      if (Math.hypot(k.x - j.x, k.y - j.y) <= snapInches) {
+        g.push(k);
+        taken.add(k.key);
+      }
+    }
+    groups.push(g);
+  }
+  const connections = [];
+  const open = [];
+  const conflicts = [];
+  for (const g of groups) {
+    if (g.length === 1) open.push(g[0].key);
+    else if (g.length === 2) connections.push({ a: g[0].key, b: g[1].key });
+    else {
+      conflicts.push({
+        x: g[0].x,
+        y: g[0].y,
+        joints: g.map((j) => j.key),
+        reason: `${g.length} track ends are stacked in one place. Rail has two ends, so a junction of three is a turnout, not a joint \u2014 none of these are joined until one is moved.`
+      });
+      for (const j of g) open.push(j.key);
+    }
+  }
+  return { joints, connections, open, conflicts, unplaceable };
+}
+function walkTrackGraph(graph, pieces, startAt, library = BUILT_IN_TRACK_PARTS) {
+  const byKey = new Map(graph.joints.map((j) => [j.key, j]));
+  const pieceById = new Map(pieces.map((p) => [p.id, p]));
+  const link = /* @__PURE__ */ new Map();
+  for (const c of graph.connections) {
+    link.set(c.a, c.b);
+    link.set(c.b, c.a);
+  }
+  const partOf = (pid) => {
+    const p = pieceById.get(pid);
+    return p ? library.find((x) => x.id === p.partId) : void 0;
+  };
+  const geoOf = (pid) => {
+    const part = partOf(pid);
+    return part ? partGeometry(part, library) : null;
+  };
+  const gap = (a, b) => a && b ? Math.hypot(a.x - b.x, a.y - b.y) : 0;
+  const routes = [];
+  const turnouts = [];
+  const warnings = [];
+  const queued = /* @__PURE__ */ new Set();
+  const pending = [];
+  const walk = (startKey, startPos, id, bornAt) => {
+    const route = {
+      id,
+      fromPos: startPos,
+      toPos: startPos,
+      bornAt,
+      endsAt: null,
+      pieces: [],
+      lateral: 0
+    };
+    let cur = startKey;
+    let pos = startPos;
+    const guard = /* @__PURE__ */ new Set();
+    while (cur && !guard.has(cur)) {
+      guard.add(cur);
+      const here = byKey.get(cur);
+      if (!here) break;
+      const geo = geoOf(here.piece);
+      if (!geo) break;
+      const opts = geo.routes.filter((r) => r.includes(here.joint));
+      if (!opts.length) break;
+      const pick = opts.find((r) => r.includes("through")) ?? opts[0];
+      const exitJoint = pick[0] === here.joint ? pick[1] : pick[0];
+      const exit = byKey.get(`${here.piece}.${exitJoint}`);
+      const part = partOf(here.piece);
+      if (part && (part.kind === "turnout" || part.kind === "wye")) {
+        const throat = byKey.get(`${here.piece}.throat`);
+        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 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
+        } : 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 frogPos = pos + toFrog;
+        if (here.joint === "diverge" || here.joint === "legB") {
+          route.endsAt = here.piece;
+          const known = turnouts.find((t) => t.id === here.piece);
+          route.toPos = known ? known.pos : frogPos;
+          break;
+        }
+        turnouts.push({ id: here.piece, pos: frogPos, onRoute: id, divergeRoute: null });
+        for (const dj of ["diverge", "legB"]) {
+          const dk = `${here.piece}.${dj}`;
+          const d = byKey.get(dk);
+          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
+          } : null;
+          pending.push({
+            from: here.piece,
+            at: frogPos,
+            joint: dk,
+            skew: fp ? Math.hypot(d.x - fp.x, d.y - fp.y) : 0
+          });
+        }
+      }
+      route.pieces.push(here.piece);
+      for (const j of graph.joints)
+        if (j.piece === here.piece && Math.abs(j.y) > Math.abs(route.lateral))
+          route.lateral = j.y;
+      pos += gap(here, exit);
+      route.toPos = pos;
+      const next = exit ? link.get(exit.key) : void 0;
+      if (!next) break;
+      cur = next;
+    }
+    return route;
+  };
+  routes.push(walk(`${startAt.piece}.${startAt.joint}`, 0, "main", null));
+  let n = 0;
+  while (pending.length) {
+    const b = pending.shift();
+    const start = link.get(b.joint);
+    if (!start) {
+      warnings.push(`the route diverging at ${b.from} is not connected to anything`);
+      continue;
+    }
+    n += 1;
+    const r = walk(start, b.at + b.skew, `route${n}`, b.from);
+    r.fromPos = b.at;
+    routes.push(r);
+    const sw = turnouts.find((t) => t.id === b.from);
+    if (sw && !sw.divergeRoute) sw.divergeRoute = r.id;
+  }
+  const reached = new Set(routes.flatMap((r) => r.pieces));
+  for (const p of pieces)
+    if (!reached.has(p.id) && !graph.unplaceable.some((u) => u.piece === p.id))
+      warnings.push(`${p.id} is not reachable from the endplate \u2014 nothing connects it`);
+  for (const c of graph.conflicts) warnings.push(c.reason);
+  return { routes, turnouts, warnings };
+}
 function frogCasting(cl, opts = {}) {
   const g = opts.gaugeInches ?? RAIL_GAUGE_INCHES;
   const w = opts.reachInches ?? g * 1.5;
@@ -2534,6 +2741,45 @@ function moduleFeatures(doc) {
     laneMax: Math.max(...allLanes)
   };
 }
+function endplateEdgePose(outline, edge) {
+  if (!outline || outline.length < 3) return null;
+  const n = outline.length;
+  const i = Math.trunc(edge.index);
+  if (!Number.isFinite(i) || i < 0 || i >= n) return null;
+  const p0 = outline[i];
+  const p1 = outline[(i + 1) % n];
+  if (p0.bulge) return null;
+  const t0 = Math.max(0, Math.min(1, edge.fromT ?? 0));
+  const t1 = Math.max(0, Math.min(1, edge.toT ?? 1));
+  const a = { x: p0.x + (p1.x - p0.x) * Math.min(t0, t1), y: p0.y + (p1.y - p0.y) * Math.min(t0, t1) };
+  const b = { x: p0.x + (p1.x - p0.x) * Math.max(t0, t1), y: p0.y + (p1.y - p0.y) * Math.max(t0, t1) };
+  const w = Math.hypot(b.x - a.x, b.y - a.y);
+  if (!(w > 0)) return null;
+  let cx = 0;
+  let cy = 0;
+  for (const v of outline) {
+    cx += v.x;
+    cy += v.y;
+  }
+  cx /= n;
+  cy /= n;
+  const mid = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+  const ex = (b.x - a.x) / w;
+  const ey = (b.y - a.y) / w;
+  let nx = ey;
+  let ny = -ex;
+  if ((mid.x - cx) * nx + (mid.y - cy) * ny < 0) {
+    nx = -nx;
+    ny = -ny;
+  }
+  return {
+    x: mid.x,
+    y: mid.y,
+    heading: norm360(Math.atan2(ny, nx) * 180 / Math.PI),
+    widthInches: w,
+    face: [a, b]
+  };
+}
 function returnLoop(shape, opts) {
   const L = Math.max(1, opts.leadInches);
   const R = Math.max(1, opts.radius);
@@ -2637,6 +2883,21 @@ function deriveEndplatePoses(geo) {
   const half = geo.trackHalfSpacingInches ?? 1;
   const cfg = (i) => geo.endplateConfigs?.[i] === "double" ? "double" : "single";
   const withOverride = (p) => {
+    const bound = geo.endplateEdges?.[p.id];
+    if (bound) {
+      const outline = (bound.section ? geo.sections?.find((s) => s.id === bound.section)?.outline : geo.outline) ?? geo.outline;
+      const e = endplateEdgePose(outline, bound);
+      if (e)
+        return {
+          ...p,
+          x: e.x,
+          y: e.y,
+          heading: e.heading,
+          widthInches: e.widthInches,
+          face: e.face,
+          boundToEdge: true
+        };
+    }
     const o = geo.poseOverrides?.[p.id];
     return o ? { ...p, x: o.x, y: o.y, heading: norm360(o.heading), manual: true } : p;
   };
@@ -2822,6 +3083,7 @@ exports.FREEMO_ENDPLATE_TRACK_FASCIA_CLEARANCE_INCHES = FREEMO_ENDPLATE_TRACK_FA
 exports.FREEMO_ENDPLATE_WIDTH_MIN_INCHES = FREEMO_ENDPLATE_WIDTH_MIN_INCHES;
 exports.FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES = FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES;
 exports.FREEMO_TRACK_SPACING_INCHES = FREEMO_TRACK_SPACING_INCHES;
+exports.JOINT_SNAP_INCHES = JOINT_SNAP_INCHES;
 exports.MAIN2_TRACK_ID = MAIN2_TRACK_ID;
 exports.MAIN_TRACK_ID = MAIN_TRACK_ID;
 exports.N_CAR_LENGTH_INCHES = N_CAR_LENGTH_INCHES;
@@ -2838,6 +3100,7 @@ exports.benchworkBand = benchworkBand;
 exports.benchworkOutline = benchworkOutline;
 exports.buildCrossover = buildCrossover;
 exports.buildPassingSiding = buildPassingSiding;
+exports.buildTrackGraph = buildTrackGraph;
 exports.buildTransition = buildTransition;
 exports.carCapacity = carCapacity;
 exports.checkEndplateWidth = checkEndplateWidth;
@@ -2848,6 +3111,7 @@ exports.divergeSideForHand = divergeSideForHand;
 exports.docToState = docToState;
 exports.emptyEditorState = emptyEditorState;
 exports.endplateCentreOffsetInches = endplateCentreOffsetInches;
+exports.endplateEdgePose = endplateEdgePose;
 exports.endplateFaceSegments = endplateFaceSegments;
 exports.endplateLead = endplateLead;
 exports.endplateTrackOffsetInches = endplateTrackOffsetInches;
@@ -2885,6 +3149,7 @@ exports.partOutlineAtFrog = partOutlineAtFrog;
 exports.partsPlaceable = partsPlaceable;
 exports.pastFrogInchesForSize = pastFrogInchesForSize;
 exports.pathLengthInches = pathLengthInches;
+exports.placedJoints = placedJoints;
 exports.poseNeedsManual = poseNeedsManual;
 exports.poseOverridesFromDoc = poseOverridesFromDoc;
 exports.remapPos = remapPos;
@@ -2917,5 +3182,6 @@ exports.turnoutFacing = turnoutFacing;
 exports.turnoutOccupiedSpan = turnoutOccupiedSpan;
 exports.turnoutPartForSize = turnoutPartForSize;
 exports.usableCapacity = usableCapacity;
+exports.walkTrackGraph = walkTrackGraph;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map