@design-core/core 0.0.2 → 0.0.4

package/test/dimensions/baseDimension.test.js

@@ -0,0 +1,239 @@
+import { BaseDimension } from '../../core/dimensions/baseDimension.js';
+import { Point } from '../../core/entities/point.js';
+import { Core } from '../../core/core/core.js';
+import { Text } from '../../core/entities/text.js';
+// import { DimType } from '../../core/properties/dimType.js';
+
+// initialise core
+new Core();
+
+describe('BaseDimension', () => {
+  let baseDim;
+
+  beforeEach(() => {
+    baseDim = new BaseDimension({});
+    baseDim.points = [new Point(1, 2, 0), new Point(3, 4, 0)];
+  });
+
+  test('constructor sets default properties', () => {
+    expect(baseDim.textOverride).toBe('');
+    expect(baseDim.blockName).toBe('');
+    expect(baseDim.dimensionStyle).toBe('STANDARD');
+    expect(baseDim.leaderLength).toBe(0);
+    expect(baseDim.linearDimAngle).toBe(0);
+  });
+
+  test('getDimensionValue formats values by dimension type', () => {
+    baseDim.dimType.setDimType(0);
+    expect(baseDim.getDimensionValue(12.3456)).toBe('12.3456');
+    baseDim.dimType.setDimType(2);
+    expect(baseDim.getDimensionValue(45)).toContain('°');
+    baseDim.dimType.setDimType(3);
+    expect(baseDim.getDimensionValue(10)).toContain('Ø');
+    baseDim.dimType.setDimType(4);
+    expect(baseDim.getDimensionValue(5)).toContain('R');
+    baseDim.dimType.setDimType(6);
+    expect(baseDim.getDimensionValue(7)).toContain('7.00');
+  });
+
+
+  describe('getDimensionValue formats to style', () => {
+    // Test cases for dimension value formatting
+    const scenarios = [
+
+      { desc: 'comma separator, 2 decimal places',
+        dimType: 0,
+        inputValue: 12.34,
+        expectedValue: '12,34',
+        DIMDSEP: ',',
+        DIMDEC: 2,
+        DIMADEC: 2,
+        DIMRND: 0.0000,
+      },
+      { desc: 'comma separator, 3 decimal places',
+        dimType: 0,
+        inputValue: 12.34,
+        expectedValue: '12,340',
+        DIMDSEP: ',',
+        DIMDEC: 3,
+        DIMADEC: 2,
+        DIMRND: 0.0000,
+      },
+      { desc: 'dot separator, 3 decimal places',
+        dimType: 0,
+        inputValue: 12.34,
+        expectedValue: '12.340',
+        DIMDSEP: '.',
+        DIMDEC: 3,
+        DIMADEC: 2,
+        DIMRND: 0.0000,
+      },
+      { desc: 'hash separator, 4 decimal places',
+        dimType: 0,
+        inputValue: 12.3456789,
+        expectedValue: '12#3457',
+        DIMDSEP: '#',
+        DIMDEC: 4,
+        DIMADEC: 2,
+        DIMRND: 0.0000,
+      },
+      { desc: 'hash separator, 2 decimal places, rounded to nearest 1',
+        dimType: 0,
+        inputValue: 12.3456789,
+        expectedValue: '12#00',
+        DIMDSEP: '#',
+        DIMDEC: 2,
+        DIMADEC: 2,
+        DIMRND: 1,
+      },
+      { desc: 'comma separator, 2 decimal places, rounded to nearest 1',
+        dimType: 0,
+        inputValue: 0.23456,
+        expectedValue: '0,00',
+        DIMDSEP: ',',
+        DIMDEC: 2,
+        DIMADEC: 2,
+        DIMRND: 1,
+      },
+      { desc: 'comma separator, 2 decimal places, rounded to nearest 0.25',
+        dimType: 0,
+        inputValue: 0.23456,
+        expectedValue: '0,25',
+        DIMDSEP: ',',
+        DIMDEC: 2,
+        DIMADEC: 2,
+        DIMRND: 0.25,
+      },
+      { desc: 'Angular dimension, comma separator, 2 decimal places, rounded to nearest 0.25',
+        dimType: 2,
+        inputValue: 0.23457,
+        expectedValue: '0,23°',
+        DIMDSEP: ',',
+        DIMDEC: 2,
+        DIMADEC: 2,
+        DIMRND: 0.25,
+      },
+      { desc: 'negative value, dot separator, 4 decimal places, rounded to nearest 2',
+        dimType: 0,
+        inputValue: -123.45678,
+        expectedValue: '124.0000',
+        DIMDSEP: '.',
+        DIMDEC: 4,
+        DIMADEC: 2,
+        DIMRND: 2,
+      },
+      { desc: 'negative value, dot separator, 4 decimal places, rounded to nearest 2, remove trailing zeros',
+        dimType: 0,
+        inputValue: -123.45678,
+        expectedValue: '124',
+        DIMDSEP: '.',
+        DIMDEC: 4,
+        DIMADEC: 2,
+        DIMRND: 2,
+        DIMZIN: 8,
+      },
+    ];
+
+    test.each(scenarios)('getDimensionValue formats to style - $desc', (scenario) => {
+      baseDim.dimType.setDimType(scenario.dimType);
+      // Mock getDimensionStyle to return specific rounding value
+      baseDim.getDimensionStyle = () => ({
+        getValue: (prop) => {
+          let returnValue = null;
+          if (prop === 'DIMDSEP') returnValue = scenario.DIMDSEP;
+          if (prop === 'DIMDEC') returnValue = scenario.DIMDEC;
+          if (prop === 'DIMRND') returnValue = scenario.DIMRND;
+          if (prop === 'DIMADEC') returnValue = scenario.DIMADEC;
+          if (prop === 'DIMZIN') returnValue = scenario.DIMZIN || 0;
+          return returnValue;
+        },
+      });
+      expect(baseDim.getDimensionValue(scenario.inputValue)).toBe(scenario.expectedValue);
+    });
+  });
+
+  test('suppressZeros', () => {
+    expect(baseDim.suppressZeros('012.3400', true, true)).toBe('12.34');
+    expect(baseDim.suppressZeros('012.3400', true, false)).toBe('12.3400');
+    expect(baseDim.suppressZeros('012.3400', false, true)).toBe('012.34');
+    expect(baseDim.suppressZeros('012.3400', false, false)).toBe('012.3400');
+    expect(baseDim.suppressZeros('0.050', true, true)).toBe('.05');
+    expect(baseDim.suppressZeros('0.0', true, true)).toBe('0');
+  });
+
+  test('constructor throws on invalid dimType', () => {
+    expect(() => new BaseDimension({ 70: 999 })).toThrow(/Invalid Dimension Type/);
+  });
+
+  test('getDimensionValue uses textOverride', () => {
+    baseDim.textOverride = 'foo <> bar';
+    expect(baseDim.getDimensionValue(10)).toBe('foo 10.0000 bar');
+  });
+
+  test('getDimensionText returns a Text object with correct values', () => {
+    const text = baseDim.getDimensionText(10, new Point(1, 2), Math.PI / 4);
+    expect(text).toBeInstanceOf(Text);
+    expect(text.height).toBe(0.18);
+    expect(text.points[0].x).toBe(1);
+    expect(text.points[0].y).toBe(2);
+    expect(typeof text.string).toBe('string');
+  });
+
+  test('getTextDirection flips angle in lower half', () => {
+    expect(baseDim.getTextDirection(Math.PI)).toBeCloseTo(Math.PI * 2);
+    expect(baseDim.getTextDirection(0)).toBe(0);
+  });
+
+  test('alignedOrOpposite returns true for aligned/opposite angles', () => {
+    expect(baseDim.alignedOrOpposite(0, 0)).toBe(true);
+    expect(baseDim.alignedOrOpposite(0, Math.PI)).toBe(true);
+    expect(baseDim.alignedOrOpposite(0, Math.PI / 2)).toBe(false);
+  });
+
+  // test('getDimensionStyle returns style object', () => {
+  //  expect(baseDim.getDimensionStyle()).toBe(styleMock);
+  // });
+
+  test('getPointBySequence returns correct point', () => {
+    baseDim.points = [Object.assign(new Point(1, 2), { sequence: 10 }), Object.assign(new Point(3, 4), { sequence: 15 })];
+    expect(baseDim.getPointBySequence(baseDim.points, 15).x).toBe(3);
+    expect(baseDim.getPointBySequence(baseDim.points, 99)).toBeNull();
+  });
+
+  test('getArrowHead returns a Solid', () => {
+    const solid = baseDim.getArrowHead(new Point(0, 0), 0);
+    expect(solid).toBeDefined();
+    expect(solid.points.length).toBe(3);
+  });
+
+  test('getCentreMark returns lines for markStyle > 0', () => {
+    const lines = baseDim.getCentreMark(new Point(0, 0));
+    expect(Array.isArray(lines)).toBe(true);
+    expect(lines.length).toBeGreaterThan(0);
+  });
+
+
+  test('snaps returns empty array', () => {
+    expect(baseDim.snaps(new Point(0, 0), 1)).toEqual([]);
+  });
+
+  test('closestPoint delegates to block', () => {
+    baseDim.block = { closestPoint: () => 'foo' };
+    expect(baseDim.closestPoint(new Point(0, 0))).toBe('foo');
+  });
+
+  test('boundingBox delegates to block', () => {
+    baseDim.block = { boundingBox: () => 'box' };
+    expect(baseDim.boundingBox()).toBe('box');
+  });
+
+  test('within delegates to block', () => {
+    baseDim.block = { within: () => true };
+    expect(baseDim.within({})).toBe(true);
+  });
+
+  test('touched delegates to block', () => {
+    baseDim.block = { touched: () => false };
+    expect(baseDim.touched({})).toBe(false);
+  });
+});

