@design-core/core 0.0.6 → 50.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-core/core",
-  "version": "0.0.6",
+  "version": "50.1.0",
   "type": "module",
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
@@ -9,7 +9,7 @@
     "eslint": "^8.26.0",
     "eslint-config-google": "^0.14.0",
     "eslint-config-standard": "^17.0.0",
-    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-n": "^15.3.0",
     "eslint-plugin-promise": "^6.1.1",
     "jest": "^29.7.0"
@@ -17,7 +17,9 @@
   "description": "2D CAD Library",
   "exports": {
     ".": "./core/core/core.js",
-    "./designCore.js": "./core/designCore.js"
+    "./designCore.js": "./core/designCore.js",
+    "./property.js": "./core/properties/property.js",
+    "./canvasRenderer.js": "./core/lib/renderers/canvasRenderer.js"
   },
   "directories": {
     "test": "test"

package/test/dimensions/alignedDimension.test.js

@@ -13,14 +13,14 @@ const scenarios = [
 
   { desc: 'Aligned dimension from point selection',
     input: [new Point(), new Point(10, 0), new Point(5, 5)],
-    selectedItems: [],
+    selectedEntities: [],
     expectedDimType: 1,
     dimensionValue: 10,
   },
 ];
 
 test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
-  const { input, selectedItems, expectedDimType, dimensionValue } = scenario;
+  const { input, selectedEntities, expectedDimType, dimensionValue } = scenario;
 
   await withMockInput(DesignCore.Scene, input, async () => {
     const dim = new AlignedDimension();
@@ -34,10 +34,10 @@ test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
     // check if the text value matches the expected dimension value
     for (const entity of dimensionBlockEntities) {
       if (entity.type === 'Text') {
-        expect(Number(entity.string)).toBeCloseTo(dimensionValue);
+        expect(Number(entity.getProperty('string'))).toBeCloseTo(dimensionValue);
       }
     }
-  }, { selectedItems });
+  }, { selectedEntities });
 });
 
 test('constructor sets default properties', () => {
@@ -104,23 +104,29 @@ describe('AlignedDimension.getPointsFromSelection', () => {
 });
 
 test('AlignedDimension.preview runs without error and calls createTempItem', () => {
-  const origCreateTempItem = DesignCore.Scene.tempEntities.create;
+  const origAddAux = DesignCore.Scene.auxiliaryEntities.add;
+  const origCreateTempItem = DesignCore.Scene.previewEntities.create;
   const origPointOnScene = DesignCore.Mouse.pointOnScene;
   // Manual mock for createTempItem
   const createTempItemCalls = [];
-  DesignCore.Scene.tempEntities.create = function(type, obj) {
+  DesignCore.Scene.previewEntities.create = function(type, obj) {
     createTempItemCalls.push([type, obj]);
   };
+  // Manual mock for auxiliaryEntities.add
+  const addAuxCalls = [];
+  DesignCore.Scene.auxiliaryEntities.add = function(item) {
+    addAuxCalls.push(item);
+  };
   // Manual mock for pointOnScene
   DesignCore.Mouse.pointOnScene = function() {
     return new Point(5, 5);
   };
 
-  // Test with 1 point (should call createTempItem with 'Line')
+  // Test with 1 point (should add a RubberBand to auxiliaryEntities)
   const dim1 = new AlignedDimension();
   dim1.points = [new Point(0, 0)];
   expect(() => dim1.preview()).not.toThrow();
-  expect(createTempItemCalls.some((call) => call[0] === 'Line')).toBe(true);
+  expect(addAuxCalls.length).toBeGreaterThanOrEqual(1);
 
   // Test with >1 point (should call createTempItem with this.type)
   const dim2 = new AlignedDimension();
@@ -129,7 +135,8 @@ test('AlignedDimension.preview runs without error and calls createTempItem', ()
   expect(createTempItemCalls.some((call) => call[0] === dim2.type)).toBe(true);
 
   // Restore
-  DesignCore.Scene.tempEntities.create = origCreateTempItem;
+  DesignCore.Scene.auxiliaryEntities.add = origAddAux;
+  DesignCore.Scene.previewEntities.create = origCreateTempItem;
   DesignCore.Mouse.pointOnScene = origPointOnScene;
 });
 
@@ -204,7 +211,7 @@ AcDbAlignedDimension
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newDimension = new AlignedDimension(dimension);
+  const newDimension = new AlignedDimension({ handle: dimension.getProperty('handle'), points: dimension.points, ...dimension });
   file = new File();
   newDimension.dxf(file);
   expect(file.contents).toEqual(dxfString);

package/test/dimensions/angularDimension.test.js

@@ -18,35 +18,35 @@ const scenarios = [
 
   { desc: 'Angular dimension from line selection - 45 degrees',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, 5)],
-    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
     expectedDimType: 2,
     dimensionValue: 45,
     dimensionEntities: 5,
   },
   { desc: 'Angular dimension from line selection - 135 degrees',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(-5, 5)],
-    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
     expectedDimType: 2,
     dimensionValue: 135,
     dimensionEntities: 6,
   },
   { desc: 'Angular dimension from line selection - 45 degrees',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(-5, -5)],
-    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
     expectedDimType: 2,
     dimensionValue: 45,
     dimensionEntities: 7,
   },
   { desc: 'Angular dimension from line selection - 135 degrees',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, -5)],
