@design-core/core 0.0.4 → 0.0.6

package/test/lib/snapping.test.js

@@ -1,6 +1,6 @@
 import { jest } from '@jest/globals';
 import { Core } from '../../core/core/core.js';
-import { Snapping } from '../../core/lib/snapping.js';
+import { Snapping, SnapPoint } from '../../core/lib/snapping.js';
 import { Point } from '../../core/entities/point.js';
 import { DesignCore } from '../../core/designCore.js';
 
@@ -24,16 +24,16 @@ test('Test Snapping.getSnapPoint', () => {
   core.mouse.mouseMoved(8, 8);
   // Get the snap point
   const snapPoint1 = snapping.getSnapPoint();
-  expect(snapPoint1.x).toBe(10);
-  expect(snapPoint1.y).toBe(10);
+  expect(snapPoint1.snapPoint.x).toBe(10);
+  expect(snapPoint1.snapPoint.y).toBe(10);
 
 
   // set the mouse position
   core.mouse.mouseMoved(101, 11);
   // Get the snap point
   const snapPoint2 = snapping.getSnapPoint();
-  expect(snapPoint2.x).toBe(100);
-  expect(snapPoint2.y).toBe(10);
+  expect(snapPoint2.snapPoint.x).toBe(100);
+  expect(snapPoint2.snapPoint.y).toBe(10);
 
   // set the mouse position
   core.mouse.mouseMoved(100, 100);
@@ -48,8 +48,8 @@ test('Test Snapping.snap active', () => {
   core.mouse.mouseMoved(8, 8);
   const result = snapping.snap();
   expect(result).toBeDefined();
-  expect(result.x).toBe(10);
-  expect(result.y).toBe(10);
+  expect(result.snapPoint.x).toBe(10);
+  expect(result.snapPoint.y).toBe(10);
   expect(DesignCore.Scene.auxiliaryEntities.count()).toBeGreaterThan(0);
 });
 
@@ -61,24 +61,29 @@ test('Test Snapping.snap inactive', () => {
 
 test('Test Snapping.addSnapPoint', () => {
   DesignCore.Scene.auxiliaryEntities.clear();
-  snapping.addSnapPoint(new Point(10, 10));
+  snapping.addSnapPoint(new SnapPoint(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));
+  snapping.addSnapPoint(new SnapPoint(new Point(0.5, 0.5), SnapPoint.Type.CENTRE));
   const snapPointEntity = DesignCore.Scene.auxiliaryEntities.get(0);
   const ctx = {
-    fillStyle: '',
+    strokeStyle: '',
+    lineWidth: 0,
+    setLineDash: jest.fn(),
     beginPath: jest.fn(),
+    moveTo: jest.fn(),
+    lineTo: jest.fn(),
+    closePath: jest.fn(),
     arc: jest.fn(),
-    fill: jest.fn(),
+    stroke: 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();
+  expect(ctx.stroke).toHaveBeenCalled();
 });
 
 test('Test Snapping.addTrackingLine', () => {
@@ -193,3 +198,204 @@ test('Test Snapping.orthoSnap', () => {
   core.mouse.mouseMoved(100, -20);
   expect(snapping.orthoSnap(new Point(0, 0))).toBeUndefined();
 });
+
+// ─── Context mock helpers ────────────────────────────────────────────────────
+
+/** @return {object} mock HTML canvas context for SnapPoint.draw tests */
+function makeSnapCtx() {
+  return {
+    strokeStyle: '',
+    lineWidth: 0,
+    setLineDash: jest.fn(),
+    beginPath: jest.fn(),
+    moveTo: jest.fn(),
+    lineTo: jest.fn(),
+    closePath: jest.fn(),
+    arc: jest.fn(),
+    stroke: jest.fn(),
+  };
+}
+
+/** @return {object} mock HTML canvas context for TrackingLine.draw tests */
+function makeTrackingCtx() {
+  return {
+    save: jest.fn(),
+    restore: jest.fn(),
+    beginPath: jest.fn(),
+    strokeStyle: '',
+    lineWidth: 0,
+    setLineDash: jest.fn(),
+    moveTo: jest.fn(),
+    lineTo: jest.fn(),
+    stroke: jest.fn(),
+  };
+}
+
+// ─── Snapping.reset ──────────────────────────────────────────────────────────
+
+test('Test Snapping.reset', () => {
+  snapping.active = true;
+  snapping.snapOverride = SnapPoint.Type.END;
+  snapping.reset();
+  expect(snapping.active).toBe(false);
+  expect(snapping.snapOverride).toBeNull();
+});
+
+// ─── Snapping.setSnapOverride ────────────────────────────────────────────────
+
+test('Test Snapping.setSnapOverride valid type', () => {
+  snapping.setSnapOverride(SnapPoint.Type.END);
+  expect(snapping.snapOverride).toBe(SnapPoint.Type.END);
+});
+
+test('Test Snapping.setSnapOverride null clears override', () => {
+  snapping.setSnapOverride(SnapPoint.Type.END);
+  snapping.setSnapOverride(null);
+  expect(snapping.snapOverride).toBeNull();
+});
+
+test('Test Snapping.setSnapOverride NONE type', () => {
+  snapping.setSnapOverride(SnapPoint.Type.NONE);
+  expect(snapping.snapOverride).toBe(SnapPoint.Type.NONE);
+  snapping.setSnapOverride(null);
+});
+
+test('Test Snapping.setSnapOverride invalid type throws', () => {
+  expect(() => snapping.setSnapOverride('invalid')).toThrow('Invalid snap override type: invalid');
+});
+
+// ─── Snapping.getSnapPoint with snap override ────────────────────────────────
+
+test('Test Snapping.getSnapPoint with END override returns end snap', () => {
+  snapping.setSnapOverride(SnapPoint.Type.END);
+  core.mouse.mouseMoved(8, 8);
+  const result = snapping.getSnapPoint();
+  expect(result).toBeDefined();
+  expect(result.type).toBe(SnapPoint.Type.END);
+  snapping.setSnapOverride(null);
+});
+
+test('Test Snapping.getSnapPoint with NONE override suppresses all snaps', () => {
+  snapping.setSnapOverride(SnapPoint.Type.NONE);
+  core.mouse.mouseMoved(8, 8);
+  const result = snapping.getSnapPoint();
+  expect(result).toBeUndefined();
+  snapping.setSnapOverride(null);
+});
+
+test('Test Snapping.getSnapPoint with non-matching override returns undefined', () => {
+  // Mouse near end of line at (10,10); mid-point is at (55,10), well outside aperture
+  snapping.setSnapOverride(SnapPoint.Type.MID);
+  core.mouse.mouseMoved(8, 8);
+  const result = snapping.getSnapPoint();
+  expect(result).toBeUndefined();
+  snapping.setSnapOverride(null);
+});
+
+// ─── SnapPoint.draw – all snap types ────────────────────────────────────────
+
+test('Test SnapPoint.draw END type draws closed polygon without arc', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.END);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.closePath).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.arc).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw MID type draws closed polygon without arc', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.MID);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.closePath).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.arc).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw QUADRANT type draws closed polygon without arc', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.QUADRANT);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.closePath).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.arc).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw NEAREST type draws closed polygon without arc', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.NEAREST);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.closePath).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.arc).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw TANGENT type draws arc with tangent line', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.TANGENT);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.arc).toHaveBeenCalledWith(5, 5, expect.any(Number), 0, 6.283);
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.closePath).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw NODE type draws arc with X inside', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.NODE);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.arc).toHaveBeenCalledWith(5, 5, expect.any(Number), 0, 6.283);
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.closePath).not.toHaveBeenCalled();
+});
+
+test('Test SnapPoint.draw PERPENDICULAR type draws L-shape without arc', () => {
+  const sp = new SnapPoint(new Point(5, 5), SnapPoint.Type.PERPENDICULAR);
+  const ctx = makeSnapCtx();
+  sp.draw(ctx, 1);
+  expect(ctx.beginPath).toHaveBeenCalled();
+  expect(ctx.stroke).toHaveBeenCalled();
+  expect(ctx.closePath).not.toHaveBeenCalled();
+  expect(ctx.arc).not.toHaveBeenCalled();
+});
+
+// ─── TrackingLine.draw – out-of-bounds cases ─────────────────────────────────
+
+test('Test TrackingLine.draw vertical line outside x bounds', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  // dir.x === 0 and from.x = 2 > boundsMax.x = 1 → draw returns early
+  snapping.addTrackingLine(new Point(2, -0.5), new Point(2, 0.5));
+  const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
+  const ctx = makeTrackingCtx();
+  trackingLine.draw(ctx, 1);
+  expect(ctx.moveTo).not.toHaveBeenCalled();
+  expect(ctx.stroke).not.toHaveBeenCalled();
+});
+
+test('Test TrackingLine.draw horizontal line outside y bounds', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  // dir.y === 0 and from.y = -5 < boundsMin.y = -1 → draw returns early
+  snapping.addTrackingLine(new Point(0.5, -5), new Point(0.8, -5));
+  const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
+  const ctx = makeTrackingCtx();
+  trackingLine.draw(ctx, 1);
+  expect(ctx.moveTo).not.toHaveBeenCalled();
+  expect(ctx.stroke).not.toHaveBeenCalled();
+});
+
+test('Test TrackingLine.draw line does not intersect canvas bounds', () => {
+  DesignCore.Scene.auxiliaryEntities.clear();
+  // from = (2, -0.5), dir = (1, 1): x-clamp gives t ∈ [-2, -1], y-clamp gives t ∈ [-0.5, 0.5]
+  // tMax (-1) < tMin (-0.5) → draw returns early
+  snapping.addTrackingLine(new Point(2, -0.5), new Point(3, 0.5));
+  const trackingLine = DesignCore.Scene.auxiliaryEntities.get(0);
+  const ctx = makeTrackingCtx();
+  trackingLine.draw(ctx, 1);
+  expect(ctx.moveTo).not.toHaveBeenCalled();
+  expect(ctx.stroke).not.toHaveBeenCalled();
+});

