@design-core/core 51.1.0 → 52.0.0

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/renderers/pdfRenderer.js

@@ -1,6 +1,16 @@
 import { RendererBase } from './rendererBase.js';
 import { Text } from '../../entities/text.js';
 
+// Unicode code points mapped to WinAnsi bytes 0x80-0x9F (the range where WinAnsi differs from Latin-1)
+const WIN_ANSI_EXTRAS = new Map([
+  [0x20ac, 0x80], [0x201a, 0x82], [0x0192, 0x83], [0x201e, 0x84], [0x2026, 0x85],
+  [0x2020, 0x86], [0x2021, 0x87], [0x02c6, 0x88], [0x2030, 0x89], [0x0160, 0x8a],
+  [0x2039, 0x8b], [0x0152, 0x8c], [0x017d, 0x8e], [0x2018, 0x91], [0x2019, 0x92],
+  [0x201c, 0x93], [0x201d, 0x94], [0x2022, 0x95], [0x2013, 0x96], [0x2014, 0x97],
+  [0x02dc, 0x98], [0x2122, 0x99], [0x0161, 0x9a], [0x203a, 0x9b], [0x0153, 0x9c],
+  [0x017e, 0x9e], [0x0178, 0x9f],
+]);
+
 /**
  * Pure-JS PDF renderer.
  * Implements the RendererBase interface by accumulating a PDF content stream in memory.
@@ -361,6 +371,12 @@ export class PdfRenderer extends RendererBase {
     return str
         .replace(/\\/g, '\\\\')
         .replace(/\(/g, '\\(')
-        .replace(/\)/g, '\\)');
+        .replace(/\)/g, '\\)')
+        // Keep output ASCII: map Unicode to WinAnsi (Windows-1252) bytes, unsupported characters become '?'
+        .replace(/[^\x00-\x7f]/g, (c) => {
+          const code = c.charCodeAt(0);
+          const byte = WIN_ANSI_EXTRAS.get(code) ?? (code >= 0xa0 && code <= 0xff ? code : 0x3f);
+          return '\\' + byte.toString(8).padStart(3, '0');
+        });
   }
 }

package/core/lib/scene.js

@@ -139,6 +139,7 @@ export class Scene {
   undo() {
     if (this.stateManager.canUndo()) {
       this.stateManager.undo();
+      this.selectionManager.reloadSelectedEntities();
       DesignCore.Canvas.requestPaint();
     } else {
       DesignCore.Core.notify(Strings.Message.NOUNDO);
@@ -151,6 +152,7 @@ export class Scene {
   redo() {
     if (this.stateManager.canRedo()) {
       this.stateManager.redo();
+      this.selectionManager.reloadSelectedEntities();
       DesignCore.Canvas.requestPaint();
     } else {
       DesignCore.Core.notify(Strings.Message.NOREDO);

package/core/lib/selectionManager.js

@@ -156,6 +156,34 @@ export class SelectionManager {
     return DesignCore.Scene.entities.findClosest(point);
   }
 
+  /**
+   * Find the grip closest to point, within tolerance, across all selected entities.
+   * Hit-tests against the real scene entities (not the selectedEntities preview clones) so a
+   * grip's apply() always recomputes from the last-committed geometry.
+   * @param {Point} point
+   * @return {Object|undefined} { entityIndex, grip } or undefined if no grip is close enough
+   */
+  findGripUnderMouse(point) {
+    const gripAperture = 25; // capture radius in pixels (screen space), matches Snapping's snapAperture
+    const delta = gripAperture / DesignCore.Canvas.getScale();
+
+    let closestGrip;
+    let closestDistance = delta;
+
+    for (const entityIndex of this.selectionSet.selectionSet) {
+      const entity = DesignCore.Scene.entities.get(entityIndex);
+      for (const grip of entity.getGrips()) {
+        const distance = grip.point.distance(point);
+        if (distance < closestDistance) {
+          closestDistance = distance;
+          closestGrip = { entityIndex, grip };
+        }
+      }
+    }
+
+    return closestGrip;
+  }
+
   /**
   * Remove the item at index from the selectionSet and selectedEntities
   * @param  {number} index - index of the item

package/core/lib/strings.js

@@ -110,9 +110,12 @@ 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',
     NEWLENGTH: 'Specify new length',
+    STRETCHPOINT: 'Specify stretch point',
   };
 };

package/core/properties/dimType.js

@@ -99,6 +99,20 @@ export class DimType {
     this.userPositionedText = (dimType & 128) !== 0;
   }
 
+  /**
+   * Set only the base dimension type (0-6), leaving the block reference, ordinate and
+   * user-positioned-text flags untouched - used by subclass constructors to pin their type
+   * without clobbering flags already loaded from a DXF group 70 value
+   * @param {number} baseType
+   */
+  setBaseType(baseType) {
+    if (!DimType.isValidDimensionType(baseType)) {
+      baseType = 0;
+    }
+
+    this.dimType = DimType.getBaseType(baseType);
+  }
+
   /**
    * Check if the dimension has a block reference
    * @return {boolean} true if the dimension has a block reference

package/core/properties/property.js

@@ -112,6 +112,7 @@ export class Property {
     LEADERLENGTH: 'leaderLength',
     LINEARDIMANGLE: 'linearDimAngle',
     TEXTOVERRIDE: 'textOverride',
+    USERPOSITIONEDTEXT: 'userPositionedText',
   });
 
   /**

package/core/tables/dimStyle.js

@@ -1,5 +1,6 @@
 
 import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { DesignCore } from '../designCore.js';
 import { Logging } from '../lib/logging.js';
 import { Flags } from '../properties/flags.js';
 import { Property } from '../properties/property.js';
@@ -383,6 +384,8 @@ export class DimStyle {
 
     // DXF Groupcode 340 - (handle of referenced STYLE)
     this.DIMTXSTY = Property.loadValue([data.DIMTXSTY, data[340]], 'Standard');
+    // internal - true when DIMTXSTY holds a style handle (loaded from group 340) rather than a style name
+    this.DIMTXSTYISHANDLE = Property.loadValue([data.DIMTXSTYISHANDLE, data.DIMTXSTY === undefined && data[340] !== undefined], false);
 
     // DXF Groupcode 341 - (handle of referenced BLOCK)
     this.DIMLDRBLK = Property.loadValue([data.DIMLDRBLK, data[341]], 'ClosedFilled');
@@ -475,6 +478,9 @@ export class DimStyle {
 
     if (this.hasOwnProperty(valueName)) {
       this[valueName] = value;
+      if (valueName === 'DIMTXSTY') {
+        this.DIMTXSTYISHANDLE = false;
+      }
     } else {
       const err = `Setting Value - Property does not exist: ${valueName}`;
       Logging.instance.warn(`${this.type} - ${err}`);
@@ -544,6 +550,23 @@ export class DimStyle {
     this.DIMCENVALUE = Math.abs(value);
   }
 
+  /**
+   * Get the handle of the text style referenced by DIMTXSTY
+   * DIMTXSTY holds a style name, or a style handle when DIMTXSTYISHANDLE is set (loaded from a dxf file)
+   * @return {string} handle or undefined if no matching style exists
+   */
+  getTextStyleHandle() {
+    const styles = DesignCore.StyleManager.getItems();
+    const reference = String(this.DIMTXSTY).toUpperCase();
+
+    const style = styles.find((item) => this.DIMTXSTYISHANDLE ?
+      String(item.handle).toUpperCase() === reference :
+      item.name.toUpperCase() === reference) ??
+      styles.find((item) => item.name.toUpperCase() === 'STANDARD');
+
+    return style?.handle;
+  }
+
   /**
    * Write the entity to file in the dxf format
    * @param {DXFFile} file
@@ -616,8 +639,15 @@ export class DimStyle {
     file.writeGroupCode('287', this.DIMFIT);
     file.writeGroupCode('288', this.DIMUPT, DXFFile.Version.R13);
     file.writeGroupCode('289', this.DIMATFIT, DXFFile.Version.R2000);
-    file.writeGroupCode('340', this.DIMTXSTY, DXFFile.Version.R13);
-    file.writeGroupCode('341', this.DIMLDRBLK, DXFFile.Version.R2000);
+    // 340 and 341 are handles - writing a name leaves AutoCAD unable to resolve the text style (dimension text is not shown)
+    const textStyleHandle = this.getTextStyleHandle();
+    if (textStyleHandle !== undefined) {
+      file.writeGroupCode('340', textStyleHandle, DXFFile.Version.R13);
+    }
+    // 'ClosedFilled' is the default leader arrowhead and has no block handle, omitting the group selects it
+    if (this.DIMLDRBLK !== 'ClosedFilled') {
+      file.writeGroupCode('341', this.DIMLDRBLK, DXFFile.Version.R2000);
+    }
     // file.writeGroupCode('342', this.DIMBLK);
     // file.writeGroupCode('343', this.DIMBLK1);
     // file.writeGroupCode('344', this.DIMBLK2);

package/core/tools/gripStretch.js

@@ -0,0 +1,97 @@
+import { Tool } from './tool.js';
+import { Strings } from '../lib/strings.js';
+import { Input } from '../lib/input.js';
+import { PromptOptions } from '../lib/promptOptions.js';
+import { Logging } from '../lib/logging.js';
+import { UpdateState } from '../lib/stateManager.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * GripStretch Command Class
+ * Not shown in any toolbar and never started via the command line - only InputManager creates it.
+ * @extends Tool
+ */
+export class GripStretch extends Tool {
+  static type = 'GripStretch';
+
+  /**
+   * Create a GripStretch command
+   * @param {number} entityIndex - index of the entity in the selection set that owns the grip
+   * @param {Object} grip - { point, apply } descriptor returned by Entity.getGrips()
+   */
+  constructor(entityIndex, grip) {
+    super();
+    this.entityIndex = entityIndex;
+    this.grip = grip;
+  }
+
+  /**
+   * Execute method
+   * requests the stretch point, then commits it - keeping the entity selected afterwards
+   * (with its grips still visible), unlike most commands which deselect on completion
+   */
+  async execute() {
+    try {
+      const op = new PromptOptions(Strings.Input.STRETCHPOINT, [Input.Type.POINT]);
+      const newPoint = await DesignCore.Scene.inputManager.requestInput(op);
+      if (newPoint === undefined) return;
+      this.points.push(newPoint);
+
+      const inputManager = DesignCore.Scene.inputManager;
+      inputManager.actionCommand();
+
+      // finish without the standard executeCommand()/reset() combo, which would deselect the
+      // entity via Scene.reset() - grip editing must leave it selected (grips still visible)
+      inputManager.activeCommand = undefined;
+      inputManager.promptOption = undefined;
+      // reset() normally clears this - without it the next command's first point (or the next
+      // grip drag's tracking line) would stay anchored to this drop, not start fresh
+      inputManager.inputPoint = null;
+      DesignCore.CommandLine.resetPrompt();
+      DesignCore.Scene.selectionManager.reloadSelectedEntities();
+      DesignCore.Canvas.requestPaint();
+    } catch (err) {
+      Logging.instance.error(`${this.type} - ${err}`);
+    }
+  }
+
+  /**
+   * Preview the live grip position while dragging
+   */
+  preview() {
+    const newPoints = this.grip.apply(DesignCore.Mouse.pointOnScene());
+    const previewIndex = DesignCore.Scene.selectionManager.selectionSet.selectionSet.indexOf(this.entityIndex);
+    if (previewIndex !== -1) {
+      DesignCore.Scene.selectionManager.selectedEntities[previewIndex].setProperty('points', newPoints);
+    }
+  }
+
+  /**
+   * Perform the command - commits the grip's new (dropped) position
+   */
+  action() {
+    const entity = DesignCore.Scene.entities.get(this.entityIndex);
+    const newPoints = this.grip.apply(this.points[0]);
+    const properties = { points: newPoints };
+    // all grips currently implemented reposition dimension text - record the flag
+    // explicitly so its pre-drag value is captured by the UpdateState undo snapshot too
+    if (entity.dimType) {
+      properties.userPositionedText = true;
+    }
+    DesignCore.Scene.commit([new UpdateState(entity, properties)]);
+  }
+
+  /**
+   * Cancel the in-progress stretch - unlike Tool's default (full reset), this must not deselect
+   * the entity, and must resolve the suspended execute()'s pending requestInput() promise so it
+   * doesn't stay forever awaiting a prompt nobody can respond to or cancel again
+   */
+  cancel() {
+    const inputManager = DesignCore.Scene.inputManager;
+    inputManager.promptOption?.cancel();
+    inputManager.promptOption = undefined;
+    inputManager.activeCommand = undefined;
+    DesignCore.Scene.selectionManager.reloadSelectedEntities();
+  }
+}

