@design-core/core 0.0.6 → 50.1.0

package/test/renderers/pdfRenderer.test.js

@@ -0,0 +1,271 @@
+import { PdfRenderer } from '../../core/lib/renderers/pdfRenderer.js';
+import { Text } from '../../core/entities/text.js';
+import { Point } from '../../core/entities/point.js';
+
+describe('PdfRenderer — getOutput()', () => {
+  test('produces a valid PDF header', () => {
+    const renderer = new PdfRenderer(100, 100);
+    const output = renderer.getOutput();
+    expect(output.startsWith('%PDF-1.4')).toBe(true);
+  });
+
+  test('ends with %%EOF', () => {
+    const renderer = new PdfRenderer(100, 100);
+    const output = renderer.getOutput();
+    expect(output.endsWith('%%EOF')).toBe(true);
+  });
+
+  test('contains required PDF structural elements', () => {
+    const renderer = new PdfRenderer(595, 842);
+    const output = renderer.getOutput();
+    expect(output).toContain('/Catalog');
+    expect(output).toContain('/Pages');
+    expect(output).toContain('/Page');
+    expect(output).toContain('/MediaBox [0 0 595 842]');
+    expect(output).toContain('/Helvetica');
+    expect(output).toContain('xref');
+    expect(output).toContain('trailer');
+    expect(output).toContain('startxref');
+  });
+});
+
+describe('PdfRenderer — drawing', () => {
+  test('drawShape emits m, l, and S operators', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 20 }], {});
+    const output = renderer.getOutput();
+    expect(output).toContain('0 0 m');
+    expect(output).toContain('10 20 l');
+    expect(output).toContain('S');
+  });
+
+  test('drawShape with closed=true emits h before S', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }, { x: 5, y: 10 }], { closed: true });
+    const output = renderer.getOutput();
+    const hPos = output.indexOf('\nh\n');
+    const sPos = output.indexOf('\nS\n');
+    expect(hPos).toBeGreaterThan(-1);
+    expect(sPos).toBeGreaterThan(hPos);
+  });
+
+  test('drawShape with fill+stroke emits B operator', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { fill: true, stroke: true });
+    const output = renderer.getOutput();
+    expect(output).toContain('\nB\n');
+  });
+
+  test('drawShape with fill only emits f operator', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { fill: true, stroke: false });
+    const output = renderer.getOutput();
+    expect(output).toContain('\nf\n');
+  });
+
+  test('drawShape with fillRule evenodd emits f* operator', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { fill: true, stroke: false, fillRule: 'evenodd' });
+    const output = renderer.getOutput();
+    expect(output).toContain('\nf*\n');
+    expect(output).not.toContain('\nf\n');
+  });
+
+  test('drawShape with fill+stroke and fillRule evenodd emits B* operator', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { fill: true, stroke: true, fillRule: 'evenodd' });
+    const output = renderer.getOutput();
+    expect(output).toContain('\nB*\n');
+    expect(output).not.toContain('\nB\n');
+  });
+
+  test('straight segment (no bulge) emits l operator', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], {});
+    const output = renderer.getOutput();
+    expect(output).toContain('10 0 l');
+    expect(output).not.toContain(' c\n');
+  });
+
+  test('bulge segment emits cubic Bézier c operator, not chord l', () => {
+    const renderer = new PdfRenderer(100, 100);
+    // bulge=1 → 180° CCW arc from (0,0) to (10,0)
+    const start = new Point(0, 0, 1);
+    const end = new Point(10, 0);
+    renderer.drawShape([start, end], {});
+    const output = renderer.getOutput();
+    expect(output).toContain(' c');
+    expect(output).not.toContain('10 0 l');
+  });
+
+  test('180° arc (bulge=1) splits into 2 Bézier curves', () => {
+    const renderer = new PdfRenderer(100, 100);
+    const start = new Point(0, 0, 1);
+    const end = new Point(10, 0);
+    renderer.drawShape([start, end], {});
+    const streamContent = renderer.getOutput().match(/stream\n([\s\S]*?)\nendstream/)[1];
+    const cCount = (streamContent.match(/ c\n/g) || []).length;
+    expect(cCount).toBe(2);
+  });
+
+  test('90° arc splits into 1 Bézier curve', () => {
+    const renderer = new PdfRenderer(100, 100);
+    // start=(100,0) bulge=tan(π/8)≈0.4142 → 90° arc, end=(150,50), centre=(100,50), r=50
+    const start = new Point(100, 0, Math.tan(Math.PI / 8));
+    const end = new Point(150, 50);
+    renderer.drawShape([start, end], {});
+    const streamContent = renderer.getOutput().match(/stream\n([\s\S]*?)\nendstream/)[1];
+    const cCount = (streamContent.match(/ c\n/g) || []).length;
+    expect(cCount).toBe(1);
+  });
+
+  test('full circle (two 180° arcs) emits 4 Bézier curves', () => {
+    const renderer = new PdfRenderer(100, 100);
+    // Circle centre=(50,50) r=50 — mirrors Circle.toPolylinePoints() output
+    const p1 = new Point(100, 50, 1);
+    const p2 = new Point(0, 50, 1);
+    const p3 = new Point(100, 50);
+    renderer.drawShape([p1, p2, p3], {});
+    const streamContent = renderer.getOutput().match(/stream\n([\s\S]*?)\nendstream/)[1];
+    const cCount = (streamContent.match(/ c\n/g) || []).length;
+    expect(cCount).toBe(4);
+  });
+
+  test('drawSegments solid batches all segments with one S', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawSegments([
+      { x1: 0, y1: 0, x2: 10, y2: 0 },
+      { x1: 20, y1: 0, x2: 30, y2: 0 },
+    ], []);
+    const output = renderer.getOutput();
+    expect(output).toContain('0 0 m');
+    expect(output).toContain('10 0 l');
+    expect(output).toContain('20 0 m');
+    expect(output).toContain('30 0 l');
+    // Only one S for the entire batch
+    const streamStart = output.indexOf('stream\n') + 'stream\n'.length;
+    const streamEnd = output.indexOf('\nendstream');
+    const streamContent = output.slice(streamStart, streamEnd);
+    expect(streamContent.split('\nS').length - 1).toBe(1);
+  });
+
+  test('drawSegments dashed emits d operator per segment', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawSegments([
+      { x1: 0, y1: 0, x2: 10, y2: 0, dashPhase: 0 },
+      { x1: 20, y1: 0, x2: 30, y2: 0, dashPhase: 5 },
+    ], [5, 3]);
+    const output = renderer.getOutput();
+    expect(output).toContain('[5 3] 0 d');
+    expect(output).toContain('[5 3] 5 d');
+  });
+
+  test('drawText emits BT block with character and position transform', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.drawText([{ char: 'A', x: 10, y: 20, rotation: 0 }], 'Helvetica', 5);
+    const output = renderer.getOutput();
+    expect(output).toContain('BT');
+    expect(output).toContain('ET');
+    expect(output).toContain('(A)');
+    expect(output).toContain('10 20 cm');
+  });
+
+  test('drawText with rotation applies sin/cos transform', () => {
+    const renderer = new PdfRenderer(100, 100);
+    const r = Math.PI / 4; // 45 degrees
+    renderer.drawText([{ char: 'X', x: 0, y: 0, rotation: r }], 'Helvetica', 5);
+    const output = renderer.getOutput();
+    // cos(π/4) ≈ 0.7071, sin(π/4) ≈ 0.7071
+    expect(output).toContain('0.7071');
+  });
+});
+
+describe('PdfRenderer — state methods', () => {
+  test('setColour emits RG and rg operators', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.setColour({ r: 255, g: 0, b: 0 });
+    const output = renderer.getOutput();
+    expect(output).toContain('1 0 0 RG');
+    expect(output).toContain('1 0 0 rg');
+  });
+
+  test('setLineWidth emits w operator', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.setLineWidth(2.5);
+    const output = renderer.getOutput();
+    expect(output).toContain('2.5 w');
+  });
+
+  test('setDash with array emits d operator', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.setDash([5, 3], 1);
+    const output = renderer.getOutput();
+    expect(output).toContain('[5 3] 1 d');
+  });
+
+  test('setDash with empty array emits solid line operator', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.setDash([], 0);
+    const output = renderer.getOutput();
+    expect(output).toContain('[] 0 d');
+  });
+
+  test('setHighlight is a no-op (does not add content)', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.setHighlight(true, { r: 255, g: 0, b: 0 }, 5);
+    const streamContent = renderer.getOutput().match(/stream\n([\s\S]*?)\nendstream/)[1];
+    expect(streamContent).toBe('');
+  });
+
+  test('fillBackground is a no-op (does not add content)', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.setBackgroundColour({ r: 0, g: 0, b: 0 });
+    renderer.fillBackground();
+    const streamContent = renderer.getOutput().match(/stream\n([\s\S]*?)\nendstream/)[1];
+    expect(streamContent).toBe('');
+  });
+});
+
+describe('PdfRenderer — transform methods', () => {
+  test('setTransform emits cm operator with matrix values', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.setTransform({ a: 2, d: 2, e: 10, f: 20 });
+    const output = renderer.getOutput();
+    expect(output).toContain('2 0 0 2 10 20 cm');
+  });
+
+  test('applyTransform with no rotation emits identity-rotate cm', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.applyTransform({ x: 5, y: 10, rotation: 0 });
+    const output = renderer.getOutput();
+    expect(output).toContain('1 0 0 1 5 10 cm');
+  });
+
+  test('save emits q operator', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.save();
+    const output = renderer.getOutput();
+    expect(output).toContain('\nq\n');
+  });
+
+  test('restore emits Q operator', () => {
+    const renderer = new PdfRenderer(100, 100);
+    renderer.restore();
+    const output = renderer.getOutput();
+    expect(output).toContain('\nQ\n');
+  });
+});
+
+describe('PdfRenderer — measurement', () => {
+  test('measureText returns width matching Text.getApproximateWidth', () => {
+    const renderer = new PdfRenderer(100, 100);
+    const result = renderer.measureText('Hello', 'Helvetica', 10);
+    expect(result).toEqual({ width: Text.getApproximateWidth('Hello', 10) });
+  });
+
+  test('measureCharWidth returns value matching Text.getApproximateWidth', () => {
+    const renderer = new PdfRenderer(100, 100);
+    const result = renderer.measureCharWidth('A');
+    expect(result).toBe(Text.getApproximateWidth('A', 1));
+  });
+});

