@design-core/core 51.2.0 → 52.0.0

package/core/tools/gripStretch.js

@@ -0,0 +1,97 @@
+import { Tool } from './tool.js';
+import { Strings } from '../lib/strings.js';
+import { Input } from '../lib/input.js';
+import { PromptOptions } from '../lib/promptOptions.js';
+import { Logging } from '../lib/logging.js';
+import { UpdateState } from '../lib/stateManager.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * GripStretch Command Class
+ * Not shown in any toolbar and never started via the command line - only InputManager creates it.
+ * @extends Tool
+ */
+export class GripStretch extends Tool {
+  static type = 'GripStretch';
+
+  /**
+   * Create a GripStretch command
+   * @param {number} entityIndex - index of the entity in the selection set that owns the grip
+   * @param {Object} grip - { point, apply } descriptor returned by Entity.getGrips()
+   */
+  constructor(entityIndex, grip) {
+    super();
+    this.entityIndex = entityIndex;
+    this.grip = grip;
+  }
+
+  /**
+   * Execute method
+   * requests the stretch point, then commits it - keeping the entity selected afterwards
+   * (with its grips still visible), unlike most commands which deselect on completion
+   */
+  async execute() {
+    try {
+      const op = new PromptOptions(Strings.Input.STRETCHPOINT, [Input.Type.POINT]);
+      const newPoint = await DesignCore.Scene.inputManager.requestInput(op);
+      if (newPoint === undefined) return;
+      this.points.push(newPoint);
+
+      const inputManager = DesignCore.Scene.inputManager;
+      inputManager.actionCommand();
+
+      // finish without the standard executeCommand()/reset() combo, which would deselect the
+      // entity via Scene.reset() - grip editing must leave it selected (grips still visible)
+      inputManager.activeCommand = undefined;
+      inputManager.promptOption = undefined;
+      // reset() normally clears this - without it the next command's first point (or the next
+      // grip drag's tracking line) would stay anchored to this drop, not start fresh
+      inputManager.inputPoint = null;
+      DesignCore.CommandLine.resetPrompt();
+      DesignCore.Scene.selectionManager.reloadSelectedEntities();
+      DesignCore.Canvas.requestPaint();
+    } catch (err) {
+      Logging.instance.error(`${this.type} - ${err}`);
+    }
+  }
+
+  /**
+   * Preview the live grip position while dragging
+   */
+  preview() {
+    const newPoints = this.grip.apply(DesignCore.Mouse.pointOnScene());
+    const previewIndex = DesignCore.Scene.selectionManager.selectionSet.selectionSet.indexOf(this.entityIndex);
+    if (previewIndex !== -1) {
+      DesignCore.Scene.selectionManager.selectedEntities[previewIndex].setProperty('points', newPoints);
+    }
+  }
+
+  /**
+   * Perform the command - commits the grip's new (dropped) position
+   */
+  action() {
+    const entity = DesignCore.Scene.entities.get(this.entityIndex);
+    const newPoints = this.grip.apply(this.points[0]);
+    const properties = { points: newPoints };
+    // all grips currently implemented reposition dimension text - record the flag
+    // explicitly so its pre-drag value is captured by the UpdateState undo snapshot too
+    if (entity.dimType) {
+      properties.userPositionedText = true;
+    }
+    DesignCore.Scene.commit([new UpdateState(entity, properties)]);
+  }
+
+  /**
+   * Cancel the in-progress stretch - unlike Tool's default (full reset), this must not deselect
+   * the entity, and must resolve the suspended execute()'s pending requestInput() promise so it
+   * doesn't stay forever awaiting a prompt nobody can respond to or cancel again
+   */
+  cancel() {
+    const inputManager = DesignCore.Scene.inputManager;
+    inputManager.promptOption?.cancel();
+    inputManager.promptOption = undefined;
+    inputManager.activeCommand = undefined;
+    DesignCore.Scene.selectionManager.reloadSelectedEntities();
+  }
+}

package/core/tools/offset.js

@@ -151,7 +151,13 @@ export class Offset extends Tool {
     const isClosed = polyPts.length >= 3 && polyPts[0].isSame(polyPts.at(-1));
     const points = isClosed ? polyPts.slice(0, -1) : polyPts;
 
-    return this.getOffsetPolylinePoints(points, isClosed, sidePoint, distance);
+    const offsetPoints = this.getOffsetPolylinePoints(points, isClosed, sidePoint, distance);
+    if (offsetPoints && isClosed) {
+      // restore the closing point so closed entities (e.g. Circle) are rebuilt as closed, not as an Arc
+      offsetPoints.push(new Point(offsetPoints[0].x, offsetPoints[0].y));
+    }
+
+    return offsetPoints;
   }
 
   /**

package/core/tools/tool.js

@@ -1,3 +1,5 @@
+import { DesignCore } from '../designCore.js';
+
 /**
  * Tool Class
  */
@@ -28,5 +30,13 @@ export class Tool {
   action() {
     // action function to be overridden by implementation
   };
+
+  /**
+   * Cancel this command while it is active - overridden by implementations that need to
+   * clean up differently to the default full reset (e.g. GripStretch, which must not deselect)
+   */
+  cancel() {
+    DesignCore.Scene.inputManager.reset();
+  };
 }
 

package/cspell.json

@@ -45,6 +45,7 @@
         "dimstyles",
         "dimline",
         "DIMENSIONSTYLE",
+        "USERPOSITIONEDTEXT",
         "DIMADEC",
         "DIMALI",
         "DIMALT",
@@ -127,6 +128,7 @@
         "DIMTSZ",
         "DIMTVP",
         "DIMTXSTY",
+        "DIMTXSTYISHANDLE",
         "DIMTXT",
         "DIMTXTDIRECTION",
         "DIMTZIN",
@@ -197,6 +199,7 @@
         "SCALEFACTOR",
         "SECONDCORNER",
         "selectedchild",
+        "STRETCHPOINT",
         "SELECTIONSET",
         "SEQEND",
         "SINGLESELECTION",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-core/core",
-  "version": "51.2.0",
+  "version": "52.0.0",
   "type": "module",
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"

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