@design-core/core 0.0.6 → 50.1.0

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,22 @@ 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';
+
+/**
+ * Create a mock requestInput function that returns values from the provided array in order.
+ * @param {Array} inputs
+ * @return {Function}
+ */
+function mockRequestInput(inputs) {
+  let i = 0;
+  return async () => {
+    if (i < inputs.length) return inputs[i++];
+    throw new Error('cancelled');
+  };
+}
 
 new Core();
 
@@ -12,19 +28,19 @@ test('Test Block', () => {
   const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
   const flags = new Flags();
   flags.addValue(1);
-  const block = new Block({ items: [line], flags: flags });
+  const block = new Block({ entities: [line], flags: flags });
 
-  expect(block.items.length).toBe(1);
+  expect(block.entities.length).toBe(1);
   expect(block.flags.getFlagValue()).toBe(1);
 });
 
 test('Test Block.clearItems', () => {
   const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
-  const block = new Block({ items: [line] });
-  expect(block.items.length).toBe(1);
+  const block = new Block({ entities: [line] });
+  expect(block.entities.length).toBe(1);
 
-  block.clearItems();
-  expect(block.items.length).toBe(0);
+  block.clearEntities();
+  expect(block.entities.length).toBe(0);
 });
 
 test('Test Block.snaps', () => {
@@ -33,7 +49,7 @@ test('Test Block.snaps', () => {
   expect(block.snaps()).toHaveLength(0);
 
   const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
-  block.addItem(line);
+  block.addEntity(line);
   expect(block.snaps()).toBeInstanceOf(Array);
   expect(block.snaps()).not.toHaveLength(0);
 });
@@ -42,9 +58,9 @@ test('Test Block', () => {
   const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
   const flags = new Flags();
   flags.addValue(1);
-  const block = new Block({ items: [line], flags: flags });
+  const block = new Block({ entities: [line], flags: flags });
 
-  expect(block.items.length).toBe(1);
+  expect(block.entities.length).toBe(1);
   expect(block.flags.getFlagValue()).toBe(1);
 });
 
@@ -60,7 +76,7 @@ test('Test Block.closestPoint', () => {
   expect(block.closestPoint(point)[1]).toBe(Infinity);
 
   const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
-  block.addItem(line);
+  block.addEntity(line);
   expect(block.closestPoint(point)).toBeInstanceOf(Array);
   expect(block.closestPoint(point)).toHaveLength(2);
   expect(block.closestPoint(point)[0]).toBeInstanceOf(Point);
@@ -72,7 +88,7 @@ test('Test Block.closestPoint', () => {
 test('Test Block.dxf', () => {
   const block = new Block({ handle: '1', endblkHandle: '1' });
   const line = new Line({ handle: '1', points: [new Point(101, 102), new Point(201, 202)] });
-  block.addItem(line);
+  block.addEntity(line);
 
   const file = new File();
   block.dxf(file);
@@ -127,7 +143,7 @@ ByLayer
 31
 0.0
 39
-2
+1
 0
 ENDBLK
 5
@@ -151,7 +167,70 @@ test('Test Block.touched', () => {
   expect(block.touched(selectionExtremesTrue)).toBe(false);
 
   const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
-  block.addItem(line);
+  block.addEntity(line);
   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.addEntity(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.addEntity(clone);
+
+  const file = new DXFFile('R2000');
+  expect(() => block.dxf(file)).not.toThrow();
+  expect(file.contents).toContain(clone.getProperty('handle'));
+});
+
+test('Test Block.execute offsets entity points by the insert point', async () => {
+  new Core();
+
+  // Add a line to the scene at world coordinates (100,200) → (300,400)
+  const line = new Line({ points: [new Point(100, 200), new Point(300, 400)] });
+  DesignCore.Scene.entities.add(line);
+  const lineIndex = DesignCore.Scene.entities.count() - 1;
+
+  // Pre-select the line so Block.execute() skips the selection-set prompt
+  DesignCore.Scene.selectionManager.reset();
+  DesignCore.Scene.selectionManager.addToSelectionSet(lineIndex);
+
+  // Feed: block name, then insert point (50, 75)
+  const insertPoint = new Point(50, 75);
+  const origRequestInput = DesignCore.Scene.inputManager.requestInput.bind(DesignCore.Scene.inputManager);
+  DesignCore.Scene.inputManager.requestInput = mockRequestInput(['TestBlock', insertPoint]);
+
+  await new Block().execute();
+
+  DesignCore.Scene.inputManager.requestInput = origRequestInput;
+
+  // The block should exist in the block manager
+  const block = DesignCore.Scene.blockManager.getItemByName('TestBlock');
+  expect(block).toBeDefined();
+  expect(block.entities).toHaveLength(1);
+
+  // Points inside the block must be offset by -insertPoint so that
+  // when Insert renders them via applyTransform(+insertPoint) they land
+  // back at their original world coordinates.
+  const blockLine = block.entities[0];
+  expect(blockLine.points[0].x).toBeCloseTo(100 - insertPoint.x);
+  expect(blockLine.points[0].y).toBeCloseTo(200 - insertPoint.y);
+  expect(blockLine.points[1].x).toBeCloseTo(300 - insertPoint.x);
+  expect(blockLine.points[1].y).toBeCloseTo(400 - insertPoint.y);
+});

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();

package/test/tables/layerManager.test.js

@@ -91,7 +91,7 @@ test('Test LayerManager.checkStyles', () => {
     layer: newItemName,
   };
 
-  core.scene.addItem('Line', data);
+  core.scene.addEntity('Line', data);
 
   layerManager.checkStyles();
   const layers = layerManager.getItems();
@@ -115,7 +115,7 @@ test('Test LayerManager.checkItems', () => {
     layer: newItemName,
   };
 
-  core.scene.addItem('Line', data);
+  core.scene.addEntity('Line', data);
 
   layerManager.checkItems();
   const layers = layerManager.getItems();