@mlightcad/data-model 1.3.3 → 1.3.4

package/lib/converter/AcDbDxfConverter.js

@@ -0,0 +1,874 @@
+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 } from '@mlightcad/common';
+import { AcDbBlockTableRecord, AcDbDimStyleTableRecord, AcDbLayerTableRecord, AcDbLinetypeTableRecord, AcDbTextStyleTableRecord, AcDbViewportTableRecord } from '../database';
+import { AcDbDatabaseConverter } from '../database/AcDbDatabaseConverter';
+import { AcDbBatchProcessing } from './AcDbBatchProcessing';
+import { AcDbDxfParser } from './AcDbDxfParser';
+import { AcDbEntityConverter } from './AcDbEntitiyConverter';
+import { AcDbObjectConverter } from './AcDbObjectConverter';
+import { createWorkerApi } from './worker';
+/**
+ * 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 (!config.parserWorkerUrl) {
+            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) {
+        return __awaiter(this, void 0, void 0, function () {
+            var api, result, parser, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.config.useWorker && this.config.parserWorkerUrl)) return [3 /*break*/, 2];
+                        api = createWorkerApi({
+                            workerUrl: this.config.parserWorkerUrl,
+                            // 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:
+                        parser = new AcDbDxfParser();
+                        result = parser.parse(data);
+                        return [2 /*return*/, {
+                                model: result,
+                                data: {
+                                    unknownEntityCount: 0
+                                }
+                            }];
+                    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 = [];
+            var fontName = getFontName(style.font);
+            if (fontName)
+                fontNames.push(fontName);
+            fontName = getFontName(style.bigFont);
+            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 == '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, 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);
+                        }
+                        modelSpaceBlockTableRecord = db.tables.blockTable.modelSpace;
+                        return [4 /*yield*/, batchProcessor.processChunk(function (start, end) { return __awaiter(_this, void 0, void 0, function () {
+                                var dbEntities, entityType, i, entity, dbEntity, percentage;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            dbEntities = [];
+                                            entityType = start < end ? entities[start].type : '';
+                                            for (i = start; i < end; i++) {
+                                                entity = entities[i];
+                                                dbEntity = converter.convert(entity);
+                                                if (dbEntity) {
+                                                    if (this.config.convertByEntityType && entity.type !== entityType) {
+                                                        modelSpaceBlockTableRecord.appendEntity(dbEntities);
+                                                        dbEntities = [];
+                                                        entityType = entity.type;
+                                                    }
+                                                    dbEntities.push(dbEntity);
+                                                }
+                                            }
+                                            // Use batch append to improve performance
+                                            modelSpaceBlockTableRecord.appendEntity(dbEntities);
+                                            if (!progress) return [3 /*break*/, 2];
+                                            percentage = startPercentage.value +
+                                                (end / entityCount) * (100 - startPercentage.value);
+                                            if (percentage > 100)
+                                                percentage = 100;
+                                            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
+     *
+     * @example
+     * ```typescript
+     * await converter.processEntitiesInBlock(entities, blockRecord);
+     * ```
+     */
+    AcDbDxfConverter.prototype.processEntitiesInBlock = function (entities, blockTableRecord) {
+        return __awaiter(this, void 0, void 0, function () {
+            var converter, entityCount, dbEntities, i, entity, dbEntity;
+            return __generator(this, function (_a) {
+                converter = new AcDbEntityConverter();
+                entityCount = entities.length;
+                dbEntities = [];
+                for (i = 0; i < entityCount; i++) {
+                    entity = entities[i];
+                    dbEntity = converter.convert(entity);
+                    if (dbEntity) {
+                        dbEntities.push(dbEntity);
+                    }
+                }
+                // Use batch append to improve performance
+                blockTableRecord.appendEntity(dbEntities);
+                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();
+                    dbBlock.objectId = block.handle;
+                    // dbBlock.ownerId = block.ownerHandle
+                    dbBlock.name = name_1;
+                    dbBlock.origin.copy(block.position);
+                    db.tables.blockTable.add(dbBlock);
+                }
+                if (block.entities) {
+                    this.processEntitiesInBlock(block.entities, dbBlock);
+                }
+            }
+        }
+        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 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['$EXTMAX'])
+            db.extmax = header['$EXTMAX'];
+        if (header['$EXTMIN'])
+            db.extmin = header['$EXTMIN'];
+        if (header['$INSUNITS'] != null)
+            db.insunits = header['$INSUNITS'];
+        db.pdmode = header['$PDMODE'] || 0;
+        db.pdsize = header['$PDSIZE'] || 0.0;
+    };
+    /**
+     * 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;
+                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.dictionaries.layouts;
+            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.dictionaries.imageDefs;
+            objects['IMAGEDEF'].forEach(function (imageDef) {
+                var dbImageDef = objectConverter.convertImageDef(imageDef);
+                imageDefDict_1.setAt(dbImageDef.objectId, dbImageDef);
+            });
+        }
+    };
+    /**
+     * 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, _b;
+        var viewports = (_b = (_a = model.tables) === null || _a === void 0 ? void 0 : _a.VPORT) === null || _b === void 0 ? void 0 : _b.entries;
+        if (viewports && viewports.length > 0) {
+            viewports.forEach(function (item) {
+                var record = new AcDbViewportTableRecord();
+                _this.processCommonTableEntryAttrs(item, record);
+                if (item.circleSides) {
+                    record.circleSides = item.circleSides;
+                }
+                record.standardFlag = item.standardFlag;
+                record.center.copy(item.center);
+                record.lowerLeftCorner.copy(item.lowerLeftCorner);
+                record.upperRightCorner.copy(item.upperRightCorner);
+                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(item.center);
+                record.gsView.viewDirectionFromTarget.copy(item.viewDirectionFromTarget);
+                record.gsView.viewTarget.copy(item.viewTarget);
+                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.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, _b;
+        var layers = (_b = (_a = model.tables) === null || _a === void 0 ? void 0 : _a.LAYER) === null || _b === void 0 ? void 0 : _b.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, _b;
+        var lineTypes = (_b = (_a = model.tables) === null || _a === void 0 ? void 0 : _a.LTYPE) === null || _b === void 0 ? void 0 : _b.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 textStyles = (_a = model.tables.STYLE) === null || _a === void 0 ? void 0 : _a.entries;
+        if (textStyles && textStyles.length > 0) {
+            textStyles.forEach(function (item) {
+                var record = new AcDbTextStyleTableRecord(item);
+                _this.processCommonTableEntryAttrs(item, record);
+                db.tables.textStyleTable.add(record);
+            });
+        }
+    };
+    /**
+     * 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 dimStyles = (_a = model.tables.DIMSTYLE) === null || _a === void 0 ? void 0 : _a.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,
+                    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 || 'Standard',
+                    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);
+            });
+        }
+    };
+    /**
+     * 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 = entry.name;
+        dbEntry.objectId = entry.handle;
+        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]; });
+    };
+    return AcDbDxfConverter;
+}(AcDbDatabaseConverter));
+export { AcDbDxfConverter };
+//# sourceMappingURL=AcDbDxfConverter.js.map