@design-core/core 0.0.5 → 0.0.7

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);
     }
   }
 }