@opendata-ai/openchart-engine 8.0.0-rc.9 → 8.0.0

package/src/sankey/__tests__/layout.test.ts

@@ -1,165 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { computeSankeyLayout } from '../layout';
-
-// ---------------------------------------------------------------------------
-// Shared fixtures
-// ---------------------------------------------------------------------------
-
-/** Linear chain: A -> B -> C (3 columns) */
-const linearData = [
-  { source: 'A', target: 'B', value: 10 },
-  { source: 'B', target: 'C', value: 10 },
-];
-
-/** Branching: A -> B, A -> C */
-const branchData = [
-  { source: 'A', target: 'B', value: 10 },
-  { source: 'A', target: 'C', value: 20 },
-];
-
-const area = { x: 0, y: 0, width: 600, height: 400 };
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('computeSankeyLayout', () => {
-  it('linear chain produces correct column count (depths 0, 1, 2)', () => {
-    const { nodes } = computeSankeyLayout(
-      linearData,
-      'source',
-      'target',
-      'value',
-      area,
-      12,
-      16,
-      'justify',
-      6,
-    );
-
-    const depths = new Set(nodes.map((n) => n.depth));
-    expect(depths.size).toBe(3);
-    expect(depths).toContain(0);
-    expect(depths).toContain(1);
-    expect(depths).toContain(2);
-  });
-
-  it('nodeWidth is respected', () => {
-    const nodeWidth = 20;
-    const { nodes } = computeSankeyLayout(
-      linearData,
-      'source',
-      'target',
-      'value',
-      area,
-      nodeWidth,
-      16,
-      'justify',
-      6,
-    );
-
-    for (const node of nodes) {
-      const computedWidth = (node.x1 ?? 0) - (node.x0 ?? 0);
-      expect(computedWidth).toBeCloseTo(nodeWidth, 0);
-    }
-  });
-
-  it('nodePadding ensures vertical gap between nodes in the same column', () => {
-    const padding = 24;
-    // Use left alignment for a deterministic test (justify may spread nodes across columns).
-    const { nodes: leftNodes } = computeSankeyLayout(
-      branchData,
-      'source',
-      'target',
-      'value',
-      area,
-      12,
-      padding,
-      'left',
-      6,
-    );
-
-    const col1 = leftNodes.filter((n) => n.depth === 1).sort((a, b) => (a.y0 ?? 0) - (b.y0 ?? 0));
-
-    if (col1.length >= 2) {
-      for (let i = 0; i < col1.length - 1; i++) {
-        const gap = (col1[i + 1].y0 ?? 0) - (col1[i].y1 ?? 0);
-        expect(gap).toBeGreaterThanOrEqual(padding - 1); // Allow 1px rounding
-      }
-    }
-  });
-
-  it('different nodeAlign values produce different layouts', () => {
-    const justifyResult = computeSankeyLayout(
-      linearData,
-      'source',
-      'target',
-      'value',
-      area,
-      12,
-      16,
-      'justify',
-      6,
-    );
-
-    const leftResult = computeSankeyLayout(
-      linearData,
-      'source',
-      'target',
-      'value',
-      area,
-      12,
-      16,
-      'left',
-      6,
-    );
-
-    // For a linear chain with justify vs left, node positions may differ.
-    // At minimum, both should produce valid layouts with the right node count.
-    expect(justifyResult.nodes).toHaveLength(3);
-    expect(leftResult.nodes).toHaveLength(3);
-
-    // The x positions should be the same for a linear chain (both align
-    // left-to-right), but verify the layouts are structurally sound.
-    for (const node of justifyResult.nodes) {
-      expect(node.x0).toBeDefined();
-      expect(node.x1).toBeDefined();
-      expect(node.y0).toBeDefined();
-      expect(node.y1).toBeDefined();
-    }
-  });
-
-  it('returns correct link count', () => {
-    const { links } = computeSankeyLayout(
-      linearData,
-      'source',
-      'target',
-      'value',
-      area,
-      12,
-      16,
-      'justify',
-      6,
-    );
-
-    expect(links).toHaveLength(2);
-  });
-
-  it('link values match input data', () => {
-    const { links } = computeSankeyLayout(
-      linearData,
-      'source',
-      'target',
-      'value',
-      area,
-      12,
-      16,
-      'justify',
-      6,
-    );
-
-    for (const link of links) {
-      expect(link.value).toBe(10);
-    }
-  });
-});

package/src/sankey/__tests__/node-label-wrap.test.ts

