@mlightcad/data-model 1.7.28 → 1.7.29

package/lib/entity/AcDbMLeader.js

@@ -13,6 +13,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -38,9 +49,20 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 import { AcGeArea2d, AcGeBox3d, AcGeMatrix3d, AcGePoint3d, AcGePolyline2d, AcGeVector3d } from '@mlightcad/geometry-engine';
 import { AcGiMTextAttachmentPoint, AcGiMTextFlowDirection } from '@mlightcad/graphic-interface';
-import { AcDbRenderingCache, DEFAULT_TEXT_STYLE } from '../misc';
+import { AcDbRenderingCache, decodeMLeaderStyleRawColor, DEFAULT_MLEADER_STYLE, DEFAULT_TEXT_STYLE } from '../misc';
 import { AcDbEntity } from './AcDbEntity';
 /**
  * Defines the type of leader line used by a multileader.
@@ -94,6 +116,13 @@ export var AcDbMLeaderDirectionType;
     /** Leader points below the content. */
     AcDbMLeaderDirectionType[AcDbMLeaderDirectionType["Bottom"] = 4] = "Bottom";
 })(AcDbMLeaderDirectionType || (AcDbMLeaderDirectionType = {}));
+var MLEADER_OVERRIDE_LEADER_LINE_TYPE = 1 << 0;
+var MLEADER_OVERRIDE_LEADER_LINE_COLOR = 1 << 1;
+var MLEADER_OVERRIDE_LEADER_LINE_TYPE_ID = 1 << 2;
+var MLEADER_OVERRIDE_LEADER_LINE_WEIGHT = 1 << 3;
+var MLEADER_OVERRIDE_DOGLEG_ENABLED = 1 << 6;
+var MLEADER_OVERRIDE_DOGLEG_LENGTH = 1 << 7;
+var MLEADER_OVERRIDE_TEXT_COLOR = 1 << 15;
 /**
  * Represents a multileader entity.
  *
@@ -104,6 +133,10 @@ var AcDbMLeader = /** @class */ (function (_super) {
     __extends(AcDbMLeader, _super);
     /**
      * Creates an empty multileader entity with default style-related state.
+     *
+     * @remarks
+     * Initializes geometry, text, and block-related members to defaults that
+     * are compatible with common MLEADER behavior.
      */
     function AcDbMLeader() {
         var _this = _super.call(this) || this;
@@ -1227,6 +1260,9 @@ var AcDbMLeader = /** @class */ (function (_super) {
     });
     /**
      * Adds a leader branch and returns its index.
+     *
+     * @param leader Optional leader payload used to initialize branch data.
+     * @returns Index of the newly added leader branch.
      */
     AcDbMLeader.prototype.addLeader = function (leader) {
         var _this = this;
@@ -1262,6 +1298,9 @@ var AcDbMLeader = /** @class */ (function (_super) {
     };
     /**
      * Removes a leader branch.
+     *
+     * @param leaderIndex Zero-based index of the leader branch to remove.
+     * @returns The current entity instance for chaining.
      */
     AcDbMLeader.prototype.removeLeader = function (leaderIndex) {
         this.checkLeaderIndex(leaderIndex);
@@ -1270,6 +1309,10 @@ var AcDbMLeader = /** @class */ (function (_super) {
     };
     /**
      * Adds a leader line to a leader branch and returns the line index.
+     *
+     * @param leaderIndex Index of the target leader branch.
+     * @param vertices Optional initial vertices for the leader line.
+     * @returns Index of the newly added leader line.
      */
     AcDbMLeader.prototype.addLeaderLine = function (leaderIndex, vertices) {
         if (vertices === void 0) { vertices = []; }
@@ -1279,6 +1322,11 @@ var AcDbMLeader = /** @class */ (function (_super) {
     };
     /**
      * Appends a vertex to one leader line.
+     *
+     * @param leaderIndex Index of the target leader branch.
+     * @param leaderLineIndex Index of the target leader line.
+     * @param point Vertex to append.
+     * @returns The current entity instance for chaining.
      */
     AcDbMLeader.prototype.appendVertex = function (leaderIndex, leaderLineIndex, point) {
         this.getMutableLeaderLine(leaderIndex, leaderLineIndex).vertices.push(this.createPoint(point));
@@ -1286,6 +1334,11 @@ var AcDbMLeader = /** @class */ (function (_super) {
     };
     /**
      * Replaces the vertices of one leader line.
+     *
+     * @param leaderIndex Index of the target leader branch.
+     * @param leaderLineIndex Index of the target leader line.
+     * @param vertices New vertex sequence.
+     * @returns The current entity instance for chaining.
      */
     AcDbMLeader.prototype.setLeaderLineVertices = function (leaderIndex, leaderLineIndex, vertices) {
         var _this = this;
@@ -1580,6 +1633,20 @@ var AcDbMLeader = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    /**
+     * @inheritdoc
+     *
+     * @returns The current entity instance with effective properties resolved.
+     */
+    AcDbMLeader.prototype.resolveEffectiveProperties = function () {
+        _super.prototype.resolveEffectiveProperties.call(this);
+        if (this._mleaderStyleId)
+            return;
+        var style = this.getDefaultMLeaderStyle();
+        if (style) {
+            this._mleaderStyleId = style.objectId;
+        }
+    };
     /**
      * Builds renderable primitives for this multileader entity.
      *
@@ -1589,7 +1656,18 @@ var AcDbMLeader = /** @class */ (function (_super) {
     AcDbMLeader.prototype.subWorldDraw = function (renderer) {
         var _this = this;
         var entities = [];
-        if (this.leaderLineType !== AcDbMLeaderLineType.InvisibleLeader) {
+        var traits = renderer.subEntityTraits;
+        var originalColor = traits.color;
+        var originalRgbColor = traits.rgbColor;
+        var originalLineType = traits.lineType;
+        var originalLineWeight = traits.lineWeight;
+        var leaderLineColor = this.getResolvedLeaderLineColor();
+        var leaderLineStyle = this.getResolvedLeaderLineStyle();
+        var leaderLineWeight = this.getResolvedLeaderLineWeight();
+        var textColor = this.getResolvedTextColor();
+        if (this.getResolvedLeaderLineType() !== AcDbMLeaderLineType.InvisibleLeader) {
+            this.applyColorTraits(traits, leaderLineColor, originalColor, originalRgbColor);
+            this.applyLineTraits(traits, leaderLineStyle, leaderLineWeight);
             this._leaders.forEach(function (leader) {
                 leader.leaderLines.forEach(function (line) {
                     var points = _this.getLeaderLineDrawPoints(leader, line);
@@ -1608,6 +1686,7 @@ var AcDbMLeader = /** @class */ (function (_super) {
         var mtextContent = this.getRenderableMTextContent();
         if (this.contentType === AcDbMLeaderContentType.MTextContent &&
             mtextContent) {
+            this.applyColorTraits(traits, textColor, originalColor, originalRgbColor);
             var textHeight = this.getResolvedTextHeight();
             var mtextData = {
                 text: mtextContent.text,
@@ -1624,6 +1703,10 @@ var AcDbMLeader = /** @class */ (function (_super) {
             // only scheduled for top-level entities, so render nested MText eagerly.
             entities.push(renderer.mtext(mtextData, this.getTextStyle(), false));
         }
+        traits.color = originalColor;
+        traits.rgbColor = originalRgbColor;
+        traits.lineType = originalLineType;
+        traits.lineWeight = originalLineWeight;
         if (entities.length === 0)
             return undefined;
         return entities.length === 1 ? entities[0] : renderer.group(entities);
@@ -1745,6 +1828,8 @@ var AcDbMLeader = /** @class */ (function (_super) {
      * Validates that a leader index is in range.
      *
      * @param leaderIndex Leader branch index to validate.
+     * @throws {Error} Thrown when `leaderIndex` is outside valid range.
+     * @returns `void`.
      */
     AcDbMLeader.prototype.checkLeaderIndex = function (leaderIndex) {
         if (leaderIndex < 0 || leaderIndex >= this._leaders.length) {
@@ -1833,34 +1918,20 @@ var AcDbMLeader = /** @class */ (function (_super) {
      * @returns Dogleg segment points, or `undefined` if not applicable.
      */
     AcDbMLeader.prototype.getDoglegPoints = function (leader) {
-        var _a, _b, _c, _d, _e;
-        if (!this.doglegEnabled)
+        var _a, _b, _c, _d;
+        if (!this.getResolvedDoglegEnabled())
             return undefined;
-        var start = (_c = (_b = (_a = leader.lastLeaderLinePoint) !== null && _a !== void 0 ? _a : leader.landingPoint) !== null && _b !== void 0 ? _b : this._landingPoint) !== null && _c !== void 0 ? _c : this.getLastLeaderLineVertex(leader);
-        var vector = (_d = leader.doglegVector) !== null && _d !== void 0 ? _d : this._doglegVector;
-        var length = (_e = leader.doglegLength) !== null && _e !== void 0 ? _e : this._doglegLength;
-        if (!start || length === 0 || vector.lengthSq() === 0)
+        var start = (_b = (_a = leader.lastLeaderLinePoint) !== null && _a !== void 0 ? _a : leader.landingPoint) !== null && _b !== void 0 ? _b : this._landingPoint;
+        var vector = (_c = leader.doglegVector) !== null && _c !== void 0 ? _c : this._doglegVector;
+        var length = (_d = leader.doglegLength) !== null && _d !== void 0 ? _d : this.getResolvedDoglegLength();
+        if (!start || length == null || length === 0 || vector.lengthSq() === 0) {
             return undefined;
+        }
         var end = start
             .clone()
             .add(vector.clone().normalize().multiplyScalar(length));
         return [start, end];
     };
-    /**
-     * Gets the last available vertex from all lines in one leader branch.
-     *
-     * @param leader Leader branch to inspect.
-     * @returns The last vertex, or `undefined` when no vertices exist.
-     */
-    AcDbMLeader.prototype.getLastLeaderLineVertex = function (leader) {
-        for (var i = leader.leaderLines.length - 1; i >= 0; i--) {
-            var line = leader.leaderLines[i];
-            if (line.vertices.length > 0) {
-                return line.vertices[line.vertices.length - 1];
-            }
-        }
-        return undefined;
-    };
     /**
      * Builds arrowhead polyline points from leader-line points.
      *
@@ -1899,16 +1970,107 @@ var AcDbMLeader = /** @class */ (function (_super) {
     };
     /**
      * Draws one leader line and applies arrow style from MLEADER/MLEADERSTYLE.
+     *
+     * @param renderer Graphics renderer used to create primitives.
+     * @param points Leader-line draw points.
+     * @returns One entity or an entity group representing the full leader line.
      */
     AcDbMLeader.prototype.drawLeaderLine = function (renderer, points) {
-        var entities = [renderer.lines(points)];
+        var entities = [];
+        var linePoints = this.getLeaderLinePointsForDraw(points);
+        if (linePoints.length >= 2) {
+            entities.push(renderer.lines(linePoints));
+        }
         var arrow = this.drawArrowhead(renderer, points);
         if (arrow)
             entities.push(arrow);
+        if (entities.length === 0)
+            return undefined;
         return entities.length === 1 ? entities[0] : renderer.group(entities);
     };
+    /**
+     * Resolves leader-line points used for stroke drawing after arrow overlap trim.
+     *
+     * @param points Original leader polyline points.
+     * @returns Trimmed points used to draw the leader stroke.
+     */
+    AcDbMLeader.prototype.getLeaderLinePointsForDraw = function (points) {
+        var trimDistance = this.getArrowheadLeaderLineTrimDistance();
+        if (trimDistance <= 0)
+            return points;
+        return this.trimPolylineStart(points, trimDistance);
+    };
+    /**
+     * Resolves how much of leader start should be trimmed to avoid arrow overlap.
+     *
+     * @returns Trim distance in drawing units.
+     */
+    AcDbMLeader.prototype.getArrowheadLeaderLineTrimDistance = function () {
+        var e_1, _a;
+        var _b;
+        if (!this.isArrowheadVisible())
+            return 0;
+        var blockTableRecord = this.getResolvedArrowheadBlockTableRecord();
+        if (!blockTableRecord)
+            return 0;
+        var size = this.getResolvedArrowheadSize();
+        if (size <= 0)
+            return 0;
+        var basePoint = (_b = blockTableRecord.origin) !== null && _b !== void 0 ? _b : AcGePoint3d.ORIGIN;
+        var maxX = basePoint.x;
+        try {
+            for (var _c = __values(blockTableRecord.newIterator()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var entity = _d.value;
+                var extents = entity.geometricExtents;
+                if (extents.isEmpty())
+                    continue;
+                if (extents.max.x > maxX)
+                    maxX = extents.max.x;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return Math.max(0, (maxX - basePoint.x) * size);
+    };
+    /**
+     * Trims the start of a polyline by a given distance.
+     *
+     * @param points Polyline points.
+     * @param trimDistance Distance to trim from the start.
+     * @returns Trimmed polyline points.
+     */
+    AcDbMLeader.prototype.trimPolylineStart = function (points, trimDistance) {
+        if (points.length < 2 || trimDistance <= 0)
+            return points;
+        var remaining = trimDistance;
+        for (var i = 0; i < points.length - 1; i++) {
+            var start = points[i];
+            var end = points[i + 1];
+            var segment = end.distanceTo(start);
+            if (segment <= 0)
+                continue;
+            if (remaining < segment) {
+                var direction = new AcGeVector3d().subVectors(end, start);
+                var newStart = start
+                    .clone()
+                    .add(direction.multiplyScalar(remaining / segment));
+                return __spreadArray([newStart], __read(points.slice(i + 1)), false);
+            }
+            remaining -= segment;
+        }
+        return [points[points.length - 1]];
+    };
     /**
      * Draws one arrowhead primitive from leader-line points.
+     *
+     * @param renderer Graphics renderer used to create primitives.
+     * @param points Leader-line points where the first point is treated as tip.
+     * @returns Arrowhead entity, or `undefined` when no arrowhead is drawable.
      */
     AcDbMLeader.prototype.drawArrowhead = function (renderer, points) {
         if (!this.isArrowheadVisible())
@@ -1934,6 +2096,10 @@ var AcDbMLeader = /** @class */ (function (_super) {
     };
     /**
      * Draws arrowhead by rendering entities from referenced arrow block record.
+     *
+     * @param renderer Graphics renderer used to create primitives.
+     * @param points Leader-line points where the first point is treated as tip.
+     * @returns Rendered block-based arrowhead entity, or `undefined`.
      */
     AcDbMLeader.prototype.drawArrowheadBlock = function (renderer, points) {
         var _a;
@@ -1959,6 +2125,9 @@ var AcDbMLeader = /** @class */ (function (_super) {
     };
     /**
      * Resolves tip point and direction for arrowhead placement.
+     *
+     * @param points Leader-line points where the first point is treated as tip.
+     * @returns Tip and normalized direction, or `undefined` when unavailable.
      */
     AcDbMLeader.prototype.getArrowheadFrame = function (points) {
         if (points.length < 2)
@@ -1987,6 +2156,8 @@ var AcDbMLeader = /** @class */ (function (_super) {
     };
     /**
      * Resolves arrowhead block record by Arrowhead ID handle.
+     *
+     * @returns Arrowhead block table record, or `undefined` when not found.
      */
     AcDbMLeader.prototype.getResolvedArrowheadBlockTableRecord = function () {
         var arrowId = this.getResolvedArrowheadId();
@@ -2007,6 +2178,8 @@ var AcDbMLeader = /** @class */ (function (_super) {
     };
     /**
      * Resolves effective text height by style and override-flag rules.
+     *
+     * @returns Effective text height used for rendering.
      */
     AcDbMLeader.prototype.getResolvedTextHeight = function () {
         var _a;
@@ -2019,6 +2192,8 @@ var AcDbMLeader = /** @class */ (function (_super) {
     };
     /**
      * Resolves renderable MText content using entity content first, with style fallback.
+     *
+     * @returns Renderable text payload, or `undefined` when unavailable.
      */
     AcDbMLeader.prototype.getRenderableMTextContent = function () {
         var _a, _b, _c;
@@ -2040,6 +2215,8 @@ var AcDbMLeader = /** @class */ (function (_super) {
     /**
      * Computes render width for current MText content.
      *
+     * @param text Source MText content string.
+     * @param textHeight Effective text height used for fallback estimation.
      * @returns Explicit width or an estimated width based on plain text length.
      */
     AcDbMLeader.prototype.getMTextRenderWidth = function (text, textHeight) {
@@ -2059,6 +2236,7 @@ var AcDbMLeader = /** @class */ (function (_super) {
      *
      * @param vector Vector to mutate.
      * @param matrix Transformation matrix.
+     * @returns `void`.
      */
     AcDbMLeader.prototype.transformVector = function (vector, matrix) {
         var origin = new AcGePoint3d();
@@ -2069,6 +2247,8 @@ var AcDbMLeader = /** @class */ (function (_super) {
     };
     /**
      * Resolves the referenced MLeader style object.
+     *
+     * @returns Resolved style object or `undefined` when not available.
      */
     AcDbMLeader.prototype.getMLeaderStyle = function () {
         var dictionary = this.database.objects.mleaderStyle;
@@ -2078,10 +2258,72 @@ var AcDbMLeader = /** @class */ (function (_super) {
             if (style)
                 return style;
         }
-        return dictionary.newIterator().toArray()[0];
+        return this.getDefaultMLeaderStyle();
+    };
+    /**
+     * Resolves the default MLEADER style from CMLEADERSTYLE, with first-entry fallback.
+     *
+     * @returns Default style object or `undefined` when style dictionary is empty.
+     */
+    AcDbMLeader.prototype.getDefaultMLeaderStyle = function () {
+        var bySysVar = this.resolveMLeaderStyleByName(this.getDefaultMLeaderStyleName());
+        if (bySysVar)
+            return bySysVar;
+        return this.database.objects.mleaderStyle.newIterator().toArray()[0];
+    };
+    /**
+     * Resolves one MLEADER style by style name (dictionary key) or object ID.
+     *
+     * @param styleName Style name or object id candidate.
+     * @returns Matching style object, or `undefined` when not found.
+     */
+    AcDbMLeader.prototype.resolveMLeaderStyleByName = function (styleName) {
+        var e_2, _a;
+        var rawName = styleName === null || styleName === void 0 ? void 0 : styleName.trim();
+        if (!rawName)
+            return undefined;
+        var dictionary = this.database.objects.mleaderStyle;
+        var directByName = dictionary.getAt(rawName);
+        if (directByName)
+            return directByName;
+        var directById = dictionary.getIdAt(rawName);
+        if (directById)
+            return directById;
+        var normalizedStyleName = rawName.toUpperCase();
+        try {
+            for (var _b = __values(dictionary.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), name_1 = _d[0], style = _d[1];
+                if (name_1.toUpperCase() === normalizedStyleName) {
+                    return style;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return undefined;
+    };
+    /**
+     * Resolves current CMLEADERSTYLE value with a stable default fallback.
+     *
+     * @returns Preferred default style name.
+     */
+    AcDbMLeader.prototype.getDefaultMLeaderStyleName = function () {
+        try {
+            return this.database.cmleaderstyle || DEFAULT_MLEADER_STYLE;
+        }
+        catch (_a) {
+            return DEFAULT_MLEADER_STYLE;
+        }
     };
     /**
      * Resolves text style name considering entity values, ids and style fallback.
+     *
+     * @returns Resolved text style name, or `undefined` when unresolved.
      */
     AcDbMLeader.prototype.getResolvedTextStyleName = function () {
         var _a, _b;
@@ -2114,6 +2356,195 @@ var AcDbMLeader = /** @class */ (function (_super) {
         }
         return style.textStyle;
     };
+    /**
+     * Resolves effective leader-line color by override-flag and style rules.
+     *
+     * @returns Effective leader-line color.
+     */
+    AcDbMLeader.prototype.getResolvedLeaderLineColor = function () {
+        var _a;
+        return this.getResolvedComponentColor(this.leaderLineColor, (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.leaderLineColor, MLEADER_OVERRIDE_LEADER_LINE_COLOR);
+    };
+    /**
+     * Resolves effective leader-line geometry type.
+     *
+     * @returns Effective leader-line type.
+     */
+    AcDbMLeader.prototype.getResolvedLeaderLineType = function () {
+        var _a;
+        var styleLineType = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.leaderLineType;
+        return this.getResolvedStyleDrivenValue(this.leaderLineType, styleLineType, MLEADER_OVERRIDE_LEADER_LINE_TYPE);
+    };
+    /**
+     * Resolves effective leader-line linetype id/handle.
+     *
+     * @returns Effective linetype id, or `undefined` when not available.
+     */
+    AcDbMLeader.prototype.getResolvedLeaderLineTypeId = function () {
+        var _a;
+        return this.getResolvedStyleDrivenValue(this.leaderLineTypeId, (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.leaderLineTypeId, MLEADER_OVERRIDE_LEADER_LINE_TYPE_ID);
+    };
+    /**
+     * Resolves renderer linetype style for leader lines.
+     *
+     * @returns User-specified renderer linetype style, or `undefined`.
+     */
+    AcDbMLeader.prototype.getResolvedLeaderLineStyle = function () {
+        var lineTypeId = this.getResolvedLeaderLineTypeId();
+        if (!lineTypeId)
+            return undefined;
+        var lineTypeRecord = this.database.tables.linetypeTable.getIdAt(lineTypeId);
+        if (!lineTypeRecord)
+            return undefined;
+        return __assign({ type: 'UserSpecified' }, lineTypeRecord.linetype);
+    };
+    /**
+     * Resolves effective leader-line weight by override-flag and style rules.
+     *
+     * @returns Effective line weight, or `undefined`.
+     */
+    AcDbMLeader.prototype.getResolvedLeaderLineWeight = function () {
+        var _a;
+        var styleLineWeight = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.leaderLineWeight;
+        var lineWeight = this.getResolvedStyleDrivenValue(this.leaderLineWeight, styleLineWeight, MLEADER_OVERRIDE_LEADER_LINE_WEIGHT);
+        if (lineWeight == null)
+            return undefined;
+        return lineWeight;
+    };
+    /**
+     * Resolves whether dogleg drawing is effectively enabled.
+     *
+     * @returns Effective dogleg-enabled state.
+     */
+    AcDbMLeader.prototype.getResolvedDoglegEnabled = function () {
+        var _a;
+        var styleEnabled = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.doglegEnabled;
+        return this.getResolvedStyleDrivenValue(this.doglegEnabled, styleEnabled, MLEADER_OVERRIDE_DOGLEG_ENABLED);
+    };
+    /**
+     * Resolves effective dogleg length by override-flag and style rules.
+     *
+     * @returns Effective dogleg length.
+     */
+    AcDbMLeader.prototype.getResolvedDoglegLength = function () {
+        var _a;
+        var styleLength = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.doglegLength;
+        return this.getResolvedStyleDrivenValue(this.doglegLength, styleLength, MLEADER_OVERRIDE_DOGLEG_LENGTH);
+    };
+    /**
+     * Resolves effective text color by override-flag and style rules.
+     *
+     * @returns Effective text color.
+     */
+    AcDbMLeader.prototype.getResolvedTextColor = function () {
+        var _a;
+        return this.getResolvedComponentColor(this.textColor, (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.textColor, MLEADER_OVERRIDE_TEXT_COLOR);
+    };
+    /**
+     * Resolves effective component color from entity raw value and style fallback.
+     *
+     * @param rawEntityColor Raw DXF color value stored on the entity.
+     * @param styleColor Style-level fallback color.
+     * @param overrideFlagMask Property-override flag mask for this component.
+     * @returns Effective color used for rendering and trait application.
+     */
+    AcDbMLeader.prototype.getResolvedComponentColor = function (rawEntityColor, styleColor, overrideFlagMask) {
+        var entityColor = rawEntityColor != null
+            ? decodeMLeaderStyleRawColor(rawEntityColor)
+            : undefined;
+        if (!entityColor)
+            return styleColor;
+        var overrideEnabled = this.isPropertyOverrideEnabled(overrideFlagMask);
+        if (overrideEnabled === true)
+            return entityColor;
+        if (overrideEnabled === false)
+            return styleColor !== null && styleColor !== void 0 ? styleColor : entityColor;
+        // Some DXF producers always write entity color fields as ByBlock/ByLayer even
+        // when no override flag is enabled. Prefer style color in that ambiguous case.
+        if (!entityColor.isByBlock && !entityColor.isByLayer) {
+            return entityColor;
+        }
+        return styleColor !== null && styleColor !== void 0 ? styleColor : entityColor;
+    };
+    /**
+     * Resolves effective value using override-flag and style fallback rules.
+     *
+     * @typeParam T Value type.
+     * @param entityValue Value stored on the entity.
+     * @param styleValue Value provided by style.
+     * @param overrideFlagMask Property-override flag mask for this component.
+     * @returns Effective resolved value.
+     */
+    AcDbMLeader.prototype.getResolvedStyleDrivenValue = function (entityValue, styleValue, overrideFlagMask) {
+        var overrideEnabled = this.isPropertyOverrideEnabled(overrideFlagMask);
+        if (overrideEnabled === true)
+            return entityValue !== null && entityValue !== void 0 ? entityValue : styleValue;
+        if (overrideEnabled === false)
+            return styleValue !== null && styleValue !== void 0 ? styleValue : entityValue;
+        return styleValue !== null && styleValue !== void 0 ? styleValue : entityValue;
+    };
+    /**
+     * Checks whether a specific property-override bit is enabled.
+     *
+     * @param flagMask Bit mask for the property being queried.
+     * @returns `true` if enabled, `false` if disabled, or `undefined` when flag is absent.
+     */
+    AcDbMLeader.prototype.isPropertyOverrideEnabled = function (flagMask) {
+        if (this.propertyOverrideFlag == null)
+            return undefined;
+        return (this.propertyOverrideFlag & flagMask) !== 0;
+    };
+    /**
+     * Applies color traits while preserving original values for reset.
+     *
+     * @param traits Renderer traits object to mutate.
+     * @param color Effective component color to apply.
+     * @param originalColor Original trait color value.
+     * @param originalRgbColor Original trait RGB value.
+     * @returns `void`.
+     */
+    AcDbMLeader.prototype.applyColorTraits = function (traits, color, originalColor, originalRgbColor) {
+        traits.color = originalColor;
+        traits.rgbColor = originalRgbColor;
+        if (!color)
+            return;
+        traits.color = color;
+        traits.rgbColor = this.resolveColorToRgb(color);
+    };
+    /**
+     * Applies line style traits when resolved values are available.
+     *
+     * @param traits Renderer traits object to mutate.
+     * @param lineType Resolved linetype style.
+     * @param lineWeight Resolved line weight.
+     * @returns `void`.
+     */
+    AcDbMLeader.prototype.applyLineTraits = function (traits, lineType, lineWeight) {
+        if (lineType) {
+            traits.lineType = lineType;
+        }
+        if (lineWeight != null) {
+            traits.lineWeight = lineWeight;
+        }
+    };
+    /**
+     * Converts an `AcCmColor` to resolved RGB for rendering.
+     *
+     * @param color Source color definition.
+     * @returns Resolved RGB integer color.
+     */
+    AcDbMLeader.prototype.resolveColorToRgb = function (color) {
+        var _a;
+        if (color.isByLayer) {
+            var layerColor = this.getLayerColor();
+            if ((layerColor === null || layerColor === void 0 ? void 0 : layerColor.RGB) != null)
+                return layerColor.RGB;
+            return this.rgbColor;
+        }
+        if (color.isByBlock)
+            return this.rgbColor;
+        return (_a = color.RGB) !== null && _a !== void 0 ? _a : this.rgbColor;
+    };
     /** The entity type name. */
     AcDbMLeader.typeName = 'MLeader';
     return AcDbMLeader;