@willcgage/module-schematic 0.85.0 → 0.89.0

package/dist/index.js

@@ -1044,6 +1044,10 @@ function stateToDoc(state, recordNumber) {
         track: ind.track,
         fromPos: ind.fromPos,
         toPos: ind.toPos,
+        // Carried, not interpreted. An anchor is what HOLDS the span (ADR
+        // 0001); dropping it here would quietly convert an anchored
+        // industry back into a typed number the next time anyone saved.
+        ...ind.anchor ? { anchor: ind.anchor } : {},
         ...ind.spots?.length ? { spots: ind.spots } : {},
         side: ind.side,
         ...ind.labelMode && ind.labelMode !== "none" ? { labelMode: ind.labelMode } : {},
@@ -1063,7 +1067,11 @@ function stateToDoc(state, recordNumber) {
     ...state.sections.length ? { sections: moduleSections({ sections: state.sections }) } : {},
     // Authored mainline path (module-local inches); only when it's a real path.
     ...state.mainPath.length >= 2 ? { mainPath: state.mainPath } : {},
-    ...state.main2Path.length >= 2 ? { main2Path: state.main2Path } : {}
+    ...state.main2Path.length >= 2 ? { main2Path: state.main2Path } : {},
+    // The pieces the owner drew, carried verbatim (ADR 0001). This function
+    // stays dumb about them on purpose: deriving here would put the derivation
+    // in every save path in both apps. `deriveGraphDoc` is the one place.
+    ...state.graph?.pieces?.length ? { graph: state.graph } : {}
   };
 }
 function docToState(doc, fallbackLength, moduleTracks = []) {
@@ -1208,6 +1216,10 @@ function docToState(doc, fallbackLength, moduleTracks = []) {
     sections: moduleSections(d),
     mainPath,
     main2Path,
+    // ⚠️ NOT scaled by `sc()` like every position above it. A piece is placed in
+    // real inches on the board; stretching the module's length does not move it,
+    // and the length is DERIVED from the pieces anyway when a graph is present.
+    ...d.graph?.pieces?.length ? { graph: d.graph } : {},
     crossings: (d.crossings ?? []).map((x) => ({
       id: x.id,
       name: x.name ?? "",
@@ -1242,12 +1254,14 @@ function docToState(doc, fallbackLength, moduleTracks = []) {
         track: s.track,
         fromPos: sc(s.fromPos ?? 0),
         toPos: s.toPos != null ? sc(s.toPos) : len,
-        ...s.side ? { side: s.side } : {}
+        ...s.side ? { side: s.side } : {},
+        ...s.anchor ? { anchor: s.anchor } : {}
       })),
       side: ind.side ?? "above",
       labelMode: ind.labelMode ?? "none",
       carTypes: Array.isArray(ind.carTypes) ? ind.carTypes : [],
-      moduleIndustryId: ind.moduleIndustryId ?? null
+      moduleIndustryId: ind.moduleIndustryId ?? null,
+      ...ind.anchor ? { anchor: ind.anchor } : {}
     }))
   };
 }
