@design-core/core 0.0.5 → 0.0.7

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');
+});

package/test/renderers/svgRenderer.test.js

@@ -0,0 +1,326 @@
+import { SvgRenderer } from '../../core/lib/renderers/svgRenderer.js';
+import { RendererBase } from '../../core/lib/renderers/rendererBase.js';
+import { Point } from '../../core/entities/point.js';
+import { Text } from '../../core/entities/text.js';
+
+describe('SvgRenderer — getOutput()', () => {
+  test('produces valid SVG with XML declaration', () => {
+    const renderer = new SvgRenderer(100, 100);
+    expect(renderer.getOutput().startsWith('<?xml version="1.0" encoding="UTF-8"?>')).toBe(true);
+  });
+
+  test('contains svg element with correct dimensions', () => {
+    const renderer = new SvgRenderer(595, 842);
+    const output = renderer.getOutput();
+    expect(output).toContain('<svg xmlns="http://www.w3.org/2000/svg" width="595" height="842"');
+    expect(output).toContain('viewBox="0 0 595 842"');
+  });
+
+  test('contains Y-flip group for scene coordinate conversion', () => {
+    const renderer = new SvgRenderer(100, 200);
+    expect(renderer.getOutput()).toContain('translate(0,200) scale(1,-1)');
+  });
+
+  test('ends with </svg>', () => {
+    const renderer = new SvgRenderer(100, 100);
+    expect(renderer.getOutput().trim().endsWith('</svg>')).toBe(true);
+  });
+
+  test('fillBackground emits rect before Y-flip group', () => {
+    const renderer = new SvgRenderer(200, 100);
+    renderer.setBackgroundColour({ r: 30, g: 30, b: 30 });
+    renderer.fillBackground();
+    const output = renderer.getOutput();
+    const rectPos = output.indexOf('<rect');
+    const flipPos = output.indexOf('scale(1,-1)');
+    expect(rectPos).toBeGreaterThan(-1);
+    expect(flipPos).toBeGreaterThan(rectPos);
+    expect(output).toContain('fill="rgb(30,30,30)"');
+  });
+});
+
+describe('SvgRenderer — drawing', () => {
+  test('drawShape emits path element with M and L commands', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 20 }], {});
+    const output = renderer.getOutput();
+    expect(output).toContain('<path');
+    expect(output).toContain('M 0 0');
+    expect(output).toContain('L 10 20');
+  });
+
+  test('drawShape with closed=true emits Z in path d', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }, { x: 5, y: 10 }], { closed: true });
+    expect(renderer.getOutput()).toContain('Z');
+  });
+
+  test('drawShape defaults to stroke=true with fill="none"', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 255, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], {});
+    const output = renderer.getOutput();
+    expect(output).toContain('stroke="rgb(255,0,0)"');
+    expect(output).toContain('fill="none"');
+  });
+
+  test('drawShape with fill=true, stroke=false emits fill colour and stroke="none"', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 128, b: 0 });
+    renderer.setLineWidth(1);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], { fill: true, stroke: false });
+    const output = renderer.getOutput();
+    expect(output).toContain('fill="rgb(0,128,0)"');
+    expect(output).toContain('stroke="none"');
+  });
+
+  test('drawShape with bulge emits A arc command', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    // bulge = 1 → semicircle CCW
+    const p1 = new Point(100, 50, 1);
+    const p2 = new Point(-100, 50);
+    renderer.drawShape([p1, p2], {});
+    expect(renderer.getOutput()).toContain(' A ');
+  });
+
+  test('drawShape arc: large-arc-flag is 0 for |bulge| <= 1', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    const p1 = new Point(10, 0, 1); // bulge=1 → semicircle, |bulge| not > 1
+    const p2 = new Point(-10, 0);
+    renderer.drawShape([p1, p2], {});
+    // A rx ry 0 0 sweep x y — large-arc-flag = 0
+    expect(renderer.getOutput()).toMatch(/A [\d.]+ [\d.]+ 0 0 /);
+  });
+
+  test('drawShape arc: large-arc-flag is 1 for |bulge| > 1', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    const p1 = new Point(10, 0, 2); // |bulge| > 1 → major arc
+    const p2 = new Point(-10, 0);
+    renderer.drawShape([p1, p2], {});
+    // A rx ry 0 1 sweep x y — large-arc-flag = 1
+    expect(renderer.getOutput()).toMatch(/A [\d.]+ [\d.]+ 0 1 /);
+  });
+
+  test('drawShape arc: sweep-flag is 1 for bulge > 0 (CCW in Y-up)', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    const p1 = new Point(10, 0, 1); // CCW
+    const p2 = new Point(-10, 0);
+    renderer.drawShape([p1, p2], {});
+    // A rx ry 0 large-arc 1 x y
+    expect(renderer.getOutput()).toMatch(/A [\d.]+ [\d.]+ 0 \d 1 /);
+  });
+
+  test('drawShape arc: sweep-flag is 0 for bulge < 0 (CW in Y-up)', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    const p1 = new Point(10, 0, -1); // CW
+    const p2 = new Point(-10, 0);
+    renderer.drawShape([p1, p2], {});
+    // A rx ry 0 large-arc 0 x y
+    expect(renderer.getOutput()).toMatch(/A [\d.]+ [\d.]+ 0 \d 0 /);
+  });
+
+  test('drawSegments solid emits one path element', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    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('M 0 0 L 10 0');
+    expect(output).toContain('M 20 0 L 30 0');
+    // Both segments in one <path>
+    expect((output.match(/<path/g) ?? []).length).toBe(1);
+  });
+
+  test('drawSegments dashed emits one path per segment with stroke-dasharray', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    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('stroke-dasharray="5,3"');
+    expect(output).toContain('stroke-dashoffset="0"');
+    expect(output).toContain('stroke-dashoffset="5"');
+    expect((output.match(/<path/g) ?? []).length).toBe(2);
+  });
+
+  test('drawText emits text element with character and transform', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.drawText([{ char: 'A', x: 10, y: 20, rotation: 0 }], 'Helvetica', 5);
+    const output = renderer.getOutput();
+    expect(output).toContain('<text');
+    expect(output).toContain('>A<');
+    expect(output).toContain('font-family="Helvetica"');
+    expect(output).toContain('font-size="5"');
+    expect(output).toContain('translate(10,20)');
+  });
+
+  test('drawText with rotation includes rotate in transform', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    const r = Math.PI / 4; // 45 degrees
+    renderer.drawText([{ char: 'X', x: 0, y: 0, rotation: r }], 'Helvetica', 5);
+    // -45 degrees in transform (negated for Y-flip compensation)
+    expect(renderer.getOutput()).toContain('rotate(-45)');
+  });
+
+  test('drawText escapes XML special characters', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.drawText([{ char: '<', x: 0, y: 0, rotation: 0 }], 'Helvetica', 5);
+    expect(renderer.getOutput()).toContain('&lt;');
+  });
+});
+
+describe('SvgRenderer — state methods', () => {
+  test('setColour affects stroke and fill on subsequent drawShape', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 100, g: 150, b: 200 });
+    renderer.setLineWidth(1);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 1, y: 0 }], {});
+    expect(renderer.getOutput()).toContain('rgb(100,150,200)');
+  });
+
+  test('setLineWidth affects stroke-width on drawShape', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(3.5);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 1, y: 0 }], {});
+    expect(renderer.getOutput()).toContain('stroke-width="3.5"');
+  });
+
+  test('setDash with array emits stroke-dasharray on drawShape', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    renderer.setDash([5, 3], 1);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], {});
+    const output = renderer.getOutput();
+    expect(output).toContain('stroke-dasharray="5,3"');
+    expect(output).toContain('stroke-dashoffset="1"');
+  });
+
+  test('setHighlight is a no-op (does not add content)', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setHighlight(true, { r: 255, g: 0, b: 0 }, 5);
+    const output = renderer.getOutput();
+    // Only the structural SVG tags — no extra elements
+    expect((output.match(/<path/g) ?? []).length).toBe(0);
+    expect((output.match(/<text/g) ?? []).length).toBe(0);
+  });
+});
+
+describe('SvgRenderer — transform methods', () => {
+  test('setTransform emits matrix group', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setTransform({ a: 2, d: 2, e: 10, f: 20 });
+    expect(renderer.getOutput()).toContain('matrix(2 0 0 2 10 20)');
+  });
+
+  test('setTransform group is automatically closed in getOutput()', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setTransform({ a: 1, d: 1, e: 0, f: 0 });
+    const output = renderer.getOutput();
+    // Every <g must have a matching </g>
+    const opens = (output.match(/<g[\s>]/g) ?? []).length;
+    const closes = (output.match(/<\/g>/g) ?? []).length;
+    expect(opens).toBe(closes);
+  });
+
+  test('save and restore emit balanced <g> and </g>', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.save();
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(1);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 1, y: 0 }], {});
+    renderer.restore();
+    const output = renderer.getOutput();
+    const opens = (output.match(/<g[\s>]/g) ?? []).length;
+    const closes = (output.match(/<\/g>/g) ?? []).length;
+    expect(opens).toBe(closes);
+  });
+
+  test('applyTransform updates innermost plain <g> with transform attribute', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.save();
+    renderer.applyTransform({ x: 5, y: 10, rotation: 0 });
+    renderer.restore();
+    expect(renderer.getOutput()).toContain('translate(5,10)');
+  });
+});
+
+describe('SvgRenderer — measurement', () => {
+  test('measureText returns width matching Text.getApproximateWidth', () => {
+    const renderer = new SvgRenderer(100, 100);
+    const result = renderer.measureText('Hello', 'Helvetica', 10);
+    expect(result.width).toBeCloseTo(Text.getApproximateWidth('Hello', 10), 5);
+  });
+
+  test('measureCharWidth returns per-character width', () => {
+    const renderer = new SvgRenderer(100, 100);
+    expect(renderer.measureCharWidth('M')).toBeCloseTo(Text.getApproximateWidth('M', 1), 5);
+  });
+});
+
+describe('SvgRenderer — plot styles', () => {
+  /**
+   * @param {SvgRenderer} renderer
+   */
+  function drawLine(renderer) {
+    renderer.setLineWidth(1);
+    renderer.drawShape([{ x: 0, y: 0 }, { x: 10, y: 0 }], {});
+  }
+
+  test('default style NONE renders colour unchanged', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setColour({ r: 255, g: 0, b: 0 });
+    drawLine(renderer);
+    expect(renderer.getOutput()).toContain('stroke="rgb(255,0,0)"');
+  });
+
+  test('style MONOCHROME maps all colours to black', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setStyle(RendererBase.Styles.MONOCHROME);
+    renderer.setColour({ r: 255, g: 0, b: 0 });
+    drawLine(renderer);
+    expect(renderer.getOutput()).toContain('stroke="rgb(0,0,0)"');
+  });
+
+  test('style GREYSCALE maps colour to grey', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setStyle(RendererBase.Styles.GREYSCALE);
+    renderer.setColour({ r: 255, g: 0, b: 0 }); // 0.299*255 ≈ 76
+    drawLine(renderer);
+    expect(renderer.getOutput()).toContain('stroke="rgb(76,76,76)"');
+  });
+
+  test('setStyle with null falls back to NONE', () => {
+    const renderer = new SvgRenderer(100, 100);
+    renderer.setStyle(RendererBase.Styles.MONOCHROME);
+    renderer.setStyle(null); // reset to NONE
+    renderer.setColour({ r: 0, g: 128, b: 255 });
+    drawLine(renderer);
+    expect(renderer.getOutput()).toContain('stroke="rgb(0,128,255)"');
+  });
+});