-    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
     expectedDimType: 2,
     dimensionValue: 135,
     dimensionEntities: 6,
   },
   { desc: 'Angular dimension from polyline selection - 45 degrees',
     input: [new SingleSelection(0, new Point(5, 0)), new SingleSelection(1, new Point(5, 5)), new Point(5, 5)],
-    selectedItems: [new Polyline({ points: [new Point(0, 0), new Point(10, 0)] }), new Polyline({ points: [new Point(0, 0), new Point(10, 10)] })],
+    selectedEntities: [new Polyline({ points: [new Point(0, 0), new Point(10, 0)] }), new Polyline({ points: [new Point(0, 0), new Point(10, 10)] })],
     expectedDimType: 2,
     dimensionValue: 45,
     dimensionEntities: 5,
@@ -54,7 +54,7 @@ const scenarios = [
 ];
 
 test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
-  const { input, selectedItems, expectedDimType, dimensionValue, dimensionEntities } = scenario;
+  const { input, selectedEntities, expectedDimType, dimensionValue, dimensionEntities } = scenario;
 
   await withMockInput(DesignCore.Scene, input, async () => {
     const dim = new AngularDimension();
@@ -69,12 +69,12 @@ test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
     for (const entity of dimensionBlockEntities) {
       if (entity.type === 'Text') {
         // remove all non-numeric characters except . and -
-        const numbersOnly = entity.string.replace(/[^0-9.-]+/g, '');
+        const numbersOnly = entity.getProperty('string').replace(/[^0-9.-]+/g, '');
         expect(Number(numbersOnly)).toBeCloseTo(dimensionValue);
-        expect(entity.string).toContain('°');
+        expect(entity.getProperty('string')).toContain('°');
       }
     }
-  }, { selectedItems });
+  }, { selectedEntities });
 });
 
 test('constructor sets default properties', () => {
@@ -100,11 +100,11 @@ test('getPointsFromSelection returns correct sequenced points', () => {
 });
 
 test('AngularDimension.preview runs without error and calls createTempItem', () => {
-  const origCreateTempItem = DesignCore.Scene.tempEntities.create;
+  const origCreateTempItem = DesignCore.Scene.previewEntities.create;
   const origPointOnScene = DesignCore.Mouse.pointOnScene;
   // Manual mock for createTempItem
   const createTempItemCalls = [];
-  DesignCore.Scene.tempEntities.create = function(type, obj) {
+  DesignCore.Scene.previewEntities.create = function(type, obj) {
     createTempItemCalls.push([type, obj]);
   };
   // Manual mock for pointOnScene
@@ -138,7 +138,7 @@ test('AngularDimension.preview runs without error and calls createTempItem', ()
   expect(createTempItemCalls.some((call) => call[0] === dim2.type)).toBe(true);
 
   // Restore
-  DesignCore.Scene.tempEntities.create = origCreateTempItem;
+  DesignCore.Scene.previewEntities.create = origCreateTempItem;
   DesignCore.Mouse.pointOnScene = origPointOnScene;
 });
 
@@ -234,7 +234,7 @@ AcDb2LineAngularDimension
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newDimension = new AngularDimension(dimension);
+  const newDimension = new AngularDimension({ handle: dimension.getProperty('handle'), points: dimension.points, ...dimension });
   file = new File();
   newDimension.dxf(file);
   expect(file.contents).toEqual(dxfString);

package/test/dimensions/diametricDimension.test.js

@@ -17,28 +17,28 @@ const scenarios = [
 
   { desc: 'Diametric dimension from circle selection - Text outside circle',
     input: [new SingleSelection(0, new Point()), new Point(20, 0)],
-    selectedItems: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
+    selectedEntities: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
     expectedDimType: 3,
     dimensionValue: 20,
     dimensionEntities: 6,
   },
   { desc: 'Diametric dimension from circle selection - Text inside circle',
     input: [new SingleSelection(0, new Point()), new Point(0, 0)],
-    selectedItems: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
+    selectedEntities: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
     expectedDimType: 3,
     dimensionValue: 20,
     dimensionEntities: 5,
   },
   { desc: 'Diametric dimension from arc selection',
     input: [new SingleSelection(0, new Point()), new Point(20, 10)],
-    selectedItems: [new Arc({ points: [new Point(0, 0), new Point(20, 0), new Point(20, 20)] })],
+    selectedEntities: [new Arc({ points: [new Point(0, 0), new Point(20, 0), new Point(20, 20)] })],
     expectedDimType: 3,
     dimensionValue: 40,
     dimensionEntities: 6,
   },
   { desc: 'Diametric dimension from polyline selection',
     input: [new SingleSelection(0, new Point(30, 10)), new Point(30, 10)],
-    selectedItems: [new Polyline({ points: [new Point(0, 0), new Point(20, 0, 1), new Point(20, 20)] })],
+    selectedEntities: [new Polyline({ points: [new Point(0, 0), new Point(20, 0, 1), new Point(20, 20)] })],
     expectedDimType: 3,
     dimensionValue: 20,
     dimensionEntities: 6,
@@ -46,7 +46,7 @@ const scenarios = [
 ];
 
 test.each(scenarios)('DiametricDimension.execute handles $desc', async (scenario) => {
-  const { input, selectedItems, expectedDimType, dimensionValue, dimensionEntities } = scenario;
+  const { input, selectedEntities, expectedDimType, dimensionValue, dimensionEntities } = scenario;
 
   await withMockInput(DesignCore.Scene, input, async () => {
     const dim = new DiametricDimension();
@@ -61,12 +61,12 @@ test.each(scenarios)('DiametricDimension.execute handles $desc', async (scenario
     for (const entity of dimensionBlockEntities) {
       if (entity.type === 'Text') {
         // remove all none numberic characters except . and -
-        const numbersOnly = entity.string.replace(/[^0-9.-]+/g, '');
+        const numbersOnly = entity.getProperty('string').replace(/[^0-9.-]+/g, '');
         expect(Number(numbersOnly)).toBeCloseTo(dimensionValue);
-        expect(entity.string).toContain('Ø');
+        expect(entity.getProperty('string')).toContain('Ø');
       }
     }
-  }, { selectedItems });
+  }, { selectedEntities });
 });
 
 test('constructor sets default properties', () => {
@@ -77,26 +77,26 @@ test('constructor sets default properties', () => {
 
 
 test('getPointsFromSelection returns correct sequenced points', () => {
-  const center = new Point(0, 0);
+  const centre = new Point(0, 0);
   const textPos = new Point(10, 0);
   // Mock item with getRadius
-  const item = { points: [center], getRadius: () => 10 };
+  const item = { points: [centre], getRadius: () => 10 };
   const result = DiametricDimension.getPointsFromSelection([item], textPos);
   expect(Array.isArray(result)).toBe(true);
   expect(result.length).toBe(3);
-  expect(result[0].sequence).toBe(10); // center
+  expect(result[0].sequence).toBe(10); // centre
   expect(result[1].sequence).toBe(15); // radius point
   expect(result[2].sequence).toBe(11); // text position
 });
 
 test('DiametricDimension.preview runs without error and calls createTempItem', () => {
-  const origCreateTempItem = DesignCore.Scene.tempEntities.create;
+  const origCreateTempItem = DesignCore.Scene.previewEntities.create;
   const origPointOnScene = DesignCore.Mouse.pointOnScene;
   const origSeletionSet = DesignCore.Scene.selectionManager.selectionSet.selectionSet.length;
 
   // Manual mock for createTempItem
   const createTempItemCalls = [];
-  DesignCore.Scene.tempEntities.create = function(type, obj) {
+  DesignCore.Scene.previewEntities.create = function(type, obj) {
     createTempItemCalls.push([type, obj]);
   };
   // Manual mock for pointOnScene
@@ -130,7 +130,7 @@ test('DiametricDimension.preview runs without error and calls createTempItem', (
   expect(createTempItemCalls.some((call) => call[0] === dim2.type)).toBe(true);
 
   // Restore
-  DesignCore.Scene.tempEntities.create = origCreateTempItem;
+  DesignCore.Scene.previewEntities.create = origCreateTempItem;
   DesignCore.Mouse.pointOnScene = origPointOnScene;
   DesignCore.Scene.selectionManager.selectionSet.selectionSet.length = origSeletionSet;
 });
@@ -196,7 +196,7 @@ AcDbDiametricDimension
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newDimension = new DiametricDimension(dimension);
+  const newDimension = new DiametricDimension({ handle: dimension.getProperty('handle'), points: dimension.points, ...dimension });
   file = new File();
   newDimension.dxf(file);
   expect(file.contents).toEqual(dxfString);

package/test/dimensions/dimension.test.js

@@ -18,61 +18,61 @@ const scenarios = [
 
   { desc: 'Rotated dimension from line selection',
     input: [new SingleSelection(0, new Point()), new Point(5, 5)],
-    selectedItems: [new Line({ points: [new Point(), new Point(10, 0)] })],
+    selectedEntities: [new Line({ points: [new Point(), new Point(10, 0)] })],
     expectedDimType: 0,
   },
   { desc: 'Aligned dimension from line selection',
     input: [new SingleSelection(0, new Point()), new Point(6.5, 3.5)],
-    selectedItems: [new Line({ points: [new Point(), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(), new Point(10, 10)] })],
     expectedDimType: 1,
   },
   { desc: 'Rotated dimension from point selection',
     input: [new Point(), new Point(10, 0), new Point(5, 5)],
-    selectedItems: [],
+    selectedEntities: [],
     expectedDimType: 0,
   },
   { desc: 'Diametric dimension from circle selection',
     input: [new SingleSelection(0, new Point()), new Point(20, 10)],
-    selectedItems: [new Circle({ points: [new Point(), new Point(10, 0)] })],
+    selectedEntities: [new Circle({ points: [new Point(), new Point(10, 0)] })],
     expectedDimType: 3,
   },
   { desc: 'Radial dimension from arc selection',
     input: [new SingleSelection(0, new Point()), new Point(20, 10)],
-    selectedItems: [new Arc({ points: [new Point(), new Point(10, 0), new Point(10, 10)] })],
+    selectedEntities: [new Arc({ points: [new Point(), new Point(10, 0), new Point(10, 10)] })],
     expectedDimType: 4,
   },
   { desc: 'Angular dimension from line selection',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, 5)],
-    selectedItems: [new Line({ points: [new Point(), new Point(10, 0)] }), new Line({ points: [new Point(), new Point(10, 10)] })],
+    selectedEntities: [new Line({ points: [new Point(), new Point(10, 0)] }), new Line({ points: [new Point(), new Point(10, 10)] })],
     expectedDimType: 2,
   },
   { desc: 'Aligned dimension from polyline selection',
     input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, 5)],
-    selectedItems: [new Polyline({ points: [new Point(), new Point(10, 0)] })],
+    selectedEntities: [new Polyline({ points: [new Point(), new Point(10, 0)] })],
     expectedDimType: 1,
   },
   { desc: 'Radial dimension from polyline selection',
     input: [new SingleSelection(0, new Point(16, 5)), new Point(20, 5)],
-    selectedItems: [new Polyline({ points: [new Point(), new Point(10, 0, 1), new Point(10, 10)] })],
+    selectedEntities: [new Polyline({ points: [new Point(), new Point(10, 0, 1), new Point(10, 10)] })],
     expectedDimType: 4,
   },
   { desc: 'Angular dimension from polyline selection',
     input: [new SingleSelection(0, new Point(5, 0)), new SingleSelection(1, new Point(5, 5)), new Point(5, 5)],
-    selectedItems: [new Polyline({ points: [new Point(), new Point(10, 0)] }), new Polyline({ points: [new Point(), new Point(10, 10)] })],
+    selectedEntities: [new Polyline({ points: [new Point(), new Point(10, 0)] }), new Polyline({ points: [new Point(), new Point(10, 10)] })],
     expectedDimType: 2,
   },
 
 ];
 
 test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
-  const { input, selectedItems, expectedDimType } = scenario;
+  const { input, selectedEntities, expectedDimType } = scenario;
 
   await withMockInput(DesignCore.Scene, input, async () => {
     const dim = new Dimension();
     await dim.execute();
 
     expect(dim.dimType.getBaseDimType()).toBe(expectedDimType);
-  }, { selectedItems });
+  }, { selectedEntities });
 });
 
 test('constructor instantiates correct dimension type', () => {
@@ -95,7 +95,7 @@ test('get linear dimension type', () => {
 
 test('preview calls createTempItem with correct args', () => {
   const dim = new Dimension({ 70: 1 });
-  dim.selectedItems = [1];
+  dim.selectedEntities = [1];
   dim.points = [{}, {}];
   // Should not throw
   expect(() => dim.preview()).not.toThrow();

package/test/dimensions/{baseDimension.test.js → dimensionBase.test.js}

@@ -1,26 +1,28 @@
-import { BaseDimension } from '../../core/dimensions/baseDimension.js';
+import { DimensionBase } from '../../core/dimensions/dimensionBase.js';
 import { Point } from '../../core/entities/point.js';
 import { Core } from '../../core/core/core.js';
 import { Text } from '../../core/entities/text.js';
+import { Line } from '../../core/entities/line.js';
+import { jest } from '@jest/globals';
 // import { DimType } from '../../core/properties/dimType.js';
 
 // initialise core
 new Core();
 
-describe('BaseDimension', () => {
+describe('DimensionBase', () => {
   let baseDim;
 
   beforeEach(() => {
-    baseDim = new BaseDimension({});
+    baseDim = new DimensionBase({});
     baseDim.points = [new Point(1, 2, 0), new Point(3, 4, 0)];
   });
 
   test('constructor sets default properties', () => {
-    expect(baseDim.textOverride).toBe('');
-    expect(baseDim.blockName).toBe('');
-    expect(baseDim.dimensionStyle).toBe('STANDARD');
-    expect(baseDim.leaderLength).toBe(0);
-    expect(baseDim.linearDimAngle).toBe(0);
+    expect(baseDim.getProperty('textOverride')).toBe('');
+    expect(baseDim.getProperty('blockName')).toBe('');
+    expect(baseDim.getProperty('dimensionStyle')).toBe('STANDARD');
+    expect(baseDim.getProperty('leaderLength')).toBe(0);
+    expect(baseDim.getProperty('linearDimAngle')).toBe(0);
   });
 
   test('getDimensionValue formats values by dimension type', () => {
@@ -162,21 +164,21 @@ describe('BaseDimension', () => {
   });
 
   test('constructor throws on invalid dimType', () => {
-    expect(() => new BaseDimension({ 70: 999 })).toThrow(/Invalid Dimension Type/);
+    expect(() => new DimensionBase({ 70: 999 })).toThrow(/Invalid Dimension Type/);
   });
 
   test('getDimensionValue uses textOverride', () => {
-    baseDim.textOverride = 'foo <> bar';
+    baseDim.setProperty('textOverride', 'foo <> bar');
     expect(baseDim.getDimensionValue(10)).toBe('foo 10.0000 bar');
   });
 
   test('getDimensionText returns a Text object with correct values', () => {
     const text = baseDim.getDimensionText(10, new Point(1, 2), Math.PI / 4);
     expect(text).toBeInstanceOf(Text);
-    expect(text.height).toBe(0.18);
+    expect(text.getProperty('height')).toBe(0.18);
     expect(text.points[0].x).toBe(1);
     expect(text.points[0].y).toBe(2);
-    expect(typeof text.string).toBe('string');
+    expect(typeof text.getProperty('string')).toBe('string');
   });
 
   test('getTextDirection flips angle in lower half', () => {
@@ -236,4 +238,63 @@ describe('BaseDimension', () => {
     baseDim.block = { touched: () => false };
     expect(baseDim.touched({})).toBe(false);
   });
+
+  describe('draw()', () => {
+    /**
+     * Return a DimensionBase with a stubbed buildDimension() that produces one Line.
+     * @return {DimensionBase}
+     */
+    function makeDim() {
+      const dim = new DimensionBase({});
+      dim.points = [new Point(0, 0), new Point(10, 0)];
+      dim.buildDimension = jest.fn(() => {
+        return [new Line({ points: [new Point(0, 0), new Point(10, 0)] })];
+      });
+      return dim;
+    }
+
+    test('draw() returns the block items array', () => {
+      const dim = makeDim();
+      const result = dim.draw({});
+      expect(result).toBe(dim.block.entities);
+    });
+
+    test('draw() calls refresh() (via buildDimension) when block is empty', () => {
+      const dim = makeDim();
+      expect(dim.block.entities).toHaveLength(0);
+      dim.draw({});
+      expect(dim.buildDimension).toHaveBeenCalledTimes(1);
+      expect(dim.block.entities.length).toBeGreaterThan(0);
+    });
+
+    test('draw() does not call refresh() when block already has items', () => {
+      const dim = makeDim();
+      // pre-populate the block
+      dim.block.addEntity(new Line({ points: [new Point(0, 0), new Point(1, 1)] }));
+      dim.draw({});
+      expect(dim.buildDimension).not.toHaveBeenCalled();
+    });
+
+    test('draw() returns populated items after initial refresh', () => {
+      const dim = makeDim();
+      const items = dim.draw({});
+      expect(items).toBeInstanceOf(Array);
+      expect(items.length).toBeGreaterThan(0);
+    });
+
+    test('draw() returns same array reference on repeated calls', () => {
+      const dim = makeDim();
+      const first = dim.draw({});
+      const second = dim.draw({});
+      expect(first).toBe(second);
+    });
+
+    test('draw() block items have BYBLOCK colour after refresh', () => {
+      const dim = makeDim();
+      dim.draw({});
+      for (const item of dim.block.entities) {
+        expect(item.entityColour.aci).toBe(0); // BYBLOCK = ACI 0
+      }
+    });
+  });
 });

package/test/dimensions/linearDimensionBase.test.js

@@ -0,0 +1,62 @@
+import { AlignedDimension } from '../../core/dimensions/alignedDimension.js';
+import { LinearDimensionBase } from '../../core/dimensions/linearDimensionBase.js';
+import { Point } from '../../core/entities/point.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Core } from '../../core/core/core.js';
+
+// initialise core
+new Core();
+
+// ─── constructor ─────────────────────────────────────────────────────────────
+
+test('LinearDimensionBase can be instantiated', () => {
+  const dim = new LinearDimensionBase();
+  expect(dim).toBeInstanceOf(LinearDimensionBase);
+  expect(dim.points).toBeDefined();
+  expect(Array.isArray(dim.points)).toBe(true);
+});
+
+// ─── preview ─────────────────────────────────────────────────────────────────
+
+test('LinearDimensionBase.preview - 0 points does nothing', () => {
+  const dim = new AlignedDimension();
+  DesignCore.Scene.auxiliaryEntities.clear();
+  DesignCore.Scene.previewEntities.clear();
+
+  expect(() => dim.preview()).not.toThrow();
+  expect(DesignCore.Scene.auxiliaryEntities.count()).toBe(0);
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+});
+
+test('LinearDimensionBase.preview - 1 point adds RubberBand to auxiliaryEntities', () => {
+  const dim = new AlignedDimension();
+  dim.points = [new Point(0, 0)];
+
+  const origAdd = DesignCore.Scene.auxiliaryEntities.add;
+  const added = [];
+  DesignCore.Scene.auxiliaryEntities.add = (item) => added.push(item);
+  DesignCore.Scene.previewEntities.clear();
+
+  expect(() => dim.preview()).not.toThrow();
+  expect(added.length).toBeGreaterThanOrEqual(1);
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+
+  DesignCore.Scene.auxiliaryEntities.add = origAdd;
+});
+
+test('LinearDimensionBase.preview - >1 points creates temp entity', () => {
+  const dim = new AlignedDimension();
+  dim.points = [new Point(0, 0), new Point(10, 0)];
+
+  const origCreate = DesignCore.Scene.previewEntities.create;
+  const created = [];
+  DesignCore.Scene.previewEntities.create = (type, data) => created.push({ type, data });
+  DesignCore.Scene.auxiliaryEntities.clear();
+
+  expect(() => dim.preview()).not.toThrow();
+  expect(created.length).toBeGreaterThanOrEqual(1);
+  expect(created[0].type).toBe(dim.type);
+  expect(DesignCore.Scene.auxiliaryEntities.count()).toBe(0);
+
+  DesignCore.Scene.previewEntities.create = origCreate;
+});