@design-core/core 0.0.4 → 0.0.6

package/core/entities/arc.js

@@ -10,12 +10,15 @@ import { AddState, RemoveState } from '../lib/stateManager.js';
 
 import { DesignCore } from '../designCore.js';
 import { Property } from '../properties/property.js';
+import { SnapPoint } from '../lib/snapping.js';
 
 /**
  * Arc Entity Class
  * @extends Entity
  * */
 export class Arc extends Entity {
+  static type = 'Arc';
+
   /**
    * Create an Arc Entity
    * @param {Array} data
@@ -392,31 +395,45 @@ export class Arc extends Entity {
   snaps(mousePoint, delta) {
     const snaps = [];
 
-    if (DesignCore.Settings.endsnap) {
-      // Speed this up by generating the proper start and end points when the arc is initialised
-      const startPoint = new Point(
-          this.points[0].x + (this.radius * Math.cos(this.startAngle())),
-          this.points[0].y + (this.radius * Math.sin(this.startAngle())),
-      );
-      const endPoint = new Point(
-          this.points[0].x + (this.radius * Math.cos(this.endAngle())),
-          this.points[0].y + (this.radius * Math.sin(this.endAngle())),
-      );
-
-      snaps.push(startPoint, endPoint);
-    }
+    const centre = this.points[0]; // arc centre point
+    const arcStartPoint = this.points[1]; // arc start point on circumference
+    const arcEndPoint = this.points[2]; // arc end point on circumference
+
+    snaps.push(new SnapPoint(centre, SnapPoint.Type.CENTRE));
+    snaps.push(new SnapPoint(arcStartPoint, SnapPoint.Type.END));
+    snaps.push(new SnapPoint(arcEndPoint, SnapPoint.Type.END));
 
-    if (DesignCore.Settings.centresnap) {
-      const centre = this.points[0];
-      snaps.push(centre);
+    if (mousePoint) {
+      const [nearestPoint, nearestDistance, isOnArc] = this.closestPoint(mousePoint);
+      // Crude way to snap to the closest point on the arc
+      if (isOnArc === true && nearestDistance < delta / 10) {
+        snaps.push(new SnapPoint(nearestPoint, SnapPoint.Type.NEAREST));
+      }
     }
 
-    if (DesignCore.Settings.nearestsnap) {
-      const closest = this.closestPoint(mousePoint);
+    const fromPoint = DesignCore.Scene.inputManager.inputPoint; // last confirmed input point (line start)
+    if (fromPoint !== null) {
+      const distanceToCenter = centre.distance(fromPoint); // distance from the input point to the arc centre
+      const angleFromCentreToInput = centre.angle(fromPoint); // angle from centre toward fromPoint
+
+      // Tangent: only possible when fromPoint is outside the arc radius
+      if (distanceToCenter > this.radius) {
+        const tangentHalfAngle = Math.acos(this.radius / distanceToCenter); // half-angle between the two tangent directions
 
-      // Crude way to snap to the closest point or a node
-      if (closest[2] === true && closest[1] < delta / 10) {
-        snaps.push(closest[0]);
+        for (const sign of [1, -1]) {
+          const tangentPoint = centre.project(angleFromCentreToInput + sign * tangentHalfAngle, this.radius);
+          if (tangentPoint.isOnArc(this.points[1], this.points[2], centre, this.direction)) {
+            snaps.push(new SnapPoint(tangentPoint, SnapPoint.Type.TANGENT));
+          }
+        }
+      }
+
+      // Perpendicular: point on the arc that lies on the line from fromPoint through the centre
+      if (distanceToCenter > 0) {
+        const perpendicularPoint = centre.project(angleFromCentreToInput, this.radius);
+        if (perpendicularPoint.isOnArc(this.points[1], this.points[2], centre, this.direction)) {
+          snaps.push(new SnapPoint(perpendicularPoint, SnapPoint.Type.PERPENDICULAR));
+        }
       }
     }
 
@@ -437,7 +454,7 @@ export class Arc extends Entity {
 
     if (pnt !== null) {
       const distance = P.distance(pnt);
-      return [pnt, distance];
+      return [pnt, distance, true];
     }
 
     // closest point not on the arc

package/core/entities/arctext.js

@@ -11,6 +11,7 @@ import { Property } from '../properties/property.js';
 import { Text } from './text.js';
 
 import { DesignCore } from '../designCore.js';
+import { SnapPoint } from '../lib/snapping.js';
 
 /**
  * Arc Aligned Character Class
@@ -95,6 +96,8 @@ export class ArcAlignedCharacter {
  * @extends Entity
  */
 export class ArcAlignedText extends Entity {
+  static type = 'ArcAlignedText';
+
   /**
    * Create a Text Entity
    * @param {Array} data
@@ -566,16 +569,15 @@ export class ArcAlignedText extends Entity {
   snaps(mousePoint, delta) {
     const snaps = [];
 
-    const ArcAlignedCharacters = this.getArcAlignedCharacters();
+    snaps.push(new SnapPoint(this.points[0], SnapPoint.Type.CENTRE)); // arc center
 
+    const ArcAlignedCharacters = this.getArcAlignedCharacters();
     for (const arcAlignedChar of ArcAlignedCharacters) {
       // Don't snap to space characters
       if (arcAlignedChar.character.trim() === '') continue;
-      snaps.push(arcAlignedChar.position);
+      snaps.push(new SnapPoint(arcAlignedChar.position, SnapPoint.Type.NODE));
     }
 
-    snaps.push(this.points[0]); // arc center
-
     return snaps;
   }
 

package/core/entities/basePolyline.js

@@ -13,12 +13,15 @@ import { Property } from '../properties/property.js';
 import { AddState, RemoveState, UpdateState } from '../lib/stateManager.js';
 
 import { DesignCore } from '../designCore.js';
+import { SnapPoint } from '../lib/snapping.js';
 
 /**
  * Base Polyline Entity Class
  * @extends Entity
  */
 export class BasePolyline extends Entity {
+  static type = 'BasePolyline';
+
   /**
    * Create a Base Polyline
    * @param {Array} data
@@ -268,35 +271,40 @@ export class BasePolyline extends Entity {
   snaps(mousePoint, delta) {
     const snaps = [];
 
-    if (DesignCore.Settings.endsnap) {
-      // End points for each segment
-      for (let i = 0; i < this.points.length; i++) {
-        snaps.push(this.points[i]);
-      }
+    // End points for each segment
+    for (let i = 0; i < this.points.length; i++) {
+      snaps.push(new SnapPoint(this.points[i], SnapPoint.Type.END));
     }
 
-    if (DesignCore.Settings.midsnap) {
-      for (let i = 1; i < this.points.length; i++) {
-        if (this.points[i - 1].bulge === 0) {
-          snaps.push(this.points[i - 1].midPoint(this.points[i]));
-        }
+    for (let i = 1; i < this.points.length; i++) {
+      if (this.points[i - 1].bulge === 0) {
+        snaps.push(new SnapPoint(this.points[i - 1].midPoint(this.points[i]), SnapPoint.Type.MID));
       }
     }
 
-    if (DesignCore.Settings.centresnap) {
-      for (let i = 1; i < this.points.length; i++) {
-        if (this.points[i - 1].bulge !== 0) {
-          snaps.push(this.points[i - 1].bulgeCentrePoint(this.points[i]));
-        }
+    for (let i = 1; i < this.points.length; i++) {
+      if (this.points[i - 1].bulge !== 0) {
+        snaps.push(new SnapPoint(this.points[i - 1].bulgeCentrePoint(this.points[i]), SnapPoint.Type.CENTRE));
       }
     }
 
-    if (DesignCore.Settings.nearestsnap) {
+    if (mousePoint) {
       const closest = this.closestPoint(mousePoint);
-
       // Crude way to snap to the closest point or a node
       if (closest[1] < delta / 10) {
-        snaps.push(closest[0]);
+        snaps.push(new SnapPoint(closest[0], SnapPoint.Type.NEAREST));
+      }
+    }
+
+    const fromPoint = DesignCore.Scene.inputManager.inputPoint;
+    if (fromPoint !== null) {
+      for (let i = 1; i < this.points.length; i++) {
+        if (this.points[i - 1].bulge === 0) {
+          const foot = fromPoint.perpendicular(this.points[i - 1], this.points[i]);
+          if (foot.isOnLine(this.points[i - 1], this.points[i])) {
+            snaps.push(new SnapPoint(foot, SnapPoint.Type.PERPENDICULAR));
+          }
+        }
       }
     }
 
@@ -390,9 +398,10 @@ export class BasePolyline extends Entity {
     let distance = Infinity;
     let minPnt = P;
 
-    for (let i = 1; i < this.points.length; i++) {
+    const segmentCount = this.flags.hasFlag(1) ? this.points.length : this.points.length - 1;
+    for (let i = 1; i <= segmentCount; i++) {
       const A = this.points[i - 1];
-      const B = this.points[i];
+      const B = this.points[i % this.points.length];
 
       let pnt;
       if (A.bulge !== 0) {

package/core/entities/circle.js

@@ -10,12 +10,15 @@ import { Utils } from '../lib/utils.js';
 
 import { DesignCore } from '../designCore.js';
 import { AddState, RemoveState } from '../lib/stateManager.js';
+import { SnapPoint } from '../lib/snapping.js';
 
 /**
  * Circle Entity Class
  * @extends Entity
  */
 export class Circle extends Entity {
+  static type = 'Circle';
+
   /**
    * Create a Circle Entity
    * @param {Array} data
@@ -246,26 +249,41 @@ export class Circle extends Entity {
   snaps(mousePoint, delta) {
     const snaps = [];
 
-    if (DesignCore.Settings.centresnap) {
-      const centre = new Point(this.points[0].x, this.points[0].y);
-      snaps.push(centre);
-    }
+    const centre = this.points[0]; // circle centre point
 
-    if (DesignCore.Settings.quadrantsnap) {
-      const angle0 = new Point(this.points[0].x + this.radius, this.points[0].y);
-      const angle90 = new Point(this.points[0].x, this.points[0].y + this.radius);
-      const angle180 = new Point(this.points[0].x - this.radius, this.points[0].y);
-      const angle270 = new Point(this.points[0].x, this.points[0].y - this.radius);
+    snaps.push(new SnapPoint(centre, SnapPoint.Type.CENTRE));
 
-      snaps.push(angle0, angle90, angle180, angle270);
+    snaps.push(
+        new SnapPoint(new Point(centre.x + this.radius, centre.y), SnapPoint.Type.QUADRANT), // 0°
+        new SnapPoint(new Point(centre.x, centre.y + this.radius), SnapPoint.Type.QUADRANT), // 90°
+        new SnapPoint(new Point(centre.x - this.radius, centre.y), SnapPoint.Type.QUADRANT), // 180°
+        new SnapPoint(new Point(centre.x, centre.y - this.radius), SnapPoint.Type.QUADRANT), // 270°
+    );
+
+    if (mousePoint) {
+      const [nearestPoint, nearestDistance] = this.closestPoint(mousePoint);
+      // Crude way to snap to the closest point on the circle
+      if (nearestDistance < delta / 10) {
+        snaps.push(new SnapPoint(nearestPoint, SnapPoint.Type.NEAREST));
+      }
     }
 
-    if (DesignCore.Settings.nearestsnap) {
-      const closest = this.closestPoint(mousePoint);
+    const fromPoint = DesignCore.Scene.inputManager.inputPoint; // last confirmed input point (line start)
+    if (fromPoint !== null) {
+      const distanceToCenter = centre.distance(fromPoint); // distance from the input point to the circle centre
+      const angleFromCentreToInput = centre.angle(fromPoint); // angle from centre toward fromPoint
+
+      // Tangent: only possible when fromPoint is outside the circle radius
+      if (distanceToCenter > this.radius) {
+        const tangentHalfAngle = Math.acos(this.radius / distanceToCenter); // half-angle between the two tangent directions
+
+        snaps.push(new SnapPoint(centre.project(angleFromCentreToInput + tangentHalfAngle, this.radius), SnapPoint.Type.TANGENT));
+        snaps.push(new SnapPoint(centre.project(angleFromCentreToInput - tangentHalfAngle, this.radius), SnapPoint.Type.TANGENT));
+      }
 
-      // Crude way to snap to the closest point or a node
-      if (closest[1] < delta / 10) {
-        snaps.push(closest[0]);
+      // Perpendicular: point on the circle that lies on the line from fromPoint through the centre
+      if (distanceToCenter > 0) {
+        snaps.push(new SnapPoint(centre.project(angleFromCentreToInput, this.radius), SnapPoint.Type.PERPENDICULAR));
       }
     }
 

package/core/entities/entity.js

@@ -19,7 +19,7 @@ export class Entity {
    */
   constructor(data) {
     Object.defineProperty(this, 'type', {
-      value: this.constructor.name,
+      value: this.constructor.type ?? this.constructor.name,
       writable: true,
     });
 

package/core/entities/hatch.js

@@ -25,6 +25,8 @@ import { Property } from '../properties/property.js';
  * @extends Entity
  */
 export class Hatch extends Entity {
+  static type = 'Hatch';
+
   /**
    * Create a Hatch Entity
    * @param {Array} data

package/core/entities/insert.js

@@ -9,6 +9,7 @@ import { Property } from '../properties/property.js';
 import { Logging } from '../lib/logging.js';
 
 import { DesignCore } from '../designCore.js';
+import { SnapPoint } from '../lib/snapping.js';
 
 
 /**
@@ -16,6 +17,8 @@ import { DesignCore } from '../designCore.js';
  * @extends Entity
  */
 export class Insert extends Entity {
+  static type = 'Insert';
+
   /**
    * Create an Insert
    * Inserts are used to define the location of blocks
@@ -209,15 +212,18 @@ export class Insert extends Entity {
    */
   snaps(mousePoint, delta) {
     const snaps = [];
+
+    snaps.push(new SnapPoint(this.points[0], SnapPoint.Type.NODE));
+
     const blockSnaps = this.block.snaps(mousePoint, delta);
 
     for (let snap = 0; snap < blockSnaps.length; snap++) {
-      const snapPoint = blockSnaps[snap];
+      const sp = blockSnaps[snap];
       // offset the item snap point by the block insert location
-      const rotatedPoint = snapPoint.add(this.points[0]);
+      const rotatedPoint = sp.snapPoint.add(this.points[0]);
       // rotate the snap point to match the item positions
       const adjustedPoint = rotatedPoint.rotate(this.points[0], Utils.degrees2radians(this.rotation));
-      snaps.push(adjustedPoint);
+      snaps.push(new SnapPoint(adjustedPoint, sp.type));
     }
 
     return snaps;

package/core/entities/line.js

@@ -9,6 +9,7 @@ import { AddState, RemoveState, UpdateState } from '../lib/stateManager.js';
 
 import { DesignCore } from '../designCore.js';
 import { Utils } from '../lib/utils.js';
+import { SnapPoint } from '../lib/snapping.js';
 
 
 /**
@@ -16,6 +17,8 @@ import { Utils } from '../lib/utils.js';
  * @extends Entity
  */
 export class Line extends Entity {
+  static type = 'Line';
+
   /**
    * Create a Line Entity
    * @param {Array} data
@@ -295,22 +298,24 @@ export class Line extends Entity {
   snaps(mousePoint, delta) {
     const snaps = [];
 
-    if (DesignCore.Settings.endsnap) {
-      const start = new Point(this.points[0].x, this.points[0].y);
-      const end = new Point(this.points[1].x, this.points[1].y);
-      snaps.push(start, end);
-    }
+    snaps.push(new SnapPoint(this.points[0], SnapPoint.Type.END));
+    snaps.push(new SnapPoint(this.points[1], SnapPoint.Type.END));
 
-    if (DesignCore.Settings.midsnap) {
-      snaps.push(this.midPoint());
-    }
+    snaps.push(new SnapPoint(this.midPoint(), SnapPoint.Type.MID));
 
-    if (DesignCore.Settings.nearestsnap) {
+    if (mousePoint) {
       const closest = this.closestPoint(mousePoint);
-
       // Crude way to snap to the closest point or a node
       if (closest[1] < delta / 10) {
-        snaps.push(closest[0]);
+        snaps.push(new SnapPoint(closest[0], SnapPoint.Type.NEAREST));
+      }
+    }
+
+    const fromPoint = DesignCore.Scene.inputManager.inputPoint;
+    if (fromPoint !== null) {
+      const foot = fromPoint.perpendicular(this.points[0], this.points[1]);
+      if (foot.isOnLine(this.points[0], this.points[1])) {
+        snaps.push(new SnapPoint(foot, SnapPoint.Type.PERPENDICULAR));
       }
     }
 

package/core/entities/lwpolyline.js

@@ -7,6 +7,8 @@ import { Polyline } from './polyline.js';
  * @extends BasePolyline
  */
 export class Lwpolyline extends BasePolyline {
+  static type = 'Lwpolyline';
+
   /**
    * Create an LW Polyline
    * @param {Array} data

package/core/entities/point.js

@@ -3,6 +3,8 @@ import { Constants } from '../lib/constants.js';
 
 /** Point Entity Class */
 export class Point {
+  static type = 'Point';
+
   /**
    * Create a Point
    * @param  {number} x
@@ -11,7 +13,7 @@ export class Point {
    * @param  {number} sequence - dxf group code sequence reference
    */
   constructor(x, y, bulge = 0, sequence) {
-    this.type = this.constructor.name;
+    this.type = this.constructor.type ?? this.constructor.name;
     this.x = 0;
     this.y = 0;
     // sequence holds a reference to the dxf group code sequence the point represents

package/core/entities/polyline.js

@@ -7,6 +7,8 @@ import { Point } from './point.js';
  * @extends BasePolyline
  */
 export class Polyline extends BasePolyline {
+  static type = 'Polyline';
+
   /**
    * Create a Polyline
    * @param {Array} data

package/core/entities/rectangle.js

@@ -12,6 +12,8 @@ import { DesignCore } from '../designCore.js';
  * @extends Entity
  */
 export class Rectangle extends Entity {
+  static type = 'Rectangle';
+
   /**
    * Create a Rectangle
    * @param {Array} data

package/core/entities/solid.js

@@ -7,6 +7,8 @@ import { BoundingBox } from '../lib/boundingBox.js';
  * @extends Entity
  */
 export class Solid extends Entity {
+  static type = 'Solid';
+
   /**
    * Create a Solid Entity
    * @param {Array} data

package/core/entities/text.js

@@ -10,12 +10,15 @@ import { Flags } from '../properties/flags.js';
 import { Property } from '../properties/property.js';
 
 import { DesignCore } from '../designCore.js';
+import { SnapPoint } from '../lib/snapping.js';
 
 /**
  * Text Entity Class
  * @extends Entity
  */
 export class Text extends Entity {
+  static type = 'Text';
+
   /**
    * Create a Text Entity
    * @param {Array} data
@@ -506,15 +509,9 @@ export class Text extends Entity {
    * @return {Array} - array of snap points
    */
   snaps(mousePoint, delta) {
-    const frameCorners = this.getTextFrameCorners();
-    const mid = frameCorners[0].midPoint(frameCorners[2]);
-    const snaps = [...frameCorners, mid];
+    const snaps = [];
 
-    // add insertion point if not already in snaps
-    // this adds an extra snap point when alignment != 0.
-    if (!snaps.some((point) => point.isSame(this.points[0]))) {
-      snaps.push(this.points[0]);
-    }
+    snaps.push(new SnapPoint(this.points[0], SnapPoint.Type.NODE));
 
     return snaps;
   }

package/core/lib/input.js

@@ -1,8 +1,12 @@
 /** Sentinel resolved when a MOUSEDOWN prompt completes */
-export class MouseDown {}
+export class MouseDown {
+  static type = 'MouseDown';
+}
 
 /** Sentinel resolved when a MOUSEUP prompt completes */
-export class MouseUp {}
+export class MouseUp {
+  static type = 'MouseUp';
+}
 
 /** Input Class */
 export class Input {
@@ -16,7 +20,7 @@ export class Input {
   /**
    * Input type definitions.
    * Each entry describes an accepted input type:
-   *   value  — matches value.constructor.name for runtime type detection via getType()
+   *   value  — matched against value.constructor.type (if defined) or value.constructor.name for runtime type detection via getType()
    *   cursor — the cursor state to apply when this type is requested (null = DEFAULT)
    */
   static Type = {
@@ -40,7 +44,7 @@ export class Input {
       return undefined;
     }
 
-    const name = value.constructor.name;
+    const name = value.constructor.type ?? value.constructor.name;
     return Object.values(Input.Type).find((t) => t.value === name);
   }
 }

package/core/lib/inputManager.js

@@ -29,7 +29,7 @@ export class InputManager {
    * Reset the inputManager
    */
   reset() {
-    this.snapping.active = false;
+    this.snapping.reset();
     this.inputPoint = null;
     DesignCore.CommandLine.resetPrompt();
     this.activeCommand = undefined;
@@ -80,7 +80,7 @@ export class InputManager {
         this.inputPoint = input;
       }
 
-      this.snapping.active = false;
+      this.snapping.reset();
       return input;
     });
   }
@@ -213,7 +213,6 @@ export class InputManager {
       const selection = DesignCore.Scene.selectionManager.singleSelect(DesignCore.Mouse.pointOnScene());
       this.onSelection(selection);
     } else if (this.promptOption !== undefined && this.promptOption.types.includes(Input.Type.POINT)) {
-      this.snapping.active = false;
       this.promptOption.respond(point);
     }
   }
@@ -294,8 +293,7 @@ export class InputManager {
    * Handle single selection
    */
   singleSelect() {
-    this.inputPoint = DesignCore.Mouse.pointOnScene();
-    this.onLeftClick(this.inputPoint);
+    this.onLeftClick(DesignCore.Mouse.pointOnScene());
   }
 
   /**

package/core/lib/selectionManager.js

@@ -5,6 +5,8 @@ import { DesignCore } from '../designCore.js';
 
 /** SingleSelection Class */
 export class SingleSelection {
+  static type = 'SingleSelection';
+
   /**
    * Create a SingleSelection
    * @param {number} index
@@ -18,6 +20,8 @@ export class SingleSelection {
 
 /** SelectionSet Class */
 export class SelectionSet {
+  static type = 'SelectionSet';
+
   /** Create SelectionSet */
   constructor() {
     this.accepted = false;

package/core/lib/settings.js

@@ -5,11 +5,10 @@ export class Settings {
   /** Create Setting */
   constructor() {
     this.canvasbackgroundcolour = { r: 30, g: 30, b: 30 };
-    this.selecteditemscolour = { r: 0, g: 255, b: 0 };
-    this.snapcolour = { r: 255, g: 0, b: 0 };
     this.gridcolour = { r: 119, g: 118, b: 123 };
-    this.helpergeometrycolour = { r: 0, g: 195, b: 255 };
-    this.polarsnapcolour = { r: 55, g: 180, b: 75 };
+    this.selecteditemscolour = { r: 0, g: 255, b: 0 };
+    this.snaptrackingcolour = { r: 55, g: 180, b: 75 };
+    // selectionWindow and crossingWindow colours
     this.selectionWindow = { r: 0, g: 255, b: 0 };
     this.crossingWindow = { r: 0, g: 0, b: 255 };
     // fontSettings
@@ -22,9 +21,14 @@ export class Settings {
     this.centresnap = true;
     this.nearestsnap = false;
     this.quadrantsnap = false;
-    this.polarangle = 45;
+    this.tangentsnap = false;
+    this.nodesnap = false;
+    this.perpendicularsnap = false;
+    // trackingSettings
     this.polar = true;
+    this.polarangle = 45;
     this.ortho = false;
+    // gridSettings
     this.drawgrid = true;
   }