@design-core/core 0.0.1 → 0.0.3

package/test/tools/pan.test.js

@@ -0,0 +1,72 @@
+import { Pan } from '../../core/tools/pan.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Core } from '../../core/core/core.js';
+import { MouseDown, MouseUp } from '../../core/lib/input.js';
+
+import { jest } from '@jest/globals';
+
+// initialise core
+new Core();
+
+afterEach(() => {
+  jest.restoreAllMocks();
+  DesignCore.Scene.inputManager.activeCommand = undefined;
+});
+
+test('Pan.execute toggles panning on mouse down then off on mouse up (single cycle)', async () => {
+  const pan = new Pan();
+  DesignCore.Scene.inputManager.activeCommand = pan;
+
+  const panSpy = jest.spyOn(DesignCore.Canvas, 'pan').mockImplementation(() => {});
+
+  let resolveMouseDown; let resolveMouseUp;
+  const mouseDownPromise = new Promise((r) => (resolveMouseDown = r));
+  const mouseUpPromise = new Promise((r) => (resolveMouseUp = r));
+
+  jest.spyOn(DesignCore.Scene.inputManager, 'requestInput')
+      .mockImplementationOnce(() => mouseDownPromise)
+      .mockImplementationOnce(() => mouseUpPromise);
+
+  const execPromise = pan.execute();
+
+  // Verify first requestInput was called with the pan prompt
+  expect(DesignCore.Scene.inputManager.requestInput.mock.calls[0][0].promptMessage)
+      .toBe('');
+
+  resolveMouseDown(new MouseDown());
+  await Promise.resolve();
+  expect(pan.panning).toBe(true);
+
+  pan.preview();
+  expect(panSpy).toHaveBeenCalledTimes(1);
+
+  DesignCore.Scene.inputManager.activeCommand = undefined;
+  resolveMouseUp(new MouseUp());
+  await execPromise;
+  expect(pan.panning).toBe(false);
+});
+
+
+test('Test Pan.register', () => {
+  const command = Pan.register();
+  expect(command.command).toBe('Pan');
+  expect(command.shortcut).toBe('P');
+  expect(command.type).toBeUndefined();
+});
+
+
+test('Pan command should call DesignCore.Canvas.pan when panning is true', () => {
+  DesignCore.Canvas.pan = jest.fn();
+  const pan = new Pan();
+  pan.panning = true;
+  pan.preview();
+  expect(DesignCore.Canvas.pan).toHaveBeenCalled();
+});
+
+test('Pan command should not call DesignCore.Canvas.pan when panning is false', () => {
+  DesignCore.Canvas.pan = jest.fn();
+  const pan = new Pan();
+  pan.panning = false;
+  pan.preview();
+  expect(DesignCore.Canvas.pan).not.toHaveBeenCalled();
+});

package/test/tools/pasteclip.test.js

