@knowvah/dot-engine 0.1.0

package/src/vpsc/index.ts

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * TypeScript bridge for the VPSC solver — mirrors csolve_VPSC.h.
+ *
+ * Also exports Rectangle and constraint-generation functions ported from
+ * generate-constraints.cpp.
+ *
+ * @see lib/vpsc/csolve_VPSC.h
+ * @see lib/vpsc/csolve_VPSC.cpp
+ * @see lib/vpsc/generate-constraints.h
+ * @see lib/vpsc/generate-constraints.cpp
+ */
+
+import { Variable } from "./Variable.js";
+import { Constraint } from "./Constraint.js";
+import { Rectangle, VPSC, IncVPSC } from "./Solver.js";
+import { generateXConstraints, generateYConstraints } from "./SweepLine.js";
+
+export { Variable, Constraint, Rectangle, VPSC, IncVPSC };
+
+// ---------------------------------------------------------------------------
+// Variable bridge
+// @see lib/vpsc/csolve_VPSC.cpp
+// ---------------------------------------------------------------------------
+
+/** @see csolve_VPSC.cpp: Variable* newVariable(int id, double desiredPos, double weight) */
+export function newVariable(id: number, desiredPos: number, weight: number): Variable {
+  return new Variable(id, desiredPos, weight);
+}
+
+/** @see csolve_VPSC.cpp: void deleteVariable(Variable* v) */
+export function deleteVariable(_v: Variable): void {
+  // No heap allocation in TS; GC handles cleanup.
+}
+
+/** @see csolve_VPSC.cpp: void setVariableDesiredPos(Variable *, double) */
+export function setVariableDesiredPos(v: Variable, pos: number): void {
+  v.desiredPosition = pos;
+}
+
+/** @see csolve_VPSC.cpp: double getVariablePos(const Variable*) */
+export function getVariablePos(v: Variable): number {
+  return v.position();
+}
+
+// ---------------------------------------------------------------------------
+// Constraint bridge
+// @see lib/vpsc/csolve_VPSC.cpp
+// ---------------------------------------------------------------------------
+
+/** @see csolve_VPSC.cpp: Constraint* newConstraint(...) */
+export function newConstraint(left: Variable, right: Variable, gap: number): Constraint {
+  return new Constraint(left, right, gap);
+}
+
+/** @see csolve_VPSC.cpp: void deleteConstraint(Constraint* c) */
+export function deleteConstraint(c: Constraint): void {
+  c.destroy();
+}
+
+/** @see csolve_VPSC.cpp: void deleteConstraints(int m, Constraint **cs) */
+export function deleteConstraints(cs: Constraint[]): void {
+  for (const c of cs) c.destroy();
+}
+
+// ---------------------------------------------------------------------------
+// VPSC bridge
+// @see lib/vpsc/csolve_VPSC.cpp
+// ---------------------------------------------------------------------------
+
+/** @see csolve_VPSC.cpp: VPSC* newIncVPSC(int n, Variable* vs[], int m, Constraint* cs[]) */
+export function newIncVPSC(vs: Variable[], cs: Constraint[]): IncVPSC {
+  return new IncVPSC(vs, cs);
+}
+
+/**
+ * Call in order: deleteVPSC → deleteConstraints → deleteVariable.
+ * deleteVPSC releases block structures. Constraints still reference
+ * Variables; delete constraints before variables to avoid dangling refs.
+ *
+ * @see csolve_VPSC.cpp: void deleteVPSC(VPSC *vpsc)
+ */
+export function deleteVPSC(_vpsc: VPSC): void {
+  // No heap allocation in TS; documents teardown order only.
+}
+
+/** @see csolve_VPSC.cpp: void satisfyVPSC(VPSC* vpsc) */
+export function satisfyVPSC(vpsc: VPSC): void {
+  vpsc.satisfy();
+}
+
+/** @see csolve_VPSC.cpp: void solveVPSC(VPSC* vpsc) */
+export function solveVPSC(vpsc: VPSC): void {
+  vpsc.solve();
+}
+
+// ---------------------------------------------------------------------------
+// Constraint generation
+// @see lib/vpsc/generate-constraints.cpp: generateXConstraints, generateYConstraints
+// @see lib/vpsc/csolve_VPSC.cpp: genXConstraints, genYConstraints
+// ---------------------------------------------------------------------------
+
+/**
+ * Prepares constraints to apply VPSC horizontally (X axis).
+ * @see lib/vpsc/csolve_VPSC.cpp: genXConstraints
+ */
+export function genXConstraints(
+  rects: Rectangle[],
+  vs: Variable[],
+  useNeighbourLists: boolean
+): Constraint[] {
+  return generateXConstraints(rects, vs, useNeighbourLists);
+}
+
+/**
+ * Prepares constraints to apply VPSC vertically (Y axis).
+ * @see lib/vpsc/csolve_VPSC.cpp: genYConstraints
+ */
+export function genYConstraints(rects: Rectangle[], vs: Variable[]): Constraint[] {
+  return generateYConstraints(rects, vs);
+}

