@design-core/core 0.0.5 → 0.0.6

package/core/entities/basePolyline.js

@@ -398,9 +398,10 @@ export class BasePolyline extends Entity {
     let distance = Infinity;
     let minPnt = P;
 
-    for (let i = 1; i < this.points.length; i++) {
+    const segmentCount = this.flags.hasFlag(1) ? this.points.length : this.points.length - 1;
+    for (let i = 1; i <= segmentCount; i++) {
       const A = this.points[i - 1];
-      const B = this.points[i];
+      const B = this.points[i % this.points.length];
 
       let pnt;
       if (A.bulge !== 0) {

package/core/lib/inputManager.js

@@ -293,8 +293,7 @@ export class InputManager {
    * Handle single selection
    */
   singleSelect() {
-    this.inputPoint = DesignCore.Mouse.pointOnScene();
-    this.onLeftClick(this.inputPoint);
+    this.onLeftClick(DesignCore.Mouse.pointOnScene());
   }
 
   /**

package/core/tools/fillet.js

@@ -257,9 +257,9 @@ export class Fillet extends ChamferFilletBase {
       const isClosingWrap = (seg1 === closeSegIdx && seg2 === 1) || (seg2 === closeSegIdx && seg1 === 1);
       const isFirstLower = seg1 < seg2;
       const cornerIdx = isClosingWrap ? 0 : Math.min(seg1, seg2);
-      const lowerTangent = (isClosingWrap ? seg1 === closeSegIdx : !isFirstLower) ? secondTangentPoint : firstTangentPoint;
-      const upperTangent = (isClosingWrap ? seg1 === closeSegIdx : !isFirstLower) ? firstTangentPoint : secondTangentPoint;
-      const polyArcDir = (isClosingWrap ? seg1 === closeSegIdx : !isFirstLower) ? -arcDirection : arcDirection;
+      const lowerTangent = (isClosingWrap ? seg1 !== closeSegIdx : !isFirstLower) ? secondTangentPoint : firstTangentPoint;
+      const upperTangent = (isClosingWrap ? seg1 !== closeSegIdx : !isFirstLower) ? firstTangentPoint : secondTangentPoint;
+      const polyArcDir = (isClosingWrap ? seg1 !== closeSegIdx : !isFirstLower) ? -arcDirection : arcDirection;
       const startAngle = arcCentre.angle(lowerTangent);
       const endAngle = arcCentre.angle(upperTangent);
       const includedAngle = ((endAngle - startAngle) * polyArcDir + 4 * Math.PI) % (2 * Math.PI);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-core/core",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "type": "module",
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"

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/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);
+});