@design-core/core 0.0.4 → 0.0.6

package/test/entities/basePolyline.test.js

@@ -626,3 +626,64 @@ test('BasePolyline.fromPolylinePoints round-trip strips closure point for closed
   expect(rebuilt.points[3].x).toBe(0);
   expect(rebuilt.points[3].y).toBe(10);
 });
+
+// ─── closestPoint: closed polyline closing segment ───────────────────────────
+
+test('BasePolyline.closestPoint finds closest point on closing segment of closed polyline', () => {
+  // Square: P0=(0,0), P1=(10,0), P2=(10,10), P3=(0,10), closed flag set.
+  // Closing segment is P3=(0,10) → P0=(0,0).
+  // A test point on the left edge (0, 5) must resolve to (0, 5) on the closing segment.
+  const points = [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)];
+  const poly = new BasePolyline({ points });
+  poly.flags.setFlagValue(1);
+
+  const [closest, dist] = poly.closestPoint(new Point(0, 5));
+  expect(closest.x).toBeCloseTo(0);
+  expect(closest.y).toBeCloseTo(5);
+  expect(dist).toBeCloseTo(0);
+});
+
+test('BasePolyline.closestPoint closing segment is preferred over other segments', () => {
+  // The test point (-1, 5) is clearly nearest the closing segment (left edge),
+  // not the bottom, right, or top edges.
+  const points = [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)];
+  const poly = new BasePolyline({ points });
+  poly.flags.setFlagValue(1);
+
+  const [closest, dist] = poly.closestPoint(new Point(-1, 5));
+  expect(closest.x).toBeCloseTo(0);
+  expect(closest.y).toBeCloseTo(5);
+  expect(dist).toBeCloseTo(1);
+});
+
+test('BasePolyline.closestPoint for open polyline does not include closing segment', () => {
+  // For point (-1, 1) on the open square:
+  //   – Nearest on seg P0→P1 (y=0): foot (-1,0) clips to (0,0), dist = √2 ≈ 1.41
+  //   – Nearest on seg P2→P3 (y=10): foot (-1,10) clips to (0,10), dist ≈ 9.06
+  //   – If the closing segment existed (x=0, y∈[0,10]): foot (0,1), dist = 1  ← closer!
+  // An open polyline must NOT check the closing segment, so it returns (0,0).
+  const points = [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)];
+  const poly = new BasePolyline({ points });
+  // flag NOT set — open polyline
+
+  const [closest] = poly.closestPoint(new Point(-1, 1));
+  expect(closest.x).toBeCloseTo(0);
+  expect(closest.y).toBeCloseTo(0);
+});
+
+test('BasePolyline.closestPoint is consistent with getClosestSegmentIndex for closed polyline', () => {
+  // For a closed square, both methods should agree that the closing segment
+  // is nearest for a point on the left edge.
+  const points = [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)];
+  const poly = new BasePolyline({ points });
+  poly.flags.setFlagValue(1);
+
+  const testPoint = new Point(-2, 5);
+  const [closest] = poly.closestPoint(testPoint);
+  const segIdx = poly.getClosestSegmentIndex(testPoint);
+
+  // Closing segment index == points.length == 4
+  expect(segIdx).toBe(points.length);
+  expect(closest.x).toBeCloseTo(0);
+  expect(closest.y).toBeCloseTo(5);
+});

package/test/entities/circle.test.js

