@design-core/core 0.0.1 → 0.0.3

package/test/entities/hatch.test.js

@@ -0,0 +1,606 @@
+import { Hatch } from '../../core/entities/hatch.js';
+import { Point } from '../../core/entities/point.js';
+import { DesignCore } from '../../core/designCore.js';
+
+import { BasePolyline } from '../../core/entities/basePolyline.js';
+import { BoundingBox } from '../../core/lib/boundingBox.js';
+import { Circle } from '../../core/entities/circle.js';
+import { Line } from '../../core/entities/line.js';
+import { Polyline } from '../../core/entities/polyline.js';
+import { Arc } from '../../core/entities/arc.js';
+import { Text } from '../../core/entities/text.js';
+
+import { File, withMockInput } from '../test-helpers/test-helpers.js';
+
+import { Core } from '../../core/core/core.js';
+
+// initialise core
+new Core();
+
+const points = [new Point(100, 100, 1), new Point(200, 100, 1)];
+const boundaryShape = new BasePolyline({ points: points });
+
+const hatch = new Hatch({ handle: '1' });
+hatch.childEntities = [boundaryShape];
+
+const hatchInputScenarios = [
+  {
+    desc: 'simple rectangle',
+    boundaryItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(10, 0), new Point(10, 10)] }),
+      new Line({ points: [new Point(10, 10), new Point(0, 10)] }), new Line({ points: [new Point(0, 10), new Point(0, 0)] })],
+    pointCount: 4,
+    pattern: 'ANSI31',
+    scale: 1,
+    angle: 0,
+    // expectedPoints: 4,
+    expectedPattern: 'ANSI31',
+    expectedScale: 1,
+    expectedAngle: 0,
+  },
+  {
+    desc: 'triangle, custom pattern and scale',
+    boundaryItems: [new Line({ points: [new Point(0, 0), new Point(5, 10)] }), new Line({ points: [new Point(5, 10), new Point(10, 0)] }),
+      new Line({ points: [new Point(10, 0), new Point(0, 0)] })],
+    pointCount: 3,
+    pattern: 'SOLID',
+    scale: 2,
+    angle: 45,
+    // expectedPoints: 3,
+    expectedPattern: 'SOLID',
+    expectedScale: 2,
+    expectedAngle: 45,
+  },
+];
+
+test.each(hatchInputScenarios)('Hatch.execute handles $desc', async (scenario) => {
+  const { boundaryItems, pointCount, pattern, scale, angle, expectedPattern, expectedScale, expectedAngle } = scenario;
+
+  await withMockInput(DesignCore.Scene, [true], async () => {
+    // Manual mock for selected items
+    DesignCore.Scene.selectionManager.selectedItems = [];
+
+    for (let i = 0; i < boundaryItems.length; i++) {
+      DesignCore.Scene.selectionManager.selectedItems.push(boundaryItems[i]);
+    }
+
+    const hatch = new Hatch({ patternName: pattern, scale: scale, angle: angle });
+
+    await hatch.execute();
+
+    expect(hatch.childEntities.length).toBe(1);
+
+    expect(hatch.childEntities[0].points.length).toBe(pointCount); // closed polyline adds extra point
+
+    expect(hatch.points.length).toBe(2);
+    // hatch first point should be at 0,0
+    expect(hatch.points.at(0).x).toBe(0);
+    expect(hatch.points.at(0).y).toBe(0);
+    // hatch last point should be at 1,1
+    expect(hatch.points.at(-1).x).toBe(1);
+    expect(hatch.points.at(-1).y).toBe(1);
+    expect(hatch.pattern).toBe(expectedPattern);
+    expect(hatch.scale).toBe(expectedScale);
+    expect(hatch.angle).toBe(expectedAngle);
+    expect(hatch.solid).toBe(expectedPattern === 'SOLID');
+  });
+});
+
+test('Test Hatch', () => {
+  const data =
+  {
+    '0': 'HATCH',
+    '2': 'HONEY', // hatch name
+    // '8': '0', // layer name
+    '41': 2, // Pattern scale
+    // '43': 0, // Pattern line base X
+    // '44': 0, // Pattern line base Y
+    // '45': -2.245064030267288, // Pattern line offset x
+    // '46': 2.245064030267288, // Pattern line offset y
+    // '47': 0.5126851563522042, // pixel size
+    '52': 45, // pattern angle
+    // '53': 45, // Pattern line angle
+    '70': 0, // Solid fill flag
+    // '71': 1, // Associativity flag
+    // '72': [0, 1], // Edge type
+    // '73': [1, 1], // Boundary annotation flag
+    // '75': 1, // Hatch style
+    // '76': 1, // Hatch pattern type
+    // '77': 0, // Hatch pattern double flag
+    // '78': 1, // Number of pattern definition lines
+    // '79': 0, // Number of dash length items
+    // '91': 2, // Number of boundary path loops
+    // '92': [7, 7], // Boundary path type flag
+    // '93': [4, 2], // Number of edges in this boundary path / number of points in polyline
+    // '97': [1, 1], // Number of source boundary objects
+    // '98': 2, // Number of seed points
+  };
+
+  const newHatch = new Hatch(data);
+
+  expect(newHatch.patternName).toBe('HONEY');
+  expect(newHatch.angle).toBe(45);
+  expect(newHatch.scale).toBe(2);
+  expect(newHatch.solid).toBe(false);
+});
+
+test('Test Hatch.getDataValue', () => {
+  const data =
+  {
+    '2': 'ANSI31', // hatch name
+    '72': [0, 1], // Edge type
+  };
+
+  expect(hatch.getDataValue(data, 2)).toBe('ANSI31');
+  expect(hatch.getDataValue(data, 72)).toBe(0);
+});
+
+test('Test Hatch.getPatternName', () => {
+  expect(hatch.getPatternName()).toBe('ANSI31');
+});
+
+test('Test Hatch.setPatternName', () => {
+  expect(hatch.solid).toBe(false);
+  hatch.setPatternName('Solid');
+  expect(hatch.pattern).toBe('SOLID');
+  expect(hatch.solid).toBe(true);
+
+  hatch.setPatternName('Ansi31');
+  expect(hatch.pattern).toBe('ANSI31');
+  expect(hatch.solid).toBe(false);
+});
+
+test('Test Hatch.closestPoint', () => {
+  // inside
+  const point1 = new Point(150, 100);
+  const closest1 = hatch.closestPoint(point1);
+  expect(closest1[0].x).toBeCloseTo(150);
+  expect(closest1[0].y).toBeCloseTo(100);
+  expect(closest1[1]).toBe(0);
+
+  // outside
+  const point2 = new Point();
+  const closest2 = hatch.closestPoint(point2);
+  expect(closest2[0].x).toBeCloseTo(0);
+  expect(closest2[0].y).toBeCloseTo(0);
+  expect(closest2[1]).toBeCloseTo(Infinity);
+});
+
+test('Test Hatch.isInside', () => {
+  // Inside Points
+  // upper right quad of circle
+  expect(hatch.isInside(new Point(165, 115))).toBe(true);
+  // upper left quad of circle
+  expect(hatch.isInside(new Point(130, 115))).toBe(true);
+  // lower left quad of circle
+  expect(hatch.isInside(new Point(130, 80))).toBe(true);
+  // lower right quad of circle
+  expect(hatch.isInside(new Point(165, 80))).toBe(true);
+  // middle of circle
+  expect(hatch.isInside(new Point(150, 100))).toBe(true);
+
+  // Outside Points
+  // upper right quad of circle
+  expect(hatch.isInside(new Point(190, 140))).toBe(false);
+  // upper left quad of circle
+  expect(hatch.isInside(new Point(110, 140))).toBe(false);
+  // lower left quad of circle
+  expect(hatch.isInside(new Point(110, 60))).toBe(false);
+  // lower right quad of circle
+  expect(hatch.isInside(new Point(190, 60))).toBe(false);
+  // middle of circle
+  expect(hatch.isInside(new Point(205, 100))).toBe(false);
+});
+
+test('Test Hatch.boundingBox', () => {
+  expect(hatch.boundingBox().xMin).toBe(100);
+  expect(hatch.boundingBox().xMax).toBe(200);
+  expect(hatch.boundingBox().yMin).toBe(50);
+  expect(hatch.boundingBox().yMax).toBe(150);
+});
+
+test('Test Hatch.dxf', () => {
+  let file = new File();
+  hatch.dxf(file);
+  // console.log(file.contents);
+
+  let dxfString = `0
+HATCH
+5
+1
+100
+AcDbEntity
+8
+0
+100
+AcDbHatch
+10
+0.0
+20
+0.0
+30
+0.0
+210
+0.0
+220
+0.0
+230
+1.0
+2
+ANSI31
+70
+0
+71
+0
+91
+1
+92
+7
+72
+1
+73
+1
+93
+2
+10
+100
+20
+100
+42
+1
+10
+200
+20
+100
+42
+1
+97
+0
+75
+1
+76
+1
+52
+0
+41
+1
+77
+0
+78
+1
+53
+45
+43
+0
+44
+0
+45
+-2.245064030267288
+46
+2.2450640302672884
+79
+0
+47
+0.5
+98
+1
+10
+1
+20
+1
+`;
+  expect(file.contents).toEqual(dxfString);
+
+  // create new entity from entity data to ensure all props are loaded
+  const newHatch = new Hatch(hatch);
+  file = new File();
+  newHatch.dxf(file);
+
+
+  // Export rotated and scaled
+  const rotatedScaleHatch = new Hatch({ handle: '1' });
+  rotatedScaleHatch.angle = 45;
+  rotatedScaleHatch.scale = 2;
+
+  file = new File();
+  rotatedScaleHatch.dxf(file);
+  // console.log(file.contents);
+
+  // Don't export hatch if no boundary shapes
+  expect(file.contents).toEqual('');
+
+  const shape = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
+  const boundary = rotatedScaleHatch.processSelection([shape]);
+  expect(boundary[0]).toBeInstanceOf(Polyline);
+
+  rotatedScaleHatch.childEntities = boundary;
+  rotatedScaleHatch.dxf(file);
+  // console.log(file.contents);
+
+  dxfString = `0
+HATCH
+5
+1
+100
+AcDbEntity
+8
+0
+100
+AcDbHatch
+10
+0.0
+20
+0.0
+30
+0.0
+210
+0.0
+220
+0.0
+230
+1.0
+2
+ANSI31
+70
+0
+71
+0
+91
+1
+92
+7
+72
+1
+73
+1
+93
+2
+10
+10
+20
+0
+42
+1
+10
+-10
+20
+0
+42
+1
+97
+0
+75
+1
+76
+1
+52
+45
+41
+2
+77
+0
+78
+1
+53
+90
+43
+0
+44
+0
+45
+-6.35
+46
+3.888253587292846e-16
+79
+0
+47
+0.5
+98
+1
+10
+1
+20
+1
+`;
+  expect(file.contents).toEqual(dxfString);
+});
+
+test('Test Hatch.processBoundaryData', () => {
+  // create data defining a square and a circle
+  const data =
+  {
+    '0': 'HATCH',
+    // '2': 'ANSI31', // hatch name
+    // '8': '0', // layer name
+    // '41': 1, // Pattern scale
+    // '43': 0, // Pattern line base X
+    // '44': 0, // Pattern line base Y
+    // '45': -2.245064030267288, // Pattern line offset x
+    // '46': 2.245064030267288, // Pattern line offset y
+    // '47': 0.5126851563522042, // pixel size
+    // '52': 0, // pattern angle
+    // '53': 45, // Pattern line angle
+    // '70': 0, // Solid fill flag
+    // '71': 1, // Associativity flag
+    '72': [0, 1], // Edge type
+    // '73': [1, 1], // Boundary annotation flag
+    // '75': 1, // Hatch style
+    // '76': 1, // Hatch pattern type
+    // '77': 0, // Hatch pattern double flag
+    '78': 1, // Number of pattern definition lines
+    // '79': 0, // Number of dash length items
+    '91': 2, // Number of boundary path loops
+    '92': [7, 7], // Boundary path type flag
+    '93': [4, 2], // Number of edges in this boundary path / number of points in polyline
+    // '97': [1, 1], // Number of source boundary objects
+    // '98': 2, // Number of seed points
+    // Points 0 and -1 are stripped before processing
+    'points': [new Point(), new Point(200, 200), new Point(100, 200), new Point(100, 100), new Point(200, 100), new Point(350, 300, 1),
+      new Point(250, 300, 1), new Point(350, 300, 1)],
+  };
+
+  const hatch = new Hatch();
+
+  const boundaryData = hatch.processBoundaryData(data);
+
+  // console.log(boundaryData);
+  expect(boundaryData[0].points.length).toEqual(4);
+  expect(boundaryData[1].points.length).toEqual(2);
+});
+
+
+test('Test Hatch.processSelection', () => {
+  // create selected items defining a square
+  let selectedItems = [];
+  selectedItems.push(new Line({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedItems.push(new Line({ points: [new Point(200, 100), new Point(200, 200)] }));
+  selectedItems.push(new Line({ points: [new Point(200, 200), new Point(100, 200)] }));
+  selectedItems.push(new Line({ points: [new Point(100, 200), new Point(100, 100)] }));
+
+  let hatch = new Hatch();
+  let boundaryData = hatch.processSelection(selectedItems);
+  expect(boundaryData.length).toEqual(1);
+  expect(boundaryData[0].points.length).toEqual(4);
+
+
+  // create selected items defining a circle
+  selectedItems = [];
+  selectedItems.push(new Circle({ points: [new Point(100, 100), new Point(200, 100)] }));
+
+  hatch = new Hatch();
+  boundaryData = hatch.processSelection(selectedItems);
+  expect(boundaryData.length).toEqual(1);
+  expect(boundaryData[0].points.length).toEqual(2);
+
+  // create selected items defining a square (polyline)
+  selectedItems = [];
+  selectedItems.push(new Polyline({
+    points: [new Point(100, 100), new Point(200, 100), new Point(200, 200),
+      new Point(100, 200), new Point(100, 100)],
+  }));
+
+  hatch = new Hatch();
+  boundaryData = hatch.processSelection(selectedItems);
+  expect(boundaryData.length).toEqual(1);
+  expect(boundaryData[0].points.length).toEqual(4);
+
+  // create selected items defining a pill shape
+  selectedItems = [];
+  selectedItems.push(new Line({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedItems.push(new Arc({ points: [new Point(200, 150), new Point(200, 100), new Point(200, 200)] }));
+  selectedItems.push(new Line({ points: [new Point(200, 200), new Point(100, 200)] }));
+  selectedItems.push(new Arc({ points: [new Point(100, 150), new Point(100, 200), new Point(100, 100)] }));
+
+  hatch = new Hatch();
+  boundaryData = hatch.processSelection(selectedItems);
+  expect(boundaryData.length).toEqual(1);
+  // 2 lines + 2 arcs: each shared connection point is merged (not duplicated),
+  // so the result is 4 unique vertices, not 5
+  expect(boundaryData[0].points.length).toEqual(4);
+
+  // Test a selection with invalid items
+  selectedItems = [];
+  selectedItems.push(new Text({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedItems.push(new Circle({ points: [new Point(100, 100), new Point(200, 100)] }));
+
+  hatch = new Hatch();
+  boundaryData = hatch.processSelection(selectedItems);
+  expect(boundaryData.length).toEqual(1);
+  expect(boundaryData[0].points.length).toEqual(2);
+});
+
+// Minimal mock canvas context that records moveTo calls and supports try/catch split
+/**
+ * Create a minimal mock canvas context
+ * @return {Object} mock context
+ */
+function makeMockCtx() {
+  let moveCount = 0;
+  let fillCalled = false;
+  return {
+    save: () => {},
+    restore: () => {},
+    translate: () => {},
+    scale: () => {},
+    rotate: () => {},
+    beginPath: () => {},
+    setLineDash: () => {},
+    lineWidth: 0,
+    moveTo: () => {
+      moveCount++;
+    },
+    lineTo: () => {},
+    stroke: () => {},
+    fill: () => {
+      fillCalled = true;
+    },
+    getMoveCalls: () => moveCount,
+    getFillCalled: () => fillCalled,
+  };
+}
+
+test('Test Hatch.createPattern solid fill calls ctx.fill', () => {
+  const solidHatch = new Hatch({ patternName: 'SOLID' });
+  solidHatch.childEntities = [new BasePolyline({ points: [new Point(0, 0), new Point(10, 0)] })];
+
+  const ctx = makeMockCtx();
+  solidHatch.createPattern(ctx, 1, solidHatch.boundingBox());
+
+  expect(ctx.getFillCalled()).toBe(true);
+  expect(ctx.getMoveCalls()).toBe(0);
+});
+
+test('Test Hatch.createPattern unknown pattern calls ctx.fill', () => {
+  const unknownHatch = new Hatch({ patternName: 'ANSI31' });
+  unknownHatch.childEntities = [new BasePolyline({ points: [new Point(0, 0), new Point(10, 0)] })];
+  // Override pattern to a nonexistent name without going through setPatternName
+  unknownHatch.pattern = 'NOTAPATTERN';
+
+  const ctx = makeMockCtx();
+  unknownHatch.createPattern(ctx, 1, unknownHatch.boundingBox());
+
+  expect(ctx.getFillCalled()).toBe(true);
+  expect(ctx.getMoveCalls()).toBe(0);
+});
+
+test('Test Hatch.createPattern tight bound line count - square boundary', () => {
+  // ANSI31: angle=45, yDelta=3.175, no dashes (dashLength = bbXLength/2)
+  // 100x100 square: halfW=halfH=50, sin45=cos45=√2/2
+  // halfY = 50*(√2/2) + 50*(√2/2) ≈ 70.71
+  // yIncrement = ceil(70.71 / 3.175) = 23 → loop i=-23..22 = 46 lines
+  const squareBB = new BoundingBox(new Point(0, 100), new Point(100, 0));
+  const squareHatch = new Hatch({ patternName: 'ANSI31' });
+  const ctx = makeMockCtx();
+  squareHatch.createPattern(ctx, 1, squareBB);
+  expect(ctx.getMoveCalls()).toBe(46);
+});
+
+test('Test Hatch.createPattern tight bound line count - flat boundary', () => {
+  // ANSI31: angle=45, yDelta=3.175, no dashes
+  // 100x10 flat box: halfW=50, halfH=5, sin45=cos45=√2/2
+  // halfY = (50+5)*(√2/2) ≈ 38.89
+  // yIncrement = ceil(38.89 / 3.175) = 13 → loop i=-13..12 = 26 lines
+  const flatBB = new BoundingBox(new Point(0, 10), new Point(100, 0));
+  const flatHatch = new Hatch({ patternName: 'ANSI31' });
+  const ctx = makeMockCtx();
+  flatHatch.createPattern(ctx, 1, flatBB);
+  expect(ctx.getMoveCalls()).toBe(26);
+});
+
+test('Test Hatch.createPattern tight bound produces fewer lines for flat boundary', () => {
+  // A flat boundary (100x10) should produce fewer lines than a square (100x100).
+  // This verifies that the tight projection avoids over-generating lines for
+  // non-square shapes, unlike the old Math.max(bbX, bbY) approach.
+  const squareBB = new BoundingBox(new Point(0, 100), new Point(100, 0));
+  const flatBB = new BoundingBox(new Point(0, 10), new Point(100, 0));
+
+  const squareHatch = new Hatch({ patternName: 'ANSI31' });
+  const flatHatch = new Hatch({ patternName: 'ANSI31' });
+
+  const squareCtx = makeMockCtx();
+  squareHatch.createPattern(squareCtx, 1, squareBB);
+
+  const flatCtx = makeMockCtx();
+  flatHatch.createPattern(flatCtx, 1, flatBB);
+
+  expect(flatCtx.getMoveCalls()).toBeLessThan(squareCtx.getMoveCalls());
+});

package/test/entities/insert.test.js

@@ -0,0 +1,90 @@
+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 { File } from '../test-helpers/test-helpers.js';
+
+// initialise core
+new Core();
+
+
+const insert = new Insert({ handle: '1', points: [new Point()] });
+const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
+insert.block.addItem(line);
+
+const rotatedInsert = new Insert({ points: [new Point()], rotation: 45 });
+rotatedInsert.block.addItem(line);
+
+test('Test Insert.snaps', () => {
+  const point = new Point(100, 100);
+  const snaps = insert.snaps(point, 1);
+  expect(snaps[0].x).toBeCloseTo(101);
+  expect(snaps[0].y).toBeCloseTo(102);
+
+  // Test snaps for a rotated block
+  const rotatedSnaps = rotatedInsert.snaps(point);
+  expect(rotatedSnaps[0].x).toBeCloseTo(-0.7071);
+  expect(rotatedSnaps[0].y).toBeCloseTo(143.5426);
+});
+
+test('Test Insert.closestPoint', () => {
+  const point = new Point(100, 100);
+  const closest = insert.closestPoint(point);
+  expect(closest[0].x).toBeCloseTo(101);
+  expect(closest[0].y).toBeCloseTo(102);
+
+  // Test closest for a rotated block
+  const rotatedClosest = rotatedInsert.closestPoint(point);
+  expect(rotatedClosest[0].x).toBeCloseTo(101);
+  expect(rotatedClosest[0].y).toBeCloseTo(102);
+});
+
+test('Test Insert.boundingBox', () => {
+  expect(insert.boundingBox().xMin).toBeCloseTo(101);
+  expect(insert.boundingBox().xMax).toBeCloseTo(201);
+  expect(insert.boundingBox().yMin).toBeCloseTo(102);
+  expect(insert.boundingBox().yMax).toBeCloseTo(202);
+
+  const line2 = new Line({ points: [new Point(1001, 1002), new Point(2001, 2002)] });
+  insert.block.addItem(line2);
+
+  expect(insert.boundingBox().xMin).toBeCloseTo(101);
+  expect(insert.boundingBox().xMax).toBeCloseTo(2001);
+  expect(insert.boundingBox().yMin).toBeCloseTo(102);
+  expect(insert.boundingBox().yMax).toBeCloseTo(2002);
+});
+
+test('Test Insert.dxf', () => {
+  let file = new File();
+  insert.dxf(file);
+  // console.log(file.contents);
+
+  const dxfString = `0
+INSERT
+5
+1
+100
+AcDbEntity
+8
+0
+100
+AcDbBlockReference
+2
+
+10
+0
+20
+0
+30
+0.0
+`;
+
+  expect(file.contents).toEqual(dxfString);
+
+  // create new entity from entity data to ensure all props are loaded
+  const newInsert = new Insert(insert);
+  file = new File();
+  newInsert.dxf(file);
+  expect(file.contents).toEqual(dxfString);
+});