@design-core/core 50.1.0 → 51.2.0

package/.github/workflows/publish.yml

@@ -0,0 +1,40 @@
+# Publishes @design-core/core to npm when a semver tag (e.g. v51.1.0) is pushed.
+# Requires an NPM_TOKEN repository secret (an "Automation" type npm access token).
+name: Publish to npm
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Use Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.x
+          registry-url: 'https://registry.npmjs.org'
+
+      - run: npm ci
+      - run: npm test -- --coverage
+      - run: npx eslint . --ext .js
+
+      # Fail fast if the tag and package.json version have drifted apart
+      - name: Verify tag matches package.json version
+        run: |
+          PKG_VERSION=$(node -p "require('./package.json').version")
+          TAG_VERSION=${GITHUB_REF_NAME#v}
+          if [ "$PKG_VERSION" != "$TAG_VERSION" ]; then
+            echo "Tag v$TAG_VERSION does not match package.json version $PKG_VERSION"
+            exit 1
+          fi
+
+      - name: Publish to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -14,10 +14,23 @@ Design-Core uses the industry standard Drawing Exchange Format (DXF) to read and
 * Design-Web: https://github.com/dubstar-04/Design-Web
 * HTML Canvas: https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API
 * Cairo: https://www.cairographics.org/
+* npm package: https://www.npmjs.com/package/@design-core/core
 
 
 ## Publishing
 
-npm login
+Releases are published to npm automatically by the [Publish to npm](.github/workflows/publish.yml) workflow whenever a `v*.*.*` tag is pushed:
+
+```bash
+npm version patch   # or minor / major, bumps package.json and creates a git tag
+git push --follow-tags
+```
+
+The workflow runs the test suite and linter, verifies the tag matches `package.json`'s version, then publishes.
 
+To publish manually instead:
+
+```bash
+npm login
 npm publish --access public
+```

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);
@@ -300,7 +305,9 @@ export class Canvas {
    */
   exportTo(renderer, plotOptions) {
     let area;
-    if (plotOptions.plotArea === PlotOptions.Area.DISPLAY) {
+    if (plotOptions.plotArea === PlotOptions.Area.WINDOW) {
+      area = new BoundingBox(plotOptions.windowArea.point1, plotOptions.windowArea.point2);
+    } else if (plotOptions.plotArea === PlotOptions.Area.DISPLAY) {
       const viewport = this.getSceneOffset();
       area = new BoundingBox(new Point(viewport.xmin, viewport.ymin), new Point(viewport.xmax, viewport.ymax));
     } else {
@@ -313,6 +320,7 @@ export class Canvas {
       pageWidth: plotOptions.pageWidth,
       pageHeight: plotOptions.pageHeight,
       plotScale: plotOptions.plotScale,
+      margin: plotOptions.margin,
     });
     if (!matrix) return false;
 

package/core/lib/commandManager.js

@@ -43,6 +43,9 @@ import { Purge } from '../tools/purge.js';
 import { Pan } from '../tools/pan.js';
 import { Zoom } from '../tools/zoom.js';
 
+// Internal tools (not shown in any toolbar, invoked programmatically)
+import { WindowPick } from '../tools/windowPick.js';
+
 // Clipboard tools
 import { Copybase } from '../tools/copybase.js';
 import { Copyclip } from '../tools/copyclip.js';
@@ -99,6 +102,8 @@ const classes = {
   Zoom,
   Pan,
 
+  WindowPick,
+
   Copybase,
   Copyclip,
   Cutclip,

package/core/lib/inputManager.js

@@ -39,6 +39,7 @@ export class InputManager {
     }
 
     this.promptOption = undefined;
+    DesignCore.Mouse.reset();
     DesignCore.Scene.reset();
     DesignCore.Canvas.setCursorForInputTypes([]);
   }

package/core/lib/mouse.js

@@ -15,6 +15,16 @@ export class Mouse {
     this.lastButton = 0; // last button for double click check
   }
 
+  /**
+   * Clear button state - guards against a stuck button when a mouseUp
+   * never reaches the canvas (e.g. focus stolen by another window mid-click)
+   */
+  reset() {
+    this.buttonOneDown = false;
+    this.buttonTwoDown = false;
+    this.buttonThreeDown = false;
+  }
+
   /**
    * Returns the point on the design canvas
    * @return {Point}

package/core/lib/plotOptions.js

@@ -9,6 +9,7 @@ export class PlotOptions {
   static Area = {
     EXTENTS: 'Extents',
     DISPLAY: 'Display',
+    WINDOW: 'Window',
   };
 
   static #fileTypes = ['pdf', 'svg'];
@@ -22,6 +23,8 @@ export class PlotOptions {
     this.setOption('pageHeight', pageHeight);
     this.plotScale = null;
     this.plotArea = PlotOptions.Area.EXTENTS;
+    this.windowArea = null;
+    this.margin = 40;
     this.style = RendererBase.Styles.NONE;
     this.fileType = 'pdf';
   }
@@ -49,6 +52,20 @@ export class PlotOptions {
           throw new Error(`PlotOptions: plotArea must be one of: ${Object.values(PlotOptions.Area).join(', ')}`);
         }
         break;
+      case 'windowArea':
+        // required when plotArea is WINDOW - two points defining the plot window, e.g. { point1, point2 }
+        if (value !== null && (!value || value.point1 === undefined || value.point2 === undefined)) {
+          throw new Error('PlotOptions: windowArea must be null or an object with point1 and point2');
+        }
+        break;
+      case 'margin':
+        if (!Number.isFinite(value) || value < 0) {
+          throw new Error('PlotOptions: margin must be a non-negative finite number');
+        }
+        if (this.pageWidth - 2 * value <= 0 || this.pageHeight - 2 * value <= 0) {
+          throw new Error('PlotOptions: margin leaves no usable page area');
+        }
+        break;
       case 'style':
         if (typeof value !== 'function') {
           throw new Error('PlotOptions: style must be a function');

package/core/lib/strings.js

@@ -110,6 +110,8 @@ export class Strings {
     DESTINATIONSET: 'Select destination object(s)',
     MIRRORFIRST: 'Specify first point of mirror line',
     MIRRORSECOND: 'Specify second point of mirror line',
+    FIRSTCORNER: 'Specify first corner',
+    SECONDCORNER: 'Specify second corner',
     ERASESOURCE: 'Erase source objects?',
     SCALEFACTOR: 'Specify scale factor',
     REFERENCELENGTH: 'Specify reference length',

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/core/tools/windowPick.js

@@ -0,0 +1,75 @@
+import { Tool } from './tool.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Strings } from '../lib/strings.js';
+import { Logging } from '../lib/logging.js';
+import { Point } from '../entities/point.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * WindowPick Command Class
+ * Internal tool used to interactively pick two corner points defining a rectangular window (e.g. for the plot window area).
+ * Not shown in any toolbar; invoked programmatically.
+ * @extends Tool
+ */
+export class WindowPick extends Tool {
+  static type = 'WindowPick';
+
+  /** Create a WindowPick command */
+  constructor() {
+    super();
+  }
+
+  /**
+   * Register the command
+   * @return {Object}
+   * command = name of the command
+   */
+  static register() {
+    const command = { command: 'WindowPick' };
+    return command;
+  }
+
+  /**
+   * Execute method
+   * requests the two corner points defining the plot window
+   */
+  async execute() {
+    try {
+      const op1 = new PromptOptions(Strings.Input.FIRSTCORNER, [Input.Type.POINT]);
+      const pt1 = await DesignCore.Scene.inputManager.requestInput(op1);
+      if (pt1 === undefined) return;
+      this.points.push(pt1);
+
+      const op2 = new PromptOptions(Strings.Input.SECONDCORNER, [Input.Type.POINT]);
+      const pt2 = await DesignCore.Scene.inputManager.requestInput(op2);
+      if (pt2 === undefined) return;
+      this.points.push(pt2);
+
+      DesignCore.Scene.inputManager.executeCommand();
+    } catch (err) {
+      Logging.instance.error(`${this.type} - ${err}`);
+    }
+  }
+
+  /**
+   * Preview the command during execution
+   */
+  preview() {
+    if (this.points.length === 1) {
+      const mousePoint = DesignCore.Mouse.pointOnScene();
+      const p1 = this.points[0];
+      const p2 = mousePoint;
+
+      const points = [
+        new Point(p1.x, p1.y),
+        new Point(p2.x, p1.y),
+        new Point(p2.x, p2.y),
+        new Point(p1.x, p2.y),
+        new Point(p1.x, p1.y),
+      ];
+
+      DesignCore.Scene.previewEntities.create('Polyline', { points: points });
+    }
+  }
+}