package/core/tools/offset.js

@@ -151,7 +151,13 @@ export class Offset extends Tool {
     const isClosed = polyPts.length >= 3 && polyPts[0].isSame(polyPts.at(-1));
     const points = isClosed ? polyPts.slice(0, -1) : polyPts;
 
-    return this.getOffsetPolylinePoints(points, isClosed, sidePoint, distance);
+    const offsetPoints = this.getOffsetPolylinePoints(points, isClosed, sidePoint, distance);
+    if (offsetPoints && isClosed) {
+      // restore the closing point so closed entities (e.g. Circle) are rebuilt as closed, not as an Arc
+      offsetPoints.push(new Point(offsetPoints[0].x, offsetPoints[0].y));
+    }
+
+    return offsetPoints;
   }
 
   /**

package/core/tools/tool.js

@@ -1,3 +1,5 @@
+import { DesignCore } from '../designCore.js';
+
 /**
  * Tool Class
  */
@@ -28,5 +30,13 @@ export class Tool {
   action() {
     // action function to be overridden by implementation
   };
+
+  /**
+   * Cancel this command while it is active - overridden by implementations that need to
+   * clean up differently to the default full reset (e.g. GripStretch, which must not deselect)
+   */
+  cancel() {
+    DesignCore.Scene.inputManager.reset();
+  };
 }
 

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

package/cspell.json

@@ -45,6 +45,7 @@
         "dimstyles",
         "dimline",
         "DIMENSIONSTYLE",
+        "USERPOSITIONEDTEXT",
         "DIMADEC",
         "DIMALI",
         "DIMALT",
@@ -127,6 +128,7 @@
         "DIMTSZ",
         "DIMTVP",
         "DIMTXSTY",
+        "DIMTXSTYISHANDLE",
         "DIMTXT",
         "DIMTXTDIRECTION",
         "DIMTZIN",
@@ -195,7 +197,9 @@
         "RRGGBB",
         "rubberbandcolour",
         "SCALEFACTOR",
+        "SECONDCORNER",
         "selectedchild",
+        "STRETCHPOINT",
         "SELECTIONSET",
         "SEQEND",
         "SINGLESELECTION",
@@ -277,6 +281,7 @@
         "INVALIDFILE",
         "INVALIDGROUPCODE",
         "INVALIDINTERSECTTYPE",
+        "FIRSTCORNER",
         "INVALIDNUMBER",
         "INVALIDPOINT",
         "INVALIDTYPE",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-core/core",
-  "version": "51.1.0",
+  "version": "52.0.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"