@design-core/core 0.0.5 → 0.0.7

package/core/entities/hatch.js

@@ -34,50 +34,45 @@ export class Hatch extends Entity {
   constructor(data) {
     super(data);
 
-    // store the boundary shapes
-    Object.defineProperty(this, 'childEntities', {
-      value: [],
+    // cache for pre-computed world-space pattern line segments
+    Object.defineProperty(this, 'cachedPattern', {
+      value: null,
       writable: true,
+      enumerable: false,
     });
 
-    Object.defineProperty(this, 'pattern', {
-      value: 'ANSI31',
-      writable: true,
+    // Boundary shapes stored in EntityProperties so all entity data lives in one place.
+    this.properties.add(Property.Names.CHILDENTITIES, {
+      type: Property.Type.ENTITIES,
+      value: [],
+      visible: false,
     });
 
-    Object.defineProperty(this, 'solid', {
-      value: false,
-      writable: true,
-    });
+    // lineType not applicable to hatch
+    this.properties.remove(Property.Names.LINETYPE);
 
-    Object.defineProperty(this, 'patternName', {
-      // value: 'ANSI31',
-      // writable: true,
-      enumerable: true,
-      get: this.getPatternName,
-      set: this.setPatternName,
-    });
+    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;
 
-    Object.defineProperty(this, 'angle', {
-      value: 0,
-      writable: true,
-      enumerable: true,
-    });
-
-    Object.defineProperty(this, 'scale', {
-      value: 1,
-      writable: true,
-      enumerable: true,
+    // 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 })),
     });
-
-    // hide inherited properties
-    // needs to be enumerable=false to not appear in the object props
-    Object.defineProperty(this, 'lineType', {
-      enumerable: false,
+    // DXF Groupcode 41 - Hatch pattern scale
+    this.properties.add(Property.Names.SCALE, {
+      type: Property.Type.NUMBER,
+      value: Property.loadValue([data?.[41], data?.scale], 1),
+      dxfCode: 41,
     });
-
-    Object.defineProperty(this, 'lineWidth', {
-      enumerable: false,
+    // DXF Groupcode 52 - Hatch pattern angle
+    this.properties.add(Property.Names.ANGLE, {
+      type: Property.Type.NUMBER,
+      value: Property.loadValue([data?.[52], data?.angle], 0),
+      dxfCode: 52,
     });
 
     // add a single point to this.points if no other points exist
@@ -85,24 +80,15 @@ export class Hatch extends Entity {
       this.points.push(new Point());
     }
 
-    // DXF Groupcode 70 - Solid Fill Flag (1 = solid, 0 = pattern)
-    this.solid = Boolean(Property.loadValue([data?.solid, data?.[70]], 0));
-    // DXF Groupcode 2 - Hatch pattern name
-    this.patternName = Property.loadValue([data?.patternName, data?.[2]], 'ANSI31');
-    // DXF Groupcode 41 - Hatch pattern scale
-    this.scale = Property.loadValue([data?.scale, data?.[41]], 1);
-    // DXF Groupcode 52 - Hatch pattern angle
-    this.angle = Property.loadValue([data?.angle, data?.[52]], 0);
-
     if (data) {
       if (data.hasOwnProperty('childEntities')) {
         if (Array.isArray(data.childEntities)) {
-          this.childEntities = data.childEntities;
+          this.setProperty(Property.Names.CHILDENTITIES, data.childEntities);
         }
       } else {
         const shapes = this.processBoundaryData(data);
         if (shapes.length) {
-          this.childEntities = shapes;
+          this.setProperty(Property.Names.CHILDENTITIES, shapes);
         }
       }
     }
@@ -118,20 +104,198 @@ export class Hatch extends Entity {
   }
 
   /**
-   * Get the hatch pattern name
-   * @return {string}
+   * Build and cache world-space line segments for the current pattern.
+   * For pattern hatches, segments are pre-clipped against the boundary using
+   * geometric intersection so draw() requires no ctx.save/clip/restore overhead.
    */
-  getPatternName() {
-    return this.pattern;
-  }
+  buildPatternCache() {
+    if (!this.getProperty(Property.Names.CHILDENTITIES).length) {
+      this.cachedPattern = [];
+      return;
+    }
 
-  /**
-   * Set the hatch pattern name
-   * @param {string} name
-   */
-  setPatternName(name) {
-    this.pattern = name.toUpperCase();
-    this.solid = this.pattern === 'SOLID';
+    if (this.getProperty(Property.Names.PATTERNNAME) === 'SOLID' || !Patterns.patternExists(this.getProperty(Property.Names.PATTERNNAME))) {
+      this.cachedPattern = [];
+      return;
+    }
+
+    // Build closed boundary arrays for intersection-based pre-clipping
+    const bb = this.boundingBox();
+    const boundaryExtentX = bb.xMax + bb.xLength + 1;
+    const boundaries = [];
+    // Collect all interior boundary vertices (the junction points between segments).
+    // An intersection point that lands exactly on a junction vertex will be reported
+    // by both adjacent segments, doubling the crossing count unless we deduplicate.
+    const boundaryVertices = [];
+    const childEntities = this.getProperty(Property.Names.CHILDENTITIES);
+    for (let i = 0; i < childEntities.length; i++) {
+      const shape = childEntities[i];
+      if (!shape.points.length) continue;
+      const pts = [...shape.points];
+      if (!pts[0].isSame(pts.at(-1))) pts.push(pts[0]);
+      boundaries.push(pts);
+      // All unique vertices (skip only the closure duplicate at pts[length-1]).
+      // pts[0] is also a junction — shared by the last and first segments.
+      for (let j = 0; j < pts.length - 1; j++) {
+        boundaryVertices.push(pts[j]);
+      }
+    }
+
+    const centerPoint = bb.centerPoint;
+    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));
+    pattern.forEach((patternLine) => {
+      let dashLength = bbXLength / 2;
+      if (patternLine.dashes.length) {
+        dashLength = patternLine.getDashLength();
+      }
+
+      let dashes = [...patternLine.dashes];
+      let dashOffset = 0;
+
+      if (dashes.length && dashes[0] < 0) {
+        const firstIndex = dashes.shift();
+        dashOffset = Math.abs(firstIndex);
+        dashes.push(firstIndex);
+      }
+
+      dashes = dashes.map((x) => (Math.abs(x) + 0.00001) * s);
+
+      // Combined rotation: pattern line angle plus the hatch entity angle
+      const rotation = Utils.degrees2radians(patternLine.angle + this.getProperty(Property.Names.ANGLE));
+
+      // Precomputed rotation components used to transform between pattern-local
+      // (line-aligned) space and world space throughout this family's loop.
+      const cosR = Math.cos(rotation);
+      const sinR = Math.sin(rotation);
+
+      // 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;
+
+      // Bounding-box half-extents in pattern-local (unscaled) space.
+      const halfW = bbXLength / (2 * s);
+      const halfH = bbYLength / (2 * s);
+
+      // Absolute trig values for projecting axis-aligned extents onto rotated axes.
+      const sinA = Math.abs(sinR);
+      const cosA = Math.abs(cosR);
+
+      // Half-extents of the bounding box projected onto the pattern line's
+      // parallel (halfX) and perpendicular (halfY) axes.  halfX bounds how far
+      // each raw segment must reach; halfY bounds how many parallel lines are needed.
+      const halfX = halfW * cosA + halfH * sinA;
+      const halfY = halfW * sinA + halfH * cosA;
+
+      // Perpendicular projection of the family's origin offset from the bounding-box
+      // centre onto the direction perpendicular to the pattern lines.  A non-zero
+      // origin shifts the whole family, so the loop range must be widened on the far
+      // side and the tangent guard must use the shifted position.
+      const originPerpOffset = patternLine.yOrigin * cosR - patternLine.xOrigin * sinR;
+
+      const maxSegmentsPerFamily = 1000;
+      const yIncrement = Math.min(
+          Math.ceil((halfY + Math.abs(originPerpOffset)) / Math.abs(patternLine.yDelta)),
+          maxSegmentsPerFamily,
+      );
+
+      const segments = [];
+      for (let i = -yIncrement; i < yIncrement; i++) {
+        const yOffset = patternLine.yDelta * i;
+        // A line whose shifted perpendicular position equals or exceeds halfY is
+        // tangent to or outside the bounding box — it cannot produce any valid
+        // inside sub-segment.  Skip it to avoid phantom slivers caused by
+        // near-tangent numerical artefacts in the arc-intersection code.
+        if (Math.abs(yOffset + originPerpOffset) >= halfY) continue;
+        // Each family member i is phase-shifted along the line direction by i × xDelta.
+        const xPhaseShift = patternLine.xDelta * i;
+        // Extend the raw segment far enough in both directions to cover the bounding
+        // box regardless of how large the phase shift grows for large i.
+        const xHalfSpan = dashLength * Math.ceil((halfX + Math.abs(xPhaseShift)) / dashLength);
+        const lx1 = xPhaseShift - xHalfSpan + dashOffset;
+        const lx2 = xPhaseShift + xHalfSpan;
+        const ly = yOffset;
+        const rx1 = (lx1 * cosR - ly * sinR) * s + cx;
+        const ry1 = (lx1 * sinR + ly * cosR) * s + cy;
+        const rx2 = (lx2 * cosR - ly * sinR) * s + cx;
+        const ry2 = (lx2 * sinR + ly * cosR) * s + cy;
+
+        // Find all intersection t-values where this segment crosses a boundary edge.
+        // A point that falls on a boundary vertex is shared by two adjacent segments
+        // and would be reported twice, doubling the crossing count. Track which vertex
+        // t-values have already been added and skip duplicates.
+        const segStartPt = new Point(rx1, ry1);
+        const segEndPt = new Point(rx2, ry2);
+        const dir = segEndPt.subtract(segStartPt);
+        const lenSq = dir.dot(dir);
+        if (lenSq === 0) continue;
+        const sqrtLenSq = Math.sqrt(lenSq);
+        const ts = [0, 1];
+        const vertexTsAdded = new Set();
+        for (const b of boundaries) {
+          const result = Intersection.intersectPolylinePolyline(b, [segStartPt, segEndPt]);
+          for (const pt of result.points) {
+            const t = pt.subtract(segStartPt).dot(dir) / lenSq;
+            if (t > 0.0001 && t < 0.9999) {
+              // Check if this point coincides with a boundary vertex
+              let isVertex = false;
+              for (const v of boundaryVertices) {
+                const vdx = pt.x - v.x;
+                const vdy = pt.y - v.y;
+                if (vdx * vdx + vdy * vdy < 1e-10) {
+                  isVertex = true;
+                  break;
+                }
+              }
+              if (isVertex) {
+                // Round t to 6 decimal places to get a stable key
+                const tKey = Math.round(t * 1e6);
+                if (!vertexTsAdded.has(tKey)) {
+                  vertexTsAdded.add(tKey);
+                  ts.push(t);
+                }
+              } else {
+                ts.push(t);
+              }
+            }
+          }
+        }
+
+        ts.sort((a, b) => a - b);
+
+        // Deduplicate very close t-values (e.g. a corner vertex found by two edges)
+        const uniqueTs = [ts[0]];
+        for (let k = 1; k < ts.length; k++) {
+          if (ts[k] - uniqueTs.at(-1) > 0.0001) uniqueTs.push(ts[k]);
+        }
+
+        // Test each interval's midpoint; keep sub-segments that are inside the boundary
+        for (let k = 0; k < uniqueTs.length - 1; k++) {
+          const tMid = (uniqueTs[k] + uniqueTs[k + 1]) / 2;
+          if (Intersection.isInsidePolyline(segStartPt.x + tMid * dir.x, segStartPt.y + tMid * dir.y, boundaries, boundaryExtentX)) {
+            const p1 = segStartPt.lerp(segEndPt, uniqueTs[k]);
+            const p2 = segStartPt.lerp(segEndPt, uniqueTs[k + 1]);
+            // Store the segment along with its initial dash phase, which is used by draw()
+            segments.push({
+              x1: p1.x,
+              y1: p1.y,
+              x2: p2.x,
+              y2: p2.y,
+              dashPhase: uniqueTs[k] * sqrtLenSq,
+            });
+          }
+        }
+      }
+
+      lines.push({ dashes, segments });
+    });
+
+    this.cachedPattern = lines;
   }
 
   /**
@@ -189,6 +353,16 @@ export class Hatch extends Entity {
                 }
 
                 shape.points.push(polyPoint);
+
+                // On the last vertex, apply the closed flag (73) to the shape.
+                // For polyline boundaries 73 = is-closed and appears once, before
+                // the vertices, so it has already been parsed into data[73]. We
+                // must not consume it inside the arc-edge branch (that branch uses
+                // 73 as the per-edge "is counter-clockwise" flag), so we read it
+                // here only when we are in the polyline branch and on the final vertex.
+                if (edgeNum === edgeCount - 1 && this.getDataValue(data, 73)) {
+                  shape.flags.addValue(1);
+                }
               } else if (edgeType === 1) {
                 // Line
                 // 10 - X; 20 - Y; 11 - X; 21 - Y
@@ -223,7 +397,7 @@ export class Hatch extends Entity {
                   throw Error(err);
                 }
                 shapeData.points.push(centerPoint);
-                shapeData[40] = this.getDataValue(data, 40);
+                shapeData.radius = this.getDataValue(data, 40);
                 shapeData.startAngle = this.getDataValue(data, 50);
                 shapeData.endAngle = this.getDataValue(data, 51);
                 // arc direction: - ccw > 0, cw <= 0 default 1
@@ -312,7 +486,7 @@ export class Hatch extends Entity {
         const boundary = this.processSelection(selectedItems);
 
         if (boundary.length) {
-          this.childEntities = boundary;
+          this.setProperty(Property.Names.CHILDENTITIES, boundary);
           validBoundary = true;
         } else {
         // reset selection
@@ -335,7 +509,7 @@ export class Hatch extends Entity {
     const selectedItems = DesignCore.Scene.selectionManager.selectedItems.slice(0);
     const shapes = this.processSelection(selectedItems);
     if (shapes.length) {
-      DesignCore.Scene.tempEntities.create(this.type, { points: this.points, childEntities: shapes });
+      DesignCore.Scene.previewEntities.create(this.type, { points: this.points, childEntities: shapes }); // childEntities is passed as plain data here, not via getProperty
     }
   }
 
@@ -409,6 +583,8 @@ export class Hatch extends Entity {
             // Drop the redundant closure point — the first point already records
             // the same position; keeping it would create a zero-length segment
             shape.points.push(...iterationPoints.slice(0, -1));
+            // Mark as closed (flag bit 1)
+            shape.flags.addValue(1);
             selectedchildEntities.push(shape);
             iterationPoints = [];
             break;
@@ -422,168 +598,52 @@ export class Hatch extends Entity {
 
   /**
    * Draw the entity
-   * @param {Object} ctx - context
+   * @param {Object} renderer
    * @param {number} scale
    */
-  draw(ctx, scale) {
+  draw(renderer) {
     // ensure the scale is valid
-    if (this.scale < 0.01) {
-      this.scale = 1;
-    }
-
-    if (!this.childEntities.length) return;
-
-    ctx.save();
-
-    // Start a new composite path for all boundary loops
-    try {
-      ctx.beginPath();
-    } catch { // Cairo
-      ctx.newPath();
-    }
-
-    // Trace all boundary paths as sub-paths in a single composite path
-    // Using even-odd fill rule, islands are automatically handled:
-    // areas enclosed by an odd number of boundaries are filled,
-    // areas enclosed by an even number are left empty
-    for (let i = 0; i < this.childEntities.length; i++) {
-      const shape = this.childEntities[i];
-      if (!shape.points.length) continue;
-
-      // Start a new sub-path for this boundary
-      ctx.moveTo(shape.points[0].x, shape.points[0].y);
-      // Trace the boundary path (without stroking)
-      shape.draw(ctx, scale, false);
-      // Close the sub-path
-      ctx.closePath();
+    if (this.getProperty(Property.Names.SCALE) < 0.01) {
+      this.setProperty(Property.Names.SCALE, 1);
     }
 
-    // Clip using even-odd rule
-    try { // Cairo - clip() takes no arguments, uses the fill rule set above
-      ctx.setFillRule(1); // Cairo.FillRule.EVEN_ODD
-      ctx.clip();
-    } catch { // HTML Canvas
-      ctx.clip('evenodd');
-    }
-
-    // Start a new path for the pattern/fill area
-    try {
-      ctx.beginPath();
-    } catch { // Cairo
-      ctx.newPath();
-    }
-
-    // Create an oversized rectangle covering all boundaries
-    const bb = this.boundingBox();
-    try {
-      ctx.rect(bb.xMin - bb.xLength, bb.yMin - bb.yLength, bb.xLength * 3, bb.yLength * 3);
-    } catch { // Cairo
-      ctx.rectangle(bb.xMin - bb.xLength, bb.yMin - bb.yLength, bb.xLength * 3, bb.yLength * 3);
-    }
-
-    // Draw the pattern/fill once over the composite clipped region
-    this.createPattern(ctx, scale, bb);
-
-    ctx.restore();
-  }
-
-  /**
-   * Draw the hatch pattern to the context
-   * @param {Object} ctx
-   * @param {number} scale
-   * @param {BoundingBox} boundingbox - bounding box of the hatch boundaries, used to size the pattern
-   */
-  createPattern(ctx, scale, boundingbox) {
-    if (!Patterns.patternExists(this.patternName) || this.solid) {
-      ctx.fill();
-      return;
-    }
-
-    const boundingBox = boundingbox;
-    const centerPoint = boundingBox.centerPoint;
-    const bbXLength = boundingBox.xLength;
-    const bbYLength = boundingBox.yLength;
-
-    const pattern = Patterns.getPattern(this.patternName);
-    pattern.forEach((patternLine) => {
-      // Each pattern line is considered to be the first member of a line family,
-      // Patterns are created by applying the delta offsets in both directions to generate an infinite family of parallel lines.
-      // originX and originY values are the offsets of the line from the origin and are applied without rotation
-      // The delta-x value indicates the displacement between members of the family in the direction of the line. It is used only for dashed lines.
-      // The delta-y value indicates the spacing between members of the family; that is, it is measured perpendicular to the lines.
-      // A line is considered to be of infinite length.
-      // A dash pattern is superimposed on the line.
-
-      // define dashlength - i.e. the length of each dash summed
-      // where there is no dash defined use half the boundingbox xlength
-      let dashLength = bbXLength / 2;
-      if (patternLine.dashes.length) {
-        dashLength = patternLine.getDashLength();
+    const childEntitiesDraw = this.getProperty(Property.Names.CHILDENTITIES);
+    if (!childEntitiesDraw.length) return;
+
+    // Build cache if stale (cachedPattern === null means never built or invalidated)
+    if (this.cachedPattern === null) this.buildPatternCache();
+
+    if (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).
+      // fill() is resolution-independent, handles curved boundaries exactly,
+      // and avoids the cost of generating and clipping thousands of segments.
+      renderer.beginPath();
+      for (const shape of childEntitiesDraw) {
+        if (!shape.points.length) continue;
+        renderer.tracePath(shape.toPolylinePoints());
+        renderer.closePath();
       }
-
-      // copy dashes to avoid mutating the pattern line
-      let dashes = [...patternLine.dashes];
-      let dashOffset = 0;
-
-      if (dashes[0] < 0) {
-        // if the first dash is negative move it to the end
-        const firstIndex = dashes.shift();
-        dashOffset = Math.abs(firstIndex);
-        dashes.push(firstIndex);
-      }
-
-      dashes = dashes.map((x) => Math.abs(x) + 0.00001);
-
-      try {
-        ctx.setLineDash(dashes, 0);
-        ctx.lineWidth = (1 / scale / this.scale);
-        ctx.beginPath();
-      } catch { // Cairo
-        ctx.setDash(dashes, 0);
-        ctx.setLineWidth(1 / scale / this.scale);
-        ctx.newPath();
+      renderer.applyPath({ fill: true, stroke: false, fillRule: 'evenodd' });
+    } else {
+      // Pattern hatch: draw pre-clipped segments directly.
+      for (const family of this.cachedPattern) {
+        renderer.setDash([], 0);
+        renderer.drawSegments(family.segments, family.dashes);
       }
+    }
 
-      const rotation = Utils.degrees2radians(patternLine.angle + this.angle);
-
-      // Project the bounding box onto the pattern's rotated local axes
-      // to compute tight line counts instead of using the worst-case max dimension.
-      const halfW = bbXLength / (2 * this.scale);
-      const halfH = bbYLength / (2 * this.scale);
-      const sinR = Math.abs(Math.sin(rotation));
-      const cosR = Math.abs(Math.cos(rotation));
-
-      // Half-extent along the line direction (X in local frame)
-      const halfX = halfW * cosR + halfH * sinR;
-      // Half-extent perpendicular to lines (Y in local frame)
-      const halfY = halfW * sinR + halfH * cosR;
-
-      const xIncrement = Math.ceil(halfX / dashLength);
-      const yIncrement = Math.ceil(halfY / Math.abs(patternLine.yDelta));
-
-      // Set transform once for all lines in this pattern line family
-      ctx.save();
-      // translate to the center of the shape
-      // apply the origin offsets without rotation
-      ctx.translate(centerPoint.x + patternLine.xOrigin * this.scale, centerPoint.y + patternLine.yOrigin * this.scale);
-      // scale the context
-      ctx.scale(this.scale, this.scale);
-      // rotate the context
-      ctx.rotate(rotation);
-
-      for (let i = -yIncrement; i < yIncrement; i++) {
-        // apply the deltaX offset for odd iterations
-        // define offsets for the current iteration
-        const xOffset = patternLine.xDelta * Math.abs(i) + dashLength * xIncrement;
-        const yOffset = patternLine.yDelta * i;
-
-        ctx.moveTo(-xOffset + dashOffset, yOffset);
-        ctx.lineTo(xOffset, yOffset);
+    // Draw the boundary outline when hovered or selected.
+    const isSelected = DesignCore.Scene.selectionManager.selectedItems.includes(this);
+    const isHovered = DesignCore.Scene.hoverEntities.indexOf(this) !== -1;
+    if (isSelected || isHovered) {
+      renderer.setDash([], 0);
+      for (const shape of childEntitiesDraw) {
+        if (!shape.points.length) continue;
+        renderer.drawShape(shape.toPolylinePoints(), { closed: true });
       }
-
-      ctx.stroke();
-      ctx.restore();
-    });
+    }
   }
 
   /**
@@ -592,14 +652,15 @@ export class Hatch extends Entity {
    */
   dxf(file) {
     // skip if no boundary shapes
-    if (!this.childEntities.length) {
+    const childEntitiesDxf = this.getProperty(Property.Names.CHILDENTITIES);
+    if (!childEntitiesDxf.length) {
       return;
     }
 
     file.writeGroupCode('0', 'HATCH');
-    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));
     file.writeGroupCode('100', 'AcDbHatch', DXFFile.Version.R2000);
     file.writeGroupCode('10', '0.0');
     file.writeGroupCode('20', '0.0');
@@ -609,15 +670,15 @@ export class Hatch extends Entity {
     file.writeGroupCode('220', '0.0'); // Extrusion Direction Y
     file.writeGroupCode('230', '1.0'); // Extrusion Direction Z
 
-    file.writeGroupCode('2', this.patternName); // Hatch pattern name
-    file.writeGroupCode('70', this.solid ? 1 : 0); // Solid Fill Flag (1 = solid, 0 = pattern)
+    file.writeGroupCode('2', this.getProperty(Property.Names.PATTERNNAME)); // Hatch pattern name
+    file.writeGroupCode('70', this.getProperty(Property.Names.PATTERNNAME) === 'SOLID' ? 1 : 0); // Solid Fill Flag (1 = solid, 0 = pattern)
     file.writeGroupCode('71', '0'); // Associativity flag (associative = 1; non-associative = 0); for MPolygon, solid-fill flag (has solidfill = 1; lacks solid fill = 0)
 
 
-    file.writeGroupCode('91', this.childEntities.length); // Number of boundary path loops
+    file.writeGroupCode('91', childEntitiesDxf.length); // Number of boundary path loops
 
-    for (let i = 0; i < this.childEntities.length; i++) {
-      const shape = this.childEntities[i];
+    for (let i = 0; i < childEntitiesDxf.length; i++) {
+      const shape = childEntitiesDxf[i];
       file.writeGroupCode('92', '7'); // Boundary path type flag (bit coded): 0 = Default; 1 = External; 2 = Polyline 4 = Derived; 8 = Textbox; 16 = Outermost
       file.writeGroupCode('72', '1'); // Edge type (only if boundary is not a polyline): 1 = Line; 2 = Circular arc; 3 = Elliptic arc; 4 = Spline
       file.writeGroupCode('73', '1'); // For MPolygon, boundary annotation flag (boundary is an annotated boundary = 1; boundary is not an annotated boundary = 0)
@@ -635,25 +696,25 @@ export class Hatch extends Entity {
     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
 
-    if (!this.solid) {
-      file.writeGroupCode('52', this.angle); // Hatch Pattern angle
-      file.writeGroupCode('41', this.scale); // Hatch Pattern scale
+    if (this.getProperty(Property.Names.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.patternName)); // Number of pattern definition lines
+      file.writeGroupCode('78', Patterns.getPatternLineCount(this.getProperty(Property.Names.PATTERNNAME))); // Number of pattern definition lines
 
       // Pattern data
-      const pattern = Patterns.getPattern(this.patternName);
+      const pattern = Patterns.getPattern(this.getProperty(Property.Names.PATTERNNAME));
       pattern.forEach((patternLine) => {
-        file.writeGroupCode('53', patternLine.angle + this.angle); // Pattern line angle
+        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
-        const deltaPoint = new Point(patternLine.xDelta * this.scale, patternLine.yDelta * this.scale);
-        const rotatedDelta = deltaPoint.rotate(new Point(), Utils.degrees2radians(patternLine.angle + this.angle));
+        const deltaPoint = new Point(patternLine.xDelta * this.getProperty(Property.Names.SCALE), patternLine.yDelta * this.getProperty(Property.Names.SCALE));
+        const rotatedDelta = deltaPoint.rotate(new Point(), Utils.degrees2radians(patternLine.angle + this.getProperty(Property.Names.ANGLE)));
         file.writeGroupCode('45', rotatedDelta.x); // Pattern line offset x
         file.writeGroupCode('46', rotatedDelta.y); // Pattern line offset y
         file.writeGroupCode('79', patternLine.dashes.length); // Number of dash length items
         patternLine.dashes.forEach((dash) => {
-          file.writeGroupCode('49', dash * this.scale); // Dash length
+          file.writeGroupCode('49', dash * this.getProperty(Property.Names.SCALE)); // Dash length
         });
       });
     }
@@ -695,8 +756,9 @@ export class Hatch extends Entity {
    */
   isInside(P) {
     // P = P.subtract(this.points[0]);
-    for (let i = 0; i < this.childEntities.length; i++) {
-      const shape = this.childEntities[i];
+    const childEntities = this.getProperty(Property.Names.CHILDENTITIES);
+    for (let i = 0; i < childEntities.length; i++) {
+      const shape = childEntities[i];
 
       if (shape.boundingBox().isInside(P)) {
         const polyline = [...shape.points];
@@ -726,7 +788,8 @@ export class Hatch extends Entity {
    * @return {BoundingBox}
    */
   boundingBox() {
-    if (this.childEntities.length === 0) {
+    const childEntities = this.getProperty(Property.Names.CHILDENTITIES);
+    if (childEntities.length === 0) {
       return new BoundingBox();
     }
 
@@ -735,8 +798,8 @@ export class Hatch extends Entity {
     let ymin = Infinity;
     let ymax = -Infinity;
 
-    for (let i = 0; i < this.childEntities.length; i++) {
-      const shape = this.childEntities[i];
+    for (let i = 0; i < childEntities.length; i++) {
+      const shape = childEntities[i];
 
       const boundingBox = shape.boundingBox();
 
@@ -758,8 +821,9 @@ export class Hatch extends Entity {
    * @return {boolean} true if touched
    */
   touched(selection) {
-    for (let i = 0; i < this.childEntities.length; i++) {
-      if (this.childEntities[i].touched(selection)) {
+    const childEntities = this.getProperty(Property.Names.CHILDENTITIES);
+    for (let i = 0; i < childEntities.length; i++) {
+      if (childEntities[i].touched(selection)) {
         return true;
       }
     }
@@ -773,10 +837,15 @@ export class Hatch extends Entity {
    * @param {any} value
    */
   setProperty(property, value) {
-    if (this.hasOwnProperty(property)) {
-      if (property === 'points') {
+    if (this.properties.has(property)) {
+      if (property === Property.Names.PATTERNNAME) {
+        const upper = String(value).toUpperCase();
+        if (this.getProperty(Property.Names.PATTERNNAME) === upper) return;
+        super.setProperty(property, upper);
+      } 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
+        const hatchChildren = this.getProperty(Property.Names.CHILDENTITIES);
         const ang = value[0].angle(value.at(-1));
         const theta = ang - this.points[0].angle(this.points.at(-1));
 
@@ -784,26 +853,30 @@ export class Hatch extends Entity {
           // set rotation center
           const center = this.points[0];
           // apply rotation to child entities points
-          this.childEntities.forEach((child) => {
+          hatchChildren.forEach((child) => {
             const rotatedPoints = child.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(center, theta));
-            child.setProperty('points', rotatedPoints);
+            child.setProperty(Property.Names.POINTS, rotatedPoints);
           });
 
-          this.angle+= Utils.radians2degrees(theta);
+          this.setProperty(Property.Names.ANGLE, this.getProperty(Property.Names.ANGLE) + Utils.radians2degrees(theta));
         }
 
         const delta = value[0].subtract(this.points[0]);
         if (delta.x !== 0 || delta.y !== 0) {
-        // apply translation to child entities points
-          this.childEntities.forEach((child) => {
+          // apply translation to child entities points
+          hatchChildren.forEach((child) => {
             const offsetPoints = child.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).add(delta));
-            child.setProperty('points', offsetPoints);
+            child.setProperty(Property.Names.POINTS, offsetPoints);
           });
         }
-      }
 
-      // other properties as normal
-      this[property] = value;
+        super.setProperty(property, value);
+      } else {
+        super.setProperty(property, value);
+      }
+      // invalidate the pattern cache — geometry, scale, angle and boundary
+      // shape are all baked into the cache
+      this.cachedPattern = null;
     }
   }
 }