@design-core/core 51.1.0 → 52.0.0

package/test/dimensions/alignedDimension.test.js

@@ -3,6 +3,8 @@ import { Point } from '../../core/entities/point.js';
 import { DesignCore } from '../../core/designCore.js';
 import { Core } from '../../core/core/core.js';
 import { Line } from '../../core/entities/line.js';
+import { DxfIterator } from '../../core/lib/dxf/dxfIterator.js';
+import { Entities } from '../../core/lib/dxf/sections/entities.js';
 import { File, withMockInput } from '../test-helpers/test-helpers.js';
 
 // initialise core
@@ -103,6 +105,154 @@ describe('AlignedDimension.getPointsFromSelection', () => {
   });
 });
 
+// Regression test: dragging the Pt11 (text) grip must recompute Pt10 (the dimension line's
+// far end) from the unchanged Pt13/Pt14 - previously Pt10 was left frozen at its creation-time
+// value, so moving Pt11 alone produced no visible change (text falls back to the midpoint,
+// and the dimension line/value are driven entirely by the stale Pt10)
+test('getGrips recomputes Pt10 (not stale) when the Pt11 grip moves', () => {
+  const pt13 = new Point(0, 0);
+  const pt14 = new Point(10, 0);
+  const points = AlignedDimension.getPointsFromSelection([new Line({ points: [pt13, pt14] })], new Point(5, 5));
+  const dim = new AlignedDimension({ points });
+
+  const originalPt10 = dim.getPointBySequence(dim.points, 10);
+  expect(originalPt10.x).toBeCloseTo(10);
+  expect(originalPt10.y).toBeCloseTo(5);
+
+  const grips = dim.getGrips();
+  expect(grips).toHaveLength(1);
+  expect(grips[0].point.x).toBeCloseTo(5);
+  expect(grips[0].point.y).toBeCloseTo(5);
+
+  const newPoints = grips[0].apply(new Point(5, 20));
+  const newPt11 = newPoints.find((p) => p.sequence === 11);
+  const newPt10 = newPoints.find((p) => p.sequence === 10);
+
+  expect(newPt11.x).toBeCloseTo(5);
+  expect(newPt11.y).toBeCloseTo(20);
+  // Pt10 must track the moved Pt11, not stay frozen at its original position
+  expect(newPt10.y).not.toBeCloseTo(originalPt10.y);
+  expect(newPt10.x).toBeCloseTo(10);
+  expect(newPt10.y).toBeCloseTo(20);
+
+  // the measured value (driven by Pt13/Pt14, unchanged) must still be correct
+  const rebuilt = new AlignedDimension({ points: newPoints });
+  const text = rebuilt.buildDimension().find((e) => e.type === 'Text');
+  expect(Number(text.getProperty('string'))).toBeCloseTo(10);
+});
+
+// Regression test: committing a grip-dragged Pt11 (the InputManager drop path - setProperty('points', ...))
+// must actually move the rendered text, not just the stored point. DIMJUST=0 (the default) hardcodes
+// textPosition to the midpoint when text fits inside the extension lines, ignoring Pt11 entirely -
+// unless the dimension is flagged as user-positioned (DXF bit 128), which setProperty() must now detect
+test('dragging the Pt11 grip via setProperty moves the rendered text, not just the stored point', () => {
+  const pt13 = new Point(0, 0);
+  const pt14 = new Point(10, 0);
+  const points = AlignedDimension.getPointsFromSelection([new Line({ points: [pt13, pt14] })], new Point(5, 1));
+  const dim = new AlignedDimension({ points });
+
+  // sanity check: with the default DIMJUST=0 and short text fitting inside, text starts at the midpoint
+  const textBefore = dim.buildDimension().find((e) => e.type === 'Text');
+  expect(textBefore.points[0].x).toBeCloseTo(5);
+
+  expect(dim.dimType.hasUserPositionedText()).toBe(false);
+
+  const grip = dim.getGrips()[0];
+  const newPoints = grip.apply(new Point(5, 30));
+
+  // exactly what InputManager's drop handler does: entity.setProperty('points', newPoints)
+  dim.setProperty('points', newPoints);
+
+  expect(dim.dimType.hasUserPositionedText()).toBe(true);
+
+  const textAfter = dim.buildDimension().find((e) => e.type === 'Text');
+  expect(textAfter.points[0].x).toBeCloseTo(5);
+  expect(textAfter.points[0].y).toBeCloseTo(30);
+});
+
+// Regression test: DIMTAD's vertical offset must still apply on top of a user-positioned
+// (grip-dragged) text anchor - user-positioning only replaces the DIMJUST auto-anchor, it
+// doesn't bypass DIMTAD entirely
+test('DIMTAD vertical offset still applies on top of a user-positioned text', () => {
+  const pt13 = new Point(0, 0);
+  const pt14 = new Point(10, 0);
+  const points = AlignedDimension.getPointsFromSelection([new Line({ points: [pt13, pt14] })], new Point(5, 5));
+  const dim = new AlignedDimension({ points });
+
+  const realStyle = dim.getDimensionStyle();
+  const DIMTXT = realStyle.getValue('DIMTXT');
+  const DIMGAP = realStyle.getValue('DIMGAP');
+  // DIMTAD = 4: places the dimension text below the dimension line
+  dim.getDimensionStyle = () => ({
+    getValue: (prop) => (prop === 'DIMTAD' ? 4 : realStyle.getValue(prop)),
+  });
+
+  const grip = dim.getGrips()[0];
+  const newPoints = grip.apply(new Point(5, 30));
+  dim.setProperty('points', newPoints);
+
+  expect(dim.dimType.hasUserPositionedText()).toBe(true);
+
+  const text = dim.buildDimension().find((e) => e.type === 'Text');
+  // anchored at the user-positioned Pt11 (x=5, y=30), then offset below by DIMTAD=4
+  expect(text.points[0].x).toBeCloseTo(5);
+  expect(text.points[0].y).toBeCloseTo(30 - (DIMTXT * 0.5 + DIMGAP));
+});
+
+// Regression test: userPositionedText (DXF group 70 bit 128) must survive a real write -> parse ->
+// reconstruct DXF round-trip. AlignedDimension's constructor used to call dimType.setDimType(1) after
+// super(data), which clobbered the flags super(data) had just loaded from group 70, reverting a
+// grip-edited dimension back to automatic text placement when the file was reopened
+test('grip-edited dimension preserves userPositionedText through a DXF round-trip', () => {
+  const pt13 = new Point(0, 0);
+  const pt14 = new Point(10, 0);
+  const points = AlignedDimension.getPointsFromSelection([new Line({ points: [pt13, pt14] })], new Point(5, 5));
+  const dim = new AlignedDimension({ points, handle: '1' });
+
+  // grip-drag Pt11 away from the DIMJUST-computed anchor
+  const grip = dim.getGrips()[0];
+  const newPoints = grip.apply(new Point(5, 30));
+  dim.setProperty('points', newPoints);
+  expect(dim.dimType.hasUserPositionedText()).toBe(true);
+
+  // write the grip-edited dimension to DXF text
+  const file = new File();
+  dim.dxf(file);
+
+  // parse the written text back through the real DXF entity reader (not an object-spread shortcut)
+  const iterator = new DxfIterator();
+  iterator.loadFile(`0\nENTITIES\n${file.contents}0\nENDSEC\n0\nEOF`);
+  const [rawEntity] = new Entities().read(iterator);
+  rawEntity.points = rawEntity.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence));
+
+  // reconstruct through the same command dispatch path used when loading a DXF file
+  const reloaded = DesignCore.CommandManager.createNew(rawEntity[0], rawEntity);
+
+  expect(reloaded).toBeInstanceOf(AlignedDimension);
+  expect(reloaded.dimType.hasUserPositionedText()).toBe(true);
+
+  const text = reloaded.buildDimension().find((e) => e.type === 'Text');
+  expect(text.points[0].x).toBeCloseTo(5);
+  expect(text.points[0].y).toBeCloseTo(30);
+});
+
+// Regression test: a rigid whole-dimension Move (all points translated together, including Pt11)
+// must NOT be mistaken for a grip-drag - auto text placement should keep working normally
+test('a rigid Move (all points translated together) does not set userPositionedText', () => {
+  const pt13 = new Point(0, 0);
+  const pt14 = new Point(10, 0);
+  const points = AlignedDimension.getPointsFromSelection([new Line({ points: [pt13, pt14] })], new Point(5, 5));
+  const dim = new AlignedDimension({ points });
+
+  const delta = new Point(100, 100);
+  const movedPoints = dim.points.map((p) => new Point(p.x + delta.x, p.y + delta.y, p.bulge, p.sequence));
+
+  dim.setProperty('points', movedPoints);
+
+  expect(dim.dimType.hasUserPositionedText()).toBe(false);
+});
+
+
 test('AlignedDimension.preview runs without error and calls createTempItem', () => {
   const origAddAux = DesignCore.Scene.auxiliaryEntities.add;
   const origCreateTempItem = DesignCore.Scene.previewEntities.create;
@@ -216,3 +366,18 @@ AcDbAlignedDimension
   newDimension.dxf(file);
   expect(file.contents).toEqual(dxfString);
 });