package/src/vpsc/sweepTypes.ts

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Internal types for the sweep-line constraint generation algorithm.
+ * Kept in a separate file so the lizard complexity analyser does not
+ * mistake interface blocks for function bodies in SweepLine.ts.
+ *
+ * @see lib/vpsc/generate-constraints.cpp
+ */
+
+import type { Variable } from "./Variable.js";
+import type { Rectangle } from "./Solver.js";
+
+export const EvType = { Open: 0, Close: 1 } as const;
+export type EvType = (typeof EvType)[keyof typeof EvType];
+
+export interface SweepNode {
+  v: Variable;
+  r: Rectangle;
+  pos: number;
+  firstAbove: SweepNode | null;
+  firstBelow: SweepNode | null;
+  leftNeighbours: Set<SweepNode>;
+  rightNeighbours: Set<SweepNode>;
+}
+
+export interface SweepEvent {
+  type: EvType;
+  node: SweepNode;
+  pos: number;
+}

package/src/xdot/index.ts

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: EPL-2.0
+/** @see lib/xdot/ */
+
+export { parseXDotFOn, parseXDotF, parseXDot, parseXDotColor } from './parse.js';
+export { freeXDot, freeXDotColor, statXDot, sprintXDot, jsonXDot } from './misc.js';
+export { XDOT_PARSE_ERROR } from './types.js';
+export type { Xdot, XdotOp, XdotStats, XdotColor, OpFunctions } from './types.js';

