@design-core/core 0.0.6 → 0.0.7

package/test/entities/arctext.test.js

@@ -29,12 +29,12 @@ test.each(arcInputScenarios)('ArcText.execute handles $desc', async (scenario) =
     const arcText = new ArcAlignedText();
     await arcText.execute();
 
-    expect(arcText.styleName).toBe('STANDARD');
-    expect(arcText.height).toBe(expectedTextHeight);
-    expect(arcText.string).toBe(expectedText);
+    expect(arcText.getProperty('styleName')).toBe('STANDARD');
+    expect(arcText.getProperty('height')).toBe(expectedTextHeight);
+    expect(arcText.getProperty('string')).toBe(expectedText);
 
     // arc props
-    expect(arcText.radius).toBe(100);
+    expect(arcText.getProperty('radius')).toBe(100);
     expect(arcText.startAngle()).toBe(0);
     expect(arcText.endAngle()).toBeCloseTo(3.14159);
   }, { selectedItems });
@@ -52,7 +52,7 @@ test('ArcAlignedCharacter', () => {
   expect(ac.position.y).toBe(point.y);
   expect(ac.angle).toBeCloseTo(angle);
   expect(ac.baseline.x).toBe(10.5);
-  expect(ac.baseline.y).toBe(19.7);
+  expect(ac.baseline.y).toBe(19.5);
   expect(ac.boundingBox).toBeInstanceOf(BoundingBox);
 });
 