package/test/tables/block.test.js

@@ -5,6 +5,9 @@ import { Point } from '../../core/entities/point.js';
 
 import { File } from '../test-helpers/test-helpers.js';
 import { Flags } from '../../core/properties/flags.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Utils } from '../../core/lib/utils.js';
+import { DXFFile } from '../../core/lib/dxf/dxfFile.js';
 
 new Core();
 
@@ -127,7 +130,7 @@ ByLayer
 31
 0.0
 39
-2
+1
 0
 ENDBLK
 5
@@ -155,3 +158,30 @@ test('Test Block.touched', () => {
   expect(block.touched(selectionExtremesTrue)).toBe(true);
   expect(block.touched(selectionExtremesFalse)).toBe(false);
 });
+
+test('Test Block.dxf throws when a block item has an undefined handle', () => {
+  const block = new Block({ handle: '1', endblkHandle: '2' });
+  // cloneObject clears the handle, simulating an item added without a handle assignment
+  const line = new Line({ handle: '3', points: [new Point(0, 0), new Point(1, 1)] });
+  const clone = Utils.cloneObject(line);
+  expect(clone.getProperty('handle')).toBeUndefined();
+  block.addItem(clone);
+
+  // Use a real DXFFile (R2000+) so the version-gated handle validation fires
+  const file = new DXFFile('R2000');
+  expect(() => block.dxf(file)).toThrow();
+});
+
+test('Test Block.dxf succeeds when block items have valid handles', () => {
+  const block = new Block({ handle: '1', endblkHandle: '2' });
+  const line = new Line({ handle: '3', points: [new Point(0, 0), new Point(1, 1)] });
+  const clone = Utils.cloneObject(line);
+  // simulate the handle assignment done in Block.execute()
+  clone.setProperty('handle', DesignCore.HandleManager.next());
+  expect(clone.getProperty('handle')).toMatch(/^[0-9A-F]+$/i);
+  block.addItem(clone);
+
+  const file = new DXFFile('R2000');
+  expect(() => block.dxf(file)).not.toThrow();
+  expect(file.contents).toContain(clone.getProperty('handle'));
+});

