@willcgage/module-schematic 0.15.0 → 0.17.0

package/dist/index.d.ts

@@ -165,17 +165,71 @@ interface ModuleSchematicDoc {
     /** @deprecated pre-grouping flat signals; read for back-compat. */
     signals?: SchematicSignal[];
 }
-/** A benchwork-outline vertex, module-local inches. */
+/** A benchwork-outline vertex, module-local inches. The edge from this vertex
+ * to the NEXT one is a straight line, unless `bulge` is set — then it's a
+ * circular arc whose midpoint is offset `bulge` inches (signed: + bows to the
+ * left of the P→next direction) perpendicular from the chord. */
 interface BenchworkPoint {
     x: number;
     y: number;
+    bulge?: number;
 }
 /** The authored benchwork outline, or null when a module hasn't drawn one
  * (renderers then fall back to a band derived from the endplate widths). A
- * valid outline needs at least 3 points. */
+ * valid outline needs at least 3 points. Normalises each vertex to {x, y, bulge?}. */
 declare function benchworkOutline(doc: {
     outline?: BenchworkPoint[] | null;
 } | null | undefined): BenchworkPoint[] | null;
+/**
+ * Expand a benchwork outline (whose edges may be arcs) into a dense closed
+ * polyline for rendering — the SAME sampling both the Repository preview and
+ * Free-Dispatcher use, so a curve looks identical in both. Straight edges emit
+ * just their start vertex; a bulged edge emits `segsPerArc` points along the
+ * circular arc through the two endpoints and the bulged midpoint.
+ */
+declare function sampleBenchworkOutline(pts: BenchworkPoint[], segsPerArc?: number): {
+    x: number;
+    y: number;
+}[];
+interface ModuleFootprintInput {
+    /** Mainline length (falls back to footprint length), inches. */
+    lengthInches: number;
+    geometryType?: string | null;
+    geometryDegrees?: number | null;
+    geometryOffsetInches?: number | null;
+    /** Authored endplate face widths by id ("A"/"B"…), inches; default recommended. */
+    endplateWidths?: Record<string, number>;
+    /** Authored benchwork outline (module-local inches), or absent for the band. */
+    outline?: BenchworkPoint[] | null;
+}
+interface OutlineFace {
+    /** The endplate face's two corners + midpoint (the track point). */
+    p1: BenchworkPoint;
+    p2: BenchworkPoint;
+    mid: BenchworkPoint;
+}
+interface ModuleFootprint {
+    /** Main track centre-line A→B (arcs sampled). */
+    centerline: BenchworkPoint[];
+    /** Derived benchwork band (endplate-width ribbon); the outline fallback. */
+    band: BenchworkPoint[];
+    /** Endplate faces: [A end, B end]. */
+    endplateFaces: OutlineFace[];
+    /** Authored outline (arc-sampled closed ring) or null → render the band. */
+    outline: BenchworkPoint[] | null;
+}
+/** Module-local main track centre-line (A→B), sampling arcs for curves/corners. */
+declare function moduleCenterline(input: ModuleFootprintInput): BenchworkPoint[];
+/** Benchwork band: the centre-line offset ±half-width, tapering widthA→widthB. */
+declare function benchworkBand(center: BenchworkPoint[], widthA?: number, widthB?: number): BenchworkPoint[];
+/** The two endplate faces (the band's flat ends): [A end at widthA, B end at widthB]. */
+declare function endplateFaceSegments(center: BenchworkPoint[], widthA?: number, widthB?: number): OutlineFace[];
+/**
+ * The full single-module physical footprint: centre-line + derived band +
+ * endplate faces + the authored outline (arc-sampled), all in module-local
+ * inches. Renderers draw `outline ?? band`.
+ */
+declare function moduleFootprint(input: ModuleFootprintInput): ModuleFootprint;
 /** Whether a doc is a single-endplate turnback (explicit flag or one endplate). */
 declare function isLoopDoc(doc: ModuleSchematicDoc): boolean;
 declare const MAIN_TRACK_ID = "main";
@@ -544,4 +598,4 @@ declare function poseOverridesFromDoc(doc: ModuleSchematicDoc): Record<string, {
     heading: number;
 }>;
 
