@design-core/core 0.0.7 → 51.1.0

package/core/tools/extend.js

@@ -19,7 +19,7 @@ export class Extend extends Tool {
   /** Create an Extend command */
   constructor() {
     super();
-    this.selectedItem = null;
+    this.selectedEntity = null;
     this.selectedBoundaryItems = [];
   }
 
@@ -48,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);
@@ -58,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();
       }
@@ -99,28 +99,28 @@ export class Extend extends Tool {
    * Perform the command
    */
   action() {
-    if (this.selectedItem && this.selectedBoundaryItems.length) {
-      if (typeof this.selectedItem.fromPolylinePoints !== 'function') {
-        DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOEXTEND}`);
-        this.selectedItem = null;
+    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.selectedItem);
+      const intersectPoints = this.#collectIntersectPoints(this.selectedEntity);
 
       if (intersectPoints.length) {
-        const stateChanges = this.#extendEntity(this.selectedItem, intersectPoints);
+        const stateChanges = this.#extendEntity(this.selectedEntity, intersectPoints);
         if (stateChanges?.length) {
           DesignCore.Scene.commit(stateChanges);
         } else {
-          DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOEXTEND}`);
+          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.selectedItem = null;
+    this.selectedEntity = null;
   }
 
   /**
@@ -147,7 +147,7 @@ export class Extend extends Tool {
    * 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
+   * 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

package/core/tools/fillet.js

@@ -5,7 +5,7 @@ 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 { PolylineBase } from '../entities/polylineBase.js';
 import { AddState } from '../lib/stateManager.js';
 import { Colour } from '../lib/colour.js';
 
@@ -65,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;
         }
@@ -79,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) &&

package/core/tools/matchProp.js

@@ -48,7 +48,7 @@ export class MatchProp extends Tool {
         const sourceSelection = new PromptOptions(Strings.Input.SOURCE, [Input.Type.SINGLESELECTION], []);
         const input = await DesignCore.Scene.inputManager.requestInput(sourceSelection);
         if (input === undefined) return;
-        this.sourceIndex = input.selectedItemIndex;
+        this.sourceIndex = input.selectedEntityIndex;
       }
 
       const destinationSelection = new PromptOptions(Strings.Input.DESTINATIONSET, [Input.Type.SELECTIONSET]);

package/core/tools/mirror.js

@@ -80,13 +80,13 @@ export class Mirror extends Tool {
 
       // Preview mirrored entities (skip if mirror line has zero length)
       if (!pt1.isSame(pt2)) {
-        for (let i = 0; i < DesignCore.Scene.selectionManager.selectedItems.length; i++) {
-          const item = DesignCore.Scene.selectionManager.selectedItems[i];
+        for (let i = 0; i < DesignCore.Scene.selectionManager.selectedEntities.length; i++) {
+          const entity = DesignCore.Scene.selectionManager.selectedEntities[i];
           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.properties?.has('direction')) {
-            item.setProperty('direction', -originalItem.getProperty('direction'));
+          const originalEntity = DesignCore.Scene.entities.get(entityIndex);
+          entity.setProperty('points', this.getMirroredPoints(originalEntity.points, pt1, pt2));
+          if (originalEntity.properties?.has('direction')) {
+            entity.setProperty('direction', -originalEntity.getProperty('direction'));
           }
         }
       }
@@ -109,18 +109,18 @@ export class Mirror extends Tool {
 
     for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
       const entityIndex = DesignCore.Scene.selectionManager.selectionSet.selectionSet[i];
-      const item = DesignCore.Scene.entities.get(entityIndex);
-      const mirroredPoints = this.getMirroredPoints(item.points, pt1, pt2);
+      const entity = DesignCore.Scene.entities.get(entityIndex);
+      const mirroredPoints = this.getMirroredPoints(entity.points, pt1, pt2);
 
       if (this.eraseSource) {
         // Replace the original with its mirrored version
         const updates = { points: mirroredPoints };
-        if (item.properties?.has('direction')) updates.direction = -item.getProperty('direction');
-        const stateChange = new UpdateState(item, updates);
+        if (entity.properties?.has('direction')) updates.direction = -entity.getProperty('direction');
+        const stateChange = new UpdateState(entity, updates);
         stateChanges.push(stateChange);
       } else {
         // Keep the original and add a mirrored copy
-        const copyOfItem = Utils.cloneObject(item);
+        const copyOfItem = Utils.cloneObject(entity);
         copyOfItem.setProperty('points', mirroredPoints);
         if (copyOfItem.properties?.has('direction')) copyOfItem.setProperty('direction', -copyOfItem.getProperty('direction'));
         const stateChange = new AddState(copyOfItem);

package/core/tools/move.js

@@ -74,9 +74,9 @@ export class Move extends Tool {
       const delta = mousePoint.subtract(this.lastMousePoint || this.points[0]);
       this.lastMousePoint = mousePoint;
 
-      for (let i = 0; i < DesignCore.Scene.selectionManager.selectedItems.length; i++) {
-        const item = DesignCore.Scene.selectionManager.selectedItems[i];
-        item.setProperty('points', this.getOffsetPoints(item.points, delta));
+      for (let i = 0; i < DesignCore.Scene.selectionManager.selectedEntities.length; i++) {
+        const entity = DesignCore.Scene.selectionManager.selectedEntities[i];
+        entity.setProperty('points', this.getOffsetPoints(entity.points, delta));
       }
     }
   }
@@ -94,8 +94,8 @@ export class Move extends Tool {
 
     for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
       const index = DesignCore.Scene.selectionManager.selectionSet.selectionSet[i];
-      const item = DesignCore.Scene.entities.get(index);
-      const stateChange = new UpdateState(item, { points: this.getOffsetPoints(item.points, delta) });
+      const entity = DesignCore.Scene.entities.get(index);
+      const stateChange = new UpdateState(entity, { points: this.getOffsetPoints(entity.points, delta) });
       stateChanges.push(stateChange);
     }
 

package/core/tools/offset.js

@@ -19,7 +19,7 @@ export class Offset extends Tool {
   /** Create an Offset command */
   constructor() {
     super();
-    this.selectedItem = null;
+    this.selectedEntity = null;
   }
 
   /**
@@ -67,28 +67,28 @@ export class Offset extends Tool {
       while (true) {
         const preselected = DesignCore.Scene.selectionManager.selectionSet.selectionSet;
         if (preselected.length === 1) {
-          this.selectedItem = DesignCore.Scene.entities.get(preselected[0]);
+          this.selectedEntity = DesignCore.Scene.entities.get(preselected[0]);
           DesignCore.Scene.selectionManager.reset();
         } else {
           DesignCore.Scene.selectionManager.reset();
           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();
         }
 
         const point = await DesignCore.Scene.inputManager.requestInput(op3);
         if (point === undefined) {
-          this.selectedItem = null;
+          this.selectedEntity = null;
           break;
         }
 
         if (throughMode) {
-          DesignCore.Scene.headers.offsetDistance = this.getThroughDistance(this.selectedItem, point);
+          DesignCore.Scene.headers.offsetDistance = this.getThroughDistance(this.selectedEntity, point);
         }
         this.points = [point];
         DesignCore.Scene.inputManager.actionCommand();
-        this.selectedItem = null;
+        this.selectedEntity = null;
       }
 
       DesignCore.Scene.inputManager.reset();
@@ -102,12 +102,12 @@ export class Offset extends Tool {
    */
   preview() {
     const offsetDistance = DesignCore.Scene.headers.offsetDistance;
-    if (this.selectedItem && offsetDistance > 0) {
+    if (this.selectedEntity && offsetDistance > 0) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
-      const offsetPoints = this.getOffsetPoints(this.selectedItem, mousePoint, offsetDistance);
+      const offsetPoints = this.getOffsetPoints(this.selectedEntity, mousePoint, offsetDistance);
 
       if (offsetPoints) {
-        const previewEntity = Utils.cloneObject(this.selectedItem).fromPolylinePoints(offsetPoints);
+        const previewEntity = Utils.cloneObject(this.selectedEntity).fromPolylinePoints(offsetPoints);
         DesignCore.Scene.previewEntities.add(previewEntity);
       }
     }
@@ -118,10 +118,10 @@ export class Offset extends Tool {
    */
   action() {
     const offsetDistance = DesignCore.Scene.headers.offsetDistance;
-    if (!this.selectedItem || offsetDistance <= 0) return;
+    if (!this.selectedEntity || offsetDistance <= 0) return;
 
     const sidePoint = this.points[0];
-    const entity = this.selectedItem;
+    const entity = this.selectedEntity;
     const offsetPoints = this.getOffsetPoints(entity, sidePoint, offsetDistance);
 
     if (!offsetPoints) {
@@ -187,20 +187,20 @@ export class Offset extends Tool {
           sign = cross >= 0 ? 1 : -1;
         }
       } else {
-        const center = A.bulgeCentrePoint(B);
-        const currentRadius = center.distance(A);
+        const centre = A.bulgeCentrePoint(B);
+        const currentRadius = centre.distance(A);
         const arcDir = A.bulge > 0 ? 1 : -1;
-        const closestPt = sidePoint.closestPointOnArc(A, B, center, arcDir);
+        const closestPt = sidePoint.closestPointOnArc(A, B, centre, arcDir);
         if (closestPt === null) continue;
         const dist = sidePoint.distance(closestPt);
         if (dist < minDist) {
           minDist = dist;
-          const distToCenter = center.distance(sidePoint);
-          // For CCW arc (arcDir>0): left of travel = toward center (smaller radius)
-          // For CW arc (arcDir<0): left of travel = away from center (larger radius)
+          const distToCentre = centre.distance(sidePoint);
+          // For CCW arc (arcDir>0): left of travel = toward centre (smaller radius)
+          // For CW arc (arcDir<0): left of travel = away from centre (larger radius)
           sign = arcDir > 0 ?
-            (distToCenter < currentRadius ? 1 : -1) :
-            (distToCenter >= currentRadius ? 1 : -1);
+            (distToCentre < currentRadius ? 1 : -1) :
+            (distToCentre >= currentRadius ? 1 : -1);
         }
       }
     }
@@ -221,19 +221,19 @@ export class Offset extends Tool {
           bulge: 0,
         });
       } else {
-        const center = A.bulgeCentrePoint(B);
-        const currentRadius = center.distance(A);
+        const centre = A.bulgeCentrePoint(B);
+        const currentRadius = centre.distance(A);
         const arcDir = A.bulge > 0 ? 1 : -1;
         const newRadius = currentRadius - arcDir * distance * sign;
         if (newRadius <= 0) return null;
-        const startAngle = Math.atan2(A.y - center.y, A.x - center.x);
-        const endAngle = Math.atan2(B.y - center.y, B.x - center.x);
+        const startAngle = Math.atan2(A.y - centre.y, A.x - centre.x);
+        const endAngle = Math.atan2(B.y - centre.y, B.x - centre.x);
         offsetSegs.push({
           type: 'arc',
-          A: new Point(center.x + newRadius * Math.cos(startAngle), center.y + newRadius * Math.sin(startAngle)),
-          B: new Point(center.x + newRadius * Math.cos(endAngle), center.y + newRadius * Math.sin(endAngle)),
+          A: new Point(centre.x + newRadius * Math.cos(startAngle), centre.y + newRadius * Math.sin(startAngle)),
+          B: new Point(centre.x + newRadius * Math.cos(endAngle), centre.y + newRadius * Math.sin(endAngle)),
           bulge: A.bulge,
-          center,
+          centre,
           radius: newRadius,
         });
       }
@@ -309,9 +309,9 @@ export class Offset extends Tool {
         const dist = throughPoint.distance(closest);
         if (dist < minDist) minDist = dist;
       } else {
-        const center = A.bulgeCentrePoint(B);
-        const radius = center.distance(A);
-        const dist = Math.abs(center.distance(throughPoint) - radius);
+        const centre = A.bulgeCentrePoint(B);
+        const radius = centre.distance(A);
+        const dist = Math.abs(centre.distance(throughPoint) - radius);
         if (dist < minDist) minDist = dist;
       }
     }

