@design-core/core 0.0.1 → 0.0.3

package/test/entities/line.test.js

@@ -1,9 +1,62 @@
-import {Line} from '../../core/entities/line.js';
-import {Point} from '../../core/entities/point.js';
+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';
 
-test('Test BasePolyline.closestPoint', () => {
+// initialise core
+new Core();
+
+const inputScenarios = [
+  {
+    desc: 'horizontal line',
+    input1: new Point(0, 0),
+    input2: new Point(10, 0),
+    expectedLength: 10,
+    expectedMid: { x: 5, y: 0 },
+  },
+  {
+    desc: 'vertical line',
+    input1: new Point(0, 0),
+    input2: new Point(0, 10),
+    expectedLength: 10,
+    expectedMid: { x: 0, y: 5 },
+  },
+  {
+    desc: 'diagonal line',
+    input1: new Point(0, 0),
+    input2: new Point(3, 4),
+    expectedLength: 5,
+    expectedMid: { x: 1.5, y: 2 },
+  },
+  {
+    desc: 'same point',
+    input1: new Point(2, 2),
+    input2: new Point(2, 2),
+    expectedLength: 0,
+    expectedMid: { x: 2, y: 2 },
+  },
+];
+
+test.each(inputScenarios)('Line.execute handles $desc', async ({ input1, input2, expectedLength, expectedMid }) => {
+  await withMockInput(DesignCore.Scene, [input1, input2], async () => {
+    const line = new Line({});
+    await line.execute();
+
+    expect(line.points.length).toBe(2);
+    expect(line.points[0]).toBe(input1);
+    expect(line.points[1]).toBe(input2);
+
+    expect(line.length()).toBeCloseTo(expectedLength);
+    expect(line.midPoint().x).toBeCloseTo(expectedMid.x);
+    expect(line.midPoint().y).toBeCloseTo(expectedMid.y);
+  });
+});
+
+test('Test Line.closestPoint', () => {
   const points = [new Point(100, 100), new Point(200, 100)];
-  const line = new Line({points: points});
+  const line = new Line({ points: points });
   // line segment
   const point1 = new Point(150, 85);
   const closest1 = line.closestPoint(point1);
@@ -13,15 +66,138 @@ test('Test BasePolyline.closestPoint', () => {
 });
 
 test('Test Line.boundingBox', () => {
-  let line = new Line({points: [new Point(101, 102), new Point(201, 202)]});
+  let line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
   expect(line.boundingBox().xMin).toBeCloseTo(101);
   expect(line.boundingBox().xMax).toBeCloseTo(201);
   expect(line.boundingBox().yMin).toBeCloseTo(102);
   expect(line.boundingBox().yMax).toBeCloseTo(202);
 
-  line = new Line({points: [new Point(101, 102), new Point(-201, 202)]});
+  line = new Line({ points: [new Point(101, 102), new Point(-201, 202)] });
   expect(line.boundingBox().xMin).toBeCloseTo(-201);
   expect(line.boundingBox().xMax).toBeCloseTo(101);
   expect(line.boundingBox().yMin).toBeCloseTo(102);
   expect(line.boundingBox().yMax).toBeCloseTo(202);
 });
+
+test('Test Line.dxf', () => {
+  const line = new Line({ handle: '1', points: [new Point(101, 102), new Point(201, 202)] });
+  let file = new File();
+  line.dxf(file);
+  // console.log(file.contents);
+
+  const dxfString = `0
+LINE
+5
+1
+100
+AcDbEntity
+100
+AcDbLine
+8
+0
+6
+ByLayer
+10
+101
+20
+102
+30
+0.0
+11
+201
+21
+202
+31
+0.0
+39
+2
+`;
+
+  expect(file.contents).toEqual(dxfString);
+
+  // create new entity from entity data to ensure all props are loaded
+  const newLine = new Line(line);
+  file = new File();
+  newLine.dxf(file);
+  expect(file.contents).toEqual(dxfString);
+});
+
+test('Test Line.toPolylinePoints', () => {
+  const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
+  const linePoints = line.toPolylinePoints();
+  expect(linePoints[0].x).toBe(101);
+  expect(linePoints[0].y).toBe(102);
+  expect(linePoints[0].bulge).toBe(0);
+
+  expect(linePoints[1].x).toBe(201);
+  expect(linePoints[1].y).toBe(202);
+  expect(linePoints[1].bulge).toBe(0);
+});
+
+
+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.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);
+  const pt3 = new Point(10, 10);
+
+  await withMockInput(DesignCore.Scene, [pt1, pt2, pt3, 'Close'], async () => {
+    const line = new Line({});
+    await line.execute();
+
+    expect(line.points.length).toBe(4);
+    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: () => {} } });
+});
+
+test('Line.fromPolylinePoints round-trip preserves points exactly', () => {
+  const line = new Line({ points: [new Point(3, 7), new Point(15, -4)] });
+  const polyPts = line.toPolylinePoints();
+  const rebuilt = new Line({});
+  rebuilt.fromPolylinePoints(polyPts);
+  expect(rebuilt.points[0].x).toBe(3);
+  expect(rebuilt.points[0].y).toBe(7);
+  expect(rebuilt.points[1].x).toBe(15);
+  expect(rebuilt.points[1].y).toBe(-4);
+});