@@ -115,14 +115,14 @@ test('ArcText getArcAlignedCharacters', () => {
   expect(chars.length).toBe(4);
   // First character
   expect(chars[0].character).toBe('T');
-  expect(chars[0].position.x).toBeCloseTo(-2.39222);
-  expect(chars[0].position.y).toBeCloseTo(101.22173);
-  expect(chars[0].angle).toBeCloseTo(0.02362);
+  expect(chars[0].position.x).toBeCloseTo(-2.05483);
+  expect(chars[0].position.y).toBeCloseTo(101.22915);
+  expect(chars[0].angle).toBeCloseTo(0.02030);
   // Fourth character
   expect(chars.at(-1).character).toBe('t');
-  expect(chars.at(-1).position.x).toBeCloseTo(2.39222);
-  expect(chars.at(-1).position.y).toBeCloseTo(101.22173);
-  expect(chars.at(-1).angle).toBeCloseTo(-0.02362);
+  expect(chars.at(-1).position.x).toBeCloseTo(2.05483);
+  expect(chars.at(-1).position.y).toBeCloseTo(101.22915);
+  expect(chars.at(-1).angle).toBeCloseTo(-0.02030);
 
 
   // //////// Text Alignment Tests //////////
@@ -133,29 +133,29 @@ test('ArcText getArcAlignedCharacters', () => {
   expect(chars.length).toBe(4);
   // First character - Reversed!
   expect(chars[0].character).toBe('t');
-  expect(chars[0].position.x).toBeCloseTo(101.24722);
-  expect(chars[0].position.y).toBeCloseTo(0.74997);
-  expect(chars[0].angle).toBeCloseTo(-1.56338);
+  expect(chars[0].position.x).toBeCloseTo(101.23852);
+  expect(chars[0].position.y).toBeCloseTo(1.52491);
+  expect(chars[0].angle).toBeCloseTo(-1.55573);
   // Last character - Reversed!
   expect(chars.at(-1).character).toBe('T');
-  expect(chars.at(-1).position.x).toBeCloseTo(101.09875);
-  expect(chars.at(-1).position.y).toBeCloseTo(5.53213);
-  expect(chars.at(-1).angle).toBeCloseTo(-1.51613);
+  expect(chars.at(-1).position.x).toBeCloseTo(101.09324);
+  expect(chars.at(-1).position.y).toBeCloseTo(5.63200);
+  expect(chars.at(-1).angle).toBeCloseTo(-1.51514);
 
-  // Create ArcAlignedText - left aligned - textAlignment = 3
+  // Create ArcAlignedText - left aligned - textAlignment = 2
   const arcTextAlignLeft = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Test', radius: 100, textAlignment: 2 });
   chars = arcTextAlignLeft.getArcAlignedCharacters();
   expect(chars.length).toBe(4);
   // First character
   expect(chars[0].character).toBe('T');
-  expect(chars[0].position.x).toBeCloseTo(-101.247222);
-  expect(chars[0].position.y).toBeCloseTo(0.749979);
-  expect(chars[0].angle).toBeCloseTo(1.56338);
+  expect(chars[0].position.x).toBeCloseTo(-101.24664);
+  expect(chars[0].position.y).toBeCloseTo(0.82499);
+  expect(chars[0].angle).toBeCloseTo(1.56265);
   // Last character
   expect(chars.at(-1).character).toBe('t');
-  expect(chars.at(-1).position.x).toBeCloseTo(-101.09875);
-  expect(chars.at(-1).position.y).toBeCloseTo(5.53213);
-  expect(chars.at(-1).angle).toBeCloseTo(1.51613);
+  expect(chars.at(-1).position.x).toBeCloseTo(-101.12976);
+  expect(chars.at(-1).position.y).toBeCloseTo(4.93298);
+  expect(chars.at(-1).angle).toBeCloseTo(1.52206);
 
   // Create ArcAlignedText - fit to arc - textAlignment = 1
   const arcTextFitToArc = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Test', radius: 100, textAlignment: 1 });
@@ -163,14 +163,14 @@ test('ArcText getArcAlignedCharacters', () => {
   expect(chars.length).toBe(4);
   // First character
   expect(chars[0].character).toBe('T');
-  expect(chars[0].position.x).toBeCloseTo(-101.247222);
-  expect(chars[0].position.y).toBeCloseTo(0.74997);
-  expect(chars[0].angle).toBeCloseTo(1.56338);
+  expect(chars[0].position.x).toBeCloseTo(-101.24664);
+  expect(chars[0].position.y).toBeCloseTo(0.82499);
+  expect(chars[0].angle).toBeCloseTo(1.56265);
   // Last character
   expect(chars.at(-1).character).toBe('t');
-  expect(chars.at(-1).position.x).toBeCloseTo(101.24722);
-  expect(chars.at(-1).position.y).toBeCloseTo(0.74997);
-  expect(chars.at(-1).angle).toBeCloseTo(-1.56338);
+  expect(chars.at(-1).position.x).toBeCloseTo(101.23852);
+  expect(chars.at(-1).position.y).toBeCloseTo(1.52491);
+  expect(chars.at(-1).angle).toBeCloseTo(-1.55573);
 
   // //////// Arc Side Tests //////////
 
@@ -180,14 +180,14 @@ test('ArcText getArcAlignedCharacters', () => {
   expect(chars.length).toBe(4);
   // First character
   expect(chars[0].character).toBe('T');
-  expect(chars[0].position.x).toBeCloseTo(-2.39222);
-  expect(chars[0].position.y).toBeCloseTo(101.22173);
-  expect(chars[0].angle).toBeCloseTo(0.02362);
+  expect(chars[0].position.x).toBeCloseTo(-2.05483);
+  expect(chars[0].position.y).toBeCloseTo(101.22915);
+  expect(chars[0].angle).toBeCloseTo(0.02030);
   // Fourth character
   expect(chars.at(-1).character).toBe('t');
-  expect(chars.at(-1).position.x).toBeCloseTo(2.39222);
-  expect(chars.at(-1).position.y).toBeCloseTo(101.22173);
-  expect(chars.at(-1).angle).toBeCloseTo(-0.02362);
+  expect(chars.at(-1).position.x).toBeCloseTo(2.05483);
+  expect(chars.at(-1).position.y).toBeCloseTo(101.22915);
+  expect(chars.at(-1).angle).toBeCloseTo(-0.02030);
 
   // Create ArcAlignedText with string 'Test' and radius 100
   const arcTextConcave = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Test', radius: 100, arcSide: 2 });
@@ -195,14 +195,14 @@ test('ArcText getArcAlignedCharacters', () => {
   expect(chars.length).toBe(4);
   // First character
   expect(chars[0].character).toBe('T');
-  expect(chars[0].position.x).toBeCloseTo(-2.39222);
-  expect(chars[0].position.y).toBeCloseTo(98.72102);
-  expect(chars[0].angle).toBeCloseTo(0.02422);
+  expect(chars[0].position.x).toBeCloseTo(-2.05482);
+  expect(chars[0].position.y).toBeCloseTo(98.72862);
+  expect(chars[0].angle).toBeCloseTo(0.02081);
   // Fourth character
   expect(chars.at(-1).character).toBe('t');
-  expect(chars.at(-1).position.x).toBeCloseTo(2.39222);
-  expect(chars.at(-1).position.y).toBeCloseTo(98.72102);
-  expect(chars.at(-1).angle).toBeCloseTo(-0.02362);
+  expect(chars.at(-1).position.x).toBeCloseTo(2.05482);
+  expect(chars.at(-1).position.y).toBeCloseTo(98.72862);
+  expect(chars.at(-1).angle).toBeCloseTo(-0.02081);
 });
 
 test('ArcText.dxf', () => {
@@ -290,7 +290,21 @@ STANDARD
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newArcAlignedText = new ArcAlignedText(arctext);
+  const newArcAlignedText = new ArcAlignedText({
+    handle: arctext.getProperty('handle'),
+    points: arctext.points,
+    string: arctext.getProperty('string'),
+    styleName: arctext.getProperty('styleName'),
+    radius: arctext.getProperty('radius'),
+    height: arctext.getProperty('height'),
+    characterSpacing: arctext.getProperty('characterSpacing'),
+    offsetFromArc: arctext.getProperty('offsetFromArc'),
+    offsetFromRight: arctext.getProperty('offsetFromRight'),
+    offsetFromLeft: arctext.getProperty('offsetFromLeft'),
+    textOrientation: arctext.getProperty('textOrientation'),
+    textAlignment: arctext.getProperty('textAlignment'),
+    arcSide: arctext.getProperty('arcSide'),
+  });
   file = new File();
   newArcAlignedText.dxf(file);
   expect(file.contents).toEqual(dxfString);
@@ -301,32 +315,32 @@ test('Test ArcText.snaps', () => {
   const point = new Point(100, 100);
   const snaps = arcText.snaps(point, 1);
   const nodeSnaps = snaps.filter((s) => s.type === 'node');
-  expect(nodeSnaps[0].snapPoint.x).toBeCloseTo(-2.39222);
-  expect(nodeSnaps[0].snapPoint.y).toBeCloseTo(101.22173);
+  expect(nodeSnaps[0].snapPoint.x).toBeCloseTo(-2.05483);
+  expect(nodeSnaps[0].snapPoint.y).toBeCloseTo(101.22915);
 });
 
 test('Test ArcText.closestPoint', () => {
   const arcText = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Test', radius: 100 });
   const point = new Point(100, 100);
   const closest = arcText.closestPoint(point);
-  expect(closest[0].x).toBeCloseTo(2.39222);
-  expect(closest[0].y).toBeCloseTo(101.22173);
+  expect(closest[0].x).toBeCloseTo(2.05483);
+  expect(closest[0].y).toBeCloseTo(101.22915);
 });
 
 test('Test ArcText.boundingBox', () => {
   const arcText = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Test', radius: 100 });
-  expect(arcText.boundingBox().xMin).toBeCloseTo(-3.14222);
-  expect(arcText.boundingBox().xMax).toBeCloseTo(3.14222);
-  expect(arcText.boundingBox().yMin).toBeCloseTo(99.97173);
-  expect(arcText.boundingBox().yMax).toBeCloseTo(102.49685);
+  expect(arcText.boundingBox().xMin).toBeCloseTo(-2.81733);
+  expect(arcText.boundingBox().xMax).toBeCloseTo(2.46733);
+  expect(arcText.boundingBox().yMin).toBeCloseTo(99.97915);
+  expect(arcText.boundingBox().yMax).toBeCloseTo(102.49878);
 });
 
 test('Test ArcText.toPolylinePoints - returns correct points array', () => {
   const arcText = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Test', radius: 100 });
   const result = arcText.toPolylinePoints();
   expect(result.length).toBe(4);
-  expect(result[0].x).toBeCloseTo(-2.39222);
-  expect(result[0].y).toBeCloseTo(101.22173);
+  expect(result[0].x).toBeCloseTo(-2.05483);
+  expect(result[0].y).toBeCloseTo(101.22915);
 });
 
 test('ArcText.snaps returns a centre snap at points[0]', () => {
@@ -343,3 +357,116 @@ test('ArcText.snaps returns node snaps only for non-space characters', () => {
   const nodeSnaps = arcText.snaps(new Point(0, 0), 100).filter((s) => s.type === 'node');
   expect(nodeSnaps.length).toBe(2);
 });
+
+test('ArcAlignedCharacter respects explicit height and width', () => {
+  const ac = new ArcAlignedCharacter('A', new Point(0, 0), 0, 5, 3);
+  expect(ac.height).toBe(5);
+  expect(ac.width).toBe(3);
+});
+
+test('ArcText getArcAlignedCharacters empty string returns empty array', () => {
+  const arcText = new ArcAlignedText({ points: [new Point(0, 0)], string: '', radius: 100 });
+  expect(arcText.getArcAlignedCharacters()).toHaveLength(0);
+});
+
+test('ArcText boundingBox empty string returns BoundingBox instance', () => {
+  const arcText = new ArcAlignedText({ points: [new Point(0, 0)], string: '', radius: 100 });
+  expect(arcText.boundingBox()).toBeInstanceOf(BoundingBox);
+});
+
+test('ArcText toPolylinePoints empty string returns empty array', () => {
+  const arcText = new ArcAlignedText({ points: [new Point(0, 0)], string: '', radius: 100 });
+  expect(arcText.toPolylinePoints()).toHaveLength(0);
+});
+
+test('ArcText snaps with empty string returns only centre snap', () => {
+  const arcText = new ArcAlignedText({ points: [new Point(0, 0)], string: '', radius: 100 });
+  const snaps = arcText.snaps(new Point(0, 0), 1);
+  expect(snaps).toHaveLength(1);
+  expect(snaps[0].type).toBe('centre');
+});
+
+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
+  const arcText = new ArcAlignedText({ points: [new Point(0, 0)], string: 'T', radius: 100 });
+  const chars = arcText.getArcAlignedCharacters();
+  const charPos = chars[0].position;
+  // 0.5 units away is within the 0.875 threshold
+  const closePoint = new Point(charPos.x + 0.5, charPos.y);
+  const [, dist] = arcText.closestPoint(closePoint);
+  expect(dist).toBe(0.1);
+});
+
+test('ArcText getArcAlignedCharacters fit-to-arc single character places at midpoint', () => {
+  const t = new ArcAlignedText({ points: [new Point(0, 0)], radius: 10, string: 'X',
+    startAngle: 0, endAngle: 180, textAlignment: 1 });
+  const chars = t.getArcAlignedCharacters();
+  expect(chars).toHaveLength(1);
+  // midpoint of 0°–180° arc at radius 10 is 90° → point near (0, 10)
+  expect(chars[0].position.x).toBeCloseTo(0, 0);
+  expect(chars[0].position.y).toBeGreaterThan(0);
+});
+
+test('ArcText getArcAlignedCharacters single character is placed at arc midpoint', () => {
+  // Single char with center 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();
+  expect(chars).toHaveLength(1);
+  expect(chars[0].character).toBe('X');
+  expect(chars[0].position.x).toBeCloseTo(0, 4);
+  expect(chars[0].position.y).toBeCloseTo(101.25, 4);
+  expect(chars[0].angle).toBeCloseTo(0, 4);
+});
+
+test('ArcText getArcAlignedCharacters textOrientation inward reverses character order', () => {
+  // textOrientation 2 reverses the string before placing characters
+  const arcText = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Test', radius: 100, textOrientation: 2 });
+  const chars = arcText.getArcAlignedCharacters();
+  expect(chars).toHaveLength(4);
+  expect(chars[0].character).toBe('t'); // reversed
+  expect(chars.at(-1).character).toBe('T'); // reversed
+});
+
+test('ArcText getArcAlignedCharacters offsetFromLeft shifts character positions', () => {
+  // offsetFromLeft moves the string start away from the arc end for left-aligned text
+  const base = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Test', radius: 100, textAlignment: 2, offsetFromLeft: 0 });
+  const offset = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Test', radius: 100, textAlignment: 2, offsetFromLeft: 10 });
+  const baseChars = base.getArcAlignedCharacters();
+  const offsetChars = offset.getArcAlignedCharacters();
+  expect(offsetChars[0].position.x).not.toBeCloseTo(baseChars[0].position.x, 1);
+});
+
+test('ArcText getArcAlignedCharacters offsetFromRight shifts character positions', () => {
+  // offsetFromRight moves the string start away from the arc start for right-aligned text
+  const base = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Test', radius: 100, textAlignment: 3, offsetFromRight: 0 });
+  const offset = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Test', radius: 100, textAlignment: 3, offsetFromRight: 10 });
+  const baseChars = base.getArcAlignedCharacters();
+  const offsetChars = offset.getArcAlignedCharacters();
+  expect(offsetChars[0].position.x).not.toBeCloseTo(baseChars[0].position.x, 1);
+});
+
+test('ArcAlignedText.toCharacters returns one entry per character with scene coords', () => {
+  const arc = new ArcAlignedText({ points: [new Point(0, 0)], string: 'AB', radius: 100 });
+  const chars = arc.toCharacters();
+  expect(chars).toHaveLength(2);
+  expect(chars[0].char).toBe('A');
+  expect(chars[1].char).toBe('B');
+  expect(typeof chars[0].x).toBe('number');
+  expect(typeof chars[0].y).toBe('number');
+  expect(typeof chars[0].rotation).toBe('number');
+});
+
+test('ArcAlignedText.draw calls renderer.drawText with all characters', () => {
+  const arc = new ArcAlignedText({ points: [new Point(0, 0)], string: 'Hi', radius: 50 });
+  let calledChars;
+  const mockRenderer = {
+    drawText(characters) {
+      calledChars = characters;
+    },
+  };
+  arc.draw(mockRenderer);
+  expect(calledChars).toHaveLength(2);
+  expect(calledChars[0].char).toBe('H');
+  expect(calledChars[1].char).toBe('i');
+});

package/test/entities/basePolyline.test.js

@@ -46,6 +46,18 @@ test.each(inputScenarios)('Polyline.execute handles $desc', async (scenario) =>
   }, { extraMethods: { actionCommand: () => {} } });
 });
 
+test('Test BasePolyline.draw calls renderer.drawShape with toPolylinePoints', () => {
+  const polyline = new Polyline({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 5)] });
+  let capturedPoints;
+  const mockRenderer = {
+    drawShape(points) {
+      capturedPoints = points;
+    },
+  };
+  polyline.draw(mockRenderer);
+  expect(capturedPoints).toEqual(polyline.toPolylinePoints());
+});
+
 test('Test BasePolyline.getClosestSegment', () => {
   // Polyline with a line and an arc segment
   const points = [new Point(0, 0), new Point(10, 0), new Point(10, 10)];
@@ -322,7 +334,7 @@ AcDbPolyline
 6
 ByLayer
 39
-2
+1
 90
 3
 70
@@ -350,7 +362,7 @@ ByLayer
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newPolyline = new Polyline(polyline);
+  const newPolyline = new Polyline({ handle: polyline.getProperty('handle'), points: polyline.points });
   file = new File();
   newPolyline.dxf(file);
 
@@ -687,3 +699,57 @@ test('BasePolyline.closestPoint is consistent with getClosestSegmentIndex for cl
   expect(closest.x).toBeCloseTo(0);
   expect(closest.y).toBeCloseTo(5);
 });
+
+// ─── preview ─────────────────────────────────────────────────────────────────
+
+test('BasePolyline.preview - 0 points does nothing', () => {
+  const poly = new BasePolyline({});
+  DesignCore.Scene.auxiliaryEntities.clear();
+  DesignCore.Scene.previewEntities.clear();
+
+  expect(() => poly.preview()).not.toThrow();
+  expect(DesignCore.Scene.auxiliaryEntities.count()).toBe(0);
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+});
+
+test('BasePolyline.preview - LINE mode creates temp entity', () => {
+  const poly = new BasePolyline({});
+  poly.points.push(new Point(0, 0));
+
+  const origCreate = DesignCore.Scene.previewEntities.create;
+  const calls = [];
+  DesignCore.Scene.previewEntities.create = (type, data) => calls.push({ type, data });
+
+  DesignCore.Scene.auxiliaryEntities.clear();
+  poly.preview();
+
+  expect(calls.length).toBeGreaterThanOrEqual(1);
+  // LINE mode: no rubber-band auxiliary entity
+  expect(DesignCore.Scene.auxiliaryEntities.count()).toBe(0);
+
+  DesignCore.Scene.previewEntities.create = origCreate;
+});
+
+test('BasePolyline.preview - ARC mode adds rubber band and creates arc temp entity', () => {
+  const poly = new BasePolyline({});
+  poly.points.push(new Point(0, 0));
+  poly.points.push(new Point(10, 0));
+  poly.inputMode = poly.modes.ARC;
+
+  const origAdd = DesignCore.Scene.auxiliaryEntities.add;
+  const origCreate = DesignCore.Scene.previewEntities.create;
+  const auxAdded = [];
+  const tempCreated = [];
+  DesignCore.Scene.auxiliaryEntities.add = (item) => auxAdded.push(item);
+  DesignCore.Scene.previewEntities.create = (type, data) => tempCreated.push({ type, data });
+
+  poly.preview();
+
+  // ARC mode: rubber-band drawn in auxiliaryEntities
+  expect(auxAdded.length).toBeGreaterThanOrEqual(1);
+  // ARC mode: arc preview drawn in previewEntities
+  expect(tempCreated.length).toBeGreaterThanOrEqual(1);
+
+  DesignCore.Scene.auxiliaryEntities.add = origAdd;
+  DesignCore.Scene.previewEntities.create = origCreate;
+});

package/test/entities/circle.test.js

@@ -96,7 +96,7 @@ ByLayer
 30
 0.0
 39
-2
+1
 40
 100
 `;
@@ -105,7 +105,7 @@ ByLayer
 
 
   // create new entity from entity data to ensure all props are loaded
-  const newCircle = new Circle(circle);
+  const newCircle = new Circle({ handle: circle.getProperty('handle'), points: circle.points });
   file = new File();
   newCircle.dxf(file);
   expect(file.contents).toEqual(dxfString);
@@ -127,73 +127,6 @@ test('Test Circle.toPolylinePoints', () => {
   expect(circlePoints[2].bulge).toBe(0);
 });
 
-test('Test Circle.trim returns empty array when provided with empty intersection list', () => {
-  const circle = new Circle({ points: [new Point(0, 0), new Point(100, 0)] });
-
-  expect(circle.trim([])).toEqual([]);
-  expect(circle.trim()).toEqual([]);
-});
-
-test('Test Circle.trim does not modify circle', () => {
-  const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
-
-  DesignCore.Mouse.pointOnScene = () => new Point(7.71, 7.71);
-
-  // test a single intersection - not valid
-  const intersections = [new Point(10, 0)];
-  expect(circle.trim(intersections)).toEqual([]);
-
-  // test two intersections - should return an arc
-  intersections.push(new Point(-10, 0));
-  let trimWithTwoPoints = circle.trim(intersections);
-  let trimResult = trimWithTwoPoints[0].entity;
-  expect(trimResult.type).toEqual('Arc');
-  // Verify trimmed arc has a unique handle (not the circle's)
-  expect(trimResult.handle).toBeUndefined();
-  expect(trimResult.points[0].x).toEqual(0);
-  expect(trimResult.points[0].y).toEqual(0);
-
-  expect(trimResult.points[1].x).toEqual(10);
-  expect(trimResult.points[1].y).toEqual(0);
-
-  expect(trimResult.points[2].x).toEqual(-10);
-  expect(trimResult.points[2].y).toEqual(0);
-
-  expect(trimWithTwoPoints[1].entity).toEqual(circle);
-
-  // test three intersections - should return an arc from first two points found
-  intersections.push(new Point(0, 10));
-  trimWithTwoPoints = circle.trim(intersections);
-  trimResult = trimWithTwoPoints[0].entity;
-  expect(trimResult.type).toEqual('Arc');
-  expect(trimResult.points[0].x).toEqual(0);
-  expect(trimResult.points[0].y).toEqual(0);
-
-  expect(trimResult.points[1].x).toEqual(10);
-  expect(trimResult.points[1].y).toEqual(0);
-
-  expect(trimResult.points[2].x).toEqual(0);
-  expect(trimResult.points[2].y).toEqual(10);
-
-  expect(trimWithTwoPoints[1].entity).toEqual(circle);
-
-  // test four intersections - should return an arc from first two points found
-  intersections.push(new Point(0, -10));
-  trimWithTwoPoints = circle.trim(intersections);
-  trimResult = trimWithTwoPoints[0].entity;
-  expect(trimResult.type).toEqual('Arc');
-  expect(trimResult.points[0].x).toEqual(0);
-  expect(trimResult.points[0].y).toEqual(0);
-
-  expect(trimResult.points[1].x).toEqual(10);
-  expect(trimResult.points[1].y).toEqual(0);
-
-  expect(trimResult.points[2].x).toEqual(0);
-  expect(trimResult.points[2].y).toEqual(10);
-
-  expect(trimWithTwoPoints[1].entity).toEqual(circle);
-});
-
 test('Circle.execute creates circle from diameter input', async () => {
   const center = new Point(0, 0);
 
@@ -234,8 +167,8 @@ test('Circle.register returns command object', () => {
   expect(Circle.register()).toEqual({ command: 'Circle', shortcut: 'C', type: 'Entity' });
 });
 
-test('Circle constructor loads radius from DXF group code 40', () => {
-  const circle = new Circle({ points: [new Point(0, 0)], 40: 50 });
+test('Circle constructor loads radius from DXF group code 40 via fromDxf', () => {
+  const circle = new Circle(Circle.fromDxf({ points: [new Point(0, 0)], 40: 50 }));
   expect(circle.getRadius()).toBeCloseTo(50);
   expect(circle.points[1].x).toBeCloseTo(50);
   expect(circle.points[1].y).toBeCloseTo(0);
@@ -263,10 +196,10 @@ test('Circle.execute re-prompts on zero-distance point input', async () => {
 });
 
 test('Circle.preview does not throw with 0 or 1 points', () => {
-  const origCreate = DesignCore.Scene.tempEntities.create;
+  const origCreate = DesignCore.Scene.previewEntities.create;
   const origMouse = DesignCore.Mouse.pointOnScene;
   const calls = [];
-  DesignCore.Scene.tempEntities.create = (type, obj) => calls.push([type, obj]);
+  DesignCore.Scene.previewEntities.create = (type, obj) => calls.push([type, obj]);
   DesignCore.Mouse.pointOnScene = () => new Point(5, 5);
 
   const circle0 = new Circle({});
@@ -278,16 +211,20 @@ test('Circle.preview does not throw with 0 or 1 points', () => {
   expect(() => circle1.preview()).not.toThrow();
   expect(calls.some(([type]) => type === 'Circle')).toBe(true);
 
-  DesignCore.Scene.tempEntities.create = origCreate;
+  DesignCore.Scene.previewEntities.create = origCreate;
   DesignCore.Mouse.pointOnScene = origMouse;
 });
 
-test('Circle.draw does not throw', () => {
+test('Circle.draw calls renderer.drawShape with toPolylinePoints', () => {
   const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
-  const ctx = { arc: jest.fn(), stroke: jest.fn() };
-  expect(() => circle.draw(ctx, 1)).not.toThrow();
-  expect(ctx.arc).toHaveBeenCalledTimes(1);
-  expect(ctx.stroke).toHaveBeenCalledTimes(1);
+  let capturedPoints;
+  const mockRenderer = {
+    drawShape(points) {
+      capturedPoints = points;
+    },
+  };
+  circle.draw(mockRenderer);
+  expect(capturedPoints).toEqual(circle.toPolylinePoints());
 });
 
 test('Circle.snaps returns centre snap', () => {
@@ -326,21 +263,21 @@ test('Circle.snaps nearest snap does not fire when too far', () => {
 test('Circle.fromPolylinePoints round-trip preserves centre and radius', () => {
   const circle = new Circle({ points: [new Point(5, 10), new Point(5, 10).project(0, 8)] });
   const polyPts = circle.toPolylinePoints();
-  const rebuilt = new Circle({});
-  rebuilt.fromPolylinePoints(polyPts);
+  const rebuilt = new Circle({}).fromPolylinePoints(polyPts);
+  expect(rebuilt.type).toBe('Circle');
   expect(rebuilt.points[0].x).toBeCloseTo(5, 10);
   expect(rebuilt.points[0].y).toBeCloseTo(10, 10);
-  expect(rebuilt.radius).toBeCloseTo(8, 10);
+  expect(rebuilt.getProperty('radius')).toBeCloseTo(8, 10);
 });
 
 test('Circle.fromPolylinePoints precision drift is negligible', () => {
   const circle = new Circle({ points: [new Point(123.456, -789.012), new Point(123.456, -789.012).project(1.234, 56.789)] });
   const polyPts = circle.toPolylinePoints();
-  const rebuilt = new Circle({});
-  rebuilt.fromPolylinePoints(polyPts);
+  const rebuilt = new Circle({}).fromPolylinePoints(polyPts);
+  expect(rebuilt.type).toBe('Circle');
   const drift = Math.hypot(rebuilt.points[0].x - circle.points[0].x, rebuilt.points[0].y - circle.points[0].y);
   expect(drift).toBeLessThan(1e-10);
-  expect(Math.abs(rebuilt.radius - circle.radius)).toBeLessThan(1e-10);
+  expect(Math.abs(rebuilt.getProperty('radius') - circle.getProperty('radius'))).toBeLessThan(1e-10);
 });
 
 test('Circle.snaps returns two tangent snaps from outside', () => {
@@ -357,6 +294,41 @@ test('Circle.snaps returns two tangent snaps from outside', () => {
   DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
 });
 
+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 });
+    expect(result.points.length).toBe(2);
+    expect(result.points[0]).toBe(center);
+    expect(result.points[1].x).toBeCloseTo(10);
+    expect(result.points[1].y).toBeCloseTo(0);
+  });
+
+  test('preserves all other data properties', () => {
+    const result = Circle.fromDxf({ points: [new Point(0, 0)], 40: 10, 8: 'MyLayer' });
+    expect(result[8]).toBe('MyLayer');
+  });
+
+  test('returns data unchanged when no center point', () => {
+    const data = { 40: 10 };
+    expect(Circle.fromDxf(data)).toBe(data);
+  });
+
+  test('returns data unchanged when no radius code', () => {
+    const data = { points: [new Point(0, 0)] };
+    expect(Circle.fromDxf(data)).toBe(data);
+  });
+
+  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)] });
+    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);
+  });
+});
+
 test('Circle.snaps returns no tangent when fromPoint is inside the circle', () => {
   const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
   const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;