@diagrammo/dgmo 0.47.0 → 0.48.0

package/src/utils/text-measure.ts

@@ -1,122 +0,0 @@
-// ============================================================
-// Shared text measurement
-// ============================================================
-// One source of truth for "how wide is this string?" Before this
-// module, ~30 renderers/layouts each carried their own char-width
-// estimate (7.5px, 7px, 0.6·fontSize, 0.58, 0.55 …). The drift meant
-// the same label measured differently per chart type — a label could
-// fit inside an org node but overflow an infra node. All sizing,
-// wrapping, and truncation now route through the per-glyph table here.
-
-// Helvetica character width ratios (fraction of fontSize). Replaces the
-// naive `chars * 0.6 * fontSize` estimate with per-character widths.
-// prettier-ignore
-const CHAR_W: Record<string, number> = {
-  ' ':.28,'!': .28,'"': .36,'#': .56,'$': .56,'%': .89,'&': .67,"'":.19,
-  '(':.33,')':.33,'*': .39,'+':.58,',':.28,'-':.33,'.':.28,'/':.28,
-  '0':.56,'1':.56,'2':.56,'3':.56,'4':.56,'5':.56,'6':.56,'7':.56,'8':.56,'9':.56,
-  ':':.28,';':.28,'<':.58,'=':.58,'>':.58,'?':.56,'@':1.02,
-  A:.67,B:.67,C:.72,D:.72,E:.67,F:.61,G:.78,H:.72,I:.28,J:.50,K:.67,L:.56,M:.83,
-  N:.72,O:.78,P:.67,Q:.78,R:.72,S:.67,T:.61,U:.72,V:.67,W:.94,X:.67,Y:.67,Z:.61,
-  a:.56,b:.56,c:.50,d:.56,e:.56,f:.28,g:.56,h:.56,i:.22,j:.22,k:.50,l:.22,m:.83,
-  n:.56,o:.56,p:.56,q:.56,r:.33,s:.50,t:.28,u:.56,v:.50,w:.72,x:.50,y:.50,z:.50,
-};
-const DEFAULT_W = 0.56;
-
-/**
- * Average glyph-width ratio (fraction of fontSize). Only for the rare
- * call site that needs a single scalar (e.g. estimating a max char count
- * up front). Prefer {@link measureText} / {@link wrapTextToWidth} —
- * they account for actual glyph widths.
- */
-export const CHAR_WIDTH_RATIO = DEFAULT_W;
-
-/** Estimate rendered text width using Helvetica proportional character widths. */
-export function measureText(text: string, fontSize: number): number {
-  let w = 0;
-  for (let i = 0; i < text.length; i++) {
-    // charAt returns '' for out-of-bounds, never undefined.
-    w += (CHAR_W[text.charAt(i)] ?? DEFAULT_W) * fontSize;
-  }
-  return w;
-}
-
-/**
- * Truncate text with a trailing ellipsis to fit within maxWidth.
- * Returns the original text if it already fits, or '' if even the
- * ellipsis alone won't fit.
- */
-export function truncateText(
-  text: string,
-  fontSize: number,
-  maxWidth: number
-): string {
-  if (measureText(text, fontSize) <= maxWidth) return text;
-  const ellipsis = '…';
-  const ellipsisW = measureText(ellipsis, fontSize);
-  if (ellipsisW > maxWidth) return '';
-  let lo = 0;
-  let hi = text.length;
-  while (lo < hi) {
-    const mid = Math.ceil((lo + hi) / 2);
-    if (measureText(text.slice(0, mid), fontSize) + ellipsisW <= maxWidth) {
-      lo = mid;
-    } else {
-      hi = mid - 1;
-    }
-  }
-  return lo === 0 ? ellipsis : text.slice(0, lo) + ellipsis;
-}
-
-/**
- * Greedy word-wrap to a pixel width using accurate glyph measurement.
- *
- * - Splits on whitespace; a word that alone exceeds `maxWidth` is kept
- *   whole unless `hardBreak` is set, in which case it is broken at the
- *   character boundary that fits.
- * - Returns at least one line (`['']` for empty input).
- */
-export function wrapTextToWidth(
-  text: string,
-  fontSize: number,
-  maxWidth: number,
-  opts?: { hardBreak?: boolean }
-): string[] {
-  const words = text.split(/\s+/).filter((w) => w.length > 0);
-  if (words.length === 0) return [''];
-  const hardBreak = opts?.hardBreak ?? false;
-  const lines: string[] = [];
-  let current = '';
-  const pushWord = (word: string) => {
-    const test = current ? `${current} ${word}` : word;
-    if (measureText(test, fontSize) <= maxWidth || !current) {
-      current = test;
-    } else {
-      lines.push(current);
-      current = word;
-    }
-  };
-  for (const word of words) {
-    if (hardBreak && measureText(word, fontSize) > maxWidth) {
-      // Break the over-long word into width-fitting chunks.
-      if (current) {
-        lines.push(current);
-        current = '';
-      }
-      let chunk = '';
-      for (const ch of word) {
-        if (chunk && measureText(chunk + ch, fontSize) > maxWidth) {
-          lines.push(chunk);
-          chunk = ch;
-        } else {
-          chunk += ch;
-        }
-      }
-      current = chunk;
-      continue;
-    }
-    pushWord(word);
-  }
-  if (current) lines.push(current);
-  return lines.length > 0 ? lines : [''];
-}

