@design-core/core 0.0.7 → 50.1.0

package/.github/workflows/DesignCoreQA.yml

@@ -27,6 +27,9 @@ jobs:
         node-version: ${{ matrix.node-version }}
         cache: 'npm'
 
+    - name: Spell Check
+      run: npx cspell "**/*.{js,md}" --no-progress
+
     - name: Circular Dependency Check
       run: npx madge --circular --extensions js .
 

package/core/designCore.js

@@ -11,7 +11,7 @@
    import {Core} from "core.js";
    import {DesignCore} from "designCore.js";
 
-   // Core must be instanciated and activated before use:
+   // Core must be instantiated and activated before use:
    const core = new Core()
    core.activate()
 

package/core/dimensions/alignedDimension.js

@@ -4,7 +4,7 @@ import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
 import { DXFFile } from '../lib/dxf/dxfFile.js';
 import { Point } from '../entities/point.js';
-import { BaseLinearDimension } from './baseLinearDimension.js';
+import { LinearDimensionBase } from './linearDimensionBase.js';
 
 import { DesignCore } from '../designCore.js';
 import { Property } from '../properties/property.js';
@@ -14,7 +14,7 @@ import { Property } from '../properties/property.js';
  * Aligned Dimension Entity Class
  * @extends LinearDimension
  */
