@design-core/core 0.0.1 → 0.0.3

package/core/tables/style.js

@@ -0,0 +1,145 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { Flags } from '../properties/flags.js';
+import { Property } from '../properties/property.js';
+
+/** Style Class */
+export class Style {
+  /**
+   * Create Style
+   * @param {Object} data
+   */
+  constructor(data) {
+    // Define Properties
+    this.type = this.constructor.name;
+    this.name = '';
+    this.font = 'Arial'; // TODO: how to set the font to one that's available. See style.js also.
+    this.textHeight = 0;
+    this.widthFactor = 1;
+    this.obliqueAngle = 0;
+    this.lastTextHeight = this.textHeight;
+    this.flags = new Flags();
+    this.standardFlags = new Flags();
+
+    // DXF Groupcode 5 - Handle
+    this.handle = Property.loadValue([data?.handle, data?.[5]]);
+    // DXF Groupcode 2 - ltype name
+    this.name = Property.loadValue([data?.name, data?.[2]], '');
+    // DXF Groupcode 3 - style font
+    this.font = Property.loadValue([data?.font, data?.[3]], 'Arial');
+    // DXF Groupcode 4 - big font
+    this.bigFont = Property.loadValue([data?.bigFont, data?.[4]]);
+    // DXF Groupcode 40 - Text height
+    this.textHeight = Property.loadValue([data?.textHeight, data?.[40]], 0);
+    // DXF Groupcode 41 - width factor
+    this.widthFactor = Property.loadValue([data?.widthFactor, data?.[41]], 1);
+    // DXF Groupcode 42 - Last text height
+    this.lastTextHeight = Property.loadValue([data?.lastTextHeight, data?.[42]], this.textHeight);
+    // DXF Groupcode 50 - test height
+    this.obliqueAngle = Property.loadValue([data?.obliqueAngle, data?.[50]], 0);
+
+    // DXF Groupcode 70 - standard flags
+    /*
+    1 = If set, this entry describes a shape
+    4 = Vertical text
+    16 = If set, table entry is externally dependent on an xref
+    32 = If this bit and bit 16 are both set, the externally dependent xref has been successfully resolved
+    64 = If set, the table entry was referenced by at least one entity in the drawing the last time the drawing was edited.
+    (This flag is for the benefit of AutoCAD commands. It can be ignored.
+    */
+    this.standardFlags.setFlagValue(Property.loadValue([data?.standardFlags, data?.[70]], 0));
+
+    // DXF Groupcode 71 - flags (bit-coded values):
+    // 2 = Text is backward (mirrored in X).
+    // 4 = Text is upside down (mirrored in Y).
+    this.flags.setFlagValue(Property.loadValue([data?.flags, data?.[71]], 0));
+  }
+
+  /**
+   * Get the vertical value
+   * @return {bool}
+   */
+  get vertical() {
+    // Vertical value is bitmasked in standardflags as value 4
+    return this.standardFlags.hasFlag(4);
+  }
+
+  /**
+   * Set the vertical value
+   * @param {boolean} bool
+   */
+  set vertical(bool) {
+    if (bool) {
+      // Add flag
+      this.standardFlags.addValue(4);
+    } else {
+      // remove flag
+      this.standardFlags.removeValue(4);
+    }
+  }
+
+  /**
+   * Get the backwards value
+   * @return {bool}
+   */
+  get backwards() {
+    // Upside down value is bitmasked in flags as value 2
+    return this.flags.hasFlag(2);
+  }
+
+  /**
+   * set the backwards value
+   * @param {boolean} bool
+   */
+  set backwards(bool) {
+    if (bool) {
+      // Add flag
+      this.flags.addValue(2);
+    } else {
+      // remove flag
+      this.flags.removeValue(2);
+    }
+  }
+
+  /**
+   * Get the upside down value
+   * @return {bool}
+   */
+  get upsideDown() {
+    // Upside down value is bitmasked in flags as value 4
+    return this.flags.hasFlag(4);
+  }
+
+  /**
+   * Set the upside down value
+   * @param {boolean} bool
+   */
+  set upsideDown(bool) {
+    if (bool) {
+      // Add flag
+      this.flags.addValue(4);
+    } else {
+      // remove flag
+      this.flags.removeValue(4);
+    }
+  }
+
+  /**
+   * Write the table to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'STYLE');
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('100', 'AcDbSymbolTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbTextStyleTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('2', this.name); // Stylename
+    file.writeGroupCode('3', this.font); // Font
+    file.writeGroupCode('4', ''); // Big font name blank is none
+    file.writeGroupCode('40', this.textHeight); // Text Height
+    file.writeGroupCode('41', this.widthFactor); // Width Factor
+    file.writeGroupCode('42', this.textHeight); // Last Text Height
+    file.writeGroupCode('50', this.obliqueAngle);
+    file.writeGroupCode('70', this.standardFlags.getFlagValue()); // Standard Flags
+    file.writeGroupCode('71', this.flags.getFlagValue()); // Flags
+  }
+}

package/core/tables/styleManager.js

@@ -0,0 +1,55 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { StyleManagerBase } from './styleManagerBase.js';
+import { Style } from './style.js';
+
+/**
+ * StyleManager Class
+ * Manages text styles
+ * @extends StyleManagerBase
+ */
+export class StyleManager extends StyleManagerBase {
+  /** Create Style Manager */
+  constructor() {
+    super();
+
+    this.indelibleItems.push('STANDARD');
+    this.itemProperty = 'style';
+  }
+
+  /** Get the item class */
+  get itemClass() {
+    return Style;
+  }
+
+  /** Add standard text styles */
+  addStandardItems() {
+    this.addItem({
+      'name': 'STANDARD',
+    });
+
+    this.addItem({
+      'name': 'ANNOTATIVE',
+    });
+
+    // DesignCore.scene.saveRequired();
+  }
+
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    // Create table data for text styles
+    file.writeGroupCode('0', 'TABLE');
+    file.writeGroupCode('2', 'STYLE');
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('100', 'AcDbSymbolTable', DXFFile.Version.R2000);
+    file.writeGroupCode('70', this.itemCount());
+
+    for (let i = 0; i < this.itemCount(); i++) {
+      this.getItemByIndex(i).dxf(file);
+    }
+
+    file.writeGroupCode('0', 'ENDTAB');
+  }
+}

