@design-core/core 50.1.0 → 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;
     }
@@ -147,7 +298,7 @@ export class Hatch extends Entity {
     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) {
@@ -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).
@@ -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');
@@ -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

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
@@ -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/lib/canvas.js

@@ -222,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);

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

package/core/properties/property.js

@@ -29,9 +29,12 @@ export class Property {
     return this._value;
   }
 
-  /** @param {any} val - new value; ignored when readOnly */
+  /** @param {any} val - new value; ignored when readOnly is true.
+   * Callable readOnly is evaluated by the caller (entityProperties.set) with
+   * the entity in scope; treat it as writable here to avoid stale closure issues. */
   set value(val) {
-    if (!this.readOnly) {
+    const isReadOnly = typeof this.readOnly === 'function' ? false : this.readOnly;
+    if (!isReadOnly) {
       this._value = val;
     }
   }
@@ -83,6 +86,8 @@ export class Property {
     // ── Hatch ─────────────────────────────────────────────────────────────────
     CHILDENTITIES: 'childEntities',
     PATTERNNAME: 'patternName',
+    HATCHSPACING: 'hatchSpacing',
+    HATCHDOUBLE: 'hatchDouble',
     // ── Text ──────────────────────────────────────────────────────────────────
     BACKWARDS: 'backwards',
     HORIZONTALALIGNMENT: 'horizontalAlignment',

package/core/properties/propertyManager.js

@@ -151,6 +151,21 @@ export class PropertyManager {
     return DesignCore.Scene.entities.get(index).properties.definition(property);
   }
 
+  /**
+   * Get the representative entity for a named property from the selection set.
+   * Used alongside getEntityPropertyDefinition when readOnly callbacks need an entity.
+   * @param {string} entityType
+   * @param {string} property
+   * @return {Object|undefined}
+   */
+  getEntityForProperty(entityType, property) {
+    const index = DesignCore.Scene.selectionManager.selectionSet.selectionSet.find((i) => {
+      const entity = DesignCore.Scene.entities.get(i);
+      return (entityType === 'All' || entity.type === entityType) && entity.properties?.has(property);
+    });
+    return index !== undefined ? DesignCore.Scene.entities.get(index) : undefined;
+  }
+
   /**
    * Get a list the property values
    * @param {string} entityType

package/core/tables/block.js

@@ -256,6 +256,8 @@ export class Block extends Entity {
    * @return {BoundingBox}
    */
   boundingBox() {
+    if (!this.entities.length) return null;
+
     let xmin = Infinity;
     let xmax = -Infinity;
     let ymin = Infinity;

package/cspell.json

@@ -141,6 +141,8 @@
         "EXTMIN",
         "FILLETRAD",
         "FONTNAME",
+        "HATCHDOUBLE",
+        "HATCHSPACING",
         "groupcode",
         "groupcodes",
         "groupvalue",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-core/core",
-  "version": "50.1.0",
+  "version": "51.1.0",
   "type": "module",
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"

package/test/entities/hatch.test.js

@@ -1,4 +1,5 @@
 import { Hatch } from '../../core/entities/hatch.js';
+import { PatternLine } from '../../core/lib/patterns.js';
 import { Point } from '../../core/entities/point.js';
 import { DesignCore } from '../../core/designCore.js';
 
@@ -10,6 +11,8 @@ import { Arc } from '../../core/entities/arc.js';
 import { Text } from '../../core/entities/text.js';
 
 import { File, withMockInput } from '../test-helpers/test-helpers.js';
+import { Logging } from '../../core/lib/logging.js';
+import { jest } from '@jest/globals';
 
 import { Core } from '../../core/core/core.js';
 
@@ -1066,6 +1069,40 @@ test('Hatch.draw HONEY dashed family sets lineDashOffset and strokes once per se
   expect(ctx.getStrokeCalls()).toBe(expectedSegs);
 });
 
+// ── unknown pattern ───────────────────────────────────────────────────────────
+
+describe('unknown hatch pattern', () => {
+  test('logs a warning when pattern name is not recognised', () => {
+    const warnSpy = jest.spyOn(Logging.instance, 'warn').mockImplementation(() => {});
+    try {
+      new Hatch({ patternName: 'NOTAPATTERN' });
+      expect(warnSpy).toHaveBeenCalledWith('Hatch: pattern \'NOTAPATTERN\' not found');
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  test('retains the original pattern name when pattern is not recognised', () => {
+    const warnSpy = jest.spyOn(Logging.instance, 'warn').mockImplementation(() => {});
+    try {
+      const h = new Hatch({ patternName: 'NOTAPATTERN' });
+      expect(h.getProperty('patternName')).toBe('NOTAPATTERN');
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  test('does not log a warning for a known pattern', () => {
+    const warnSpy = jest.spyOn(Logging.instance, 'warn').mockImplementation(() => {});
+    try {
+      new Hatch({ patternName: 'ANSI31' });
+      expect(warnSpy).not.toHaveBeenCalled();
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+});
+
 // ── processSelection: uncloseable items ──────────────────────────────────────
 
 test('Hatch.processSelection returns empty array when items cannot form a closed loop', () => {
@@ -1077,3 +1114,289 @@ test('Hatch.processSelection returns empty array when items cannot form a closed
   const h = new Hatch();
   expect(h.processSelection(disconnected)).toEqual([]);
 });
+
+// ── patternLines: library (76=1 default) ─────────────────────────────────────
+
+test('Hatch.patternLines is non-enumerable', () => {
+  const h = new Hatch({ patternName: 'ANSI31' });
+  const descriptor = Object.getOwnPropertyDescriptor(h, 'patternLines');
+  expect(descriptor.enumerable).toBe(false);
+});
+
+test('Hatch.patternLines populated from library for known predefined pattern', () => {
+  const h = new Hatch({ patternName: 'ANSI31' });
+  expect(h.patternLines.length).toBeGreaterThan(0);
+  expect(h.patternLines[0]).toBeInstanceOf(PatternLine);
+});
+
+test('Hatch.patternLines is empty for unknown pattern', () => {
+  const warnSpy = jest.spyOn(Logging.instance, 'warn').mockImplementation(() => {});
+  try {
+    const h = new Hatch({ patternName: 'NOTAPATTERN' });
+    expect(h.patternLines).toEqual([]);
+  } finally {
+    warnSpy.mockRestore();
+  }
+});
+
+test('Hatch.patternLines is empty for SOLID pattern', () => {
+  const h = new Hatch({ patternName: 'SOLID' });
+  expect(h.patternLines).toEqual([]);
+});
+
+test('Hatch.patternLines rebuilt when patternName changes via setProperty', () => {
+  const h = new Hatch({ patternName: 'ANSI31' });
+  const originalLength = h.patternLines.length;
+  expect(originalLength).toBeGreaterThan(0);
+
+  h.setProperty('patternName', 'HONEY');
+  expect(h.patternLines.length).toBeGreaterThan(0);
+  // HONEY has 3 families; ANSI31 has 1
+  expect(h.patternLines.length).toBeGreaterThan(originalLength);
+});
+
+test('Hatch.patternLines becomes empty when patternName set to unknown', () => {
+  const warnSpy = jest.spyOn(Logging.instance, 'warn').mockImplementation(() => {});
+  try {
+    const h = new Hatch({ patternName: 'ANSI31' });
+    h.setProperty('patternName', 'NOTAPATTERN');
+    expect(h.patternLines).toEqual([]);
+  } finally {
+    warnSpy.mockRestore();
+  }
+});
+
+// ── patternLines: user-defined inline (76=0) ─────────────────────────────────
+
+test('Hatch with 76=0 uses inline pattern lines, not library', () => {
+  const data = {
+    '76': 0,
+    '41': 1,
+    '52': 0,
+    '78': 1,
+    '53': 0,
+    '45': 0,
+    '46': 10, // dy delta (10 inches)
+    '79': 0,
+  };
+  const h = new Hatch(data);
+  expect(h.patternLines.length).toBe(1);
+  expect(h.patternLines[0]).toBeInstanceOf(PatternLine);
+  expect(h.patternLines[0].angle).toBe(0);
+  expect(h.patternLines[0].yDelta).toBeCloseTo(10, 5); // 10 (drawing units)
+  expect(h.patternLines[0].dashes).toEqual([]);
+});
+
+test('Hatch with 76=0 correctly scales delta by dividing out the scale factor', () => {
+  // scale=2: DXF stores delta pre-multiplied, so raw dy=20 → 20/2=10 (drawing units)
+  const data = {
+    '76': 0,
+    '41': 2,
+    '52': 0,
+    '78': 1,
+    '53': 0,
+    '45': 0,
+    '46': 20,
+    '79': 0,
+  };
+  const h = new Hatch(data);
+  expect(h.patternLines[0].yDelta).toBeCloseTo(10, 5);
+});
+
+test('Hatch with 76=0 and 77=1 (double flag) adds a perpendicular family', () => {
+  const data = {
+    '76': 0,
+    '77': 1,
+    '41': 1,
+    '52': 0,
+    '78': 1,
+    '53': 0,
+    '45': 0,
+    '46': 10,
+    '79': 0,
+  };
+  const h = new Hatch(data);
+  expect(h.patternLines.length).toBe(2);
+  expect(h.patternLines[1].angle).toBe(90);
+  expect(h.patternLines[1].yDelta).toBeCloseTo(h.patternLines[0].yDelta, 5);
+});
+
+test('Hatch with 76=0 and dashes parses and converts to mm', () => {
+  // [5, -5] → [5, -5] (drawing units)
+  const data = {
+    '76': 0,
+    '41': 1,
+    '52': 0,
+    '78': 1,
+    '53': 0,
+    '45': 0,
+    '46': 10,
+    '79': 2,
+    '49': [5, -5],
+  };
+  const h = new Hatch(data);
+  expect(h.patternLines[0].dashes.length).toBe(2);
+  expect(h.patternLines[0].dashes[0]).toBeCloseTo(5, 5);
+  expect(h.patternLines[0].dashes[1]).toBeCloseTo(-5, 5);
+});
+
+test('Hatch with 76=0 and multiple line families parses each correctly', () => {
+  const data = {
+    '76': 0,
+    '41': 1,
+    '52': 0,
+    '78': 2,
+    '53': [0, 90],
+    '45': [0, 0],
+    '46': [10, 10],
+    '79': [0, 0],
+  };
+  const h = new Hatch(data);
+  expect(h.patternLines.length).toBe(2);
+  expect(h.patternLines[0].angle).toBe(0);
+  expect(h.patternLines[1].angle).toBe(90);
+  expect(h.patternLines[0].yDelta).toBeCloseTo(10, 5);
+  expect(h.patternLines[1].yDelta).toBeCloseTo(10, 5);
+});
+
+test('Hatch with 76=0 and no inline families synthesises from spacing (47)', () => {
+  const data = { '76': 0, '41': 1, '52': 45, '47': 5 };
+  const h = new Hatch(data);
+  expect(h.patternLines.length).toBe(1);
+  expect(h.patternLines[0].angle).toBe(0);
+  expect(h.patternLines[0].yDelta).toBeCloseTo(5, 5);
+  expect(h.patternLines[0].dashes).toEqual([]);
+});
+
+test('Hatch with 76=0 explicit families: data[53] absolute angle is stored relative to entity angle', () => {
+  // AutoCAD writes data[53]=45 as the absolute line angle when entity angle (52) is 45.
+  // Subtracting entityAngle makes it 0 so buildPatternCache's addition yields the correct 45°.
+  const data = { '76': 0, '41': 1, '52': 45, '78': 1, '53': 45, '45': 0, '46': 10, '79': 0 };
+  const h = new Hatch(data);
+  expect(h.patternLines[0].angle).toBeCloseTo(0, 5); // 45 - 45 = 0 (relative)
+});
+
+test('Hatch with 76=0, no inline families, double flag (77=1) synthesises two families', () => {
+  const data = { '76': 0, '77': 1, '41': 1, '52': 0, '47': 5 };
+  const h = new Hatch(data);
+  expect(h.patternLines.length).toBe(2);
+  expect(h.patternLines[0].angle).toBe(0);
+  expect(h.patternLines[1].angle).toBe(90);
+  expect(h.patternLines[1].yDelta).toBeCloseTo(5, 5);
+});
+
+// ── patternLines: custom embedded (76=2) ─────────────────────────────────────
+
+test('Hatch with 76=2 uses inline pattern lines', () => {
+  const data = {
+    '76': 2,
+    '41': 1,
+    '52': 0,
+    '78': 1,
+    '53': 45,
+    '45': 0,
+    '46': 10,
+    '79': 0,
+  };
+  const h = new Hatch(data);
+  expect(h.patternLines.length).toBe(1);
+  expect(h.patternLines[0].angle).toBe(45);
+  expect(h.patternLines[0].yDelta).toBeCloseTo(10, 5);
+});
+
+// ── dxf() output: 76 group code ──────────────────────────────────────────────
+
+test('Hatch.dxf writes 76=1 for library patterns', () => {
+  const h = new Hatch({ patternName: 'ANSI31', handle: '1' });
+  h.setProperty('childEntities', makeSquare());
+  const file = new File();
+  h.dxf(file);
+  const match = file.contents.match(/^76\n(\d+)/m);
+  expect(match).not.toBeNull();
+  expect(match[1]).toBe('1');
+});
+
+test('Hatch.dxf writes 76=0 for user-defined patterns', () => {
+  const data = {
+    '76': 0,
+    '41': 1,
+    '52': 0,
+    '78': 1,
+    '53': 0,
+    '45': 0,
+    '46': 10,
+    '79': 0,
+    'handle': '1',
+  };
+  const h = new Hatch(data);
+  h.setProperty('childEntities', makeSquare());
+  const file = new File();
+  h.dxf(file);
+  const match = file.contents.match(/^76\n(\d+)/m);
+  expect(match).not.toBeNull();
+  expect(match[1]).toBe('0');
+});
+
+test('Hatch.dxf 76=0 double-flag round-trip writes correct family count', () => {
+  const data = {
+    '76': 0,
+    '77': 1,
+    '41': 1,
+    '52': 0,
+    '78': 1,
+    '53': 0,
+    '45': 0,
+    '46': 10,
+    '79': 0,
+    'handle': '1',
+  };
+  const h = new Hatch(data);
+  h.setProperty('childEntities', makeSquare());
+  const file = new File();
+  h.dxf(file);
+  const match = file.contents.match(/^78\n(\d+)/m);
+  expect(match).not.toBeNull();
+  expect(match[1]).toBe('2');
+});
+
+// ── buildPatternCache with inline patterns ────────────────────────────────────
+
+test('Hatch with 76=0 inline pattern renders segments inside boundary', () => {
+  const data = {
+    '76': 0,
+    '41': 1,
+    '52': 0,
+    '78': 1,
+    '53': 0,
+    '45': 0,
+    '46': 1, // 1 (drawing unit) spacing
+    '79': 0,
+  };
+  const h = new Hatch(data);
+  h.setProperty('childEntities', makeSquare());
+  h.buildPatternCache();
+
+  expect(h.cachedPattern.length).toBe(1);
+  expect(h.cachedPattern[0].segments.length).toBeGreaterThan(0);
+});
+
+test('Hatch with 76=0 double flag renders two families of segments', () => {
+  const data = {
+    '76': 0,
+    '77': 1,
+    '41': 1,
+    '52': 0,
+    '78': 1,
+    '53': 0,
+    '45': 0,
+    '46': 1,
+    '79': 0,
+  };
+  const h = new Hatch(data);
+  h.setProperty('childEntities', makeSquare());
+  h.buildPatternCache();
+
+  expect(h.cachedPattern.length).toBe(2);
+  expect(h.cachedPattern[0].segments.length).toBeGreaterThan(0);
+  expect(h.cachedPattern[1].segments.length).toBeGreaterThan(0);
+});

package/test/lib/clipboard.test.js

@@ -4,6 +4,8 @@ import { Point } from '../../core/entities/point.js';
 import { DesignCore } from '../../core/designCore.js';
 import { Logging } from '../../core/lib/logging.js';
 import { jest } from '@jest/globals';
+import { Polyline } from '../../core/entities/polyline.js';
+import { Text } from '../../core/entities/text.js';
 
 // Initialize core (sets DesignCore.Core)
 new Core();
@@ -67,4 +69,75 @@ describe('Clipboard', () => {
     expect(fresh.Entities).toHaveLength(0);
     errorSpy.mockRestore();
   });
+
+  describe('stringify/parse flag survival', () => {
+    test('closed Polyline retains closed flag after stringify/parse roundtrip', () => {
+      // Create a closed polyline (flags bit 1 = closed)
+      const poly = new Polyline({
+        points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)],
+        flags: 1,
+      });
+      expect(poly.getProperty('closed')).toBe(true);
+
+      DesignCore.Clipboard.Entities = [poly];
+      const json = DesignCore.Clipboard.stringify();
+
+      const fresh = new Clipboard();
+      fresh.parse(json);
+
+      expect(fresh.Entities).toHaveLength(1);
+      expect(fresh.Entities[0].getProperty('closed')).toBe(true);
+    });
+
+    test('closed Polyline retains correct point count after stringify/parse roundtrip', () => {
+      // A closed polyline stores 4 points (not 5 — the closing duplicate is removed)
+      const poly = new Polyline({
+        points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)],
+        flags: 1,
+      });
+      expect(poly.points).toHaveLength(4);
+
+      DesignCore.Clipboard.Entities = [poly];
+      const json = DesignCore.Clipboard.stringify();
+
+      const fresh = new Clipboard();
+      fresh.parse(json);
+
+      expect(fresh.Entities[0].points).toHaveLength(4);
+    });
+
+    test('backwards (mirrored) Text retains backwards flag after stringify/parse roundtrip', () => {
+      // Text flags bit 2 = backwards
+      const text = new Text({
+        points: [new Point(0, 0), new Point(10, 0)],
+        textValue: 'hello',
+        flags: 2,
+      });
+      expect(text.getBackwards()).toBe(true);
+
+      DesignCore.Clipboard.Entities = [text];
+      const json = DesignCore.Clipboard.stringify();
+
+      const fresh = new Clipboard();
+      fresh.parse(json);
+
+      expect(fresh.Entities).toHaveLength(1);
+      expect(fresh.Entities[0].getBackwards()).toBe(true);
+    });
+
+    test('non-flagged entities are unaffected', () => {
+      const poly = new Polyline({
+        points: [new Point(0, 0), new Point(10, 0), new Point(10, 10)],
+      });
+      expect(poly.getProperty('closed')).toBe(false);
+
+      DesignCore.Clipboard.Entities = [poly];
+      const json = DesignCore.Clipboard.stringify();
+
+      const fresh = new Clipboard();
+      fresh.parse(json);
+
+      expect(fresh.Entities[0].getProperty('closed')).toBe(false);
+    });
+  });
 });

package/test/properties/flags.test.js

@@ -162,3 +162,27 @@ test('Test flags.removeValue', () => {
   // 2 shouldn't exist again
   expect(flags.hasFlag(2)).toBe(false);
 });
+
+test('Test flags.toJSON returns the numeric flag value', () => {
+  const flags = new Flags();
+  expect(flags.toJSON()).toBe(0);
+
+  flags.setFlagValue(7);
+  expect(flags.toJSON()).toBe(7);
+});
+
+test('Test flags.toJSON round-trips through JSON.stringify/parse', () => {
+  const flags = new Flags();
+  flags.setFlagValue(1);
+
+  // JSON.stringify should produce the plain number, not a nested object
+  const json = JSON.stringify({ flags });
+  expect(json).toBe('{"flags":1}');
+
+  // The parsed value is a plain number — Flags constructor accepts it via setFlagValue
+  const parsed = JSON.parse(json);
+  const restored = new Flags();
+  restored.setFlagValue(parsed.flags);
+  expect(restored.getFlagValue()).toBe(1);
+  expect(restored.hasFlag(1)).toBe(true);
+});

package/test/properties/propertyManager.test.js

@@ -113,3 +113,74 @@ test('Test propertyManager.getEntityPropertyValue', () => {
   propertyValues = propertiesManager.getEntityPropertyValue('All', 'colour');
   expect(propertyValues).toBe('Varies');
 });
+
+test('Test propertyManager.getEntityPropertyDefinition', () => {
+  // clear the selection set
+  DesignCore.Scene.reset();
+
+  // returns undefined when nothing is selected
+  let def = propertiesManager.getEntityPropertyDefinition('All', 'colour');
+  expect(def).toBeUndefined();
+
+  // select the line entity
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(0);
+
+  // returns a Property descriptor for a valid property
+  def = propertiesManager.getEntityPropertyDefinition('All', 'colour');
+  expect(def).toBeDefined();
+  expect(typeof def.type).toBe('string');
+
+  // returns undefined for a property the entity does not have
+  def = propertiesManager.getEntityPropertyDefinition('All', 'non-existent-prop');
+  expect(def).toBeUndefined();
+
+  // filters by entityType — Circle not selected, so returns undefined
+  def = propertiesManager.getEntityPropertyDefinition('Circle', 'colour');
+  expect(def).toBeUndefined();
+});
+
+test('Test propertyManager.getEntityForProperty', () => {
+  // clear the selection set
+  DesignCore.Scene.reset();
+
+  // returns undefined when nothing is selected
+  let entity = propertiesManager.getEntityForProperty('All', 'colour');
+  expect(entity).toBeUndefined();
+
+  // select the line (index 0) and circle (index 1)
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(0);
+  DesignCore.Scene.selectionManager.selectionSet.selectionSet.push(1);
+
+  // returns an entity for 'All' and a known property
+  entity = propertiesManager.getEntityForProperty('All', 'colour');
+  expect(entity).toBeDefined();
+  expect(entity.type === 'Line' || entity.type === 'Circle').toBe(true);
+
+  // filters by entityType — only Circle entities
+  entity = propertiesManager.getEntityForProperty('Circle', 'colour');
+  expect(entity).toBeDefined();
+  expect(entity.type).toBe('Circle');
+
+  // returns undefined when the property does not exist on any selected entity
+  entity = propertiesManager.getEntityForProperty('All', 'non-existent-prop');
+  expect(entity).toBeUndefined();
+});
+
+test('Test propertyManager.setPropertyCallbackFunction and selectionSetChanged', () => {
+  let callCount = 0;
+  const callback = () => {
+    callCount++;
+  };
+
+  // selectionSetChanged with no callback set should not throw
+  propertiesManager.selectionSetChanged();
+
+  propertiesManager.setPropertyCallbackFunction(callback);
+
+  // callback is invoked when selectionSetChanged is called
+  propertiesManager.selectionSetChanged();
+  expect(callCount).toBe(1);
+
+  propertiesManager.selectionSetChanged();
+  expect(callCount).toBe(2);
+});

package/test/tools/zoom.test.js

@@ -181,40 +181,38 @@ test('Test Canvas.zoomToWindow - reversed points', () => {
   expect(finalScale).not.toBe(initialScale);
 });
 
-test('Test Canvas.zoomToWindow - zero width (should not zoom)', () => {
+test('Test Canvas.zoomToWindow - zero width (zooms using height)', () => {
   core.canvas.width = 800;
   core.canvas.height = 600;
   core.canvas.matrix.scale(1, 1);
 
-  const initialScale = core.canvas.getScale();
-
-  // Points with same x coordinate (zero width)
+  // Points with same x coordinate (zero width, i.e. a vertical line)
   const pt1 = new Point(50, 0);
   const pt2 = new Point(50, 100);
 
   core.canvas.zoomToWindow(pt1, pt2);
 
-  // Should not change scale
+  // Resulting scale depends only on the window size, not the prior scale,
+  // so assert the expected value rather than comparing against initialScale
   const finalScale = core.canvas.getScale();
-  expect(finalScale).toBe(initialScale);
+  expect(finalScale).toBeCloseTo((core.canvas.height / 100) * 0.9);
 });
 
-test('Test Canvas.zoomToWindow - zero height (should not zoom)', () => {
+test('Test Canvas.zoomToWindow - zero height (zooms using width)', () => {
   core.canvas.width = 800;
   core.canvas.height = 600;
   core.canvas.matrix.scale(1, 1);
 
-  const initialScale = core.canvas.getScale();
-
-  // Points with same y coordinate (zero height)
+  // Points with same y coordinate (zero height, i.e. a horizontal line)
   const pt1 = new Point(0, 50);
   const pt2 = new Point(100, 50);
 
   core.canvas.zoomToWindow(pt1, pt2);
 
-  // Should not change scale
+  // Resulting scale depends only on the window size, not the prior scale,
+  // so assert the expected value rather than comparing against initialScale
   const finalScale = core.canvas.getScale();
-  expect(finalScale).toBe(initialScale);
+  expect(finalScale).toBeCloseTo((core.canvas.width / 100) * 0.9);
 });
 
 test('Test Canvas.zoomToWindow - same point (should not zoom)', () => {