@mlightcad/dxf-json-converter 1.9.0

package/lib/AcDbDxfConverter.js

@@ -0,0 +1,1062 @@
+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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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));
+};
+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 { AcCmColor, AcDbBatchProcessing, AcDbBlockTableRecord, AcDbDatabaseConverter, AcDbDimStyleTableRecord, AcDbLayerTableRecord, AcDbLinetypeTableRecord, AcDbSystemVariables, AcDbSysVarManager, AcDbTextStyleTableRecord, AcDbViewportTableRecord, ByLayer, createWorkerApi, DEFAULT_MLEADER_STYLE, DEFAULT_MLINE_STYLE, DEFAULT_TEXT_STYLE, VPORT_FALLBACK_CENTER_2D, VPORT_FALLBACK_LLC, VPORT_FALLBACK_URC, VPORT_FALLBACK_VIEW_DIR, VPORT_FALLBACK_VIEW_TARGET } from '@mlightcad/data-model';
+import { AcDbEntityConverter } from './AcDbEntitiyConverter';
+import { AcDbObjectConverter } from './AcDbObjectConverter';
+/**
+ * Default database converter for DXF files.
+ *
+ * This class extends AcDbDatabaseConverter to provide specialized functionality
+ * for converting DXF (Drawing Exchange Format) files into AcDbDatabase objects.
+ * It handles parsing DXF data, processing entities, blocks, tables, and other
+ * DXF-specific structures.
+ *
+ * @example
+ * ```typescript
+ * const converter = new AcDbDxfConverter();
+ * const database = await converter.convert(dxfData);
+ * ```
+ */
+var AcDbDxfConverter = /** @class */ (function (_super) {
+    __extends(AcDbDxfConverter, _super);
+    function AcDbDxfConverter(config) {
+        if (config === void 0) { config = {}; }
+        var _this = _super.call(this, config) || this;
+        if (!_this.config.parserWorkerUrl) {
+            _this.config.parserWorkerUrl = '/assets/dxf-parser-worker.js';
+        }
+        return _this;
+    }
+    /**
+     * Parses DXF data into a ParsedDxf object.
+     *
+     * @param data - The DXF data
+     * @returns Parsed DXF object containing all the parsed data
+     *
+     */
+    AcDbDxfConverter.prototype.parse = function (data, timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var effectiveConfig, resolvedTimeout, api, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        effectiveConfig = this.config;
+                        resolvedTimeout = this.getParserWorkerTimeout(data, timeout);
+                        if (!(effectiveConfig.useWorker && effectiveConfig.parserWorkerUrl)) return [3 /*break*/, 2];
+                        api = createWorkerApi({
+                            workerUrl: effectiveConfig.parserWorkerUrl,
+                            timeout: resolvedTimeout,
+                            // One concurrent worker needed for parser
+                            maxConcurrentWorkers: 1
+                        });
+                        return [4 /*yield*/, api.execute(data)
+                            // Release worker
+                        ];
+                    case 1:
+                        result = _a.sent();
+                        // Release worker
+                        api.destroy();
+                        if (result.success) {
+                            return [2 /*return*/, {
+                                    model: result.data,
+                                    data: {
+                                        unknownEntityCount: 0
+                                    }
+                                }];
+                        }
+                        else {
+                            throw new Error("Failed to parse drawing due to error: '".concat(result.error, "'"));
+                        }
+                        return [3 /*break*/, 3];
+                    case 2: throw new Error('dxf converter can run in web worker only!');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Gets all fonts used by entities in model space and paper space.
+     *
+     * This method analyzes the DXF data to extract all font names used by
+     * text entities, MText entities, and insert entities throughout the drawing.
+     *
+     * @param dxf - Input parsed DXF model
+     * @returns Array of font names used in the drawing
+     *
+     * @example
+     * ```typescript
+     * const fonts = converter.getFonts(parsedDxf);
+     * console.log('Used fonts:', fonts);
+     * ```
+     */
+    AcDbDxfConverter.prototype.getFonts = function (dxf) {
+        var _a;
+        // Build text style map. The key is text style name, and the value is font name list.
+        var styleMap = new Map();
+        var getFontName = function (fontFileName) {
+            if (fontFileName) {
+                var lastDotIndex = fontFileName.lastIndexOf('.');
+                if (lastDotIndex >= 0) {
+                    return fontFileName.substring(0, lastDotIndex).toLowerCase();
+                }
+                else {
+                    return fontFileName.toLowerCase();
+                }
+            }
+        };
+        (_a = dxf.tables.STYLE) === null || _a === void 0 ? void 0 : _a.entries.forEach(function (style) {
+            var fontNames = [];
+            if (style.font) {
+                var fontName = getFontName(style.font);
+                if (fontName)
+                    fontNames.push(fontName);
+            }
+            if (style.bigFont) {
+                var fontName = getFontName(style.bigFont);
+                if (fontName)
+                    fontNames.push(fontName);
+            }
+            if (style.extendedFont) {
+                var fontName = getFontName(style.extendedFont);
+                if (fontName)
+                    fontNames.push(fontName);
+            }
+            styleMap.set(style.name, fontNames);
+        });
+        var fonts = new Set();
+        this.getFontsInBlock(dxf.entities, dxf.blocks, styleMap, fonts);
+        return Array.from(fonts);
+    };
+    /**
+     * Iterates through entities in a block to get fonts used by text, MText, and insert entities.
+     *
+     * This is a helper method that recursively processes entities to extract font information
+     * from text-based entities and block references.
+     *
+     * @param entities - Array of DXF entities to process
+     * @param blockMap - Map of block definitions
+     * @param styleMap - Map of text styles to font names
+     * @param fonts - Set to collect font names
+     *
+     * @example
+     * ```typescript
+     * const fonts = new Set<string>();
+     * converter.getFontsInBlock(entities, blocks, styleMap, fonts);
+     * ```
+     */
+    AcDbDxfConverter.prototype.getFontsInBlock = function (entities, blockMap, styleMap, fonts) {
+        var _this = this;
+        var regex = /\\f(.*?)\|/g;
+        entities.forEach(function (entity) {
+            if (entity.type == 'MTEXT') {
+                var mtext = entity;
+                var text = mtext.text;
+                __spreadArray([], __read(text.matchAll(regex)), false).forEach(function (match) {
+                    fonts.add(match[1].toLowerCase());
+                });
+                var fontNames = styleMap.get(mtext.styleName);
+                fontNames === null || fontNames === void 0 ? void 0 : fontNames.forEach(function (name) { return fonts.add(name); });
+            }
+            else if (entity.type == 'TEXT') {
+                var text = entity;
+                var fontNames = styleMap.get(text.styleName);
+                fontNames === null || fontNames === void 0 ? void 0 : fontNames.forEach(function (name) { return fonts.add(name); });
+            }
+            else if (entity.type == 'MULTILEADER' || entity.type == 'MLEADER') {
+                var mleader = entity;
+                var text = typeof mleader.textContent === 'string' ? mleader.textContent : '';
+                __spreadArray([], __read(text.matchAll(regex)), false).forEach(function (match) {
+                    fonts.add(match[1].toLowerCase());
+                });
+                var styleName = typeof mleader.textStyleName === 'string'
+                    ? mleader.textStyleName
+                    : typeof mleader.styleName === 'string'
+                        ? mleader.styleName
+                        : undefined;
+                var fontNames = styleName ? styleMap.get(styleName) : undefined;
+                fontNames === null || fontNames === void 0 ? void 0 : fontNames.forEach(function (name) { return fonts.add(name); });
+            }
+            else if (entity.type == 'INSERT') {
+                var insert = entity;
+                var block = blockMap[insert.name];
+                if (block && block.entities)
+                    _this.getFontsInBlock(block.entities, blockMap, styleMap, fonts);
+            }
+        });
+    };
+    /**
+     * Processes entities in batches to maintain UI responsiveness.
+     *
+     * This method breaks up the entity processing work into smaller chunks that are
+     * executed asynchronously. This is often referred to as "batch processing" or
+     * "cooperative multitasking," where the time-consuming task is broken into
+     * smaller pieces and executed in small intervals to allow the UI to remain responsive.
+     *
+     * @param dxf - Parsed DXF data
+     * @param db - Target database to add entities to
+     * @param minimumChunkSize - Minimum number of entities to process in each chunk
+     * @param startPercentage - Object containing the starting percentage for progress tracking
+     * @param progress - Optional callback for progress updates
+     *
+     * @example
+     * ```typescript
+     * await converter.processEntities(dxf, database, 100, { value: 0 }, progressCallback);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processEntities = function (dxf, db, minimumChunkSize, startPercentage, progress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var converter, entities, entityCount, batchProcessor, attributeMap, i, entity, dbEntity, attributes, modelSpaceBlockTableRecord;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        converter = new AcDbEntityConverter();
+                        entities = dxf.entities;
+                        entityCount = entities.length;
+                        batchProcessor = new AcDbBatchProcessing(entityCount, 100 - startPercentage.value, minimumChunkSize);
+                        // Groups entities by their `type` property and flattens the result into a single array.
+                        if (this.config.convertByEntityType) {
+                            entities = this.groupAndFlattenByType(entities);
+                        }
+                        attributeMap = new Map();
+                        for (i = 0; i < entityCount; i++) {
+                            entity = entities[i];
+                            if (entity.type === 'ATTRIB') {
+                                dbEntity = converter.convert(entity);
+                                if (dbEntity && dbEntity.ownerId && dbEntity.ownerId !== '0') {
+                                    attributes = attributeMap.get(dbEntity === null || dbEntity === void 0 ? void 0 : dbEntity.ownerId);
+                                    if (attributes == null) {
+                                        attributes = [];
+                                        attributeMap.set(dbEntity.ownerId, attributes);
+                                    }
+                                    attributes.push(dbEntity);
+                                }
+                            }
+                        }
+                        modelSpaceBlockTableRecord = db.tables.blockTable.modelSpace;
+                        return [4 /*yield*/, batchProcessor.processChunk(function (start, end) { return __awaiter(_this, void 0, void 0, function () {
+                                var dbEntities, entityType, _loop_1, this_1, i, percentage;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            dbEntities = [];
+                                            entityType = start < end ? entities[start].type : '';
+                                            _loop_1 = function (i) {
+                                                var entity = entities[i];
+                                                if (entity.ownerBlockRecordSoftId &&
+                                                    entity.ownerBlockRecordSoftId !== modelSpaceBlockTableRecord.objectId) {
+                                                    return "continue";
+                                                }
+                                                if (entity.type !== 'ATTRIB') {
+                                                    var dbEntity_1 = converter.convert(entity);
+                                                    if (dbEntity_1) {
+                                                        if (this_1.config.convertByEntityType && entity.type !== entityType) {
+                                                            modelSpaceBlockTableRecord.appendEntity(dbEntities);
+                                                            dbEntities = [];
+                                                            entityType = entity.type;
+                                                        }
+                                                        if (entity.type === 'INSERT') {
+                                                            var attributes = attributeMap.get(dbEntity_1.objectId);
+                                                            if (attributes && attributes.length > 0) {
+                                                                attributes.forEach(function (attribute) {
+                                                                    ;
+                                                                    dbEntity_1.appendAttributes(attribute);
+                                                                });
+                                                            }
+                                                        }
+                                                        dbEntities.push(dbEntity_1);
+                                                    }
+                                                }
+                                            };
+                                            this_1 = this;
+                                            for (i = start; i < end; i++) {
+                                                _loop_1(i);
+                                            }
+                                            // Use batch append to improve performance
+                                            modelSpaceBlockTableRecord.appendEntity(dbEntities);
+                                            percentage = startPercentage.value +
+                                                (end / entityCount) * (100 - startPercentage.value);
+                                            if (percentage > 100)
+                                                percentage = 100;
+                                            if (!progress) return [3 /*break*/, 2];
+                                            return [4 /*yield*/, progress(percentage, 'ENTITY', 'IN-PROGRESS')];
+                                        case 1:
+                                            _a.sent();
+                                            _a.label = 2;
+                                        case 2: return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Processes entities within a specific block.
+     *
+     * This method handles the conversion and addition of entities to a specific
+     * block table record.
+     *
+     * @param entities - Array of DXF entities to process
+     * @param blockTableRecord - The block table record to use
+     * @param checkOwner - The flag whether to check the owner of entity is the passed
+     * blockTableRecord. If yes, convert it and append it to the block table record.
+     * Otherwise, ignore the entity.
+     *
+     * @example
+     * ```typescript
+     * await converter.processEntitiesInBlock(entities, blockRecord);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processEntitiesInBlock = function (entities_1, blockTableRecord_1) {
+        return __awaiter(this, arguments, void 0, function (entities, blockTableRecord, checkOwner) {
+            var converter, entityCount, dbEntities, btrId, attributes, i, entity, dbEntity;
+            if (checkOwner === void 0) { checkOwner = false; }
+            return __generator(this, function (_a) {
+                converter = new AcDbEntityConverter();
+                entityCount = entities.length;
+                dbEntities = [];
+                btrId = blockTableRecord.objectId;
+                attributes = [];
+                for (i = 0; i < entityCount; i++) {
+                    entity = entities[i];
+                    dbEntity = converter.convert(entity);
+                    if (dbEntity) {
+                        if (entity.type === 'ATTRIB') {
+                            attributes.push(dbEntity);
+                        }
+                        else if (!checkOwner || entity.ownerBlockRecordSoftId === btrId) {
+                            dbEntities.push(dbEntity);
+                        }
+                    }
+                }
+                // Use batch append to improve performance
+                blockTableRecord.appendEntity(dbEntities);
+                attributes.forEach(function (attribute) {
+                    var owner = blockTableRecord.getIdAt(attribute.ownerId);
+                    if (owner) {
+                        owner.appendAttributes(attribute);
+                    }
+                });
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Processes blocks defined in the DXF file.
+     *
+     * This method iterates through all blocks in the DXF data and creates
+     * corresponding AcDbBlockTableRecord objects in the database.
+     *
+     * @param model - Parsed DXF model containing block definitions
+     * @param db - Target database to add blocks to
+     *
+     * @example
+     * ```typescript
+     * converter.processBlocks(parsedDxf, database);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processBlocks = function (model, db) {
+        var e_1, _a;
+        var blocks = model.blocks;
+        try {
+            for (var _b = __values(Object.entries(blocks)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), name_1 = _d[0], block = _d[1];
+                var dbBlock = db.tables.blockTable.getAt(block.name);
+                if (!dbBlock) {
+                    dbBlock = new AcDbBlockTableRecord();
+                    if (block.handle != null) {
+                        dbBlock.objectId = String(block.handle);
+                    }
+                    // dbBlock.ownerId = block.ownerHandle
+                    dbBlock.name = name_1;
+                    dbBlock.origin.copy(block.position);
+                    db.tables.blockTable.add(dbBlock);
+                }
+                if (block.entities) {
+                    // Process entities in user-defined blocks
+                    this.processEntitiesInBlock(block.entities, dbBlock);
+                }
+                else {
+                    // Process paper space block definiton. Entities in model space are
+                    // handled in method processEntities
+                    if (dbBlock.isPaperSapce) {
+                        this.processEntitiesInBlock(model.entities, dbBlock, true);
+                    }
+                }
+            }
+        }
+        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; }
+        }
+    };
+    /**
+     * Processes header variables from the DXF file.
+     *
+     * This method extracts and sets various header variables such as color settings,
+     * angle base, angle direction, units, and point display settings.
+     *
+     * @param model - Parsed DXF model containing header information
+     * @param db - Target database to set header variables on
+     *
+     * @example
+     * ```typescript
+     * converter.processHeader(parsedDxf, database);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processHeader = function (model, db) {
+        var _a;
+        var header = model.header;
+        if (header['$ACADVER']) {
+            db.version = header['$ACADVER'];
+        }
+        // Color index 256 is 'ByLayer'
+        db.cecolor.colorIndex = header['$CECOLOR'] || 256;
+        db.angbase = header['$ANGBASE'] || 0;
+        db.angdir = header['$ANGDIR'] || 0;
+        if (header['$AUNITS'] != null)
+            db.aunits = header['$AUNITS'];
+        if (header['$AUPREC'] != null)
+            db.auprec = header['$AUPREC'];
+        if (header['$LUNITS'] != null)
+            db.lunits = header['$LUNITS'];
+        if (header['$LUPREC'] != null)
+            db.luprec = header['$LUPREC'];
+        if (header['$UNITMODE'] != null)
+            db.unitmode = header['$UNITMODE'];
+        if (header['$MEASUREMENT'] != null)
+            db.measurement = header['$MEASUREMENT'];
+        db.celtype = header['$CELTYPE'] || ByLayer;
+        AcDbSysVarManager.instance().setVar(AcDbSystemVariables.CETRANSPARENCY, header['$CETRANSPARENCY'] || 'ByLayer', db);
+        db.celtscale = header['$CELTSCALE'] || 1;
+        var cmlStyle = this.normalizeHeaderStringValue(header['$CMLSTYLE']) ||
+            this.normalizeHeaderStringValue(header['CMLSTYLE']) ||
+            DEFAULT_MLINE_STYLE;
+        db.cmlstyle = cmlStyle;
+        var cmlScale = (_a = header['$CMLSCALE']) !== null && _a !== void 0 ? _a : header['CMLSCALE'];
+        if (typeof cmlScale === 'number' && Number.isFinite(cmlScale)) {
+            db.cmlscale = cmlScale;
+        }
+        var cmleaderStyle = this.normalizeHeaderStringValue(header['$CMLEADERSTYLE']) ||
+            this.normalizeHeaderStringValue(header['CMLEADERSTYLE']) ||
+            DEFAULT_MLEADER_STYLE;
+        db.cmleaderstyle = cmleaderStyle;
+        // db.hpcolor = this.parseHpColor(
+        //   this.normalizeHeaderStringValue(header['$HPCOLOR']) ||
+        //     this.normalizeHeaderStringValue(header['HPCOLOR']),
+        //   db.cecolor
+        // )
+        // db.hpbackgroundcolor = this.parseHpBackgroundColor(
+        //   this.normalizeHeaderStringValue(header['$HPBACKGROUNDCOLOR']) ||
+        //     this.normalizeHeaderStringValue(header['HPBACKGROUNDCOLOR'])
+        // )
+        db.hplayer =
+            this.normalizeHeaderStringValue(header['$HPLAYER']) ||
+                this.normalizeHeaderStringValue(header['HPLAYER']) ||
+                '.';
+        // db.hptransparency = this.parseHpTransparency(
+        //   this.normalizeHeaderStringValue(header['$HPTRANSPARENCY']) ||
+        //     this.normalizeHeaderStringValue(header['HPTRANSPARENCY'])
+        // )
+        db.ltscale = header['$LTSCALE'] || 1;
+        if (header['$EXTMAX'])
+            db.extmax = header['$EXTMAX'];
+        if (header['$EXTMIN'])
+            db.extmin = header['$EXTMIN'];
+        if (header['$INSUNITS'] != null)
+            db.insunits = header['$INSUNITS'];
+        db.osmode = header['$OSMODE'] || 0;
+        db.orthomode = header['$ORTHOMODE'] || 0;
+        db.pdmode = header['$PDMODE'] || 0;
+        db.pdsize = header['$PDSIZE'] || 0.0;
+        db.textstyle = header['$TEXTSTYLE'] || DEFAULT_TEXT_STYLE;
+    };
+    /**
+     * Processes block table records from the DXF file.
+     *
+     * This method creates AcDbBlockTableRecord objects for each block record
+     * defined in the DXF tables section.
+     *
+     * @param dxf - Parsed DXF data
+     * @param db - Target database to add block table records to
+     *
+     * @example
+     * ```typescript
+     * converter.processBlockTables(parsedDxf, database);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processBlockTables = function (dxf, db) {
+        var _a;
+        var btrs = (_a = dxf.tables.BLOCK_RECORD) === null || _a === void 0 ? void 0 : _a.entries;
+        if (btrs && btrs.length > 0) {
+            db.tables.blockTable.removeAll();
+            btrs.forEach(function (btr) {
+                var dbBlock = new AcDbBlockTableRecord();
+                dbBlock.objectId = btr.handle;
+                dbBlock.name = btr.name;
+                dbBlock.layoutId = btr.layoutObjects;
+                dbBlock.blockInsertUnits = btr.insertionUnits;
+                dbBlock.explodability = btr.explodability;
+                dbBlock.blockScaling = btr.scalability;
+                if (btr.bmpPreview) {
+                    dbBlock.bmpPreview = btr.bmpPreview;
+                }
+                db.tables.blockTable.add(dbBlock);
+            });
+        }
+    };
+    /**
+     * Processes objects defined in the DXF file.
+     *
+     * This method handles the conversion of DXF objects such as layouts and
+     * image definitions into their corresponding AcDb objects.
+     *
+     * @param model - Parsed DXF model containing object definitions
+     * @param db - Target database to add objects to
+     *
+     * @example
+     * ```typescript
+     * converter.processObjects(parsedDxf, database);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processObjects = function (model, db) {
+        var objects = model.objects.byName;
+        var objectConverter = new AcDbObjectConverter();
+        if ('LAYOUT' in objects) {
+            var layoutDict_1 = db.objects.layout;
+            objects['LAYOUT'].forEach(function (layout) {
+                var dbLayout = objectConverter.convertLayout(layout, model);
+                layoutDict_1.setAt(dbLayout.layoutName, dbLayout);
+            });
+        }
+        if ('IMAGEDEF' in objects) {
+            var imageDefDict_1 = db.objects.imageDefinition;
+            objects['IMAGEDEF'].forEach(function (imageDef) {
+                var dbImageDef = objectConverter.convertImageDef(imageDef);
+                imageDefDict_1.setAt(dbImageDef.objectId, dbImageDef);
+            });
+        }
+        if ('MLEADERSTYLE' in objects) {
+            var mleaderStyleDict_1 = db.objects.mleaderStyle;
+            objects['MLEADERSTYLE'].forEach(function (style) {
+                var dbStyle = objectConverter.convertMLeaderStyle(style);
+                mleaderStyleDict_1.setAt(dbStyle.objectId, dbStyle);
+            });
+        }
+        if ('MLINESTYLE' in objects) {
+            var mlineStyleDict_1 = db.objects.mlineStyle;
+            objects['MLINESTYLE'].forEach(function (style) {
+                var dbStyle = objectConverter.convertMLineStyle(style);
+                mlineStyleDict_1.setAt(dbStyle.styleName || dbStyle.objectId, dbStyle);
+            });
+        }
+    };
+    /**
+     * Processes viewport table records from the DXF file.
+     *
+     * This method creates AcDbViewportTableRecord objects for each viewport
+     * defined in the DXF tables section, including their properties like
+     * center, corners, snap settings, and grid settings.
+     *
+     * @param model - Parsed DXF model containing viewport definitions
+     * @param db - Target database to add viewport table records to
+     *
+     * @example
+     * ```typescript
+     * converter.processViewports(parsedDxf, database);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processViewports = function (model, db) {
+        var _this = this;
+        var _a;
+        var viewportTable = (_a = model.tables) === null || _a === void 0 ? void 0 : _a.VPORT;
+        if (viewportTable) {
+            this.processCommonTableAttrs(viewportTable, db.tables.viewportTable);
+            var viewports = viewportTable.entries;
+            if (viewports && viewports.length > 0) {
+                viewports.forEach(function (item) {
+                    var _a, _b, _c, _d, _e, _f;
+                    var record = new AcDbViewportTableRecord();
+                    _this.processCommonTableEntryAttrs(item, record);
+                    if (item.circleSides) {
+                        record.circleSides = item.circleSides;
+                    }
+                    record.standardFlag = item.standardFlag;
+                    record.center.copy((_a = item.center) !== null && _a !== void 0 ? _a : VPORT_FALLBACK_CENTER_2D);
+                    record.lowerLeftCorner.copy((_b = item.lowerLeftCorner) !== null && _b !== void 0 ? _b : VPORT_FALLBACK_LLC);
+                    record.upperRightCorner.copy((_c = item.upperRightCorner) !== null && _c !== void 0 ? _c : VPORT_FALLBACK_URC);
+                    if (item.snapBasePoint) {
+                        record.snapBase.copy(item.snapBasePoint);
+                    }
+                    if (item.snapRotationAngle) {
+                        record.snapAngle = item.snapRotationAngle;
+                    }
+                    if (item.snapSpacing) {
+                        record.snapIncrements.copy(item.snapSpacing);
+                    }
+                    if (item.majorGridLines) {
+                        record.gridMajor = item.majorGridLines;
+                    }
+                    if (item.gridSpacing) {
+                        record.gridIncrements.copy(item.gridSpacing);
+                    }
+                    if (item.backgroundObjectId) {
+                        record.backgroundObjectId = item.backgroundObjectId;
+                    }
+                    record.gsView.center.copy((_d = item.center) !== null && _d !== void 0 ? _d : VPORT_FALLBACK_CENTER_2D);
+                    record.gsView.viewDirectionFromTarget.copy((_e = item.viewDirectionFromTarget) !== null && _e !== void 0 ? _e : VPORT_FALLBACK_VIEW_DIR);
+                    record.gsView.viewTarget.copy((_f = item.viewTarget) !== null && _f !== void 0 ? _f : VPORT_FALLBACK_VIEW_TARGET);
+                    if (item.lensLength) {
+                        record.gsView.lensLength = item.lensLength;
+                    }
+                    if (item.frontClippingPlane) {
+                        record.gsView.frontClippingPlane = item.frontClippingPlane;
+                    }
+                    if (item.backClippingPlane) {
+                        record.gsView.backClippingPlane = item.backClippingPlane;
+                    }
+                    if (item.viewHeight) {
+                        record.gsView.viewHeight = item.viewHeight;
+                    }
+                    if (item.aspectRatio != null &&
+                        Number.isFinite(item.aspectRatio) &&
+                        item.aspectRatio > 0) {
+                        record.gsView.aspectRatio = item.aspectRatio;
+                    }
+                    if (item.viewTwistAngle) {
+                        record.gsView.viewTwistAngle = item.viewTwistAngle;
+                    }
+                    if (item.frozenLayers) {
+                        record.gsView.frozenLayers = item.frozenLayers;
+                    }
+                    if (item.styleSheet) {
+                        record.gsView.styleSheet = item.styleSheet;
+                    }
+                    if (item.renderMode) {
+                        record.gsView.renderMode =
+                            item.renderMode;
+                    }
+                    if (item.viewMode) {
+                        record.gsView.viewMode = item.viewMode;
+                    }
+                    if (item.ucsIconSetting) {
+                        record.gsView.ucsIconSetting = item.ucsIconSetting;
+                    }
+                    if (item.ucsOrigin) {
+                        record.gsView.ucsOrigin.copy(item.ucsOrigin);
+                    }
+                    if (item.ucsXAxis) {
+                        record.gsView.ucsXAxis.copy(item.ucsXAxis);
+                    }
+                    if (item.ucsYAxis) {
+                        record.gsView.ucsYAxis.copy(item.ucsYAxis);
+                    }
+                    if (item.orthographicType) {
+                        record.gsView.orthographicType =
+                            item.orthographicType;
+                    }
+                    if (item.shadePlotSetting) {
+                        record.gsView.shadePlotSetting = item.shadePlotSetting;
+                    }
+                    if (item.shadePlotObjectId) {
+                        record.gsView.shadePlotObjectId = item.shadePlotObjectId;
+                    }
+                    if (item.visualStyleObjectId) {
+                        record.gsView.visualStyleObjectId = item.visualStyleObjectId;
+                    }
+                    if (item.isDefaultLightingOn) {
+                        record.gsView.isDefaultLightingOn = item.isDefaultLightingOn;
+                    }
+                    if (item.defaultLightingType) {
+                        record.gsView.defaultLightingType =
+                            item.defaultLightingType;
+                    }
+                    if (item.brightness) {
+                        record.gsView.brightness = item.brightness;
+                    }
+                    if (item.contrast) {
+                        record.gsView.contrast = item.contrast;
+                    }
+                    if (item.ambientColor) {
+                        record.gsView.ambientColor = item.ambientColor;
+                    }
+                    db.tables.viewportTable.add(record);
+                });
+            }
+        }
+    };
+    /**
+     * Processes layer table records from the DXF file.
+     *
+     * This method creates AcDbLayerTableRecord objects for each layer
+     * defined in the DXF tables section, including their properties like
+     * color, linetype, lineweight, and visibility settings.
+     *
+     * @param model - Parsed DXF model containing layer definitions
+     * @param db - Target database to add layer table records to
+     *
+     * @example
+     * ```typescript
+     * converter.processLayers(parsedDxf, database);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processLayers = function (model, db) {
+        var _this = this;
+        var _a;
+        var layerTable = (_a = model.tables) === null || _a === void 0 ? void 0 : _a.LAYER;
+        if (layerTable) {
+            this.processCommonTableAttrs(layerTable, db.tables.layerTable);
+            var layers = layerTable.entries;
+            if (layers && layers.length > 0) {
+                layers.forEach(function (item) {
+                    var color = new AcCmColor();
+                    color.colorIndex = item.colorIndex;
+                    var record = new AcDbLayerTableRecord({
+                        name: item.name,
+                        standardFlags: item.standardFlag,
+                        linetype: item.lineType,
+                        lineWeight: item.lineweight,
+                        isOff: item.colorIndex < 0,
+                        color: color,
+                        isPlottable: item.isPlotting
+                    });
+                    _this.processCommonTableEntryAttrs(item, record);
+                    db.tables.layerTable.add(record);
+                });
+            }
+        }
+    };
+    /**
+     * Processes linetype table records from the DXF file.
+     *
+     * This method creates AcDbLinetypeTableRecord objects for each linetype
+     * defined in the DXF tables section.
+     *
+     * @param model - Parsed DXF model containing linetype definitions
+     * @param db - Target database to add linetype table records to
+     *
+     * @example
+     * ```typescript
+     * converter.processLineTypes(parsedDxf, database);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processLineTypes = function (model, db) {
+        var _this = this;
+        var _a;
+        var lineTypeTable = (_a = model.tables) === null || _a === void 0 ? void 0 : _a.LTYPE;
+        if (lineTypeTable) {
+            this.processCommonTableAttrs(lineTypeTable, db.tables.linetypeTable);
+            var lineTypes = lineTypeTable.entries;
+            if (lineTypes && lineTypes.length > 0) {
+                lineTypes.forEach(function (item) {
+                    var record = new AcDbLinetypeTableRecord(item);
+                    _this.processCommonTableEntryAttrs(item, record);
+                    record.name = item.name;
+                    db.tables.linetypeTable.add(record);
+                });
+            }
+        }
+    };
+    /**
+     * Processes text style table records from the DXF file.
+     *
+     * This method creates AcDbTextStyleTableRecord objects for each text style
+     * defined in the DXF tables section.
+     *
+     * @param model - Parsed DXF model containing text style definitions
+     * @param db - Target database to add text style table records to
+     *
+     * @example
+     * ```typescript
+     * converter.processTextStyles(parsedDxf, database);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processTextStyles = function (model, db) {
+        var _this = this;
+        var _a;
+        var textStyleTable = (_a = model.tables) === null || _a === void 0 ? void 0 : _a.STYLE;
+        if (textStyleTable) {
+            this.processCommonTableAttrs(textStyleTable, db.tables.textStyleTable);
+            var textStyles = textStyleTable.entries;
+            if (textStyles && textStyles.length > 0) {
+                textStyles.forEach(function (item) {
+                    var record = new AcDbTextStyleTableRecord(item);
+                    _this.processCommonTableEntryAttrs(item, record);
+                    db.tables.textStyleTable.add(record);
+                });
+            }
+        }
+        db.ensureTextStyleDefaults();
+    };
+    /**
+     * Processes dimension style table records from the DXF file.
+     *
+     * This method creates AcDbDimStyleTableRecord objects for each dimension style
+     * defined in the DXF tables section, including all dimension-related properties
+     * like text positioning, arrow settings, and tolerance settings.
+     *
+     * @param model - Parsed DXF model containing dimension style definitions
+     * @param db - Target database to add dimension style table records to
+     *
+     * @example
+     * ```typescript
+     * converter.processDimStyles(parsedDxf, database);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processDimStyles = function (model, db) {
+        var _this = this;
+        var _a;
+        var dimStyleTable = (_a = model.tables) === null || _a === void 0 ? void 0 : _a.DIMSTYLE;
+        if (dimStyleTable) {
+            this.processCommonTableAttrs(dimStyleTable, db.tables.dimStyleTable);
+            var dimStyles = dimStyleTable.entries;
+            if (dimStyles && dimStyles.length > 0) {
+                dimStyles.forEach(function (item) {
+                    var attrs = {
+                        name: item.name,
+                        ownerId: item.ownerObjectId,
+                        dimpost: item.DIMPOST || '',
+                        dimapost: item.DIMAPOST || '',
+                        dimscale: item.DIMSCALE,
+                        dimasz: item.DIMASZ,
+                        dimexo: item.DIMEXO,
+                        dimdli: item.DIMDLI,
+                        dimexe: item.DIMEXE,
+                        dimrnd: item.DIMRND,
+                        dimdle: item.DIMDLE,
+                        dimtp: item.DIMTP,
+                        dimtm: item.DIMTM,
+                        dimtxt: item.DIMTXT,
+                        dimcen: item.DIMCEN,
+                        dimtsz: item.DIMTSZ,
+                        dimaltf: item.DIMALTF,
+                        dimlfac: item.DIMLFAC,
+                        dimtvp: item.DIMTVP,
+                        dimtfac: item.DIMTFAC,
+                        dimgap: item.DIMGAP,
+                        dimaltrnd: item.DIMALTRND,
+                        dimtol: item.DIMTOL == null || item.DIMTOL == 0 ? 0 : 1,
+                        dimlim: item.DIMLIM == null || item.DIMLIM == 0 ? 0 : 1,
+                        dimtih: item.DIMTIH == null || item.DIMTIH == 0 ? 0 : 1,
+                        dimtoh: item.DIMTOH == null || item.DIMTOH == 0 ? 0 : 1,
+                        dimse1: item.DIMSE1 == null || item.DIMSE1 == 0 ? 0 : 1,
+                        dimse2: item.DIMSE2 == null || item.DIMSE2 == 0 ? 0 : 1,
+                        dimtad: item.DIMTAD,
+                        dimzin: item.DIMZIN,
+                        dimazin: item.DIMAZIN,
+                        dimalt: item.DIMALT,
+                        dimaltd: item.DIMALTD,
+                        dimtofl: item.DIMTOFL,
+                        dimsah: item.DIMSAH,
+                        dimtix: item.DIMTIX,
+                        dimsoxd: item.DIMSOXD,
+                        dimclrd: item.DIMCLRD,
+                        dimclre: item.DIMCLRE,
+                        dimclrt: item.DIMCLRT,
+                        dimadec: item.DIMADEC || 0,
+                        dimunit: item.DIMUNIT || 2,
+                        dimdec: item.DIMDEC,
+                        dimtdec: item.DIMTDEC,
+                        dimaltu: item.DIMALTU,
+                        dimalttd: item.DIMALTTD,
+                        dimaunit: item.DIMAUNIT,
+                        dimfrac: item.DIMFRAC,
+                        dimlunit: item.DIMLUNIT,
+                        dimdsep: item.DIMDSEP ? item.DIMDSEP.toString() : '.',
+                        dimtmove: item.DIMTMOVE || 0,
+                        dimjust: item.DIMJUST,
+                        dimsd1: item.DIMSD1,
+                        dimsd2: item.DIMSD2,
+                        dimtolj: item.DIMTOLJ,
+                        dimtzin: item.DIMTZIN,
+                        dimaltz: item.DIMALTZ,
+                        dimalttz: item.DIMALTTZ,
+                        dimfit: item.DIMFIT || 0,
+                        dimupt: item.DIMUPT,
+                        dimatfit: item.DIMATFIT,
+                        dimtxsty: item.DIMTXSTY || DEFAULT_TEXT_STYLE,
+                        dimldrblk: item.DIMLDRBLK || '',
+                        dimblk: item.DIMBLK || '',
+                        dimblk1: item.DIMBLK1 || '',
+                        dimblk2: item.DIMBLK2 || '',
+                        dimlwd: item.DIMLWD,
+                        dimlwe: item.DIMLWE
+                    };
+                    var record = new AcDbDimStyleTableRecord(attrs);
+                    _this.processCommonTableEntryAttrs(item, record);
+                    db.tables.dimStyleTable.add(record);
+                });
+            }
+        }
+    };
+    AcDbDxfConverter.prototype.processCommonTableAttrs = function (table, dbTable) {
+        if (table.handle != null) {
+            dbTable.objectId = table.handle;
+        }
+        if (table.ownerObjectId != null) {
+            dbTable.ownerId = table.ownerObjectId;
+        }
+    };
+    /**
+     * Processes common table entry attributes from DXF data.
+     *
+     * This helper method sets the common attributes (name, objectId, ownerId)
+     * that are shared across all table entries.
+     *
+     * @param entry - DXF table entry containing the source data
+     * @param dbEntry - AcDbSymbolTableRecord to populate with the data
+     *
+     * @example
+     * ```typescript
+     * converter.processCommonTableEntryAttrs(dxfEntry, dbRecord);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processCommonTableEntryAttrs = function (entry, dbEntry) {
+        dbEntry.name = 'name' in entry ? entry.name : '';
+        // All of objects in drawing database should have handle. However, some VPORT objects in DXF file
+        // don't have handle. In this time, just use objectId created in constructor of AcDbObject.
+        // https://github.com/mlightcad/cad-viewer/issues/101
+        if (entry.handle != null)
+            dbEntry.objectId = entry.handle;
+        if (entry.ownerObjectId != null) {
+            dbEntry.ownerId = entry.ownerObjectId;
+        }
+    };
+    /**
+     * Groups entities by their `type` property and flattens the result into a single array.
+     *
+     * The order of `type` groups follows the order in which they first appear in the input array.
+     * Items within each group preserve their original order.
+     *
+     * This runs in O(n) time, which is generally faster than sorting when you
+     * don't care about alphabetical order of types.
+     *
+     * @param entities - The array of entities to group and flatten.
+     *
+     * @returns A new array of entities grouped by their `type` property.
+     */
+    AcDbDxfConverter.prototype.groupAndFlattenByType = function (entities) {
+        var e_2, _a;
+        var groups = {};
+        var order = [];
+        try {
+            for (var entities_1 = __values(entities), entities_1_1 = entities_1.next(); !entities_1_1.done; entities_1_1 = entities_1.next()) {
+                var entity = entities_1_1.value;
+                if (!groups[entity.type]) {
+                    groups[entity.type] = [];
+                    order.push(entity.type);
+                }
+                groups[entity.type].push(entity);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return order.flatMap(function (type) { return groups[type]; });
+    };
+    AcDbDxfConverter.prototype.normalizeHeaderStringValue = function (value) {
+        if (typeof value !== 'string')
+            return undefined;
+        var trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : undefined;
+    };
+    return AcDbDxfConverter;
+}(AcDbDatabaseConverter));
+export { AcDbDxfConverter };
+//# sourceMappingURL=AcDbDxfConverter.js.map