@knowvah/dot-engine 0.1.0

package/src/ortho/trap-update.ts

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Trapezoid update logic — updateTrapezoid and its helpers.
+ *
+ * @see lib/ortho/trapezoid.c:update_trapezoid
+ */
+
+import {
+  S_LEFT, TRAP_MAX, isValidTrap,
+} from "./trap-types.js";
+import type { SegmentT, TrapT } from "./trap-types.js";
+import { isLeftOf } from "./trap-query.js";
+
+/**
+ * Update upper-neighbour pointers when threading a segment through t and tn.
+ * @see lib/ortho/trapezoid.c:update_trapezoid
+ */
+export function updateTrapezoid(
+  s: SegmentT,
+  seg: SegmentT[],
+  tr: TrapT[],
+  t: number,
+  tn: number,
+): void {
+  if (isValidTrap(tr[t].u0) && isValidTrap(tr[t].u1)) {
+    updateContinuation(tr, t, tn);
+  } else {
+    updateFreshOrCusp(s, seg, tr, t, tn);
+  }
+}
+
+function updateContinuation(tr: TrapT[], t: number, tn: number): void {
+  if (isValidTrap(tr[t].usave)) {
+    applyUsave(tr, t, tn);
+  } else {
+    tr[tn].u0 = tr[t].u1;
+    tr[t].u1 = TRAP_MAX;
+    tr[tn].u1 = TRAP_MAX;
+    tr[tr[tn].u0].d0 = tn;
+  }
+}
+
+function applyUsave(tr: TrapT[], t: number, tn: number): void {
+  if (tr[t].uside === S_LEFT) {
+    tr[tn].u0 = tr[t].u1;
+    tr[t].u1 = TRAP_MAX;
+    tr[tn].u1 = tr[t].usave;
+    tr[tr[t].u0].d0 = t;
+    tr[tr[tn].u0].d0 = tn;
+    tr[tr[tn].u1].d0 = tn;
+  } else {
+    tr[tn].u1 = TRAP_MAX;
+    tr[tn].u0 = tr[t].u1;
+    tr[t].u1 = tr[t].u0;
+    tr[t].u0 = tr[t].usave;
+    tr[tr[t].u0].d0 = t;
+    tr[tr[t].u1].d0 = t;
+    tr[tr[tn].u0].d0 = tn;
+  }
+  tr[t].usave = 0;
+  tr[tn].usave = 0;
+}
+
+function updateFreshOrCusp(
+  s: SegmentT,
+  seg: SegmentT[],
+  tr: TrapT[],
+  t: number,
+  tn: number,
+): void {
+  const tmpU = tr[t].u0;
+  const td0 = tr[tmpU].d0;
+  if (isValidTrap(td0) && isValidTrap(tr[tmpU].d1)) {
+    if (tr[td0].rseg > 0 && !isLeftOf(tr[td0].rseg, seg, s.v1)) {
+      tr[t].u0 = TRAP_MAX;
+      tr[t].u1 = TRAP_MAX;
+      tr[tn].u1 = TRAP_MAX;
+      tr[tr[tn].u0].d1 = tn;
+    } else {
+      tr[tn].u0 = TRAP_MAX;
+      tr[tn].u1 = TRAP_MAX;
+      tr[t].u1 = TRAP_MAX;
+      tr[tr[t].u0].d0 = t;
+    }
+  } else {
+    tr[tr[t].u0].d0 = t;
+    tr[tr[t].u0].d1 = tn;
+  }
+}

