@knowvah/dot-engine 0.1.0

package/src/common/ps-fontalias.ts

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: EPL-2.0
+//
+// PostScript font-name → SVG font-family translation, ported from C graphviz
+// (lib/common/ps_font_equiv.h table + lib/common/textspan.c:66
+// translate_postscript_fontname). Native dot maps a standard PostScript font
+// name (e.g. "Times-Roman") to a renderer family with a generic SVG fallback
+// (e.g. font-family="Times,serif"); the SVG emitter consumes the alias's
+// family/weight/stretch/style. Without this the port emitted the name verbatim.
+//
+// The C lookup is a bsearch with strcasecmp — a case-insensitive EXACT match on
+// the name (NOT the fuzzy separator-insensitive normalization used by the
+// separate text-metrics table). A lower-cased Map reproduces that exactly.
+//
+// Platform: ps_font_equiv.h uses "Times"/"Palatino Linotype" on non-Windows and
+// "Times New Roman" on _WIN32. The oracle and goldens are non-Windows, so the
+// non-Windows family strings are used here.
+
+/**
+ * One PostScript-font alias entry (the fields the SVG renderer uses in the
+ * default NATIVEFONTS mode). `xfig_code` and the SVGFONTS-only svg_font_weight/
+ * svg_font_style fields are intentionally omitted — unused for SVG output.
+ * @see lib/common/textspan.h _PostscriptAlias
+ */
+export interface PostscriptAlias {
+  family: string;
+  weight: string | null;
+  stretch: string | null;
+  style: string | null;
+  svgFontFamily: string;
+}
+
+// Rows ported verbatim from ps_font_equiv.h (macros resolved, non-Windows):
+// [name, family, weight, stretch, style, svgFontFamily].
+const ALIAS_ROWS: readonly (readonly [
+  string, string, string | null, string | null, string | null, string,
+])[] = [
+  ['AvantGarde-Book', 'URW Gothic L', 'book', null, null, 'sans-Serif'],
+  ['AvantGarde-BookOblique', 'URW Gothic L', 'book', null, 'oblique', 'sans-Serif'],
+  ['AvantGarde-Demi', 'URW Gothic L', 'demi', null, null, 'sans-Serif'],
+  ['AvantGarde-DemiOblique', 'URW Gothic L', 'demi', null, 'oblique', 'sans-Serif'],
+  ['Bookman-Demi', 'URW Bookman L', 'demi', null, null, 'serif'],
+  ['Bookman-DemiItalic', 'URW Bookman L', 'demi', null, 'italic', 'serif'],
+  ['Bookman-Light', 'URW Bookman L', 'light', null, null, 'serif'],
+  ['Bookman-LightItalic', 'URW Bookman L', 'light', null, 'italic', 'serif'],
+  ['Courier', 'Courier', null, null, null, 'monospace'],
+  ['Courier-Bold', 'Courier', 'bold', null, null, 'monospace'],
+  ['Courier-BoldOblique', 'Courier', 'bold', null, 'oblique', 'monospace'],
+  ['Courier-Oblique', 'Courier', null, null, 'oblique', 'monospace'],
+  ['Helvetica', 'Helvetica', null, null, null, 'sans-Serif'],
+  ['Helvetica-Bold', 'Helvetica', 'bold', null, null, 'sans-Serif'],
+  ['Helvetica-BoldOblique', 'Helvetica', 'bold', null, 'oblique', 'sans-Serif'],
+  ['Helvetica-Narrow', 'Helvetica', null, 'condensed', null, 'sans-Serif'],
+  ['Helvetica-Narrow-Bold', 'Helvetica', 'bold', 'condensed', null, 'sans-Serif'],
+  ['Helvetica-Narrow-BoldOblique', 'Helvetica', 'bold', 'condensed', 'oblique', 'sans-Serif'],
+  ['Helvetica-Narrow-Oblique', 'Helvetica', null, 'condensed', 'oblique', 'sans-Serif'],
+  ['Helvetica-Oblique', 'Helvetica', null, null, 'oblique', 'sans-Serif'],
+  ['NewCenturySchlbk-Bold', 'Century Schoolbook L', 'bold', null, null, 'serif'],
+  ['NewCenturySchlbk-BoldItalic', 'Century Schoolbook L', 'bold', null, 'italic', 'serif'],
+  ['NewCenturySchlbk-Italic', 'Century Schoolbook L', null, null, 'italic', 'serif'],
+  ['NewCenturySchlbk-Roman', 'Century Schoolbook L', 'roman', null, null, 'serif'],
+  ['Palatino-Bold', 'Palatino Linotype', 'bold', null, null, 'serif'],
+  ['Palatino-BoldItalic', 'Palatino Linotype', 'bold', null, 'italic', 'serif'],
+  ['Palatino-Italic', 'Palatino Linotype', null, null, 'italic', 'serif'],
+  ['Palatino-Roman', 'Palatino Linotype', 'roman', null, null, 'serif'],
+  ['Symbol', 'Symbol', null, null, null, 'fantasy'],
+  ['Times-Bold', 'Times', 'bold', null, null, 'serif'],
+  ['Times-BoldItalic', 'Times', 'bold', null, 'italic', 'serif'],
+  ['Times-Italic', 'Times', null, null, 'italic', 'serif'],
+  ['Times-Roman', 'Times', null, null, null, 'serif'],
+  ['ZapfChancery-MediumItalic', 'URW Chancery L', 'medium', null, 'italic', 'serif'],
+  ['ZapfDingbats', 'Dingbats', null, null, null, 'fantasy'],
+];
+
+const ALIAS_BY_NAME: ReadonlyMap<string, PostscriptAlias> = new Map(
+  ALIAS_ROWS.map((r) => [
+    r[0].toLowerCase(),
+    { family: r[1], weight: r[2], stretch: r[3], style: r[4], svgFontFamily: r[5] },
+  ]),
+);
+
+/**
+ * Resolve a PostScript font name to its alias, or null when unknown.
+ * Case-insensitive exact match (mirrors C's strcasecmp bsearch).
+ * @see lib/common/textspan.c:66 translate_postscript_fontname
+ */
+export function translatePostscriptFontname(name: string): PostscriptAlias | null {
+  return ALIAS_BY_NAME.get(name.toLowerCase()) ?? null;
+}
+
+/**
+ * Build the SVG font attribute string for a span's font name when it resolves
+ * to a PostScript alias: ` font-family="family[,svgFontFamily]"` plus the
+ * alias's weight/stretch/style. Returns null when there is no alias (the caller
+ * emits the name verbatim). `weight`/`style` report whether the alias set them,
+ * so the HTML-flag block can avoid duplicating bold/italic.
+ *
+ * Family strings contain no XML-special characters, so (like C's raw `%s`) no
+ * escaping is applied here.
+ * @see plugin/core/gvrender_core_svg.c:462-495 svg_textspan (NATIVEFONTS)
+ */
+export function fontFamilyAttrs(
+  fontName: string | null,
+): { attrs: string; weight: boolean; style: boolean } | null {
+  const a = fontName !== null ? translatePostscriptFontname(fontName) : null;
+  if (a === null) return null;
+  const fam = a.svgFontFamily !== a.family ? a.family + ',' + a.svgFontFamily : a.family;
+  let attrs = ' font-family="' + fam + '"';
+  if (a.weight !== null) attrs += ' font-weight="' + a.weight + '"';
+  if (a.stretch !== null) attrs += ' font-stretch="' + a.stretch + '"';
+  if (a.style !== null) attrs += ' font-style="' + a.style + '"';
+  return { attrs, weight: a.weight !== null, style: a.style !== null };
+}

