@design-core/core 0.0.7 → 51.1.0

package/test/entities/hatch.test.js

@@ -1,8 +1,9 @@
 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';
 
-import { BasePolyline } from '../../core/entities/basePolyline.js';
+import { PolylineBase } from '../../core/entities/polylineBase.js';
 import { Circle } from '../../core/entities/circle.js';
 import { Line } from '../../core/entities/line.js';
 import { Polyline } from '../../core/entities/polyline.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';
 
@@ -17,7 +20,7 @@ import { Core } from '../../core/core/core.js';
 new Core();
 
 const points = [new Point(100, 100, 1), new Point(200, 100, 1)];
-const boundaryShape = new BasePolyline({ points: points });
+const boundaryShape = new PolylineBase({ points: points });
 
 const hatch = new Hatch({ handle: '1' });
 hatch.setProperty('childEntities', [boundaryShape]);
@@ -56,10 +59,10 @@ test.each(hatchInputScenarios)('Hatch.execute handles $desc', async (scenario) =
 
   await withMockInput(DesignCore.Scene, [true], async () => {
     // Manual mock for selected items
-    DesignCore.Scene.selectionManager.selectedItems = [];
+    DesignCore.Scene.selectionManager.selectedEntities = [];
 
     for (let i = 0; i < boundaryItems.length; i++) {
-      DesignCore.Scene.selectionManager.selectedItems.push(boundaryItems[i]);
+      DesignCore.Scene.selectionManager.selectedEntities.push(boundaryItems[i]);
     }
 
     const hatch = new Hatch({ patternName: pattern, scale: scale, angle: angle });
@@ -448,60 +451,60 @@ test('Test Hatch.processBoundaryData', () => {
 
 test('Test Hatch.processSelection', () => {
   // create selected items defining a square
-  let selectedItems = [];
-  selectedItems.push(new Line({ points: [new Point(100, 100), new Point(200, 100)] }));
-  selectedItems.push(new Line({ points: [new Point(200, 100), new Point(200, 200)] }));
-  selectedItems.push(new Line({ points: [new Point(200, 200), new Point(100, 200)] }));
-  selectedItems.push(new Line({ points: [new Point(100, 200), new Point(100, 100)] }));
+  let selectedEntities = [];
+  selectedEntities.push(new Line({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedEntities.push(new Line({ points: [new Point(200, 100), new Point(200, 200)] }));
+  selectedEntities.push(new Line({ points: [new Point(200, 200), new Point(100, 200)] }));
+  selectedEntities.push(new Line({ points: [new Point(100, 200), new Point(100, 100)] }));
 
   let hatch = new Hatch();
-  let boundaryData = hatch.processSelection(selectedItems);
+  let boundaryData = hatch.processSelection(selectedEntities);
   expect(boundaryData.length).toEqual(1);
   expect(boundaryData[0].points.length).toEqual(4);
 
 
   // create selected items defining a circle
-  selectedItems = [];
-  selectedItems.push(new Circle({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedEntities = [];
+  selectedEntities.push(new Circle({ points: [new Point(100, 100), new Point(200, 100)] }));
 
   hatch = new Hatch();
-  boundaryData = hatch.processSelection(selectedItems);
+  boundaryData = hatch.processSelection(selectedEntities);
   expect(boundaryData.length).toEqual(1);
   expect(boundaryData[0].points.length).toEqual(2);
 
   // create selected items defining a square (polyline)
-  selectedItems = [];
-  selectedItems.push(new Polyline({
+  selectedEntities = [];
+  selectedEntities.push(new Polyline({
     points: [new Point(100, 100), new Point(200, 100), new Point(200, 200),
       new Point(100, 200), new Point(100, 100)],
   }));
 
   hatch = new Hatch();
-  boundaryData = hatch.processSelection(selectedItems);
+  boundaryData = hatch.processSelection(selectedEntities);
   expect(boundaryData.length).toEqual(1);
   expect(boundaryData[0].points.length).toEqual(4);
 
   // create selected items defining a pill shape
-  selectedItems = [];
-  selectedItems.push(new Line({ points: [new Point(100, 100), new Point(200, 100)] }));
-  selectedItems.push(new Arc({ points: [new Point(200, 150), new Point(200, 100), new Point(200, 200)] }));
-  selectedItems.push(new Line({ points: [new Point(200, 200), new Point(100, 200)] }));
-  selectedItems.push(new Arc({ points: [new Point(100, 150), new Point(100, 200), new Point(100, 100)] }));
+  selectedEntities = [];
+  selectedEntities.push(new Line({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedEntities.push(new Arc({ points: [new Point(200, 150), new Point(200, 100), new Point(200, 200)] }));
+  selectedEntities.push(new Line({ points: [new Point(200, 200), new Point(100, 200)] }));
+  selectedEntities.push(new Arc({ points: [new Point(100, 150), new Point(100, 200), new Point(100, 100)] }));
 
   hatch = new Hatch();
-  boundaryData = hatch.processSelection(selectedItems);
+  boundaryData = hatch.processSelection(selectedEntities);
   expect(boundaryData.length).toEqual(1);
   // 2 lines + 2 arcs: each shared connection point is merged (not duplicated),
   // so the result is 4 unique vertices, not 5
   expect(boundaryData[0].points.length).toEqual(4);
 
   // Test a selection with invalid items
-  selectedItems = [];
-  selectedItems.push(new Text({ points: [new Point(100, 100), new Point(200, 100)] }));
-  selectedItems.push(new Circle({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedEntities = [];
+  selectedEntities.push(new Text({ points: [new Point(100, 100), new Point(200, 100)] }));
+  selectedEntities.push(new Circle({ points: [new Point(100, 100), new Point(200, 100)] }));
 
   hatch = new Hatch();
-  boundaryData = hatch.processSelection(selectedItems);
+  boundaryData = hatch.processSelection(selectedEntities);
   expect(boundaryData.length).toEqual(1);
   expect(boundaryData[0].points.length).toEqual(2);
 });
@@ -539,7 +542,7 @@ function makeMockCtx() {
 
 test('Test Hatch.draw solid fill renders filled boundary', () => {
   const solidHatch = new Hatch({ patternName: 'SOLID' });
-  solidHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
+  solidHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
 
   const ctx = makeMockCtx();
   solidHatch.draw(ctx);
@@ -549,7 +552,7 @@ test('Test Hatch.draw solid fill renders filled boundary', () => {
 
 test('Test Hatch.draw unknown pattern does not stroke pattern lines', () => {
   const unknownHatch = new Hatch({ patternName: 'ANSI31' });
-  unknownHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
+  unknownHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
   // Override pattern to a nonexistent name
   unknownHatch.setProperty('patternName', 'NOTAPATTERN');
 
@@ -567,7 +570,7 @@ test('Test Hatch.draw tight bound line count - square boundary', () => {
   // yIncrement = ceil(70.71 / 3.175) = 23 → loop i=-23..22 = 46 raw lines
   // i=-23 (|ly|=73.025 > halfY=70.71) misses the square → 45 clipped segments
   const squareHatch = new Hatch({ patternName: 'ANSI31' });
-  squareHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
+  squareHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
   const ctx = makeMockCtx();
   squareHatch.draw(ctx);
   expect(ctx.getMoveCalls()).toBe(45);
@@ -580,7 +583,7 @@ test('Test Hatch.draw tight bound line count - flat boundary', () => {
   // yIncrement = ceil(38.89 / 3.175) = 13 → loop i=-13..12 = 26 raw lines
   // i=-13 (|ly|=41.275 > halfY=38.89) misses the flat box → 25 clipped segments
   const flatHatch = new Hatch({ patternName: 'ANSI31' });
-  flatHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 10), new Point(0, 10)] })]);
+  flatHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 10), new Point(0, 10)] })]);
   const ctx = makeMockCtx();
   flatHatch.draw(ctx);
   expect(ctx.getMoveCalls()).toBe(25);
@@ -589,10 +592,10 @@ test('Test Hatch.draw tight bound line count - flat boundary', () => {
 test('Test Hatch.draw tight bound produces fewer lines for flat boundary', () => {
   // A flat boundary (100x10) should produce fewer lines than a square (100x100).
   const squareHatch = new Hatch({ patternName: 'ANSI31' });
-  squareHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
+  squareHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
 
   const flatHatch = new Hatch({ patternName: 'ANSI31' });
-  flatHatch.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 10), new Point(0, 10)] })]);
+  flatHatch.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 10), new Point(0, 10)] })]);
 
   const squareCtx = makeMockCtx();
   squareHatch.draw(squareCtx);
@@ -614,14 +617,14 @@ test('Hatch.buildPatternCache no childEntities sets cachedPattern to empty array
 
 test('Hatch.buildPatternCache solid fill sets cachedPattern to empty array', () => {
   const h = new Hatch({ patternName: 'SOLID' });
-  h.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
+  h.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
   h.buildPatternCache();
   expect(h.cachedPattern).toEqual([]);
 });
 
 test('Hatch.buildPatternCache unknown pattern sets cachedPattern to empty array', () => {
   const h = new Hatch({ patternName: 'HONEY' });
-  h.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
+  h.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })]);
   h.setProperty('patternName', 'NOTAPATTERN');
   h.buildPatternCache();
   expect(h.cachedPattern).toEqual([]);
@@ -631,9 +634,9 @@ test('Hatch.buildPatternCache unknown pattern sets cachedPattern to empty array'
 
 /**
  * Build a 100×100 square boundary
- * @return {Array} array containing one BasePolyline boundary
+ * @return {Array} array containing one PolylineBase boundary
  */
-const makeSquare = () => [new BasePolyline({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })];
+const makeSquare = () => [new PolylineBase({ points: [new Point(0, 0), new Point(100, 0), new Point(100, 100), new Point(0, 100)] })];
 
 /**
  * Sum all segment counts across all families in a cached hatch
@@ -731,9 +734,9 @@ test('Hatch.buildPatternCache scale change invalidates and rebuilds cache with u
 
 /**
  * A 20×20 inner square hole centred in the 100×100 outer square
- * @return {BasePolyline} inner boundary polyline
+ * @return {PolylineBase} inner boundary polyline
  */
-const makeInnerSquare = () => new BasePolyline({ points: [new Point(40, 40), new Point(60, 40), new Point(60, 60), new Point(40, 60)] });
+const makeInnerSquare = () => new PolylineBase({ points: [new Point(40, 40), new Point(60, 40), new Point(60, 60), new Point(40, 60)] });
 
 test('Hatch.buildPatternCache ANSI31 nested boundary: no segment midpoint inside inner hole', () => {
   // Even-odd rule: a ray from inside the hole crosses 2 boundaries → even → not hatched
@@ -951,7 +954,7 @@ test('Hatch.setProperty patternName updates pattern and solid flag via setter',
 test('Hatch.setProperty points translation shifts child entity positions', () => {
   const h = new Hatch({ patternName: 'ANSI31' });
   // h.points = [Point(0,0), Point(1,1)] — 45° angle set by constructor
-  h.setProperty('childEntities', [new BasePolyline({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
+  h.setProperty('childEntities', [new PolylineBase({ points: [new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(0, 10)] })]);
 
   // New points: same 45° angle (delta angle = 0 → no rotation), origin shifted by (5, 0)
   h.setProperty('points', [new Point(5, 0), new Point(6, 1)]);
@@ -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/entities/insert.test.js

@@ -13,10 +13,10 @@ new Core();
 
 const insert = new Insert({ handle: '1', points: [new Point()] });
 const line = new Line({ points: [new Point(101, 102), new Point(201, 202)] });
-insert.block.addItem(line);
+insert.block.addEntity(line);
 
 const rotatedInsert = new Insert({ points: [new Point()], rotation: 45 });
-rotatedInsert.block.addItem(line);
+rotatedInsert.block.addEntity(line);
 
 test('Test Insert.snaps', () => {
   const point = new Point(100, 100);
@@ -51,7 +51,7 @@ test('Test Insert.boundingBox', () => {
   expect(insert.boundingBox().yMax).toBeCloseTo(202);
 
   const line2 = new Line({ points: [new Point(1001, 1002), new Point(2001, 2002)] });
-  insert.block.addItem(line2);
+  insert.block.addEntity(line2);
 
   expect(insert.boundingBox().xMin).toBeCloseTo(101);
   expect(insert.boundingBox().xMax).toBeCloseTo(2001);
@@ -115,17 +115,17 @@ describe('Test Insert.draw', () => {
   test('draw() returns the block items array', () => {
     const ins = new Insert({ points: [new Point(0, 0)] });
     const line = new Line({ points: [new Point(0, 0), new Point(1, 1)] });
-    ins.block.addItem(line);
+    ins.block.addEntity(line);
 
     const result = ins.draw(makeMockCtx());
-    expect(result).toBe(ins.block.items);
+    expect(result).toBe(ins.block.entities);
   });
 
   test('draw() returns empty array when block has no items', () => {
     const ins = new Insert({ points: [new Point(0, 0)] });
     const result = ins.draw(makeMockCtx());
     expect(result).toEqual([]);
-    expect(result).toBe(ins.block.items);
+    expect(result).toBe(ins.block.entities);
   });
 
   test('draw() calls renderer.applyTransform with the insert point coordinates', () => {
@@ -159,9 +159,9 @@ describe('Test Insert.draw', () => {
   test('draw() returns same items reference regardless of scale', () => {
     const ins = new Insert({ points: [new Point(0, 0)] });
     const line = new Line({ points: [new Point(0, 0), new Point(1, 1)] });
-    ins.block.addItem(line);
-    expect(ins.draw(makeMockCtx())).toBe(ins.block.items);
-    expect(ins.draw(makeMockCtx())).toBe(ins.block.items);
+    ins.block.addEntity(line);
+    expect(ins.draw(makeMockCtx())).toBe(ins.block.entities);
+    expect(ins.draw(makeMockCtx())).toBe(ins.block.entities);
   });
 });
 

package/test/entities/point.test.js

@@ -701,7 +701,7 @@ test('Test Point.bulgeAngle', () => {
 
 test('Test Point.bulgeRadius', () => {
   // start point: 100,0
-  // center: 100,50
+  // centre: 100,50
   // radius: 50
   const point = new Point(100, 0);
 
@@ -771,7 +771,7 @@ test('Test Point.bulgeRadius', () => {
 
 test('Test Point.apothem', () => {
   // start point: 100,0
-  // center: 100,50
+  // centre: 100,50
   // radius: 50
   const point = new Point(100, 0);
 
@@ -829,7 +829,7 @@ test('Test Point.apothem', () => {
 
 test('Test Point.bulgeCentrePoint', () => {
   // start point: 100,0
-  // center: 100,50
+  // centre: 100,50
   // radius: 50
   const point = new Point(100, 0);