@design-core/core 0.0.1 → 0.0.3

package/test/tools/copyclip.test.js

@@ -0,0 +1,92 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Copyclip } from '../../core/tools/copyclip.js';
+import { DesignCore } from '../../core/designCore.js';
+
+import { jest } from '@jest/globals';
+
+// Initialize core (sets DesignCore.Core)
+new Core();
+
+describe('Copyclip Tool', () => {
+  beforeEach(() => {
+    // reset scene entities and selection
+    DesignCore.Scene.entities.clear();
+    DesignCore.Scene.selectionManager.reset();
+    // clear clipboard
+    DesignCore.Clipboard.Entities = [];
+  });
+
+  test('action copies selected entities and sets base point to bounding box bottom-left', () => {
+    // Create two line entities and add to scene
+    const line1 = DesignCore.CommandManager.createNew('Line', { layer: '0', points: [new Point(10, 20), new Point(30, 40)] });
+    const line2 = DesignCore.CommandManager.createNew('Line', { layer: '0', points: [new Point(-5, 100), new Point(0, 80)] });
+    DesignCore.Scene.entities.add(line1);
+    DesignCore.Scene.entities.add(line2);
+
+    // Select both
+    DesignCore.Scene.selectionManager.addToSelectionSet(0);
+    DesignCore.Scene.selectionManager.addToSelectionSet(1);
+    expect(DesignCore.Scene.selectionManager.selectedItems).toHaveLength(2);
+
+    const tool = new Copyclip();
+    tool.action();
+
+    // Clipboard now holds selected items (cloned)
+    expect(DesignCore.Clipboard.Entities).toHaveLength(2);
+    // BasePoint should be min x (-5), min y (20) across all points
+    expect(DesignCore.Clipboard.BasePoint.x).toBe(-5);
+    expect(DesignCore.Clipboard.BasePoint.y).toBe(20);
+  });
+
+  test('clipboard entities are clones (mutating original does not change 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);
+    const originalClonePoints = DesignCore.Scene.selectionManager.selectedItems[0].points.map((p) => ({ x: p.x, y: p.y }));
+
+    const tool = new Copyclip();
+    tool.action();
+    expect(DesignCore.Clipboard.Entities).toHaveLength(1);
+
+    // Mutate original entity
+    line.points[0].x = 999;
+    // Clipboard should remain with old coordinates
+    expect(DesignCore.Clipboard.Entities[0].points[0].x).toBe(originalClonePoints[0].x);
+  });
+
+  test('execute requests selection when none selected then calls executeCommand', async () => {
+    const tool = new Copyclip();
+    const requestSpy = jest.fn().mockResolvedValue(undefined);
+    const execSpy = jest.fn();
+    DesignCore.Scene.selectionManager.reset();
+
+    // Mock inputManager methods
+    DesignCore.Scene.inputManager.requestInput = requestSpy;
+    DesignCore.Scene.inputManager.executeCommand = execSpy;
+
+    await tool.execute();
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+    expect(execSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test('execute skips requestInput when selection exists', async () => {
+    // Prepare selection
+    const ent = DesignCore.CommandManager.createNew('Line', { layer: '0', points: [new Point(1, 1), new Point(2, 2)] });
+    DesignCore.Scene.entities.add(ent);
+    DesignCore.Scene.selectionManager.addToSelectionSet(0);
+    expect(DesignCore.Scene.selectionManager.selectionSet.selectionSet.length).toBe(1);
+
+    const tool = new Copyclip();
+    const requestSpy = jest.fn().mockResolvedValue(undefined);
+    const execSpy = jest.fn();
+    DesignCore.Scene.inputManager.requestInput = requestSpy;
+    DesignCore.Scene.inputManager.executeCommand = execSpy;
+
+    await tool.execute();
+    expect(requestSpy).not.toHaveBeenCalled();
+    expect(execSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+

package/test/tools/cornerEntity.test.js

@@ -0,0 +1,201 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Line } from '../../core/entities/line.js';
+import { CornerEntity } from '../../core/tools/cornerEntity.js';
+import { expect, jest } from '@jest/globals';
+
+const core = new Core();
+
+// ─── activeSeg ────────────────────────────────────────────────────────────────
+
+test('CornerEntity.activeSeg returns entity when segment is null', () => {
+  const corner = new CornerEntity();
+  const entity = {};
+  corner.entity = entity;
+  expect(corner.activeSeg).toBe(entity);
+});
+
+test('CornerEntity.activeSeg returns segment when segment is set', () => {
+  const corner = new CornerEntity();
+  corner.entity = {};
+  const seg = {};
+  corner.segment = seg;
+  expect(corner.activeSeg).toBe(seg);
+});
+
+// ─── direction ────────────────────────────────────────────────────────────────
+
+test('CornerEntity.direction returns lineEnd minus lineStart', () => {
+  const corner = new CornerEntity();
+  corner.lineStart = new Point(1, 2);
+  corner.lineEnd = new Point(4, 6);
+  const dir = corner.direction;
+  expect(dir.x).toBeCloseTo(3);
+  expect(dir.y).toBeCloseTo(4);
+});
+
+// ─── resolveEndpoints ─────────────────────────────────────────────────────────
+
+test('CornerEntity.resolveEndpoints returns true and sets lineStart/lineEnd for a Line', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  const line = core.scene.entities.get(0);
+
+  const corner = new CornerEntity();
+  corner.entity = line;
+
+  expect(corner.resolveEndpoints()).toBe(true);
+  expect(corner.lineStart).toBe(line.points[0]);
+  expect(corner.lineEnd).toBe(line.points[1]);
+});
+
+test('CornerEntity.resolveEndpoints returns false and leaves endpoints null for a non-Line', () => {
+  core.scene.clear();
+  core.scene.addItem('Circle', { points: [new Point(0, 0), new Point(5, 0)] });
+  const circle = core.scene.entities.get(0);
+
+  const corner = new CornerEntity();
+  corner.entity = circle;
+
+  expect(corner.resolveEndpoints()).toBe(false);
+  expect(corner.lineStart).toBeNull();
+  expect(corner.lineEnd).toBeNull();
+});
+
+// ─── setEntity ────────────────────────────────────────────────────────────────
+
+test('CornerEntity.setEntity returns true and clears segment for a plain Line entity', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(10, 0)] });
+  const line = core.scene.entities.get(0);
+
+  const corner = new CornerEntity();
+  expect(corner.setPick(line, new Point(5, 0), 'error')).toBe(true);
+  expect(corner.segment).toBeNull();
+  expect(corner.segmentIndex).toBeNull();
+});
+
+test('CornerEntity.setEntity sets segment and segmentIndex for a polyline straight segment', () => {
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10)] });
+  const poly = core.scene.entities.get(0);
+
+  const corner = new CornerEntity();
+  expect(corner.setPick(poly, new Point(5, 0), 'error')).toBe(true); // near first (horizontal) segment
+  expect(corner.segment).toBeInstanceOf(Line);
+  expect(corner.segmentIndex).toBe(1);
+});
+
+test('CornerEntity.setEntity notifies and returns false for a polyline arc segment', () => {
+  core.scene.clear();
+  const notifySpy = jest.spyOn(core, 'notify');
+
+  // bulge on the start point makes the segment an arc
+  const arcStart = new Point(0, 0);
+  arcStart.bulge = 1;
+  core.scene.addItem('Lwpolyline', { points: [arcStart, new Point(10, 0)] });
+  const poly = core.scene.entities.get(0);
+
+  const errorMsg = 'arc segment error';
+  expect(new CornerEntity().setPick(poly, new Point(5, 2), errorMsg)).toBe(false);
+  expect(notifySpy).toHaveBeenCalledWith(errorMsg);
+  notifySpy.mockRestore();
+});
+
+// ─── click-side geometry getters ─────────────────────────────────────────────
+
+test('CornerEntity click-side geometry methods return correct values', () => {
+  // Horizontal line (0,0)→(10,0), intersection at (5,0), click at (3,2)
+  // clickOnLine = perpendicular foot of (3,2) on the line = (3,0)
+  // clickDir = (3,0)−(5,0) = (−2,0)
+  // clickDistance = 2, clickUnit = (−1,0)
+  // lineKeptEnd = lineStart because clickDir points toward start
+  const corner = new CornerEntity();
+  corner.lineStart = new Point(0, 0);
+  corner.lineEnd = new Point(10, 0);
+  corner.clickPoint = new Point(3, 2);
+  const ip = new Point(5, 0);
+
+  expect(corner.clickDistance(ip)).toBeCloseTo(2);
+  expect(corner.clickDir(ip).x).toBeCloseTo(-2);
+  expect(corner.clickDir(ip).y).toBeCloseTo(0);
+  expect(corner.clickUnit(ip).x).toBeCloseTo(-1);
+  expect(corner.clickUnit(ip).y).toBeCloseTo(0);
+  expect(corner.lineKeptEnd(ip)).toBe(corner.lineStart);
+});
+
+test('CornerEntity.clickDistance is near zero when click projects exactly to intersection', () => {
+  // clickOnLine = (5,0) = intersectionPoint → clickDistance = 0 → ambiguous corner
+  const corner = new CornerEntity();
+  corner.lineStart = new Point(0, 0);
+  corner.lineEnd = new Point(10, 0);
+  corner.clickPoint = new Point(5, 0);
+
+  expect(corner.clickDistance(new Point(5, 0))).toBeCloseTo(0);
+});
+
+test('CornerEntity.lineKeptEnd is lineEnd when click is past intersection', () => {
+  // Click at (8,1): clickOnLine = (8,0), clickDir from (5,0) = (3,0) → points toward end
+  const corner = new CornerEntity();
+  corner.lineStart = new Point(0, 0);
+  corner.lineEnd = new Point(10, 0);
+  corner.clickPoint = new Point(8, 1);
+
+  expect(corner.lineKeptEnd(new Point(5, 0))).toBe(corner.lineEnd);
+});
+
+// ─── keepStart ───────────────────────────────────────────────────────────────
+
+test('CornerEntity.keepStart returns true when segment start is on the click side', () => {
+  // Polyline: (0,0)→(10,0)→(10,10), click at (3,2), intersection=(10,0)
+  // clickOnLine=(3,0), clickDir=(−7,0) → points toward start side
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10)] });
+  const poly = core.scene.entities.get(0);
+
+  const corner = new CornerEntity();
+  corner.entity = poly;
+  corner.segmentIndex = 1;
+  corner.lineStart = new Point(0, 0);
+  corner.lineEnd = new Point(10, 0);
+  corner.clickPoint = new Point(3, 2);
+
+  expect(corner.keepStart(new Point(10, 0))).toBe(true);
+});
+
+test('CornerEntity.keepStart returns false when segment end is on the click side', () => {
+  // Same polyline, click at (8,2), intersection=(0,0)
+  // clickOnLine=(8,0), clickDir=(8,0) → points toward end side
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10)] });
+  const poly = core.scene.entities.get(0);
+
+  const corner = new CornerEntity();
+  corner.entity = poly;
+  corner.segmentIndex = 1;
+  corner.lineStart = new Point(0, 0);
+  corner.lineEnd = new Point(10, 0);
+  corner.clickPoint = new Point(8, 2);
+
+  expect(corner.keepStart(new Point(0, 0))).toBe(false);
+});
+
+test('CornerEntity.keepStart handles closing segment of closed polyline (segmentIndex === points.length)', () => {
+  // Closed polyline: (0,0)→(10,0)→(10,10), closing segment is index 3 (back to (0,0))
+  // segmentIndex === points.length wraps segEnd to points[0] = (0,0)
+  // lineStart=(10,10), lineEnd=(0,0), click at (9,9), intersection=(10,0)
+  // clickOnLine=(10,9.something...) but we just need keepStart not to throw
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10)] });
+  const poly = core.scene.entities.get(0);
+
+  const corner = new CornerEntity();
+  corner.entity = poly;
+  corner.segmentIndex = poly.points.length; // closing segment
+  corner.lineStart = new Point(10, 10);
+  corner.lineEnd = new Point(0, 0);
+  corner.clickPoint = new Point(9, 9);
+
+  // Should not throw; segEnd wraps to points[0] = (0,0)
+  expect(() => corner.keepStart(new Point(10, 0))).not.toThrow();
+});

