@design-core/core 0.0.6 → 50.1.0

package/core/tools/cornerEntity.js

@@ -1,5 +1,5 @@
 import { Line } from '../entities/line.js';
-import { BasePolyline } from '../entities/basePolyline.js';
+import { PolylineBase } from '../entities/polylineBase.js';
 
 import { DesignCore } from '../designCore.js';
 
@@ -61,7 +61,7 @@ export class CornerEntity {
   setPick(entity, clickPoint, arcSegmentErrorMsg) {
     this.entity = entity;
     this.clickPoint = clickPoint;
-    if (!(this.entity instanceof BasePolyline)) {
+    if (!(this.entity instanceof PolylineBase)) {
       this.segment = null;
       this.segmentIndex = null;
       return true;

package/core/tools/cutclip.js

@@ -53,11 +53,11 @@ export class Cutclip extends Tool {
    * Perform the command
    */
   action() {
-    // generate clipboard data from selected items
-    const selectedItems = DesignCore.Scene.selectionManager.selectedItems;
+    // generate clipboard data from selected entities
+    const selectedEntities = DesignCore.Scene.selectionManager.selectedEntities;
 
     // create clipboard data
-    DesignCore.Clipboard.Entities = selectedItems;
+    DesignCore.Clipboard.Entities = selectedEntities;
     // get a copy of the selection set
     const selections = DesignCore.Scene.selectionManager.selectionSet.selectionSet.slice();
     // create state changes for each of the selections

package/core/tools/explode.js

@@ -83,23 +83,23 @@ export class Explode extends Tool {
 
       // check the insert has a block and
       // check the block has items
-      if (insert.block === undefined || insert.block.items.length == 0) {
+      if (insert.block === undefined || insert.block.entities.length === 0) {
         counter++;
         continue;
       }
 
       const insertPoint = insert.points[0];
       const block = insert.block;
-      const blockItems = block.items;
+      const blockItems = block.entities;
 
-      const rotation = Utils.degrees2radians(insert.rotation);
+      const rotation = Utils.degrees2radians(insert.getProperty('rotation'));
       const origin = new Point(0, 0);
 
       blockItems.forEach((blockItem) => {
-        const copyofitem = Utils.cloneObject(blockItem);
-        const points = copyofitem.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(origin, rotation).add(insertPoint));
-        copyofitem.setProperty('points', points);
-        const stateChange = new AddState(copyofitem);
+        const copyOfItem = Utils.cloneObject(blockItem);
+        const points = copyOfItem.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(origin, rotation).add(insertPoint));
+        copyOfItem.points = points;
+        const stateChange = new AddState(copyOfItem);
         stateChanges.push(stateChange);
       });
 

package/core/tools/extend.js

@@ -3,6 +3,9 @@ import { Strings } from '../lib/strings.js';
 import { Tool } from './tool.js';
 import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
+import { UpdateState } from '../lib/stateManager.js';
+import { Utils } from '../lib/utils.js';
+import { PolylineUtils } from '../lib/polylineUtils.js';
 
 import { DesignCore } from '../designCore.js';
 
@@ -16,7 +19,7 @@ export class Extend extends Tool {
   /** Create an Extend command */
   constructor() {
     super();
-    this.selectedItem = null;
+    this.selectedEntity = null;
     this.selectedBoundaryItems = [];
   }
 
@@ -45,7 +48,7 @@ export class Extend extends Tool {
         if (boundary === undefined) return;
       }
 
-      // add all selected items to boundary items
+      // add all selected entities to boundary items
       for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
         const boundaryItem = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]);
         this.selectedBoundaryItems.push(boundaryItem);
@@ -55,7 +58,7 @@ export class Extend extends Tool {
       while (true) {
         const selection = await DesignCore.Scene.inputManager.requestInput(op2);
         if (selection === undefined) break;
-        this.selectedItem = DesignCore.Scene.entities.get(selection.selectedItemIndex);
+        this.selectedEntity = DesignCore.Scene.entities.get(selection.selectedEntityIndex);
         DesignCore.Scene.selectionManager.removeLastSelection();
         DesignCore.Scene.inputManager.actionCommand();
       }
@@ -70,44 +73,154 @@ export class Extend extends Tool {
    * Preview the command during execution
    */
   preview() {
-    // No Preview
+    if (!this.selectedBoundaryItems.length) return;
+
+    const index = DesignCore.Scene.selectionManager.findClosestItem(DesignCore.Mouse.pointOnScene());
+    if (index === undefined) return;
+
+    const entity = DesignCore.Scene.entities.get(index);
+    if (typeof entity.toPolylinePoints !== 'function' || typeof entity.fromPolylinePoints !== 'function') return;
+    const intersectPoints = this.#collectIntersectPoints(entity);
+    if (!intersectPoints.length) return;
+
+    const stateChanges = this.#extendEntity(entity, intersectPoints);
+    if (!stateChanges?.length) return;
+
+    for (const change of stateChanges) {
+      if (change instanceof UpdateState) {
+        const extended = Utils.cloneObject(entity);
+        extended.setProperty('points', change.properties.points);
+        DesignCore.Scene.previewEntities.add(extended);
+      }
+    }
   }
 
   /**
    * Perform the command
    */
   action() {
-    if (this.selectedItem && this.selectedBoundaryItems.length) {
-      const intersectPoints = [];
-
-      for (const boundaryItem of this.selectedBoundaryItems) {
-        if (boundaryItem !== this.selectedItem) {
-          try {
-            const intersect = Intersection.intersectPolylinePolyline(boundaryItem.toPolylinePoints(), this.selectedItem.toPolylinePoints(), true);
-            if (intersect.points.length) {
-              for (let point = 0; point < intersect.points.length; point++) {
-                intersectPoints.push(intersect.points[point]);
-              }
-            }
-          } catch {
-            Logging.instance.warn(`${this.constructor.name}: Error intersecting between ${boundaryItem.type} and ${this.selectedItem.type}`);
-            continue;
-          }
-        }
+    if (this.selectedEntity && this.selectedBoundaryItems.length) {
+      if (typeof this.selectedEntity.fromPolylinePoints !== 'function') {
+        DesignCore.Core.notify(`${this.type} - ${this.selectedEntity.type} ${Strings.Message.NOEXTEND}`);
+        this.selectedEntity = null;
+        return;
       }
 
+      const intersectPoints = this.#collectIntersectPoints(this.selectedEntity);
+
       if (intersectPoints.length) {
-        const stateChanges = this.selectedItem.extend(intersectPoints);
+        const stateChanges = this.#extendEntity(this.selectedEntity, intersectPoints);
         if (stateChanges?.length) {
           DesignCore.Scene.commit(stateChanges);
+        } else {
+          DesignCore.Core.notify(`${this.type} - ${this.selectedEntity.type} ${Strings.Message.NOEXTEND}`);
         }
       } else {
-        DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOEXTEND}`);
+        DesignCore.Core.notify(`${this.type} - ${this.selectedEntity.type} ${Strings.Message.NOEXTEND}`);
+      }
+    }
+
+    this.selectedEntity = null;
+  }
+
+  /**
+   * Collect all intersection points between the boundary items and the given entity.
+   * Unsupported entity combinations are silently skipped.
+   * @param {Object} entity
+   * @return {Array}
+   */
+  #collectIntersectPoints(entity) {
+    const intersectPoints = [];
+    for (const boundaryItem of this.selectedBoundaryItems) {
+      if (boundaryItem === entity) continue;
+      try {
+        const intersect = Intersection.intersectPolylinePolyline(boundaryItem.toPolylinePoints(), entity.toPolylinePoints(), true);
+        intersectPoints.push(...intersect.points);
+      } catch {
+        // skip unsupported entity combinations
+      }
+    }
+    return intersectPoints;
+  }
+
+  /**
+   * Compute a state change to extend entity to the nearest valid boundary
+   * intersection. Operates entirely in polyline-point space via
+   * entity.toPolylinePoints() / entity.fromPolylinePoints(), so it works for
+   * any entity that implements that protocol (Line, PolylineBase, and future
+   * entities such as Spline or Ellipse).
+   * Only straight end-segments (bulge === 0) can be extended.
+   * @param {Object} entity
+   * @param {Array}  intersectPoints
+   * @return {Array}
+   */
+  #extendEntity(entity, intersectPoints) {
+    if (!intersectPoints?.length) return [];
+
+    const polyPoints = entity.toPolylinePoints();
+
+    // Closed entities have no open endpoints to extend
+    if (polyPoints[0].isSame(polyPoints.at(-1))) return [];
+
+    const mousePosition = DesignCore.Mouse.pointOnScene();
+    const lastIndex = polyPoints.length - 1;
+
+    // Determine which end segment is closest to the mouse
+    const closestOnFirst = PolylineUtils.closestPointOnSegment(polyPoints, mousePosition, 1);
+    const closestOnLast = PolylineUtils.closestPointOnSegment(polyPoints, mousePosition, lastIndex);
+    const distToFirst = mousePosition.distance(closestOnFirst);
+    const distToLast = mousePosition.distance(closestOnLast);
+
+    let endPointIndex;
+    let endSegmentBulge;
+    if (distToFirst < distToLast) {
+      endPointIndex = 0;
+      endSegmentBulge = polyPoints[0].bulge ?? 0;
+    } else if (distToLast < distToFirst) {
+      endPointIndex = lastIndex;
+      endSegmentBulge = polyPoints[lastIndex - 1].bulge ?? 0;
+    } else {
+      if (mousePosition.distance(polyPoints[0]) <= mousePosition.distance(polyPoints[lastIndex])) {
+        endPointIndex = 0;
+        endSegmentBulge = polyPoints[0].bulge ?? 0;
+      } else {
+        endPointIndex = lastIndex;
+        endSegmentBulge = polyPoints[lastIndex - 1].bulge ?? 0;
       }
     }
 
-    // reset selected item
-    this.selectedItem = null;
+    // Only straight end-segments can be extended
+    if (endSegmentBulge !== 0) return [];
+
+    const endPoint = polyPoints[endPointIndex];
+    const adjacentPoint = endPointIndex === 0 ? polyPoints[1] : polyPoints[lastIndex - 1];
+
+    Utils.sortPointsByDistance(intersectPoints, endPoint);
+
+    const direction = endPoint.subtract(adjacentPoint);
+    const newEndPoint = intersectPoints.find((p) => {
+      // Ignore the current end point itself
+      if (p.isSame(endPoint)) return false;
+      // Point must be ahead of the end point in the extension direction
+      if (p.subtract(endPoint).dot(direction) <= 0) return false;
+      // Point must be further from the adjacent point than the end point is (i.e. actually extends the segment)
+      if (adjacentPoint.distance(p) <= adjacentPoint.distance(endPoint)) return false;
+      // Point must lie on the extension line of the end segment; intersections from internal
+      // segments extended as infinite lines will have a non-zero cross product with direction
+      if (Utils.round(direction.cross(p.subtract(adjacentPoint))) !== 0) return false;
+      return true;
+    });
+
+    if (!newEndPoint) return [];
+
+    const newPolyPoints = polyPoints.map((p) => p.clone());
+    newPolyPoints[endPointIndex] = newEndPoint.clone();
+
+    if (newPolyPoints[endPointIndex].isSame(polyPoints[endPointIndex])) return [];
+
+    const clone = Utils.cloneObject(entity);
+    const output = clone.fromPolylinePoints(newPolyPoints);
+    return [new UpdateState(entity, { points: output.points })];
   }
 }
 

package/core/tools/fillet.js

@@ -3,9 +3,11 @@ import { ChamferFilletBase } from './chamferFilletBase.js';
 import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
 import { Constants } from '../lib/constants.js';
+import { Utils } from '../lib/utils.js';
 import { Line } from '../entities/line.js';
-import { BasePolyline } from '../entities/basePolyline.js';
-import { AddState, RemoveState, UpdateState } from '../lib/stateManager.js';
+import { PolylineBase } from '../entities/polylineBase.js';
+import { AddState } from '../lib/stateManager.js';
+import { Colour } from '../lib/colour.js';
 
 import { DesignCore } from '../designCore.js';
 
@@ -63,9 +65,9 @@ export class Fillet extends ChamferFilletBase {
         }
 
         // input1 is a selection — validate and store first entity
-        const firstEntity = DesignCore.Scene.entities.get(input1.selectedItemIndex);
+        const firstEntity = DesignCore.Scene.entities.get(input1.selectedEntityIndex);
         DesignCore.Scene.selectionManager.removeLastSelection();
-        if (!(firstEntity instanceof Line) && !(firstEntity instanceof BasePolyline)) {
+        if (!(firstEntity instanceof Line) && !(firstEntity instanceof PolylineBase)) {
           DesignCore.Core.notify(`${this.type} - ${firstEntity.type} ${Strings.Message.NOFILLET}`);
           continue;
         }
@@ -77,16 +79,16 @@ export class Fillet extends ChamferFilletBase {
           const input2 = await DesignCore.Scene.inputManager.requestInput(op2);
           if (input2 === undefined) return;
 
-          const candidate = DesignCore.Scene.entities.get(input2.selectedItemIndex);
+          const candidate = DesignCore.Scene.entities.get(input2.selectedEntityIndex);
           DesignCore.Scene.selectionManager.removeLastSelection();
-          if (!(candidate instanceof Line) && !(candidate instanceof BasePolyline)) {
+          if (!(candidate instanceof Line) && !(candidate instanceof PolylineBase)) {
             DesignCore.Core.notify(`${this.type} - ${candidate.type} ${Strings.Message.NOFILLET}`);
             continue;
           }
           if (!this.secondPick.setPick(candidate, input2.selectedPoint, `${Strings.Strings.ARC} - ${Strings.Message.NOFILLET}`)) continue;
           // If both selections are the same polyline, segments must be consecutive
           // or they must be the open-end segments of an open polyline.
-          if (candidate === firstEntity && firstEntity instanceof BasePolyline) {
+          if (candidate === firstEntity && firstEntity instanceof PolylineBase) {
             const isConsecutive = firstEntity.areConsecutiveSegments(this.firstPick.segmentIndex, this.secondPick.segmentIndex);
             const lastIdx = firstEntity.points.length - 1;
             const isOpenEnds = !firstEntity.flags.hasFlag(1) &&
@@ -113,7 +115,43 @@ export class Fillet extends ChamferFilletBase {
    * Preview the command during execution
    */
   preview() {
-    // No preview
+    const selection = this.validateSelection();
+    if (!selection) return;
+
+    const filletRadius = DesignCore.Scene.headers.filletRadius;
+    const trimMode = DesignCore.Scene.headers.trimMode;
+
+    const geo = this.#computeFillet(this.firstPick, selection.tempSecond, selection.intersectionPoint, filletRadius);
+    if (!geo) return;
+    if (trimMode && !geo.tangentsInBounds) return;
+
+    if (!trimMode) {
+      if (geo.arc) DesignCore.Scene.previewEntities.add(geo.arc);
+      return;
+    }
+
+    // trimMode: dull the original segments then show the shortened versions + arc
+    const firstSeg = Utils.cloneObject(this.firstPick.activeSeg);
+    firstSeg.setProperty('colour', Colour.blend(this.firstPick.entity.getDrawColour(), DesignCore.Settings.canvasbackgroundcolour, DesignCore.Settings.previewBlendFactor));
+    DesignCore.Scene.previewEntities.add(firstSeg);
+
+    const secondSeg = Utils.cloneObject(selection.tempSecond.activeSeg);
+    secondSeg.setProperty('colour', Colour.blend(selection.tempSecond.entity.getDrawColour(), DesignCore.Settings.canvasbackgroundcolour, DesignCore.Settings.previewBlendFactor));
+    DesignCore.Scene.previewEntities.add(secondSeg);
+
+    const firstTrimLine = DesignCore.CommandManager.createNew('Line', {
+      points: [this.firstPick.lineKeptEnd(selection.intersectionPoint), geo.firstTangentPoint],
+      ...Utils.cloneProperties(this.firstPick.entity),
+    });
+    DesignCore.Scene.previewEntities.add(firstTrimLine);
+
+    const secondTrimLine = DesignCore.CommandManager.createNew('Line', {
+      points: [selection.tempSecond.lineKeptEnd(selection.intersectionPoint), geo.secondTangentPoint],
+      ...Utils.cloneProperties(selection.candidate),
+    });
+    DesignCore.Scene.previewEntities.add(secondTrimLine);
+
+    if (geo.arc) DesignCore.Scene.previewEntities.add(geo.arc);
   }
 
   /**
@@ -126,205 +164,70 @@ export class Fillet extends ChamferFilletBase {
     // radius = 0: trim/extend both lines to the sharp intersection with no arc
     const filletRadius = DesignCore.Scene.headers.filletRadius;
     const trimMode = DesignCore.Scene.headers.trimMode;
-    if (filletRadius === 0) {
-      if (trimMode) {
-        const stateChanges = this.applySharpTrim();
-        DesignCore.Scene.commit(stateChanges);
-      }
-      return;
-    }
-
-    // Angle between the two clicked-side direction vectors (i.e. the opening angle of the chosen corner)
-    const firstUnit = this.firstPick.clickUnit(this.intersectionPoint);
-    const secondUnit = this.secondPick.clickUnit(this.intersectionPoint);
-    const cosAngle = Math.min(1, Math.max(-1, firstUnit.dot(secondUnit)));
-    const cornerAngle = Math.acos(cosAngle);
-
-    // Collinear or antiparallel lines cannot be filleted
-    if (cornerAngle < Constants.Tolerance.EPSILON || cornerAngle > Math.PI - Constants.Tolerance.EPSILON) {
+    const geo = this.#computeFillet(this.firstPick, this.secondPick, this.intersectionPoint, filletRadius);
+    if (!geo) {
       DesignCore.Core.notify(`${this.type} - ${Strings.Error.ERROR}:${Strings.Error.PARALLELLINES}`);
       return;
     }
 
-    // Bisector unit vector: points into the chosen corner toward the fillet centre
-    const bisectorUnit = firstUnit.add(secondUnit).normalise();
-
-    // Distance from the intersection point to the fillet centre along the bisector
-    const intersectToCentreDistance = filletRadius / Math.sin(cornerAngle / 2);
-
-    // Fillet arc centre point
-    const arcCentre = this.intersectionPoint.add(bisectorUnit.scale(intersectToCentreDistance));
-
-    // Tangent points where the fillet arc meets each line (foot of perpendicular from centre to line)
-    const firstTangentPoint = arcCentre.perpendicular(this.firstPick.lineStart, this.firstPick.lineEnd);
-    const secondTangentPoint = arcCentre.perpendicular(this.secondPick.lineStart, this.secondPick.lineEnd);
-
-    // Verify the tangent points are reachable — same direction as the kept end from the
-    // intersection and not farther than the kept end (which would flip the line direction).
-    if (trimMode) {
-      const firstKeptDir = this.firstPick.lineKeptEnd(this.intersectionPoint).subtract(this.intersectionPoint);
-      const secondKeptDir = this.secondPick.lineKeptEnd(this.intersectionPoint).subtract(this.intersectionPoint);
-      const firstTangentDot = firstTangentPoint.subtract(this.intersectionPoint).dot(firstKeptDir);
-      const secondTangentDot = secondTangentPoint.subtract(this.intersectionPoint).dot(secondKeptDir);
-      if (firstTangentDot < 0 || firstTangentDot > firstKeptDir.dot(firstKeptDir) ||
-          secondTangentDot < 0 || secondTangentDot > secondKeptDir.dot(secondKeptDir)) {
-        DesignCore.Core.notify(`${this.type} - ${Strings.Error.ERROR}:${Strings.Error.RADIUSTOOLARGE}`);
-        return;
-      }
+    if (trimMode && !geo.tangentsInBounds) {
+      DesignCore.Core.notify(`${this.type} - ${Strings.Error.ERROR}:${Strings.Error.RADIUSTOOLARGE}`);
+      return;
     }
 
-    // Determine arc winding direction: if the cross product of the two centre-to-tangent
-    // vectors is positive, the short arc from firstTangentPoint to secondTangentPoint
-    // travels CCW (direction = 1), otherwise CW (direction = -1).
-    const centreToFirst = firstTangentPoint.subtract(arcCentre);
-    const centreToSecond = secondTangentPoint.subtract(arcCentre);
-    const windingCross = centreToFirst.cross(centreToSecond);
-    const arcDirection = windingCross > 0 ? 1 : -1;
-
-    const arc = DesignCore.CommandManager.createNew('Arc', {
-      points: [arcCentre, firstTangentPoint, secondTangentPoint],
-      direction: arcDirection,
-    });
-
-    const firstIsPolyline = this.firstPick.entity instanceof BasePolyline;
-    const secondIsPolyline = this.secondPick.entity instanceof BasePolyline;
-
     if (!trimMode) {
-      DesignCore.Scene.commit([new AddState(arc)]);
+      if (geo.arc) DesignCore.Scene.commit([new AddState(geo.arc)]);
       return;
     }
 
-    if (!firstIsPolyline && !secondIsPolyline) {
-      const stateChanges = this.#trimLineAndLine(firstTangentPoint, secondTangentPoint, arc);
-      DesignCore.Scene.commit(stateChanges);
-    } else if (firstIsPolyline && secondIsPolyline && this.firstPick.entity === this.secondPick.entity) {
-      const stateChanges = this.#trimPolyAndPoly(firstTangentPoint, secondTangentPoint, arcDirection, arcCentre, arc);
-      DesignCore.Scene.commit(stateChanges);
-    } else {
-      const stateChanges = this.#trimLineAndPoly(firstTangentPoint, secondTangentPoint, arcDirection, arcCentre);
-      DesignCore.Scene.commit(stateChanges);
-    }
+    const [firstCornerPoint, secondCornerPoint] = geo.arc ?
+      geo.arc.toPolylinePoints() :
+      [this.intersectionPoint, this.intersectionPoint];
+    const stateChanges = this.applyCornerTrim(firstCornerPoint, secondCornerPoint, geo.arc ?? null);
+    DesignCore.Scene.commit(stateChanges);
   }
 
   /**
-   * Apply trim and arc for a Line + Line fillet.
-   * @param {Point} firstTangentPoint
-   * @param {Point} secondTangentPoint
-   * @param {Arc} arc
-   * @return {Array}
+   * Compute the fillet geometry for two picks meeting at intersectionPoint.
+   * Returns null if the lines are collinear or antiparallel.
+   * When filletRadius is 0, returns arc: null with both tangent points at the intersection.
+   * @param {CornerEntity} firstPick
+   * @param {CornerEntity} secondPick
+   * @param {Point} intersectionPoint
+   * @param {number} filletRadius
+   * @return {{arc, firstTangentPoint, secondTangentPoint, tangentsInBounds}|null}
    */
-  #trimLineAndLine(firstTangentPoint, secondTangentPoint, arc) {
-    return [
-      new AddState(arc),
-      new UpdateState(this.firstPick.entity, { points: [this.firstPick.lineKeptEnd(this.intersectionPoint), firstTangentPoint] }),
-      new UpdateState(this.secondPick.entity, { points: [this.secondPick.lineKeptEnd(this.intersectionPoint), secondTangentPoint] }),
-    ];
-  }
-
-  /**
-   * Apply trim and arc for a Polyline + Polyline (same entity) fillet.
-   * Handles both the open-ends case and the consecutive-segments case.
-   * @param {Point} firstTangentPoint
-   * @param {Point} secondTangentPoint
-   * @param {number} arcDirection
-   * @param {Point} arcCentre
-   * @param {Arc} arc
-   * @return {Array}
-   */
-  #trimPolyAndPoly(firstTangentPoint, secondTangentPoint, arcDirection, arcCentre, arc) {
-    const closeSegIdx = this.firstPick.entity.points.length;
-    const lastIdx = closeSegIdx - 1;
-    const segDiff = Math.abs(this.firstPick.segmentIndex - this.secondPick.segmentIndex);
-    const isOpenEnds = !this.firstPick.entity.flags.hasFlag(1) && segDiff !== 1 && (
-      (this.firstPick.segmentIndex === 1 && this.secondPick.segmentIndex === lastIdx) ||
-      (this.firstPick.segmentIndex === lastIdx && this.secondPick.segmentIndex === 1)
-    );
-    const newPoints = this.firstPick.entity.points.map((p) => p.clone());
-    const stateChanges = [];
-
-    if (isOpenEnds) {
-      stateChanges.push(new AddState(arc));
-      if (this.firstPick.segmentIndex === 1) {
-        newPoints[0] = firstTangentPoint.clone();
-        newPoints[lastIdx] = secondTangentPoint.clone();
-      } else {
-        newPoints[0] = secondTangentPoint.clone();
-        newPoints[lastIdx] = firstTangentPoint.clone();
-      }
-    } else {
-      const seg1 = this.firstPick.segmentIndex;
-      const seg2 = this.secondPick.segmentIndex;
-      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 startAngle = arcCentre.angle(lowerTangent);
-      const endAngle = arcCentre.angle(upperTangent);
-      const includedAngle = ((endAngle - startAngle) * polyArcDir + 4 * Math.PI) % (2 * Math.PI);
-      const bulge = polyArcDir * Math.tan(includedAngle / 4);
-      const arcStartPoint = lowerTangent.clone();
-      arcStartPoint.bulge = bulge;
-      newPoints.splice(cornerIdx, 1, arcStartPoint, upperTangent.clone());
+  #computeFillet(firstPick, secondPick, intersectionPoint, filletRadius) {
+    if (filletRadius === 0) {
+      return { arc: null, firstTangentPoint: intersectionPoint, secondTangentPoint: intersectionPoint, tangentsInBounds: true };
     }
 
-    stateChanges.push(new UpdateState(this.firstPick.entity, { points: newPoints }));
-    return stateChanges;
-  }
-
-  /**
-   * Apply trim and arc for a Line + Polyline (or Polyline + Line) fillet.
-   * The line is consumed into the polyline with the arc encoded as a bulge.
-   * @param {Point} firstTangentPoint
-   * @param {Point} secondTangentPoint
-   * @param {number} arcDirection
-   * @param {Point} arcCentre
-   * @return {Array}
-   */
-  #trimLineAndPoly(firstTangentPoint, secondTangentPoint, arcDirection, arcCentre) {
-    const firstIsPolyline = this.firstPick.entity instanceof BasePolyline;
-    const [poly, line] = firstIsPolyline ? [this.firstPick, this.secondPick] : [this.secondPick, this.firstPick];
-    const lineTangentPoint = line === this.firstPick ? firstTangentPoint : secondTangentPoint;
-    const polyTangentPoint = poly === this.firstPick ? firstTangentPoint : secondTangentPoint;
-    const polyToLineDir = firstIsPolyline ? arcDirection : -arcDirection;
-
-    const startAngle = arcCentre.angle(polyTangentPoint);
-    const endAngle = arcCentre.angle(lineTangentPoint);
-    const includedAngle = ((endAngle - startAngle) * polyToLineDir + 4 * Math.PI) % (2 * Math.PI);
-    const bulge = polyToLineDir * Math.tan(includedAngle / 4);
-    const arcStartPoint = polyTangentPoint.clone();
-    arcStartPoint.bulge = bulge;
+    const firstUnit = firstPick.clickUnit(intersectionPoint);
+    const secondUnit = secondPick.clickUnit(intersectionPoint);
+    const cosAngle = Math.min(1, Math.max(-1, firstUnit.dot(secondUnit)));
+    const cornerAngle = Math.acos(cosAngle);
+    if (cornerAngle < Constants.Tolerance.EPSILON || cornerAngle > Math.PI - Constants.Tolerance.EPSILON) return null;
 
-    const polySegIdx = poly.segmentIndex;
-    const keepStart = poly.keepStart(this.intersectionPoint);
-    let newPoints;
-    if (keepStart) {
-      // Keep the polyline points up to (not including) the selected segment start,
-      // then the arc start (with bulge), the line tangent point, and the kept end of the line.
-      newPoints = [
-        ...poly.entity.points.slice(0, polySegIdx).map((p) => p.clone()),
-        arcStartPoint,
-        lineTangentPoint.clone(),
-        line.lineKeptEnd(this.intersectionPoint).clone(),
-      ];
-    } else {
-      // Keep the polyline points from the selected segment start onwards,
-      // prepending the kept end of the line, the reversed arc start (with negated bulge), and the poly tangent point.
-      const revArcStartPoint = lineTangentPoint.clone();
-      revArcStartPoint.bulge = -bulge;
-      newPoints = [
-        line.lineKeptEnd(this.intersectionPoint).clone(),
-        revArcStartPoint,
-        polyTangentPoint.clone(),
-        ...poly.entity.points.slice(polySegIdx).map((p) => p.clone()),
-      ];
-    }
+    const bisectorUnit = firstUnit.add(secondUnit).normalise();
+    const arcCentre = intersectionPoint.add(bisectorUnit.scale(filletRadius / Math.sin(cornerAngle / 2)));
+    const firstTangentPoint = arcCentre.perpendicular(firstPick.lineStart, firstPick.lineEnd);
+    const secondTangentPoint = arcCentre.perpendicular(secondPick.lineStart, secondPick.lineEnd);
+
+    const firstKeptDir = firstPick.lineKeptEnd(intersectionPoint).subtract(intersectionPoint);
+    const secondKeptDir = secondPick.lineKeptEnd(intersectionPoint).subtract(intersectionPoint);
+    const firstDot = firstTangentPoint.subtract(intersectionPoint).dot(firstKeptDir);
+    const secondDot = secondTangentPoint.subtract(intersectionPoint).dot(secondKeptDir);
+    const tangentsInBounds = firstDot >= 0 && firstDot <= firstKeptDir.dot(firstKeptDir) &&
+                             secondDot >= 0 && secondDot <= secondKeptDir.dot(secondKeptDir);
+
+    const windingCross = firstTangentPoint.subtract(arcCentre).cross(secondTangentPoint.subtract(arcCentre));
+    const arc = DesignCore.CommandManager.createNew('Arc', {
+      points: [arcCentre, firstTangentPoint, secondTangentPoint],
+      direction: windingCross > 0 ? 1 : -1,
+      ...Utils.cloneProperties(firstPick.entity),
+    });
 
-    return [
-      new RemoveState(line.entity),
-      new UpdateState(poly.entity, { points: newPoints }),
-    ];
+    return { arc, firstTangentPoint, secondTangentPoint, tangentsInBounds };
   }
 
   /**