@@ -0,0 +1,100 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Pasteclip } from '../../core/tools/pasteclip.js';
+import { Copyclip } from '../../core/tools/copyclip.js';
+import { DesignCore } from '../../core/designCore.js';
+import { expect, jest } from '@jest/globals';
+
+// Init core context
+new Core();
+
+describe('Pasteclip Tool', () => {
+  beforeEach(() => {
+    DesignCore.Scene.entities.clear();
+    DesignCore.Scene.selectionManager.reset();
+    DesignCore.Scene.tempEntities.clear();
+    DesignCore.Clipboard.Entities = []; // also resets basePoint
+  });
+
+  test('execute throws / resets when clipboard invalid', async () => {
+    const tool = new Pasteclip();
+    const resetSpy = jest.spyOn(DesignCore.Scene.inputManager, 'reset').mockImplementation(() => {});
+    const requestSpy = jest.spyOn(DesignCore.Scene.inputManager, 'requestInput').mockResolvedValue(new Point());
+    await tool.execute();
+    expect(resetSpy).toHaveBeenCalled();
+    expect(requestSpy).not.toHaveBeenCalled();
+  });
+
+  test('execute requests base point and then calls executeCommand when clipboard valid', async () => {
+    // Prepare clipboard via copyclip to ensure validity
+    const line = DesignCore.CommandManager.createNew('Line', { layer: '0', points: [new Point(10, 10), new Point(20, 20)] });
+    DesignCore.Scene.entities.add(line);
+    DesignCore.Scene.selectionManager.addToSelectionSet(0);
+    new Copyclip().action();
+    expect(DesignCore.Clipboard.isValid).toBe(true);
+
+    const tool = new Pasteclip();
+    const pt = new Point(100, 100);
+    const requestSpy = jest.spyOn(DesignCore.Scene.inputManager, 'requestInput').mockResolvedValue(pt);
+    const execSpy = jest.spyOn(DesignCore.Scene.inputManager, 'executeCommand').mockImplementation(() => {});
+    await tool.execute();
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+    expect(execSpy).toHaveBeenCalledTimes(1);
+    expect(tool.points[0]).toBe(pt);
+  });
+
+  test('preview creates temp entities offset from mouse', () => {
+    // Setup clipboard
+    const line = DesignCore.CommandManager.createNew('Line', { layer: '0', points: [new Point(0, 0), new Point(10, 0)] });
+    DesignCore.Scene.entities.add(line);
+    DesignCore.Scene.selectionManager.addToSelectionSet(0);
+    new Copyclip().action();
+    const basePoint = DesignCore.Clipboard.BasePoint; // bottom-left of line
+
+    // Mock mouse pointOnScene to return offset target
+    const targetPoint = new Point(50, 50);
+    DesignCore.Mouse.pointOnScene = () => targetPoint;
+
+    const tool = new Pasteclip();
+    tool.preview();
+    expect(DesignCore.Scene.tempEntities.count()).toBeGreaterThan(0);
+    const tempLine = DesignCore.Scene.tempEntities.get(0);
+    const deltaX = targetPoint.x - basePoint.x;
+    const deltaY = targetPoint.y - basePoint.y;
+    expect(tempLine.points[0].x).toBe(line.points[0].x + deltaX);
+    expect(tempLine.points[0].y).toBe(line.points[0].y + deltaY);
+  });
+
+  test('action pastes entities with correct offset', () => {
+    const line = DesignCore.CommandManager.createNew('Circle', { layer: '0', points: [new Point(), new Point(5, 0)] });
+    DesignCore.Scene.entities.add(line);
+    DesignCore.Scene.selectionManager.addToSelectionSet(0);
+    new Copyclip().action();
+
+    const basePoint = DesignCore.Clipboard.BasePoint;
+    expect(basePoint.x).toBe(-5);
+    expect(basePoint.y).toBe(-5);
+
+    const entityCount = DesignCore.Scene.entities.count();
+    const tool = new Pasteclip();
+    const insertion = new Point(10, 10);
+    tool.points.push(insertion); // simulate execute collected base point
+    tool.action();
+
+    expect(DesignCore.Scene.entities.count()).toBe(entityCount + 1);
+
+
+    const newEntity = DesignCore.Scene.entities.get(-1);
+    expect(newEntity.points[0].x).toBe(15);
+    expect(newEntity.points[0].y).toBe(15);
+
+    // Ensure the in clipboard was not mutated
+    const pasted = DesignCore.Clipboard.Entities[0];
+    expect(pasted.points[0].x).toBe(0);
+    expect(pasted.points[0].y).toBe(0);
+
+    // Verify pasted entity has a unique handle
+    expect(newEntity.handle).toBeDefined();
+    expect(newEntity.handle).not.toBe(line.handle);
+  });
+});

package/test/tools/purge.test.js

