@design-core/core 0.0.1 → 0.0.3

package/test/dimensions/dimension.test.js

@@ -0,0 +1,102 @@
+import { Dimension } from '../../core/dimensions/dimension.js';
+import { DiametricDimension } from '../../core/dimensions/diametricDimension.js';
+import { Circle } from '../../core/entities/circle.js';
+import { Point } from '../../core/entities/point.js';
+import { Line } from '../../core/entities/line.js';
+import { Arc } from '../../core/entities/arc.js';
+import { Polyline } from '../../core/entities/polyline.js';
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { SingleSelection } from '../../core/lib/selectionManager.js';
+import { withMockInput } from '../test-helpers/test-helpers.js';
+
+// initialise core
+new Core();
+
+// Test cases for user input
+const scenarios = [
+
+  { desc: 'Rotated dimension from line selection',
+    input: [new SingleSelection(0, new Point()), new Point(5, 5)],
+    selectedItems: [new Line({ points: [new Point(), new Point(10, 0)] })],
+    expectedDimType: 0,
+  },
+  { desc: 'Aligned dimension from line selection',
+    input: [new SingleSelection(0, new Point()), new Point(6.5, 3.5)],
+    selectedItems: [new Line({ points: [new Point(), new Point(10, 10)] })],
+    expectedDimType: 1,
+  },
+  { desc: 'Rotated dimension from point selection',
+    input: [new Point(), new Point(10, 0), new Point(5, 5)],
+    selectedItems: [],
+    expectedDimType: 0,
+  },
+  { desc: 'Diametric dimension from circle selection',
+    input: [new SingleSelection(0, new Point()), new Point(20, 10)],
+    selectedItems: [new Circle({ points: [new Point(), new Point(10, 0)] })],
+    expectedDimType: 3,
+  },
+  { desc: 'Radial dimension from arc selection',
+    input: [new SingleSelection(0, new Point()), new Point(20, 10)],
+    selectedItems: [new Arc({ points: [new Point(), new Point(10, 0), new Point(10, 10)] })],
+    expectedDimType: 4,
+  },
+  { desc: 'Angular dimension from line selection',
+    input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, 5)],
+    selectedItems: [new Line({ points: [new Point(), new Point(10, 0)] }), new Line({ points: [new Point(), new Point(10, 10)] })],
+    expectedDimType: 2,
+  },
+  { desc: 'Aligned dimension from polyline selection',
+    input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, 5)],
+    selectedItems: [new Polyline({ points: [new Point(), new Point(10, 0)] })],
+    expectedDimType: 1,
+  },
+  { desc: 'Radial dimension from polyline selection',
+    input: [new SingleSelection(0, new Point(16, 5)), new Point(20, 5)],
+    selectedItems: [new Polyline({ points: [new Point(), new Point(10, 0, 1), new Point(10, 10)] })],
+    expectedDimType: 4,
+  },
+  { desc: 'Angular dimension from polyline selection',
+    input: [new SingleSelection(0, new Point(5, 0)), new SingleSelection(1, new Point(5, 5)), new Point(5, 5)],
+    selectedItems: [new Polyline({ points: [new Point(), new Point(10, 0)] }), new Polyline({ points: [new Point(), new Point(10, 10)] })],
+    expectedDimType: 2,
+  },
+
+];
+
+test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
+  const { input, selectedItems, expectedDimType } = scenario;
+
+  await withMockInput(DesignCore.Scene, input, async () => {
+    const dim = new Dimension();
+    await dim.execute();
+
+    expect(dim.dimType.getBaseDimType()).toBe(expectedDimType);
+  }, { selectedItems });
+});
+
+test('constructor instantiates correct dimension type', () => {
+  const data = { 70: 3, 2: 'blockName' };
+  const dim = new Dimension(data);
+  expect(dim instanceof DiametricDimension).toBe(true);
+});
+
+test('register returns command object', () => {
+  expect(Dimension.register()).toEqual({ command: 'Dimension', shortcut: 'DIM' });
+});
+
+test('get linear dimension type', () => {
+  const dim = new Dimension();
+  expect(dim.getLinearDimensionType(new Point(0, 0), new Point(10, 0), new Point(5, 5))).toBe(0);
+  expect(dim.getLinearDimensionType(new Point(0, 0), new Point(10, 10), new Point(7.5, 2.5))).toBe(1);
+  expect(dim.getLinearDimensionType(new Point(0, 0), new Point(10, 10), new Point(12.5, 8.5))).toBe(0);
+});
+
+
+test('preview calls createTempItem with correct args', () => {
+  const dim = new Dimension({ 70: 1 });
+  dim.selectedItems = [1];
+  dim.points = [{}, {}];
+  // Should not throw
+  expect(() => dim.preview()).not.toThrow();
+});