+
+test('snaps returns END snaps at the dimension line endpoints', () => {
+  const points = AlignedDimension.getPointsFromSelection([new Line({ points: [new Point(0, 0), new Point(10, 0)] })], new Point(5, 5));
+  const dim = new AlignedDimension({ points });
+  const snaps = dim.snaps(new Point(), 1);
+
+  expect(snaps.length).toBe(2);
+  expect(snaps.every((snap) => snap.type === 'end')).toBe(true);
+  expect(snaps[0].snapPoint.isSame(new Point(0, 5))).toBe(true);
+  expect(snaps[1].snapPoint.isSame(new Point(10, 5))).toBe(true);
+});
+
+test('snaps returns no snaps when the dimension has no points', () => {
+  expect(new AlignedDimension().snaps(new Point(), 1)).toEqual([]);
+});

package/test/dimensions/angularDimension.test.js

@@ -6,6 +6,7 @@ import { Polyline } from '../../core/entities/polyline.js';
 import { Core } from '../../core/core/core.js';
 import { DesignCore } from '../../core/designCore.js';
 import { SingleSelection } from '../../core/lib/selectionManager.js';
+import { Utils } from '../../core/lib/utils.js';
 
 import { File, withMockInput } from '../test-helpers/test-helpers.js';
 
@@ -77,6 +78,29 @@ test.each(scenarios)('Dimension.execute handles $desc', async (scenario) => {
   }, { selectedEntities });
 });
 
