@design-core/core 0.0.7 → 51.1.0

package/core/entities/text.js

@@ -83,7 +83,7 @@ export class Text extends Entity {
       type: Property.Type.LIST,
       value: hAlign > 2 ? 1 : hAlign,
       dxfCode: 72,
-      options: () => [{ display: 'Left', value: 0 }, { display: 'Center', value: 1 }, { display: 'Right', value: 2 }],
+      options: () => [{ display: 'Left', value: 0 }, { display: 'Centre', value: 1 }, { display: 'Right', value: 2 }],
     });
     // DXF Groupcode 73 - Vertical Alignment (0=Baseline; 1=Bottom; 2=Middle; 3=Top)
     this.properties.add(Property.Names.VERTICALALIGNMENT, {
@@ -354,13 +354,13 @@ export class Text extends Entity {
       case 0:
         return 'left';
       case 1:
-        return 'center';
+        return 'centre';
       case 2:
         return 'right';
       case 3:
         return (this.getProperty(Property.Names.VERTICALALIGNMENT) === 0 ? 'aligned' : 'left');
       case 4:
-        return (this.getProperty(Property.Names.VERTICALALIGNMENT) === 0 ? 'center' : 'left');
+        return (this.getProperty(Property.Names.VERTICALALIGNMENT) === 0 ? 'centre' : 'left');
       case 5:
         return (this.getProperty(Property.Names.VERTICALALIGNMENT) === 0 ? 'fit' : 'left');
       default:
@@ -539,7 +539,7 @@ export class Text extends Entity {
       case 0: // left
         offsetX = 0;
         break;
-      case 1: // center
+      case 1: // centre
         offsetX = -rect.width / 2;
         break;
       case 2: // right

package/core/lib/boundingBox.js

@@ -55,9 +55,9 @@ export class BoundingBox {
   }
 
   /**
-   * return bounding box center point
+   * return bounding box centre point
    */
-  get centerPoint() {
+  get centrePoint() {
     return new Point(this.xMin + this.xLength / 2, this.yMin + this.yLength / 2);
   }
 
@@ -136,16 +136,16 @@ export class BoundingBox {
 
   /**
    * Calculate the boundingbox for an arc
-   * @param {Point} centerPoint
+   * @param {Point} centrePoint
    * @param {Point} startPoint
    * @param {Point} endPoint
    * @param {number} direction - ccw > 0, cw < 0
    * @return {BoundingBox}
    */
-  static arcBoundingBox(centerPoint, startPoint, endPoint, direction = 1) {
-    const startAngle = centerPoint.angle(startPoint);
-    const endAngle = centerPoint.angle(endPoint);
-    const radius = centerPoint.distance(startPoint);
+  static arcBoundingBox(centrePoint, startPoint, endPoint, direction = 1) {
+    const startAngle = centrePoint.angle(startPoint);
+    const endAngle = centrePoint.angle(endPoint);
+    const radius = centrePoint.distance(startPoint);
 
     const cross0 = this.crossesAxis(startAngle, endAngle, 0, direction);
     const cross90 = this.crossesAxis(startAngle, endAngle, Math.PI * 0.5, direction);
@@ -154,10 +154,10 @@ export class BoundingBox {
 
     // if the arc crosses the axis the min or max is where the arc intersects the axis
     // otherwise max/min is the arc endpoint
-    const xmin = cross180 ? centerPoint.x - radius : Math.min(startPoint.x, endPoint.x);
-    const xmax = cross0 ? centerPoint.x + radius : Math.max(startPoint.x, endPoint.x);
-    const ymin = cross270 ? centerPoint.y - radius : Math.min(startPoint.y, endPoint.y);
-    const ymax = cross90 ? centerPoint.y + radius : Math.max(startPoint.y, endPoint.y);
+    const xmin = cross180 ? centrePoint.x - radius : Math.min(startPoint.x, endPoint.x);
+    const xmax = cross0 ? centrePoint.x + radius : Math.max(startPoint.x, endPoint.x);
+    const ymin = cross270 ? centrePoint.y - radius : Math.min(startPoint.y, endPoint.y);
+    const ymax = cross90 ? centrePoint.y + radius : Math.max(startPoint.y, endPoint.y);
 
     const topLeft = new Point(xmin, ymax);
     const bottomRight = new Point(xmax, ymin);

package/core/lib/canvas.js

@@ -189,7 +189,9 @@ export class Canvas {
    */
   wheel(delta) {
     if (DesignCore.Mouse.buttonTwoDown) return;
-    const scale = Math.pow(1 + Math.abs(delta), delta > 0 ? 1 : -1);
+    // Clamp to [-1, 1] so that high-resolution mice and track pads don't produce runaway jumps.
+    const clampedDelta = Math.max(-1, Math.min(1, delta));
+    const scale = Math.pow(1.2, clampedDelta);
     if (scale < 1 && this.getScale() > this.minScaleFactor || scale > 1 && this.getScale() < this.maxScaleFactor) {
       this.zoom(scale);
     }
@@ -220,16 +222,21 @@ export class Canvas {
     const width = xMax - xMin;
     const height = yMax - yMin;
 
-    if (width === 0 || height === 0) {
+    if (width === 0 && height === 0) {
       return;
     }
 
     const selectionCenter = new Point(xMin + width / 2, yMin + height / 2);
     const screenCenter = new Point(this.width / 2, this.height / 2);
     const translateDelta = DesignCore.Mouse.transformToScene(screenCenter).subtract(selectionCenter);
-    const targetScale = Math.min((this.width / width), (this.height / height));
+    // fall back to the non-zero axis when the window is a single line
+    const targetScale = width === 0 ? this.height / height :
+      height === 0 ? this.width / width :
+      Math.min((this.width / width), (this.height / height));
     const scaleDelta = targetScale / this.getScale() * 0.9;
 
+    if (!isFinite(scaleDelta) || scaleDelta <= 0) return;
+
     this.matrix.scale(scaleDelta, scaleDelta);
     this.matrix.translate((selectionCenter.x / scaleDelta) - selectionCenter.x, (selectionCenter.y / scaleDelta) - selectionCenter.y);
     this.matrix.translate(translateDelta.x / scaleDelta, translateDelta.y / scaleDelta);
@@ -386,8 +393,8 @@ export class Canvas {
     this.#paintEntities(DesignCore.Scene.previewEntities, renderer);
 
     // Paint the selected scene items: single pass — renderer handles glow + entity internally.
-    const selectedItems = DesignCore.Scene.selectionManager.selectedItems;
-    this.#paintEntities(selectedItems, renderer, { colour: selectionHaloColour, lineWidthDelta: selectionLineWidthDelta });
+    const selectedEntities = DesignCore.Scene.selectionManager.selectedEntities;
+    this.#paintEntities(selectedEntities, renderer, { colour: selectionHaloColour, lineWidthDelta: selectionLineWidthDelta });
 
     // Paint the auxiliary scene items
     // auxiliary items include things like the selection window, snap points etc
@@ -403,7 +410,7 @@ export class Canvas {
 
   /**
    * Recursively paint a single entity and any children it returns.
-   * Container entities (Insert, BaseDimension) return an array of child items from draw().
+   * Container entities (Insert, DimensionBase) return an array of child items from draw().
    * Leaf entities return undefined. Renderer state is saved/restored around each entity.
    * @param {Object} entity - entity to paint
    * @param {Object} renderer - renderer instance

package/core/lib/clipboard.js

@@ -69,7 +69,7 @@ export class Clipboard {
       return;
     }
 
-    // copy the item to avoid mutation of originals
+    // copy the entity to avoid mutation of originals
     this.#Entities = entities.map((entity) => Utils.cloneObject(entity));
     // set basepoint to bottom left of selection bounding box
     const bbox = BoundingBox.fromEntities(entities);
@@ -152,7 +152,7 @@ export class Clipboard {
     const clipboardData = { basePoint: undefined, Entities: undefined };
     const jsonEntities = [];
 
-    // convert each entity to a simple object - this allows non-enumberable properties (like points) to be copied
+    // convert each entity to a simple object - this allows non-enumerable properties (like points) to be copied
     for (const ent of this.#Entities) {
       const jsonEntity = this.#simplify(ent);
       jsonEntities.push(jsonEntity);

package/core/lib/dxf/dxf.js

@@ -311,14 +311,14 @@ export class DXF {
               DesignCore.HandleManager.checkHandle(itemHandle);
             }
 
-            if (block.hasOwnProperty('items') === false) {
-              block.items = [];
+            if (block.hasOwnProperty('entities') === false) {
+              block.entities = [];
             }
 
             // add the child to the block items
             // TODO: create a block instance and add the items.
             // check block is valid before adding to scene
-            block.items.push(item);
+            block.entities.push(item);
           }
         });
       }
@@ -347,7 +347,7 @@ export class DXF {
         entity.points = this.parsePoints(entity.points);
       }
 
-      this.addItem(entity);
+      this.addEntity(entity);
     });
 
     // ensure all layers, ltypes, styles, dimstyles exist
@@ -378,18 +378,18 @@ export class DXF {
   }
 
   /**
-   * Add Item
-   * @param {Object} item
+   * Add Entity
+   * @param {Object} entity
    */
-  addItem(item) {
-    if (item.hasOwnProperty('0') === false) {
+  addEntity(entity) {
+    if (entity.hasOwnProperty('0') === false) {
       return;
     }
 
-    const command = item[0];
+    const command = entity[0];
     if (DesignCore.CommandManager.isCommand(command)) {
-      const entity = DesignCore.CommandManager.createNew(command, item);
-      DesignCore.Scene.entities.add(entity);
+      const newEntity = DesignCore.CommandManager.createNew(command, entity);
+      DesignCore.Scene.entities.add(newEntity);
     } else {
       Logging.instance.warn(`${Strings.Message.UNKNOWNCOMMAND} ${command}`);
       this.unsupportedElements = true;

package/core/lib/dxf/dxfIterator.js

@@ -23,11 +23,11 @@ Example DXF Entity Pairs:
  value: 100.0       - y position
  */
 
-/** DXF Interator Class */
+/** DXF Iterator Class */
 export class DxfIterator {
   static _instance;
 
-  /** Create DXFInterator */
+  /** Create DXFIterator */
   constructor() {
     this.currentIndex = 0;
     this.lines = [];

package/core/lib/entityManager.js

@@ -92,26 +92,26 @@ export class EntityManager {
   }
 
   /**
-   * Find items in scene
+   * Find entities  in scene
    * @param {string} type - entity type or "ANY"
    * @param {string} prop - object of entity parameters
    * @param {any} value - value of the property
-   * @return {number} - index of items
+   * @return {number} - index of entities
    */
   find(type, prop, value) {
-    const filteredItems = [];
+    const filteredEntities = [];
 
-    this.#entities.forEach((item, index) => {
-      if (type.toUpperCase() === 'ANY' || item.type.toUpperCase() === type.toUpperCase()) {
-        const inStore = item.properties?.has(prop);
-        const propValue = inStore ? item.getProperty(prop) : (Object.prototype.hasOwnProperty.call(item, prop) ? item[prop] : undefined);
+    this.#entities.forEach((entity, index) => {
+      if (type.toUpperCase() === 'ANY' || entity.type.toUpperCase() === type.toUpperCase()) {
+        const inStore = entity.properties?.has(prop);
+        const propValue = inStore ? entity.getProperty(prop) : (Object.prototype.hasOwnProperty.call(entity, prop) ? entity[prop] : undefined);
         if (propValue !== undefined && propValue === value) {
-          filteredItems.push(index);
+          filteredEntities.push(index);
         }
       }
     });
 
-    return filteredItems;
+    return filteredEntities;
   }
 
   /** Get index of entity
@@ -124,16 +124,16 @@ export class EntityManager {
 
 
   /**
-   * Find closest item to point
+   * Find closest entity to point
    * @param  {Point} point
-   * @return {number} - return index of closest item or undefined
+   * @return {number} - return index of closest entity or undefined
    */
   findClosest(point) {
     let delta = 1.65 / DesignCore.Core.canvas.getScale(); // find a more suitable starting value
-    let closestItemIndex;
+    let closestEntityIndex;
 
     for (let i = 0; i < this.#entities.length; i++) {
-      // check the items layer is selectable - i.e. on, thawed, etc...
+      // check the entities  layer is selectable - i.e. on, thawed, etc...
       const layer = DesignCore.LayerManager.getItemByName(this.#entities[i].getProperty(Property.Names.LAYER));
 
       if (!layer?.isSelectable) {
@@ -144,11 +144,11 @@ export class EntityManager {
 
       if (distance < delta) {
         delta = distance;
-        closestItemIndex = i;
+        closestEntityIndex = i;
       }
     }
 
-    return closestItemIndex;
+    return closestEntityIndex;
   }
 
   /**
@@ -157,14 +157,14 @@ export class EntityManager {
    * @param {object} data
    */
   update(index, data) {
-    const item = this.get(index);
+    const entity = this.get(index);
 
-    if (!item) {
-      throw Error('Item not found in scene');
+    if (!entity) {
+      throw Error('Entity not found in scene');
     }
 
     for (const property of Object.keys(data)) {
-      item.setProperty(property, data[property]);
+      entity.setProperty(property, data[property]);
     }
   }
 

package/core/lib/inputManager.js

@@ -392,7 +392,7 @@ export class InputManager {
     }
 
     if (Input.getType(selection) === Input.Type.SINGLESELECTION) {
-      DesignCore.Scene.selectionManager.addToSelectionSet(selection.selectedItemIndex);
+      DesignCore.Scene.selectionManager.addToSelectionSet(selection.selectedEntityIndex);
     }
   }
 

package/core/lib/matrix.js

@@ -37,7 +37,7 @@ export class Matrix {
   };
 
   /**
-   * Apply tranlation to matrix
+   * Apply translation to matrix
    * @param {number} x - translation in x
    * @param {number} y - translation in y
    */

package/core/lib/patterns.js

@@ -462,7 +462,7 @@ export class Patterns {
 60, 0, 0, 4.7625, 2.749630645, -6.35, 3.175` },
 
     'HOUND': {
-      description: 'Houndstooth check', pattern:
+      description: 'Hounds tooth check', pattern:
                 `0, 0, 0, 6.35, 1.5875, 25.4, -12.7
 90, 0, 0, 6.35, 1.5875, 25.4, -12.7` },
 

package/core/lib/polylineUtils.js

@@ -16,12 +16,12 @@ export class PolylineUtils {
    */
   static isPointOnSegment(point, A, B) {
     if (A.bulge !== 0 && A.bulge !== undefined) {
-      const center = A.bulgeCentrePoint(B);
-      const radius = center.distance(A);
+      const centre = A.bulgeCentrePoint(B);
+      const radius = centre.distance(A);
       // Point must lie on the circle before checking the angular range.
-      if (Utils.round(center.distance(point)) !== Utils.round(radius)) return false;
+      if (Utils.round(centre.distance(point)) !== Utils.round(radius)) return false;
       const direction = A.bulge > 0 ? 1 : -1;
-      return point.isOnArc(A, B, center, direction);
+      return point.isOnArc(A, B, centre, direction);
     }
     return point.isOnLine(A, B);
   }
@@ -38,9 +38,9 @@ export class PolylineUtils {
     const B = points[segmentIndex % points.length];
 
     if (A.bulge !== 0 && A.bulge !== undefined) {
-      const center = A.bulgeCentrePoint(B);
+      const centre = A.bulgeCentrePoint(B);
       const direction = A.bulge > 0 ? 1 : -1;
-      const closest = point.closestPointOnArc(A, B, center, direction);
+      const closest = point.closestPointOnArc(A, B, centre, direction);
       if (closest) return closest;
       // Point not on arc — return the nearer endpoint
       return point.distance(A) < point.distance(B) ? A : B;
@@ -63,10 +63,10 @@ export class PolylineUtils {
     const B = points[segmentIndex % points.length];
 
     if (A.bulge !== 0 && A.bulge !== undefined) {
-      const center = A.bulgeCentrePoint(B);
+      const centre = A.bulgeCentrePoint(B);
       const direction = A.bulge > 0 ? 1 : -1;
-      const startAngle = center.angle(A);
-      const pointAngle = center.angle(point);
+      const startAngle = centre.angle(A);
+      const pointAngle = centre.angle(point);
       return ((pointAngle - startAngle) * direction + 4 * Math.PI) % (2 * Math.PI);
     }
 

package/core/lib/renderers/cairoRenderer.js

@@ -159,14 +159,14 @@ export class CairoRenderer extends RendererBase {
       if (!p.bulge) {
         this.#cr.lineTo(next.x, next.y);
       } else {
-        const center = p.bulgeCentrePoint(next);
+        const centre = p.bulgeCentrePoint(next);
         const radius = p.bulgeRadius(next);
-        const startAngle = center.angle(p);
-        const endAngle = center.angle(next);
+        const startAngle = centre.angle(p);
+        const endAngle = centre.angle(next);
         if (p.bulge > 0) {
-          this.#cr.arc(center.x, center.y, radius, startAngle, endAngle);
+          this.#cr.arc(centre.x, centre.y, radius, startAngle, endAngle);
         } else {
-          this.#cr.arcNegative(center.x, center.y, radius, startAngle, endAngle);
+          this.#cr.arcNegative(centre.x, centre.y, radius, startAngle, endAngle);
         }
       }
     }

package/core/lib/renderers/canvasRenderer.js

@@ -141,12 +141,12 @@ export class CanvasRenderer extends RendererBase {
       if (!p.bulge) {
         this.#ctx.lineTo(next.x, next.y);
       } else {
-        const center = p.bulgeCentrePoint(next);
+        const centre = p.bulgeCentrePoint(next);
         const radius = p.bulgeRadius(next);
-        const startAngle = center.angle(p);
-        const endAngle = center.angle(next);
+        const startAngle = centre.angle(p);
+        const endAngle = centre.angle(next);
         // Canvas arc: CCW = false (default), CW = true (anticlockwise flag inverted)
-        this.#ctx.arc(center.x, center.y, radius, startAngle, endAngle, p.bulge < 0);
+        this.#ctx.arc(centre.x, centre.y, radius, startAngle, endAngle, p.bulge < 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/entityProperties.js

@@ -58,7 +58,8 @@ export class EntityProperties {
   set(name, value, entity) {
     const prop = this._store[name];
     if (!prop) return;
-    if (prop.readOnly) return;
+    const isReadOnly = typeof prop.readOnly === 'function' ? prop.readOnly(entity) : prop.readOnly;
+    if (isReadOnly) return;
     if (prop.set) {
       prop.set(entity, value);
     } else {

package/core/properties/flags.js

@@ -28,6 +28,18 @@ export class Flags {
     return this.flags;
   }
 
+  /**
+   * Serialise as a plain number so JSON.stringify produces e.g. `"flags":1`
+   * instead of `"flags":{"flags":1}`. Without this, the round-trip through
+   * clipboard stringify/parse loses the flag value (e.g. the closed flag on a
+   * polyline), because the reconstructed plain object is not a Flags instance
+   * and Property.loadValue cannot extract the numeric value from it.
+   * @return {number}
+   */
+  toJSON() {
+    return this.flags;
+  }
+
   /**
    * Get the backwards value
    * @param {number} flagValue