@design-core/core 0.0.7 → 50.1.0

package/test/integration/exportIntegration.test.js

@@ -11,7 +11,7 @@ import { Lwpolyline } from '../../core/entities/lwpolyline.js';
 import { Hatch } from '../../core/entities/hatch.js';
 import { Insert } from '../../core/entities/insert.js';
 // import { ArcAlignedText } from '../../core/entities/arctext.js';
-import { BasePolyline } from '../../core/entities/basePolyline.js';
+import { PolylineBase } from '../../core/entities/polylineBase.js';
 
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
@@ -106,7 +106,7 @@ beforeAll(() => {
   // core.scene.entities.add(new Text({ points: [new Point(15, 205)], string: 'Solid', height: 4 }));
 
   // Row 2, Col 0: Hatch
-  const boundary = new BasePolyline({
+  const boundary = new PolylineBase({
     points: [new Point(25, 230), new Point(75, 230), new Point(75, 280), new Point(25, 280)],
   });
   const hatch = new Hatch({
@@ -122,7 +122,7 @@ beforeAll(() => {
   blockLine.setProperty('handle', DesignCore.HandleManager.next());
   const block = DesignCore.Scene.blockManager.addItem({
     name: 'TEST_BLOCK',
-    items: [blockLine],
+    entities: [blockLine],
   });
   const insert = new Insert({
     points: [new Point(130, 235)],

package/test/integration/userInputIntegration.test.js

@@ -106,13 +106,13 @@ beforeAll(async () => {
     new Point(90, 50),
   ]);
 
-  // col 1, row 0 — Circle, center (250,50) r=30 → idx 1
+  // col 1, row 0 — Circle, centre (250,50) r=30 → idx 1
   await executeWithInputs(new Circle(), [
     new Point(250, 50),
     30,
   ]);
 
-  // col 2, row 0 — Arc, center (450,50), start (480,50), 270° CCW → idx 2
+  // col 2, row 0 — Arc, centre (450,50), start (480,50), 270° CCW → idx 2
   await executeWithInputs(new Arc(), [
     new Point(450, 50),
     new Point(480, 50),
@@ -149,10 +149,10 @@ beforeAll(async () => {
   // col 0, row 1 — Hatch using the rectangle boundary (idx 6) → idx 7
   {
     const hatchBoundary = DesignCore.Scene.entities.get(6);
-    const origSelectedItems = DesignCore.Scene.selectionManager.selectedItems;
-    DesignCore.Scene.selectionManager.selectedItems = [hatchBoundary];
+    const origSelectedEntities = DesignCore.Scene.selectionManager.selectedEntities;
+    DesignCore.Scene.selectionManager.selectedEntities = [hatchBoundary];
     await executeWithInputs(new Hatch(), ['accept']);
-    DesignCore.Scene.selectionManager.selectedItems = origSelectedItems;
+    DesignCore.Scene.selectionManager.selectedEntities = origSelectedEntities;
   }
 
   // col 1, row 1 — Arc for ArcAlignedText, in its own cell → idx 8

package/test/lib/boundingBox.test.js

@@ -29,9 +29,9 @@ test('Test BoundingBox.yLength', () => {
   expect(bb.yLength).toBe(100);
 });
 
-test('Test BoundingBox.centerPoint', () => {
-  expect(bb.centerPoint.x).toBe(151);
-  expect(bb.centerPoint.y).toBe(152);
+test('Test BoundingBox.centrePoint', () => {
+  expect(bb.centrePoint.x).toBe(151);
+  expect(bb.centrePoint.y).toBe(152);
 });
 
 test('Test BoundingBox.isInside', () => {

package/test/lib/canvas.test.js

@@ -169,7 +169,7 @@ test('Test Canvas.getSceneOffset returns extents', () => {
 });
 
 test('Test Canvas.zoomExtents with entities', () => {
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(500, 500)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(500, 500)] });
   canvas.matrix = new Matrix();
   canvas.width = 800;
   canvas.height = 600;
@@ -496,7 +496,7 @@ test('Test Canvas.doubleClick left and right buttons do not throw', () => {
 test('Test Canvas.doubleClick middle button triggers zoomExtents', () => {
   const testCore = new Core();
   testCore.activate();
-  testCore.scene.addItem('Line', { points: [new Point(0, 0), new Point(500, 500)] });
+  testCore.scene.addEntity('Line', { points: [new Point(0, 0), new Point(500, 500)] });
   testCore.canvas.width = 800;
   testCore.canvas.height = 600;
   testCore.canvas.matrix = new Matrix();
@@ -1138,13 +1138,13 @@ describe('Canvas.exportTo', () => {
   });
 
   test('returns true when scene has entities', () => {
-    exportCore.scene.addItem('Line', { points: [new Point(0, 0), new Point(100, 100)] });
+    exportCore.scene.addEntity('Line', { points: [new Point(0, 0), new Point(100, 100)] });
     const options = new PlotOptions(595, 842);
     expect(exportCanvas.exportTo(renderer, options)).toBe(true);
   });
 
   test('calls renderer.setTransform with a valid matrix', () => {
-    exportCore.scene.addItem('Line', { points: [new Point(0, 0), new Point(100, 100)] });
+    exportCore.scene.addEntity('Line', { points: [new Point(0, 0), new Point(100, 100)] });
     let receivedMatrix;
     renderer.setTransform = (m) => {
       receivedMatrix = m;
@@ -1157,7 +1157,7 @@ describe('Canvas.exportTo', () => {
   });
 
   test('calls renderer.setBackgroundColour with white', () => {
-    exportCore.scene.addItem('Line', { points: [new Point(0, 0), new Point(100, 100)] });
+    exportCore.scene.addEntity('Line', { points: [new Point(0, 0), new Point(100, 100)] });
     let bgColour;
     renderer.setBackgroundColour = (c) => {
       bgColour = c;
@@ -1168,7 +1168,7 @@ describe('Canvas.exportTo', () => {
   });
 
   test('calls renderer.setStyle with the plotOptions style', () => {
-    exportCore.scene.addItem('Line', { points: [new Point(0, 0), new Point(100, 100)] });
+    exportCore.scene.addEntity('Line', { points: [new Point(0, 0), new Point(100, 100)] });
     const options = new PlotOptions(595, 842);
     const spyCalls = [];
     renderer.setStyle = (fn) => {
@@ -1179,7 +1179,7 @@ describe('Canvas.exportTo', () => {
   });
 
   test('EXTENTS uses Scene.boundingBox regardless of viewport', () => {
-    exportCore.scene.addItem('Line', { points: [new Point(0, 0), new Point(500, 500)] });
+    exportCore.scene.addEntity('Line', { points: [new Point(0, 0), new Point(500, 500)] });
     // Pan far away so viewport does not contain the entity
     exportCanvas.matrix.translate(-10000, -10000);
     let receivedMatrix;
@@ -1195,7 +1195,7 @@ describe('Canvas.exportTo', () => {
   });
 
   test('DISPLAY uses current viewport instead of entity extents', () => {
-    exportCore.scene.addItem('Line', { points: [new Point(0, 0), new Point(500, 500)] });
+    exportCore.scene.addEntity('Line', { points: [new Point(0, 0), new Point(500, 500)] });
     let extentsMatrix;
     let displayMatrix;
 
@@ -1222,7 +1222,7 @@ describe('Canvas.exportTo', () => {
   });
 
   test('explicit plotScale is forwarded to buildExportMatrix', () => {
-    exportCore.scene.addItem('Line', { points: [new Point(0, 0), new Point(100, 100)] });
+    exportCore.scene.addEntity('Line', { points: [new Point(0, 0), new Point(100, 100)] });
     let receivedMatrix;
     renderer.setTransform = (m) => {
       receivedMatrix = m;

package/test/lib/inputManager.test.js

@@ -241,7 +241,7 @@ test('onCommandButton with no active command - starts command', () => {
 
 test('starting an entity command from idle clears the selection', () => {
   inputManager.reset();
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
   core.scene.selectionManager.addToSelectionSet(0);
   expect(core.scene.selectionManager.selectionSet.selectionSet.length).toBe(1);
 
@@ -252,7 +252,7 @@ test('starting an entity command from idle clears the selection', () => {
 
 test('starting a tool command from idle preserves the selection', () => {
   inputManager.reset();
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
   core.scene.selectionManager.addToSelectionSet(0);
   expect(core.scene.selectionManager.selectionSet.selectionSet.length).toBe(1);
 
@@ -388,7 +388,7 @@ test('onLeftClick with POINT prompt and no nearby entity - responds with the giv
 
 test('onLeftClick with entity found and no active command - delegates to onSelection', () => {
   inputManager.reset();
-  const mockSelection = { selectedItemIndex: 0 };
+  const mockSelection = { selectedEntityIndex: 0 };
   jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(0);
   jest.spyOn(core.scene.selectionManager, 'singleSelect').mockReturnValue(mockSelection);
   const onSelectionSpy = jest.spyOn(inputManager, 'onSelection').mockImplementation(() => {});
@@ -1183,7 +1183,7 @@ test('highlightEntityUnderMouse returns false when buttonThreeDown is true', ()
 
 test('refreshPreview clears hoverEntities in addition to previewEntities and auxiliaryEntities', () => {
   core.scene.clear();
-  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  core.scene.addEntity('Line', { points: [new Point(0, 0), new Point(10, 0)] });
 
   // Simulate a stale hover glow left by the previous mouseMoved()
   DesignCore.Scene.hoverEntities.add(core.scene.entities.get(0));

package/test/lib/scene.test.js

@@ -11,16 +11,16 @@ test('Test Scene.boundingBox', () => {
   expect(scene.boundingBox()).toBeUndefined();
 
   const line1 = new Line({ points: [new Point(-102, -102), new Point(201, 202)] });
-  // add to scene (bypass scene.addItem())
-  scene.addItem('Line', line1);
+  // add to scene
+  scene.addEntity('Line', line1);
   expect(scene.boundingBox().xMin).toBeCloseTo(-102);
   expect(scene.boundingBox().xMax).toBeCloseTo(201);
   expect(scene.boundingBox().yMin).toBeCloseTo(-102);
   expect(scene.boundingBox().yMax).toBeCloseTo(202);
 
   const line2 = new Line({ points: [new Point(1001, -2002), new Point(-2001, 2002)] });
-  // add to scene (bypass scene.addItem())
-  scene.addItem('Line', line2);
+  // add to scene
+  scene.addEntity('Line', line2);
   expect(scene.boundingBox().xMin).toBeCloseTo(-2001);
   expect(scene.boundingBox().xMax).toBeCloseTo(1001);
   expect(scene.boundingBox().yMin).toBeCloseTo(-2002);
@@ -28,26 +28,26 @@ test('Test Scene.boundingBox', () => {
 });
 
 
-test('Test Scene.addItem', () => {
+test('Test Scene.addEntity', () => {
   // Throw error on missing data
   expect(() => {
-    scene.addItem('Line');
+    scene.addEntity('Line');
   }).toThrow();
 
   // Add a invalid item type
   const itemCnt = scene.entities.count();
-  const returnIndex = scene.addItem('FakeItem', {});
+  const returnIndex = scene.addEntity('FakeItem', {});
   expect(scene.entities.count()).toBe(itemCnt);
   expect(returnIndex).toBeUndefined();
 
   // Add a valid item with data
   const itemCount = scene.entities.count();
-  const index = scene.addItem('Line', { points: [new Point(), new Point(10, 10)] });
+  const index = scene.addEntity('Line', { points: [new Point(), new Point(10, 10)] });
   expect(scene.entities.count()).toBe(itemCount + 1);
   expect(index).toBe(itemCount);
 
   // Add a valid item with data at index - item count should not increase
-  scene.addItem('Line', { points: [new Point(123, 123), new Point(321, 321)] }, index);
+  scene.addEntity('Line', { points: [new Point(123, 123), new Point(321, 321)] }, index);
   expect(scene.entities.count()).toBe(itemCount + 1);
   // check the items points to make sure index was replaced
   expect(scene.entities.get(index).points[0].x).toBe(123);

package/test/lib/selectionManager.test.js

@@ -5,9 +5,9 @@ const core = new Core();
 const selectionManager = core.scene.selectionManager;
 
 // Add a valid item to scene
-core.scene.addItem('Line', { points: [new Point(10, 10), new Point(100, 10)] });
-core.scene.addItem('Line', { points: [new Point(10, 20), new Point(100, 20)] });
-core.scene.addItem('Circle', { points: [new Point(), new Point(5, 0)] });
+core.scene.addEntity('Line', { points: [new Point(10, 10), new Point(100, 10)] });
+core.scene.addEntity('Line', { points: [new Point(10, 20), new Point(100, 20)] });
+core.scene.addEntity('Circle', { points: [new Point(), new Point(5, 0)] });
 
 
 test('Test SelectionManager.findClosestItem', () => {

package/test/lib/snapping.test.js

@@ -9,7 +9,7 @@ const core = new Core();
 const snapping = new Snapping();
 
 // Add a valid item to scene
-core.scene.addItem('Line', { points: [new Point(10, 10), new Point(100, 10)] });
+core.scene.addEntity('Line', { points: [new Point(10, 10), new Point(100, 10)] });
 
 afterEach(() => {
   // Reset all mouse button states so tests don't affect each other via

package/test/properties/propertyManager.test.js

@@ -14,45 +14,45 @@ const data = {
   colour: { r: 100, g: 100, b: 100 },
 };
 
-DesignCore.Scene.addItem('Line', data);
-DesignCore.Scene.addItem('Circle', data);
-DesignCore.Scene.addItem('Text', data);
+DesignCore.Scene.addEntity('Line', data);
+DesignCore.Scene.addEntity('Circle', data);
+DesignCore.Scene.addEntity('Text', data);
 // Add Arc with a different Colour
-DesignCore.Scene.addItem('Arc', { points: [point1, point2], colour: { r: 130, g: 130, b: 130 } });
+DesignCore.Scene.addEntity('Arc', { points: [point1, point2], colour: { r: 130, g: 130, b: 130 } });
 
-test('Test propertyManager.getItemTypes', () => {
+test('Test propertyManager.getEntityTypes', () => {
   // Add an item to the selectionSet
   DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(0);
-  let types = propertiesManager.getItemTypes();
+  let types = propertiesManager.getEntityTypes();
   expect(types.length).toBe(1);
 
   // Add the same item to the selectionSet - shouldn't change the count
   DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(0);
-  types = propertiesManager.getItemTypes();
+  types = propertiesManager.getEntityTypes();
   expect(types.length).toBe(1);
 
   // Add a new item to the selectionSet - result should include 'All'
   DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(1);
-  types = propertiesManager.getItemTypes();
+  types = propertiesManager.getEntityTypes();
   expect(types.length).toBe(3);
   expect(types[0]).toBe('All');
 });
 
-test('Test propertyManager.setItemProperties', () => {
+test('Test propertyManager.setEntityProperties', () => {
   // clear the selection set
   DesignCore.Scene.reset();
   // add the text entity
   DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(2);
   // set the string attribute of the text entity
   const string = 'test text';
-  propertiesManager.setItemProperties('string', string);
+  propertiesManager.setEntityProperties('string', string);
 
   let text = DesignCore.Scene.entities.get(2);
   expect(text.type).toBe('Text');
   expect(text.getProperty('string')).toBe(string);
 
   // try and set a non-existent property
-  propertiesManager.setItemProperties('faux-prop', string);
+  propertiesManager.setEntityProperties('faux-prop', string);
   text = DesignCore.Scene.entities.get(2);
   expect(text['faux-prop']).toBeUndefined();
 
@@ -63,53 +63,53 @@ test('Test propertyManager.setItemProperties', () => {
   // get the current radius
   const radius = DesignCore.Scene.entities.get(1).getProperty('radius');
   // try and set an incorrect value
-  propertiesManager.setItemProperties('radius', string);
+  propertiesManager.setEntityProperties('radius', string);
   const circle = DesignCore.Scene.entities.get(1);
   expect(circle.getProperty('radius')).toBe(radius);
 });
 
-test('Test propertyManager.getItemProperties', () => {
+test('Test propertyManager.getEntityProperties', () => {
   // clear the selection set
   DesignCore.Scene.reset();
 
   // get props with nothing selected - should be undefined
-  let properties = propertiesManager.getItemProperties();
+  let properties = propertiesManager.getEntityProperties();
   expect(properties).toBeUndefined();
 
   // Add the line entity to the selectionSet
   DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(0);
-  properties = propertiesManager.getItemProperties('Line');
+  properties = propertiesManager.getEntityProperties('Line');
   expect(properties.length).toBeGreaterThan(0);
 
   // check properties for All itemTypes
-  properties = propertiesManager.getItemProperties('All');
+  properties = propertiesManager.getEntityProperties('All');
   expect(properties.length).toBeGreaterThan(0);
 
   // get circle props with a line selected - should be 0
-  properties = propertiesManager.getItemProperties('Circle');
+  properties = propertiesManager.getEntityProperties('Circle');
   expect(properties.length).toBe(0);
 });
 
-test('Test propertyManager.getItemPropertyValue', () => {
+test('Test propertyManager.getEntityPropertyValue', () => {
   // clear the selection set
   DesignCore.Scene.reset();
 
   // get props with nothing selected - should be undefined
-  let propertyValues = propertiesManager.getItemPropertyValue();
+  let propertyValues = propertiesManager.getEntityPropertyValue();
   expect(propertyValues).toBeUndefined();
 
   // Add the line entity to the selectionSet
   DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(0);
   // get the line colour
-  propertyValues = propertiesManager.getItemPropertyValue('Line', 'colour');
+  propertyValues = propertiesManager.getEntityPropertyValue('Line', 'colour');
   expect(propertyValues).toEqual(data.colour);
 
   // get circle props with a line selected - should be undefined
-  propertyValues = propertiesManager.getItemPropertyValue('Circle', 'colour');
+  propertyValues = propertiesManager.getEntityPropertyValue('Circle', 'colour');
   expect(propertyValues).toBeUndefined();
 
   // get props for all selected types - index 0 and 3 colour should be Varies
   DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(3);
-  propertyValues = propertiesManager.getItemPropertyValue('All', 'colour');
+  propertyValues = propertiesManager.getEntityPropertyValue('All', 'colour');
   expect(propertyValues).toBe('Varies');
 });

package/test/renderers/pdfRenderer.test.js

@@ -110,7 +110,7 @@ describe('PdfRenderer — drawing', () => {
 
   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
+    // 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], {});
@@ -121,7 +121,7 @@ describe('PdfRenderer — drawing', () => {
 
   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
+    // 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);

package/test/tables/block.test.js

@@ -9,25 +9,38 @@ 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();
 
 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', () => {
@@ -36,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);
 });
@@ -45,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);
 });
 
@@ -63,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);
@@ -75,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);
@@ -154,7 +167,7 @@ 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);
 });
@@ -165,7 +178,7 @@ test('Test Block.dxf throws when a block item has an undefined handle', () => {
   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);
+  block.addEntity(clone);
 
   // Use a real DXFFile (R2000+) so the version-gated handle validation fires
   const file = new DXFFile('R2000');
@@ -179,9 +192,45 @@ test('Test Block.dxf succeeds when block items have valid handles', () => {
   // 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);
+  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/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();

package/test/test-helpers/hatchGridRenderer.js

@@ -15,7 +15,7 @@
 
 import { Core } from '../../core/core/core.js';
 import { Hatch } from '../../core/entities/hatch.js';
-import { BasePolyline } from '../../core/entities/basePolyline.js';
+import { PolylineBase } from '../../core/entities/polylineBase.js';
 import { Point } from '../../core/entities/point.js';
 import { Text } from '../../core/entities/text.js';
 
@@ -136,7 +136,7 @@ export function buildHatchGrid(renderer) {
     let outlinePoints;
 
     if (i % 2 === 0) {
-      hatchBoundary = new BasePolyline({ points: [
+      hatchBoundary = new PolylineBase({ points: [
         new Point(cx - SHAPE_R, cy - SHAPE_R),
         new Point(cx + SHAPE_R, cy - SHAPE_R),
         new Point(cx + SHAPE_R, cy + SHAPE_R),
@@ -145,7 +145,7 @@ export function buildHatchGrid(renderer) {
       outlinePoints = hatchBoundary.toPolylinePoints();
     } else {
       // Two exact semicircle arcs (bulge = 1) for clipping; polygon for visible outline
-      hatchBoundary = new BasePolyline({ points: [
+      hatchBoundary = new PolylineBase({ points: [
         new Point(cx + SHAPE_R, cy, 1),
         new Point(cx - SHAPE_R, cy, 1),
       ] });

package/test/test-helpers/test-helpers.js

@@ -27,10 +27,10 @@ export class File {
  * @param {Function} testFn - async function to run with the mock active
  * @param {object} [options] - optional configuration
  * @param {object} [options.extraMethods] - additional methods to add to the mock inputManager
- * @param {Array} [options.selectedItems] - sequential values returned by entities.get
+ * @param {Array} [options.selectedEntities] - sequential values returned by entities.get
  */
 export async function withMockInput(scene, inputs, testFn, options = {}) {
-  const { extraMethods = {}, selectedItems } = options;
+  const { extraMethods = {}, selectedEntities } = options;
   const origInputManager = scene.inputManager;
   let callCount = 0;
 
@@ -47,11 +47,11 @@ export async function withMockInput(scene, inputs, testFn, options = {}) {
   };
 
   let origGetItem;
-  if (selectedItems) {
+  if (selectedEntities) {
     origGetItem = scene.entities.get;
-    let selectedItemsCallCount = 0;
+    let selectedEntitiesCallCount = 0;
     scene.entities.get = () => {
-      return selectedItems[selectedItemsCallCount++];
+      return selectedEntities[selectedEntitiesCallCount++];
     };
   }
 
@@ -59,7 +59,7 @@ export async function withMockInput(scene, inputs, testFn, options = {}) {
     await testFn();
   } finally {
     scene.inputManager = origInputManager;
-    if (selectedItems) {
+    if (selectedEntities) {
       scene.entities.get = origGetItem;
     }
   }