package/src/utils/time-ticks.ts

@@ -1,253 +0,0 @@
-// ============================================================
-// Time axis tick computation — shared by d3.ts and gantt/renderer.ts
-// ============================================================
-
-import type * as d3Scale from 'd3-scale';
-
-export const MONTH_ABBR = [
-  'Jan',
-  'Feb',
-  'Mar',
-  'Apr',
-  'May',
-  'Jun',
-  'Jul',
-  'Aug',
-  'Sep',
-  'Oct',
-  'Nov',
-  'Dec',
-];
-
-function fractionalYearToDate(frac: number): Date {
-  const year = Math.floor(frac);
-  const remainder = frac - year;
-  // Inverse of: (month-1)/12 + (day-1)/365 + hour/8760 + minute/525600 + second/31536000
-  const monthFrac = remainder * 12;
-  const month = Math.floor(monthFrac); // 0-based
-  const monthRemainder = remainder - month / 12;
-  const dayFrac = monthRemainder * 365; // fractional day-of-year offset
-  const day = Math.floor(dayFrac) + 1;
-  const dayRemainder = dayFrac - Math.floor(dayFrac);
-  const hourFrac = dayRemainder * 24;
-  const hour = Math.floor(hourFrac);
-  const minuteFrac = (hourFrac - hour) * 60;
-  const minute = Math.floor(minuteFrac);
-  const second = Math.round((minuteFrac - minute) * 60);
-  return new Date(year, month, day, hour, minute, second);
-}
-
-/** Convert a Date to a fractional year number. */
-function dateToFractionalYear(d: Date): number {
-  return (
-    d.getFullYear() +
-    d.getMonth() / 12 +
-    (d.getDate() - 1) / 365 +
-    d.getHours() / 8760 +
-    d.getMinutes() / 525600 +
-    d.getSeconds() / 31536000
-  );
-}
-
-/** Year axis label: negative years render as `N BCE`. */
-function formatYearTick(y: number): string {
-  return y < 0 ? `${-y} BCE` : String(y);
-}
-
-/**
- * Generates adaptive tick marks along a time axis.
- * Picks the right granularity (years, months, weeks, days, hours, minutes)
- * based on the domain span.
- *
- * Optional boundary parameters add ticks at exact data start/end:
- * - boundaryStart/boundaryEnd: numeric date values
- * - boundaryStartLabel/boundaryEndLabel: formatted labels for those dates
- */
-export function computeTimeTicks(
-  domainMin: number,
-  domainMax: number,
-  scale: d3Scale.ScaleLinear<number, number>,
-  boundaryStart?: number,
-  boundaryEnd?: number,
-  boundaryStartLabel?: string,
-  boundaryEndLabel?: string
-): { pos: number; label: string }[] {
-  const minYear = Math.floor(domainMin);
-  const maxYear = Math.floor(domainMax);
-  const span = domainMax - domainMin;
-
-  let ticks: { pos: number; label: string }[] = [];
-
-  // Year ticks for multi-year spans (need at least 2 boundaries)
-  const firstYear = Math.ceil(domainMin);
-  const lastYear = Math.floor(domainMax);
-  if (lastYear >= firstYear + 1) {
-    // Decimate ticks for long spans so labels don't overlap. The ladder runs
-    // up to century/bicentury steps so millennium-scale spans (and BCE labels,
-    // which are ~2× wider) stay legible.
-    const yearSpan = lastYear - firstYear;
-    let step = 1;
-    if (yearSpan > 800) step = 200;
-    else if (yearSpan > 400) step = 100;
-    else if (yearSpan > 160) step = 50;
-    else if (yearSpan > 80) step = 20;
-    else if (yearSpan > 40) step = 10;
-    else if (yearSpan > 20) step = 5;
-    else if (yearSpan > 10) step = 2;
-
-    // Align to step boundary so ticks land on round years (1700, 1710, …)
-    const alignedFirst = Math.ceil(firstYear / step) * step;
-    for (let y = alignedFirst; y <= lastYear; y += step) {
-      ticks.push({ pos: scale(y), label: formatYearTick(y) });
-    }
-  } else if (span > 0.25) {
-    // Month ticks for spans > ~3 months
-    const crossesYear = maxYear > minYear;
-    for (let y = minYear; y <= maxYear + 1; y++) {
-      for (let m = 1; m <= 12; m++) {
-        const val = y + (m - 1) / 12;
-        if (val > domainMax) break;
-        if (val >= domainMin) {
-          // m is 1..12, so MONTH_ABBR[m-1] is always defined.
-          const abbr = MONTH_ABBR[m - 1]!;
-          ticks.push({
-            pos: scale(val),
-            label: crossesYear ? `${abbr} '${String(y).slice(-2)}` : abbr,
-          });
-        }
-      }
-    }
-  } else if (span <= 0.0000114) {
-    // Second ticks for spans ≤ ~6 minutes
-    // Adaptive step: >3min → 30s, >1min → 15s, >30s → 10s, else 5s
-    let stepSec = 5;
-    const spanSec = span * 31536000;
-    if (spanSec > 180) stepSec = 30;
-    else if (spanSec > 60) stepSec = 15;
-    else if (spanSec > 30) stepSec = 10;
-
-    const startDate = fractionalYearToDate(domainMin);
-    // Round down to nearest step boundary
-    startDate.setSeconds(
-      Math.floor(startDate.getSeconds() / stepSec) * stepSec,
-      0
-    );
-
-    while (true) {
-      const val = dateToFractionalYear(startDate);
-      if (val > domainMax) break;
-      if (val >= domainMin) {
-        const hh = String(startDate.getHours()).padStart(2, '0');
-        const mm = String(startDate.getMinutes()).padStart(2, '0');
-        const ss = String(startDate.getSeconds()).padStart(2, '0');
-        ticks.push({ pos: scale(val), label: `${hh}:${mm}:${ss}` });
-      }
-      startDate.setSeconds(startDate.getSeconds() + stepSec);
-    }
-  } else if (span <= 0.000685) {
-    // Minute ticks for spans ≤ ~6 hours
-    // Adaptive step: >3h → 30min, >1h → 15min, >30min → 10min, else 5min
-    let stepMin = 5;
-    const spanHours = span * 8760;
-    if (spanHours > 3) stepMin = 30;
-    else if (spanHours > 1) stepMin = 15;
-    else if (spanHours > 0.5) stepMin = 10;
-
-    // Iterate from the start hour boundary
-    const startDate = fractionalYearToDate(domainMin);
-    // Round down to nearest step boundary
-    startDate.setMinutes(
-      Math.floor(startDate.getMinutes() / stepMin) * stepMin,
-      0,
-      0
-    );
-
-    while (true) {
-      const val = dateToFractionalYear(startDate);
-      if (val > domainMax) break;
-      if (val >= domainMin) {
-        const hh = String(startDate.getHours()).padStart(2, '0');
-        const mm = String(startDate.getMinutes()).padStart(2, '0');
-        ticks.push({ pos: scale(val), label: `${hh}:${mm}` });
-      }
-      startDate.setMinutes(startDate.getMinutes() + stepMin);
-    }
-  } else if (span <= 0.00822) {
-    // Hour ticks for spans ≤ ~3 days
-    // Adaptive step: >2d → 6h, >1d → 3h, >12h → 2h, else 1h
-    let stepHour = 1;
-    const spanHours = span * 8760;
-    if (spanHours > 48) stepHour = 6;
-    else if (spanHours > 24) stepHour = 3;
-    else if (spanHours > 12) stepHour = 2;
-
-    // For single-day spans, just show HH:MM without the date prefix
-    const singleDay = spanHours <= 24;
-
-    const startDate = fractionalYearToDate(domainMin);
-    // Round down to nearest step boundary
-    startDate.setHours(
-      Math.floor(startDate.getHours() / stepHour) * stepHour,
-      0,
-      0,
-      0
-    );
-
-    while (true) {
-      const val = dateToFractionalYear(startDate);
-      if (val > domainMax) break;
-      if (val >= domainMin) {
-        const hh = String(startDate.getHours()).padStart(2, '0');
-        const mm = String(startDate.getMinutes()).padStart(2, '0');
-        if (singleDay) {
-          ticks.push({ pos: scale(val), label: `${hh}:${mm}` });
-        } else {
-          const mon = MONTH_ABBR[startDate.getMonth()];
-          const d = startDate.getDate();
-          ticks.push({ pos: scale(val), label: `${mon} ${d} ${hh}:${mm}` });
-        }
-      }
-      startDate.setHours(startDate.getHours() + stepHour);
-    }
-  } else {
-    // Week ticks for spans ≤ ~3 months (1st, 8th, 15th, 22nd of each month)
-    for (let y = minYear; y <= maxYear + 1; y++) {
-      for (let m = 1; m <= 12; m++) {
-        for (const d of [1, 8, 15, 22]) {
-          const val = y + (m - 1) / 12 + (d - 1) / 365;
-          if (val > domainMax) break;
-          if (val >= domainMin) {
-            ticks.push({
-              pos: scale(val),
-              label: `${MONTH_ABBR[m - 1]} ${d}`,
-            });
-          }
-        }
-      }
-    }
-  }
-
-  // Add boundary ticks at exact data start/end if provided
-  // When a boundary tick collides with a standard tick, replace the standard tick
-  const collisionThreshold = 40; // pixels
-
-  if (boundaryStart !== undefined && boundaryStartLabel) {
-    const boundaryPos = scale(boundaryStart);
-    // Remove any standard ticks that would collide with the start boundary
-    ticks = ticks.filter(
-      (t) => Math.abs(t.pos - boundaryPos) >= collisionThreshold
-    );
-    ticks.unshift({ pos: boundaryPos, label: boundaryStartLabel });
-  }
-
-  if (boundaryEnd !== undefined && boundaryEndLabel) {
-    const boundaryPos = scale(boundaryEnd);
-    // Remove any standard ticks that would collide with the end boundary
-    ticks = ticks.filter(
-      (t) => Math.abs(t.pos - boundaryPos) >= collisionThreshold
-    );
-    ticks.push({ pos: boundaryPos, label: boundaryEndLabel });
-  }
-
-  return ticks;
-}