package/test/tools/fillet.test.js

@@ -829,3 +829,118 @@ test('Fillet.action radius>0 trimMode=false Line + Lwpolyline: standalone arc ad
   expect(core.scene.entities.get(0).points.length).toBe(2);
   expect(core.scene.entities.get(1).points.length).toBe(4);
 });
+
+// ─── action: closed polyline closing-wrap arc direction (regression) ──────────
+//
+// Square: P0=(0,0), P1=(10,0), P2=(10,10), P3=(0,10), closed flag=1.
+// Closing segment (idx=4): P3=(0,10)→P0=(0,0) — i.e. the left edge, travelling downward.
+// Segment 1: P0=(0,0)→P1=(10,0) — i.e. the bottom edge, travelling rightward.
+// The shared corner is P0=(0,0).
+//
+// With radius 2 the fillet must sit inside the square (bottom-left interior corner).
+// The arc centre is at (2,2).
+//   – lowerTangent = (0,2)  on the closing segment (left edge, y=2)
+//   – upperTangent = (2,0)  on segment 1 (bottom edge, x=2)
+//   – bulge on lowerTangent must be POSITIVE (CCW arc from (0,2) to (2,0) through ≈(0.59,0.59))
+//     (BasePolyline convention: –ve bulge = CW, +ve bulge = CCW)
+//
+// Before the fix the lowerTangent/upperTangent assignment was inverted, producing
+// an arc that traversed the exterior of the square.
+
+test('Fillet.action closing-wrap: lowerTangent is on closing segment (left edge)', () => {
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] });
+  const polyEntity = core.scene.entities.get(0);
+  polyEntity.flags.setFlagValue(1);
+
+  core.scene.headers.filletRadius = 2;
+  core.scene.headers.trimMode = true;
+
+  // firstPick = closing segment (idx=4, left edge), secondPick = segment 1 (bottom edge)
+  const fillet = new Fillet();
+  fillet.firstPick.entity = polyEntity;
+  fillet.secondPick.entity = polyEntity;
+  fillet.firstPick.segment = polyEntity.getClosestSegment(new Point(0, 5));
+  fillet.firstPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(0, 5));
+  fillet.firstPick.clickPoint = new Point(0, 5);
+  fillet.secondPick.segment = polyEntity.getClosestSegment(new Point(5, 0));
+  fillet.secondPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(5, 0));
+  fillet.secondPick.clickPoint = new Point(5, 0);
+  fillet.action();
+
+  expect(core.scene.entities.count()).toBe(1);
+  const poly = core.scene.entities.get(0);
+  expect(poly.points.length).toBe(5);
+
+  // After the splice at cornerIdx=0:
+  //   points[0] = lowerTangent (arcStartPoint), points[1] = upperTangent
+  // lowerTangent must be on the closing segment (left edge, x≈0)
+  expect(poly.points[0].x).toBeCloseTo(0);
+  expect(poly.points[0].y).toBeCloseTo(2);
+  // upperTangent must be on segment 1 (bottom edge, y≈0)
+  expect(poly.points[1].x).toBeCloseTo(2);
+  expect(poly.points[1].y).toBeCloseTo(0);
+});
+
+test('Fillet.action closing-wrap: arc bulge sign is positive (CCW, fillet inside square)', () => {
+  // Same setup. The CCW arc from (0,2) to (2,0) sweeps through (≈0.59, ≈0.59)
+  // staying inside the square — a positive bulge value.
+  // Before the fix the lowerTangent/upperTangent were swapped, producing an arc
+  // that traversed the exterior of the square.
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] });
+  const polyEntity = core.scene.entities.get(0);
+  polyEntity.flags.setFlagValue(1);
+
+  core.scene.headers.filletRadius = 2;
+  core.scene.headers.trimMode = true;
+
+  const fillet = new Fillet();
+  fillet.firstPick.entity = polyEntity;
+  fillet.secondPick.entity = polyEntity;
+  fillet.firstPick.segment = polyEntity.getClosestSegment(new Point(0, 5));
+  fillet.firstPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(0, 5));
+  fillet.firstPick.clickPoint = new Point(0, 5);
+  fillet.secondPick.segment = polyEntity.getClosestSegment(new Point(5, 0));
+  fillet.secondPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(5, 0));
+  fillet.secondPick.clickPoint = new Point(5, 0);
+  fillet.action();
+
+  const poly = core.scene.entities.get(0);
+  // points[0] carries the bulge for the arc from lowerTangent to upperTangent
+  expect(poly.points[0].bulge).toBeGreaterThan(0);
+});
+
+test('Fillet.action closing-wrap reversed pick order: arc bulge sign and tangent positions are correct', () => {
+  // Swap firstPick/secondPick — should produce the same geometry.
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] });
+  const polyEntity = core.scene.entities.get(0);
+  polyEntity.flags.setFlagValue(1);
+
+  core.scene.headers.filletRadius = 2;
+  core.scene.headers.trimMode = true;
+
+  // firstPick = segment 1 (bottom edge), secondPick = closing segment (left edge, idx=4)
+  const fillet = new Fillet();
+  fillet.firstPick.entity = polyEntity;
+  fillet.secondPick.entity = polyEntity;
+  fillet.firstPick.segment = polyEntity.getClosestSegment(new Point(5, 0));
+  fillet.firstPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(5, 0));
+  fillet.firstPick.clickPoint = new Point(5, 0);
+  fillet.secondPick.segment = polyEntity.getClosestSegment(new Point(0, 5));
+  fillet.secondPick.segmentIndex = polyEntity.getClosestSegmentIndex(new Point(0, 5));
+  fillet.secondPick.clickPoint = new Point(0, 5);
+  fillet.action();
+
+  expect(core.scene.entities.count()).toBe(1);
+  const poly = core.scene.entities.get(0);
+  expect(poly.points.length).toBe(5);
+
+  // Regardless of pick order: lowerTangent at (0,2), upperTangent at (2,0), bulge > 0 (CCW)
+  expect(poly.points[0].x).toBeCloseTo(0);
+  expect(poly.points[0].y).toBeCloseTo(2);
+  expect(poly.points[1].x).toBeCloseTo(2);
+  expect(poly.points[1].y).toBeCloseTo(0);
+  expect(poly.points[0].bulge).toBeGreaterThan(0);
+});