package/test/tables/endblk.test.js

@@ -3,12 +3,12 @@ import { File } from '../test-helpers/test-helpers.js';
 
 test('Test EndBlock constructor defaults', () => {
   const endblk = new EndBlock();
-  expect(endblk.layer).toBe('0');
+  expect(endblk.getProperty('layer')).toBe('0');
 });
 
 test('Test EndBlock constructor with layer', () => {
   const endblk = new EndBlock({ 8: 'TestLayer' });
-  expect(endblk.layer).toBe('TestLayer');
+  expect(endblk.getProperty('layer')).toBe('TestLayer');
 });
 
 test('Test EndBlock.dxf', () => {

package/test/tables/layer.test.js

@@ -62,6 +62,36 @@ test('Test Layer.isSelectable', () => {
   expect(layer.isSelectable).toBe(true);
 });
 
+test('Test Layer.isPlottable - defaults to true', () => {
+  const layer = new Layer();
+  expect(layer.isPlottable).toBe(true);
+});
+
+test('Test Layer.isPlottable - false when plotting is false', () => {
+  const layer = new Layer();
+  layer.plotting = false;
+  expect(layer.isPlottable).toBe(false);
+});
+
+test('Test Layer.isPlottable - false when layer is frozen', () => {
+  const layer = new Layer();
+  layer.frozen = true;
+  expect(layer.isPlottable).toBe(false);
+});
+
+test('Test Layer.isPlottable - false when layer is off', () => {
+  const layer = new Layer();
+  layer.on = false;
+  expect(layer.isPlottable).toBe(false);
+});
+
+test('Test Layer.isPlottable - false when both plotting false and frozen', () => {
+  const layer = new Layer();
+  layer.plotting = false;
+  layer.frozen = true;
+  expect(layer.isPlottable).toBe(false);
+});
+
 test('Test Layer.dxf', () => {
   const layer = new Layer({ handle: 'A', name: 'TestLayer' });
   const file = new File();