@mlightcad/data-model 1.3.3 → 1.3.5

package/lib/database/AcDbLayerTableRecord.js

@@ -0,0 +1,397 @@
+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 __());
+    };
+})();
+import { AcCmColor, defaults } from '@mlightcad/common';
+import { AcDbSymbolTableRecord } from './AcDbSymbolTableRecord';
+/**
+ * Represents a record in the layer table.
+ *
+ * This class contains information about a layer in the drawing database,
+ * including color, visibility settings, linetype, and other layer properties.
+ * Layers are used to organize and control the display of entities in the drawing.
+ *
+ * @example
+ * ```typescript
+ * const layer = new AcDbLayerTableRecord({
+ *   name: 'MyLayer',
+ *   color: new AcCmColor(255, 0, 0), // Red
+ *   isOff: false,
+ *   isPlottable: true
+ * });
+ * ```
+ */
+var AcDbLayerTableRecord = /** @class */ (function (_super) {
+    __extends(AcDbLayerTableRecord, _super);
+    /**
+     * Creates a new AcDbLayerTableRecord instance.
+     *
+     * @param attrs - Input attribute values for this layer table record
+     * @param defaultAttrs - Default values for attributes of this layer table record
+     *
+     * @example
+     * ```typescript
+     * const layer = new AcDbLayerTableRecord({
+     *   name: 'MyLayer',
+     *   color: new AcCmColor(255, 0, 0)
+     * });
+     * ```
+     */
+    function AcDbLayerTableRecord(attrs, defaultAttrs) {
+        var _this = this;
+        attrs = attrs || {};
+        defaults(attrs, {
+            color: new AcCmColor(),
+            description: '',
+            standardFlags: 0,
+            isHidden: false,
+            isInUse: true,
+            isOff: false,
+            isPlottable: true,
+            transparency: 0,
+            linetype: '',
+            lineWeight: 1,
+            materialId: -1
+        });
+        _this = _super.call(this, attrs, defaultAttrs) || this;
+        _this.attrs.events.attrChanged.addEventListener(function (args) {
+            _this.database.events.layerModified.dispatch({
+                database: _this.database,
+                layer: _this,
+                changes: args.object.changedAttributes()
+            });
+        });
+        return _this;
+    }
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "color", {
+        /**
+         * Gets or sets the color value of this layer.
+         *
+         * @returns The color of the layer
+         *
+         * @example
+         * ```typescript
+         * const color = layer.color;
+         * layer.color = new AcCmColor(255, 0, 0); // Red
+         * ```
+         */
+        get: function () {
+            return this.getAttr('color');
+        },
+        set: function (value) {
+            this.setAttr('color', value.clone());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "description", {
+        /**
+         * Gets or sets the description of this layer.
+         *
+         * @returns The description of the layer
+         *
+         * @example
+         * ```typescript
+         * const description = layer.description;
+         * layer.description = 'My custom layer';
+         * ```
+         */
+        get: function () {
+            return this.getAttr('description');
+        },
+        set: function (value) {
+            this.setAttr('description', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "standardFlags", {
+        /**
+         * Gets or sets the standard flags for this layer.
+         *
+         * Standard flags are bit-coded values:
+         * - 1 = Layer is frozen; otherwise layer is thawed
+         * - 2 = Layer is frozen by default in new viewports
+         * - 4 = Layer is locked
+         * - 16 = If set, table entry is externally dependent on an xref
+         * - 32 = If both this bit and bit 16 are set, the externally dependent xref has been successfully resolved
+         * - 64 = If set, the table entry was referenced by at least one entity in the drawing the last time the drawing was edited
+         *
+         * @returns The standard flags value
+         *
+         * @example
+         * ```typescript
+         * const flags = layer.standardFlags;
+         * layer.standardFlags = 1; // Freeze the layer
+         * ```
+         */
+        get: function () {
+            return this.getAttr('standardFlags');
+        },
+        set: function (value) {
+            this.setAttr('standardFlags', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "isFrozen", {
+        /**
+         * Gets or sets whether this layer is frozen.
+         *
+         * When a layer is frozen, its entities are not displayed and cannot be modified.
+         *
+         * @returns True if the layer is frozen, false otherwise
+         *
+         * @example
+         * ```typescript
+         * if (layer.isFrozen) {
+         *   console.log('Layer is frozen');
+         * }
+         * layer.isFrozen = true;
+         * ```
+         */
+        get: function () {
+            return (this.standardFlags & 0x01) == 1;
+        },
+        set: function (value) {
+            var flag = value ? 1 : 0;
+            this.standardFlags = this.standardFlags | flag;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "isHidden", {
+        /**
+         * Gets or sets whether this layer is hidden.
+         *
+         * When a layer is hidden, it isn't shown in the user interface of
+         * the host application, but entities on the layer are still displayed.
+         *
+         * @returns True if the layer is hidden, false otherwise
+         *
+         * @example
+         * ```typescript
+         * if (layer.isHidden) {
+         *   console.log('Layer is hidden from UI');
+         * }
+         * layer.isHidden = true;
+         * ```
+         */
+        get: function () {
+            return this.getAttr('isHidden');
+        },
+        set: function (value) {
+            this.setAttr('isHidden', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "isInUse", {
+        /**
+         * Gets or sets whether this layer is in use.
+         *
+         * A layer is considered in use if it contains entities or is referenced
+         * by other objects in the drawing.
+         *
+         * @returns True if the layer is in use, false otherwise
+         *
+         * @example
+         * ```typescript
+         * if (layer.isInUse) {
+         *   console.log('Layer contains entities');
+         * }
+         * ```
+         */
+        get: function () {
+            return this.getAttr('isInUse');
+        },
+        set: function (value) {
+            this.setAttr('isInUse', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "isLocked", {
+        /**
+         * Gets or sets whether this layer is locked.
+         *
+         * When a layer is locked, its entities cannot be modified but are still visible.
+         *
+         * @returns True if the layer is locked, false otherwise
+         *
+         * @example
+         * ```typescript
+         * if (layer.isLocked) {
+         *   console.log('Layer is locked');
+         * }
+         * layer.isLocked = true;
+         * ```
+         */
+        get: function () {
+            return (this.standardFlags & 0x04) == 4;
+        },
+        set: function (value) {
+            var flag = value ? 4 : 0;
+            this.standardFlags = this.standardFlags | flag;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "isOff", {
+        /**
+         * Gets or sets whether this layer is turned off.
+         *
+         * When a layer is turned off, its entities are not displayed but can still be modified.
+         *
+         * @returns True if the layer is turned off, false otherwise
+         *
+         * @example
+         * ```typescript
+         * if (layer.isOff) {
+         *   console.log('Layer is turned off');
+         * }
+         * layer.isOff = true;
+         * ```
+         */
+        get: function () {
+            return this.getAttr('isOff');
+        },
+        set: function (value) {
+            this.setAttr('isOff', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "isPlottable", {
+        /**
+         * Gets or sets whether this layer is plottable.
+         *
+         * When a layer is plottable, its entities will be included when the drawing is plotted or printed.
+         *
+         * @returns True if the layer is plottable, false otherwise
+         *
+         * @example
+         * ```typescript
+         * if (layer.isPlottable) {
+         *   console.log('Layer will be included in plots');
+         * }
+         * layer.isPlottable = false;
+         * ```
+         */
+        get: function () {
+            return this.getAttr('isPlottable');
+        },
+        set: function (value) {
+            this.setAttr('isPlottable', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "transparency", {
+        /**
+         * Gets or sets the transparency level of this layer.
+         *
+         * Transparency values range from 0 (opaque) to 1 (fully transparent).
+         *
+         * @returns The transparency level (0-1)
+         *
+         * @example
+         * ```typescript
+         * const transparency = layer.transparency;
+         * layer.transparency = 0.5; // 50% transparent
+         * ```
+         */
+        get: function () {
+            return this.getAttr('transparency');
+        },
+        set: function (value) {
+            this.setAttr('transparency', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "linetype", {
+        /**
+         * Gets or sets the linetype name for this layer.
+         *
+         * The linetype defines the pattern of dashes, dots, and spaces used
+         * to display lines and curves on this layer.
+         *
+         * @returns The linetype name
+         *
+         * @example
+         * ```typescript
+         * const linetype = layer.linetype;
+         * layer.linetype = 'DASHED';
+         * ```
+         */
+        get: function () {
+            return this.getAttr('linetype');
+        },
+        set: function (value) {
+            this.setAttr('linetype', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "lineWeight", {
+        /**
+         * Gets or sets the line weight for this layer.
+         *
+         * Line weight determines the thickness of lines and curves on this layer.
+         *
+         * @returns The line weight value
+         *
+         * @example
+         * ```typescript
+         * const weight = layer.lineWeight;
+         * layer.lineWeight = 2.0; // 2.0mm line weight
+         * ```
+         */
+        get: function () {
+            return this.getAttr('lineWeight');
+        },
+        set: function (value) {
+            this.setAttr('lineWeight', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbLayerTableRecord.prototype, "materialId", {
+        /**
+         * Gets or sets the material ID associated with this layer.
+         *
+         * Material IDs are used for rendering and visualization purposes.
+         *
+         * @returns The material ID
+         *
+         * @example
+         * ```typescript
+         * const materialId = layer.materialId;
+         * layer.materialId = 'concrete';
+         * ```
+         */
+        get: function () {
+            return this.getAttr('materialId');
+        },
+        set: function (value) {
+            this.setAttr('materialId', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AcDbLayerTableRecord;
+}(AcDbSymbolTableRecord));
+export { AcDbLayerTableRecord };
+//# sourceMappingURL=AcDbLayerTableRecord.js.map

package/lib/database/AcDbLayerTableRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcDbLayerTableRecord.js","sourceRoot":"","sources":["../../src/database/AcDbLayerTableRecord.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAEvD,OAAO,EACL,qBAAqB,EAEtB,MAAM,yBAAyB,CAAA;AAiChC;;;;;;;;;;;;;;;;GAgBG;AACH;IAA0C,wCAAgD;IACxF;;;;;;;;;;;;;OAaG;IACH,8BACE,KAA0C,EAC1C,YAAiD;QAFnD,iBA0BC;QAtBC,KAAK,GAAG,KAAK,IAAI,EAAE,CAAA;QACnB,QAAQ,CAAC,KAAK,EAAE;YACd,KAAK,EAAE,IAAI,SAAS,EAAE;YACtB,WAAW,EAAE,EAAE;YACf,aAAa,EAAE,CAAC;YAChB,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,KAAK;YACZ,WAAW,EAAE,IAAI;YACjB,YAAY,EAAE,CAAC;YACf,QAAQ,EAAE,EAAE;YACZ,UAAU,EAAE,CAAC;YACb,UAAU,EAAE,CAAC,CAAC;SACf,CAAC,CAAA;QACF,QAAA,MAAK,YAAC,KAAK,EAAE,YAAY,CAAC,SAAA;QAC1B,KAAI,CAAC,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,UAAA,IAAI;YACjD,KAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC;gBAC1C,QAAQ,EAAE,KAAI,CAAC,QAAQ;gBACvB,KAAK,EAAE,KAAI;gBACX,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE;aACzC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;;IACJ,CAAC;IAaD,sBAAI,uCAAK;QAXT;;;;;;;;;;WAUG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QAC9B,CAAC;aACD,UAAU,KAAgB;YACxB,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAA;QACtC,CAAC;;;OAHA;IAgBD,sBAAI,6CAAW;QAXf;;;;;;;;;;WAUG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAA;QACpC,CAAC;aACD,UAAgB,KAAa;YAC3B,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,KAAK,CAAC,CAAA;QACpC,CAAC;;;OAHA;IAwBD,sBAAI,+CAAa;QAnBjB;;;;;;;;;;;;;;;;;;WAkBG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;QACtC,CAAC;aACD,UAAkB,KAAa;YAC7B,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,KAAK,CAAC,CAAA;QACtC,CAAC;;;OAHA;IAoBD,sBAAI,0CAAQ;QAfZ;;;;;;;;;;;;;;WAcG;aACH;YACE,OAAO,CAAC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,CAAA;QACzC,CAAC;aACD,UAAa,KAAc;YACzB,IAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YAC1B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,GAAG,IAAI,CAAA;QAChD,CAAC;;;OAJA;IAsBD,sBAAI,0CAAQ;QAhBZ;;;;;;;;;;;;;;;WAeG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;QACjC,CAAC;aACD,UAAa,KAAc;YACzB,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAA;QACjC,CAAC;;;OAHA;IAoBD,sBAAI,yCAAO;QAfX;;;;;;;;;;;;;;WAcG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;QAChC,CAAC;aACD,UAAY,KAAc;YACxB,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;QAChC,CAAC;;;OAHA;IAoBD,sBAAI,0CAAQ;QAfZ;;;;;;;;;;;;;;WAcG;aACH;YACE,OAAO,CAAC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,CAAA;QACzC,CAAC;aACD,UAAa,KAAc;YACzB,IAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YAC1B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,GAAG,IAAI,CAAA;QAChD,CAAC;;;OAJA;IAqBD,sBAAI,uCAAK;QAfT;;;;;;;;;;;;;;WAcG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QAC9B,CAAC;aACD,UAAU,KAAc;YACtB,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QAC9B,CAAC;;;OAHA;IAoBD,sBAAI,6CAAW;QAff;;;;;;;;;;;;;;WAcG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAA;QACpC,CAAC;aACD,UAAgB,KAAc;YAC5B,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,KAAK,CAAC,CAAA;QACpC,CAAC;;;OAHA;IAkBD,sBAAI,8CAAY;QAbhB;;;;;;;;;;;;WAYG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAA;QACrC,CAAC;aACD,UAAiB,KAAa;YAC5B,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,KAAK,CAAC,CAAA;QACrC,CAAC;;;OAHA;IAmBD,sBAAI,0CAAQ;QAdZ;;;;;;;;;;;;;WAaG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;QACjC,CAAC;aACD,UAAa,KAAa;YACxB,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAA;QACjC,CAAC;;;OAHA;IAkBD,sBAAI,4CAAU;QAbd;;;;;;;;;;;;WAYG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAA;QACnC,CAAC;aACD,UAAe,KAAa;YAC1B,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,CAAA;QACnC,CAAC;;;OAHA;IAkBD,sBAAI,4CAAU;QAbd;;;;;;;;;;;;WAYG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAA;QACnC,CAAC;aACD,UAAe,KAAa;YAC1B,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,CAAA;QACnC,CAAC;;;OAHA;IAIH,2BAAC;AAAD,CAAC,AAhUD,CAA0C,qBAAqB,GAgU9D"}

package/lib/database/AcDbLinetypeTable.d.ts

@@ -0,0 +1,30 @@
+import { AcDbDatabase } from './AcDbDatabase';
+import { AcDbLinetypeTableRecord } from './AcDbLinetypeTableRecord';
+import { AcDbSymbolTable } from './AcDbSymbolTable';
+/**
+ * Symbol table for linetype table records.
+ *
+ * This class manages linetype table records which represent line types within a
+ * drawing database. Line types define the pattern of dashes, dots, and spaces
+ * used to display lines and curves in the drawing.
+ *
+ * @example
+ * ```typescript
+ * const linetypeTable = new AcDbLinetypeTable(database);
+ * const linetype = linetypeTable.getAt('Continuous');
+ * ```
+ */
+export declare class AcDbLinetypeTable extends AcDbSymbolTable<AcDbLinetypeTableRecord> {
+    /**
+     * Creates a new AcDbLinetypeTable instance.
+     *
+     * @param db - The database this linetype table belongs to
+     *
+     * @example
+     * ```typescript
+     * const linetypeTable = new AcDbLinetypeTable(database);
+     * ```
+     */
+    constructor(db: AcDbDatabase);
+}
+//# sourceMappingURL=AcDbLinetypeTable.d.ts.map

package/lib/database/AcDbLinetypeTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcDbLinetypeTable.d.ts","sourceRoot":"","sources":["../../src/database/AcDbLinetypeTable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAA;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAEnD;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAkB,SAAQ,eAAe,CAAC,uBAAuB,CAAC;IAC7E;;;;;;;;;OASG;gBACS,EAAE,EAAE,YAAY;CAG7B"}

package/lib/database/AcDbLinetypeTable.js

@@ -0,0 +1,48 @@
+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 __());
+    };
+})();
+import { AcDbSymbolTable } from './AcDbSymbolTable';
+/**
+ * Symbol table for linetype table records.
+ *
+ * This class manages linetype table records which represent line types within a
+ * drawing database. Line types define the pattern of dashes, dots, and spaces
+ * used to display lines and curves in the drawing.
+ *
+ * @example
+ * ```typescript
+ * const linetypeTable = new AcDbLinetypeTable(database);
+ * const linetype = linetypeTable.getAt('Continuous');
+ * ```
+ */
+var AcDbLinetypeTable = /** @class */ (function (_super) {
+    __extends(AcDbLinetypeTable, _super);
+    /**
+     * Creates a new AcDbLinetypeTable instance.
+     *
+     * @param db - The database this linetype table belongs to
+     *
+     * @example
+     * ```typescript
+     * const linetypeTable = new AcDbLinetypeTable(database);
+     * ```
+     */
+    function AcDbLinetypeTable(db) {
+        return _super.call(this, db) || this;
+    }
+    return AcDbLinetypeTable;
+}(AcDbSymbolTable));
+export { AcDbLinetypeTable };
+//# sourceMappingURL=AcDbLinetypeTable.js.map

package/lib/database/AcDbLinetypeTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcDbLinetypeTable.js","sourceRoot":"","sources":["../../src/database/AcDbLinetypeTable.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAEnD;;;;;;;;;;;;GAYG;AACH;IAAuC,qCAAwC;IAC7E;;;;;;;;;OASG;IACH,2BAAY,EAAgB;QAC1B,OAAA,MAAK,YAAC,EAAE,CAAC,SAAA;IACX,CAAC;IACH,wBAAC;AAAD,CAAC,AAdD,CAAuC,eAAe,GAcrD"}

package/lib/database/AcDbLinetypeTableRecord.d.ts

@@ -0,0 +1,79 @@
+import { AcGiBaseLineStyle } from '@mlightcad/graphic-interface';
+import { AcDbSymbolTableRecord } from './AcDbSymbolTableRecord';
+/**
+ * Represents a record in the line type table within the AutoCAD drawing database.
+ *
+ * Each line type table record contains the information necessary to define a specific line type,
+ * including its pattern, description, and rendering characteristics. Line types define how lines
+ * are drawn, including patterns of dashes, dots, and spaces.
+ *
+ * Within the line type table record, the dashes (line segments that make up characteristics of the
+ * linetype) are stored in a list with an index that is zero based. If the linetype is complex, then
+ * embedded shapes or text strings are stored in the list at the same index as the dash that preceded
+ * them in the linetype definition. So there will always be a dashLength for any valid index in the
+ * list, even if there is a shape or text string sharing the same index. When the linetype is elaborated,
+ * a shape's insertion point will coincide with the end of the dash that it shares an index with.
+ */
+export declare class AcDbLinetypeTableRecord extends AcDbSymbolTableRecord {
+    private _linetype;
+    /**
+     * Creates a new line type table record.
+     *
+     * @param linetype - The line type style object that defines the visual characteristics
+     *                   and pattern of this line type
+     */
+    constructor(linetype: AcGiBaseLineStyle);
+    /**
+     * Gets the number of dash elements in the line type pattern.
+     *
+     * This value represents the total count of dashes, spaces, dots, and other pattern elements
+     * that make up the line type. It corresponds to DXF group code 73 in the AutoCAD file format.
+     *
+     * @returns The number of pattern elements in the line type
+     */
+    get numDashes(): number;
+    /**
+     * Gets the total pattern length in AutoCAD drawing units.
+     *
+     * The pattern length represents the total length of all dashes and spaces when the line type
+     * scale is 1.0. This value is used to calculate how the pattern repeats along a line.
+     *
+     * Note: Embedded shapes or text strings do not add to the pattern length because they are
+     * overlaid and do not interrupt the actual dash pattern.
+     *
+     * @returns The total length of the line type pattern in drawing units
+     */
+    get patternLength(): number;
+    /**
+     * Gets the description or comments associated with this line type.
+     *
+     * This property provides additional information about the line type, such as its intended
+     * use or any special characteristics.
+     *
+     * @returns The description text for the line type
+     */
+    get comments(): string;
+    /**
+     * Gets the line type style object used by the renderer.
+     *
+     * This property provides access to the underlying line type definition that contains
+     * all the visual characteristics and rendering information.
+     *
+     * @returns The line type style object
+     */
+    get linetype(): AcGiBaseLineStyle;
+    /**
+     * Gets the length of a specific dash element in the line type pattern.
+     *
+     * Each dash element in the pattern has a specific length that determines how it appears
+     * when the line type is rendered. Positive values represent visible dashes, while negative
+     * values represent spaces (pen up).
+     *
+     * @param index - Zero-based index of the dash element. Must be greater than or equal to zero,
+     *                but less than the value of property 'numDashes'
+     * @returns The length of the specified dash element in drawing units
+     * @throws {Error} When the index is out of range
+     */
+    dashLengthAt(index: number): number;
+}
+//# sourceMappingURL=AcDbLinetypeTableRecord.d.ts.map

package/lib/database/AcDbLinetypeTableRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcDbLinetypeTableRecord.d.ts","sourceRoot":"","sources":["../../src/database/AcDbLinetypeTableRecord.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AAEhE,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AAE/D;;;;;;;;;;;;;GAaG;AACH,qBAAa,uBAAwB,SAAQ,qBAAqB;IAChE,OAAO,CAAC,SAAS,CAAmB;IAEpC;;;;;OAKG;gBACS,QAAQ,EAAE,iBAAiB;IAMvC;;;;;;;OAOG;IACH,IAAI,SAAS,WAEZ;IAED;;;;;;;;;;OAUG;IACH,IAAI,aAAa,WAEhB;IAED;;;;;;;OAOG;IACH,IAAI,QAAQ,WAEX;IAED;;;;;;;OAOG;IACH,IAAI,QAAQ,sBAEX;IAED;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM;CAQ3B"}