@design-core/core 0.0.1 → 0.0.3

package/core/lib/entityManager.js

@@ -0,0 +1,178 @@
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * Entity Manager Class
+ * Holds all entity instances and manages all changes to them
+ */
+export class EntityManager {
+  #entities = [];
+  #trackHandles;
+
+  /**
+   * Create EntityManager
+   * @param {boolean} [trackHandles=true] - whether to track handles for entities
+   */
+  constructor(trackHandles = true) {
+    this.#trackHandles = trackHandles;
+  }
+
+  /**
+   * Create and add new entity
+   * @param {string} type
+   * @param {object} data
+   */
+  create(type, data) {
+    data.layer = DesignCore.LayerManager.getCstyle();
+    const entity = DesignCore.CommandManager.createNew(type, data);
+    this.add(entity);
+  }
+
+  /**
+   * Add entity to manager
+   * @param {object} entity
+   */
+  add(entity) {
+    if (!entity) return;
+
+    if (this.#trackHandles) {
+      if (entity.handle === undefined) {
+        entity.handle = DesignCore.HandleManager.next();
+      } else {
+        DesignCore.HandleManager.checkHandle(entity.handle);
+      }
+    }
+
+    this.#entities.push(entity);
+  }
+
+  /**
+   * Remove entity at index
+   * @param {number} index
+   */
+  remove(index) {
+    if (this.#trackHandles) {
+      const entity = this.#entities[index];
+      if (entity?.handle !== undefined) {
+        DesignCore.HandleManager.releaseHandle(entity.handle);
+      }
+    }
+    this.#entities.splice(index, 1);
+  }
+
+  /**
+   * Get entity at index
+   * @param {number} index
+   * @return {object} entity
+   */
+  get(index) {
+    return this.#entities.at(index);
+  }
+
+  /**
+   * Return all entities
+   * @return {Array} all entities
+   */
+  getAll() {
+    return this.#entities;
+  }
+
+  /**
+   * Replace entity at index
+   * @param {number} index
+   * @param {object} entity
+   */
+  replace(index, entity) {
+    this.#entities.splice(index, 1, entity);
+  }
+
+  /**
+   * Find items in scene
+   * @param {string} type - entity type or "ANY"
+   * @param {string} prop - object of entity parameters
+   * @param {any} value - value of the property
+   * @return {number} - index of items
+   */
+  find(type, prop, value) {
+    const filteredItems = [];
+
+    this.#entities.forEach((item, index) => {
+      if ((type.toUpperCase() === 'ANY' || item.type.toUpperCase() === type.toUpperCase()) && item.hasOwnProperty(prop) && item[prop] === value) {
+        filteredItems.push(index);
+      }
+    });
+
+    return filteredItems;
+  }
+
+  /** Get index of entity
+   * @param {object} entity
+   * @return {number} index
+   */
+  indexOf(entity) {
+    return this.#entities.indexOf(entity);
+  }
+
+
+  /**
+   * Find closest item to point
+   * @param  {Point} point
+   * @return {number} - return index of closest item or undefined
+   */
+  findClosest(point) {
+    let delta = 1.65 / DesignCore.Core.canvas.getScale(); // find a more suitable starting value
+    let closestItemIndex;
+
+    for (let i = 0; i < this.#entities.length; i++) {
+      // check the items layer is selectable - i.e. on, thawed, etc...
+      const layer = DesignCore.LayerManager.getItemByName(this.#entities[i].layer);
+
+      if (!layer?.isSelectable) {
+        continue;
+      }
+
+      const distance = this.#entities[i].closestPoint(point)[1]; // ClosestPoint()[1] returns a distance to the closest point
+
+      if (distance < delta) {
+        delta = distance;
+        closestItemIndex = i;
+      }
+    }
+
+    return closestItemIndex;
+  }
+
+  /**
+   * Update entity at index with data
+   * @param {number} index
+   * @param {object} data
+   */
+  update(index, data) {
+    const item = this.get(index);
+
+    if (!item) {
+      throw Error('Item not found in scene');
+    }
+
+    for (const property of Object.keys(data)) {
+      if (item.hasOwnProperty(property)) {
+        item.setProperty(property, data[property]);
+      }
+    }
+  }
+
+  /**
+   * Get count of entities
+   * @return {number}
+   */
+  count() {
+    return this.#entities.length;
+  }
+
+  /**
+   * Clear all entities
+   */
+  clear() {
+    this.#entities = [];
+  }
+}