@@ -292,45 +292,35 @@ test('Circle.draw does not throw', () => {
 
 test('Circle.snaps returns centre snap', () => {
   const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
-  DesignCore.Settings.centresnap = true;
-  DesignCore.Settings.quadrantsnap = false;
-  DesignCore.Settings.nearestsnap = false;
   const snaps = circle.snaps(new Point(5, 0), 100);
-  expect(snaps).toHaveLength(1);
-  expect(snaps[0].x).toBe(0);
-  expect(snaps[0].y).toBe(0);
+  const centreSnaps = snaps.filter((s) => s.type === 'centre');
+  expect(centreSnaps).toHaveLength(1);
+  expect(centreSnaps[0].snapPoint.x).toBe(0);
+  expect(centreSnaps[0].snapPoint.y).toBe(0);
 });
 
 test('Circle.snaps returns four quadrant snaps', () => {
   const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
-  DesignCore.Settings.centresnap = false;
-  DesignCore.Settings.quadrantsnap = true;
-  DesignCore.Settings.nearestsnap = false;
   const snaps = circle.snaps(new Point(5, 0), 100);
-  expect(snaps).toHaveLength(4);
-  expect(snaps.some((p) => p.x === 10 && p.y === 0)).toBe(true);// 0°
-  expect(snaps.some((p) => p.x === 0 && p.y === 10)).toBe(true);// 90°
-  expect(snaps.some((p) => p.x === -10 && p.y === 0)).toBe(true);// 180°
-  expect(snaps.some((p) => p.x === 0 && p.y === -10)).toBe(true);// 270°
+  const quadrantSnaps = snaps.filter((s) => s.type === 'quadrant');
+  expect(quadrantSnaps).toHaveLength(4);
+  expect(quadrantSnaps.some((p) => p.snapPoint.x === 10 && p.snapPoint.y === 0)).toBe(true);// 0°
+  expect(quadrantSnaps.some((p) => p.snapPoint.x === 0 && p.snapPoint.y === 10)).toBe(true);// 90°
+  expect(quadrantSnaps.some((p) => p.snapPoint.x === -10 && p.snapPoint.y === 0)).toBe(true);// 180°
+  expect(quadrantSnaps.some((p) => p.snapPoint.x === 0 && p.snapPoint.y === -10)).toBe(true);// 270°
 });
 
 test('Circle.snaps nearest snap fires when close enough', () => {
   const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
-  DesignCore.Settings.centresnap = false;
-  DesignCore.Settings.quadrantsnap = false;
-  DesignCore.Settings.nearestsnap = true;
   // Mouse on the circle surface with large delta
   const snaps = circle.snaps(new Point(10, 0), 1000);
-  expect(snaps.length).toBeGreaterThanOrEqual(1);
+  expect(snaps.filter((s) => s.type === 'nearest').length).toBeGreaterThanOrEqual(1);
 });
 
 test('Circle.snaps nearest snap does not fire when too far', () => {
   const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
-  DesignCore.Settings.centresnap = false;
-  DesignCore.Settings.quadrantsnap = false;
-  DesignCore.Settings.nearestsnap = true;
   const snaps = circle.snaps(new Point(100, 100), 1);
-  expect(snaps.length).toBe(0);
+  expect(snaps.filter((s) => s.type === 'nearest').length).toBe(0);
 });
 
 test('Circle.fromPolylinePoints round-trip preserves centre and radius', () => {
@@ -352,3 +342,39 @@ test('Circle.fromPolylinePoints precision drift is negligible', () => {
   expect(drift).toBeLessThan(1e-10);
   expect(Math.abs(rebuilt.radius - circle.radius)).toBeLessThan(1e-10);
 });
+
+test('Circle.snaps returns two tangent snaps from outside', () => {
+  const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
+  const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;
+  // fromPoint=(20,0): distanceToCenter=20 > radius=10
+  // tangentHalfAngle = acos(10/20) = π/3; both tangent points at (5, ±8.66) are on the full circle
+  DesignCore.Scene.inputManager.inputPoint = new Point(20, 0);
+  const snaps = circle.snaps(new Point(5, 0), 100);
+  const tangentSnaps = snaps.filter((s) => s.type === 'tangent');
+  expect(tangentSnaps.length).toBe(2);
+  expect(tangentSnaps.some((s) => s.snapPoint.x > 4.9 && s.snapPoint.y > 8.5)).toBe(true);
+  expect(tangentSnaps.some((s) => s.snapPoint.x > 4.9 && s.snapPoint.y < -8.5)).toBe(true);
+  DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
+});
+
+test('Circle.snaps returns no tangent when fromPoint is inside the circle', () => {
+  const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
+  const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;
+  DesignCore.Scene.inputManager.inputPoint = new Point(1, 1); // distanceToCenter ≈ 1.41 < radius 10
+  const snaps = circle.snaps(new Point(5, 0), 100);
+  expect(snaps.filter((s) => s.type === 'tangent').length).toBe(0);
+  DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
+});
+
+test('Circle.snaps returns perpendicular snap from outside', () => {
+  const circle = new Circle({ points: [new Point(0, 0), new Point(10, 0)] });
+  const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;
+  // fromPoint=(20,0): angleFromCentreToInput=0; perpendicularPoint=(10,0)
+  DesignCore.Scene.inputManager.inputPoint = new Point(20, 0);
+  const snaps = circle.snaps(new Point(5, 0), 100);
+  const perpSnaps = snaps.filter((s) => s.type === 'perpendicular');
+  expect(perpSnaps.length).toBe(1);
+  expect(perpSnaps[0].snapPoint.x).toBeCloseTo(10);
+  expect(perpSnaps[0].snapPoint.y).toBeCloseTo(0);
+  DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
+});

package/test/entities/insert.test.js

@@ -19,13 +19,15 @@ rotatedInsert.block.addItem(line);
 test('Test Insert.snaps', () => {
   const point = new Point(100, 100);
   const snaps = insert.snaps(point, 1);
-  expect(snaps[0].x).toBeCloseTo(101);
-  expect(snaps[0].y).toBeCloseTo(102);
+  const endSnaps = snaps.filter((s) => s.type === 'end');
+  expect(endSnaps[0].snapPoint.x).toBeCloseTo(101);
+  expect(endSnaps[0].snapPoint.y).toBeCloseTo(102);
 
   // Test snaps for a rotated block
   const rotatedSnaps = rotatedInsert.snaps(point);
-  expect(rotatedSnaps[0].x).toBeCloseTo(-0.7071);
-  expect(rotatedSnaps[0].y).toBeCloseTo(143.5426);
+  const rotatedEndSnaps = rotatedSnaps.filter((s) => s.type === 'end');
+  expect(rotatedEndSnaps[0].snapPoint.x).toBeCloseTo(-0.7071);
+  expect(rotatedEndSnaps[0].snapPoint.y).toBeCloseTo(143.5426);
 });
 
 test('Test Insert.closestPoint', () => {
@@ -88,3 +90,11 @@ AcDbBlockReference
   newInsert.dxf(file);
   expect(file.contents).toEqual(dxfString);
 });
+
+test('Insert.snaps returns a node snap at points[0]', () => {
+  const nodeInsert = new Insert({ points: [new Point(5, 10)] });
+  const nodeSnaps = nodeInsert.snaps(new Point(0, 0), 100).filter((s) => s.type === 'node');
+  expect(nodeSnaps.length).toBe(1);
+  expect(nodeSnaps[0].snapPoint.x).toBe(5);
+  expect(nodeSnaps[0].snapPoint.y).toBe(10);
+});

package/test/entities/line.test.js

@@ -201,3 +201,56 @@ test('Line.fromPolylinePoints round-trip preserves points exactly', () => {
   expect(rebuilt.points[1].x).toBe(15);
   expect(rebuilt.points[1].y).toBe(-4);
 });
+
+test('Line.snaps returns two end snaps at both endpoints', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const endSnaps = line.snaps(new Point(5, 0), 100).filter((s) => s.type === 'end');
+  expect(endSnaps.length).toBe(2);
+  expect(endSnaps.some((s) => s.snapPoint.x === 0 && s.snapPoint.y === 0)).toBe(true);
+  expect(endSnaps.some((s) => s.snapPoint.x === 10 && s.snapPoint.y === 0)).toBe(true);
+});
+
+test('Line.snaps returns mid snap at midpoint', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const midSnaps = line.snaps(new Point(5, 0), 100).filter((s) => s.type === 'mid');
+  expect(midSnaps.length).toBe(1);
+  expect(midSnaps[0].snapPoint.x).toBe(5);
+  expect(midSnaps[0].snapPoint.y).toBe(0);
+});
+
+test('Line.snaps nearest fires when mouse is close to the line', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  // mouse at (5, 0.5): distance to line = 0.5; delta=10 so delta/10=1; 0.5 < 1 → fires
+  const snaps = line.snaps(new Point(5, 0.5), 10);
+  expect(snaps.filter((s) => s.type === 'nearest').length).toBe(1);
+});
+
+test('Line.snaps nearest does not fire when mouse is too far from the line', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  // mouse at (5, 20): distance to line = 20; delta=1 so delta/10=0.1; 20 > 0.1 → no fire
+  const snaps = line.snaps(new Point(5, 20), 1);
+  expect(snaps.filter((s) => s.type === 'nearest').length).toBe(0);
+});
+
+test('Line.snaps perpendicular fires when foot falls on the segment', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;
+  // fromPoint=(5,5): foot of perpendicular = (5,0), which IS on the segment
+  DesignCore.Scene.inputManager.inputPoint = new Point(5, 5);
+  const snaps = line.snaps(new Point(5, 0), 100);
+  const perpSnaps = snaps.filter((s) => s.type === 'perpendicular');
+  expect(perpSnaps.length).toBe(1);
+  expect(perpSnaps[0].snapPoint.x).toBeCloseTo(5);
+  expect(perpSnaps[0].snapPoint.y).toBeCloseTo(0);
+  DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
+});
+
+test('Line.snaps perpendicular does not fire when foot falls off the segment', () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const savedInputPoint = DesignCore.Scene.inputManager.inputPoint;
+  // fromPoint=(20,5): foot = (20,0), which is BEYOND the segment end at (10,0)
+  DesignCore.Scene.inputManager.inputPoint = new Point(20, 5);
+  const snaps = line.snaps(new Point(5, 0), 100);
+  expect(snaps.filter((s) => s.type === 'perpendicular').length).toBe(0);
+  DesignCore.Scene.inputManager.inputPoint = savedInputPoint;
+});

