@design-core/core 0.0.1 → 0.0.3

package/test/lib/scene.test.js

@@ -1,27 +1,26 @@
-import {Core} from '../../core/core/core.js';
-import {Line} from '../../core/entities/line';
-import {Point} from '../../core/entities/point';
+import { Core } from '../../core/core/core.js';
+import { Line } from '../../core/entities/line';
+import { Point } from '../../core/entities/point';
 
 
 const core = new Core();
 const scene = core.scene;
 
-
 test('Test Scene.boundingBox', () => {
   // empty scene
   expect(scene.boundingBox()).toBeUndefined();
 
-  const line1 = new Line({points: [new Point(-102, -102), new Point(201, 202)]});
+  const line1 = new Line({ points: [new Point(-102, -102), new Point(201, 202)] });
   // add to scene (bypass scene.addItem())
-  scene.items.push(line1);
+  scene.addItem('Line', line1);
   expect(scene.boundingBox().xMin).toBeCloseTo(-102);
   expect(scene.boundingBox().xMax).toBeCloseTo(201);
   expect(scene.boundingBox().yMin).toBeCloseTo(-102);
   expect(scene.boundingBox().yMax).toBeCloseTo(202);
 
-  const line2 = new Line({points: [new Point(1001, -2002), new Point(-2001, 2002)]});
+  const line2 = new Line({ points: [new Point(1001, -2002), new Point(-2001, 2002)] });
   // add to scene (bypass scene.addItem())
-  scene.items.push(line2);
+  scene.addItem('Line', line2);
   expect(scene.boundingBox().xMin).toBeCloseTo(-2001);
   expect(scene.boundingBox().xMax).toBeCloseTo(1001);
   expect(scene.boundingBox().yMin).toBeCloseTo(-2002);
@@ -36,56 +35,21 @@ test('Test Scene.addItem', () => {
   }).toThrow();
 
   // Add a invalid item type
-  const itemCnt = scene.items.length;
+  const itemCnt = scene.entities.count();
   const returnIndex = scene.addItem('FakeItem', {});
-  expect(scene.items.length).toBe(itemCnt);
+  expect(scene.entities.count()).toBe(itemCnt);
   expect(returnIndex).toBeUndefined();
 
   // Add a valid item with data
-  const itemCount = scene.items.length;
-  const index = scene.addItem('Line', {points: [new Point(), new Point(10, 10)]});
-  expect(scene.items.length).toBe(itemCount + 1);
+  const itemCount = scene.entities.count();
+  const index = scene.addItem('Line', { points: [new Point(), new Point(10, 10)] });
+  expect(scene.entities.count()).toBe(itemCount + 1);
   expect(index).toBe(itemCount);
 
   // Add a valid item with data at index - item count should not increase
-  scene.addItem('Line', {points: [new Point(123, 123), new Point(321, 321)]}, index);
-  expect(scene.items.length).toBe(itemCount + 1);
+  scene.addItem('Line', { points: [new Point(123, 123), new Point(321, 321)] }, index);
+  expect(scene.entities.count()).toBe(itemCount + 1);
   // check the items points to make sure index was replaced
-  expect(scene.items[index].points[0].x).toBe(123);
-  expect(scene.items[index].points[1].x).toBe(321);
-});
-
-test('Test Scene.findItem', () => {
-  // Add a circle with a known radius
-  const index = scene.addItem('Circle', {points: [new Point(543, 543)], radius: 123});
-  // find the item
-  const foundItems = scene.findItem('Circle', 'radius', 123);
-  expect(foundItems[0]).toBe(index);
-  expect(scene.items[index].points[0].x).toBe(543);
-  expect(scene.items[index].radius).toBe(123);
-});
-
-test('Test Scene.getItem', () => {
-  // Add a valid item with data at index - item count should not increase
-  const index = 0;
-  scene.addItem('Line', {points: [new Point(1234, 1234), new Point(4321, 4321)]}, index);
-  // check the items points to make sure index was replaced
-  expect(scene.getItem(index).points[0].x).toBe(1234);
-  expect(scene.getItem(index).points[1].x).toBe(4321);
-});
-
-
-test('Test Scene.removeItem', () => {
-  // Remove an existing index
-  const itemCount = scene.items.length;
-  const index = 0;
-  const removed = scene.removeItem(index);
-  expect(removed).toBe(true);
-  expect(scene.items.length).toBe(itemCount - 1);
-
-  // Remove a non-existing index
-  const itemCount2 = scene.items.length;
-  const notRemoved = scene.removeItem(100);
-  expect(notRemoved).toBe(false);
-  expect(scene.items.length).toBe(itemCount2);
+  expect(scene.entities.get(index).points[0].x).toBe(123);
+  expect(scene.entities.get(index).points[1].x).toBe(321);
 });