package/core/tables/styleManagerBase.js

@@ -0,0 +1,110 @@
+import { DesignCore } from '../designCore.js';
+// import {Strings} from '../lib/strings.js';
+import { TableManagerBase } from './tableManagerBase.js';
+
+/**
+ * StyleManagerBase Class
+ * @extends TableManagerBase
+ */
+export class StyleManagerBase extends TableManagerBase {
+  /**
+   * Create Style Manager
+   */
+  constructor() {
+    super();
+
+    // set the current style to the first available style
+    this.currentstyle = this.items[0].name;
+  }
+
+  /**
+   * Delete a style using the style index
+   * @param {number} itemIndex
+   * @param {boolean} showWarning
+   */
+  deleteStyle(itemIndex, showWarning = true) {
+    // call the super class delete
+    const deletedItem = this.deleteItem(itemIndex, showWarning);
+
+    if (deletedItem) {
+      // delete all item using the selected style
+      this.deleteStyleFromScene(deletedItem.name);
+    }
+  }
+
+  /**
+   * Delete all items that use style
+   * @param {string} style
+   */
+  deleteStyleFromScene(style) {
+    const selectionSet = [];
+
+    for (let i = 0; i < DesignCore.Scene.entities.count(); i++) {
+      if (DesignCore.Scene.entities.get(i)[this.itemProperty] === style) {
+        selectionSet.push(i);
+      }
+    }
+
+    // sort the selection in descending order
+    selectionSet.sort((a, b) => b - a);
+
+    for (let j = 0; j < selectionSet.length; j++) {
+      DesignCore.Scene.entities.remove((selectionSet[j]));
+    }
+  }
+
+  /**
+   * Get the name of the current style
+   * @return {Object}
+   */
+  getCstyle() {
+    return this.currentstyle;
+  }
+
+  /**
+   * Set the current style
+   * @param {string} cstyle
+   */
+  setCstyle(cstyle) {
+    if (this.getItemByName(cstyle) !== undefined) {
+      this.currentstyle = cstyle;
+    }
+  }
+
+
+  /**
+   * Ensure that used styles and default styles exist
+   */
+  checkStyles() {
+    this.addStandardItems();
+
+    for (let i = 0; i < DesignCore.Scene.entities.count(); i++) {
+      const style = (DesignCore.Scene.entities.get(i)[this.itemProperty]);
+      this.addItem({
+        'name': style,
+      });
+    }
+  }
+
+  /**
+   * Rename the style at index with newName
+   * @param {number} styleIndex
+   * @param {string} newName
+   */
+  renameStyle(styleIndex, newName) {
+    // get the existing name
+    const currentStyleName = this.items[styleIndex].name;
+
+    // call the super class rename
+    const newUniqueName = this.renameItem(styleIndex, newName);
+
+    if (newUniqueName === undefined) {
+      return;
+    }
+
+    // if the style to change is the current style, update the currentstyle property
+    if (currentStyleName === this.currentstyle) {
+      this.setCstyle(newUniqueName);
+    }
+  }
+}

