@knowvah/dot-engine 2.6.11 → 2.6.12

package/src/render/color-resolve.ts

@@ -18,10 +18,17 @@
 
 import {
   colorxlate,
+  ColorxlateResult,
   getColorScheme,
   setColorScheme,
   type GVColor,
 } from '../common/color.js';
+import type { Edge } from '../model/edge.js';
+import { registerRenderState } from '../common/render-state.js';
+import { agerrorf, agwarningf } from '../common/agerr.js';
+import { parseSegs } from '../common/multicolor.js';
+import { findStopColor, styleTokens } from '../common/style-resolve.js';
+import { emitOnce } from '../common/emit-once.js';
 
 /**
  * The SVG renderer's known color names, ported verbatim from
@@ -78,19 +85,70 @@ const SVG_KNOWN_COLORS: readonly string[] = [
 /** Lower-cased lookup set for the SVG known colors (case-insensitive, as C). */
 export const KNOWN_COLORS: ReadonlySet<string> = new Set(SVG_KNOWN_COLORS);
 
+/**
+ * Whether the active renderer has the SVG known-colors list (svg). Only then
+ * does a known name skip colorxlate; every other renderer runs colorxlate on
+ * every name, which under a colorscheme can reject a name the list accepts.
+ * Per render (AD-4); a render that sets nothing is svg.
+ * @see lib/gvc/gvrender.c:195-199 gvrender_resolve_color (knowncolors)
+ */
+const rendererColors = { hasKnownList: true };
+registerRenderState(() => {
+  rendererColors.hasKnownList = true;
+});
+
+/** Select the active renderer's known-colors behaviour; svg is the only list. */
+export function setRendererKnownColors(hasList: boolean): void {
+  rendererColors.hasKnownList = hasList;
+}
+
+/**
+ * The first color of a `c1:c2` list: gvrender_set_pencolor cuts the name at the
+ * first ':' before resolving it.
+ * @see lib/gvc/gvrender.c:gvrender_set_pencolor
+ */
+export function firstColor(name: string): string {
+  const i = name.indexOf(':');
+  return i < 0 ? name : name.slice(0, i);
+}
+
 /**
  * Resolve a raw color string to a canonical {@link GVColor} for rendering.
  *
+ * `report` false resolves without the unknown-color warning, for a caller that
+ * resolves earlier than C does (the warning belongs to C's own call order).
+ *
  * @see lib/gvc/gvrender.c:188-213 gvrender_resolve_color
  */