package/src/ortho/trapezoid.ts

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * construct_trapezoids — main entry point for Seidel trapezoidation.
+ * Also re-exports the public surface used by partition.ts.
+ *
+ * @see lib/ortho/trapezoid.c:construct_trapezoids
+ */
+
+import {
+  mathLogstarN, mathN, newTrap, isValidTrap,
+} from "./trap-types.js";
+import type { SegmentT, TrapT, QNode } from "./trap-types.js";
+import { addSegment, findNewRoots } from "./trap-segment.js";
+
+export type { SegmentT, TrapT };
+export { isValidTrap, mathLogstarN, mathN };
+export type { QNode };
+
+// re-export helpers needed by partition.ts
+export {
+  fpEqual, equalTo, greaterThan, dfpCmp, C_EPS,
+} from "./trap-types.js";
+
+/**
+ * Build the trapezoidal decomposition of the polygon defined by seg[1..nseg].
+ * @see lib/ortho/trapezoid.c:construct_trapezoids
+ */
+export function constructTrapezoids(
+  nseg: number,
+  seg: SegmentT[],
+  permute: number[],
+): TrapT[] {
+  const qs: QNode[] = [];
+  const tr: TrapT[] = [];
+  // index 0 is a sentinel (invalid trap)
+  tr.push({
+    lseg: 0, rseg: 0,
+    hi: { x: 0, y: 0 }, lo: { x: 0, y: 0 },
+    u0: 0, u1: 0, d0: 0, d1: 0,
+    sink: 0, usave: 0, uside: 0, isValid: false,
+  });
+
+  let segi = 0;
+  const root = initQueryStructure(permute[segi++], seg, tr, qs);
+
+  for (let i = 1; i <= nseg; i++) {
+    seg[i].root0 = root;
+    seg[i].root1 = root;
+  }
+
+  const logstar = mathLogstarN(nseg);
+  for (let h = 1; h <= logstar; h++) {
+    const lo = mathN(nseg, h - 1) + 1;
+    const hi = mathN(nseg, h);
+    for (let i = lo; i <= hi; i++) {
+      addSegment(permute[segi++], seg, tr, qs);
+    }
+    for (let i = 1; i <= nseg; i++) {
+      findNewRoots(i, seg, tr, qs);
+    }
+  }
+
+  const remaining = mathN(nseg, logstar) + 1;
+  for (let i = remaining; i <= nseg; i++) {
+    addSegment(permute[segi++], seg, tr, qs);
+  }
+
+  return tr;
+}
+
+// ─── init_query_structure ─────────────────────────────────────────────────────
+
+import {
+  T_X, T_Y, T_SINK, maxPt, minPt, newQNode,
+} from "./trap-types.js";
+
+function initQueryStructure(
+  segnum: number,
+  seg: SegmentT[],
+  tr: TrapT[],
+  qs: QNode[],
+): number {
+  const s = seg[segnum];
+  const i1 = newQNode(qs); qs[i1].nodetype = T_Y; qs[i1].yval = maxPt(s.v0, s.v1);
+  const root = i1;
+  const i2 = newQNode(qs); qs[i1].right = i2; qs[i2].nodetype = T_SINK; qs[i2].parent = i1;
+  const i3 = newQNode(qs); qs[i1].left = i3; qs[i3].nodetype = T_Y; qs[i3].yval = minPt(s.v0, s.v1); qs[i3].parent = i1;
+  const i4 = newQNode(qs); qs[i3].left = i4; qs[i4].nodetype = T_SINK; qs[i4].parent = i3;
+  const i5 = newQNode(qs); qs[i3].right = i5; qs[i5].nodetype = T_X; qs[i5].segnum = segnum; qs[i5].parent = i3;
+  const i6 = newQNode(qs); qs[i5].left = i6; qs[i6].nodetype = T_SINK; qs[i6].parent = i5;
+  const i7 = newQNode(qs); qs[i5].right = i7; qs[i7].nodetype = T_SINK; qs[i7].parent = i5;
+
+  const t1 = newTrap(tr); const t2 = newTrap(tr);
+  const t3 = newTrap(tr); const t4 = newTrap(tr);
+
+  wireInitTraps(tr, qs, t1, t2, t3, t4, i1, i2, i3, i4, i6, i7, segnum);
+  seg[segnum].isInserted = true;
+  return root;
+}
+
+function wireInitTraps(
+  tr: TrapT[], qs: QNode[],
+  t1: number, t2: number, t3: number, t4: number,
+  i1: number, i2: number, i3: number, i4: number,
+  i6: number, i7: number, segnum: number,
+): void {
+  tr[t1].hi = qs[i1].yval; tr[t2].hi = qs[i1].yval; tr[t4].lo = qs[i1].yval;
+  tr[t1].lo = qs[i3].yval; tr[t2].lo = qs[i3].yval; tr[t3].hi = qs[i3].yval;
+  tr[t4].hi = { y: Number.MAX_VALUE, x: Number.MAX_VALUE };
+  tr[t3].lo = { y: -Number.MAX_VALUE, x: -Number.MAX_VALUE };
+  tr[t1].rseg = segnum; tr[t2].lseg = segnum;
+  tr[t1].u0 = t4; tr[t2].u0 = t4;
+  tr[t1].d0 = t3; tr[t2].d0 = t3;
+  tr[t4].d0 = t1; tr[t3].u0 = t1;
+  tr[t4].d1 = t2; tr[t3].u1 = t2;
+  tr[t1].sink = i6; tr[t2].sink = i7; tr[t3].sink = i4; tr[t4].sink = i2;
+  tr[t1].isValid = true; tr[t2].isValid = true;
+  tr[t3].isValid = true; tr[t4].isValid = true;
+  qs[i2].trnum = t4; qs[i4].trnum = t3; qs[i6].trnum = t1; qs[i7].trnum = t2;
+}

