@design-core/core 0.0.7 → 50.1.0

package/core/lib/renderers/pdfRenderer.js

@@ -102,11 +102,11 @@ export class PdfRenderer extends RendererBase {
       if (!p.bulge) {
         this.#emit(`${this.#fmt(next.x)} ${this.#fmt(next.y)} l`);
       } else {
-        const center = p.bulgeCentrePoint(next);
+        const centre = p.bulgeCentrePoint(next);
         const radius = p.bulgeRadius(next);
-        const startAngle = center.angle(p);
+        const startAngle = centre.angle(p);
         const sweepAngle = p.bulgeAngle();
-        for (const curve of this.#arcToBezier(center, radius, startAngle, sweepAngle)) {
+        for (const curve of this.#arcToBezier(centre, radius, startAngle, sweepAngle)) {
           this.#emit(`${this.#fmt(curve.cp1x)} ${this.#fmt(curve.cp1y)} ${this.#fmt(curve.cp2x)} ${this.#fmt(curve.cp2y)} ${this.#fmt(curve.x)} ${this.#fmt(curve.y)} c`);
         }
       }
@@ -321,13 +321,13 @@ export class PdfRenderer extends RendererBase {
   /**
    * Approximate a circular arc as one or more PDF cubic Bezier curves.
    * Arcs larger than 90° are split into ≤90° segments for accuracy.
-   * @param {Point} center - arc centre
+   * @param {Point} centre - arc centre
    * @param {number} radius  - arc radius
    * @param {number} startAngle - angle from positive x-axis to arc start (radians)
    * @param {number} sweepAngle - signed sweep: positive = CCW, negative = CW (radians)
    * @return {Array<{cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number}>}
    */
-  #arcToBezier(center, radius, startAngle, sweepAngle) {
+  #arcToBezier(centre, radius, startAngle, sweepAngle) {
     // Number of ≤90° segments needed to keep Bezier error below ~0.03%
     const steps = Math.max(1, Math.ceil(Math.abs(sweepAngle) / (Math.PI / 2)));
     // Signed angle of each segment (negative for CW arcs)
@@ -340,8 +340,8 @@ export class PdfRenderer extends RendererBase {
       const a1 = startAngle + i * stepAngle;
       const a2 = a1 + stepAngle;
       // Points on the circle at the segment start and end angles
-      const p1 = center.project(a1, radius);
-      const p2 = center.project(a2, radius);
+      const p1 = centre.project(a1, radius);
+      const p2 = centre.project(a2, radius);
       // Control points are offset from p1/p2 along the tangent direction by radius*tangentScale.
       // Tangent at p1 (CCW) is a1 + π/2; tangent at p2 (CW, pointing back) is a2 - π/2.
       // tangentScale is signed, so CW arcs (negative sweepAngle) automatically reverse the offset.

package/core/lib/renderers/rendererBase.js

@@ -11,7 +11,7 @@
  * correction.
  *
  * Transform helpers (applyTransform, save, restore) are called by canvas.js
- * when processing container entities (Insert, BaseDimension) that return a
+ * when processing container entities (Insert, DimensionBase) that return a
  * child list from draw().
  */
 export class RendererBase {

package/core/lib/scene.js

@@ -75,7 +75,7 @@ export class Scene {
    * @param {number} index - integer of item to replace
    * @return {number} - index of created item
    */
-  addItem(type, data, index) {
+  addEntity(type, data, index) {
     // TODO: validate data is valid for type
     if (!data) {
       throw Error('Input data missing');

package/core/lib/selectionManager.js

@@ -13,7 +13,7 @@ export class SingleSelection {
    * @param {Point} point
    */
   constructor(index, point) {
-    this.selectedItemIndex = index;
+    this.selectedEntityIndex = index;
     this.selectedPoint = point;
   }
 }
@@ -41,24 +41,24 @@ export class SelectionSet {
 export class SelectionManager {
   /** Create a SelectionManager */
   constructor() {
-    this.selectionSet = new SelectionSet(); // store a list of selected items indices
-    this.selectedItems = []; // store a copy of selected items
+    this.selectionSet = new SelectionSet(); // store a list of selected entities indices
+    this.selectedEntities = []; // store a copy of selected entities
   }
 
   /**
    * Reset the selection state
    */
   reset() {
-    this.selectedItems = [];
+    this.selectedEntities = [];
     this.selectionSet = new SelectionSet();
     this.selectionSetChanged();
   }
 
   /**
-   * Remove the last selection from the selected items
+   * Remove the last selection from the selected entities
    */
   removeLastSelection() {
-    this.selectedItems.pop();
+    this.selectedEntities.pop();
     this.selectionSet.removeLastSelection();
     this.selectionSetChanged();
   }
@@ -157,19 +157,19 @@ export class SelectionManager {
   }
 
   /**
-  * Remove the item at index from the selectionSet and selectedItems
+  * Remove the item at index from the selectionSet and selectedEntities
   * @param  {number} index - index of the item
   */
   removeFromSelectionSet(index) {
     const itemIndex = this.selectionSet.selectionSet.indexOf(index);
     if (itemIndex !== -1) {
       this.selectionSet.selectionSet.splice(itemIndex, 1);
-      this.selectedItems.splice(itemIndex, 1);
+      this.selectedEntities.splice(itemIndex, 1);
     }
   }
 
   /**
-  * Add the item at index to the selectionSet and selectedItems
+  * Add the item at index to the selectionSet and selectedEntities
   * @param  {number} index
   */
   addToSelectionSet(index) {
@@ -179,28 +179,28 @@ export class SelectionManager {
     // only store selections once
     if (this.selectionSet.selectionSet.indexOf(index) === -1) {
       this.selectionSet.selectionSet.push(index);
-      this.addToSelectedItems(index);
+      this.addToSelectedEntities(index);
     }
   }
 
   /**
-   * Duplicate the item at index and add to selectedItems
+   * Duplicate the item at index and add to selectedEntities
    * @param  {number} index
    */
-  addToSelectedItems(index) {
-    const copyofitem = Utils.cloneObject(DesignCore.Scene.entities.get(index));
-    this.selectedItems.push(copyofitem);
+  addToSelectedEntities(index) {
+    const copyOfItem = Utils.cloneObject(DesignCore.Scene.entities.get(index));
+    this.selectedEntities.push(copyOfItem);
   }
 
   /**
-   * Reload the selectedItems
+   * Reload the selectedEntities
    * This is required following changes to selected item properties
    */
-  reloadSelectedItems() {
-    this.selectedItems = [];
+  reloadSelectedEntities() {
+    this.selectedEntities = [];
 
     for (let i = 0; i < this.selectionSet.selectionSet.length; i++) {
-      this.addToSelectedItems(this.selectionSet.selectionSet[i]);
+      this.addToSelectedEntities(this.selectionSet.selectionSet[i]);
     }
 
     DesignCore.Core.canvas.requestPaint();

package/core/lib/utils.js

@@ -47,26 +47,26 @@ export class Utils {
   }
 
   /**
-   * Sort points around an arc center by angular position.
+   * Sort points around an arc centre by angular position.
    * Mutates the points array.
    *
    * @param {Array} points - array of points
    * @param {Point} startPoint - arc start point
    * @param {Point} endPoint - arc end point
-   * @param {Point} centerPoint - arc center point
+   * @param {Point} centrePoint - arc centre point
    * @param {number} direction - arc direction (ccw >0, cw <=0)
    *
    */
-  static sortPointsOnArc(points, startPoint, endPoint, centerPoint, direction = 1) {
+  static sortPointsOnArc(points, startPoint, endPoint, centrePoint, direction = 1) {
     if (!Array.isArray(points)) return;
 
-    const refAngle = direction > 0 ? centerPoint.angle(startPoint) : centerPoint.angle(endPoint);
+    const refAngle = direction > 0 ? centrePoint.angle(startPoint) : centrePoint.angle(endPoint);
     const twoPi = Math.PI * 2;
     const normalize = (ang) => ((ang % twoPi) + twoPi) % twoPi;
 
     // map points to angles
     const mapped = points.map((point) => {
-      const angle = Math.atan2(point.y - centerPoint.y, point.x - centerPoint.x);
+      const angle = Math.atan2(point.y - centrePoint.y, point.x - centrePoint.x);
       const normalizedAngle = normalize(angle - refAngle);
       return { point, normalizedAngle };
     });

package/core/properties/property.js

@@ -78,7 +78,7 @@ export class Property {
     SCALE: 'scale',
     STRING: 'string',
     STYLENAME: 'styleName',
-    // ── BasePolyline ──────────────────────────────────────────────────────────
+    // ── PolylineBase ──────────────────────────────────────────────────────────
     CLOSED: 'closed',
     // ── Hatch ─────────────────────────────────────────────────────────────────
     CHILDENTITIES: 'childEntities',

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,14 +138,14 @@ 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);
@@ -153,23 +153,23 @@ export class PropertyManager {
 
   /**
    * 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;
       }
     }
 
@@ -259,13 +261,13 @@ export class Block extends Entity {
     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 +282,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) &&