@design-core/core 0.0.7 → 51.1.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);