@design-core/core 0.0.7 → 50.1.0

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
@@ -148,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}`);
       }
@@ -301,7 +301,7 @@ export class BaseDimension extends Entity {
     const textHeight = this.getDimensionStyle().getValue('DIMTXT');
     // set the text height
     text.setProperty(Property.Names.HEIGHT, textHeight);
-    // Always set text horizontal alignment to center
+    // Always set text horizontal alignment to centre
     text.setProperty(Property.Names.HORIZONTALALIGNMENT, 1);
     // Always set text vertical alignment to middle
     text.setProperty(Property.Names.VERTICALALIGNMENT, 2);
@@ -391,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');
@@ -433,14 +433,14 @@ export class BaseDimension extends Entity {
   /**
    * Draw the entity
    * @param {Object} renderer
-   * @return {Array} block items for the canvas to render recursively
+   * @return {Array} block entities for the canvas to render recursively
    */
   draw(renderer) {
-    if (this.block.items.length === 0) {
+    if (this.block.entities.length === 0) {
       this.refresh();
     }
 
-    return this.block.items;
+    return this.block.entities;
   }
 
   /**
@@ -490,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.setProperty(Property.Names.COLOUR, 'BYBLOCK');
-        this.block.addItem(element);
+        this.block.addEntity(element);
       });
     }
   }

package/core/dimensions/{baseLinearDimension.js → linearDimensionBase.js}

@@ -3,7 +3,7 @@ import { Line } from '../entities/line.js';
 import { Text } from '../entities/text.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 { Point } from '../entities/point.js';
 
 import { DesignCore } from '../designCore.js';
@@ -13,9 +13,9 @@ import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 /**
  * Aligned Dimension Entity Class
- * @extends BaseDimension
+ * @extends DimensionBase
  */
-export class BaseLinearDimension extends BaseDimension {
+export class LinearDimensionBase extends DimensionBase {
   /**
    * Create an Aligned Dimension
    * @param {Array} data
@@ -62,7 +62,7 @@ export class BaseLinearDimension extends BaseDimension {
    * Preview the entity during creation
    */
   preview() {
-    if (this.points.length == 1) {
+    if (this.points.length === 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
       DesignCore.Scene.auxiliaryEntities.add(new RubberBand([this.points.at(0), mousePoint]));
     }
@@ -190,7 +190,7 @@ export class BaseLinearDimension extends BaseDimension {
     const outsideOffsetDirection = Pt11.distance(Pt13e) < Pt11.distance(Pt14e) ? reverseDimLineAngle : dimLineAngle;
 
     switch (DIMJUST) {
-      case 0: // 0 = Center-justified between extension lines
+      case 0: // 0 = Centre-justified between extension lines
         if (textOutSide) {
           textPosition = midPoint.project(outsideOffsetDirection, outsideOffsetDistance);
         }
@@ -237,7 +237,7 @@ export class BaseLinearDimension 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);
@@ -301,8 +301,8 @@ export class BaseLinearDimension extends BaseDimension {
         dimLineTwoEnd = Pt14e;
       }
       // get the distance to extend the dimension line
-      // when text is vertically centered trim the dimension line back from the text position
-      // when text is not vertically centered extend the dimension line beyond the text position by half the text width
+      // when text is vertically centred trim the dimension line back from the text position
+      // when text is not vertically centred extend the dimension line beyond the text position by half the text width
       const dimlineExtendDistance = textDimlineIntersection.isSame(textPosition) ? approxTextHalfWidth + DIMGAP : -approxTextHalfWidth;
 
       if (Pt11.distance(Pt13e) < Pt11.distance(Pt14e)) {
@@ -314,7 +314,7 @@ export class BaseLinearDimension extends BaseDimension {
       }
     }
 
-    // split the dimension line when the text is centered vertically
+    // split the dimension line when the text is centred vertically
     if (textIsOnInternalDimLine) {
       dimLineOneEnd = dimLineOneEnd.project(reverseDimLineAngle, approxTextWidth * 0.6);
       dimLineTwoEnd = dimLineTwoEnd.project(dimLineAngle, approxTextWidth * 0.6);

package/core/dimensions/radialDimension.js

@@ -1,13 +1,13 @@
 
 import { DXFFile } from '../lib/dxf/dxfFile.js';
-import { BaseCircularDimension } from './baseCircularDimension.js';
+import { CircularDimensionBase } from './circularDimensionBase.js';
 import { Property } from '../properties/property.js';
 
 /**
  * Radial Dimension Entity Class
- * @extends BaseCircularDimension
+ * @extends CircularDimensionBase
  */
-export class RadialDimension extends BaseCircularDimension {
+export class RadialDimension extends CircularDimensionBase {
   /**
    * Create a Radial Dimension
    * @param {Array} data
@@ -31,17 +31,17 @@ export class RadialDimension 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];
+  static getPointsFromSelection(entities, textPos) {
+    const entity = entities[0];
     const Pt11 = textPos;
     Pt11.sequence = 11;
-    const Pt10 = item.points[0]; // Centre
+    const Pt10 = entity.points[0]; // Centre
     Pt10.sequence = 10;
-    const Pt15 = Pt10.project(Pt10.angle(Pt11), item.getRadius());// Radius
+    const Pt15 = Pt10.project(Pt10.angle(Pt11), entity.getRadius());// Radius
     Pt15.sequence = 15;
 
     const points = [Pt10, Pt15, Pt11];

package/core/dimensions/rotatedDimension.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';
@@ -13,9 +13,9 @@ import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 /**
  * Rotated Dimension Entity Class
- * @extends BaseLinearDimension
+ * @extends LinearDimensionBase
  */
-export class RotatedDimension extends BaseLinearDimension {
+export class RotatedDimension extends LinearDimensionBase {
   /**
    * Create an Rotated Dimension
    * @param {Array} data
@@ -77,20 +77,20 @@ export class RotatedDimension extends BaseLinearDimension {
 
   /**
      * Get sequenced points from user selection
-     * @param {any} items
+     * @param {any} entities
      * @param {Point} textPos
      * @param {number} angle - rotation angle in degrees (default 0 = horizontal)
      * @return {Array} array of points
      */
-  static getPointsFromSelection(items, textPos, angle = 0) {
+  static getPointsFromSelection(entities, textPos, angle = 0) {
     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/entities/arc.js

@@ -27,7 +27,7 @@ export class Arc extends Entity {
   constructor(data) {
     super(data);
 
-    // If only the center point is present, project start/end from named scalar properties.
+    // If only the centre point is present, project start/end from named scalar properties.
     // Full-points data (post-execute or post-fromDxf) skips this block entirely.
     if (data && this.points.length < 2) {
       const radius = data.radius ?? 1;
@@ -73,8 +73,8 @@ export class Arc extends Entity {
    * @return {Object}
    */
   static fromDxf(data) {
-    const center = data.points?.[0];
-    if (!center) return data;
+    const centre = data.points?.[0];
+    if (!centre) return data;
     // validate required group codes for points-based arc representation are present
     if (data[40] === undefined || data[50] === undefined || data[51] === undefined) return data;
 
@@ -82,9 +82,9 @@ export class Arc extends Entity {
     return {
       ...data,
       points: [
-        center,
-        center.project(Utils.degrees2radians(data[50] ?? 0), radius),
-        center.project(Utils.degrees2radians(data[51] ?? 0), radius),
+        centre,
+        centre.project(Utils.degrees2radians(data[50] ?? 0), radius),
+        centre.project(Utils.degrees2radians(data[51] ?? 0), radius),
       ],
       direction: data[73] ?? 1,
     };
@@ -116,16 +116,16 @@ export class Arc extends Entity {
 
       let pt2;
       while (true) {
-        DesignCore.Scene.inputManager.inputPoint = pt; // polar/ortho tracks from center on each attempt
+        DesignCore.Scene.inputManager.inputPoint = pt; // polar/ortho tracks from centre on each attempt
         const op2 = new PromptOptions(`${Strings.Input.END} ${Strings.Strings.OR} ${Strings.Input.ANGLE}`, [Input.Type.POINT, Input.Type.NUMBER]);
         pt2 = await DesignCore.Scene.inputManager.requestInput(op2);
         if (pt2 === undefined) return;
 
         if (Input.getType(pt2) === Input.Type.POINT) {
-          // Must not be same as center or start
-          const center = this.points[0];
+          // Must not be same as centre or start
+          const centre = this.points[0];
           const start = this.points[1];
-          if (pt2.isSame?.(center) || pt2.isSame?.(start)) {
+          if (pt2.isSame?.(centre) || pt2.isSame?.(start)) {
             DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDPOINT}`);
             continue;
           }
