@design-core/core 0.0.6 → 50.1.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();
@@ -61,12 +61,12 @@ test.each(scenarios)('RadialDimension.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('R');
+        expect(entity.getProperty('string')).toContain('R');
       }
     }
-  }, { 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 = 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
 });
 
 test('RadialDimension.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('RadialDimension.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 @@ AcDbRadialDimension
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newDimension = new RadialDimension(dimension);
+  const newDimension = new RadialDimension({ handle: dimension.getProperty('handle'), points: dimension.points, ...dimension });
   file = new File();
   newDimension.dxf(file);
   expect(file.contents).toEqual(dxfString);

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();
@@ -40,10 +40,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', () => {
@@ -113,23 +113,29 @@ describe('RotatedDimension.getPointsFromSelection', () => {
 });
 
 test('RotatedDimension.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 RotatedDimension();
   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 RotatedDimension();
@@ -138,7 +144,8 @@ test('RotatedDimension.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;
 });
 
@@ -217,7 +224,7 @@ AcDbRotatedDimension
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newDimension = new RotatedDimension(dimension);
+  const newDimension = new RotatedDimension({ handle: dimension.getProperty('handle'), points: dimension.points, ...dimension });
   file = new File();
   newDimension.dxf(file);
   expect(file.contents).toEqual(dxfString);

package/test/entities/arc.test.js

@@ -1,6 +1,15 @@
+import { Core } from '../../core/core/core.js';
+import { Arc } from '../../core/entities/arc.js';
+import { Point } from '../../core/entities/point.js';
+import { DesignCore } from '../../core/designCore.js';
+
+import { File, withMockInput } from '../test-helpers/test-helpers.js';
 import { jest } from '@jest/globals';
 import { Strings } from '../../core/lib/strings.js';
 
+// initialise core
+new Core();
+
 describe('Arc.execute input validation and notifications', () => {
   let notifySpy;
   beforeEach(() => {
@@ -49,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();
@@ -69,16 +78,6 @@ describe('Arc.execute input validation and notifications', () => {
     });
   });
 });
-import { Core } from '../../core/core/core.js';
-import { Arc } from '../../core/entities/arc.js';
-import { Point } from '../../core/entities/point.js';
-import { DesignCore } from '../../core/designCore.js';
-import { AddState, RemoveState } from '../../core/lib/stateManager.js';
-
-import { File, withMockInput } from '../test-helpers/test-helpers.js';
-
-// initialise core
-new Core();
 
 const arcInputScenarios = [
   {
@@ -95,7 +94,7 @@ const arcInputScenarios = [
     input1: new Point(0, 0),
     input2: new Point(10, 0),
     input3: new Point(10, 10),
-    expectedPt2: (input1, input2, input3) => input3,
+    expectedPt2: (input1, input2, input3) => input1.project(input1.angle(input3), input1.distance(input2)),
     expectedStart: 0,
     expectedEnd: Math.PI / 4,
   },
@@ -274,7 +273,7 @@ ByLayer
 30
 0.0
 39
-2
+1
 40
 100
 100
@@ -288,7 +287,7 @@ AcDbArc
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newArc = new Arc(arc);
+  const newArc = new Arc({ handle: arc.getProperty('handle'), points: arc.points, direction: arc.getProperty('direction') });
   file = new File();
   newArc.dxf(file);
   expect(file.contents).toEqual(dxfString);
@@ -327,58 +326,14 @@ test('Arc constructor handles missing/invalid data', () => {
   expect(() => new Arc({ points: [null, undefined, {}] })).not.toThrow();
 });
 
-test('Arc.trim returns empty for no intersections', () => {
-  const arc = new Arc({ points: [new Point(100, 100), new Point(200, 100), new Point(170.71, 170.71)] });
-  expect(arc.trim([])).toEqual([]);
-  expect(arc.trim()).toEqual([]);
-});
-
-
-test('Arc.trim returns remove + add states when trimming between two intersections', () => {
-  const arc = new Arc({ points: [new Point(), new Point(10, 0), new Point(-10, 0)], handle: 'B2' });
-  // Intersection points on the arc.
-  const i1 = new Point(7.71, 7.71);
-  const i2 = new Point(-7.71, 7.71);
-  const intersections = [i1, i2];
-
-  // set the mouse position to mid point of the arc
-  DesignCore.Mouse.pointOnScene = () => new Point(0, 10);
-
-  const changes = arc.trim(intersections);
-
-  expect(Array.isArray(changes)).toBe(true);
-  expect(changes.length).toBeGreaterThanOrEqual(2);
-
-  expect(changes[0]).toBeInstanceOf(AddState);
-  expect(changes[1]).toBeInstanceOf(AddState);
-  expect(changes[2]).toBeInstanceOf(RemoveState);
-
-  // Verify trimmed arcs have unique handles (not the original)
-  expect(changes[0].entity.handle).toBeUndefined();
-  expect(changes[1].entity.handle).toBeUndefined();
-
-  expect(changes[0].entity.points[0].x).toBe(0);
-  expect(changes[0].entity.points[0].y).toBe(0);
-
-  expect(changes[0].entity.points[1].x).toBeCloseTo(10);
-  expect(changes[0].entity.points[1].y).toBeCloseTo(0);
-  expect(changes[0].entity.points[2].x).toBeCloseTo(7.71);
-  expect(changes[0].entity.points[2].y).toBeCloseTo(7.71);
-
-  expect(changes[1].entity.points[1].x).toBeCloseTo(-7.71);
-  expect(changes[1].entity.points[1].y).toBeCloseTo(7.71);
-  expect(changes[1].entity.points[2].x).toBe(-10);
-  expect(changes[1].entity.points[2].y).toBe(0);
-});
-
 test('Arc.getRadius returns the arc radius', () => {
   const arc = new Arc({ points: [new Point(0, 0), new Point(10, 0), new Point(0, 10)] });
   expect(arc.getRadius()).toBe(10);
 });
 
-test('Arc constructor loads from DXF group codes', () => {
-  const arc = new Arc({ points: [new Point(100, 100)], 40: 50, 50: 0, 51: 90 });
-  expect(arc.radius).toBe(50);
+test('Arc constructor loads from DXF group codes via fromDxf', () => {
+  const arc = new Arc(Arc.fromDxf({ points: [new Point(100, 100)], 40: 50, 50: 0, 51: 90 }));
+  expect(arc.getProperty('radius')).toBe(50);
   expect(arc.points[1].x).toBeCloseTo(150);
   expect(arc.points[1].y).toBeCloseTo(100);
   expect(arc.points[2].x).toBeCloseTo(100);
@@ -387,7 +342,7 @@ test('Arc constructor loads from DXF group codes', () => {
 
 test('Arc constructor loads direction from data', () => {
   const arc = new Arc({ points: [new Point(0, 0), new Point(10, 0), new Point(0, 10)], direction: -1 });
-  expect(arc.direction).toBe(-1);
+  expect(arc.getProperty('direction')).toBe(-1);
 });
 
 test('Arc.toPolylinePoints handles a full circle (360 degrees)', () => {
@@ -401,9 +356,9 @@ test('Arc.toPolylinePoints handles a full circle (360 degrees)', () => {
 });
 
 test('Arc.preview does not throw with 1, 2 or 3 points', () => {
-  const origCreate = DesignCore.Scene.tempEntities.create;
+  const origCreate = DesignCore.Scene.previewEntities.create;
   const origMouse = DesignCore.Mouse.pointOnScene;
-  DesignCore.Scene.tempEntities.create = () => {};
+  DesignCore.Scene.previewEntities.create = () => {};
   DesignCore.Mouse.pointOnScene = () => new Point(5, 5);
 
   const arc1 = new Arc({});
@@ -418,20 +373,30 @@ test('Arc.preview does not throw with 1, 2 or 3 points', () => {
   arc3.points = [new Point(0, 0), new Point(10, 0), new Point(0, 10)];
   expect(() => arc3.preview()).not.toThrow();
 
-  DesignCore.Scene.tempEntities.create = origCreate;
+  DesignCore.Scene.previewEntities.create = origCreate;
   DesignCore.Mouse.pointOnScene = origMouse;
 });
 
-test('Arc.draw does not throw (ccw and cw)', () => {
-  const ctx = { arc: jest.fn(), stroke: jest.fn() };
+test('Arc.draw calls renderer.drawShape with toPolylinePoints', () => {
   const arc = new Arc({ points: [new Point(0, 0), new Point(10, 0), new Point(0, 10)], direction: 1 });
-  expect(() => arc.draw(ctx, 1)).not.toThrow();
-  expect(ctx.arc).toHaveBeenCalledTimes(1);
-  expect(ctx.stroke).toHaveBeenCalledTimes(1);
+  let capturedPoints;
+  const mockRenderer = {
+    drawShape(points) {
+      capturedPoints = points;
+    },
+  };
+  arc.draw(mockRenderer);
+  expect(capturedPoints).toEqual(arc.toPolylinePoints());
+});
 
-  const ctx2 = { arc: jest.fn(), stroke: jest.fn() };
+test('Arc.draw (cw) calls renderer.drawShape with toPolylinePoints', () => {
   const arcCw = new Arc({ points: [new Point(0, 0), new Point(10, 0), new Point(0, 10)], direction: -1 });
-  expect(() => arcCw.draw(ctx2, 1)).not.toThrow();
+  let capturedPoints;
+  const mockRenderer = { drawShape(points) {
+    capturedPoints = points;
+  } };
+  arcCw.draw(mockRenderer);
+  expect(capturedPoints).toEqual(arcCw.toPolylinePoints());
 });
 
 test('Arc.snaps returns end and centre snap points', () => {
@@ -454,7 +419,7 @@ test('Arc.execute handles negative angle (clockwise)', async () => {
     const arc = new Arc({});
     await arc.execute();
     expect(arc.points.length).toBe(3);
-    expect(arc.direction).toBe(-1);
+    expect(arc.getProperty('direction')).toBe(-1);
   });
 });
 
@@ -468,35 +433,26 @@ test('Arc.execute notifies on angle > 360', async () => {
   notifySpy.mockRestore();
 });
 
-test('Arc.trim returns empty when only intersection is at an endpoint', () => {
-  const arc = new Arc({ points: [new Point(0, 0), new Point(10, 0), new Point(-10, 0)] });
-  // intersection exactly at the start point — filtered out, nothing to trim
-  const changes = arc.trim([new Point(10, 0)]);
-  expect(changes).toEqual([]);
-});
-
 test('Arc.fromPolylinePoints round-trip preserves centre, radius and angles', () => {
   const arc = new Arc({ points: [new Point(0, 0), new Point(10, 0), new Point(0, 10)] });
-  arc.radius = 10;
   const polyPts = arc.toPolylinePoints();
   const rebuilt = new Arc({});
   rebuilt.fromPolylinePoints(polyPts);
   expect(rebuilt.points[0].x).toBeCloseTo(0, 10);
   expect(rebuilt.points[0].y).toBeCloseTo(0, 10);
-  expect(rebuilt.radius).toBeCloseTo(10, 10);
+  expect(rebuilt.getProperty('radius')).toBeCloseTo(10, 10);
   expect(rebuilt.startAngle()).toBeCloseTo(arc.startAngle(), 10);
   expect(rebuilt.endAngle()).toBeCloseTo(arc.endAngle(), 10);
 });
 
 test('Arc.fromPolylinePoints precision drift is negligible', () => {
   const arc = new Arc({ points: [new Point(50, 50), new Point(50, 50).project(0.7, 30), new Point(50, 50).project(2.1, 30)] });
-  arc.radius = 30;
   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);
-  expect(Math.abs(rebuilt.radius - arc.radius)).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);
 });
 
 test('Arc.snaps nearest does not fire when mouse is too far from arc', () => {
@@ -531,6 +487,47 @@ test('Arc.snaps returns no tangent when fromPoint is inside the arc radius', ()
   DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
 });
 
+describe('Arc.fromDxf', () => {
+  test('projects start and end points from DXF angle codes', () => {
+    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(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)
+    expect(result.points[2].y).toBeCloseTo(10);
+  });
+
+  test('uses direction from data[73], defaults to 1', () => {
+    const result1 = Arc.fromDxf({ points: [new Point(0, 0)], 40: 10, 50: 0, 51: 90, 73: -1 });
+    expect(result1.direction).toBe(-1);
+
+    const result2 = Arc.fromDxf({ points: [new Point(0, 0)], 40: 10, 50: 0, 51: 90 });
+    expect(result2.direction).toBe(1);
+  });
+
+  test('preserves all other data properties', () => {
+    const result = Arc.fromDxf({ points: [new Point(0, 0)], 40: 10, 50: 0, 51: 90, 8: 'MyLayer', 6: 'ByLayer' });
+    expect(result[8]).toBe('MyLayer');
+    expect(result[6]).toBe('ByLayer');
+  });
+
+  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 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());
+  });
+});
+
 test('Arc.snaps returns perpendicular snap when radial point is on the arc', () => {
   const arc = new Arc({ points: [new Point(0, 0), new Point(10, 0), new Point(0, 10)], direction: 1 });
   const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;