package/test/dimensions/diametricDimension.test.js

@@ -0,0 +1,203 @@
+import { DiametricDimension } from '../../core/dimensions/diametricDimension.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: 'Diametric 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: 3,
+    dimensionValue: 20,
+    dimensionEntities: 6,
+  },
+  { desc: 'Diametric 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: 3,
+    dimensionValue: 20,
+    dimensionEntities: 5,
+  },
+  { desc: 'Diametric 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: 3,
+    dimensionValue: 40,
+    dimensionEntities: 6,
+  },
+  { desc: 'Diametric 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: 3,
+    dimensionValue: 20,
+    dimensionEntities: 6,
+  },
+];
+
+test.each(scenarios)('DiametricDimension.execute handles $desc', async (scenario) => {
+  const { input, selectedItems, expectedDimType, dimensionValue, dimensionEntities } = scenario;
+
+  await withMockInput(DesignCore.Scene, input, async () => {
+    const dim = new DiametricDimension();
+    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 none numberic characters except . and -
+        const numbersOnly = entity.string.replace(/[^0-9.-]+/g, '');
+        expect(Number(numbersOnly)).toBeCloseTo(dimensionValue);
+        expect(entity.string).toContain('Ø');
+      }
+    }
+  }, { selectedItems });
+});
+
+test('constructor sets default properties', () => {
+  const dim = new DiametricDimension();
+  expect(dim).toBeInstanceOf(DiametricDimension);
+  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 = DiametricDimension.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('DiametricDimension.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 DiametricDimension();
+  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 DiametricDimension();
+  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 DiametricDimension.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 DiametricDimension({ 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
+3
+3
+STANDARD
+100
+AcDbDiametricDimension
+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 DiametricDimension(dimension);
+  file = new File();
+  newDimension.dxf(file);
+  expect(file.contents).toEqual(dxfString);
+});

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();
+});