@design-core/core 0.0.6 → 50.1.0

package/core/dimensions/dimension.js

@@ -1,4 +1,4 @@
-import { BaseDimension } from './baseDimension.js';
+import { DimensionBase } from './dimensionBase.js';
 import { AlignedDimension } from './alignedDimension.js';
 import { DiametricDimension } from './diametricDimension.js';
 import { AngularDimension } from './angularDimension.js';
@@ -8,7 +8,7 @@ import { RotatedDimension } from './rotatedDimension.js';
 import { Arc } from '../entities/arc.js';
 import { Circle } from '../entities/circle.js';
 import { Line } from '../entities/line.js';
-import { BasePolyline } from '../entities/basePolyline.js';
+import { PolylineBase } from '../entities/polylineBase.js';
 import { Point } from '../entities/point.js';
 
 import { Strings } from '../lib/strings.js';
@@ -17,15 +17,16 @@ import { Logging } from '../lib/logging.js';
 import { Intersection } from '../lib/intersect.js';
 
 import { DesignCore } from '../designCore.js';
+import { Property } from '../properties/property.js';
 import { SingleSelection } from '../lib/selectionManager.js';
 import { Utils } from '../lib/utils.js';
 import { DimType } from '../properties/dimType.js';
 
 /**
  * Dimension Entity Class
- * @extends BaseDimension
+ * @extends DimensionBase
  */