package/core/lib/fileio.js

@@ -1,16 +1,26 @@
-import {DXF} from './dxf/dxf.js';
-import {Logging} from './logging.js';
-import {Strings} from './strings.js';
+import { DXF } from './dxf/dxf.js';
+import { Logging } from './logging.js';
+import { Strings } from './strings.js';
 
-import {DesignCore} from '../designCore.js';
+import { DesignCore } from '../designCore.js';
 
+/** FileIO Class */
 export class FileIO {
+  /**
+   * Save to DXF
+   * @param {string} version
+   * @return {string} dxf file as a string
+   */
   static saveDxf(version) {
     const dxfWriter = new DXF();
     const data = dxfWriter.write(version);
     return data;
   }
 
+  /**
+   * Open data as a dxf file
+   * @param {string} data
+   */
   static openFile(data) {
     const dxf = new DXF();
     try {

package/core/lib/headers.js

@@ -0,0 +1,229 @@
+import { DesignCore } from '../designCore.js';
+import { DXFFile } from './dxf/dxfFile.js';
+import { Property } from '../properties/property.js';
+
+/** Headers Class
+ *
+ * Stores drawing-level variables that correspond to DXF HEADER section entries.
+ * These values are per-drawing, not application preferences
+ */
+export class Headers {
+  // $FILLETRAD (group code 40)
+  #filletRadius = 0;
+
+  // $TRIMMODE (group code 70) - false = no trim, true = trim
+  #trimMode = true;
+
+  // $TEXTSIZE (group code 40)
+  #textSize = 2.5;
+
+  // $CHAMFERA (group code 40)
+  #chamferDistanceA = 0;
+
+  // $CHAMFERB (group code 40)
+  #chamferDistanceB = 0;
+
+  // $CHAMFERC (group code 40)
+  #chamferLength = 0;
+
+  // $CHAMFERD (group code 40)
+  #chamferAngle = 0;
+
+  // $CHAMMODE (group code 70) - false = distances, true = angle
+  #chamferMode = false;
+
+  // $OFFSETDIST (group code 40)
+  #offsetDistance = 0;
+
+  // $ACADVER (group code 1)
+  #dxfVersion = 'R2018';
+
+  /** Create Headers */
+  constructor() { }
+
+  /** @type {number} Fillet radius ($FILLETRAD) */
+  get filletRadius() {
+    return this.#filletRadius;
+  }
+
+  /** @param {number} value */
+  set filletRadius(value) {
+    const num = parseFloat(value);
+    if (!isFinite(num) || num < 0) throw new Error(`Invalid filletRadius: ${value}`);
+    this.#filletRadius = num;
+  }
+
+  /** @type {boolean} Trim mode ($TRIMMODE) */
+  get trimMode() {
+    return this.#trimMode;
+  }
+
+  /** @param {boolean} value */
+  set trimMode(value) {
+    if (typeof value !== 'boolean') throw new Error(`Invalid trimMode: ${value}`);
+    this.#trimMode = value;
+  }
+
+  /** @type {number} Default text size ($TEXTSIZE) */
+  get textSize() {
+    return this.#textSize;
+  }
+
+  /** @param {number} value */
+  set textSize(value) {
+    const num = parseFloat(value);
+    if (!isFinite(num) || num <= 0) throw new Error(`Invalid textSize: ${value}`);
+    this.#textSize = num;
+  }
+
+  /** @type {number} Chamfer distance A ($CHAMFERA) */
+  get chamferDistanceA() {
+    return this.#chamferDistanceA;
+  }
+
+  /** @param {number} value */
+  set chamferDistanceA(value) {
+    const num = parseFloat(value);
+    if (!isFinite(num) || num < 0) throw new Error(`Invalid chamferDistanceA: ${value}`);
+    this.#chamferDistanceA = num;
+  }
+
+  /** @type {number} Chamfer distance B ($CHAMFERB) */
+  get chamferDistanceB() {
+    return this.#chamferDistanceB;
+  }
+
+  /** @param {number} value */
+  set chamferDistanceB(value) {
+    const num = parseFloat(value);
+    if (!isFinite(num) || num < 0) throw new Error(`Invalid chamferDistanceB: ${value}`);
+    this.#chamferDistanceB = num;
+  }
+
+  /** @type {number} Chamfer length ($CHAMFERC) */
+  get chamferLength() {
+    return this.#chamferLength;
+  }
+
+  /** @param {number} value */
+  set chamferLength(value) {
+    const num = parseFloat(value);
+    if (!isFinite(num) || num < 0) throw new Error(`Invalid chamferLength: ${value}`);
+    this.#chamferLength = num;
+  }
+
+  /** @type {number} Chamfer angle ($CHAMFERD) */
+  get chamferAngle() {
+    return this.#chamferAngle;
+  }
+
+  /** @param {number} value */
+  set chamferAngle(value) {
+    const num = parseFloat(value);
+    if (!isFinite(num) || num < 0) throw new Error(`Invalid chamferAngle: ${value}`);
+    this.#chamferAngle = num;
+  }
+
+  /** @type {boolean} Chamfer method ($CHAMMODE): false = distances, true = angle */
+  get chamferMode() {
+    return this.#chamferMode;
+  }
+
+  /** @param {boolean} value */
+  set chamferMode(value) {
+    if (typeof value !== 'boolean') throw new Error(`Invalid chamferMode: ${value}`);
+    this.#chamferMode = value;
+  }
+
+  /** @type {number} Offset distance ($OFFSETDIST) */
+  get offsetDistance() {
+    return this.#offsetDistance;
+  }
+
+  /** @param {number} value */
+  set offsetDistance(value) {
+    const num = parseFloat(value);
+    if (!isFinite(num)) throw new Error(`Invalid offsetDistance: ${value}`);
+    this.#offsetDistance = num;
+  }
+
+  /** @type {string} DXF version key ($ACADVER) */
+  get dxfVersion() {
+    return this.#dxfVersion;
+  }
+
+  /** @param {string} value - DXF version string or key */
+  set dxfVersion(value) {
+    if (DXFFile.validDxfVersion(value)) value = DXFFile.getVersionKey(value);
+    if (!DXFFile.validDxfKey(value)) throw new Error(`Invalid DXF version: ${value}`);
+    this.#dxfVersion = value;
+  }
+
+  /**
+   * Load header values from a parsed DXF header object.
+   * Only updates values that are present in the file; defaults are preserved otherwise.
+   * @param {Object} header - parsed header section object from DXFReader
+   */
+  load(header) {
+    this.filletRadius = parseFloat(Property.loadValue([header?.['$FILLETRAD']?.['40']], this.filletRadius));
+    this.textSize = parseFloat(Property.loadValue([header?.['$TEXTSIZE']?.['40']], this.textSize));
+    this.chamferDistanceA = parseFloat(Property.loadValue([header?.['$CHAMFERA']?.['40']], this.chamferDistanceA));
+    this.chamferDistanceB = parseFloat(Property.loadValue([header?.['$CHAMFERB']?.['40']], this.chamferDistanceB));
+    this.chamferLength = parseFloat(Property.loadValue([header?.['$CHAMFERC']?.['40']], this.chamferLength));
+    this.chamferAngle = parseFloat(Property.loadValue([header?.['$CHAMFERD']?.['40']], this.chamferAngle));
+
+    // $TRIMMODE, $CHAMMODE, and $OFFSETDIST are system variables not written to file by AutoCAD.
+    // These are commented out but retained in case files from other applications include them.
+    // const trimModeRaw = Property.loadValue([header?.['$TRIMMODE']?.['70']]);
+    // if (trimModeRaw !== undefined) this.trimMode = parseInt(trimModeRaw) !== 0;
+
+    // const chamferModeRaw = Property.loadValue([header?.['$CHAMMODE']?.['70']]);
+    // if (chamferModeRaw !== undefined) this.chamferMode = parseInt(chamferModeRaw) !== 0;
+
+    // this.offsetDistance = parseFloat(Property.loadValue([header?.['$OFFSETDIST']?.['40']], this.offsetDistance));
+
+    const acadVer = Property.loadValue([header?.['$ACADVER']?.['1']]);
+    if (acadVer !== undefined) this.dxfVersion = acadVer;
+  }
+
+  /**
+   * Write the DXF HEADER section content to a DXF file
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('9', '$ACADVER');
+    file.writeGroupCode('1', file.version);
+    file.writeGroupCode('9', '$TEXTSTYLE');
+    // TODO: StyleManager write to headers?
+    file.writeGroupCode('7', DesignCore.StyleManager.getCstyle());
+    file.writeGroupCode('9', '$CLAYER');
+    // TODO: LayerManager write to headers?
+    file.writeGroupCode('8', DesignCore.LayerManager.getCstyle());
+    file.writeGroupCode('9', '$DIMSTYLE');
+    // TODO: DimStyleManager write to headers?
+    file.writeGroupCode('2', DesignCore.DimStyleManager.getCstyle());
+    file.writeGroupCode('9', '$HANDSEED', DXFFile.Version.R2000);
+    file.writeGroupCode('5', DesignCore.HandleManager.handseed, DXFFile.Version.R2000);
+    file.writeGroupCode('9', '$TEXTSIZE');
+    file.writeGroupCode('40', this.textSize);
+    file.writeGroupCode('9', '$FILLETRAD');
+    file.writeGroupCode('40', this.filletRadius);
+    // $TRIMMODE is a system variable and is not written to file by AutoCAD
+    // file.writeGroupCode('9', '$TRIMMODE');
+    // file.writeGroupCode('70', this.trimMode ? 1 : 0);
+    file.writeGroupCode('9', '$CHAMFERA');
+    file.writeGroupCode('40', this.chamferDistanceA);
+    file.writeGroupCode('9', '$CHAMFERB');
+    file.writeGroupCode('40', this.chamferDistanceB);
+    file.writeGroupCode('9', '$CHAMFERC');
+    file.writeGroupCode('40', this.chamferLength);
+    file.writeGroupCode('9', '$CHAMFERD');
+    file.writeGroupCode('40', this.chamferAngle);
+    // $CHAMMODE is a system variable and is not written to file by AutoCAD
+    // file.writeGroupCode('9', '$CHAMMODE');
+    // file.writeGroupCode('70', this.chamferMode ? 1 : 0);
+    // $OFFSETDIST is a system variable and is not written to file by AutoCAD
+    // file.writeGroupCode('9', '$OFFSETDIST');
+    // file.writeGroupCode('40', this.offsetDistance);
+  }
+}

package/core/lib/input.js

@@ -0,0 +1,46 @@
+/** Sentinel resolved when a MOUSEDOWN prompt completes */
+export class MouseDown {}
+
+/** Sentinel resolved when a MOUSEUP prompt completes */
+export class MouseUp {}
+
+/** Input Class */
+export class Input {
+  static Cursor = {
+    DEFAULT: 'DEFAULT',
+    GRAB: 'GRAB',
+    GRABBING: 'GRABBING',
+    SELECTION: 'SELECTION',
+  };
+
+  /**
+   * Input type definitions.
+   * Each entry describes an accepted input type:
+   *   value  — matches value.constructor.name for runtime type detection via getType()
+   *   cursor — the cursor state to apply when this type is requested (null = DEFAULT)
+   */
+  static Type = {
+    POINT: { value: 'Point', cursor: null },
+    SELECTIONSET: { value: 'SelectionSet', cursor: Input.Cursor.SELECTION },
+    SINGLESELECTION: { value: 'SingleSelection', cursor: Input.Cursor.SELECTION },
+    NUMBER: { value: 'Number', cursor: null },
+    STRING: { value: 'String', cursor: null },
+    DYNAMIC: { value: 'Dynamic', cursor: null },
+    MOUSEDOWN: { value: 'MouseDown', cursor: null },
+    MOUSEUP: { value: 'MouseUp', cursor: null },
+  };
+
+  /**
+   * Return the Input.Type for value
+   * @param {any} value
+   * @return {Object|undefined}
+   */
+  static getType(value) {
+    if (value === undefined) {
+      return undefined;
+    }
+
+    const name = value.constructor.name;
+    return Object.values(Input.Type).find((t) => t.value === name);
+  }
+}