@design-core/core 0.0.5 → 0.0.7

package/core/dimensions/rotatedDimension.js

@@ -7,6 +7,8 @@ import { Point } from '../entities/point.js';
 import { BaseLinearDimension } from './baseLinearDimension.js';
 
 import { DesignCore } from '../designCore.js';
+import { Property } from '../properties/property.js';
+import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 
 /**
@@ -42,12 +44,12 @@ export class RotatedDimension extends BaseLinearDimension {
   async execute() {
     try {
       DesignCore.Scene.selectionManager.reset();
-      this.dimensionStyle = DesignCore.DimStyleManager.getCstyle();
+      this.setProperty(Property.Names.DIMENSIONSTYLE, DesignCore.DimStyleManager.getCstyle());
       this.dimType.setDimType(0); // Rotated dimension
 
       const opAngle = new PromptOptions(Strings.Input.ROTATION, [Input.Type.NUMBER]);
       const angleValue = await DesignCore.Scene.inputManager.requestInput(opAngle);
-      this.linearDimAngle = Number(angleValue) || 0;
+      this.setProperty(Property.Names.LINEARDIMANGLE, Number(angleValue) || 0);
 
       const op = new PromptOptions(Strings.Input.START, [Input.Type.POINT]);
       const pt13 = await DesignCore.Scene.inputManager.requestInput(op);
@@ -65,7 +67,7 @@ export class RotatedDimension extends BaseLinearDimension {
       this.points.push(pt11);
 
       const tempLine = new Line({ points: [pt13, pt14] });
-      this.points = RotatedDimension.getPointsFromSelection([tempLine], pt11, this.linearDimAngle);
+      this.points = RotatedDimension.getPointsFromSelection([tempLine], pt11, this.getProperty(Property.Names.LINEARDIMANGLE));
 
       DesignCore.Scene.inputManager.executeCommand(this);
     } catch (err) {
@@ -117,16 +119,15 @@ export class RotatedDimension extends BaseLinearDimension {
   preview() {
     if (this.points.length === 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
-      const points = [this.points.at(0), mousePoint];
-      DesignCore.Scene.tempEntities.create('Line', { points: points });
+      DesignCore.Scene.auxiliaryEntities.add(new RubberBand([this.points.at(0), mousePoint]));
     }
 
     if (this.points.length > 1) {
       const pt11 = DesignCore.Mouse.pointOnScene();
       pt11.sequence = 11;
       const tempLine = new Line({ points: [this.points[0], this.points[1]] });
-      const points = RotatedDimension.getPointsFromSelection([tempLine], pt11, this.linearDimAngle);
-      DesignCore.Scene.tempEntities.create(this.type, { points: points, dimensionStyle: this.dimensionStyle });
+      const points = RotatedDimension.getPointsFromSelection([tempLine], pt11, this.getProperty(Property.Names.LINEARDIMANGLE));
+      DesignCore.Scene.previewEntities.create(this.type, { points: points, dimensionStyle: this.getProperty(Property.Names.DIMENSIONSTYLE) });
     }
   }
 
@@ -141,10 +142,10 @@ export class RotatedDimension extends BaseLinearDimension {
     const Pt14 = this.getPointBySequence(this.points, 14);
 
     file.writeGroupCode('0', 'DIMENSION');
-    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('5', this.getProperty(Property.Names.HANDLE), DXFFile.Version.R2000); // Handle
     file.writeGroupCode('100', 'AcDbEntity', DXFFile.Version.R2000);
     file.writeGroupCode('100', 'AcDbDimension', DXFFile.Version.R2000);
-    file.writeGroupCode('8', this.layer);
+    file.writeGroupCode('8', this.getProperty(Property.Names.LAYER));
     // file.writeGroupCode('2', this.blockName);  // Block not required
     file.writeGroupCode('10', Pt10.x); // X - definition / arrow point
     file.writeGroupCode('20', Pt10.y); // Y
@@ -153,7 +154,7 @@ export class RotatedDimension extends BaseLinearDimension {
     file.writeGroupCode('21', Pt11.y); // Y
     file.writeGroupCode('31', '0.0'); // Z
     file.writeGroupCode('70', this.dimType.getDimType()); // DIMENSION TYPE
-    file.writeGroupCode('3', this.dimensionStyle); // DIMENSION STYLE
+    file.writeGroupCode('3', this.getProperty(Property.Names.DIMENSIONSTYLE)); // DIMENSION STYLE
     file.writeGroupCode('100', 'AcDbAlignedDimension', DXFFile.Version.R2000);
     file.writeGroupCode('13', Pt13.x); // X - start point of first extension line
     file.writeGroupCode('23', Pt13.y); // Y
@@ -161,7 +162,7 @@ export class RotatedDimension extends BaseLinearDimension {
     file.writeGroupCode('14', Pt14.x); // X - start point of second extension line
     file.writeGroupCode('24', Pt14.y); // Y
     file.writeGroupCode('34', '0.0'); // Z
-    file.writeGroupCode('50', this.linearDimAngle); // Utils.radians2degrees(Pt13.angle(Pt14))); // Rotation angle
+    file.writeGroupCode('50', this.getProperty(Property.Names.LINEARDIMANGLE)); // Utils.radians2degrees(Pt13.angle(Pt14))); // Rotation angle
     file.writeGroupCode('100', 'AcDbRotatedDimension', DXFFile.Version.R2000);
   }
 }

package/core/entities/arc.js

@@ -6,11 +6,12 @@ import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
 import { DXFFile } from '../lib/dxf/dxfFile.js';
 import { BoundingBox } from '../lib/boundingBox.js';
-import { AddState, RemoveState } from '../lib/stateManager.js';
+
 
 import { DesignCore } from '../designCore.js';
 import { Property } from '../properties/property.js';
-import { SnapPoint } from '../lib/snapping.js';
+import { SnapPoint } from '../lib/auxiliary/snapPoint.js';
+import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 /**
  * Arc Entity Class
@@ -25,46 +26,32 @@ export class Arc extends Entity {
    */
   constructor(data) {
     super(data);
-    this.radius = 1;
-
-    // direction: - ccw > 0, cw <= 0
-    // default to 1 - counter clockwise
-    Object.defineProperty(this, 'direction', {
-      value: 1,
-      writable: true,
-    });
 
-    if (data) {
-      if (data.hasOwnProperty('points') || data.hasOwnProperty('40')) {
-        // DXF Groupcode 40 - Radius
-        // get the radius from the points or the incoming dxf groupcode
-        const radius = this.points[1] ? this.points[0].distance(this.points[1]) : data[40];
-
-        if (radius !== undefined) {
-          this.radius = radius;
-        }
+    // If only the center point is present, project start/end from named scalar properties.
+    // Full-points data (post-execute or post-fromDxf) skips this block entirely.
+    if (data && this.points.length < 2) {
+      const radius = data.radius ?? 1;
+      if (data.hasOwnProperty('startAngle')) {
+        this.points[1] = this.points[0].project(Utils.degrees2radians(data.startAngle), radius);
       }
-
-      if (data.hasOwnProperty('startAngle') || data.hasOwnProperty('50')) {
-        // DXF Groupcode 50 - Start Angle
-
-        const angle = Property.loadValue([data.startAngle, data[50]], 0);
-        const projectionAngle = Utils.degrees2radians(angle);
-        this.points[1] = this.points[0].project(projectionAngle, this.radius);
+      if (data.hasOwnProperty('endAngle')) {
+        this.points[2] = this.points[0].project(Utils.degrees2radians(data.endAngle), radius);
       }
+    }
 
-      if (data.hasOwnProperty('endAngle') || data.hasOwnProperty('51')) {
-        // DXF Groupcode 51 - End Angle
-        const angle = Property.loadValue([data.endAngle, data[51]], 0);
-        const projectionAngle = Utils.degrees2radians(angle);
-        this.points[2] = this.points[0].project(projectionAngle, this.radius);
-      }
+    // direction: ccw > 0, cw <= 0
+    this.properties.add(Property.Names.DIRECTION, {
+      type: Property.Type.NUMBER,
+      value: data?.direction ?? 1,
+      dxfCode: 73,
+    });
 
-      if (data.hasOwnProperty('direction') || data.hasOwnProperty('73')) {
-        // No DXF Groupcode - Arc Direction
-        this.direction = Property.loadValue([data.direction, data[73]], 1);
-      }
-    }
+    // radius: computed from points — stored in EntityProperties
+    this.properties.add(Property.Names.RADIUS, {
+      type: Property.Type.NUMBER,
+      get: (entity) => entity.points[1] ? entity.points[0].distance(entity.points[1]) : 1,
+      dxfCode: 40,
+    });
   }
 
   /**
@@ -79,6 +66,30 @@ export class Arc extends Entity {
     return command;
   }
 
+  /**
+   * Normalise DXF group codes into the canonical points-based representation.
+   * Called by the DXF loader before construction.
+   * @param {Object} data
+   * @return {Object}
+   */
+  static fromDxf(data) {
+    const center = data.points?.[0];
+    if (!center) return data;
+    // validate required group codes for points-based arc representation are present
+    if (data[40] === undefined || data[50] === undefined || data[51] === undefined) return data;
+
+    const radius = data[40];
+    return {
+      ...data,
+      points: [
+        center,
+        center.project(Utils.degrees2radians(data[50] ?? 0), radius),
+        center.project(Utils.degrees2radians(data[51] ?? 0), radius),
+      ],
+      direction: data[73] ?? 1,
+    };
+  }
+
   /**
    * Execute method
    * executes the workflow, requesting input required to create an entity
@@ -90,13 +101,22 @@ export class Arc extends Entity {
       if (pt === undefined) return;
       this.points.push(pt);
 
-      const op1 = new PromptOptions(Strings.Input.START, [Input.Type.POINT]);
-      const pt1 = await DesignCore.Scene.inputManager.requestInput(op1);
-      if (pt1 === undefined) return;
+      let pt1;
+      while (true) {
+        const op1 = new PromptOptions(Strings.Input.START, [Input.Type.POINT]);
+        pt1 = await DesignCore.Scene.inputManager.requestInput(op1);
+        if (pt1 === undefined) return;
+        if (pt1.isSame?.(pt)) {
+          DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDPOINT}`);
+          continue;
+        }
+        break;
+      }
       this.points.push(pt1);
 
       let pt2;
       while (true) {
+        DesignCore.Scene.inputManager.inputPoint = pt; // polar/ortho tracks from center on each attempt
         const op2 = new PromptOptions(`${Strings.Input.END} ${Strings.Strings.OR} ${Strings.Input.ANGLE}`, [Input.Type.POINT, Input.Type.NUMBER]);
         pt2 = await DesignCore.Scene.inputManager.requestInput(op2);
         if (pt2 === undefined) return;
@@ -109,10 +129,18 @@ export class Arc extends Entity {
             DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDPOINT}`);
             continue;
           }
-          this.points.push(pt2);
+
+          const angle = this.points[0].angle(pt2);
+          const projectedEnd = this.points[0].project(angle, this.getProperty(Property.Names.RADIUS));
+          if (projectedEnd.isSame(this.points[1])) {
+            DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDPOINT}`);
+            continue;
+          }
+          this.points.push(projectedEnd);
+
           // Infer arc direction using cross product if we have 3 points
           if (this.points.length === 3) {
-            this.direction = Arc.#inferDirection(this.points[0], this.points[1], this.points[2]);
+            this.setProperty(Property.Names.DIRECTION, Arc.#inferDirection(this.points[0], this.points[1], this.points[2]));
             // Check total angle > 1 degree
             if (Math.abs(this.totalAngle) <= 1) {
               this.points.pop(); // Remove invalid end point
@@ -134,7 +162,7 @@ export class Arc extends Entity {
           const point = startPoint.rotate(basePoint, angle);
           this.points.push(point);
           // Set direction based on sign of angle
-          this.direction = angle >= 0 ? 1 : -1;
+          this.setProperty(Property.Names.DIRECTION, angle >= 0 ? 1 : -1);
           // Check total angle > 1 degree
           if (Math.abs(this.totalAngle) <= 1) {
             this.points.pop(); // Remove invalid end point
@@ -159,13 +187,16 @@ export class Arc extends Entity {
   preview() {
     if (this.points.length >= 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
-      const points = [this.points.at(0), mousePoint];
-      DesignCore.Scene.tempEntities.create('Line', { points: points });
+      DesignCore.Scene.auxiliaryEntities.add(new RubberBand([this.points.at(0), mousePoint]));
     }
 
     if (this.points.length >= 2) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
-      const points = [...this.points, mousePoint];
+      // const points = [...this.points, mousePoint];
+      const center = this.points[0];
+      const endPoint = center.project(center.angle(mousePoint), this.getProperty(Property.Names.RADIUS));
+      if (endPoint.isSame(this.points[1])) return;
+      const points = [...this.points, endPoint];
 
       // Infer direction for preview, so it matches what will be created
       let direction = 1;
@@ -173,7 +204,7 @@ export class Arc extends Entity {
         direction = Arc.#inferDirection(points[0], points[1], points[2]);
       }
 
-      DesignCore.Scene.tempEntities.create(this.type, { points: points, direction: direction });
+      DesignCore.Scene.previewEntities.create(this.type, { points: points, direction: direction });
     }
   }
 
@@ -228,7 +259,7 @@ export class Arc extends Entity {
     let endAngle = this.endAngle();
 
 
-    if (this.direction > 0) {
+    if (this.getProperty(Property.Names.DIRECTION) > 0) {
       if (startAngle > endAngle || startAngle === endAngle) {
         endAngle += (Math.PI * 2);
       }
@@ -245,7 +276,7 @@ export class Arc extends Entity {
    * @return {number} - arc radius
    */
   getRadius() {
-    return this.radius;
+    return this.getProperty(Property.Names.RADIUS);
   }
 
   /**
@@ -253,9 +284,12 @@ export class Arc extends Entity {
    * @param {Object} ctx - context
    * @param {number} scale
    */
-  draw(ctx, scale) {
-    ctx.arc(this.points[0].x, this.points[0].y, this.radius, this.direction > 0 ? this.startAngle() : this.endAngle(), this.direction > 0 ? this.endAngle() : this.startAngle());
-    ctx.stroke();
+  /**
+   * Draw the arc
+   * @param {Object} renderer
+   */
+  draw(renderer) {
+    renderer.drawShape(this.toPolylinePoints());
   }
 
   /**
@@ -264,19 +298,19 @@ export class Arc extends Entity {
    */
   dxf(file) {
     file.writeGroupCode('0', 'ARC');
-    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('5', this.getProperty(Property.Names.HANDLE), DXFFile.Version.R2000); // Handle
     file.writeGroupCode('100', 'AcDbEntity', DXFFile.Version.R2000);
     file.writeGroupCode('100', 'AcDbCircle', DXFFile.Version.R2000);
-    file.writeGroupCode('8', this.layer); // LAYERNAME
-    file.writeGroupCode('6', this.lineType); // LINETYPE
+    file.writeGroupCode('8', this.getProperty(Property.Names.LAYER)); // LAYERNAME
+    file.writeGroupCode('6', this.getProperty(Property.Names.LINETYPE)); // LINETYPE
     file.writeGroupCode('10', this.points[0].x); // X
     file.writeGroupCode('20', this.points[0].y); // Y
     file.writeGroupCode('30', '0.0'); // Z
-    file.writeGroupCode('39', this.lineWidth); // Line Width
-    file.writeGroupCode('40', this.radius); // Radius
+    file.writeGroupCode('39', this.getProperty(Property.Names.LINEWIDTH)); // Line Width
+    file.writeGroupCode('40', this.getProperty(Property.Names.RADIUS)); // Radius
     file.writeGroupCode('100', 'AcDbArc', DXFFile.Version.R2000);
-    file.writeGroupCode('50', Utils.radians2degrees(this.direction > 0 ? this.startAngle() : this.endAngle())); // Start Angle
-    file.writeGroupCode('51', Utils.radians2degrees(this.direction > 0 ? this.endAngle() : this.startAngle())); // End Angle
+    file.writeGroupCode('50', Utils.radians2degrees(this.getProperty(Property.Names.DIRECTION) > 0 ? this.startAngle() : this.endAngle())); // Start Angle
+    file.writeGroupCode('51', Utils.radians2degrees(this.getProperty(Property.Names.DIRECTION) > 0 ? this.endAngle() : this.startAngle())); // End Angle
   }
 
   /**
@@ -289,101 +323,32 @@ export class Arc extends Entity {
 
     // If the arc forms a complete circle
     // Split into two separate polyline arcs
+    const radius = this.getProperty(Property.Names.RADIUS);
     if (Math.abs(this.totalAngle) === 360) {
-      const startPoint = this.points[0].project(0, this.radius);
+      const startPoint = this.points[0].project(0, radius);
       startPoint.bulge = 1;
-      const endPoint = this.points[0].project(0, -this.radius);
+      const endPoint = this.points[0].project(0, -radius);
       endPoint.bulge = 1;
-      const closurePoint = this.points[0].project(0, this.radius);
+      const closurePoint = this.points[0].project(0, radius);
       return [startPoint, endPoint, closurePoint];
     }
 
-    const startPoint = this.points[0].project(this.startAngle(), this.radius);
+    const startPoint = this.points[0].project(this.startAngle(), radius);
     const bulge = Math.tan(Utils.degrees2radians(-this.totalAngle % 360) / 4);
     startPoint.bulge = bulge;
-    const endPoint = this.points[0].project(this.endAngle(), this.radius);
+    const endPoint = this.points[0].project(this.endAngle(), radius);
     return [startPoint, endPoint];
   }
 
   /**
    * Set entity points from a polyline point representation
    * @param {Array} points
+   * @return {Arc}
    */
   fromPolylinePoints(points) {
     const center = points[0].bulgeCentrePoint(points[1]);
-    const radius = center.distance(points[0]);
-    this.points = [center, new Point(points[0].x, points[0].y), new Point(points[1].x, points[1].y)];
-    this.radius = radius;
-  }
-
-  /**
-   * Trim the entity
-   * @param {Array} intersections
-   * @return {Array} - array of state changes
-   */
-  trim(intersections) {
-    // array to hold state changes
-    const stateChanges = [];
-
-    if (intersections?.length === 0 || !intersections) {
-      return stateChanges;
-    }
-
-    // get the mouse position
-    const mousePosition = DesignCore.Mouse.pointOnScene();
-    // get the point on the arc closest to the mouse
-    const pointOnArc = mousePosition.closestPointOnArc(this.points[1], this.points[2], this.points[0], this.direction);
-    // remove any intersections that are at the end points of the arc
-    intersections = intersections.filter((p) => !p.isSame(this.points[1]) && !p.isSame(this.points[2]));
-    // sort intersection points by distance to start point
-    Utils.sortPointsOnArc(intersections, this.points[1], this.points[2], this.points[0], this.direction);
-    // Add arc points to the start and the end of the point array
-    const testPoints = [this.points[1], ...intersections, this.points[2]];
-
-    // Test if mouse position is between two intersection points
-    if (testPoints.length > 1) {
-      for (let i = 0; i < testPoints.length - 1; i++) {
-        const startPoint = testPoints[i];
-        const endPoint = testPoints[i + 1];
-
-        // check if the mouse is between startPoint and endPoint
-        if (pointOnArc.isOnArc(startPoint, endPoint, this.points[0], this.direction)) {
-          // Store new entity points
-          const newPoints = [];
-
-          for (const p of testPoints) {
-            const inOriginalArc = this.points.indexOf(p) !== -1;
-            const inIntersections = intersections.indexOf(p) !== -1;
-
-            // Keep points which:
-            // - The mouse is between are intersections
-            // - The mouse is not between and in this arc
-            const isBetween = p.isSame(startPoint) || p.isSame(endPoint);
-            if ((isBetween && inIntersections) || (!isBetween && inOriginalArc)) {
-              newPoints.push(p);
-            }
-          }
-
-          if (newPoints.length % 2 === 0) {
-            // Add arcs for each point pair
-            for (let j = 0; j < newPoints.length; j += 2) {
-              const arc = Utils.cloneObject(this);
-              arc.points = [this.points[0], newPoints[j], newPoints[j + 1]];
-              const addState = new AddState(arc);
-              stateChanges.push(addState);
-            }
-          }
-
-          if (stateChanges.length > 0) {
-            // Remove the existing arc
-            const removeState = new RemoveState(this);
-            stateChanges.push(removeState);
-          }
-        }
-      }
-    }
-
-    return stateChanges;
+    this.points = [center, new Point(points[0].x, points[0].y), new Point(points.at(-1).x, points.at(-1).y)];
+    return this;
   }
 
   /**
@@ -417,12 +382,14 @@ export class Arc extends Entity {
       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
+      const radius = this.getProperty(Property.Names.RADIUS);
+      const direction = this.getProperty(Property.Names.DIRECTION);
+      if (distanceToCenter > radius) {
+        const tangentHalfAngle = Math.acos(radius / distanceToCenter); // half-angle between the two tangent directions
 
         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)) {
+          const tangentPoint = centre.project(angleFromCentreToInput + sign * tangentHalfAngle, radius);
+          if (tangentPoint.isOnArc(this.points[1], this.points[2], centre, direction)) {
             snaps.push(new SnapPoint(tangentPoint, SnapPoint.Type.TANGENT));
           }
         }
@@ -430,8 +397,8 @@ export class Arc extends Entity {
 
       // 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)) {
+        const perpendicularPoint = centre.project(angleFromCentreToInput, radius);
+        if (perpendicularPoint.isOnArc(this.points[1], this.points[2], centre, direction)) {
           snaps.push(new SnapPoint(perpendicularPoint, SnapPoint.Type.PERPENDICULAR));
         }
       }
@@ -450,7 +417,7 @@ export class Arc extends Entity {
     const endPoint = this.points[2];
     const centerPoint = this.points[0];
 
-    const pnt = P.closestPointOnArc(startPoint, endPoint, centerPoint, this.direction);
+    const pnt = P.closestPointOnArc(startPoint, endPoint, centerPoint, this.getProperty(Property.Names.DIRECTION));
 
     if (pnt !== null) {
       const distance = P.distance(pnt);
@@ -466,6 +433,6 @@ export class Arc extends Entity {
    * @return {BoundingBox}
    */
   boundingBox() {
-    return BoundingBox.arcBoundingBox(this.points[0], this.points[1], this.points[2], this.direction);
+    return BoundingBox.arcBoundingBox(this.points[0], this.points[1], this.points[2], this.getProperty(Property.Names.DIRECTION));
   }
 }