package/test/tools/cutclip.test.js

@@ -0,0 +1,94 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Cutclip } from '../../core/tools/cutclip.js';
+import { DesignCore } from '../../core/designCore.js';
+
+import { jest } from '@jest/globals';
+
+// Initialize core (sets DesignCore.Core)
+new Core();
+
+describe('Cutclip Tool', () => {
+  beforeEach(() => {
+    // reset scene entities and selection
+    DesignCore.Scene.entities.clear();
+    DesignCore.Scene.selectionManager.reset();
+    // clear clipboard
+    DesignCore.Clipboard.Entities = [];
+  });
+
+  test('action copies selected entities and sets base point to bounding box bottom-left', () => {
+    // Create two line entities and add to scene
+    const line1 = DesignCore.CommandManager.createNew('Line', { layer: '0', points: [new Point(10, 20), new Point(30, 40)] });
+    const line2 = DesignCore.CommandManager.createNew('Line', { layer: '0', points: [new Point(-5, 100), new Point(0, 80)] });
+    DesignCore.Scene.entities.add(line1);
+    DesignCore.Scene.entities.add(line2);
+
+    // Select both
+    DesignCore.Scene.selectionManager.addToSelectionSet(0);
+    DesignCore.Scene.selectionManager.addToSelectionSet(1);
+    expect(DesignCore.Scene.selectionManager.selectedItems).toHaveLength(2);
+
+    const tool = new Cutclip();
+    tool.action();
+
+    // Clipboard now holds selected items (cloned)
+    expect(DesignCore.Clipboard.Entities).toHaveLength(2);
+    // BasePoint should be min x (-5), min y (20) across all points
+    expect(DesignCore.Clipboard.BasePoint.x).toBe(-5);
+    expect(DesignCore.Clipboard.BasePoint.y).toBe(20);
+    // Scene entities should be removed
+    expect(DesignCore.Scene.entities.count()).toBe(0);
+  });
+
+  test('clipboard entities are clones (mutating original does not change 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);
+    const originalClonePoints = DesignCore.Scene.selectionManager.selectedItems[0].points.map((p) => ({ x: p.x, y: p.y }));
+
+    const tool = new Cutclip();
+    tool.action();
+    expect(DesignCore.Clipboard.Entities).toHaveLength(1);
+
+    // Mutate original entity
+    line.points[0].x = 999;
+    // Clipboard should remain with old coordinates
+    expect(DesignCore.Clipboard.Entities[0].points[0].x).toBe(originalClonePoints[0].x);
+  });
+
+  test('execute requests selection when none selected then calls executeCommand', async () => {
+    const tool = new Cutclip();
+    const requestSpy = jest.fn().mockResolvedValue(undefined);
+    const execSpy = jest.fn();
+    DesignCore.Scene.selectionManager.reset();
+
+    // Mock inputManager methods
+    DesignCore.Scene.inputManager.requestInput = requestSpy;
+    DesignCore.Scene.inputManager.executeCommand = execSpy;
+
+    await tool.execute();
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+    expect(execSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test('execute skips requestInput when selection exists', async () => {
+    // Prepare selection
+    const ent = DesignCore.CommandManager.createNew('Line', { layer: '0', points: [new Point(1, 1), new Point(2, 2)] });
+    DesignCore.Scene.entities.add(ent);
+    DesignCore.Scene.selectionManager.addToSelectionSet(0);
+    expect(DesignCore.Scene.selectionManager.selectionSet.selectionSet.length).toBe(1);
+
+    const tool = new Cutclip();
+    const requestSpy = jest.fn().mockResolvedValue(undefined);
+    const execSpy = jest.fn();
+    DesignCore.Scene.inputManager.requestInput = requestSpy;
+    DesignCore.Scene.inputManager.executeCommand = execSpy;
+
+    await tool.execute();
+    expect(requestSpy).not.toHaveBeenCalled();
+    expect(execSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+

package/test/tools/distance.test.js

@@ -1,30 +1,152 @@
-import {Core} from '../../core/core/core.js';
-import {DesignCore} from '../../core/designCore.js';
-import {Point} from '../../core/entities/point.js';
-import {Distance} from '../../core/tools/distance.js';
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Distance } from '../../core/tools/distance.js';
+import { Strings } from '../../core/lib/strings.js';
+import { expect, jest } from '@jest/globals';
+import { withMockInput } from '../test-helpers/test-helpers.js';
 
 const core = new Core();
-let output;
 
-core.notify = (notification) => {
-  output = notification;
-};
+// ─── register ────────────────────────────────────────────────────────────────
 
-test('Test distance.action', () => {
-  // Add items to scene
-  DesignCore.Scene.addItem('Line', {points: [new Point(), new Point(0, 10)]});
+test('Distance.register returns correct command object', () => {
+  const reg = Distance.register();
+  expect(reg.command).toBe('Distance');
+  expect(reg.shortcut).toBe('DI');
+});
 
-  const distance = new Distance();
+// ─── action ───────────────────────────────────────────────────────────────────
 
-  // set base point
-  distance.points.push(new Point());
+test('Distance.action vertical line: correct length, angle, and deltas', () => {
+  const notifySpy = jest.spyOn(core, 'notify');
 
-  // set destination point
+  const distance = new Distance();
+  distance.points.push(new Point(0, 0));
   distance.points.push(new Point(0, 10));
+  distance.action();
+
+  expect(notifySpy).toHaveBeenCalledWith(`${Strings.Strings.LENGTH}: 10.0 Angle: 90.0${Strings.Symbol.DEGREE} ${Strings.Symbol.DELTA}X: 0.0 ${Strings.Symbol.DELTA}Y: 10.0`);
+  notifySpy.mockRestore();
+});
+
+test('Distance.action horizontal line: correct length, angle, and deltas', () => {
+  const notifySpy = jest.spyOn(core, 'notify');
+
+  const distance = new Distance();
+  distance.points.push(new Point(0, 0));
+  distance.points.push(new Point(10, 0));
+  distance.action();
+
+  expect(notifySpy).toHaveBeenCalledWith(`${Strings.Strings.LENGTH}: 10.0 Angle: 0.0${Strings.Symbol.DEGREE} ${Strings.Symbol.DELTA}X: 10.0 ${Strings.Symbol.DELTA}Y: 0.0`);
+  notifySpy.mockRestore();
+});
+
+test('Distance.action diagonal 3-4-5 triangle: correct length and angle', () => {
+  const notifySpy = jest.spyOn(core, 'notify');
 
-  // Perform distance
+  const distance = new Distance();
+  distance.points.push(new Point(0, 0));
+  distance.points.push(new Point(3, 4));
   distance.action();
 
-  expect(output).not.toBeUndefined();
-  expect(output).toBe('Length: 10.0 ΔX: 0.0 ΔY: 10.0');
+  // length = 5, angle = atan2(4,3) ≈ 53.1°
+  expect(notifySpy).toHaveBeenCalledWith(`${Strings.Strings.LENGTH}: 5.0 Angle: 53.1${Strings.Symbol.DEGREE} ${Strings.Symbol.DELTA}X: 3.0 ${Strings.Symbol.DELTA}Y: 4.0`);
+  notifySpy.mockRestore();
+});
+
+test('Distance.action reversed horizontal line: negative delta and 180° angle', () => {
+  const notifySpy = jest.spyOn(core, 'notify');
+
+  const distance = new Distance();
+  distance.points.push(new Point(10, 0));
+  distance.points.push(new Point(0, 0));
+  distance.action();
+
+  // angle = atan2(0, -10) = 180°
+  expect(notifySpy).toHaveBeenCalledWith(`${Strings.Strings.LENGTH}: 10.0 Angle: 180.0${Strings.Symbol.DEGREE} ${Strings.Symbol.DELTA}X: -10.0 ${Strings.Symbol.DELTA}Y: 0.0`);
+  notifySpy.mockRestore();
+});
+
+test('Distance.action non-origin start point: deltas computed from actual coordinates', () => {
+  const notifySpy = jest.spyOn(core, 'notify');
+
+  const distance = new Distance();
+  distance.points.push(new Point(5, 5));
+  distance.points.push(new Point(5, 10));
+  distance.action();
+
+  // dx=0, dy=5, length=5, angle=90°
+  expect(notifySpy).toHaveBeenCalledWith(`${Strings.Strings.LENGTH}: 5.0 Angle: 90.0${Strings.Symbol.DEGREE} ${Strings.Symbol.DELTA}X: 0.0 ${Strings.Symbol.DELTA}Y: 5.0`);
+  notifySpy.mockRestore();
+});
+
+// ─── execute ──────────────────────────────────────────────────────────────────
+
+test('Distance.execute collects two points and calls executeCommand', async () => {
+  const executeCommandSpy = jest.fn();
+
+  await withMockInput(
+      core.scene,
+      [new Point(0, 0), new Point(10, 0)],
+      async () => {
+        const distance = new Distance();
+        await distance.execute();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+
+  expect(executeCommandSpy).toHaveBeenCalled();
+});
+
+test('Distance.execute returns early when first point is undefined', async () => {
+  const executeCommandSpy = jest.fn();
+
+  await withMockInput(
+      core.scene,
+      [],
+      async () => {
+        const distance = new Distance();
+        await distance.execute();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+
+  expect(executeCommandSpy).not.toHaveBeenCalled();
+});
+
+test('Distance.execute returns early when second point is undefined', async () => {
+  const executeCommandSpy = jest.fn();
+
+  await withMockInput(
+      core.scene,
+      [new Point(0, 0)],
+      async () => {
+        const distance = new Distance();
+        await distance.execute();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+
+  expect(executeCommandSpy).not.toHaveBeenCalled();
+});
+
+test('Distance.execute stores collected points for action', async () => {
+  let capturedDistance;
+  const executeCommandSpy = jest.fn();
+
+  await withMockInput(
+      core.scene,
+      [new Point(0, 0), new Point(0, 5)],
+      async () => {
+        capturedDistance = new Distance();
+        await capturedDistance.execute();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+
+  expect(capturedDistance.points).toHaveLength(2);
+  expect(capturedDistance.points[0].x).toBe(0);
+  expect(capturedDistance.points[0].y).toBe(0);
+  expect(capturedDistance.points[1].x).toBe(0);
+  expect(capturedDistance.points[1].y).toBe(5);
 });

package/test/tools/erase.test.js

@@ -1,28 +1,28 @@
-import {Core} from '../../core/core/core.js';
-import {Point} from '../../core/entities/point.js';
-import {Erase} from '../../core/tools/erase.js';
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Erase } from '../../core/tools/erase.js';
 
 const core = new Core();
 
 test('Test Erase.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);
   }
 
-  expect(core.scene.items.length).toBe(6);
+  expect(core.scene.entities.count()).toBe(6);
 
   // Perform Erase
   const erase = new Erase();
   erase.action();
 
-  expect(core.scene.items.length).toBe(0);
+  expect(core.scene.entities.count()).toBe(0);
 });

package/test/tools/explode.test.js

@@ -0,0 +1,45 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Explode } from '../../core/tools/explode.js';
+import { Line } from '../../core/entities/line.js';
+
+const core = new Core();
+
+test('Test Explode.action', () => {
+  const insertPoint = new Point(100, 100);
+  const insertIndex = core.scene.addItem('Insert', { points: [insertPoint] });
+  const insert = core.scene.entities.get(insertIndex);
+
+  for (let i = 0; i < 5; i++) {
+    const line = new Line({ points: [new Point(0, i * 10), new Point(100, i * 10)] });
+    insert.block.addItem(line);
+  }
+
+  expect(core.scene.entities.count()).toBe(1);
+
+  // Add items to selection set
+  for (let i = 0; i < core.scene.entities.count(); i++) {
+    core.scene.selectionManager.addToSelectionSet(i);
+  }
+
+  // Perform Explode
+  const explode = new Explode();
+  explode.action();
+
+  expect(core.scene.entities.count()).toBe(5);
+
+  // loop through all exploded items, check the type and
+  // check the points have been modified when exploded
+  const handles = new Set();
+  for (let i = 0; i < core.scene.entities.count(); i++) {
+    const item = core.scene.entities.get(i);
+    expect(item instanceof Line).toBe(true);
+    expect(item.points[0].x).toBe(0 + insertPoint.x);
+    expect(item.points[0].y).toBe(i * 10 + insertPoint.y);
+
+    // Verify each exploded entity has a unique handle
+    expect(item.handle).toBeDefined();
+    expect(handles.has(item.handle)).toBe(false);
+    handles.add(item.handle);
+  }
+});