package/test/entities/text.test.js

@@ -535,7 +535,8 @@ test('Text snaps returns all snap points', () => {
   const t = new Text({ points: [new Point(1, 2)] });
   t.boundingRect = { width: 10, height: 10 };
   const snaps = t.snaps(new Point(0, 0), 1);
-  expect(snaps.length).toBe(5);
+  expect(snaps.length).toBe(1);
+  expect(snaps[0].type).toBe('node');
 });
 
 test('Text closestPoint returns correct distance', () => {
@@ -630,3 +631,11 @@ test('Text.execute does not create entity for empty string', async () => {
 
   expect(executeCommandCalled).toBe(false);
 });
+
+test('Text.snaps node snap position matches points[0]', () => {
+  const t = new Text({ points: [new Point(5, 10)] });
+  const nodeSnaps = t.snaps(new Point(0, 0), 100).filter((s) => s.type === 'node');
+  expect(nodeSnaps.length).toBe(1);
+  expect(nodeSnaps[0].snapPoint.x).toBe(5);
+  expect(nodeSnaps[0].snapPoint.y).toBe(10);
+});

package/test/lib/input.test.js

@@ -0,0 +1,117 @@
+import { Input, MouseDown, MouseUp } from '../../core/lib/inputManager.js';
+import { Point } from '../../core/entities/point.js';
+import { SingleSelection, SelectionSet } from '../../core/lib/selectionManager.js';
+import { expect } from '@jest/globals';
+
+// Stub classes that simulate what terser does in a production build:
+// constructor.name is mangled to a single letter but static type is preserved.
+
+/** Stub simulating a minified class resolved as Point. */
+class MangledPoint {
+  static type = 'Point';
+}
+
+/** Stub simulating a minified class resolved as SingleSelection. */
+class MangledSingleSelection {
+  static type = 'SingleSelection';
+}
+
+/** Stub simulating a minified class resolved as SelectionSet. */
+class MangledSelectionSet {
+  static type = 'SelectionSet';
+}
+
+/** Stub simulating a minified class resolved as MouseDown. */
+class MangledMouseDown {
+  static type = 'MouseDown';
+}
+
+/** Stub simulating a minified class resolved as MouseUp. */
+class MangledMouseUp {
+  static type = 'MouseUp';
+}
+
+/** Stub with no static type and an unrecognised constructor.name. */
+class UnknownStub {}
+
+// ─── Input.Type ───────────────────────────────────────────────────────────────
+
+test('Input.Type contains all expected type entries', () => {
+  const keys = Object.keys(Input.Type);
+  expect(keys).toContain('POINT');
+  expect(keys).toContain('SELECTIONSET');
+  expect(keys).toContain('SINGLESELECTION');
+  expect(keys).toContain('NUMBER');
+  expect(keys).toContain('STRING');
+  expect(keys).toContain('DYNAMIC');
+  expect(keys).toContain('MOUSEDOWN');
+  expect(keys).toContain('MOUSEUP');
+});
+
+// ─── Input.getType — undefined ────────────────────────────────────────────────
+
+test('Input.getType returns undefined for undefined input', () => {
+  expect(Input.getType(undefined)).toBeUndefined();
+});
+
+// ─── Input.getType — constructor.name path (dev / unminified) ─────────────────
+
+test('Input.getType resolves Point via constructor.name', () => {
+  expect(Input.getType(new Point(1, 2))).toBe(Input.Type.POINT);
+});
+
+test('Input.getType resolves SingleSelection via constructor.name', () => {
+  expect(Input.getType(new SingleSelection(0, new Point(0, 0)))).toBe(Input.Type.SINGLESELECTION);
+});
+
+test('Input.getType resolves SelectionSet via constructor.name', () => {
+  expect(Input.getType(new SelectionSet())).toBe(Input.Type.SELECTIONSET);
+});
+
+test('Input.getType resolves MouseDown via constructor.name', () => {
+  expect(Input.getType(new MouseDown())).toBe(Input.Type.MOUSEDOWN);
+});
+
+test('Input.getType resolves MouseUp via constructor.name', () => {
+  expect(Input.getType(new MouseUp())).toBe(Input.Type.MOUSEUP);
+});
+
+test('Input.getType resolves Number via constructor.name', () => {
+  expect(Input.getType(42)).toBe(Input.Type.NUMBER);
+});
+
+test('Input.getType resolves String via constructor.name', () => {
+  expect(Input.getType('hello')).toBe(Input.Type.STRING);
+});
+
+// ─── Input.getType — static type path (minified / production) ─────────────────
+
+test('Input.getType resolves via static type when constructor.name is mangled (Point)', () => {
+  expect(Input.getType(new MangledPoint())).toBe(Input.Type.POINT);
+});
+
+test('Input.getType resolves via static type when constructor.name is mangled (SingleSelection)', () => {
+  expect(Input.getType(new MangledSingleSelection())).toBe(Input.Type.SINGLESELECTION);
+});
+
+test('Input.getType resolves via static type when constructor.name is mangled (SelectionSet)', () => {
+  expect(Input.getType(new MangledSelectionSet())).toBe(Input.Type.SELECTIONSET);
+});
+
+test('Input.getType resolves via static type when constructor.name is mangled (MouseDown)', () => {
+  expect(Input.getType(new MangledMouseDown())).toBe(Input.Type.MOUSEDOWN);
+});
+
+test('Input.getType resolves via static type when constructor.name is mangled (MouseUp)', () => {
+  expect(Input.getType(new MangledMouseUp())).toBe(Input.Type.MOUSEUP);
+});
+
+// ─── Input.getType — no match ─────────────────────────────────────────────────
+
+test('Input.getType returns undefined when neither static type nor constructor.name matches', () => {
+  expect(Input.getType(new UnknownStub())).toBeUndefined();
+});
+
+test('Input.getType returns undefined for a plain object', () => {
+  expect(Input.getType({})).toBeUndefined();
+});

package/test/lib/settings.test.js

@@ -41,10 +41,8 @@ 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.snaptrackingcolour).toEqual({ r: 55, g: 180, b: 75 });
   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 });
 });
@@ -84,9 +82,9 @@ test('setSetting with false value does not trigger polar/ortho exclusion', () =>
 });
 
 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 });
+  settings.setSetting('snaptrackingcolour', { r: 1, g: 2, b: 3 });
+  expect(settings.snaptrackingcolour).toEqual({ r: 1, g: 2, b: 3 });
+  settings.setSetting('snaptrackingcolour', { r: 55, g: 180, b: 75 });
 });
 
 test('setSetting updates polarangle', () => {
@@ -118,7 +116,7 @@ test('getSetting returns current value after setSetting', () => {
 });
 
 test('getSetting returns correct type for colour objects', () => {
-  const colour = settings.getSetting('snapcolour');
+  const colour = settings.getSetting('snaptrackingcolour');
   expect(colour).toHaveProperty('r');
   expect(colour).toHaveProperty('g');
   expect(colour).toHaveProperty('b');