package/src/common/random.ts

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Exact port of the POSIX drand48/srand48 48-bit linear congruential
+ * generator used by the C layout engines (decision D3: iterative
+ * engines must replicate C numerics bit-for-bit; Math.random is
+ * forbidden in layout code).
+ *
+ * X(n+1) = (a * X(n) + c) mod 2^48, a = 0x5DEECE66D, c = 0xB.
+ * drand48() returns X(n+1) / 2^48 as a double.
+ * srand48(seed) sets X = (seed << 16) | 0x330E.
+ *
+ * @see POSIX drand48(3)
+ * @see lib/neatogen/neatoinit.c:checkStart (srand48 call)
+ */
+
+const A = 0x5deece66dn;
+const C = 0xbn;
+const MASK48 = (1n << 48n) - 1n;
+const TWO48 = 2 ** 48;
+
+let state = 0x330en; // POSIX default: X0 = 0x1234ABCD330E... see srand48 note
+
+/**
+ * Seed the generator: X = (seed << 16) | 0x330E (low 32 bits of seed).
+ * @see POSIX srand48(3)
+ */
+export function srand48(seed: number): void {
+  const s = BigInt(Math.trunc(seed)) & 0xffffffffn;
+  state = ((s << 16n) | 0x330en) & MASK48;
+}
+
+/** Next double in [0, 1). @see POSIX drand48(3) */
+export function drand48(): number {
+  state = (A * state + C) & MASK48;
+  return Number(state) / TWO48;
+}

