@design-core/core 50.1.0 → 51.2.0

package/cspell.json

@@ -141,6 +141,8 @@
         "EXTMIN",
         "FILLETRAD",
         "FONTNAME",
+        "HATCHDOUBLE",
+        "HATCHSPACING",
         "groupcode",
         "groupcodes",
         "groupvalue",
@@ -193,6 +195,7 @@
         "RRGGBB",
         "rubberbandcolour",
         "SCALEFACTOR",
+        "SECONDCORNER",
         "selectedchild",
         "SELECTIONSET",
         "SEQEND",
@@ -275,6 +278,7 @@
         "INVALIDFILE",
         "INVALIDGROUPCODE",
         "INVALIDINTERSECTTYPE",
+        "FIRSTCORNER",
         "INVALIDNUMBER",
         "INVALIDPOINT",
         "INVALIDTYPE",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-core/core",
-  "version": "50.1.0",
+  "version": "51.2.0",
   "type": "module",
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
@@ -19,7 +19,12 @@
     ".": "./core/core/core.js",
     "./designCore.js": "./core/designCore.js",
     "./property.js": "./core/properties/property.js",
-    "./canvasRenderer.js": "./core/lib/renderers/canvasRenderer.js"
+    "./canvasRenderer.js": "./core/lib/renderers/canvasRenderer.js",
+    "./constants.js": "./core/lib/constants.js",
+    "./plotOptions.js": "./core/lib/plotOptions.js",
+    "./rendererBase.js": "./core/lib/renderers/rendererBase.js",
+    "./svgRenderer.js": "./core/lib/renderers/svgRenderer.js",
+    "./pdfRenderer.js": "./core/lib/renderers/pdfRenderer.js"
   },
   "directories": {
     "test": "test"

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/integration/plotPageSizeIntegration.test.js

@@ -0,0 +1,113 @@
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
+import { Constants } from '../../core/lib/constants.js';
+import { PlotOptions } from '../../core/lib/plotOptions.js';
+import { BoundingBox } from '../../core/lib/boundingBox.js';
+import { SvgRenderer } from '../../core/lib/renderers/svgRenderer.js';
+import { jest } from '@jest/globals';
+
+// smallest -> largest; each rectangle fully contains all previous ones when aligned at the origin
+const PAGE_NAMES_ASC = ['A4', 'A3', 'A2', 'A1', 'A0'];
+
+// Portrait uses the raw (width < height) page size; Landscape swaps the two axes,
+// matching the orientation toggle in the GTK plot dialog (plotWindow.js)
+const ORIENTATIONS = {
+  Portrait: (size) => ({ pageWidth: size.width, pageHeight: size.height }),
+  Landscape: (size) => ({ pageWidth: size.height, pageHeight: size.width }),
+};
+
+/**
+ * Build a closed 4-corner loop, mirroring Rectangle.rectPoints()
+ * @param {Point} pt1
+ * @param {Point} pt2
+ * @return {Array}
+ */
+function rectPoints(pt1, pt2) {
+  return [
+    new Point(pt1.x, pt1.y),
+    new Point(pt2.x, pt1.y),
+    new Point(pt2.x, pt2.y),
+    new Point(pt1.x, pt2.y),
+    new Point(pt1.x, pt1.y),
+  ];
+}
+
+describe.each(Object.keys(ORIENTATIONS))('%s orientation', (orientation) => {
+  const toPage = ORIENTATIONS[orientation];
+
+  test.each(PAGE_NAMES_ASC)('Extents matches %s page size exactly', (name) => {
+    const { pageWidth, pageHeight } = toPage(Constants.PageSizes[name]);
+    const core = new Core();
+    core.activate();
+    core.scene.addEntity('Polyline', { points: rectPoints(new Point(0, 0), new Point(pageWidth, pageHeight)) });
+
+    const area = core.scene.boundingBox();
+    expect(area.xLength).toBeCloseTo(pageWidth, 5);
+    expect(area.yLength).toBeCloseTo(pageHeight, 5);
+
+    const matrix = core.canvas.buildExportMatrix({
+      area, pageWidth, pageHeight, plotScale: 1, margin: 0,
+    });
+    expect(matrix.a).toBe(1);
+    expect(matrix.e).toBeCloseTo(0, 5);
+    expect(matrix.f).toBeCloseTo(0, 5);
+  });
+
+  test('Extents grows to match each page size as rectangles are added smallest to largest', () => {
+    const core = new Core();
+    core.activate();
+
+    for (const name of PAGE_NAMES_ASC) {
+      const { pageWidth, pageHeight } = toPage(Constants.PageSizes[name]);
+      core.scene.addEntity('Polyline', { points: rectPoints(new Point(0, 0), new Point(pageWidth, pageHeight)) });
+
+      const area = core.scene.boundingBox();
+      expect(area.xLength).toBeCloseTo(pageWidth, 5);
+      expect(area.yLength).toBeCloseTo(pageHeight, 5);
+    }
+  });
+
+  test('Window area isolates each nested rectangle regardless of surrounding sizes', () => {
+    const core = new Core();
+    core.activate();
+
+    const rects = {};
+    for (const name of PAGE_NAMES_ASC) {
+      const { pageWidth, pageHeight } = toPage(Constants.PageSizes[name]);
+      rects[name] = { p1: new Point(0, 0), p2: new Point(pageWidth, pageHeight) };
+      core.scene.addEntity('Polyline', { points: rectPoints(rects[name].p1, rects[name].p2) });
+    }
+
+    for (const name of PAGE_NAMES_ASC) {
+      const { pageWidth, pageHeight } = toPage(Constants.PageSizes[name]);
+      const { p1, p2 } = rects[name];
+
+      const windowArea = new BoundingBox(p1, p2);
+      expect(windowArea.xLength).toBeCloseTo(pageWidth, 5);
+      expect(windowArea.yLength).toBeCloseTo(pageHeight, 5);
+
+      // full exportTo path: WINDOW plotArea must isolate only this rectangle's bounds,
+      // not the full-scene extents (which would be A0 for every iteration)
+      const plotOptions = new PlotOptions(pageWidth, pageHeight);
+      plotOptions.setOption('plotArea', PlotOptions.Area.WINDOW);
+      plotOptions.setOption('windowArea', { point1: p1, point2: p2 });
+      plotOptions.setOption('plotScale', 1);
+      plotOptions.setOption('margin', 0);
+
+      const renderer = new SvgRenderer(pageWidth, pageHeight);
+      const setTransformSpy = jest.spyOn(renderer, 'setTransform');
+      expect(core.canvas.exportTo(renderer, plotOptions)).toBe(true);
+
+      // with plotScale 1 and margin 0, the matrix must map exactly this rectangle's
+      // own bounds onto the page - a full-scene (A0) fallback would produce a very
+      // different translation since every rect shares the same (0,0) origin
+      const matrix = setTransformSpy.mock.calls[0][0];
+      expect(matrix.a).toBe(1);
+      expect(matrix.d).toBe(1);
+      expect(matrix.e).toBeCloseTo(0, 5);
+      expect(matrix.f).toBeCloseTo(0, 5);
+
+      setTransformSpy.mockRestore();
+    }
+  });
+});

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/lib/plotOptions.test.js

@@ -130,7 +130,7 @@ test('setOption accepts PlotOptions.Area.DISPLAY for plotArea', () => {
 
 test('setOption throws for an unknown plotArea value', () => {
   const po = new PlotOptions(595, 842);
-  expect(() => po.setOption('plotArea', 'Window')).toThrow('plotArea');
+  expect(() => po.setOption('plotArea', 'Unknown')).toThrow('plotArea');
 });
 
 // ─── setOption — style ────────────────────────────────────────────────────────
@@ -152,6 +152,63 @@ test('setOption throws when style is not a function', () => {
   expect(() => po.setOption('style', 'monochrome')).toThrow('style');
 });
 
+// ─── setOption — margin ───────────────────────────────────────────────────────
+
+test('setOption accepts a valid margin', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('margin', 40);
+  expect(po.margin).toBe(40);
+});
+
+test('setOption accepts zero margin', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('margin', 0);
+  expect(po.margin).toBe(0);
+});
+
+test('setOption throws for negative margin', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('margin', -1)).toThrow('margin');
+});
+
+test('setOption throws for non-numeric margin', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('margin', '40')).toThrow('margin');
+});
+
+test('setOption throws for NaN margin', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('margin', NaN)).toThrow('margin');
+});
+
+test('setOption throws for Infinity margin', () => {
+  const po = new PlotOptions(595, 842);
+  expect(() => po.setOption('margin', Infinity)).toThrow('margin');
+});
+
+test('setOption throws when margin leaves zero usable width', () => {
+  const po = new PlotOptions(595, 842);
+  // 297.5 * 2 === pageWidth -> usable width would be exactly 0
+  expect(() => po.setOption('margin', 297.5)).toThrow('usable page area');
+});
+
+test('setOption throws when margin leaves zero usable height', () => {
+  const po = new PlotOptions(842, 595);
+  expect(() => po.setOption('margin', 297.5)).toThrow('usable page area');
+});
+
+test('setOption throws when margin exceeds half the narrower page dimension only', () => {
+  const po = new PlotOptions(595, 842);
+  // exceeds half of pageWidth (297.5) but not half of pageHeight (421)
+  expect(() => po.setOption('margin', 300)).toThrow('usable page area');
+});
+
+test('setOption accepts a margin just under half the narrower page dimension', () => {
+  const po = new PlotOptions(595, 842);
+  po.setOption('margin', 297);
+  expect(po.margin).toBe(297);
+});
+
 // ─── setOption — fileType ─────────────────────────────────────────────────────
 
 test('setOption accepts pdf for fileType', () => {

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);
+});