@design-core/core 0.0.5 → 0.0.7

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,12 +303,12 @@ 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) {

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);
@@ -97,8 +102,12 @@ export class EntityManager {
     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);
+      if (type.toUpperCase() === 'ANY' || item.type.toUpperCase() === type.toUpperCase()) {
+        const inStore = item.properties?.has(prop);
+        const propValue = inStore ? item.getProperty(prop) : (Object.prototype.hasOwnProperty.call(item, prop) ? item[prop] : undefined);
+        if (propValue !== undefined && propValue === value) {
+          filteredItems.push(index);
+        }
       }
     });
 
@@ -125,7 +134,7 @@ export class EntityManager {
 
     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);
+      const layer = DesignCore.LayerManager.getItemByName(this.#entities[i].getProperty(Property.Names.LAYER));
 
       if (!layer?.isSelectable) {
         continue;
@@ -155,9 +164,7 @@ export class EntityManager {
     }
 
     for (const property of Object.keys(data)) {
-      if (item.hasOwnProperty(property)) {
-        item.setProperty(property, data[property]);
-      }
+      item.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;
     }
 
@@ -293,8 +317,7 @@ export class InputManager {
    * Handle single selection
    */
   singleSelect() {
-    this.inputPoint = DesignCore.Mouse.pointOnScene();
-    this.onLeftClick(this.inputPoint);
+    this.onLeftClick(DesignCore.Mouse.pointOnScene());
   }
 
   /**
@@ -407,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/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': {

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 center = A.bulgeCentrePoint(B);
+      const radius = center.distance(A);
+      // Point must lie on the circle before checking the angular range.
+      if (Utils.round(center.distance(point)) !== Utils.round(radius)) return false;
+      const direction = A.bulge > 0 ? 1 : -1;
+      return point.isOnArc(A, B, center, 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 center = A.bulgeCentrePoint(B);
+      const direction = A.bulge > 0 ? 1 : -1;
+      const closest = point.closestPointOnArc(A, B, center, 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 center = A.bulgeCentrePoint(B);
+      const direction = A.bulge > 0 ? 1 : -1;
+      const startAngle = center.angle(A);
+      const pointAngle = center.angle(point);
+      return ((pointAngle - startAngle) * direction + 4 * Math.PI) % (2 * Math.PI);
+    }
+
+    return A.distance(point);
+  }
+}