-export function resolveRenderColor(raw: string): GVColor {
+export function resolveRenderColor(raw: string, report = true): GVColor {
   if (raw === '' || raw === 'none') return { type: 'none' };
   // C keeps a known name verbatim (case preserved); only the compare is
   // case-insensitive (bsearch over a lowercase table).
-  if (KNOWN_COLORS.has(raw.toLowerCase())) return { type: 'string', s: raw };
+  const known = KNOWN_COLORS.has(raw.toLowerCase());
+  if (known && (rendererColors.hasKnownList || !report)) return { type: 'string', s: raw };
   const color: GVColor = { type: 'rgba', r: 0, g: 0, b: 0, a: 0 };
-  colorxlate(raw, color, 'rgba');
-  return color;
+  const rc = colorxlate(raw, color, 'rgba');
+  if (report) reportColorxlate(raw, rc);
+  return known ? { type: 'string', s: raw } : color;
+}
+
+/**
+ * The non-OK branch of gvrender_resolve_color: an unknown name warns once per
+ * render (emit_once "color <name>"), any other failure is an error.
+ *
+ * The result is renderer independent: every renderer's known-colors list is
+ * either absent (dot, xdot, json, cmapx, ...) or the SVG list, whose names all
+ * colorxlate to COLOR_OK, so only the xlate result decides whether C warns.
+ *
+ * @see lib/gvc/gvrender.c:201-209 gvrender_resolve_color
+ */
+function reportColorxlate(name: string, rc: ColorxlateResult): void {
+  if (rc === ColorxlateResult.ColorOk) return;
+  if (rc === ColorxlateResult.ColorUnknown) {
+    if (emitOnce(`color ${name}`)) agwarningf(`${name} is not a known color.`);
+  } else {
+    agerrorf('error in colorxlate()');
+  }
 }
 
 /**
@@ -169,3 +227,134 @@ export function textFillAttrs(fontColor: string | null): string {
   if (byte < 255) out += ' fill-opacity="' + (byte / 255).toFixed(6) + '"';
   return out;
 }
+
+// ---------------------------------------------------------------------------
+// Unknown-color reporting in C's call order
+//
+// Which names C hands to gvrender_resolve_color, and in what order, is fixed by
+// the emit code (emit_edge_graphics, emit_background, emit_label, ...), not by
+// the renderer. The port's renderers resolve in their own order and not at all
+// for the non-drawing ones (plain, imap, cmapx), so each pass below lists the
+// names in C's order and resolves them once, before any renderer code runs;
+// emit_once then makes every later resolve of the same name silent.
+// ---------------------------------------------------------------------------
+
+/** @see lib/common/const.h DEFAULT_COLOR */
+const DEFAULT_COLOR = 'black';
+/** @see lib/common/emit.c:452 AEQ0 (EPS) */
+const SEG_EPS = 1e-5;
+
+/**
+ * Resolve each name as gvrender_set_pencolor/_fillcolor/_gradient_vals would
+ * (cut at the first ':'), reporting unknown colors.
+ */
+export function reportColorNames(names: readonly string[]): void {
+  for (const name of names) resolveRenderColor(firstColor(name));
+}
+
+/** The per-bezier arrow flags emit_edge_graphics consults. */
+export interface EdgeArrowFlags {
+  sflag: boolean;
+  eflag: boolean;
+}
+
+/** The inputs of emit_edge_graphics' colour decisions. */
+export interface EdgeColorSpec {
+  /** late_string(e, E_color, ""). */
+  color: string;
+  /** E_fillcolor when set and non-empty, else "". */
+  fillcolor: string;
+  tapered: boolean;
+  arrows: readonly EdgeArrowFlags[];
+}
+
+/** Count occurrences of one character. */
+function countChar(s: string, ch: string): number {
+  return s.split(ch).length - 1;
+}
+
+/**
+ * The colours C's multicolor() sets, or null when the colour spec is rejected
+ * (parseSegs rv 1 or 2) and emit_edge_graphics falls back to DEFAULT_COLOR.
+ * @see lib/common/emit.c:1975 multicolor
+ */
+function multicolorNames(
+  color: string,
+  arrows: readonly EdgeArrowFlags[],
+): string[] | null {
+  const { segs, error } = parseSegs(color);
+  if (error === 1 || error === 2) return null;
+  const out: string[] = [];
+  const front = segs[0]?.color ?? null;
+  for (const bz of arrows) {
+    let endcolor: string | null = null;
+    for (const seg of segs) {
+      if (seg.color === null) break;
+      if (Math.abs(seg.t) < SEG_EPS) continue;
+      out.push(seg.color);
+      endcolor = seg.color;
+    }
+    if (bz.sflag && front !== null) out.push(front);
+    if (bz.eflag && endcolor !== null) out.push(endcolor);
+  }
+  return out;
+}
+
+/** The tapered branch: transparent pen, colour as fill, then pen and fill. */
+function taperedNames(color: string, fillcolor: string, hasFill: boolean): string[] {
+  const pen = color === '' ? DEFAULT_COLOR : color;
+  return hasFill ? [pen, fillcolor === '' ? DEFAULT_COLOR : fillcolor] : [pen];
+}
+
+/**
+ * The names emit_edge_graphics resolves for an edge with a spline, in order.
+ * @see lib/common/emit.c:2350 emit_edge_graphics
+ */
+export function edgeGraphicsColors(spec: EdgeColorSpec): string[] {
+  const numc = countChar(spec.color, ':');
+  let color = spec.color;
+  if (countChar(color, ';') > 0 && numc > 0) {
+    const multi = multicolorNames(color, spec.arrows);
+    if (multi !== null) return multi;
+    color = DEFAULT_COLOR;
+  }
+  const hasFill = spec.fillcolor !== '';
+  const early = hasFill ? [spec.fillcolor] : [];
+  if (spec.tapered) return [...early, ...taperedNames(color, spec.fillcolor, hasFill)];
+  if (numc > 0) return [...early, ...color.split(':').filter((c) => c !== '')];
+  const fill = hasFill ? spec.fillcolor : color;
+  if (color !== '') return [...early, color, fill];
+  return [...early, DEFAULT_COLOR, fill !== '' ? fill : DEFAULT_COLOR];
+}
+
+/**
+ * Report the unknown colours of an edge's graphics in C's order.
+ * @see lib/common/emit.c:2350 emit_edge_graphics
+ */
+export function reportEdgeColors(e: Edge): void {
+  const spl = e.info.spl;
+  if (!spl) return;
+  const color = e.attrs.get('color') ?? '';
+  reportColorNames(edgeGraphicsColors({
+    color,
+    fillcolor: e.attrs.get('fillcolor') ?? '',
+    tapered: styleTokens(e.attrs.get('style')).includes('tapered'),
+    arrows: spl.list.map((bz) => ({ sflag: bz.sflag !== 0, eflag: bz.eflag !== 0 })),
+  }));
+}
+
+/**
+ * The names emit_background resolves: the fill (a gradient's first colour, the
+ * transparent pen, then the stop). Only a truecolor device (svg) keeps a
+ * transparent background unpainted; elsewhere it becomes white.
+ * @see lib/common/emit.c:1476 emit_background
+ */
+export function backgroundColors(bgcolor: string | undefined, truecolor: boolean): string[] {
+  let str = bgcolor !== undefined && bgcolor !== '' ? bgcolor : 'white';
+  if (str === 'transparent') {
+    if (truecolor) return [];
+    str = 'white';
+  }
+  const stop = findStopColor(str);
+  return stop === null ? [str, 'transparent'] : [stop.fillColor, 'transparent', stop.stopColor];
+}

package/src/render/public.ts

@@ -14,6 +14,7 @@ import type { Graph } from '../model/graph.js';
 import { createDefaultContext } from '../gvc/default-context.js';
 import { render as deviceRender } from '../gvc/device.js';
 import { invalidArgType, rethrowAtBoundary } from '../errors.js';
+import { resetRenderState } from '../common/render-state.js';
 import type { EngineName } from '../gvc/context.js';
 
 // ---------------------------------------------------------------------------
@@ -118,6 +119,7 @@ export function render(
   opts?: RenderOptions,
 ): string {
   checkRenderArgs(g, format, opts);
+  resetRenderState(); // AD-4: one render = one native process
   const engine: EngineName = opts?.engine ?? 'dot';
   const inlineImages = opts?.inlineImages ?? false;
   const ctx = createDefaultContext();

package/src/render/svg-edge-split.ts

@@ -20,6 +20,7 @@ import type { Edge } from '../model/edge.js';
 import type { RenderJob } from '../gvc/job.js';
 import type { Point, Bezier } from '../model/geom.js';
 import { bezier } from '../common/bezier.js';
+import { dist2 } from '../common/spline-midpoint.js';
 import { parseSegs } from '../common/multicolor.js';
 import { transformPoint } from '../gvc/device.js';
 import { emitBezierPath, emitDash, emitPenWidth } from './svg-helpers.js';
@@ -31,12 +32,13 @@ const PENWIDTH_THRESHOLD = 0.005;
 /** AEQ0 tolerance for fraction comparisons. */
 const EPS = 1e-5;
 
+/** DIST: sqrt of the fused DIST2 (libgvc splitBSpline: fmla + fsqrt). @see lib/common/geom.h:DIST */
 function dist(a: Point, b: Point): number {
-  return Math.hypot(a.x - b.x, a.y - b.y);
+  return Math.sqrt(dist2(a, b));
 }
 
 /** Chord length of one cubic (control points at off..off+3). @see emit.c:1908 */
-function approxLen(list: Point[], off: number): number {
+export function approxLen(list: Point[], off: number): number {
   return dist(list[off]!, list[off + 1]!) +
     dist(list[off + 1]!, list[off + 2]!) +
     dist(list[off + 2]!, list[off + 3]!);

package/src/render/xdot-public.ts

@@ -35,6 +35,7 @@ import { createDefaultContext } from '../gvc/default-context.js';
 import { parseXDot } from '../xdot/index.js';
 import type { EngineName } from '../gvc/context.js';
 import { invalidArgType, rethrowAtBoundary } from '../errors.js';
+import { resetRenderState } from '../common/render-state.js';
 
 /**
  * `Xdot` — the parsed result of one xdot attribute stream: `ops` (the
@@ -160,6 +161,7 @@ function layoutAndRenderXdot(g: Graph, engine: EngineName): string {
  */
 export function getDrawOps(g: Graph, opts?: DrawOpsOptions): XdotOp[] {
   checkDrawOpsArgs(g, opts);
+  resetRenderState(); // AD-4: one render = one native process
   const engine = opts?.engine ?? DEFAULT_DRAW_ENGINE;
   return collectGraphOps(parse(layoutAndRenderXdot(g, engine)));
 }