package/src/xdot/lex.ts

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Low-level lexer primitives for xdot attribute string parsing.
+ * Ported from ~/git/graphviz/lib/xdot/xdot.c helper functions.
+ */
+
+import type { XdotAlign, XdotPoint, XdotRect, XdotPolyline } from "./types.js";
+
+export type PR<T> = { val: T; pos: number } | null;
+
+// ---------------------------------------------------------------------------
+// Character helpers
+// ---------------------------------------------------------------------------
+export function isWs(c: string): boolean {
+  return c === " " || c === "\t" || c === "\n" || c === "\r";
+}
+
+export function isDigit(c: string): boolean {
+  return c >= "0" && c <= "9";
+}
+
+export function isAlnum(c: string): boolean {
+  return isDigit(c) || (c >= "a" && c <= "z") || (c >= "A" && c <= "Z");
+}
+
+export function skipWs(s: string, pos: number): number {
+  while (pos < s.length && isWs(s[pos])) pos++;
+  return pos;
+}
+
+// ---------------------------------------------------------------------------
+// Digit / exponent consumers
+// ---------------------------------------------------------------------------
+export function consumeDigits(s: string, i: number): number {
+  while (i < s.length && isDigit(s[i])) i++;
+  return i;
+}
+
+function consumeExponent(s: string, i: number): number {
+  if (i >= s.length) return i;
+  if (s[i] !== "e" && s[i] !== "E") return i;
+  i++;
+  if (i < s.length && (s[i] === "+" || s[i] === "-")) i++;
+  return consumeDigits(s, i);
+}
+
+// ---------------------------------------------------------------------------
+// parseReal — @see xdot.c:parseReal
+// ---------------------------------------------------------------------------
+export function parseReal(s: string, pos: number): PR<number> {
+  let i = skipWs(s, pos);
+  const start = i;
+  if (i < s.length && (s[i] === "-" || s[i] === "+")) i++;
+  const digStart = i;
+  i = consumeDigits(s, i);
+  if (i < s.length && s[i] === ".") { i++; i = consumeDigits(s, i); }
+  i = consumeExponent(s, i);
+  if (i === start || i === digStart) return null;
+  return { val: parseFloat(s.slice(start, i)), pos: i };
+}
+
+// ---------------------------------------------------------------------------
+// parseInt_ — @see xdot.c:parseInt
+// ---------------------------------------------------------------------------
+export function parseInt_(s: string, pos: number): PR<number> {
+  let i = skipWs(s, pos);
+  const start = i;
+  if (i < s.length && (s[i] === "-" || s[i] === "+")) i++;
+  const digStart = i;
+  i = consumeDigits(s, i);
+  if (i === digStart) return null;
+  return { val: parseInt(s.slice(start, i), 10), pos: i };
+}
+
+// ---------------------------------------------------------------------------
+// parseUInt_ — @see xdot.c:parseUInt
+// ---------------------------------------------------------------------------
+export function parseUInt_(s: string, pos: number): PR<number> {
+  const i = skipWs(s, pos);
+  const end = consumeDigits(s, i);
+  if (end === i) return null;
+  return { val: parseInt(s.slice(i, end), 10), pos: end };
+}
+
+// ---------------------------------------------------------------------------
+// parseRect — @see xdot.c:parseRect
+// ---------------------------------------------------------------------------
+export function parseRect(s: string, pos: number): PR<XdotRect> {
+  const rx = parseReal(s, pos); if (!rx) return null;
+  const ry = parseReal(s, rx.pos); if (!ry) return null;
+  const rw = parseReal(s, ry.pos); if (!rw) return null;
+  const rh = parseReal(s, rw.pos); if (!rh) return null;
+  return { val: { x: rx.val, y: ry.val, w: rw.val, h: rh.val }, pos: rh.pos };
+}
+
+// ---------------------------------------------------------------------------
+// parsePoint / parsePolyline — @see xdot.c:parsePolyline
+// ---------------------------------------------------------------------------
+function parsePoint(s: string, pos: number): PR<XdotPoint> {
+  const rx = parseReal(s, pos); if (!rx) return null;
+  const ry = parseReal(s, rx.pos); if (!ry) return null;
+  return { val: { x: rx.val, y: ry.val, z: 0 }, pos: ry.pos };
+}
+
+export function parsePolyline(s: string, pos: number): PR<XdotPolyline> {
+  const ri = parseUInt_(s, pos); if (!ri) return null;
+  let cur = ri.pos;
+  const pts: XdotPoint[] = [];
+  for (let i = 0; i < ri.val; i++) {
+    const rp = parsePoint(s, cur); if (!rp) return null;
+    pts.push(rp.val);
+    cur = rp.pos;
+  }
+  return { val: { pts }, pos: cur };
+}
+
+// ---------------------------------------------------------------------------
+// parseString — @see xdot.c:parseString
+// len counts source characters; a lone `\` is an escape prefix (not counted).
+// ---------------------------------------------------------------------------
+function nextAccounted(ch: string, prev: string, n: number): number {
+  return (ch !== "\\" || prev === "\\") ? n + 1 : n;
+}
+
+export function parseString(s: string, pos: number): PR<string> {
+  const ri = parseInt_(s, pos);
+  if (!ri || ri.val <= 0) return null;
+  const len = ri.val;
+  let cur = skipWs(s, ri.pos);
+  if (s[cur] !== "-") return null;
+  cur++;
+  let out = "";
+  let accounted = 0;
+  for (let j = 0; accounted < len; j++) {
+    if (cur + j >= s.length) return null;
+    const ch = s[cur + j];
+    out += ch;
+    accounted = nextAccounted(ch, j > 0 ? s[cur + j - 1] : "", accounted);
+    if (accounted >= len) return { val: out, pos: cur + j + 1 };
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// parseAlign — @see xdot.c:parseAlign
+// ---------------------------------------------------------------------------
+export function parseAlign(s: string, pos: number): PR<XdotAlign> {
+  const ri = parseInt_(s, pos); if (!ri) return null;
+  const align: XdotAlign = ri.val < 0 ? "left" : ri.val > 0 ? "right" : "center";
+  return { val: align, pos: ri.pos };
+}

package/src/xdot/misc.ts

@@ -0,0 +1,226 @@
+// SPDX-License-Identifier: EPL-2.0
+/** @see lib/xdot/xdot.c: sprintXDot, jsonXDot, statXDot, freeXDot */
+
+import type {
+  Xdot, XdotOp, XdotStats, XdotColor,
+  XdotLinearGrad, XdotRadialGrad, XdotPoint, XdotColorStop,
+} from './types.js';
+
+const ALIGN_NUM: Record<string, number> = { left: -1, center: 0, right: 1 };
+const SHAPE_LETTER: Record<string, string> = {
+  filled_ellipse: "E", unfilled_ellipse: "e",
+  filled_polygon: "P", unfilled_polygon: "p",
+  filled_bezier: "b", unfilled_bezier: "B",
+  polyline: "L",
+};
+const COLOR_KINDS = new Set(["fill_color","pen_color","grad_fill_color","grad_pen_color"]);
+const SHAPE_KINDS = new Set(Object.keys(SHAPE_LETTER));
+
+class XdotMiscHelper {
+  static trimZeros(s: string): string {
+    if (!s.includes(".")) return s;
+    return s.replace(/\.?0+$/, "");
+  }
+
+  static fmt(n: number): string {
+    return " " + XdotMiscHelper.trimZeros(n.toFixed(2));
+  }
+
+  static fmtStr(s: string): string {
+    return ` ${s.length} -${s}`;
+  }
+
+  static fmtPts(pts: XdotPoint[]): string {
+    return `${pts.length}${pts.map(p => `${XdotMiscHelper.fmt(p.x)}${XdotMiscHelper.fmt(p.y)}`).join("")}`;
+  }
+
+  static fmtStops(stops: XdotColorStop[]): string {
+    return stops.map(s => `${XdotMiscHelper.fmt(s.frac)}${XdotMiscHelper.fmtStr(s.color)}`).join("");
+  }
+
+  static fmtLinGrad(g: XdotLinearGrad): string {
+    const h = XdotMiscHelper;
+    return `[${h.fmt(g.x0)}${h.fmt(g.y0)}${h.fmt(g.x1)}${h.fmt(g.y1)}${h.fmt(g.stops.length)}${h.fmtStops(g.stops)}]`;
+  }
+
+  static fmtRadGrad(g: XdotRadialGrad): string {
+    const h = XdotMiscHelper;
+    return `(${h.fmt(g.x0)}${h.fmt(g.y0)}${h.fmt(g.r0)}${h.fmt(g.x1)}${h.fmt(g.y1)}${h.fmt(g.r1)}${h.fmt(g.stops.length)}${h.fmtStops(g.stops)})`;
+  }
+
+  static fmtColor(c: XdotColor): string {
+    if (c.type === "linear") return XdotMiscHelper.fmtLinGrad(c.ling);
+    if (c.type === "radial") return XdotMiscHelper.fmtRadGrad(c.ring);
+    return c.clr;
+  }
+
+  static sprintShapeOp(op: XdotOp): string {
+    const ch = SHAPE_LETTER[op.kind] ?? "";
+    const k = op.kind;
+    if (k === "filled_ellipse" || k === "unfilled_ellipse") {
+      const e = op.ellipse;
+      return `${ch}${XdotMiscHelper.fmt(e.x)}${XdotMiscHelper.fmt(e.y)}${XdotMiscHelper.fmt(e.w)}${XdotMiscHelper.fmt(e.h)}`;
+    }
+    if (k === "filled_polygon" || k === "unfilled_polygon") {
+      return `${ch} ${XdotMiscHelper.fmtPts(op.polygon.pts)}`;
+    }
+    if (k === "filled_bezier" || k === "unfilled_bezier") {
+      return `${ch} ${XdotMiscHelper.fmtPts(op.bezier.pts)}`;
+    }
+    return `${ch} ${XdotMiscHelper.fmtPts((op as Extract<XdotOp, { kind: "polyline" }>).polyline.pts)}`;
+  }
+
+  static sprintTextOp(op: Extract<XdotOp, { kind: "text" }>): string {
+    const t = op.text;
+    return `T${XdotMiscHelper.fmt(t.x)}${XdotMiscHelper.fmt(t.y)} ${ALIGN_NUM[t.align]}${XdotMiscHelper.fmt(t.width)}${XdotMiscHelper.fmtStr(t.text)}`;
+  }
+
+  static sprintColorOp(op: XdotOp): string {
+    const k = op.kind;
+    const ch = (k === "fill_color" || k === "grad_fill_color") ? "C" : "c";
+    const raw = op as { kind: string; color?: string; gradColor?: XdotColor };
+    if (k === "fill_color" || k === "pen_color") {
+      return `${ch}${XdotMiscHelper.fmtStr(raw.color!)}`;
+    }
+    const clr = XdotMiscHelper.fmtColor(raw.gradColor!);
+    return `${ch}${XdotMiscHelper.fmtStr(clr)}`;
+  }
+
+  static sprintMetaOp(op: XdotOp): string {
+    const k = op.kind;
+    if (k === "font") {
+      const f = op.font;
+      return `F${XdotMiscHelper.fmt(f.size)}${XdotMiscHelper.fmtStr(f.name)}`;
+    }
+    if (k === "style") return `S${XdotMiscHelper.fmtStr(op.style)}`;
+    if (k === "image") {
+      const img = op.image;
+      const r = img.pos;
+      return `I${XdotMiscHelper.fmt(r.x)}${XdotMiscHelper.fmt(r.y)}${XdotMiscHelper.fmt(r.w)}${XdotMiscHelper.fmt(r.h)}${XdotMiscHelper.fmtStr(img.name)}`;
+    }
+    return `t ${(op as Extract<XdotOp, { kind: "fontchar" }>).fontchar}`;
+  }
+
+  static sprintOp(op: XdotOp, more: number): string {
+    let s: string;
+    if (SHAPE_KINDS.has(op.kind)) s = XdotMiscHelper.sprintShapeOp(op);
+    else if (op.kind === "text") s = XdotMiscHelper.sprintTextOp(op as Extract<XdotOp, { kind: "text" }>);
+    else if (COLOR_KINDS.has(op.kind)) s = XdotMiscHelper.sprintColorOp(op);
+    else s = XdotMiscHelper.sprintMetaOp(op);
+    return more ? s + " " : s;
+  }
+
+  static jsonFmt(n: number): string { return n.toFixed(6); }
+
+  static jsonPts(pts: XdotPoint[]): string {
+    const f = XdotMiscHelper.jsonFmt;
+    return "[" + pts.map(p => `[${f(p.x)},${f(p.y)},${f(p.z)}]`).join(",") + "]";
+  }
+
+  static jsonOp(op: XdotOp): string {
+    const k = op.kind;
+    const f = XdotMiscHelper.jsonFmt;
+    if (k === "filled_ellipse" || k === "unfilled_ellipse") {
+      const e = op.ellipse;
+      const key = k === "filled_ellipse" ? "E" : "e";
+      return `{"${key}":[${f(e.x)},${f(e.y)},${f(e.w)},${f(e.h)}]}`;
+    }
+    if (k === "filled_polygon" || k === "unfilled_polygon") {
+      const key = k === "filled_polygon" ? "P" : "p";
+      return `{"${key}":${XdotMiscHelper.jsonPts(op.polygon.pts)}}`;
+    }
+    return XdotMiscHelper.jsonOp2(op);
+  }
+
+  static jsonOp2(op: XdotOp): string {
+    const k = op.kind;
+    const f = XdotMiscHelper.jsonFmt;
+    if (k === "filled_bezier" || k === "unfilled_bezier") {
+      const key = k === "filled_bezier" ? "b" : "B";
+      return `{"${key}":${XdotMiscHelper.jsonPts(op.bezier.pts)}}`;
+    }
+    if (k === "polyline") return `{"L":${XdotMiscHelper.jsonPts(op.polyline.pts)}}`;
+    if (k === "text") {
+      const t = op.text;
+      return `{"T":{"x":${f(t.x)},"y":${f(t.y)},"align":${ALIGN_NUM[t.align]},"width":${f(t.width)},"text":${JSON.stringify(t.text)}}}`;
+    }
+    return XdotMiscHelper.jsonOp3(op);
+  }
+
+  static jsonOp3(op: XdotOp): string {
+    const k = op.kind;
+    const jf = XdotMiscHelper.jsonFmt;
+    if (k === "fill_color") return `{"C":${JSON.stringify(op.color)}}`;
+    if (k === "pen_color") return `{"c":${JSON.stringify(op.color)}}`;
+    if (k === "grad_fill_color") return `{"C":${JSON.stringify(XdotMiscHelper.fmtColor(op.gradColor))}}`;
+    if (k === "grad_pen_color") return `{"c":${JSON.stringify(XdotMiscHelper.fmtColor(op.gradColor))}}`;
+    if (k === "font") {
+      const fnt = op.font;
+      return `{"F":{"size":${jf(fnt.size)},"name":${JSON.stringify(fnt.name)}}}`;
+    }
+    if (k === "style") return `{"S":${JSON.stringify(op.style)}}`;
+    if (k === "image") {
+      const img = op.image;
+      const r = img.pos;
+      return `{"I":{"x":${jf(r.x)},"y":${jf(r.y)},"w":${jf(r.w)},"h":${jf(r.h)},"name":${JSON.stringify(img.name)}}}`;
+    }
+    return `{"t":${(op as Extract<XdotOp, { kind: "fontchar" }>).fontchar}}`;
+  }
+
+  static statShapeCounts(op: XdotOp, sp: XdotStats): void {
+    const k = op.kind;
+    if (k === "filled_ellipse" || k === "unfilled_ellipse") { sp.nEllipse++; return; }
+    if (k === "filled_polygon" || k === "unfilled_polygon") {
+      sp.nPolygon++; sp.nPolygonPts += op.polygon.pts.length; return;
+    }
+    if (k === "filled_bezier" || k === "unfilled_bezier") {
+      sp.nBezier++; sp.nBezierPts += op.bezier.pts.length; return;
+    }
+    if (k === "polyline") { sp.nPolyline++; sp.nPolylinePts += op.polyline.pts.length; return; }
+    if (k === "text") sp.nText++;
+  }
+
+  static statAttrCounts(op: XdotOp, sp: XdotStats): void {
+    const k = op.kind;
+    if (k === "font") { sp.nFont++; return; }
+    if (k === "style") { sp.nStyle++; return; }
+    if (k === "fill_color" || k === "pen_color") { sp.nColor++; return; }
+    if (k === "grad_fill_color" || k === "grad_pen_color") { sp.nGradcolor++; return; }
+    if (k === "image") { sp.nImage++; return; }
+    if (k === "fontchar") sp.nFontchar++;
+  }
+
+  static stat(x: Xdot, sp: XdotStats): boolean {
+    if (!x) return false;
+    for (const op of x.ops) {
+      sp.cnt++;
+      XdotMiscHelper.statShapeCounts(op, sp);
+      XdotMiscHelper.statAttrCounts(op, sp);
+    }
+    return true;
+  }
+
+  static sprint(x: Xdot): string {
+    const n = x.ops.length;
+    return x.ops.map((op, i) => XdotMiscHelper.sprintOp(op, i < n - 1 ? 1 : 0)).join("");
+  }
+
+  static json(x: Xdot): string {
+    return "[\n" + x.ops.map(op => XdotMiscHelper.jsonOp(op) + "\n").join("") + "\n]";
+  }
+}
+
+/** @see lib/xdot/xdot.c:Pxdot_free */
+export function freeXDot(_x: Xdot | null): void { /* GC handles memory */ }
+
+/** @see lib/xdot/xdot.c:freeXDotColor */
+export function freeXDotColor(_c: XdotColor | null): void { /* GC handles memory */ }
+
+/** @see lib/xdot/xdot.c:statXDot */
+export function statXDot(x: Xdot, sp: XdotStats): boolean { return XdotMiscHelper.stat(x, sp); }
+
+/** @see lib/xdot/xdot.c:sprintXDot */
+export function sprintXDot(x: Xdot): string { return XdotMiscHelper.sprint(x); }
+
+/** @see lib/xdot/xdot.c:jsonXDot */
+export function jsonXDot(x: Xdot): string { return XdotMiscHelper.json(x); }