@knowvah/dot-engine 1.2.2 → 1.2.4

package/src/layout/osage/layout.ts

@@ -1,254 +0,0 @@
-// SPDX-License-Identifier: EPL-2.0
-
-/**
- * Osage recursive layout helpers.
- *
- * @see lib/osage/osageinit.c:layout
- * @see lib/osage/osageinit.c:reposition
- */
-
-import type { Graph } from '../../model/graph.js';
-import type { Node } from '../../model/node.js';
-import type { Box, Point } from '../../model/geom.js';
-import type { PackInfo } from '../pack/index.js';
-import type { ChildLists } from './types.js';
-import { PackMode, getPackInfo, putRects, PK_USER_VALS } from '../pack/index.js';
-import { PARENT } from './index.js';
-
-export type { ChildLists };
-
-const DFLT_SZ = 18;
-const DFLT_MARGIN = 8;
-
-// ---------------------------------------------------------------------------
-// Box helpers
-// ---------------------------------------------------------------------------
-
-const makeBox = (llx: number, lly: number, urx: number, ury: number): Box =>
-  ({ ll: { x: llx, y: lly }, ur: { x: urx, y: ury } });
-
-const copyBox = (b: Box): Box =>
-  makeBox(b.ll.x, b.ll.y, b.ur.x, b.ur.y);
-
-const shiftBox = (b: Box, p: Point): Box =>
-  makeBox(b.ll.x + p.x, b.ll.y + p.y, b.ur.x + p.x, b.ur.y + p.y);
-
-// ---------------------------------------------------------------------------
-// PackInfo builder
-// ---------------------------------------------------------------------------
-
-/** Build and populate a PackInfo from graph attributes. @see lib/osage/osageinit.c:layout */
-export const buildPackInfo = (g: Graph): PackInfo => {
-  const p: PackInfo = { aspect: 1, sz: 0, margin: DFLT_MARGIN,
-    doSplines: false, mode: PackMode.Array, fixed: null, vals: null, flags: 0 };
-  getPackInfo(g, PackMode.Array, DFLT_MARGIN, p);
-  if (p.mode < PackMode.Graph) p.mode = PackMode.Graph;
-  return p;
-};
-
-// ---------------------------------------------------------------------------
-// ChildLists builders
-// ---------------------------------------------------------------------------
-
-const newChildLists = (): ChildLists =>
-  ({ gs: [], childGraphs: [], childNodes: [], vals: [] });
-
-const addCluster = (lists: ChildLists, sg: Graph, useVals: boolean): void => {
-  lists.gs.push(copyBox(sg.info.bb));
-  lists.childGraphs.push(sg);
-  if (useVals) lists.vals.push(0);
-};
-
-const addNode = (lists: ChildLists, n: Node, owner: Graph, useVals: boolean): void => {
-  n.info.alg = { kind: 'osage', ownerCluster: owner };
-  lists.gs.push(makeBox(0, 0, n.info.lw + n.info.rw, n.info.ht));
-  lists.childNodes.push(n);
-  if (useVals) lists.vals.push(0);
-};
-
-const fillClusters = (g: Graph, nClust: number, lists: ChildLists, uv: boolean): void => {
-  for (let i = 1; i <= nClust; i++) addCluster(lists, g.info.clust![i - 1], uv);
-};
-
-const fillNodes = (g: Graph, nvs: number, lists: ChildLists, uv: boolean): void => {
-  if (g.nodes.size <= nvs) return;
-  for (const n of g.nodes.values()) {
-    if (n.info.alg === undefined) addNode(lists, n, g, uv);
-  }
-};
-
-/**
- * Build child arrays for putRects.
- * @see lib/osage/osageinit.c:layout (child list construction)
- */
-export const buildChildLists = (g: Graph, nClust: number, nvs: number, p: PackInfo): ChildLists => {
-  const useVals = p.mode === PackMode.Array && (p.flags & PK_USER_VALS) !== 0;
-  const lists = newChildLists();
-  fillClusters(g, nClust, lists, useVals);
-  fillNodes(g, nvs, lists, useVals);
-  return lists;
-};
-
-// ---------------------------------------------------------------------------
-// Bounding-box union accumulator
-// ---------------------------------------------------------------------------
-
-const emptyUnion = (): Box => makeBox(Infinity, Infinity, -Infinity, -Infinity);
-
-const expandUnion = (u: Box, b: Box): void => {
-  if (b.ll.x < u.ll.x) u.ll.x = b.ll.x;
-  if (b.ll.y < u.ll.y) u.ll.y = b.ll.y;
-  if (b.ur.x > u.ur.x) u.ur.x = b.ur.x;
-  if (b.ur.y > u.ur.y) u.ur.y = b.ur.y;
-};
-
-const placeChild = (lists: ChildLists, i: number, tb: Box): void => {
-  const ng = lists.childGraphs.length;
-  if (i < ng) {
-    lists.childGraphs[i]!.info.bb = tb;
-  } else {
-    const nd = lists.childNodes[i - ng]!;
-    nd.info.coord = { x: (tb.ll.x + tb.ur.x) / 2, y: (tb.ll.y + tb.ur.y) / 2 };
-  }
-};
-
-/**
- * Apply putRects offsets to child bbs/coords; return union bounding box.
- * @see lib/osage/osageinit.c:layout (offset application loop)
- */
-export const applyOffsets = (lists: ChildLists, pts: Point[]): Box => {
-  const u = emptyUnion();
-  for (let i = 0; i < lists.gs.length; i++) {
-    const tb = shiftBox(lists.gs[i]!, pts[i]!);
-    expandUnion(u, tb);
-    placeChild(lists, i, tb);
-  }
-  return u;
-};
-
-// ---------------------------------------------------------------------------
-// Label + margin adjustments
-// ---------------------------------------------------------------------------
-
-/**
- * Widen union bb if the graph label is wider than packed content.
- * @see lib/osage/osageinit.c:layout (GD_label block)
- */
-export const applyLabelExpansion = (g: Graph, total: number, u: Box): Box => {
-  const dim = (g.info.label as { dimen?: Point } | undefined)?.dimen;
-  if (!dim) return u;
-  if (total === 0) return makeBox(0, 0, dim.x, dim.y);
-  const d = dim.x - (u.ur.x - u.ll.x);
-  if (d > 0) { u.ll.x -= d / 2; u.ur.x += d / 2; }
-  return u;
-};
-
-const borderY = (g: Graph, idx: 2 | 3): number =>
-  g.info.border ? g.info.border[idx].y : 0;
-
-/**
- * Add margin and label-border padding to the union bounding box.
- * @see lib/osage/osageinit.c:layout (margin/border block)
- */
-export const addMarginAndBorder = (g: Graph, margin: number, u: Box): Box =>
-  makeBox(
-    u.ll.x - margin, u.ll.y - margin - borderY(g, 3),
-    u.ur.x + margin, u.ur.y + margin + borderY(g, 2),
-  );
-
-// ---------------------------------------------------------------------------
-// Origin translation
-// ---------------------------------------------------------------------------
-
-const shiftCluster = (sg: Graph, ox: number, oy: number): void => {
-  const b = sg.info.bb;
-  sg.info.bb = makeBox(b.ll.x - ox, b.ll.y - oy, b.ur.x - ox, b.ur.y - oy);
-};
-
-const shiftNode = (nd: Node, ox: number, oy: number): void => {
-  nd.info.coord = { x: nd.info.coord.x - ox, y: nd.info.coord.y - oy };
-};
-
-/**
- * Subtract union.ll from all child positions so this cluster's LL = (0,0).
- * @see lib/osage/osageinit.c:layout (translate-to-origin loop)
- */
-export const translateToOrigin = (lists: ChildLists, u: Box): void => {
-  for (const sg of lists.childGraphs) shiftCluster(sg, u.ll.x, u.ll.y);
-  for (const nd of lists.childNodes) shiftNode(nd, u.ll.x, u.ll.y);
-};
-
-// ---------------------------------------------------------------------------
-// osageLayoutRec
-// ---------------------------------------------------------------------------
-
-const recurseSubclusters = (g: Graph, nClust: number, depth: number): number => {
-  let nvs = 0;
-  for (let i = 1; i <= nClust; i++) {
-    const sg = g.info.clust![i - 1];
-    osageLayoutRec(sg, depth + 1);
-    nvs += sg.nodes.size;
-  }
-  return nvs;
-};
-
-const packAndPlace = (g: Graph, nClust: number, nvs: number, depth: number): void => {
-  const p = buildPackInfo(g);
-  const lists = buildChildLists(g, nClust, nvs, p);
-  if (p.vals === null && lists.vals.length > 0) p.vals = lists.vals;
-  const pts = putRects(lists.gs.length, lists.gs, p);
-  if (!pts) return;
-  let u = applyOffsets(lists, pts);
-  u = applyLabelExpansion(g, g.nodes.size - nvs + nClust, u);
-  u = addMarginAndBorder(g, depth > 0 ? p.margin / 2 : 0, u);
-  translateToOrigin(lists, u);
-  g.info.bb = makeBox(0, 0, u.ur.x - u.ll.x, u.ur.y - u.ll.y);
-};
-
-/**
- * Recursively pack all direct children (subclusters + loose nodes) of g.
- * @see lib/osage/osageinit.c:layout
- */
-export const osageLayoutRec = (g: Graph, depth: number): void => {
-  const nClust = g.info.n_cluster ?? 0;
-  const nvs = recurseSubclusters(g, nClust, depth);
-  if (g.nodes.size - nvs + nClust === 0 && !g.info.label) {
-    g.info.bb = makeBox(0, 0, DFLT_SZ, DFLT_SZ);
-    return;
-  }
-  packAndPlace(g, nClust, nvs, depth);
-};
-
-// ---------------------------------------------------------------------------
-// osageReposition
-// ---------------------------------------------------------------------------
-
-const repositionNodes = (g: Graph, bb: Box): void => {
-  for (const n of g.nodes.values()) {
-    if (PARENT(n) !== g) continue;
-    n.info.coord = { x: n.info.coord.x + bb.ll.x, y: n.info.coord.y + bb.ll.y };
-  }
-};
-
-const shiftSubclusterBb = (sg: Graph, parentBb: Box): void => {
-  const s = sg.info.bb;
-  sg.info.bb = makeBox(
-    s.ll.x + parentBb.ll.x, s.ll.y + parentBb.ll.y,
-    s.ur.x + parentBb.ll.x, s.ur.y + parentBb.ll.y,
-  );
-};
-
-/**
- * Convert cluster-relative coordinates to absolute root-relative coordinates.
- * @see lib/osage/osageinit.c:reposition
- */
-export const osageReposition = (g: Graph, depth: number): void => {
-  const bb = g.info.bb;
-  const nClust = g.info.n_cluster ?? 0;
-  if (depth > 0) repositionNodes(g, bb);
-  for (let i = 1; i <= nClust; i++) {
-    const sg = g.info.clust![i - 1];
-    if (depth > 0) shiftSubclusterBb(sg, bb);
-    osageReposition(sg, depth + 1);
-  }
-};