-export class AlignedDimension extends BaseLinearDimension {
+export class AlignedDimension extends LinearDimensionBase {
   /**
    * Create an Aligned Dimension
    * @param {Array} data
@@ -72,19 +72,19 @@ export class AlignedDimension extends BaseLinearDimension {
 
   /**
      * Get sequenced points from user selection
-     * @param {any} items
+     * @param {any} entities
      * @param {Point} textPos
      * @return {Array} array of points
      */
-  static getPointsFromSelection(items, textPos) {
+  static getPointsFromSelection(entities, textPos) {
     const points = [];
-    const item = items[0];
+    const entity = entities[0];
 
-    const Pt13 = item.points[0];
+    const Pt13 = entity.points[0];
     Pt13.sequence = 13;
     points.push(Pt13);
 
-    const Pt14 = item.points[1];
+    const Pt14 = entity.points[1];
     Pt14.sequence = 14;
     points.push(Pt14);
 

package/core/dimensions/angularDimension.js

@@ -2,12 +2,12 @@
 import { Utils } from '../lib/utils.js';
 import { Strings } from '../lib/strings.js';
 import { Arc } from '../entities/arc.js';
-import { BasePolyline } from '../entities/basePolyline.js';
+import { PolylineBase } from '../entities/polylineBase.js';
 import { Line } from '../entities/line.js';
 import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
 import { DXFFile } from '../lib/dxf/dxfFile.js';
-import { BaseDimension } from './baseDimension.js';
+import { DimensionBase } from './dimensionBase.js';
 import { Intersection } from '../lib/intersect.js';
 import { Point } from '../entities/point.js';
 
@@ -18,9 +18,9 @@ import { Property } from '../properties/property.js';
 
 /**
  * Angular Dimension Entity Class
- * @extends BaseDimension
+ * @extends DimensionBase
  */
-export class AngularDimension extends BaseDimension {
+export class AngularDimension extends DimensionBase {
   /**
    * Create an Angular Dimension
    * @param {Array} data
@@ -62,25 +62,25 @@ export class AngularDimension extends BaseDimension {
 
         const op = new PromptOptions(Strings.Input.SELECT, [Input.Type.SINGLESELECTION]);
         const selection = await DesignCore.Scene.inputManager.requestInput(op);
-        let selectedItem = DesignCore.Scene.entities.get(selection.selectedItemIndex);
+        let selectedEntity = DesignCore.Scene.entities.get(selection.selectedEntityIndex);
 
-        if ([Line, BasePolyline].some((entity) => selectedItem instanceof entity)) {
-          if (selectedItem instanceof BasePolyline) {
+        if ([Line, PolylineBase].some((entity) => selectedEntity instanceof entity)) {
+          if (selectedEntity instanceof PolylineBase) {
             // get the segment closest to the mouse point
-            const segment = selectedItem.getClosestSegment(selection.selectedPoint);
+            const segment = selectedEntity.getClosestSegment(selection.selectedPoint);
 
             if (segment instanceof Line) {
-              // update the selected item to be the polyline arc segment
-              selectedItem = segment;
+              // update the selected entity to be the polyline arc segment
+              selectedEntity = segment;
             }
           }
 
-          if (selectedItem instanceof Line) {
-            Pt15 = selectedItem.points[0];
+          if (selectedEntity instanceof Line) {
+            Pt15 = selectedEntity.points[0];
             Pt15.sequence = 15;
             this.points.push(Pt15);
 
-            Pt10 = selectedItem.points[1];
+            Pt10 = selectedEntity.points[1];
             Pt10.sequence = 10;
             this.points.push(Pt10);
           }
@@ -91,24 +91,24 @@ export class AngularDimension extends BaseDimension {
         DesignCore.Scene.selectionManager.reset();
         const op1 = new PromptOptions(Strings.Input.SELECT, [Input.Type.SINGLESELECTION]);
         const selection2 = await DesignCore.Scene.inputManager.requestInput(op1);
-        let selectedItem = DesignCore.Scene.entities.get(selection2.selectedItemIndex);
+        let selectedEntity = DesignCore.Scene.entities.get(selection2.selectedEntityIndex);
 
-        if ([Line, BasePolyline].some((entity) => selectedItem instanceof entity)) {
-          if (selectedItem instanceof BasePolyline) {
+        if ([Line, PolylineBase].some((entity) => selectedEntity instanceof entity)) {
+          if (selectedEntity instanceof PolylineBase) {
             // get the segment closest to the mouse point
-            const segment = selectedItem.getClosestSegment(selection2.selectedPoint);
+            const segment = selectedEntity.getClosestSegment(selection2.selectedPoint);
 
             if (segment instanceof Line) {
-              // update the selected item to be the polyline arc segment
-              selectedItem = segment;
+              // update the selected entity to be the polyline arc segment
+              selectedEntity = segment;
             }
           }
-          if (selectedItem instanceof Line) {
-            Pt13 = selectedItem.points[0];
+          if (selectedEntity instanceof Line) {
+            Pt13 = selectedEntity.points[0];
             Pt13.sequence = 13;
             this.points.push(Pt13);
 
-            Pt14 = selectedItem.points[1];
+            Pt14 = selectedEntity.points[1];
             Pt14.sequence = 14;
             this.points.push(Pt14);
           }
@@ -153,23 +153,23 @@ export class AngularDimension extends BaseDimension {
 
   /**
    * Get sequenced points from user selection
-   * @param {any} items
+   * @param {any} entities
    * @param {Point} textPos
    * @return {Array} array of points
    */
-  static getPointsFromSelection(items, textPos) {
-  // Transform the items into points
-  // Do nothing more than transform the items into points
+  static getPointsFromSelection(entities, textPos) {
+  // Transform the entities into points
+  // Do nothing more than transform the entities into points
 
     const points = [];
-    const item1 = items[0];
-    const item2 = items[1];
+    const entity1 = entities[0];
+    const entity2 = entities[1];
 
-    const tempPt15 = item1.points[0];
-    const tempPt10 = item1.points[1];
+    const tempPt15 = entity1.points[0];
+    const tempPt10 = entity1.points[1];
 
-    const tempPt13 = item2.points[0];
-    const tempPt14 = item2.points[1];
+    const tempPt13 = entity2.points[0];
+    const tempPt14 = entity2.points[1];
 
     // Check the lines intersect
     const intersect = Intersection.intersectSegmentSegment(tempPt15, tempPt10, tempPt13, tempPt14, false, true);

package/core/dimensions/{baseCircularDimension.js → circularDimensionBase.js}

@@ -1,14 +1,14 @@
 import { Strings } from '../lib/strings.js';
 import { Circle } from '../entities/circle.js';
 import { Arc } from '../entities/arc.js';
-import { BasePolyline } from '../entities/basePolyline.js';
+import { PolylineBase } from '../entities/polylineBase.js';
 import { Line } from '../entities/line.js';
 import { Text } from '../entities/text.js';
 import { Point } from '../entities/point.js';
 import { Intersection } from '../lib/intersect.js';
 import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
-import { BaseDimension } from './baseDimension.js';
+import { DimensionBase } from './dimensionBase.js';
 
 import { DesignCore } from '../designCore.js';
 import { Property } from '../properties/property.js';
@@ -16,9 +16,9 @@ import { Property } from '../properties/property.js';
 
 /**
  * Base Class for Circular Dimensions - Radius and Diameter
- * @extends BaseDimension
+ * @extends DimensionBase
  */
-export class BaseCircularDimension extends BaseDimension {
+export class CircularDimensionBase extends DimensionBase {
   /**
    * Circular Dimension Constructor
    * @param {Array} data
@@ -44,25 +44,25 @@ export class BaseCircularDimension extends BaseDimension {
         const op = new PromptOptions(Strings.Input.SELECT, [Input.Type.SINGLESELECTION]);
         const selection = await DesignCore.Scene.inputManager.requestInput(op);
 
-        let selectedItem = DesignCore.Scene.entities.get(selection.selectedItemIndex);
+        let selectedEntity = DesignCore.Scene.entities.get(selection.selectedEntityIndex);
 
-        if ([Circle, Arc, BasePolyline].some((entity) => selectedItem instanceof entity)) {
-          if (selectedItem instanceof BasePolyline) {
+        if ([Circle, Arc, PolylineBase].some((entity) => selectedEntity instanceof entity)) {
+          if (selectedEntity instanceof PolylineBase) {
             // get the segment closest to the mouse point
-            const segment = selectedItem.getClosestSegment(selection.selectedPoint);
+            const segment = selectedEntity.getClosestSegment(selection.selectedPoint);
 
             if (segment instanceof Arc) {
-              // update the selected item to be the polyline arc segment
-              selectedItem = segment;
+              // update the selected entity to be the polyline arc segment
+              selectedEntity = segment;
             }
           }
 
-          if (selectedItem instanceof Circle || selectedItem instanceof Arc) {
-            Pt15 = selectedItem.points[1];
+          if (selectedEntity instanceof Circle || selectedEntity instanceof Arc) {
+            Pt15 = selectedEntity.points[1];
             Pt15.sequence = 15;
             this.points.push(Pt15);
 
-            Pt10 = selectedItem.points[0];
+            Pt10 = selectedEntity.points[0];
             Pt10.sequence = 10;
             this.points.push(Pt10);
           }
@@ -111,7 +111,7 @@ export class BaseCircularDimension extends BaseDimension {
     const entities = [];
 
     const Pt15 = this.getPointBySequence(this.points, 15); // radius point
-    const Pt10 = this.getPointBySequence(this.points, 10); // center point for radial dim or radial point for diameteric dim
+    const Pt10 = this.getPointBySequence(this.points, 10); // centre point for radial dim or radial point for diametric dim
     let Pt11 = this.getPointBySequence(this.points, 11); // text position
 
     // Style values
@@ -192,7 +192,7 @@ export class BaseCircularDimension extends BaseDimension {
 
     // DIMTAD - Text vertical position
     switch (DIMTAD) {
-      case 0: // 0 = Centers the dimension text between the extension lines.
+      case 0: // 0 = Centres the dimension text between the extension lines.
         break;
       case 1: // 1 = Places the dimension text above the dimension line except when the dimension line is not horizontal and text inside the extension lines is forced horizontal ( DIMTIH = 1).
         textPosition = textPosition.project(textAboveDirection, textAboveDistance);
@@ -231,13 +231,13 @@ export class BaseCircularDimension extends BaseDimension {
     if (!DIMTOFL) {
     // Add the centre mark for circular dimensions
 
-      let center = Pt10;
+      let centre = Pt10;
 
-      // center point is mid point for diametric dimensions
+      // centre point is mid point for diametric dimensions
       if (this.dimType.getBaseDimType() === 3) {
-        center = Pt10.midPoint(Pt15);
+        centre = Pt10.midPoint(Pt15);
       }
-      entities.push(...this.getCentreMark(center));
+      entities.push(...this.getCentreMark(centre));
     }
 
     return entities;

package/core/dimensions/diametricDimension.js

@@ -1,12 +1,12 @@
 import { DXFFile } from '../lib/dxf/dxfFile.js';
-import { BaseCircularDimension } from './baseCircularDimension.js';
+import { CircularDimensionBase } from './circularDimensionBase.js';
 import { Property } from '../properties/property.js';
 
 /**
  * Diametric Dimension Entity Class
- * @extends BaseCircularDimension
+ * @extends CircularDimensionBase
  */
-export class DiametricDimension extends BaseCircularDimension {
+export class DiametricDimension extends CircularDimensionBase {
   /**
    * Create a Diametric Dimension
    * @param {Array} data
@@ -30,22 +30,22 @@ export class DiametricDimension extends BaseCircularDimension {
 
   /**
    * Get sequenced points from user selection
-   * @param {any} items
+   * @param {any} entities
    * @param {Point} textPos
    * @return {Array} array of points
    */
-  static getPointsFromSelection(items, textPos) {
-    const item = items[0];
-    const center = item.points[0];
+  static getPointsFromSelection(entities, textPos) {
+    const entity = entities[0];
+    const centre = entity.points[0];
 
     const Pt11 = textPos;
     Pt11.sequence = 11;
 
-    const angle = Pt11.angle(center);
-    const Pt10 = center.project(angle, item.getRadius());
+    const angle = Pt11.angle(centre);
+    const Pt10 = centre.project(angle, entity.getRadius());
     Pt10.sequence = 10;
     // Pt15 should be closest point to the text position
-    const Pt15 = center.project(angle - Math.PI, item.getRadius());
+    const Pt15 = centre.project(angle - Math.PI, entity.getRadius());
     Pt15.sequence = 15;
 
     const points = [Pt10, Pt15, Pt11];

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';
@@ -24,9 +24,9 @@ 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
@@ -48,13 +48,13 @@ export class Dimension extends BaseDimension {
       writable: true,
     });
 
-    Object.defineProperty(this, 'selectedItems', {
+    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]);
@@ -64,7 +64,7 @@ export class Dimension extends BaseDimension {
         DesignCore.Scene.entities.remove(linkedBlockIndex[0]);
       }
 
-      return item;
+      return entity;
     }
   }
 
@@ -104,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();
           }
@@ -162,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);
         }
@@ -178,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));
           }
         }
 
@@ -206,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);
@@ -229,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);
               }
@@ -239,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();
           }
@@ -280,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();
@@ -288,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
@@ -297,7 +297,7 @@ 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.previewEntities.create(dimensionTypeString, { points: points, dimensionStyle: this.getProperty(Property.Names.DIMENSIONSTYLE) });
     }