@mlightcad/data-model 1.3.3 → 1.3.4

package/lib/database/AcDbDatabase.js

@@ -0,0 +1,842 @@
+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 __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.");
+};
+/* eslint-disable simple-import-sort/imports */
+import { AcCmColor, AcCmEventManager } from '@mlightcad/common';
+import { AcDbObject } from '../base';
+import { AcDbRegenerator } from '../converter';
+import { AcDbDatabaseConverterManager, AcDbFileType } from './AcDbDatabaseConverterManager';
+import { AcDbAngleUnits, AcDbUnitsValue } from '../misc';
+import { AcDbDictionary, AcDbLayout, AcDbLayoutDictionary } from '../object';
+import { AcDbBlockTable } from './AcDbBlockTable';
+import { AcDbDimStyleTable } from './AcDbDimStyleTable';
+import { AcDbLayerTable } from './AcDbLayerTable';
+import { AcDbLayerTableRecord } from './AcDbLayerTableRecord';
+import { AcDbLinetypeTable } from './AcDbLinetypeTable';
+import { AcDbTextStyleTable } from './AcDbTextStyleTable';
+import { AcDbViewportTable } from './AcDbViewportTable';
+import { AcGeBox3d } from '@mlightcad/geometry-engine';
+import { AcDbLinetypeTableRecord } from './AcDbLinetypeTableRecord';
+import { AcDbTextStyleTableRecord } from './AcDbTextStyleTableRecord';
+import { AcDbDimStyleTableRecord } from './AcDbDimStyleTableRecord';
+import { AcDbDwgVersion } from './AcDbDwgVersion';
+/**
+ * The AcDbDatabase class represents an AutoCAD drawing file.
+ *
+ * Each AcDbDatabase object contains the various header variables, symbol tables,
+ * table records, entities, and objects that make up the drawing. The AcDbDatabase
+ * class has member functions to allow access to all the symbol tables, to read
+ * and write to DWG files, to get or set database defaults, to execute various
+ * database-level operations, and to get or set all header variables.
+ *
+ * @example
+ * ```typescript
+ * const database = new AcDbDatabase();
+ * await database.read(dxfData, { readOnly: true });
+ * const entities = database.tables.blockTable.modelSpace.entities;
+ * ```
+ */
+var AcDbDatabase = /** @class */ (function (_super) {
+    __extends(AcDbDatabase, _super);
+    /**
+     * Creates a new AcDbDatabase instance.
+     */
+    function AcDbDatabase() {
+        var _this = _super.call(this) || this;
+        /**
+         * Events that can be triggered by the database.
+         *
+         * These events allow applications to respond to various database operations
+         * such as entity modifications, layer changes, and progress updates.
+         */
+        _this.events = {
+            /** Fired when an object is set to the dictionary */
+            dictObjetSet: new AcCmEventManager(),
+            /** Fired when an object in the dictionary is removed */
+            dictObjectErased: new AcCmEventManager(),
+            /** Fired when an entity is appended to the database */
+            entityAppended: new AcCmEventManager(),
+            /** Fired when an entity is modified in the database */
+            entityModified: new AcCmEventManager(),
+            /** Fired when a layer is appended to the database */
+            layerAppended: new AcCmEventManager(),
+            /** Fired when a layer is modified in the database */
+            layerModified: new AcCmEventManager(),
+            /** Fired when a layer is erased from the database */
+            layerErased: new AcCmEventManager(),
+            /** Fired during database opening operations to report progress */
+            openProgress: new AcCmEventManager(),
+            /** Fired when a header system variable is changed */
+            headerSysVarChanged: new AcCmEventManager()
+        };
+        _this._version = new AcDbDwgVersion('AC1014');
+        _this._angBase = 0;
+        _this._angDir = 0;
+        _this._aunits = AcDbAngleUnits.DecimalDegrees;
+        _this._celtscale = 1;
+        _this._cecolor = new AcCmColor();
+        _this._extents = new AcGeBox3d();
+        // TODO: Default value is 1 (imperial) or 4 (metric)
+        _this._insunits = AcDbUnitsValue.Millimeters;
+        _this._ltscale = 1;
+        _this._pdmode = 0;
+        _this._pdsize = 0;
+        _this._tables = {
+            blockTable: new AcDbBlockTable(_this),
+            dimStyleTable: new AcDbDimStyleTable(_this),
+            linetypeTable: new AcDbLinetypeTable(_this),
+            textStyleTable: new AcDbTextStyleTable(_this),
+            layerTable: new AcDbLayerTable(_this),
+            viewportTable: new AcDbViewportTable(_this)
+        };
+        _this._dictionaries = {
+            layouts: new AcDbLayoutDictionary(_this),
+            imageDefs: new AcDbDictionary(_this)
+        };
+        return _this;
+    }
+    Object.defineProperty(AcDbDatabase.prototype, "tables", {
+        /**
+         * Gets all tables in this drawing database.
+         *
+         * @returns Object containing all the symbol tables in the database
+         *
+         * @example
+         * ```typescript
+         * const tables = database.tables;
+         * const layers = tables.layerTable;
+         * const blocks = tables.blockTable;
+         * ```
+         */
+        get: function () {
+            return this._tables;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "dictionaries", {
+        /**
+         * Gets all named object dictionaries in this drawing database.
+         *
+         * @returns Object containing all the dictionaries in the database
+         *
+         * @example
+         * ```typescript
+         * const dictionaries = database.dictionaries;
+         * const layouts = dictionaries.layouts;
+         * ```
+         */
+        get: function () {
+            return this._dictionaries;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "currentSpaceId", {
+        /**
+         * Gets the object ID of the AcDbBlockTableRecord of the current space.
+         *
+         * The current space can be either model space or paper space.
+         *
+         * @returns The object ID of the current space
+         *
+         * @example
+         * ```typescript
+         * const currentSpaceId = database.currentSpaceId;
+         * ```
+         */
+        get: function () {
+            if (!this._currentSpace) {
+                this._currentSpace = this._tables.blockTable.modelSpace;
+            }
+            return this._currentSpace.objectId;
+        },
+        /**
+         * Sets the current space by object ID.
+         *
+         * @param value - The object ID of the block table record to set as current space
+         * @throws {Error} When the specified block table record ID doesn't exist
+         *
+         * @example
+         * ```typescript
+         * database.currentSpaceId = 'some-block-record-id';
+         * ```
+         */
+        set: function (value) {
+            var currentSpace = this.tables.blockTable.getIdAt(value);
+            if (currentSpace == null) {
+                throw new Error("[AcDbDatabase] The specified block table record id '".concat(value, "' doesn't exist in the drawing database!"));
+            }
+            else {
+                this._currentSpace = currentSpace;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "aunits", {
+        /**
+         * Gets the angle units for the database.
+         *
+         * This is the current AUNITS value for the database.
+         *
+         * @returns The angle units value
+         *
+         * @example
+         * ```typescript
+         * const angleUnits = database.aunits;
+         * ```
+         */
+        get: function () {
+            return this._aunits;
+        },
+        /**
+         * Sets the angle units for the database.
+         *
+         * @param value - The new angle units value
+         *
+         * @example
+         * ```typescript
+         * database.aunits = AcDbAngleUnits.DecimalDegrees;
+         * ```
+         */
+        set: function (value) {
+            this._aunits = value || 0;
+            this.triggerHeaderSysVarChangedEvent('aunits');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "version", {
+        /**
+         * Gets the version of the database.
+         *
+         * @returns The version of the database
+         *
+         */
+        get: function () {
+            return this._version;
+        },
+        /**
+         * Sets the version of the database.
+         *
+         * @param value - The version value of the database
+         */
+        set: function (value) {
+            this._version = new AcDbDwgVersion(value);
+            this.triggerHeaderSysVarChangedEvent('version');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "insunits", {
+        /**
+         * Gets the drawing-units value for automatic scaling of blocks, images, or xrefs.
+         *
+         * This is the current INSUNITS value for the database.
+         *
+         * @returns The insertion units value
+         *
+         * @example
+         * ```typescript
+         * const insertionUnits = database.insunits;
+         * ```
+         */
+        get: function () {
+            return this._insunits;
+        },
+        /**
+         * Sets the drawing-units value for automatic scaling.
+         *
+         * @param value - The new insertion units value
+         *
+         * @example
+         * ```typescript
+         * database.insunits = AcDbUnitsValue.Millimeters;
+         * ```
+         */
+        set: function (value) {
+            // TODO: Default value is 1 (imperial) or 4 (metric)
+            this._insunits = value || 4;
+            this.triggerHeaderSysVarChangedEvent('insunits');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "ltscale", {
+        /**
+         * Gets the line type scale factor.
+         *
+         * @returns The line type scale factor
+         *
+         * @example
+         * ```typescript
+         * const lineTypeScale = database.ltscale;
+         * ```
+         */
+        get: function () {
+            return this._ltscale;
+        },
+        /**
+         * Sets the line type scale factor.
+         *
+         * @param value - The new line type scale factor
+         *
+         * @example
+         * ```typescript
+         * database.ltscale = 2.0;
+         * ```
+         */
+        set: function (value) {
+            this._ltscale = value || 1;
+            this.triggerHeaderSysVarChangedEvent('ltscale');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "cecolor", {
+        /**
+         * Gets the color of new objects as they are created.
+         *
+         * @returns The current entity color
+         *
+         * @example
+         * ```typescript
+         * const currentColor = database.cecolor;
+         * ```
+         */
+        get: function () {
+            return this._cecolor;
+        },
+        /**
+         * Sets the color of new objects as they are created.
+         *
+         * @param value - The new current entity color
+         *
+         * @example
+         * ```typescript
+         * database.cecolor = new AcCmColor(0xFF0000);
+         * ```
+         */
+        set: function (value) {
+            this._cecolor = value || 0;
+            this.triggerHeaderSysVarChangedEvent('cecolor');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "celtscale", {
+        /**
+         * The line type scaling for new objects relative to the ltscale setting. A line created with
+         * celtscale = 2 in a drawing with ltscale set to 0.5 would appear the same as a line created
+         * with celtscale = 1 in a drawing with ltscale = 1.
+         */
+        get: function () {
+            return this._celtscale;
+        },
+        set: function (value) {
+            this._celtscale = value || 1;
+            this.triggerHeaderSysVarChangedEvent('celtscale');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "angBase", {
+        /**
+         * The zero (0) base angle with respect to the current UCS in radians.
+         */
+        get: function () {
+            return this._angBase;
+        },
+        set: function (value) {
+            this._angBase = value || 0;
+            this.triggerHeaderSysVarChangedEvent('angbase');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "angDir", {
+        /**
+         * The direction of positive angles.
+         * - 0: Counterclockwise
+         * - 1: Clockwise
+         */
+        get: function () {
+            return this._angDir;
+        },
+        set: function (value) {
+            this._angDir = value || 0;
+            this.triggerHeaderSysVarChangedEvent('angdir');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "extmax", {
+        /**
+         * The current Model Space EXTMAX value
+         */
+        get: function () {
+            return this._extents.max;
+        },
+        set: function (value) {
+            if (value) {
+                this._extents.expandByPoint(value);
+                this.triggerHeaderSysVarChangedEvent('extmax');
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "extmin", {
+        /**
+         * The current Model Space EXTMIN value
+         */
+        get: function () {
+            return this._extents.min;
+        },
+        set: function (value) {
+            if (value) {
+                this._extents.expandByPoint(value);
+                this.triggerHeaderSysVarChangedEvent('extmin');
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "extents", {
+        /**
+         * The extents of current Model Space
+         */
+        get: function () {
+            return this._extents;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "pdmode", {
+        /**
+         * Point display mode. Please get more details on value of this property from [this page](https://help.autodesk.com/view/ACDLT/2022/ENU/?guid=GUID-82F9BB52-D026-4D6A-ABA6-BF29641F459B).
+         */
+        get: function () {
+            return this._pdmode;
+        },
+        set: function (value) {
+            this._pdmode = value || 0;
+            this.triggerHeaderSysVarChangedEvent('pdmode');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDatabase.prototype, "pdsize", {
+        /**
+         * Point display size.
+         * - 0: Create a point at 5 percent of the drawing area height
+         * - > 0: Specifie an absolute size
+         * - < 0: Specifie a percentage of the viewport size
+         */
+        get: function () {
+            return this._pdsize;
+        },
+        set: function (value) {
+            this._pdsize = value || 0;
+            this.triggerHeaderSysVarChangedEvent('pdsize');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Reads drawing data from a string or ArrayBuffer.
+     *
+     * This method parses the provided data and populates the database with
+     * the resulting entities, tables, and objects. The method supports
+     * both DXF and DWG file formats.
+     *
+     * @param data - The drawing data as a string or ArrayBuffer
+     *   - For DXF files: Pass a string containing the DXF content
+     *   - For DWG files: Pass an ArrayBuffer instance containing the binary DWG data
+     * @param options - Options for reading the database
+     * @param fileType - The type of file being read (defaults to DXF)
+     *
+     * @example
+     * ```typescript
+     * // Reading a DXF file (string)
+     * const database = new AcDbDatabase();
+     * await database.read(dxfString, { readOnly: true }, AcDbFileType.DXF);
+     *
+     * // Reading a DWG file (ArrayBuffer)
+     * const database = new AcDbDatabase();
+     * await database.read(dwgArrayBuffer, { readOnly: true }, AcDbFileType.DWG);
+     * ```
+     */
+    AcDbDatabase.prototype.read = function (data_1, options_1) {
+        return __awaiter(this, arguments, void 0, function (data, options, fileType) {
+            var converter;
+            var _this = this;
+            if (fileType === void 0) { fileType = AcDbFileType.DXF; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        converter = AcDbDatabaseConverterManager.instance.get(fileType);
+                        if (converter == null)
+                            throw new Error("Database converter for file type '".concat(fileType, "' isn't registered and can can't read this file!"));
+                        this.clear();
+                        return [4 /*yield*/, converter.read(data, this, (options && options.minimumChunkSize) || 10, function (percentage, stage, stageStatus, data) { return __awaiter(_this, void 0, void 0, function () {
+                                var fonts_1;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            this.events.openProgress.dispatch({
+                                                database: this,
+                                                percentage: percentage,
+                                                stage: 'CONVERSION',
+                                                subStage: stage,
+                                                subStageStatus: stageStatus,
+                                                data: data
+                                            });
+                                            if (!(options &&
+                                                options.fontLoader &&
+                                                stage == 'FONT' &&
+                                                stageStatus == 'END')) return [3 /*break*/, 2];
+                                            fonts_1 = data
+                                                ? data
+                                                : this.tables.textStyleTable.fonts;
+                                            return [4 /*yield*/, options.fontLoader.load(fonts_1)];
+                                        case 1:
+                                            _a.sent();
+                                            _a.label = 2;
+                                        case 2: return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Read AutoCAD DXF or DWG drawing specified by the URL into the database object.
+     * The method automatically detects the file type based on the URL extension:
+     * - .dxf files are read as text using readAsText()
+     * - .dwg files are read as binary data using readAsArrayBuffer()
+     * @param url Input the URL linked to one AutoCAD DXF or DWG file
+     * @param options Input options to read drawing data
+     */
+    AcDbDatabase.prototype.openUri = function (url, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, contentLength, totalBytes, loadedBytes, reader, chunks, _a, done, value, percentage, content, position, chunks_1, chunks_1_1, chunk, fileExtension;
+            var e_1, _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        this.events.openProgress.dispatch({
+                            database: this,
+                            percentage: 0,
+                            stage: 'FETCH_FILE',
+                            subStageStatus: 'START'
+                        });
+                        return [4 /*yield*/, fetch(url)];
+                    case 1:
+                        response = _d.sent();
+                        if (!response.ok) {
+                            this.events.openProgress.dispatch({
+                                database: this,
+                                percentage: 100,
+                                stage: 'FETCH_FILE',
+                                subStageStatus: 'ERROR'
+                            });
+                            throw new Error("Failed to fetch file '".concat(url, "' with HTTP status code '").concat(response.status, "'!"));
+                        }
+                        contentLength = response.headers.get('content-length');
+                        totalBytes = contentLength ? parseInt(contentLength, 10) : null;
+                        loadedBytes = 0;
+                        reader = (_c = response.body) === null || _c === void 0 ? void 0 : _c.getReader();
+                        if (!reader) {
+                            throw new Error('Failed to get response reader');
+                        }
+                        chunks = [];
+                        _d.label = 2;
+                    case 2:
+                        if (!true) return [3 /*break*/, 4];
+                        return [4 /*yield*/, reader.read()];
+                    case 3:
+                        _a = _d.sent(), done = _a.done, value = _a.value;
+                        if (done) {
+                            return [3 /*break*/, 4];
+                        }
+                        chunks.push(value);
+                        loadedBytes += value.length;
+                        // Calculate and report progress if we know the total size
+                        if (totalBytes !== null) {
+                            percentage = Math.round((loadedBytes / totalBytes) * 100);
+                            this.events.openProgress.dispatch({
+                                database: this,
+                                percentage: percentage,
+                                stage: 'FETCH_FILE',
+                                subStageStatus: 'IN-PROGRESS'
+                            });
+                        }
+                        return [3 /*break*/, 2];
+                    case 4:
+                        content = new Uint8Array(loadedBytes);
+                        position = 0;
+                        try {
+                            for (chunks_1 = __values(chunks), chunks_1_1 = chunks_1.next(); !chunks_1_1.done; chunks_1_1 = chunks_1.next()) {
+                                chunk = chunks_1_1.value;
+                                content.set(chunk, position);
+                                position += chunk.length;
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (chunks_1_1 && !chunks_1_1.done && (_b = chunks_1.return)) _b.call(chunks_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        fileExtension = url.toLowerCase().split('.').pop();
+                        if (!(fileExtension === 'dwg')) return [3 /*break*/, 6];
+                        // DWG files are binary, convert to ArrayBuffer
+                        return [4 /*yield*/, this.read(content.buffer, options, AcDbFileType.DWG)];
+                    case 5:
+                        // DWG files are binary, convert to ArrayBuffer
+                        _d.sent();
+                        return [3 /*break*/, 8];
+                    case 6: return [4 /*yield*/, this.read(content.buffer, options, AcDbFileType.DXF)];
+                    case 7:
+                        _d.sent();
+                        _d.label = 8;
+                    case 8:
+                        this.events.openProgress.dispatch({
+                            database: this,
+                            percentage: 100,
+                            stage: 'FETCH_FILE',
+                            subStageStatus: 'END'
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Triggers xxxAppended events with data in the database to redraw the associated viewer.
+     */
+    AcDbDatabase.prototype.regen = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var converter;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        converter = new AcDbRegenerator(this);
+                        return [4 /*yield*/, converter.read(null, this, 500, function (percentage, stage, stageStatus, data) { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    this.events.openProgress.dispatch({
+                                        database: this,
+                                        percentage: percentage,
+                                        stage: 'CONVERSION',
+                                        subStage: stage,
+                                        subStageStatus: stageStatus,
+                                        data: data
+                                    });
+                                    return [2 /*return*/];
+                                });
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Create default layer, line type, dimension type, text style and layout.
+     * @param - Options to specify data to create
+     */
+    AcDbDatabase.prototype.createDefaultData = function (options) {
+        if (options === void 0) { options = {
+            layer: true,
+            lineType: true,
+            textStyle: true,
+            dimStyle: true,
+            layout: true
+        }; }
+        // Create default layer
+        if (options.layer) {
+            var defaultColor = new AcCmColor();
+            defaultColor.colorIndex = 7; // white
+            this._tables.layerTable.add(new AcDbLayerTableRecord({
+                name: '0',
+                standardFlags: 0,
+                linetype: 'Continuous',
+                lineWeight: 0,
+                isOff: false,
+                color: defaultColor,
+                isPlottable: true
+            }));
+        }
+        // Create default line type
+        if (options.lineType) {
+            this._tables.linetypeTable.add(new AcDbLinetypeTableRecord({
+                name: 'ByBlock',
+                standardFlag: 0,
+                description: '',
+                totalPatternLength: 0
+            }));
+            this._tables.linetypeTable.add(new AcDbLinetypeTableRecord({
+                name: 'ByLayer',
+                standardFlag: 0,
+                description: '',
+                totalPatternLength: 0
+            }));
+            this._tables.linetypeTable.add(new AcDbLinetypeTableRecord({
+                name: 'Continuous',
+                standardFlag: 0,
+                description: 'Solid line',
+                totalPatternLength: 0
+            }));
+        }
+        // Create default text style
+        if (options.textStyle) {
+            this._tables.textStyleTable.add(new AcDbTextStyleTableRecord({
+                name: 'Standard',
+                standardFlag: 0,
+                fixedTextHeight: 0,
+                widthFactor: 1,
+                obliqueAngle: 0,
+                textGenerationFlag: 0,
+                lastHeight: 0.2,
+                font: 'SimKai',
+                bigFont: '',
+                extendedFont: 'SimKai'
+            }));
+        }
+        // Create default dimension style
+        if (options.dimStyle) {
+            this._tables.dimStyleTable.add(new AcDbDimStyleTableRecord({
+                name: 'Standard',
+                dimtxsty: 'Standard'
+            }));
+        }
+        // Create default layer for model space
+        if (options.layout) {
+            var layout = new AcDbLayout();
+            layout.layoutName = 'Model';
+            layout.tabOrder = 0;
+            layout.blockTableRecordId = this._tables.blockTable.modelSpace.objectId;
+            layout.limits.min.copy({ x: 0, y: 0 });
+            layout.limits.max.copy({ x: 1000000, y: 1000000 });
+            layout.extents.min.copy({ x: 0, y: 0, z: 0 });
+            layout.extents.max.copy({ x: 1000000, y: 1000000, z: 0 });
+            this._dictionaries.layouts.setAt(layout.layoutName, layout);
+            this._tables.blockTable.modelSpace.layoutId = layout.objectId;
+        }
+    };
+    /**
+     * Clears all data from the database.
+     *
+     * This method removes all entities, tables, and objects from the database,
+     * effectively resetting it to an empty state.
+     *
+     * @example
+     * ```typescript
+     * database.clear();
+     * ```
+     */
+    AcDbDatabase.prototype.clear = function () {
+        // Clear all tables and dictionaries
+        this._tables.blockTable.removeAll();
+        this._tables.dimStyleTable.removeAll();
+        this._tables.linetypeTable.removeAll();
+        this._tables.textStyleTable.removeAll();
+        this._tables.layerTable.removeAll();
+        this._tables.viewportTable.removeAll();
+        this._dictionaries.layouts.removeAll();
+        this._currentSpace = undefined;
+        this._extents.makeEmpty();
+    };
+    /**
+     * Triggers a header system variable changed event.
+     *
+     * This method is called internally when header system variables
+     * are modified to notify listeners of the change.
+     *
+     * @param sysVarName - The name of the system variable that changed
+     *
+     * @example
+     * ```typescript
+     * database.triggerHeaderSysVarChangedEvent('aunits');
+     * ```
+     */
+    AcDbDatabase.prototype.triggerHeaderSysVarChangedEvent = function (sysVarName) {
+        this.events.headerSysVarChanged.dispatch({
+            database: this,
+            name: sysVarName
+        });
+    };
+    return AcDbDatabase;
+}(AcDbObject));
+export { AcDbDatabase };
+/* eslint-enable simple-import-sort/imports */
+//# sourceMappingURL=AcDbDatabase.js.map