@design-core/core 0.0.1 → 0.0.3

package/core/lib/dxf/dxf.js

@@ -1,41 +1,68 @@
-import {DXFReader} from './dxfRead.js';
-import {DXFWriter} from './dxfWrite.js';
-import {DXFFile} from './dxfFile.js';
-import {Point} from '../../entities/point.js';
-import {Strings} from '../strings.js';
-import {Logging} from '../logging.js';
+import { DXFReader } from './dxfRead.js';
+import { DXFWriter } from './dxfWrite.js';
+import { DXFFile } from './dxfFile.js';
+import { Point } from '../../entities/point.js';
+import { Strings } from '../strings.js';
+import { Logging } from '../logging.js';
 
-import {DesignCore} from '../../designCore.js';
+import { DesignCore } from '../../designCore.js';
 
+/** DXF Class */
 export class DXF {
+  /** Create DXF */
   constructor() {
     this.reader;
     this.writer;
 
     // flag indicates if dxf contains unsupported elements
     this.unsupportedElements = false;
+
+    // map of block name to block record handle
+    this.blockRecordHandles = {};
   }
 
+  /**
+   * Read
+   * @param {Object} data
+   */
   read(data) {
     this.reader = new DXFReader();
     this.reader.read(data);
   }
 
+  /**
+   * Write
+   * @param {string} version
+   * @return {Object}
+   */
   write(version) {
     const writer = new DXFWriter();
     const data = writer.write(version);
     return data;
   }
 
+  /**
+   * Load DXF
+   * @param {string} data
+   */
   loadDxf(data) {
     Logging.instance.debug('Loading File');
     this.read(data);
 
+    // Reset handles before loading
+    // This prevents handle collisions between init handles and file handles
+    DesignCore.HandleManager.reset();
+
+    // load handseed first to ensure the handle counter is correctly set
+    // before any new handles are assigned during table/block/entity loading
+    this.loadHandseed();
+
     this.loadTables();
     this.loadBlocks();
     this.loadEntities();
+    this.loadObjects();
 
-    // load headers last to ensure the elements and layers exist
+    // load headers for styles and version
     this.loadHeader();
 
     if (this.unsupportedElements) {
@@ -43,9 +70,38 @@ export class DXF {
     }
   }
 
+  /**
+   * Load Handseed from header
+   * Must be called before loading tables/blocks/entities
+   * to ensure the handle counter is set beyond all handles in the file
+   */
+  loadHandseed() {
+    const header = this.reader.header;
+
+    if (header.hasOwnProperty('$HANDSEED')) {
+      const handseed = header['$HANDSEED'];
+      if (handseed.hasOwnProperty('5')) {
+        const maxHandseed = handseed['5'];
+        Logging.instance.debug(`Opening DXF Handseed: ${maxHandseed}`);
+        DesignCore.HandleManager.handseed = maxHandseed;
+      }
+    }
+  }
+
+  /**
+   * Load Header
+   */
   loadHeader() {
     const header = this.reader.header;
 
+    if (header.hasOwnProperty('$TEXTSTYLE')) {
+      const cstyle = header['$TEXTSTYLE'];
+      if (cstyle.hasOwnProperty('7')) {
+        const styleName = cstyle['7'];
+        DesignCore.StyleManager.setCstyle(styleName);
+      }
+    }
+
     if (header.hasOwnProperty('$CLAYER')) {
       const clayer = header['$CLAYER'];
       if (clayer.hasOwnProperty('8')) {
@@ -54,6 +110,14 @@ export class DXF {
       }
     }
 
+    if (header.hasOwnProperty('$DIMSTYLE')) {
+      const dimstyle = header['$DIMSTYLE'];
+      if (dimstyle.hasOwnProperty('2')) {
+        const styleName = dimstyle['2'];
+        DesignCore.DimStyleManager.setCstyle(styleName);
+      }
+    }
+
     if (header.hasOwnProperty('$ACADVER')) {
       const version = header['$ACADVER'];
       if (version.hasOwnProperty('1')) {
@@ -64,63 +128,154 @@ export class DXF {
         DesignCore.Core.dxfVersion = versionNumber;
       }
     }
+
+    // Load drawing-level header variables into Scene.headers
+    DesignCore.Scene.headers.load(header);
   }
 
 
+  /**
+   * Load Tables
+   */
   loadTables() {
     const tables = this.reader.tables;
 
     tables.forEach((table) => {
       if (table[2] === 'LAYER') {
+        if (table[5]) {
+          DesignCore.HandleManager.checkHandle(table[5]);
+          DesignCore.LayerManager.handle = table[5];
+        }
+        if (table.children.length) {
+          DesignCore.LayerManager.clearItems();
+        }
         table.children.forEach((layer) => {
-          DesignCore.LayerManager.addStyle(layer, true);
+          DesignCore.LayerManager.addItem(layer, true);
         });
       }
 
       if (table[2] === 'LTYPE') {
+        if (table[5]) {
+          DesignCore.HandleManager.checkHandle(table[5]);
+          DesignCore.LTypeManager.handle = table[5];
+        }
+        if (table.children.length) {
+          DesignCore.LTypeManager.clearItems();
+        }
         table.children.forEach((ltype) => {
-          DesignCore.LTypeManager.addStyle(ltype, true);
+          DesignCore.LTypeManager.addItem(ltype, true);
         });
       }
 
       if (table[2] === 'STYLE') {
+        if (table[5]) {
+          DesignCore.HandleManager.checkHandle(table[5]);
+          DesignCore.StyleManager.handle = table[5];
+        }
+        if (table.children.length) {
+          DesignCore.StyleManager.clearItems();
+        }
         table.children.forEach((style) => {
-          DesignCore.StyleManager.addStyle(style, true);
+          DesignCore.StyleManager.addItem(style, true);
         });
       }
 
       if (table[2] === 'DIMSTYLE') {
+        if (table[5]) {
+          DesignCore.HandleManager.checkHandle(table[5]);
+          DesignCore.DimStyleManager.handle = table[5];
+        }
+        if (table.children.length) {
+          DesignCore.DimStyleManager.clearItems();
+        }
         table.children.forEach((style) => {
-          DesignCore.DimStyleManager.addStyle(style, true);
+          DesignCore.DimStyleManager.addItem(style, true);
+        });
+      }
+
+      if (table[2] === 'VPORT') {
+        if (table[5]) {
+          DesignCore.HandleManager.checkHandle(table[5]);
+          DesignCore.VPortManager.handle = table[5];
+        }
+        if (table.children.length) {
+          DesignCore.VPortManager.clearItems();
+        }
+        table.children.forEach((vport) => {
+          DesignCore.VPortManager.addItem(vport, true);
         });
       }
+
+      if (table[2] === 'VIEW') {
+        if (table[5]) {
+          DesignCore.HandleManager.checkHandle(table[5]);
+          DesignCore.ViewManager.handle = table[5];
+        }
+        if (table.children.length) {
+          DesignCore.ViewManager.clearItems();
+        }
+        table.children.forEach((view) => {
+          DesignCore.ViewManager.addItem(view, true);
+        });
+      }
+
+      if (table[2] === 'UCS') {
+        if (table[5]) {
+          DesignCore.HandleManager.checkHandle(table[5]);
+          DesignCore.UCSManager.handle = table[5];
+        }
+        if (table.children.length) {
+          DesignCore.UCSManager.clearItems();
+        }
+        table.children.forEach((ucs) => {
+          DesignCore.UCSManager.addItem(ucs, true);
+        });
+      }
+
+      if (table[2] === 'APPID') {
+        if (table[5]) {
+          DesignCore.HandleManager.checkHandle(table[5]);
+          DesignCore.AppIDManager.handle = table[5];
+        }
+        if (table.children.length) {
+          DesignCore.AppIDManager.clearItems();
+        }
+        table.children.forEach((appid) => {
+          DesignCore.AppIDManager.addItem(appid, true);
+        });
+      }
+
+      if (table[2] === 'BLOCK_RECORD') {
+        if (table[5]) {
+          DesignCore.HandleManager.checkHandle(table[5]);
+          DesignCore.BlockRecordManager.handle = table[5];
+        }
+        // Build a map of block name to block record handle
+        // This is used when loading blocks to assign the correct blockRecordHandle
+
+        if (table.children) {
+          table.children.forEach((record) => {
+            if (record[2] && record[5]) {
+              DesignCore.HandleManager.checkHandle(record[5]);
+              this.blockRecordHandles[record[2]] = record[5];
+            }
+          });
+        }
+      }
     });
   }
 
+  /**
+   * Load Blocks
+   */
   loadBlocks() {
     const blocks = this.reader.blocks;
 
+    if (blocks.length) {
+      DesignCore.Scene.blockManager.clearItems();
+    }
+
     blocks.forEach((block) => {
-      if (block.hasOwnProperty('2')) {
-        /*
-        Three empty definitions always appear in the BLOCKS section.
-        They are titled *Model_Space, *Paper_Space and *Paper_Space0.
-        These definitions manifest the representations of model space and paper space as block definitions internally.
-        The internal name of the first paper space layout is *Paper_Space,
-        the second is *Paper_Space0,
-        the third is *Paper_Space1,
-        and so on.
-        */
-        if (block[2].toUpperCase().includes('MODEL_SPACE')) {
-          // skip model_space blocks
-          return;
-        }
-
-        if (block[2].toUpperCase().includes('PAPER_SPACE')) {
-          // skip paper_space blocks
-          return;
-        }
-      }
       if (block.hasOwnProperty('points')) {
         block.points = this.parsePoints(block.points);
       }
@@ -131,6 +286,14 @@ export class DXF {
           if (child.hasOwnProperty('0') === false) {
             return;
           }
+
+          // Extract the ENDBLK handle from the block children
+          if (child[0] === 'ENDBLK' && child[5]) {
+            DesignCore.HandleManager.checkHandle(child[5]);
+            block.endblkHandle = child[5];
+            return;
+          }
+
           // Convert child points to design points
           if (child.hasOwnProperty('points')) {
             child.points = this.parsePoints(child.points);
@@ -142,6 +305,11 @@ export class DXF {
             // create an instance of the child entity
             const item = DesignCore.CommandManager.createNew(command, child);
 
+            // Register the child entity handle
+            if (item.handle) {
+              DesignCore.HandleManager.checkHandle(item.handle);
+            }
+
             if (block.hasOwnProperty('items') === false) {
               block.items = [];
             }
@@ -154,13 +322,25 @@ export class DXF {
         });
       }
 
-      this.addItem(block);
+      // Assign the block record handle from the BLOCK_RECORD table
+      if (block[2] && this.blockRecordHandles[block[2]]) {
+        block.blockRecordHandle = this.blockRecordHandles[block[2]];
+      }
+
+      DesignCore.Scene.blockManager.addItem(block, true);
     });
   }
 
+  /**
+   * Load Entities
+   */
   loadEntities() {
     const entities = this.reader.entities;
 
+    if (entities.length) {
+      DesignCore.Scene.entities.clear();
+    }
+
     entities.forEach((entity) => {
       if (entity.hasOwnProperty('points')) {
         entity.points = this.parsePoints(entity.points);
@@ -168,9 +348,38 @@ export class DXF {
 
       this.addItem(entity);
     });
+
+    // ensure all layers, ltypes, styles, dimstyles exist
+    DesignCore.LayerManager.checkItems();
+    DesignCore.LTypeManager.checkItems();
+    DesignCore.StyleManager.checkItems();
+    DesignCore.DimStyleManager.checkItems();
   }
 
+  /**
+   * Load Objects
+   */
+  loadObjects() {
+    const objects = this.reader.objects;
+
+    if (objects.length) {
+      DesignCore.DictionaryManager.clearItems();
+    }
+
+    objects.forEach((object) => {
+      if (object[0] === 'DICTIONARY') {
+        DesignCore.DictionaryManager.addItem(object);
+      }
+    });
+
+    // Ensure standard items exist
+    DesignCore.DictionaryManager.checkItems();
+  }
 
+  /**
+   * Add Item
+   * @param {Object} item
+   */
   addItem(item) {
     if (item.hasOwnProperty('0') === false) {
       return;
@@ -178,13 +387,19 @@ export class DXF {
 
     const command = item[0];
     if (DesignCore.CommandManager.isCommand(command)) {
-      DesignCore.Scene.addItem(command, item);
+      const entity = DesignCore.CommandManager.createNew(command, item);
+      DesignCore.Scene.entities.add(entity);
     } else {
       Logging.instance.warn(`${Strings.Message.UNKNOWNCOMMAND} ${command}`);
       this.unsupportedElements = true;
     }
   }
 
+  /**
+   * Parse Points
+   * @param {Object} dxfPoints
+   * @return {Array}
+   */
   parsePoints(dxfPoints) {
     const points = [];
     dxfPoints.forEach((point) => {

package/core/lib/dxf/dxfFile.js

@@ -1,8 +1,13 @@
-import {Logging} from '../logging.js';
-import {Strings} from '../strings.js';
+import { Logging } from '../logging.js';
+import { Strings } from '../strings.js';
 
+/** DXF File Class */
 export class DXFFile {
-  constructor(version='R2018') {
+  /**
+   * Create DXFFile
+   * @param {string} version
+   */
+  constructor(version = 'R2018') {
     this.contents = '';
 
     // Validate version
@@ -11,13 +16,12 @@ export class DXFFile {
     }
 
     this.version = DXFFile.Version[version];
-    this.handleCounter = 10;
   }
 
   /**
    * Check if a dxf version is valid - 'AC1009' = valid, R12 = not valid
    * @param {string} version
-   * @returns boolean - true if version is valid
+   * @return {boolean} - true if version is valid
    */
   static validDxfVersion(version) {
     if (Object.values(DXFFile.Version).indexOf(version) === -1) {
@@ -30,7 +34,7 @@ export class DXFFile {
   /**
    * Check if a dxf key is valid - R12 = valid, 'AC1009' = not valid
    * @param {string} key
-   * @returns boolean - true if version is valid
+   * @return {boolean} - true if version is valid
    */
   static validDxfKey(key) {
     if (Object.keys(DXFFile.Version).indexOf(key) === -1) {
@@ -41,8 +45,8 @@ export class DXFFile {
 
   /**
    * Return the dxf key for the dxf version e.g key = R12 version = 'AC1009'
-   * @param {*} dxfVersion
-   * @returns dxf key (R Number) for valid dxf versions
+   * @param {string} dxfVersion
+   * @return {string} dxf key (R Number) for valid dxf versions
    */
   static getVersionKey(dxfVersion) {
     if (DXFFile.validDxfVersion(dxfVersion)) {
@@ -77,52 +81,33 @@ export class DXFFile {
    */
   clearFile() {
     this.contents = '';
-    this.handleCounter = 10;
-  }
-
-  /**
-   * Returns the next available handle value
-   * R12 handles are optional.
-   * R13+ handles are mandatory.
-   * The header variable $HANDSEED must be greater than the largest handle value
-   * @returns handle value
-   */
-  nextHandle() {
-    const handle = this.formatHandle(this.handleCounter);
-    this.handleCounter++;
-    return handle;
-  }
-
-  /**
-   * Format a handle value
-   * A handle is an arbitrary but unique hex value as string up to 16 hexadecimal digits (8 bytes).
-   * @param {number} value
-   * @returns handle hex value
-   */
-  formatHandle(value) {
-    return value.toString(16).toUpperCase();
   }
 
   /**
    * Write the group code and value to file
-   * @param {String} groupCode
-   * @param {String} groupValue
-   * @param {String} version - DXFFile.Version
-   * @returns
+   * @param {string} groupCode
+   * @param {string} groupValue
+   * @param {string} version - DXFFile.Version
    */
-  writeGroupCode(groupCode, groupValue, version=DXFFile.Version.R12) {
+  writeGroupCode(groupCode, groupValue, version = DXFFile.Version.R12) {
     // return if the groupcode is required for a later version
     if (version > this.version) {
       return;
     }
 
+    if (groupValue === undefined) {
+      const err = `Invalid groupvalue for dxf groupcode ${groupCode}`;
+      Logging.instance.error(`${this.type} - ${err}`);
+      throw Error(Strings.Error.INVALIDDXFFORMAT);
+    }
+
     this.writeLine(groupCode);
     this.writeLine(groupValue);
   }
 
   /**
    * Write a new line to the contents
-   * @param {String} value
+   * @param {string} value
    */
   writeLine(value) {
     this.contents = this.contents.concat(`${value}\n`);

package/core/lib/dxf/dxfIterator.js

@@ -1,4 +1,4 @@
-import {Strings} from '../strings.js';
+import { Strings } from '../strings.js';
 
 /**
 This class is designed to iterate though an internal array of DXF groupcode and value pairs
@@ -23,9 +23,11 @@ Example DXF Entity Pairs:
  value: 100.0       - y position
  */
 
+/** DXF Interator Class */
 export class DxfIterator {
   static _instance;
 
+  /** Create DXFInterator */
   constructor() {
     this.currentIndex = 0;
     this.lines = [];
@@ -38,6 +40,9 @@ export class DxfIterator {
     return DxfIterator._instance;
   }
 
+  /**
+   * Get Instance
+   */
   static get instance() {
     if (this._instance === undefined) {
       this._instance = new this();
@@ -47,7 +52,7 @@ export class DxfIterator {
 
   /**
    * Load a string object representing the dxf file
-   * @param  {String} file
+   * @param  {string} file
    */
   loadFile(file) {
     // check there is data
@@ -82,7 +87,7 @@ export class DxfIterator {
 
   /**
    * Stop iteration and throw error
-   * @param  {String} msg - error message
+   * @param  {string} msg - error message
    */
   dxfError(msg) {
     throw Error(`${msg} - ${Strings.Strings.LINE}: ${this.currentIndex + 1}`);
@@ -91,6 +96,7 @@ export class DxfIterator {
 
   /**
    * Format and return the current value
+   * @return {any}
    */
   current() {
     const current = this.formatted(this.lines[this.currentIndex]);
@@ -100,7 +106,8 @@ export class DxfIterator {
 
   /**
    * Format the input value removing line breaks
-   * @param  {String} value
+   * @param  {string} value
+   * @return {string}
    */
   formatted(value) {
     return value.replace(/(\r\n|\n|\r)/gm, '');
@@ -108,6 +115,7 @@ export class DxfIterator {
 
   /**
    * Format and return the next value
+   * @return {any}
    */
   nextValue() {
     if (this.currentIndex < this.lines.length - 1) {
@@ -118,6 +126,7 @@ export class DxfIterator {
 
   /**
    * Format and return the previous value
+   * @return {any}
    */
   prevValue() {
     if (this.currentIndex > 0) {
@@ -128,6 +137,7 @@ export class DxfIterator {
 
   /**
    * Format and return the previous groupcode and value pair
+   * @return {Array}
    */
   prevPair() {
     if (this.currentIndex >= 2) {
@@ -140,13 +150,15 @@ export class DxfIterator {
 
   /**
    * Format and return the current groupcode and value pair
+   * @return {Array}
    */
   currentPair() {
-    return {code: this.current().trim(), value: this.nextValue()};
+    return { code: this.current().trim(), value: this.nextValue() };
   }
 
   /**
    * Format and return the next groupcode and value pair
+   * @return {Array}
    */
   nextPair() {
     if (this.currentIndex < this.lines.length - 2) {

package/core/lib/dxf/dxfRead.js

@@ -1,24 +1,35 @@
 
-import {Header} from './sections/header.js';
-import {Entities} from './sections/entities.js';
-import {Blocks} from './sections/blocks.js';
-import {Tables} from './sections/tables.js';
-import {DxfIterator} from './dxfIterator.js';
+import { Header } from './sections/header.js';
+import { Entities } from './sections/entities.js';
+import { Blocks } from './sections/blocks.js';
+import { Tables } from './sections/tables.js';
+import { Objects } from './sections/objects.js';
+import { DxfIterator } from './dxfIterator.js';
 
+/** DXF Reader Class */
 export class DXFReader {
+  /** Create DXF Reader */
   constructor() {
     this.iterator = new DxfIterator();
     this.blocks = [];
     this.header = new Header();
     this.entities = [];
     this.tables = [];
+    this.objects = [];
   }
 
+  /**
+   * Read
+   * @param {string} file
+   */
   read(file) {
     this.iterator.loadFile(file);
     this.parseFile();
   }
 
+  /**
+   * Parse File
+   */
   parseFile() {
     while (this.iterator.nextPair().value !== 'EOF') {
       const currentPair = this.iterator.currentPair();
@@ -27,7 +38,7 @@ export class DXFReader {
           this.header.read(this.iterator);
           break;
 
-        case (currentPair.value ==='TABLES'):
+        case (currentPair.value === 'TABLES'):
           const tables = new Tables();
           this.tables = tables.read(this.iterator);
           break;
@@ -37,10 +48,15 @@ export class DXFReader {
           this.blocks = blocks.read(this.iterator);
           break;
 
-        case (currentPair.value ==='ENTITIES'):
+        case (currentPair.value === 'ENTITIES'):
           const entities = new Entities();
           this.entities = entities.read(this.iterator);
           break;
+
+        case (currentPair.value === 'OBJECTS'):
+          const objects = new Objects();
+          this.objects = objects.read(this.iterator);
+          break;
       }
     }
   }