@design-core/core 0.0.5 → 0.0.7

package/test/entities/insert.test.js

@@ -2,6 +2,8 @@ import { Core } from '../../core/core/core.js';
 import { Insert } from '../../core/entities/insert.js';
 import { Point } from '../../core/entities/point.js';
 import { Line } from '../../core/entities/line.js';
+import { Utils } from '../../core/lib/utils.js';
+import { jest } from '@jest/globals';
 
 import { File } from '../test-helpers/test-helpers.js';
 
@@ -85,7 +87,7 @@ AcDbBlockReference
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newInsert = new Insert(insert);
+  const newInsert = new Insert({ handle: insert.getProperty('handle'), points: insert.points });
   file = new File();
   newInsert.dxf(file);
   expect(file.contents).toEqual(dxfString);
@@ -98,3 +100,96 @@ test('Insert.snaps returns a node snap at points[0]', () => {
   expect(nodeSnaps[0].snapPoint.x).toBe(5);
   expect(nodeSnaps[0].snapPoint.y).toBe(10);
 });
+
+describe('Test Insert.draw', () => {
+  /**
+   * Create a minimal mock renderer with a jest spy for applyTransform.
+   * @return {Object} mock renderer
+   */
+  function makeMockCtx() {
+    return {
+      applyTransform: jest.fn(),
+    };
+  }
+
+  test('draw() returns the block items array', () => {
+    const ins = new Insert({ points: [new Point(0, 0)] });
+    const line = new Line({ points: [new Point(0, 0), new Point(1, 1)] });
+    ins.block.addItem(line);
+
+    const result = ins.draw(makeMockCtx());
+    expect(result).toBe(ins.block.items);
+  });
+
+  test('draw() returns empty array when block has no items', () => {
+    const ins = new Insert({ points: [new Point(0, 0)] });
+    const result = ins.draw(makeMockCtx());
+    expect(result).toEqual([]);
+    expect(result).toBe(ins.block.items);
+  });
+
+  test('draw() calls renderer.applyTransform with the insert point coordinates', () => {
+    const ins = new Insert({ points: [new Point(50, 75)] });
+    const ctx = makeMockCtx();
+    ins.draw(ctx);
+    expect(ctx.applyTransform).toHaveBeenCalledWith(expect.objectContaining({ x: 50, y: 75 }));
+  });
+
+  test('draw() calls renderer.applyTransform with rotation converted to radians', () => {
+    const ins = new Insert({ points: [new Point(0, 0)], rotation: 90 });
+    const ctx = makeMockCtx();
+    ins.draw(ctx);
+    expect(ctx.applyTransform).toHaveBeenCalledWith(expect.objectContaining({ rotation: Utils.degrees2radians(90) }));
+  });
+
+  test('draw() calls renderer.applyTransform with rotation 0 when rotation is 0', () => {
+    const ins = new Insert({ points: [new Point(0, 0)] });
+    const ctx = makeMockCtx();
+    ins.draw(ctx);
+    expect(ctx.applyTransform).toHaveBeenCalledWith(expect.objectContaining({ rotation: 0 }));
+  });
+
+  test('draw() calls renderer.applyTransform exactly once', () => {
+    const ins = new Insert({ points: [new Point(10, 20)], rotation: 45 });
+    const ctx = makeMockCtx();
+    ins.draw(ctx);
+    expect(ctx.applyTransform).toHaveBeenCalledTimes(1);
+  });
+
+  test('draw() returns same items reference regardless of scale', () => {
+    const ins = new Insert({ points: [new Point(0, 0)] });
+    const line = new Line({ points: [new Point(0, 0), new Point(1, 1)] });
+    ins.block.addItem(line);
+    expect(ins.draw(makeMockCtx())).toBe(ins.block.items);
+    expect(ins.draw(makeMockCtx())).toBe(ins.block.items);
+  });
+});
+
+describe('Insert.fromDxf', () => {
+  test('maps group code 2 to blockName', () => {
+    const data = Insert.fromDxf({ points: [new Point(0, 0)], 2: 'MYBLOCK' });
+    expect(data.blockName).toBe('MYBLOCK');
+  });
+
+  test('maps group code 50 to rotation', () => {
+    const data = Insert.fromDxf({ points: [new Point(0, 0)], 50: 45 });
+    expect(data.rotation).toBe(45);
+  });
+
+  test('preserves other properties unchanged', () => {
+    const data = Insert.fromDxf({ points: [new Point(1, 2)], layer: 'TEST', 2: 'BLK' });
+    expect(data.layer).toBe('TEST');
+    expect(data.points[0].x).toBe(1);
+  });
+
+  test('result with rotation is equivalent to direct construction', () => {
+    const pt = new Point(5, 10);
+    const i1 = new Insert(Insert.fromDxf({ points: [pt], 50: 90 }));
+    const i2 = new Insert({ points: [pt], rotation: 90 });
+    expect(i1.getProperty('rotation')).toBeCloseTo(i2.getProperty('rotation'));
+  });
+
+  test('unimplemented codes do not throw', () => {
+    expect(() => Insert.fromDxf({ points: [new Point()], 41: 2, 42: 2, 43: 2, 44: 5, 45: 5, 70: 2, 71: 3 })).not.toThrow();
+  });
+});