package/test/dimensions/radialDimension.test.js

@@ -0,0 +1,203 @@
+import { RadialDimension } from '../../core/dimensions/radialDimension.js';
+import { Point } from '../../core/entities/point.js';
+import { Arc } from '../../core/entities/arc.js';
+import { File, withMockInput } from '../test-helpers/test-helpers.js';
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { SingleSelection } from '../../core/lib/selectionManager.js';
+import { Circle } from '../../core/entities/circle.js';
+import { Polyline } from '../../core/entities/polyline.js';
+
+
+// initialise core
+new Core();
+
+// Test cases for user input
+const scenarios = [
+
+  { desc: 'Radial dimension from circle selection - Text outside circle',
+    input: [new SingleSelection(0, new Point()), new Point(20, 0)],
+    selectedItems: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
+    expectedDimType: 4,
+    dimensionValue: 10,
+    dimensionEntities: 6,
+  },
+  { desc: 'Radial dimension from circle selection - Text inside circle',
+    input: [new SingleSelection(0, new Point()), new Point(0, 0)],
+    selectedItems: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
+    expectedDimType: 4,
+    dimensionValue: 10,
+    dimensionEntities: 5,
+  },
+  { desc: 'Radial dimension from arc selection',
+    input: [new SingleSelection(0, new Point()), new Point(20, 10)],
+    selectedItems: [new Arc({ points: [new Point(0, 0), new Point(20, 0), new Point(20, 20)] })],
+    expectedDimType: 4,
+    dimensionValue: 20,
+    dimensionEntities: 6,
+  },
+  { desc: 'Radial dimension from polyline selection',
+    input: [new SingleSelection(0, new Point(30, 10)), new Point(30, 10)],
+    selectedItems: [new Polyline({ points: [new Point(0, 0), new Point(20, 0, 1), new Point(20, 20)] })],
+    expectedDimType: 4,
+    dimensionValue: 10,
+    dimensionEntities: 6,
+  },
+];
+
+test.each(scenarios)('RadialDimension.execute handles $desc', async (scenario) => {
+  const { input, selectedItems, expectedDimType, dimensionValue, dimensionEntities } = scenario;
+
+  await withMockInput(DesignCore.Scene, input, async () => {
+    const dim = new RadialDimension();
+    await dim.execute();
+
+    expect(dim.dimType.getBaseDimType()).toBe(expectedDimType);
+    // get the text entities from the dimension block
+    const dimensionBlockEntities = dim.buildDimension();
+    expect(dimensionBlockEntities.length).toBe(dimensionEntities);
+
+    // check if the text value matches the expected dimension value
+    for (const entity of dimensionBlockEntities) {
+      if (entity.type === 'Text') {
+        // remove all non-numeric characters except . and -
+        const numbersOnly = entity.string.replace(/[^0-9.-]+/g, '');
+        expect(Number(numbersOnly)).toBeCloseTo(dimensionValue);
+        expect(entity.string).toContain('R');
+      }
+    }
+  }, { selectedItems });
+});
+
+test('constructor sets default properties', () => {
+  const dim = new RadialDimension();
+  expect(dim).toBeInstanceOf(RadialDimension);
+  expect(dim.points).toBeDefined();
+});
+
+
+test('getPointsFromSelection returns correct sequenced points', () => {
+  const center = new Point(0, 0);
+  const textPos = new Point(10, 0);
+  // Mock item with getRadius
+  const item = { points: [center], getRadius: () => 10 };
+  const result = RadialDimension.getPointsFromSelection([item], textPos);
+  expect(Array.isArray(result)).toBe(true);
+  expect(result.length).toBe(3);
+  expect(result[0].sequence).toBe(10); // center
+  expect(result[1].sequence).toBe(15); // radius point
+  expect(result[2].sequence).toBe(11); // text position
+});
+
+test('RadialDimension.preview runs without error and calls createTempItem', () => {
+  const origCreateTempItem = DesignCore.Scene.tempEntities.create;
+  const origPointOnScene = DesignCore.Mouse.pointOnScene;
+  const origSeletionSet = DesignCore.Scene.selectionManager.selectionSet.selectionSet.length;
+
+  // Manual mock for createTempItem
+  const createTempItemCalls = [];
+  DesignCore.Scene.tempEntities.create = function(type, obj) {
+    createTempItemCalls.push([type, obj]);
+  };
+  // Manual mock for pointOnScene
+  DesignCore.Mouse.pointOnScene = function() {
+    return new Point(5, 5);
+  };
+  // Manual mock for selection set
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet = [];
+
+  const points = [];
+
+  const Pt10 = new Point();
+  Pt10.sequence = 10;
+  points.push(Pt10);
+
+  const Pt15 = new Point(10, 0);
+  Pt15.sequence = 15;
+  points.push(Pt15);
+
+  // Test with no selection - no action
+  const dim1 = new RadialDimension();
+  dim1.points = points;
+  expect(() => dim1.preview()).not.toThrow();
+  expect(createTempItemCalls.length).toBe(0);
+
+  // Test with selection (should call createTempItem with this.type)
+  const dim2 = new RadialDimension();
+  dim2.points = points;
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(1);
+  expect(() => dim2.preview()).not.toThrow();
+  expect(createTempItemCalls.some((call) => call[0] === dim2.type)).toBe(true);
+
+  // Restore
+  DesignCore.Scene.tempEntities.create = origCreateTempItem;
+  DesignCore.Mouse.pointOnScene = origPointOnScene;
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet.length = origSeletionSet;
+});
+
+test('Test RadialDimension.dxf', () => {
+  const points = [];
+
+  const Pt10 = new Point();
+  Pt10.sequence = 10;
+  points.push(Pt10);
+
+  const Pt11 = new Point(20, 0);
+  Pt11.sequence = 11;
+  points.push(Pt11);
+
+  const Pt15 = new Point(10, 0);
+  Pt15.sequence = 15;
+  points.push(Pt15);
+
+  points.push(Pt10, Pt11, Pt15);
+
+  const dimension = new RadialDimension({ points: points, handle: '1' });
+  let file = new File();
+  dimension.dxf(file);
+  // console.log(file.contents);
+
+  const dxfString = `0
+DIMENSION
+5
+1
+100
+AcDbEntity
+100
+AcDbDimension
+8
+0
+10
+0
+20
+0
+30
+0.0
+11
+20
+21
+0
+31
+0.0
+70
+4
+3
+STANDARD
+100
+AcDbRadialDimension
+15
+10
+25
+0
+35
+0.0
+`;
+
+  expect(file.contents).toEqual(dxfString);
+
+  // create new entity from entity data to ensure all props are loaded
+  const newDimension = new RadialDimension(dimension);
+  file = new File();
+  newDimension.dxf(file);
+  expect(file.contents).toEqual(dxfString);
+});

