@design-core/core 0.0.1 → 0.0.3

package/core/lib/strings.js

@@ -1,9 +1,14 @@
+
+/**
+ * String Class
+ * Holds common strings for consistency and translation
+ */
 export class Strings {
-// Error Strings
+  // Error Strings
   static Error = {
     ERROR: 'Error',
-    FILEOPEN: 'Error opening file',
-    INPUT: 'Incorrect input',
+    FILEOPEN: 'Error Opening File',
+    INPUT: 'Invalid Input',
     INVALIDFILE: 'Invalid File',
     INVALIDDXFFORMAT: 'Invalid DXF Format',
     INVALIDPOINT: 'Invalid Point Data',
@@ -11,6 +16,15 @@ export class Strings {
     INVALIDNUMBER: 'Invalid Number',
     INVALIDTYPE: 'Invalid Type',
     INVALIDINTERSECTTYPE: 'Invalid Intersect Type',
+    SELECTION: 'Invalid Selection',
+    PARALLELLINES: 'Parallel Lines',
+    RADIUSTOOLARGE: 'Radius too large',
+    INVALIDCLIPBOARD: 'Invalid Clipboard Data',
+    INVALIDBOUNDARY: 'Invalid Boundary Item',
+    NONZERO: 'Value must be positive and nonzero',
+    MINVALUE: 'Value is too small',
+    MAXVALUE: 'Value is too large',
+    ZEROLENGTH: 'Cannot define a zero length line',
   };
 
   // Warning Strings
@@ -27,19 +41,43 @@ export class Strings {
     CSTYLEDELETE: 'Currently selected style cannot be deleted',
     CANNOTBEDELETED: 'cannot be deleted',
     CANNOTBERENAMED: 'cannot be renamed',
+    CANNOTBEACTIONED: 'cannot be actioned',
+    COMPLETED: 'completed',
+    NOUNDO: 'No actions to undo',
+    NOREDO: 'No actions to redo',
+    NOTRIM: 'cannot be trimmed',
+    NOEXTEND: 'cannot be extended',
+    NOFILLET: 'cannot be filleted',
+    NOCHAMFER: 'cannot be chamfered',
+    NONCONSECUTIVESEGMENTS: 'segments must be consecutive',
+    NOTIMPLEMENTED: 'Not Implemented',
   };
 
   // Strings
   static Strings = {
+    ARC: 'Arc',
     LENGTH: 'Length',
     LINE: 'Line',
     VARIES: 'Varies',
+    AND: 'and',
+    OR: 'or',
+    ITEMS: 'item(s)',
+    ADDED: 'added',
+    REMOVED: 'removed',
+  };
+
+  // colours
+  static Colour = {
+    BYLAYER: 'ByLayer',
+    BYBLOCK: 'ByBlock',
   };
 
   // Unicode Symbols
   static Symbol = {
-    DIAMETER: '\u2300',
+    DIAMETER: '\u00D8',
     DEGREE: '\u00B0',
+    RADIUS: 'R',
+    DELTA: '\u0394',
   };
 
   // Input Strings
@@ -50,17 +88,31 @@ export class Strings {
     START: 'Specify start point',
     END: 'Specify end point',
     POINT: 'Specify a point',
-    DIMENSION: 'Specify dimension location',
+    DIMENSION: 'Specify dimension position',
+    CLOSE: 'Close',
     NEXTPOINT: 'Specify next point',
     RADIUS: 'Specify radius',
+    DIAMETER: 'Specify diameter',
     POSITION: 'Specify position',
     HEIGHT: 'Specify height',
     STRING: 'Specify text',
+    NAME: 'Specify name',
     OPTION: 'Specify option',
     ANGLE: 'Specify angle',
     ROTATION: 'Specify rotation angle',
     DESTINATION: 'Specify destination',
+    DISTANCE: 'Specify offset distance',
+    SIDE: 'Specify point on side to offset',
+    THROUGHPOINT: 'Specify through point',
     SELECT: 'Select object',
     SELECTIONSET: 'Select Items',
+    SOURCE: 'Select source object',
+    DESTINATIONSET: 'Select destination object(s)',
+    MIRRORFIRST: 'Specify first point of mirror line',
+    MIRRORSECOND: 'Specify second point of mirror line',
+    ERASESOURCE: 'Erase source objects?',
+    SCALEFACTOR: 'Specify scale factor',
+    REFERENCELENGTH: 'Specify reference length',
+    NEWLENGTH: 'Specify new length',
   };
 };

package/core/lib/utils.js

@@ -1,8 +1,13 @@
+
+import { Logging } from './logging.js';
+import { Constants } from './constants.js';
+
+/** Utils Class */
 export class Utils {
   /**
    * Convert degrees to radians
    * @param {number} degrees
-   * @returns angle in radians
+   * @return {number} angle in radians
    */
   static degrees2radians(degrees) {
     return degrees * Math.PI / 180;
@@ -11,7 +16,7 @@ export class Utils {
   /**
    * Convert radians to degrees
    * @param {number} radians
-   * @returns angle in degrees
+   * @return {number} angle in degrees
    */
   static radians2degrees(radians) {
     return radians * 180 / Math.PI;
@@ -20,19 +25,71 @@ export class Utils {
   /**
    * Round to 5 decimal places
    * @param {number} number
-   * @returns rounded number
+   * @return {number} rounded number
    */
   static round(number) {
-    return Number(number.toFixed(5));
+    return Number(Number(number).toFixed(Constants.Precision.DECIMALPLACES));
+  }
+
+  /**
+   * Sort points by distance to reference point
+   * note this mutates the points array
+   * @param {Array} points
+   * @param {Point} refPoint
+   */
+  static sortPointsByDistance(points, refPoint) {
+    points.sort((a, b) => {
+      const da = (a.x - refPoint.x) ** 2 + (a.y - refPoint.y) ** 2;
+      const db = (b.x - refPoint.x) ** 2 + (b.y - refPoint.y) ** 2;
+      return da - db; // nearest first
+    });
+  }
+
+  /**
+   * Sort points around an arc center by angular position.
+   * Mutates the points array.
+   *
+   * @param {Array} points - array of points
+   * @param {Point} startPoint - arc start point
+   * @param {Point} endPoint - arc end point
+   * @param {Point} centerPoint - arc center point
+   * @param {number} direction - arc direction (ccw >0, cw <=0)
+   *
+   */
+  static sortPointsOnArc(points, startPoint, endPoint, centerPoint, direction = 1) {
+    if (!Array.isArray(points)) return;
+
+    const refAngle = direction > 0 ? centerPoint.angle(startPoint) : centerPoint.angle(endPoint);
+    const twoPi = Math.PI * 2;
+    const normalize = (ang) => ((ang % twoPi) + twoPi) % twoPi;
+
+    // map points to angles
+    const mapped = points.map((point) => {
+      const angle = Math.atan2(point.y - centerPoint.y, point.x - centerPoint.x);
+      const normalizedAngle = normalize(angle - refAngle);
+      return { point, normalizedAngle };
+    });
+
+    // sort by angle
+    mapped.sort((u, v) => u.normalizedAngle - v.normalizedAngle);
+
+    // direction: - ccw > 0, cw <= 0
+    if (direction <= 0) mapped.reverse();
+
+    // write back into original array (preserve Point instances)
+    for (let i = 0; i < mapped.length; i++) {
+      points[i] = mapped[i].point;
+    }
   }
 
   /**
    * Deep clone object
-   * @param {objec} obj - object to clone
-   * @returns - new cloned object
+   * @param {Object} obj - object to clone
+   * @return {Object} - new cloned object
    */
   static cloneObject(obj) {
     // deep clone obj and all its attributes
+
     if (obj === null || typeof obj !== 'object') {
       return obj;
     }
@@ -42,19 +99,46 @@ export class Utils {
 
     for (const key of Reflect.ownKeys(obj)) {
       const value = obj[key];
-      clone[key] = value instanceof Object && typeof value !== 'function' ? this.cloneObject(value) : value;
+      try {
+        if (Array.isArray(value)) {
+          clone[key] = value.map((v) => this.cloneObject(v));
+        } else if (value && typeof value === 'object' && typeof value !== 'function') {
+          clone[key] = this.cloneObject(value);
+        } else {
+          clone[key] = value;
+        }
+      } catch (e) {
+        const err = 'Utils.cloneObject - Could not clone property';
+        Logging.instance.warn(`${err}:${key} - ${e}`);
+      }
+    }
+
+    // Clear handle so a fresh unique handle is assigned when added to the scene
+    if (clone.handle !== undefined) {
+      clone.handle = undefined;
     }
 
     return clone;
   }
 
+  /**
+   * Calculate area of triangle given 3 points
+   * @param {Point} p1
+   * @param {Point} p2
+   * @param {Point} p3
+   * @return {number} area of triangle
+   */
+  static areaOfTriangle(p1, p2, p3) {
+    return Math.abs((p1.x * (p2.y - p3.y) + p2.x * (p3.y - p1.y) + p3.x * (p1.y - p2.y)) / 2.0);
+  }
+
   /**
    * Returns a levenshtein edit distance to the input strings
    * The distance represents the minimum number of character edits required to change one string into the other.
    * a lower number suggests the strings are more similar and value of 0 means they are the same.
    * @param {string} a
    * @param {string} b
-   * @returns {integer} levenshtein edit distance
+   * @return {number} levenshtein edit distance
    * inspired by https://gist.github.com/andrei-m/982927
    */
   static getLevenshteinDistance(a, b) {
@@ -67,9 +151,9 @@ export class Utils {
         m[0][j] = j;
         if (j === 0) continue;
         m[i][j] = b.charAt(i - 1) == a.charAt(j - 1) ? m[i - 1][j - 1] : Math.min(
-            m[i-1][j-1] + 1,
-            m[i][j-1] + 1,
-            m[i-1][j] + 1,
+            m[i - 1][j - 1] + 1,
+            m[i][j - 1] + 1,
+            m[i - 1][j] + 1,
         );
       }
     }

package/core/objects/dictionary.js

@@ -0,0 +1,43 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { Property } from '../properties/property.js';
+
+/** Dictionary Class */
+export class Dictionary {
+  /**
+   * Create a Dictionary
+   * @param {Object} data
+   */
+  constructor(data) {
+    // DXF Groupcode 5 - Handle
+    this.handle = Property.loadValue([data?.handle, data?.[5]]);
+    this.name = Property.loadValue([data?.name, data?.[3]], '');
+    this.duplicateRecordCloning = Property.loadValue([data?.duplicateRecordCloning, data?.[281]], 1);
+    this.entries = Property.loadValue([data?.entries], []);
+
+    // Build entries from DXF group codes 3 (name) and 350 (handle)
+    if (!this.entries.length && data?.[3] !== undefined && data?.[350] !== undefined) {
+      const names = Array.isArray(data[3]) ? data[3] : [data[3]];
+      const handles = Array.isArray(data[350]) ? data[350] : [data[350]];
+
+      for (let i = 0; i < names.length && i < handles.length; i++) {
+        this.entries.push({ 'name': names[i], 'handle': handles[i] });
+      }
+    }
+  }
+
+  /**
+   * Write the item to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'DICTIONARY', DXFFile.Version.R2000);
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbDictionary', DXFFile.Version.R2000);
+    file.writeGroupCode('281', this.duplicateRecordCloning.toString(), DXFFile.Version.R2000);
+
+    for (let i = 0; i < this.entries.length; i++) {
+      file.writeGroupCode('3', this.entries[i].name, DXFFile.Version.R2000);
+      file.writeGroupCode('350', this.entries[i].handle, DXFFile.Version.R2000);
+    }
+  }
+}

package/core/objects/dictionaryManager.js

@@ -0,0 +1,80 @@
+import { Dictionary } from './dictionary.js';
+import { DesignCore } from '../designCore.js';
+
+/**
+ * DictionaryManager Class
+ * Manages DXF dictionary objects for the OBJECTS section
+ */
+export class DictionaryManager {
+  /** Create a DictionaryManager */
+  constructor() {
+    this.addStandardItems();
+  }
+
+  /**
+   * Create the standard dictionary items
+   */
+  addStandardItems() {
+    // ACAD_GROUP: child dictionary that stores named entity groups (selections)
+    this.groupDictionary = new Dictionary({
+      'name': 'ACAD_GROUP',
+      'handle': DesignCore.HandleManager.next(),
+    });
+
+    // Root dictionary with entry pointing to ACAD_GROUP
+    this.rootDictionary = new Dictionary({
+      'handle': DesignCore.HandleManager.next(),
+      'entries': [{ 'name': 'ACAD_GROUP', 'handle': this.groupDictionary.handle }],
+    });
+  }
+
+  /**
+   * Clear all dictionary items
+   */
+  clearItems() {
+    this.groupDictionary = undefined;
+    this.rootDictionary = undefined;
+  }
+
+  /**
+   * Add a dictionary item from parsed DXF data
+   * @param {Object} data - parsed DICTIONARY object
+   */
+  addItem(data) {
+    const dictionary = new Dictionary(data);
+    DesignCore.HandleManager.checkHandle(dictionary.handle);
+
+    if (!this.rootDictionary) {
+      // The first dictionary is the root dictionary
+      this.rootDictionary = dictionary;
+      // Only keep entries for dictionaries that Design manages
+      const groupEntry = this.rootDictionary.entries.find((entry) => entry.name === 'ACAD_GROUP');
+      this.rootDictionary.entries = groupEntry ? [groupEntry] : [];
+    } else if (!this.groupDictionary) {
+      // Check if this dictionary is the ACAD_GROUP child
+      const groupEntry = this.rootDictionary.entries[0];
+      if (groupEntry && dictionary.handle === groupEntry.handle) {
+        dictionary.name = groupEntry.name;
+        this.groupDictionary = dictionary;
+      }
+    }
+  }
+
+  /**
+   * Ensure standard dictionary items exist
+   */
+  checkItems() {
+    if (!this.rootDictionary || !this.groupDictionary) {
+      this.addStandardItems();
+    }
+  }
+
+  /**
+   * Write the dictionaries to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    this.rootDictionary.dxf(file);
+    this.groupDictionary.dxf(file);
+  }
+}

package/core/properties/dimType.js

@@ -0,0 +1,117 @@
+
+/** DimType Class */
+export class DimType {
+  /** Create DimType
+   * @param {number} dimType - dxf dimType value
+  */
+  constructor(dimType=0) {
+    // 0 = Rotated, horizontal, or vertical;
+    // 1 = Aligned;
+    // 2 = Angular;
+    // 3 = Diameter;
+    // 4 = Radius;
+    // 5 = Angular 3 point;
+    // 6 = Ordinate;
+    // 32 = Indicates that the block reference (group code 2) is referenced by this dimension only
+    // 64 = Ordinate type. This is a bit value (bit 7) used only with integer value 6. If set, ordinate is X-type; if not set, ordinate is Y-type
+    // 128 = This is a bit value (bit 8) added to the other group 70 values if the dimension text
+
+    this.dimType = 0;
+    this.blockReference = true; // dimType bit 32 - dimension uses a block
+    this.xTypeOrdinate = false; // dimType bit 64 - ordinate is X-type
+    this.userPositionedText = false; // dimType bit 128 - text is user positioned
+
+    this.setDimType(dimType);
+  }
+
+  /** Check if dimension type is valid
+   * @param {number} dimType
+   * @return {boolean} true if valid dimension type
+  */
+  static isValidDimensionType(dimType) {
+    // get the base type
+    const baseType = DimType.getBaseType(dimType);
+    // check if base type is valid
+    return baseType >= 0 && baseType <= 6;
+  }
+
+
+  /** Get Base Type
+   * @param {number} dimType
+   * @return {number} base dimension type
+  */
+  static getBaseType(dimType) {
+    // sort the type temporarily
+    let baseType = Number(dimType);
+    // strip off the bit values
+    if ((baseType & 128) !== 0) {
+      baseType -= 128;
+    };
+    if ((baseType & 64) !== 0) {
+      baseType -= 64;
+    };
+    if ((baseType & 32) !== 0) {
+      baseType -= 32;
+    };
+    // return base type
+    return baseType;
+  }
+
+  /**
+   * Get Dimension Type without any flags
+   * @return {number}
+   */
+  getBaseDimType() {
+    return this.dimType;
+  }
+
+  /**
+   * Get Dimension Type with flags
+   * @return {number}
+   */
+  getDimType() {
+    let dimType = this.dimType;
+    if (this.blockReference) {
+      dimType += 32;
+    }
+    if (this.xTypeOrdinate) {
+      dimType += 64;
+    }
+    if (this.userPositionedText) {
+      dimType += 128;
+    }
+    return dimType;
+  }
+
+  /**
+   * Set Dimension Type
+   * @param {number} dimType
+   */
+  setDimType(dimType) {
+    // handle invalid input
+    if (!DimType.isValidDimensionType(dimType)) {
+      dimType = 0; // default to 0 if invalid
+    }
+
+    this.dimType = DimType.getBaseType(dimType);
+    this.blockReference = (dimType & 32) !== 0;
+    this.xTypeOrdinate = (dimType & 64) !== 0;
+    this.userPositionedText = (dimType & 128) !== 0;
+  }
+
+  /**
+   * Check if the dimension has a block reference
+   * @return {boolean} true if the dimension has a block reference
+   */
+  hasBlockReference() {
+    return this.blockReference;
+  }
+
+  /**
+   * Check if the dimension text is user positioned
+   * @return {boolean} true if the dimension text is user positioned
+   */
+  hasUserPositionedText() {
+    return this.userPositionedText;
+  }
+}

package/core/properties/flags.js

@@ -0,0 +1,66 @@
+/** Flags Class */
+export class Flags {
+  /** Create Flags */
+  constructor() {
+    /* flags - bit-coded values
+    | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
+      0     0    0    1    0   0   1   1
+    */
+    this.flags = 0;
+  }
+
+  /**
+   * Set the flag value
+   * @param {number} flagValue
+   */
+  setFlagValue(flagValue) {
+    const value = Number(flagValue);
+    if (isNaN(value) === false) {
+      this.flags = value;
+    }
+  }
+
+  /**
+ * Get the flag value
+ * @return {number} flags value
+ */
+  getFlagValue() {
+    return this.flags;
+  }
+
+  /**
+   * Get the backwards value
+   * @param {number} flagValue
+   * @return {boolean} true if flags contains the flagValue
+   */
+  hasFlag(flagValue) {
+    // check if the flagValue is bitmasked in flags
+    // Bitwise AND (&) returns a value where each number has a 1 in the respective bit
+    /* Example
+      this.flags = 7 (01011)
+      flagValue = 3 (0011)
+      bits:       16 | 8 | 4 | 2 | 1
+      flags:      0  | 0 | 1 | 1 | 1
+      flagValue:  0  | 0 | 0 | 1 | 1
+      result:     0  | 0 | 0 | 1 | 1
+      decimal:  3
+    */
+    return Boolean((this.flags & flagValue) === flagValue);
+  }
+
+  /**
+   * Set the flag value
+   * @param {number} flagValue
+   */
+  addValue(flagValue) {
+    this.flags = (this.flags | Number(flagValue));
+  }
+
+  /**
+ * Remove the flag value
+ * @param {number} flagValue
+ */
+  removeValue(flagValue) {
+    this.flags = (this.flags ^ (this.flags & flagValue));
+  }
+}

package/core/properties/property.js

@@ -0,0 +1,26 @@
+import { Flags } from './flags.js';
+
+/** Property Class */
+export class Property {
+  /** Create property */
+  constructor() { }
+
+  /**
+   * Parse the input values and return a value
+   * @param {Array} values - list of values
+   * @param {any} def - default value
+   * @return {any}
+   */
+  static loadValue(values, def) {
+    // return any value in values
+    for (let i = 0; i < values.length; i++) {
+      if (values[i] !== undefined) {
+        // check if the value is a flags object
+        return (values[i] instanceof Flags) ? values[i].getFlagValue() : values[i];
+      }
+    };
+
+    // no valid values, return the default value
+    return def;
+  }
+}