+// Regression test: rigidly rotating an AngularDimension (points, as the Rotate tool
+// does) must not change the measured angle - buildDimension() derives everything from
+// relative angles between the points, not world-axis alignment, so this should already
+// be rotation-invariant (confirms it, mirroring the RotatedDimension/DiametricDimension checks)
+test.each([0, 30, 45, 90, 137, 200])('measured angle is rotation-invariant at %s degrees', (rotationDeg) => {
+  const line1 = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const line2 = new Line({ points: [new Point(0, 0), new Point(10, 10)] }); // 45 degree angle
+  const textPos = new Point(5, 5);
+
+  const points = AngularDimension.getPointsFromSelection([line1, line2], textPos);
+  const dim = new AngularDimension({ points });
+
+  const theta = Utils.degrees2radians(rotationDeg);
+  const centre = new Point(0, 0);
+  const rotatedPoints = dim.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(centre, theta));
+  const rotatedDim = new AngularDimension({ points: rotatedPoints });
+
+  const entities = rotatedDim.buildDimension();
+  const text = entities.find((e) => e.type === 'Text');
+  expect(text).toBeDefined();
+  expect(Number(text.getProperty('string').replace(/[^0-9.-]+/g, ''))).toBeCloseTo(45);
+});
+
 test('constructor sets default properties', () => {
   const dim = new AngularDimension();
   expect(dim).toBeInstanceOf(AngularDimension);
@@ -99,6 +123,114 @@ test('getPointsFromSelection returns correct sequenced points', () => {
   expect(result.length).toBeGreaterThanOrEqual(4);
 });
 
+// Regression test: dragging the Pt11 (text) grip must recompute Pt16 (the dimension arc's
+// radial position) from the unchanged defining lines - previously Pt16 was a frozen copy of
+// Pt11 taken at creation time, so the arc stayed at its original radius when only Pt11 moved
+test('getGrips recomputes Pt16 (not stale) when the Pt11 grip moves', () => {
+  const lineOne = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const lineTwo = new Line({ points: [new Point(0, 0), new Point(10, 10)] });
+  const points = AngularDimension.getPointsFromSelection([lineOne, lineTwo], new Point(5, 5));
+  const dim = new AngularDimension({ points });
+
+  const originalPt16 = dim.getPointBySequence(dim.points, 16);
+
+  const grips = dim.getGrips();
+  expect(grips).toHaveLength(1);
+  expect(grips[0].point.x).toBeCloseTo(5);
+  expect(grips[0].point.y).toBeCloseTo(5);
+
+  const newPoints = grips[0].apply(new Point(20, 20));
+  const newPt11 = newPoints.find((p) => p.sequence === 11);
+  const newPt16 = newPoints.find((p) => p.sequence === 16);
+
+  expect(newPt11.x).toBeCloseTo(20);
+  expect(newPt11.y).toBeCloseTo(20);
+  // Pt16 must track the moved Pt11 (further out along the angle), not stay at its original radius
+  expect(newPt16.x).not.toBeCloseTo(originalPt16.x);
+  expect(newPt16.y).not.toBeCloseTo(originalPt16.y);
+
+  // the measured angle (driven by the two defining lines, unchanged) must still be correct
+  const rebuilt = new AngularDimension({ points: newPoints });
+  const text = rebuilt.buildDimension().find((e) => e.type === 'Text');
+  expect(Number(text.getProperty('string').replace(/[^0-9.-]+/g, ''))).toBeCloseTo(45);
+});
+
+// Regression test: committing a grip-dragged Pt11 (the InputManager drop path - setProperty('points', ...))
+// must actually move the rendered text, not just the stored point - the default auto-placement
+// (arcMiddle) ignores Pt11 entirely unless the dimension is flagged as user-positioned (DXF bit 128)
+test('dragging the Pt11 grip via setProperty moves the rendered text, not just the stored point', () => {
+  const lineOne = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const lineTwo = new Line({ points: [new Point(0, 0), new Point(10, 10)] });
+  const points = AngularDimension.getPointsFromSelection([lineOne, lineTwo], new Point(5, 5));
+  const dim = new AngularDimension({ points });
+
+  expect(dim.dimType.hasUserPositionedText()).toBe(false);
+
+  const grip = dim.getGrips()[0];
+  const newPoints = grip.apply(new Point(20, 20));
+
+  // exactly what InputManager's drop handler does: entity.setProperty('points', newPoints)
+  dim.setProperty('points', newPoints);
+
+  expect(dim.dimType.hasUserPositionedText()).toBe(true);
+
+  const text = dim.buildDimension().find((e) => e.type === 'Text');
+  expect(text.points[0].x).toBeCloseTo(20);
+  expect(text.points[0].y).toBeCloseTo(20);
+});
+
+// Regression test: DIMTAD's vertical offset must still apply on top of a user-positioned
+// (grip-dragged) text anchor - user-positioning only replaces the DIMJUST auto-anchor, it
+// doesn't bypass DIMTAD entirely
+test('DIMTAD vertical offset still applies on top of a user-positioned text', () => {
+  const lineOne = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const lineTwo = new Line({ points: [new Point(0, 0), new Point(10, 10)] });
+  const points = AngularDimension.getPointsFromSelection([lineOne, lineTwo], new Point(5, 5));
+  const dim = new AngularDimension({ points });
+
+  const realStyle = dim.getDimensionStyle();
+  // DIMTAD = 4: places the dimension text below the dimension line
+  dim.getDimensionStyle = () => ({
+    getValue: (prop) => (prop === 'DIMTAD' ? 4 : realStyle.getValue(prop)),
+  });
+
+  const grip = dim.getGrips()[0];
+  const newPoints = grip.apply(new Point(20, 20));
+  dim.setProperty('points', newPoints);
+
+  expect(dim.dimType.hasUserPositionedText()).toBe(true);
+
+  const text = dim.buildDimension().find((e) => e.type === 'Text');
+  // DIMTAD=4 must offset the text away from the pure user-positioned anchor (20,20)
+  const distanceFromAnchor = text.points[0].distance(new Point(20, 20));
+  expect(distanceFromAnchor).toBeGreaterThan(0.01);
+});
+
+// Regression test: a grip-dragged text's rotation must follow the tangent at its new
+// (dragged) position, not stay frozen at the pre-drag DIMJUST-computed rotation
+test('text rotation follows the dragged position, not the pre-drag rotation', () => {
+  const lineOne = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const lineTwo = new Line({ points: [new Point(0, 0), new Point(10, 10)] });
+  const points = AngularDimension.getPointsFromSelection([lineOne, lineTwo], new Point(5, 5));
+  const dim = new AngularDimension({ points });
+
+  const realStyle = dim.getDimensionStyle();
+  // DIMTIH/DIMTOH = 0: text follows the dimension line's direction rather than staying horizontal
+  dim.getDimensionStyle = () => ({
+    getValue: (prop) => ((prop === 'DIMTIH' || prop === 'DIMTOH') ? 0 : realStyle.getValue(prop)),
+  });
+
+  const grip = dim.getGrips()[0];
+  const dragTo = new Point(-20, 5);
+  const newPoints = grip.apply(dragTo);
+  dim.setProperty('points', newPoints);
+
+  const text = dim.buildDimension().find((e) => e.type === 'Text');
+  // expected rotation is the tangent at the dragged point, not the original chord-based angle
+  const expectedRotation = Utils.radians2degrees(dim.getTextDirection(new Point(0, 0).angle(dragTo) + Math.PI / 2)) % 360;
+  expect(text.getProperty('rotation')).toBeCloseTo(expectedRotation);
+});
+
 test('AngularDimension.preview runs without error and calls createTempItem', () => {
   const origCreateTempItem = DesignCore.Scene.previewEntities.create;
   const origPointOnScene = DesignCore.Mouse.pointOnScene;
@@ -241,3 +373,20 @@ AcDb2LineAngularDimension
 });
 
 
+test('snaps returns END snaps at the dimension arc end points', () => {
+  const lineOne = new Line({ points: [new Point(0, 0), new Point(10, 0)] });
+  const lineTwo = new Line({ points: [new Point(0, 0), new Point(0, 10)] });
+  const points = AngularDimension.getPointsFromSelection([lineOne, lineTwo], new Point(5, 5));
+  const dim = new AngularDimension({ points });
+  const snaps = dim.snaps(new Point(), 1);
+  const radius = Math.hypot(5, 5);
+
+  expect(snaps.length).toBe(2);
+  expect(snaps.every((snap) => snap.type === 'end')).toBe(true);
+  expect(snaps.some((snap) => snap.snapPoint.isSame(new Point(radius, 0)))).toBe(true);
+  expect(snaps.some((snap) => snap.snapPoint.isSame(new Point(0, radius)))).toBe(true);
+});
+
+test('snaps returns no snaps when the dimension has no points', () => {
+  expect(new AngularDimension().snaps(new Point(), 1)).toEqual([]);
+});

package/test/dimensions/diametricDimension.test.js

@@ -7,6 +7,7 @@ import { DesignCore } from '../../core/designCore.js';
 import { SingleSelection } from '../../core/lib/selectionManager.js';
 import { Circle } from '../../core/entities/circle.js';
 import { Polyline } from '../../core/entities/polyline.js';
+import { Utils } from '../../core/lib/utils.js';
 
 
 // initialise core
@@ -20,28 +21,28 @@ const scenarios = [
     selectedEntities: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
     expectedDimType: 3,
     dimensionValue: 20,
-    dimensionEntities: 6,
+    dimensionEntities: 7,
   },
   { desc: 'Diametric dimension from circle selection - Text inside circle',
     input: [new SingleSelection(0, new Point()), new Point(0, 0)],
     selectedEntities: [new Circle({ points: [new Point(0, 0), new Point(10, 0)] })],
     expectedDimType: 3,
     dimensionValue: 20,
-    dimensionEntities: 5,
+    dimensionEntities: 8,
   },
   { desc: 'Diametric dimension from arc selection',
     input: [new SingleSelection(0, new Point()), new Point(20, 10)],
     selectedEntities: [new Arc({ points: [new Point(0, 0), new Point(20, 0), new Point(20, 20)] })],
     expectedDimType: 3,
     dimensionValue: 40,
-    dimensionEntities: 6,
+    dimensionEntities: 7,
   },
   { desc: 'Diametric dimension from polyline selection',
     input: [new SingleSelection(0, new Point(30, 10)), new Point(30, 10)],
     selectedEntities: [new Polyline({ points: [new Point(0, 0), new Point(20, 0, 1), new Point(20, 20)] })],
     expectedDimType: 3,
     dimensionValue: 20,
-    dimensionEntities: 6,
+    dimensionEntities: 7,
   },
 ];
 
@@ -69,6 +70,29 @@ test.each(scenarios)('DiametricDimension.execute handles $desc', async (scenario
   }, { selectedEntities });
 });
 