@@ -1,114 +0,0 @@
-/**
- * Characterization test for sankey node-label wrapping at narrow widths.
- *
- * Part of refactor/v7-cohesion step 1. The sankey engine computes a label's
- * `maxWidth` based on available horizontal space from the label anchor to the
- * container edge (see computeNodeLabel in compile-sankey.ts around line 137).
- * When the container is narrow and node labels are long, the computed
- * `maxWidth` falls below the estimated text width — the adapter then wraps the
- * label into multiple lines via its own wrapText routine.
- *
- * Step 3 of the v7 plan extracts `wrapText` to core while keeping the sankey
- * path heuristic-only. This test guards the engine's responsibility: produce a
- * label `maxWidth` that forces wrapping on long-label narrow-width sankeys.
- */
-
-import { estimateTextWidth, wrapText } from '@opendata-ai/openchart-core';
-import { describe, expect, it } from 'vitest';
-import { compileSankey } from '../../compile';
-
-describe('sankey node-label wrapping', () => {
-  it('produces at least one node whose label maxWidth forces wrapping at narrow widths', () => {
-    const spec = {
-      type: 'sankey' as const,
-      data: [
-        {
-          from: 'Renewable Energy Sources International',
-          to: 'Grid Transmission Network',
-          amount: 100,
-        },
-        { from: 'Grid Transmission Network', to: 'Residential Consumption Households', amount: 60 },
-        { from: 'Grid Transmission Network', to: 'Commercial Industrial Facilities', amount: 40 },
-      ],
-      encoding: {
-        source: { field: 'from', type: 'nominal' as const },
-        target: { field: 'to', type: 'nominal' as const },
-        value: { field: 'amount', type: 'quantitative' as const },
-      },
-    };
-
-    // 300px wide total is cramped for the labels above across 3 columns,
-    // forcing per-label maxWidth to be well below the longest text width.
-    const layout = compileSankey(spec, { width: 300, height: 300 });
-
-    // Every node should have a finite maxWidth set (a proxy for "engine
-    // participated in wrap geometry") when overflow-compression kicked in.
-    const withMaxWidth = layout.nodes.filter(
-      (n) => typeof n.label.maxWidth === 'number' && (n.label.maxWidth as number) >= 0,
-    );
-    expect(withMaxWidth.length).toBe(layout.nodes.length);
-
-    // At least one node label requires wrapping: its natural text width
-    // exceeds the engine-assigned maxWidth at the same font size/weight.
-    const wrapsRequired = withMaxWidth.filter((n) => {
-      const tw = estimateTextWidth(
-        n.label.text,
-        n.label.style.fontSize,
-        n.label.style.fontWeight ?? 400,
-      );
-      return tw > (n.label.maxWidth as number);
-    });
-    expect(wrapsRequired.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('does not force wrapping at generous widths for the same long-label spec', () => {
-    // Control: the same spec at a comfortable width does not require wrapping.
-    const spec = {
-      type: 'sankey' as const,
-      data: [
-        {
-          from: 'Renewable Energy Sources International',
-          to: 'Grid Transmission Network',
-          amount: 100,
-        },
-        { from: 'Grid Transmission Network', to: 'Residential Consumption Households', amount: 60 },
-      ],
-      encoding: {
-        source: { field: 'from', type: 'nominal' as const },
-        target: { field: 'to', type: 'nominal' as const },
-        value: { field: 'amount', type: 'quantitative' as const },
-      },
-    };
-
-    const layout = compileSankey(spec, { width: 1600, height: 300 });
-
-    const wrapsRequired = layout.nodes.filter((n) => {
-      if (typeof n.label.maxWidth !== 'number') return false;
-      const tw = estimateTextWidth(
-        n.label.text,
-        n.label.style.fontSize,
-        n.label.style.fontWeight ?? 400,
-      );
-      return tw > (n.label.maxWidth as number);
-    });
-    expect(wrapsRequired.length).toBe(0);
-  });
-
-  // ---------------------------------------------------------------------------
-  // Pinned behavior (refactor/v7-cohesion code review item 1):
-  // The shared wrapText in core/src/layout/text-wrap.ts splits on `\n` before
-  // word-wrapping. The previous sankey-local wrapText did not. Pin the new
-  // behavior so anyone relying on `\n` in node labels sees the multi-line break.
-  // ---------------------------------------------------------------------------
-  it('honors explicit `\\n` in node labels by producing multi-line wrap output', () => {
-    const lines = wrapText('First line\nSecond line', 12, 400, 1000);
-
-    expect(lines).toEqual(['First line', 'Second line']);
-  });
-
-  it('preserves blank lines between consecutive `\\n` characters', () => {
-    const lines = wrapText('A\n\nB', 12, 400, 1000);
-
-    expect(lines).toEqual(['A', '', 'B']);
-  });
-});

package/src/sankey/__tests__/node-sort.test.ts

@@ -1,45 +0,0 @@
-/**
- * Characterization test for sankey explicit `nodeSort`.
- *
- * Part of refactor/v7-cohesion step 1. Pins the `nodeSort` handling in
- * `packages/engine/src/sankey/layout.ts` around line 120, where an explicit
- * ordered-ID array is translated into a d3-sankey `nodeSort` comparator so
- * nodes stack top-to-bottom within each column following the user's order
- * rather than d3-sankey's default (data-insertion / value-based) ordering.
- */
-
-import { describe, expect, it } from 'vitest';
-import { computeSankeyLayout } from '../layout';
-
-describe('sankey explicit nodeSort', () => {
-  it('orders nodes within a column according to the nodeSort array', () => {
-    // A, B, C all live in column 0 and flow into D in column 1.
-    // Data-insertion order is A, B, C (the default d3-sankey order varies
-    // with value anyway). Explicit nodeSort forces C, A, B top-to-bottom.
-    const data = [
-      { source: 'A', target: 'D', value: 10 },
-      { source: 'B', target: 'D', value: 20 },
-      { source: 'C', target: 'D', value: 15 },
-    ];
-
-    const { nodes } = computeSankeyLayout(
-      data,
-      'source',
-      'target',
-      'value',
-      { x: 0, y: 0, width: 600, height: 400 },
-      12,
-      16,
-      'justify',
-      6,
-      ['C', 'A', 'B'],
-    );
-
-    // Collect column-0 nodes, sort them by vertical position, and read back IDs.
-    const col0 = nodes.filter((n) => n.depth === 0);
-    expect(col0.map((n) => n.id).sort()).toEqual(['A', 'B', 'C']);
-
-    const ordered = [...col0].sort((a, b) => (a.y0 ?? 0) - (b.y0 ?? 0)).map((n) => n.id);
-    expect(ordered).toEqual(['C', 'A', 'B']);
-  });
-});