-export { type BenchworkPoint, type BranchConnector, type DrawCrossing, type DrawCrossover, type DrawSignal, type DrawTrack, type DrawTurnout, type EditorBranch, type EditorControlPoint, type EditorCpSignal, type EditorCrossing, type EditorState, type EditorTrack, type EditorTurnout, type EndplateBConfig, type EndplatePose, FREEMO_ENDPLATE_WIDTH_MIN_INCHES, FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES, type GeometryType, MAIN2_TRACK_ID, MAIN_TRACK_ID, type ModuleFeatures, type ModuleGeometryInput, type ModuleSchematicDoc, type ModuleTrackRow, N_SCALE_RATIO, type SchematicBlock, type SchematicControlPoint, type SchematicCrossing, type SchematicEndplate, type SchematicEndplateTrack, type SchematicSignal, type SchematicTrack, type SchematicTurnout, type SignalFacing, type SignalSide, type TrackConfig, type TrackRole, type TurnoutKind, asModuleSchematic, benchworkOutline, buildCrossover, buildPassingSiding, buildTransition, deriveEndplatePoses, divergeSideForHand, docToState, emptyEditorState, endplateWidthInches, geometryTurnDegrees, inchesToScaleFeet, isLoopDoc, isTransitionTurnout, moduleFeatures, nextId, poseNeedsManual, poseOverridesFromDoc, scaleFeetToInches, stateToDoc };
+export { type BenchworkPoint, type BranchConnector, type DrawCrossing, type DrawCrossover, type DrawSignal, type DrawTrack, type DrawTurnout, type EditorBranch, type EditorControlPoint, type EditorCpSignal, type EditorCrossing, type EditorState, type EditorTrack, type EditorTurnout, type EndplateBConfig, type EndplatePose, FREEMO_ENDPLATE_WIDTH_MIN_INCHES, FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES, type GeometryType, MAIN2_TRACK_ID, MAIN_TRACK_ID, type ModuleFeatures, type ModuleFootprint, type ModuleFootprintInput, type ModuleGeometryInput, type ModuleSchematicDoc, type ModuleTrackRow, N_SCALE_RATIO, type OutlineFace, type SchematicBlock, type SchematicControlPoint, type SchematicCrossing, type SchematicEndplate, type SchematicEndplateTrack, type SchematicSignal, type SchematicTrack, type SchematicTurnout, type SignalFacing, type SignalSide, type TrackConfig, type TrackRole, type TurnoutKind, asModuleSchematic, benchworkBand, benchworkOutline, buildCrossover, buildPassingSiding, buildTransition, deriveEndplatePoses, divergeSideForHand, docToState, emptyEditorState, endplateFaceSegments, endplateWidthInches, geometryTurnDegrees, inchesToScaleFeet, isLoopDoc, isTransitionTurnout, moduleCenterline, moduleFeatures, moduleFootprint, nextId, poseNeedsManual, poseOverridesFromDoc, sampleBenchworkOutline, scaleFeetToInches, stateToDoc };

package/dist/index.js

@@ -6,11 +6,135 @@ function endplateWidthInches(ep) {
   return typeof w === "number" && w > 0 ? w : FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES;
 }
 function benchworkOutline(doc) {
-  const pts = (doc?.outline ?? []).filter(
-    (p) => p && Number.isFinite(p.x) && Number.isFinite(p.y)
-  );
+  const pts = (doc?.outline ?? []).filter((p) => p && Number.isFinite(p.x) && Number.isFinite(p.y)).map((p) => ({
+    x: p.x,
+    y: p.y,
+    ...Number.isFinite(p.bulge) && p.bulge ? { bulge: p.bulge } : {}
+  }));
   return pts.length >= 3 ? pts : null;
 }