package/core/tools/purge.js

@@ -60,31 +60,31 @@ export class Purge extends Tool {
     let purgedCount = 0;
 
     if (this.option === 'Blocks' || this.option === 'All') {
-      const intialitemCount = DesignCore.Scene.blockManager.itemCount();
+      const initialItemCount = DesignCore.Scene.blockManager.itemCount();
       DesignCore.Scene.blockManager.purge();
-      const finalitemCount = DesignCore.Scene.blockManager.itemCount();
-      purgedCount += (intialitemCount - finalitemCount);
+      const finalItemCount = DesignCore.Scene.blockManager.itemCount();
+      purgedCount += (initialItemCount - finalItemCount);
     }
 
     if (this.option === 'Dimstyles' || this.option === 'All') {
-      const intialitemCount = DesignCore.DimStyleManager.itemCount();
+      const initialItemCount = DesignCore.DimStyleManager.itemCount();
       DesignCore.DimStyleManager.purge();
-      const finalitemCount = DesignCore.DimStyleManager.itemCount();
-      purgedCount += (intialitemCount - finalitemCount);
+      const finalItemCount = DesignCore.DimStyleManager.itemCount();
+      purgedCount += (initialItemCount - finalItemCount);
     }
 
     if (this.option === 'Layers' || this.option === 'All') {
-      const intialLayerCount = DesignCore.LayerManager.itemCount();
+      const initialLayerCount = DesignCore.LayerManager.itemCount();
       DesignCore.LayerManager.purge();
       const finalLayerCount = DesignCore.LayerManager.itemCount();
-      purgedCount += (intialLayerCount - finalLayerCount);
+      purgedCount += (initialLayerCount - finalLayerCount);
     }
 
     if (this.option === 'LTypes' || this.option === 'All') {
-      const intialLTypeCount = DesignCore.LTypeManager.itemCount();
+      const initialLTypeCount = DesignCore.LTypeManager.itemCount();
       DesignCore.LTypeManager.purge();
       const finalLTypeCount = DesignCore.LTypeManager.itemCount();
-      purgedCount += (intialLTypeCount - finalLTypeCount);
+      purgedCount += (initialLTypeCount - finalLTypeCount);
     }
 
     DesignCore.Core.notify(`${this.type} - ${this.option}: ${purgedCount} ${Strings.Strings.ITEMS} ${Strings.Strings.REMOVED}`);

package/core/tools/rotate.js

@@ -73,7 +73,7 @@ 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
+          // restore inputPoint to the rotation centre 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) {
@@ -99,22 +99,22 @@ export class Rotate extends Tool {
     const mousePoint = DesignCore.Mouse.pointOnScene();
 
     if (this.points.length >= 1 && this.baseAngle !== null || this.basePoint !== null) {
-      // Draw a rubber-band line from center to mouse
-      const center = this.basePoint === null ? this.points.at(0) : this.basePoint;
-      DesignCore.Scene.auxiliaryEntities.add(new RubberBand([center, mousePoint]));
+      // Draw a rubber-band line from centre to mouse
+      const centre = this.basePoint === null ? this.points.at(0) : this.basePoint;
+      DesignCore.Scene.auxiliaryEntities.add(new RubberBand([centre, mousePoint]));
     }
 
     if (this.points.length >= 1) {
       const ang = this.points[0].angle(mousePoint);
       const theta = this.baseAngle === null ? 0 : ang - this.baseAngle;
-      const center = this.points[0];
+      const centre = this.points[0];
 
-      for (let i = 0; i < DesignCore.Scene.selectionManager.selectedItems.length; i++) {
-        const item = DesignCore.Scene.selectionManager.selectedItems[i];
+      for (let i = 0; i < DesignCore.Scene.selectionManager.selectedEntities.length; i++) {
+        const entity = DesignCore.Scene.selectionManager.selectedEntities[i];
         // get the original points from the scene entities
         const entityIndex = DesignCore.Scene.selectionManager.selectionSet.selectionSet[i];
-        const originalItem = DesignCore.Scene.entities.get(entityIndex);
-        item.setProperty('points', this.getRotatedPoints(originalItem.points, center, theta));
+        const originalEntity = DesignCore.Scene.entities.get(entityIndex);
+        entity.setProperty('points', this.getRotatedPoints(originalEntity.points, centre, theta));
       }
     }
   };
@@ -125,13 +125,13 @@ export class Rotate extends Tool {
   action() {
     const ang = this.points[0].angle(this.points[1]);
     const theta = ang - this.baseAngle;
-    const center = this.points[0];
+    const centre = this.points[0];
 
     const stateChanges = [];
 
     for (let index = 0; index < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; index++) {
-      const item = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[index]);
-      const stateChange = new UpdateState(item, { points: this.getRotatedPoints(item.points, center, theta) });
+      const entity = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[index]);
+      const stateChange = new UpdateState(entity, { points: this.getRotatedPoints(entity.points, centre, theta) });
       stateChanges.push(stateChange);
     }
 
@@ -141,12 +141,12 @@ export class Rotate extends Tool {
   /**
  * Get rotated points
  * @param {Array} points
- * @param {Point} center
- * @param {Point} theta
+ * @param {Point} centre
+ * @param {number} theta
  * @return {Array} rotatedPoints
  */
-  getRotatedPoints(points, center, theta) {
-    const rotatedPoints = points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(center, theta));
+  getRotatedPoints(points, centre, theta) {
+    const rotatedPoints = points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(centre, theta));
     return rotatedPoints;
   }
 }

package/core/tools/scale.js

@@ -130,11 +130,11 @@ export class Scale extends Tool {
 
       const factor = this.referenceLength !== null ? distance / this.referenceLength : distance;
 
-      for (let i = 0; i < DesignCore.Scene.selectionManager.selectedItems.length; i++) {
-        const item = DesignCore.Scene.selectionManager.selectedItems[i];
+      for (let i = 0; i < DesignCore.Scene.selectionManager.selectedEntities.length; i++) {
+        const entity = DesignCore.Scene.selectionManager.selectedEntities[i];
         const entityIndex = DesignCore.Scene.selectionManager.selectionSet.selectionSet[i];
-        const originalItem = DesignCore.Scene.entities.get(entityIndex);
-        item.setProperty('points', this.getScaledPoints(originalItem.points, base, factor));
+        const originalEntity = DesignCore.Scene.entities.get(entityIndex);
+        entity.setProperty('points', this.getScaledPoints(originalEntity.points, base, factor));
       }
     }
   }
@@ -147,8 +147,8 @@ export class Scale extends Tool {
     const stateChanges = [];
 
     for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-      const item = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]);
