@design-core/core 0.0.6 → 50.1.0

package/core/entities/circle.js

@@ -5,12 +5,11 @@ 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 { Property } from '../properties/property.js';
-import { Utils } from '../lib/utils.js';
-
 import { DesignCore } from '../designCore.js';
-import { AddState, RemoveState } from '../lib/stateManager.js';
-import { SnapPoint } from '../lib/snapping.js';
+
+import { Property } from '../properties/property.js';
+import { SnapPoint } from '../lib/auxiliary/snapPoint.js';
+import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 /**
  * Circle Entity Class
@@ -26,19 +25,20 @@ export class Circle extends Entity {
   constructor(data) {
     super(data);
 
-    // add radius property with getter and setter
-    // needs to be enumerable to appear in the object props
-    Object.defineProperty(this, 'radius', {
-      get: this.getRadius,
-      set: this.setRadius,
-      enumerable: true,
+    // 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]) : 0,
+      set: (entity, rad) => {
+        entity.points[1] = entity.points[0].project(0, rad);
+      },
+      dxfCode: 40,
     });
 
-    if (data) {
-      if (data.hasOwnProperty('radius') || data.hasOwnProperty('40')) {
-        // DXF Groupcode 40 - Radius
-        this.setRadius(Property.loadValue([data.radius, data[40]], 0));
-      }
+    // Named scalar radius (internal API / named prop) — projects points[1] from centre.
+    // Full-points data (post-execute or post-fromDxf) skips this.
+    if (data?.radius !== undefined && this.points.length < 2) {
+      this.setRadius(data.radius);
     }
   }
 
@@ -54,6 +54,21 @@ export class Circle 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 centre = data.points?.[0];
+    if (!centre || data[40] === undefined) return data;
+    return {
+      ...data,
+      points: [centre, centre.project(0, data[40])],
+    };
+  }
+
   /**
    * Execute method
    * executes the workflow, requesting input required to create an entity
@@ -113,8 +128,8 @@ export class Circle extends Entity {
   preview() {
     if (this.points.length >= 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
-      const points = [this.points.at(-1), mousePoint];
-      DesignCore.Scene.tempEntities.create(this.type, { points: points });
+      DesignCore.Scene.auxiliaryEntities.add(new RubberBand([this.points.at(0), mousePoint]));
+      DesignCore.Scene.previewEntities.create(this.type, { points: [this.points.at(0), mousePoint] });
     }
   }
 
@@ -139,9 +154,12 @@ export class Circle extends Entity {
    * @param {Object} ctx - context
    * @param {number} scale
    */
