@heartlandone/vega 2.76.0 → 2.77.1

package/dist/collection/polyfill/d3/test/d3-integration.test.js

@@ -0,0 +1,137 @@
+/* eslint-disable @typescript-eslint/typedef */
+/**
+ * D3 Polyfill Integration Tests
+ *
+ * Cross-module integration tests verifying Vega chart usage patterns
+ * work correctly with the polyfill modules.
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+import { select, create } from '../d3-selection-polyfill';
+import { line, arc, pie } from '../d3-shape-polyfill';
+import { scaleLinear, scaleTime, scaleBand } from '../d3-scale-polyfill';
+import { min, max, extent, map } from '../d3-array-polyfill';
+import { timeParse } from '../d3-time-format-polyfill';
+// ─── Integration Tests (Vega Chart Patterns) ────────────────────────
+describe('D3 Polyfill Integration - Vega Chart Patterns', () => {
+  it('should work with SVG renderer setLayout pattern', () => {
+    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+    select(svg)
+      .attr('width', 300)
+      .attr('height', 200)
+      .attr('viewBox', [0, 0, 300, 200])
+      .property('style', 'display:block;max-width:100%;height:auto;')
+      .call(g => {
+      g.append('g').attr('class', 'vega-chart-draw-g').attr('transform', 'translate(10,10)');
+    })
+      .call(g => {
+      g.append('g').attr('class', 'vega-chart-legend-g').attr('transform', 'translate(3,2)');
+    });
+    expect(svg.getAttribute('width')).toBe('300');
+    expect(svg.querySelector('.vega-chart-draw-g')).not.toBeNull();
+    expect(svg.querySelector('.vega-chart-legend-g')).not.toBeNull();
+  });
+  it('should work with line path drawing pattern', () => {
+    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+    const drawG = document.createElementNS('http://www.w3.org/2000/svg', 'g');
+    drawG.setAttribute('class', 'vega-chart-draw-g');
+    svg.appendChild(drawG);
+    const positions = [
+      { x: 0, y: 100 },
+      { x: 50, y: 50 },
+      { x: 100, y: 75 },
+    ];
+    select(svg)
+      .select('.vega-chart-draw-g')
+      .append('path')
+      .attr('class', 'vega-chart-line-path')
+      .datum(positions)
+      .attr('fill', 'none')
+      .attr('stroke', '#1362E2')
+      .attr('d', line()
+      .x(p => p.x)
+      .y(p => p.y));
+    const path = svg.querySelector('.vega-chart-line-path');
+    expect(path).not.toBeNull();
+    expect(path === null || path === void 0 ? void 0 : path.getAttribute('d')).toBe('M0,100L50,50L100,75');
+  });
+  it('should work with pie chart arc path pattern', () => {
+    const data = [
+      { name: 'Slice1', value: 40 },
+      { name: 'Slice2', value: 60 },
+    ];
+    const arcs = pie().value(d => d.value)(data);
+    expect(arcs.length).toBe(2);
+    // Generate arc paths
+    for (const arcItem of arcs) {
+      const path = arc().innerRadius(0).outerRadius(100)(arcItem);
+      expect(path.length).toBeGreaterThan(0);
+      expect(path).toContain('A');
+    }
+  });
+  it('should work with format-time-positions pattern', () => {
+    const parseDate = timeParse('%Y-%m-%d');
+    const dateStringArray = [
+      { x: '2021-01-01', y: 10 },
+      { x: '2022-01-01', y: 20 },
+    ];
+    const result = map(dateStringArray, d => ({
+      x: typeof d.x === 'string' ? parseDate(d.x) : d.x,
+      y: d.y,
+    }));
+    expect(result[0].x instanceof Date).toBe(true);
+    expect(result[0].x.getFullYear()).toBe(2021);
+    expect(result[1].y).toBe(20);
+  });
+  it('should work with y-axis-input-processor pattern', () => {
+    const yData = [10, 20, 30, 0];
+    const maxY = max(yData);
+    const minY = min(yData);
+    expect(maxY).toBe(30);
+    expect(minY).toBe(0);
+    const scale = scaleLinear().domain([minY, maxY]);
+    const ticks = scale.ticks(4);
+    expect(ticks.length).toBeGreaterThan(0);
+    const [minTick, maxTick] = extent(ticks);
+    expect(minTick).toBeLessThanOrEqual(minY);
+    expect(maxTick).toBeGreaterThanOrEqual(maxY);
+  });
+  it('should work with x-axis-input-processor scaleTime pattern', () => {
+    const dates = [new Date(2020, 0, 1), new Date(2022, 0, 1)];
+    const [minDate, maxDate] = extent(dates);
+    const scale = scaleTime().domain([minDate, maxDate]).range([0, 400]);
+    expect(scale(minDate)).toBe(0);
+    expect(scale(maxDate)).toBe(400);
+  });
+  it('should work with x-axis-input-processor scaleBand pattern', () => {
+    const categories = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'];
+    const scale = scaleBand(categories, [0, 500]).padding(0.1);
+    expect(scale('Mon')).toBeDefined();
+    expect(scale.bandwidth()).toBeGreaterThan(0);
+  });
+  it('should work with canvas-renderer drawLinePath pattern', () => {
+    const positions = [
+      { x: 0, y: 100 },
+      { x: 50, y: 50 },
+    ];
+    const pathNode = create('svg:path')
+      .datum(positions)
+      .attr('d', line()
+      .x(p => p.x)
+      .y(p => p.y))
+      .node();
+    expect(pathNode === null || pathNode === void 0 ? void 0 : pathNode.getAttribute('d')).toBe('M0,100L50,50');
+  });
+  it('should work with clear() pattern', () => {
+    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+    const drawG = document.createElementNS('http://www.w3.org/2000/svg', 'g');
+    drawG.setAttribute('class', 'vega-chart-draw-g');
+    const legendG = document.createElementNS('http://www.w3.org/2000/svg', 'g');
+    legendG.setAttribute('class', 'vega-chart-legend-g');
+    svg.appendChild(drawG);
+    svg.appendChild(legendG);
+    select(svg).selectAll('.vega-chart-draw-g').remove();
+    select(svg).selectAll('.vega-chart-legend-g').remove();
+    expect(svg.childNodes.length).toBe(0);
+  });
+});

package/dist/collection/polyfill/d3/test/d3-scale-polyfill.test.js

@@ -0,0 +1,382 @@
+/* eslint-disable @typescript-eslint/typedef */
+/**
+ * D3 Scale Polyfill Tests
+ *
+ * Tests for the d3-scale-polyfill module: scaleLinear(), scaleTime(), and scaleBand().
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+import { scaleLinear, scaleTime, scaleBand } from '../d3-scale-polyfill';
+// ─── Scale Tests ────────────────────────────────────────────────────
+describe('D3 Scale Polyfill', () => {
+  describe('scaleLinear()', () => {
+    it('should map domain values to range values', () => {
+      const scale = scaleLinear().domain([0, 100]).range([0, 200]);
+      expect(scale(0)).toBe(0);
+      expect(scale(50)).toBe(100);
+      expect(scale(100)).toBe(200);
+    });
+    it('should handle inverse range', () => {
+      const scale = scaleLinear().domain([0, 100]).range([200, 0]);
+      expect(scale(0)).toBe(200);
+      expect(scale(100)).toBe(0);
+    });
+    it('should generate ticks', () => {
+      const scale = scaleLinear().domain([0, 100]);
+      const ticks = scale.ticks(5);
+      expect(ticks.length).toBeGreaterThan(0);
+      expect(ticks[0]).toBeGreaterThanOrEqual(0);
+      expect(ticks[ticks.length - 1]).toBeLessThanOrEqual(100);
+    });
+    it('should return domain and range', () => {
+      const scale = scaleLinear().domain([10, 50]).range([0, 300]);
+      expect(scale.domain()).toEqual([10, 50]);
+      expect(scale.range()).toEqual([0, 300]);
+    });
+  });
+  describe('scaleTime()', () => {
+    it('should map Date domain to numeric range', () => {
+      const d0 = new Date(2020, 0, 1);
+      const d1 = new Date(2020, 11, 31);
+      const scale = scaleTime().domain([d0, d1]).range([0, 100]);
+      expect(scale(d0)).toBe(0);
+      expect(scale(d1)).toBe(100);
+    });
+    it('should have tickFormat function', () => {
+      const scale = scaleTime();
+      expect(typeof scale.tickFormat).toBe('function');
+    });
+  });
+  describe('scaleBand()', () => {
+    it('should map discrete domain to band positions', () => {
+      const scale = scaleBand(['Mon', 'Tue', 'Wed'], [0, 300]);
+      const monPosition = scale('Mon');
+      const tuePosition = scale('Tue');
+      expect(monPosition).toBeDefined();
+      expect(tuePosition).toBeDefined();
+      expect(tuePosition).toBeGreaterThan(monPosition);
+    });
+    it('should return undefined for unknown domain values', () => {
+      const scale = scaleBand(['A', 'B'], [0, 100]);
+      expect(scale('Z')).toBeUndefined();
+    });
+    it('should calculate bandwidth', () => {
+      const scale = scaleBand(['A', 'B', 'C'], [0, 300]);
+      expect(scale.bandwidth()).toBe(100);
+    });
+    it('should apply padding', () => {
+      const scale = scaleBand(['A', 'B'], [0, 100]).padding(0.5);
+      expect(scale.bandwidth()).toBe(20);
+    });
+  });
+});
+// ─── Additional Scale Coverage ──────────────────────────────────────
+describe('D3 Scale Polyfill - Additional Coverage', () => {
+  describe('scaleLinear() - copy()', () => {
+    it('should create an independent copy of the scale', () => {
+      // Covers LinearScale.copy() (lines 108-111) and scaleLinearFromInstance (lines 171-194)
+      const original = scaleLinear().domain([0, 100]).range([0, 500]);
+      const copied = original.copy();
+      expect(copied(50)).toBe(250);
+      // Modify original, copy should be unaffected
+      original.domain([0, 200]);
+      expect(copied(50)).toBe(250);
+      expect(original(50)).toBe(125);
+    });
+    it('should allow chaining domain/range on copied scale', () => {
+      const original = scaleLinear().domain([0, 100]).range([0, 500]);
+      const copied = original.copy();
+      // Use domain setter on copied scale (scaleLinearFromInstance domain setter)
+      copied.domain([0, 50]);
+      expect(copied(25)).toBe(250);
+      // Use range setter on copied scale (scaleLinearFromInstance range setter)
+      copied.range([0, 100]);
+      expect(copied(25)).toBe(50);
+    });
+    it('should support get methods on copied scale', () => {
+      const original = scaleLinear().domain([10, 90]).range([0, 400]);
+      const copied = original.copy();
+      // Use domain/range get methods on copied scale (from copy)
+      expect(copied.domain()).toEqual([10, 90]);
+      expect(copied.range()).toEqual([0, 400]);
+    });
+    it('should support ticks and tickFormat on copied scale', () => {
+      const original = scaleLinear().domain([0, 100]).range([0, 500]);
+      const copied = original.copy();
+      // ticks on copied scale (scaleLinearFromInstance ticks)
+      const ticks = copied.ticks(5);
+      expect(ticks.length).toBeGreaterThan(0);
+      // tickFormat on copied scale (scaleLinearFromInstance tickFormat)
+      const formatter = copied.tickFormat();
+      expect(formatter(42)).toBe('42');
+    });
+    it('should support nested copy', () => {
+      const original = scaleLinear().domain([0, 100]).range([0, 500]);
+      const copy1 = original.copy();
+      const copy2 = copy1.copy();
+      expect(copy2(50)).toBe(250);
+    });
+    it('should return 0 bandwidth for copied linear scale', () => {
+      const original = scaleLinear().domain([0, 100]).range([0, 500]);
+      const copied = original.copy();
+      expect(copied.bandwidth()).toBe(0);
+    });
+  });
+  describe('scaleLinear() - tickFormat()', () => {
+    it('should return a function that converts values to strings', () => {
+      // Covers LinearScale.tickFormat() (lines 159-160)
+      const scale = scaleLinear().domain([0, 100]);
+      const formatter = scale.tickFormat();
+      expect(formatter(42)).toBe('42');
+      // domain [0,100] with step=10 yields precision=0, so decimals are truncated
+      expect(formatter(3.14)).toBe('3');
+    });
+  });
+  describe('scaleTime() - ticks and tickFormat', () => {
+    it('should return ticks as time values', () => {
+      // Covers TimeScale.ticks() (lines 255-256)
+      const d0 = new Date(2020, 0, 1);
+      const d1 = new Date(2020, 11, 31);
+      const scale = scaleTime().domain([d0, d1]).range([0, 100]);
+      const ticks = scale.ticks();
+      // ~365 day domain with count=10 defaults to monthly ticks
+      expect(ticks.length).toBeGreaterThanOrEqual(2);
+      const firstTick = ticks[0];
+      const lastTick = ticks[ticks.length - 1];
+      expect(firstTick.getTime()).toBeGreaterThanOrEqual(d0.getTime());
+      expect(lastTick.getTime()).toBeLessThanOrEqual(d1.getTime());
+    });
+    it('should generate second-based ticks for small time', () => {
+      const start = new Date('2020-01-01T00:00:00.000Z');
+      const end = new Date('2020-01-01T00:00:10.000Z');
+      const ticks = scaleTime().domain([start, end]).ticks(10);
+      expect(ticks.length).toBeGreaterThanOrEqual(2);
+    });
+    it('should generate minute-based ticks for medium time', () => {
+      const start = new Date('2020-01-01T00:00:00.000Z');
+      const end = new Date('2020-01-01T00:10:00.000Z');
+      const ticks = scaleTime().domain([start, end]).ticks(10);
+      expect(ticks.length).toBeGreaterThanOrEqual(2);
+    });
+    it('should generate hour-based ticks for hourly time', () => {
+      const start = new Date('2020-01-01T00:00:00.000Z');
+      const end = new Date('2020-01-01T12:00:00.000Z');
+      const ticks = scaleTime().domain([start, end]).ticks(12);
+      expect(ticks.length).toBeGreaterThanOrEqual(2);
+    });
+    it('should generate week-based ticks for weekly time', () => {
+      const start = new Date('2020-01-05T00:00:00.000Z'); // Sunday
+      const end = new Date('2020-02-02T00:00:00.000Z');
+      const ticks = scaleTime().domain([start, end]).ticks(4);
+      expect(ticks.length).toBeGreaterThanOrEqual(2);
+    });
+    it('should generate year-based ticks for very large time', () => {
+      const start = new Date('1900-01-01T00:00:00.000Z');
+      const end = new Date('2000-01-01T00:00:00.000Z');
+      const ticks = scaleTime().domain([start, end]).ticks(10);
+      expect(ticks.length).toBeGreaterThanOrEqual(2);
+    });
+    it('should return tickFormat that formats dates', () => {
+      // Covers TimeScale.tickFormat() (lines 265-266)
+      const scale = scaleTime();
+      const formatter = scale.tickFormat();
+      const date = new Date(2023, 5, 15);
+      const result = formatter(date);
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+    it('should use tickFormat to handle non-Date values', () => {
+      const scale = scaleTime();
+      const formatter = scale.tickFormat();
+      expect(formatter(42)).toBe('42');
+    });
+    it('should return domain and range for scaleTime', () => {
+      // Covers scaleTime domain/range getter methods (lines 293-294)
+      const d0 = new Date(2020, 0, 1);
+      const d1 = new Date(2020, 11, 31);
+      const scale = scaleTime().domain([d0, d1]).range([0, 400]);
+      const domain = scale.domain();
+      expect(domain.length).toBe(2);
+      const range = scale.range();
+      expect(range).toEqual([0, 400]);
+    });
+    it('should return a single tick when duration is zero', () => {
+      const d0 = new Date('2020-01-01T00:00:00.000Z');
+      const ticks = scaleTime().domain([d0, d0]).ticks();
+      expect(ticks).toHaveLength(1);
+      expect(ticks[0].getTime()).toBe(d0.getTime());
+    });
+    it('should support copy() for scaleTime', () => {
+      const original = scaleTime().domain([
+        new Date('2020-01-01T00:00:00.000Z'),
+        new Date('2020-02-01T00:00:00.000Z'),
+      ]);
+      const copied = original.copy();
+      expect(typeof copied).toBe('function');
+      expect(typeof copied.tickFormat).toBe('function');
+    });
+    it('should choose week interval for ~10-week domains', () => {
+      const start = new Date('2020-01-05T00:00:00.000Z'); // Sunday boundary
+      const end = new Date('2020-03-15T00:00:00.000Z'); // ~10 weeks later
+      const ticks = scaleTime().domain([start, end]).ticks();
+      expect(ticks.length).toBeGreaterThanOrEqual(2);
+      // After ceiling to next Sunday, all ticks should land on Sunday (day 0)
+      expect(ticks.every(d => d.getUTCDay() === 0)).toBe(true);
+    });
+  });
+  describe('scaleBand() - additional coverage', () => {
+    it('should return positions for all domain values via call()', () => {
+      // Covers BandScale.call positions (lines 347-362)
+      const scale = scaleBand(['A', 'B', 'C', 'D'], [0, 400]);
+      const positionA = scale('A');
+      const positionB = scale('B');
+      const positionC = scale('C');
+      const positionD = scale('D');
+      expect(positionA).toBeDefined();
+      expect(positionB).toBeDefined();
+      expect(positionC).toBeDefined();
+      expect(positionD).toBeDefined();
+      expect(positionA).toBeLessThan(positionB);
+      expect(positionB).toBeLessThan(positionC);
+      expect(positionC).toBeLessThan(positionD);
+    });
+    it('should return 0 bandwidth for empty domain', () => {
+      // Covers BandScale.bandwidth empty domain (line 396)
+      const scale = scaleBand([], [0, 400]);
+      expect(scale.bandwidth()).toBe(0);
+    });
+    it('should support domain setter on scaleBand', () => {
+      // Covers scaleBand domain setter (lines 415-418)
+      const scale = scaleBand([], [0, 300]);
+      scale.domain(['X', 'Y', 'Z']);
+      expect(scale('X')).toBeDefined();
+      expect(scale('Y')).toBeDefined();
+      expect(scale.bandwidth()).toBeGreaterThan(0);
+    });
+    it('should support range setter on scaleBand', () => {
+      // Covers scaleBand range setter (lines 420-423)
+      const scale = scaleBand(['A', 'B'], [0, 100]);
+      scale.range([0, 200]);
+      expect(scale.bandwidth()).toBe(100);
+    });
+    it('should support domain and range get methods on scaleBand', () => {
+      const scale = scaleBand(['A', 'B'], [0, 100]);
+      expect(scale.domain()).toEqual(['A', 'B']);
+      expect(scale.range()).toEqual([0, 100]);
+    });
+    it('should handle padding with positions', () => {
+      const scale = scaleBand(['A', 'B'], [0, 100]).padding(0.2);
+      const positionA = scale('A');
+      const positionB = scale('B');
+      expect(positionA).toBeDefined();
+      expect(positionB).toBeDefined();
+      expect(positionA).toBeLessThan(positionB);
+    });
+  });
+});
+// ─── Scale Branch Edge Cases ────────────────────────────────────────
+describe('D3 Scale Polyfill - Branch Edge Cases', () => {
+  describe('LinearScale edge cases', () => {
+    it('should return range midpoint when domain values are equal', () => {
+      const scale = scaleLinear().domain([50, 50]).range([100, 300]);
+      expect(scale(50)).toBe(200);
+    });
+    it('should return domain start when step is 0 or non-finite', () => {
+      const scale = scaleLinear().domain([5, 5]).range([0, 100]);
+      const ticks = scale.ticks(5);
+      expect(ticks).toEqual([5]);
+    });
+    it('should return domain start when step is non-finite (NaN)', () => {
+      const scale = scaleLinear().domain([0, 0]).range([0, 100]);
+      const ticks = scale.ticks(0);
+      expect(ticks).toEqual([0]);
+    });
+    it('should use default tick count when calling ticks() without arguments', () => {
+      // Cover default-arg branch: ticks(count: number = 10) — use default
+      const scale = scaleLinear().domain([0, 100]).range([0, 500]);
+      const ticks = scale.ticks();
+      expect(ticks.length).toBeGreaterThan(0);
+    });
+    it('should handle reversed domain where stop < start', () => {
+      // Cover tickStep stop < start branch — produces negative step
+      const scale = scaleLinear().domain([100, 0]).range([0, 500]);
+      const ticks = scale.ticks(5);
+      // With reversed domain, ticks may be empty due to loop direction
+      expect(Array.isArray(ticks)).toBe(true);
+    });
+  });
+  describe('tickStep branches', () => {
+    it('should multiply step by 10 when error >= 7.5', () => {
+      // Covers tickStep error >= 7.5 branch (line 129)
+      const scale = scaleLinear().domain([0, 80]).range([0, 100]);
+      const ticks = scale.ticks(1);
+      expect(ticks.length).toBeGreaterThanOrEqual(1);
+    });
+    it('should multiply step by 5 when error >= 3.5 but < 7.5', () => {
+      // Covers tickStep error >= 3.5 branch (line 131)
+      const scale = scaleLinear().domain([0, 50]).range([0, 100]);
+      const ticks = scale.ticks(1);
+      expect(ticks.length).toBeGreaterThanOrEqual(1);
+    });
+    it('should not multiply step when error < 1.5', () => {
+      // Covers tickStep error < 1.5 branch (line 131 else)
+      // Need: span/count/step results in error < 1.5
+      // span=10, count=10 → raw step=1, error=10/10/1=1 < 1.5
+      const scale = scaleLinear().domain([0, 10]).range([0, 100]);
+      const ticks = scale.ticks(10);
+      expect(ticks.length).toBeGreaterThanOrEqual(1);
+      // Step should be 1 (not multiplied)
+      if (ticks.length > 1) {
+        expect(ticks[1] - ticks[0]).toBe(1);
+      }
+    });
+  });
+  describe('scaleTime domain/range getter methods', () => {
+    it('should get domain and range independently', () => {
+      // Cover scaleTime get methods (lines 318-319)
+      const d0 = new Date(2020, 0, 1);
+      const d1 = new Date(2020, 11, 31);
+      const scale = scaleTime().domain([d0, d1]).range([50, 250]);
+      const domain = scale.domain();
+      expect(domain.length).toBe(2);
+      const range = scale.range();
+      expect(range).toEqual([50, 250]);
+    });
+    it('should handle numeric value (non-Date) in scaleTime', () => {
+      // Cover TimeScale.call non-Date branch (line 214)
+      const d0 = new Date(2020, 0, 1);
+      const d1 = new Date(2020, 11, 31);
+      const scale = scaleTime().domain([d0, d1]).range([0, 100]);
+      const midTimestamp = (d0.getTime() + d1.getTime()) / 2;
+      expect(scale(midTimestamp)).toBeCloseTo(50, 0);
+    });
+    it('should return range start when time domain values are equal', () => {
+      // Cover TimeScale.call t1 === t0 branch (line 219)
+      const sameDate = new Date(2020, 6, 1);
+      const scale = scaleTime().domain([sameDate, sameDate]).range([0, 100]);
+      expect(scale(sameDate)).toBe(0);
+    });
+  });
+  describe('scaleBand no-argument constructor paths', () => {
+    it('should create scaleBand without domain or range arguments', () => {
+      // Cover BandScale constructor when domain/range are undefined (lines 318-319 false branches)
+      const scale = scaleBand();
+      expect(scale.domain()).toEqual([]);
+      expect(scale.range()).toEqual([0, 1]);
+    });
+    it('should create scaleBand with domain only', () => {
+      const scale = scaleBand(['A', 'B']);
+      expect(scale.domain()).toEqual(['A', 'B']);
+      expect(scale.range()).toEqual([0, 1]);
+    });
+  });
+  describe('scaleLinear domain/range getter methods through scaleLinearFromInstance', () => {
+    it('should get domain from copied scale (scaleLinearFromInstance getter)', () => {
+      // Covers line 214-219 (scaleLinearFromInstance domain/range getter branches)
+      const original = scaleLinear().domain([5, 95]).range([10, 490]);
+      const copied = original.copy();
+      expect(copied.domain()).toEqual([5, 95]);
+      expect(copied.range()).toEqual([10, 490]);
+    });
+  });
+});