-export class Dimension extends BaseDimension {
+export class Dimension extends DimensionBase {
   /**
    * Create a Dimension
    * @param {Array} data
@@ -33,21 +34,27 @@ export class Dimension extends BaseDimension {
   constructor(data) {
     super(data);
 
-    // map dimensions type to the class name
-    this.dimensionMap = {
-      0: RotatedDimension,
-      1: AlignedDimension,
-      2: AngularDimension,
-      3: DiametricDimension,
-      4: RadialDimension,
-      5: null, // 5 = Angular 3 point;
-      6: null, // 6 = Ordinate;
-    };
-
-    this.selectedItems = [];
+    // map dimensions type to the class name — non-enumerable: internal workflow state
+    Object.defineProperty(this, 'dimensionMap', {
+      value: {
+        0: RotatedDimension,
+        1: AlignedDimension,
+        2: AngularDimension,
+        3: DiametricDimension,
+        4: RadialDimension,
+        5: null, // 5 = Angular 3 point;
+        6: null, // 6 = Ordinate;
+      },
+      writable: true,
+    });
+
+    Object.defineProperty(this, 'selectedEntities', {
+      value: [],
+      writable: true,
+    });
 
     if (data) {
-      const item = new this.dimensionMap[DimType.getBaseType(this.dimType.getBaseDimType())](data);
+      const entity = new this.dimensionMap[DimType.getBaseType(this.dimType.getBaseDimType())](data);
 
       // find the block linked to this dimension
       const linkedBlockIndex = DesignCore.Scene.entities.find('BLOCK', 'name', data[2]);
@@ -57,7 +64,7 @@ export class Dimension extends BaseDimension {
         DesignCore.Scene.entities.remove(linkedBlockIndex[0]);
       }
 
-      return item;
+      return entity;
     }
   }
 
@@ -80,7 +87,7 @@ export class Dimension extends BaseDimension {
   async execute() {
     try {
       let inputValid = false;
-      this.dimensionStyle = DesignCore.DimStyleManager.getCstyle();
+      this.setProperty(Property.Names.DIMENSIONSTYLE, DesignCore.DimStyleManager.getCstyle());
 
       while (!inputValid) {
         DesignCore.Scene.selectionManager.reset();
@@ -97,51 +104,51 @@ export class Dimension extends BaseDimension {
           if (pt14 === undefined) return;
           // Create a temporary line using the selected points
           const tempLine = new Line({ points: [input1, pt14] });
-          this.selectedItems.push(tempLine);
+          this.selectedEntities.push(tempLine);
         }
 
         if (input1 instanceof SingleSelection) {
-          const selectedItem = DesignCore.Scene.entities.get(input1.selectedItemIndex);
+          const selectedEntity = DesignCore.Scene.entities.get(input1.selectedEntityIndex);
 
           // check the selected entity is supported
-          if ([Line, Circle, Arc, BasePolyline].some((entity) => selectedItem instanceof entity)) {
+          if ([Line, Circle, Arc, PolylineBase].some((entity) => selectedEntity instanceof entity)) {
             // set the dimension type
-            if (selectedItem instanceof Line) {
+            if (selectedEntity instanceof Line) {
               this.dimType.setDimType(1);
-              this.selectedItems.push(selectedItem);
+              this.selectedEntities.push(selectedEntity);
               inputValid = true;
             }
 
-            if (selectedItem instanceof Circle) {
+            if (selectedEntity instanceof Circle) {
               this.dimType.setDimType(3);
-              this.selectedItems.push(selectedItem);
+              this.selectedEntities.push(selectedEntity);
               inputValid = true;
             }
 
-            if (selectedItem instanceof Arc) {
+            if (selectedEntity instanceof Arc) {
               this.dimType.setDimType(4);
-              this.selectedItems.push(selectedItem);
+              this.selectedEntities.push(selectedEntity);
               inputValid = true;
             }
 
-            if (selectedItem instanceof BasePolyline) {
+            if (selectedEntity instanceof PolylineBase) {
               // get the segment closest to the mouse point
-              const segment = selectedItem.getClosestSegment(input1.selectedPoint);
+              const segment = selectedEntity.getClosestSegment(input1.selectedPoint);
 
               if (segment instanceof Line) {
                 this.dimType.setDimType(1);
-                this.selectedItems.push(segment);
+                this.selectedEntities.push(segment);
                 inputValid = true;
               }
 
               if (segment instanceof Arc) {
                 this.dimType.setDimType(4);
-                this.selectedItems.push(segment);
+                this.selectedEntities.push(segment);
                 inputValid = true;
               }
             }
           } else {
-            const msg = `${this.type} - ${Strings.Error.INVALIDTYPE}: ${selectedItem.type}`;
+            const msg = `${this.type} - ${Strings.Error.INVALIDTYPE}: ${selectedEntity.type}`;
             DesignCore.Core.notify(msg);
             DesignCore.Scene.selectionManager.reset();
           }
@@ -155,12 +162,12 @@ export class Dimension extends BaseDimension {
         let op2 = new PromptOptions(Strings.Input.DIMENSION, [Input.Type.POINT]);
 
         // Angular dimension prompt: select a second line for an angular dimension or location for the text position
-        if ((this.selectedItems[0] instanceof Line) && this.selectedItems.length < 2) {
+        if ((this.selectedEntities[0] instanceof Line) && this.selectedEntities.length < 2) {
           op2 = new PromptOptions(`${Strings.Input.DIMENSION} or ${Strings.Input.SELECT}`, [Input.Type.POINT, Input.Type.SINGLESELECTION]);
         }
 
         // diametric prompt: select radial or diametric type dimension or location for the the text position
-        if (this.selectedItems[0] instanceof Circle) {
+        if (this.selectedEntities[0] instanceof Circle) {
           const options = this.dimType.getBaseDimType() === 3 ? ['Radius'] : ['Diameter'];
           op2 = new PromptOptions(`${Strings.Input.DIMENSION}`, [Input.Type.POINT], options);
         }
@@ -171,19 +178,19 @@ export class Dimension extends BaseDimension {
         if (Input.getType(input2) === Input.Type.POINT) {
           const Pt11 = input2;
 
-          // if selected items are available, get the points from the selected items
-          // dimensions can be created from point selection only, therefore selected items may not be available
-          if (this.selectedItems.length) {
+          // if selected entities are available, get the points from the selected entities
+          // dimensions can be created from point selection only, therefore selected entities may not be available
+          if (this.selectedEntities.length) {
             // for linear dimensions, determine if aligned or rotated based on mouse position
             if (this.dimType.getBaseDimType() === 0 || this.dimType.getBaseDimType() === 1) {
-              const Pt13 = this.selectedItems[0].points[0];
-              const Pt14 = this.selectedItems[0].points[1];
+              const Pt13 = this.selectedEntities[0].points[0];
+              const Pt14 = this.selectedEntities[0].points[1];
               const linearDimTypeNumber = this.getLinearDimensionType(Pt13, Pt14, Pt11);
               this.dimType.setDimType(linearDimTypeNumber);
             }
 
             const dimensionType = this.dimensionMap[this.dimType.getBaseDimType()]; // TODO: use this.dimensionMap.name?
-            this.points.push(...dimensionType.getPointsFromSelection(this.selectedItems, Pt11));
+            this.points.push(...dimensionType.getPointsFromSelection(this.selectedEntities, Pt11));
           }
         }
 
@@ -199,20 +206,20 @@ export class Dimension extends BaseDimension {
         }
 
         if (Input.getType(input2) === Input.Type.SINGLESELECTION) {
-          let selectedItem2 = DesignCore.Scene.entities.get(input2.selectedItemIndex);
-          if ([Line, BasePolyline].some((entity) => selectedItem2 instanceof entity)) {
+          let selectedEntity2 = DesignCore.Scene.entities.get(input2.selectedEntityIndex);
+          if ([Line, PolylineBase].some((entity) => selectedEntity2 instanceof entity)) {
             // if a polyline is selected, get the segment closest to the mouse point
-            if (selectedItem2 instanceof BasePolyline) {
+            if (selectedEntity2 instanceof PolylineBase) {
               // get the segment closest to the mouse point
-              const segment = selectedItem2.getClosestSegment(input2.selectedPoint);
+              const segment = selectedEntity2.getClosestSegment(input2.selectedPoint);
 
               if (segment instanceof Line) {
-                selectedItem2 = segment;
+                selectedEntity2 = segment;
               }
             }
             // Check lines intersect
-            const line1 = { start: this.selectedItems[0].points[0], end: this.selectedItems[0].points[1] };
-            const line2 = { start: selectedItem2.points[0], end: selectedItem2.points[1] };
+            const line1 = { start: this.selectedEntities[0].points[0], end: this.selectedEntities[0].points[1] };
+            const line2 = { start: selectedEntity2.points[0], end: selectedEntity2.points[1] };
 
             // Check the lines are not parallel - Can't dimension parallel lines
             const lineOneSlope = (line1.end.y - line1.start.y) / (line1.end.x - line1.start.x);
@@ -222,7 +229,7 @@ export class Dimension extends BaseDimension {
               const intersect = Intersection.intersectSegmentSegment(line1.start, line1.end, line2.start, line2.end, false, true);
               if (intersect.points.length >= 1) {
               // add line to selection
-                this.selectedItems.push(selectedItem2);
+                this.selectedEntities.push(selectedEntity2);
                 // Two lines selected - switch to angular dimension
                 this.dimType.setDimType(2);
               }
@@ -232,7 +239,7 @@ export class Dimension extends BaseDimension {
               DesignCore.Scene.selectionManager.removeLastSelection();
             }
           } else {
-            const msg = `${this.type} - ${Strings.Error.INVALIDTYPE}: ${selectedItem2.type}`;
+            const msg = `${this.type} - ${Strings.Error.INVALIDTYPE}: ${selectedEntity2.type}`;
             DesignCore.Core.notify(msg);
             DesignCore.Scene.selectionManager.reset();
           }
@@ -273,7 +280,7 @@ export class Dimension extends BaseDimension {
    * Preview the entity during creation
    */
   preview() {
-    if (this.selectedItems.length) {
+    if (this.selectedEntities.length) {
       let dimTypeNumber = this.dimType.getBaseDimType();
 
       const Pt11 = DesignCore.Mouse.pointOnScene();
@@ -281,8 +288,8 @@ export class Dimension extends BaseDimension {
 
       if (dimTypeNumber === 0 || dimTypeNumber === 1) {
         // for linear dimensions, determine if aligned or rotated based on mouse position
-        const Pt13 = this.selectedItems[0].points[0];
-        const Pt14 = this.selectedItems[0].points[1];
+        const Pt13 = this.selectedEntities[0].points[0];
+        const Pt14 = this.selectedEntities[0].points[1];
         dimTypeNumber = this.getLinearDimensionType(Pt13, Pt14, Pt11);
       }
       // get the dimension class
@@ -290,9 +297,9 @@ export class Dimension extends BaseDimension {
       // get the dimension type as a string
       const dimensionTypeString = dimensionType.register().command;
       // get the points for the dimension
-      const points = dimensionType.getPointsFromSelection(this.selectedItems, Pt11);
+      const points = dimensionType.getPointsFromSelection(this.selectedEntities, Pt11);
       // create the temporary dimension
-      DesignCore.Scene.tempEntities.create(dimensionTypeString, { points: points, dimensionStyle: this.dimensionStyle });
+      DesignCore.Scene.previewEntities.create(dimensionTypeString, { points: points, dimensionStyle: this.getProperty(Property.Names.DIMENSIONSTYLE) });
     }
   }
 }

package/core/dimensions/{baseDimension.js → dimensionBase.js}

@@ -16,7 +16,7 @@ import { DimType } from '../properties/dimType.js';
  * Base Dimension Entity Class
  * @extends Entity
  */
-export class BaseDimension extends Entity {
+export class DimensionBase extends Entity {
   /**
    * Create a Base Dimension
    * @param {Array} data
@@ -24,91 +24,67 @@ export class BaseDimension extends Entity {
   constructor(data) {
     super(data);
 
-    // hide inherited property
-    // needs to be enumerable=false to not appear in the object props
-    Object.defineProperty(this, 'lineType', {
-      enumerable: false,
-    });
+    // lineType and lineWidth not applicable to dimensions
+    this.properties.remove(Property.Names.LINETYPE);
+    this.properties.remove(Property.Names.LINEWIDTH);
 
-    // hide inherited property
-    Object.defineProperty(this, 'lineWidth', {
-      enumerable: false,
+    // DXF Groupcode 1 - Dimension text override
+    this.properties.add(Property.Names.TEXTOVERRIDE, {
+      type: Property.Type.STRING,
+      value: Property.loadValue([data?.[1], data?.textOverride], ''),
+      dxfCode: 1,
     });
 
-    Object.defineProperty(this, 'blockName', {
-      value: '',
-      writable: true,
+    // DXF Groupcode 2 - Block name
+    this.properties.add(Property.Names.BLOCKNAME, {
+      type: Property.Type.STRING,
+      value: Property.loadValue([data?.blockName, data?.[2]], ''),
+      dxfCode: 2,
+      visible: false,
     });
 
-    Object.defineProperty(this, 'block', {
-      value: new Block({ points: [new Point(), new Point()] }),
-      writable: true,
-    });
-
-    /*
-    Object.defineProperty(this, 'text', {
-      value: new Text(),
-      writable: true,
+    // DXF Groupcode 3 - Dimension Style Name
+    this.properties.add(Property.Names.DIMENSIONSTYLE, {
+      type: Property.Type.LIST,
+      value: Property.loadValue([data?.dimensionStyle, data?.[3]], 'STANDARD'),
+      dxfCode: 3,
     });
-    */
 
-    Object.defineProperty(this, 'textOverride', {
-      value: '',
-      writable: true,
-      enumerable: true,
+    // DXF Groupcode 40 - Leader length for radius and diameter dimensions
+    this.properties.add(Property.Names.LEADERLENGTH, {
+      type: Property.Type.NUMBER,
+      value: Property.loadValue([data?.[40], data?.leaderLength], 0),
+      dxfCode: 40,
+      visible: false,
     });
 
-    Object.defineProperty(this, 'dimType', {
-      value: new DimType(),
-      writable: true,
+    // DXF Groupcode 50 - Angle of rotated, horizontal, or vertical dimensions
+    this.properties.add(Property.Names.LINEARDIMANGLE, {
+      type: Property.Type.NUMBER,
+      value: Property.loadValue([data?.[50], data?.linearDimAngle], 0),
+      dxfCode: 50,
+      visible: false,
     });
 
-    Object.defineProperty(this, 'dimensionStyle', {
-      value: 'STANDARD',
-      writable: true,
-      enumerable: true,
+    // DXF Groupcode 53 - Rotation angle of dimension text away from default orientation
+    this.properties.add(Property.Names.ANGLE, {
+      type: Property.Type.NUMBER,
+      value: Property.loadValue([data?.[53], data?.angle], 0),
+      dxfCode: 53,
+      visible: false,
     });
 
-    Object.defineProperty(this, 'leaderLength', {
-      value: 0,
+    Object.defineProperty(this, 'block', {
+      value: new Block({ points: [new Point(), new Point()] }),
       writable: true,
     });
 
-    Object.defineProperty(this, 'linearDimAngle', {
-      value: 0,
+    Object.defineProperty(this, 'dimType', {
+      value: new DimType(),
       writable: true,
     });
 
     if (data) {
-      if (data.hasOwnProperty('1')) {
-        // DXF Groupcode 1 - Dimension text
-        // The string explicitly entered by the user.
-        // Optional; default is the measurement. If null or “<>”, the dimension measurement is drawn as the text,
-        // if ““ (one blank space), the text is suppressed. Anything else is drawn as the text
-        this.textOverride = Property.loadValue([data[1], data.textOverride], '');
-      }
-
-      /*
-      if (data.hasOwnProperty('block')) {
-        // Reference to block that contains the entities that make up this dimension
-        this.block = data.block;
-      }*/
-
-      if (data.hasOwnProperty('blockName') || data.hasOwnProperty('2')) {
-        // DXF Groupcode 2 - Blockname
-        this.blockName = Property.loadValue([data.blockName, data[2]], '');
-      }
-
-      if (data.hasOwnProperty('dimensionStyle') || data.hasOwnProperty('3')) {
-        // DXF Groupcode 3 - Dimension Style Name
-        this.dimensionStyle = Property.loadValue([data.dimensionStyle, data[3]], 'STANDARD');
-      }
-
-      if (data.hasOwnProperty('40')) {
-        // DXF Groupcode 40 - Leader length for radius and diameter dimensions
-        this.leaderLength = data[40];
-      }
-
       if (data.hasOwnProperty('41')) {
         // DXF Groupcode 41 - Line Spacing Factor
         // Percentage of default (3-on-5) line spacing to be applied.
@@ -124,11 +100,6 @@ export class BaseDimension extends Entity {
         Logging.instance.debug(`${this.type} - ${err}`);
       }
 
-      if (data.hasOwnProperty('50')) {
-        // DXF Groupcode 50 - Angle of rotated, horizontal, or vertical dimensions
-        this.linearDimAngle = Property.loadValue([data[50]], 0);
-      }
-
       if (data.hasOwnProperty('51')) {
         // DXF Groupcode 51 - Horizontal Direction
         // All dimension types have an optional 51 group code, which indicates the horizontal direction
@@ -140,12 +111,6 @@ export class BaseDimension extends Entity {
         Logging.instance.warn(`${this.type} - ${err}`);
       }
 
-      if (data.hasOwnProperty('angle') || data.hasOwnProperty('53')) {
-        // DXF Groupcode 53 - Rotation
-        // rotation angle of the dimension text away from its default orientation
-        this.angle = Property.loadValue([data.angle, data[53]], 0);
-      }
-
       if (data.hasOwnProperty('dimType') || data.hasOwnProperty('70')) {
         // DXF Groupcode 70 - Dimension Type
         // Values 0-6 are integer values that represent the dimension type. Values 32, 64, and 128
@@ -183,9 +148,9 @@ export class BaseDimension extends Entity {
 
       if (data.hasOwnProperty('71')) {
         // DXF Groupcode 71 - Attachment Point
-        // 1 = Top left; 2 = Top center; 3 = Top right
-        // 4 = Middle left; 5 = Middle center; 6 = Middle right
-        // 7 = Bottom left; 8 = Bottom center; 9 = Bottom right
+        // 1 = Top left; 2 = Top centre; 3 = Top right
+        // 4 = Middle left; 5 = Middle centre; 6 = Middle right
+        // 7 = Bottom left; 8 = Bottom centre; 9 = Bottom right
         const err = 'Groupcode 71 not implemented';
         Logging.instance.debug(`${this.type} - ${err}`);
       }
@@ -197,10 +162,6 @@ export class BaseDimension extends Entity {
         const err = 'Groupcode 72 not implemented';
         Logging.instance.debug(`${this.type} - ${err}`);
       }
-
-      if (data.leaderLength) {
-        this.leaderLength = data.leaderLength;
-      }
     }
   }
 
@@ -280,8 +241,9 @@ export class BaseDimension extends Entity {
     }
 
     // Handle textOverride
-    if (this.textOverride !== '') {
-      formattedDimensionValue = this.textOverride.replace(/<>/g, formattedDimensionValue);
+    const textOverride = this.getProperty(Property.Names.TEXTOVERRIDE);
+    if (textOverride !== '') {
+      formattedDimensionValue = textOverride.replace(/<>/g, formattedDimensionValue);
     }
 
     // TODO: Implement prefix and postsuffix - DIMPOST
@@ -338,13 +300,13 @@ export class BaseDimension extends Entity {
     // get the text height
     const textHeight = this.getDimensionStyle().getValue('DIMTXT');
     // set the text height
-    text.height = textHeight;
-    // Always set text horizontal alignment to center
-    text.horizontalAlignment = 1;
+    text.setProperty(Property.Names.HEIGHT, textHeight);
+    // Always set text horizontal alignment to centre
+    text.setProperty(Property.Names.HORIZONTALALIGNMENT, 1);
     // Always set text vertical alignment to middle
-    text.verticalAlignment = 2;
+    text.setProperty(Property.Names.VERTICALALIGNMENT, 2);
     // set the text value
-    text.string = this.getDimensionValue(textValue);
+    text.setProperty(Property.Names.STRING, this.getDimensionValue(textValue));
     // set the text position
     text.points = [textPosition];
     // set the text rotation
@@ -385,7 +347,7 @@ export class BaseDimension extends Entity {
    * @return {Object} - the dimension style object
    */
   getDimensionStyle() {
-    return DesignCore.DimStyleManager.getItemByName(this.dimensionStyle);
+    return DesignCore.DimStyleManager.getItemByName(this.getProperty(Property.Names.DIMENSIONSTYLE));
   }
 
   /**
@@ -429,19 +391,19 @@ export class BaseDimension extends Entity {
 
   /**
    * Get the geometry for the centre mark
-   * @param {Point} point centre point for center mark
-   * @return {Array} array of entities representing the center mark
+   * @param {Point} point centre point for centre mark
+   * @return {Array} array of entities representing the centre mark
    */
   getCentreMark(point) {
     /*
     * DIMCEN value defines the centre mark type and size
-    * 0 = No center marks or lines are drawn
-    * <0 = Centerlines are drawn
-    * >0 = Center marks are drawn
+    * 0 = No centre marks or lines are drawn
+    * <0 = Centrelines are drawn
+    * >0 = Centre marks are drawn
     */
 
     const centreMark = [];
-    // get the center mark style
+    // get the centre mark style
     const markStyle = this.getDimensionStyle().getValue('DIMCENSTYL');
     // get the centre mark size
     const markSize = this.getDimensionStyle().getValue('DIMCENVALUE');
@@ -470,15 +432,15 @@ export class BaseDimension extends Entity {
 
   /**
    * Draw the entity
-   * @param {Object} ctx - context
-   * @param {number} scale
+   * @param {Object} renderer
+   * @return {Array} block entities for the canvas to render recursively
    */
-  draw(ctx, scale) {
-    if (this.block.items.length === 0) {
+  draw(renderer) {
+    if (this.block.entities.length === 0) {
       this.refresh();
     }
 
-    this.block.draw(ctx, scale, this);
+    return this.block.entities;
   }
 
   /**
@@ -528,18 +490,18 @@ export class BaseDimension extends Entity {
   }
 
   /**
-   * Refesh the dimension geometry
+   * Refresh the dimension geometry
    */
   refresh() {
     const entities = this.buildDimension();
 
     if (entities) {
-      this.block.clearItems();
+      this.block.clearEntities();
 
       entities.forEach((element) => {
         // For colour BYBLOCK for dimensions
-        element.setColour('BYBLOCK');
-        this.block.addItem(element);
+        element.setProperty(Property.Names.COLOUR, 'BYBLOCK');
+        this.block.addEntity(element);
       });
     }
   }
@@ -550,6 +512,10 @@ export class BaseDimension extends Entity {
    * @param {any} value
    */
   setProperty(property, value) {
+    if (this.properties.has(property)) {
+      super.setProperty(property, value);
+      return;
+    }
     if (this.hasOwnProperty(property)) {
       this[property] = value;
       this.refresh();