@design-core/core 0.0.1 → 0.0.3

package/test/tools/identify.test.js

@@ -1,27 +1,126 @@
-import {Core} from '../../core/core/core.js';
-import {DesignCore} from '../../core/designCore.js';
-import {Point} from '../../core/entities/point.js';
-import {Identify} from '../../core/tools/identify.js';
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Identify } from '../../core/tools/identify.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('Identify.register returns correct command object', () => {
+  const reg = Identify.register();
+  expect(reg.command).toBe('Identify');
+  expect(reg.shortcut).toBe('ID');
+});
 
-  const identify = new Identify();
+// ─── action ───────────────────────────────────────────────────────────────────
+
+test('Identify.action notifies formatted X and Y coordinates', () => {
+  const notifySpy = jest.spyOn(core, 'notify');
 
-  // set base point
+  const identify = new Identify();
   identify.points.push(new Point(0, 10));
+  identify.action();
+
+  expect(notifySpy).toHaveBeenCalledWith('X:0.0 Y:10.0');
+  notifySpy.mockRestore();
+});
+
+test('Identify.action at origin formats both coordinates as zero', () => {
+  const notifySpy = jest.spyOn(core, 'notify');
+
+  const identify = new Identify();
+  identify.points.push(new Point(0, 0));
+  identify.action();
+
+  expect(notifySpy).toHaveBeenCalledWith('X:0.0 Y:0.0');
+  notifySpy.mockRestore();
+});
+
+test('Identify.action with negative coordinates', () => {
+  const notifySpy = jest.spyOn(core, 'notify');
+
+  const identify = new Identify();
+  identify.points.push(new Point(-5, -3));
+  identify.action();
+
+  expect(notifySpy).toHaveBeenCalledWith('X:-5.0 Y:-3.0');
+  notifySpy.mockRestore();
+});
+
+test('Identify.action with fractional coordinates rounded to 1 decimal place', () => {
+  const notifySpy = jest.spyOn(core, 'notify');
 
-  // Perform identify
+  const identify = new Identify();
+  identify.points.push(new Point(1.5, 2.5));
+  identify.action();
+
+  expect(notifySpy).toHaveBeenCalledWith('X:1.5 Y:2.5');
+  notifySpy.mockRestore();
+});
+
+test('Identify.action uses the last point when multiple points are present', () => {
+  const notifySpy = jest.spyOn(core, 'notify');
+
+  const identify = new Identify();
+  identify.points.push(new Point(1, 2));
+  identify.points.push(new Point(7, 8));
   identify.action();
 
-  expect(output).not.toBeUndefined();
-  expect(output).toBe('X:0.0 Y:10.0');
+  expect(notifySpy).toHaveBeenCalledWith('X:7.0 Y:8.0');
+  notifySpy.mockRestore();
+});
+
+// ─── execute ──────────────────────────────────────────────────────────────────
+
+test('Identify.execute collects one point and calls executeCommand', async () => {
+  const executeCommandSpy = jest.fn();
+
+  await withMockInput(
+      core.scene,
+      [new Point(3, 4)],
+      async () => {
+        const identify = new Identify();
+        await identify.execute();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+
+  expect(executeCommandSpy).toHaveBeenCalled();
+});
+
+test('Identify.execute returns early when input is undefined', async () => {
+  const executeCommandSpy = jest.fn();
+
+  await withMockInput(
+      core.scene,
+      [],
+      async () => {
+        const identify = new Identify();
+        await identify.execute();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+
+  expect(executeCommandSpy).not.toHaveBeenCalled();
+});
+
+test('Identify.execute stores the collected point for action', async () => {
+  let capturedIdentify;
+  const executeCommandSpy = jest.fn();
+
+  await withMockInput(
+      core.scene,
+      [new Point(9, 11)],
+      async () => {
+        capturedIdentify = new Identify();
+        await capturedIdentify.execute();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+
+  expect(capturedIdentify.points).toHaveLength(1);
+  expect(capturedIdentify.points[0].x).toBe(9);
+  expect(capturedIdentify.points[0].y).toBe(11);
 });

package/test/tools/matchProp.test.js

@@ -0,0 +1,84 @@
+import { Core } from '../../core/core/core.js';
+import { DesignCore } from '../../core/designCore.js';
+import { Point } from '../../core/entities/point.js';
+import { MatchProp } from '../../core/tools/matchProp.js';
+import { Input } from '../../core/lib/inputManager.js';
+import { jest } from '@jest/globals';
+
+const core = new Core();
+
+// Add items to scene
+DesignCore.Scene.addItem('Line', { points: [new Point(10, 0), new Point(20, 0)], layer: 'test' });
+DesignCore.Scene.addItem('Circle', { points: [new Point(10, 0), new Point(20, 0)] });
+DesignCore.Scene.addItem('Polyline', { points: [new Point(10, 0), new Point(20, 0)] });
+DesignCore.Scene.addItem('Arc', { points: [new Point(10, 0), new Point(10, 10), new Point(0, 10)] });
+DesignCore.Scene.addItem('Rectangle', { points: [new Point(10, 0), new Point(0, 10)] });
+DesignCore.Scene.addItem('Text', { points: [new Point(10, 0), new Point(0, 10)], height: 10, rotation: 0, string: 'text test' });
+
+test('Test MatchProp.execute requests source and targets and completes', async () => {
+  const match = new MatchProp();
+
+  // Use existing items added at top of file
+  const src = core.scene.entities.get(0);
+  const tgt1 = core.scene.entities.get(1);
+  const tgt2 = core.scene.entities.get(2);
+
+  const im = core.scene.inputManager;
+
+  const promptCalls = [];
+  const reqSpy = jest
+      .spyOn(im, 'requestInput')
+  // First prompt: pick source entity (single selection)
+      .mockImplementationOnce((po) => {
+        promptCalls.push(po);
+        return Promise.resolve(src);
+      })
+  // Second prompt: pick target entities (selection set)
+      .mockImplementationOnce((po) => {
+        promptCalls.push(po);
+        return Promise.resolve([tgt1, tgt2]);
+      });
+
+  await expect(match.execute()).resolves.toBeUndefined();
+
+  // Validate input sequence
+  expect(reqSpy).toHaveBeenCalledTimes(2);
+  expect(promptCalls[0].types).toContain(Input.Type.SINGLESELECTION);
+  expect(promptCalls[1].types).toContain(Input.Type.SELECTIONSET);
+
+  reqSpy.mockRestore();
+});
+
+
+test('Test MatchProp.register', () => {
+  const command = MatchProp.register();
+  expect(command.command).toBe('MatchProp');
+  expect(command.shortcut).toBe('MA');
+  expect(command.type).toBeUndefined();
+});
+
+test('Test MatchProp.action matches properties from source to targets', () => {
+  const match = new MatchProp();
+
+  // Use existing items added at top of file
+  match.sourceIndex = 0; // Line with layer 'test'
+  match.destinationSetIndices = [1, 2, 3, 4, 5]; // Circle, Polyline, Arc, Rectangle, Text
+
+  match.action();
+
+  // Validate that layer property was matched to targets
+  for (let i = 0; i < match.destinationSetIndices.length; i++) {
+    const tgt = core.scene.entities.get(match.destinationSetIndices[i]);
+    expect(tgt.layer).toBe('test');
+  }
+
+  const circle = core.scene.entities.get(1);
+  expect(circle.radius).toBe(10); // original radius
+
+  const arc = core.scene.entities.get(3);
+  expect(arc.radius).toBe(10); // original radius
+
+  const text = core.scene.entities.get(5);
+  expect(text.height).toBe(10); // original height
+  expect(text.string).toBe('text test'); // original string
+});

package/test/tools/mirror.test.js

@@ -0,0 +1,475 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Mirror } from '../../core/tools/mirror.js';
+
+const core = new Core();
+
+const inputScenarios = [
+  {
+    desc: 'mirror across X axis keeping source',
+    points: [new Point(0, 5), new Point(10, 5)],
+    inputs: [new Point(0, 0), new Point(1, 0), 'No'],
+    expectedCount: 2,
+    checkIndex: 1,
+    expectedX: 0,
+    expectedY: -5,
+  },
+  {
+    desc: 'mirror across X axis erasing source',
+    points: [new Point(0, 5), new Point(10, 5)],
+    inputs: [new Point(0, 0), new Point(1, 0), 'Yes'],
+    expectedCount: 1,
+    checkIndex: 0,
+    expectedX: 0,
+    expectedY: -5,
+  },
+  {
+    desc: 'mirror across Y axis keeping source',
+    points: [new Point(5, 0), new Point(5, 10)],
+    inputs: [new Point(0, 0), new Point(0, 1), 'No'],
+    expectedCount: 2,
+    checkIndex: 1,
+    expectedX: -5,
+    expectedY: 0,
+  },
+];
+
+test.each(inputScenarios)('Mirror.execute handles $desc', async (scenario) => {
+  const { points, inputs, expectedCount, checkIndex, expectedX, expectedY } = scenario;
+
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points });
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const origInputManager = core.scene.inputManager;
+  let callCount = 0;
+  core.scene.inputManager = {
+    requestInput: async () => {
+      if (callCount < inputs.length) {
+        return inputs[callCount++];
+      }
+    },
+    executeCommand: () => {},
+    reset: () => {},
+  };
+
+  const mirror = new Mirror();
+  await mirror.execute();
+  mirror.action();
+
+  expect(core.scene.entities.count()).toBe(expectedCount);
+
+  const entity = core.scene.entities.get(checkIndex);
+  expect(entity.points[0].x).toBeCloseTo(expectedX);
+  expect(entity.points[0].y).toBeCloseTo(expectedY);
+
+  core.scene.inputManager = origInputManager;
+});
+
+test('Mirror.execute - cancel at first point does not mirror', async () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const origInputManager = core.scene.inputManager;
+  core.scene.inputManager = {
+    requestInput: async () => undefined,
+    executeCommand: () => {},
+    reset: () => {},
+  };
+
+  const mirror = new Mirror();
+  await mirror.execute();
+
+  expect(core.scene.entities.count()).toBe(1);
+  expect(core.scene.entities.get(0).points[0].y).toBeCloseTo(5);
+
+  core.scene.inputManager = origInputManager;
+});
+
+test('Mirror.execute - cancel at second point does not mirror', async () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const origInputManager = core.scene.inputManager;
+  let callCount = 0;
+  const inputs = [new Point(0, 0)]; // provides pt1, then undefined on pt2
+  core.scene.inputManager = {
+    requestInput: async () => {
+      if (callCount < inputs.length) {
+        return inputs[callCount++];
+      }
+    },
+    executeCommand: () => {},
+    reset: () => {},
+  };
+
+  const mirror = new Mirror();
+  await mirror.execute();
+
+  expect(core.scene.entities.count()).toBe(1);
+  expect(core.scene.entities.get(0).points[0].y).toBeCloseTo(5);
+
+  core.scene.inputManager = origInputManager;
+});
+
+test('Mirror.execute - undefined erase prompt defaults to keeping source', async () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const origInputManager = core.scene.inputManager;
+  let callCount = 0;
+  const inputs = [new Point(0, 0), new Point(1, 0)]; // pt1 + pt2, then undefined on erase
+  core.scene.inputManager = {
+    requestInput: async () => {
+      if (callCount < inputs.length) {
+        return inputs[callCount++];
+      }
+    },
+    executeCommand: () => {},
+    reset: () => {},
+  };
+
+  const mirror = new Mirror();
+  await mirror.execute();
+  mirror.action();
+
+  // eraseSource defaults to false — original kept and mirrored copy added
+  expect(mirror.eraseSource).toBe(false);
+  expect(core.scene.entities.count()).toBe(2);
+  expect(core.scene.entities.get(1).points[0].y).toBeCloseTo(-5);
+
+  core.scene.inputManager = origInputManager;
+});
+
+test('Mirror.execute - entity count unchanged when keeping source', async () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.addItem('Circle', { points: [new Point(0, 5), new Point(10, 5)] });
+
+  const entityCount = core.scene.entities.count();
+
+  for (let i = 0; i < entityCount; i++) {
+    core.scene.selectionManager.addToSelectionSet(i);
+  }
+
+  const origInputManager = core.scene.inputManager;
+  let callCount = 0;
+  const inputs = [new Point(0, 0), new Point(1, 0), 'No'];
+  core.scene.inputManager = {
+    requestInput: async () => {
+      if (callCount < inputs.length) {
+        return inputs[callCount++];
+      }
+    },
+    executeCommand: () => {},
+    reset: () => {},
+  };
+
+  const mirror = new Mirror();
+  await mirror.execute();
+  mirror.action();
+
+  expect(core.scene.entities.count()).toBe(entityCount * 2);
+
+  core.scene.inputManager = origInputManager;
+});
+
+test('Test Mirror.action - keep source (default)', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  // Add entities
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.addItem('Circle', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.addItem('Polyline', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.addItem('Arc', { points: [new Point(0, 5), new Point(10, 5), new Point(5, 10)] });
+  core.scene.addItem('Rectangle', { points: [new Point(0, 5), new Point(10, 5)] });
+
+  const entityCount = core.scene.entities.count();
+
+  // Select all
+  for (let i = 0; i < entityCount; i++) {
+    core.scene.selectionManager.addToSelectionSet(i);
+  }
+
+  const mirror = new Mirror();
+
+  // Mirror line along the X axis (y=0)
+  mirror.points.push(new Point(0, 0));
+  mirror.points.push(new Point(1, 0));
+  mirror.eraseSource = false;
+
+  mirror.action();
+
+  // Originals kept + mirrored copies added
+  expect(core.scene.entities.count()).toBe(entityCount * 2);
+
+  // Originals unchanged
+  for (let i = 0; i < entityCount; i++) {
+    expect(core.scene.entities.get(i).points[0].y).toBeCloseTo(5);
+  }
+
+  // Mirrored copies have y negated
+  for (let i = entityCount; i < core.scene.entities.count(); i++) {
+    expect(core.scene.entities.get(i).points[0].y).toBeCloseTo(-5);
+  }
+
+  // Mirrored copies have unique handles
+  for (let i = 0; i < entityCount; i++) {
+    const original = core.scene.entities.get(i);
+    const copy = core.scene.entities.get(i + entityCount);
+    expect(copy.handle).toBeDefined();
+    expect(copy.handle).not.toBe(original.handle);
+  }
+});
+
+test('Test Mirror.action - erase source', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.addItem('Circle', { points: [new Point(0, 5), new Point(10, 5)] });
+
+  const entityCount = core.scene.entities.count();
+
+  for (let i = 0; i < entityCount; i++) {
+    core.scene.selectionManager.addToSelectionSet(i);
+  }
+
+  const mirror = new Mirror();
+
+  // Mirror line along the X axis (y=0)
+  mirror.points.push(new Point(0, 0));
+  mirror.points.push(new Point(1, 0));
+  mirror.eraseSource = true;
+
+  mirror.action();
+
+  // No new entities — originals replaced in place
+  expect(core.scene.entities.count()).toBe(entityCount);
+
+  // All entities now have y negated
+  for (let i = 0; i < entityCount; i++) {
+    expect(core.scene.entities.get(i).points[0].y).toBeCloseTo(-5);
+  }
+});
+
+test('Test Mirror.action - mirror across Y axis', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(5, 0), new Point(5, 10)] });
+
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const mirror = new Mirror();
+
+  // Mirror line along the Y axis (x=0)
+  mirror.points.push(new Point(0, 0));
+  mirror.points.push(new Point(0, 1));
+  mirror.eraseSource = false;
+
+  mirror.action();
+
+  const mirrored = core.scene.entities.get(1);
+  expect(mirrored.points[0].x).toBeCloseTo(-5);
+  expect(mirrored.points[0].y).toBeCloseTo(0);
+});
+
+test('Test Mirror.action - arc direction is reversed', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  // CCW arc (direction = 1)
+  core.scene.addItem('Arc', { points: [new Point(0, 5), new Point(10, 5), new Point(5, 10)], direction: 1 });
+
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const mirror = new Mirror();
+
+  // Mirror across X axis
+  mirror.points.push(new Point(0, 0));
+  mirror.points.push(new Point(1, 0));
+  mirror.eraseSource = false;
+
+  mirror.action();
+
+  const original = core.scene.entities.get(0);
+  const mirrored = core.scene.entities.get(1);
+
+  expect(original.direction).toBe(1);
+  expect(mirrored.direction).toBe(-1);
+});
+
+test('Test Mirror.getMirroredPoints', () => {
+  const mirror = new Mirror();
+  const pt1 = new Point(0, 0);
+  const pt2 = new Point(1, 0);
+
+  // Mirror two points across X axis
+  const points = [new Point(3, 4), new Point(-2, 7)];
+  const result = mirror.getMirroredPoints(points, pt1, pt2);
+
+  expect(result[0].x).toBeCloseTo(3);
+  expect(result[0].y).toBeCloseTo(-4);
+  expect(result[1].x).toBeCloseTo(-2);
+  expect(result[1].y).toBeCloseTo(-7);
+});
+
+test('Mirror.action - zero-length mirror line does not modify entities', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const mirror = new Mirror();
+  mirror.points.push(new Point(3, 3)); // pt1 === pt2 — degenerate mirror line
+  mirror.points.push(new Point(3, 3));
+  mirror.eraseSource = false;
+
+  mirror.action();
+
+  // No new entity should have been added
+  expect(core.scene.entities.count()).toBe(1);
+  // Original entity is unchanged
+  expect(core.scene.entities.get(0).points[0].y).toBeCloseTo(5);
+});
+
+test('Mirror.execute - requests selection set when none pre-selected', async () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  // Intentionally do NOT add to selection set — triggers the SELECTIONSET prompt
+
+  const origInputManager = core.scene.inputManager;
+  let callCount = 0;
+  core.scene.inputManager = {
+    requestInput: async () => {
+      callCount++;
+      if (callCount === 1) {
+        // SELECTIONSET prompt: populate the selection manually and return
+        core.scene.selectionManager.addToSelectionSet(0);
+        return;
+      }
+      if (callCount === 2) return new Point(0, 0); // pt1
+      if (callCount === 3) return new Point(1, 0); // pt2
+      if (callCount === 4) return 'No'; // keep source
+    },
+    executeCommand: () => {},
+    reset: () => {},
+  };
+
+  const mirror = new Mirror();
+  await mirror.execute();
+  mirror.action();
+
+  expect(core.scene.entities.count()).toBe(2);
+  expect(core.scene.entities.get(1).points[0].y).toBeCloseTo(-5);
+
+  core.scene.inputManager = origInputManager;
+});
+
+test('Mirror.preview - no points set, adds no temp entities', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const mirror = new Mirror();
+  // No points pushed — guard condition should prevent any work
+  mirror.preview();
+
+  expect(core.scene.tempEntities.count()).toBe(0);
+});
+
+test('Mirror.preview - one point set, draws temp mirror line using mouse position', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const mirror = new Mirror();
+  mirror.points.push(new Point(3, 3)); // pt1 distinct from default mouse (0,0) scene position
+  mirror.preview();
+
+  // Temp mirror line should have been created
+  expect(core.scene.tempEntities.count()).toBeGreaterThanOrEqual(1);
+});
+
+test('Mirror.preview - two distinct points, draws mirror line and mirrors selected items', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const mirror = new Mirror();
+  mirror.points.push(new Point(0, 0)); // pt1
+  mirror.points.push(new Point(1, 0)); // pt2 — mirror across X axis
+  mirror.preview();
+
+  // Temp mirror line should exist
+  expect(core.scene.tempEntities.count()).toBeGreaterThanOrEqual(1);
+
+  // The selectedItems copy should have its points mirrored (y negated)
+  const previewItem = core.scene.selectionManager.selectedItems[0];
+  expect(previewItem.points[0].y).toBeCloseTo(-5);
+});
+
+test('Mirror.preview - identical points, draws line but skips mirroring selected items', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  core.scene.addItem('Line', { points: [new Point(0, 5), new Point(10, 5)] });
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const mirror = new Mirror();
+  mirror.points.push(new Point(5, 5)); // pt1
+  mirror.points.push(new Point(5, 5)); // pt2 — same as pt1, zero-length mirror line
+  mirror.preview();
+
+  // Temp line is still drawn
+  expect(core.scene.tempEntities.count()).toBeGreaterThanOrEqual(1);
+
+  // Selected item points should be unchanged (mirroring skipped)
+  const previewItem = core.scene.selectionManager.selectedItems[0];
+  expect(previewItem.points[0].y).toBeCloseTo(5);
+});
+
+test('Mirror.preview - reverses direction for entities with a direction property', () => {
+  core.scene.clear();
+  core.scene.selectionManager.reset();
+
+  // Arc with CCW direction
+  core.scene.addItem('Arc', { points: [new Point(0, 5), new Point(10, 5), new Point(5, 10)], direction: 1 });
+  core.scene.selectionManager.addToSelectionSet(0);
+
+  const mirror = new Mirror();
+  mirror.points.push(new Point(0, 0)); // pt1
+  mirror.points.push(new Point(1, 0)); // pt2 — mirror across X axis
+  mirror.preview();
+
+  // Original entity direction is unchanged
+  expect(core.scene.entities.get(0).direction).toBe(1);
+
+  // Preview copy has direction reversed
+  const previewItem = core.scene.selectionManager.selectedItems[0];
+  expect(previewItem.direction).toBe(-1);
+});