@knowvah/dot-engine 2.0.0 → 2.0.2

package/src/layout/neato/dijkstra.ts

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: EPL-2.0
 /** @see lib/neatogen/dijkstra.c */
 
-import type { GraphSgd } from './sgd.js';
-
 /**
  * Sparse-graph vertex descriptor used by neato layout algorithms.
  * Matches `vtx_data` in lib/neatogen/sparsegraph.h.
@@ -31,9 +29,6 @@ export interface TermSgd {
   w: number;  // weight = 1/d²
 }
 
-/** Sentinel used for unvisited BFS nodes (matches C INT_MAX). */
-const BFS_INF = 0x7fffffff;
-
 // ---------------------------------------------------------------------------
 // Min-heap (keyed by Float32Array distances)
 // ---------------------------------------------------------------------------
@@ -158,139 +153,3 @@ export function dijkstra(
     dijkstraRelax(closest, closestDist, graph, dist, heap);
   }
 }
-
-// ---------------------------------------------------------------------------
-// Public: All-pairs shortest paths (packed upper-triangular)
-// ---------------------------------------------------------------------------
-
-/**
- * BFS single-source distances for unweighted graphs.
- * Fills `dist` with hop counts; unreachable nodes get BFS_INF (0x7fffffff).
- * edges[0] of each vertex is the self-loop and is skipped.
- * @see lib/neatogen/bfs.c:bfs
- */
-export function bfsDistances(
-  src: number,
-  graph: VtxData[],
-  n: number,
-  dist: Float32Array,
-): void {
-  for (let i = 0; i < n; i++) dist[i] = BFS_INF;
-  dist[src] = 0;
-  const queue = new Int32Array(n);
-  let head = 0, tail = 0;
-  queue[tail++] = src;
-  while (head < tail) {
-    const u = queue[head++];
-    const d = dist[u] + 1;
-    const vtx = graph[u];
-    for (let e = 1; e < vtx.nedges; e++) {
-      const v = vtx.edges[e];
-      if (dist[v] === BFS_INF) { dist[v] = d; queue[tail++] = v; }
-    }
-  }
-}
-
-/**
- * All-pairs shortest paths (unweighted), packed upper-triangular.
- * Length n*(n+1)/2; index for (i,j) j>=i: i*(2n-i-1)/2 + j.
- * @see lib/neatogen/stress.c:compute_apsp_packed
- */
-export function computeApspPacked(graph: VtxData[], n: number): Float32Array {
-  const result = new Float32Array(n * (n + 1) / 2);
-  const di = new Float32Array(n);
-  let count = 0;
-  for (let i = 0; i < n; i++) {
-    bfsDistances(i, graph, n, di);
-    for (let j = i; j < n; j++) result[count++] = di[j];
-  }
-  return result;
-}
-
-/**
- * All-pairs shortest paths (weighted), packed upper-triangular.
- * Length n*(n+1)/2.
- * @see lib/neatogen/stress.c:compute_weighted_apsp_packed
- */
-export function computeWeightedApspPacked(
-  graph: VtxData[],
-  n: number,
-): Float32Array {
-  const result = new Float32Array(n * (n + 1) / 2);
-  const di = new Float32Array(n);
-  let count = 0;
-  for (let i = 0; i < n; i++) {
-    dijkstra(i, graph, n, di);
-    for (let j = i; j < n; j++) result[count++] = di[j];
-  }
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// dijkstraSgd helpers
-// ---------------------------------------------------------------------------
-
-/** Initialise SGD dists from source's adjacency list. @internal */
-export function sgdInitDist(
-  graph: GraphSgd,
-  src: number,
-  dists: Float32Array,
-): void {
-  dists[src] = 0;
-  const end = graph.sources[src + 1];
-  for (let i = graph.sources[src]; i < end; i++) {
-    dists[graph.targets[i]] = graph.weights[i];
-  }
-}
-
-/** Relax SGD neighbours of `closest` and push updates onto `heap`. @internal */
-export function sgdRelaxNeighbors(
-  graph: GraphSgd,
-  closest: number,
-  d: number,
-  dists: Float32Array,
-  heap: number[],
-): void {
-  const end = graph.sources[closest + 1];
-  for (let i = graph.sources[closest]; i < end; i++) {
-    const target = graph.targets[i];
-    const nd = d + graph.weights[i];
-    if (nd < dists[target]) {
-      dists[target] = nd;
-      heapPush(heap, dists, target);
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Public: dijkstraSgd
-// ---------------------------------------------------------------------------
-
-/**
- * Single-source shortest paths for the SGD engine.
- * Writes terms for all reachable `j < src` and pinned nodes.
- * Returns the count of terms written.
- *
- * @see lib/neatogen/dijkstra.c:dijkstra_sgd
- */
-export function dijkstraSgd(
-  graph: GraphSgd,
-  src: number,
-  terms: TermSgd[],
-): number {
-  const n = graph.n;
-  const dists = new Float32Array(n).fill(Infinity);
-  sgdInitDist(graph, src, dists);
-  const heap = heapBuildExcluding(src, n, dists);
-  let offset = 0;
-  while (heap.length > 0) {
-    const closest = heapPop(heap, dists);
-    const d = dists[closest];
-    if (!isFinite(d)) break;
-    if (graph.pinneds[closest] || closest < src) {
-      terms[offset++] = { i: src, j: closest, d, w: 1 / (d * d) };
-    }
-    sgdRelaxNeighbors(graph, closest, d, dists, heap);
-  }
-  return offset;
-}

package/src/layout/neato/fdp-adjust.ts

@@ -18,6 +18,8 @@ import {
 } from '../sfdp/sparse-matrix.js';
 import { removeOverlapPrism } from './overlap-prism.js';
 import { scAdjust } from './sc-adjust.js';
+import { simpleScale } from './simple-scale.js';
+import { normalizeG } from '../fdp/normalize.js';
 import { AM_ORTHO, AM_ORTHO_YX, AM_ORTHOXY, AM_ORTHOYX, AM_PORTHO, AM_PORTHO_YX, AM_PORTHOXY, AM_PORTHOYX, cAdjust } from './constraint-adjust.js';
 import { countOverlapIn, sAdjustGraph } from './adjust-info.js';
 import { vpscAdjust } from './vpsc-adjust.js';
@@ -149,12 +151,26 @@ const ADJUST_MODES = new Map<string, readonly [number, string]>([
   ['porthoyx', [AM_PORTHOYX, 'yx pseudo-orthogonal constraints']],
 ]);
 
+/**
+ * getAdjustMode's fallback warning: a value that is not a mode name, not
+ * prism*, and not a boolean is used as `false` (prism) with this warning.
+ * @see lib/neatogen/adjust.c:getAdjustMode (unmappable branch)
+ */
+export function warnUnrecognizedOverlap(flag: string | undefined): void {
+  if (flag === undefined || flag === '') return;
+  const s = flag.toLowerCase();
+  if (s.startsWith('prism') || NAMED_MODES.has(s)) return;
+  if (mapBoolDflt(flag, false) === mapBoolDflt(flag, true)) return;
+  console.warn(`Unrecognized overlap value "${flag}" - using false`);
+}
+
 /**
  * Resolve an `overlap` value to its adjust mode (the PRISM try count lands in
- * `value`).
+ * `value`), warning as C does for an unrecognized value.
  * @see lib/neatogen/adjust.c:getAdjustMode
  */
 export function getAdjustMode(flag: string | undefined): AdjustData {
+  warnUnrecognizedOverlap(flag);
   const ntry = overlapPrismTries(flag);
   if (ntry !== null) return { mode: AM_PRISM, print: 'prism', value: ntry };
   const named = ADJUST_MODES.get((flag ?? '').toLowerCase());
@@ -208,15 +224,16 @@ function adjustVoronoi(g: Graph, am: AdjustData): number {
 
 /**
  * Use `am` to decide if and how to remove node overlaps. normalize and
- * simpleScale (only active with the `normalize`/`scale` attributes) are not
- * ported (see sc-adjust module doc).
+ * simpleScale run first, whatever the mode (the `normalize` / `scale`
+ * attributes); returns non-zero if nodes moved.
  * @see lib/neatogen/adjust.c:removeOverlapWith
  */
 export function removeOverlapWith(g: Graph, am: AdjustData): number {
   if (g.nodes.size < 2) return 0;
-  if (am.mode === AM_NONE) return 0;
-  if (am.mode > AM_SCALE) return adjustLate(g, am);
-  return am.mode === AM_SCALE ? sAdjustGraph(g) : adjustVoronoi(g, am);
+  const nret = normalizeG(g) + simpleScale(g);
+  if (am.mode === AM_NONE) return nret;
+  if (am.mode > AM_SCALE) return nret + adjustLate(g, am);
+  return nret + (am.mode === AM_SCALE ? sAdjustGraph(g) : adjustVoronoi(g, am));
 }
 
 /**
@@ -224,6 +241,14 @@ export function removeOverlapWith(g: Graph, am: AdjustData): number {
  * @see lib/neatogen/adjust.c:adjustNodes / removeOverlapAs
  */
 export function adjustNodesFull(g: Graph): number {
-  const flag = g.attrs.get('overlap') ?? g.root.attrs.get('overlap');
-  return removeOverlapWith(g, getAdjustMode(flag));
+  if (g.nodes.size < 2) return 0; // removeOverlapAs returns before getAdjustMode
+  return removeOverlapWith(g, graphAdjustMode(g));
+}
+
+/**
+ * The graph's `overlap` value resolved once (agget falls back to the root).
+ * @see lib/neatogen/adjust.c:graphAdjustMode
+ */
+export function graphAdjustMode(g: Graph): AdjustData {
+  return getAdjustMode(g.attrs.get('overlap') ?? g.root.attrs.get('overlap'));
 }

package/src/layout/neato/index.ts

@@ -25,7 +25,7 @@ import {
   MODEL_MDS,
 } from './init.js';
 import { neatoMode } from './start.js';
-import { adjustNodesFull } from './fdp-adjust.js';
+import { removeOverlapWith, graphAdjustMode, type AdjustData } from './fdp-adjust.js';
 import { splineEdgesShifted, EDGETYPE_LINE } from './splines.js';
 import { setEdgeTypeFromAttr } from '../dot/index.js';
 import {
@@ -100,15 +100,14 @@ export function parseModel(g: Graph): number {
 // ---------------------------------------------------------------------------
 
 /**
- * Remove node overlaps per the `overlap` attribute: C's removeOverlapWith
- * dispatch (prism, scale family, oscale, ortho*, portho*, vpsc, voronoi) for
- * every mode, as neato_layout's adjustNodes call does.
+ * Remove node overlaps with the mode neato_layout resolved once
+ * (graphAdjustMode): C's removeOverlapWith dispatch for every mode.
  *
- * @see lib/neatogen/neatoinit.c:neato_layout (adjustNodes call)
+ * @see lib/neatogen/neatoinit.c:neato_layout (removeOverlapWith calls)
  * @see lib/neatogen/adjust.c:removeOverlapWith
  */
-export function maybeRemoveOverlap(g: Graph): void {
-  adjustNodesFull(g);
+export function maybeRemoveOverlap(g: Graph, am: AdjustData): void {
+  removeOverlapWith(g, am);
 }
 
 // ---------------------------------------------------------------------------
@@ -164,6 +163,8 @@ export function neatoLayout(g: Graph): void {
   }
 
   const mode = parseMode(g);
+  // C resolves the overlap mode once, before any component. @see neatoinit.c:1369
+  const am = graphAdjustMode(g);
   const model = parseModel(g);
 
   // C uses pccomps (pin-aware): components with a pinned node are collected
@@ -172,10 +173,10 @@ export function neatoLayout(g: Graph): void {
     ? pccomps(g, '_neato_cc')
     : { graphs: [g], pinned: false };
   if (comps.length > 1) {
-    layoutComponents(g, comps, mode, model, pinned);
+    layoutComponents(g, comps, { mode, model, am }, pinned);
   } else {
     solveModel(g, mode, model); // srand48 happens inside (C checkStart)
-    maybeRemoveOverlap(g);
+    maybeRemoveOverlap(g, am);
     // C: spline_edges shifts pos to the origin, syncs coord, routes.
     splineEdgesShifted(g);
   }
@@ -236,13 +237,13 @@ function addClusters(g: Graph): void {
  * @see lib/neatogen/neatoinit.c:neato_layout (Pack >= 0 branch)
  */
 function layoutComponents(
-  g: Graph, comps: Graph[], mode: number, model: number, pinned: boolean,
+  g: Graph, comps: Graph[], solve: { mode: number; model: number; am: AdjustData }, pinned: boolean,
 ): void {
   for (const gc of comps) {
     // @see lib/neatogen/neatoinit.c:1398 (setEdgeType FUNCTION, per component)
     setEdgeTypeFromAttr(gc, EDGETYPE_LINE);
-    solveModel(gc, mode, model);
-    maybeRemoveOverlap(gc);
+    solveModel(gc, solve.mode, solve.model);
+    maybeRemoveOverlap(gc, solve.am);
     splineEdgesShifted(gc);
   }
   // C sets fixed[0]=true when a pinned node is present: pccomps merges every

package/src/layout/neato/sc-adjust.ts

@@ -11,9 +11,8 @@
  * Using Constrained Optimization", Constraints 8(2):143-172, 2003 (per the
  * C source comment).
  *
- * Other overlap modes (voronoi, prism, vpsc, ortho*) remain unported; with
- * the attr unset C's getAdjustMode resolves to AM_NONE and the pass is a
- * no-op (normalize/simpleScale only fire on rare attrs, also unported).
+ * Dispatched from removeOverlapWith (fdp-adjust.ts) for overlap=scale,
+ * scalexy and compress.
  *
  * @see lib/neatogen/constraint.c:scAdjust
  * @see lib/neatogen/adjust.c:removeOverlapWith / getAdjustMode
@@ -191,16 +190,3 @@ export function scAdjust(g: Graph, equal: number): number {
   return 1;
 }
 
-/**
- * The adjustNodes overlap-mode subset reaching scAdjust; other modes are
- * no-ops (see module doc).
- * @see lib/neatogen/adjust.c:999 adjustNodes, :776 adjustMode table
- */
-export function adjustNodesScale(g: Graph): number {
-  // agget falls back to the root graph's attrs for component subgraphs.
-  const flag = (g.attrs.get('overlap') ?? g.root.attrs.get('overlap') ?? '').toLowerCase();
-  if (flag === 'scale') return scAdjust(g, 1);       // AM_NSCALE
-  if (flag === 'scalexy') return scAdjust(g, 0);     // AM_SCALEXY
-  if (flag === 'compress') return scAdjust(g, -1);   // AM_COMPRESS
-  return 0; // unset -> AM_NONE; other modes unported
-}

package/src/layout/neato/simple-scale.ts

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * The `scale` graph attribute: multiply every node position by (sx, sy)
+ * before overlap removal. removeOverlapWith runs it right after normalize,
+ * whatever the overlap mode.
+ *
+ * @see lib/neatogen/adjust.c:simpleScale
+ */
+
+import type { Graph } from '../../model/graph.js';
+import { aggetGraph } from '../fdp/fdp-model.js';
+
+/** @see lib/neatogen/adjust.c:ISZERO */
+const ISZERO = (d: number): boolean => Math.abs(d) < 0.000000001;
+
+/** One C `%lf` conversion: optional leading whitespace, then a strtod number. */
+const LF = /^\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)/;
+
+/**
+ * C `sscanf(p, "%lf,%lf", &x, &y)`: the values converted, in order (0, 1 or
+ * 2 of them). An empty string returns none — C's EOF (-1) there reads an
+ * uninitialised pointf, undefined behaviour the port defines as a no-op.
+ */
+function scanPair(p: string): number[] {
+  const m1 = LF.exec(p);
+  if (m1 === null) return [];
+  const rest = p.slice(m1[0].length);
+  if (!rest.startsWith(',')) return [parseFloat(m1[1]!)];
+  const m2 = LF.exec(rest.slice(1));
+  return m2 === null ? [parseFloat(m1[1]!)] : [parseFloat(m1[1]!), parseFloat(m2[1]!)];
+}
+
+/**
+ * Scale node positions by the `scale` attribute ("s" or "sx,sy"). Returns 1
+ * if nodes moved, else 0 (unset, unparsable, a zero factor, or 1,1).
+ * @see lib/neatogen/adjust.c:simpleScale
+ */
+export function simpleScale(g: Graph): number {
+  const p = aggetGraph(g, 'scale');
+  if (p === undefined) return 0;
+  const sc = scanPair(p);
+  if (sc.length === 0) return 0;
+  const x = sc[0]!;
+  if (ISZERO(x)) return 0;
+  const y = sc.length === 1 ? x : sc[1]!;
+  if (ISZERO(y)) return 0;
+  if (y === 1 && x === 1) return 0;
+  for (const n of g.nodes.values()) {
+    n.info.pos![0] *= x;
+    n.info.pos![1] *= y;
+  }
+  return 1;
+}

package/src/layout/sfdp/index.ts

@@ -31,7 +31,7 @@ import { CL_OFFSET } from '../twopi/pipeline.js';
 import { placeGraphLabel } from '../dot/position-bbox.js';
 import { gvPostprocess } from '../../common/postproc.js';
 import { aggetGraph } from '../fdp/fdp-model.js';
-import { overlapPrismTries, adjustNodesFull } from '../neato/fdp-adjust.js';
+import { overlapPrismTries, adjustNodesFull, warnUnrecognizedOverlap } from '../neato/fdp-adjust.js';
 import { lateDouble } from '../../common/nodeinit.js';
 import {
   type SpringElectricalControl,
@@ -98,6 +98,7 @@ function resolveControl(g: Graph): {
   // graphAdjustMode(g, &am, "prism0"): agget NULL (unset) → "prism0" default.
   const overlap = aggetGraph(g, 'overlap');
   const flag = overlap === undefined ? 'prism0' : overlap;
+  warnUnrecognizedOverlap(flag); // graphAdjustMode → getAdjustMode, once per layout
   const ntry = overlapPrismTries(flag);
   if (ntry !== null) {
     // AM_PRISM && doAdjust: overlap removal happens inside sfdp.

package/src/render/public.ts

@@ -60,13 +60,14 @@ export interface RenderOptions {
 }
 
 // ---------------------------------------------------------------------------
-// Private helpers (mirrors index.ts)
+// Argument validation (shared with the async entry points)
 // ---------------------------------------------------------------------------
 
-
-
-/** Reject a bad `g` / `format` / `opts` before any work starts. */
-function checkRenderArgs(g: unknown, format: unknown, opts: unknown): void {
+/**
+ * Reject a bad `g` / `format` / `opts` before any work starts.
+ * @internal shared with src/async/render-async.ts; not part of the public API.
+ */
+export function checkRenderArgs(g: unknown, format: unknown, opts: unknown): void {
   if (typeof g !== 'object' || g === null) {
     throw invalidArgType('g', 'object', g);
   }

package/dist/layout/neato/overlap.d.ts

@@ -1,85 +0,0 @@
-/**
- * VPSC-based overlap removal for the neato layout engine.
- *
- * Two independent VPSC passes (X then Y) ensure that no two node bounding
- * boxes intersect after the call returns. Each pass builds its own Variables,
- * Rectangles, and Constraints; none are shared between passes.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust
- * @see lib/vpsc/csolve_VPSC.h
- */
-import type { Node } from '../../model/node.js';
-import { type Variable, type Constraint, VPSC, Rectangle } from '../../vpsc/index.js';
-/**
- * Builds one Rectangle per node centred on pos[], expanding each half-size
- * by sep/2 so the VPSC gap `(w_i+w_j)/2` incorporates the padding.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust
- */
-export declare function buildRectangles(nodes: Node[], sep: {
-    x: number;
-    y: number;
-}): Rectangle[];
-/**
- * Allocates one Variable per node for a single VPSC axis pass.
- *
- * @see lib/vpsc/csolve_VPSC.h:newVariable
- */
-export declare function allocateVariables(nodes: Node[], axis: 0 | 1): Variable[];
-/**
- * Writes solved positions back into node.info.pos[axis].
- *
- * @see lib/neatogen/adjust.c:vpscAdjust (position write-back loop)
- */
-export declare function writePositions(nodes: Node[], vars: Variable[], axis: 0 | 1): void;
-/**
- * Tears down a VPSC pass in mandatory order (AD-4):
- * deleteVPSC → deleteConstraints → deleteVariable per variable.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust teardown sequence
- */
-export declare function teardownPass(vpsc: VPSC, constraints: Constraint[], vars: Variable[]): void;
-/**
- * Runs one complete VPSC axis pass: solve constraints then write positions.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust
- */
-export declare function runAxisPass(nodes: Node[], sep: {
-    x: number;
-    y: number;
-}, constraints: Constraint[], vars: Variable[], axis: 0 | 1): void;
-/**
- * One full VPSC pass on the X axis.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust (X pass section)
- */
-export declare function runXPass(nodes: Node[], sep: {
-    x: number;
-    y: number;
-}): void;
-/**
- * One full VPSC pass on the Y axis.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust (Y pass section)
- */
-export declare function runYPass(nodes: Node[], sep: {
-    x: number;
-    y: number;
-}): void;
-/**
- * Removes overlaps between nodes using two independent VPSC passes (X then Y).
- *
- * After this call no two node bounding boxes intersect (with sep padding).
- * Positions are written into node.info.pos[0] (X) and node.info.pos[1] (Y).
- *
- * @param nodes - Nodes with info.pos, info.width, info.height set.
- * @param sep   - Minimum padding added beyond each node's half-size per axis.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust
- * @see lib/vpsc/csolve_VPSC.h
- */
-export declare function removeOverlap(nodes: Node[], sep: {
-    x: number;
-    y: number;
-}): void;
-//# sourceMappingURL=overlap.d.ts.map

package/dist/layout/neato/overlap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"overlap.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/overlap.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAQL,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,IAAI,EACJ,SAAS,EACV,MAAM,qBAAqB,CAAC;AAE7B;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,SAAS,EAAE,CAQb;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,QAAQ,EAAE,CAExE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,IAAI,EAAE,EACb,IAAI,EAAE,QAAQ,EAAE,EAChB,IAAI,EAAE,CAAC,GAAG,CAAC,GACV,IAAI,CAON;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,UAAU,EAAE,EACzB,IAAI,EAAE,QAAQ,EAAE,GACf,IAAI,CAIN;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAC7B,WAAW,EAAE,UAAU,EAAE,EACzB,IAAI,EAAE,QAAQ,EAAE,EAChB,IAAI,EAAE,CAAC,GAAG,CAAC,GACV,IAAI,CAKN;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,IAAI,CAKN;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,IAAI,CAKN;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,IAAI,CAIN"}

package/src/layout/neato/overlap.ts

@@ -1,158 +0,0 @@
-// SPDX-License-Identifier: EPL-2.0
-
-/**
- * VPSC-based overlap removal for the neato layout engine.
- *
- * Two independent VPSC passes (X then Y) ensure that no two node bounding
- * boxes intersect after the call returns. Each pass builds its own Variables,
- * Rectangles, and Constraints; none are shared between passes.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust
- * @see lib/vpsc/csolve_VPSC.h
- */
-
-import type { Node } from '../../model/node.js';
-import {
-  newVariable,
-  deleteVariable,
-  deleteVPSC,
-  deleteConstraints,
-  solveVPSC,
-  genXConstraints,
-  genYConstraints,
-  type Variable,
-  type Constraint,
-  VPSC,
-  Rectangle,
-} from '../../vpsc/index.js';
-
-/**
- * Builds one Rectangle per node centred on pos[], expanding each half-size
- * by sep/2 so the VPSC gap `(w_i+w_j)/2` incorporates the padding.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust
- */
-export function buildRectangles(
-  nodes: Node[],
-  sep: { x: number; y: number },
-): Rectangle[] {
-  return nodes.map((n) => {
-    const x = n.info.pos?.[0] ?? 0;
-    const y = n.info.pos?.[1] ?? 0;
-    const hw = n.info.width / 2 + sep.x / 2;
-    const hh = n.info.height / 2 + sep.y / 2;
-    return new Rectangle(x - hw, x + hw, y - hh, y + hh);
-  });
-}
-
-/**
- * Allocates one Variable per node for a single VPSC axis pass.
- *
- * @see lib/vpsc/csolve_VPSC.h:newVariable
- */
-export function allocateVariables(nodes: Node[], axis: 0 | 1): Variable[] {
-  return nodes.map((n, i) => newVariable(i, n.info.pos?.[axis] ?? 0, 1));
-}
-
-/**
- * Writes solved positions back into node.info.pos[axis].
- *
- * @see lib/neatogen/adjust.c:vpscAdjust (position write-back loop)
- */
-export function writePositions(
-  nodes: Node[],
-  vars: Variable[],
-  axis: 0 | 1,
-): void {
-  for (let i = 0; i < nodes.length; i++) {
-    const n = nodes[i]!;
-    if (!n.info.pos) n.info.pos = [0, 0];
-    n.info.pos[axis] =
-      vars[i]!.block !== null ? vars[i]!.position() : vars[i]!.desiredPosition;
-  }
-}
-
-/**
- * Tears down a VPSC pass in mandatory order (AD-4):
- * deleteVPSC → deleteConstraints → deleteVariable per variable.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust teardown sequence
- */
-export function teardownPass(
-  vpsc: VPSC,
-  constraints: Constraint[],
-  vars: Variable[],
-): void {
-  deleteVPSC(vpsc);
-  deleteConstraints(constraints);
-  for (const v of vars) deleteVariable(v);
-}
-
-/**
- * Runs one complete VPSC axis pass: solve constraints then write positions.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust
- */
-export function runAxisPass(
-  nodes: Node[],
-  sep: { x: number; y: number },
-  constraints: Constraint[],
-  vars: Variable[],
-  axis: 0 | 1,
-): void {
-  const vpsc = new VPSC(vars, constraints);
-  solveVPSC(vpsc);
-  writePositions(nodes, vars, axis);
-  teardownPass(vpsc, constraints, vars);
-}
-
-/**
- * One full VPSC pass on the X axis.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust (X pass section)
- */
-export function runXPass(
-  nodes: Node[],
-  sep: { x: number; y: number },
-): void {
-  const rects = buildRectangles(nodes, sep);
-  const vars = allocateVariables(nodes, 0);
-  const cs = genXConstraints(rects, vars, true);
-  runAxisPass(nodes, sep, cs, vars, 0);
-}
-
-/**
- * One full VPSC pass on the Y axis.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust (Y pass section)
- */
-export function runYPass(
-  nodes: Node[],
-  sep: { x: number; y: number },
-): void {
-  const rects = buildRectangles(nodes, sep);
-  const vars = allocateVariables(nodes, 1);
-  const cs = genYConstraints(rects, vars);
-  runAxisPass(nodes, sep, cs, vars, 1);
-}
-
-/**
- * Removes overlaps between nodes using two independent VPSC passes (X then Y).
- *
- * After this call no two node bounding boxes intersect (with sep padding).
- * Positions are written into node.info.pos[0] (X) and node.info.pos[1] (Y).
- *
- * @param nodes - Nodes with info.pos, info.width, info.height set.
- * @param sep   - Minimum padding added beyond each node's half-size per axis.
- *
- * @see lib/neatogen/adjust.c:vpscAdjust
- * @see lib/vpsc/csolve_VPSC.h
- */
-export function removeOverlap(
-  nodes: Node[],
-  sep: { x: number; y: number },
-): void {
-  if (nodes.length < 2) return;
-  runXPass(nodes, sep);
-  runYPass(nodes, sep);
-}