@mlightcad/data-model 1.10.1 → 1.10.3

package/lib/entity/AcDbFcf.js

@@ -0,0 +1,718 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { AcGeBox3d, AcGePoint3d, AcGeVector3d } from '@mlightcad/geometry-engine';
+import { AcGiMTextAttachmentPoint, AcGiMTextFlowDirection } from '@mlightcad/graphic-interface';
+import { AcDbDimStyleTableRecord } from '../database';
+import { AcDbOsnapMode } from '../misc/AcDbOsnapMode';
+import { AcDbEntity } from './AcDbEntity';
+import { acdbMovePrimaryGripPointAt } from './AcDbGripHelpers';
+import { acdbEstimatePlainTextWidth, acdbStripMTextControlCodes } from './AcDbTextExtentsHelpers';
+var TOLERANCE_SLOT_COUNT = 6;
+/**
+ * Represents a feature control frame (FCF) entity in AutoCAD.
+ *
+ * Feature control frames are used for geometric dimensioning and tolerancing
+ * (GD&T). They are created by the TOLERANCE command and controlled by dimension
+ * styles, mirroring {@link https://help.autodesk.com/view/OARX/2023/ENU/?guid=OARX-RefGuide-AcDbFcf AcDbFcf}
+ * in ObjectARX.
+ *
+ * @example
+ * ```typescript
+ * const fcf = new AcDbFcf();
+ * fcf.location = new AcGePoint3d(10, 20, 0);
+ * fcf.text = '{\\Fgdt.shx|b0|i0|c134|p6;j}|0.05|A|';
+ * fcf.dimensionStyle = 'Standard';
+ * ```
+ */
+var AcDbFcf = /** @class */ (function (_super) {
+    __extends(AcDbFcf, _super);
+    /**
+     * Creates a new feature control frame entity at the origin with default orientation.
+     */
+    function AcDbFcf() {
+        var _this = _super.call(this) || this;
+        _this._location = new AcGePoint3d();
+        _this._text = '';
+        _this._dimensionStyle = '';
+        _this._normal = new AcGeVector3d(0, 0, 1);
+        _this._direction = new AcGeVector3d(1, 0, 0);
+        return _this;
+    }
+    Object.defineProperty(AcDbFcf.prototype, "dxfTypeName", {
+        get: function () {
+            return 'TOLERANCE';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbFcf.prototype, "location", {
+        /**
+         * Gets the insertion point of this feature control frame.
+         *
+         * Mirrors `AcDbFcf::location()` in ObjectARX.
+         */
+        get: function () {
+            return this._location;
+        },
+        /**
+         * Sets the insertion point of this feature control frame.
+         *
+         * Mirrors `AcDbFcf::setLocation()` in ObjectARX.
+         */
+        set: function (value) {
+            var _a;
+            this._location.set(value.x, value.y, (_a = value.z) !== null && _a !== void 0 ? _a : 0);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbFcf.prototype, "text", {
+        /**
+         * Gets the encoded tolerance text string.
+         *
+         * Mirrors `AcDbFcf::text()` in ObjectARX.
+         */
+        get: function () {
+            return this._text;
+        },
+        /**
+         * Sets the encoded tolerance text string.
+         *
+         * Mirrors `AcDbFcf::setText()` in ObjectARX.
+         */
+        set: function (value) {
+            this._text = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbFcf.prototype, "dimensionStyle", {
+        /**
+         * Gets the dimension style name applied to this feature control frame.
+         */
+        get: function () {
+            return this._dimensionStyle;
+        },
+        /**
+         * Sets the dimension style name applied to this feature control frame.
+         */
+        set: function (value) {
+            this._dimensionStyle = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbFcf.prototype, "normal", {
+        /**
+         * Gets the plane normal vector in WCS coordinates.
+         *
+         * Mirrors `AcDbFcf::normal()` in ObjectARX.
+         */
+        get: function () {
+            return this._normal;
+        },
+        /**
+         * Sets the plane normal vector in WCS coordinates.
+         */
+        set: function (value) {
+            var _a;
+            this._normal.set(value.x, value.y, (_a = value.z) !== null && _a !== void 0 ? _a : 0);
+            if (this._normal.lengthSq() > 0) {
+                this._normal.normalize();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbFcf.prototype, "direction", {
+        /**
+         * Gets the X-axis direction vector in WCS coordinates.
+         *
+         * Mirrors `AcDbFcf::direction()` in ObjectARX.
+         */
+        get: function () {
+            return this._direction;
+        },
+        /**
+         * Sets the X-axis direction vector in WCS coordinates.
+         */
+        set: function (value) {
+            var _a;
+            this._direction.set(value.x, value.y, (_a = value.z) !== null && _a !== void 0 ? _a : 0);
+            if (this._direction.lengthSq() > 0) {
+                this._direction.normalize();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Sets the plane normal and X-axis direction for this feature control frame.
+     *
+     * Mirrors `AcDbFcf::setOrientation()` in ObjectARX.
+     */
+    AcDbFcf.prototype.setOrientation = function (normal, direction) {
+        this.normal = normal;
+        this.direction = direction;
+        return this;
+    };
+    /**
+     * Returns the consecutive distinct corner points of the feature control frame.
+     *
+     * Mirrors `AcDbFcf::getBoundingPoints()` in ObjectARX.
+     */
+    AcDbFcf.prototype.getBoundingPoints = function () {
+        return this.getBoundingPolyline().slice(0, 4);
+    };
+    /**
+     * Returns the closed bounding polyline of the feature control frame.
+     *
+     * Mirrors `AcDbFcf::getBoundingPolyline()` in ObjectARX.
+     */
+    AcDbFcf.prototype.getBoundingPolyline = function () {
+        var _this = this;
+        var _a = this.resolveFrameLayout(), width = _a.width, rowHeight = _a.rowHeight, rowCount = _a.rowCount;
+        var frameTop = rowHeight / 2;
+        var frameBottom = frameTop - rowHeight * rowCount;
+        var corners = [
+            new AcGePoint3d(0, frameTop, 0),
+            new AcGePoint3d(width, frameTop, 0),
+            new AcGePoint3d(width, frameBottom, 0),
+            new AcGePoint3d(0, frameBottom, 0),
+            new AcGePoint3d(0, frameTop, 0)
+        ];
+        return corners.map(function (corner) { return _this.toFrameWcs(corner.x, corner.y); });
+    };
+    Object.defineProperty(AcDbFcf.prototype, "geometricExtents", {
+        get: function () {
+            var e_1, _a;
+            var box = new AcGeBox3d();
+            try {
+                for (var _b = __values(this.getBoundingPoints()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var point = _c.value;
+                    box.expandByPoint(point);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (box.isEmpty()) {
+                box.expandByPoint(this._location);
+            }
+            return box;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcDbFcf.prototype.subGetGripPoints = function () {
+        return [this._location];
+    };
+    /** @inheritdoc */
+    AcDbFcf.prototype.subMoveGripPointsAt = function (indices, offset) {
+        acdbMovePrimaryGripPointAt(indices, offset, this._location);
+        return this;
+    };
+    AcDbFcf.prototype.subGetOsnapPoints = function (osnapMode, _pickPoint, _lastPoint, snapPoints) {
+        if (osnapMode === AcDbOsnapMode.Insertion) {
+            snapPoints.push(this._location);
+        }
+    };
+    AcDbFcf.prototype.transformBy = function (matrix) {
+        var basis = this.resolveLocalBasis();
+        var origin = this._location.clone();
+        var xAxisPoint = origin.clone().add(basis.xAxis);
+        var yAxisPoint = origin.clone().add(basis.yAxis);
+        origin.applyMatrix4(matrix);
+        xAxisPoint.applyMatrix4(matrix);
+        yAxisPoint.applyMatrix4(matrix);
+        var xAxis = new AcGeVector3d(xAxisPoint).sub(origin);
+        var yAxis = new AcGeVector3d(yAxisPoint).sub(origin);
+        var normal = new AcGeVector3d().crossVectors(xAxis, yAxis);
+        if (normal.lengthSq() === 0) {
+            normal = this._normal.clone().transformDirection(matrix);
+        }
+        else {
+            normal.normalize();
+        }
+        var direction = xAxis.clone();
+        if (direction.lengthSq() === 0) {
+            direction = this._direction.clone().transformDirection(matrix);
+        }
+        else {
+            direction.normalize();
+        }
+        this._location.copy(origin);
+        this._normal.copy(normal);
+        this._direction.copy(direction);
+        return this;
+    };
+    Object.defineProperty(AcDbFcf.prototype, "properties", {
+        get: function () {
+            var _this = this;
+            return {
+                type: this.type,
+                groups: [
+                    this.getGeneralProperties(),
+                    {
+                        groupName: 'tolerance',
+                        properties: [
+                            {
+                                name: 'text',
+                                type: 'string',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.text; },
+                                    set: function (v) {
+                                        _this.text = v;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'dimensionStyle',
+                                type: 'string',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.dimensionStyle; },
+                                    set: function (v) {
+                                        _this.dimensionStyle = v;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'textHeight',
+                                type: 'float',
+                                editable: false,
+                                accessor: {
+                                    get: function () { return _this.textHeight; }
+                                }
+                            }
+                        ]
+                    },
+                    {
+                        groupName: 'geometry',
+                        properties: [
+                            {
+                                name: 'locationX',
+                                type: 'float',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.location.x; },
+                                    set: function (v) {
+                                        _this.location.x = v;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'locationY',
+                                type: 'float',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.location.y; },
+                                    set: function (v) {
+                                        _this.location.y = v;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'locationZ',
+                                type: 'float',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.location.z; },
+                                    set: function (v) {
+                                        _this.location.z = v;
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                ]
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcDbFcf.prototype.subWorldDraw = function (renderer, delay) {
+        var frameSegments = this.collectFrameLineSegments();
+        var frameEntities = frameSegments.map(function (_a) {
+            var _b = __read(_a, 2), start = _b[0], end = _b[1];
+            return renderer.lines([start, end]);
+        });
+        var textEntity = this.drawToleranceText(renderer, delay);
+        if (frameEntities.length > 0 && textEntity) {
+            return renderer.group(__spreadArray(__spreadArray([], __read(frameEntities), false), [textEntity], false));
+        }
+        if (frameEntities.length === 1) {
+            return frameEntities[0];
+        }
+        if (frameEntities.length > 1) {
+            return renderer.group(frameEntities);
+        }
+        return textEntity;
+    };
+    AcDbFcf.prototype.dxfOutFields = function (filer) {
+        _super.prototype.dxfOutFields.call(this, filer);
+        filer.writeSubclassMarker('AcDbFcf');
+        if (this._dimensionStyle) {
+            filer.writeString(3, this._dimensionStyle);
+        }
+        filer.writePoint3d(10, this._location);
+        filer.writeString(1, this._text);
+        if (!this._normal.equals(AcGeVector3d.Z_AXIS)) {
+            filer.writeVector3d(210, this._normal);
+        }
+        if (!this._direction.equals(AcGeVector3d.X_AXIS)) {
+            filer.writeVector3d(11, this._direction);
+        }
+        return this;
+    };
+    Object.defineProperty(AcDbFcf.prototype, "textHeight", {
+        /**
+         * Gets the rendered text height derived from the associated dimension style.
+         */
+        get: function () {
+            var _a, _b;
+            var dimStyle = this.resolveDimensionStyle();
+            var dimtxt = (_a = dimStyle === null || dimStyle === void 0 ? void 0 : dimStyle.dimtxt) !== null && _a !== void 0 ? _a : AcDbDimStyleTableRecord.DEFAULT_DIM_VALUES.dimtxt;
+            var dimscale = (_b = dimStyle === null || dimStyle === void 0 ? void 0 : dimStyle.dimscale) !== null && _b !== void 0 ? _b : AcDbDimStyleTableRecord.DEFAULT_DIM_VALUES.dimscale;
+            return dimtxt * dimscale;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcDbFcf.prototype.drawToleranceText = function (renderer, delay) {
+        var _a;
+        var rows = this.parseToleranceFrame(this._text);
+        if (rows.length === 0) {
+            return undefined;
+        }
+        var layout = this.resolveFrameLayout(rows);
+        var textStyle = this.getTextStyle();
+        var entities = [];
+        for (var rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+            var row = rows[rowIndex];
+            var cellOffset = layout.cellPadding;
+            var rowCenterY = -layout.rowHeight * rowIndex;
+            for (var columnIndex = 0; columnIndex < row.cells.length; columnIndex++) {
+                var cellText = row.cells[columnIndex];
+                var cellWidth = (_a = layout.columnWidths[columnIndex]) !== null && _a !== void 0 ? _a : this.textHeight;
+                if (cellText.trim()) {
+                    var position = this.toFrameWcs(cellOffset + cellWidth / 2, rowCenterY);
+                    var mtextData = {
+                        text: cellText,
+                        height: this.textHeight,
+                        width: Infinity,
+                        position: position,
+                        directionVector: this._direction,
+                        attachmentPoint: AcGiMTextAttachmentPoint.MiddleCenter,
+                        drawingDirection: AcGiMTextFlowDirection.LEFT_TO_RIGHT
+                    };
+                    entities.push(renderer.mtext(mtextData, textStyle, delay));
+                }
+                cellOffset += cellWidth + layout.columnGap;
+            }
+        }
+        if (entities.length === 0) {
+            return undefined;
+        }
+        if (entities.length === 1) {
+            return entities[0];
+        }
+        return renderer.group(entities);
+    };
+    AcDbFcf.prototype.collectFrameLineSegments = function () {
+        var e_2, _a;
+        var rows = this.parseToleranceFrame(this._text);
+        var layout = this.resolveFrameLayout(rows);
+        var width = layout.width, rowHeight = layout.rowHeight, rowCount = layout.rowCount, columnDivisions = layout.columnDivisions;
+        if (width <= 0 || rowHeight <= 0 || rowCount <= 0) {
+            return [];
+        }
+        var frameTop = rowHeight / 2;
+        var frameBottom = frameTop - rowHeight * rowCount;
+        var segments = [];
+        var pushSegment = function (start, end) {
+            segments.push([start, end]);
+        };
+        pushSegment(this.toFrameWcs(0, frameTop), this.toFrameWcs(width, frameTop));
+        pushSegment(this.toFrameWcs(width, frameTop), this.toFrameWcs(width, frameBottom));
+        pushSegment(this.toFrameWcs(width, frameBottom), this.toFrameWcs(0, frameBottom));
+        pushSegment(this.toFrameWcs(0, frameBottom), this.toFrameWcs(0, frameTop));
+        try {
+            for (var columnDivisions_1 = __values(columnDivisions), columnDivisions_1_1 = columnDivisions_1.next(); !columnDivisions_1_1.done; columnDivisions_1_1 = columnDivisions_1.next()) {
+                var division = columnDivisions_1_1.value;
+                pushSegment(this.toFrameWcs(division, frameTop), this.toFrameWcs(division, frameBottom));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (columnDivisions_1_1 && !columnDivisions_1_1.done && (_a = columnDivisions_1.return)) _a.call(columnDivisions_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        for (var rowIndex = 1; rowIndex < rows.length; rowIndex++) {
+            var y = frameTop - rowHeight * rowIndex;
+            pushSegment(this.toFrameWcs(0, y), this.toFrameWcs(width, y));
+        }
+        return segments;
+    };
+    AcDbFcf.prototype.toFrameWcs = function (localX, localY) {
+        var basis = this.resolveLocalBasis();
+        return this._location
+            .clone()
+            .addScaledVector(basis.xAxis, localX)
+            .addScaledVector(basis.yAxis, localY);
+    };
+    AcDbFcf.prototype.resolveFrameLayout = function (rows) {
+        var e_3, _a;
+        var _b, _c;
+        var frameRows = rows !== null && rows !== void 0 ? rows : this.parseToleranceFrame(this._text);
+        var textHeight = this.textHeight;
+        var rowHeight = textHeight * 2;
+        var cellPadding = textHeight / 2;
+        var columnGap = textHeight;
+        if (textHeight <= 0 || frameRows.length === 0) {
+            return {
+                width: 0,
+                totalHeight: 0,
+                rowHeight: 0,
+                columnWidths: [],
+                columnDivisions: [],
+                rowCount: 0,
+                cellPadding: 0,
+                columnGap: 0
+            };
+        }
+        var columnCount = Math.max.apply(Math, __spreadArray(__spreadArray([], __read(frameRows.map(function (row) { return row.cells.length; })), false), [0], false));
+        var columnWidths = [];
+        for (var columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            var maxWidth = textHeight;
+            try {
+                for (var frameRows_1 = (e_3 = void 0, __values(frameRows)), frameRows_1_1 = frameRows_1.next(); !frameRows_1_1.done; frameRows_1_1 = frameRows_1.next()) {
+                    var row = frameRows_1_1.value;
+                    var cell = (_b = row.cells[columnIndex]) !== null && _b !== void 0 ? _b : '';
+                    if (!cell.trim()) {
+                        continue;
+                    }
+                    var plainText = acdbStripMTextControlCodes(cell).trim();
+                    var estimatedWidth = acdbEstimatePlainTextWidth(plainText, textHeight);
+                    maxWidth = Math.max(maxWidth, estimatedWidth);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (frameRows_1_1 && !frameRows_1_1.done && (_a = frameRows_1.return)) _a.call(frameRows_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            columnWidths.push(maxWidth);
+        }
+        var columnDivisions = [0];
+        var cursorX = cellPadding;
+        for (var columnIndex = 0; columnIndex < columnWidths.length; columnIndex++) {
+            cursorX += columnWidths[columnIndex];
+            cursorX += columnGap;
+            columnDivisions.push(cursorX - cellPadding);
+        }
+        var width = (_c = columnDivisions[columnDivisions.length - 1]) !== null && _c !== void 0 ? _c : 0;
+        return {
+            width: width,
+            totalHeight: rowHeight * frameRows.length,
+            rowHeight: rowHeight,
+            columnWidths: columnWidths,
+            columnDivisions: columnDivisions,
+            rowCount: frameRows.length,
+            cellPadding: cellPadding,
+            columnGap: columnGap
+        };
+    };
+    AcDbFcf.prototype.parseToleranceFrame = function (text) {
+        var _this = this;
+        if (!text) {
+            return [];
+        }
+        var rowTexts = this.splitToleranceRows(text);
+        if (rowTexts.length === 0) {
+            return [];
+        }
+        if (!text.includes('%%v')) {
+            return rowTexts.map(function (row) { return ({
+                cells: _this.parsePipeSeparatedCells(row)
+            }); });
+        }
+        var slotRows = rowTexts.map(function (row) {
+            var slots = _this.splitToleranceTokens(row, '%%v');
+            var padded = slots.slice(0, TOLERANCE_SLOT_COUNT);
+            while (padded.length < TOLERANCE_SLOT_COUNT) {
+                padded.push('');
+            }
+            return padded;
+        });
+        var columnIndices = [0, 1];
+        if (slotRows.some(function (slots) { var _a; return (_a = slots[2]) === null || _a === void 0 ? void 0 : _a.trim(); })) {
+            columnIndices.push(2);
+        }
+        var _loop_1 = function (slotIndex) {
+            if (slotRows.some(function (slots) { var _a; return (_a = slots[slotIndex]) === null || _a === void 0 ? void 0 : _a.trim(); })) {
+                columnIndices.push(slotIndex);
+            }
+        };
+        for (var slotIndex = 3; slotIndex < TOLERANCE_SLOT_COUNT; slotIndex++) {
+            _loop_1(slotIndex);
+        }
+        return slotRows.map(function (slots) { return ({
+            cells: columnIndices.map(function (index) { var _a; return (_a = slots[index]) !== null && _a !== void 0 ? _a : ''; })
+        }); });
+    };
+    AcDbFcf.prototype.splitToleranceRows = function (text) {
+        var normalized = text.replace(/\^J/g, '\n');
+        return normalized
+            .split(/\r\n|\r|\n|\\P/i)
+            .map(function (row) { return row.trim(); })
+            .filter(function (row) { return row.length > 0; });
+    };
+    AcDbFcf.prototype.splitToleranceTokens = function (text, delimiter) {
+        if (!text) {
+            return [];
+        }
+        var tokens = [];
+        var current = '';
+        var braceDepth = 0;
+        for (var index = 0; index < text.length;) {
+            if (text.startsWith(delimiter, index) && braceDepth === 0) {
+                tokens.push(current);
+                current = '';
+                index += delimiter.length;
+                continue;
+            }
+            var char = text[index];
+            if (char === '{') {
+                braceDepth++;
+            }
+            else if (char === '}') {
+                braceDepth = Math.max(0, braceDepth - 1);
+            }
+            current += char;
+            index++;
+        }
+        tokens.push(current);
+        return tokens;
+    };
+    AcDbFcf.prototype.parsePipeSeparatedCells = function (text) {
+        if (!text) {
+            return [];
+        }
+        var cells = this.splitToleranceTokens(text, '|');
+        return cells.filter(function (cell) { return cell.length > 0; });
+    };
+    AcDbFcf.prototype.resolveLocalBasis = function () {
+        var zAxis = this._normal.clone();
+        if (zAxis.lengthSq() === 0) {
+            zAxis.set(0, 0, 1);
+        }
+        else {
+            zAxis.normalize();
+        }
+        var xAxis = this._direction.clone();
+        if (xAxis.lengthSq() === 0) {
+            xAxis.set(1, 0, 0);
+        }
+        else {
+            xAxis.normalize();
+        }
+        var yAxis = new AcGeVector3d().crossVectors(zAxis, xAxis);
+        if (yAxis.lengthSq() === 0) {
+            xAxis = AcGeVector3d.X_AXIS.clone();
+            yAxis = new AcGeVector3d().crossVectors(zAxis, xAxis);
+        }
+        yAxis.normalize();
+        xAxis = new AcGeVector3d().crossVectors(yAxis, zAxis).normalize();
+        return { xAxis: xAxis, yAxis: yAxis, zAxis: zAxis };
+    };
+    AcDbFcf.prototype.resolveDimensionStyle = function () {
+        var styleName = this._dimensionStyle.trim();
+        var database = this.tryGetDatabase();
+        if (!styleName || !database) {
+            return undefined;
+        }
+        return database.tables.dimStyleTable.getAt(styleName);
+    };
+    AcDbFcf.prototype.tryGetDatabase = function () {
+        try {
+            return this.database;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    };
+    AcDbFcf.prototype.getTextStyle = function () {
+        var _a, _b;
+        var dimStyle = this.resolveDimensionStyle();
+        var styleName = (_b = (_a = dimStyle === null || dimStyle === void 0 ? void 0 : dimStyle.dimtxsty) !== null && _a !== void 0 ? _a : AcDbDimStyleTableRecord.DEFAULT_DIM_VALUES.dimtxsty) !== null && _b !== void 0 ? _b : 'Standard';
+        var style = this.database.tables.textStyleTable.resolveAt(styleName);
+        if (!style) {
+            throw new Error('No valid text style found in text style table.');
+        }
+        return style.textStyle;
+    };
+    /** The entity type name */
+    AcDbFcf.typeName = 'Fcf';
+    return AcDbFcf;
+}(AcDbEntity));
+export { AcDbFcf };
+//# sourceMappingURL=AcDbFcf.js.map