@heartlandone/vega 2.76.0 → 2.77.1

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

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

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

@@ -0,0 +1,225 @@
+/* eslint-disable @typescript-eslint/typedef */
+/**
+ * D3 Shape Polyfill Tests
+ *
+ * Tests for the d3-shape-polyfill module: line(), arc(), and pie() factories.
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+import { line, arc, pie } from '../d3-shape-polyfill';
+// ─── Shape Tests ────────────────────────────────────────────────────
+describe('D3 Shape Polyfill', () => {
+  describe('line()', () => {
+    it('should generate SVG path data from data points', () => {
+      const positions = [
+        { x: 0, y: 0 },
+        { x: 10, y: 20 },
+        { x: 30, y: 15 },
+      ];
+      const pathData = line()
+        .x(d => d.x)
+        .y(d => d.y)(positions);
+      expect(pathData).toBe('M0,0L10,20L30,15');
+    });
+    it('should return empty string for empty array', () => {
+      const pathData = line()
+        .x(d => d.x)
+        .y(d => d.y)([]);
+      expect(pathData).toBe('');
+    });
+    it('should handle single data point', () => {
+      const pathData = line()
+        .x(d => d.x)
+        .y(d => d.y)([{ x: 5, y: 10 }]);
+      expect(pathData).toBe('M5,10');
+    });
+  });
+  describe('arc()', () => {
+    it('should generate SVG arc path data', () => {
+      const arcData = {
+        startAngle: 0,
+        endAngle: Math.PI / 2,
+        data: { name: 'test', value: 25 },
+        index: 0,
+        value: 25,
+        padAngle: 0,
+      };
+      const pathStr = arc().innerRadius(0).outerRadius(100)(arcData);
+      expect(pathStr).toContain('M');
+      expect(pathStr).toContain('A');
+      expect(pathStr).toContain('Z');
+    });
+    it('should generate donut arc with inner radius', () => {
+      const arcData = {
+        startAngle: 0,
+        endAngle: Math.PI,
+        data: { name: 'test', value: 50 },
+        index: 0,
+        value: 50,
+        padAngle: 0,
+      };
+      const pathStr = arc().innerRadius(50).outerRadius(100)(arcData);
+      expect(pathStr).toContain('M');
+      expect(pathStr).toContain('A');
+      // Donut arcs should have two arcs (outer and inner)
+      expect((pathStr.match(/A/g) || []).length).toBe(2);
+    });
+  });
+  describe('pie()', () => {
+    it('should generate pie arc data from values', () => {
+      const data = [
+        { name: 'A', value: 30 },
+        { name: 'B', value: 70 },
+      ];
+      const arcs = pie().value(d => d.value)(data);
+      expect(arcs.length).toBe(2);
+      // Sorted descending: B(70) gets startAngle=0, A(30) ends at 2π
+      expect(arcs[1].startAngle).toBe(0);
+      expect(arcs[0].data).toEqual({ name: 'A', value: 30 });
+      expect(arcs[1].data).toEqual({ name: 'B', value: 70 });
+      expect(arcs[0].endAngle).toBeCloseTo(2 * Math.PI, 5);
+    });
+    it('should set correct angles proportional to values', () => {
+      const data = [
+        { name: 'Equal1', value: 50 },
+        { name: 'Equal2', value: 50 },
+      ];
+      const arcs = pie().value(d => d.value)(data);
+      const angle1 = arcs[0].endAngle - arcs[0].startAngle;
+      const angle2 = arcs[1].endAngle - arcs[1].startAngle;
+      expect(angle1).toBeCloseTo(Math.PI, 5);
+      expect(angle2).toBeCloseTo(Math.PI, 5);
+    });
+    it('should handle single value', () => {
+      const data = [{ name: 'Only', value: 100 }];
+      const arcs = pie().value(d => d.value)(data);
+      expect(arcs[0].startAngle).toBe(0);
+      expect(arcs[0].endAngle).toBeCloseTo(2 * Math.PI, 5);
+    });
+  });
+});
+// ─── Additional Shape Coverage ──────────────────────────────────────
+describe('D3 Shape Polyfill - Additional Coverage', () => {
+  it('should generate path from callable line factory', () => {
+    const lineFn = line()
+      .x(d => d.x)
+      .y(d => d.y);
+    expect(typeof lineFn).toBe('function');
+    const result = lineFn([
+      { x: 0, y: 0 },
+      { x: 10, y: 20 },
+    ]);
+    expect(result).toBe('M0,0L10,20');
+  });
+  it('should use default x/y value extractor for objects with x/y properties', () => {
+    // Cover default _x and _y value extractor (lines 19-20) — object.x and object.y path
+    const pathData = line()([
+      { x: 5, y: 10 },
+      { x: 15, y: 25 },
+    ]);
+    expect(pathData).toBe('M5,10L15,25');
+  });
+  it('should use default pie value accessor when .value() not called', () => {
+    // Cover default _value accessor (line 218) — object.value path
+    const data = [{ value: 40 }, { value: 60 }];
+    const arcs = pie()(data);
+    expect(arcs.length).toBe(2);
+    expect(arcs[0].value).toBe(40);
+    expect(arcs[1].value).toBe(60);
+    // Sorted descending: 60 starts at 0, 40 ends at 2π
+    expect(arcs[0].endAngle).toBeCloseTo(2 * Math.PI, 5);
+  });
+});
+// ─── Shape Factory Edge Cases ───────────────────────────────────────
+describe('D3 Shape Polyfill - Branch Edge Cases', () => {
+  describe('Shape factory default value extractor', () => {
+    it('should use default value extractor on line factory', () => {
+      // Covers default x and y value extractor — object.x and object.y path
+      const lineFn = line();
+      // Don't set custom value extractor — use defaults
+      const result = lineFn.generate([
+        { x: 5, y: 10 },
+        { x: 15, y: 25 },
+      ]);
+      expect(result).toBe('M5,10L15,25');
+    });
+  });
+  describe('Pie and line factory direct usage', () => {
+    it('should use pie().value() and generate() methods directly', () => {
+      // Cover pie factory value and generate methods
+      const pieFn = pie();
+      pieFn.value((d) => d.v);
+      const result = pieFn.generate([{ v: 30 }, { v: 70 }]);
+      expect(result.length).toBe(2);
+      expect(result[0].value).toBe(30);
+      expect(result[1].value).toBe(70);
+      // Sorted descending: 70 starts at 0, 30 ends at 2π
+      expect(result[0].endAngle).toBeCloseTo(2 * Math.PI, 5);
+    });
+    it('should use pie default value extractor', () => {
+      // Cover pie default value extractor path
+      const pieFn = pie();
+      const result = pieFn.generate([{ value: 50 }, { value: 50 }]);
+      expect(result.length).toBe(2);
+      expect(result[0].value).toBe(50);
+    });
+    it('should use pie default extractor fallback to 0', () => {
+      // Cover pie default value extractor fallback path
+      const pieFn = pie();
+      const result = pieFn.generate([{ name: 'test' }]);
+      expect(result.length).toBe(1);
+      expect(result[0].value).toBe(0);
+    });
+    it('should use arc factory methods directly', () => {
+      const arcFn = arc();
+      arcFn.innerRadius(0).outerRadius(100);
+      const path = arcFn.generate({ startAngle: 0, endAngle: Math.PI / 2 });
+      expect(path).toContain('A');
+    });
+    it('should use line default value extractor via factory', () => {
+      // Cover line default x and y value extractor
+      const lineFn = line();
+      const result = lineFn.generate([{ x: 3, y: 7 }]);
+      expect(result).toBe('M3,7');
+    });
+    it('should use line default extractor fallback to array indices', () => {
+      // Cover line default x/y fallback paths
+      const lineFn = line();
+      const result = lineFn.generate([
+        [5, 10],
+        [15, 25],
+      ]);
+      expect(result).toBe('M5,10L15,25');
+    });
+  });
+  describe('Factory wrapper .generate() method coverage', () => {
+    it('should call .generate() on line() factory wrapper (line 91)', () => {
+      const lineFn = line()
+        .x(d => d.x)
+        .y(d => d.y);
+      const result = lineFn.generate([
+        { x: 0, y: 0 },
+        { x: 10, y: 20 },
+      ]);
+      expect(typeof result).toBe('string');
+      expect(result).toBe('M0,0L10,20');
+    });
+    it('should call .generate() on arc() factory wrapper (line 193)', () => {
+      const arcFn = arc().innerRadius(0).outerRadius(50);
+      const result = arcFn.generate({ startAngle: 0, endAngle: Math.PI / 2 });
+      expect(typeof result).toBe('string');
+      expect(result).toContain('A');
+    });
+    it('should call .generate() on pie() factory wrapper (line 274)', () => {
+      const pieFn = pie().value(d => d.v);
+      const result = pieFn.generate([{ v: 10 }, { v: 20 }, { v: 30 }]);
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(3);
+      result.forEach(d => {
+        expect(d).toHaveProperty('startAngle');
+        expect(d).toHaveProperty('endAngle');
+        expect(d).toHaveProperty('data');
+      });
+    });
+  });
+});

package/dist/collection/polyfill/d3/test/d3-time-format-polyfill.test.js

@@ -0,0 +1,162 @@
+/* eslint-disable @typescript-eslint/typedef */
+/**
+ * D3 Time Format Polyfill Tests
+ *
+ * Tests for the d3-time-format-polyfill module: timeFormat() and timeParse().
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+import { timeFormat, timeParse } from '../d3-time-format-polyfill';
+// ─── Time Format Tests ──────────────────────────────────────────────
+describe('D3 Time Format Polyfill', () => {
+  describe('timeFormat()', () => {
+    it('should format year', () => {
+      const format = timeFormat('%Y');
+      expect(format(new Date(2023, 0, 1))).toBe('2023');
+    });
+    it('should format date string %Y-%m-%d', () => {
+      const format = timeFormat('%Y-%m-%d');
+      expect(format(new Date(2023, 2, 15))).toBe('2023-03-15');
+    });
+    it('should format milliseconds .%L', () => {
+      const format = timeFormat('.%L');
+      const date = new Date(2023, 0, 1, 0, 0, 0, 42);
+      expect(format(date)).toBe('.042');
+    });
+    it('should format seconds :%S', () => {
+      const format = timeFormat(':%S');
+      const date = new Date(2023, 0, 1, 0, 0, 30);
+      expect(format(date)).toBe(':30');
+    });
+    it('should format minutes %I:%M', () => {
+      const format = timeFormat('%I:%M');
+      const date = new Date(2023, 0, 1, 14, 30);
+      expect(format(date)).toBe('02:30');
+    });
+    it('should format hours %H:00', () => {
+      const format = timeFormat('%H:00');
+      const date = new Date(2023, 0, 1, 14, 0);
+      expect(format(date)).toBe('14:00');
+    });
+    it('should format day %d', () => {
+      const format = timeFormat('%d');
+      expect(format(new Date(2023, 0, 5))).toBe('05');
+    });
+    it('should format month abbreviation %b', () => {
+      const format = timeFormat('%b');
+      expect(format(new Date(2023, 0, 1))).toBe('Jan');
+      expect(format(new Date(2023, 11, 1))).toBe('Dec');
+    });
+    it('should format week %b %d', () => {
+      const format = timeFormat('%b %d');
+      expect(format(new Date(2023, 2, 15))).toBe('Mar 15');
+    });
+  });
+  describe('timeParse()', () => {
+    it('should parse %Y-%m-%d format', () => {
+      const parse = timeParse('%Y-%m-%d');
+      const date = parse('2023-03-15');
+      expect(date).not.toBeNull();
+      expect(date === null || date === void 0 ? void 0 : date.getFullYear()).toBe(2023);
+      expect(date === null || date === void 0 ? void 0 : date.getMonth()).toBe(2);
+      expect(date === null || date === void 0 ? void 0 : date.getDate()).toBe(15);
+    });
+    it('should return null for invalid strings', () => {
+      const parse = timeParse('%Y-%m-%d');
+      expect(parse('invalid')).toBeNull();
+    });
+    it('should parse same format as Vega chart uses', () => {
+      const parse = timeParse('%Y-%m-%d');
+      const date1 = parse('2011-01-01');
+      const date2 = parse('2022-01-01');
+      expect(date1 === null || date1 === void 0 ? void 0 : date1.getFullYear()).toBe(2011);
+      expect(date2 === null || date2 === void 0 ? void 0 : date2.getFullYear()).toBe(2022);
+    });
+    it('should parse dates consistently across multiple calls', () => {
+      const parse = timeParse('%Y-%m-%d');
+      const d1 = parse('2021-01-01');
+      const d2 = parse('2021-01-01');
+      expect(d1 === null || d1 === void 0 ? void 0 : d1.getTime()).toBe(d2 === null || d2 === void 0 ? void 0 : d2.getTime());
+    });
+  });
+});
+// ─── Additional Time Format Coverage ────────────────────────────────
+describe('D3 Time Format Polyfill - Additional Coverage', () => {
+  describe('timeFormat() - uncovered directives', () => {
+    it('should format full month name %B', () => {
+      // Covers FORMAT_DIRECTIVES['%B'] (lines 31-36)
+      const format = timeFormat('%B');
+      expect(format(new Date(2023, 0, 1))).toBe('January');
+      expect(format(new Date(2023, 5, 1))).toBe('June');
+      expect(format(new Date(2023, 11, 1))).toBe('December');
+    });
+    it('should format abbreviated day name %a', () => {
+      // Covers FORMAT_DIRECTIVES['%a'] (lines 37-40)
+      const format = timeFormat('%a');
+      const firstDate = new Date(2023, 0, 1); // Jan 1, 2023 is Sun
+      expect(format(firstDate)).toBe('Sun');
+      const secondDate = new Date(2023, 0, 2);
+      expect(format(secondDate)).toBe('Mon');
+    });
+    it('should format AM/PM indicator %p', () => {
+      // Covers FORMAT_DIRECTIVES['%p'] (line 41)
+      const format = timeFormat('%p');
+      expect(format(new Date(2023, 0, 1, 9, 0))).toBe('AM');
+      expect(format(new Date(2023, 0, 1, 0, 0))).toBe('AM');
+      expect(format(new Date(2023, 0, 1, 12, 0))).toBe('PM');
+      expect(format(new Date(2023, 0, 1, 23, 0))).toBe('PM');
+    });
+    it('should format literal percent %%', () => {
+      // Covers FORMAT_DIRECTIVES['%%'] (line 42)
+      const format = timeFormat('100%%');
+      expect(format(new Date(2023, 0, 1))).toBe('100%');
+    });
+    it('should format combined %I:%M %p', () => {
+      const format = timeFormat('%I:%M %p');
+      expect(format(new Date(2023, 0, 1, 14, 30))).toBe('02:30 PM');
+      expect(format(new Date(2023, 0, 1, 0, 0))).toBe('12:00 AM');
+    });
+    it('should format %a, %B %d, %Y', () => {
+      const format = timeFormat('%a, %B %d, %Y');
+      // Jan 1, 2023 is a Sunday
+      expect(format(new Date(2023, 0, 1))).toBe('Sun, January 01, 2023');
+    });
+  });
+  describe('timeParse() - uncovered patterns', () => {
+    it('should parse 12-hour format %I', () => {
+      // Covers PARSE_PATTERNS['%I'] (lines 88-91)
+      const parse = timeParse('%Y-%m-%d %I');
+      const date = parse('2023-03-15 02');
+      expect(date).not.toBeNull();
+      expect(date === null || date === void 0 ? void 0 : date.getHours()).toBe(2);
+    });
+    it('should parse minutes %M', () => {
+      // Covers PARSE_PATTERNS['%M'] (lines 92-95)
+      const parse = timeParse('%Y-%m-%d %H:%M');
+      const date = parse('2023-03-15 14:30');
+      expect(date).not.toBeNull();
+      expect(date === null || date === void 0 ? void 0 : date.getHours()).toBe(14);
+      expect(date === null || date === void 0 ? void 0 : date.getMinutes()).toBe(30);
+    });
+    it('should parse seconds %S', () => {
+      // Covers PARSE_PATTERNS['%S'] (lines 96-99)
+      const parse = timeParse('%Y-%m-%d %H:%M:%S');
+      const date = parse('2023-03-15 14:30:45');
+      expect(date).not.toBeNull();
+      expect(date === null || date === void 0 ? void 0 : date.getSeconds()).toBe(45);
+    });
+    it('should parse milliseconds %L', () => {
+      // Covers PARSE_PATTERNS['%L'] (lines 100-103)
+      const parse = timeParse('%Y-%m-%d %H:%M:%S.%L');
+      const date = parse('2023-03-15 14:30:45.123');
+      expect(date).not.toBeNull();
+      expect(date === null || date === void 0 ? void 0 : date.getMilliseconds()).toBe(123);
+    });
+    it('should parse %H (24-hour hours)', () => {
+      const parse = timeParse('%H');
+      const date = parse('23');
+      expect(date).not.toBeNull();
+      expect(date === null || date === void 0 ? void 0 : date.getHours()).toBe(23);
+    });
+  });
+});