@design-core/core 0.0.5 → 0.0.7

package/test/renderers/canvasRenderer.test.js

@@ -0,0 +1,317 @@
+import { CanvasRenderer } from '../../core/lib/renderers/canvasRenderer.js';
+import { Point } from '../../core/entities/point.js';
+
+// ─── Mock context factory ─────────────────────────────────────────────────────
+
+/**
+ * Build a minimal mock CanvasRenderingContext2D that records every call.
+ * @return {Object} mock context with a `calls` array
+ */
+function makeMockCtx() {
+  const calls = [];
+  const record = (name) => (...args) => calls.push({ name, args });
+  return {
+    calls,
+    save: record('save'),
+    restore: record('restore'),
+    beginPath: record('beginPath'),
+    closePath: record('closePath'),
+    moveTo: record('moveTo'),
+    lineTo: record('lineTo'),
+    arc: record('arc'),
+    stroke: record('stroke'),
+    fill: record('fill'),
+    clip: record('clip'),
+    fillText: record('fillText'),
+    strokeText: record('strokeText'),
+    translate: record('translate'),
+    rotate: record('rotate'),
+    scale: record('scale'),
+    setLineDash: record('setLineDash'),
+    setTransform: record('setTransform'),
+    fillRect: record('fillRect'),
+    measureText: (s) => ({ width: s.length * 8 }),
+    strokeStyle: '', fillStyle: '', lineWidth: 0, lineDashOffset: 0, globalAlpha: 1, font: '',
+  };
+}
+
+// ─── drawShape ────────────────────────────────────────────────────────────────
+
+describe('CanvasRenderer — drawShape', () => {
+  test('returns early and emits nothing for empty points', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawShape([]);
+    expect(ctx.calls).toHaveLength(0);
+  });
+
+  test('calls beginPath, moveTo, lineTo, stroke for a basic shape', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawShape([{ x: 0, y: 0 }, { x: 10, y: 20 }]);
+    const names = ctx.calls.map((c) => c.name);
+    expect(names).toContain('beginPath');
+    expect(names).toContain('moveTo');
+    expect(names).toContain('lineTo');
+    expect(names).toContain('stroke');
+    expect(names).not.toContain('fill');
+  });
+
+  test('calls closePath before stroke when closed=true', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { closed: true });
+    const names = ctx.calls.map((c) => c.name);
+    const closeIdx = names.lastIndexOf('closePath');
+    const strokeIdx = names.lastIndexOf('stroke');
+    expect(closeIdx).toBeGreaterThan(-1);
+    expect(strokeIdx).toBeGreaterThan(closeIdx);
+  });
+
+  test('calls fill with nonzero when fill=true', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { fill: true, stroke: false });
+    const fillCall = ctx.calls.find((c) => c.name === 'fill');
+    expect(fillCall).toBeDefined();
+    expect(fillCall.args[0]).toBe('nonzero');
+    expect(ctx.calls.map((c) => c.name)).not.toContain('stroke');
+  });
+
+  test('calls fill with evenodd when fillRule=evenodd', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { fill: true, stroke: false, fillRule: 'evenodd' });
+    const fillCall = ctx.calls.find((c) => c.name === 'fill');
+    expect(fillCall.args[0]).toBe('evenodd');
+  });
+
+  test('calls both fill and stroke when fill=true and stroke=true', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { fill: true, stroke: true });
+    const names = ctx.calls.map((c) => c.name);
+    expect(names).toContain('fill');
+    expect(names).toContain('stroke');
+  });
+
+  test('calls clip with nonzero when clip=true', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { clip: true });
+    const clipCall = ctx.calls.find((c) => c.name === 'clip');
+    expect(clipCall).toBeDefined();
+    expect(clipCall.args[0]).toBe('nonzero');
+    expect(ctx.calls.map((c) => c.name)).not.toContain('stroke');
+  });
+
+  test('calls clip with evenodd when clip=true and fillRule=evenodd', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { clip: true, fillRule: 'evenodd' });
+    const clipCall = ctx.calls.find((c) => c.name === 'clip');
+    expect(clipCall.args[0]).toBe('evenodd');
+  });
+
+  test('wraps fill in save/restore when alpha < 1', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { fill: true, stroke: false, alpha: 0.5 });
+    const names = ctx.calls.map((c) => c.name);
+    const saveIdx = names.lastIndexOf('save');
+    const fillIdx = names.lastIndexOf('fill');
+    const restoreIdx = names.lastIndexOf('restore');
+    expect(saveIdx).toBeLessThan(fillIdx);
+    expect(fillIdx).toBeLessThan(restoreIdx);
+    expect(ctx.globalAlpha).toBe(0.5);
+  });
+
+  test('draws highlight halo before normal path when highlighted', () => {
+    const ctx = makeMockCtx();
+    const renderer = new CanvasRenderer(ctx);
+    renderer.setHighlight(true, { r: 255, g: 0, b: 0 }, 3);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }]);
+    // Two save/restore pairs: one for the highlight pass, none extra for normal
+    const saves = ctx.calls.filter((c) => c.name === 'save');
+    const strokes = ctx.calls.filter((c) => c.name === 'stroke');
+    expect(saves.length).toBeGreaterThanOrEqual(1);
+    expect(strokes.length).toBe(2); // halo stroke + normal stroke
+  });
+});
+
+// ─── tracePath ────────────────────────────────────────────────────────────────
+
+describe('CanvasRenderer — tracePath', () => {
+  test('returns early for empty points', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).tracePath([]);
+    expect(ctx.calls).toHaveLength(0);
+  });
+
+  test('calls moveTo for first point and lineTo for each subsequent straight segment', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).tracePath([{ x: 0, y: 0, bulge: 0 }, { x: 5, y: 0, bulge: 0 }, { x: 10, y: 5, bulge: 0 }]);
+    expect(ctx.calls[0]).toEqual({ name: 'moveTo', args: [0, 0] });
+    expect(ctx.calls[1]).toEqual({ name: 'lineTo', args: [5, 0] });
+    expect(ctx.calls[2]).toEqual({ name: 'lineTo', args: [10, 5] });
+  });
+
+  test('calls arc for a bulge segment', () => {
+    const ctx = makeMockCtx();
+    const p1 = new Point(0, 0, 1); // bulge=1 → semicircle CCW
+    const p2 = new Point(10, 0);
+    new CanvasRenderer(ctx).tracePath([p1, p2]);
+    const arcCall = ctx.calls.find((c) => c.name === 'arc');
+    expect(arcCall).toBeDefined();
+    expect(arcCall.args).toHaveLength(6);
+  });
+
+  test('passes anticlockwise=true to arc for negative bulge', () => {
+    const ctx = makeMockCtx();
+    const p1 = new Point(0, 0, -1); // negative bulge → CW in DXF = anticlockwise=true in canvas
+    const p2 = new Point(10, 0);
+    new CanvasRenderer(ctx).tracePath([p1, p2]);
+    const arcCall = ctx.calls.find((c) => c.name === 'arc');
+    expect(arcCall.args[5]).toBe(true);
+  });
+
+  test('passes anticlockwise=false to arc for positive bulge', () => {
+    const ctx = makeMockCtx();
+    const p1 = new Point(0, 0, 1);
+    const p2 = new Point(10, 0);
+    new CanvasRenderer(ctx).tracePath([p1, p2]);
+    const arcCall = ctx.calls.find((c) => c.name === 'arc');
+    expect(arcCall.args[5]).toBe(false);
+  });
+});
+
+// ─── drawSegments ─────────────────────────────────────────────────────────────
+
+describe('CanvasRenderer — drawSegments', () => {
+  test('returns early for empty segments', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawSegments([]);
+    expect(ctx.calls).toHaveLength(0);
+  });
+
+  test('calls stroke without setLineDash for solid segments', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawSegments([{ x1: 0, y1: 0, x2: 10, y2: 0 }]);
+    expect(ctx.calls.map((c) => c.name)).not.toContain('setLineDash');
+    expect(ctx.calls.map((c) => c.name)).toContain('stroke');
+  });
+
+  test('calls setLineDash per segment when dashes provided', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawSegments(
+        [{ x1: 0, y1: 0, x2: 10, y2: 0, dashPhase: 2 }],
+        [5, 3],
+    );
+    const dashCall = ctx.calls.find((c) => c.name === 'setLineDash');
+    expect(dashCall).toBeDefined();
+    expect(dashCall.args[0]).toEqual([5, 3]);
+    expect(ctx.lineDashOffset).toBe(2);
+  });
+
+  test('draws highlight halo before normal pass when highlighted', () => {
+    const ctx = makeMockCtx();
+    const renderer = new CanvasRenderer(ctx);
+    renderer.setHighlight(true, { r: 0, g: 255, b: 0 }, 2);
+    renderer.drawSegments([{ x1: 0, y1: 0, x2: 10, y2: 0 }]);
+    const strokes = ctx.calls.filter((c) => c.name === 'stroke');
+    expect(strokes.length).toBe(2);
+  });
+});
+
+// ─── drawText ─────────────────────────────────────────────────────────────────
+
+describe('CanvasRenderer — drawText', () => {
+  test('returns early for null characters', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawText(null, 'Arial', 12);
+    expect(ctx.calls).toHaveLength(0);
+  });
+
+  test('returns early for empty characters array', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawText([], 'Arial', 12);
+    expect(ctx.calls).toHaveLength(0);
+  });
+
+  test('sets ctx.font from height and fontName', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawText([{ x: 0, y: 0, char: 'A' }], 'Courier', 14);
+    expect(ctx.font).toBe('14pt Courier');
+  });
+
+  test('calls translate, scale(1,-1), fillText for each character', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawText([{ x: 5, y: 10, char: 'X' }], 'Arial', 12);
+    const translateCall = ctx.calls.find((c) => c.name === 'translate');
+    const scaleCall = ctx.calls.find((c) => c.name === 'scale');
+    const fillTextCall = ctx.calls.find((c) => c.name === 'fillText');
+    expect(translateCall.args).toEqual([5, 10]);
+    expect(scaleCall.args).toEqual([1, -1]);
+    expect(fillTextCall.args).toEqual(['X', 0, 0]);
+  });
+
+  test('calls rotate with negated rotation when rotation is set', () => {
+    const ctx = makeMockCtx();
+    new CanvasRenderer(ctx).drawText([{ x: 0, y: 0, char: 'A', rotation: Math.PI / 4 }], 'Arial', 12);
+    const rotateCall = ctx.calls.find((c) => c.name === 'rotate');
+    expect(rotateCall).toBeDefined();
+    expect(rotateCall.args[0]).toBeCloseTo(-Math.PI / 4);
+  });
+
+  test('uses strokeText for highlight pass', () => {
+    const ctx = makeMockCtx();
+    const renderer = new CanvasRenderer(ctx);
+    renderer.setHighlight(true, { r: 255, g: 0, b: 0 }, 2);
+    renderer.drawText([{ x: 0, y: 0, char: 'A' }], 'Arial', 12);
+    expect(ctx.calls.map((c) => c.name)).toContain('strokeText');
+    expect(ctx.calls.map((c) => c.name)).toContain('fillText');
+  });
+});
+
+// ─── state setters ────────────────────────────────────────────────────────────
+
+describe('CanvasRenderer — state setters', () => {
+  test('setColour sets strokeStyle and fillStyle', () => {
+    const ctx = makeMockCtx();
+    const renderer = new CanvasRenderer(ctx);
+    renderer.setColour({ r: 255, g: 0, b: 0 });
+    expect(ctx.strokeStyle).toBeTruthy();
+    expect(ctx.fillStyle).toBeTruthy();
+    expect(ctx.strokeStyle).toBe(ctx.fillStyle);
+  });
+
+  test('setLineWidth sets ctx.lineWidth and is reflected in next drawShape', () => {
+    const ctx = makeMockCtx();
+    const renderer = new CanvasRenderer(ctx);
+    renderer.setLineWidth(4);
+    expect(ctx.lineWidth).toBe(4);
+  });
+
+  test('setDash sets ctx.setLineDash and lineDashOffset', () => {
+    const ctx = makeMockCtx();
+    const renderer = new CanvasRenderer(ctx);
+    renderer.setDash([4, 2], 1);
+    const dashCall = ctx.calls.find((c) => c.name === 'setLineDash');
+    expect(dashCall.args[0]).toEqual([4, 2]);
+    expect(ctx.lineDashOffset).toBe(1);
+  });
+
+  test('save and restore delegate to ctx', () => {
+    const ctx = makeMockCtx();
+    const renderer = new CanvasRenderer(ctx);
+    renderer.save();
+    renderer.restore();
+    expect(ctx.calls.map((c) => c.name)).toEqual(['save', 'restore']);
+  });
+});
+
+// ─── measureText / measureCharWidth ──────────────────────────────────────────
+
+describe('CanvasRenderer — measurement', () => {
+  test('measureText delegates to ctx.measureText', () => {
+    const ctx = makeMockCtx();
+    const result = new CanvasRenderer(ctx).measureText('hello', 'Arial', 12);
+    expect(result).toEqual({ width: 40 }); // 5 chars × 8
+  });
+
+  test('measureCharWidth returns width from ctx.measureText', () => {
+    const ctx = makeMockCtx();
+    expect(new CanvasRenderer(ctx).measureCharWidth('A')).toBe(8);
+  });
+});

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), center=(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 center=(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));
+  });
+});