@diagrammo/dgmo 0.46.0 → 0.48.0

package/src/kanban/types.ts

@@ -1,39 +0,0 @@
-import type { DgmoError } from '../diagnostics';
-import type { TagGroup, TagEntry } from '../utils/tag-groups';
-
-/** @deprecated Use `TagEntry` from `utils/tag-groups` */
-export type KanbanTagEntry = TagEntry;
-/** @deprecated Use `TagGroup` from `utils/tag-groups` */
-export type KanbanTagGroup = TagGroup;
-
-export interface KanbanCard {
-  readonly id: string;
-  readonly title: string;
-  readonly tags: Readonly<Record<string, string>>; // groupName → value
-  readonly details: readonly string[]; // freeform indented lines
-  readonly lineNumber: number; // first line of the card (1-based)
-  readonly endLineNumber: number; // last line inclusive (1-based)
-  readonly color?: string; // explicit color override via (color) suffix
-}
-
-export interface KanbanColumn {
-  readonly id: string;
-  readonly name: string;
-  readonly wipLimit?: number;
-  readonly color?: string;
-  readonly collapsed?: boolean; // `[Column] collapsed: true` view-state marker
-  readonly metadata?: Readonly<Record<string, string>>;
-  readonly cards: readonly KanbanCard[];
-  readonly lineNumber: number;
-}
-
-export interface ParsedKanban {
-  readonly type: 'kanban';
-  readonly title?: string;
-  readonly titleLineNumber?: number;
-  readonly columns: readonly KanbanColumn[];
-  readonly tagGroups: readonly KanbanTagGroup[];
-  readonly options: Readonly<Record<string, string>>;
-  readonly diagnostics: readonly DgmoError[];
-  readonly error: string | null;
-}

package/src/label-layout.ts

