@design-core/core 0.0.5 → 0.0.7

package/core/lib/stateManager.js

@@ -200,7 +200,7 @@ class State {
           // capture previous properties for undo
           const previousProperties = {};
           for (const prop of Object.getOwnPropertyNames(stateChange.properties)) {
-            previousProperties[prop] = stateChange.entity[prop];
+            previousProperties[prop] = stateChange.entity.getProperty(prop);
           }
           const undoStateChange = new UpdateState(stateChange.entity, previousProperties);
           this.undoStateChanges.push(undoStateChange);
@@ -208,6 +208,15 @@ class State {
           this.entityManager.update(index, stateChange.properties);
         }
       }
+
+      if (stateChange instanceof ReplaceState) {
+        const index = this.entityManager.indexOf(stateChange.entity);
+        if (index !== -1) {
+          this.entityManager.replace(index, stateChange.replacement);
+          const undoStateChange = new ReplaceState(stateChange.replacement, stateChange.entity);
+          this.undoStateChanges.push(undoStateChange);
+        }
+      }
     }
   }
 
@@ -231,6 +240,13 @@ class State {
           this.entityManager.update(index, stateChange.properties);
         }
       }
+
+      if (stateChange instanceof ReplaceState) {
+        const index = this.entityManager.indexOf(stateChange.entity);
+        if (index !== -1) {
+          this.entityManager.replace(index, stateChange.replacement);
+        }
+      }
     }
   }
 }
@@ -286,3 +302,16 @@ export class UpdateState extends StateChange {
     super(entity, properties);
   }
 }
+
+/** Replace State Class */
+export class ReplaceState {
+  /**
+   * Create Replace State
+   * @param {object} entity - the entity to be replaced (used to locate it by reference)
+   * @param {object} replacement - the entity to put in its place
+   */
+  constructor(entity, replacement) {
+    this.entity = entity;
+    this.replacement = replacement;
+  }
+}

package/core/lib/utils.js

@@ -1,6 +1,7 @@
 
 import { Logging } from './logging.js';
 import { Constants } from './constants.js';
