@willcgage/module-schematic 0.83.2 → 0.85.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)),
@@ -2128,6 +2144,107 @@ function turnoutClosure(size, opts = {}) {
     }
   };
 }
+function partGeometryGap(part) {
+  if (part.kind === "flex") return null;
+  if (part.kind === "crossover")
+    return "a crossover fixture builds one HALF of the assembly (piecesPerAssembly), so its published lengths describe a piece, not the finished part \u2014 the geometry of the whole crossover is not yet derivable from them";
+  if (part.kind === "crossing") return "crossing geometry is not modelled yet";
+  if (part.kind === "curved-turnout")
+    return "a curved turnout needs both radii AND its points/frog landmarks; only the radii are published";
+  if (!part.pointsOffset)
+    return "no points offset \u2014 without it there is nowhere for the diverging route to begin";
+  if (!part.overallLength) return "no overall length \u2014 the part has no end to put a joint on";
+  if (part.frogNumber == null) return "no frog number \u2014 the diverging angle is unknown";
+  return null;
+}
+function partGeometry(part, library = BUILT_IN_TRACK_PARTS) {
+  if (partGeometryGap(part)) return null;
+  if (part.kind === "flex") {
+    return {
+      joints: [
+        { id: "a", role: "throat", x: 0, y: 0, angleDeg: 180 },
+        { id: "b", role: "through", x: 0, y: 0, angleDeg: 0 }
+      ],
+      routes: [["a", "b"]],
+      source: "derived",
+      divergingEndMeasured: false
+    };
+  }
+  const N = part.frogNumber;
+  const points = part.pointsOffset;
+  const overall = part.overallLength;
+  const frog = part.frogOffset;
+  const lead = part.lead?.inches ?? (frog ? frog.inches - points.inches : void 0);
+  if (lead == null || !(lead > 0)) return null;
+  const isWye = part.kind === "wye";
+  const effN = isWye ? N * 2 : N;
+  const closure = turnoutClosure(effN, { leadInches: lead });
+  const divergingEnd = () => {
+    const frogX = frog ? frog.inches : points.inches + lead;
+    const slope = closure.frogSlope;
+    const dir = 1 / Math.hypot(1, slope);
+    if (part.divergingLength) {
+      const L = part.divergingLength.inches;
+      return {
+        x: frogX + L * dir,
+        y: closure.offsetAt(frogX - points.inches) + L * slope * dir,
+        measured: true
+      };
+    }
+    return {
+      x: overall.inches,
+      y: closure.offsetAt(overall.inches - points.inches),
+      measured: false
+    };
+  };
+  const weakest = (...ds) => {
+    const rank = ["measured", "manufacturer", "derived", "unverified"];
+    let worst = 0;
+    for (const d of ds) if (d) worst = Math.max(worst, rank.indexOf(d.source));
+    return rank[worst];
+  };
+  const de = divergingEnd();
+  const legAngle = Math.atan(closure.frogSlope) * 180 / Math.PI;
+  if (isWye) {
+    return {
+      joints: [
+        { id: "throat", role: "throat", x: 0, y: 0, angleDeg: 180 },
+        { id: "legA", role: "diverge", x: de.x, y: de.y, angleDeg: legAngle },
+        { id: "legB", role: "divergeB", x: de.x, y: -de.y, angleDeg: -legAngle }
+      ],
+      routes: [
+        ["throat", "legA"],
+        ["throat", "legB"]
+      ],
+      source: weakest(points, overall, frog, part.divergingLength),
+      divergingEndMeasured: de.measured
+    };
+  }
+  return {
+    joints: [
+      { id: "throat", role: "throat", x: 0, y: 0, angleDeg: 180 },
+      { id: "through", role: "through", x: overall.inches, y: 0, angleDeg: 0 },
+      { id: "diverge", role: "diverge", x: de.x, y: de.y, angleDeg: legAngle }
+    ],
+    routes: [
+      ["throat", "through"],
+      ["throat", "diverge"]
+    ],
+    source: weakest(points, overall, frog, part.divergingLength),
+    divergingEndMeasured: de.measured
+  };
+}
+function partsPlaceable(library = BUILT_IN_TRACK_PARTS) {
+  const placeable = [];
+  const blocked = [];
+  for (const p of library) {
+    const why = partGeometryGap(p);
+    if (why) blocked.push({ part: p, why });
+    else if (partGeometry(p, library)) placeable.push(p);
+    else blocked.push({ part: p, why: "dimensions present but inconsistent" });
+  }
+  return { placeable, blocked };
+}
 function frogCasting(cl, opts = {}) {
   const g = opts.gaugeInches ?? RAIL_GAUGE_INCHES;
   const w = opts.reachInches ?? g * 1.5;
@@ -2433,6 +2550,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);
@@ -2536,6 +2692,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;
   };
@@ -2747,6 +2918,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;
@@ -2778,7 +2950,10 @@ exports.nextId = nextId;
 exports.parseXtpLibrary = parseXtpLibrary;
 exports.partExtent = partExtent;
 exports.partExtentForSize = partExtentForSize;
+exports.partGeometry = partGeometry;
+exports.partGeometryGap = partGeometryGap;
 exports.partOutlineAtFrog = partOutlineAtFrog;
+exports.partsPlaceable = partsPlaceable;
 exports.pastFrogInchesForSize = pastFrogInchesForSize;
 exports.pathLengthInches = pathLengthInches;
 exports.poseNeedsManual = poseNeedsManual;