@heartlandone/vega 2.79.0 → 2.80.0

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

@@ -1,382 +0,0 @@
-/* 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]);
-    });
-  });
-});

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

@@ -1,239 +0,0 @@
-/* eslint-disable @typescript-eslint/typedef */
-/**
- * D3 Selection Polyfill Tests
- *
- * Tests for the d3-selection-polyfill module: select() and create() functions.
- *
- * @see VD-5022 - [Zero Dependencies] remove d3 dependency
- */
-import { select, create } from '../d3-selection-polyfill';
-// ─── Selection Tests ────────────────────────────────────────────────
-describe('D3 Selection Polyfill', () => {
-  it('should wrap a DOM element with select()', () => {
-    const el = document.createElement('div');
-    const selection = select(el);
-    expect(selection.node()).toBe(el);
-  });
-  it('should set attributes with attr()', () => {
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const selection = select(el);
-    selection.attr('width', 300).attr('height', 200);
-    expect(el.getAttribute('width')).toBe('300');
-    expect(el.getAttribute('height')).toBe('200');
-  });
-  it('should set viewBox with array value', () => {
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    select(el).attr('viewBox', [0, 0, 300, 200]);
-    expect(el.getAttribute('viewBox')).toBe('0,0,300,200');
-  });
-  it('should set properties with property()', () => {
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    select(el).property('__data__', { test: true });
-    expect(el['__data__']).toEqual({ test: true });
-  });
-  it('should set text content with text()', () => {
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'text');
-    select(el).text('hello');
-    expect(el.textContent).toBe('hello');
-  });
-  it('should select child elements', () => {
-    const parent = document.createElement('div');
-    const child = document.createElement('span');
-    child.className = 'test';
-    parent.appendChild(child);
-    const selection = select(parent).select('.test');
-    expect(selection.node()).toBe(child);
-  });
-  it('should selectAll matching elements', () => {
-    const parent = document.createElement('div');
-    const child1 = document.createElement('span');
-    const child2 = document.createElement('span');
-    child1.className = 'item';
-    child2.className = 'item';
-    parent.appendChild(child1);
-    parent.appendChild(child2);
-    const nodes = select(parent).selectAll('.item').nodes();
-    expect(nodes.length).toBe(2);
-  });
-  it('should append child elements', () => {
-    var _a;
-    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const g = select(svg).append('g');
-    expect((_a = g.node()) === null || _a === void 0 ? void 0 : _a.tagName).toBe('g');
-    expect(svg.childNodes.length).toBe(1);
-  });
-  it('should append with factory function', () => {
-    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const circle = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
-    select(svg).append(() => circle);
-    expect(svg.childNodes[0]).toBe(circle);
-  });
-  it('should bind datum with datum()', () => {
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-    const data = { startAngle: 0, endAngle: Math.PI };
-    const selection = select(el).datum(data);
-    expect(selection.node()).toBe(el);
-  });
-  it('should support attr with function value using datum', () => {
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-    const data = { name: 'test-item' };
-    select(el)
-      .datum(data)
-      .attr('data-name', (d) => d.name);
-    expect(el.getAttribute('data-name')).toBe('test-item');
-  });
-  it('should call() a function with the selection', () => {
-    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const fn = jest.fn();
-    const selection = select(svg);
-    selection.call(fn);
-    expect(fn).toHaveBeenCalledWith(selection);
-  });
-  it('should iterate with each()', () => {
-    const parent = document.createElement('div');
-    parent.innerHTML = '<span class="item">a</span><span class="item">b</span>';
-    const elements = [];
-    select(parent)
-      .selectAll('.item')
-      .each(function () {
-      elements.push(this);
-    });
-    expect(elements.length).toBe(2);
-  });
-  it('should remove elements', () => {
-    const parent = document.createElement('div');
-    const child = document.createElement('span');
-    child.className = 'removable';
-    parent.appendChild(child);
-    select(parent).selectAll('.removable').remove();
-    expect(parent.childNodes.length).toBe(0);
-  });
-  it('should clone elements', () => {
-    const parent = document.createElement('div');
-    const child = document.createElement('span');
-    child.className = 'original';
-    parent.appendChild(child);
-    const cloned = select(parent).selectAll('.original').clone();
-    expect(parent.childNodes.length).toBe(2);
-    expect(cloned.nodes().length).toBe(1);
-  });
-  it('should handle transition() and duration() as no-ops', () => {
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-    select(el).transition(100).duration(100).attr('d', 'M0,0');
-    expect(el.getAttribute('d')).toBe('M0,0');
-  });
-  it('should create detached SVG elements with create()', () => {
-    const textSelection = create('svg:text');
-    const textNode = textSelection.node();
-    expect(textNode).not.toBeNull();
-    expect(textNode === null || textNode === void 0 ? void 0 : textNode.tagName).toBe('text');
-  });
-  it('should create circle elements with create()', () => {
-    const circleSelection = create('svg:circle');
-    circleSelection.attr('r', 5).attr('cx', 10).attr('cy', 20);
-    const circle = circleSelection.node();
-    expect(circle === null || circle === void 0 ? void 0 : circle.getAttribute('r')).toBe('5');
-    expect(circle === null || circle === void 0 ? void 0 : circle.getAttribute('cx')).toBe('10');
-    expect(circle === null || circle === void 0 ? void 0 : circle.getAttribute('cy')).toBe('20');
-  });
-  it('should create element with plain tag name (no namespace prefix)', () => {
-    var _a;
-    // Cover create() single-part path (line 284 branch)
-    const rectangleSelection = create('rect');
-    expect((_a = rectangleSelection.node()) === null || _a === void 0 ? void 0 : _a.tagName).toBe('rect');
-  });
-});
-// ─── Additional Selection Coverage ──────────────────────────────────
-describe('D3 Selection Polyfill - Additional Coverage', () => {
-  it('should return empty selection when select() is called on empty selection', () => {
-    const emptySelection = select(document.createElement('div'));
-    // Create a selection with no elements
-    const emptyChild = emptySelection.selectAll('.nonexistent');
-    // select on an empty selection (line 47)
-    const result = emptyChild.select('.anything');
-    expect(result.node()).toBeNull();
-  });
-  it('should return empty selection when selectAll() is called on empty selection', () => {
-    const emptySelection = select(document.createElement('div'));
-    const emptyChild = emptySelection.selectAll('.nonexistent');
-    // selectAll on an empty selection (line 64)
-    const result = emptyChild.selectAll('.anything');
-    expect(result.nodes()).toEqual([]);
-  });
-  it('should remove attribute when attr value is null', () => {
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    el.setAttribute('stroke', 'red');
-    expect(el.getAttribute('stroke')).toBe('red');
-    // attr with null value (line 109)
-    select(el).attr('stroke', null);
-    expect(el.getAttribute('stroke')).toBeNull();
-  });
-  it('should remove attribute when attr value is undefined', () => {
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    el.setAttribute('fill', 'blue');
-    expect(el.getAttribute('fill')).toBe('blue');
-    // attr with undefined value (line 110)
-    select(el).attr('fill', undefined);
-    expect(el.getAttribute('fill')).toBeNull();
-  });
-  it('should return null when getting attr on empty selection', () => {
-    const emptySelection = select(document.createElement('div')).selectAll('.nonexistent');
-    // attr getter on empty selection (line 118)
-    const result = emptySelection.attr('class');
-    expect(result).toBeNull();
-  });
-  it('should return attribute value when getting attr on non-empty selection', () => {
-    // Cover line 110 — el ? el.getAttribute(name) : null (truthy branch)
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    el.setAttribute('width', '300');
-    const result = select(el).attr('width');
-    expect(result).toBe('300');
-  });
-});
-// ─── Selection Branch Edge Cases ────────────────────────────────────
-describe('D3 Selection Polyfill - Branch Edge Cases', () => {
-  it('should handle select on empty selectAll result (no first element)', () => {
-    // Covers line 50 — select() when _groups[0] is undefined
-    const parent = document.createElement('div');
-    const selection = select(parent).selectAll('.missing');
-    const innerSelection = selection.select('.anything');
-    expect(innerSelection.node()).toBeNull();
-    expect(innerSelection.nodes()).toEqual([]);
-  });
-  it('should return empty array when select finds no match', () => {
-    // Covers line 50 — found ? [found] : [] (the [] branch)
-    const parent = document.createElement('div');
-    const selection = select(parent).select('.nonexistent');
-    expect(selection.node()).toBeNull();
-  });
-  it('should remove attribute when function accessor returns null', () => {
-    // Covers line 110 — resolvedValue is null from function
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
-    el.setAttribute('fill', 'red');
-    select(el).attr('fill', () => null);
-    expect(el.getAttribute('fill')).toBeNull();
-  });
-  it('should set attribute when function accessor returns non-null/undefined value', () => {
-    // Covers line 110 — the else branch (resolvedValue is not null/undefined)
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
-    select(el).attr('width', () => 42);
-    expect(el.getAttribute('width')).toBe('42');
-  });
-  it('should remove attribute when function accessor returns undefined', () => {
-    // Covers line 110 — resolvedValue === undefined from function
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
-    el.setAttribute('opacity', '0.5');
-    select(el).attr('opacity', () => undefined);
-    expect(el.getAttribute('opacity')).toBeNull();
-  });
-  it('should not throw when removing a detached element (no parentNode)', () => {
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    expect(() => select(el).remove()).not.toThrow();
-  });
-  it('should clone a detached element without inserting (no parentNode)', () => {
-    const el = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-    const cloned = select(el).clone();
-    expect(cloned.nodes().length).toBe(1);
-    expect(cloned.node()).not.toBeNull();
-  });
-});