@design-core/core 0.0.6 → 50.1.0

package/core/lib/constants.js

@@ -11,6 +11,10 @@ export class Constants {
   static Tolerance = {
     /** Near-zero threshold for floating-point geometric comparisons (1e-10). */
     EPSILON: 1e-10,
+    /** Small relative offset for geometric offsets (1e-9).
+     * Suitable where a nudge must be negligible compared to the scale of
+     * the geometry but larger than floating-point noise. */
+    DELTA: 1e-9,
   };
 
   /**
@@ -20,4 +24,28 @@ export class Constants {
     /** Number of decimal places used by Utils.round(). */
     DECIMALPLACES: 5,
   };
+
+  /**
+   * Standard paper sizes in PDF points (portrait orientation).
+   * 1 PDF point = 1/72 inch = 25.4/72 mm.
+   * Swap width and height for landscape.
+   *
+   * ISO sizes are defined by ISO 216: A4 = 210×297mm, A3 = 297×420mm, etc.
+   * ANSI sizes follow ANSI/ASME Y14.1.
+   */
+  static PageSizes = {
+    // ISO A-series (portrait)
+    'A4': { width: 595, height: 842 },
+    'A3': { width: 842, height: 1191 },
+    'A2': { width: 1191, height: 1684 },
+    'A1': { width: 1684, height: 2384 },
+    'A0': { width: 2384, height: 3370 },
+    // ANSI sizes (portrait)
+    'Letter': { width: 612, height: 792 },
+    'Legal': { width: 612, height: 1008 },
+    'Tabloid': { width: 792, height: 1224 },
+    'ANSI C': { width: 1224, height: 1584 },
+    'ANSI D': { width: 1584, height: 2448 },
+    'ANSI E': { width: 2448, height: 3168 },
+  };
 }

package/core/lib/dxf/dxf.js

@@ -30,6 +30,7 @@ export class DXF {
     this.reader.read(data);
   }
 
+
   /**
    * Write
    * @param {string} version
@@ -302,22 +303,22 @@ export class DXF {
           const command = child[0];
           // check if the child is a valid entity
           if (DesignCore.CommandManager.isCommand(command)) {
-            // create an instance of the child entity
             const item = DesignCore.CommandManager.createNew(command, child);
 
             // Register the child entity handle
-            if (item.handle) {
-              DesignCore.HandleManager.checkHandle(item.handle);
+            const itemHandle = item?.getProperty?.('handle') ?? item?.handle;
+            if (itemHandle) {
+              DesignCore.HandleManager.checkHandle(itemHandle);
             }
 
-            if (block.hasOwnProperty('items') === false) {
-              block.items = [];
+            if (block.hasOwnProperty('entities') === false) {
+              block.entities = [];
             }
 
             // add the child to the block items
             // TODO: create a block instance and add the items.
             // check block is valid before adding to scene
-            block.items.push(item);
+            block.entities.push(item);
           }
         });
       }
@@ -346,7 +347,7 @@ export class DXF {
         entity.points = this.parsePoints(entity.points);
       }
 
-      this.addItem(entity);
+      this.addEntity(entity);
     });
 
     // ensure all layers, ltypes, styles, dimstyles exist
@@ -377,18 +378,18 @@ export class DXF {
   }
 
   /**
-   * Add Item
-   * @param {Object} item
+   * Add Entity
+   * @param {Object} entity
    */
