@design-core/core 0.0.5 → 0.0.7

package/core/tools/scale.js

@@ -122,7 +122,7 @@ export class Scale extends Tool {
     if (this.points.length >= 1 && this.referencePoint === null) {
       // Draw a line from base point to mouse
       const points = [this.points[0], mousePoint];
-      DesignCore.Scene.tempEntities.create('Line', { points: points });
+      DesignCore.Scene.previewEntities.create('Line', { points: points });
 
       const base = this.points[0];
       const distance = base.distance(mousePoint);

package/core/tools/trim.js

@@ -3,6 +3,10 @@ import { Strings } from '../lib/strings.js';
 import { Tool } from './tool.js';
 import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
+import { AddState, RemoveState } from '../lib/stateManager.js';
+import { Utils } from '../lib/utils.js';
+import { Colour } from '../lib/colour.js';
+import { PolylineUtils } from '../lib/polylineUtils.js';
 
 import { DesignCore } from '../designCore.js';
 
@@ -38,10 +42,10 @@ export class Trim extends Tool {
    */
   async execute() {
     try {
-      const op = new PromptOptions(Strings.Input.BOUNDARY, [Input.Type.SELECTIONSET]);
+      const boundaryOp = new PromptOptions(Strings.Input.BOUNDARY, [Input.Type.SELECTIONSET]);
 
       if (!DesignCore.Scene.selectionManager.selectionSet.selectionSet.length) {
-        const boundary = await DesignCore.Scene.inputManager.requestInput(op);
+        const boundary = await DesignCore.Scene.inputManager.requestInput(boundaryOp);
         if (boundary === undefined) return;
       }
 
@@ -51,9 +55,9 @@ export class Trim extends Tool {
         this.selectedBoundaryItems.push(boundaryItem);
       }
 
-      const op2 = new PromptOptions(Strings.Input.SELECT, [Input.Type.SINGLESELECTION]);
+      const selectOp = new PromptOptions(Strings.Input.SELECT, [Input.Type.SINGLESELECTION]);
       while (true) {
-        const selection = await DesignCore.Scene.inputManager.requestInput(op2);
+        const selection = await DesignCore.Scene.inputManager.requestInput(selectOp);
         if (selection === undefined) break;
         this.selectedItem = DesignCore.Scene.entities.get(selection.selectedItemIndex);
         DesignCore.Scene.selectionManager.removeLastSelection();
@@ -70,7 +74,29 @@ export class Trim extends Tool {
    * Preview the command during execution
    */
   preview() {
-    // No Preview
+    if (!this.selectedBoundaryItems.length) return;
+
+    const index = DesignCore.Scene.selectionManager.findClosestItem(DesignCore.Mouse.pointOnScene());
+    if (index === undefined) return;
+
+    const entity = DesignCore.Scene.entities.get(index);
+    if (typeof entity.toPolylinePoints !== 'function' || typeof entity.fromPolylinePoints !== 'function') return;
+    const intersectPoints = this.#collectIntersectPoints(entity);
+    if (!intersectPoints.length) return;
+
+    const stateChanges = this.#trimEntity(entity, intersectPoints);
+    if (!stateChanges?.length) return;
+
+    // Draw the full entity in a dulled colour, then draw survivors on top.
+    const dulledEntity = Utils.cloneObject(entity);
+    dulledEntity.setProperty('colour', Colour.blend(entity.getDrawColour(), DesignCore.Settings.canvasbackgroundcolour, DesignCore.Settings.previewBlendFactor));
+    DesignCore.Scene.previewEntities.add(dulledEntity);
+
+    for (const change of stateChanges) {
+      if (change instanceof AddState) {
+        DesignCore.Scene.previewEntities.add(change.entity);
+      }
+    }
   }
 
   /**
@@ -78,26 +104,16 @@ export class Trim extends Tool {
    */
   action() {
     if (this.selectedItem && this.selectedBoundaryItems.length) {
-      const intersectPoints = [];
-
-      for (const boundaryItem of this.selectedBoundaryItems) {
-        if (boundaryItem !== this.selectedItem) {
-          try {
-            const intersect = Intersection.intersectPolylinePolyline(boundaryItem.toPolylinePoints(), this.selectedItem.toPolylinePoints());
-            if (intersect.points.length) {
-              for (let point = 0; point < intersect.points.length; point++) {
-                intersectPoints.push(intersect.points[point]);
-              }
-            }
-          } catch {
-            Logging.instance.warn(`${this.constructor.name}: Error intersecting between ${boundaryItem.type} and ${this.selectedItem.type}`);
-            continue;
-          }
-        }
+      if (typeof this.selectedItem.fromPolylinePoints !== 'function') {
+        DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOTRIM}`);
+        this.selectedItem = null;
+        return;
       }
 
+      const intersectPoints = this.#collectIntersectPoints(this.selectedItem);
+
       if (intersectPoints.length) {
-        const stateChanges = this.selectedItem.trim(intersectPoints);
+        const stateChanges = this.#trimEntity(this.selectedItem, intersectPoints);
         if (stateChanges?.length) {
           DesignCore.Scene.commit(stateChanges);
         }
@@ -106,8 +122,234 @@ export class Trim extends Tool {
       }
     }
 
-    // reset selected item
     this.selectedItem = null;
   }
+
+  /**
+   * Collect all intersection points between the boundary items and the given entity.
+   * Unsupported entity combinations are silently skipped.
+   * @param {Object} entity
+   * @return {Array}
+   */
+  #collectIntersectPoints(entity) {
+    const intersectPoints = [];
+    for (const boundaryItem of this.selectedBoundaryItems) {
+      if (boundaryItem === entity) continue;
+      try {
+        const intersect = Intersection.intersectPolylinePolyline(boundaryItem.toPolylinePoints(), entity.toPolylinePoints());
+        intersectPoints.push(...intersect.points);
+      } catch {
+        // skip unsupported entity combinations
+      }
+    }
+    return intersectPoints;
+  }
+
+  /**
+   * Compute state changes to trim entity at the pair of intersection points
+   * surrounding the mouse position. Operates entirely in polyline-point space
+   * via entity.toPolylinePoints() / entity.fromPolylinePoints(), so it works
+   * for any entity that implements that protocol (Line, Arc, Circle,
+   * BasePolyline, and future entities such as Spline or Ellipse).
+   * @param {Object} entity
+   * @param {Array}  intersectPoints
+   * @return {Array}
+   */
+  #trimEntity(entity, intersectPoints) {
+    const polyPoints = entity.toPolylinePoints();
+    const mousePosition = DesignCore.Mouse.pointOnScene();
+    const isClosed = polyPoints[0].isSame(polyPoints.at(-1));
+
+    // Drop any intersection point that coincides with an existing vertex
+    const filtered = intersectPoints.filter((p) => !polyPoints.some((v) => v.isSame(p)));
+    if (!filtered.length) return [];
+
+    // Locate each intersection point within the polyline segments
+    const locatedIntersections = [];
+    for (const point of filtered) {
+      for (let i = 1; i < polyPoints.length; i++) {
+        if (PolylineUtils.isPointOnSegment(point, polyPoints[i - 1], polyPoints[i])) {
+          locatedIntersections.push({
+            segmentIndex: i,
+            point,
+            positionAlongSegment: PolylineUtils.positionOnSegment(polyPoints, point, i),
+          });
+          break;
+        }
+      }
+    }
+
+    if (!locatedIntersections.length) return [];
+
+    locatedIntersections.sort((a, b) => {
+      if (a.segmentIndex !== b.segmentIndex) return a.segmentIndex - b.segmentIndex;
+      return a.positionAlongSegment - b.positionAlongSegment;
+    });
+
+    // Find which segment the mouse is closest to
+    let mouseSegmentIndex = 0;
+    let mouseClosest = null;
+    let minDistance = Infinity;
+    for (let i = 1; i < polyPoints.length; i++) {
+      const closest = PolylineUtils.closestPointOnSegment(polyPoints, mousePosition, i);
+      if (closest) {
+        const dist = mousePosition.distance(closest);
+        if (dist < minDistance) {
+          minDistance = dist;
+          mouseSegmentIndex = i;
+          mouseClosest = closest;
+        }
+      }
+    }
+
+    const mousePos = mouseClosest ?
+      PolylineUtils.positionOnSegment(polyPoints, mouseClosest, mouseSegmentIndex) :
+      0;
+
+    // Find the nearest intersections before and after the mouse position
+    let trimBefore = null;
+    let trimAfter = null;
+    for (const loc of locatedIntersections) {
+      if (loc.segmentIndex < mouseSegmentIndex) {
+        trimBefore = loc;
+      } else if (loc.segmentIndex === mouseSegmentIndex) {
+        if (loc.positionAlongSegment <= mousePos) {
+          trimBefore = loc;
+        } else if (!trimAfter) {
+          trimAfter = loc;
+        }
+      } else if (!trimAfter) {
+        trimAfter = loc;
+      }
+    }
+
+    const stateChanges = [];
+
+    if (isClosed) {
+      // Wrap cyclically: if trimBefore is null use the last intersection,
+      // if trimAfter is null use the first.
+      if (!trimBefore) trimBefore = locatedIntersections.at(-1);
+      if (!trimAfter) trimAfter = locatedIntersections[0];
+
+      // A single intersection point cannot divide a closed shape.
+      if (trimBefore === trimAfter) return [];
+
+      // Build the single kept open portion from trimAfter to trimBefore,
+      // going away from the mouse (i.e. not through the mouse segment).
+      let outputPoints;
+      if (trimAfter.segmentIndex < trimBefore.segmentIndex ||
+          (trimAfter.segmentIndex === trimBefore.segmentIndex &&
+           trimAfter.positionAlongSegment < trimBefore.positionAlongSegment)) {
+        // Forward walk: trimAfter → trimBefore without crossing the seam
+        outputPoints = this.#buildPortion(polyPoints, trimAfter, trimBefore);
+      } else {
+        // Wrapping walk: trimAfter → end → seam → start → trimBefore
+        outputPoints = this.#buildWrappingPortion(polyPoints, trimAfter, trimBefore);
+      }
+
+      if (outputPoints && outputPoints.length >= 2) {
+        const output = Utils.cloneObject(entity).fromPolylinePoints(outputPoints);
+        output.flags?.removeValue(1);
+        stateChanges.push(new AddState(output));
+        stateChanges.push(new RemoveState(entity));
+      }
+      return stateChanges;
+    }
+
+    // Open entity: build portionOne (start → trimBefore) and portionTwo (trimAfter → end)
+    const startLoc = { segmentIndex: 1, point: polyPoints[0] };
+    const endLoc = { segmentIndex: polyPoints.length - 1, point: polyPoints.at(-1) };
+    const portionOnePoints = trimBefore ? this.#buildPortion(polyPoints, startLoc, trimBefore) : null;
+    const portionTwoPoints = trimAfter ? this.#buildPortion(polyPoints, trimAfter, endLoc) : null;
+
+    if (portionOnePoints) {
+      const output = Utils.cloneObject(entity).fromPolylinePoints(portionOnePoints);
+      output.flags?.removeValue(1);
+      stateChanges.push(new AddState(output));
+    }
+    if (portionTwoPoints) {
+      const output = Utils.cloneObject(entity).fromPolylinePoints(portionTwoPoints);
+      output.flags?.removeValue(1);
+      stateChanges.push(new AddState(output));
+    }
+
+    if (trimBefore || trimAfter) {
+      stateChanges.push(new RemoveState(entity));
+    }
+
+    return stateChanges;
+  }
+
+  /**
+   * Build a sub-polyline from fromLoc to toLoc going forward (no seam crossing).
+   * Both locations must appear in forward order along the polyline.
+   * @param {Array}  polyPoints
+   * @param {Object} fromLoc - { segmentIndex, point, positionAlongSegment }
+   * @param {Object} toLoc   - { segmentIndex, point, positionAlongSegment }
+   * @return {Array|null}
+   */
+  #buildPortion(polyPoints, fromLoc, toLoc) {
+    const fromSegStart = polyPoints[fromLoc.segmentIndex - 1];
+    const fromSegEnd = polyPoints[fromLoc.segmentIndex];
+
+    // Same-segment case: compute the sub-arc bulge directly from the arc geometry
+    if (fromLoc.segmentIndex === toLoc.segmentIndex) {
+      const startPoint = fromLoc.point.clone();
+      if (fromSegStart.bulge !== 0 && fromSegStart.bulge !== undefined) {
+        const center = fromSegStart.bulgeCentrePoint(fromSegEnd);
+        const direction = fromSegStart.bulge > 0 ? 1 : -1;
+        const startAngle = center.angle(fromLoc.point);
+        const endAngle = center.angle(toLoc.point);
+        const includedAngle = ((endAngle - startAngle) * direction + 4 * Math.PI) % (2 * Math.PI);
+        startPoint.bulge = Math.tan(includedAngle / 4) * direction;
+      }
+      return [startPoint, toLoc.point.clone()];
+    }
+
+    const points = [];
+
+    // Start point: fromLoc.point with partial bulge covering the rest of its segment
+    const startPoint = fromLoc.point.clone();
+    if (fromSegStart.bulge !== 0 && fromSegStart.bulge !== undefined) {
+      startPoint.bulge = fromSegStart.partialBulge(fromSegEnd, fromLoc.point, true);
+    }
+    points.push(startPoint);
+
+    // Intermediate vertices between the two segments
+    for (let i = fromLoc.segmentIndex; i <= toLoc.segmentIndex - 2; i++) {
+      points.push(polyPoints[i].clone());
+    }
+
+    // Start of toLoc's segment with partial bulge trimmed to toLoc.point
+    const toSegStart = polyPoints[toLoc.segmentIndex - 1];
+    const toSegEnd = polyPoints[toLoc.segmentIndex];
+    const lastSegStart = toSegStart.clone();
+    if (toSegStart.bulge !== 0 && toSegStart.bulge !== undefined) {
+      lastSegStart.bulge = toSegStart.partialBulge(toSegEnd, toLoc.point);
+    }
+    if (!points.at(-1).isSame(lastSegStart)) points.push(lastSegStart);
+
+    const endPoint = toLoc.point.clone();
+    if (!points.at(-1).isSame(endPoint)) points.push(endPoint);
+
+    return points.length >= 2 ? points : null;
+  }
+
+  /**
+   * Build a sub-polyline from fromLoc to toLoc crossing the seam (wrapping).
+   * Used for closed entities when the kept portion wraps through the closure point.
+   * Implemented as two forward #buildPortion calls joined at the seam.
+   * @param {Array}  polyPoints
+   * @param {Object} fromLoc - { segmentIndex, point, positionAlongSegment }
+   * @param {Object} toLoc   - { segmentIndex, point, positionAlongSegment }
+   * @return {Array|null}
+   */
+  #buildWrappingPortion(polyPoints, fromLoc, toLoc) {
+    const firstHalf = this.#buildPortion(polyPoints, fromLoc, { segmentIndex: polyPoints.length - 1, point: polyPoints.at(-1) });
+    const secondHalf = this.#buildPortion(polyPoints, { segmentIndex: 1, point: polyPoints[0] }, toLoc);
+    if (!firstHalf || !secondHalf) return null;
+    firstHalf.pop(); // discard closure point before joining
+    return firstHalf.concat(secondHalf);
+  }
 }
 

package/core/tools/zoom.js

@@ -99,7 +99,7 @@ export class Zoom extends Tool {
         new Point(p1.x, p1.y),
       ];
 
-      DesignCore.Scene.tempEntities.create('Polyline', { points: points });
+      DesignCore.Scene.previewEntities.create('Polyline', { points: points });
     }
   }
 

package/jest.config.js

@@ -0,0 +1,6 @@
+export default {
+  coveragePathIgnorePatterns: [
+    '/node_modules/',
+    '/test/',
+  ],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-core/core",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "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

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

@@ -69,9 +69,9 @@ 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 });
@@ -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/baseDimension.test.js

@@ -2,6 +2,8 @@ import { BaseDimension } from '../../core/dimensions/baseDimension.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
@@ -16,11 +18,11 @@ describe('BaseDimension', () => {
   });
 
   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', () => {
@@ -166,17 +168,17 @@ describe('BaseDimension', () => {
   });
 
   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 BaseDimension with a stubbed buildDimension() that produces one Line.
+     * @return {BaseDimension}
+     */
+    function makeDim() {
+      const dim = new BaseDimension({});
+      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.items);
+    });
+
+    test('draw() calls refresh() (via buildDimension) when block is empty', () => {
+      const dim = makeDim();
+      expect(dim.block.items).toHaveLength(0);
+      dim.draw({});
+      expect(dim.buildDimension).toHaveBeenCalledTimes(1);
+      expect(dim.block.items.length).toBeGreaterThan(0);
+    });
+
+    test('draw() does not call refresh() when block already has items', () => {
+      const dim = makeDim();
+      // pre-populate the block
+      dim.block.addItem(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.items) {
+        expect(item.entityColour.aci).toBe(0); // BYBLOCK = ACI 0
+      }
+    });
+  });
 });

package/test/dimensions/baseLinearDimension.test.js

@@ -0,0 +1,62 @@
+import { AlignedDimension } from '../../core/dimensions/alignedDimension.js';
+import { BaseLinearDimension } from '../../core/dimensions/baseLinearDimension.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('BaseLinearDimension can be instantiated', () => {
+  const dim = new BaseLinearDimension();
+  expect(dim).toBeInstanceOf(BaseLinearDimension);
+  expect(dim.points).toBeDefined();
+  expect(Array.isArray(dim.points)).toBe(true);
+});
+
+// ─── preview ─────────────────────────────────────────────────────────────────
+
+test('BaseLinearDimension.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('BaseLinearDimension.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('BaseLinearDimension.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;
+});