@design-core/core 0.0.7 → 51.1.0

package/core/entities/hatch.js

@@ -19,6 +19,7 @@ import { Line } from './line.js';
 import { Arc } from './arc.js';
 import { Polyline } from './polyline.js';
 import { Property } from '../properties/property.js';
+import { PatternLine } from '../lib/patterns.js';
 
 /**
  * Hatch Entity Class
@@ -41,6 +42,14 @@ export class Hatch extends Entity {
       enumerable: false,
     });
 
+    // resolved PatternLine array — populated at construction from inline DXF
+    // data (type 0/2) or from the Patterns library (type 1)
+    Object.defineProperty(this, 'patternLines', {
+      value: [],
+      writable: true,
+      enumerable: false,
+    });
+
     // Boundary shapes stored in EntityProperties so all entity data lives in one place.
     this.properties.add(Property.Names.CHILDENTITIES, {
       type: Property.Type.ENTITIES,
@@ -53,14 +62,24 @@ export class Hatch extends Entity {
 
     const rawPatternName = String(Property.loadValue([data?.[2], data?.patternName], 'ANSI31')).toUpperCase();
     // DXF Groupcode 70 - Solid Fill Flag (1 = solid, 0 = pattern): if set, override pattern name
-    const resolvedPatternName = data?.[70] === 1 ? 'SOLID' : rawPatternName;
+    // DXF Groupcode 76 - Hatch pattern type: 0 = User-defined ('U'); 1 = Predefined; 2 = Custom
+    const patternType = data?.[76] ?? 1;
+    // User-defined hatches (76=0) are normalised to the sentinel name 'U'
+    // so the pattern type is implied by the name rather than stored separately.
+    const resolvedPatternName = data?.[70] === 1 ? 'SOLID' : patternType === 0 ? 'U' : rawPatternName;
+    if (patternType === 1 && resolvedPatternName !== 'SOLID' && !Patterns.patternExists(resolvedPatternName)) {
+      Logging.instance.warn(`Hatch: pattern '${resolvedPatternName}' not found`);
+    }
 
     // DXF Groupcode 2 - Hatch pattern name
     this.properties.add(Property.Names.PATTERNNAME, {
       type: Property.Type.LIST,
       value: resolvedPatternName,
       dxfCode: 2,
-      options: () => Object.keys(Patterns.hatch_patterns).map((name) => ({ display: name, value: name })),
+      options: () => [
+        { display: 'User Defined', value: 'U' },
+        ...Object.keys(Patterns.hatch_patterns).map((name) => ({ display: name, value: name })),
+      ],
     });
     // DXF Groupcode 41 - Hatch pattern scale
     this.properties.add(Property.Names.SCALE, {
@@ -74,6 +93,28 @@ export class Hatch extends Entity {
       value: Property.loadValue([data?.[52], data?.angle], 0),
       dxfCode: 52,
     });
+    // DXF Groupcode 47 - Line spacing (user-defined hatches only)
+    this.properties.add(Property.Names.HATCHSPACING, {
+      type: Property.Type.NUMBER,
+      value: Property.loadValue([data?.[47]], 1),
+      dxfCode: 47,
+      readOnly: (entity) => entity.getProperty(Property.Names.PATTERNNAME) !== 'U',
+    });
+    // DXF Groupcode 77 - Double flag (user-defined hatches only): 0 = not double; 1 = double
+    this.properties.add(Property.Names.HATCHDOUBLE, {
+      type: Property.Type.BOOLEAN,
+      value: (data?.[77] ?? 0) === 1,
+      dxfCode: 77,
+      readOnly: (entity) => entity.getProperty(Property.Names.PATTERNNAME) !== 'U',
+    });
+
+    // Populate patternLines: inline data for user-defined (76=0) and custom
+    // (76=2) patterns; Patterns library for predefined (76=1, default).
+    if ((patternType === 0 || patternType === 2) && data) {
+      this.patternLines = this.#buildInlinePatternLines(data);
+    } else if (resolvedPatternName !== 'SOLID' && Patterns.patternExists(resolvedPatternName)) {
+      this.patternLines = this._copyLibraryPattern(resolvedPatternName);
+    }
 
     // add a single point to this.points if no other points exist
     if (!this.points.length) {
@@ -103,6 +144,116 @@ export class Hatch extends Entity {
     }
   }
 
+  /**
+   * Return unfrozen copies of library PatternLine objects for a named pattern.
+   * Patterns.getPattern() returns frozen objects (shared cache); cloneObject()
+   * uses Reflect.ownKeys and would fail writing into frozen instances.
+   * @param {string} name - upper-case pattern name
+   * @return {Array<PatternLine>} array of mutable PatternLine copies
+   */
+  _copyLibraryPattern(name) {
+    return Patterns.getPattern(name).map((pl) => {
+      const copy = new PatternLine();
+      copy.angle = pl.angle;
+      copy.xOrigin = pl.xOrigin;
+      copy.yOrigin = pl.yOrigin;
+      copy.xDelta = pl.xDelta;
+      copy.yDelta = pl.yDelta;
+      copy.dashes = [...pl.dashes];
+      return copy;
+    });
+  }
+
+  /**
+   * Synthesise PatternLine objects for a user-defined hatch from line spacing.
+   * Used when the pattern name is 'U' and the pattern has no explicit family data.
+   * @param {number} spacing - perpendicular distance between parallel lines
+   * @param {boolean} isDouble - when true, add a second family at 90° to the first
+   * @return {Array<PatternLine>}
+   */
+  _buildSpacingPatternLines(spacing, isDouble) {
+    const pl = new PatternLine();
+    pl.angle = 0;
+    pl.xOrigin = 0;
+    pl.yOrigin = 0;
+    pl.xDelta = 0;
+    pl.yDelta = spacing;
+    pl.dashes = [];
+    const result = [pl];
+    if (isDouble) {
+      const pl2 = new PatternLine();
+      pl2.angle = 90;
+      pl2.xOrigin = 0;
+      pl2.yOrigin = 0;
+      pl2.xDelta = 0;
+      pl2.yDelta = spacing;
+      pl2.dashes = [];
+      result.push(pl2);
+    }
+    return result;
+  }
+
+  /**
+   * Build PatternLine objects from inline DXF pattern data (group code 76 = 0 or 2).
+   * DXF stores deltas pre-multiplied by scale; we divide by scale to recover the
+   * normalised (scale=1) values that buildPatternCache expects.
+   * @param {Object} data - raw DXF group-code data for the HATCH entity
+   * @return {Array<PatternLine>} array of PatternLine objects
+   */
+  #buildInlinePatternLines(data) {
+    const scale = data[41] ?? 1;
+    // DXF group code 53 per-family angles are written by AutoCAD as absolute
+    // angles that already include the entity rotation (group code 52). Subtract
+    // the entity angle here so that buildPatternCache's addition of ANGLE
+    // restores the correct absolute rotation without doubling it.
+    const entityAngle = data[52] ?? 0;
+    const angles = [].concat(data[53] ?? []);
+    const dxDeltas = [].concat(data[45] ?? []);
+    const dyDeltas = [].concat(data[46] ?? []);
+    const dashCounts = [].concat(data[79] ?? []);
+    const allDashes = [].concat(data[49] ?? []);
+
+    // Pure user-defined hatch (76=0): no inline family data — synthesise
+    // from group code 47 (line spacing) and 77 (double flag).
+    if (!angles.length) {
+      return this._buildSpacingPatternLines((data[47] ?? 1) / scale, data[77] === 1);
+    }
+
+    const patternLines = [];
+    let dashIdx = 0;
+
+    angles.forEach((angle, i) => {
+      const pl = new PatternLine();
+      pl.angle = angle - entityAngle;
+      pl.xOrigin = 0;
+      pl.yOrigin = 0;
+      // DXF deltas are already in drawing units, pre-multiplied by scale; divide out.
+      pl.xDelta = (dxDeltas[i] ?? 0) / scale;
+      pl.yDelta = (dyDeltas[i] ?? 0) / scale;
+
+      const count = dashCounts[i] ?? 0;
+      pl.dashes = allDashes.slice(dashIdx, dashIdx + count).map((d) => d / scale);
+      dashIdx += count;
+
+      patternLines.push(pl);
+    });
+
+    // DXF group code 77: double flag — add a perpendicular family
+    if (data[77] === 1 && patternLines.length > 0) {
+      const first = patternLines[0];
+      const pl = new PatternLine();
+      pl.angle = first.angle + 90;
+      pl.xOrigin = 0;
+      pl.yOrigin = 0;
+      pl.xDelta = first.xDelta;
+      pl.yDelta = first.yDelta;
+      pl.dashes = [...first.dashes];
+      patternLines.push(pl);
+    }
+
+    return patternLines;
+  }
+
   /**
    * Build and cache world-space line segments for the current pattern.
    * For pattern hatches, segments are pre-clipped against the boundary using
@@ -114,7 +265,7 @@ export class Hatch extends Entity {
       return;
     }
 
-    if (this.getProperty(Property.Names.PATTERNNAME) === 'SOLID' || !Patterns.patternExists(this.getProperty(Property.Names.PATTERNNAME))) {
+    if (!this.patternLines.length) {
       this.cachedPattern = [];
       return;
     }
@@ -141,13 +292,13 @@ 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);
     const lines = [];
 
-    const pattern = Patterns.getPattern(this.getProperty(Property.Names.PATTERNNAME));
+    const pattern = this.patternLines;
     pattern.forEach((patternLine) => {
       let dashLength = bbXLength / 2;
       if (patternLine.dashes.length) {
@@ -175,8 +326,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 +541,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 +633,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 +657,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 +666,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 +726,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();
@@ -613,7 +764,7 @@ export class Hatch extends Entity {
     // Build cache if stale (cachedPattern === null means never built or invalidated)
     if (this.cachedPattern === null) this.buildPatternCache();
 
-    if (this.getProperty(Property.Names.PATTERNNAME) === 'SOLID') {
+    if (this.cachedPattern.length === 0 && this.getProperty(Property.Names.PATTERNNAME) === 'SOLID') {
       // Design renders solid hatches with a direct fill() call rather than the
       // dense cross-hatch line pattern used by commercial CAD applications
       // (Commercial CAD's SOLID pattern uses two line families at 0.0001-unit spacing).
@@ -635,7 +786,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);
@@ -694,17 +845,20 @@ export class Hatch extends Entity {
       file.writeGroupCode('97', '0'); // Number of source boundary objects
     }
     file.writeGroupCode('75', '1'); // Hatch style: 0 = Hatch “odd parity” area (Normal style) 1 = Hatch outermost area only (Outer style) 2 = Hatch through entire area (Ignore style)
-    file.writeGroupCode('76', '1'); // Hatch pattern type: 0 = User-defined; 1 = Predefined; 2 = Custom
+    // Hatch pattern type: 0 = User-defined; 1 = Predefined; 2 = Custom
+    const patternName = this.getProperty(Property.Names.PATTERNNAME);
+    const isUserDefined = patternName === 'U';
+    const isLibraryPattern = !isUserDefined && patternName !== 'SOLID' && Patterns.patternExists(patternName);
+    file.writeGroupCode('76', isUserDefined ? '0' : isLibraryPattern ? '1' : '2');
 
-    if (this.getProperty(Property.Names.PATTERNNAME) !== 'SOLID') {
+    if (patternName !== 'SOLID') {
       file.writeGroupCode('52', this.getProperty(Property.Names.ANGLE)); // Hatch Pattern angle
       file.writeGroupCode('41', this.getProperty(Property.Names.SCALE)); // Hatch Pattern scale
-      file.writeGroupCode('77', '0'); // Hatch pattern double flag(pattern fill only): 0 = not double; 1 = double
-      file.writeGroupCode('78', Patterns.getPatternLineCount(this.getProperty(Property.Names.PATTERNNAME))); // Number of pattern definition lines
+      file.writeGroupCode('77', this.getProperty(Property.Names.HATCHDOUBLE) ? '1' : '0'); // Hatch pattern double flag(pattern fill only): 0 = not double; 1 = double
+      file.writeGroupCode('78', this.patternLines.length); // Number of pattern definition lines
 
       // Pattern data
-      const pattern = Patterns.getPattern(this.getProperty(Property.Names.PATTERNNAME));
-      pattern.forEach((patternLine) => {
+      this.patternLines.forEach((patternLine) => {
         file.writeGroupCode('53', patternLine.angle + this.getProperty(Property.Names.ANGLE)); // Pattern line angle
         file.writeGroupCode('43', patternLine.xOrigin); // Pattern line base X
         file.writeGroupCode('44', patternLine.yOrigin); // Pattern line base y
@@ -719,7 +873,7 @@ export class Hatch extends Entity {
       });
     }
 
-    file.writeGroupCode('47', '0.5'); // pixel size
+    file.writeGroupCode('47', isUserDefined ? this.getProperty(Property.Names.HATCHSPACING) : '0.5'); // line spacing (user-defined) / pixel size
     file.writeGroupCode('98', '1'); // Number of seed points
     // seed points
     file.writeGroupCode('10', '1');
@@ -774,7 +928,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;
         }
       }
@@ -842,6 +996,22 @@ export class Hatch extends Entity {
         const upper = String(value).toUpperCase();
         if (this.getProperty(Property.Names.PATTERNNAME) === upper) return;
         super.setProperty(property, upper);
+        if (upper === 'U') {
+          this.patternLines = this._buildSpacingPatternLines(
+              this.getProperty(Property.Names.HATCHSPACING),
+              this.getProperty(Property.Names.HATCHDOUBLE),
+          );
+        } else {
+          this.patternLines = (upper !== 'SOLID' && Patterns.patternExists(upper)) ? this._copyLibraryPattern(upper) : [];
+        }
+      } else if (property === Property.Names.HATCHSPACING || property === Property.Names.HATCHDOUBLE) {
+        super.setProperty(property, value);
+        if (this.getProperty(Property.Names.PATTERNNAME) === 'U') {
+          this.patternLines = this._buildSpacingPatternLines(
+              this.getProperty(Property.Names.HATCHSPACING),
+              this.getProperty(Property.Names.HATCHDOUBLE),
+          );
+        }
       } else if (property === Property.Names.POINTS) {
         // Special handling for hatch points to move child entities
         // Consider the changes from the hatch points to be an offset and rotation
@@ -850,11 +1020,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);
           });
 

package/core/entities/insert.js

@@ -51,7 +51,11 @@ export class Insert extends Entity {
       // DXF Groupcode 2 - Block name
       if (data.blockName !== undefined) {
         const block = DesignCore.Scene.blockManager.getItemByName(data.blockName);
-        this.block = block;
+        if (block) {
+          this.block = block;
+        } else {
+          Logging.instance.warn(`Insert: block '${data.blockName}' not found`);
+        }
       }
 
       // Named scalar rotation (internal API); DXF code 50 is handled by fromDxf
@@ -153,13 +157,13 @@ export class Insert 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) {
     // blocks are associated with an insert point.
-    // Apply the insert location and rotation so block items draw correctly.
+    // Apply the insert location and rotation so block entities draw correctly.
     renderer.applyTransform({ x: this.points[0].x, y: this.points[0].y, rotation: Utils.degrees2radians(this.getRotation()) });
-    return this.block.items;
+    return this.block.entities;
   }
 
   /**
@@ -204,9 +208,9 @@ export class Insert extends Entity {
 
     for (let snap = 0; snap < blockSnaps.length; snap++) {
       const sp = blockSnaps[snap];
-      // offset the item snap point by the block insert location
+      // offset the entity snap point by the block insert location
       const rotatedPoint = sp.snapPoint.add(this.points[0]);
-      // rotate the snap point to match the item positions
+      // rotate the snap point to match the entity positions
       const adjustedPoint = rotatedPoint.rotate(this.points[0], Utils.degrees2radians(this.getRotation()));
       snaps.push(new SnapPoint(adjustedPoint, sp.type));
     }
@@ -247,6 +251,7 @@ export class Insert extends Entity {
    */
   boundingBox() {
     const blockBB = this.block.boundingBox();
+    if (!blockBB) return new BoundingBox();
     const topLeft = blockBB.pt1.add(this.points[0]);
     const bottomRight = blockBB.pt2.add(this.points[0]);
     return new BoundingBox(topLeft, bottomRight);

package/core/entities/point.js

@@ -298,16 +298,16 @@ export class Point {
    * Find the closest point on a arc between start and end points
    * @param {Point} startPoint
    * @param {Point} endPoint
-   * @param {Point} centerPoint
+   * @param {Point} centrePoint
    * @param {number} direction - CCW if > 0
    * @return {Point} the closest point on the arc or null
    */
-  closestPointOnArc(startPoint, endPoint, centerPoint, direction = 0) {
-    const length = this.distance(centerPoint);
-    const radius = centerPoint.distance(startPoint);
+  closestPointOnArc(startPoint, endPoint, centrePoint, direction = 0) {
+    const length = this.distance(centrePoint);
+    const radius = centrePoint.distance(startPoint);
 
-    const Cx = centerPoint.x + radius * (this.x - centerPoint.x) / length;
-    const Cy = centerPoint.y + radius * (this.y - centerPoint.y) / length;
+    const Cx = centrePoint.x + radius * (this.x - centrePoint.x) / length;
+    const Cy = centrePoint.y + radius * (this.y - centrePoint.y) / length;
     const closest = new Point(Cx, Cy);
 
     // circle
@@ -315,7 +315,7 @@ export class Point {
       return closest;
     }
 
-    if (closest.isOnArc(startPoint, endPoint, centerPoint, direction)) {
+    if (closest.isOnArc(startPoint, endPoint, centrePoint, direction)) {
       return closest;
     }
 
@@ -327,15 +327,15 @@ export class Point {
    * Determine if point is on arc segment
    * @param {Point} startPoint
    * @param {Point} endPoint
-   * @param {Point} centerPoint
+   * @param {Point} centrePoint
    * @param {number} direction - CCW if > 0
    * @return {Point} true or false
    */
-  isOnArc(startPoint, endPoint, centerPoint, direction = 0) {
+  isOnArc(startPoint, endPoint, centrePoint, direction = 0) {
     // direction: ccw arc > 0, clockwise arc <= 0
-    const snapAngle = centerPoint.angle(this);
-    const startAngle = centerPoint.angle(startPoint);
-    const endAngle = centerPoint.angle(endPoint);
+    const snapAngle = centrePoint.angle(this);
+    const startAngle = centrePoint.angle(startPoint);
+    const endAngle = centrePoint.angle(endPoint);
 
     if (direction > 0) {
       // Counter Clockwise Arc
@@ -438,7 +438,7 @@ export class Point {
   }
 
   /**
-   * Returns apothem; the distance from arc center to cord midpoint
+   * Returns apothem; the distance from arc centre to cord midpoint
    * @param {Point} nextPoint
    * @return {number} apothem
    */
@@ -465,12 +465,12 @@ export class Point {
 
     let a = this.apothem(nextPoint);
 
-    // check if the center point is inverted. i.e. at 180 it goes inside the arc
+    // check if the centre point is inverted. i.e. at 180 it goes inside the arc
     if (Math.abs(this.bulgeAngle()) > Math.PI) {
       a = -a;
     }
 
-    // get the direction from the midpoint to the center point
+    // get the direction from the midpoint to the centre point
     const direction = this.angle(nextPoint) + (Math.PI / 2) * Math.sign(this.bulge);
     // centre point is the apothem distance from the mid point in the given direction
     const centre = midp.project(direction, a);
@@ -486,12 +486,12 @@ export class Point {
    * @return {number} - the partial bulge value
    */
   partialBulge(nextPoint, splitPoint, afterSplit = false) {
-    const center = this.bulgeCentrePoint(nextPoint);
+    const centre = this.bulgeCentrePoint(nextPoint);
     const direction = this.bulge > 0 ? 1 : -1;
 
-    const startAngle = center.angle(this);
-    const endAngle = center.angle(nextPoint);
-    const splitAngle = center.angle(splitPoint);
+    const startAngle = centre.angle(this);
+    const endAngle = centre.angle(nextPoint);
+    const splitAngle = centre.angle(splitPoint);
 
     let includedAngle;
     if (afterSplit) {

package/core/entities/polyline.js

@@ -1,12 +1,12 @@
 import { DXFFile } from '../lib/dxf/dxfFile.js';
-import { BasePolyline } from './basePolyline.js';
+import { PolylineBase } from './polylineBase.js';
 import { Point } from './point.js';
 
 /**
  * Polyline Entity Class
- * @extends BasePolyline
+ * @extends PolylineBase
  */
-export class Polyline extends BasePolyline {
+export class Polyline extends PolylineBase {
   static type = 'Polyline';
 
   /**

package/core/entities/{basePolyline.js → polylineBase.js}

@@ -20,8 +20,8 @@ import { RubberBand } from '../lib/auxiliary/rubberBand.js';
  * Base Polyline Entity Class
  * @extends Entity
  */
-export class BasePolyline extends Entity {
-  static type = 'BasePolyline';
+export class PolylineBase extends Entity {
+  static type = 'PolylineBase';
 
   /**
    * Create a Base Polyline
@@ -233,7 +233,7 @@ export class BasePolyline extends Entity {
   /**
    * Set entity points from a polyline point representation
    * @param {Array} points
-   * @return {BasePolyline}
+   * @return {PolylineBase}
    */
   fromPolylinePoints(points) {
     const pts = points.map((p) => new Point(p.x, p.y, p.bulge));
@@ -311,10 +311,10 @@ export class BasePolyline extends Entity {
       let closestPoint;
       let candidateSegment;
       if (A.bulge !== 0) {
-        const center = A.bulgeCentrePoint(B);
+        const centre = A.bulgeCentrePoint(B);
         const direction = A.bulge > 0 ? 1 : -1;
-        closestPoint = P.closestPointOnArc(A, B, center, direction);
-        candidateSegment = new Arc({ points: [center, A, B], direction });
+        closestPoint = P.closestPointOnArc(A, B, centre, direction);
+        candidateSegment = new Arc({ points: [centre, A, B], direction });
       } else {
         closestPoint = P.closestPointOnLine(A, B);
         candidateSegment = new Line({ points: [A, B] });
@@ -420,9 +420,9 @@ export class BasePolyline extends Entity {
    */
   isPointOnSegment(point, A, B) {
     if (A.bulge !== 0) {
-      const center = A.bulgeCentrePoint(B);
+      const centre = A.bulgeCentrePoint(B);
       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);
   }
@@ -438,9 +438,9 @@ export class BasePolyline extends Entity {
     const B = this.points[segmentIndex % this.points.length];
 
     if (A.bulge !== 0) {
-      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;
@@ -464,10 +464,10 @@ export class BasePolyline extends Entity {
     const B = this.points[segmentIndex % this.points.length];
 
     if (A.bulge !== 0) {
-      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);
     }
 
@@ -490,8 +490,8 @@ export class BasePolyline extends Entity {
       let boundingBox = BoundingBox.lineBoundingBox(this.points[i], nextPoint);
 
       if (this.points[i].bulge !== 0) {
-        const centerPoint = this.points[i].bulgeCentrePoint(nextPoint);
-        boundingBox = BoundingBox.arcBoundingBox(centerPoint, this.points[i], nextPoint, this.points[i].bulge);
+        const centrePoint = this.points[i].bulgeCentrePoint(nextPoint);
+        boundingBox = BoundingBox.arcBoundingBox(centrePoint, this.points[i], nextPoint, this.points[i].bulge);
       }
 
       xmin = Math.min(xmin, boundingBox.xMin);
@@ -519,9 +519,9 @@ export class BasePolyline extends Entity {
     // get the angle at the end of the previous segment
     let lastSegAngle;
     if (lastSegIsArc) {
-      const centerPoint = this.points.at(-2).bulgeCentrePoint(this.points.at(-1));
-      // angle is perpendicular to the center-to-end point ray, in the direction of the bulge
-      lastSegAngle = centerPoint.angle(this.points.at(-1)) + (Math.PI / 2) * Math.sign(lastSegBulge);
+      const centrePoint = this.points.at(-2).bulgeCentrePoint(this.points.at(-1));
+      // angle is perpendicular to the centre-to-end point ray, in the direction of the bulge
+      lastSegAngle = centrePoint.angle(this.points.at(-1)) + (Math.PI / 2) * Math.sign(lastSegBulge);
     } else {
       // line segment angle is the angle from point 0 to point 1
       lastSegAngle = this.points.at(-2).angle(this.points.at(-1));