package/test/entities/line.test.js

@@ -2,7 +2,6 @@ import { Line } from '../../core/entities/line.js';
 import { Point } from '../../core/entities/point.js';
 import { Core } from '../../core/core/core.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
@@ -110,13 +109,13 @@ ByLayer
 31
 0.0
 39
-2
+1
 `;
 
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newLine = new Line(line);
+  const newLine = new Line({ handle: line.getProperty('handle'), points: line.points });
   file = new File();
   newLine.dxf(file);
   expect(file.contents).toEqual(dxfString);
@@ -135,45 +134,19 @@ test('Test Line.toPolylinePoints', () => {
 });
 
 
-test('Test Line.trim returns remove and add states', () => {
-  const line = new Line({ points: [new Point(0, 0), new Point(100, 0)], handle: 'A1' });
-
-  // intersections along the line
-  const i1 = new Point(30, 0);
-  const i2 = new Point(60, 0);
-
-  // place mouse between intersections so trim targets that segment
-  DesignCore.Mouse.pointOnScene = () => new Point(45, 0);
-
-  const changes = line.trim([i1, i2]);
-
-  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 lines have unique handles (not the original)
-  expect(changes[0].entity.handle).toBeUndefined();
-  expect(changes[1].entity.handle).toBeUndefined();
+test('Test Line.draw calls renderer.drawShape with toPolylinePoints', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 5)] });
+  let capturedPoints;
+  const mockRenderer = {
+    drawShape(points) {
+      capturedPoints = points;
+    },
+  };
+  line.draw(mockRenderer);
+  expect(capturedPoints).toEqual(line.toPolylinePoints());
 });
 
 
-test('Test Line.trim returns empty array when provided with empty intersection list', () => {
-  const line = new Line({ points: [new Point(0, 0), new Point(100, 0)] });
-
-  expect(line.trim([])).toEqual([]);
-  expect(line.trim()).toEqual([]);
-});
-
-
-test('Test Line.extend returns empty array when provided with empty intersection list', () => {
-  const line = new Line({ points: [new Point(0, 0), new Point(100, 0)] });
-
-  expect(line.extend([])).toEqual([]);
-  expect(line.extend()).toEqual([]);
-});
-
 test('Line.execute handles Close option', async () => {
   const pt1 = new Point(0, 0);
   const pt2 = new Point(10, 0);
@@ -183,11 +156,12 @@ test('Line.execute handles Close option', async () => {
     const line = new Line({});
     await line.execute();
 
-    expect(line.points.length).toBe(4);
+    // this.points accumulates all confirmed input points (not the closing segment,
+    // which is committed as a separate entity)
+    expect(line.points.length).toBe(3);
     expect(line.points[0]).toBe(pt1);
     expect(line.points[1]).toBe(pt2);
     expect(line.points[2]).toBe(pt3);
-    expect(line.points[3]).toBe(pt1);
   }, { extraMethods: { actionCommand: () => {} } });
 });
 

package/test/entities/lwpolyline.test.js

@@ -0,0 +1,104 @@
+import { jest } from '@jest/globals';
+import { Lwpolyline } from '../../core/entities/lwpolyline.js';
+import { Polyline } from '../../core/entities/polyline.js';
+import { Point } from '../../core/entities/point.js';
+import { Core } from '../../core/core/core.js';
+
+// initialise core
+new Core();
+
+// ─── constructor returns a Polyline ──────────────────────────────────────────
+
+test('Lwpolyline constructor returns a Polyline instance', () => {
+  const result = new Lwpolyline({ points: [new Point(0, 0), new Point(10, 0)] });
+  expect(result).toBeInstanceOf(Polyline);
+});
+
+test('Lwpolyline with no data returns a Polyline instance', () => {
+  const result = new Lwpolyline();
+  expect(result).toBeInstanceOf(Polyline);
+});
+
+// ─── group code 90 vertex count validation ───────────────────────────────────
+
+test('Lwpolyline logs no error when group code 90 matches points.length', () => {
+  const spy = jest.spyOn(console, 'log').mockImplementation(() => {});
+  new Lwpolyline({ 90: 2, points: [new Point(0, 0), new Point(10, 0)] });
+  const errorCalls = spy.mock.calls.filter(([msg]) => msg.startsWith('Error:'));
+  expect(errorCalls).toHaveLength(0);
+  spy.mockRestore();
+});
+
+test('Lwpolyline logs error when group code 90 count does not match points.length', () => {
+  const spy = jest.spyOn(console, 'log').mockImplementation(() => {});
+  new Lwpolyline({ 90: 3, points: [new Point(0, 0), new Point(10, 0)] });
+  const errorCalls = spy.mock.calls.filter(([msg]) => msg.startsWith('Error:'));
+  expect(errorCalls).toHaveLength(1);
+  expect(errorCalls[0][0]).toMatch(/specifies 3 vertices/);
+  expect(errorCalls[0][0]).toMatch(/2 were parsed/);
+  spy.mockRestore();
+});
+
+test('Lwpolyline logs error when group code 90 present but points is undefined', () => {
+  const spy = jest.spyOn(console, 'log').mockImplementation(() => {});
+  new Lwpolyline({ 90: 2 });
+  const errorCalls = spy.mock.calls.filter(([msg]) => msg.startsWith('Error:'));
+  expect(errorCalls).toHaveLength(1);
+  expect(errorCalls[0][0]).toMatch(/points array is missing or invalid/);
+  spy.mockRestore();
+});
+
+test('Lwpolyline logs error when group code 90 present but points is not an array', () => {
+  const spy = jest.spyOn(console, 'log').mockImplementation(() => {});
+  new Lwpolyline({ 90: 1, points: 'bad' });
+  const errorCalls = spy.mock.calls.filter(([msg]) => msg.startsWith('Error:'));
+  expect(errorCalls).toHaveLength(1);
+  expect(errorCalls[0][0]).toMatch(/points array is missing or invalid/);
+  spy.mockRestore();
+});
+
+test('Lwpolyline does not throw when group code 90 present but points is undefined', () => {
+  expect(() => new Lwpolyline({ 90: 2 })).not.toThrow();
+});
+
+// ─── closed-polyline deduplication ───────────────────────────────────────────
+
+test('Lwpolyline removes duplicate closing point and sets closed flag', () => {
+  const pts = [
+    new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 0),
+  ];
+  const result = new Lwpolyline({ points: pts });
+  expect(result.points).toHaveLength(3);
+  expect(result.flags.hasFlag(1)).toBe(true);
+});
+
+test('Lwpolyline preserves existing flags when setting closed bit', () => {
+  const pts = [
+    new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 0),
+  ];
+  // pass flag bit 2 (arbitrary extra flag)
+  const result = new Lwpolyline({ points: pts, 70: 2 });
+  const flagVal = result.flags.getFlagValue();
+  expect(flagVal & 1).toBe(1); // closed bit set
+  expect(flagVal & 2).toBe(2); // original bit preserved
+});
+
+test('Lwpolyline does not remove point when fewer than 4 points with matching ends', () => {
+  const pts = [new Point(0, 0), new Point(10, 0), new Point(0, 0)];
+  const result = new Lwpolyline({ points: pts });
+  expect(result.points).toHaveLength(3);
+  expect(result.flags.hasFlag(1)).toBe(false);
+});
+
+test('Lwpolyline does not modify open polyline', () => {
+  const pts = [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 5)];
+  const result = new Lwpolyline({ points: pts });
+  expect(result.points).toHaveLength(4);
+  expect(result.flags.hasFlag(1)).toBe(false);
+});
+
+// ─── register ────────────────────────────────────────────────────────────────
+
+test('Lwpolyline.register returns command object', () => {
+  expect(Lwpolyline.register()).toEqual({ command: 'Lwpolyline' });
+});

package/test/entities/polyline.test.js

@@ -0,0 +1,11 @@
+import { Polyline } from '../../core/entities/polyline.js';
+import { Core } from '../../core/core/core.js';
+
+// initialise core
+new Core();
+
+// ─── register ────────────────────────────────────────────────────────────────
+
+test('Polyline.register returns correct command object', () => {
+  expect(Polyline.register()).toEqual({ command: 'Polyline', shortcut: 'PL', type: 'Entity' });
+});

package/test/entities/rectangle.test.js

@@ -0,0 +1,11 @@
+import { Rectangle } from '../../core/entities/rectangle.js';
+import { Core } from '../../core/core/core.js';
+
+// initialise core
+new Core();
+
+// ─── register ────────────────────────────────────────────────────────────────
+
+test('Rectangle.register returns correct command object', () => {
+  expect(Rectangle.register()).toEqual({ command: 'Rectangle', shortcut: 'REC', type: 'Entity' });
+});

package/test/entities/solid.test.js

@@ -59,7 +59,7 @@ AcDbTrace
   expect(file.contents).toEqual(dxfString);
 
   // create new entity from entity data to ensure all props are loaded
-  const newSolid = new Solid(solid);
+  const newSolid = new Solid({ handle: solid.getProperty('handle'), points: solid.points });
   file = new File();
   newSolid.dxf(file);
   expect(file.contents).toEqual(dxfString);