@design-core/core 0.0.2 → 0.0.4

package/core/tools/zoom.js

@@ -0,0 +1,152 @@
+import { Tool } from './tool.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Strings } from '../lib/strings.js';
+import { Logging } from '../lib/logging.js';
+import { Point } from '../entities/point.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * Zoom Command Class
+ * Provides: All, Extents, Window
+ * @extends Tool
+ */
+export class Zoom extends Tool {
+  /** Create a Zoom command */
+  constructor() {
+    super();
+    this.modes = {
+      ALL: 'All',
+      EXTENTS: 'Extents',
+      WINDOW: 'Window',
+      OBJECT: 'Object',
+    };
+    this.mode = this.modes.WINDOW; // default to window mode
+  }
+
+  /**
+   * Register the command
+   * @return {Object}
+   */
+  static register() {
+    const command = { command: 'Zoom', shortcut: 'Z' };
+    return command;
+  }
+
+  /**
+   * Execute method
+   */
+  async execute() {
+    try {
+      const op = new PromptOptions(Strings.Input.POINT, [Input.Type.POINT], [this.modes.ALL, this.modes.EXTENTS, this.modes.WINDOW, this.modes.OBJECT]);
+      const input = await DesignCore.Scene.inputManager.requestInput(op);
+      if (input === undefined) return;
+
+      if (Object.values(this.modes).includes(input)) {
+        // input matches one of the mode values
+        this.mode = input;
+      }
+
+      // default window mode
+      if (this.mode === this.modes.WINDOW) {
+        if (Input.getType(input) === Input.Type.POINT) {
+          this.points.push(input);
+        } else {
+          const p1op = new PromptOptions(Strings.Input.POINT, [Input.Type.POINT]);
+          const pt1 = await DesignCore.Scene.inputManager.requestInput(p1op);
+          if (pt1 === undefined) return;
+          this.points.push(pt1);
+        }
+
+        const p2op = new PromptOptions(Strings.Input.END, [Input.Type.POINT]);
+        const pt2 = await DesignCore.Scene.inputManager.requestInput(p2op);
+        if (pt2 === undefined) return;
+        this.points.push(pt2);
+      }
+
+      // Zoom to objects in selection
+      if (this.mode === this.modes.OBJECT) {
+        const op = new PromptOptions(Strings.Input.SELECTIONSET, [Input.Type.SELECTIONSET]);
+
+        if (!DesignCore.Scene.selectionManager.selectionSet.selectionSet.length) {
+          const sel = await DesignCore.Scene.inputManager.requestInput(op);
+          if (sel === undefined) return;
+        }
+      }
+
+      DesignCore.Scene.inputManager.executeCommand();
+    } catch (err) {
+      Logging.instance.error(`${this.type} - ${err}`);
+    }
+  }
+
+  /**
+   * Preview the command during execution
+   */
+  preview() {
+    if (this.mode === this.modes.WINDOW && this.points.length === 1) {
+      const mousePoint = DesignCore.Mouse.pointOnScene();
+      const p1 = this.points[0];
+      const p2 = mousePoint;
+
+      const points = [
+        new Point(p1.x, p1.y),
+        new Point(p2.x, p1.y),
+        new Point(p2.x, p2.y),
+        new Point(p1.x, p2.y),
+        new Point(p1.x, p1.y),
+      ];
+
+      DesignCore.Scene.tempEntities.create('Polyline', { points: points });
+    }
+  }
+
+  /**
+   * Perform the command
+   */
+  action() {
+    // Zoom to window
+    if (this.mode === this.modes.WINDOW && this.points.length === 2) {
+      DesignCore.Canvas.zoomToWindow(this.points[0], this.points[1]);
+    }
+
+    // Zoom Extents
+    if (this.mode === this.modes.ALL || this.mode === this.modes.EXTENTS) {
+      DesignCore.Canvas.zoomExtents();
+    }
+
+    // Zoom to Object(s)
+    if (this.mode === this.modes.OBJECT) {
+      let xmin = Infinity;
+      let xmax = -Infinity;
+      let ymin = Infinity;
+      let ymax = -Infinity;
+
+      // return if nothing selection
+      if (DesignCore.Scene.selectionManager.selectionSet.selectionSet.length === 0) {
+        return;
+      }
+
+      for (let i = 0; i <DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
+        const itemBoundingBox = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]).boundingBox();
+
+        xmin = Math.min(xmin, itemBoundingBox.xMin);
+        xmax = Math.max(xmax, itemBoundingBox.xMax);
+        ymin = Math.min(ymin, itemBoundingBox.yMin);
+        ymax = Math.max(ymax, itemBoundingBox.yMax);
+      }
+
+      // if all values are zero return undefined
+      if (xmin === 0 && xmax === 0, ymin === 0, ymax === 0) {
+        return;
+      }
+
+      const Pt1 = new Point(xmin, ymin);
+      const Pt2 = new Point(xmax, ymax);
+
+      DesignCore.Canvas.zoomToWindow(Pt1, Pt2);
+    }
+  }
+}
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-core/core",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
@@ -12,7 +12,7 @@
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-n": "^15.3.0",
     "eslint-plugin-promise": "^6.1.1",