@@ -193,8 +193,8 @@ export class Arc extends Entity {
     if (this.points.length >= 2) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
       // const points = [...this.points, mousePoint];
-      const center = this.points[0];
-      const endPoint = center.project(center.angle(mousePoint), this.getProperty(Property.Names.RADIUS));
+      const centre = this.points[0];
+      const endPoint = centre.project(centre.angle(mousePoint), this.getProperty(Property.Names.RADIUS));
       if (endPoint.isSame(this.points[1])) return;
       const points = [...this.points, endPoint];
 
@@ -210,22 +210,22 @@ export class Arc extends Entity {
 
   /**
    * Infer arc direction from three points using cross product
-   * @param {Point} center
+   * @param {Point} centre
    * @param {Point} start
    * @param {Point} end
    * @return {number} 1 for ccw, -1 for cw
    */
-  static #inferDirection(center, start, end) {
+  static #inferDirection(centre, start, end) {
     // All points must be defined and distinct
-    if (!center || !start || !end) {
+    if (!centre || !start || !end) {
       return 1; // Default to counterclockwise
     }
-    if (center.isSame?.(start) || center.isSame?.(end) || start.isSame?.(end)) {
+    if (centre.isSame?.(start) || centre.isSame?.(end) || start.isSame?.(end)) {
       return 1;
     }
 
-    const v1 = start.subtract(center);
-    const v2 = end.subtract(center);
+    const v1 = start.subtract(centre);
+    const v2 = end.subtract(centre);
     const cross = v1.cross(v2);
     const direction = cross > 0 ? 1 : -1;
     return direction;
@@ -346,8 +346,8 @@ export class Arc extends Entity {
    * @return {Arc}
    */
   fromPolylinePoints(points) {
-    const center = points[0].bulgeCentrePoint(points[1]);
-    this.points = [center, new Point(points[0].x, points[0].y), new Point(points.at(-1).x, points.at(-1).y)];
+    const centre = points[0].bulgeCentrePoint(points[1]);
+    this.points = [centre, new Point(points[0].x, points[0].y), new Point(points.at(-1).x, points.at(-1).y)];
     return this;
   }
 
@@ -415,9 +415,9 @@ export class Arc extends Entity {
   closestPoint(P) {
     const startPoint = this.points[1];
     const endPoint = this.points[2];
-    const centerPoint = this.points[0];
+    const centrePoint = this.points[0];
 
-    const pnt = P.closestPointOnArc(startPoint, endPoint, centerPoint, this.getProperty(Property.Names.DIRECTION));
+    const pnt = P.closestPointOnArc(startPoint, endPoint, centrePoint, this.getProperty(Property.Names.DIRECTION));
 
     if (pnt !== null) {
       const distance = P.distance(pnt);

package/core/entities/arctext.js

@@ -25,7 +25,7 @@ export class ArcAlignedCharacter {
 
   /**
    * @param {string} character - text character
-   * @param {Point} position - center mid point of character
+   * @param {Point} position - centre mid point of character
    * @param {number} angle - in radians
    * @param {number} height - character height
    * @param {number} width - character width
@@ -192,10 +192,10 @@ export class ArcAlignedText extends Entity {
       dxfCode: 46,
     });
 
-    // ensure points array has at least one point - the arc center
+    // ensure points array has at least one point - the arc centre
     if (!this.points.length) {
       this.points = [];
-      this.points.push(new Point(0, 0)); // center point
+      this.points.push(new Point(0, 0)); // centre point
     }
 
     // DXF Groupcode 50 - Start Angle in degrees
@@ -225,7 +225,7 @@ export class ArcAlignedText extends Entity {
       dxfCode: 71,
       options: () => [{ display: 'Outward', value: 1 }, { display: 'Inward', value: 2 }],
     });
-    // DXF Groupcode 72 - 1 = fit to arc, 2 = left align, 3 = right align, 4 = center
+    // DXF Groupcode 72 - 1 = fit to arc, 2 = left align, 3 = right align, 4 = centre
     this.properties.add(Property.Names.TEXTALIGNMENT, {
       type: Property.Type.LIST,
       value: Property.loadValue([data?.textAlignment, data?.[72]], 4),
@@ -302,7 +302,7 @@ export class ArcAlignedText extends Entity {
 
         const selection = await DesignCore.Scene.inputManager.requestInput(op);
         if (selection === undefined) return;
-        selectedArc = DesignCore.Scene.entities.get(selection.selectedItemIndex);
+        selectedArc = DesignCore.Scene.entities.get(selection.selectedEntityIndex);
 
         if (selectedArc instanceof Arc === false) {
           const msg = `${this.type} - ${Strings.Error.INVALIDTYPE}: ${selectedArc.type}`;
@@ -464,7 +464,7 @@ export class ArcAlignedText extends Entity {
 
     let string = str.slice(); // make a copy of the string
 
-    // 1 = fit to arc, 2 = left align, 3 = right align, 4 = center
+    // 1 = fit to arc, 2 = left align, 3 = right align, 4 = centre
     if (textAlignment === 3) { // right align
       // start at the arc start position and create the text cw around the arc
       stringStartPoint = this.points[0].project(this.startAngle() + startOffsetAngle, radialDistance);
@@ -492,8 +492,8 @@ export class ArcAlignedText extends Entity {
     // build per-character widths for the final (possibly reversed) string
     const charWidths = [...string].map((ch) => Text.getApproximateWidth(ch, height));
 
-    // build cumulative arc angle offsets from the string start position to each character center
-    // step between adjacent centers is the average of their two half-widths plus spacing
+    // build cumulative arc angle offsets from the string start position to each character centre
+    // step between adjacent centres is the average of their two half-widths plus spacing
     const charOffsetAngles = [0];
     if (textAlignment === 1) { // fit to arc
       if (string.length === 1) {
@@ -512,7 +512,7 @@ export class ArcAlignedText extends Entity {
         charOffsetAngles.push(charOffsetAngles[i] + this.linearToAngular(step * 0.5, radialDistance));
       }
 
-      if (textAlignment === 4) { // center
+      if (textAlignment === 4) { // centre
         const arcMidPoint = this.points[0].project(this.arcMidAngle(this.startAngle(), this.endAngle()), radialDistance);
         stringStartPoint = arcMidPoint.rotate(this.points[0], charOffsetAngles.at(-1) * 0.5);
       }
@@ -568,9 +568,9 @@ export class ArcAlignedText extends Entity {
     file.writeGroupCode('2', style?.font);
     file.writeGroupCode('3', '');
     file.writeGroupCode('7', this.getProperty(Property.Names.STYLENAME)); // Test style name
-    file.writeGroupCode('10', this.points[0].x); // x of arc center
-    file.writeGroupCode('20', this.points[0].y); // y of arc center
-    file.writeGroupCode('30', '0.0'); // z of arc center
+    file.writeGroupCode('10', this.points[0].x); // x of arc centre
+    file.writeGroupCode('20', this.points[0].y); // y of arc centre
+    file.writeGroupCode('30', '0.0'); // z of arc centre
     file.writeGroupCode('40', this.getProperty(Property.Names.RADIUS));
     file.writeGroupCode('41', this.getProperty(Property.Names.WIDTHFACTOR));
     file.writeGroupCode('42', this.getProperty(Property.Names.HEIGHT));
@@ -607,7 +607,7 @@ export class ArcAlignedText extends Entity {
   snaps(mousePoint, delta) {
     const snaps = [];
 
-    snaps.push(new SnapPoint(this.points[0], SnapPoint.Type.CENTRE)); // arc center
+    snaps.push(new SnapPoint(this.points[0], SnapPoint.Type.CENTRE)); // arc centre
 
     const ArcAlignedCharacters = this.getArcAlignedCharacters();
     for (const arcAlignedChar of ArcAlignedCharacters) {

package/core/entities/circle.js

@@ -35,7 +35,7 @@ export class Circle extends Entity {
       dxfCode: 40,
     });
 
-    // Named scalar radius (internal API / named prop) — projects points[1] from center.
+    // Named scalar radius (internal API / named prop) — projects points[1] from centre.
     // Full-points data (post-execute or post-fromDxf) skips this.
     if (data?.radius !== undefined && this.points.length < 2) {
       this.setRadius(data.radius);
@@ -61,11 +61,11 @@ export class Circle extends Entity {
    * @return {Object}
    */
   static fromDxf(data) {
-    const center = data.points?.[0];
-    if (!center || data[40] === undefined) return data;
+    const centre = data.points?.[0];
+    if (!centre || data[40] === undefined) return data;
     return {
       ...data,
-      points: [center, center.project(0, data[40])],
+      points: [centre, centre.project(0, data[40])],
     };
   }
 
@@ -205,9 +205,9 @@ export class Circle extends Entity {
    */
   fromPolylinePoints(points) {
     if (points.length >= 3 && points[0].isSame(points.at(-1))) {
-      const center = points[0].bulgeCentrePoint(points[1]);
-      const radius = center.distance(points[0]);
-      this.points = [center, center.project(0, radius)];
+      const centre = points[0].bulgeCentrePoint(points[1]);
+      const radius = centre.distance(points[0]);
+      this.points = [centre, centre.project(0, radius)];
       return this;
     }
     const arc = DesignCore.CommandManager.createNew('Arc', this);

package/core/entities/hatch.js

@@ -141,7 +141,7 @@ export class Hatch extends Entity {
       }
     }
 
-    const centerPoint = bb.centerPoint;
+    const centrePoint = bb.centrePoint;
     const bbXLength = bb.xLength;
     const bbYLength = bb.yLength;
     const s = this.getProperty(Property.Names.SCALE);
@@ -175,8 +175,8 @@ export class Hatch extends Entity {
 
       // World-space anchor for this family: bounding-box centre shifted by the
       // pattern line's origin offset (scaled to match the hatch scale).
-      const cx = centerPoint.x + patternLine.xOrigin * s;
-      const cy = centerPoint.y + patternLine.yOrigin * s;
+      const cx = centrePoint.x + patternLine.xOrigin * s;
+      const cy = centrePoint.y + patternLine.yOrigin * s;
 
       // Bounding-box half-extents in pattern-local (unscaled) space.
       const halfW = bbXLength / (2 * s);
@@ -390,13 +390,13 @@ export class Hatch extends Entity {
                 // 10 - X; 20 - Y;  40 - Radius;  50 - Start Angle;  51 - End Angle; 73 - Is Counter Clockwise
                 const shapeData = { points: [] };
 
-                const centerPoint = points.shift();
-                if (centerPoint.sequence !== undefined && centerPoint.sequence !== 10) {
+                const centrePoint = points.shift();
+                if (centrePoint.sequence !== undefined && centrePoint.sequence !== 10) {
                   const msg = 'Invalid point sequence';
                   const err = (`${this.type} - ${msg}`);
                   throw Error(err);
                 }
-                shapeData.points.push(centerPoint);
+                shapeData.points.push(centrePoint);
                 shapeData.radius = this.getDataValue(data, 40);
                 shapeData.startAngle = this.getDataValue(data, 50);
                 shapeData.endAngle = this.getDataValue(data, 51);
@@ -482,8 +482,8 @@ export class Hatch extends Entity {
         const result = await DesignCore.Scene.inputManager.requestInput(op);
         if (result === undefined) return;
 
-        const selectedItems = DesignCore.Scene.selectionManager.selectedItems.slice(0);
-        const boundary = this.processSelection(selectedItems);
+        const selectedEntities = DesignCore.Scene.selectionManager.selectedEntities.slice(0);
+        const boundary = this.processSelection(selectedEntities);
 
         if (boundary.length) {
           this.setProperty(Property.Names.CHILDENTITIES, boundary);
@@ -506,8 +506,8 @@ export class Hatch extends Entity {
    * Preview the entity during creation
    */
   preview() {
-    const selectedItems = DesignCore.Scene.selectionManager.selectedItems.slice(0);
-    const shapes = this.processSelection(selectedItems);
+    const selectedEntities = DesignCore.Scene.selectionManager.selectedEntities.slice(0);
+    const shapes = this.processSelection(selectedEntities);
     if (shapes.length) {
       DesignCore.Scene.previewEntities.create(this.type, { points: this.points, childEntities: shapes }); // childEntities is passed as plain data here, not via getProperty
     }
@@ -515,31 +515,31 @@ export class Hatch extends Entity {
 
   /**
    * Convert the selection to boundary items
-   * @param {Array} selectedItems
+   * @param {Array} selectedEntities
    * @return {Array} - Array of boundary items
    */
-  processSelection(selectedItems) {
+  processSelection(selectedEntities) {
     const selectedchildEntities = [];
 
     let iterationPoints = [];
 
     // track the last index count to make sure the loop is closed
-    let lastIndexCount = selectedItems.length + 1;
+    let lastIndexCount = selectedEntities.length + 1;
 
-    while (selectedItems.length) {
-      if (selectedItems.length === lastIndexCount) {
+    while (selectedEntities.length) {
+      if (selectedEntities.length === lastIndexCount) {
         return [];
       }
 
-      lastIndexCount = selectedItems.length;
+      lastIndexCount = selectedEntities.length;
 
-      for (let i = 0; i < selectedItems.length; i++) {
-        // no points collected - get the first index from selected items
+      for (let i = 0; i < selectedEntities.length; i++) {
+        // no points collected - get the first index from selected entities
 
-        const currentItem = selectedItems[i];
-        // if the item can't be converted to polyline points, remove from selected items and go again
+        const currentItem = selectedEntities[i];
+        // if the item can't be converted to polyline points, remove from selected entities and go again
         if (typeof currentItem.toPolylinePoints === 'undefined' || currentItem.type === 'Text' || currentItem.type === 'ArcAlignedText') {
-          selectedItems.splice(i, 1);
+          selectedEntities.splice(i, 1);
           break;
         }
 
@@ -575,8 +575,8 @@ export class Hatch extends Entity {
             iterationPoints.push(...currentPoints);
           }
 
-          // remove the index from selected items
-          selectedItems = selectedItems.filter((index) => index !== selectedItems[i]);
+          // remove the index from selected entities
+          selectedEntities = selectedEntities.filter((index) => index !== selectedEntities[i]);
 
           if (iterationPoints.at(0).isSame(iterationPoints.at(-1))) {
             const shape = new Polyline();
@@ -635,7 +635,7 @@ export class Hatch extends Entity {
     }
 
     // Draw the boundary outline when hovered or selected.
-    const isSelected = DesignCore.Scene.selectionManager.selectedItems.includes(this);
+    const isSelected = DesignCore.Scene.selectionManager.selectedEntities.includes(this);
     const isHovered = DesignCore.Scene.hoverEntities.indexOf(this) !== -1;
     if (isSelected || isHovered) {
       renderer.setDash([], 0);
@@ -774,7 +774,7 @@ export class Hatch extends Entity {
         const intersect = Intersection.intersectPolylinePolyline(polyline, line);
         const intersects = intersect.points.length;
         // P is inside shape if there is a odd number of intersects
-        if (Math.abs(intersects % 2) == 1) {
+        if (Math.abs(intersects % 2) === 1) {
           return true;
         }
       }
@@ -850,11 +850,11 @@ export class Hatch extends Entity {
         const theta = ang - this.points[0].angle(this.points.at(-1));
 
         if (theta !== 0) {
-          // set rotation center
-          const center = this.points[0];
+          // set rotation centre
+          const centre = this.points[0];
           // apply rotation to child entities points
           hatchChildren.forEach((child) => {
-            const rotatedPoints = child.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(center, theta));
+            const rotatedPoints = child.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(centre, theta));
             child.setProperty(Property.Names.POINTS, rotatedPoints);
           });