-  draw(ctx, scale) {
-    ctx.arc(this.points[0].x, this.points[0].y, this.radius, 0, 6.283);
-    ctx.stroke();
+  /**
+   * Draw the circle
+   * @param {Object} renderer
+   */
+  draw(renderer) {
+    renderer.drawShape(this.toPolylinePoints());
   }
 
   /**
@@ -150,17 +168,17 @@ export class Circle extends Entity {
    */
   dxf(file) {
     file.writeGroupCode('0', 'CIRCLE');
-    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);
-    file.writeGroupCode('6', this.lineType);
+    file.writeGroupCode('8', this.getProperty(Property.Names.LAYER));
+    file.writeGroupCode('6', this.getProperty(Property.Names.LINETYPE));
     this.writeDxfColour(file);
     file.writeGroupCode('10', this.points[0].x);
     file.writeGroupCode('20', this.points[0].y);
     file.writeGroupCode('30', '0.0');
-    file.writeGroupCode('39', this.lineWidth);
-    file.writeGroupCode('40', this.radius);
+    file.writeGroupCode('39', this.getProperty(Property.Names.LINEWIDTH));
+    file.writeGroupCode('40', this.getProperty(Property.Names.RADIUS));
   }
 
   /**
@@ -168,76 +186,34 @@ export class Circle extends Entity {
    * @return {Array}
    */
   toPolylinePoints() {
-    const startPoint = this.points[0].project(0, this.radius);
+    const radius = this.getProperty(Property.Names.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];
   }
 
   /**
-   * Set entity points from a polyline point representation
+   * Set entity points from a polyline point representation.
+   * If the points describe a full circle (start === end), mutates this Circle
+   * in place and returns it. Otherwise creates and returns an Arc, since a
+   * Circle cannot represent an open arc.
    * @param {Array} points
+   * @return {Circle|Arc}
    */
   fromPolylinePoints(points) {
-    const center = points[0].bulgeCentrePoint(points[1]);
-    const radius = center.distance(points[0]);
-    this.points = [center, center.project(0, 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;
+    if (points.length >= 3 && points[0].isSame(points.at(-1))) {
+      const centre = points[0].bulgeCentrePoint(points[1]);
+      const radius = centre.distance(points[0]);
+      this.points = [centre, centre.project(0, radius)];
+      return this;
     }
-
-    const direction = 1; // Circle is always CCW for trimming purposes
-
-    // get the mouse position
-    const mousePosition = DesignCore.Mouse.pointOnScene();
-    // get the point on the arc closest to the mouse
-    const pointOnCircle = mousePosition.closestPointOnArc(this.points[1], this.points[1], this.points[0]);
-    // sort intersection points
-    Utils.sortPointsOnArc(intersections, this.points[0], this.points[0], this.points[0], direction);
-    // Repeat the first point to close the circle
-    const testPoints = [...intersections, intersections.at(0)]; // Closing the circle
-
-    // 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 (pointOnCircle.isOnArc(startPoint, endPoint, this.points[0], direction)) {
-          // create a new arc entity
-          const arc = DesignCore.CommandManager.createNew('Arc', this);
-          arc.handle = undefined;
-          // flip direction
-          arc.direction = direction * -1;
-          arc.points = [this.points[0], startPoint, endPoint];
-          const addState = new AddState(arc);
-          stateChanges.push(addState);
-
-          // Remove the existing arc
-          if (stateChanges.length > 0) {
-            const removeState = new RemoveState(this);
-            stateChanges.push(removeState);
-            return stateChanges;
-          }
-        }
-      }
-    }
-
-    return stateChanges;
+    const arc = DesignCore.CommandManager.createNew('Arc', this);
+    arc.setProperty('handle', undefined);
+    arc.fromPolylinePoints(points);
+    return arc;
   }
 
   /**
@@ -251,13 +227,14 @@ export class Circle extends Entity {
 
     const centre = this.points[0]; // circle centre point
 
+    const radius = this.getProperty(Property.Names.RADIUS);
     snaps.push(new SnapPoint(centre, SnapPoint.Type.CENTRE));
 
     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°
+        new SnapPoint(new Point(centre.x + radius, centre.y), SnapPoint.Type.QUADRANT), // 0°
+        new SnapPoint(new Point(centre.x, centre.y + radius), SnapPoint.Type.QUADRANT), // 90°
+        new SnapPoint(new Point(centre.x - radius, centre.y), SnapPoint.Type.QUADRANT), // 180°
+        new SnapPoint(new Point(centre.x, centre.y - radius), SnapPoint.Type.QUADRANT), // 270°
     );
 
     if (mousePoint) {
@@ -274,16 +251,16 @@ export class Circle extends Entity {
       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
+      if (distanceToCenter > radius) {
+        const tangentHalfAngle = Math.acos(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));
+        snaps.push(new SnapPoint(centre.project(angleFromCentreToInput + tangentHalfAngle, radius), SnapPoint.Type.TANGENT));
+        snaps.push(new SnapPoint(centre.project(angleFromCentreToInput - tangentHalfAngle, radius), SnapPoint.Type.TANGENT));
       }
 
       // 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));
+        snaps.push(new SnapPoint(centre.project(angleFromCentreToInput, radius), SnapPoint.Type.PERPENDICULAR));
       }
     }
 
@@ -308,10 +285,11 @@ export class Circle extends Entity {
    * @return {BoundingBox}
    */
   boundingBox() {
-    const xmin = this.points[0].x - this.radius;
-    const xmax = this.points[0].x + this.radius;
-    const ymin = this.points[0].y - this.radius;
-    const ymax = this.points[0].y + this.radius;
+    const radius = this.getProperty(Property.Names.RADIUS);
+    const xmin = this.points[0].x - radius;
+    const xmax = this.points[0].x + radius;
+    const ymin = this.points[0].y - radius;
+    const ymax = this.points[0].y + radius;
 
     const topLeft = new Point(xmin, ymax);
     const bottomRight = new Point(xmax, ymin);

package/core/entities/entity.js

@@ -2,8 +2,9 @@ import { Colours } from '../lib/colours.js';
 import { EntityColour } from '../lib/colour.js';
 import { Intersection } from '../lib/intersect.js';
 import { Point } from './point.js';
-import { Strings } from '../lib/strings.js';
+
 import { Property } from '../properties/property.js';
+import { EntityProperties } from '../properties/entityProperties.js';
 
 
 import { DesignCore } from '../designCore.js';
@@ -23,80 +24,130 @@ export class Entity {
       writable: true,
     });
 