package/test/renderers/rendererBase.test.js

@@ -0,0 +1,213 @@
+import { RendererBase } from '../../core/lib/renderers/rendererBase.js';
+
+/** Concrete subclass used throughout — only implements what the tests need. */
+class TestRenderer extends RendererBase {}
+
+// ─── RendererBase.Styles ──────────────────────────────────────────────────────
+
+describe('RendererBase.Styles', () => {
+  // Use lowercase aliases to satisfy the new-cap lint rule
+  const applyNone = RendererBase.Styles.NONE;
+  const applyMono = RendererBase.Styles.MONOCHROME;
+  const applyGrey = RendererBase.Styles.GREYSCALE;
+
+  test('NONE returns colour unchanged', () => {
+    expect(applyNone({ r: 100, g: 150, b: 200 })).toEqual({ r: 100, g: 150, b: 200 });
+  });
+
+  test('MONOCHROME returns black for any colour', () => {
+    expect(applyMono({ r: 255, g: 128, b: 0 })).toEqual({ r: 0, g: 0, b: 0 });
+  });
+
+  test('MONOCHROME returns black even for white', () => {
+    expect(applyMono({ r: 255, g: 255, b: 255 })).toEqual({ r: 0, g: 0, b: 0 });
+  });
+
+  test('GREYSCALE produces equal r/g/b channels', () => {
+    const result = applyGrey({ r: 255, g: 0, b: 0 });
+    expect(result.r).toBe(result.g);
+    expect(result.g).toBe(result.b);
+  });
+
+  test('GREYSCALE pure red uses BT.601 red coefficient (~76)', () => {
+    // 0.299 * 255 = 76.245 → rounds to 76
+    const result = applyGrey({ r: 255, g: 0, b: 0 });
+    expect(result.r).toBe(76);
+  });
+
+  test('GREYSCALE pure green uses BT.601 green coefficient (~150)', () => {
+    // 0.587 * 255 = 149.685 → rounds to 150
+    const result = applyGrey({ r: 0, g: 255, b: 0 });
+    expect(result.r).toBe(150);
+  });
+
+  test('GREYSCALE pure blue uses BT.601 blue coefficient (~29)', () => {
+    // 0.114 * 255 = 29.07 → rounds to 29
+    const result = applyGrey({ r: 0, g: 0, b: 255 });
+    expect(result.r).toBe(29);
+  });
+
+  test('GREYSCALE white maps to white (255, 255, 255)', () => {
+    expect(applyGrey({ r: 255, g: 255, b: 255 })).toEqual({ r: 255, g: 255, b: 255 });
+  });
+
+  test('GREYSCALE black maps to black (0, 0, 0)', () => {
+    expect(applyGrey({ r: 0, g: 0, b: 0 })).toEqual({ r: 0, g: 0, b: 0 });
+  });
+});
+
+// ─── setBackgroundColour / getBackgroundColour ────────────────────────────────
+
+test('getBackgroundColour returns null before any set', () => {
+  const r = new TestRenderer();
+  expect(r.getBackgroundColour()).toBeNull();
+});
+
+test('setBackgroundColour stores and getBackgroundColour returns the colour', () => {
+  const r = new TestRenderer();
+  const colour = { r: 255, g: 255, b: 255 };
+  r.setBackgroundColour(colour);
+  expect(r.getBackgroundColour()).toBe(colour);
+});
+
+test('setBackgroundColour can be updated', () => {
+  const r = new TestRenderer();
+  r.setBackgroundColour({ r: 0, g: 0, b: 0 });
+  const updated = { r: 255, g: 0, b: 0 };
+  r.setBackgroundColour(updated);
+  expect(r.getBackgroundColour()).toBe(updated);
+});
+
+test('setBackgroundColour accepts null to clear', () => {
+  const r = new TestRenderer();
+  r.setBackgroundColour({ r: 0, g: 0, b: 0 });
+  r.setBackgroundColour(null);
+  expect(r.getBackgroundColour()).toBeNull();
+});
+
+// ─── setStyle / applyStyle ────────────────────────────────────────────────────
+
+test('applyStyle defaults to NONE (colour passes through unchanged)', () => {
+  const r = new TestRenderer();
+  expect(r.applyStyle({ r: 10, g: 20, b: 30 })).toEqual({ r: 10, g: 20, b: 30 });
+});
+
+test('setStyle to MONOCHROME causes applyStyle to return black', () => {
+  const r = new TestRenderer();
+  r.setStyle(RendererBase.Styles.MONOCHROME);
+  expect(r.applyStyle({ r: 100, g: 150, b: 200 })).toEqual({ r: 0, g: 0, b: 0 });
+});
+
+test('setStyle to GREYSCALE causes applyStyle to return grey', () => {
+  const r = new TestRenderer();
+  r.setStyle(RendererBase.Styles.GREYSCALE);
+  const result = r.applyStyle({ r: 255, g: 0, b: 0 });
+  expect(result.r).toBe(result.g);
+  expect(result.g).toBe(result.b);
+});
+
+test('setStyle falls back to NONE when passed a falsy value', () => {
+  const r = new TestRenderer();
+  r.setStyle(RendererBase.Styles.MONOCHROME);
+  r.setStyle(null);
+  expect(r.applyStyle({ r: 10, g: 20, b: 30 })).toEqual({ r: 10, g: 20, b: 30 });
+});
+
+test('setStyle can be changed multiple times', () => {
+  const r = new TestRenderer();
+  r.setStyle(RendererBase.Styles.MONOCHROME);
+  r.setStyle(RendererBase.Styles.NONE);
+  expect(r.applyStyle({ r: 50, g: 100, b: 150 })).toEqual({ r: 50, g: 100, b: 150 });
+});
+
+// ─── Abstract methods throw ───────────────────────────────────────────────────
+
+test('drawShape throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.drawShape([])).toThrow('TestRenderer: drawShape() not implemented');
+});
+
+test('drawText throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.drawText([], 'Arial', 12)).toThrow('TestRenderer: drawText() not implemented');
+});
+
+test('tracePath throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.tracePath([])).toThrow('TestRenderer: tracePath() not implemented');
+});
+
+test('drawSegments throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.drawSegments([])).toThrow('TestRenderer: drawSegments() not implemented');
+});
+
+test('beginPath throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.beginPath()).toThrow('TestRenderer: beginPath() not implemented');
+});
+
+test('stroke throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.stroke()).toThrow('TestRenderer: stroke() not implemented');
+});
+
+test('closePath throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.closePath()).toThrow('TestRenderer: closePath() not implemented');
+});
+
+test('setColour throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.setColour({ r: 0, g: 0, b: 0 })).toThrow('TestRenderer: setColour() not implemented');
+});
+
+test('setLineWidth throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.setLineWidth(1)).toThrow('TestRenderer: setLineWidth() not implemented');
+});
+
+test('setDash throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.setDash([])).toThrow('TestRenderer: setDash() not implemented');
+});
+
+test('setHighlight throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.setHighlight(true)).toThrow('TestRenderer: setHighlight() not implemented');
+});
+
+test('setTransform throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.setTransform({})).toThrow('TestRenderer: setTransform() not implemented');
+});
+
+test('fillBackground throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.fillBackground({ x: 0, y: 0 }, 800, 600, 1)).toThrow('TestRenderer: fillBackground() not implemented');
+});
+
+test('applyTransform throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.applyTransform({})).toThrow('TestRenderer: applyTransform() not implemented');
+});
+
+test('save throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.save()).toThrow('TestRenderer: save() not implemented');
+});
+
+test('restore throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.restore()).toThrow('TestRenderer: restore() not implemented');
+});
+
+test('measureText throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.measureText('hello')).toThrow('TestRenderer: measureText() not implemented');
+});
+
+test('measureCharWidth throws with renderer name in message', () => {
+  const r = new TestRenderer();
+  expect(() => r.measureCharWidth('A')).toThrow('TestRenderer: measureCharWidth() not implemented');
+});