@design-core/core 0.0.7 → 51.1.0

package/core/properties/property.js

@@ -29,9 +29,12 @@ export class Property {
     return this._value;
   }
 
-  /** @param {any} val - new value; ignored when readOnly */
+  /** @param {any} val - new value; ignored when readOnly is true.
+   * Callable readOnly is evaluated by the caller (entityProperties.set) with
+   * the entity in scope; treat it as writable here to avoid stale closure issues. */
   set value(val) {
-    if (!this.readOnly) {
+    const isReadOnly = typeof this.readOnly === 'function' ? false : this.readOnly;
+    if (!isReadOnly) {
       this._value = val;
     }
   }
@@ -78,11 +81,13 @@ export class Property {
     SCALE: 'scale',
     STRING: 'string',
     STYLENAME: 'styleName',
-    // ── BasePolyline ──────────────────────────────────────────────────────────
+    // ── PolylineBase ──────────────────────────────────────────────────────────
     CLOSED: 'closed',
     // ── Hatch ─────────────────────────────────────────────────────────────────
     CHILDENTITIES: 'childEntities',
     PATTERNNAME: 'patternName',
+    HATCHSPACING: 'hatchSpacing',
+    HATCHDOUBLE: 'hatchDouble',
     // ── Text ──────────────────────────────────────────────────────────────────
     BACKWARDS: 'backwards',
     HORIZONTALALIGNMENT: 'horizontalAlignment',

package/core/properties/propertyManager.js

@@ -28,81 +28,81 @@ export class PropertyManager {
   }
 
   /**
-   * Set item properties
+   * Set entity properties
    * @param {string} property
    * @param {any} newPropertyValue
-   * @param {string} itemType
+   * @param {string} entityType
    */
-  setItemProperties(property, newPropertyValue, itemType='All') {
+  setEntityProperties(property, newPropertyValue, entityType='All') {
     const stateChanges = [];
     for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
       const index = DesignCore.Scene.selectionManager.selectionSet.selectionSet[i];
 
-      const item = DesignCore.Scene.entities.get(index);
+      const entity = DesignCore.Scene.entities.get(index);
 
-      // check if the item is of the selected type
-      if (itemType !== 'All' && item.type !== itemType) {
+      // check if the entity is of the selected type
+      if (entityType !== 'All' && entity.type !== entityType) {
         continue;
       }
 
-      // check if the item has the selected property
-      if (!item.properties?.has(property)) {
+      // check if the entity has the selected property
+      if (!entity.properties?.has(property)) {
         continue;
       }
 
-      const currentValue = item.getProperty(property);
+      const currentValue = entity.getProperty(property);
 
       if (typeof (currentValue) !== typeof (newPropertyValue)) {
         DesignCore.Core.notify(Strings.Error.INPUT);
       } else {
-        // update the item property
+        // update the entity property
         const update = {};
         update[property] = newPropertyValue;
-        const stateChange = new UpdateState(item, update);
+        const stateChange = new UpdateState(entity, update);
         stateChanges.push(stateChange);
       }
     }
     DesignCore.Scene.commit(stateChanges);
-    DesignCore.Scene.selectionManager.reloadSelectedItems();
+    DesignCore.Scene.selectionManager.reloadSelectedEntities();
   }
 
   /**
    * Get the types of items selected
    * @return {Array}
    */
-  getItemTypes() {
-    // Loop through the items and get a list of item types.
-    const itemTypes = [];
+  getEntityTypes() {
+    // Loop through the items and get a list of entity types.
+    const entityTypes = [];
 
     if (DesignCore.Scene.selectionManager.selectionSet.selectionSet.length > 0) {
       for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-        const item = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]);
-        const itemType = item.type;
+        const entity = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]);
+        const entityType = entity.type;
 
-        if (itemTypes.indexOf(itemType, 0) === -1) {
-          itemTypes.push(itemType);
+        if (entityTypes.indexOf(entityType, 0) === -1) {
+          entityTypes.push(entityType);
         }
       }
 
       // if there is more that one type add an option for all
-      if (itemTypes.length > 1) {
-        itemTypes.unshift('All');
+      if (entityTypes.length > 1) {
+        entityTypes.unshift('All');
       }
     }
 
-    return itemTypes;
+    return entityTypes;
   }
 
   /**
-   * Get a list of common propertie
-   * @param {string} itemType
+   * Get a list of common properties
+   * @param {string} entityType
    * @return {Array}
    */
-  getItemProperties(itemType) {
+  getEntityProperties(entityType) {
     // Loop through the items and get a list of common properties.
 
-    // check for valid itemType and selectionSet
-    if (itemType === undefined || itemType === null || DesignCore.Scene.selectionManager.selectionSet.selectionSet.length <= 0) {
+    // check for valid entityType and selectionSet
+    if (entityType === undefined || entityType === null || DesignCore.Scene.selectionManager.selectionSet.selectionSet.length <= 0) {
       return;
     }
 
@@ -114,8 +114,8 @@ export class PropertyManager {
     });
 
     // get a subset of the selectionSet
-    if (itemType !== 'All') {
-      subset = subset.filter((el) => el.type === itemType);
+    if (entityType !== 'All') {
+      subset = subset.filter((el) => el.type === entityType);
     }
 
     const propertiesList = [];
@@ -138,38 +138,53 @@ export class PropertyManager {
 
   /**
    * Get the Property descriptor for a named property from a representative selected entity.
-   * @param {string} itemType
+   * @param {string} entityType
    * @param {string} property
    * @return {Property|undefined}
    */
-  getItemPropertyDefinition(itemType, property) {
+  getEntityPropertyDefinition(entityType, property) {
     const index = DesignCore.Scene.selectionManager.selectionSet.selectionSet.find((i) => {
-      const item = DesignCore.Scene.entities.get(i);
-      return (itemType === 'All' || item.type === itemType) && item.properties?.has(property);
+      const entity = DesignCore.Scene.entities.get(i);
+      return (entityType === 'All' || entity.type === entityType) && entity.properties?.has(property);
     });
     if (index === undefined) return undefined;
     return DesignCore.Scene.entities.get(index).properties.definition(property);
   }
 
+  /**
+   * Get the representative entity for a named property from the selection set.
+   * Used alongside getEntityPropertyDefinition when readOnly callbacks need an entity.
+   * @param {string} entityType
+   * @param {string} property
+   * @return {Object|undefined}
+   */
+  getEntityForProperty(entityType, property) {
+    const index = DesignCore.Scene.selectionManager.selectionSet.selectionSet.find((i) => {
+      const entity = DesignCore.Scene.entities.get(i);
+      return (entityType === 'All' || entity.type === entityType) && entity.properties?.has(property);
+    });
+    return index !== undefined ? DesignCore.Scene.entities.get(index) : undefined;
+  }
+
   /**
    * Get a list the property values
-   * @param {string} itemType
+   * @param {string} entityType
    * @param {string} property
    * @return {Array}
    */
-  getItemPropertyValue(itemType, property) {
+  getEntityPropertyValue(entityType, property) {
     // Loop through the items and get a list the property values
     const propertiesValueList = [];
     if (DesignCore.Scene.selectionManager.selectionSet.selectionSet.length > 0) {
       for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-        if (DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]).type === itemType || itemType === 'All') {
+        if (DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]).type === entityType || entityType === 'All') {
           const entity = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]);
           propertiesValueList.push(entity.getProperty(property));
         }
       }
     }
 
-    // Check if every item in the selection set has the same value for the property
+    // Check if every entity in the selection set has the same value for the property
     if (propertiesValueList.every((prop) => {
       return prop === propertiesValueList[0];
     })) {

package/core/tables/block.js

@@ -8,9 +8,11 @@ import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Flags } from '../properties/flags.js';
 import { Property } from '../properties/property.js';
 import { AddState, RemoveState } from '../lib/stateManager.js';
+import { Logging } from '../lib/logging.js';
+import { Utils } from '../lib/utils.js';
 
 import { DesignCore } from '../designCore.js';
-import { Utils } from '../lib/utils.js';
+
 
 /**
  * Block Entity Class
@@ -36,7 +38,7 @@ export class Block extends Entity {
       writable: true,
     });
 
-    Object.defineProperty(this, 'items', {
+    Object.defineProperty(this, 'entities', {
       value: [],
       writable: true,
     });
@@ -47,8 +49,8 @@ export class Block extends Entity {
         this.name = data.name || data[2];
       }
 
-      if (data.hasOwnProperty('items')) {
-        this.items = data.items;
+      if (data.hasOwnProperty('entities')) {
+        this.entities = data.entities;
       }
 
       if (data.hasOwnProperty('flags') || data.hasOwnProperty('70')) {
@@ -114,21 +116,21 @@ export class Block extends Entity {
       // array to hold state changes
       const stateChanges = [];
 
-      // move selected items from scene to block
+      // move selected entities from scene to block
       selections.forEach((index) => {
-        const item = DesignCore.Scene.entities.get(index);
-        // remove item from scene
-        const copyofitem = Utils.cloneObject(item);
-        // assign a fresh handle — the block item is a new entity distinct from the scene entity
-        copyofitem.setProperty('handle', DesignCore.HandleManager.next());
-        // adjust the items points to reflect the insert point
+        const entity = DesignCore.Scene.entities.get(index);
+        // remove entity from scene
+        const copyOfEntity = Utils.cloneObject(entity);
+        // assign a fresh handle — the block entity is a new entity distinct from the scene entity
+        copyOfEntity.setProperty('handle', DesignCore.HandleManager.next());
+        // adjust the entity's points to reflect the insert point
         const delta = new Point(-insertPoint.x, -insertPoint.y);
-        if (item.hasOwnProperty('points')) {
-          const points = copyofitem.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).add(delta));
-          copyofitem.setProperty('points', points);
+        if (copyOfEntity.points?.length) {
+          const points = copyOfEntity.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).add(delta));
+          copyOfEntity.setProperty('points', points);
         }
-        block.items.push(copyofitem);
-        const stateChangeRemove = new RemoveState(item);
+        block.entities.push(copyOfEntity);
+        const stateChangeRemove = new RemoveState(entity);
         stateChanges.push(stateChangeRemove);
       });
 
@@ -175,8 +177,8 @@ export class Block extends Entity {
     file.writeGroupCode('3', this.name); // Name again
     file.writeGroupCode('1', '');
 
-    for (let i = 0; i < this.items.length; i++) {
-      this.items[i].dxf(file);
+    for (let i = 0; i < this.entities.length; i++) {
+      this.entities[i].dxf(file);
     }
 
     const endblk = new EndBlock({ handle: this.endblkHandle });
@@ -184,18 +186,18 @@ export class Block extends Entity {
   }
 
   /**
-   * Clear items from the block
+   * Clear entities from the block
    */
-  clearItems() {
-    this.items = [];
+  clearEntities() {
+    this.entities = [];
   }
 
   /**
-   * Add an item to the block
-   * @param {Object} item
+   * Add an entity to the block
+   * @param {Object} entity
    */
-  addItem(item) {
-    this.items.push(item);
+  addEntity(entity) {
+    this.entities.push(entity);
   }
 
   /**
@@ -207,15 +209,15 @@ export class Block extends Entity {
   snaps(mousePoint, delta) {
     const snaps = [];
 
-    if (!this.items.length) {
+    if (!this.entities.length) {
       // nothing to draw
       return snaps;
     }
 
-    for (let item = 0; item < this.items.length; item++) {
-      // collect the child item snaps
-      const itemSnaps = this.items[item].snaps(mousePoint, delta);
-      snaps.push(...itemSnaps);
+    for (let entity = 0; entity < this.entities.length; entity++) {
+      // collect the child entity snaps
+      const entitySnaps = this.entities[entity].snaps(mousePoint, delta);
+      snaps.push(...entitySnaps);
     }
 
     return snaps;
@@ -230,19 +232,19 @@ export class Block extends Entity {
     let distance = Infinity;
     let minPnt = P;
 
-    if (!this.items.length) {
+    if (!this.entities.length) {
       // nothing to draw
       return [minPnt, distance];
     }
 
-    for (let idx = 0; idx < this.items.length; idx++) {
-      const itemClosestPoint = this.items[idx].closestPoint(P);
-      const itemPnt = itemClosestPoint[0];
-      const itemDist = itemClosestPoint[1];
+    for (let idx = 0; idx < this.entities.length; idx++) {
+      const entityClosestPoint = this.entities[idx].closestPoint(P);
+      const entityPnt = entityClosestPoint[0];
+      const entityDist = entityClosestPoint[1];
 
-      if (itemDist < distance) {
-        distance = itemDist;
-        minPnt = itemPnt;
+      if (entityDist < distance) {
+        distance = entityDist;
+        minPnt = entityPnt;
       }
     }
 
@@ -254,18 +256,20 @@ export class Block extends Entity {
    * @return {BoundingBox}
    */
   boundingBox() {
+    if (!this.entities.length) return null;
+
     let xmin = Infinity;
     let xmax = -Infinity;
     let ymin = Infinity;
     let ymax = -Infinity;
 
-    for (let idx = 0; idx < this.items.length; idx++) {
-      const itemBoundingBox = this.items[idx].boundingBox();
+    for (let idx = 0; idx < this.entities.length; idx++) {
+      const entityBoundingBox = this.entities[idx].boundingBox();
 
-      xmin = Math.min(xmin, itemBoundingBox.xMin);
-      xmax = Math.max(xmax, itemBoundingBox.xMax);
-      ymin = Math.min(ymin, itemBoundingBox.yMin);
-      ymax = Math.max(ymax, itemBoundingBox.yMax);
+      xmin = Math.min(xmin, entityBoundingBox.xMin);
+      xmax = Math.max(xmax, entityBoundingBox.xMax);
+      ymin = Math.min(ymin, entityBoundingBox.yMin);
+      ymax = Math.max(ymax, entityBoundingBox.yMax);
     }
 
     const topLeft = new Point(xmin, ymax);
@@ -280,8 +284,8 @@ export class Block extends Entity {
    * @return {boolean} true if touched
    */
   touched(selection) {
-    for (let idx = 0; idx < this.items.length; idx++) {
-      const touched = this.items[idx].touched(selection);
+    for (let idx = 0; idx < this.entities.length; idx++) {
+      const touched = this.entities[idx].touched(selection);
       if (touched) {
         return true;
       }

package/core/tables/dimStyle.js

@@ -321,11 +321,11 @@ export class DimStyle {
     this.DIMTMOVE = Property.loadValue([data.DIMTMOVE, data[279]], 0);
 
     // DXF Groupcode 280 - Horizontal dimension text position:
-    // 0 = Above dimension line and center-justified between extension lines
+    // 0 = Above dimension line and centre-justified between extension lines
     // 1 = Above dimension line and next to first extension line
     // 2 = Above dimension line and next to second extension line
-    // 3 = Above and center-justified to first extension line
-    // 4 = Above and center-justified to second extension line
+    // 3 = Above and centre-justified to first extension line
+    // 4 = Above and centre-justified to second extension line
     this.DIMJUST = Property.loadValue([data.DIMJUST, data[280]], 0);
 
     // DXF Groupcode 281 - Suppression of first extension line:
@@ -506,7 +506,7 @@ export class DimStyle {
   }
 
   /**
-   * get the DIMCEN property for the center mark size
+   * get the DIMCEN property for the centre mark size
    * @return {Number} DIMCEN value
    * This uses two internal values to define the DIMCEN property
    * DIMCENSTYL & DIMCENVALUE
@@ -604,7 +604,7 @@ export class DimStyle {
     file.writeGroupCode('275', this.DIMAUNIT, DXFFile.Version.R13);
     file.writeGroupCode('276', this.DIMFRAC, DXFFile.Version.R2000);
     file.writeGroupCode('277', this.DIMLUNIT, DXFFile.Version.R2000);
-    // file.writeGroupCode('278', this.DIMDSEP, DXFFile.Version.R14)); - TODO: AutoCAD uses a numberical description
+    // file.writeGroupCode('278', this.DIMDSEP, DXFFile.Version.R14)); - TODO: AutoCAD uses a numerical description
     file.writeGroupCode('279', this.DIMTMOVE, DXFFile.Version.R2000);
     file.writeGroupCode('280', this.DIMJUST, DXFFile.Version.R13);
     file.writeGroupCode('281', this.DIMSD1 ? 1 : 0, DXFFile.Version.R13); // convert bool to int

package/core/tables/ltypeManager.js

@@ -48,7 +48,7 @@ export class LTypeManager extends StyleManagerBase {
    */
   dxf(file) {
     // Create table data for ltype styles
-    // The LTYPE Table must preceed the LAYER table
+    // The LTYPE Table must precede the LAYER table
     file.writeGroupCode('0', 'TABLE');
     file.writeGroupCode('2', 'LTYPE');
     file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);

package/core/tables/vport.js

@@ -12,9 +12,9 @@ export class VPort {
     this.handle = Property.loadValue([data?.handle, data?.[5]]);
     // DXF Groupcode 2 - Name
     this.name = Property.loadValue([data?.name, data?.[2]], '*ACTIVE');
-    // DXF Groupcode 12 - View center X
+    // DXF Groupcode 12 - View centre X
     this.viewCenterX = Property.loadValue([data?.viewCenterX, data?.[12]], 0);
-    // DXF Groupcode 22 - View center Y
+    // DXF Groupcode 22 - View centre Y
     this.viewCenterY = Property.loadValue([data?.viewCenterY, data?.[22]], 0);
     // DXF Groupcode 40 - VPort height
     this.height = Property.loadValue([data?.height, data?.[40]], 0);

package/core/tools/chamfer.js

@@ -6,7 +6,7 @@ import { Logging } from '../lib/logging.js';
 import { Utils } from '../lib/utils.js';
 import { Point } from '../entities/point.js';
 import { Line } from '../entities/line.js';
-import { BasePolyline } from '../entities/basePolyline.js';
+import { PolylineBase } from '../entities/polylineBase.js';
 import { AddState } from '../lib/stateManager.js';
 import { Colour } from '../lib/colour.js';
 
@@ -98,9 +98,9 @@ export class Chamfer extends ChamferFilletBase {
         }
 
         // input1 is a selection — validate and store first entity
-        const firstEntity = DesignCore.Scene.entities.get(input1.selectedItemIndex);
+        const firstEntity = DesignCore.Scene.entities.get(input1.selectedEntityIndex);
         DesignCore.Scene.selectionManager.removeLastSelection();
-        if (!(firstEntity instanceof Line) && !(firstEntity instanceof BasePolyline)) {
+        if (!(firstEntity instanceof Line) && !(firstEntity instanceof PolylineBase)) {
           DesignCore.Core.notify(`${firstEntity.type} - ${Strings.Message.NOCHAMFER}`);
           continue;
         }
@@ -112,16 +112,16 @@ export class Chamfer extends ChamferFilletBase {
           const input2 = await DesignCore.Scene.inputManager.requestInput(op2);
           if (input2 === undefined) return;
 
-          const candidate = DesignCore.Scene.entities.get(input2.selectedItemIndex);
+          const candidate = DesignCore.Scene.entities.get(input2.selectedEntityIndex);
           DesignCore.Scene.selectionManager.removeLastSelection();
-          if (!(candidate instanceof Line) && !(candidate instanceof BasePolyline)) {
+          if (!(candidate instanceof Line) && !(candidate instanceof PolylineBase)) {
             DesignCore.Core.notify(`${this.type} - ${candidate.type} ${Strings.Message.NOCHAMFER}`);
             continue;
           }
           if (!this.secondPick.setPick(candidate, input2.selectedPoint, `${Strings.Strings.ARC} - ${Strings.Message.NOCHAMFER}`)) continue;
           // If both selections are the same polyline, segments must be consecutive
           // or they must be the open-end segments of an open polyline.
-          if (candidate === firstEntity && firstEntity instanceof BasePolyline) {
+          if (candidate === firstEntity && firstEntity instanceof PolylineBase) {
             const isConsecutive = firstEntity.areConsecutiveSegments(this.firstPick.segmentIndex, this.secondPick.segmentIndex);
             const lastIdx = firstEntity.points.length - 1;
             const isOpenEnds = !firstEntity.flags.hasFlag(1) &&

package/core/tools/chamferFilletBase.js

@@ -2,7 +2,7 @@ import { Tool } from './tool.js';
 import { Strings } from '../lib/strings.js';
 import { Constants } from '../lib/constants.js';
 import { Line } from '../entities/line.js';
-import { BasePolyline } from '../entities/basePolyline.js';
+import { PolylineBase } from '../entities/polylineBase.js';
 import { AddState, RemoveState, UpdateState } from '../lib/stateManager.js';
 import { CornerEntity } from './cornerEntity.js';
 import { Intersection } from '../lib/intersect.js';
@@ -104,7 +104,7 @@ export class ChamferFilletBase extends Tool {
     if (index === undefined) return null;
 
     const candidate = DesignCore.Scene.entities.get(index);
-    if (!(candidate instanceof Line) && !(candidate instanceof BasePolyline)) return null;
+    if (!(candidate instanceof Line) && !(candidate instanceof PolylineBase)) return null;
 
     const tempSecond = new CornerEntity();
     if (!tempSecond.setPick(candidate, mousePoint, '')) return null;
@@ -143,8 +143,8 @@ export class ChamferFilletBase extends Tool {
    */
   applyCornerTrim(firstCornerPoint, secondCornerPoint, newEntity) {
     const isSharpTrim = newEntity === null;
-    const firstIsPolyline = this.firstPick.entity instanceof BasePolyline;
-    const secondIsPolyline = this.secondPick.entity instanceof BasePolyline;
+    const firstIsPolyline = this.firstPick.entity instanceof PolylineBase;
+    const secondIsPolyline = this.secondPick.entity instanceof PolylineBase;
 
     // Two standalone entities: update both, optionally add the new entity.
     if (!firstIsPolyline && !secondIsPolyline) {

package/core/tools/copy.js

@@ -84,10 +84,10 @@ export class Copy extends Tool {
       const delta = mousePoint.subtract(this.lastMousePoint || this.points[0]);
       this.lastMousePoint = mousePoint;
 
-      for (let i = 0; i < DesignCore.Scene.selectionManager.selectedItems.length; i++) {
-        const item = DesignCore.Scene.selectionManager.selectedItems[i];
-        const offsetPoints = item.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).add(delta));
-        item.setProperty('points', offsetPoints);
+      for (let i = 0; i < DesignCore.Scene.selectionManager.selectedEntities.length; i++) {
+        const entity = DesignCore.Scene.selectionManager.selectedEntities[i];
+        const offsetPoints = entity.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).add(delta));
+        entity.setProperty('points', offsetPoints);
       }
     }
   }
@@ -103,10 +103,10 @@ export class Copy extends Tool {
     const stateChanges = [];
 
     for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-      const copyofitem = Utils.cloneObject(DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]));
-      const offsetPoints = copyofitem.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).add(delta));
-      copyofitem.setProperty('points', offsetPoints);
-      const stateChange = new AddState(copyofitem);
+      const copyOfEntity = Utils.cloneObject(DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]));
+      const offsetPoints = copyOfEntity.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).add(delta));
+      copyOfEntity.setProperty('points', offsetPoints);
+      const stateChange = new AddState(copyOfEntity);
       stateChanges.push(stateChange);
     }
 

package/core/tools/copybase.js

@@ -56,11 +56,11 @@ export class Copybase extends Tool {
    * Perform the command
    */
   action() {
-    // generate clipboard data from selected items
-    const selectedItems = DesignCore.Scene.selectionManager.selectedItems;
+    // generate clipboard data from selected entities
+    const selectedEntities = DesignCore.Scene.selectionManager.selectedEntities;
 
     // create clipboard data
-    DesignCore.Clipboard.Entities = selectedItems;
+    DesignCore.Clipboard.Entities = selectedEntities;
     // set base point
     DesignCore.Clipboard.BasePoint = this.points[0];
   }

package/core/tools/copyclip.js

@@ -52,10 +52,10 @@ export class Copyclip extends Tool {
    * Perform the command
    */
   action() {
-    // generate clipboard data from selected items
-    const selectedItems = DesignCore.Scene.selectionManager.selectedItems;
+    // generate clipboard data from selected entities
+    const selectedEntities = DesignCore.Scene.selectionManager.selectedEntities;
 
     // create clipboard data
-    DesignCore.Clipboard.Entities = selectedItems;
+    DesignCore.Clipboard.Entities = selectedEntities;
   }
 }

package/core/tools/cornerEntity.js

@@ -1,5 +1,5 @@
 import { Line } from '../entities/line.js';
-import { BasePolyline } from '../entities/basePolyline.js';
+import { PolylineBase } from '../entities/polylineBase.js';
 
 import { DesignCore } from '../designCore.js';
 
@@ -61,7 +61,7 @@ export class CornerEntity {
   setPick(entity, clickPoint, arcSegmentErrorMsg) {
     this.entity = entity;
     this.clickPoint = clickPoint;
-    if (!(this.entity instanceof BasePolyline)) {
+    if (!(this.entity instanceof PolylineBase)) {
       this.segment = null;
       this.segmentIndex = null;
       return true;

package/core/tools/cutclip.js

@@ -53,11 +53,11 @@ export class Cutclip extends Tool {
    * Perform the command
    */
   action() {
-    // generate clipboard data from selected items
-    const selectedItems = DesignCore.Scene.selectionManager.selectedItems;
+    // generate clipboard data from selected entities
+    const selectedEntities = DesignCore.Scene.selectionManager.selectedEntities;
 
     // create clipboard data
-    DesignCore.Clipboard.Entities = selectedItems;
+    DesignCore.Clipboard.Entities = selectedEntities;
     // get a copy of the selection set
     const selections = DesignCore.Scene.selectionManager.selectionSet.selectionSet.slice();
     // create state changes for each of the selections

package/core/tools/explode.js

@@ -83,23 +83,23 @@ export class Explode extends Tool {
 
       // check the insert has a block and
       // check the block has items
-      if (insert.block === undefined || insert.block.items.length == 0) {
+      if (insert.block === undefined || insert.block.entities.length === 0) {
         counter++;
         continue;
       }
 
       const insertPoint = insert.points[0];
       const block = insert.block;
-      const blockItems = block.items;
+      const blockItems = block.entities;
 
       const rotation = Utils.degrees2radians(insert.getProperty('rotation'));
       const origin = new Point(0, 0);
 
       blockItems.forEach((blockItem) => {
-        const copyofitem = Utils.cloneObject(blockItem);
-        const points = copyofitem.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(origin, rotation).add(insertPoint));
-        copyofitem.points = points;
-        const stateChange = new AddState(copyofitem);
+        const copyOfItem = Utils.cloneObject(blockItem);
+        const points = copyOfItem.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(origin, rotation).add(insertPoint));
+        copyOfItem.points = points;
+        const stateChange = new AddState(copyOfItem);
         stateChanges.push(stateChange);
       });