package/src/ortho/types.ts

@@ -0,0 +1,286 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Shared internal types for the ortho edge router.
+ *
+ * Corresponds to lib/ortho/structures.h, lib/ortho/maze.h,
+ * lib/ortho/sgraph.h, and lib/ortho/rawgraph.h.
+ *
+ * @see lib/ortho/structures.h
+ * @see lib/ortho/maze.h
+ * @see lib/ortho/sgraph.h
+ * @see lib/ortho/rawgraph.h
+ */
+
+import type { CdtOset } from "./chan-dict.js";
+
+/**
+ * A 2D point with floating-point coordinates.
+ * Corresponds to `pointf` in the C source.
+ * @see common/types.h:pointf
+ */
+export interface OrthoPoint {
+  x: number;
+  y: number;
+}
+
+/**
+ * Axis-aligned bounding box.
+ * Corresponds to `boxf` in the C source.
+ * @see common/geom.h:boxf
+ */
+export interface OrthoBox {
+  LL: OrthoPoint; // lower-left
+  UR: OrthoPoint; // upper-right
+}
+
+/**
+ * Bend direction for segment endpoints.
+ * Corresponds to `enum bend` in structures.h.
+ * @see lib/ortho/structures.h:bend
+ */
+export const enum Bend {
+  B_NODE = 0,
+  B_UP = 1,
+  B_LEFT = 2,
+  B_DOWN = 3,
+  B_RIGHT = 4,
+}
+
+/**
+ * Pair of doubles (interval / extent).
+ * Corresponds to `paird` in structures.h.
+ * @see lib/ortho/structures.h:paird
+ */
+export interface Paird {
+  p1: number;
+  p2: number;
+}
+
+/**
+ * A routing segment — either horizontal or vertical.
+ * Corresponds to `struct segment` in structures.h.
+ * @see lib/ortho/structures.h:segment
+ */
+export interface OrthoSegment {
+  isVert: boolean;
+  commCoord: number; // the common (fixed) coordinate
+  p: Paird; // end-point range; p1 <= p2
+  l1: Bend;
+  l2: Bend;
+  indNo: number | null; // index in channel (-1 = unset)
+  trackNo: number | null; // assigned track number
+  prev: OrthoSegment | null;
+  next: OrthoSegment | null;
+}
+
+/**
+ * A route — an ordered array of segments.
+ * Corresponds to `route` in structures.h.
+ * @see lib/ortho/structures.h:route
+ */
+export interface Route {
+  segs: OrthoSegment[];
+}
+
+// ─── Maze cell ───────────────────────────────────────────────────────────────
+
+/** Cell flag constants. @see lib/ortho/maze.h */
+export const MZ_ISNODE = 1;
+export const MZ_VSCAN = 2;
+export const MZ_HSCAN = 4;
+export const MZ_SMALLV = 8;
+export const MZ_SMALLH = 16;
+
+/** Side indices. @see lib/ortho/maze.h */
+export const M_RIGHT = 0;
+export const M_TOP = 1;
+export const M_LEFT = 2;
+export const M_BOTTOM = 3;
+
+/** Forward references resolved by maze.ts */
+export interface SNode {
+  nVal: number; // negative while in PQ, positive when finalized
+  nIdx: number; // index in PQ heap
+  nDad: SNode | null; // parent in shortest-path tree
+  nEdge: SEdge | null; // edge leading to this node
+  nAdj: number; // number of adjacent edges (live)
+  saveNAdj: number; // saved nAdj for reset
+  cells: [Cell | null, Cell | null]; // [0] left/bottom, [1] top/right
+  // Adjacency as a spill-capable view into the graph's ONE shared edge-index
+  // buffer (sgraph.c:initSEdges allocates 6*nnodes + 2*maxdeg ints; each regular
+  // node gets a 6-slot region, each dummy `maxdeg`). addEdgeToNode writes at
+  // adjEdgeList[nAdj] with no bound, so a node with >6 incident edges (≤6
+  // permanent + temp edges) OVERFLOWS into the next node's region — and those
+  // spilled writes survive `reset` (only nAdj is restored), a load-bearing C
+  // behavior. An Int32Array subarray from the node's offset to the buffer end
+  // reproduces the forward spill exactly. `number[]` remains for the PQ guard /
+  // never-routed placeholder nodes that hold no edges.
+  adjEdgeList: Int32Array | number[]; // indices into edges array
+  index: number; // index in graph nodes array
+  isVert: boolean; // true = vertical boundary segment
+  x: number; // segment point x — mirrors C snode.p.x (maze dict key, numeric)
+  y: number; // segment point y — mirrors C snode.p.y
+}
+
+export interface SEdge {
+  weight: number;
+  cnt: number; // path usage counter
+  v1: number; // index of first endpoint
+  v2: number; // index of second endpoint
+}
+
+export interface SGraph {
+  nnodes: number;
+  nedges: number;
+  saveNnodes: number;
+  saveNedges: number;
+  nodes: SNode[];
+  edges: SEdge[];
+  /**
+   * The single contiguous adjacency buffer that every node's `adjEdgeList` is a
+   * subarray view into (sgraph.c:initSEdges). Kept on the graph so the backing
+   * store outlives the per-node views. Undefined until initSEdges runs.
+   */
+  adjBuf?: Int32Array;
+}
+
+/**
+ * A cell in the maze — a rectangular region between nodes.
+ * Corresponds to `struct cell` in maze.h.
+ * @see lib/ortho/maze.h:cell
+ */
+export interface Cell {
+  flags: number;
+  nedges: number;
+  edges: (SEdge | null)[]; // up to 6
+  nsides: number;
+  sides: (SNode | null)[]; // indexed by M_RIGHT, M_TOP, M_LEFT, M_BOTTOM
+  bb: OrthoBox;
+}
+
+/**
+ * The maze — partitioned free space around graph nodes.
+ * Corresponds to `maze` in maze.h.
+ * @see lib/ortho/maze.h:maze
+ */
+export interface Maze {
+  ncells: number;
+  ngcells: number;
+  cells: Cell[]; // non-node cells
+  gcells: Cell[]; // node cells
+  sg: SGraph;
+  hchans: ChanDict; // horizontal channels
+  vchans: ChanDict; // vertical channels
+}
+
+// ─── Rawgraph ────────────────────────────────────────────────────────────────
+
+/**
+ * Topological sort graph vertex.
+ * Corresponds to `vertex` in rawgraph.h.
+ * @see lib/ortho/rawgraph.h:vertex
+ */
+export interface RawVertex {
+  color: number; // 0=UNSCANNED, 1=SCANNING, 2=SCANNED
+  topsortOrder: number;
+  adjList: number[]; // adjacency list (directed)
+}
+
+/**
+ * Simple directed graph for channel ordering.
+ * Corresponds to `rawgraph` in rawgraph.h.
+ * @see lib/ortho/rawgraph.h:rawgraph
+ */
+export interface RawGraph {
+  nvs: number;
+  vertices: RawVertex[];
+}
+
+// ─── Channel ─────────────────────────────────────────────────────────────────
+
+/**
+ * A routing channel containing ordered segments.
+ * Corresponds to `channel` in structures.h.
+ * @see lib/ortho/structures.h:channel
+ */
+export interface Channel {
+  p: Paird; // spatial extent of channel
+  segList: OrthoSegment[]; // segments in this channel
+  G: RawGraph | null; // ordering graph
+  cp: Cell | null; // first cell in channel
+}
+
+/**
+ * One line of channels — outer channel-dict entry.
+ * Corresponds to `chanItem` in ortho.c.
+ * @see lib/ortho/ortho.c:chanItem
+ */
+export interface ChanItem {
+  v: number;
+  chans: CdtOset<Channel, Paird>;
+}
+
+/**
+ * Two-level channel dictionary — C's `Dt_t*` of chanItem (Dtoset keyed by v),
+ * each holding a Dtoset of Channel keyed by interval p (chancmpid).
+ * MUST be a C-exact cdt Dtoset: add_p_edges walks it flattened while
+ * chanSearch re-splays it mid-walk (load-bearing; see chan-dict.ts).
+ */
+export type ChanDict = CdtOset<ChanItem, number>;
+
+// ─── Public graph interface (self-contained) ─────────────────────────────────
+
+/**
+ * Minimal graph interface accepted by orthoEdges.
+ * Does not import from src/model or src/common.
+ */
+export interface OrthoNode {
+  /** Node bounding box in graph coordinates */
+  bb: OrthoBox;
+  /**
+   * ND_coord / ND_xsize (= lw+rw) / ND_ysize (= ht) exactly as C's mkMaze
+   * reads them (maze.c:452: gcell = coord ± fmax(1, size/2)). Deriving these
+   * from `bb` re-rounds — (coord+rw)-(coord-lw) loses the size's low bits when
+   * |coord| >> size — and that ULP shift can cross an integer boundary in the
+   * int-truncated Dijkstra (sgraph.c:165). Optional: callers that only model a
+   * bb fall back to bb-derived values.
+   */
+  coord?: OrthoPoint;
+  xsize?: number;
+  ysize?: number;
+}
+
+export interface OrthoEdge {
+  /** Source node */
+  tail: OrthoNode;
+  /** Destination node */
+  head: OrthoNode;
+  /**
+   * Tail attach point: ND_coord(tail) + ED_tail_port.p. Undefined (the
+   * default, port-less case) falls back to the tail node's bb centre.
+   * @see lib/ortho/ortho.c:1075 (attachOrthoEdges)
+   */
+  tailPoint?: OrthoPoint;
+  /**
+   * Head attach point: ND_coord(head) + ED_head_port.p. Undefined (the
+   * default, port-less case) falls back to the head node's bb centre.
+   * @see lib/ortho/ortho.c:1076 (attachOrthoEdges)
+   */
+  headPoint?: OrthoPoint;
+}
+
+export interface OrthoGraph {
+  nodes: OrthoNode[];
+  edges: OrthoEdge[];
+}
+
+/**
+ * Callback type for installing routed edges (corresponds to clip_and_install).
+ * @see lib/common/splines.c:clip_and_install
+ */
+export type ClipAndInstallFn = (
+  g: OrthoGraph,
+  e: OrthoEdge,
+  path: OrthoPoint[],
+  merge: boolean,
+) => void;

