@design-core/core 0.0.6 → 50.1.0

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'];
   }
 
   /**
@@ -49,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]);
@@ -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,18 +75,18 @@ 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)) {
-        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.direction !== undefined) {
-            item.setProperty('direction', -originalItem.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'));
           }
         }
       }
@@ -108,20 +109,20 @@ 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.direction !== undefined) updates.direction = -item.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.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,17 +67,16 @@ 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]);
       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,14 +102,13 @@ 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);
-        previewEntity.fromPolylinePoints(offsetPoints);
-        DesignCore.Scene.tempEntities.add(previewEntity);
+        const previewEntity = Utils.cloneObject(this.selectedEntity).fromPolylinePoints(offsetPoints);
+        DesignCore.Scene.previewEntities.add(previewEntity);
       }
     }
   }
@@ -119,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) {
@@ -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]);
@@ -189,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);
         }
       }
     }
@@ -223,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,
         });
       }
@@ -311,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/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/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

@@ -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 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) {
           const basePoint = this.points.at(0);
           const angle = Utils.degrees2radians(input2);
@@ -95,23 +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 line
-      const center = this.basePoint === null ? this.points.at(0) : this.basePoint;
-      const points = [center, mousePoint];
-      DesignCore.Scene.tempEntities.create('Line', { points: points });
+      // 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));
       }
     }
   };
@@ -122,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);
     }
 
@@ -138,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

@@ -122,7 +122,7 @@ export class Scale extends Tool {
     if (this.points.length >= 1 && this.referencePoint === null) {
       // Draw a line from base point to mouse
       const points = [this.points[0], mousePoint];
-      DesignCore.Scene.tempEntities.create('Line', { points: points });
+      DesignCore.Scene.previewEntities.create('Line', { points: points });
 
       const base = this.points[0];
       const distance = base.distance(mousePoint);
@@ -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);
     }