@design-core/core 0.0.7 → 50.1.0

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

@@ -1,4 +1,4 @@
-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';
@@ -9,11 +9,11 @@ import { jest } from '@jest/globals';
 // 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)];
   });
 
@@ -164,7 +164,7 @@ 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', () => {
@@ -241,11 +241,11 @@ describe('BaseDimension', () => {
 
   describe('draw()', () => {
     /**
-     * Return a BaseDimension with a stubbed buildDimension() that produces one Line.
-     * @return {BaseDimension}
+     * Return a DimensionBase with a stubbed buildDimension() that produces one Line.
+     * @return {DimensionBase}
      */
     function makeDim() {
-      const dim = new BaseDimension({});
+      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)] })];
@@ -256,21 +256,21 @@ describe('BaseDimension', () => {
     test('draw() returns the block items array', () => {
       const dim = makeDim();
       const result = dim.draw({});
-      expect(result).toBe(dim.block.items);
+      expect(result).toBe(dim.block.entities);
     });
 
     test('draw() calls refresh() (via buildDimension) when block is empty', () => {
       const dim = makeDim();
-      expect(dim.block.items).toHaveLength(0);
+      expect(dim.block.entities).toHaveLength(0);
       dim.draw({});
       expect(dim.buildDimension).toHaveBeenCalledTimes(1);
-      expect(dim.block.items.length).toBeGreaterThan(0);
+      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.addItem(new Line({ points: [new Point(0, 0), new Point(1, 1)] }));
+      dim.block.addEntity(new Line({ points: [new Point(0, 0), new Point(1, 1)] }));
       dim.draw({});
       expect(dim.buildDimension).not.toHaveBeenCalled();
     });
@@ -292,7 +292,7 @@ describe('BaseDimension', () => {
     test('draw() block items have BYBLOCK colour after refresh', () => {
       const dim = makeDim();
       dim.draw({});
-      for (const item of dim.block.items) {
+      for (const item of dim.block.entities) {
         expect(item.entityColour.aci).toBe(0); // BYBLOCK = ACI 0
       }
     });

package/test/dimensions/{baseLinearDimension.test.js → linearDimensionBase.test.js}

@@ -1,5 +1,5 @@
 import { AlignedDimension } from '../../core/dimensions/alignedDimension.js';
-import { BaseLinearDimension } from '../../core/dimensions/baseLinearDimension.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';
@@ -9,16 +9,16 @@ new Core();
 
 // ─── constructor ─────────────────────────────────────────────────────────────
 
-test('BaseLinearDimension can be instantiated', () => {
-  const dim = new BaseLinearDimension();
-  expect(dim).toBeInstanceOf(BaseLinearDimension);
+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('BaseLinearDimension.preview - 0 points does nothing', () => {
+test('LinearDimensionBase.preview - 0 points does nothing', () => {
   const dim = new AlignedDimension();
   DesignCore.Scene.auxiliaryEntities.clear();
   DesignCore.Scene.previewEntities.clear();
@@ -28,7 +28,7 @@ test('BaseLinearDimension.preview - 0 points does nothing', () => {
   expect(DesignCore.Scene.previewEntities.count()).toBe(0);
 });
 
-test('BaseLinearDimension.preview - 1 point adds RubberBand to auxiliaryEntities', () => {
+test('LinearDimensionBase.preview - 1 point adds RubberBand to auxiliaryEntities', () => {
   const dim = new AlignedDimension();
   dim.points = [new Point(0, 0)];
 
@@ -44,7 +44,7 @@ test('BaseLinearDimension.preview - 1 point adds RubberBand to auxiliaryEntities
   DesignCore.Scene.auxiliaryEntities.add = origAdd;
 });
 
-test('BaseLinearDimension.preview - >1 points creates temp entity', () => {
+test('LinearDimensionBase.preview - >1 points creates temp entity', () => {
   const dim = new AlignedDimension();
   dim.points = [new Point(0, 0), new Point(10, 0)];
 

package/test/dimensions/radialDimension.test.js

@@ -17,28 +17,28 @@ const scenarios = [
 
   { desc: 'Radial 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: 4,
     dimensionValue: 10,
     dimensionEntities: 6,
   },
   { desc: 'Radial 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: 4,
     dimensionValue: 10,
     dimensionEntities: 5,
   },
   { desc: 'Radial 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: 4,
     dimensionValue: 20,
     dimensionEntities: 6,
   },
   { desc: 'Radial 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: 4,
     dimensionValue: 10,
     dimensionEntities: 6,
@@ -46,7 +46,7 @@ const scenarios = [
 ];
 
 test.each(scenarios)('RadialDimension.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 RadialDimension();
@@ -66,7 +66,7 @@ test.each(scenarios)('RadialDimension.execute handles $desc', async (scenario) =
         expect(entity.getProperty('string')).toContain('R');
       }
     }
-  }, { selectedItems });
+  }, { selectedEntities });
 });
 
 test('constructor sets default properties', () => {
@@ -77,14 +77,14 @@ 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 = RadialDimension.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
 });

package/test/dimensions/rotatedDimension.test.js

@@ -13,20 +13,20 @@ const scenarios = [
 
   { desc: 'Rotated dimension from point selection (angle 0)',
     input: [0, new Point(), new Point(10, 0), new Point(5, 5)],
-    selectedItems: [],
+    selectedEntities: [],
     expectedDimType: 0,
     dimensionValue: 10,
   },
   { desc: 'Rotated dimension from point selection (angle 90)',
     input: [90, new Point(), new Point(0, 10), new Point(5, 5)],
-    selectedItems: [],
+    selectedEntities: [],
     expectedDimType: 0,
     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 RotatedDimension();
@@ -43,7 +43,7 @@ test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
         expect(Number(entity.getProperty('string'))).toBeCloseTo(dimensionValue);
       }
     }
-  }, { selectedItems });
+  }, { selectedEntities });
 });
 
 test('constructor sets default properties', () => {

package/test/entities/arc.test.js

@@ -58,7 +58,7 @@ describe('Arc.execute input validation and notifications', () => {
   test('Notifies on invalid point input (duplicate)', async () => {
     const input1 = new Point(0, 0);
     const input2 = new Point(10, 0);
-    const input3 = new Point(0, 0); // Same as center
+    const input3 = new Point(0, 0); // Same as centre
     await withMockInput(DesignCore.Scene, [input1, input2, input3, new Point(10, 10)], async () => {
       const arc = new Arc({});
       await arc.execute();
@@ -450,8 +450,8 @@ test('Arc.fromPolylinePoints precision drift is negligible', () => {
   const polyPts = arc.toPolylinePoints();
   const rebuilt = new Arc({});
   rebuilt.fromPolylinePoints(polyPts);
-  const centerDrift = Math.hypot(rebuilt.points[0].x - arc.points[0].x, rebuilt.points[0].y - arc.points[0].y);
-  expect(centerDrift).toBeLessThan(1e-10);
+  const centreDrift = Math.hypot(rebuilt.points[0].x - arc.points[0].x, rebuilt.points[0].y - arc.points[0].y);
+  expect(centreDrift).toBeLessThan(1e-10);
   expect(Math.abs(rebuilt.getProperty('radius') - arc.getProperty('radius'))).toBeLessThan(1e-10);
 });
 
@@ -489,10 +489,10 @@ test('Arc.snaps returns no tangent when fromPoint is inside the arc radius', ()
 
 describe('Arc.fromDxf', () => {
   test('projects start and end points from DXF angle codes', () => {
-    const center = new Point(0, 0);
-    const result = Arc.fromDxf({ points: [center], 40: 10, 50: 0, 51: 90 });
+    const centre = new Point(0, 0);
+    const result = Arc.fromDxf({ points: [centre], 40: 10, 50: 0, 51: 90 });
     expect(result.points.length).toBe(3);
-    expect(result.points[0]).toBe(center);
+    expect(result.points[0]).toBe(centre);
     expect(result.points[1].x).toBeCloseTo(10); // project(0°, 10)
     expect(result.points[1].y).toBeCloseTo(0);
     expect(result.points[2].x).toBeCloseTo(0); // project(90°, 10)
@@ -513,15 +513,15 @@ describe('Arc.fromDxf', () => {
     expect(result[6]).toBe('ByLayer');
   });
 
-  test('returns data unchanged when no center point', () => {
+  test('returns data unchanged when no centre point', () => {
     const data = { 40: 10, 50: 0, 51: 90 };
     expect(Arc.fromDxf(data)).toBe(data);
   });
 
   test('arc constructed via fromDxf matches arc constructed directly', () => {
-    const center = new Point(100, 100);
-    const fromDxfArc = new Arc(Arc.fromDxf({ points: [center], 40: 50, 50: 0, 51: 90 }));
-    const directArc = new Arc({ points: [center, new Point(150, 100), new Point(100, 150)] });
+    const centre = new Point(100, 100);
+    const fromDxfArc = new Arc(Arc.fromDxf({ points: [centre], 40: 50, 50: 0, 51: 90 }));
+    const directArc = new Arc({ points: [centre, new Point(150, 100), new Point(100, 150)] });
     expect(fromDxfArc.getProperty('radius')).toBeCloseTo(directArc.getProperty('radius'));
     expect(fromDxfArc.startAngle()).toBeCloseTo(directArc.startAngle());
     expect(fromDxfArc.endAngle()).toBeCloseTo(directArc.endAngle());

package/test/entities/arctext.test.js

@@ -16,14 +16,14 @@ const arcInputScenarios = [
   {
     desc: 'two points and an angle',
     input: [new SingleSelection(0, new Point(5, 0)), 2.5, 'Test Arc'],
-    selectedItems: [new Arc({ points: [new Point(), new Point(100, 0), new Point(-100, 0)] })],
+    selectedEntities: [new Arc({ points: [new Point(), new Point(100, 0), new Point(-100, 0)] })],
     expectedTextHeight: 2.5,
     expectedText: 'Test Arc',
   },
 ];
 
 test.each(arcInputScenarios)('ArcText.execute handles $desc', async (scenario) => {
-  const { input, selectedItems, expectedTextHeight, expectedText } = scenario;
+  const { input, selectedEntities, expectedTextHeight, expectedText } = scenario;
 
   await withMockInput(DesignCore.Scene, input, async () => {
     const arcText = new ArcAlignedText();
@@ -37,7 +37,7 @@ test.each(arcInputScenarios)('ArcText.execute handles $desc', async (scenario) =
     expect(arcText.getProperty('radius')).toBe(100);
     expect(arcText.startAngle()).toBe(0);
     expect(arcText.endAngle()).toBeCloseTo(3.14159);
-  }, { selectedItems });
+  }, { selectedEntities });
 });
 
 test('ArcAlignedCharacter', () => {
@@ -105,7 +105,7 @@ test('ArcText getArcAlignedCharacters', () => {
   // offsetFromLeft 0 - mm
   // textReversed 0 = forward, 1 = reversed
   // textOrientation 1 = outward, 2 = inward
-  // textAlignment 1 = fit to arc, 2 = left align, 3 = right align, 4 = center
+  // textAlignment 1 = fit to arc, 2 = left align, 3 = right align, 4 = centre
   // ArcSide convex = 1, concave = 2
   let chars = [];
 
@@ -387,7 +387,7 @@ test('ArcText snaps with empty string returns only centre snap', () => {
 });
 
 test('ArcText closestPoint returns distance 0.1 when within height * 0.35', () => {
-  // Single char 'T' center-aligned sits at (0, 101.25); height = 2.5, threshold = 0.875
+  // Single char 'T' centre-aligned sits at (0, 101.25); height = 2.5, threshold = 0.875
   const arcText = new ArcAlignedText({ points: [new Point(0, 0)], string: 'T', radius: 100 });
   const chars = arcText.getArcAlignedCharacters();
   const charPos = chars[0].position;
@@ -408,7 +408,7 @@ test('ArcText getArcAlignedCharacters fit-to-arc single character places at midp
 });
 
 test('ArcText getArcAlignedCharacters single character is placed at arc midpoint', () => {
-  // Single char with center alignment: charOffsetAngles = [0], stringStartPoint = arcMidPoint
+  // Single char with centre alignment: charOffsetAngles = [0], stringStartPoint = arcMidPoint
   // arcMidAngle(0, PI) = PI/2 → project(PI/2, 101.25) = (0, 101.25), angle = PI/2 - PI/2 = 0
   const arcText = new ArcAlignedText({ points: [new Point(0, 0)], string: 'X', radius: 100 });
   const chars = arcText.getArcAlignedCharacters();

package/test/entities/circle.test.js

@@ -128,22 +128,22 @@ test('Test Circle.toPolylinePoints', () => {
 });
 
 test('Circle.execute creates circle from diameter input', async () => {
-  const center = new Point(0, 0);
+  const centre = new Point(0, 0);
 
-  await withMockInput(DesignCore.Scene, [center, 'Diameter', 20], async () => {
+  await withMockInput(DesignCore.Scene, [centre, 'Diameter', 20], async () => {
     const circle = new Circle({});
     await circle.execute();
 
-    expect(circle.points[0]).toBe(center);
+    expect(circle.points[0]).toBe(centre);
     expect(circle.getRadius()).toBeCloseTo(10);
   });
 });
 
 test('Circle.execute re-prompts on zero or negative radius', async () => {
-  const center = new Point(0, 0);
+  const centre = new Point(0, 0);
 
   // 0 and -5 are rejected; 10 is accepted
-  await withMockInput(DesignCore.Scene, [center, 0, -5, 10], async () => {
+  await withMockInput(DesignCore.Scene, [centre, 0, -5, 10], async () => {
     const circle = new Circle({});
     await circle.execute();
 
@@ -152,10 +152,10 @@ test('Circle.execute re-prompts on zero or negative radius', async () => {
 });
 
 test('Circle.execute re-prompts on zero or negative diameter', async () => {
-  const center = new Point(0, 0);
+  const centre = new Point(0, 0);
 
   // 'Diameter', then 0 and -20 rejected, then 20 accepted (radius = 10)
-  await withMockInput(DesignCore.Scene, [center, 'Diameter', 0, -20, 20], async () => {
+  await withMockInput(DesignCore.Scene, [centre, 'Diameter', 0, -20, 20], async () => {
     const circle = new Circle({});
     await circle.execute();
 
@@ -175,8 +175,8 @@ test('Circle constructor loads radius from DXF group code 40 via fromDxf', () =>
 });
 
 test('Circle.execute creates circle from numeric radius input', async () => {
-  const center = new Point(0, 0);
-  await withMockInput(DesignCore.Scene, [center, 25], async () => {
+  const centre = new Point(0, 0);
+  await withMockInput(DesignCore.Scene, [centre, 25], async () => {
     const circle = new Circle({});
     await circle.execute();
     expect(circle.getRadius()).toBeCloseTo(25);
@@ -185,8 +185,8 @@ test('Circle.execute creates circle from numeric radius input', async () => {
 
 test('Circle.execute re-prompts on zero-distance point input', async () => {
   const notifySpy = jest.spyOn(DesignCore.Core, 'notify').mockImplementation(() => {});
-  const center = new Point(0, 0);
-  await withMockInput(DesignCore.Scene, [center, new Point(0, 0), new Point(10, 0)], async () => {
+  const centre = new Point(0, 0);
+  await withMockInput(DesignCore.Scene, [centre, new Point(0, 0), new Point(10, 0)], async () => {
     const circle = new Circle({});
     await circle.execute();
     expect(notifySpy).toHaveBeenCalledWith(expect.stringContaining(Strings.Error.NONZERO));
@@ -296,10 +296,10 @@ test('Circle.snaps returns two tangent snaps from outside', () => {
 
 describe('Circle.fromDxf', () => {
   test('projects edge point from DXF radius code', () => {
-    const center = new Point(0, 0);
-    const result = Circle.fromDxf({ points: [center], 40: 10 });
+    const centre = new Point(0, 0);
+    const result = Circle.fromDxf({ points: [centre], 40: 10 });
     expect(result.points.length).toBe(2);
-    expect(result.points[0]).toBe(center);
+    expect(result.points[0]).toBe(centre);
     expect(result.points[1].x).toBeCloseTo(10);
     expect(result.points[1].y).toBeCloseTo(0);
   });
@@ -309,7 +309,7 @@ describe('Circle.fromDxf', () => {
     expect(result[8]).toBe('MyLayer');
   });
 
-  test('returns data unchanged when no center point', () => {
+  test('returns data unchanged when no centre point', () => {
     const data = { 40: 10 };
     expect(Circle.fromDxf(data)).toBe(data);
   });
@@ -320,9 +320,9 @@ describe('Circle.fromDxf', () => {
   });
 
   test('circle constructed via fromDxf matches circle constructed directly', () => {
-    const center = new Point(100, 100);
-    const fromDxfCircle = new Circle(Circle.fromDxf({ points: [center], 40: 50 }));
-    const directCircle = new Circle({ points: [center, new Point(150, 100)] });
+    const centre = new Point(100, 100);
+    const fromDxfCircle = new Circle(Circle.fromDxf({ points: [centre], 40: 50 }));
+    const directCircle = new Circle({ points: [centre, new Point(150, 100)] });
     expect(fromDxfCircle.getRadius()).toBeCloseTo(directCircle.getRadius());
     expect(fromDxfCircle.points[0].x).toBeCloseTo(directCircle.points[0].x);
     expect(fromDxfCircle.points[0].y).toBeCloseTo(directCircle.points[0].y);

package/test/entities/hatch.test.js

@@ -2,7 +2,7 @@ import { Hatch } from '../../core/entities/hatch.js';
 import { Point } from '../../core/entities/point.js';
 import { DesignCore } from '../../core/designCore.js';
 
-import { BasePolyline } from '../../core/entities/basePolyline.js';
+import { PolylineBase } from '../../core/entities/polylineBase.js';
 import { Circle } from '../../core/entities/circle.js';
 import { Line } from '../../core/entities/line.js';
 import { Polyline } from '../../core/entities/polyline.js';
@@ -17,7 +17,7 @@ import { Core } from '../../core/core/core.js';
 new Core();
 
 const points = [new Point(100, 100, 1), new Point(200, 100, 1)];
-const boundaryShape = new BasePolyline({ points: points });
+const boundaryShape = new PolylineBase({ points: points });
 
 const hatch = new Hatch({ handle: '1' });
 hatch.setProperty('childEntities', [boundaryShape]);
@@ -56,10 +56,10 @@ test.each(hatchInputScenarios)('Hatch.execute handles $desc', async (scenario) =
 
   await withMockInput(DesignCore.Scene, [true], async () => {
     // Manual mock for selected items
-    DesignCore.Scene.selectionManager.selectedItems = [];
+    DesignCore.Scene.selectionManager.selectedEntities = [];
 
     for (let i = 0; i < boundaryItems.length; i++) {
-      DesignCore.Scene.selectionManager.selectedItems.push(boundaryItems[i]);
+      DesignCore.Scene.selectionManager.selectedEntities.push(boundaryItems[i]);
     }
 
     const hatch = new Hatch({ patternName: pattern, scale: scale, angle: angle });
@@ -448,60 +448,60 @@ test('Test Hatch.processBoundaryData', () => {
 
 test('Test Hatch.processSelection', () => {
   // create selected items defining a square
-  let selectedItems = [];
-  selectedItems.push(new Line({ points: [new Point(100, 100), new Point(200, 100)] }));
-  selectedItems.push(new Line({ points: [new Point(200, 100), new Point(200, 200)] }));
-  selectedItems.push(new Line({ points: [new Point(200, 200), new Point(100, 200)] }));
-  selectedItems.push(new Line({ points: [new Point(100, 200), new Point(100, 100)] }));
+  let selectedEntities = [];
+  selectedEntities.push(new Line({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedEntities.push(new Line({ points: [new Point(200, 100), new Point(200, 200)] }));
+  selectedEntities.push(new Line({ points: [new Point(200, 200), new Point(100, 200)] }));
+  selectedEntities.push(new Line({ points: [new Point(100, 200), new Point(100, 100)] }));
 
   let hatch = new Hatch();
-  let boundaryData = hatch.processSelection(selectedItems);
+  let boundaryData = hatch.processSelection(selectedEntities);
   expect(boundaryData.length).toEqual(1);
   expect(boundaryData[0].points.length).toEqual(4);
 
 
   // create selected items defining a circle
-  selectedItems = [];
-  selectedItems.push(new Circle({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedEntities = [];
+  selectedEntities.push(new Circle({ points: [new Point(100, 100), new Point(200, 100)] }));
 
   hatch = new Hatch();
-  boundaryData = hatch.processSelection(selectedItems);
+  boundaryData = hatch.processSelection(selectedEntities);
   expect(boundaryData.length).toEqual(1);
   expect(boundaryData[0].points.length).toEqual(2);
 
   // create selected items defining a square (polyline)
-  selectedItems = [];
-  selectedItems.push(new Polyline({
+  selectedEntities = [];
+  selectedEntities.push(new Polyline({
     points: [new Point(100, 100), new Point(200, 100), new Point(200, 200),
       new Point(100, 200), new Point(100, 100)],
   }));
 
   hatch = new Hatch();
-  boundaryData = hatch.processSelection(selectedItems);
+  boundaryData = hatch.processSelection(selectedEntities);
   expect(boundaryData.length).toEqual(1);
   expect(boundaryData[0].points.length).toEqual(4);
 
   // create selected items defining a pill shape
-  selectedItems = [];
-  selectedItems.push(new Line({ points: [new Point(100, 100), new Point(200, 100)] }));
-  selectedItems.push(new Arc({ points: [new Point(200, 150), new Point(200, 100), new Point(200, 200)] }));
-  selectedItems.push(new Line({ points: [new Point(200, 200), new Point(100, 200)] }));
-  selectedItems.push(new Arc({ points: [new Point(100, 150), new Point(100, 200), new Point(100, 100)] }));
+  selectedEntities = [];
+  selectedEntities.push(new Line({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedEntities.push(new Arc({ points: [new Point(200, 150), new Point(200, 100), new Point(200, 200)] }));
+  selectedEntities.push(new Line({ points: [new Point(200, 200), new Point(100, 200)] }));
+  selectedEntities.push(new Arc({ points: [new Point(100, 150), new Point(100, 200), new Point(100, 100)] }));
 
   hatch = new Hatch();
-  boundaryData = hatch.processSelection(selectedItems);
+  boundaryData = hatch.processSelection(selectedEntities);
   expect(boundaryData.length).toEqual(1);
   // 2 lines + 2 arcs: each shared connection point is merged (not duplicated),
   // so the result is 4 unique vertices, not 5
   expect(boundaryData[0].points.length).toEqual(4);
 
   // Test a selection with invalid items
-  selectedItems = [];
-  selectedItems.push(new Text({ points: [new Point(100, 100), new Point(200, 100)] }));
-  selectedItems.push(new Circle({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedEntities = [];
+  selectedEntities.push(new Text({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedEntities.push(new Circle({ points: [new Point(100, 100), new Point(200, 100)] }));
 
   hatch = new Hatch();
-  boundaryData = hatch.processSelection(selectedItems);
+  boundaryData = hatch.processSelection(selectedEntities);
   expect(boundaryData.length).toEqual(1);
   expect(boundaryData[0].points.length).toEqual(2);
 });
@@ -539,7 +539,7 @@ function makeMockCtx() {
 
 test('Test Hatch.draw solid fill renders filled boundary', () => {
   const solidHatch = new Hatch({ patternName: 'SOLID' });
-  solidHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
+  solidHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
 
   const ctx = makeMockCtx();
   solidHatch.draw(ctx);
@@ -549,7 +549,7 @@ test('Test Hatch.draw solid fill renders filled boundary', () => {
 
 test('Test Hatch.draw unknown pattern does not stroke pattern lines', () => {
   const unknownHatch = new Hatch({ patternName: 'ANSI31' });
-  unknownHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
+  unknownHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
   // Override pattern to a nonexistent name
   unknownHatch.setProperty('patternName', 'NOTAPATTERN');
 
@@ -567,7 +567,7 @@ test('Test Hatch.draw tight bound line count - square boundary', () => {
   // yIncrement = ceil(70.71 / 3.175) = 23 → loop i=-23..22 = 46 raw lines
   // i=-23 (|ly|=73.025 > halfY=70.71) misses the square → 45 clipped segments
   const squareHatch = new Hatch({ patternName: 'ANSI31' });
-  squareHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
+  squareHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
   const ctx = makeMockCtx();
   squareHatch.draw(ctx);
   expect(ctx.getMoveCalls()).toBe(45);
@@ -580,7 +580,7 @@ test('Test Hatch.draw tight bound line count - flat boundary', () => {
   // yIncrement = ceil(38.89 / 3.175) = 13 → loop i=-13..12 = 26 raw lines
   // i=-13 (|ly|=41.275 > halfY=38.89) misses the flat box → 25 clipped segments
   const flatHatch = new Hatch({ patternName: 'ANSI31' });
-  flatHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 10), new Point(0, 10)] })]);
+  flatHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 10), new Point(0, 10)] })]);
   const ctx = makeMockCtx();
   flatHatch.draw(ctx);
   expect(ctx.getMoveCalls()).toBe(25);
@@ -589,10 +589,10 @@ test('Test Hatch.draw tight bound line count - flat boundary', () => {
 test('Test Hatch.draw tight bound produces fewer lines for flat boundary', () => {
   // A flat boundary (100x10) should produce fewer lines than a square (100x100).
   const squareHatch = new Hatch({ patternName: 'ANSI31' });
-  squareHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
+  squareHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
 
   const flatHatch = new Hatch({ patternName: 'ANSI31' });
-  flatHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 10), new Point(0, 10)] })]);
+  flatHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 10), new Point(0, 10)] })]);
 
   const squareCtx = makeMockCtx();
   squareHatch.draw(squareCtx);
@@ -614,14 +614,14 @@ test('Hatch.buildPatternCache no childEntities sets cachedPattern to empty array
 
 test('Hatch.buildPatternCache solid fill sets cachedPattern to empty array', () => {
   const h = new Hatch({ patternName: 'SOLID' });
-  h.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
+  h.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
   h.buildPatternCache();
   expect(h.cachedPattern).toEqual([]);
 });
 
 test('Hatch.buildPatternCache unknown pattern sets cachedPattern to empty array', () => {
   const h = new Hatch({ patternName: 'HONEY' });
-  h.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
+  h.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
   h.setProperty('patternName', 'NOTAPATTERN');
   h.buildPatternCache();
   expect(h.cachedPattern).toEqual([]);
@@ -631,9 +631,9 @@ test('Hatch.buildPatternCache unknown pattern sets cachedPattern to empty array'
 
 /**
  * Build a 100×100 square boundary
- * @return {Array} array containing one BasePolyline boundary
+ * @return {Array} array containing one PolylineBase boundary
  */
-const makeSquare = () => [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })];
+const makeSquare = () => [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })];
 
 /**
  * Sum all segment counts across all families in a cached hatch
@@ -731,9 +731,9 @@ test('Hatch.buildPatternCache scale change invalidates and rebuilds cache with u
 
 /**
  * A 20×20 inner square hole centred in the 100×100 outer square
- * @return {BasePolyline} inner boundary polyline
+ * @return {PolylineBase} inner boundary polyline
  */
-const makeInnerSquare = () => new BasePolyline({ points: [new Point(40, 40), new Point(60, 40), new Point(60, 60), new Point(40, 60)] });
+const makeInnerSquare = () => new PolylineBase({ points: [new Point(40, 40), new Point(60, 40), new Point(60, 60), new Point(40, 60)] });
 
 test('Hatch.buildPatternCache ANSI31 nested boundary: no segment midpoint inside inner hole', () => {
   // Even-odd rule: a ray from inside the hole crosses 2 boundaries → even → not hatched
@@ -951,7 +951,7 @@ test('Hatch.setProperty patternName updates pattern and solid flag via setter',
 test('Hatch.setProperty points translation shifts child entity positions', () => {
   const h = new Hatch({ patternName: 'ANSI31' });
   // h.points = [Point(0,0), Point(1,1)] — 45° angle set by constructor
-  h.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
+  h.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
 
   // New points: same 45° angle (delta angle = 0 → no rotation), origin shifted by (5, 0)
   h.setProperty('points', [new Point(5, 0), new Point(6, 1)]);