@design-core/core 51.2.0 → 52.0.0

package/core/dimensions/alignedDimension.js

@@ -21,7 +21,7 @@ export class AlignedDimension extends LinearDimensionBase {
    */
   constructor(data) {
     super(data);
-    this.dimType.setDimType(1); // Aligned dimension
+    this.dimType.setBaseType(1); // Aligned dimension - preserve flags loaded from DXF group 70
   }
 
   /**
@@ -57,6 +57,8 @@ export class AlignedDimension extends LinearDimensionBase {
       this.points.push(pt14);
 
       const op2 = new PromptOptions(Strings.Input.DIMENSION, [Input.Type.POINT]);
+      // avoid polar/ortho tracking a line from pt14 while placing the dimension
+      DesignCore.Scene.inputManager.inputPoint = null;
       const pt11 = await DesignCore.Scene.inputManager.requestInput(op2);
       pt11.sequence = 11;
       this.points.push(pt11);

package/core/dimensions/angularDimension.js

@@ -10,6 +10,7 @@ import { DXFFile } from '../lib/dxf/dxfFile.js';
 import { DimensionBase } from './dimensionBase.js';
 import { Intersection } from '../lib/intersect.js';
 import { Point } from '../entities/point.js';
+import { SnapPoint } from '../lib/auxiliary/snapPoint.js';
 
 import { Text } from '../entities/text.js'; // used to debug the dimension points
 
@@ -27,7 +28,7 @@ export class AngularDimension extends DimensionBase {
    */
   constructor(data) {
     super(data);
-    this.dimType.setDimType(2); // Angular dimension
+    this.dimType.setBaseType(2); // Angular dimension - preserve flags loaded from DXF group 70
   }
 
   /**
@@ -116,6 +117,8 @@ export class AngularDimension extends DimensionBase {
       }
 
       const op2 = new PromptOptions(Strings.Input.START, [Input.Type.POINT]);
+      // avoid polar/ortho tracking a line from the last defining point while placing the dimension
+      DesignCore.Scene.inputManager.inputPoint = null;
       const Pt11 = await DesignCore.Scene.inputManager.requestInput(op2);
 
       const tempLineOne = new Line({ points: [Pt15, Pt10] });
@@ -151,6 +154,32 @@ export class AngularDimension extends DimensionBase {
     }
   }
 
+  /**
+   * Get the grip points for interactive editing on the canvas.
+   * Pt16 (the dimension arc's radial position) is derived from Pt11 via getPointsFromSelection() -
+   * must be recomputed from the two unchanged defining lines, not left stale.
+   * @return {Array<{point: Point, apply: Function}>} grips
+   */
+  getGrips() {
+    const Pt15 = this.getPointBySequence(this.points, 15);
+    const Pt10 = this.getPointBySequence(this.points, 10);
+    const Pt13 = this.getPointBySequence(this.points, 13);
+    const Pt14 = this.getPointBySequence(this.points, 14);
+    const Pt11 = this.getPointBySequence(this.points, 11);
+
+    if (!Pt15 || !Pt10 || !Pt13 || !Pt14 || !Pt11) {
+      return [];
+    }
+
+    const apply = (newPoint) => {
+      const tempLineOne = new Line({ points: [Pt15, Pt10] });
+      const tempLineTwo = new Line({ points: [Pt13, Pt14] });
+      return AngularDimension.getPointsFromSelection([tempLineOne, tempLineTwo], newPoint);
+    };
+
+    return [{ point: Pt11, apply: apply }];
+  }
+
   /**
    * Get sequenced points from user selection
    * @param {any} entities
@@ -298,6 +327,79 @@ export class AngularDimension extends DimensionBase {
     return sortedPoints;
   }
 
+  /**
+   * Get the dimension arc end points (arrow positions) and the extension line extents
+   * @param {Point} Pt10 - sorted point 10
+   * @param {Point} Pt13 - sorted point 13
+   * @param {Point} Pt14 - sorted point 14
+   * @param {Point} Pt15 - sorted point 15
+   * @param {Point} Pt16 - dimension arc position
+   * @return {Object} {intersectPt, radius, arrow1pos, arrow2pos, line1Extents, line2Extents}
+   */
+  getDimensionArcGeometry(Pt10, Pt13, Pt14, Pt15, Pt16) {
+    const intersectPt = Intersection.intersectSegmentSegment(Pt15, Pt10, Pt13, Pt14, false, true).points[0];
+    const radius = intersectPt.distance(Pt16);
+
+    const quadOneStart = Pt14;
+    const quadOneEnd = Pt10;
+    const quadTwoStart = Pt14.rotate(intersectPt, Math.PI);
+    const quadTwoEnd = Pt10.rotate(intersectPt, Math.PI);
+    let arrow1pos = intersectPt;
+    let arrow2pos = intersectPt;
+    let line1Extents = Pt14;
+    let line2Extents = Pt10;
+    if (Pt16.isOnArc(quadOneStart, quadOneEnd, intersectPt, 1)) {
+      arrow1pos = intersectPt.project(intersectPt.angle(quadOneStart), radius);
+      arrow2pos = intersectPt.project(intersectPt.angle(quadOneEnd), radius);
+      line1Extents = Pt14;
+      line2Extents = Pt10;
+    } else if (Pt16.isOnArc(quadOneEnd, quadTwoStart, intersectPt, 1)) {
+      arrow1pos = intersectPt.project(intersectPt.angle(quadOneEnd), radius);
+      arrow2pos = intersectPt.project(intersectPt.angle(quadTwoStart), radius);
+      line1Extents = Pt10;
+      line2Extents = Pt13;
+    } else if (Pt16.isOnArc(quadTwoStart, quadTwoEnd, intersectPt, 1)) {
+      arrow1pos = intersectPt.project(intersectPt.angle(quadTwoStart), radius);
+      arrow2pos = intersectPt.project(intersectPt.angle(quadTwoEnd), radius);
+      line1Extents = Pt13;
+      line2Extents = Pt15;
+    } else if (Pt16.isOnArc(quadTwoEnd, quadOneStart, intersectPt, 1)) {
+      arrow1pos = intersectPt.project(intersectPt.angle(quadTwoEnd), radius);
+      arrow2pos = intersectPt.project(intersectPt.angle(quadOneStart), radius);
+      line1Extents = Pt15;
+      line2Extents = Pt14;
+    }
+
+    return { intersectPt, radius, arrow1pos, arrow2pos, line1Extents, line2Extents };
+  }
+
+  /**
+   * Get snap points
+   * @param {Point} mousePoint
+   * @param {number} delta
+   * @return {Array} - array of snap points
+   */
+  snaps(mousePoint, delta) {
+    if (!this.getPointBySequence(this.points, 16) || this.points.length < 6) {
+      return [];
+    }
+
+    const sortedPoints = this.sortDimensionPoints();
+    const Pt10 = this.getPointBySequence(sortedPoints, 10);
+    const Pt13 = this.getPointBySequence(sortedPoints, 13);
+    const Pt14 = this.getPointBySequence(sortedPoints, 14);
+    const Pt15 = this.getPointBySequence(sortedPoints, 15);
+    const Pt16 = this.getPointBySequence(this.points, 16);
+
+    const { radius, arrow1pos, arrow2pos } = this.getDimensionArcGeometry(Pt10, Pt13, Pt14, Pt15, Pt16);
+
+    if (radius === 0) {
+      return [];
+    }
+
+    return [arrow1pos, arrow2pos].map((point) => new SnapPoint(point, SnapPoint.Type.END));
+  }
+
   /**
    * Build the dimension
    * @param {Object} style
@@ -337,36 +439,7 @@ export class AngularDimension extends DimensionBase {
       return;
     }
 
-    // Inline quadrant/arrow/line logic
-    const quadOneStart = Pt14;
-    const quadOneEnd = Pt10;
-    const quadTwoStart = Pt14.rotate(intersectPt, Math.PI);
-    const quadTwoEnd = Pt10.rotate(intersectPt, Math.PI);
-    let arrow1pos = intersectPt;
-    let arrow2pos = intersectPt;
-    let line1Extents = Pt14;
-    let line2Extents = Pt10;
-    if (Pt16.isOnArc(quadOneStart, quadOneEnd, intersectPt, 1)) {
-      arrow1pos = intersectPt.project(intersectPt.angle(quadOneStart), radius);
-      arrow2pos = intersectPt.project(intersectPt.angle(quadOneEnd), radius);
-      line1Extents = Pt14;
-      line2Extents = Pt10;
-    } else if (Pt16.isOnArc(quadOneEnd, quadTwoStart, intersectPt, 1)) {
-      arrow1pos = intersectPt.project(intersectPt.angle(quadOneEnd), radius);
-      arrow2pos = intersectPt.project(intersectPt.angle(quadTwoStart), radius);
-      line1Extents = Pt10;
-      line2Extents = Pt13;
-    } else if (Pt16.isOnArc(quadTwoStart, quadTwoEnd, intersectPt, 1)) {
-      arrow1pos = intersectPt.project(intersectPt.angle(quadTwoStart), radius);
-      arrow2pos = intersectPt.project(intersectPt.angle(quadTwoEnd), radius);
-      line1Extents = Pt13;
-      line2Extents = Pt15;
-    } else if (Pt16.isOnArc(quadTwoEnd, quadOneStart, intersectPt, 1)) {
-      arrow1pos = intersectPt.project(intersectPt.angle(quadTwoEnd), radius);
-      arrow2pos = intersectPt.project(intersectPt.angle(quadOneStart), radius);
-      line1Extents = Pt15;
-      line2Extents = Pt14;
-    }
+    const { arrow1pos, arrow2pos, line1Extents, line2Extents } = this.getDimensionArcGeometry(Pt10, Pt13, Pt14, Pt15, Pt16);
 
     const line1Angle = intersectPt.angle(arrow1pos);
     const line2Angle = intersectPt.angle(arrow2pos);
@@ -389,7 +462,7 @@ export class AngularDimension extends DimensionBase {
     let textPosition = arcMiddle;
     let textRotation = this.getTextDirection(horizontalText ? 0 : arrow1pos.angle(arrow2pos));
     let textAboveDirection = textRotation + Math.PI / 2;
-    let textAboveDistance = DIMTXT * 0.5 + DIMGAP;
+    const textAboveDistance = DIMTXT * 0.5 + DIMGAP;
     const outsideOffsetDirection = Pt11.distance(arrow1pos) < Pt11.distance(arrow2pos) ? -1 : 1;
     const textPositionOffsetAngle = arrowRadians * 3;
     const internalPositionAdjustmentAngle = dimension * 0.5 > textPositionOffsetAngle ? dimension * 0.5 - textPositionOffsetAngle : 0;
@@ -428,10 +501,19 @@ export class AngularDimension extends DimensionBase {
         break;
     }
 
-    // Text vertical position
-    const textAndDimlineAligned = this.alignedOrOpposite(textRotation, (intersectPt.angle(textPosition) + Math.PI / 2));
-    const textIsOnExtensionLine = textPosition.perpendicular(intersectPt, arrow1pos).isSame(textPosition) || textPosition.perpendicular(intersectPt, arrow2pos).isSame(textPosition);
-    if (!textAndDimlineAligned && !textIsOnExtensionLine) textAboveDistance = 0;
+    // A grip-dragged text position overrides the DIMJUST auto-placement above with Pt11 as
+    // the anchor - DIMTAD's vertical offset below still applies on top, matching AutoCAD.
+    // Rotation must be recomputed from Pt11's own tangent too, otherwise it's stuck at the
+    // DIMJUST-computed (pre-drag) rotation, which is wrong once the text has moved elsewhere
+    if (this.dimType.hasUserPositionedText()) {
+      textPosition = Pt11;
+      textRotation = this.getTextDirection(horizontalText ? 0 : (intersectPt.angle(Pt11) + Math.PI / 2));
+      textAboveDirection = textRotation + Math.PI / 2;
+    }
+
+    // DIMTAD applies unconditionally (matching CircularDimensionBase) - forced-horizontal text
+    // (DIMTIH/DIMTOH) rarely aligns with the arc's tangent, so gating the offset on that
+    // alignment suppressed DIMTAD for nearly every angular dimension
     switch (DIMTAD) {
       case 1:
       case 2:

package/core/dimensions/circularDimensionBase.js

@@ -5,7 +5,6 @@ import { PolylineBase } from '../entities/polylineBase.js';
 import { Line } from '../entities/line.js';
 import { Text } from '../entities/text.js';
 import { Point } from '../entities/point.js';
-import { Intersection } from '../lib/intersect.js';
 import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
 import { DimensionBase } from './dimensionBase.js';
@@ -70,6 +69,8 @@ export class CircularDimensionBase extends DimensionBase {
       }
 
       const op1 = new PromptOptions(Strings.Input.DIMENSION, [Input.Type.POINT]);
+      // avoid polar/ortho tracking a line from the last defining point while placing the dimension
+      DesignCore.Scene.inputManager.inputPoint = null;
       const Pt11 = await DesignCore.Scene.inputManager.requestInput(op1);
       Pt11.sequence = 11;
       this.points.push(Pt11);
@@ -130,15 +131,9 @@ export class CircularDimensionBase extends DimensionBase {
     // Ensure points are aligned Pt10 > Pt15 > Pt11
     // This resets the points to a known state to allow application of the dimstyle
     if (Pt15.isOnLine(Pt10, Pt11) === false) {
-      // Find the intersection between Pt10 > Pt15 and a horizontal ray from Pt11
-      const line2 = { start: Pt10, end: Pt15 };
-      const line1 = { start: Pt11, end: new Point(Pt10.x, Pt11.y) };
-      const intersect = Intersection.intersectSegmentSegment(line1.start, line1.end, line2.start, line2.end, false, true);
-      // Reset Pt11 - This should be the same as the originally selected Pt11
-      // Pt11 position can be changed depending on the dimstyle
-      if (intersect.points[0]) {
-        Pt11 = intersect.points[0];
-      }
+      // Snap Pt11 onto the (extended) dimension line through Pt10/Pt15 via perpendicular
+      // projection - rotation-invariant, unlike a world-axis-aligned ray intersection
+      Pt11 = Pt11.perpendicular(Pt10, Pt15);
     }
 
     // set a minimum position for the text
@@ -216,13 +211,38 @@ export class CircularDimensionBase extends DimensionBase {
     if (DIMTAD !== 0 && textAndDimlineAligned) {
       lineLength = lineLength + approxTextWidth + DIMTXT; // Add text offset to line length
     }
-    const startPoint = DIMTOFL ? Pt10 : Pt15;
-    const endPoint = Pt15.project(Pt10.angle(Pt15), isInside ? -lineLength : lineLength);
+    const isDiametric = this.dimType.getBaseDimType() === 3;
+    // inside diametric dimensions start at Pt15 so the arrow stays connected to the text
+    const startPoint = isDiametric ? (isInside ? Pt15 : Pt10) : (DIMTOFL ? Pt10 : Pt15);
+    let endPoint = Pt15.project(Pt10.angle(Pt15), isInside ? -lineLength : lineLength);
+    const textOnLine = DIMTAD === 0 && textAndDimlineAligned;
+    const insideDiametric = isDiametric && isInside;
+
+    // text is not on the dimension line, so the line continues to the opposite arrow
+    if (insideDiametric && !textOnLine) {
+      endPoint = Pt10;
+    }
+
     const line = new Line({ points: [startPoint, endPoint] });
     const arrowDirection = isInside ? Pt15.angle(Pt10) : Pt10.angle(Pt15);
     const arrowHead = this.getArrowHead(Pt15, arrowDirection);
     entities.push(line, arrowHead);
 
+    if (insideDiametric && textOnLine) {
+      // opposite side segment, starting after the text and its gap
+      const dirToPt10 = Pt15.angle(Pt10);
+      const oppositeStart = textPosition.project(dirToPt10, approxTextWidth * 0.5 + DIMGAP);
+      if (Pt15.distance(oppositeStart) < Pt15.distance(Pt10)) {
+        entities.push(new Line({ points: [oppositeStart, Pt10] }));
+      }
+    }
+
+    if (isDiametric) {
+      // diametric dimensions have an arrow at both ends of the diameter
+      const oppositeDirection = isInside ? Pt10.angle(Pt15) : Pt15.angle(Pt10);
+      entities.push(this.getArrowHead(Pt10, oppositeDirection));
+    }
+
     // Get the dimension text using the value, position and rotation
     const text = this.getDimensionText(dimension, textPosition, textRotation);
     entities.push(text);

package/core/dimensions/diametricDimension.js

@@ -13,7 +13,7 @@ export class DiametricDimension extends CircularDimensionBase {
    */
   constructor(data) {
     super(data);
-    this.dimType.setDimType(3); // Diametric dimension
+    this.dimType.setBaseType(3); // Diametric dimension - preserve flags loaded from DXF group 70
   }
 
   /**
@@ -52,6 +52,34 @@ export class DiametricDimension extends CircularDimensionBase {
     return points;
   }
 
+  /**
+   * Get the grip points for interactive editing on the canvas.
+   * Pt10/Pt15 are the two diametrically-opposite circle attach points (NOT the centre -
+   * unlike RadialDimension, getPointsFromSelection() reassigns both when Pt11 moves), derived
+   * from Pt11 via getPointsFromSelection() - must be recomputed from the unchanged centre/radius
+   * (reconstructed as their midpoint/half-distance), not left stale.
+   * @return {Array<{point: Point, apply: Function}>} grips
+   */
+  getGrips() {
+    const Pt10 = this.getPointBySequence(this.points, 10); // circle attach point
+    const Pt15 = this.getPointBySequence(this.points, 15); // opposite circle attach point
+    const Pt11 = this.getPointBySequence(this.points, 11); // text position
+
+    if (!Pt10 || !Pt15 || !Pt11) {
+      return [];
+    }
+
+    const centre = Pt10.midPoint(Pt15);
+    const radius = centre.distance(Pt10);
+
+    const apply = (newPoint) => {
+      const tempEntity = { points: [centre], getRadius: () => radius };
+      return this.constructor.getPointsFromSelection([tempEntity], newPoint);
+    };
+
+    return [{ point: Pt11, apply: apply }];
+  }
+
   /**
    * Write the entity to file in the dxf format
    * @param {DXFFile} file

package/core/dimensions/dimension.js

@@ -54,7 +54,14 @@ export class Dimension extends DimensionBase {
     });
 
     if (data) {
-      const entity = new this.dimensionMap[DimType.getBaseType(this.dimType.getBaseDimType())](data);
+      const DimensionType = this.dimensionMap[DimType.getBaseType(this.dimType.getBaseDimType())];
+
+      if (!DimensionType) {
+        // dimType 5 (Angular 3 point) and 6 (Ordinate) are valid DXF types but not yet implemented
+        throw new Error(`${this.type} - ${Strings.Error.INVALIDTYPE}: ${this.dimType.getBaseDimType()}`);
+      }
+
+      const entity = new DimensionType(data);
 
       // find the block linked to this dimension
       const linkedBlockIndex = DesignCore.Scene.entities.find('BLOCK', 'name', data[2]);
@@ -100,6 +107,8 @@ export class Dimension extends DimensionBase {
           this.dimType.setDimType(1);
           // select a second point to define the dimension
           const op1 = new PromptOptions(Strings.Input.END, [Input.Type.POINT]);
+          // avoid polar/ortho tracking a line from the first point while picking the second
+          DesignCore.Scene.inputManager.inputPoint = null;
           const pt14 = await DesignCore.Scene.inputManager.requestInput(op1);
           if (pt14 === undefined) return;
           // Create a temporary line using the selected points
@@ -172,6 +181,8 @@ export class Dimension extends DimensionBase {
           op2 = new PromptOptions(`${Strings.Input.DIMENSION}`, [Input.Type.POINT], options);
         }
 
+        // avoid polar/ortho tracking a line from the last defining point while placing the dimension
+        DesignCore.Scene.inputManager.inputPoint = null;
         const input2 = await DesignCore.Scene.inputManager.requestInput(op2);
         if (input2 === undefined) return;
 
@@ -187,10 +198,16 @@ export class Dimension extends DimensionBase {
               const Pt14 = this.selectedEntities[0].points[1];
               const linearDimTypeNumber = this.getLinearDimensionType(Pt13, Pt14, Pt11);
               this.dimType.setDimType(linearDimTypeNumber);
+
+              // Rotated dimensions use a fixed angle - choose horizontal or vertical based on the pick point
+              if (linearDimTypeNumber === 0) {
+                this.setProperty(Property.Names.LINEARDIMANGLE, this.getRotatedDimensionAngle(Pt13, Pt14, Pt11));
+              }
             }
 
             const dimensionType = this.dimensionMap[this.dimType.getBaseDimType()]; // TODO: use this.dimensionMap.name?
-            this.points.push(...dimensionType.getPointsFromSelection(this.selectedEntities, Pt11));
+            const angle = this.getProperty(Property.Names.LINEARDIMANGLE);
+            this.points.push(...dimensionType.getPointsFromSelection(this.selectedEntities, Pt11, angle));
           }
         }
 
@@ -246,7 +263,15 @@ export class Dimension extends DimensionBase {
         }
       }
 
-      DesignCore.Scene.inputManager.executeCommand(this);
+      // Dimension is a router entity with no buildDimension() of its own -
+      // commit an instance of the resolved subtype (e.g. RotatedDimension), not this
+      const DimensionType = this.dimensionMap[this.dimType.getBaseDimType()];
+      const entity = new DimensionType({
+        points: this.points,
+        dimensionStyle: this.getProperty(Property.Names.DIMENSIONSTYLE),
+        linearDimAngle: this.getProperty(Property.Names.LINEARDIMANGLE),
+      });
+      DesignCore.Scene.inputManager.executeCommand(entity);
     } catch (err) {
       Logging.instance.error(`${this.type} - ${err}`);
     }
@@ -276,6 +301,28 @@ export class Dimension extends DimensionBase {
     }
   }
 
+  /**
+   * Determine the fixed dimension line angle for a Rotated dimension (horizontal or vertical)
+   * @param {Point} Pt13 - start point
+   * @param {Point} Pt14 - end point
+   * @param {Point} Pt11 - pick point used to choose the axis
+   * @return {number} angle in degrees - 0 = horizontal, 90 = vertical
+   */
+  getRotatedDimensionAngle(Pt13, Pt14, Pt11) {
+    const dx = Pt14.x - Pt13.x;
+    const dy = Pt14.y - Pt13.y;
+
+    // axis-aligned edges only have one non-degenerate orientation
+    if (Utils.round(dx) === 0) return 90;
+    if (Utils.round(dy) === 0) return 0;
+
+    // Diagonal edge: pick the axis the pick point deviates from the edge the most along
+    const iX = (Math.abs(Pt11.x - Pt13.x) + Math.abs(Pt14.x - Pt11.x)) - Math.abs(dx);
+    const iY = (Math.abs(Pt11.y - Pt13.y) + Math.abs(Pt14.y - Pt11.y)) - Math.abs(dy);
+
+    return iX >= iY ? 90 : 0;
+  }
+
   /**
    * Preview the entity during creation
    */
@@ -286,20 +333,26 @@ export class Dimension extends DimensionBase {
       const Pt11 = DesignCore.Mouse.pointOnScene();
       Pt11.sequence = 11;
 
+      let angle;
       if (dimTypeNumber === 0 || dimTypeNumber === 1) {
         // for linear dimensions, determine if aligned or rotated based on mouse position
         const Pt13 = this.selectedEntities[0].points[0];
         const Pt14 = this.selectedEntities[0].points[1];
         dimTypeNumber = this.getLinearDimensionType(Pt13, Pt14, Pt11);
+
+        // Rotated dimensions use a fixed angle - choose horizontal or vertical based on the pick point
+        if (dimTypeNumber === 0) {
+          angle = this.getRotatedDimensionAngle(Pt13, Pt14, Pt11);
+        }
       }
       // get the dimension class
       const dimensionType = this.dimensionMap[dimTypeNumber];
       // get the dimension type as a string
       const dimensionTypeString = dimensionType.register().command;
       // get the points for the dimension
-      const points = dimensionType.getPointsFromSelection(this.selectedEntities, Pt11);
+      const points = dimensionType.getPointsFromSelection(this.selectedEntities, Pt11, angle);
       // create the temporary dimension
-      DesignCore.Scene.previewEntities.create(dimensionTypeString, { points: points, dimensionStyle: this.getProperty(Property.Names.DIMENSIONSTYLE) });
+      DesignCore.Scene.previewEntities.create(dimensionTypeString, { points: points, dimensionStyle: this.getProperty(Property.Names.DIMENSIONSTYLE), linearDimAngle: angle });
     }
   }
 }