package/test/dimensions/rotatedDimension.test.js

@@ -0,0 +1,224 @@
+import { RotatedDimension } from '../../core/dimensions/rotatedDimension.js';
+import { Point } from '../../core/entities/point.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Core } from '../../core/core/core.js';
+import { Line } from '../../core/entities/line.js';
+import { File, withMockInput } from '../test-helpers/test-helpers.js';
+
+// initialise core
+new Core();
+
+// Test cases for user input
+const scenarios = [
+
+  { desc: 'Rotated dimension from point selection (angle 0)',
+    input: [0, new Point(), new Point(10, 0), new Point(5, 5)],
+    selectedItems: [],
+    expectedDimType: 0,
+    dimensionValue: 10,
+  },
+  { desc: 'Rotated dimension from point selection (angle 90)',
+    input: [90, new Point(), new Point(0, 10), new Point(5, 5)],
+    selectedItems: [],
+    expectedDimType: 0,
+    dimensionValue: 10,
+  },
+];
+
+test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
+  const { input, selectedItems, expectedDimType, dimensionValue } = scenario;
+
+  await withMockInput(DesignCore.Scene, input, async () => {
+    const dim = new RotatedDimension();
+    await dim.execute();
+
+    expect(dim.dimType.getBaseDimType()).toBe(expectedDimType);
+    // get the text entities from the dimension block
+    const dimensionBlockEntities = dim.buildDimension();
+    expect(dimensionBlockEntities.length).toBe(7);
+
+    // check if the text value matches the expected dimension value
+    for (const entity of dimensionBlockEntities) {
+      if (entity.type === 'Text') {
+        expect(Number(entity.string)).toBeCloseTo(dimensionValue);
+      }
+    }
+  }, { selectedItems });
+});
+
+test('constructor sets default properties', () => {
+  const dim = new RotatedDimension();
+  expect(dim).toBeInstanceOf(RotatedDimension);
+  expect(dim.points).toBeDefined();
+});
+
+
+test('register returns command object', () => {
+  expect(RotatedDimension.register()).toEqual({ command: 'RotatedDimension', shortcut: 'DIMROT' });
+});
+
+
+describe('RotatedDimension.getPointsFromSelection', () => {
+  const scenarios = [
+    {
+      desc: 'horizontal line',
+      pt1: new Point(0, 0),
+      pt2: new Point(10, 0),
+      textPos: new Point(5, 5),
+      angle: 0,
+      expected: {
+        text: { x: 5, y: 5 },
+        arrow: { x: 10, y: 5 },
+      },
+    },
+    {
+      desc: 'vertical line',
+      pt1: new Point(0, 0),
+      pt2: new Point(0, 10),
+      textPos: new Point(5, 5),
+      angle: 90,
+      expected: {
+        text: { x: 5, y: 5 },
+        arrow: { x: 5, y: 10 },
+      },
+    },
+    {
+      desc: 'diagonal line',
+      pt1: new Point(0, 0),
+      pt2: new Point(10, 10),
+      textPos: new Point(5, 0),
+      angle: 90,
+      expected: {
+        text: { x: 5, y: 0 },
+        arrow: { x: 5, y: 10 },
+      },
+    },
+  ];
+
+  test.each(scenarios)('returns correct sequenced points for $desc', ({ pt1, pt2, textPos, angle, expected }) => {
+    const line = new Line({ points: [pt1, pt2] });
+    const result = RotatedDimension.getPointsFromSelection([line], textPos, angle);
+    expect(result).toHaveLength(4);
+    expect(result[0].sequence).toBe(13);
+    expect(result[1].sequence).toBe(14);
+    expect(result[2].sequence).toBe(11);
+    expect(result[3].sequence).toBe(10);
+    // check text position
+    expect(result[2].x).toBeCloseTo(expected.text.x);
+    expect(result[2].y).toBeCloseTo(expected.text.y);
+    // check arrow position
+    expect(result[3].x).toBeCloseTo(expected.arrow.x);
+    expect(result[3].y).toBeCloseTo(expected.arrow.y);
+  });
+});
+
+test('RotatedDimension.preview runs without error and calls createTempItem', () => {
+  const origCreateTempItem = DesignCore.Scene.tempEntities.create;
+  const origPointOnScene = DesignCore.Mouse.pointOnScene;
+  // Manual mock for createTempItem
+  const createTempItemCalls = [];
+  DesignCore.Scene.tempEntities.create = function(type, obj) {
+    createTempItemCalls.push([type, obj]);
+  };
+  // Manual mock for pointOnScene
+  DesignCore.Mouse.pointOnScene = function() {
+    return new Point(5, 5);
+  };
+
+  // Test with 1 point (should call createTempItem with 'Line')
+  const dim1 = new RotatedDimension();
+  dim1.points = [new Point(0, 0)];
+  expect(() => dim1.preview()).not.toThrow();
+  expect(createTempItemCalls.some((call) => call[0] === 'Line')).toBe(true);
+
+  // Test with >1 point (should call createTempItem with this.type)
+  const dim2 = new RotatedDimension();
+  dim2.points = [new Point(0, 0), new Point(10, 0), new Point(5, 5)];
+  expect(() => dim2.preview()).not.toThrow();
+  expect(createTempItemCalls.some((call) => call[0] === dim2.type)).toBe(true);
+
+  // Restore
+  DesignCore.Scene.tempEntities.create = origCreateTempItem;
+  DesignCore.Mouse.pointOnScene = origPointOnScene;
+});
+
+test('Test RotatedDimension.dxf', () => {
+  const points = [];
+
+  const Pt13 = new Point(0, 0);
+  Pt13.sequence = 13;
+  points.push(Pt13);
+
+  const Pt14 = new Point(10, 0);
+  Pt14.sequence = 14;
+  points.push(Pt14);
+
+  const Pt10 = new Point(5, 5);
+  Pt10.sequence = 10;
+  points.push(Pt10);
+
+  const Pt11 = new Point(5, 5);
+  Pt11.sequence = 11;
+  points.push(Pt11);
+
+  points.push(Pt10, Pt14, Pt13, Pt11);
+
+  const dimension = new RotatedDimension({ points: points, handle: '1' });
+  let file = new File();
+  dimension.dxf(file);
+  // console.log(file.contents);
+
+  const dxfString = `0
+DIMENSION
+5
+1
+100
+AcDbEntity
+100
+AcDbDimension
+8
+0
+10
+5
+20
+5
+30
+0.0
+11
+5
+21
+5
+31
+0.0
+70
+0
+3
+STANDARD
+100
+AcDbAlignedDimension
+13
+0
+23
+0
+33
+0.0
+14
+10
+24
+0
+34
+0.0
+50
+0
+100
+AcDbRotatedDimension
+`;
+
+  expect(file.contents).toEqual(dxfString);
+
+  // create new entity from entity data to ensure all props are loaded
+  const newDimension = new RotatedDimension(dimension);
+  file = new File();
+  newDimension.dxf(file);
+  expect(file.contents).toEqual(dxfString);
+});