@design-core/core 51.1.0 → 52.0.0

package/.github/workflows/publish.yml

@@ -0,0 +1,40 @@
+# Publishes @design-core/core to npm when a semver tag (e.g. v51.1.0) is pushed.
+# Requires an NPM_TOKEN repository secret (an "Automation" type npm access token).
+name: Publish to npm
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Use Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.x
+          registry-url: 'https://registry.npmjs.org'
+
+      - run: npm ci
+      - run: npm test -- --coverage
+      - run: npx eslint . --ext .js
+
+      # Fail fast if the tag and package.json version have drifted apart
+      - name: Verify tag matches package.json version
+        run: |
+          PKG_VERSION=$(node -p "require('./package.json').version")
+          TAG_VERSION=${GITHUB_REF_NAME#v}
+          if [ "$PKG_VERSION" != "$TAG_VERSION" ]; then
+            echo "Tag v$TAG_VERSION does not match package.json version $PKG_VERSION"
+            exit 1
+          fi
+
+      - name: Publish to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -14,10 +14,23 @@ Design-Core uses the industry standard Drawing Exchange Format (DXF) to read and
 * Design-Web: https://github.com/dubstar-04/Design-Web
 * HTML Canvas: https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API
 * Cairo: https://www.cairographics.org/
+* npm package: https://www.npmjs.com/package/@design-core/core
 
 
 ## Publishing
 
-npm login
+Releases are published to npm automatically by the [Publish to npm](.github/workflows/publish.yml) workflow whenever a `v*.*.*` tag is pushed:
+
+```bash
+npm version patch   # or minor / major, bumps package.json and creates a git tag
+git push --follow-tags
+```
+
+The workflow runs the test suite and linter, verifies the tag matches `package.json`'s version, then publishes.
 
+To publish manually instead:
+
+```bash
+npm login
 npm publish --access public
+```

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