@mlightcad/data-model 1.15.17 → 1.15.19

package/lib/entity/AcDbLeader.js

@@ -49,10 +49,14 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
-import { AcGeBox3d, AcGePoint2d, AcGePoint3d, AcGeSpline3d, AcGeVector3d } from '@mlightcad/geometry-engine';
-import { AcDbBlockTableRecord, AcDbDimStyleTableRecord, AcDbDimTextVertical } from '../database/index.js';
+import { AcCmColor } from '@mlightcad/common';
+import { AcGeArea2d, AcGeBox3d, AcGeMatrix3d, AcGePoint2d, AcGePoint3d, AcGePolyline2d, AcGeSpline3d, AcGeVector3d } from '@mlightcad/geometry-engine';
+import { AcDbBlockTableRecord, AcDbDimStyleTableRecord } from '../database/index.js';
+import { ACDB_DSTYLE_XDATA_APP, acdbResolveEffectiveDimStyle } from '../misc/AcDbDimStyleOverrides.js';
 import { acdbDrawTessellateOptions } from '../misc/AcDbDrawTessellate.js';
+import { acdbDecodeDimStyleColor } from '../misc/AcDbMLeaderStyleColorCodec.js';
 import { AcDbOsnapMode } from '../misc/AcDbOsnapMode.js';
+import { AcDbRenderingCache } from '../misc/AcDbRenderingCache.js';
 import { AcDbCurve } from './AcDbCurve.js';
 import { acdbMovePointArrayGripAt } from './AcDbGripHelpers.js';
 import { acdbIntersectPrimitivesFromPointPath } from './AcDbIntersectHelpers.js';
@@ -60,6 +64,8 @@ import { AcDbMText } from './AcDbMText.js';
 import { acdbCollectLineSegmentOsnapPoints, acdbPickNearestOsnapPoint } from './AcDbOsnapHelpers.js';
 import { acdbOffsetVertexPathAsPolyline, AcDbPolyline } from './AcDbPolyline.js';
 import { acdbCollectMTextOrientedCorners, acdbEstimatePlainTextWidth, acdbResolveMTextLayoutMetrics, acdbScorePointAgainstMTextLayout, acdbStripMTextControlCodes } from './AcDbTextExtentsHelpers.js';
+import { acdbEnsureDimArrowBlocks, acdbResolveArrowBlockName, CLOSED_FILLED_ARROW_BLOCK } from './dimension/AcDbDimBlockBuilder.js';
+import { acdbDimFeatureScale } from './dimension/AcDbDimFeatureScale.js';
 /**
  * Defines the annotation type for leader entities.
  */