package/src/common/record-port.ts

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Record-shape edge ports: resolve a `field:compass` port string to a point on
+ * the named field's bounding box (falling back to a compass on the whole
+ * record bbox when the name is not a field id).
+ *
+ * @see lib/common/shapes.c:map_rec_port (line 3716)
+ * @see lib/common/shapes.c:record_port (line 3732)
+ */
+
+import type { Node } from '../model/node.js';
+import type { Box, Port } from '../model/geom.js';
+import type { FieldT } from './types.js';
+import { makePort } from '../model/edgeInfo.js';
+import { compassPort } from './compass-port.js';
+import { BOTTOM, RIGHT, TOP, LEFT } from './splines-constants.js';
+
+const ALL_SIDES = BOTTOM | RIGHT | TOP | LEFT;
+
+/**
+ * Recurse the field tree for a field whose id equals str (depth-first).
+ * @see lib/common/shapes.c:map_rec_port
+ */
+export function mapRecPort(f: FieldT, str: string): FieldT | null {
+  if (f.id !== null && f.id === str) return f;
+  if (f.fld !== null) {
+    for (let i = 0; i < f.n_flds; i++) {
+      const rv = mapRecPort(f.fld[i]!, str);
+      if (rv !== null) return rv;
+    }
+  }
+  return null;
+}
+
+/**
+ * portfn for record shapes. Empty portname → Center (makePort, byte-stable).
+ * A matching field → compass on the field bbox; otherwise the portname is
+ * treated as a compass on the whole record bbox.
+ * @see lib/common/shapes.c:record_port
+ */
+export function recordPort(n: Node, portname: string, compass: string): Port {
+  if (portname.length === 0) return makePort(); // C: return Center
+  const compassStr = compass.length === 0 ? '_' : compass; // C: NULL → "_"
+  const f = n.info.shape_info as FieldT | undefined;
+  const rv = makePort();
+  if (f === undefined) return rv;
+  const subf = mapRecPort(f, portname);
+  if (subf !== null) {
+    compassPort(n, { bp: subf.b, compass: compassStr, sides: subf.sides }, rv);
+  } else {
+    compassPort(n, { bp: f.b, compass: portname, sides: ALL_SIDES }, rv);
+  }
+  return rv;
+}
+
+/**
+ * pboxfn for record shapes: "generate box path from port to border". Emit ONE
+ * box — the full-node-height vertical strip of the TOP-LEVEL field whose axis
+ * range brackets the port point `prt.p.x` — into `rv[0]`, set `kptr[0]=1`, and
+ * return `side`. Returns 0 when the port is undefined. Without this, a record
+ * head/tail port with no explicit side (interior cell, side==0) falls back to
+ * the node's maximal bbox and the spline cuts straight across instead of
+ * hugging the port column. @see lib/common/shapes.c:record_path (line 3793)
+ */
+export function recordPath(n: Node, prt: Port, side: number, rv: Box[], kptr: number[]): number {
+  if (!prt.defined) return 0;
+  const info = n.info.shape_info as FieldT | undefined;
+  if (info === undefined || info.fld === null) return side;
+  const flip = n.root.info.flip === true; // GD_flip
+  const cx = n.info.coord.x;
+  const cy = n.info.coord.y;
+  const ht2 = n.info.ht / 2;
+  for (let i = 0; i < info.n_flds; i++) {
+    const fb = info.fld[i]!.b;
+    // C: axis is x for TB/BT, y for LR/RL (GD_flip).
+    const ls = flip ? fb.ll.y : fb.ll.x;
+    const rs = flip ? fb.ur.y : fb.ur.x;
+    if (ls <= prt.p.x && prt.p.x <= rs) {
+      // C sets LL.x/LL.y/UR.x in-branch, then UR.y = coord.y + ht/2 for both.
+      rv[0] = flip
+        ? { ll: { x: fb.ll.y + cx, y: fb.ll.x + cy }, ur: { x: fb.ur.y + cx, y: cy + ht2 } }
+        : { ll: { x: cx + ls, y: cy - ht2 }, ur: { x: cx + rs, y: cy + ht2 } };
+      kptr[0] = 1;
+      break;
+    }
+  }
+  return side;
+}