@design-core/core 51.2.0 → 52.2.0

package/test/dimensions/diametricDimension.test.js

@@ -7,10 +7,12 @@ 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
 new Core();
+DesignCore.DimStyleManager.setCstyle('STANDARD');
 
 // Test cases for user input
 const scenarios = [
@@ -20,28 +22,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 +71,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 +114,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 +259,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 });

package/test/dimensions/dimensionBase.test.js

@@ -219,26 +219,119 @@ describe('DimensionBase', () => {
     expect(baseDim.snaps(new Point(0, 0), 1)).toEqual([]);
   });
 
+  describe('getGrips', () => {
+    test('returns no grips when there is no sequence 11 point', () => {
+      baseDim.points = [Object.assign(new Point(1, 2), { sequence: 13 })];
+      expect(baseDim.getGrips()).toEqual([]);
+    });
+
+    test('returns the text position (Pt11) grip', () => {
+      baseDim.points = [
+        Object.assign(new Point(1, 2), { sequence: 13 }),
+        Object.assign(new Point(5, 6), { sequence: 11 }),
+      ];
+      const grips = baseDim.getGrips();
+      expect(grips.length).toBe(1);
+      expect(grips[0].point.x).toBe(5);
+      expect(grips[0].point.y).toBe(6);
+    });
+
+    test('apply() replaces only the Pt11 point, preserving others and the sequence tag', () => {
+      baseDim.points = [
+        Object.assign(new Point(1, 2), { sequence: 13 }),
+        Object.assign(new Point(5, 6), { sequence: 11 }),
+      ];
+      const grip = baseDim.getGrips()[0];
+      const newPoints = grip.apply(new Point(9, 9));
+
+      expect(newPoints.length).toBe(2);
+      expect(newPoints[0].x).toBe(1);
+      expect(newPoints[0].y).toBe(2);
+      expect(newPoints[0].sequence).toBe(13);
+      expect(newPoints[1].x).toBe(9);
+      expect(newPoints[1].y).toBe(9);
+      expect(newPoints[1].sequence).toBe(11);
+    });
+  });
+
   test('closestPoint delegates to block', () => {
-    baseDim.block = { closestPoint: () => 'foo' };
+    baseDim.block = { entities: ['dummy'], closestPoint: () => 'foo' };
     expect(baseDim.closestPoint(new Point(0, 0))).toBe('foo');
   });
 
   test('boundingBox delegates to block', () => {
-    baseDim.block = { boundingBox: () => 'box' };
+    baseDim.block = { entities: ['dummy'], boundingBox: () => 'box' };
     expect(baseDim.boundingBox()).toBe('box');
   });
 
   test('within delegates to block', () => {
-    baseDim.block = { within: () => true };
+    baseDim.block = { entities: ['dummy'], within: () => true };
     expect(baseDim.within({})).toBe(true);
   });
 
   test('touched delegates to block', () => {
-    baseDim.block = { touched: () => false };
+    baseDim.block = { entities: ['dummy'], touched: () => false };
     expect(baseDim.touched({})).toBe(false);
   });
 