+function sampleBenchworkOutline(pts, segsPerArc = 20) {
+  const n = pts.length;
+  if (n < 2) return pts.map((p) => ({ x: p.x, y: p.y }));
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const p0 = pts[i];
+    const p1 = pts[(i + 1) % n];
+    out.push({ x: p0.x, y: p0.y });
+    const bulge = p0.bulge ?? 0;
+    if (!bulge) continue;
+    const dx = p1.x - p0.x;
+    const dy = p1.y - p0.y;
+    const c = Math.hypot(dx, dy);
+    if (c < 1e-6) continue;
+    const nx = -dy / c;
+    const ny = dx / c;
+    const mid = { x: (p0.x + p1.x) / 2 + nx * bulge, y: (p0.y + p1.y) / 2 + ny * bulge };
+    const circ = circleThrough(p0, mid, p1);
+    if (!circ) continue;
+    const a0 = Math.atan2(p0.y - circ.cy, p0.x - circ.cx);
+    const am = Math.atan2(mid.y - circ.cy, mid.x - circ.cx);
+    const a1 = Math.atan2(p1.y - circ.cy, p1.x - circ.cx);
+    const sweep = arcSweep(a0, a1, am);
+    for (let s = 1; s < segsPerArc; s++) {
+      const a = a0 + sweep * s / segsPerArc;
+      out.push({ x: circ.cx + circ.r * Math.cos(a), y: circ.cy + circ.r * Math.sin(a) });
+    }
+  }
+  return out;
+}
+function circleThrough(a, b, c) {
+  const d = 2 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
+  if (Math.abs(d) < 1e-9) return null;
+  const a2 = a.x * a.x + a.y * a.y;
+  const b2 = b.x * b.x + b.y * b.y;
+  const c2 = c.x * c.x + c.y * c.y;
+  const cx = (a2 * (b.y - c.y) + b2 * (c.y - a.y) + c2 * (a.y - b.y)) / d;
+  const cy = (a2 * (c.x - b.x) + b2 * (a.x - c.x) + c2 * (b.x - a.x)) / d;
+  return { cx, cy, r: Math.hypot(a.x - cx, a.y - cy) };
+}
+function arcSweep(a0, a1, am) {
+  const norm = (x) => {
+    let v = (x - a0) % (2 * Math.PI);
+    if (v < 0) v += 2 * Math.PI;
+    return v;
+  };
+  const m = norm(am);
+  const one = norm(a1);
+  return m <= one ? one : one - 2 * Math.PI;
+}
+var DEG_FP = Math.PI / 180;
+function moduleCenterline(input) {
+  const L = input.lengthInches > 0 ? input.lengthInches : 24;
+  const gt = input.geometryType;
+  if (gt === "dead_end") return [{ x: 0, y: 0 }];
+  if (gt === "offset") return [{ x: 0, y: 0 }, { x: L, y: input.geometryOffsetInches ?? 0 }];
+  const turn = gt === "corner_45" ? 45 : gt === "corner_90" ? 90 : gt === "curve" ? input.geometryDegrees ?? 0 : 0;
+  if (turn === 0) return [{ x: 0, y: 0 }, { x: L, y: 0 }];
+  const t = turn * DEG_FP;
+  const r = L / t;
+  const steps = 12;
+  const pts = [];
+  for (let i = 0; i <= steps; i++) {
+    const a = t * i / steps;
+    pts.push({ x: r * Math.sin(a), y: r * (1 - Math.cos(a)) });
+  }
+  return pts;
+}
+function centerlineNormals(center) {
+  return center.map((_, i) => {
+    const a = center[Math.max(0, i - 1)];
+    const b = center[Math.min(center.length - 1, i + 1)];
+    let dx = b.x - a.x;
+    let dy = b.y - a.y;
+    const len = Math.hypot(dx, dy) || 1;
+    dx /= len;
+    dy /= len;
+    return { x: -dy, y: dx };
+  });
+}
+function centerlineFractions(center) {
+  const cum = [0];
+  for (let i = 1; i < center.length; i++)
+    cum.push(cum[i - 1] + Math.hypot(center[i].x - center[i - 1].x, center[i].y - center[i - 1].y));
+  const total = cum[cum.length - 1] || 1;
+  return cum.map((d) => d / total);
+}
+function benchworkBand(center, widthA = FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES, widthB = FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES) {
+  if (center.length < 2) return [];
+  const n = centerlineNormals(center);
+  const f = centerlineFractions(center);
+  const half = (i) => (widthA * (1 - f[i]) + widthB * f[i]) / 2;
+  const left = center.map((p, i) => ({ x: p.x + n[i].x * half(i), y: p.y + n[i].y * half(i) }));
+  const right = center.map((p, i) => ({ x: p.x - n[i].x * half(i), y: p.y - n[i].y * half(i) }));
+  return [...left, ...right.reverse()];
+}
+function endplateFaceSegments(center, widthA = FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES, widthB = FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES) {
+  if (center.length < 2) return [];
+  const n = centerlineNormals(center);
+  const face = (i, w) => ({
+    p1: { x: center[i].x + n[i].x * (w / 2), y: center[i].y + n[i].y * (w / 2) },
+    p2: { x: center[i].x - n[i].x * (w / 2), y: center[i].y - n[i].y * (w / 2) },
+    mid: { x: center[i].x, y: center[i].y }
+  });
+  return [face(0, widthA), face(center.length - 1, widthB)];
+}
+function moduleFootprint(input) {
+  const centerline = moduleCenterline(input);
+  const widthA = endplateWidthFor(input.endplateWidths, "A");
+  const widthB = endplateWidthFor(input.endplateWidths, "B");
+  const authored = benchworkOutline(input);
+  return {
+    centerline,
+    band: benchworkBand(centerline, widthA, widthB),
+    endplateFaces: endplateFaceSegments(centerline, widthA, widthB),
+    outline: authored ? sampleBenchworkOutline(authored) : null
+  };
+}
+function endplateWidthFor(widths, id) {
+  const w = widths?.[id];
+  return typeof w === "number" && w > 0 ? w : FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES;
+}
 function isLoopDoc(doc) {
   return doc.loop === true || doc.endplates.length === 1;
 }
