@svgrid/grid 1.1.1 → 1.2.1

package/dist/chart.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/chart.test.js

@@ -1,289 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildChart, rowsToChartSpec, niceScale } from './chart';
-describe('niceScale', () => {
-    it('rounds a positive domain to nice ticks including 0', () => {
-        const s = niceScale(0, 95);
-        expect(s.min).toBe(0);
-        expect(s.max).toBeGreaterThanOrEqual(95);
-        expect(s.ticks[0]).toBe(0);
-    });
-    it('handles a signed domain (negatives)', () => {
-        const s = niceScale(-40, 80);
-        expect(s.min).toBeLessThanOrEqual(-40);
-        expect(s.max).toBeGreaterThanOrEqual(80);
-        expect(s.ticks).toContain(0);
-    });
-});
-describe('buildChart', () => {
-    it('bar: one rect per category per series, heights scale to max', () => {
-        const g = buildChart({
-            type: 'bar',
-            categories: ['A', 'B'],
-            series: [{ label: 's1', values: [10, 20] }],
-            width: 400,
-            height: 200,
-        });
-        expect(g.bars).toHaveLength(2);
-        expect(g.bars[1].h).toBeGreaterThan(g.bars[0].h);
-        expect(g.xTicks.map((t) => t.label)).toEqual(['A', 'B']);
-        expect(g.bars[1]).toMatchObject({ label: 'B', series: 's1', value: 20 });
-    });
-    it('bar: negative values drop below the zero baseline', () => {
-        const g = buildChart({ type: 'bar', categories: ['A', 'B'], series: [{ label: 's', values: [50, -50] }] });
-        const baseY = g.yTicks.find((t) => t.value === 0).y;
-        // positive bar sits above the baseline, negative bar below it
-        expect(g.bars[0].y).toBeLessThan(baseY);
-        expect(g.bars[1].y).toBeGreaterThanOrEqual(baseY - 0.01);
-        expect(g.bars[1].value).toBe(-50);
-    });
-    it('stacked bars: same x per category, segment heights stack', () => {
-        const g = buildChart({
-            type: 'bar',
-            stacked: true,
-            categories: ['A'],
-            series: [
-                { label: 'x', values: [10] },
-                { label: 'y', values: [20] },
-            ],
-        });
-        expect(g.bars).toHaveLength(2);
-        // both segments share the same x (stacked, not grouped)
-        expect(g.bars[0].x).toBe(g.bars[1].x);
-    });
-    it('combo + dual axis: bar on left, line on right axis', () => {
-        const g = buildChart({
-            type: 'bar',
-            categories: ['A', 'B'],
-            series: [
-                { label: 'rev', values: [100, 200], type: 'bar', axis: 'left' },
-                { label: 'pct', values: [0.4, 0.9], type: 'line', axis: 'right' },
-            ],
-        });
-        expect(g.bars.length).toBe(2);
-        expect(g.lines.length).toBe(1);
-        expect(g.hasRightAxis).toBe(true);
-        expect(g.y2Ticks.length).toBeGreaterThan(1);
-    });
-    it('line: a path through every point, area closes when type=area', () => {
-        const line = buildChart({ type: 'line', categories: ['A', 'B', 'C'], series: [{ label: 's', values: [1, 2, 3] }] });
-        expect(line.lines[0].path.startsWith('M')).toBe(true);
-        expect(line.lines[0].areaPath).toBe('');
-        expect(line.lines[0].label).toBe('s');
-        expect(line.lines[0].points.map((p) => p.value)).toEqual([1, 2, 3]);
-        const area = buildChart({ type: 'area', categories: ['A', 'B'], series: [{ label: 's', values: [1, 2] }] });
-        expect(area.lines[0].areaPath.endsWith('Z')).toBe(true);
-    });
-    it('line: null / NaN values break the line (gap) and drop the dot', () => {
-        const g = buildChart({ type: 'line', categories: ['A', 'B', 'C', 'D'], series: [{ label: 's', values: [1, NaN, 3, 4] }] });
-        const pts = g.lines[0].points;
-        expect(pts.map((p) => p.defined)).toEqual([true, false, true, true]);
-        // a gap => a second "move" command, so the path has two M's
-        expect((g.lines[0].path.match(/M/g) ?? []).length).toBe(2);
-    });
-    it('area: a gap splits the fill into separate closed polygons', () => {
-        const g = buildChart({ type: 'area', categories: ['A', 'B', 'C', 'D'], series: [{ label: 's', values: [2, NaN, 4, 5] }] });
-        expect((g.lines[0].areaPath.match(/Z/g) ?? []).length).toBe(2);
-    });
-    it('axis titles reserve gutter space', () => {
-        const plain = buildChart({ type: 'bar', categories: ['A'], series: [{ label: 's', values: [1] }] });
-        const titled = buildChart({ type: 'bar', categories: ['A'], series: [{ label: 's', values: [1] }], yAxisTitle: 'Revenue', xAxisTitle: 'Region' });
-        expect(titled.plot.x).toBeGreaterThan(plain.plot.x); // left gutter wider for the y title
-        expect(titled.plot.h).toBeLessThan(plain.plot.h); // bottom gutter wider for the x title
-    });
-    it('pie: slice percents sum to ~100, slices have a centroid', () => {
-        const g = buildChart({ type: 'pie', categories: ['A', 'B', 'C'], series: [{ label: 's', values: [1, 1, 2] }] });
-        expect(g.slices).toHaveLength(3);
-        expect(g.slices.reduce((a, s) => a + s.percent, 0)).toBeCloseTo(100);
-        expect(g.slices[2].percent).toBeCloseTo(50);
-        expect(Number.isFinite(g.slices[0].cx)).toBe(true);
-        expect(g.donut).toBeNull();
-    });
-    it('donut: innerRadius produces a centre with the total', () => {
-        const g = buildChart({ type: 'pie', innerRadius: 0.6, categories: ['A', 'B'], series: [{ label: 's', values: [3, 7] }] });
-        expect(g.donut).not.toBeNull();
-        expect(g.donut.total).toBe(10);
-    });
-    it('rotates x labels when there are many / long categories', () => {
-        const many = buildChart({ type: 'bar', categories: Array.from({ length: 12 }, (_, i) => `Cat ${i}`), series: [{ label: 's', values: Array(12).fill(1) }] });
-        expect(many.xLabelRotated).toBe(true);
-        const few = buildChart({ type: 'bar', categories: ['A', 'B'], series: [{ label: 's', values: [1, 2] }] });
-        expect(few.xLabelRotated).toBe(false);
-    });
-    it('assigns palette colors when series omit color', () => {
-        const g = buildChart({ type: 'bar', categories: ['A'], series: [{ label: 'x', values: [1] }, { label: 'y', values: [2] }] });
-        expect(g.legend[0].color).not.toBe(g.legend[1].color);
-    });
-    it('reference line: a horizontal line at the value, included in the domain', () => {
-        const g = buildChart({
-            type: 'bar',
-            categories: ['A', 'B'],
-            series: [{ label: 's', values: [10, 20] }],
-            referenceLines: [{ value: 25, label: 'Target' }],
-        });
-        expect(g.referenceLines).toHaveLength(1);
-        expect(g.referenceLines[0].label).toBe('Target');
-        // domain stretched to include the reference value above the data max
-        expect(g.yTicks[g.yTicks.length - 1].value).toBeGreaterThanOrEqual(25);
-    });
-    it('stacked100: each category fills the full plot height (0..100 axis)', () => {
-        const g = buildChart({
-            type: 'bar',
-            stacked100: true,
-            categories: ['A'],
-            series: [
-                { label: 'x', values: [1] },
-                { label: 'y', values: [3] },
-            ],
-        });
-        expect(g.yTicks.map((t) => t.value)).toContain(100);
-        // two stacked segments whose heights sum to ~ the plot height
-        const sum = g.bars.reduce((a, b) => a + b.h, 0);
-        expect(sum).toBeCloseTo(g.plot.h, 0);
-        // values stay the originals (not the normalized %)
-        expect(g.bars.map((b) => b.value).sort()).toEqual([1, 3]);
-    });
-    it('stacked100 area: the top series reaches the 100% line, not the raw total', () => {
-        const g = buildChart({
-            type: 'area',
-            stacked100: true,
-            categories: ['A', 'B'],
-            series: [
-                { label: 'x', values: [200, 600] },
-                { label: 'y', values: [600, 200] },
-            ],
-        });
-        const y100 = g.yTicks.find((t) => t.value === 100).y;
-        const y0 = g.yTicks.find((t) => t.value === 0).y;
-        // top of the (cumulative) second area sits at the 100% gridline for every category
-        const topPts = g.lines[1].points;
-        for (const p of topPts)
-            expect(p.y).toBeCloseTo(y100, 0);
-        // and the stack stays within the plot (never below the 0 baseline)
-        for (const l of g.lines)
-            for (const p of l.points)
-                expect(p.y).toBeGreaterThanOrEqual(y100 - 0.5);
-        expect(y100).toBeLessThan(y0); // 100% is above 0 on screen
-    });
-    it('scatter: one dot per point, bubble radius scales with r', () => {
-        const g = buildChart({
-            type: 'scatter',
-            categories: [],
-            series: [
-                { label: 'pts', values: [], points: [{ x: 1, y: 1, r: 1 }, { x: 5, y: 8, r: 10 }, { x: 3, y: 4, r: 5 }] },
-            ],
-        });
-        expect(g.scatterPoints).toHaveLength(3);
-        const byR = [...g.scatterPoints].sort((a, b) => a.r - b.r);
-        expect(byR[0].r).toBeLessThan(byR[2].r); // bigger r => bigger bubble
-        expect(g.xTicks.length).toBeGreaterThan(1);
-        expect(g.yTicks.length).toBeGreaterThan(1);
-    });
-    it('horizontal bars: bars grow along x, categories run down the y axis', () => {
-        const g = buildChart({
-            type: 'bar',
-            orientation: 'horizontal',
-            categories: ['A', 'B'],
-            series: [{ label: 's', values: [10, 30] }],
-            width: 400,
-            height: 200,
-        });
-        expect(g.orientation).toBe('horizontal');
-        expect(g.bars).toHaveLength(2);
-        // bigger value => wider bar (grows along x)
-        expect(g.bars[1].w).toBeGreaterThan(g.bars[0].w);
-        // bars share a left baseline x (value 0), differ in y (one per category band)
-        expect(g.bars[0].x).toBeCloseTo(g.bars[1].x, 1);
-        expect(g.bars[0].y).not.toBe(g.bars[1].y);
-        // category labels live on the left axis, value ticks along the bottom
-        expect(g.catTicks.map((t) => t.label)).toEqual(['A', 'B']);
-        expect(g.valueTicks.length).toBeGreaterThan(1);
-    });
-    it('horizontal bars: a reference line becomes a vertical line', () => {
-        const g = buildChart({
-            type: 'bar',
-            orientation: 'horizontal',
-            categories: ['A'],
-            series: [{ label: 's', values: [10] }],
-            referenceLines: [{ value: 20, label: 'Goal' }],
-        });
-        expect(g.referenceLines).toHaveLength(0);
-        expect(g.referenceLinesV).toHaveLength(1);
-        expect(g.referenceLinesV[0].label).toBe('Goal');
-        expect(Number.isFinite(g.referenceLinesV[0].x)).toBe(true);
-    });
-    it('horizontal falls back to vertical when a series is not a bar (combo)', () => {
-        const g = buildChart({
-            type: 'bar',
-            orientation: 'horizontal',
-            categories: ['A', 'B'],
-            series: [
-                { label: 'bar', values: [1, 2] },
-                { label: 'line', values: [3, 4], type: 'line' },
-            ],
-        });
-        expect(g.orientation).toBe('vertical');
-    });
-    it('time axis: irregular date gaps map to proportional x positions', () => {
-        const g = buildChart({
-            type: 'line',
-            xType: 'time',
-            categories: ['2024-01-01', '2024-01-02', '2024-02-01'],
-            series: [{ label: 's', values: [1, 2, 3] }],
-        });
-        const xs = g.lines[0].points.map((p) => p.x);
-        // gap 1->2 (1 day) is far smaller than gap 2->3 (31 days)
-        expect(xs[1] - xs[0]).toBeLessThan(xs[2] - xs[1]);
-        expect(g.xLabelRotated).toBe(false);
-    });
-});
-describe('rowsToChartSpec', () => {
-    const rows = [
-        { region: 'EMEA', product: 'A', revenue: 100, cost: 60 },
-        { region: 'EMEA', product: 'B', revenue: 50, cost: 20 },
-        { region: 'APAC', product: 'A', revenue: 200, cost: 90 },
-    ];
-    it('groups by category and sums one value field', () => {
-        const spec = rowsToChartSpec(rows, { type: 'bar', category: 'region', value: 'revenue' });
-        expect(spec.categories).toEqual(['EMEA', 'APAC']);
-        expect(spec.series).toHaveLength(1);
-        expect(spec.series[0].values).toEqual([150, 200]);
-    });
-    it('multiple value fields => one series each', () => {
-        const spec = rowsToChartSpec(rows, { type: 'bar', category: 'region', value: ['revenue', 'cost'] });
-        expect(spec.series.map((s) => s.label)).toEqual(['revenue', 'cost']);
-        expect(spec.series[1].values).toEqual([80, 90]);
-    });
-    it('series field => pivot into one series per distinct value', () => {
-        const spec = rowsToChartSpec(rows, { type: 'bar', category: 'region', value: 'revenue', series: 'product' });
-        expect(spec.series.map((s) => s.label).sort()).toEqual(['A', 'B']);
-        const a = spec.series.find((s) => s.label === 'A');
-        // EMEA/A = 100, APAC/A = 200
-        expect(a.values).toEqual([100, 200]);
-    });
-    it('supports avg and count reducers', () => {
-        expect(rowsToChartSpec(rows, { type: 'bar', category: 'region', value: 'revenue', reduce: 'avg' }).series[0].values).toEqual([75, 200]);
-        expect(rowsToChartSpec(rows, { type: 'bar', category: 'region', value: 'revenue', reduce: 'count' }).series[0].values).toEqual([2, 1]);
-    });
-    it('sorts categories by total value descending', () => {
-        const spec = rowsToChartSpec(rows, { type: 'bar', category: 'region', value: 'revenue', sort: 'value-desc' });
-        // APAC (200) outranks EMEA (150)
-        expect(spec.categories).toEqual(['APAC', 'EMEA']);
-        expect(spec.series[0].values).toEqual([200, 150]);
-    });
-    it('topN buckets the remainder into an "Other" category', () => {
-        const many = [
-            { cat: 'A', v: 100 },
-            { cat: 'B', v: 50 },
-            { cat: 'C', v: 30 },
-            { cat: 'D', v: 20 },
-        ];
-        const spec = rowsToChartSpec(many, { type: 'bar', category: 'cat', value: 'v', topN: 2 });
-        expect(spec.categories).toEqual(['A', 'B', 'Other']);
-        // Other = C + D = 50
-        expect(spec.series[0].values).toEqual([100, 50, 50]);
-    });
-    it('stacked100 flag passes through to the spec', () => {
-        const spec = rowsToChartSpec(rows, { type: 'bar', category: 'region', value: ['revenue', 'cost'], stacked100: true });
-        expect(spec.stacked100).toBe(true);
-    });
-});

package/dist/clipboard.test.d.ts

@@ -1 +0,0 @@
-export {};