@design-core/core 0.0.5 → 0.0.7

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';
 
@@ -70,7 +73,26 @@ 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);
+      }
+    }
   }
 
   /**
@@ -78,36 +100,127 @@ export class Extend extends Tool {
    */
   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 (typeof this.selectedItem.fromPolylinePoints !== 'function') {
+        DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOEXTEND}`);
+        this.selectedItem = null;
+        return;
       }
 
+      const intersectPoints = this.#collectIntersectPoints(this.selectedItem);
+
       if (intersectPoints.length) {
-        const stateChanges = this.selectedItem.extend(intersectPoints);
+        const stateChanges = this.#extendEntity(this.selectedItem, intersectPoints);
         if (stateChanges?.length) {
           DesignCore.Scene.commit(stateChanges);
+        } else {
+          DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOEXTEND}`);
         }
       } else {
         DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOEXTEND}`);
       }
     }
 
-    // reset selected item
     this.selectedItem = 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, BasePolyline, 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;
+      }
+    }
+
+    // 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 { AddState } from '../lib/stateManager.js';
+import { Colour } from '../lib/colour.js';
 
 import { DesignCore } from '../designCore.js';
 
@@ -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 };
   }
 
   /**

package/core/tools/matchProp.js

@@ -2,6 +2,7 @@ import { Tool } from './tool.js';
 import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Strings } from '../lib/strings.js';
 import { Logging } from '../lib/logging.js';
+import { Utils } from '../lib/utils.js';
 import { UpdateState } from '../lib/stateManager.js';
 
 import { DesignCore } from '../designCore.js';
@@ -21,8 +22,6 @@ export class MatchProp extends Tool {
     this.sourceIndex = null;
     // array of destination item indices
     this.destinationSetIndices = [];
-    // properties to match
-    this.properties = ['colour', 'layer', 'lineType', 'lineWidth', 'height', 'styleName', 'dimensionStyle'];
   }
 
   /**
@@ -76,21 +75,13 @@ export class MatchProp extends Tool {
 
     // get source item
     const sourceItem = DesignCore.Scene.entities.get(this.sourceIndex);
+    const propertySet = Utils.cloneProperties(sourceItem);
 
     const stateChanges = [];
 
     // loop through destination set
     for (let i = 0; i < this.destinationSetIndices.length; i++) {
       const targetItem = DesignCore.Scene.entities.get(this.destinationSetIndices[i]);
-      const propertySet = {};
-      // loop through properties and match
-      for (let p = 0; p < this.properties.length; p++) {
-        // check property exists on both items
-        const prop = this.properties[p];
-        if (sourceItem.hasOwnProperty(prop)) {
-          propertySet[prop] = sourceItem[prop];
-        }
-      }
 
       // only add state change if there are properties to change
       if (Object.keys(propertySet).length > 0) {

package/core/tools/mirror.js

@@ -7,6 +7,7 @@ import { Point } from '../entities/point.js';
 import { AddState, UpdateState } from '../lib/stateManager.js';
 
 import { DesignCore } from '../designCore.js';
+import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 /**
  * Mirror Command Class
@@ -74,8 +75,8 @@ export class Mirror extends Tool {
       const pt1 = this.points[0];
       const pt2 = this.points.length >= 2 ? this.points[1] : mousePoint;
 
-      // Draw the mirror line
-      DesignCore.Scene.tempEntities.create('Line', { points: [pt1, pt2] });
+      // Draw the mirror line as a rubber-band indicator
+      DesignCore.Scene.auxiliaryEntities.add(new RubberBand([pt1, pt2]));
 
       // Preview mirrored entities (skip if mirror line has zero length)
       if (!pt1.isSame(pt2)) {
@@ -84,8 +85,8 @@ export class Mirror extends Tool {
           const entityIndex = DesignCore.Scene.selectionManager.selectionSet.selectionSet[i];
           const originalItem = DesignCore.Scene.entities.get(entityIndex);
           item.setProperty('points', this.getMirroredPoints(originalItem.points, pt1, pt2));
-          if (originalItem.direction !== undefined) {
-            item.setProperty('direction', -originalItem.direction);
+          if (originalItem.properties?.has('direction')) {
+            item.setProperty('direction', -originalItem.getProperty('direction'));
           }
         }
       }
@@ -114,14 +115,14 @@ export class Mirror extends Tool {
       if (this.eraseSource) {
         // Replace the original with its mirrored version
         const updates = { points: mirroredPoints };
-        if (item.direction !== undefined) updates.direction = -item.direction;
+        if (item.properties?.has('direction')) updates.direction = -item.getProperty('direction');
         const stateChange = new UpdateState(item, updates);
         stateChanges.push(stateChange);
       } else {
         // Keep the original and add a mirrored copy
         const copyOfItem = Utils.cloneObject(item);
         copyOfItem.setProperty('points', mirroredPoints);
-        if (copyOfItem.direction !== undefined) copyOfItem.setProperty('direction', -copyOfItem.direction);
+        if (copyOfItem.properties?.has('direction')) copyOfItem.setProperty('direction', -copyOfItem.getProperty('direction'));
         const stateChange = new AddState(copyOfItem);
         stateChanges.push(stateChange);
       }

package/core/tools/move.js

@@ -6,6 +6,7 @@ import { Point } from '../entities/point.js';
 
 import { DesignCore } from '../designCore.js';
 import { UpdateState } from '../lib/stateManager.js';
+import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 /**
  * Move Command Class
@@ -66,9 +67,8 @@ export class Move extends Tool {
     if (this.points.length >= 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
 
-      // Draw a line
-      const points = [this.points.at(-1), mousePoint];
-      DesignCore.Scene.tempEntities.create('Line', { points: points });
+      // Draw a rubber-band line from base point to mouse
+      DesignCore.Scene.auxiliaryEntities.add(new RubberBand([this.points.at(-1), mousePoint]));
 
       // Get the delta from the last mouse point
       const delta = mousePoint.subtract(this.lastMousePoint || this.points[0]);

package/core/tools/offset.js

@@ -107,9 +107,8 @@ export class Offset extends Tool {
       const offsetPoints = this.getOffsetPoints(this.selectedItem, mousePoint, offsetDistance);
 
       if (offsetPoints) {
-        const previewEntity = Utils.cloneObject(this.selectedItem);
-        previewEntity.fromPolylinePoints(offsetPoints);
-        DesignCore.Scene.tempEntities.add(previewEntity);
+        const previewEntity = Utils.cloneObject(this.selectedItem).fromPolylinePoints(offsetPoints);
+        DesignCore.Scene.previewEntities.add(previewEntity);
       }
     }
   }
@@ -130,8 +129,7 @@ export class Offset extends Tool {
       return;
     }
 
-    const offsetEntity = Utils.cloneObject(entity);
-    offsetEntity.fromPolylinePoints(offsetPoints);
+    const offsetEntity = Utils.cloneObject(entity).fromPolylinePoints(offsetPoints);
 
     const stateChange = new AddState(offsetEntity);
     DesignCore.Scene.commit([stateChange]);

package/core/tools/pasteclip.js

@@ -66,7 +66,7 @@ export class Pasteclip extends Tool {
       const tempEntity = Utils.cloneObject(entity);
       const offsetPoints = tempEntity.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).add(delta));
       tempEntity.setProperty('points', offsetPoints);
-      DesignCore.Scene.tempEntities.add(tempEntity);
+      DesignCore.Scene.previewEntities.add(tempEntity);
     }
   }
 

package/core/tools/rotate.js

@@ -7,6 +7,7 @@ import { Point } from '../entities/point.js';
 import { UpdateState } from '../lib/stateManager.js';
 
 import { DesignCore } from '../designCore.js';
+import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 /**
  * Rotate Command Class
@@ -72,6 +73,9 @@ export class Rotate extends Tool {
           this.baseAngle = refBase.angle(refEnd);
           // set the base point to null
           this.basePoint = null;
+          // restore inputPoint to the rotation center so the tracking line
+          // uses the correct origin for the final angle input
+          DesignCore.Scene.inputManager.inputPoint = this.points[0];
         } else if (Input.getType(input2) === Input.Type.NUMBER) {
           const basePoint = this.points.at(0);
           const angle = Utils.degrees2radians(input2);
@@ -95,10 +99,9 @@ export class Rotate extends Tool {
     const mousePoint = DesignCore.Mouse.pointOnScene();
 
     if (this.points.length >= 1 && this.baseAngle !== null || this.basePoint !== null) {
-      // Draw a line
+      // Draw a rubber-band line from center to mouse
       const center = this.basePoint === null ? this.points.at(0) : this.basePoint;
-      const points = [center, mousePoint];
-      DesignCore.Scene.tempEntities.create('Line', { points: points });
+      DesignCore.Scene.auxiliaryEntities.add(new RubberBand([center, mousePoint]));
     }
 
     if (this.points.length >= 1) {