@@ -0,0 +1,89 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Purge } from '../../core/tools/purge.js';
+import { DesignCore } from '../../core/designCore.js';
+
+new Core();
+const purge = new Purge();
+const layerManager = DesignCore.LayerManager;
+const ltypeManager = DesignCore.LTypeManager;
+const blockManager = DesignCore.Scene.blockManager;
+const dimStyleManager = DesignCore.DimStyleManager;
+
+// Runc this before each test
+beforeEach(() => {
+  // insert needed for block?
+  blockManager.addItem({ name: 'blockWithoutItems' });
+  blockManager.addItem({ name: 'blockWithItems' });
+
+  layerManager.addItem({ 'name': 'layerWithoutItems' });
+  layerManager.addItem({ 'name': 'layerWithItems' });
+
+  ltypeManager.addItem({ 'name': 'ltypeWithoutItems' });
+  ltypeManager.addItem({ 'name': 'ltypeWithItems' });
+
+  dimStyleManager.addItem({ 'name': 'dimstyleWithItems' });
+
+  const point1 = new Point();
+  const point2 = new Point(0, 100);
+
+  const data = { points: [point1, point2], layer: 'layerWithItems', lineType: 'ltypeWithItems' };
+
+  DesignCore.Scene.addItem('Insert', { blockName: 'blockWithItems' });
+  DesignCore.Scene.addItem('Line', data);
+  DesignCore.Scene.addItem('Circle', data);
+  DesignCore.Scene.addItem('Text', data);
+});
+
+test('Test purge.action', () => {
+  expect(blockManager.itemCount()).toBe(4);
+  purge.option = 'Blocks';
+  purge.action();
+  expect(blockManager.itemCount()).toBe(3);
+  expect(blockManager.itemExists('blockWithoutItems')).toBe(false);
+  expect(blockManager.itemExists('blockWithItems')).toBe(true);
+
+  expect(dimStyleManager.itemCount()).toBe(4);
+  purge.option = 'Dimstyles';
+  purge.action();
+  expect(dimStyleManager.itemCount()).toBe(1);
+
+  expect(layerManager.itemCount()).toBe(4);
+  purge.option = 'Layers';
+  purge.action();
+  expect(layerManager.itemCount()).toBe(3);
+  expect(layerManager.itemExists('layerWithoutItems')).toBe(false);
+  expect(layerManager.itemExists('layerWithItems')).toBe(true);
+
+  expect(ltypeManager.itemCount()).toBe(5);
+  purge.option = 'LTypes';
+  purge.action();
+  expect(ltypeManager.itemCount()).toBe(4);
+  expect(ltypeManager.itemExists('ltypeWithOutItems')).toBe(false);
+  expect(ltypeManager.itemExists('ltypeWithItems')).toBe(true);
+});
+
+test('Test purge.action - All', () => {
+  expect(blockManager.itemCount()).toBe(4);
+  expect(layerManager.itemCount()).toBe(4);
+  expect(ltypeManager.itemCount()).toBe(5);
+
+  purge.option = 'All';
+  purge.action();
+
+  // Blocks
+  expect(blockManager.itemCount()).toBe(3);
+  expect(blockManager.itemExists('blockWithoutItems')).toBe(false);
+  expect(blockManager.itemExists('blockWithItems')).toBe(true);
+
+  // Layers
+  expect(layerManager.itemCount()).toBe(3);
+  expect(layerManager.itemExists('layerWithoutItems')).toBe(false);
+  expect(layerManager.itemExists('layerWithItems')).toBe(true);
+
+  // Ltypes
+  expect(ltypeManager.itemCount()).toBe(4);
+  expect(ltypeManager.itemExists('ltypeWithOutItems')).toBe(false);
+  expect(ltypeManager.itemExists('ltypeWithItems')).toBe(true);
+});
+

package/test/tools/rotate.test.js

@@ -1,20 +1,92 @@
-import {Core} from '../../core/core/core.js';
-import {Point} from '../../core/entities/point.js';
-import {Rotate} from '../../core/tools/rotate.js';
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Rotate } from '../../core/tools/rotate.js';
 
 const core = new Core();
 