+// Regression test: Pt11 (text position) not lying on the Pt10-Pt15 segment used to be
+// snapped back onto the dimension line via a world-horizontal ray intersection, which
+// silently fails (no intersection) whenever the dimension line itself is near-horizontal -
+// perpendicular projection has no such degenerate case at any rotation angle
+test.each([0, 30, 45, 90, 135, 180, 270])('off-segment text stays connected at %s degree dimension line rotation', (rotationDeg) => {
+  const centre = new Point(0, 0);
+  const circle = new Circle({ points: [centre, new Point(10, 0)] });
+  // text placed off to the side, not on the Pt10-Pt15 line
+  const textPos = new Point(20, 15);
+
+  const theta = Utils.degrees2radians(rotationDeg);
+  const points = DiametricDimension.getPointsFromSelection([circle], textPos)
+      .map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(centre, theta));
+
+  const dim = new DiametricDimension({ points });
+  const entities = dim.buildDimension();
+
+  expect(entities.length).toBeGreaterThan(0);
+  const text = entities.find((e) => e.type === 'Text');
+  expect(text).toBeDefined();
+  expect(Number(text.getProperty('string').replace(/[^0-9.-]+/g, ''))).toBeCloseTo(20);
+});
+
 test('constructor sets default properties', () => {
   const dim = new DiametricDimension();
   expect(dim).toBeInstanceOf(DiametricDimension);
@@ -89,6 +113,39 @@ test('getPointsFromSelection returns correct sequenced points', () => {
   expect(result[2].sequence).toBe(11); // text position
 });
 
+// Regression test: dragging the Pt11 (text) grip must recompute Pt10/Pt15 (the circle attach
+// points) from the unchanged centre/radius - previously they were left frozen at their
+// creation-time angle, so the leader line tracked the new Pt11 but attached to a stale point
+test('getGrips recomputes Pt10/Pt15 (not stale) when the Pt11 grip moves', () => {
+  const centre = new Point(0, 0);
+  const item = { points: [centre], getRadius: () => 10 };
+  const points = DiametricDimension.getPointsFromSelection([item], new Point(10, 0));
+  const dim = new DiametricDimension({ points });
+
+  const originalPt15 = dim.getPointBySequence(dim.points, 15);
+
+  const grips = dim.getGrips();
+  expect(grips).toHaveLength(1);
+  expect(grips[0].point.x).toBeCloseTo(10);
+  expect(grips[0].point.y).toBeCloseTo(0);
+
+  const newPoints = grips[0].apply(new Point(0, -10));
+  const newPt11 = newPoints.find((p) => p.sequence === 11);
+  const newPt15 = newPoints.find((p) => p.sequence === 15);
+
+  expect(newPt11.x).toBeCloseTo(0);
+  expect(newPt11.y).toBeCloseTo(-10);
+  // Pt15 must track the moved Pt11 around the circle, not stay frozen at its original angle
+  expect(newPt15.x).not.toBeCloseTo(originalPt15.x);
+  expect(newPt15.y).not.toBeCloseTo(originalPt15.y);
+  expect(centre.distance(newPt15)).toBeCloseTo(10);
+
+  // the measured value (the diameter, driven by radius, unchanged) must still be correct
+  const rebuilt = new DiametricDimension({ points: newPoints });
+  const text = rebuilt.buildDimension().find((e) => e.type === 'Text');
+  expect(Number(text.getProperty('string').replace(/[^0-9.-]+/g, ''))).toBeCloseTo(20);
+});
+
 test('DiametricDimension.preview runs without error and calls createTempItem', () => {
   const origCreateTempItem = DesignCore.Scene.previewEntities.create;
   const origPointOnScene = DesignCore.Mouse.pointOnScene;
@@ -201,3 +258,18 @@ AcDbDiametricDimension
   newDimension.dxf(file);
   expect(file.contents).toEqual(dxfString);
 });
+
+test('inside text keeps the Pt15 arrow connected to the text and adds an opposite segment', () => {
+  const dim = new DiametricDimension({
+    points: [new Point(-10, 0, 0, 10), new Point(10, 0, 0, 15), new Point(2, 0, 0, 11)],
+  });
+  const lines = dim.buildDimension().filter((e) => e.type === 'Line');
+  const segments = lines.map((l) => l.points.map((p) => p.x).sort((a, b) => a - b));
+
+  // Pt15 to text position
+  expect(segments.some(([a, b]) => a === 2 && b === 10)).toBe(true);
+  // opposite side segment ends at Pt10 and leaves a gap for the text
+  const toPt10 = segments.find(([a]) => a === -10);
+  expect(toPt10).toBeDefined();
+  expect(toPt10[1]).toBeLessThan(2);
+});

package/test/dimensions/dimension.test.js

@@ -92,6 +92,136 @@ test('get linear dimension type', () => {
   expect(dim.getLinearDimensionType(new Point(0, 0), new Point(10, 10), new Point(12.5, 8.5))).toBe(0);
 });
 
+test('get rotated dimension angle', () => {
+  const dim = new Dimension();
+  // vertical edge - only a vertical dimension is non-degenerate
+  expect(dim.getRotatedDimensionAngle(new Point(0, 0), new Point(0, 100), new Point(50, 50))).toBe(90);
+  // horizontal edge - only a horizontal dimension is non-degenerate
+  expect(dim.getRotatedDimensionAngle(new Point(0, 0), new Point(100, 0), new Point(50, 50))).toBe(0);
+  // diagonal edge, pick point deviates mostly in x - vertical dimension
+  expect(dim.getRotatedDimensionAngle(new Point(0, 0), new Point(100, 100), new Point(300, 50))).toBe(90);
+  // diagonal edge, pick point deviates mostly in y - horizontal dimension
+  expect(dim.getRotatedDimensionAngle(new Point(0, 0), new Point(100, 100), new Point(50, 300))).toBe(0);
+});
+
+test.each([
+  { desc: 'vertical', line: new Line({ points: [new Point(0, 0), new Point(0, 100)] }), textPos: new Point(50, 50), expectedAngle: 90 },
+  { desc: 'horizontal', line: new Line({ points: [new Point(0, 0), new Point(100, 0)] }), textPos: new Point(50, 50), expectedAngle: 0 },
+])('Dimension.execute commits a non-degenerate Rotated dimension for a $desc edge', async (scenario) => {
+  const { line, textPos, expectedAngle } = scenario;
+  let committed;
+
+  await withMockInput(DesignCore.Scene, [new SingleSelection(0, new Point()), textPos], async () => {
+    const dim = new Dimension();
+    await dim.execute();
+  }, {
+    selectedEntities: [line],
+    extraMethods: { executeCommand: (entity) => {
+      committed = entity;
+    } },
+  });
+
+  expect(committed.getProperty('linearDimAngle')).toBe(expectedAngle);
+  const box = committed.boundingBox();
+  expect(box.xLength).toBeGreaterThan(0);
+  expect(box.yLength).toBeGreaterThan(0);
+});
+
+test.each([
+  { desc: 'pick far to the right picks a vertical dimension', line: new Line({ points: [new Point(0, 0), new Point(100, 100)] }), textPos: new Point(300, 50), expectedAngle: 90 },
+  { desc: 'pick far above picks a horizontal dimension', line: new Line({ points: [new Point(0, 0), new Point(100, 100)] }), textPos: new Point(50, 300), expectedAngle: 0 },
+])('Dimension.execute allows $desc for a diagonal edge', async (scenario) => {
+  const { line, textPos, expectedAngle } = scenario;
+  let committed;
+
+  await withMockInput(DesignCore.Scene, [new SingleSelection(0, new Point()), textPos], async () => {
+    const dim = new Dimension();
+    await dim.execute();
+  }, {
+    selectedEntities: [line],
+    extraMethods: { executeCommand: (entity) => {
+      committed = entity;
+    } },
+  });
+
+  expect(committed.dimType.getBaseDimType()).toBe(0);
+  expect(committed.getProperty('linearDimAngle')).toBe(expectedAngle);
+  const box = committed.boundingBox();
+  expect(box.xLength).toBeGreaterThan(0);
+  expect(box.yLength).toBeGreaterThan(0);
+});
+
+test('Dimension.execute still allows an Aligned dimension for a diagonal edge', async () => {
+  const line = new Line({ points: [new Point(0, 0), new Point(100, 100)] });
+  let committed;
+
+  await withMockInput(DesignCore.Scene, [new SingleSelection(0, new Point()), new Point(60, 40)], async () => {
+    const dim = new Dimension();
+    await dim.execute();
+  }, {
+    selectedEntities: [line],
+    extraMethods: { executeCommand: (entity) => {
+      committed = entity;
+    } },
+  });
+
+  expect(committed.dimType.getBaseDimType()).toBe(1);
+});
+
+test('Dimension.execute does not show a polar tracking line while picking pt14 or the text position', async () => {
+  const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+  const hoverAt = (point) => {
+    DesignCore.Mouse.setPosFromScenePoint(point);
+    DesignCore.Canvas.mouseMoved();
+  };
+  const clickAt = (point) => {
+    DesignCore.Mouse.setPosFromScenePoint(point);
+    DesignCore.Canvas.mouseDown(0);
+    DesignCore.Canvas.mouseUp(0);
+  };
+
+  const prevEndSnap = DesignCore.Settings.endsnap;
+  const prevMidSnap = DesignCore.Settings.midsnap;
+  const prevCentreSnap = DesignCore.Settings.centresnap;
+  const prevPolar = DesignCore.Settings.polar;
+  DesignCore.Settings.endsnap = false;
+  DesignCore.Settings.midsnap = false;
+  DesignCore.Settings.centresnap = false;
+  DesignCore.Settings.polar = true;
+
+  try {
+    const dim = new Dimension();
+    DesignCore.Scene.inputManager.activeCommand = dim;
+    const execPromise = dim.execute();
+    await flush();
+
+    // pick pt13 directly (point path, not selecting an existing entity)
+    clickAt(new Point(0, 0));
+    await flush();
+
+    // hover to pick pt14 - should not draw a polar tracking line from pt13
+    hoverAt(new Point(100, 1));
+    expect(DesignCore.Scene.auxiliaryEntities.count()).toBe(0);
+
+    clickAt(new Point(100, 0));
+    await flush();
+
+    // hover to pick the text position - should not draw a polar tracking line from pt14
+    hoverAt(new Point(50, 50));
+    expect(DesignCore.Scene.auxiliaryEntities.count()).toBe(0);
+
+    clickAt(new Point(50, 50));
+    await flush();
+    await execPromise;
+  } finally {
+    DesignCore.Settings.endsnap = prevEndSnap;
+    DesignCore.Settings.midsnap = prevMidSnap;
+    DesignCore.Settings.centresnap = prevCentreSnap;
+    DesignCore.Settings.polar = prevPolar;
+    DesignCore.Scene.inputManager.reset();
+  }
+});
+
 
 test('preview calls createTempItem with correct args', () => {
   const dim = new Dimension({ 70: 1 });