-    Object.defineProperty(this, 'points', {
-      value: [],
+    Object.defineProperty(this, 'entityColour', {
+      value: new EntityColour(),
       writable: true,
     });
 
-    Object.defineProperty(this, 'colour', {
-      get: this.getColour,
-      set: this.setColour,
-    });
+    // DXF Groupcode 62 (normalised to colourACI by Entity.fromDxf) - ACI colour index
+    // DXF Groupcode 420 (normalised to trueColour by Entity.fromDxf) - 24-bit true colour
+    if (data?.colourACI !== undefined) {
+      this.entityColour.setColourFromACI(data.colourACI);
+    }
 
-    Object.defineProperty(this, 'entityColour', {
-      value: new EntityColour(),
+    if (data?.trueColour !== undefined) {
+      const trueColour = Colours.trueColourToRGB(data.trueColour);
+      if (trueColour) this.entityColour.setColour(trueColour);
+    }
+
+    // Typed property store — non-enumerable so it doesn't appear in serialisation
+    Object.defineProperty(this, 'properties', {
+      value: new EntityProperties(),
       writable: true,
     });
 
-    this.lineWidth = 2;
-    this.lineType = 'ByLayer';
-    this.layer = '0';
-
     // DXF Groupcode 5 - Handle
-    Object.defineProperty(this, 'handle', {
+    this.properties.add(Property.Names.HANDLE, {
+      type: Property.Type.STRING,
       value: Property.loadValue([data?.handle, data?.[5]]),
-      writable: true,
+      visible: false,
+      dxfCode: 5,
+    });
+    // DXF Groupcode 8 - Layer name
+    this.properties.add(Property.Names.LAYER, {
+      type: Property.Type.LIST,
+      value: Property.loadValue([data?.layer, data?.[8]], '0'),
+      dxfCode: 8,
+      options: () => DesignCore.LayerManager.getItems().map((l) => ({ display: l.name, value: l.name })),
+    });
+    // DXF Groupcode 6 - Line type
+    this.properties.add(Property.Names.LINETYPE, {
+      type: Property.Type.LIST,
+      value: Property.loadValue([data?.lineType, data?.[6]], 'ByLayer'),
+      dxfCode: 6,
+      options: () => DesignCore.LTypeManager.getItems().map((s) => ({ display: s.name, value: s.name })),
     });
-    // DXF Groupcode 6 - lineType
-    this.lineType = Property.loadValue([data?.lineType, data?.[6]], 'ByLayer');
     // DXF Groupcode 39 - Thickness (lineWidth)
-    this.lineWidth = Property.loadValue([data?.lineWidth, data?.[39]], 2);
-    // DXF Groupcode 8 - layername
-    this.layer = Property.loadValue([data?.layer, data?.[8]], '0');
-
-    if (data) {
-      if (data.hasOwnProperty('points')) {
-        this.points = data.points;
-      }
-
-      if (data.hasOwnProperty('colour') || data.hasOwnProperty('62')) {
-        // DXF Groupcode 62 - Color Number (present if not BYLAYER)(optional);
-        // zero indicates BYBLOCK
-        // 256 indicates BYLAYER;
-        // a negative value indicates that the layer is turned off
-        if (data.colour) {
-          if (Colours.isRGB(data.colour)) {
-            this.colour = data.colour;
-          }
-        } else if (data.hasOwnProperty('62')) {
-          this.entityColour.setColourFromACI(Math.abs(data[62]));
-        }
-      }
-
-      if (data.hasOwnProperty('trueColour') || data.hasOwnProperty('420')) {
-        // DXF Groupcode 420 - true color
-        // A 24-bit color value that should be dealt with in terms of bytes with values
-        // of 0 to 255. The lowest byte is the blue value, the middle byte is the
-        // green value, and the third byte is the red value. The top byte is always
-        // 0. The group code cannot be used by custom entities for their own data
-        // because the group code is reserved for AcDbEntity, class-level color data
-        // and AcDbEntity, class-level transparency data
-
-        const trueColour = Colours.trueColourToRGB(data.trueColour || data[420]);
-        if (trueColour) {
-          this.colour = trueColour;
-        }
-      }
+    this.properties.add(Property.Names.LINEWIDTH, {
+      type: Property.Type.NUMBER,
+      value: Property.loadValue([data?.lineWidth, data?.[39]], 1),
+      dxfCode: 39,
+    });
+    // DXF Groupcode 62/420 - colour (computed, backed by entityColour)
+    this.properties.add(Property.Names.COLOUR, {
+      type: Property.Type.COLOUR,
+      get: (entity) => entity.entityColour.getColour(),
+      set: (entity, value) => entity.entityColour.setColour(value),
+      dxfCode: 62,
+    });
+
+    // Apply colour from data if RGB was passed directly
+    if (data?.colour && Colours.isRGB(data.colour)) {
+      this.entityColour.setColour(data.colour);
     }
+
+    // points — stored value in EntityProperties
+    this.properties.add(Property.Names.POINTS, {
+      visible: false,
+      value: data?.points ?? [],
+    });
   }
 
+  /**
+   * Get the entity's geometry points.
+   * @return {Array<Point>}
+   */
+  get points() {
+    return this.properties.get(Property.Names.POINTS, this);
+  }
+
+  /**
+   * Set the entity's geometry points.
+   * @param {Array<Point>} value
+   */
+  set points(value) {
+    this.properties.set(Property.Names.POINTS, value, this);
+  }
+
+  /**
+   * Normalise entity-level DXF group codes before construction.
+   * Subclasses override this for geometric transformation; they receive data
+   * that has already passed through this method via CommandManager.
+   * @param {Object} data - raw DXF group code object
+   * @return {Object} normalised data
+   *
+   * Handles:
+   * - Group code 62: ACI colour index → colourACI (absolute value)
+   * - Group code 420: 24-bit true colour integer → trueColour
+   */
+  static fromDxf(data) {
+    const normalised = { ...data };
+    // DXF group code 62 - Color Number (ACI)
+    if (data[62] !== undefined) {
+      normalised.colourACI = Math.abs(data[62]);
+    }
+    // DXF group code 420 - True Color (24-bit integer)
+    if (data[420] !== undefined) {
+      normalised.trueColour = data[420];
+    }
+    return normalised;
+  }
+
+  /**
+   * Get a property value by name.
+   * @param {string} name
+   * @return {any}
+   */
+  getProperty(name) {
+    return this.properties.get(name, this);
+  }
 
   /**
    * get rgb colour
    * @return {number} rgb colour object
    */
   getColour() {
-    return this.entityColour.getColour(); ;
+    return this.entityColour.getColour();
   }
 
   /**
@@ -107,30 +158,22 @@ export class Entity {
     let rgb = this.getColour();
 
     if (this.entityColour.byLayer) {
-      const layer = DesignCore.LayerManager.getItemByName(this.layer);
+      const layer = DesignCore.LayerManager.getItemByName(this.getProperty(Property.Names.LAYER));
       rgb = layer?.colour;
     }
 
     return rgb;
   }
 
-  /**
-   * Set the entity colour
-   * @param {Object} rgb
-   */
-  setColour(rgb) {
-    this.entityColour.setColour(rgb);
-  }
-
   /**
    * Get the line type
    * @return {LType}
    */
   getLineType() {
-    let lineTypeName = this.lineType;
+    let lineTypeName = this.getProperty(Property.Names.LINETYPE) ?? 'ByLayer';
 
     if (lineTypeName.toUpperCase() === 'BYLAYER') {
-      const layer = DesignCore.LayerManager.getItemByName(this.layer);
+      const layer = DesignCore.LayerManager.getItemByName(this.getProperty(Property.Names.LAYER));
       lineTypeName = layer?.lineType;
     }
 
@@ -148,7 +191,7 @@ export class Entity {
       file.writeGroupCode('62', this.entityColour.aci);
     }
     if (this.entityColour.isTrueColour) {
-      file.writeGroupCode('420', Colours.rgbToTrueColour(this.colour));
+      file.writeGroupCode('420', Colours.rgbToTrueColour(this.getColour()));
     }
   }
 
@@ -158,7 +201,7 @@ export class Entity {
    * @return {boolean} true if within
    */
   within(selection) {
-    const layer = DesignCore.LayerManager.getItemByName(this.layer);
+    const layer = DesignCore.LayerManager.getItemByName(this.getProperty(Property.Names.LAYER));
 
     if (!layer?.isSelectable) {
       return;
@@ -182,7 +225,7 @@ export class Entity {
    * @return {boolean} true if touched
    */
   touched(selection) {
-    const layer = DesignCore.LayerManager.getItemByName(this.layer);
+    const layer = DesignCore.LayerManager.getItemByName(this.getProperty(Property.Names.LAYER));
 
     if (!layer?.isSelectable) {
       return;
@@ -205,36 +248,14 @@ export class Entity {
     return false;
   }
 
-  /**
-   * Extend the entity
-   * @param {Array} points
-   * @return {Array} - array of state changes
-   */
-  extend(points) {
-    // extend function to be overridden by implementation
-    DesignCore.Core.notify(`${this.type} - ${Strings.Message.NOEXTEND}`);
-    return [];
-  }
-
-  /**
-   * Trim the entity
-   * @param {Array} points
-   * @return {Array} - array of state changes
-   */
-  trim(points) {
-    // trim function to be overridden by implementation
-    DesignCore.Core.notify(`${this.type} - ${Strings.Message.NOTRIM}`);
-    return [];
-  }
-
   /**
    * Set a property if it exists
    * @param {string} property
    * @param {any} value
    */
   setProperty(property, value) {
-    if (this.hasOwnProperty(property)) {
-      this[property] = value;
+    if (this.properties.has(property)) {
+      this.properties.set(property, value, this);
     }
   }
 }