package/src/parser/__fixtures__/directed.dot

@@ -0,0 +1,10 @@
+digraph pipeline {
+  a [label="Source"]
+  b [label="Transform"]
+  c [label="Filter"]
+  d [label="Sink"]
+  a -> b [weight="2"]
+  b -> c [weight="1"]
+  b -> d [weight="3"]
+  c -> d [weight="1"]
+}

package/src/parser/__fixtures__/simple.dot

@@ -0,0 +1,7 @@
+graph simple {
+  a [label="Node A", color="blue"]
+  b [label="Node B", color="red"]
+  c [label="Node C", color="green"]
+  a -- b
+  b -- c
+}

package/src/parser/__fixtures__/subgraph.dot

@@ -0,0 +1,17 @@
+digraph clustered {
+  node [shape="box"]
+  edge [style="dashed"]
+  subgraph cluster_a {
+    label="Cluster A"
+    x [label="X"]
+    y [label="Y"]
+    x -> y
+  }
+  subgraph cluster_b {
+    label="Cluster B"
+    p [label="P"]
+    q [label="Q"]
+    p -> q
+  }
+  x -> p [label="cross"]
+}

package/src/parser/ast.ts

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * AST node types emitted by the Peggy-generated DOT parser.
+ *
+ * @see src/parser/dot.pegjs
+ * @see lib/cgraph/grammar.y
+ */
+
+export interface AttrPair {
+  readonly key: string;
+  readonly value: string;
+}
+
+export interface NodeId {
+  readonly id: string;
+  readonly port: string | null;
+  readonly compass: string | null;
+}
+
+export interface NodeStmt {
+  readonly type: 'node';
+  readonly id: NodeId;
+  readonly attrs: AttrPair[];
+}
+
+export interface EdgeStmt {
+  readonly type: 'edge';
+  readonly nodes: Array<NodeId | SubgraphStmt>;
+  readonly attrs: AttrPair[];
+}
+
+export interface AttrStmt {
+  readonly type: 'attr';
+  readonly target: 'graph' | 'node' | 'edge';
+  readonly attrs: AttrPair[];
+}
+
+export interface AssignStmt {
+  readonly type: 'assign';
+  readonly key: string;
+  readonly value: string;
+}
+
+export interface SubgraphStmt {
+  readonly type: 'subgraph';
+  readonly id: string | null;
+  readonly stmts: ParsedStmt[];
+}
+
+export type ParsedStmt =
+  | NodeStmt
+  | EdgeStmt
+  | AttrStmt
+  | AssignStmt
+  | SubgraphStmt;
+
+export interface ParsedGraph {
+  readonly type: 'graph';
+  readonly strict: boolean;
+  readonly directed: boolean;
+  readonly id: string | null;
+  readonly stmts: ParsedStmt[];
+}