package/core/tables/tableManagerBase.js

@@ -0,0 +1,354 @@
+import { DesignCore } from '../designCore.js';
+import { Strings } from '../lib/strings.js';
+import { Logging } from '../lib/logging.js';
+
+/**
+ * Table Manager Base Class
+ */
+export class TableManagerBase {
+  // Cached Map<string, item> for O(1) lookups by name.
+  // Lazily built on first getItemByName() call and
+  // invalidated when items are added, deleted, or cleared.
+  #lookupMap = null;
+  #items = [];
+
+  /**
+   * Get the list of items
+   * @return {Array}
+   */
+  get items() {
+    return this.#items;
+  }
+
+  /**
+   * Set the list of items and invalidate the lookup cache
+   * @param {Array} value
+   */
+  set items(value) {
+    this.#items = value;
+    this.#invalidateLookup();
+  }
+
+  /**
+   * Create a Table Manager
+   */
+  constructor() {
+    this.handle = DesignCore.HandleManager.next();
+    this.addStandardItems();
+
+    // list of mandatory items that cannot be deleted
+    this.indelibleItems = [];
+  }
+
+  /**
+   * Invalidate the lookup map cache.
+   * Must be called whenever the items array is mutated.
+   */
+  #invalidateLookup() {
+    this.#lookupMap = null;
+  }
+
+  /**
+   * Create a new typed item
+   * @param {Object} data
+   * @return {Object}
+   */
+  createItem(data) {
+    const ItemClass = this.itemClass;
+    return new ItemClass(data);
+  }
+
+  /**
+   * Get items
+   * @return {Array} list of items
+   */
+  getItems() {
+    return this.items;
+  }
+
+  /**
+   * Get item count
+   * @return {number} number of items
+   */
+  itemCount() {
+    return this.items.length;
+  }
+
+  /**
+   * Adds a new item to the list of active items
+   */
+  newItem() {
+    this.addItem({
+      'name': this.getUniqueName(`NEW_${this.itemProperty}`.toUpperCase()),
+    });
+  }
+
+  /**
+   * Generate a unique name
+   * @param {string} name
+   * @return {string} unique name
+   */
+  getUniqueName(name) {
+    let count = 0;
+    let styStr = name.replace(/ /g, '_'); // .toUpperCase();
+    for (let i = 0; i < this.itemCount(); i++) {
+      const itemName = this.items[i].name.toUpperCase();
+      if (itemName.includes(styStr.toUpperCase())) {
+        count = count + 1;
+      }
+    }
+    if (count > 0) {
+      styStr = styStr + '_' + count;
+    }
+
+    return styStr;
+  };
+
+  /**
+   * Add a item to the list of items
+   * @param {item} item
+   * @param {boolean} overwrite
+   * @return {Objects}
+   */
+  addItem(item, overwrite = false) {
+    // Call the subclass to create a new typed item object
+    const newItem = this.createItem(item);
+    const newItemName = newItem.name;
+
+    const exists = this.itemExists(newItemName);
+
+    // Return the existing item if it already exists and overwrite is not requested
+    if (exists && !overwrite) {
+      return this.getItemByName(newItemName);
+    }
+
+    if (newItem.handle === undefined) {
+      newItem.handle = DesignCore.HandleManager.next();
+    } else {
+      DesignCore.HandleManager.checkHandle(newItem.handle);
+    }
+
+    if (!exists) {
+      this.items.push(newItem);
+    } else {
+      // Overwrite the existing item
+      // This is used when loading files;
+      // Standard items already exist but should be overwritten by the incoming item
+      this.items.splice(this.getItemIndex(newItemName), 1, newItem);
+    }
+
+    this.#invalidateLookup();
+    // DesignCore.Scene.saveRequired();
+    return newItem;
+  }
+
+  /**
+   * Delete a item using the item index
+   * @param {number} itemIndex
+   * @param {boolean} showWarning
+   * @return {Array} array containing deleted item or undefined
+   */
+  deleteItem(itemIndex, showWarning = true) {
+    if (this.items[itemIndex] === undefined) {
+      return;
+    }
+
+    const itemToDelete = this.getItemByIndex(itemIndex).name;
+
+    // Can't delete indelible items (Standard Text Item, Layer 0)
+    if (this.indelibleItems.some((item) => item.toUpperCase() === itemToDelete.toUpperCase())) {
+      if (showWarning) {
+        DesignCore.Core.notify(`${itemToDelete} - ${Strings.Message.CANNOTBEDELETED}`);
+      }
+      return;
+    }
+
+    // Delete The item
+    const deleted = this.items.splice(itemIndex, 1);
+    this.#invalidateLookup();
+    return deleted;
+  }
+
+
+  /**
+   * Check if a item with itemName exists
+   * @param {string} itemName
+   * @return {boolean}
+   */
+  itemExists(itemName) {
+    const itemExists = this.items.some((el) => el.name.toUpperCase() === itemName.toUpperCase());
+    return itemExists;
+  }
+
+  /**
+   * Ensure that used items and default items exist
+   */
+  checkItems() {
+    this.addStandardItems();
+
+    for (let i = 0; i < DesignCore.Scene.entities.count(); i++) {
+      const item = (DesignCore.Scene.entities.get(i));
+
+      // check the item has the required property
+      if (Object.hasOwn(item, this.itemProperty) === false) {
+        continue;
+      }
+
+      // get the property value
+      const propertyValue = (item[this.itemProperty]);
+
+      // create missing items
+      // example if an entity uses a missing layer, create the layer.
+      if (!this.itemExists(propertyValue)) {
+        this.addItem({
+          'name': propertyValue,
+        });
+      }
+    }
+  }
+
+  /**
+   * Clear all existing items
+   */
+  clearItems() {
+    this.items = [];
+  }
+
+  /**
+   * Find the index of itemName
+   * @param {string} itemName
+   * @return {number} index of the item or -1 if item doesn't exist
+   */
+  getItemIndex(itemName) {
+    return this.items.findIndex((item) => item.name.toUpperCase() === itemName.toUpperCase());
+  }
+
+  /**
+   * get a item matching itemname
+   * @param {string} itemName
+   * @return {Object}
+   */
+  getItemByName(itemName) {
+    if (!this.#lookupMap) {
+      this.#lookupMap = new Map();
+      for (let i = 0; i < this.items.length; i++) {
+        this.#lookupMap.set(this.items[i].name.toUpperCase(), this.items[i]);
+      }
+    }
+
+    const item = this.#lookupMap.get(itemName.toUpperCase());
+
+    if (item === undefined) {
+      // Log warning if item doesn't exist
+      // Consider nested blocks where block may not exist yet
+      const msg = 'Invalid Item Name';
+      const err = (`${this.constructor.name} - ${msg}: ${itemName}`);
+      Logging.instance.warn(`${err}`);
+    }
+
+    return item;
+  }
+
+  /**
+   * Get the item from an index
+   * @param {number} itemIndex
+   * @return {Object}
+   */
+  getItemByIndex(itemIndex) {
+    return this.items[itemIndex];
+  }
+
+
+  /**
+   * Rename the item at index with newName
+   * @param {number} itemIndex
+   * @param {string} newName
+   * @return {string} new name or undefined
+   */
+  renameItem(itemIndex, newName) {
+    const itemToRename = this.getItemByIndex(itemIndex).name;
+
+    // make sure it is a new name
+    if (itemToRename.toUpperCase() === newName.toUpperCase()) {
+      return;
+    }
+
+    // Can't rename indelible items (Standard Text Item, Layer 0)
+    if (this.indelibleItems.some((item) => item.toUpperCase() === itemToRename.toUpperCase())) {
+      DesignCore.Core.notify(`${itemToRename} - ${Strings.Message.CANNOTBERENAMED}`);
+      return;
+    }
+
+    // Can't use the name of indelible items (Standard Text Item, Layer 0)
+    if (this.indelibleItems.some((item) => item.toUpperCase() === newName.toUpperCase())) {
+      DesignCore.Core.notify(`${newName} - ${Strings.Message.CANNOTBERENAMED}`);
+      return;
+    }
+
+    const newUniqueName = this.getUniqueName(newName);
+    const currentItemName = this.items[itemIndex].name;
+    this.items[itemIndex].name = newUniqueName;
+    this.#invalidateLookup();
+
+    // update all scene items with the new item value
+    this.updateSceneItem(currentItemName, newUniqueName);
+
+    return newUniqueName;
+  }
+
+  /**
+   * Update all items that use item
+   * @param {string} oldItemName
+   * @param {string} newItemName
+   */
+  updateSceneItem(oldItemName, newItemName) {
+    for (let i = 0; i < DesignCore.Scene.entities.count(); i++) {
+      if (DesignCore.Scene.entities.get(i)[this.itemProperty] === oldItemName) {
+        DesignCore.Scene.entities.get(i)[this.itemProperty] = newItemName;
+      }
+    }
+  }
+
+  /**
+   * Update the item property with value
+   * @param {number} itemIndex
+   * @param {string} property
+   * @param {any} value
+   */
+  updateItem(itemIndex, property, value) {
+    // check of the index exists
+    if (this.items[itemIndex] === undefined) {
+      const msg = 'Invalid Item Index';
+      const err = (`${this.type} - ${msg}`);
+      throw Error(err);
+    }
+
+    if (this.items[itemIndex][property] === undefined) {
+      const msg = 'Invalid Item Property';
+      const err = (`${this.type} - ${msg}`);
+      throw Error(err);
+    }
+
+    if (property.toUpperCase() === 'NAME') {
+      this.renameItem(itemIndex, value);
+    } else {
+      this.items[itemIndex][property] = value;
+    }
+  }
+
+  /** Purge unused items */
+  purge() {
+    const itemsToPurge = [];
+    this.items.forEach((item, index) => {
+      const searchTerm = this.itemProperty === 'block' ? item : item.name;
+      const items = DesignCore.Scene.entities.find('ANY', this.itemProperty, searchTerm);
+      if (items.length === 0) {
+        itemsToPurge.push(index);
+      }
+    });
+
+    // sort the selection in descending order
+    itemsToPurge.sort((a, b) => b - a);
+    itemsToPurge.forEach((itemIndex) => this.deleteItem(itemIndex, false));
+  }
+}

package/core/tables/ucs.js

@@ -0,0 +1,28 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { Property } from '../properties/property.js';
+
+/** UCS Class */
+export class UCS {
+  /**
+   * Create a UCS
+   * @param {Object} data
+   */
+  constructor(data) {
+    // DXF Groupcode 5 - Handle
+    this.handle = Property.loadValue([data?.handle, data?.[5]]);
+    // DXF Groupcode 2 - Name
+    this.name = Property.loadValue([data?.name, data?.[2]], '');
+  }
+
+  /**
+   * Write the item to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'UCS', DXFFile.Version.R2000);
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbUCSTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('2', this.name, DXFFile.Version.R2000);
+  }
+}