+import { Property } from '../properties/property.js';
 
 /** Utils Class */
 export class Utils {
@@ -114,13 +115,31 @@ export class Utils {
     }
 
     // Clear handle so a fresh unique handle is assigned when added to the scene
-    if (clone.handle !== undefined) {
-      clone.handle = undefined;
+    if (clone.getProperty?.(Property.Names.HANDLE) !== undefined) {
+      clone.setProperty?.(Property.Names.HANDLE, undefined);
     }
 
     return clone;
   }
 
+  /**
+   * Copy display properties from a source entity into a plain data object.
+   * Useful when creating a new entity that should inherit the visual properties
+   * of an existing one (e.g. the arc produced by Fillet).
+   * @param {Entity} entity - source entity
+   * @param {Array<string>} properties - property names to copy
+   * @return {Object} plain object containing the copied properties
+   */
+  static cloneProperties(entity, properties = ['colour', 'layer', 'lineType', 'lineWidth', 'height', 'styleName', 'dimensionStyle', 'patternName', 'scale']) {
+    const result = {};
+    for (const prop of properties) {
+      if (entity.properties?.has(prop)) {
+        result[prop] = entity.getProperty(prop);
+      }
+    }
+    return result;
+  }
+
   /**
    * Calculate area of triangle given 3 points
    * @param {Point} p1

package/core/properties/entityProperties.js

@@ -0,0 +1,104 @@
+import { Property } from './property.js';
+
+/**
+ * EntityProperties — typed property store for an entity.
+ *
+ * Holds a plain-object store of named Property descriptors.
+ * Each descriptor owns its value.
+ * Using a plain object (rather than a private Map) ensures the store is deep-cloneable by Utils.cloneObject.
+ *
+ * Computed properties may supply get(entity) and set(entity, value) functions.
+ * These are stateless functions (not bound methods) so they survive cloneObject.
+ */
+export class EntityProperties {
+  /** @type {Object.<string, Property>} */
+  // Store is a plain object to ensure it is deep-cloneable by Utils.cloneObject.
+  _store = {};
+
+  /**
+   * Register a property.
+   * @param {string} name - property name
+   * @param {Object} definition - passed directly to the Property constructor
+   * @param {string} definition.type - Property.Type constant
+   * @param {any} definition.value - initial value
+   * @param {boolean} [definition.readOnly=false]
+   * @param {boolean} [definition.visible=true]
+   * @param {number} [definition.dxfCode]
+   * @param {Function} [definition.get] - computed getter: (entity) => value
+   * @param {Function} [definition.set] - computed setter: (entity, value) => void
+   */
+  add(name, definition) {
+    this._store[name] = new Property(definition);
+  }
+
+  /**
+   * Get the current value of a property.
+   * For computed properties, invokes get(entity).
+   * For stored properties, returns prop.value directly.
+   * @param {string} name
+   * @param {Object} [entity] - passed to the computed getter when prop.get is defined
+   * @return {any} value, or undefined if not registered
+   */
+  get(name, entity) {
+    const prop = this._store[name];
+    if (!prop) return undefined;
+    if (prop.get) return prop.get(entity);
+    return prop.value;
+  }
+
+  /**
+   * Set the value of a property.
+   * For computed properties, invokes set(entity, value).
+   * For stored properties, updates prop.value directly.
+   * No-op if the property is not registered or is readOnly.
+   * @param {string} name
+   * @param {any} value
+   * @param {Object} [entity] - passed to the computed setter when prop.set is defined
+   */
+  set(name, value, entity) {
+    const prop = this._store[name];
+    if (!prop) return;
+    if (prop.readOnly) return;
+    if (prop.set) {
+      prop.set(entity, value);
+    } else {
+      prop.value = value;
+    }
+  }
+
+  /**
+   * Check whether a property is registered.
+   * @param {string} name
+   * @return {boolean}
+   */
+  has(name) {
+    return name in this._store;
+  }
+
+  /**
+   * Remove a property from the store.
+   * @param {string} name
+   */
+  remove(name) {
+    delete this._store[name];
+  }
+
+  /**
+   * Return names of all visible properties in registration order.
+   * @return {string[]}
+   */
+  list() {
+    return Object.entries(this._store)
+        .filter(([, prop]) => prop.visible)
+        .map(([name]) => name);
+  }
+
+  /**
+   * Return the full Property descriptor for a named property.
+   * @param {string} name
+   * @return {Property|undefined}
+   */
+  definition(name) {
+    return this._store[name];
+  }
+}

package/core/properties/property.js

@@ -2,8 +2,112 @@ import { Flags } from './flags.js';
 
 /** Property Class */
 export class Property {
-  /** Create property */
-  constructor() { }
+  /**
+   * Create a Property descriptor
+   * @param {Object} [options]
+   * @param {string} options.type - Property.Type constant describing the value kind
+   * @param {any} options.value - initial value
+   * @param {boolean} [options.readOnly=false] - when true, set() is a no-op
+   * @param {boolean} [options.visible=true] - controls whether the property appears in listings
+   * @param {number} [options.dxfCode] - associated DXF group code (informational)
+   * @param {Function} [options.get] - computed getter: (entity) => value
+   * @param {Function} [options.set] - computed setter: (entity, value) => void
+   */
+  constructor({ type, value, readOnly = false, visible = true, dxfCode, get, set, options } = {}) {
+    this.type = type;
+    this._value = value;
+    this.readOnly = readOnly;
+    this.visible = visible;
+    this.dxfCode = dxfCode;
+    this.get = get;
+    this.set = set;
+    this.options = options;
+  }
+
+  /** @return {any} current value */
+  get value() {
+    return this._value;
+  }
+
+  /** @param {any} val - new value; ignored when readOnly */
+  set value(val) {
+    if (!this.readOnly) {
+      this._value = val;
+    }
+  }
+
+  /**
+   * Property type constants
+   * Used to describe the type of a property value for UI rendering and validation.
+   * - NUMBER: numeric value (integer or float)
+   * - STRING: text value
+   * - BOOLEAN: true/false toggle
+   * - LIST: selection from a named set (layer, lineType, hatch pattern, etc.)
+   * - COLOUR: RGB colour object
+   * - LABEL: read-only display value (no editing)
+   */
+  static Type = {
+    NUMBER: 'NUMBER',
+    STRING: 'STRING',
+    BOOLEAN: 'BOOLEAN',
+    LIST: 'LIST',
+    COLOUR: 'COLOUR',
+    LABEL: 'LABEL',
+    ENTITIES: 'ENTITIES',
+  };
+
+  /**
+   * Canonical property name constants.
+   * Use these instead of raw strings when calling getProperty() / setProperty().
+   */
+  static Names = Object.freeze({
+    // ── Base entity (Entity class) ────────────────────────────────────────────
+    HANDLE: 'handle',
+    LAYER: 'layer',
+    LINETYPE: 'lineType',
+    LINEWIDTH: 'lineWidth',
+    COLOUR: 'colour',
+    POINTS: 'points',
+    // ── Shared (multiple entities) ────────────────────────────────────────────
+    ANGLE: 'angle',
+    BLOCKNAME: 'blockName',
+    DIRECTION: 'direction',
+    HEIGHT: 'height',
+    RADIUS: 'radius',
+    ROTATION: 'rotation',
+    SCALE: 'scale',
+    STRING: 'string',
+    STYLENAME: 'styleName',
+    // ── BasePolyline ──────────────────────────────────────────────────────────
+    CLOSED: 'closed',
+    // ── Hatch ─────────────────────────────────────────────────────────────────
+    CHILDENTITIES: 'childEntities',
+    PATTERNNAME: 'patternName',
+    // ── Text ──────────────────────────────────────────────────────────────────
+    BACKWARDS: 'backwards',
+    HORIZONTALALIGNMENT: 'horizontalAlignment',
+    UPSIDEDOWN: 'upsideDown',
+    VERTICALALIGNMENT: 'verticalAlignment',
+    // ── ArcAlignedText ────────────────────────────────────────────────────────
+    ARCSIDE: 'arcSide',
+    BOLD: 'bold',
+    CHARACTERSPACING: 'characterSpacing',
+    FONTNAME: 'fontName',
+    ITALIC: 'italic',
+    OFFSETFROMARC: 'offsetFromArc',
+    OFFSETFROMLEFT: 'offsetFromLeft',
+    OFFSETFROMRIGHT: 'offsetFromRight',
+    TEXTALIGNMENT: 'textAlignment',
+    TEXTORIENTATION: 'textOrientation',
+    TEXTREVERSED: 'textReversed',
+    UNDERLINE: 'underline',
+    WIDTHFACTOR: 'widthFactor',
+    // ── Dimensions ────────────────────────────────────────────────────────────
+    DIMENSIONSTYLE: 'dimensionStyle',
+    LEADERLENGTH: 'leaderLength',
+    LINEARDIMANGLE: 'linearDimAngle',
+    TEXTOVERRIDE: 'textOverride',
+  });
 
   /**
    * Parse the input values and return a value

package/core/properties/propertyManager.js

@@ -46,11 +46,13 @@ export class PropertyManager {
       }
 
       // check if the item has the selected property
-      if (!item.hasOwnProperty(property)) {
+      if (!item.properties?.has(property)) {
         continue;
       }
 
-      if (typeof (item[property]) !== typeof (newPropertyValue)) {
+      const currentValue = item.getProperty(property);
+
+      if (typeof (currentValue) !== typeof (newPropertyValue)) {
         DesignCore.Core.notify(Strings.Error.INPUT);
       } else {
         // update the item property
@@ -119,22 +121,36 @@ export class PropertyManager {
     const propertiesList = [];
 
     subset.forEach((el) => {
-      // get list of keys
-      Object.keys(el).forEach((key) => {
-        // check if the key is already in the propertiesList
-        if (propertiesList.includes(key) === false) {
-          // check if all subset items contain the key and the key is enumberable
-          if (subset.every((el) => el.hasOwnProperty(key) && Object.getOwnPropertyDescriptor(el, key).enumerable)) {
-            propertiesList.push(key);
+      if (el.properties) {
+        el.properties.list().forEach((key) => {
+          if (propertiesList.includes(key) === false) {
+            if (subset.every((sub) => sub.properties?.has(key))) {
+              propertiesList.push(key);
+            }
           }
-        }
-      });
+        });
+      }
     });
 
     return propertiesList;
   }
 
 
+  /**
+   * Get the Property descriptor for a named property from a representative selected entity.
+   * @param {string} itemType
+   * @param {string} property
+   * @return {Property|undefined}
+   */
+  getItemPropertyDefinition(itemType, property) {
+    const index = DesignCore.Scene.selectionManager.selectionSet.selectionSet.find((i) => {
+      const item = DesignCore.Scene.entities.get(i);
+      return (itemType === 'All' || item.type === itemType) && item.properties?.has(property);
+    });
+    if (index === undefined) return undefined;
+    return DesignCore.Scene.entities.get(index).properties.definition(property);
+  }
+
   /**
    * Get a list the property values
    * @param {string} itemType
@@ -147,8 +163,8 @@ export class PropertyManager {
     if (DesignCore.Scene.selectionManager.selectionSet.selectionSet.length > 0) {
       for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
         if (DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]).type === itemType || itemType === 'All') {
-          const prop = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i])[property];
-          propertiesValueList.push(prop);
+          const entity = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]);
+          propertiesValueList.push(entity.getProperty(property));
         }
       }
     }

package/core/tables/block.js

@@ -119,6 +119,8 @@ export class Block extends Entity {
         const item = DesignCore.Scene.entities.get(index);
         // remove item from scene
         const copyofitem = Utils.cloneObject(item);
+        // assign a fresh handle — the block item is a new entity distinct from the scene entity
+        copyofitem.setProperty('handle', DesignCore.HandleManager.next());
         // adjust the items points to reflect the insert point
         const delta = new Point(-insertPoint.x, -insertPoint.y);
         if (item.hasOwnProperty('points')) {
@@ -161,9 +163,9 @@ export class Block extends Entity {
    */
   dxf(file) {
     file.writeGroupCode('0', 'BLOCK');
-    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('5', this.getProperty('handle'), DXFFile.Version.R2000); // Handle
     file.writeGroupCode('100', 'AcDbEntity', DXFFile.Version.R2000);
-    file.writeGroupCode('8', this.layer);
+    file.writeGroupCode('8', this.getProperty('layer'));
     file.writeGroupCode('100', 'AcDbBlockBegin', DXFFile.Version.R2000);
     file.writeGroupCode('2', this.name);
     file.writeGroupCode('70', this.flags.getFlagValue());
@@ -196,41 +198,6 @@ export class Block extends Entity {
     this.items.push(item);
   }
 
-  /**
-   * Draw the entity
-   * @param {Object} ctx - context
-   * @param {number} scale
-   * @param {Object} insert - insert entity
-   */
-  draw(ctx, scale, insert = undefined) {
-    if (!this.items.length) {
-      // nothing to draw
-      return;
-    }
-
-    this.items.forEach((item) => {
-      ctx.save();
-      // Use the current item and block insert to set the context
-      // insert required for colour ByBlock
-      DesignCore.Canvas.setContext(item, ctx, insert);
-
-      item.draw(ctx, scale);
-      ctx.restore();
-    });
-
-    /*
-        //////////////////////////////////////////
-        // draw test point for location
-        ctx.strokeStyle = Colours.rgbToString(colour);
-        ctx.lineWidth = 1 / scale;
-        ctx.beginPath()
-        ctx.moveTo(this.points[0].x, this.points[0].y);
-        ctx.arc(this.points[0].x, this.points[0].y, 5 / scale, radians2degrees(0), radians2degrees(360), false);
-        ctx.stroke();
-        //////////////////////////////////////////
-        */
-  }
-
   /**
    * Get snap points
    * @param {Point} mousePoint

package/core/tables/endblk.js

@@ -20,7 +20,7 @@ export class EndBlock extends Entity {
    */
   dxf(file) {
     file.writeGroupCode('0', 'ENDBLK');
-    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('5', this.getProperty('handle'), DXFFile.Version.R2000); // Handle
     file.writeGroupCode('100', 'AcDbEntity', DXFFile.Version.R2000);
     // file.writeGroupCode('8', this.layer);
     file.writeGroupCode('100', 'AcDbBlockEnd', DXFFile.Version.R2000);

package/core/tables/layer.js

@@ -166,6 +166,14 @@ export class Layer {
     return false;
   }
 
+  /**
+   * Determine if layer is plottable (visible and plotting flag set)
+   * @return {boolean}
+   */
+  get isPlottable() {
+    return this.isVisible && this.plotting;
+  }
+
   /**
    * Determine if layer is selectable
    * @return {boolean}

package/core/tables/styleManagerBase.js

@@ -40,7 +40,7 @@ export class StyleManagerBase extends TableManagerBase {
     const selectionSet = [];
 
     for (let i = 0; i < DesignCore.Scene.entities.count(); i++) {
-      if (DesignCore.Scene.entities.get(i)[this.itemProperty] === style) {
+      if ((DesignCore.Scene.entities.get(i).getProperty?.(this.itemProperty) ?? DesignCore.Scene.entities.get(i)[this.itemProperty]) === style) {
         selectionSet.push(i);
       }
     }
@@ -79,7 +79,8 @@ export class StyleManagerBase extends TableManagerBase {
     this.addStandardItems();
 
     for (let i = 0; i < DesignCore.Scene.entities.count(); i++) {
-      const style = (DesignCore.Scene.entities.get(i)[this.itemProperty]);
+      const entity = DesignCore.Scene.entities.get(i);
+      const style = entity.getProperty?.(this.itemProperty) ?? entity[this.itemProperty];
       this.addItem({
         'name': style,
       });

package/core/tables/tableManagerBase.js

@@ -122,10 +122,15 @@ export class TableManagerBase {
       return this.getItemByName(newItemName);
     }
 
-    if (newItem.handle === undefined) {
-      newItem.handle = DesignCore.HandleManager.next();
+    const existingHandle = newItem.getProperty?.('handle') ?? newItem.handle;
+    if (existingHandle === undefined) {
+      if (newItem.setProperty) {
+        newItem.setProperty('handle', DesignCore.HandleManager.next());
+      } else {
+        newItem.handle = DesignCore.HandleManager.next();
+      }
     } else {
-      DesignCore.HandleManager.checkHandle(newItem.handle);
+      DesignCore.HandleManager.checkHandle(existingHandle);
     }
 
     if (!exists) {