@@ -1,368 +0,0 @@
-// ---------------------------------------------------------------------------
-// Shared label collision detection and placement utilities
-// ---------------------------------------------------------------------------
-
-import { measureText } from './utils/text-measure';
-
-export interface LabelRect {
-  x: number;
-  y: number;
-  w: number;
-  h: number;
-}
-
-export interface PointCircle {
-  cx: number;
-  cy: number;
-  r: number;
-}
-
-/** Axis-aligned bounding box overlap test. */
-export function rectsOverlap(a: LabelRect, b: LabelRect): boolean {
-  return (
-    a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y
-  );
-}
-
-/** Rect vs circle overlap using nearest-point-on-rect distance check. */
-export function rectCircleOverlap(
-  rect: LabelRect,
-  circle: PointCircle
-): boolean {
-  const nearestX = Math.max(rect.x, Math.min(circle.cx, rect.x + rect.w));
-  const nearestY = Math.max(rect.y, Math.min(circle.cy, rect.y + rect.h));
-  const dx = nearestX - circle.cx;
-  const dy = nearestY - circle.cy;
-  return dx * dx + dy * dy < circle.r * circle.r;
-}
-
-/** Line-segment vs axis-aligned rect intersection (Liang–Barsky clip). True
- *  when any part of the segment lies inside or crosses the rect. */
-export function segmentRectOverlap(
-  x0: number,
-  y0: number,
-  x1: number,
-  y1: number,
-  rect: LabelRect
-): boolean {
-  const dx = x1 - x0;
-  const dy = y1 - y0;
-  let t0 = 0;
-  let t1 = 1;
-  const edges: Array<[number, number]> = [
-    [-dx, x0 - rect.x],
-    [dx, rect.x + rect.w - x0],
-    [-dy, y0 - rect.y],
-    [dy, rect.y + rect.h - y0],
-  ];
-  for (const [p, q] of edges) {
-    if (p === 0) {
-      if (q < 0) return false; // parallel and outside this edge
-    } else {
-      const t = q / p;
-      if (p < 0) {
-        if (t > t1) return false;
-        if (t > t0) t0 = t;
-      } else {
-        if (t < t0) return false;
-        if (t < t1) t1 = t;
-      }
-    }
-  }
-  return true;
-}
-
-/** Segment vs segment proper intersection (orientation test). True when the two
- *  open segments cross. Shared endpoints / collinear touching count as crossing
- *  too (the conservative choice for "do these two leader lines tangle?"). */
-export function segmentsCross(
-  ax: number,
-  ay: number,
-  bx: number,
-  by: number,
-  cx: number,
-  cy: number,
-  dx: number,
-  dy: number
-): boolean {
-  const o = (
-    px: number,
-    py: number,
-    qx: number,
-    qy: number,
-    rx: number,
-    ry: number
-  ): number => Math.sign((qx - px) * (ry - py) - (qy - py) * (rx - px));
-  const o1 = o(ax, ay, bx, by, cx, cy);
-  const o2 = o(ax, ay, bx, by, dx, dy);
-  const o3 = o(cx, cy, dx, dy, ax, ay);
-  const o4 = o(cx, cy, dx, dy, bx, by);
-  if (o1 !== o2 && o3 !== o4) return true;
-  // Collinear-overlap edge cases: treat any on-segment touch as a crossing.
-  const onSeg = (
-    px: number,
-    py: number,
-    qx: number,
-    qy: number,
-    rx: number,
-    ry: number
-  ): boolean =>
-    Math.min(px, qx) <= rx &&
-    rx <= Math.max(px, qx) &&
-    Math.min(py, qy) <= ry &&
-    ry <= Math.max(py, qy);
-  if (o1 === 0 && onSeg(ax, ay, bx, by, cx, cy)) return true;
-  if (o2 === 0 && onSeg(ax, ay, bx, by, dx, dy)) return true;
-  if (o3 === 0 && onSeg(cx, cy, dx, dy, ax, ay)) return true;
-  if (o4 === 0 && onSeg(cx, cy, dx, dy, bx, by)) return true;
-  return false;
-}
-
-// ---------------------------------------------------------------------------
-// Quadrant chart point label placement
-// ---------------------------------------------------------------------------
-
-export interface QuadrantLabelPoint {
-  label: string;
-  cx: number; // pixel x
-  cy: number; // pixel y
-}
-
-interface PlacedQuadrantLabel {
-  label: string;
-  x: number; // text x
-  y: number; // text y (center of label)
-  anchor: 'middle' | 'start' | 'end';
-  connectorLine?: { x1: number; y1: number; x2: number; y2: number };
-}
-
-/**
- * Greedy label placement for quadrant chart points.
- * Avoids collisions with other point labels, point circles, and obstacle rects
- * (quadrant watermark labels). Labels are constrained within chartBounds.
- *
- * Pure function — no DOM dependency.
- */
-export function computeQuadrantPointLabels(
-  points: QuadrantLabelPoint[],
-  chartBounds: { left: number; top: number; right: number; bottom: number },
-  obstacles: LabelRect[],
-  pointRadius: number,
-  fontSize: number
-): PlacedQuadrantLabel[] {
-  const labelHeight = fontSize + 4;
-  const stepSize = labelHeight + 2;
-  const minGap = pointRadius + 4;
-
-  // Build collision circles for all points
-  const pointCircles: PointCircle[] = points.map((p) => ({
-    cx: p.cx,
-    cy: p.cy,
-    r: pointRadius,
-  }));
-
-  const placedLabels: LabelRect[] = [];
-  const results: PlacedQuadrantLabel[] = [];
-
-  for (let i = 0; i < points.length; i++) {
-    const pt = points[i]!; // In-bounds by loop guard.
-    const labelWidth = measureText(pt.label, fontSize) + 8;
-
-    // Try 4 directions: above, below, left, right
-    // Each direction generates candidate (labelX, labelY, anchor)
-    type Candidate = {
-      rect: LabelRect;
-      textX: number;
-      textY: number;
-      anchor: 'middle' | 'start' | 'end';
-      dist: number;
-    };
-
-    let best: Candidate | null = null;
-
-    // Direction generators: for a given offset, produce a candidate rect + text position
-    const directions: Array<{
-      gen: (offset: number) => {
-        rect: LabelRect;
-        textX: number;
-        textY: number;
-        anchor: 'middle' | 'start' | 'end';
-      } | null;
-    }> = [
-      {
-        // Above
-        gen: (offset) => {
-          const lx = pt.cx - labelWidth / 2;
-          const ly = pt.cy - offset - labelHeight;
-          if (
-            ly < chartBounds.top ||
-            lx < chartBounds.left ||
-            lx + labelWidth > chartBounds.right
-          )
-            return null;
-          return {
-            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
-            textX: pt.cx,
-            textY: ly + labelHeight / 2,
-            anchor: 'middle',
-          };
-        },
-      },
-      {
-        // Below
-        gen: (offset) => {
-          const lx = pt.cx - labelWidth / 2;
-          const ly = pt.cy + offset;
-          if (
-            ly + labelHeight > chartBounds.bottom ||
-            lx < chartBounds.left ||
-            lx + labelWidth > chartBounds.right
-          )
-            return null;
-          return {
-            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
-            textX: pt.cx,
-            textY: ly + labelHeight / 2,
-            anchor: 'middle',
-          };
-        },
-      },
-      {
-        // Right
-        gen: (offset) => {
-          const lx = pt.cx + offset;
-          const ly = pt.cy - labelHeight / 2;
-          if (
-            lx + labelWidth > chartBounds.right ||
-            ly < chartBounds.top ||
-            ly + labelHeight > chartBounds.bottom
-          )
-            return null;
-          return {
-            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
-            textX: lx,
-            textY: pt.cy,
-            anchor: 'start',
-          };
-        },
-      },
-      {
-        // Left
-        gen: (offset) => {
-          const lx = pt.cx - offset - labelWidth;
-          const ly = pt.cy - labelHeight / 2;
-          if (
-            lx < chartBounds.left ||
-            ly < chartBounds.top ||
-            ly + labelHeight > chartBounds.bottom
-          )
-            return null;
-          return {
-            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
-            textX: lx + labelWidth,
-            textY: pt.cy,
-            anchor: 'end',
-          };
-        },
-      },
-    ];
-
-    for (const { gen } of directions) {
-      for (let offset = minGap; ; offset += stepSize) {
-        const cand = gen(offset);
-        if (!cand) break; // out of bounds in this direction
-
-        // Check collisions with placed labels
-        let collision = false;
-        for (const pl of placedLabels) {
-          if (rectsOverlap(cand.rect, pl)) {
-            collision = true;
-            break;
-          }
-        }
-
-        // Check collisions with point circles
-        if (!collision) {
-          for (const circle of pointCircles) {
-            if (rectCircleOverlap(cand.rect, circle)) {
-              collision = true;
-              break;
-            }
-          }
-        }
-
-        // Check collisions with obstacle rects (quadrant labels)
-        if (!collision) {
-          for (const obs of obstacles) {
-            if (rectsOverlap(cand.rect, obs)) {
-              collision = true;
-              break;
-            }
-          }
-        }
-
-        if (!collision) {
-          const dist = offset;
-          if (!best || dist < best.dist) {
-            best = {
-              rect: cand.rect,
-              textX: cand.textX,
-              textY: cand.textY,
-              anchor: cand.anchor,
-              dist,
-            };
-          }
-          break; // best for this direction found
-        }
-      }
-    }
-
-    // Fallback: place above at minGap (may overlap, but at least visible)
-    if (!best) {
-      const lx = pt.cx - labelWidth / 2;
-      const ly = pt.cy - minGap - labelHeight;
-      best = {
-        rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
-        textX: pt.cx,
-        textY: ly + labelHeight / 2,
-        anchor: 'middle',
-        dist: minGap,
-      };
-    }
-
-    placedLabels.push(best.rect);
-
-    // Connector line when label is pushed beyond immediate adjacency
-    let connectorLine: PlacedQuadrantLabel['connectorLine'];
-    if (best.dist > minGap + stepSize) {
-      // Determine connector endpoints: from point edge to label edge
-      const dx = best.textX - pt.cx;
-      const dy = best.textY - pt.cy;
-      const angle = Math.atan2(dy, dx);
-      const x1 = pt.cx + Math.cos(angle) * pointRadius;
-      const y1 = pt.cy + Math.sin(angle) * pointRadius;
-
-      // Label edge: closest point on label rect to the point
-      const x2 = Math.max(
-        best.rect.x,
-        Math.min(pt.cx, best.rect.x + best.rect.w)
-      );
-      const y2 = Math.max(
-        best.rect.y,
-        Math.min(pt.cy, best.rect.y + best.rect.h)
-      );
-
-      connectorLine = { x1, y1, x2, y2 };
-    }
-
-    results.push({
-      label: pt.label,
-      x: best.textX,
-      y: best.textY,
-      anchor: best.anchor,
-      ...(connectorLine !== undefined && { connectorLine }),
-    });
-  }
-
-  return results;
-}

