@knowvah/dot-engine 1.2.1 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowvah/dot-engine",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Faithful TypeScript port of Graphviz (dot, neato, fdp, sfdp, circo, twopi, osage, patchwork) — no C: no native binary, no WASM. Oracle-verified against the C implementation, runs in the browser.",
   "keywords": [
     "graphviz",

package/src/common/arrows-shapes-poly.ts

@@ -9,6 +9,7 @@
  */
 
 import type { Point } from '../model/geom.js';
+import { ccwrotatepf, cwrotatepf } from '../model/geom.js';
 import type { GenResult } from './arrows-shapes-util.js';
 import {
   vsub, vadd, miterShape, negUnit, backwardDelta, axialProjection,
@@ -217,7 +218,25 @@ function curveControlPoints(p: Point, v: Point, w: Point, flag: number): Point[]
 }
 
 /** @see lib/common/arrows.c:arrow_type_curve */
-export function genCurve(p0: Point, u: Point, _arrowsize: number, penwidth: number, flag: number): GenResult {
+export function genCurve(
+  p0: Point, u: Point, _arrowsize: number, penwidth: number, flag: number,
+  rankdir = 0,
+): GenResult {
+  // C generates arrowheads at RENDER time, in the final (post-rankdir) frame;
+  // the port generates during routing and postproc rotates the stored ops.
+  // That round-trip is exact for every other generator, but this formula is
+  // not rotation-equivariant (0.95 shortens the x arm only; the y arm comes
+  // from AF0/AF3 verbatim), so run it in the final frame and rotate back.
+  // The rankdir maps are pure sign/swaps — rankdir 0 (TB) is untouched.
+  if (rankdir !== 0) {
+    const rot = rankdir * 90;
+    const fin = genCurve(ccwrotatepf(p0, rot), ccwrotatepf(u, rot), _arrowsize, penwidth, flag);
+    return {
+      ops: fin.ops.map((op) =>
+        'points' in op ? { ...op, points: op.points.map((pt) => cwrotatepf(pt, rot)) } : op),
+      q: cwrotatepf(fin.q, rot),
+    };
+  }
   const arrowwidth = penwidth > 4 ? (0.5 * penwidth) / 4 : 0.5;
   const noShift = (flag & ARR_MOD_INV) || (u.x === 0 && u.y === 0);
   const p = noShift ? p0 : vsub(p0, backwardDelta(u, penwidth));

package/src/common/arrows-shapes.ts

@@ -319,6 +319,7 @@ export function arrowLength(comps: ResolvedArrow[], arrowsize: number, penwidth:
  */
 export function dispatchSimple(
   r: ResolvedArrow, tip: Point, dir: Point, arrowsize: number, penwidth: number,
+  rankdir = 0,
 ): GenResult {
   const flag = arrowFlag(r);
   const u = componentU(dir, r.lenfact, arrowsize);
@@ -328,7 +329,9 @@ export function dispatchSimple(
     case ARR_TYPE_BOX: return genBox(tip, u, arrowsize, penwidth, flag);
     case ARR_TYPE_DIAMOND: return genDiamond(tip, u, arrowsize, penwidth, flag);
     case ARR_TYPE_DOT: return genDot(tip, u, arrowsize, penwidth, flag);
-    case ARR_TYPE_CURVE: return genCurve(tip, u, arrowsize, penwidth, flag);
+    // curve is the one generator that is not rotation-equivariant; it needs
+    // the rankdir to reproduce C's render-time (final-frame) generation.
+    case ARR_TYPE_CURVE: return genCurve(tip, u, arrowsize, penwidth, flag, rankdir);
     case ARR_TYPE_GAP: return genGap(tip, u, arrowsize, penwidth, flag);
     case ARR_TYPE_NORM:
     default:
@@ -345,6 +348,7 @@ export function dispatchSimple(
  */
 export function arrowDrawOps(
   comps: ResolvedArrow[], tip: Point, dir: Point, arrowsize: number, penwidth: number,
+  rankdir = 0,
 ): ArrowDrawOp[] {
   const ops: ArrowDrawOp[] = [];
   let p = tip;
@@ -352,7 +356,7 @@ export function arrowDrawOps(
   for (let i = 0; i < n; i++) {
     const r = comps[i];
     if ((r.type & ARR_TYPE_MASK) === ARR_TYPE_NONE) break;
-    const res = dispatchSimple(r, p, dir, arrowsize, penwidth);
+    const res = dispatchSimple(r, p, dir, arrowsize, penwidth, rankdir);
     ops.push(...res.ops);
     p = res.q;
   }

package/src/common/nodeinit.ts

@@ -201,6 +201,7 @@ function pointSizeResult(
   return {
     ...gvNodesize(sz, sz, false),
     outlineW: szOutline, outlineH: szOutline, baseW: sz0, baseH: sz0,
+    fixedshape: false, // C point_init never sets option.fixedshape
   };
 }
 
@@ -262,17 +263,20 @@ function initNodeFromLabel(n: Node, g: Graph, measurer: TextMeasurer): boolean {
   // C poly_init installs the ATTR-RESOLVED polygon into ND_shape_info
   // (sides/orientation/skew/distortion/peripheries/regular); edge
   // clipping and rendering read it.
-  assignShapeInfo(n, effectivePolygon(poly, params));
+  assignShapeInfo(n, effectivePolygon(poly, params, sz.fixedshape));
   return true;
 }
 
 /** The attr-resolved polygon poly_init stores. @see shapes.c:poly_init (poly->... assignments) */
-function effectivePolygon(poly: PolygonT, p: PolySizeParams): PolygonT {
+function effectivePolygon(poly: PolygonT, p: PolySizeParams, fixedshape: boolean): PolygonT {
   let sides = p.sides;
   // ellipses with distortion/skew become 120-gons
   if (sides <= 2 && (p.distortion !== 0 || p.skew !== 0)) sides = 120;
   return {
     ...poly,
+    // C: poly->option.fixedshape = true inside the fixedsize="shape" branch;
+    // poly-inside and computeVertices key the shape-box/width split on it.
+    option: { ...poly.option, fixedshape },
     regular: p.regular,
     peripheries: p.peripheries,
     sides,

package/src/common/poly-inside.ts

@@ -32,7 +32,7 @@ export function sameSide(p0: Point, p1: Point, L0: Point, L1: Point): boolean {
 }
 
 /** Vertex-extent box of a fixedshape polygon. @see lib/common/shapes.c:polyBB */
-function fixedShapeSize(poly: PolygonT): { w: number; h: number } {
+export function fixedShapeSize(poly: PolygonT): { w: number; h: number } {
   let xmax = 0;
   let ymax = 0;
   for (const v of poly.vertices ?? []) {
@@ -50,13 +50,10 @@ interface InsideScale {
   boxURy: number;
 }
 
-/** Node size + outline extents (points) for the inside scale. */
-function insideDims(n: Node, poly: PolygonT, xsize: number, ysize: number):
+/** Node size + outline extents (points) for the inside scale (non-fixedshape;
+ * the fixedshape branch short-circuits in insideScale). */
+function insideDims(n: Node, xsize: number, ysize: number):
   { w: number; h: number; ow: number; oh: number } {
-  if (poly.option.fixedshape) {
-    const { w, h } = fixedShapeSize(poly);
-    return { w, h, ow: w, oh: h };
-  }
   const w = 72 * (n.info.width || xsize / 72);
   const h = 72 * (n.info.height || ysize / 72);
   // Nodes that skipped poly_init (no measurer) have no outline dims.
@@ -67,10 +64,26 @@ function insideDims(n: Node, poly: PolygonT, xsize: number, ysize: number):
 function insideScale(n: Node, poly: PolygonT): InsideScale {
   // C swaps the node extents for flipped (LR/RL) layouts. @see poly_inside (GD_flip)
   const flip = n.root.info.flip === true;
+  // C's fixedshape branch derives xsize/ysize from the polyBB shape box
+  // itself (NOT ND_lw/rw/ht, which are label-grown there), so the scale
+  // collapses to 1 (swapped under flip) and the boundary is the pure vertex
+  // extent with no penwidth outline growth.
+  // @see shapes.c:poly_inside (option.fixedshape branch)
+  if (poly.option.fixedshape) {
+    const { w, h } = fixedShapeSize(poly);
+    const xsize = flip ? h : w;
+    const ysize = flip ? w : h;
+    return {
+      scalex: xsize !== 0 ? w / xsize : w,
+      scaley: ysize !== 0 ? h / ysize : h,
+      boxURx: w / 2,
+      boxURy: h / 2,
+    };
+  }
   const lwrw = n.info.lw + n.info.rw;
   const xsize = flip ? n.info.ht : lwrw;
   const ysize = flip ? lwrw : n.info.ht;
-  const { w, h, ow, oh } = insideDims(n, poly, xsize, ysize);
+  const { w, h, ow, oh } = insideDims(n, xsize, ysize);
   return {
     scalex: xsize !== 0 ? w / xsize : w,
     scaley: ysize !== 0 ? h / ysize : h,

package/src/common/poly-sizing.ts

@@ -110,6 +110,14 @@ export interface PolySizeResult extends NodeSize {
    */
   baseW: number;
   baseH: number;
+  /**
+   * fixedsize="shape": the drawn shape stays at the attr box while
+   * width/height grow to max(label, shape). Installed on the polygon
+   * descriptor as `option.fixedshape`; vertex generation and insideness
+   * must read the base box, not the label-grown width.
+   * @see lib/common/shapes.c:poly_init (poly->option.fixedshape)
+   */
+  fixedshape: boolean;
   /**
    * Justification borders — the space available for the label within the node
    * box. `emit_label` reads this (not `dimen`) for `labelloc` top/bottom and
@@ -628,6 +636,7 @@ function assembleResult(
       outlineW: Math.max(dimen.x, grown.outline.x),
       outlineH: Math.max(dimen.y, grown.outline.y),
       baseW: grown.base.x, baseH: grown.base.y,
+      fixedshape,
     };
   }
   return {
@@ -635,5 +644,6 @@ function assembleResult(
     outlineW: grown.outline.x,
     outlineH: grown.outline.y,
     baseW: grown.base.x, baseH: grown.base.y,
+    fixedshape,
   };
 }

package/src/common/poly-vertices.ts

@@ -100,11 +100,32 @@ export function generalPolyVertices(poly: PolygonT, w: number, h: number): Point
  * which grows bb to the outermost ring after placing rings outward.
  * @see lib/common/shapes.c:poly_init (ellipse peripheries, :2173-2184)
  */
-function ellipseRings(w: number, h: number, peripheries: number): Point[] {
+function ellipseRings(
+  w: number,
+  h: number,
+  peripheries: number,
+  base?: { w: number; h: number },
+): Point[] {
+  if (base === undefined) {
+    const out: Point[] = [];
+    for (let j = 0; j < peripheries; j++) {
+      const inset = (peripheries - 1 - j) * GAP;
+      out.push(...ellipseVertices(w - 2 * inset, h - 2 * inset));
+    }
+    return out;
+  }
+  // C's forward order: the base ring at the shape box, each further ring
+  // stepping the half-extent OUTWARD by GAP. Needed under fixedshape, where
+  // the stored width is label-grown and the inset-from-width form above
+  // cannot recover the shape box. @see lib/common/shapes.c:poly_init
+  // (sides < 3: vertices[0/1] = ±bb/2, then P.x += GAP per periphery)
   const out: Point[] = [];
+  let px = base.w / 2;
+  let py = base.h / 2;
   for (let j = 0; j < peripheries; j++) {
-    const inset = (peripheries - 1 - j) * GAP;
-    out.push(...ellipseVertices(w - 2 * inset, h - 2 * inset));
+    out.push({ x: -px, y: -py }, { x: px, y: py });
+    px += GAP;
+    py += GAP;
   }
   return out;
 }
@@ -221,13 +242,25 @@ export function computeVertices(
   base?: { w: number; h: number },
 ): Point[] {
   const sides = poly.sides;
+  // C builds vertices from the constrained shape box (bb) BEFORE the
+  // fixedshape branch sets ND_width/ND_height to max(label, bb)
+  // (shapes.c:poly_init tail), so under fixedsize="shape" the stored width
+  // is label-grown while the drawn shape stays at the attr box. Substitute
+  // the stored base box (= that bb) as the vertex source; every other case
+  // has width == shape box and is untouched.
+  if (poly.option.fixedshape && base !== undefined) {
+    w = base.w;
+    h = base.h;
+  }
   // Cylinder is a 19-point bezier control polygon, not a regular 19-gon.
   if (poly.option.shape === CYLINDER) return cylinderVertices(w, h);
   // C generates one ring even for peripheries=0 (outp >= 1); the draw
   // loop is what skips it. @see lib/common/shapes.c:poly_init (outp)
   const peripheries = Math.max(poly.peripheries, 1);
   if (poly.option.shape === STAR) return starRings({ w, h, base }, peripheries);
-  if (sides <= 2) return ellipseRings(w, h, peripheries);
+  if (sides <= 2) {
+    return ellipseRings(w, h, peripheries, poly.option.fixedshape ? base : undefined);
+  }
   // C's isBox test: right angles only (diamond = orientation 45).
   if (sides === 4 && Math.abs(poly.orientation % 90) < 0.5
       && poly.distortion === 0 && poly.skew === 0) {

package/src/layout/dot/edge-route-arrow.ts

@@ -56,7 +56,11 @@ export function arrowheadPolygon(arrowTip: Point, arrowDir: Point, penwidth = 1.
 // ---------------------------------------------------------------------------
 
 /** Minimal edge shape exposing the arrow-related attributes. */
-interface ArrowAttrEdge { attrs: Map<string, string> }
+interface ArrowAttrEdge {
+  attrs: Map<string, string>;
+  /** Present on real edges; the curve generator needs the rankdir frame. */
+  tail?: { root?: { info?: { rankdir?: number } } };
+}
 
 /** The arrowhead/arrowtail name for an edge end (default "normal"). */
 export function edgeArrowName(e: ArrowAttrEdge, end: 'head' | 'tail'): string {
@@ -81,7 +85,8 @@ export function arrowDrawOpsForEnd(
   e: ArrowAttrEdge, end: 'head' | 'tail', tip: Point, dir: Point, penwidth: number,
 ): ArrowDrawOp[] {
   const comps = parseArrow(edgeArrowName(e, end)).map(resolveArrowType);
+  const rankdir = (e.tail?.root?.info?.rankdir ?? 0) & 0x3;
   // Pass the RAW direction (not normalized): componentU reproduces arrow_gen's
   // EPSILON normalization, which is relative to the raw shaft magnitude.
-  return arrowDrawOps(comps, tip, dir, edgeArrowsize(e), penwidth);
+  return arrowDrawOps(comps, tip, dir, edgeArrowsize(e), penwidth, rankdir);
 }

package/src/layout/dot/edge-route-helpers.ts

@@ -15,6 +15,8 @@ import type { Graph } from '../../model/graph.js';
 import type { Node } from '../../model/node.js';
 import type { Edge as GraphEdge } from '../../model/edge.js';
 import { nodeAttr } from '../../common/poly-init.js';
+import { fixedShapeSize } from '../../common/poly-inside.js';
+import type { PolygonT } from '../../common/types.js';
 import type { Point, Bezier, Spline } from '../../model/geom.js';
 import { routeSpline } from '../../pathplan/route.js';
 import type { Edge as BarrierEdge } from '../../pathplan/types.js';
@@ -69,6 +71,23 @@ export function nodeBoxOf(n: Node, g: Graph): NodeBox {
     const rb = recordClipBox(n);
     if (rb) return { center: n.info.coord, ...rb, isEllipse: false, penwidth };
   }
+  // C poly_inside sizes the boundary from polyBB (the vertex extent) under
+  // fixedshape — ND_lw/rw/ht are label-grown there and must not clip the
+  // edge, and the boundary carries NO penwidth outline growth.
+  // @see lib/common/shapes.c:poly_inside (option.fixedshape branch)
+  const si = n.info.shape_info as PolygonT | undefined;
+  if (si?.option?.fixedshape === true && si.vertices) {
+    const ext = fixedShapeSize(si);
+    const flip = g.root.info.flip === true;
+    const w = flip ? ext.h : ext.w;
+    const h = flip ? ext.w : ext.h;
+    return {
+      center: n.info.coord,
+      lw: w / 2, rw: w / 2, ht: h,
+      isEllipse: ELLIPSE_SHAPES.has(shapeName),
+      penwidth: 0,
+    };
+  }
   return {
     center: n.info.coord,
     lw: n.info.lw > 0 ? n.info.lw : 27,

package/src/model/geom.ts

@@ -144,6 +144,20 @@ export function ccwrotatepf(p: Point, ccwrot: number): Point {
   }
 }
 
+/**
+ * Clockwise counterpart — the exact inverse of {@link ccwrotatepf} per case.
+ * @see lib/common/geom.c:cwrotatepf
+ */
+export function cwrotatepf(p: Point, cwrot: number): Point {
+  switch (cwrot) {
+    case 0:   return p;
+    case 90:  return { x: p.y, y: -p.x };
+    case 180: return { x: p.x, y: -p.y };
+    case 270: return { x: p.y, y: p.x };
+    default:  return p;
+  }
+}
+
 /**
  * Returns true if box `b0` completely contains box `b1`.
  *