package/src/layout/pack/test-helpers.ts

@@ -1,46 +0,0 @@
-// SPDX-License-Identifier: EPL-2.0
-
-/**
- * Shared test helpers for pack module tests.
- * Isolated in their own file so Lizard counts each function independently.
- */
-
-import { expect } from 'vitest';
-import type { Box, Point } from '../../model/geom.js';
-import { type PackInfo, PackMode } from './types.js';
-
-export function box(llx: number, lly: number, urx: number, ury: number): Box {
-  return { ll: { x: llx, y: lly }, ur: { x: urx, y: ury } };
-}
-
-export function defaultPackInfo(overrides?: Partial<PackInfo>): PackInfo {
-  return {
-    aspect: 1, sz: 0, margin: 0, doSplines: false,
-    mode: PackMode.Graph, fixed: null, vals: null, flags: 0,
-    ...overrides,
-  };
-}
-
-export function applyPlaces(bbs: Box[], places: Point[]): Box[] {
-  return bbs.map((bb, i) => {
-    const p = places[i] ?? { x: 0, y: 0 };
-    return box(bb.ll.x + p.x, bb.ll.y + p.y, bb.ur.x + p.x, bb.ur.y + p.y);
-  });
-}
-
-function overlaps(a: Box, b: Box): boolean {
-  return a.ur.x > b.ll.x && b.ur.x > a.ll.x &&
-    a.ur.y > b.ll.y && b.ur.y > a.ll.y;
-}
-
-export function assertNoOverlap(placed: Box[]): void {
-  for (let i = 0; i < placed.length; i++) {
-    for (let j = i + 1; j < placed.length; j++) {
-      const a = placed[i];
-      const b = placed[j];
-      if (a !== undefined && b !== undefined) {
-        expect(overlaps(a, b), `boxes ${i} and ${j} overlap`).toBe(false);
-      }
-    }
-  }
-}

