@design-core/core 0.0.1 → 0.0.3

package/core/tables/dimStyleManager.js

@@ -0,0 +1,187 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { DimStyle } from './dimStyle.js';
+import { StyleManagerBase } from './styleManagerBase.js';
+
+/**
+ * DimStyleManager Class
+ * @extends StyleManagerBase
+ */
+export class DimStyleManager extends StyleManagerBase {
+  /** Create a DimStyleManager */
+  constructor() {
+    super();
+
+    this.indelibleItems.push('STANDARD');
+    this.itemProperty = 'dimensionStyle';
+  }
+
+  /** Get the item class */
+  get itemClass() {
+    return DimStyle;
+  }
+
+  /**
+   * Add standard dimension styles
+   */
+  addStandardItems() {
+    this.addItem({
+      // Add standard imperial dimension
+      'name': 'STANDARD',
+      /*
+      Standard Defaults
+      'DIMALTD': 2,
+      'DIMAPOST': '',
+      'DIMALTRND': 0,
+      'DIMALTF': 25.4,
+      'DIMALTTD': 2,
+      'DIMALTTZ': 0,
+      'DIMALTU': 2,
+      'DIMALTMZF': 100,
+      'DIMALTMZS': '',
+      'DIMALTZ': 0,
+      'DIMALT': 0,
+      'DIMAUNIT': 0,
+      'DIMADEC': 0,
+      'DIMAZIN': 0,
+      'DIMARCSYM': 0,
+      'DIMBLK': 'ClosedFilled',
+      'DIMBLK1': 'ClosedFilled',
+      'DIMBLK2': 'ClosedFilled',
+      'DIMASZ': 0.18,
+      'DIMCEN': 0.09,
+      'DIMDSEP': '.',
+      'DIMCLRD': 'BYBLOCK',
+      'DIMDLE': 0,
+      'DIMTOFL': 0,
+      'DIMLTYPE': 'BYBLOCK',
+      'DIMLWD': -2,
+      'DIMDLI': 0.38,
+      'DIMTXTDIRECTION': 0,
+      'DIMLTEX1': 'BYBLOCK',
+      'DIMLTEX2': 'BYBLOCK',
+      'DIMCLRE': 'BYBLOCK',
+      'DIMEXE': 0.18,
+      'DIMLWE': -2,
+      'DIMEXO': 0.0625,
+      'DIMATFIT': 3,
+      'DIMTMOVE': 0,
+      'DIMFXLON': 0,
+      'DIMFXL': 1,
+      'DIMFRAC': 0,
+      'DIMJOGANG': 45,
+      'DIMLDRBLK': 'ClosedFilled',
+      'DIMLFAC': 1,
+      'DIMLUNIT': 2,
+      'DIMSD1': 0,
+      'DIMSD2': 0,
+      'DIMSOXD': 0,
+      'DIMSE1': 0,
+      'DIMSE2': 0,
+      'DIMSCALE': 1,
+      'DIMDEC': 4,
+      'DIMRND': 0,
+      'DIMSAH': 0,
+      'DIMTFILLCLR': 'BYBLOCK',
+      'DIMTFILL': 0,
+      'DIMCLRT': 'BYBLOCK',
+      'DIMTXT': 0.18,
+      'DIMTIX': 0,
+      'DIMTIH': 1,
+      'DIMGAP': 0.09,
+      'DIMTOH': 1,
+      'DIMJUST': 0,
+      'DIMTAD': 0,
+      'DIMPOST': '',
+      'DIMTXSTY': 'Standard',
+      'DIMTM': 0,
+      'DIMTP': 0,
+      'DIMTOL': 0,
+      'DIMLIM': 0,
+      'DIMTOLJ': 1,
+      'DIMTDEC': 4,
+      'DIMTFAC': 1,
+      'DIMTZIN': 0,
+      'DIMMZF': 100,
+      'DIMMZS': '',
+      'DIMZIN': 0,
+      */
+
+    });
+
+    this.addItem({
+      // Add annotative dimension
+      // set the properties where they are different to STANDARD dimstyle
+      'name': 'ANNOTATIVE',
+      'DIMALTD': 3,
+      'DIMALTF': 0.0394,
+      'DIMALTTD': 3,
+      'DIMASZ': 2.5,
+      'DIMCEN': 2.5,
+      'DIMDSEP': ',',
+      'DIMTOFL': 1,
+      'DIMDLI': 3.75,
+      'DIMEXE': 1.25,
+      'DIMEXO': 0.625,
+      'DIMSCALE': 0,
+      'DIMDEC': 2,
+      'DIMTXT': 2.5,
+      'DIMTIH': 0,
+      'DIMGAP': 0.625,
+      'DIMTOH': 0,
+      'DIMTAD': 1,
+      'DIMTOLJ': 0,
+      'DIMTDEC': 2,
+      'DIMTZIN': 8,
+      'DIMZIN': 8,
+
+    });
+
+    this.addItem({
+      // Create standard metric dimension
+      // set the properties where they are different to STANDARD dimstyle
+      'name': 'ISO-25',
+      'DIMALTD': 3,
+      'DIMALTF': 0.0394,
+      'DIMALTTD': 3,
+      'DIMASZ': 2.5,
+      'DIMCEN': 2.5,
+      'DIMDSEP': ',',
+      'DIMTOFL': 1,
+      'DIMDLI': 3.75,
+      'DIMEXE': 1.25,
+      'DIMEXO': 0.625,
+      'DIMDEC': 2,
+      'DIMTXT': 2.5,
+      'DIMTIH': 0,
+      'DIMGAP': 0.625,
+      'DIMTOH': 0,
+      'DIMTAD': 1,
+      'DIMTOLJ': 0,
+      'DIMTDEC': 2,
+      'DIMTZIN': 8,
+      'DIMZIN': 8,
+    });
+
+    // DesignCore.scene.saveRequired();
+  }
+
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    // Create table data for dimension styles
+    file.writeGroupCode('0', 'TABLE');
+    file.writeGroupCode('2', 'DIMSTYLE');
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTable', DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbDimStyleTable', 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/endblk.js

@@ -0,0 +1,28 @@
+import { Entity } from '../entities/entity.js';
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+
+/**
+ * EndBlock Entity Class
+ * @extends Entity
+ */
+export class EndBlock extends Entity {
+  /**
+   * Create an EndBlock Entity
+   * @param {Array} data
+   */
+  constructor(data) {
+    super(data);
+  }
+
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'ENDBLK');
+    file.writeGroupCode('5', this.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

@@ -0,0 +1,219 @@
+import { Colours } from '../lib/colours.js';
+import { Colour } from '../lib/colour.js';
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { Flags } from '../properties/flags.js';
+import { Property } from '../properties/property.js';
+
+/** later Class */
+export class Layer {
+  /**
+   * Create a new Layer
+   * @param {Object} data
+   */
+  constructor(data) {
+    // Define Properties
+    this.type = 'Layer';
+    this.name = '';
+    // this.frozen = false;
+    this.on = true;
+    // this.locked = false;
+    // this.trueColour; // undefined - only used when non-aci colours are set
+    this.lineType = 'CONTINUOUS';
+    this.lineWeight = 'DEFAULT';
+    this.plotting = true;
+
+    Object.defineProperty(this, 'colour', {
+      get: this.getColour,
+      set: this.setColour,
+    });
+
+    Object.defineProperty(this, 'layerColour', {
+      value: new Colour(),
+      writable: true,
+    });
+
+    Object.defineProperty(this, 'flags', {
+      value: new Flags(),
+      writable: true,
+    });
+
+    // DXF Groupcode 5 - Handle
+    this.handle = Property.loadValue([data?.handle, data?.[5]]);
+    // DXF Groupcode 390 - Plot style name handle
+    this.plotStyleHandle = Property.loadValue([data?.plotStyleHandle, data?.[390]], '0');
+
+    if (data) {
+      if (data.hasOwnProperty('name') || data.hasOwnProperty('2')) {
+        // DXF Groupcode 2 - Layer Name
+        this.name = data.name || data[2];
+      }
+
+      if (data.hasOwnProperty('flags') || data.hasOwnProperty('70')) {
+        // DXF Groupcode 70 - Layer Flags
+        // Standard flags (bit-coded values):
+        // 1 = Layer is frozen; otherwise layer is thawed
+        // 2 = Layer is frozen by default in new viewports
+        // 4 = Layer is locked
+        // 16 = If set, table entry is externally dependent on an xref
+        // 32 = If both this bit and bit 16 are 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.flags.setFlagValue(Property.loadValue([data.flags, data[70]], 0));
+      }
+
+      if (data.hasOwnProperty('colour') || data.hasOwnProperty('62')) {
+        // DXF Groupcode 62 - Color Number(present if not BYLAYER)(optional);
+        // zero indicates the BYBLOCK
+        // 256 indicates BYLAYER;
+        // A negative value indicates that the layer is turned off
+
+        if (data.colour) {
+          if (Colours.isRGB(data.colour)) {
+            this.colour = data.colour;
+          }
+        } else if (data.hasOwnProperty('62')) {
+          this.layerColour.setColourFromACI(Math.abs(data[62]));
+        }
+      }
+
+      if (data.hasOwnProperty('lineType') || data.hasOwnProperty('6')) {
+        // DXF Groupcode 6 - Linetype Name
+        this.lineType = data.lineType || data[6];
+      }
+
+      if (data.hasOwnProperty('lineWeight') || data.hasOwnProperty('370')) {
+        // DXF Groupcode 370 - Linetype Weight
+        this.lineWeight = data.lineWeight || data[370];
+      }
+
+      if (data.hasOwnProperty('plotting') || data.hasOwnProperty('290')) {
+        // DXF Groupcode 290 - Plotting flag
+        // If set to 0, do not plot this layer
+        this.plotting = data.plotting || data[290];
+      }
+
+      if (data.hasOwnProperty('trueColour') || data.hasOwnProperty('420')) {
+        // DXF Groupcode 420 - true color
+        // A 24-bit color value that should be dealt with in terms of bytes with values
+        // of 0 to 255. The lowest byte is the blue value, the middle byte is the
+        // green value, and the third byte is the red value. The top byte is always
+        // 0. The group code cannot be used by custom entities for their own data
+        // because the group code is reserved for AcDbEntity, class-level color data
+        // and AcDbEntity, class-level transparency data
+        const trueColour = Colours.trueColourToRGB(Math.abs(data.trueColour || data[420]));
+        if (trueColour) {
+          this.colour = trueColour;
+        }
+      }
+    }
+  }
+
+  /**
+   * Get the frozen value
+   * @return {bool}
+   */
+  get frozen() {
+    // Frozen value is bitmasked in flags as value 1
+    return this.flags.hasFlag(1);
+  }
+
+  /**
+     * Set the frozen value
+     * @param {boolean} bool
+     */
+  set frozen(bool) {
+    if (bool) {
+      // Add flag
+      this.flags.addValue(1);
+    } else {
+      // remove flag
+      this.flags.removeValue(1);
+    }
+  }
+
+  /**
+   * Get the locked value
+   * @return {bool}
+   */
+  get locked() {
+    // locked value is bitmasked in flags as value 4
+    return this.flags.hasFlag(4);
+  }
+
+  /**
+       * Set the locked value
+       * @param {boolean} bool
+       */
+  set locked(bool) {
+    if (bool) {
+      // Add flag
+      this.flags.addValue(4);
+    } else {
+      // remove flag
+      this.flags.removeValue(4);
+    }
+  }
+
+  /**
+   * Determine if layer is visible
+   * @return {boolean}
+   */
+  get isVisible() {
+    if (this.on && !this.frozen) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Determine if layer is selectable
+   * @return {boolean}
+   */
+  get isSelectable() {
+    if (this.isVisible && !this.locked) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get the layer colour
+   * @return {number} rgb colour
+   */
+  getColour() {
+    return this.layerColour.getColour();
+  }
+
+  /**
+   * Set the layer colour
+   * @param {Object} colour - rgb colour
+   */
+  setColour(colour) {
+    this.layerColour.setColour(colour);
+  }
+
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'LAYER');
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbLayerTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('2', this.name); // Layername
+    file.writeGroupCode('70', this.flags.getFlagValue()); // Flags
+    const colourValue = this.on ? this.layerColour.aci : (0 - this.layerColour.aci);
+    file.writeGroupCode('62', colourValue); // Colour: Negative if layer is off
+    if (this.layerColour.isTrueColour) {
+      file.writeGroupCode('420', Colours.rgbToTrueColour(this.colour));
+    }
+    file.writeGroupCode('6', this.lineType);
+    file.writeGroupCode('290', this.plotting ? 1 : 0); // plotting - required to be 0 for defpoints
+    file.writeGroupCode('390', this.plotStyleHandle, DXFFile.Version.R2000);
+
+    // file.writeGroupCode('370', 'this.lineWeight '); // lineWeight      |  These items codes don't seem to be supported in ACAD.
+  }
+}

package/core/tables/layerManager.js

@@ -0,0 +1,47 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { Layer } from './layer.js';
+import { StyleManagerBase } from './styleManagerBase.js';
+
+/**
+ * LayerManager Class
+ * @extends StyleManagerBase
+ */
+export class LayerManager extends StyleManagerBase {
+  /** Create a LayerManager */
+  constructor() {
+    super();
+
+    this.indelibleItems.push('0', 'DEFPOINTS');
+    this.itemProperty = 'layer';
+  }
+
+  /** Get the item class */
+  get itemClass() {
+    return Layer;
+  }
+
+  /** Add standard layers */
+  addStandardItems() {
+    this.addItem({ 'name': '0' });
+    this.addItem({ 'name': 'DEFPOINTS', 'plotting': false });
+  }
+
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    // Create table data for layers
+    file.writeGroupCode('0', 'TABLE');
+    file.writeGroupCode('2', 'LAYER');
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    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/ltype.js

@@ -0,0 +1,85 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { Flags } from '../properties/flags.js';
+import { Property } from '../properties/property.js';
+
+/** LineType Class */
+export class LType {
+  /**
+   * Create a Line Type
+   * @param {Object} data
+   */
+  constructor(data) {
+    this.type = 'LType';
+    this.name = '';
+    this.description = '';
+    this.pattern = [];
+
+    Object.defineProperty(this, 'flags', {
+      value: new Flags(),
+      writable: true,
+    });
+
+    // 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 - description text
+    this.description = Property.loadValue([data?.description, data?.[3]], '');
+    // DXF Groupcode 49 - line type pattern
+    this.pattern = Property.loadValue([data?.pattern, data?.[49]], []);
+
+    if (data?.hasOwnProperty('73')) {
+      // DXF Groupcode 73 - number of line type elements in data[49]
+      if (data[73] !== this.pattern.length) {
+        throw Error('invalid line type pattern');
+      }
+    }
+
+    // DXF Groupcode 70 - Polyline flag (bit-coded; default = 0):
+    // 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 = line type was referenced by at least one entity in the drawing the last time the drawing was edited. (This flag can be ignored by most programs)
+    this.flags.setFlagValue(Property.loadValue([data?.flags, data?.[70]], 0));
+  }
+
+  /**
+   * Get a dash pattern that cairo and html canvas understand
+   * @param {Array} scale
+   * @return {Array} array for dash pattern
+   */
+  getPattern(scale) {
+    // DXF Patterns use -ve values for gaps and 0.0 for dots
+    // cairo and canvas require pattern to include +ve non-zero values
+    const pattern = this.pattern.map((x) => (Math.abs(x) + 1) / scale);
+    return pattern;
+  }
+
+  /**
+   * Write the dxf representation to file
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'LTYPE');
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbLinetypeTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('2', this.name);
+    file.writeGroupCode('70', this.flags.getFlagValue());
+    file.writeGroupCode('3', this.description);
+    file.writeGroupCode('72', 65); // Alignment code; value is always 65, the ASCII code for A
+    file.writeGroupCode('73', this.pattern.length);
+
+    let patternLength = 0;
+
+    if (this.pattern.length) {
+      patternLength = this.pattern.reduce((accumulator, patternValue) => accumulator + Math.abs(patternValue));
+    }
+
+    file.writeGroupCode('40', patternLength);
+
+    for (let i = 0; i < this.pattern.length; i++) {
+      file.writeGroupCode('49', this.pattern[i]);
+      file.writeGroupCode('74', '0', DXFFile.Version.R2000);
+    }
+  }
+}

package/core/tables/ltypeManager.js

@@ -0,0 +1,65 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { StyleManagerBase } from './styleManagerBase.js';
+import { LType } from './ltype.js';
+
+/**
+ * Line Type Manager Class
+ * @extends StyleManagerBase
+ */
+export class LTypeManager extends StyleManagerBase {
+  /** Create a LTypeManager */
+  constructor() {
+    super();
+
+    this.indelibleItems.push('CONTINUOUS', 'ByLayer', 'ByBlock');
+    this.itemProperty = 'lineType';
+  }
+
+  /** Get the item class */
+  get itemClass() {
+    return LType;
+  }
+
+  /** Add standard line types */
+  addStandardItems() {
+    this.addItem({ 'name': 'CONTINUOUS', 'description': 'Solid Line ________________________________________' });
+    this.addItem({ 'name': 'ByLayer' });
+    this.addItem({ 'name': 'ByBlock' });
+  }
+
+  /**
+   * Get a list of optional line types
+   * @return {Array}
+   */
+  getOptionalStyles() {
+    const styles = [];
+    styles.push({ 'name': 'CONTINUOUS', 'description': 'Solid Line ________________________________________' });
+    styles.push({ 'name': 'CENTER', 'pattern': [31.75, -6.35, 6.35, -6.35], 'description': 'Center ____ _ ____ _ ____ _ ____ _ ____ _ ____' });
+    styles.push({ 'name': 'DASHDOT', 'pattern': [12.7, -6.345, 0, -6.345], 'description': 'Dash dot __ . __ . __ . __ . __ . __ . __ . __' });
+    styles.push({ 'name': 'DOT', 'pattern': [0, -6.35], 'description': 'Dot . . . . . . . . . . . . . . . . . . . . . .' });
+    styles.push({ 'name': 'DASHED', 'pattern': [12.7, -6.35], 'description': 'Dashed __ __ __ __ __ __ __ __ __ __ __ __ __ _' });
+    styles.push({ 'name': 'HIDDEN', 'pattern': [6.35, -3.175], 'description': 'Hidden __ __ __ __ __ __ __ __ __ __ __ __ __ _' });
+    return styles;
+  }
+
+  /**
+   * Write the table to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    // Create table data for ltype styles
+    // The LTYPE Table must preceed the LAYER table
+    file.writeGroupCode('0', 'TABLE');
+    file.writeGroupCode('2', 'LTYPE');
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    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');
+  }
+}