package/src/utils/title-constants.ts

@@ -1,24 +0,0 @@
-// ============================================================
-// Shared chart title constants
-// All renderers import from here to stay in sync.
-// ============================================================
-
-export const TITLE_FONT_SIZE = 20;
-export const TITLE_FONT_WEIGHT = '700';
-export const TITLE_Y = 30;
-export const TITLE_OFFSET = 40;
-
-// Caption — supplementary banner text. The pert renderer wraps caption
-// content in a node-styled rectangle below the diagram body; backward-
-// anchor annotations still render as a free-floating italic line below
-// the title. Pixel `dy` (not `'1.2em'`) so layout math and rendered text
-// never drift between JSDOM and resvg.
-export const CAPTION_FONT_SIZE = 13;
-export const CAPTION_FONT_WEIGHT = '400';
-export const CAPTION_LINE_HEIGHT = 18;
-export const CAPTION_TOP_GAP = 12;
-// Inner padding for the caption rectangle. X = horizontal inset from
-// rect edge to bullet glyph; Y = vertical inset from rect top to first
-// baseline.
-export const CAPTION_BOX_PADDING_X = 16;
-export const CAPTION_BOX_PADDING_Y = 12;

package/src/utils/visual-conventions.ts

@@ -1,61 +0,0 @@
-// ============================================================
-// Visual conventions — shared card/group/collapse constants (Story 111.1)
-// ============================================================
-//
-// Single source of truth for the structured-diagram visual constants described
-// in docs/architecture/diagram-visual-conventions.md. Before this module these
-// values were re-declared in every renderer (NODE_STROKE_WIDTH in 13 files,
-// HEADER_HEIGHT in 12, ...), so a convention change meant editing N files and
-// hoping the snapshots agreed.
-//
-// Two tiers, because the renderers do NOT all agree:
-//
-//   1. UNIVERSAL — identical at every call site. Import these everywhere; never
-//      re-declare. Changing one of these is a deliberate cross-chart change.
-//
-//   2. CONVENTION DEFAULTS — the org/sitemap baseline from the convention. Most
-//      card-shaped renderers match these and should import them. A few have a
-//      DOCUMENTED intentional deviation and keep a local override (with a
-//      comment saying why):
-//        - infra: META_FONT_SIZE 10 / META_LINE_HEIGHT 14 (denser meta rows)
-//        - boxes-and-lines: COLLAPSE_BAR_HEIGHT 4 / SEPARATOR_GAP 4
-//        - cycle, raci: HEADER_HEIGHT 36 (not label+meta cards)
-//      Those overrides are the exception that proves the rule — they stay local
-//      and visible, not hidden inside a re-declared full constant set.
-
-// ── Universal (same value at every site) ──
-
-/** Node card + group border stroke width. */
-export const NODE_STROKE_WIDTH = 1.5;
-/** Edge / connector stroke width. */
-export const EDGE_STROKE_WIDTH = 1.5;
-/** Node card corner radius. */
-export const CARD_RADIUS = 6;
-/** Group / container corner radius. */
-export const CONTAINER_RADIUS = 8;
-/** Collapse accent bar horizontal inset from the card edges. */
-export const COLLAPSE_BAR_INSET = 0;
-
-// ── Convention defaults (org/sitemap baseline; see deviations above) ──
-
-/** Node card header band height. */
-export const HEADER_HEIGHT = 28;
-/** Node card label font size. */
-export const LABEL_FONT_SIZE = 13;
-/** Node card metadata-row font size. */
-export const META_FONT_SIZE = 11;
-/** Node card metadata-row line height. */
-export const META_LINE_HEIGHT = 16;
-/** Gap between the header separator and the first metadata row. */
-export const SEPARATOR_GAP = 6;
-/** Collapse accent bar height. */
-export const COLLAPSE_BAR_HEIGHT = 6;
-
-/** Group / container reserved header band height. */
-export const CONTAINER_HEADER_HEIGHT = 28;
-/** Group / container label font size. */
-export const CONTAINER_LABEL_FONT_SIZE = 13;
-/** Group / container metadata-row font size. */
-export const CONTAINER_META_FONT_SIZE = 11;
-/** Group / container metadata-row line height. */
-export const CONTAINER_META_LINE_HEIGHT = 16;

