@design-core/core 0.0.6 → 50.1.0

package/core/entities/{basePolyline.js → polylineBase.js}

@@ -10,17 +10,18 @@ import { Line } from './line.js';
 import { Arc } from './arc.js';
 import { Flags } from '../properties/flags.js';
 import { Property } from '../properties/property.js';
-import { AddState, RemoveState, UpdateState } from '../lib/stateManager.js';
+
 
 import { DesignCore } from '../designCore.js';
-import { SnapPoint } from '../lib/snapping.js';
+import { SnapPoint } from '../lib/auxiliary/snapPoint.js';
+import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 /**
  * Base Polyline Entity Class
  * @extends Entity
  */
-export class BasePolyline extends Entity {
-  static type = 'BasePolyline';
+export class PolylineBase extends Entity {
+  static type = 'PolylineBase';
 
   /**
    * Create a Base Polyline
@@ -75,6 +76,14 @@ export class BasePolyline extends Entity {
 
     this.flags.setFlagValue(Property.loadValue([data?.flags, data?.[70]], 0));
 
+    // DXF Groupcode 70 bit 1 - closed flag exposed via EntityProperties
+    this.properties.add(Property.Names.CLOSED, {
+      type: Property.Type.BOOLEAN,
+      get: (entity) => entity.flags.hasFlag(1),
+      set: (entity, value) => value ? entity.flags.addValue(1) : entity.flags.removeValue(1),
+      dxfCode: 70,
+    });
+
     // If the first and last points are the same the polyline should be considered closed.
     // Require at least 4 points so that after removing the duplicate endpoint at least 3 remain.
     if (this.points.length >= 4 && this.points[0].isSame(this.points.at(-1))) {
@@ -161,54 +170,25 @@ export class BasePolyline extends Entity {
 
     if (this.points.length >= 1) {
       const points = [...this.points, mousePoint];
-      DesignCore.Scene.tempEntities.create(this.type, { points: points });
-    }
-
-    if (this.inputMode === this.modes.ARC) {
-      const arcpoints = Utils.cloneObject(this.points);
-      arcpoints.at(-1).bulge = this.getBulgeFromSegment(mousePoint);
-      const points = [...arcpoints, mousePoint];
-      DesignCore.Scene.tempEntities.create(this.type, { points: points });
+      if (this.inputMode === this.modes.ARC) {
+        // Straight segment is not the final form — show as rubber-band indicator
+        DesignCore.Scene.auxiliaryEntities.add(new RubberBand([this.points.at(-1), mousePoint]));
+        // Arc segment is the final form — draw on the current layer
+        const arcpoints = Utils.cloneObject(this.points);
+        arcpoints.at(-1).bulge = this.getBulgeFromSegment(mousePoint);
+        DesignCore.Scene.previewEntities.create(this.type, { points: [...arcpoints, mousePoint] });
+      } else {
+        DesignCore.Scene.previewEntities.create(this.type, { points: points });
+      }
     }
   }
 
   /**
    * Draw the polyline
-   * @param {Object} ctx
-   * @param {number} scale
-   * @param {boolean} stroke - don't stroke hatch boundary shapes
+   * @param {Object} renderer
    */
-  draw(ctx, scale, stroke = true) {
-    for (let i = 0; i < this.points.length; i++) {
-      if (this.points[i].bulge === 0) {
-        ctx.lineTo(this.points[i].x, this.points[i].y);
-      } else {
-        // define the next point or the first point for closed shapes
-        const nextPoint = this.points[i + 1] || this.points[0];
-        const centerPoint = this.points[i].bulgeCentrePoint(nextPoint);
-        const radius = this.points[i].bulgeRadius(nextPoint);
-
-        if (this.points[i].bulge > 0) {
-          // TODO: make this work with canvas
-          ctx.arc(centerPoint.x, centerPoint.y, radius, centerPoint.angle(this.points[i]), centerPoint.angle(nextPoint));
-        } else {
-          try { // HTML
-            ctx.arc(centerPoint.x, centerPoint.y, radius, centerPoint.angle(this.points[i]), centerPoint.angle(nextPoint), true);
-          } catch { // Cairo
-            ctx.arcNegative(centerPoint.x, centerPoint.y, radius, centerPoint.angle(this.points[i]), centerPoint.angle(nextPoint));
-          }
-        }
-      }
-    }
-
-    // handle a closed shape
-    if (this.flags.hasFlag(1)) {
-      ctx.lineTo(this.points[0].x, this.points[0].y);
-    }
-
-    if (stroke) {
-      ctx.stroke();
-    }
+  draw(renderer) {
+    renderer.drawShape(this.toPolylinePoints());
   }
 
   /**
@@ -217,12 +197,12 @@ export class BasePolyline extends Entity {
    */
   dxf(file) {
     file.writeGroupCode('0', 'LWPOLYLINE');
-    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('5', this.getProperty(Property.Names.HANDLE), DXFFile.Version.R2000); // Handle
     file.writeGroupCode('100', 'AcDbEntity', DXFFile.Version.R2000);
     file.writeGroupCode('100', 'AcDbPolyline', DXFFile.Version.R2000);
-    file.writeGroupCode('8', this.layer); // LAYERNAME
-    file.writeGroupCode('6', this.lineType);
-    file.writeGroupCode('39', this.lineWidth);
+    file.writeGroupCode('8', this.getProperty(Property.Names.LAYER)); // LAYERNAME
+    file.writeGroupCode('6', this.getProperty(Property.Names.LINETYPE));
+    file.writeGroupCode('39', this.getProperty(Property.Names.LINEWIDTH));
     file.writeGroupCode('90', this.points.length);
     file.writeGroupCode('70', this.flags.getFlagValue());
     for (let i = 0; i < this.points.length; i++) {
@@ -253,6 +233,7 @@ export class BasePolyline extends Entity {
   /**
    * Set entity points from a polyline point representation
    * @param {Array} points
+   * @return {PolylineBase}
    */
   fromPolylinePoints(points) {
     const pts = points.map((p) => new Point(p.x, p.y, p.bulge));
@@ -260,6 +241,7 @@ export class BasePolyline extends Entity {
       pts.pop();
     }
     this.points = pts;
+    return this;
   }
 
   /**
@@ -329,10 +311,10 @@ export class BasePolyline extends Entity {
       let closestPoint;
       let candidateSegment;
       if (A.bulge !== 0) {
-        const center = A.bulgeCentrePoint(B);
+        const centre = A.bulgeCentrePoint(B);
         const direction = A.bulge > 0 ? 1 : -1;
-        closestPoint = P.closestPointOnArc(A, B, center, direction);
-        candidateSegment = new Arc({ points: [center, A, B], direction });
+        closestPoint = P.closestPointOnArc(A, B, centre, direction);
+        candidateSegment = new Arc({ points: [centre, A, B], direction });
       } else {
         closestPoint = P.closestPointOnLine(A, B);
         candidateSegment = new Line({ points: [A, B] });
@@ -438,9 +420,9 @@ export class BasePolyline extends Entity {
    */
   isPointOnSegment(point, A, B) {
     if (A.bulge !== 0) {
-      const center = A.bulgeCentrePoint(B);
+      const centre = A.bulgeCentrePoint(B);
       const direction = A.bulge > 0 ? 1 : -1;
-      return point.isOnArc(A, B, center, direction);
+      return point.isOnArc(A, B, centre, direction);
     }
     return point.isOnLine(A, B);
   }
@@ -456,9 +438,9 @@ export class BasePolyline extends Entity {
     const B = this.points[segmentIndex % this.points.length];
 
     if (A.bulge !== 0) {
-      const center = A.bulgeCentrePoint(B);
+      const centre = A.bulgeCentrePoint(B);
       const direction = A.bulge > 0 ? 1 : -1;
-      const closest = point.closestPointOnArc(A, B, center, direction);
+      const closest = point.closestPointOnArc(A, B, centre, direction);
 
       if (closest) {
         return closest;
@@ -482,250 +464,16 @@ export class BasePolyline extends Entity {
     const B = this.points[segmentIndex % this.points.length];
 
     if (A.bulge !== 0) {
-      const center = A.bulgeCentrePoint(B);
+      const centre = A.bulgeCentrePoint(B);
       const direction = A.bulge > 0 ? 1 : -1;
-      const startAngle = center.angle(A);
-      const pointAngle = center.angle(point);
+      const startAngle = centre.angle(A);
+      const pointAngle = centre.angle(point);
       return ((pointAngle - startAngle) * direction + 4 * Math.PI) % (2 * Math.PI);
     }
 
     return A.distance(point);
   }
 
-  /**
-   * Extend the entity
-   * Only extends when the end segment closest to the mouse is a line segment (bulge === 0)
-   * @param {Array} intersections - array of intersection points
-   * @return {Array} - array of state changes
-   */
-  extend(intersections) {
-    const stateChanges = [];
-
-    if (!intersections?.length) {
-      return stateChanges;
-    }
-
-    const mousePosition = DesignCore.Mouse.pointOnScene();
-    const lastIndex = this.points.length - 1;
-
-    // Determine which end segment is closer to the mouse
-    const closestOnFirst = this.closestPointOnSegment(mousePosition, 1);
-    const closestOnLast = this.closestPointOnSegment(mousePosition, lastIndex);
-    const distToFirst = mousePosition.distance(closestOnFirst);
-    const distToLast = mousePosition.distance(closestOnLast);
-
-    // Identify the selected end: the endpoint index and the bulge of its segment
-    let endPointIndex;
-    let endSegmentBulge;
-
-    if (distToFirst < distToLast) {
-      endPointIndex = 0;
-      endSegmentBulge = this.points[0].bulge;
-    } else if (distToLast < distToFirst) {
-      endPointIndex = lastIndex;
-      endSegmentBulge = this.points[lastIndex - 1].bulge;
-    } else {
-      // Tie (includes 2-point polyline where both segments are the same)
-      // Break tie by distance to the actual endpoints
-      if (mousePosition.distance(this.points[0]) <= mousePosition.distance(this.points[lastIndex])) {
-        endPointIndex = 0;
-        endSegmentBulge = this.points[0].bulge;
-      } else {
-        endPointIndex = lastIndex;
-        endSegmentBulge = this.points[lastIndex - 1].bulge;
-      }
-    }
-
-    // Only allow extending line segments (not arcs)
-    if (endSegmentBulge !== 0) {
-      DesignCore.Core.notify(`${this.type} - ${Strings.Message.NOEXTEND}`);
-      return stateChanges;
-    }
-
-    const endPoint = this.points[endPointIndex];
-    const adjacentPoint = endPointIndex === 0 ? this.points[1] : this.points[lastIndex - 1];
-
-    // Sort intersections by distance from the end point
-    Utils.sortPointsByDistance(intersections, endPoint);
-
-    // Find the closest intersection that lies beyond the endpoint
-    const direction = endPoint.subtract(adjacentPoint);
-    const newEndPoint = intersections.find((p) => {
-      if (p.isSame(endPoint)) return false;
-      if (p.subtract(endPoint).dot(direction) <= 0) return false;
-      if (adjacentPoint.distance(p) <= adjacentPoint.distance(endPoint)) return false;
-      return true;
-    });
-
-    if (!newEndPoint) {
-      return stateChanges;
-    }
-
-    // Build the new points array
-    const newPoints = this.points.map((p) => p.clone());
-    newPoints[endPointIndex] = newEndPoint;
-
-    if (newPoints[endPointIndex].isSame(this.points[endPointIndex])) {
-      return stateChanges;
-    }
-
-    stateChanges.push(new UpdateState(this, { points: newPoints }));
-    return stateChanges;
-  }
-
-  /**
-   * Trim the entity
-   * @param {Array} intersections - array of intersection points
-   * @return {Array} - array of state changes
-   */
-  trim(intersections) {
-    const stateChanges = [];
-
-    if (!intersections?.length) {
-      return stateChanges;
-    }
-
-    const mousePosition = DesignCore.Mouse.pointOnScene();
-
-    // Find the segment index closest to the mouse
-    let mouseSegmentIndex = 0;
-    let minDistance = Infinity;
-
-    for (let i = 1; i < this.points.length; i++) {
-      const closestPoint = this.closestPointOnSegment(mousePosition, i);
-      if (closestPoint) {
-        const dist = mousePosition.distance(closestPoint);
-        if (dist < minDistance) {
-          minDistance = dist;
-          mouseSegmentIndex = i;
-        }
-      }
-    }
-
-    // Filter out intersections that coincide with existing polyline vertices
-    const filteredIntersections = intersections.filter((point) => !this.points.some((vertex) => vertex.isSame(point)));
-
-    if (!filteredIntersections.length) {
-      return stateChanges;
-    }
-
-    // Locate each intersection on its segment with an ordering value
-    const locatedIntersections = [];
-
-    for (const point of filteredIntersections) {
-      for (let i = 1; i < this.points.length; i++) {
-        if (this.isPointOnSegment(point, this.points[i - 1], this.points[i])) {
-          locatedIntersections.push({
-            segmentIndex: i,
-            point: point,
-            positionAlongSegment: this.positionOnSegment(point, i),
-          });
-          break;
-        }
-      }
-    }
-
-    if (!locatedIntersections.length) {
-      return stateChanges;
-    }
-
-    // Sort by segment index, then by position along segment
-    locatedIntersections.sort((a, b) => {
-      if (a.segmentIndex !== b.segmentIndex) return a.segmentIndex - b.segmentIndex;
-      return a.positionAlongSegment - b.positionAlongSegment;
-    });
-
-    // Precompute the mouse position along its segment
-    const mouseClosest = this.closestPointOnSegment(mousePosition, mouseSegmentIndex);
-    const mousePos = mouseClosest ? this.positionOnSegment(mouseClosest, mouseSegmentIndex) : 0;
-
-    // Find the nearest intersections that bracket the mouse segment
-    // - trimBefore: the last intersection at or before the mouse
-    // - trimAfter: the first intersection at or after the mouse
-    let trimBefore = null;
-    let trimAfter = null;
-
-    for (const loc of locatedIntersections) {
-      if (loc.segmentIndex < mouseSegmentIndex) {
-        trimBefore = loc;
-      } else if (loc.segmentIndex === mouseSegmentIndex) {
-        if (loc.positionAlongSegment <= mousePos) {
-          trimBefore = loc;
-        } else if (!trimAfter) {
-          trimAfter = loc;
-        }
-      } else if (!trimAfter) {
-        trimAfter = loc;
-      }
-    }
-
-    // Build new polyline(s) from the remaining portions
-    // Portion 1: start of polyline to trimBefore point
-    if (trimBefore) {
-      const points = [];
-
-      for (let i = 0; i < trimBefore.segmentIndex - 1; i++) {
-        points.push(this.points[i].clone());
-      }
-
-      // Add the segment start point (with adjusted bulge for arcs)
-      const segStart = this.points[trimBefore.segmentIndex - 1];
-      const segStartClone = segStart.clone();
-      if (segStart.bulge !== 0) {
-        segStartClone.bulge = segStart.partialBulge(this.points[trimBefore.segmentIndex], trimBefore.point);
-      }
-      points.push(segStartClone);
-
-      // Add the trim point (skip if it coincides with the last added point)
-      const trimPoint = trimBefore.point.clone();
-      if (!points.at(-1).isSame(trimPoint)) {
-        points.push(trimPoint);
-      }
-
-      if (points.length >= 2) {
-        const polyline = Utils.cloneObject(this);
-        polyline.points = points;
-        polyline.flags.removeValue(1); // clear closed bit
-        stateChanges.push(new AddState(polyline));
-      }
-    }
-
-    // Portion 2: trimAfter point to end of polyline
-    if (trimAfter) {
-      const points = [];
-      const trimPoint = trimAfter.point.clone();
-
-      // If the segment is an arc, set remaining arc bulge
-      const segStart = this.points[trimAfter.segmentIndex - 1];
-      if (segStart.bulge !== 0) {
-        trimPoint.bulge = segStart.partialBulge(this.points[trimAfter.segmentIndex], trimPoint, true);
-      }
-
-      points.push(trimPoint);
-
-      // Add remaining points (skip if coincides with the trim point)
-      for (let i = trimAfter.segmentIndex; i < this.points.length; i++) {
-        const nextPoint = this.points[i].clone();
-        if (!points.at(-1).isSame(nextPoint)) {
-          points.push(nextPoint);
-        }
-      }
-
-      if (points.length >= 2) {
-        const polyline = Utils.cloneObject(this);
-        polyline.points = points;
-        polyline.flags.removeValue(1); // clear closed bit
-        stateChanges.push(new AddState(polyline));
-      }
-    }
-
-    if (trimBefore || trimAfter) {
-      stateChanges.push(new RemoveState(this));
-    }
-
-    return stateChanges;
-  }
-
   /**
    * Return boundingbox for entity
    * @return {BoundingBox}
@@ -742,8 +490,8 @@ export class BasePolyline extends Entity {
       let boundingBox = BoundingBox.lineBoundingBox(this.points[i], nextPoint);
 
       if (this.points[i].bulge !== 0) {
-        const centerPoint = this.points[i].bulgeCentrePoint(nextPoint);
-        boundingBox = BoundingBox.arcBoundingBox(centerPoint, this.points[i], nextPoint, this.points[i].bulge);
+        const centrePoint = this.points[i].bulgeCentrePoint(nextPoint);
+        boundingBox = BoundingBox.arcBoundingBox(centrePoint, this.points[i], nextPoint, this.points[i].bulge);
       }
 
       xmin = Math.min(xmin, boundingBox.xMin);
@@ -771,9 +519,9 @@ export class BasePolyline extends Entity {
     // get the angle at the end of the previous segment
     let lastSegAngle;
     if (lastSegIsArc) {
-      const centerPoint = this.points.at(-2).bulgeCentrePoint(this.points.at(-1));
-      // angle is perpendicular to the center-to-end point ray, in the direction of the bulge
-      lastSegAngle = centerPoint.angle(this.points.at(-1)) + (Math.PI / 2) * Math.sign(lastSegBulge);
+      const centrePoint = this.points.at(-2).bulgeCentrePoint(this.points.at(-1));
+      // angle is perpendicular to the centre-to-end point ray, in the direction of the bulge
+      lastSegAngle = centrePoint.angle(this.points.at(-1)) + (Math.PI / 2) * Math.sign(lastSegBulge);
     } else {
       // line segment angle is the angle from point 0 to point 1
       lastSegAngle = this.points.at(-2).angle(this.points.at(-1));

package/core/entities/rectangle.js

@@ -4,6 +4,7 @@ import { Entity } from './entity.js';
 import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
 import { Polyline } from './polyline.js';
+import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 import { DesignCore } from '../designCore.js';
 
@@ -67,8 +68,9 @@ export class Rectangle extends Entity {
   preview() {
     if (this.points.length >= 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
+      DesignCore.Scene.auxiliaryEntities.add(new RubberBand([this.points.at(-1), mousePoint]));
       const points = this.rectPoints(this.points.at(-1), mousePoint);
-      DesignCore.Scene.tempEntities.create('Polyline', { points: points });
+      DesignCore.Scene.previewEntities.create('Polyline', { points: points });
     }
   }
 

package/core/entities/solid.js

@@ -1,6 +1,7 @@
 import { Entity } from './entity.js';
 import { DXFFile } from '../lib/dxf/dxfFile.js';
 import { BoundingBox } from '../lib/boundingBox.js';
+import { Property } from '../properties/property.js';
 
 /**
  * Solid Entity Class
@@ -19,20 +20,10 @@ export class Solid extends Entity {
 
   /**
    * Draw the entity
-   * @param {Object} ctx - context
-   * @param {number} scale
+   * @param {Object} renderer
    */
-  draw(ctx, scale) {
-    this.points.forEach((point, index) => {
-      if (index == 0) {
-        ctx.moveTo(point.x, point.y);
-      } else {
-        ctx.lineTo(point.x, point.y);
-      }
-    });
-
-    ctx.closePath();
-    ctx.fill();
+  draw(renderer) {
+    renderer.drawShape(this.points, { closed: true, fill: true, stroke: false });
   }
 
   /**
@@ -41,10 +32,10 @@ export class Solid extends Entity {
    */
   dxf(file) {
     file.writeGroupCode('0', 'SOLID');
-    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('5', this.getProperty(Property.Names.HANDLE), DXFFile.Version.R2000); // Handle
     file.writeGroupCode('100', 'AcDbEntity', DXFFile.Version.R2000);
     file.writeGroupCode('100', 'AcDbTrace', DXFFile.Version.R2000);
-    file.writeGroupCode('8', this.layer);
+    file.writeGroupCode('8', this.getProperty(Property.Names.LAYER));
     file.writeGroupCode('10', this.points[0].x);
     file.writeGroupCode('20', this.points[0].y);
     file.writeGroupCode('30', '0.0');