@design-core/core 0.0.5 → 0.0.7

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;

package/test/entities/entity.test.js

@@ -10,7 +10,7 @@ new Core();
 
 test('Test Entity.colour', () => {
   const entity = new Entity();
-  expect(entity.colour).toEqual({ 'r': 1, 'g': 1, 'b': 1 });
+  expect(entity.getProperty('colour')).toEqual({ 'r': 1, 'g': 1, 'b': 1 });
 });
 
 test('Test Entity.getLineType', () => {
@@ -36,12 +36,46 @@ test('Test Entity.touched', () => {
   expect(entity.touched(selectionExtremesTrue)).toBe(true);
 });
 
-test('Test Entity.trim', () => {
-  const entity = new Entity();
-  expect(entity.trim()).toEqual([]);
-});
+describe('Entity.fromDxf', () => {
+  test('maps group code 62 to colourACI (absolute value)', () => {
+    const data = Entity.fromDxf({ 62: 3 });
+    expect(data.colourACI).toBe(3);
 
-test('Test Entity.extend', () => {
-  const entity = new Entity();
-  expect(entity.extend()).toEqual([]);
+    // negative ACI indicates layer is off; should be made positive
+    const negData = Entity.fromDxf({ 62: -3 });
+    expect(negData.colourACI).toBe(3);
+  });
+
+  test('maps group code 420 to trueColour', () => {
+    // Red=200, Green=100, Blue=50 → 0x00C86432 = 13132850
+    const data = Entity.fromDxf({ 420: 13132850 });
+    expect(data.trueColour).toBe(13132850);
+  });
+
+  test('preserves all other properties unchanged', () => {
+    const data = Entity.fromDxf({ layer: 'TEST', 8: 'TEST', 5: 'ABC' });
+    expect(data.layer).toBe('TEST');
+    expect(data[8]).toBe('TEST');
+    expect(data[5]).toBe('ABC');
+  });
+
+  test('ACI colour is applied to entity via colourACI', () => {
+    const e = new Entity(Entity.fromDxf({ 62: 1 })); // ACI 1 = red
+    expect(e.getProperty('colour')).toEqual({ r: 255, g: 0, b: 0 });
+  });
+
+  test('true colour overrides ACI when both are present', () => {
+    // ACI 1 = red; trueColour = green (0x0000FF00 >> 8 = 255... actually 0x00 00 FF 00)
+    // pure green = r:0, g:255, b:0 → 0x0000FF00 = 65280
+    const e = new Entity(Entity.fromDxf({ 62: 1, 420: 65280 }));
+    expect(e.getProperty('colour').g).toBe(255);
+    expect(e.getProperty('colour').r).toBe(0);
+    expect(e.getProperty('colour').b).toBe(0);
+  });
+
+  test('no colour codes leaves entity at default byLayer colour', () => {
+    const data = Entity.fromDxf({ layer: '0' });
+    expect(data.colourACI).toBeUndefined();
+    expect(data.trueColour).toBeUndefined();
+  });
 });