package/src/utils/wrapped-desc.ts

@@ -1,87 +0,0 @@
-// ============================================================
-// Wrapped Description — shared bullet-aware text wrapping
-// ============================================================
-
-/**
- * One rendered description line. `kind` controls horizontal placement and
- * whether the renderer draws a bullet glyph:
- *  - `plain`        — flush left at the description's left edge
- *  - `bullet-first` — "•" drawn at the left edge, body text at the bullet column
- *  - `bullet-cont`  — body continuation at the bullet column (no glyph)
- *
- * Splitting first-line bullet rendering into separate text elements lets
- * continuation lines align exactly under the first word past the bullet,
- * regardless of font-width estimation drift.
- */
-export interface WrappedDescLine {
-  text: string;
-  kind: 'plain' | 'bullet-first' | 'bullet-cont';
-}
-
-/** Bullet prefix that triggers split-rendering with a hanging body column. */
-export const BULLET_PREFIX = '• ';
-/** Equivalent body-column width in characters (subtracted from wrap width). */
-export const BULLET_INDENT_CHARS = 2;
-
-/**
- * Optional measurer — returns the *display* length of a string in characters.
- * Defaults to `s.length`. Pass a markdown-aware function (stripping link
- * targets, emphasis markers, etc.) when wrapping rich text so the wrap
- * boundary matches what the user will actually see.
- */
-export type LengthFn = (s: string) => number;
-
-/**
- * Word-wrap description lines. Bullet lines (starting with "• ") are split
- * so the renderer can place the "•" glyph at the description's left edge and
- * the body text at a fixed bullet-body column — continuation lines align
- * exactly under the first word past the bullet without depending on
- * font-width estimation.
- */
-export function wrapDescriptionLines(
-  lines: string[],
-  charsPerLine: number,
-  lengthFn: LengthFn = (s) => s.length
-): WrappedDescLine[] {
-  const result: WrappedDescLine[] = [];
-  for (const line of lines) {
-    if (!line.startsWith(BULLET_PREFIX)) {
-      const wrapped = wrapPlainLine(line, charsPerLine, lengthFn);
-      for (const w of wrapped) result.push({ text: w, kind: 'plain' });
-      continue;
-    }
-    // Strip "• " — the renderer draws the bullet glyph; we only wrap the body.
-    const body = line.slice(BULLET_PREFIX.length);
-    const bodyLimit = Math.max(8, charsPerLine - BULLET_INDENT_CHARS);
-    const wrapped = wrapPlainLine(body, bodyLimit, lengthFn);
-    wrapped.forEach((w, i) => {
-      result.push({ text: w, kind: i === 0 ? 'bullet-first' : 'bullet-cont' });
-    });
-  }
-  return result;
-}
-
-/**
- * Greedy word-wrap of a single string at the given character limit.
- * Long words are kept whole even if they exceed the limit (no mid-word break).
- */
-function wrapPlainLine(
-  line: string,
-  charsPerLine: number,
-  lengthFn: LengthFn
-): string[] {
-  const words = line.split(/\s+/);
-  const result: string[] = [];
-  let current = '';
-  for (const word of words) {
-    const test = current ? `${current} ${word}` : word;
-    if (lengthFn(test) > charsPerLine && current) {
-      result.push(current);
-      current = word;
-    } else {
-      current = test;
-    }
-  }
-  if (current) result.push(current);
-  return result;
-}

package/src/venn/parser.ts

@@ -1,18 +0,0 @@
-// ============================================================
-// venn parser door — Story 109.2 (arch-review).
-//
-// The six visualizations share one parse state machine (visualizations/parse.ts);
-// this is venn's typed entry point into it, returning the narrowed
-// ParsedVenn shape. The registry binds the 'venn' chart type to this door.
-// ============================================================
-
-import type { PaletteColors } from '../palettes';
-import { parseVisualization } from '../visualizations/parse';
-import type { ParsedVenn } from '../visualizations/types';
-
-export function parseVenn(
-  content: string,
-  palette?: PaletteColors
-): ParsedVenn {
-  return parseVisualization(content, palette) as ParsedVenn;
-}