-      const stateChange = new UpdateState(item, { points: this.getScaledPoints(item.points, base, this.scaleFactor) });
+      const entity = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]);
+      const stateChange = new UpdateState(entity, { points: this.getScaledPoints(entity.points, base, this.scaleFactor) });
       stateChanges.push(stateChange);
     }
 

package/core/tools/trim.js

@@ -20,7 +20,7 @@ export class Trim extends Tool {
   /** Create a Trim command */
   constructor() {
     super();
-    this.selectedItem = null;
+    this.selectedEntity = null;
     this.selectedBoundaryItems = [];
   }
 
@@ -49,7 +49,7 @@ export class Trim 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);
@@ -59,7 +59,7 @@ export class Trim extends Tool {
       while (true) {
         const selection = await DesignCore.Scene.inputManager.requestInput(selectOp);
         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();
       }
@@ -103,26 +103,26 @@ export class Trim extends Tool {
    * Perform the command
    */
   action() {
-    if (this.selectedItem && this.selectedBoundaryItems.length) {
-      if (typeof this.selectedItem.fromPolylinePoints !== 'function') {
-        DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOTRIM}`);
-        this.selectedItem = null;
+    if (this.selectedEntity && this.selectedBoundaryItems.length) {
+      if (typeof this.selectedEntity.fromPolylinePoints !== 'function') {
+        DesignCore.Core.notify(`${this.type} - ${this.selectedEntity.type} ${Strings.Message.NOTRIM}`);
+        this.selectedEntity = null;
         return;
       }
 
-      const intersectPoints = this.#collectIntersectPoints(this.selectedItem);
+      const intersectPoints = this.#collectIntersectPoints(this.selectedEntity);
 
       if (intersectPoints.length) {
-        const stateChanges = this.#trimEntity(this.selectedItem, intersectPoints);
+        const stateChanges = this.#trimEntity(this.selectedEntity, intersectPoints);
         if (stateChanges?.length) {
           DesignCore.Scene.commit(stateChanges);
         }
       } else {
-        DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOTRIM}`);
+        DesignCore.Core.notify(`${this.type} - ${this.selectedEntity.type} ${Strings.Message.NOTRIM}`);
       }
     }
 
-    this.selectedItem = null;
+    this.selectedEntity = null;
   }
 
   /**
@@ -150,7 +150,7 @@ export class Trim extends Tool {
    * surrounding the mouse position. Operates entirely in polyline-point space
    * via entity.toPolylinePoints() / entity.fromPolylinePoints(), so it works
    * for any entity that implements that protocol (Line, Arc, Circle,
-   * BasePolyline, and future entities such as Spline or Ellipse).
+   * PolylineBase, and future entities such as Spline or Ellipse).
    * @param {Object} entity
    * @param {Array}  intersectPoints
    * @return {Array}
@@ -296,10 +296,10 @@ export class Trim extends Tool {
     if (fromLoc.segmentIndex === toLoc.segmentIndex) {
       const startPoint = fromLoc.point.clone();
       if (fromSegStart.bulge !== 0 && fromSegStart.bulge !== undefined) {
-        const center = fromSegStart.bulgeCentrePoint(fromSegEnd);
+        const centre = fromSegStart.bulgeCentrePoint(fromSegEnd);
         const direction = fromSegStart.bulge > 0 ? 1 : -1;
-        const startAngle = center.angle(fromLoc.point);
-        const endAngle = center.angle(toLoc.point);
+        const startAngle = centre.angle(fromLoc.point);
+        const endAngle = centre.angle(toLoc.point);
         const includedAngle = ((endAngle - startAngle) * direction + 4 * Math.PI) % (2 * Math.PI);
         startPoint.bulge = Math.tan(includedAngle / 4) * direction;
       }