@knowvah/dot-engine 1.2.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowvah/dot-engine",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "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/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-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,