-    "jest": "^29.2.2"
+    "jest": "^29.7.0"
   },
   "description": "2D CAD Library",
   "exports": {
@@ -22,8 +22,6 @@
   "directories": {
     "test": "test"
   },
-  "dependencies": {
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dubstar-04/Design-Core.git"
@@ -37,4 +35,4 @@
     "url": "https://github.com/dubstar-04/Design-Core/issues"
   },
   "homepage": "https://github.com/dubstar-04/Design-Core#readme"
-}
+}

package/test/dimensions/alignedDimension.test.js

@@ -0,0 +1,211 @@
+import { AlignedDimension } from '../../core/dimensions/alignedDimension.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: 'Aligned dimension from point selection',
+    input: [new Point(), new Point(10, 0), new Point(5, 5)],
+    selectedItems: [],
+    expectedDimType: 1,
+    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 AlignedDimension();
+    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 AlignedDimension();
+  expect(dim).toBeInstanceOf(AlignedDimension);
+  expect(dim.points).toBeDefined();
+});
+
+
+test('register returns command object', () => {
+  expect(AlignedDimension.register()).toEqual({ command: 'AlignedDimension', shortcut: 'DIMALI' });
+});
+
+
+describe('AlignedDimension.getPointsFromSelection', () => {
+  const scenarios = [
+    {
+      desc: 'horizontal line',
+      pt1: new Point(0, 0),
+      pt2: new Point(10, 0),
+      textPos: new Point(5, 5),
+      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),
+      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),
+      expected: {
+        text: { x: 5, y: 0 },
+        arrow: { x: 12.5, y: 7.5 },
+      },
+    },
+  ];
+
+  test.each(scenarios)('returns correct sequenced points for $desc', ({ pt1, pt2, textPos, expected }) => {
+    const line = new Line({ points: [pt1, pt2] });
+    const result = AlignedDimension.getPointsFromSelection([line], textPos);
+    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('AlignedDimension.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 AlignedDimension();
+  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 AlignedDimension();
+  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 AlignedDimension.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 AlignedDimension({ 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
+1
+3
+STANDARD
+100
+AcDbAlignedDimension
+13
+0
+23
+0
+33
+0.0
+14
+10
+24
+0
+34
+0.0
+`;
+
+  expect(file.contents).toEqual(dxfString);
+
+  // create new entity from entity data to ensure all props are loaded
+  const newDimension = new AlignedDimension(dimension);
+  file = new File();
+  newDimension.dxf(file);
+  expect(file.contents).toEqual(dxfString);
+});

package/test/dimensions/angularDimension.test.js

@@ -0,0 +1,243 @@
+
+import { AngularDimension } from '../../core/dimensions/angularDimension.js';
+import { Point } from '../../core/entities/point.js';
+import { Line } from '../../core/entities/line.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 { File, withMockInput } from '../test-helpers/test-helpers.js';
+
+// initialise core
+new Core();
+
+
+// Test cases for user input
+const scenarios = [
+
+  { desc: 'Angular dimension from line selection - 45 degrees',
+    input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, 5)],
+    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    expectedDimType: 2,
+    dimensionValue: 45,
+    dimensionEntities: 5,
+  },
+  { desc: 'Angular dimension from line selection - 135 degrees',
+    input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(-5, 5)],
+    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    expectedDimType: 2,
+    dimensionValue: 135,
+    dimensionEntities: 6,
+  },
+  { desc: 'Angular dimension from line selection - 45 degrees',
+    input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(-5, -5)],
+    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    expectedDimType: 2,
+    dimensionValue: 45,
+    dimensionEntities: 7,
+  },
+  { desc: 'Angular dimension from line selection - 135 degrees',
+    input: [new SingleSelection(0, new Point()), new SingleSelection(1, new Point()), new Point(5, -5)],
+    selectedItems: [new Line({ points: [new Point(0, 0), new Point(10, 0)] }), new Line({ points: [new Point(0, 0), new Point(10, 10)] })],
+    expectedDimType: 2,
+    dimensionValue: 135,
+    dimensionEntities: 6,
+  },
+  { desc: 'Angular dimension from polyline selection - 45 degrees',
+    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(0, 0), new Point(10, 0)] }), new Polyline({ points: [new Point(0, 0), new Point(10, 10)] })],
+    expectedDimType: 2,
+    dimensionValue: 45,
+    dimensionEntities: 5,
+  },
+];
+
+test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
+  const { input, selectedItems, expectedDimType, dimensionValue, dimensionEntities } = scenario;
+
+  await withMockInput(DesignCore.Scene, input, async () => {
+    const dim = new AngularDimension();
+    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('°');
+      }
+    }
+  }, { selectedItems });
+});
+
+test('constructor sets default properties', () => {
+  const dim = new AngularDimension();
+  expect(dim).toBeInstanceOf(AngularDimension);
+  expect(dim.points).toBeDefined();
+});
+
+test('register returns command object', () => {
+  expect(AngularDimension.register()).toEqual({ command: 'AngularDimension', shortcut: 'DIMANG' });
+});
+
+test('getPointsFromSelection returns correct sequenced points', () => {
+  const pt1 = new Point(0, 0);
+  const pt2 = new Point(10, 0);
+  const pt3 = new Point(10, 10);
+  const textPos = new Point(5, 5);
+  const line1 = new Line({ points: [pt1, pt2] });
+  const line2 = new Line({ points: [pt2, pt3] });
+  const result = AngularDimension.getPointsFromSelection([line1, line2], textPos);
+  expect(Array.isArray(result)).toBe(true);
+  expect(result.length).toBeGreaterThanOrEqual(4);
+});
+
+test('AngularDimension.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 >4 point (should call createTempItem with this.type)
+  const dim2 = new AngularDimension();
+
+  dim2.points = [];
+
+  const Pt10 = new Point();
+  Pt10.sequence = 10;
+  dim2.points.push(Pt10);
+
+  const Pt13 = new Point();
+  Pt13.sequence = 13;
+  dim2.points.push(Pt13);
+
+  const Pt14 = new Point();
+  Pt14.sequence = 14;
+  dim2.points.push(Pt14);
+
+  const Pt15 = new Point();
+  Pt15.sequence = 15;
+  dim2.points.push(Pt15);
+
+  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 AngularDimension.dxf', () => {
+  const points = [];
+
+  const Pt10 = new Point(5, 6);
+  Pt10.sequence = 10;
+  points.push(Pt10);
+
+  const Pt11 = new Point(7, 8);
+  Pt11.sequence = 11;
+  points.push(Pt11);
+
+  const Pt13 = new Point(9, 10);
+  Pt13.sequence = 13;
+  points.push(Pt13);
+
+  const Pt14 = new Point(11, 12);
+  Pt14.sequence = 14;
+  points.push(Pt14);
+
+  const Pt15 = new Point(13, 14);
+  Pt15.sequence = 15;
+  points.push(Pt15);
+
+  const Pt16 = new Point(15, 16);
+  Pt16.sequence = 16;
+  points.push(Pt16);
+
+
+  points.push(Pt10, Pt11, Pt13, Pt14, Pt15, Pt16);
+
+  const dimension = new AngularDimension({ 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
+6
+30
+0.0
+11
+7
+21
+8
+31
+0.0
+70
+2
+3
+STANDARD
+100
+AcDb2LineAngularDimension
+13
+9
+23
+10
+33
+0.0
+14
+11
+24
+12
+34
+0.0
+15
+13
+25
+14
+35
+0.0
+16
+15
+26
+16
+36
+0.0
+`;
+
+  expect(file.contents).toEqual(dxfString);
+
+  // create new entity from entity data to ensure all props are loaded
+  const newDimension = new AngularDimension(dimension);
+  file = new File();
+  newDimension.dxf(file);
+  expect(file.contents).toEqual(dxfString);
+});
+
+