package/src/layout/patchwork/tree-node.ts

@@ -1,120 +0,0 @@
-// SPDX-License-Identifier: EPL-2.0
-
-/**
- * Internal tree node and construction helpers for the patchwork layout.
- *
- * Mirrors treenode_t and mkTree from lib/patchwork/patchwork.c.
- *
- * @see lib/patchwork/patchwork.c:treenode_t
- * @see lib/patchwork/patchwork.c:mkTree
- */
-
-import type { Graph } from '../../model/graph.js';
-import type { Node } from '../../model/node.js';
-import type { Rectangle } from './tree-map.js';
-
-/** @see lib/patchwork/patchwork.c:treenode_t */
-export interface TreeNode {
-  area: number;
-  childArea: number;
-  r: Rectangle;
-  leftChild: TreeNode | null;
-  rightSib: TreeNode | null;
-  kind: 'graph' | 'node';
-  ref: Graph | Node;
-  nChildren: number;
-}
-
-/** Default area when attribute is missing or zero. @see lib/patchwork/patchwork.c */
-const DFLT_SZ = 1.0;
-
-/** Area multiplier for numerical stability. @see lib/patchwork/patchwork.c */
-const SCALE = 1000.0;
-
-/** @see lib/patchwork/patchwork.c:getArea */
-export function getArea(attrs: Map<string, string>): number {
-  const raw = attrs.get('area');
-  let area = raw !== undefined ? parseFloat(raw) : DFLT_SZ;
-  if (!isFinite(area) || area === 0) area = DFLT_SZ;
-  return area * SCALE;
-}
-
-/** @see lib/patchwork/patchwork.c:fullArea (mp parameter) */
-export function getInset(attrs: Map<string, string>): number {
-  const raw = attrs.get('inset');
-  if (raw === undefined) return 0;
-  const v = parseFloat(raw);
-  return isFinite(v) ? v : 0;
-}
-
-/** wid = 2*inset + sqrt(childArea), area = wid². @see lib/patchwork/patchwork.c:fullArea */
-export function fullArea(childArea: number, inset: number): number {
-  const wid = 2.0 * inset + Math.sqrt(childArea);
-  return wid * wid;
-}
-
-/** Mutable accumulator used during tree construction. */
-export interface ChildAccum {
-  first: TreeNode | null;
-  prev: TreeNode | null;
-  area: number;
-  nChildren: number;
-}
-
-/** Append all cluster children of g to accum. @see lib/patchwork/patchwork.c:mkTree */
-export function appendClusters(g: Graph, sparent: Map<Node, Graph>, accum: ChildAccum): void {
-  for (const subg of g.info.clust ?? []) {
-    const cp = mkTree(subg, sparent);
-    accum.nChildren++;
-    accum.area += cp.area;
-    if (!accum.first) accum.first = cp;
-    if (accum.prev) accum.prev.rightSib = cp;
-    accum.prev = cp;
-  }
-}
-
-/** Append unclaimed direct nodes of g to accum. @see lib/patchwork/patchwork.c:mkTree */
-export function appendNodes(g: Graph, sparent: Map<Node, Graph>, accum: ChildAccum): void {
-  for (const n of g.nodes.values()) {
-    if (sparent.has(n)) continue;
-    const cp: TreeNode = {
-      area: getArea(n.attrs),
-      childArea: 0,
-      r: { x: [0, 0], size: [0, 0] },
-      leftChild: null, rightSib: null,
-      kind: 'node', ref: n, nChildren: 0,
-    };
-    accum.nChildren++;
-    accum.area += cp.area;
-    if (!accum.first) accum.first = cp;
-    if (accum.prev) accum.prev.rightSib = cp;
-    accum.prev = cp;
-    sparent.set(n, g);
-  }
-}
-
-/**
- * Recursively build the internal TreeNode tree from a Graph hierarchy.
- * Nodes already owned by a cluster (sparent set) are skipped.
- * @see lib/patchwork/patchwork.c:mkTree
- */
-export function mkTree(g: Graph, sparent: Map<Node, Graph>): TreeNode {
-  const p: TreeNode = {
-    area: 0, childArea: 0,
-    r: { x: [0, 0], size: [0, 0] },
-    leftChild: null, rightSib: null,
-    kind: 'graph', ref: g, nChildren: 0,
-  };
-  const accum: ChildAccum = { first: null, prev: null, area: 0, nChildren: 0 };
-  appendClusters(g, sparent, accum);
-  appendNodes(g, sparent, accum);
-  p.nChildren = accum.nChildren;
-  if (accum.nChildren > 0) {
-    p.childArea = accum.area;
-    p.area = fullArea(accum.area, getInset(g.attrs));
-  } else {
-    p.area = getArea(g.attrs);
-  }
-  p.leftChild = accum.first;
-  return p;
-}

package/src/xdot/lex.ts

@@ -1,151 +0,0 @@
-// 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 };
-}