@@ -297,6 +303,8 @@ var AcDbLeader = /** @class */ (function (_super) {
          */
         set: function (value) {
             this._dimensionStyle = value;
+            this._dimStyle = undefined;
+            this._dimStyleName = undefined;
         },
         enumerable: false,
         configurable: true
@@ -414,6 +422,162 @@ var AcDbLeader = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcDbLeader.prototype, "properties", {
+        /**
+         * Returns the runtime property definition of this leader so the property
+         * palette can show and edit it like other entities.
+         *
+         * The palette resolves each `name` through the `entity.property` locale
+         * namespace and each enum `label` through `entity.enum`, so the names used
+         * here are the ones translated by the viewer.
+         */
+        get: function () {
+            var _this = this;
+            return {
+                type: this.type,
+                groups: [
+                    this.getGeneralProperties(),
+                    {
+                        groupName: 'leader',
+                        properties: [
+                            this.createProperty('dimensionStyleName', 'string', function () { return _this.dimensionStyle; }, function (value) {
+                                _this.dimensionStyle = value;
+                            }),
+                            this.createProperty('annoType', 'enum', function () { return _this.annoType; }, function (value) {
+                                _this.annoType = value;
+                            }, [
+                                {
+                                    label: AcDbLeaderAnnotationType[AcDbLeaderAnnotationType.MText],
+                                    value: AcDbLeaderAnnotationType.MText
+                                },
+                                {
+                                    label: AcDbLeaderAnnotationType[AcDbLeaderAnnotationType.Fcf],
+                                    value: AcDbLeaderAnnotationType.Fcf
+                                },
+                                {
+                                    label: AcDbLeaderAnnotationType[AcDbLeaderAnnotationType.BlockReference],
+                                    value: AcDbLeaderAnnotationType.BlockReference
+                                },
+                                {
+                                    label: AcDbLeaderAnnotationType[AcDbLeaderAnnotationType.NoAnnotation],
+                                    value: AcDbLeaderAnnotationType.NoAnnotation
+                                }
+                            ]),
+                            this.createProperty('hasArrowHead', 'boolean', function () { return _this.hasArrowHead; }, function (value) {
+                                _this.hasArrowHead = value;
+                            }),
+                            this.createProperty('hasHookLine', 'boolean', function () { return _this.hasHookLine; }, function (value) {
+                                _this.hasHookLine = value;
+                            }),
+                            this.createProperty('isHookLineSameDirection', 'boolean', function () { return _this.isHookLineSameDirection; }, function (value) {
+                                _this.isHookLineSameDirection = value;
+                            }),
+                            this.createProperty('isSplined', 'boolean', function () { return _this.isSplined; }, function (value) {
+                                _this.isSplined = value;
+                            }),
+                            this.createProperty('associatedAnnotation', 'string', function () { return _this._associatedAnnotation; }),
+                            this.createProperty('byBlockColor', 'int', function () { return _this._byBlockColor; })
+                        ]
+                    },
+                    {
+                        groupName: 'text',
+                        properties: [
+                            this.createProperty('textHeight', 'float', function () { return _this.textHeight; }, function (value) {
+                                _this.textHeight = value;
+                            }),
+                            this.createProperty('textWidth', 'float', function () { return _this.textWidth; }, function (value) {
+                                _this.textWidth = value;
+                            })
+                        ]
+                    },
+                    {
+                        groupName: 'geometry',
+                        properties: __spreadArray(__spreadArray(__spreadArray(__spreadArray([
+                            {
+                                name: 'vertices',
+                                type: 'array',
+                                editable: false,
+                                itemSchema: {
+                                    properties: [
+                                        { name: 'x', type: 'float', editable: false },
+                                        { name: 'y', type: 'float', editable: false },
+                                        { name: 'z', type: 'float', editable: false }
+                                    ]
+                                },
+                                accessor: {
+                                    get: function () {
+                                        return _this.vertices.map(function (vertex) { return ({
+                                            x: vertex.x,
+                                            y: vertex.y,
+                                            z: vertex.z
+                                        }); });
+                                    }
+                                }
+                            }
+                        ], __read(this.createPoint3dProperties('normal', function () { return _this._normal; })), false), __read(this.createPoint3dProperties('horizontalDirection', function () { return _this._horizontalDirection; })), false), __read(this.createOptionalPoint3dProperties('offsetFromBlock', function () { return _this.offsetFromBlock; }, function (value) {
+                            _this.offsetFromBlock = value;
+                        })), false), __read(this.createOptionalPoint3dProperties('offsetFromAnnotation', function () { return _this.offsetFromAnnotation; }, function (value) {
+                            _this.offsetFromAnnotation = value;
+                        })), false)
+                    }
+                ]
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Builds one runtime property, marking it editable only when a setter exists.
+     */
+    AcDbLeader.prototype.createProperty = function (name, type, get, set, options) {
+        return {
+            name: name,
+            type: type,
+            editable: set != null,
+            options: options,
+            accessor: set ? { get: get, set: set } : { get: get }
+        };
+    };
+    /**
+     * Builds the X/Y/Z properties of a required vector.
+     */
+    AcDbLeader.prototype.createPoint3dProperties = function (prefix, getVector) {
+        return [
+            this.createProperty("".concat(prefix, "X"), 'float', function () { return getVector().x; }, function (value) {
+                getVector().x = value;
+            }),
+            this.createProperty("".concat(prefix, "Y"), 'float', function () { return getVector().y; }, function (value) {
+                getVector().y = value;
+            }),
+            this.createProperty("".concat(prefix, "Z"), 'float', function () { return getVector().z; }, function (value) {
+                getVector().z = value;
+            })
+        ];
+    };
+    /**
+     * Builds the X/Y/Z properties of a vector that may not be present yet.
+     *
+     * Reading an absent vector returns `undefined` so the palette shows an empty
+     * cell; writing any component materializes the vector with the other
+     * components defaulting to `0`.
+     */
+    AcDbLeader.prototype.createOptionalPoint3dProperties = function (prefix, getVector, setVector) {
+        var _this = this;
+        var createAxis = function (axis) {
+            return _this.createProperty("".concat(prefix).concat(axis.toUpperCase()), 'float', function () { var _a; return (_a = getVector()) === null || _a === void 0 ? void 0 : _a[axis]; }, function (value) {
+                var _a, _b, _c;
+                if (value == null)
+                    return;
+                var vector = getVector();
+                setVector({
+                    x: axis === 'x' ? value : ((_a = vector === null || vector === void 0 ? void 0 : vector.x) !== null && _a !== void 0 ? _a : 0),
+                    y: axis === 'y' ? value : ((_b = vector === null || vector === void 0 ? void 0 : vector.y) !== null && _b !== void 0 ? _b : 0),
+                    z: axis === 'z' ? value : ((_c = vector === null || vector === void 0 ? void 0 : vector.z) !== null && _c !== void 0 ? _c : 0)
+                });
+            });
+        };
+        return [createAxis('x'), createAxis('y'), createAxis('z')];
+    };
     /**
      * Appends vertex to the end of the vertex list for this leader. If vertex is not in the plane of the
      * leader, then it will be projected parallel the leader's normal onto the leader's plane and the
@@ -583,11 +747,20 @@ var AcDbLeader = /** @class */ (function (_super) {
     };
     Object.defineProperty(AcDbLeader.prototype, "directBatchPrimitive", {
         /**
-         * This leader always draws as a single `lineStrip` primitive.
+         * This leader draws as a single `lineStrip` primitive unless drawing it
+         * needs more than the entity color already applied by `worldDraw`.
+         *
+         * An arrowhead (DXF 71) adds a second primitive. A DIMCLRD or group 77 color
+         * that differs from the entity color is applied inside `subWorldDraw`, and a
+         * geometry-only batch would keep the entity color instead. Either case falls
+         * back to the legacy draw path. The style lookup is memoized on the leader.
          *
          * @internal
          */
         get: function () {
+            var mayDrawArrowHead = this._hasArrowHead && this._vertices.length >= 2;
+            if (mayDrawArrowHead || this.leaderLineColorDiffersFromEntity())
+                return null;
             return 'lineStrip';
         },
         enumerable: false,
@@ -597,7 +770,238 @@ var AcDbLeader = /** @class */ (function (_super) {
      * @inheritdoc
      */
     AcDbLeader.prototype.subWorldDraw = function (renderer) {
-        return renderer.lines(this.collectDrawPoints(renderer));
+        var _this = this;
+        var entities = [];
+        var points = this.collectDrawPoints(renderer);
+        var leaderColor = this.resolveLeaderLineColor();
+        var traits = renderer.subEntityTraits;
+        var drawGeometry = function () {
+            if (points.length > 0) {
+                entities.push(renderer.lines(points));
+            }
+            var arrowHead = _this.drawArrowHead(renderer, points, leaderColor);
+            if (arrowHead)
+                entities.push(arrowHead);
+        };
+        // Geometry-only renderers omit traits. Touch them only when a dimension
+        // color has to replace the entity color for this draw.
+        if (leaderColor && traits) {
+            var previousColor = traits.color;
+            traits.color = leaderColor;
+            try {
+                drawGeometry();
+            }
+            finally {
+                traits.color = previousColor;
+            }
+        }
+        else {
+            drawGeometry();
+        }
+        if (entities.length === 0)
+            return renderer.lines([]);
+        return entities.length === 1 ? entities[0] : renderer.group(entities);
+    };
+    Object.defineProperty(AcDbLeader.prototype, "hasRenderableArrowHead", {
+        /**
+         * Whether an arrowhead primitive is emitted at the leader start.
+         *
+         * DXF group code 71 (`hasArrowHead`) is authoritative: when it is 0 AutoCAD
+         * draws no arrowhead at all. The arrow geometry itself comes from the
+         * dimension style (DIMLDRBLK arrow block scaled by DIMASZ).
+         */
+        get: function () {
+            if (!this._hasArrowHead || this.numVertices < 2)
+                return false;
+            if (this.resolveArrowHeadBlockName() === '')
+                return false;
+            return this.resolveArrowHeadSize() > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Color of the leader line and arrowhead.
+     *
+     * AutoCAD paints both from DIMCLRD. An explicit ACI (including a DSTYLE
+     * override) wins over the entity color, which is why a ByLayer leader on
+     * layer 0 still draws red when DIMCLRD is 1. ByBlock keeps the entity
+     * color, unless DXF group 77 names a color to use in that case. Group 77
+     * follows the same ACI convention as group 62: 256 is ByLayer.
+     *
+     * @returns The dimension color, or `undefined` when the entity color
+     *   already on the renderer traits should be kept.
+     */
+    AcDbLeader.prototype.resolveLeaderLineColor = function () {
+        var style = this.resolveDimensionStyle();
+        if (!style)
+            return undefined;
+        var dimColor = acdbDecodeDimStyleColor(style.dimclrd);
+        if (dimColor.isByBlock)
+            return this.resolveByBlockLeaderColor();
+        if (dimColor.isByLayer)
+            return this.resolveLayerLeaderColor();
+        return dimColor;
+    };
+    /**
+     * Whether {@link resolveLeaderLineColor} would paint something other than
+     * the color `worldDraw` already stored on the renderer.
+     */
+    AcDbLeader.prototype.leaderLineColorDiffersFromEntity = function () {
+        var leaderColor = this.resolveLeaderLineColor();
+        if (!leaderColor)
+            return false;
+        try {
+            return !leaderColor.equals(this.resolvedColor);
+        }
+        catch (_a) {
+            return true;
+        }
+    };
+    /**
+     * DXF group 77, used only when DIMCLRD is ByBlock.
+     *
+     * `0` and a missing value keep the entity color. `256` is ByLayer.
+     */
+    AcDbLeader.prototype.resolveByBlockLeaderColor = function () {
+        var override = this._byBlockColor;
+        if (override == null || override === 0)
+            return undefined;
+        if (override === 256)
+            return this.resolveLayerLeaderColor();
+        if (override > 0 && override < 256) {
+            var color = new AcCmColor();
+            color.colorIndex = override;
+            return color;
+        }
+        return undefined;
+    };
+    /**
+     * Layer color for DIMCLRD / group 77 ByLayer.
+     *
+     * The returned color is a clone so assigning it to renderer traits cannot
+     * mutate the layer table record.
+     */
+    AcDbLeader.prototype.resolveLayerLeaderColor = function () {
+        var _a;
+        try {
+            return (_a = this.getLayerColor()) === null || _a === void 0 ? void 0 : _a.clone();
+        }
+        catch (_b) {
+            return undefined;
+        }
+    };
+    /**
+     * Draws the arrowhead (DXF group code 71) at the first leader vertex.
+     *
+     * The tip sits on the first vertex and the tail points toward the second
+     * vertex. Arrow blocks are authored with the tip at the block origin and the
+     * tail along -X, so the insert angle maps block +X onto the outward leader
+     * direction. When the referenced block is missing, the built-in AutoCAD
+     * arrow blocks are generated on demand; only the default closed filled arrow
+     * can still be reproduced procedurally if that lookup also fails.
+     *
+     * @param renderer - Renderer used to create the primitive.
+     * @param points - Leader draw points whose first entry is the arrow tip.
+     * @param leaderColor - DIMCLRD color, when it replaces the entity color.
+     * @returns The arrowhead primitive, or `undefined` when none is drawn.
+     */
+    AcDbLeader.prototype.drawArrowHead = function (renderer, points, leaderColor) {
+        var _a;
+        if (!this.hasRenderableArrowHead || points.length < 2)
+            return undefined;
+        var tip = points[0];
+        var next = points.find(function (point) { return !point.equals(tip); });
+        if (!next)
+            return undefined;
+        var intoBody = new AcGeVector3d().subVectors(next, tip);
+        if (intoBody.lengthSq() === 0)
+            return undefined;
+        intoBody.normalize();
+        var size = this.resolveArrowHeadSize();
+        var angle = Math.atan2(-intoBody.y, -intoBody.x);
+        var blockName = this.resolveArrowHeadBlockName();
+        var blockTableRecord = this.resolveArrowHeadBlock(blockName);
+        if (blockTableRecord) {
+            var basePoint = (_a = blockTableRecord.origin) !== null && _a !== void 0 ? _a : AcGePoint3d.ORIGIN;
+            var mBase = new AcGeMatrix3d().makeTranslation(-basePoint.x, -basePoint.y, -basePoint.z);
+            var mScale = new AcGeMatrix3d().makeScale(size, size, size);
+            var mRot = new AcGeMatrix3d().makeRotationZ(angle);
+            var mInsert = new AcGeMatrix3d().makeTranslation(tip.x, tip.y, tip.z);
+            var matrix = new AcGeMatrix3d()
+                .multiplyMatrices(mInsert, mRot)
+                .multiply(mScale)
+                .multiply(mBase);
+            return AcDbRenderingCache.instance.draw(renderer, blockTableRecord, leaderColor !== null && leaderColor !== void 0 ? leaderColor : this.resolvedColor, [], true, matrix, new AcGeVector3d(this.normal));
+        }
+        // Only the default closed-filled arrow can be reproduced procedurally.
+        if (blockName !== CLOSED_FILLED_ARROW_BLOCK)
+            return undefined;
+        var baseCenter = tip.clone().addScaledVector(intoBody, size);
+        var halfWidth = size / 6;
+        var perpendicular = new AcGeVector3d(-intoBody.y, intoBody.x, intoBody.z);
+        var left = baseCenter.clone().addScaledVector(perpendicular, halfWidth);
+        var right = baseCenter.clone().addScaledVector(perpendicular, -halfWidth);
+        var area = new AcGeArea2d();
+        area.add(new AcGePolyline2d([tip, left, right, tip], true));
+        var traits = renderer.subEntityTraits;
+        var originalFillType = traits.fillType;
+        traits.fillType = {
+            solidFill: true,
+            patternAngle: 0,
+            definitionLines: []
+        };
+        var entity = renderer.area(area);
+        traits.fillType = originalFillType;
+        return entity;
+    };
+    /**
+     * Resolves the arrowhead size in drawing units.
+     *
+     * AutoCAD documents DIMASZ as "the size of dimension line **and leader line**
+     * arrowheads", so leaders always use DIMASZ (not the DIMTSZ oblique-tick size,
+     * which only replaces terminators on linear/radius/diameter dimensions).
+     * DIMASZ is scaled by the effective dimension/annotation scale.
+     */
+    AcDbLeader.prototype.resolveArrowHeadSize = function () {
+        var _a;
+        var dimStyle = this.resolveDimensionStyle();
+        if (!dimStyle) {
+            return AcDbDimStyleTableRecord.DEFAULT_DIM_VALUES.dimasz;
+        }
+        var scale = acdbDimFeatureScale(dimStyle, this);
+        var size = ((_a = dimStyle.dimasz) !== null && _a !== void 0 ? _a : 0) * (scale > 0 ? scale : 1);
+        return size > 0 ? size : 0;
+    };
+    /**
+     * Resolves the leader arrowhead block name from DIMLDRBLK.
+     *
+     * An empty DIMLDRBLK means the default closed filled arrow; `_NONE` resolves
+     * to an empty name so no arrowhead is drawn.
+     */
+    AcDbLeader.prototype.resolveArrowHeadBlockName = function () {
+        var dimStyle = this.resolveDimensionStyle();
+        return acdbResolveArrowBlockName(dimStyle === null || dimStyle === void 0 ? void 0 : dimStyle.dimldrblk);
+    };
+    /**
+     * Looks up the arrowhead block table record by name.
+     */
+    AcDbLeader.prototype.resolveArrowHeadBlock = function (name) {
+        if (!name)
+            return undefined;
+        var database = this.tryGetDatabase();
+        if (!database)
+            return undefined;
+        var existing = database.tables.blockTable.getAt(name);
+        if (existing)
+            return existing;
+        // Arrowhead blocks such as `_DOT` / `_ARCHTICK` are AutoCAD built-ins and
+        // are often missing from the drawing's block table; dimension entities
+        // generate them on demand, so leaders must do the same before giving up.
+        var dimStyle = this.resolveDimensionStyle();
+        if (dimStyle)
+            acdbEnsureDimArrowBlocks(database, dimStyle);
+        return database.tables.blockTable.getAt(name);
     };
     /**
      * Builds the leader polyline including the optional horizontal hook line
@@ -621,26 +1025,19 @@ var AcDbLeader = /** @class */ (function (_super) {
         return points;
     };
     /**
-     * Whether a hook line should be rendered for the landing vertex.
+     * Whether a hook line (the landing segment at the annotation end) should be
+     * rendered for the landing vertex.
+     *
+     * DXF group code 75 (and its DWG equivalent `hookline_on`) is authoritative:
+     * when it is 0 AutoCAD does not draw any landing segment, even if the leader
+     * happens to sit next to a text entity. Only a leader that advertises a hook
+     * line is extended here.
      */
     AcDbLeader.prototype.shouldDrawHookLine = function (lastVertex) {
-        var _a;
-        if (this.resolveHookLineLength(lastVertex) <= 0) {
-            return false;
-        }
-        if (this._hasHookLine) {
-            return true;
-        }
-        var mtext = this.resolveAssociatedMText();
-        if (mtext && this.resolveHookSpanFromMText(mtext, lastVertex) > 0) {
-            return true;
-        }
-        if (this._annoType !== AcDbLeaderAnnotationType.MText) {
+        if (!this._hasHookLine) {
             return false;
         }
-        var dimStyle = this.resolveDimensionStyle();
-        var dimtad = (_a = dimStyle === null || dimStyle === void 0 ? void 0 : dimStyle.dimtad) !== null && _a !== void 0 ? _a : AcDbDimStyleTableRecord.DEFAULT_DIM_VALUES.dimtad;
-        return dimtad !== AcDbDimTextVertical.Center;
+        return this.resolveHookLineLength(lastVertex) > 0;
     };
     /**
      * Computes the hook-line endpoint from the last leader vertex.
@@ -654,32 +1051,43 @@ var AcDbLeader = /** @class */ (function (_super) {
         return lastVertex.clone().addScaledVector(direction, hookLength);
     };
     /**
-     * Resolves hook-line length using dimension-style gap plus associated MTEXT
-     * geometry when available.
+     * Resolves the hook-line (landing segment) length and side.
+     *
+     * The landing segment spans the annotation box (DXF 41 / associated MTEXT
+     * width) plus the dimension-style gap. A negative DXF 41 means the author
+     * flipped the landing to the opposite side, which matches AutoCAD. When no
+     * annotation width can be resolved there is nothing to land under, so the
+     * hook line is skipped instead of drawing a gap-sized stub past the author's
+     * own geometry.
+     *
+     * @returns The absolute landing length.
      */
     AcDbLeader.prototype.resolveHookLineLength = function (lastVertex) {
-        var _a, _b;
+        var _a;
         var dimStyle = this.resolveDimensionStyle();
         var gap = ((_a = dimStyle === null || dimStyle === void 0 ? void 0 : dimStyle.dimgap) !== null && _a !== void 0 ? _a : AcDbDimStyleTableRecord.DEFAULT_DIM_VALUES.dimgap) *
-            ((_b = dimStyle === null || dimStyle === void 0 ? void 0 : dimStyle.dimscale) !== null && _b !== void 0 ? _b : AcDbDimStyleTableRecord.DEFAULT_DIM_VALUES.dimscale);
-        var length = this._textWidth + gap;
+            (dimStyle ? acdbDimFeatureScale(dimStyle, this) : 1);
+        var declaredWidth = Math.abs(this._textWidth);
+        var length = declaredWidth > 0 ? declaredWidth + gap : 0;
         var mtext = this.resolveAssociatedMText();
         if (mtext) {
             var span = this.resolveHookSpanFromMText(mtext, lastVertex);
-            if (span > 0) {
-                length = Math.max(length, span);
+            if (span > length) {
+                length = span;
             }
             else {
                 var width = this.resolveAnnotationWidth(mtext);
-                if (width > 0) {
-                    length = Math.max(length, width);
-                }
+                if (width > length)
+                    length = width;
             }
         }
         return length;
     };
     /**
      * Returns the signed axis along which the hook line extends.
+     *
+     * DXF 74 gives the hook-line direction relative to the horizontal vector and
+     * a negative DXF 41 (annotation box width) flips it once more.
      */
     AcDbLeader.prototype.resolveHookAxis = function () {
         var direction = this._horizontalDirection.clone();
@@ -689,12 +1097,18 @@ var AcDbLeader = /** @class */ (function (_super) {
         else {
             direction.normalize();
         }
+        // Same direction as the horizontal vector → +1; a negative DXF 41 flips it.
         var sign = this._isHookLineSameDirection ? 1 : -1;
+        if (this._textWidth < 0)
+            sign = -sign;
         direction.multiplyScalar(sign);
         return direction;
     };
     /**
      * Computes hook span from the landing vertex to the far edge of MTEXT bounds.
+     *
+     * The span is measured along the resolved landing axis, which already folds
+     * in the DXF 74 direction and a negative DXF 41 flip.
      */
     AcDbLeader.prototype.resolveHookSpanFromMText = function (mtext, lastVertex) {
         var e_1, _a;
@@ -763,6 +1177,14 @@ var AcDbLeader = /** @class */ (function (_super) {
     };
     /**
      * Resolves the dimension style referenced by this leader.
+     *
+     * Entity-level `ACAD`/`DSTYLE` XData overrides are layered on top of the
+     * referenced table record, so per-leader changes to DIMASZ / DIMGAP /
+     * DIMLDRBLK take effect the way AutoCAD draws them.
+     *
+     * The resolved record is memoized: a leader with overrides needs the
+     * detached style copy, and `subWorldDraw` asks for the style several times
+     * per frame (arrow size, arrow block name, hook gap).
      */
     AcDbLeader.prototype.resolveDimensionStyle = function () {
         var _a;
@@ -771,10 +1193,40 @@ var AcDbLeader = /** @class */ (function (_super) {
         if (!styleName || !database) {
             return undefined;
         }
-        return database.tables.dimStyleTable.getAt(styleName);
+        if (this._dimStyle && this._dimStyleName === styleName) {
+            return this._dimStyle;
+        }
+        var base = database.tables.dimStyleTable.getAt(styleName);
+        var resolved = acdbResolveEffectiveDimStyle(this, base, database);
+        this._dimStyle = resolved;
+        this._dimStyleName = styleName;
+        return resolved;
+    };
+    /**
+     * Drops the memoized effective style when `ACAD` XData changes.
+     */
+    AcDbLeader.prototype.onXDataChanged = function (appId) {
+        if (appId === ACDB_DSTYLE_XDATA_APP) {
+            this._dimStyle = undefined;
+            this._dimStyleName = undefined;
+        }
+    };
+    /**
+     * Drops the memoized effective style when the leader moves to another
+     * database, because the referenced style record belongs to the previous one.
+     */
+    AcDbLeader.prototype.onDatabaseChanged = function () {
+        this._dimStyle = undefined;
+        this._dimStyleName = undefined;
     };
     /**
      * Resolves the MTEXT annotation associated with this leader.
+     *
+     * An explicit `associatedAnnotation` hard pointer (DXF 340) always wins.
+     * The spatial search is only a fallback for leaders that were created with an
+     * MTEXT annotation (DXF 73 = 0); a standalone leader (DXF 73 = 3) has no
+     * annotation, so borrowing an unrelated nearby MTEXT would corrupt its
+     * landing geometry.
      */
     AcDbLeader.prototype.resolveAssociatedMText = function () {
         var e_2, _a;
@@ -784,11 +1236,10 @@ var AcDbLeader = /** @class */ (function (_super) {
         }
         if (this._associatedAnnotation) {
             var object = database.getObjectById(this._associatedAnnotation);
-            if (object instanceof AcDbMText) {
-                return object;
-            }
+            return object instanceof AcDbMText ? object : undefined;
         }
-        if (this._vertices.length === 0) {
+        if (this._annoType !== AcDbLeaderAnnotationType.MText ||
+            this._vertices.length === 0) {
             return undefined;
         }
         var ownerId = this.getAttrWithoutException('ownerId');