@design-core/core 0.0.6 → 50.1.0

package/core/entities/insert.js

@@ -5,11 +5,11 @@ import { Block } from '../tables/block.js';
 import { BoundingBox } from '../lib/boundingBox.js';
 import { Point } from './point.js';
 import { Utils } from '../lib/utils.js';
-import { Property } from '../properties/property.js';
 import { Logging } from '../lib/logging.js';
+import { Property } from '../properties/property.js';
 
 import { DesignCore } from '../designCore.js';
-import { SnapPoint } from '../lib/snapping.js';
+import { SnapPoint } from '../lib/auxiliary/snapPoint.js';
 
 
 /**
@@ -34,59 +34,29 @@ export class Insert extends Entity {
       writable: true,
     });
 
-    // add rotation property with getter and setter
-    // needs to be enumerable to appear in the object props
-    Object.defineProperty(this, 'rotation', {
-      get: this.getRotation,
-      set: this.setRotation,
-      enumerable: true,
+    this.properties.add(Property.Names.ROTATION, {
+      type: Property.Type.NUMBER,
+      dxfCode: 50,
+      get: (entity) => entity.getRotation(),
+      set: (entity, value) => entity.setRotation(value),
     });
 
-    if (data) {
-      if (data.hasOwnProperty('blockName') || data.hasOwnProperty('2')) {
-        // DXF Groupcode 2 - Block name
+    this.properties.add(Property.Names.BLOCKNAME, {
+      type: Property.Type.LABEL,
+      readOnly: true,
+      get: (entity) => entity.block?.name ?? '',
+    });
 
-        const blockName = data.blockName || data[2];
-        const block = DesignCore.Scene.blockManager.getItemByName(blockName);
+    if (data) {
+      // DXF Groupcode 2 - Block name
+      if (data.blockName !== undefined) {
+        const block = DesignCore.Scene.blockManager.getItemByName(data.blockName);
         this.block = block;
       }
 
-      if (data.hasOwnProperty('41')) {
-        // DXF Groupcode 41 - X Scale Factor (optional, default = 1)
-        const err = 'Groupcode 41 not implemented';
-        Logging.instance.warn(`${this.type} - ${err}`);
-      }
-
-      if (data.hasOwnProperty('42')) {
-        // DXF Groupcode 42 - Y Scale Factor (optional, default = 1)
-        const err = 'Groupcode 42 not implemented';
-        Logging.instance.warn(`${this.type} - ${err}`);
-      }
-
-      if (data.hasOwnProperty('43')) {
-        // DXF Groupcode 43 - Z Scale Factor (optional, default = 1)
-        const err = 'Groupcode 43 not implemented';
-        Logging.instance.warn(`${this.type} - ${err}`);
-      }
-
-      if (data.hasOwnProperty('44')) {
-        // DXF Groupcode 44 - Column Spacing (optional, default = 0)
-        const err = 'Groupcode 44 not implemented';
-        Logging.instance.warn(`${this.type} - ${err}`);
-      }
-
-      if (data.hasOwnProperty('45')) {
-        // DXF Groupcode 45 - Row Spacing (optional, default = 0)
-        const err = 'Groupcode 45 not implemented';
-        Logging.instance.warn(`${this.type} - ${err}`);
-      }
-
-      if (data.hasOwnProperty('rotation') || data.hasOwnProperty('50')) {
-        // DXF Groupcode 50 - Text Rotation, angle in degrees
-        // if we get rotation data store this as a point[1] at an angle from point[0]
-        // this allows all the entities to be rotated by rotating the points i.e. not all entities have a rotation property
-
-        this.setRotation(Property.loadValue([data.rotation, data[50]], 0));
+      // Named scalar rotation (internal API); DXF code 50 is handled by fromDxf
+      if (data.rotation !== undefined) {
+        this.setRotation(data.rotation);
       } else {
         // create points[1] used to determine the rotation
         if (this.points[0] === undefined) {
@@ -95,18 +65,6 @@ export class Insert extends Entity {
 
         this.points[1] = this.points[0].add(new Point(10, 0));
       }
-
-      if (data.hasOwnProperty('70')) {
-        // DXF Groupcode 70 - Column Count (optional, default = 1)
-        const err = 'Groupcode 70 not implemented';
-        Logging.instance.warn(`${this.type} - ${err}`);
-      }
-
-      if (data.hasOwnProperty('71')) {
-        // DXF Groupcode 71 - Row Count(optional, default = 1)
-        const err = 'Groupcode 71 not implemented';
-        Logging.instance.warn(`${this.type} - ${err}`);
-      }
     }
   }
 
@@ -122,6 +80,40 @@ export class Insert extends Entity {
     return command;
   }
 
+  /**
+   * Normalise raw DXF data before construction
+   * @param {Object} data - raw DXF group code object
+   * @return {Object} normalised data with blockName and rotation encoded as points[1]
+   *
+   * Handles:
+   * - Group code 2: block name
+   * - Group code 50: rotation angle (degrees) encoded into points[1]
+   * - Group codes 41–45, 70, 71: unimplemented — logged as warnings
+   */
+  static fromDxf(data) {
+    const normalised = { ...data };
+
+    // DXF group code 2 - Block name
+    if (data[2] !== undefined) {
+      normalised.blockName = data[2];
+    }
+
+    // DXF group code 50 - rotation angle in degrees; encode into points
+    if (data[50] !== undefined) {
+      normalised.rotation = data[50];
+    }
+
+    // Unimplemented group codes
+    const unimplemented = { 41: 'X Scale Factor', 42: 'Y Scale Factor', 43: 'Z Scale Factor', 44: 'Column Spacing', 45: 'Row Spacing', 70: 'Column Count', 71: 'Row Count' };
+    for (const [code, label] of Object.entries(unimplemented)) {
+      if (data[code] !== undefined) {
+        Logging.instance.warn(`Insert - Groupcode ${code} (${label}) not implemented`);
+      }
+    }
+
+    return normalised;
+  }
+
   /**
    * Execute method
    * executes the workflow, requesting input required to create an entity
@@ -144,37 +136,30 @@ export class Insert extends Entity {
    */
   dxf(file) {
     file.writeGroupCode('0', 'INSERT');
-    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('5', this.getProperty(Property.Names.HANDLE), DXFFile.Version.R2000); // Handle
     file.writeGroupCode('100', 'AcDbEntity', DXFFile.Version.R2000);
-    file.writeGroupCode('8', this.layer);
+    file.writeGroupCode('8', this.getProperty(Property.Names.LAYER));
     this.writeDxfColour(file);
     file.writeGroupCode('100', 'AcDbBlockReference', DXFFile.Version.R2000);
     file.writeGroupCode('2', this.block.name);
     file.writeGroupCode('10', this.points[0].x);
     file.writeGroupCode('20', this.points[0].y);
     file.writeGroupCode('30', '0.0');
-    if (this.rotation) {
-      file.writeGroupCode('50', this.rotation);
+    if (this.getProperty(Property.Names.ROTATION)) {
+      file.writeGroupCode('50', this.getProperty(Property.Names.ROTATION));
     }
   }
 
   /**
    * Draw the entity
-   * @param {Object} ctx - context
-   * @param {number} scale
+   * @param {Object} renderer
+   * @return {Array} block entities for the canvas to render recursively
    */
-  draw(ctx, scale) {
+  draw(renderer) {
     // blocks are associated with an insert point.
-    // translate ctx by the insert location
-    // this allows the block items to be draw without knowing the insert location
-
-    ctx.save();
-    ctx.translate(this.points[0].x, this.points[0].y);
-    const rotation = Utils.degrees2radians(this.rotation);
-    ctx.rotate(rotation);
-    // pass *this* to the block to allow colour ByBlock
-    this.block.draw(ctx, scale, this);
-    ctx.restore();
+    // 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.entities;
   }
 
   /**
@@ -219,10 +204,10 @@ 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
-      const adjustedPoint = rotatedPoint.rotate(this.points[0], Utils.degrees2radians(this.rotation));
+      // 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));
     }
 
@@ -250,7 +235,7 @@ export class Insert extends Entity {
   closestPoint(P) {
     // get the closest point from the blocks entities
     // rotate P to match the block rotation
-    const rotatedPoint = P.rotate(this.points[0], Utils.degrees2radians(-this.rotation));
+    const rotatedPoint = P.rotate(this.points[0], Utils.degrees2radians(-this.getRotation()));
     // adjust P by the insert position
     const adjustedPoint = rotatedPoint.subtract(this.points[0]);
     return this.block.closestPoint(adjustedPoint);
@@ -273,7 +258,7 @@ export class Insert extends Entity {
    * @return {boolean} true if touched
    */
   touched(selection) {
-    const layer = DesignCore.LayerManager.getItemByName(this.layer);
+    const layer = DesignCore.LayerManager.getItemByName(this.getProperty(Property.Names.LAYER));
 
     if (!layer?.isSelectable) {
       return;

package/core/entities/line.js

@@ -5,11 +5,11 @@ import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
 import { DXFFile } from '../lib/dxf/dxfFile.js';
 import { BoundingBox } from '../lib/boundingBox.js';
-import { AddState, RemoveState, UpdateState } from '../lib/stateManager.js';
+import { Property } from '../properties/property.js';
 
 import { DesignCore } from '../designCore.js';
-import { Utils } from '../lib/utils.js';
-import { SnapPoint } from '../lib/snapping.js';
+
+import { SnapPoint } from '../lib/auxiliary/snapPoint.js';
 
 
 /**
@@ -70,13 +70,18 @@ export class Line extends Entity {
         if (pt2 === undefined) break;
 
         if (Input.getType(pt2) === Input.Type.STRING && pt2 === 'Close') {
-          this.points.push(pt1);
-          DesignCore.Scene.inputManager.executeCommand(this);
+          // Commit a 2-point segment from the last accumulated point back to pt1
+          const segment = new Line({ points: [this.points.at(-1), pt1] });
+          DesignCore.Scene.inputManager.executeCommand(segment);
           return;
         }
 
+        // Commit a fresh 2-point segment; keep this.points as the accumulator
+        // so preview() always draws from the last confirmed point to the mouse.
+        const segStart = this.points.at(-1);
         this.points.push(pt2);
-        DesignCore.Scene.inputManager.actionCommand(this);
+        const segment = new Line({ points: [segStart, pt2] });
+        DesignCore.Scene.inputManager.actionCommand(segment);
       }
     } catch (err) {
       Logging.instance.error(`${this.type} - ${err}`);
@@ -90,19 +95,16 @@ export class Line extends Entity {
     if (this.points.length >= 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
       const points = [this.points.at(-1), mousePoint];
-      DesignCore.Scene.tempEntities.create(this.type, { points: points });
+      DesignCore.Scene.previewEntities.create(this.type, { points: points });
     }
   }
 
   /**
    * Draw the entity
-   * @param {Object} ctx - context
-   * @param {number} scale
+   * @param {Object} renderer
    */
-  draw(ctx, scale) {
-    ctx.moveTo(this.points[0].x, this.points[0].y);
-    ctx.lineTo(this.points[1].x, this.points[1].y);
-    ctx.stroke();
+  draw(renderer) {
+    renderer.drawShape(this.toPolylinePoints());
   }
 
   /**
@@ -111,18 +113,18 @@ export class Line extends Entity {
    */
   dxf(file) {
     file.writeGroupCode('0', 'LINE');
-    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('5', this.getProperty(Property.Names.HANDLE), DXFFile.Version.R2000); // Handle
     file.writeGroupCode('100', 'AcDbEntity', DXFFile.Version.R2000);
     file.writeGroupCode('100', 'AcDbLine', DXFFile.Version.R2000);
-    file.writeGroupCode('8', this.layer);
-    file.writeGroupCode('6', this.lineType);
+    file.writeGroupCode('8', this.getProperty(Property.Names.LAYER));
+    file.writeGroupCode('6', this.getProperty(Property.Names.LINETYPE));
     file.writeGroupCode('10', this.points[0].x);
     file.writeGroupCode('20', this.points[0].y);
     file.writeGroupCode('30', '0.0');
     file.writeGroupCode('11', this.points[1].x);
     file.writeGroupCode('21', this.points[1].y);
     file.writeGroupCode('31', '0.0');
-    file.writeGroupCode('39', this.lineWidth);
+    file.writeGroupCode('39', this.getProperty(Property.Names.LINEWIDTH));
   }
 
   /**
@@ -136,134 +138,11 @@ export class Line extends Entity {
   /**
    * Set entity points from a polyline point representation
    * @param {Array} points
+   * @return {Line}
    */
   fromPolylinePoints(points) {
     this.points = [new Point(points[0].x, points[0].y), new Point(points[1].x, points[1].y)];
-  }
-
-  /**
-   * Trim the entity
-   * @param {Array} intersections
-   * @return {Array} - array of state changes
-   */
-  trim(intersections) {
-    // array to hold state changes
-    const stateChanges = [];
-
-    if (intersections?.length === 0 || !intersections) {
-      return stateChanges;
-    }
-
-    // get the mouse position
-    const mousePosition = DesignCore.Mouse.pointOnScene();
-    // get the point on the line closest to the mouse
-    const pointOnLine = mousePosition.closestPointOnLine(this.points[0], this.points[1]);
-    // remove any intersections that are at the end points of the line
-    intersections = intersections.filter((p) => !p.isSame(this.points[0]) && !p.isSame(this.points[1]));
-
-    Utils.sortPointsByDistance(intersections, this.points[0]);
-
-    // Add line points to the start and the end of the point array
-    const testPoints = [this.points[0], ...intersections, this.points[1]];
-
-    // Test if mouse position is between two intersection points
-    if (testPoints.length > 1) {
-      for (let i = 0; i < testPoints.length - 1; i++) {
-        const startPoint = testPoints[i];
-        const endPoint = testPoints[i + 1];
-
-        // check if the mouse is between startPoint and endPoint
-        if (pointOnLine.isOnLine(startPoint, endPoint)) {
-          const newPoints = [];
-
-          for (const p of testPoints) {
-            const inOriginalLine = this.points.indexOf(p) !== -1;
-            const inIntersections = intersections.indexOf(p) !== -1;
-
-            // Keep points which:
-            // - The mouse is between are intersections
-            // - The mouse is not between and in this line
-            const isBetween = p.isSame(startPoint) || p.isSame(endPoint);
-            if ((isBetween && inIntersections) || (!isBetween && inOriginalLine)) {
-              newPoints.push(p);
-            }
-          }
-
-          if (newPoints.length % 2 === 0) {
-            // Add lines for each point pair
-            for (let j = 0; j < newPoints.length; j += 2) {
-              const line = Utils.cloneObject(this);
-              line.points = [newPoints[j], newPoints[j + 1]];
-              const addState = new AddState(line);
-              stateChanges.push(addState);
-            }
-          }
-          // Remove the existing line
-          const removeState = new RemoveState(this);
-          stateChanges.push(removeState);
-        }
-      }
-    }
-
-    return stateChanges;
-  }
-
-  /**
-   * Extend the entity
-   * @param {Array} intersections
-   * @return {Array} - array of state changes
-   */
-  extend(intersections) {
-    // array to hold state changes
-    const stateChanges = [];
-
-    if (intersections?.length === 0 || !intersections) {
-      return stateChanges;
-    }
-
-    let originPoint;
-    // Find which end is closer to the mouse
-    if (this.points[0].distance(DesignCore.Mouse.pointOnScene()) < this.points[1].distance(DesignCore.Mouse.pointOnScene())) {
-      originPoint = 0;
-    } else {
-      originPoint = 1;
-    }
-
-    Utils.sortPointsByDistance(intersections, this.points[originPoint]);
-
-    const endPoint = this.points[originPoint];
-    const adjacentPoint = this.points[1 - originPoint];
-
-    // Find the closest intersection that lies beyond the endpoint
-    const direction = endPoint.subtract(adjacentPoint);
-    const newEndPoint = intersections.find((p) => {
-      if (p.isSame(endPoint)) return false;
-      if (p.subtract(endPoint).dot(direction) <= 0) return false;
-      if (adjacentPoint.distance(p) <= adjacentPoint.distance(endPoint)) return false;
-      return true;
-    });
-
-    if (!newEndPoint) {
-      return stateChanges;
-    }
-
-    const newPoints = [];
-    if (originPoint === 0) {
-      newPoints.push(newEndPoint, this.points[1]);
-    } else {
-      newPoints.push(this.points[0], newEndPoint);
-    }
-
-    if (newPoints[0].isSame(this.points[0]) && newPoints[1].isSame(this.points[1])) {
-      // No change
-      return stateChanges;
-    }
-
-    // update the line
-    const addState = new UpdateState(this, { points: newPoints });
-    stateChanges.push(addState);
-
-    return stateChanges;
+    return this;
   }
 
   /**

package/core/entities/lwpolyline.js

@@ -1,12 +1,13 @@
 import { Logging } from '../lib/logging.js';
-import { BasePolyline } from './basePolyline.js';
 import { Polyline } from './polyline.js';
 
 /**
  * LWPolyline Entity Class
- * @extends BasePolyline
+ * LWPolyline is a DXF import-only entity. The constructor pre-processes the
+ * raw DXF data and returns a {@link Polyline} instance. It is never
+ * instantiated as a standalone entity within the application.
  */
-export class Lwpolyline extends BasePolyline {
+export class Lwpolyline {
   static type = 'Lwpolyline';
 
   /**
@@ -14,16 +15,20 @@ export class Lwpolyline extends BasePolyline {
    * @param {Array} data
    */
   constructor(data) {
-    super(data);
-
-    if (data) {
-      if (data.hasOwnProperty('90')) {
-        // DXF Groupcode 90 - Number of vertices
-        if (this.points.length !== data[90]) {
-          Logging.instance.error(`LWPOLYLINE Vertices Count`);
-        }
+    if (data?.hasOwnProperty('90')) {
+      // DXF Groupcode 90 - Number of vertices
+      if (!Array.isArray(data.points)) {
+        Logging.instance.error(`LWPOLYLINE: group code 90 specifies ${data[90]} vertices but points array is missing or invalid`);
+      } else if (data.points.length !== data[90]) {
+        Logging.instance.error(`LWPOLYLINE: group code 90 specifies ${data[90]} vertices but ${data.points.length} were parsed`);
       }
     }
+
+    if (data?.points?.length >= 4 && data.points[0].isSame(data.points.at(-1))) {
+      data.points.pop();
+      data[70] = (data[70] ?? 0) | 1;
+    }
+
     return new Polyline(data);
   }
 

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';
 
   /**
@@ -47,14 +47,14 @@ export class Polyline extends BasePolyline {
     if (file.version < DXFFile.Version.R2000) {
       // POLYLINE/VERTEX/SEQEND format for R12
       file.writeGroupCode('0', 'POLYLINE');
-      file.writeGroupCode('8', this.layer);
-      file.writeGroupCode('6', this.lineType);
+      file.writeGroupCode('8', this.getProperty('layer'));
+      file.writeGroupCode('6', this.getProperty('lineType'));
       file.writeGroupCode('66', 1); // vertices-follow flag
       file.writeGroupCode('70', this.flags.getFlagValue());
 
       for (let i = 0; i < this.points.length; i++) {
         file.writeGroupCode('0', 'VERTEX');
-        file.writeGroupCode('8', this.layer);
+        file.writeGroupCode('8', this.getProperty('layer'));
         file.writeGroupCode('10', this.points[i].x);
         file.writeGroupCode('20', this.points[i].y);
         file.writeGroupCode('30', '0.0');
@@ -62,7 +62,7 @@ export class Polyline extends BasePolyline {
       }
 
       file.writeGroupCode('0', 'SEQEND');
-      file.writeGroupCode('8', this.layer);
+      file.writeGroupCode('8', this.getProperty('layer'));
       return;
     }