package/src/map/colorize.ts

@@ -1,54 +0,0 @@
-// Political fill-assignment pass (§24B colorize). PURE + DETERMINISTIC — no
-// projection, no palette, no DOM. Given the per-topology arc-adjacency graph
-// (from geo.ts buildAdjacency), assign every drawn region a colour INDEX such
-// that no two arc-neighbours share one. The only job of a political fill is
-// boundary disambiguation; "no two neighbours share a hue" is the minimal
-// property — and a planar political map famously needs only a handful of colours.
-//
-// FIRST-FIT greedy: each region takes the LOWEST index not used by an
-// already-coloured neighbour. This is collision-free by construction (a node with
-// k coloured neighbours has at most k forbidden indices, so index ≤ k is always
-// free) AND clusters regions into the FEWEST colours — on the shipped graphs the
-// max index used is 5 (world) / 4 (us-states), i.e. 5–6 colours total. The caller
-// generates exactly that many palette tints, so the fills stay on-palette (no
-// need for the old Δ+1 ≈ 17 wheel hues).
-
-/** Result of {@link assignColors}: a colour INDEX per ISO + the number of
- *  distinct colours actually used (`= maxIndex + 1`). The index is a stable
- *  function of (ISO, global arc-adjacency) — extent-independent (AC10). */
-export interface ColorAssignment {
-  readonly byIso: Map<string, number>;
-  readonly huesNeeded: number;
-}
-
-/** First-fit greedy graph-coloring over `isos` using `adjacency` (ISO → neighbour
- *  ISOs). Visits ISOs in stable ascending order; each takes the lowest index not
- *  taken by an already-coloured neighbour — collision-free, and minimises the
- *  total colour count.
- *
- *  EVERY iso in `isos` is assigned an index — including zero-degree nodes
- *  (islands, DC, territories with no neighbour entry) — so the caller never needs
- *  a fallback fill (F14). */
-export function assignColors(
-  isos: readonly string[],
-  adjacency: ReadonlyMap<string, readonly string[]>
-): ColorAssignment {
-  const sorted = [...isos].sort();
-  const byIso = new Map<string, number>();
-  let maxIndex = -1;
-
-  for (const iso of sorted) {
-    const taken = new Set<number>();
-    for (const n of adjacency.get(iso) ?? []) {
-      const c = byIso.get(n);
-      if (c !== undefined) taken.add(c);
-    }
-    // Lowest index not taken by a neighbour (always exists: ≤ neighbour count).
-    let h = 0;
-    while (taken.has(h)) h++;
-    byIso.set(iso, h);
-    if (h > maxIndex) maxIndex = h;
-  }
-
-  return { byIso, huesNeeded: maxIndex + 1 };
-}