@@ -2243,6 +2257,359 @@ 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: [],
+      spans: [],
+      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;
+      const entered = pos;
+      pos += gap(here, exit);
+      route.spans.push({
+        piece: here.piece,
+        entryJoint: here.joint,
+        exitJoint,
+        fromPos: entered,
+        toPos: pos
+      });
+      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;
+    }
+    const already = routes.find((r2) => r2.pieces.includes(byKey.get(start).piece));
+    if (already) {
+      const swFar = turnouts.find((t) => t.id === b.from);
+      if (swFar && !swFar.divergeRoute) swFar.divergeRoute = already.id;
+      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 resolveGraphAnchor(anchor, walk, pieces, library = BUILT_IN_TRACK_PARTS) {
+  const piece = pieces.find((p) => p.id === anchor.piece);
+  const part = piece ? library.find((x) => x.id === piece.partId) : void 0;
+  const origin = part?.kind === "flex" ? "a" : "throat";
+  for (const r of walk.routes) {
+    const span = r.spans.find((s) => s.piece === anchor.piece);
+    if (!span) continue;
+    if (span.entryJoint === origin)
+      return { pos: span.fromPos + anchor.atInches, routeId: r.id, reversed: false };
+    if (span.exitJoint === origin)
+      return { pos: span.toPos - anchor.atInches, routeId: r.id, reversed: true };
+    return null;
+  }
+  return null;
+}
+function graphToDoc(pieces, input) {
+  const library = input.library ?? BUILT_IN_TRACK_PARTS;
+  const graph = buildTrackGraph(pieces, library);
+  const walk = walkTrackGraph(graph, pieces, input.startAt, library);
+  const warnings = [...walk.warnings];
+  const round = (n) => Math.round(n * 100) / 100;
+  const base = input.base ?? {};
+  const endplates = base.endplates && base.endplates.length ? base.endplates : [{ id: "A", label: "West" }, { id: "B", label: "East" }];
+  const epA = endplates[0];
+  const epB = endplates[1];
+  const main = walk.routes.find((r) => r.id === "main");
+  const lengthInches = round(main.toPos);
+  const branches = walk.routes.filter((r) => r.id !== "main" && r.pieces.length);
+  const trackIdOf = /* @__PURE__ */ new Map([["main", MAIN_TRACK_ID]]);
+  for (const r of branches) trackIdOf.set(r.id, r.pieces[0]);
+  const laneOf = (r) => {
+    const side = Math.sign(r.lateral) || 1;
+    const sameSide = branches.filter((x) => (Math.sign(x.lateral) || 1) === side).sort((a, b) => Math.abs(a.lateral) - Math.abs(b.lateral));
+    return side * (sameSide.indexOf(r) + 1);
+  };
+  const tracks = [
+    {
+      id: MAIN_TRACK_ID,
+      role: "main",
+      lane: 0,
+      from: epA?.id ?? "A",
+      ...epB ? { to: epB.id } : {}
+    }
+  ];
+  for (const r of branches) {
+    const id = trackIdOf.get(r.id);
+    const meta = input.meta?.[id] ?? {};
+    tracks.push({
+      id,
+      // It runs back into a second turnout, or it doesn't. That is the whole
+      // difference between a siding and a spur, and it is read, not declared.
+      role: r.endsAt ? "siding" : "spur",
+      lane: laneOf(r),
+      fromPos: round(Math.min(r.fromPos, r.toPos)),
+      toPos: round(Math.max(r.fromPos, r.toPos)),
+      ...meta.trackName ? { trackName: meta.trackName } : {},
+      ...meta.capacityFeet != null ? { capacityFeet: meta.capacityFeet } : {},
+      ...meta.moduleTrackId != null ? { moduleTrackId: meta.moduleTrackId } : {}
+    });
+  }
+  const pieceById = new Map(pieces.map((p) => [p.id, p]));
+  const turnouts = [];
+  for (const t of walk.turnouts) {
+    const diverge = t.divergeRoute ? trackIdOf.get(t.divergeRoute) : void 0;
+    if (!diverge) {
+      warnings.push(
+        `${t.id} is placed but its diverging route goes nowhere, so it is not in the operations view`
+      );
+      continue;
+    }
+    const piece = pieceById.get(t.id);
+    const part = piece ? library.find((p) => p.id === piece.partId) : void 0;
+    turnouts.push({
+      id: t.id,
+      pos: round(t.pos),
+      onTrack: trackIdOf.get(t.onRoute) ?? MAIN_TRACK_ID,
+      divergeTrack: diverge,
+      ...piece?.name ? { name: piece.name } : {},
+      ...part?.frogNumber != null ? { size: part.frogNumber } : {},
+      ...part ? { partId: part.id } : {}
+    });
+  }
+  turnouts.sort((a, b) => a.pos - b.pos);
+  const place = (a, what) => {
+    if (!a) return null;
+    const hit = resolveGraphAnchor(a, walk, pieces, library);
+    if (!hit) {
+      warnings.push(
+        `${what} is anchored to ${a.piece}, which is not on any route \u2014 its authored position stands`
+      );
+      return null;
+    }
+    return hit;
+  };
+  const spanAt = (hit, from, to) => {
+    const len = Math.abs(to - from);
+    return hit.reversed ? [round(hit.pos - len), round(hit.pos)] : [round(hit.pos), round(hit.pos + len)];
+  };
+  const industries = base.industries?.map((ind) => {
+    const hit = place(ind.anchor, `industry "${ind.name}"`);
+    const spots = ind.spots?.map((s) => {
+      const sh = place(s.anchor, `a spot of industry "${ind.name}"`);
+      if (!sh) return s;
+      const [from, to] = spanAt(sh, s.fromPos, s.toPos);
+      return { ...s, track: trackIdOf.get(sh.routeId) ?? s.track, fromPos: from, toPos: to };
+    });
+    if (!hit) return spots ? { ...ind, spots } : ind;
+    const [fromPos, toPos] = spanAt(hit, ind.fromPos, ind.toPos);
+    return {
+      ...ind,
+      track: trackIdOf.get(hit.routeId) ?? ind.track,
+      fromPos,
+      toPos,
+      ...spots ? { spots } : {}
+    };
+  });
+  const signals = base.signals?.map((sig) => {
+    const hit = place(sig.anchor, `signal "${sig.name ?? sig.id}"`);
+    return hit ? { ...sig, pos: round(hit.pos), track: trackIdOf.get(hit.routeId) ?? sig.track } : sig;
+  });
+  const doc = {
+    version: 1,
+    ...base,
+    lengthInches,
+    endplates,
+    tracks,
+    turnouts,
+    ...industries ? { industries } : {},
+    ...signals ? { signals } : {}
+  };
+  return { doc, graph, walk, warnings };
+}
+function deriveGraphDoc(doc, library = BUILT_IN_TRACK_PARTS) {
+  const g = doc.graph;
+  if (!g || !g.pieces?.length || !g.startAt) return { doc, warnings: [] };
+  const meta = {};
+  for (const t of doc.tracks ?? []) {
+    if (t.role === "main") continue;
+    meta[t.id] = {
+      ...t.trackName ? { trackName: t.trackName } : {},
+      ...t.capacityFeet != null ? { capacityFeet: t.capacityFeet } : {},
+      ...t.moduleTrackId != null ? { moduleTrackId: t.moduleTrackId } : {}
+    };
+  }
+  const out = graphToDoc(g.pieces, { startAt: g.startAt, base: doc, meta, library });
+  return { doc: out.doc, warnings: out.warnings };
+}
 function frogCasting(cl, opts = {}) {
   const g = opts.gaugeInches ?? RAIL_GAUGE_INCHES;
   const w = opts.reachInches ?? g * 1.5;
@@ -2876,6 +3243,6 @@ function poseOverridesFromDoc(doc) {
   return out;
 }
 
-export { ATLAS_CODE55_N, BUILT_IN_TRACK_PARTS, CLEARANCE_SPACING_INCHES, CODE55_RAIL_HEIGHT_INCHES, DEFAULT_FLEX_PART_ID, ENDPLATE_FASCIA_CLEAR_INCHES, ENDPLATE_LEAD_INCHES, FAST_TRACKS_N_ME55, FAST_TRACKS_N_ME55_CROSSOVERS, FLEX_TRACK_PARTS, FREEMO_ENDPLATE_TRACK_FASCIA_CLEARANCE_INCHES, FREEMO_ENDPLATE_WIDTH_MIN_INCHES, FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES, FREEMO_TRACK_SPACING_INCHES, MAIN2_TRACK_ID, MAIN_TRACK_ID, N_CAR_LENGTH_INCHES, N_SCALE_RATIO, PINCH_EASE_INCHES, RAIL_GAUGE_INCHES, TIE_HALF_LENGTH_INCHES, TURNOUT_LEAD_INCHES_PER_FROG, WHOLE_MODULE_SECTION_ID, asModuleSchematic, assessSectionEnd, assessSectionJoint, benchworkBand, benchworkOutline, buildCrossover, buildPassingSiding, buildTransition, carCapacity, checkEndplateWidth, clearancePointPastFrogInches, crossoverPinches, deriveEndplatePoses, divergeSideForHand, docToState, emptyEditorState, endplateCentreOffsetInches, endplateEdgePose, endplateFaceSegments, endplateLead, endplateTrackOffsetInches, endplateWidthInches, flexPartFor, flexParts, flexPieces, flexUsage, frogCasting, frogNumberFromName, fromSectionRelative, geometryTurnDegrees, hasNoFarEndplate, importedPartToTrackPart, inchesToScaleFeet, isLoopDoc, isTransitionTurnout, laneOffsetAt, leadInchesForSize, maxFlexPieceInches, mergeImportedParts, mergeStoredParts, moduleCenterline, moduleFeatures, moduleFootprint, moduleLengthFromSections, moduleSections, nextId, parseXtpLibrary, partExtent, partExtentForSize, partGeometry, partGeometryGap, partOutlineAtFrog, partsPlaceable, pastFrogInchesForSize, pathLengthInches, poseNeedsManual, poseOverridesFromDoc, remapPos, resizeFlexPiece, returnLoop, sampleBenchworkOutline, samplePartSegments, samplePath, scaleFeetToInches, sectionAdjacency, sectionBand, sectionBreaksFromSections, sectionComponents, sectionFootprints, sectionNeighbours, sectionSpans, sectionSpansOrWhole, sectionedCenterline, sectionedEndPose, sliceCenterline, spanOverhang, stateToDoc, storedPartToTrackPart, toSectionRelative, trackMeetsEndplateIssues, trackPart, trackPath, turnoutClosure, turnoutFacing, turnoutOccupiedSpan, turnoutPartForSize, usableCapacity };
+export { ATLAS_CODE55_N, BUILT_IN_TRACK_PARTS, CLEARANCE_SPACING_INCHES, CODE55_RAIL_HEIGHT_INCHES, DEFAULT_FLEX_PART_ID, ENDPLATE_FASCIA_CLEAR_INCHES, ENDPLATE_LEAD_INCHES, FAST_TRACKS_N_ME55, FAST_TRACKS_N_ME55_CROSSOVERS, FLEX_TRACK_PARTS, FREEMO_ENDPLATE_TRACK_FASCIA_CLEARANCE_INCHES, FREEMO_ENDPLATE_WIDTH_MIN_INCHES, FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES, FREEMO_TRACK_SPACING_INCHES, JOINT_SNAP_INCHES, MAIN2_TRACK_ID, MAIN_TRACK_ID, N_CAR_LENGTH_INCHES, N_SCALE_RATIO, PINCH_EASE_INCHES, RAIL_GAUGE_INCHES, TIE_HALF_LENGTH_INCHES, TURNOUT_LEAD_INCHES_PER_FROG, WHOLE_MODULE_SECTION_ID, asModuleSchematic, assessSectionEnd, assessSectionJoint, benchworkBand, benchworkOutline, buildCrossover, buildPassingSiding, buildTrackGraph, buildTransition, carCapacity, checkEndplateWidth, clearancePointPastFrogInches, crossoverPinches, deriveEndplatePoses, deriveGraphDoc, divergeSideForHand, docToState, emptyEditorState, endplateCentreOffsetInches, endplateEdgePose, endplateFaceSegments, endplateLead, endplateTrackOffsetInches, endplateWidthInches, flexPartFor, flexParts, flexPieces, flexUsage, frogCasting, frogNumberFromName, fromSectionRelative, geometryTurnDegrees, graphToDoc, hasNoFarEndplate, importedPartToTrackPart, inchesToScaleFeet, isLoopDoc, isTransitionTurnout, laneOffsetAt, leadInchesForSize, maxFlexPieceInches, mergeImportedParts, mergeStoredParts, moduleCenterline, moduleFeatures, moduleFootprint, moduleLengthFromSections, moduleSections, nextId, parseXtpLibrary, partExtent, partExtentForSize, partGeometry, partGeometryGap, partOutlineAtFrog, partsPlaceable, pastFrogInchesForSize, pathLengthInches, placedJoints, poseNeedsManual, poseOverridesFromDoc, remapPos, resizeFlexPiece, resolveGraphAnchor, returnLoop, sampleBenchworkOutline, samplePartSegments, samplePath, scaleFeetToInches, sectionAdjacency, sectionBand, sectionBreaksFromSections, sectionComponents, sectionFootprints, sectionNeighbours, sectionSpans, sectionSpansOrWhole, sectionedCenterline, sectionedEndPose, sliceCenterline, spanOverhang, stateToDoc, storedPartToTrackPart, toSectionRelative, trackMeetsEndplateIssues, trackPart, trackPath, turnoutClosure, turnoutFacing, turnoutOccupiedSpan, turnoutPartForSize, usableCapacity, walkTrackGraph };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map