-  addItem(item) {
-    if (item.hasOwnProperty('0') === false) {
+  addEntity(entity) {
+    if (entity.hasOwnProperty('0') === false) {
       return;
     }
 
-    const command = item[0];
+    const command = entity[0];
     if (DesignCore.CommandManager.isCommand(command)) {
-      const entity = DesignCore.CommandManager.createNew(command, item);
-      DesignCore.Scene.entities.add(entity);
+      const newEntity = DesignCore.CommandManager.createNew(command, entity);
+      DesignCore.Scene.entities.add(newEntity);
     } else {
       Logging.instance.warn(`${Strings.Message.UNKNOWNCOMMAND} ${command}`);
       this.unsupportedElements = true;

package/core/lib/dxf/dxfIterator.js

@@ -23,11 +23,11 @@ Example DXF Entity Pairs:
  value: 100.0       - y position
  */
 
-/** DXF Interator Class */
+/** DXF Iterator Class */
 export class DxfIterator {
   static _instance;
 
-  /** Create DXFInterator */
+  /** Create DXFIterator */
   constructor() {
     this.currentIndex = 0;
     this.lines = [];

package/core/lib/entityManager.js

@@ -1,5 +1,6 @@
 
 import { DesignCore } from '../designCore.js';
+import { Property } from '../properties/property.js';
 
 /**
  * Entity Manager Class
@@ -36,10 +37,13 @@ export class EntityManager {
     if (!entity) return;
 
     if (this.#trackHandles) {
-      if (entity.handle === undefined) {
-        entity.handle = DesignCore.HandleManager.next();
+      const existingHandle = entity.getProperty?.(Property.Names.HANDLE) ?? entity.handle;
+      if (existingHandle === undefined) {
+        if (entity.setProperty) {
+          entity.setProperty(Property.Names.HANDLE, DesignCore.HandleManager.next());
+        }
       } else {
-        DesignCore.HandleManager.checkHandle(entity.handle);
+        DesignCore.HandleManager.checkHandle(existingHandle);
       }
     }
 
@@ -53,8 +57,9 @@ export class EntityManager {
   remove(index) {
     if (this.#trackHandles) {
       const entity = this.#entities[index];
-      if (entity?.handle !== undefined) {
-        DesignCore.HandleManager.releaseHandle(entity.handle);
+      const handle = entity?.getProperty?.(Property.Names.HANDLE) ?? entity?.handle;
+      if (handle !== undefined) {
+        DesignCore.HandleManager.releaseHandle(handle);
       }
     }
     this.#entities.splice(index, 1);
@@ -87,22 +92,26 @@ export class EntityManager {
   }
 
   /**
-   * Find items in scene
+   * Find entities  in scene
    * @param {string} type - entity type or "ANY"
    * @param {string} prop - object of entity parameters
    * @param {any} value - value of the property
-   * @return {number} - index of items
+   * @return {number} - index of entities
    */
   find(type, prop, value) {
-    const filteredItems = [];
-
-    this.#entities.forEach((item, index) => {
-      if ((type.toUpperCase() === 'ANY' || item.type.toUpperCase() === type.toUpperCase()) && item.hasOwnProperty(prop) && item[prop] === value) {
-        filteredItems.push(index);
+    const filteredEntities = [];
+
+    this.#entities.forEach((entity, index) => {
+      if (type.toUpperCase() === 'ANY' || entity.type.toUpperCase() === type.toUpperCase()) {
+        const inStore = entity.properties?.has(prop);
+        const propValue = inStore ? entity.getProperty(prop) : (Object.prototype.hasOwnProperty.call(entity, prop) ? entity[prop] : undefined);
+        if (propValue !== undefined && propValue === value) {
+          filteredEntities.push(index);
+        }
       }
     });
 
-    return filteredItems;
+    return filteredEntities;
   }
 
   /** Get index of entity
@@ -115,17 +124,17 @@ export class EntityManager {
 
 
   /**
-   * Find closest item to point
+   * Find closest entity to point
    * @param  {Point} point
-   * @return {number} - return index of closest item or undefined
+   * @return {number} - return index of closest entity or undefined
    */
   findClosest(point) {
     let delta = 1.65 / DesignCore.Core.canvas.getScale(); // find a more suitable starting value
-    let closestItemIndex;
+    let closestEntityIndex;
 
     for (let i = 0; i < this.#entities.length; i++) {
-      // check the items layer is selectable - i.e. on, thawed, etc...
-      const layer = DesignCore.LayerManager.getItemByName(this.#entities[i].layer);
+      // check the entities  layer is selectable - i.e. on, thawed, etc...
+      const layer = DesignCore.LayerManager.getItemByName(this.#entities[i].getProperty(Property.Names.LAYER));
 
       if (!layer?.isSelectable) {
         continue;
@@ -135,11 +144,11 @@ export class EntityManager {
 
       if (distance < delta) {
         delta = distance;
-        closestItemIndex = i;
+        closestEntityIndex = i;
       }
     }
 
-    return closestItemIndex;
+    return closestEntityIndex;
   }
 
   /**
@@ -148,16 +157,14 @@ export class EntityManager {
    * @param {object} data
    */
   update(index, data) {
-    const item = this.get(index);
+    const entity = this.get(index);
 
-    if (!item) {
-      throw Error('Item not found in scene');
+    if (!entity) {
+      throw Error('Entity not found in scene');
     }
 
     for (const property of Object.keys(data)) {
-      if (item.hasOwnProperty(property)) {
-        item.setProperty(property, data[property]);
-      }
+      entity.setProperty(property, data[property]);
     }
   }
 

package/core/lib/inputManager.js

@@ -1,8 +1,8 @@
 import { Tool } from '../tools/tool.js';
 import { Snapping } from './snapping.js';
-import { Utils } from './utils.js';
 
 import { DesignCore } from '../designCore.js';
+import { Property } from '../properties/property.js';
 import { Point } from '../entities/point.js';
 import { Input, MouseDown, MouseUp } from './input.js';
 
@@ -137,6 +137,14 @@ export class InputManager {
     const resolvedCommand = DesignCore.CommandManager.getCommand(command);
     DesignCore.CommandLine.addToCommandHistory(resolvedCommand);
     this.activeCommand = DesignCore.CommandManager.createNew(resolvedCommand);
+
+    // Clear selection for Entity commands
+    // Tools (Erase, Offset, etc.) consume preselection in execute().
+    if (!(this.activeCommand instanceof Tool)) {
+      DesignCore.Scene.selectionManager.reset();
+      DesignCore.Canvas.requestPaint();
+    }
+
     this.activeCommand.execute();
   }
 
@@ -217,11 +225,24 @@ export class InputManager {
     }
   }
 
+  /**
+   * Clears preview entities and re-runs the active command preview
+   */
+  refreshPreview() {
+    if (this.activeCommand === undefined) return;
+    DesignCore.Scene.previewEntities.clear();
+    DesignCore.Scene.auxiliaryEntities.clear();
+    DesignCore.Scene.hoverEntities.clear();
+    this.activeCommand.preview();
+    DesignCore.Canvas.requestPaint();
+  }
+
   /**
    * Handle mouse position changes
    */
   mouseMoved() {
-    DesignCore.Scene.tempEntities.clear();
+    DesignCore.Scene.previewEntities.clear();
+    DesignCore.Scene.hoverEntities.clear();
     DesignCore.Scene.auxiliaryEntities.clear();
 
     if (DesignCore.Mouse.buttonOneDown) {
@@ -255,13 +276,16 @@ export class InputManager {
       }
     }
 
-    const selecting = !snapped && this.highlightEntityUnderMouse();
-
-    // preview active commands when items are not being selected
-    if (this.activeCommand !== undefined && !selecting) {
+    // preview active commands
+    if (this.activeCommand !== undefined) {
       this.activeCommand.preview();
     }
 
+    // Only show hover glow when no command preview is occupying previewEntities
+    if (!snapped && DesignCore.Scene.previewEntities.count() === 0) {
+      this.highlightEntityUnderMouse();
+    }
+
     DesignCore.Canvas.requestPaint();
   }
 
@@ -282,7 +306,7 @@ export class InputManager {
 
     const index = DesignCore.Scene.selectionManager.findClosestItem(DesignCore.Mouse.pointOnScene());
     if (index !== undefined) {
-      DesignCore.Scene.tempEntities.add(Utils.cloneObject(DesignCore.Scene.entities.get(index)));
+      DesignCore.Scene.hoverEntities.add(DesignCore.Scene.entities.get(index));
       return true;
     }
 
@@ -368,7 +392,7 @@ export class InputManager {
     }
 
     if (Input.getType(selection) === Input.Type.SINGLESELECTION) {
-      DesignCore.Scene.selectionManager.addToSelectionSet(selection.selectedItemIndex);
+      DesignCore.Scene.selectionManager.addToSelectionSet(selection.selectedEntityIndex);
     }
   }
 
@@ -406,10 +430,10 @@ export class InputManager {
       this.activeCommand.action();
     } else {
       if (item !== undefined) {
-      // set the items layer to the current layer
-        item.layer = DesignCore.LayerManager.getCstyle();
-        // return the item index
-        return DesignCore.Scene.addItem(item.type, item, index);
+        // set the items layer to the current layer
+        item.setProperty(Property.Names.LAYER, DesignCore.LayerManager.getCstyle());
+        // commit the already-constructed entity directly, bypassing createNew
+        return DesignCore.Scene.commitEntity(item, index);
       }
     }
   }

package/core/lib/intersect.js

@@ -448,5 +448,30 @@ export class Intersection {
 
     return result;
   };
+
+  /**
+   * Even-odd point-in-boundary test using a horizontal ray to the right.
+   * A tiny y-offset prevents the ray from passing exactly through the
+   * top or bottom of a curved boundary (e.g. a circle), which would produce a
+   * wrong crossing count. The offset scales with the y-coordinate of the test
+   * point so it stays negligible regardless of drawing scale or position.
+   * @param {number} px - x coordinate of the test point
+   * @param {number} py - y coordinate of the test point
+   * @param {Array} boundaries - array of closed point arrays (each a polyline loop)
+   * @param {number} boundaryExtentX - x coordinate of the ray endpoint, must be rightward of all geometry
+   * @return {boolean} true if the point is inside the boundaries under the even-odd rule
+   */
+  static isInsidePolyline(px, py, boundaries, boundaryExtentX) {
+    // Scale epsilon by the y-coordinate magnitude of the test point rather than
+    // boundaryExtentX: a y-offset should be negligible relative to the y-scale of
+    // the geometry, not the (unrelated) x-extent of the ray. The +1 handles py=0.
+    const rayEps = Constants.Tolerance.DELTA * (Math.abs(py) + 1);
+    const testLine = [new Point(px, py + rayEps), new Point(boundaryExtentX, py + rayEps)];
+    let count = 0;
+    for (const b of boundaries) {
+      count += Intersection.intersectPolylinePolyline(b, testLine).points.length;
+    }
+    return (count % 2) === 1;
+  }
 }
 

package/core/lib/matrix.js

@@ -37,7 +37,7 @@ export class Matrix {
   };
 
   /**
-   * Apply tranlation to matrix
+   * Apply translation to matrix
    * @param {number} x - translation in x
    * @param {number} y - translation in y
    */

package/core/lib/patterns.js

@@ -116,8 +116,15 @@ export class Patterns {
 
   static hatch_patterns = {
     'SOLID': {
+      // Commercial CAD defines SOLID as two dense cross-hatch line families
+      // (45° and -45°) with a near-zero spacing of 0.0001 inches. Design does
+      // not use this pattern for rendering — solid hatches are drawn with a
+      // direct fill() call for quality and performance reasons. The definition
+      // is retained here so that patternExists('SOLID') returns true and the
+      // name is available for pattern selection and DXF round-trip validation.
       description: 'Solid Fill', pattern:
-                `45, 0,0, 0,3.175`,
+                `45, 0,0, 0,0.00254
+-45, 0,0, 0,0.00254`,
     },
 
     'ANGLE': {
@@ -455,7 +462,7 @@ export class Patterns {
 60, 0, 0, 4.7625, 2.749630645, -6.35, 3.175` },
 
     'HOUND': {
-      description: 'Houndstooth check', pattern:
+      description: 'Hounds tooth check', pattern:
                 `0, 0, 0, 6.35, 1.5875, 25.4, -12.7
 90, 0, 0, 6.35, 1.5875, 25.4, -12.7` },
 

package/core/lib/plotOptions.js

@@ -0,0 +1,67 @@
+import { RendererBase } from './renderers/rendererBase.js';
+
+/**
+ * PlotOptions Class
+ * Encapsulates all parameters for a plot/export operation.
+ */
+export class PlotOptions {
+  /** Valid plot area modes. */
+  static Area = {
+    EXTENTS: 'Extents',
+    DISPLAY: 'Display',
+  };
+
+  static #fileTypes = ['pdf', 'svg'];
+
+  /**
+   * @param {number} pageWidth - required, positive number (PDF points)
+   * @param {number} pageHeight - required, positive number (PDF points)
+   */
+  constructor(pageWidth, pageHeight) {
+    this.setOption('pageWidth', pageWidth);
+    this.setOption('pageHeight', pageHeight);
+    this.plotScale = null;
+    this.plotArea = PlotOptions.Area.EXTENTS;
+    this.style = RendererBase.Styles.NONE;
+    this.fileType = 'pdf';
+  }
+
+  /**
+   * Validate and set a single option.
+   * @param {string} key
+   * @param {*} value
+   */
+  setOption(key, value) {
+    switch (key) {
+      case 'pageWidth':
+      case 'pageHeight':
+        if (typeof value !== 'number' || value <= 0) {
+          throw new Error(`PlotOptions: ${key} must be a positive number`);
+        }
+        break;
+      case 'plotScale':
+        if (value !== null && (typeof value !== 'number' || value <= 0)) {
+          throw new Error('PlotOptions: plotScale must be a positive number or null');
+        }
+        break;
+      case 'plotArea':
+        if (!Object.values(PlotOptions.Area).includes(value)) {
+          throw new Error(`PlotOptions: plotArea must be one of: ${Object.values(PlotOptions.Area).join(', ')}`);
+        }
+        break;
+      case 'style':
+        if (typeof value !== 'function') {
+          throw new Error('PlotOptions: style must be a function');
+        }
+        break;
+      case 'fileType':
+        if (!PlotOptions.#fileTypes.includes(value)) {
+          throw new Error(`PlotOptions: fileType must be one of: ${PlotOptions.#fileTypes.join(', ')}`);
+        }
+        break;
+      default:
+        throw new Error(`PlotOptions: unknown option '${key}'`);
+    }
+    this[key] = value;
+  }
+}

package/core/lib/polylineUtils.js

@@ -0,0 +1,75 @@
+import { Utils } from './utils.js';
+
+/**
+ * Shared polyline-segment geometry helpers used by the Trim and Extend tools.
+ * All methods accept an explicit `points` array rather than operating on
+ * `this.points`, so they are entity-independent and can be reused by any
+ * tool that works in polyline-point space.
+ */
+export class PolylineUtils {
+  /**
+   * Test whether a point lies on the segment from A to B (line or arc).
+   * @param {Point} point
+   * @param {Point} A - segment start; carries bulge for arc segments
+   * @param {Point} B - segment end
+   * @return {boolean}
+   */
+  static isPointOnSegment(point, A, B) {
+    if (A.bulge !== 0 && A.bulge !== undefined) {
+      const centre = A.bulgeCentrePoint(B);
+      const radius = centre.distance(A);
+      // Point must lie on the circle before checking the angular range.
+      if (Utils.round(centre.distance(point)) !== Utils.round(radius)) return false;
+      const direction = A.bulge > 0 ? 1 : -1;
+      return point.isOnArc(A, B, centre, direction);
+    }
+    return point.isOnLine(A, B);
+  }
+
+  /**
+   * Get the closest point on a segment to a reference point.
+   * @param {Array}  points       - polyline points array
+   * @param {Point}  point        - reference point
+   * @param {number} segmentIndex - 1-based segment index
+   * @return {Point|null}
+   */
+  static closestPointOnSegment(points, point, segmentIndex) {
+    const A = points[segmentIndex - 1];
+    const B = points[segmentIndex % points.length];
+
+    if (A.bulge !== 0 && A.bulge !== undefined) {
+      const centre = A.bulgeCentrePoint(B);
+      const direction = A.bulge > 0 ? 1 : -1;
+      const closest = point.closestPointOnArc(A, B, centre, direction);
+      if (closest) return closest;
+      // Point not on arc — return the nearer endpoint
+      return point.distance(A) < point.distance(B) ? A : B;
+    }
+
+    return point.closestPointOnLine(A, B);
+  }
+
+  /**
+   * Get the normalised position of a point along a segment (used for ordering).
+   * For line segments returns chord distance from A; for arc segments returns
+   * the angular sweep from A, normalised to [0, 2π).
+   * @param {Array}  points       - polyline points array
+   * @param {Point}  point        - a point known to lie on the segment
+   * @param {number} segmentIndex - 1-based segment index
+   * @return {number}
+   */
+  static positionOnSegment(points, point, segmentIndex) {
+    const A = points[segmentIndex - 1];
+    const B = points[segmentIndex % points.length];
+
+    if (A.bulge !== 0 && A.bulge !== undefined) {
+      const centre = A.bulgeCentrePoint(B);
+      const direction = A.bulge > 0 ? 1 : -1;
+      const startAngle = centre.angle(A);
+      const pointAngle = centre.angle(point);
+      return ((pointAngle - startAngle) * direction + 4 * Math.PI) % (2 * Math.PI);
+    }
+
+    return A.distance(point);
+  }
+}