@design-core/core 0.0.7 → 51.1.0

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/clipboard.test.js

@@ -4,6 +4,8 @@ import { Point } from '../../core/entities/point.js';
 import { DesignCore } from '../../core/designCore.js';
 import { Logging } from '../../core/lib/logging.js';
 import { jest } from '@jest/globals';
+import { Polyline } from '../../core/entities/polyline.js';
+import { Text } from '../../core/entities/text.js';
 
 // Initialize core (sets DesignCore.Core)
 new Core();
@@ -67,4 +69,75 @@ describe('Clipboard', () => {
     expect(fresh.Entities).toHaveLength(0);
     errorSpy.mockRestore();
   });
+
+  describe('stringify/parse flag survival', () => {
+    test('closed Polyline retains closed flag after stringify/parse roundtrip', () => {
+      // Create a closed polyline (flags bit 1 = closed)
+      const poly = new Polyline({
+        points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)],
+        flags: 1,
+      });
+      expect(poly.getProperty('closed')).toBe(true);
+
+      DesignCore.Clipboard.Entities = [poly];
+      const json = DesignCore.Clipboard.stringify();
+
+      const fresh = new Clipboard();
+      fresh.parse(json);
+
+      expect(fresh.Entities).toHaveLength(1);
+      expect(fresh.Entities[0].getProperty('closed')).toBe(true);
+    });
+
+    test('closed Polyline retains correct point count after stringify/parse roundtrip', () => {
+      // A closed polyline stores 4 points (not 5 — the closing duplicate is removed)
+      const poly = new Polyline({
+        points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)],
+        flags: 1,
+      });
+      expect(poly.points).toHaveLength(4);
+
+      DesignCore.Clipboard.Entities = [poly];
+      const json = DesignCore.Clipboard.stringify();
+
+      const fresh = new Clipboard();
+      fresh.parse(json);
+
+      expect(fresh.Entities[0].points).toHaveLength(4);
+    });
+
+    test('backwards (mirrored) Text retains backwards flag after stringify/parse roundtrip', () => {
+      // Text flags bit 2 = backwards
+      const text = new Text({
+        points: [new Point(0, 0), new Point(10, 0)],
+        textValue: 'hello',
+        flags: 2,
+      });
+      expect(text.getBackwards()).toBe(true);
+
+      DesignCore.Clipboard.Entities = [text];
+      const json = DesignCore.Clipboard.stringify();
+
+      const fresh = new Clipboard();
+      fresh.parse(json);
+
+      expect(fresh.Entities).toHaveLength(1);
+      expect(fresh.Entities[0].getBackwards()).toBe(true);
+    });
+
+    test('non-flagged entities are unaffected', () => {
+      const poly = new Polyline({
+        points: [new Point(0, 0), new Point(10, 0), new Point(10, 10)],
+      });
+      expect(poly.getProperty('closed')).toBe(false);
+
+      DesignCore.Clipboard.Entities = [poly];
+      const json = DesignCore.Clipboard.stringify();
+
+      const fresh = new Clipboard();
+      fresh.parse(json);
+
+      expect(fresh.Entities[0].getProperty('closed')).toBe(false);
+    });
+  });
 });

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/flags.test.js

@@ -162,3 +162,27 @@ test('Test flags.removeValue', () => {
   // 2 shouldn't exist again
   expect(flags.hasFlag(2)).toBe(false);
 });
+
+test('Test flags.toJSON returns the numeric flag value', () => {
+  const flags = new Flags();
+  expect(flags.toJSON()).toBe(0);
+
+  flags.setFlagValue(7);
+  expect(flags.toJSON()).toBe(7);
+});
+
+test('Test flags.toJSON round-trips through JSON.stringify/parse', () => {
+  const flags = new Flags();
+  flags.setFlagValue(1);
+
+  // JSON.stringify should produce the plain number, not a nested object
+  const json = JSON.stringify({ flags });
+  expect(json).toBe('{"flags":1}');
+
+  // The parsed value is a plain number — Flags constructor accepts it via setFlagValue
+  const parsed = JSON.parse(json);
+  const restored = new Flags();
+  restored.setFlagValue(parsed.flags);
+  expect(restored.getFlagValue()).toBe(1);
+  expect(restored.hasFlag(1)).toBe(true);
+});

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,124 @@ 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');
 });
+
+test('Test propertyManager.getEntityPropertyDefinition', () => {
+  // clear the selection set
+  DesignCore.Scene.reset();
+
+  // returns undefined when nothing is selected
+  let def = propertiesManager.getEntityPropertyDefinition('All', 'colour');
+  expect(def).toBeUndefined();
+
+  // select the line entity
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(0);
+
+  // returns a Property descriptor for a valid property
+  def = propertiesManager.getEntityPropertyDefinition('All', 'colour');
+  expect(def).toBeDefined();
+  expect(typeof def.type).toBe('string');
+
+  // returns undefined for a property the entity does not have
+  def = propertiesManager.getEntityPropertyDefinition('All', 'non-existent-prop');
+  expect(def).toBeUndefined();
+
+  // filters by entityType — Circle not selected, so returns undefined
+  def = propertiesManager.getEntityPropertyDefinition('Circle', 'colour');
+  expect(def).toBeUndefined();
+});
+
+test('Test propertyManager.getEntityForProperty', () => {
+  // clear the selection set
+  DesignCore.Scene.reset();
+
+  // returns undefined when nothing is selected
+  let entity = propertiesManager.getEntityForProperty('All', 'colour');
+  expect(entity).toBeUndefined();
+
+  // select the line (index 0) and circle (index 1)
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(0);
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(1);
+
+  // returns an entity for 'All' and a known property
+  entity = propertiesManager.getEntityForProperty('All', 'colour');
+  expect(entity).toBeDefined();
+  expect(entity.type === 'Line' || entity.type === 'Circle').toBe(true);
+
+  // filters by entityType — only Circle entities
+  entity = propertiesManager.getEntityForProperty('Circle', 'colour');
+  expect(entity).toBeDefined();
+  expect(entity.type).toBe('Circle');
+
+  // returns undefined when the property does not exist on any selected entity
+  entity = propertiesManager.getEntityForProperty('All', 'non-existent-prop');
+  expect(entity).toBeUndefined();
+});
+
+test('Test propertyManager.setPropertyCallbackFunction and selectionSetChanged', () => {
+  let callCount = 0;
+  const callback = () => {
+    callCount++;
+  };
+
+  // selectionSetChanged with no callback set should not throw
+  propertiesManager.selectionSetChanged();
+
+  propertiesManager.setPropertyCallbackFunction(callback);
+
+  // callback is invoked when selectionSetChanged is called
+  propertiesManager.selectionSetChanged();
+  expect(callCount).toBe(1);
+
+  propertiesManager.selectionSetChanged();
+  expect(callCount).toBe(2);
+});

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