@@ -290,9 +414,11 @@ function docToState(doc, fallbackLength, moduleTracks = []) {
     if (typeof e.widthInches === "number" && e.widthInches > 0)
       endplateWidths[e.id] = e.widthInches;
   }
-  const outline = (d.outline ?? []).filter(
-    (p) => p && Number.isFinite(p.x) && Number.isFinite(p.y)
-  );
+  const outline = (d.outline ?? []).filter((p) => p && Number.isFinite(p.x) && Number.isFinite(p.y)).map((p) => ({
+    x: p.x,
+    y: p.y,
+    ...Number.isFinite(p.bulge) && p.bulge ? { bulge: p.bulge } : {}
+  }));
   return {
     lengthInches: len,
     loop,
@@ -766,6 +892,6 @@ function poseOverridesFromDoc(doc) {
   return out;
 }
 
-export { FREEMO_ENDPLATE_WIDTH_MIN_INCHES, FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES, MAIN2_TRACK_ID, MAIN_TRACK_ID, N_SCALE_RATIO, asModuleSchematic, benchworkOutline, buildCrossover, buildPassingSiding, buildTransition, deriveEndplatePoses, divergeSideForHand, docToState, emptyEditorState, endplateWidthInches, geometryTurnDegrees, inchesToScaleFeet, isLoopDoc, isTransitionTurnout, moduleFeatures, nextId, poseNeedsManual, poseOverridesFromDoc, scaleFeetToInches, stateToDoc };
+export { FREEMO_ENDPLATE_WIDTH_MIN_INCHES, FREEMO_ENDPLATE_WIDTH_RECOMMENDED_INCHES, MAIN2_TRACK_ID, MAIN_TRACK_ID, N_SCALE_RATIO, asModuleSchematic, benchworkBand, benchworkOutline, buildCrossover, buildPassingSiding, buildTransition, deriveEndplatePoses, divergeSideForHand, docToState, emptyEditorState, endplateFaceSegments, endplateWidthInches, geometryTurnDegrees, inchesToScaleFeet, isLoopDoc, isTransitionTurnout, moduleCenterline, moduleFeatures, moduleFootprint, nextId, poseNeedsManual, poseOverridesFromDoc, sampleBenchworkOutline, scaleFeetToInches, stateToDoc };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map