+  /**
+   * Return a DimensionBase with a stubbed buildDimension() that produces one Line,
+   * with an empty (unrefreshed) block - mirrors a freshly created dimension that
+   * hasn't been drawn yet.
+   * @return {DimensionBase}
+   */
+  function makeUnrefreshedDim() {
+    const dim = new DimensionBase({});
+    dim.buildDimension = jest.fn(() => {
+      return [new Line({ points: [new Point(0, 0), new Point(10, 0)] })];
+    });
+    return dim;
+  }
+
+  test('boundingBox refreshes an empty block before delegating (fixes crash on unpainted dimension)', () => {
+    const dim = makeUnrefreshedDim();
+    expect(dim.block.entities).toHaveLength(0);
+    const box = dim.boundingBox();
+    expect(dim.buildDimension).toHaveBeenCalledTimes(1);
+    expect(box).toBeDefined();
+  });
+
+  test('within refreshes an empty block before delegating (fixes window-select crash before first draw)', () => {
+    const dim = makeUnrefreshedDim();
+    expect(dim.block.entities).toHaveLength(0);
+    const result = dim.within({ min: new Point(-100, -100), max: new Point(100, 100) });
+    expect(dim.buildDimension).toHaveBeenCalledTimes(1);
+    expect(result).toBe(true);
+  });
+
+  test('touched refreshes an empty block before delegating', () => {
+    const dim = makeUnrefreshedDim();
+    expect(dim.block.entities).toHaveLength(0);
+    dim.touched({ min: new Point(-100, -100), max: new Point(100, 100) });
+    expect(dim.buildDimension).toHaveBeenCalledTimes(1);
+  });
+
+  test('repeated delegate calls only refresh once the block is populated', () => {
+    const dim = makeUnrefreshedDim();
+    dim.boundingBox();
+    dim.within({ min: new Point(-100, -100), max: new Point(100, 100) });
+    dim.touched({ min: new Point(-100, -100), max: new Point(100, 100) });
+    dim.closestPoint(new Point(0, 0));
+    dim.draw({});
+    expect(dim.buildDimension).toHaveBeenCalledTimes(1);
+  });
+
+  test('setProperty("points", ...) refreshes geometry (fixes Rotate tool not updating dimension display)', () => {
+    const dim = makeUnrefreshedDim();
+    dim.draw({}); // populate block.entities once so we can detect a rebuild
+    const before = dim.block.entities;
+
+    dim.setProperty('points', [new Point(5, 5), new Point(15, 5)]);
+
+    expect(dim.buildDimension).toHaveBeenCalledTimes(2);
+    expect(dim.block.entities).not.toBe(before);
+  });
+
   describe('draw()', () => {
     /**
      * Return a DimensionBase with a stubbed buildDimension() that produces one Line.

package/test/dimensions/radialDimension.test.js

@@ -11,6 +11,7 @@ import { Polyline } from '../../core/entities/polyline.js';
 
 // initialise core
 new Core();
+DesignCore.DimStyleManager.setCstyle('STANDARD');
 
 // Test cases for user input
 const scenarios = [
@@ -89,6 +90,39 @@ test('getPointsFromSelection returns correct sequenced points', () => {
   expect(result[2].sequence).toBe(11); // text position
 });
 
+// Regression test: dragging the Pt11 (text) grip must recompute Pt15 (the circle attach
+// point) from the unchanged centre/radius - previously it was left frozen at its
+// creation-time angle, so the leader line tracked the new Pt11 but attached to a stale point
+test('getGrips recomputes Pt15 (not stale) when the Pt11 grip moves', () => {
+  const centre = new Point(0, 0);
+  const item = { points: [centre], getRadius: () => 10 };
+  const points = RadialDimension.getPointsFromSelection([item], new Point(10, 0));
+  const dim = new RadialDimension({ 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 radius, unchanged) must still be correct
+  const rebuilt = new RadialDimension({ points: newPoints });
+  const text = rebuilt.buildDimension().find((e) => e.type === 'Text');
+  expect(Number(text.getProperty('string').replace(/[^0-9.-]+/g, ''))).toBeCloseTo(10);
+});
+
 test('RadialDimension.preview runs without error and calls createTempItem', () => {
   const origCreateTempItem = DesignCore.Scene.previewEntities.create;
   const origPointOnScene = DesignCore.Mouse.pointOnScene;

package/test/dimensions/rotatedDimension.test.js

@@ -3,6 +3,7 @@ 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 { Utils } from '../../core/lib/utils.js';
 import { File, withMockInput } from '../test-helpers/test-helpers.js';
 
 // initialise core
@@ -229,3 +230,82 @@ AcDbRotatedDimension
   newDimension.dxf(file);
   expect(file.contents).toEqual(dxfString);
 });
+
+// Regression test: rigidly rotating a RotatedDimension (points + linearDimAngle, as the
+// Rotate tool does) must not change the measured value - the dimension line direction is
+// a fixed angle relative to the geometry, not derived from world-axis alignment
+test.each([0, 30, 45, 90, 137, 200])('measured value is rotation-invariant at %s degrees', (rotationDeg) => {
+  const pt13 = new Point(0, 0);
+  const pt14 = new Point(30, 40); // 3-4-5 triangle x10, diagonal edge
+  const pt11 = new Point(60, 20);
+
+  const angleDeg = 90; // vertical dimension line - measures the Y-extent (40)
+  const points = RotatedDimension.getPointsFromSelection([new Line({ points: [pt13, pt14] })], pt11, angleDeg);
+  const dim = new RotatedDimension({ points, linearDimAngle: angleDeg });
+
+  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 rotated = new RotatedDimension({ points: rotatedPoints, linearDimAngle: angleDeg + rotationDeg });
+
+  const entities = rotated.buildDimension();
+  const text = entities.find((e) => e.type === 'Text');
+  expect(Number(text.getProperty('string'))).toBeCloseTo(40);
+});
+
+// Regression test: the Rotate tool only calls entity.setProperty('points', rotatedPoints) -
+// it never touches linearDimAngle directly, so DimensionBase.setProperty() must detect
+// the implied rotation from the points themselves and keep linearDimAngle in sync
+test.each([30, 45, 90, 137, 200])('setProperty(points) alone keeps the measured value correct after a %s degree rotation', (rotationDeg) => {
+  const pt13 = new Point(0, 0);
+  const pt14 = new Point(30, 40);
+  const pt11 = new Point(60, 20);
+
+  const angleDeg = 90;
+  const points = RotatedDimension.getPointsFromSelection([new Line({ points: [pt13, pt14] })], pt11, angleDeg);
+  const dim = new RotatedDimension({ points, linearDimAngle: angleDeg });
+
+  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));
+
+  // exactly what Rotate.action()/preview() call - nothing else
+  dim.setProperty('points', rotatedPoints);
+
+  expect(dim.getProperty('linearDimAngle')).toBeCloseTo(angleDeg + rotationDeg);
+  const text = dim.buildDimension().find((e) => e.type === 'Text');
+  expect(Number(text.getProperty('string'))).toBeCloseTo(40);
+});
+
+// Regression test: dragging the Pt11 (text) grip must recompute Pt10 (the dimension line's
+// far end) from the unchanged Pt13/Pt14 - Pt10 is derived from Pt11 at creation time via
+// getPointsFromSelection() and must not be left stale when only Pt11 moves
+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 = RotatedDimension.getPointsFromSelection([new Line({ points: [pt13, pt14] })], new Point(5, 5), 0);
+  const dim = new RotatedDimension({ points, linearDimAngle: 0 });
+
+  const originalPt10 = dim.getPointBySequence(dim.points, 10);
+
+  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.y).toBeCloseTo(20);
+
+  // the measured value (driven by Pt13/Pt14, unchanged) must still be correct
+  const rebuilt = new RotatedDimension({ points: newPoints, linearDimAngle: 0 });
+  const text = rebuilt.buildDimension().find((e) => e.type === 'Text');
+  expect(Number(text.getProperty('string'))).toBeCloseTo(10);
+});
+

package/test/integration/exportIntegration.reference.dxf

@@ -545,9 +545,7 @@ CloseFilled
 289
 3
 340
-Standard
-341
-ClosedFilled
+19
 371
 -2
 372
@@ -683,9 +681,7 @@ CloseFilled
 289
 3
 340
-Standard
-341
-ClosedFilled
+19
 371
 -2
 372
@@ -821,9 +817,7 @@ CloseFilled
 289
 3
 340
-Standard
-341
-ClosedFilled
+19
 371
 -2
 372

package/test/integration/exportIntegration.test.js

@@ -24,6 +24,7 @@ let core;
 
 beforeAll(() => {
   core = new Core();
+  core.dimStyleManager.setCstyle('STANDARD');
 
   // Entities are arranged in a 3x3 grid of 100x100 cells:
   //

package/test/integration/userInputIntegration.reference.dxf

@@ -405,9 +405,7 @@ CloseFilled
 289
 3
 340
-Standard
-341
-ClosedFilled
+19
 371
 -2
 372
@@ -543,9 +541,7 @@ CloseFilled
 289
 3
 340
-Standard
-341
-ClosedFilled
+19
 371
 -2
 372
@@ -681,9 +677,7 @@ CloseFilled
 289
 3
 340
-Standard
-341
-ClosedFilled
+19
 371
 -2
 372

package/test/integration/userInputIntegration.test.js

@@ -95,6 +95,7 @@ async function executeToolWithInputs(tool, selectionIndices, inputs) {
 
 beforeAll(async () => {
   core = new Core();
+  core.dimStyleManager.setCstyle('STANDARD');
 
   // =====================================================================
   // Phase 1: Showcase entities  (idx 0–7)