package/core/dimensions/dimensionBase.js

@@ -84,6 +84,17 @@ export class DimensionBase extends Entity {
       writable: true,
     });
 
+    // DXF Groupcode 70 bit 128 - user-positioned text flag, exposed as a property so a grip-drop
+    // commit can include it explicitly in the UpdateState snapshot, alongside points, for undo/redo
+    this.properties.add(Property.Names.USERPOSITIONEDTEXT, {
+      type: Property.Type.BOOLEAN,
+      visible: false,
+      get: (entity) => entity.dimType.hasUserPositionedText(),
+      set: (entity, value) => {
+        entity.dimType.userPositionedText = value;
+      },
+    });
+
     if (data) {
       if (data.hasOwnProperty('41')) {
         // DXF Groupcode 41 - Line Spacing Factor
@@ -350,6 +361,30 @@ export class DimensionBase extends Entity {
     return DesignCore.DimStyleManager.getItemByName(this.getProperty(Property.Names.DIMENSIONSTYLE));
   }
 
+  /**
+   * Get the grip points for interactive editing on the canvas.
+   * Only the text position (Pt11) is exposed - it's never a dependency for any other point.
+   * @return {Array<{point: Point, apply: Function}>} grips
+   */
+  getGrips() {
+    const Pt11 = this.getPointBySequence(this.points, 11);
+
+    if (!Pt11) {
+      return [];
+    }
+
+    const apply = (newPoint) => {
+      return this.points.map((point) => {
+        if (point.sequence === 11) {
+          return new Point(newPoint.x, newPoint.y, point.bulge, point.sequence);
+        }
+        return point;
+      });
+    };
+
+    return [{ point: Pt11, apply: apply }];
+  }
+
   /**
    * Get the point for the sequence number
    * @param {Array} points - array of points to search
@@ -430,15 +465,24 @@ export class DimensionBase extends Entity {
     return centreMark;
   }
 
+  /**
+   * Refresh the block geometry if it hasn't been built yet.
+   * Needed because block delegates (draw, boundingBox, within, touched, closestPoint)
+   * can run before the first draw() call (e.g. a window-select immediately after creation).
+   */
+  ensureRefreshed() {
+    if (this.block.entities.length === 0) {
+      this.refresh();
+    }
+  }
+
   /**
    * Draw the entity
    * @param {Object} renderer
    * @return {Array} block entities for the canvas to render recursively
    */
   draw(renderer) {
-    if (this.block.entities.length === 0) {
-      this.refresh();
-    }
+    this.ensureRefreshed();
 
     return this.block.entities;
   }
@@ -460,6 +504,7 @@ export class DimensionBase extends Entity {
    * @return {Array} - [Point, distance]
    */
   closestPoint(P) {
+    this.ensureRefreshed();
     return this.block.closestPoint(P);
   }
 
@@ -468,6 +513,7 @@ export class DimensionBase extends Entity {
    * @return {BoundingBox}
    */
   boundingBox() {
+    this.ensureRefreshed();
     return this.block.boundingBox();
   }
 
@@ -477,6 +523,7 @@ export class DimensionBase extends Entity {
    * @return {boolean} true if within
    */
   within(selection) {
+    this.ensureRefreshed();
     return this.block.within(selection);
   }
 
@@ -486,6 +533,7 @@ export class DimensionBase extends Entity {
    * @return {boolean} true if touched
    */
   touched(selection) {
+    this.ensureRefreshed();
     return this.block.touched(selection);
   }
 
@@ -493,7 +541,22 @@ export class DimensionBase extends Entity {
    * Refresh the dimension geometry
    */
   refresh() {
-    const entities = this.buildDimension();
+    // buildDimension() can itself call setProperty() (e.g. LINEARDIMANGLE) which would
+    // otherwise re-enter refresh() recursively - skip while already refreshing
+    if (this.refreshing) {
+      return;
+    }
+
+    this.refreshing = true;
+    let entities;
+    try {
+      entities = this.buildDimension();
+    } catch (err) {
+      // geometry can't be built yet (e.g. incomplete points during interactive creation) - skip this refresh
+      return;
+    } finally {
+      this.refreshing = false;
+    }
 
     if (entities) {
       this.block.clearEntities();
@@ -513,7 +576,47 @@ export class DimensionBase extends Entity {
    */
   setProperty(property, value) {
     if (this.properties.has(property)) {
+      if (property === Property.Names.POINTS) {
+        // Dragging the Pt11 grip independently of the anchor points (Pt13/Pt14) - as opposed
+        // to a rigid whole-dimension Move/Rotate, which moves them together - means the user
+        // has explicitly repositioned the text; record that via the DXF bit 128 flag so
+        // buildDimension() uses Pt11 directly instead of auto-placing it (DIMJUST/DIMTAD)
+        const oldPt11 = this.getPointBySequence(this.points, 11);
+        const oldPt13 = this.getPointBySequence(this.points, 13);
+        const oldPt14 = this.getPointBySequence(this.points, 14);
+        const newPt11 = this.getPointBySequence(value, 11);
+        const newPt13 = this.getPointBySequence(value, 13);
+        const newPt14 = this.getPointBySequence(value, 14);
+
+        if (oldPt11 && newPt11 && oldPt13 && newPt13 && oldPt14 && newPt14) {
+          const pt11Moved = !oldPt11.isSame(newPt11);
+          const anchorsUnchanged = oldPt13.isSame(newPt13) && oldPt14.isSame(newPt14);
+          if (pt11Moved && anchorsUnchanged) {
+            this.dimType.userPositionedText = true;
+          }
+        }
+      }
+
+      if (property === Property.Names.POINTS && this.dimType.getBaseDimType() === 0) {
+        // Rotated dimension: LINEARDIMANGLE is a fixed angle independent of the points,
+        // so a rigid rotation of the points (e.g. via the Rotate tool) must also rotate
+        // this stored angle by the same amount - mirrors Hatch's points -> angle handling
+        const oldPt13 = this.getPointBySequence(this.points, 13);
+        const oldPt14 = this.getPointBySequence(this.points, 14);
+        const newPt13 = this.getPointBySequence(value, 13);
+        const newPt14 = this.getPointBySequence(value, 14);
+
+        if (oldPt13 && oldPt14 && newPt13 && newPt14) {
+          const theta = newPt13.angle(newPt14) - oldPt13.angle(oldPt14);
+          if (theta !== 0) {
+            this.setProperty(Property.Names.LINEARDIMANGLE, this.getProperty(Property.Names.LINEARDIMANGLE) + Utils.radians2degrees(theta));
+          }
+        }
+      }
       super.setProperty(property, value);
+      // geometry is derived from properties (points, style, angle, etc.) - rebuild it,
+      // e.g. so tools like Rotate/Move that update 'points' are reflected visually
+      this.refresh();
       return;
     }
     if (this.hasOwnProperty(property)) {