+const inputScenarios = [
+  {
+    desc: 'rotate by point',
+    inputs: [new Point(10, 0), new Point(30, 20)],
+    result: new Point(17.07106, 7.07106),
+
+  },
+  {
+    desc: 'rotate by angle',
+    inputs: [new Point(10, 0), 45],
+    result: new Point(17.07106, 7.07106),
+
+  },
+  {
+    desc: 'rotate by negative angle',
+    inputs: [new Point(10, 0), -45],
+    result: new Point(17.07106, -7.07106),
+
+  },
+  {
+    desc: 'rotate 90 by reference point',
+    inputs: [new Point(10, 0), 'r', new Point(), new Point(0, 20), new Point(-10, 0)],
+    result: new Point(10, 10),
+  },
+];
+
+test.each(inputScenarios)('Rotate.execute handles $desc', async (scenario) => {
+  const { inputs, result } = scenario;
+  const origInputManager = core.scene.inputManager;
+  let callCount = 0;
+  core.scene.inputManager = {
+    requestInput: async () => {
+      if (callCount < inputs.length) {
+        const input = inputs[callCount];
+        callCount++;
+        return input;
+      }
+    },
+  };
+
+  // clear all scene entities
+  core.scene.clear();
+  // create line
+  const pointOne = new Point(10, 0);
+  const pointTwo = new Point(20, 0);
+  core.scene.addItem('Line', { points: [pointOne, pointTwo] });
+
+  // select line
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const rotate = new Rotate();
+  await rotate.execute();
+
+  expect(core.scene.tempEntities.count()).toBe(0); // no temp entities before preview
+  rotate.preview(); // to set up any preview state if needed
+  expect(core.scene.tempEntities.count()).toBe(1); // preview should create temp entity
+
+  rotate.action();
+
+  const line = core.scene.entities.get(0);
+
+  expect(line.points[0].x).toBe(pointOne.x);
+  expect(line.points[0].y).toBeCloseTo(pointOne.y);
+
+  expect(line.points[1].x).toBeCloseTo(result.x);
+  expect(line.points[1].y).toBeCloseTo(result.y);
+
+
+  // Restore original inputManager
+  core.scene.inputManager = origInputManager;
+});
+
 test('Test Rotate.action', () => {
   // Add items to scene
-  core.scene.addItem('Line', {points: [new Point(10, 0), new Point(20, 0)]});
-  core.scene.addItem('Circle', {points: [new Point(10, 0), new Point(20, 0)]});
-  core.scene.addItem('Polyline', {points: [new Point(10, 0), new Point(20, 0)]});
-  core.scene.addItem('Arc', {points: [new Point(10, 0), new Point(10, 10), new Point(0, 10)]});
-  core.scene.addItem('Rectangle', {points: [new Point(10, 0), new Point(0, 10)]});
-  core.scene.addItem('Text', {points: [new Point(10, 0), new Point(0, 10)], height: 10, rotation: 0, string: 'text test'});
+  core.scene.addItem('Line', { points: [new Point(10, 0), new Point(20, 0)] });
+  core.scene.addItem('Circle', { points: [new Point(10, 0), new Point(20, 0)] });
+  core.scene.addItem('Polyline', { points: [new Point(10, 0), new Point(20, 0)] });
+  core.scene.addItem('Arc', { points: [new Point(10, 0), new Point(10, 10), new Point(0, 10)] });
+  core.scene.addItem('Rectangle', { points: [new Point(10, 0), new Point(0, 10)] });
+  core.scene.addItem('Text', { points: [new Point(10, 0), new Point(0, 10)], height: 10, rotation: 0, string: 'text test' });
 
   // Add items to selection set
-  for (let i = 0; i < core.scene.items.length; i++) {
+  for (let i = 0; i < core.scene.entities.count(); i++) {
     core.scene.selectionManager.addToSelectionSet(i);
   }
 
@@ -27,18 +99,15 @@ test('Test Rotate.action', () => {
   // set base point
   rotate.points.push(new Point());
 
-  // set rotation reference point
-  rotate.points.push(new Point(10, 0));
-
   // set rotation destination point
   rotate.points.push(new Point(0, 10));
 
   // Perform rotate
   rotate.action();
 
-  for (let i = 0; i < core.scene.items.length; i++) {
-    expect(core.scene.items[i].points[0].x).toBeCloseTo(0);
-    expect(core.scene.items[i].points[0].y).toBeCloseTo(10);
+  for (let i = 0; i < core.scene.entities.count(); i++) {
+    expect(core.scene.entities.get(i).points[0].x).toBeCloseTo(0);
+    expect(core.scene.entities.get(i).points[0].y).toBeCloseTo(10);
   }
 
   /**
@@ -51,17 +120,14 @@ test('Test Rotate.action', () => {
   // set base point
   rotate.points.push(new Point());
 
-  // set rotation reference point
-  rotate.points.push(new Point(0, 10));
-
   // set rotation destination point
-  rotate.points.push(new Point(10, 0));
+  rotate.points.push(new Point(0, -10));
 
   // Perform rotate
   rotate.action();
 
-  for (let i = 0; i < core.scene.items.length; i++) {
-    expect(core.scene.items[i].points[0].x).toBeCloseTo(10);
-    expect(core.scene.items[i].points[0].y).toBeCloseTo(0);
+  for (let i = 0; i < core.scene.entities.count(); i++) {
+    expect(core.scene.entities.get(i).points[0].x).toBeCloseTo(10);
+    expect(core.scene.entities.get(i).points[0].y).toBeCloseTo(0);
   }
 });