package/test/lib/selectionManager.test.js

@@ -1,13 +1,13 @@
-import {Core} from '../../core/core/core.js';
-import {Point} from '../../core/entities/point.js';
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
 
 const core = new Core();
 const selectionManager = core.scene.selectionManager;
 
 // Add a valid item to scene
-core.scene.addItem('Line', {points: [new Point(10, 10), new Point(100, 10)]});
-core.scene.addItem('Line', {points: [new Point(10, 20), new Point(100, 20)]});
-core.scene.addItem('Circle', {points: [new Point(), new Point(5, 0)]});
+core.scene.addItem('Line', { points: [new Point(10, 10), new Point(100, 10)] });
+core.scene.addItem('Line', { points: [new Point(10, 20), new Point(100, 20)] });
+core.scene.addItem('Circle', { points: [new Point(), new Point(5, 0)] });
 
 
 test('Test SelectionManager.findClosestItem', () => {
@@ -59,3 +59,15 @@ test('Test SelectionManager.reset()', () => {
   expect(selectionManager.selectionSet.selectionSet.length).toBe(0);
 });
 
+test('Test SelectionManager.selectAll()', () => {
+  // Start with some selections
+  selectionManager.reset();
+  expect(selectionManager.selectionSet.selectionSet.length).toBe(0);
+
+  // Select all
+  selectionManager.selectAll();
+  expect(selectionManager.selectionSet.selectionSet.length).toBe(core.scene.entities.count());
+  // The indices should match all scene items
+  expect(selectionManager.selectionSet.selectionSet).toEqual([0, 1, 2]);
+});
+

package/test/lib/settings.test.js

@@ -1,4 +1,4 @@
-import {Core} from '../../core/core/core.js';
+import { Core } from '../../core/core/core.js';
 
 const core = new Core();
 const settings = core.settings;
@@ -8,12 +8,118 @@ test('Test Settings.setSetting', () => {
   settings.setSetting('endsnap', false);
   expect(settings.endsnap).toBe(false);
 
-  expect(settings.canvasbackgroundcolour).toBe('#1e1e1e');
-  settings.setSetting('canvasbackgroundcolour', '#000000');
-  expect(settings.canvasbackgroundcolour).toBe('#000000');
+  expect(settings.canvasbackgroundcolour).toEqual({ 'r': 30, 'g': 30, 'b': 30 });
+  settings.setSetting('canvasbackgroundcolour', { 'r': 130, 'g': 130, 'b': 130 });
+  expect(settings.canvasbackgroundcolour).toEqual({ 'r': 130, 'g': 130, 'b': 130 });
 });
 
 test('Test Settings.getSetting', () => {
   expect(settings.getSetting('endsnap')).toBe(false);
-  expect(settings.getSetting('canvasbackgroundcolour')).toBe('#000000');
+  expect(settings.getSetting('canvasbackgroundcolour')).toEqual({ 'r': 130, 'g': 130, 'b': 130 });
+});
+
+test('polar and ortho are mutually exclusive', () => {
+  settings.setSetting('polar', false);
+  settings.setSetting('ortho', false);
+
+  settings.setSetting('polar', true);
+  expect(settings.polar).toBe(true);
+  expect(settings.ortho).toBe(false);
+
+  settings.setSetting('ortho', true);
+  expect(settings.ortho).toBe(true);
+  expect(settings.polar).toBe(false);
+
+  settings.setSetting('ortho', false);
+  expect(settings.ortho).toBe(false);
+  expect(settings.polar).toBe(false);
+});
+
+// ─── constructor defaults ─────────────────────────────────────────────────────
+
+test('Settings constructor - colour defaults', () => {
+  const fresh = new (settings.constructor)();
+  expect(fresh.canvasbackgroundcolour).toEqual({ r: 30, g: 30, b: 30 });
+  expect(fresh.selecteditemscolour).toEqual({ r: 0, g: 255, b: 0 });
+  expect(fresh.snapcolour).toEqual({ r: 255, g: 0, b: 0 });
+  expect(fresh.gridcolour).toEqual({ r: 119, g: 118, b: 123 });
+  expect(fresh.helpergeometrycolour).toEqual({ r: 0, g: 195, b: 255 });
+  expect(fresh.polarsnapcolour).toEqual({ r: 55, g: 180, b: 75 });
+  expect(fresh.selectionWindow).toEqual({ r: 0, g: 255, b: 0 });
+  expect(fresh.crossingWindow).toEqual({ r: 0, g: 0, b: 255 });
+});
+
+test('Settings constructor - font defaults', () => {
+  expect(settings.font).toBe('Arial');
+  expect(settings.fontupsidedown).toBe(false);
+  expect(settings.fontbackwards).toBe(false);
+});
+
+test('Settings constructor - snap defaults', () => {
+  expect(settings.endsnap).toBeDefined();
+  expect(settings.midsnap).toBe(true);
+  expect(settings.centresnap).toBe(true);
+  expect(settings.nearestsnap).toBe(false);
+  expect(settings.quadrantsnap).toBe(false);
+});
+
+test('Settings constructor - polar/ortho/grid defaults', () => {
+  // restore to known state after previous tests may have modified them
+  const fresh = new (settings.constructor)();
+  expect(fresh.polar).toBe(true);
+  expect(fresh.ortho).toBe(false);
+  expect(fresh.polarangle).toBe(45);
+  expect(fresh.drawgrid).toBe(true);
+});
+
+// ─── setSetting ───────────────────────────────────────────────────────────────
+
+test('setSetting with false value does not trigger polar/ortho exclusion', () => {
+  settings.setSetting('polar', true);
+  settings.setSetting('ortho', false);
+  // setting polar to false should not flip ortho
+  settings.setSetting('polar', false);
+  expect(settings.polar).toBe(false);
+  expect(settings.ortho).toBe(false);
+});
+
+test('setSetting updates arbitrary colour settings', () => {
+  settings.setSetting('polarsnapcolour', { r: 1, g: 2, b: 3 });
+  expect(settings.polarsnapcolour).toEqual({ r: 1, g: 2, b: 3 });
+  settings.setSetting('polarsnapcolour', { r: 55, g: 180, b: 75 });
+});
+
+test('setSetting updates polarangle', () => {
+  settings.setSetting('polarangle', 90);
+  expect(settings.polarangle).toBe(90);
+  settings.setSetting('polarangle', 45);
+});
+
+test('setSetting updates font settings', () => {
+  settings.setSetting('font', 'Courier');
+  expect(settings.font).toBe('Courier');
+  settings.setSetting('fontupsidedown', true);
+  expect(settings.fontupsidedown).toBe(true);
+  settings.setSetting('fontbackwards', true);
+  expect(settings.fontbackwards).toBe(true);
+  // restore
+  settings.setSetting('font', 'Arial');
+  settings.setSetting('fontupsidedown', false);
+  settings.setSetting('fontbackwards', false);
+});
+
+// ─── getSetting ───────────────────────────────────────────────────────────────
+
+test('getSetting returns current value after setSetting', () => {
+  settings.setSetting('drawgrid', false);
+  expect(settings.getSetting('drawgrid')).toBe(false);
+  settings.setSetting('drawgrid', true);
+  expect(settings.getSetting('drawgrid')).toBe(true);
+});
+
+test('getSetting returns correct type for colour objects', () => {
+  const colour = settings.getSetting('snapcolour');
+  expect(colour).toHaveProperty('r');
+  expect(colour).toHaveProperty('g');
+  expect(colour).toHaveProperty('b');
 });

package/test/lib/snapping.test.js

@@ -1,12 +1,22 @@
-import {Core} from '../../core/core/core.js';
-import {Snapping} from '../../core/lib/snapping.js';
-import {Point} from '../../core/entities/point.js';
+import { jest } from '@jest/globals';
+import { Core } from '../../core/core/core.js';
+import { Snapping } from '../../core/lib/snapping.js';
+import { Point } from '../../core/entities/point.js';
+import { DesignCore } from '../../core/designCore.js';
 
 const core = new Core();
 const snapping = new Snapping();
 
 // Add a valid item to scene
-core.scene.addItem('Line', {points: [new Point(10, 10), new Point(100, 10)]});
+core.scene.addItem('Line', { points: [new Point(10, 10), new Point(100, 10)] });
+
+afterEach(() => {
+  // Reset all mouse button states so tests don't affect each other via
+  // Canvas.mouseMoved() / InputManager.mouseMoved() behaviour
+  core.mouse.buttonOneDown = false;
+  core.mouse.buttonTwoDown = false;
+  core.mouse.buttonThreeDown = false;
+});
 
 
 test('Test Snapping.getSnapPoint', () => {
@@ -31,6 +41,98 @@ test('Test Snapping.getSnapPoint', () => {
   expect(snapping.getSnapPoint()).toBeUndefined();
 });
 
+test('Test Snapping.snap active', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  snapping.active = true;
+  // mouse near (10, 10) endpoint of the line
+  core.mouse.mouseMoved(8, 8);
+  const result = snapping.snap();
+  expect(result).toBeDefined();
+  expect(result.x).toBe(10);
+  expect(result.y).toBe(10);
+  expect(DesignCore.Scene.auxiliaryEntities.count()).toBeGreaterThan(0);
+});
+
+test('Test Snapping.snap inactive', () => {
+  snapping.active = false;
+  core.mouse.mouseMoved(8, 8);
+  expect(snapping.snap()).toBeUndefined();
+});
+
+test('Test Snapping.addSnapPoint', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  snapping.addSnapPoint(new Point(10, 10));
+  expect(DesignCore.Scene.auxiliaryEntities.count()).toBe(1);
+});
+
+test('Test SnapPoint.draw', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  snapping.addSnapPoint(new Point(0.5, 0.5));
+  const snapPointEntity = DesignCore.Scene.auxiliaryEntities.get(0);
+  const ctx = {
+    fillStyle: '',
+    beginPath: jest.fn(),
+    arc: jest.fn(),
+    fill: jest.fn(),
+  };
+  snapPointEntity.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.arc).toHaveBeenCalledWith(0.5, 0.5, expect.any(Number), 0, 6.283);
+  expect(ctx.fill).toHaveBeenCalled();
+});
+
+test('Test Snapping.addTrackingLine', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  snapping.addTrackingLine(new Point(0.2, 0.5), new Point(0.8, 0.5));
+  expect(DesignCore.Scene.auxiliaryEntities.count()).toBe(1);
+});
+
+test('Test TrackingLine.draw', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  // horizontal tracking line within the default scene bounds ([0,1] x [-1,0])
+  // note: the default matrix has d=-1, so scene y is in [-1, 0] for a 1x1 canvas
+  snapping.addTrackingLine(new Point(0.2, -0.5), new Point(0.8, -0.5));
+  const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
+  const ctx = {
+    save: jest.fn(),
+    restore: jest.fn(),
+    beginPath: jest.fn(),
+    strokeStyle: '',
+    lineWidth: 0,
+    setLineDash: jest.fn(),
+    moveTo: jest.fn(),
+    lineTo: jest.fn(),
+    stroke: jest.fn(),
+  };
+  trackingLine.draw(ctx, 1);
+  expect(ctx.save).toHaveBeenCalled();
+  expect(ctx.moveTo).toHaveBeenCalled();
+  expect(ctx.lineTo).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.restore).toHaveBeenCalled();
+});
+
+test('Test TrackingLine.draw degenerate zero direction', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  // inputPoint equals snapPoint → direction is zero vector → draw returns early
+  snapping.addTrackingLine(new Point(0.5, 0.5), new Point(0.5, 0.5));
+  const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
+  const ctx = {
+    save: jest.fn(),
+    restore: jest.fn(),
+    beginPath: jest.fn(),
+    strokeStyle: '',
+    lineWidth: 0,
+    setLineDash: jest.fn(),
+    moveTo: jest.fn(),
+    lineTo: jest.fn(),
+    stroke: jest.fn(),
+  };
+  trackingLine.draw(ctx, 1);
+  expect(ctx.moveTo).not.toHaveBeenCalled();
+  expect(ctx.stroke).not.toHaveBeenCalled();
+});
+
 test('Test Snapping.polarSnap', () => {
   // set the mouse position
   // note mouseMoved flips the y axis
@@ -52,6 +154,42 @@ test('Test Snapping.polarSnap', () => {
   // expect(polarSnapOne.y).toBeCloseTo(100);
 });
 
+test('Test Snapping.polarSnap within tolerance', () => {
+  snapping.active = true;
+  // Mouse at (100, 2) from previous (0, 0): angle ≈ 1.15° which is within 4° tolerance of 0°
+  core.mouse.mouseMoved(100, 2);
+  const snapPoint = snapping.polarSnap(new Point(0, 0));
+  expect(snapPoint).toBeDefined();
+  // Snapped to 0° direction → y should be approximately 0
+  expect(snapPoint.y).toBeCloseTo(0, 0);
+});
+
+test('Test Snapping.polarSnap inactive', () => {
+  snapping.active = false;
+  core.mouse.mouseMoved(100, 2);
+  expect(snapping.polarSnap(new Point(0, 0))).toBeUndefined();
+});
+
 test('Test Snapping.orthoSnap', () => {
+  snapping.active = true;
+
+  // Mouse far right of previous: x delta dominates → y locked to previous y
+  // note: mouseMoved(x, -y) maps to scene (x, y) due to y-axis flip in the matrix
+  core.mouse.mouseMoved(100, -20); // scene (100, 20), previous (0, 0): |dx|=100 > |dy|=20
+  const snapPointX = snapping.orthoSnap(new Point(0, 0));
+  expect(snapPointX).toBeDefined();
+  expect(snapPointX.x).toBeCloseTo(100);
+  expect(snapPointX.y).toBeCloseTo(0);
+
+  // Mouse far above previous: y delta dominates → x locked to previous x
+  core.mouse.mouseMoved(20, -100); // scene (20, 100), previous (0, 0): |dx|=20 < |dy|=100
+  const snapPointY = snapping.orthoSnap(new Point(0, 0));
+  expect(snapPointY).toBeDefined();
+  expect(snapPointY.x).toBeCloseTo(0);
+  expect(snapPointY.y).toBeCloseTo(100);
 
+  // Inactive: returns undefined
+  snapping.active = false;
+  core.mouse.mouseMoved(100, -20);
+  expect(snapping.orthoSnap(new Point(0, 0))).toBeUndefined();
 });

package/test/lib/stateManager.test.js

@@ -0,0 +1,155 @@
+import { Core } from '../../core/core/core.js';
+import { StateManager } from '../../core/lib/stateManager.js';
+import { EntityManager } from '../../core/lib/entityManager.js';
+import { AddState, RemoveState, UpdateState } from '../../core/lib/stateManager.js';
+import { Line } from '../../core/entities/line.js';
+import { Point } from '../../core/entities/point.js';
+import { jest } from '@jest/globals';
+
+new Core();
+
+describe('StateManager', () => {
+  let sm;
+
+  beforeEach(() => {
+    sm = new StateManager();
+  });
+
+  test('limitHistory only allows max history states', () => {
+    const em = new EntityManager();
+    for (let i = 0; i < 20; i++) {
+      sm.commit(em, [new AddState({ id: `e${i}` })]);
+      expect(sm.getHistoryLength()).toBeLessThanOrEqual(10);
+    }
+  });
+
+  test('add() creates an AddState, performs do, undo and redo', () => {
+    const em = new EntityManager();
+    const entity = { id: 'e1' };
+    sm.commit(em, [new AddState(entity)]);
+    expect(em.count()).toBe(1);
+    expect(sm.getHistoryLength()).toBe(1);
+    sm.undo();
+    expect(em.count()).toBe(0);
+    expect(sm.getHistoryLength()).toBe(1);
+    sm.redo();
+    expect(em.count()).toBe(1);
+  });
+
+  test('remove() creates a RemoveState, performs do, undo and redo', () => {
+    const em = new EntityManager();
+    const entity = { id: 'e2' };
+    sm.commit(em, [new AddState(entity)]);
+    expect(em.count()).toBe(1);
+    sm.commit(em, [new RemoveState(entity)]);
+    expect(em.count()).toBe(0);
+    sm.undo();
+    expect(em.count()).toBe(1);
+    sm.redo();
+    expect(em.count()).toBe(0);
+  });
+
+  test('update() creates UpdateState and undo restores previous properties', () => {
+    const em = new EntityManager();
+    // seed entities
+    for (let i = 0; i < 5; i++) {
+      const line = new Line({ layer: 'testLayer', points: [new Point(i, i), new Point(10, 11)] });
+      sm.commit(em, [new AddState(line)]);
+    }
+    const target = em.get(2);
+    sm.commit(em, [new UpdateState(target, { layer: 'newLayer' })]);
+    expect(em.get(2).layer).toBe('newLayer');
+    sm.undo();
+    expect(em.get(2).layer).toBe('testLayer');
+    sm.redo();
+    expect(em.get(2).layer).toBe('newLayer');
+  });
+
+  test('addState removed future states', () => {
+    const em = new EntityManager();
+    const line = new Line({ layer: 'testLayer', points: [new Point(), new Point(10, 11)] });
+    sm.commit(em, [new AddState(line)]);
+    expect(em.get(0).layer).toBe('testLayer');
+    sm.commit(em, [new UpdateState(line, { layer: 'differentLayer', points: [new Point(1, 2), new Point(101, 110)] })]);
+    expect(em.get(0).layer).toBe('differentLayer');
+    sm.undo();
+    expect(em.get(0).layer).toBe('testLayer');
+    sm.redo();
+    expect(em.get(0).layer).toBe('differentLayer');
+  });
+
+  test('clearHistory resets history and indices', () => {
+    const em = new EntityManager();
+    sm.commit(em, [new AddState({ id: 'a' })]);
+    expect(sm.getHistoryLength()).toBe(1);
+    sm.clearHistory();
+    expect(sm.getHistoryLength()).toBe(0);
+    expect(sm.canUndo()).toBe(false);
+    expect(sm.canRedo()).toBe(false);
+  });
+
+  test('canUndo and canRedo basic lifecycle', () => {
+    const em = new EntityManager();
+    expect(sm.canUndo()).toBe(false);
+    expect(sm.canRedo()).toBe(false);
+    sm.commit(em, [new AddState({ id: 'first' })]);
+    expect(sm.canUndo()).toBe(true);
+    expect(sm.canRedo()).toBe(false);
+    sm.undo();
+    expect(sm.canUndo()).toBe(false);
+    expect(sm.canRedo()).toBe(true);
+    sm.redo();
+    expect(sm.canUndo()).toBe(true);
+    expect(sm.canRedo()).toBe(false);
+  });
+
+  test('canRedo cleared after new commit following undo', () => {
+    const em = new EntityManager();
+    sm.commit(em, [new AddState({ id: 'A' })]);
+    sm.commit(em, [new AddState({ id: 'B' })]);
+    expect(sm.canUndo()).toBe(true);
+    expect(sm.canRedo()).toBe(false);
+    sm.undo();
+    expect(sm.canRedo()).toBe(true);
+    sm.commit(em, [new AddState({ id: 'C' })]);
+    expect(sm.canRedo()).toBe(false);
+  });
+
+  test('isModified getter reflects internal flag and stateChanged invokes callback and respects parameter', () => {
+    // initial state should be not modified
+    expect(sm.isModified).toBe(false);
+
+    const cb = jest.fn();
+    sm.setStateCallbackFunction(cb);
+
+    // calling stateChanged with default should set modified to true and call callback
+    sm.stateChanged();
+    expect(sm.isModified).toBe(true);
+    expect(cb).toHaveBeenCalledTimes(1);
+
+    // calling stateChanged(false) should clear modified flag and call callback
+    sm.stateChanged(false);
+    expect(sm.isModified).toBe(false);
+    expect(cb).toHaveBeenCalledTimes(2);
+  });
+
+  test('stateChanged is invoked after commit/undo/redo', () => {
+    const em = new EntityManager();
+    const cb = jest.fn();
+    sm.setStateCallbackFunction(cb);
+
+    // commit should call stateChanged once
+    sm.commit(em, [new AddState({ id: 'x' })]);
+    expect(cb).toHaveBeenCalledTimes(1);
+    expect(sm.isModified).toBe(true);
+
+    // undo should call stateChanged again
+    sm.undo();
+    expect(cb).toHaveBeenCalledTimes(2);
+
+    // redo should call stateChanged again
+    sm.redo();
+    expect(cb).toHaveBeenCalledTimes(3);
+  });
+});
+

package/test/lib/utils.test.js

@@ -1,4 +1,6 @@
-import {Utils} from '../../core/lib/utils.js';
+import { Arc } from '../../core/entities/arc.js';
+import { Utils } from '../../core/lib/utils.js';
+import { Point } from '../../core/entities/point.js';
 
 test('Test Utils.degrees2radians', () => {
   // Positive
@@ -6,6 +8,8 @@ test('Test Utils.degrees2radians', () => {
   expect(Utils.degrees2radians(45)).toBe(Math.PI/4);
   expect(Utils.degrees2radians(90)).toBe(Math.PI/2);
   expect(Utils.degrees2radians(180)).toBe(Math.PI);
+  expect(Utils.degrees2radians(270)).toBe(Math.PI * 1.5);
+  expect(Utils.degrees2radians(360)).toBe(Math.PI * 2);
 
   // Negative
   expect(Utils.degrees2radians(-22.5)).toBe(-Math.PI/8);
@@ -34,3 +38,79 @@ test('Test Utils.getLevenshteinDistance', () => {
   expect(Utils.getLevenshteinDistance('design', 'resign')).toBe(1);
   expect(Utils.getLevenshteinDistance('design', 'sign')).toBe(2);
 });
+
+test('Test Utils.sortPointsByDistance mutates array ordered by distance', () => {
+  const ref = { x: 0, y: 0 };
+  const pts = [
+    { x: 3, y: 4 }, // dist^2 = 25
+    { x: 1, y: 1 }, // dist^2 = 2
+    { x: -2, y: 0 }, // dist^2 = 4
+    { x: 0, y: 5 }, // dist^2 = 25
+  ];
+  Utils.sortPointsByDistance(pts, ref);
+  // Expect ascending order: (1,1) ( -2,0 ) then the two distance=25 points (order between them not critical)
+  expect(pts[0].x).toBe(1);
+  expect(pts[0].y).toBe(1);
+  expect(pts[1].x).toBe(-2);
+  expect(pts[1].y).toBe(0);
+  const lastTwo = pts.slice(2).map((p) => `${p.x},${p.y}`);
+  expect(lastTwo.sort()).toEqual(['0,5', '3,4']);
+});
+
+test('Test Utils.sortPointsByDistance with empty array does nothing', () => {
+  const ref = { x: 5, y: 5 };
+  const pts = [];
+  Utils.sortPointsByDistance(pts, ref);
+  expect(pts).toEqual([]);
+});
+
+test('Test Utils.sortPointsOnArc mutates array ordered by angular position', () => {
+  const pts = [
+    new Point(7.1, 7.1), // 45 degree
+    new Point(10, 0), // end
+    new Point(-10, 0), // start
+    new Point(-7.1, 7.1), // 45 degree
+    new Point(10, 10), // mid
+  ];
+
+  const arc = new Arc({ points: [new Point(0, 0), new Point(10, 0), new Point(-10, 0)], direction: 1 });
+  Utils.sortPointsOnArc(pts, arc.points[1], arc.points[2], arc.points[0], arc.direction);
+  // Expect order: (10,0), (7.1, 7.1), (10,10), (-7.1, 7.1), (-10,0)
+  expect(pts[0].x).toBe(10);
+  expect(pts[0].y).toBe(0);
+
+  expect(pts[1].x).toBe(7.1);
+  expect(pts[1].y).toBe(7.1);
+
+  expect(pts[2].x).toBe(10);
+  expect(pts[2].y).toBe(10);
+
+  expect(pts[3].x).toBe(-7.1);
+  expect(pts[3].y).toBe(7.1);
+
+  expect(pts[4].x).toBe(-10);
+  expect(pts[4].y).toBe(0);
+
+  const cwArc = new Arc({ points: [new Point(0, 0), new Point(-10, 0), new Point(10, 0)], direction: -1 });
+  Utils.sortPointsOnArc(pts, cwArc.points[1], cwArc.points[2], cwArc.points[0], cwArc.direction);
+  // Expect order: (-10,0), (-7.1, 7.1), (10,10), (7.1, 7.1), (10,0)
+  expect(pts[0].x).toBe(-10);
+  expect(pts[0].y).toBe(0);
+
+  expect(pts[1].x).toBe(-7.1);
+  expect(pts[1].y).toBe(7.1);
+
+  expect(pts[2].x).toBe(10);
+  expect(pts[2].y).toBe(10);
+
+  expect(pts[3].x).toBe(7.1);
+  expect(pts[3].y).toBe(7.1);
+
+  expect(pts[4].x).toBe(10);
+  expect(pts[4].y).toBe(0);
+});
+
+test('Test Utils.areaOfTriangle', () => {
+  expect(Utils.areaOfTriangle(new Point(0, 0), new Point(10, 0), new Point(0, 10))).toBe(50);
+  expect(Utils.areaOfTriangle(new Point(-5, -5), new Point(5, -5), new Point(0, 5))).toBe(50);
+});