@mlightcad/data-model 1.3.1 → 1.3.3

package/lib/entity/AcDbArc.js

@@ -1,340 +0,0 @@
-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 { AcGeCircArc3d, AcGeVector3d } from '@mlightcad/geometry-engine';
-import { AcDbCurve } from './AcDbCurve';
-/**
- * Represents an arc entity in AutoCAD.
- *
- * An arc is a 2D geometric object defined by its center point, radius, start angle,
- * and end angle. Arcs are portions of circles that can be used to create curved
- * line segments in drawings. The arc is always drawn in the plane defined by its normal vector.
- *
- * @example
- * ```typescript
- * // Create a 90-degree arc from 0 to π/2 radians
- * const arc = new AcDbArc(
- *   new AcGePoint3d(0, 0, 0),
- *   10,
- *   0,
- *   Math.PI / 2
- * );
- *
- * // Access arc properties
- * console.log(`Center: ${arc.center}`);
- * console.log(`Radius: ${arc.radius}`);
- * console.log(`Start angle: ${arc.startAngle}`);
- * console.log(`End angle: ${arc.endAngle}`);
- * ```
- */
-var AcDbArc = /** @class */ (function (_super) {
-    __extends(AcDbArc, _super);
-    /**
-     * Creates a new arc entity.
-     *
-     * This constructor creates an arc using the specified center point, radius,
-     * start angle, and end angle. The center point must be in World Coordinate
-     * System (WCS) coordinates. Angles are specified in radians.
-     *
-     * @param center - The center point of the arc in WCS coordinates
-     * @param radius - The radius of the arc (must be positive)
-     * @param startAngle - The starting angle in radians (0 to 2π)
-     * @param endAngle - The ending angle in radians (0 to 2π)
-     *
-     * @example
-     * ```typescript
-     * // Create a quarter circle arc (0 to 90 degrees)
-     * const quarterArc = new AcDbArc(
-     *   new AcGePoint3d(0, 0, 0),
-     *   15,
-     *   0,
-     *   Math.PI / 2
-     * );
-     *
-     * // Create a semicircle arc (0 to 180 degrees)
-     * const semicircle = new AcDbArc(
-     *   new AcGePoint3d(10, 20, 0),
-     *   25,
-     *   0,
-     *   Math.PI
-     * );
-     * ```
-     */
-    function AcDbArc(center, radius, startAngle, endAngle) {
-        var _this = _super.call(this) || this;
-        _this._geo = new AcGeCircArc3d(center, radius, startAngle, endAngle, AcGeVector3d.Z_AXIS, AcGeVector3d.X_AXIS);
-        return _this;
-    }
-    Object.defineProperty(AcDbArc.prototype, "center", {
-        /**
-         * Gets the center point of this arc.
-         *
-         * @returns The center point as a 3D point
-         *
-         * @example
-         * ```typescript
-         * const centerPoint = arc.center;
-         * console.log(`Arc center: ${centerPoint.x}, ${centerPoint.y}, ${centerPoint.z}`);
-         * ```
-         */
-        get: function () {
-            return this._geo.center;
-        },
-        /**
-         * Sets the center point of this arc.
-         *
-         * @param value - The new center point
-         *
-         * @example
-         * ```typescript
-         * arc.center = new AcGePoint3d(5, 5, 0);
-         * ```
-         */
-        set: function (value) {
-            this._geo.center = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AcDbArc.prototype, "radius", {
-        /**
-         * Gets the radius of this arc.
-         *
-         * @returns The radius value
-         *
-         * @example
-         * ```typescript
-         * const radius = arc.radius;
-         * console.log(`Arc radius: ${radius}`);
-         * ```
-         */
-        get: function () {
-            return this._geo.radius;
-        },
-        /**
-         * Sets the radius of this arc.
-         *
-         * @param value - The new radius value (must be positive)
-         *
-         * @example
-         * ```typescript
-         * arc.radius = 25;
-         * ```
-         */
-        set: function (value) {
-            this._geo.radius = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AcDbArc.prototype, "startAngle", {
-        /**
-         * Gets the start angle of this arc.
-         *
-         * @returns The start angle in radians
-         *
-         * @example
-         * ```typescript
-         * const startAngle = arc.startAngle;
-         * console.log(`Arc start angle: ${startAngle} radians (${startAngle * 180 / Math.PI} degrees)`);
-         * ```
-         */
-        get: function () {
-            return this._geo.startAngle;
-        },
-        /**
-         * Sets the start angle of this arc.
-         *
-         * @param value - The new start angle in radians (0 to 2π)
-         *
-         * @example
-         * ```typescript
-         * arc.startAngle = Math.PI / 4; // 45 degrees
-         * ```
-         */
-        set: function (value) {
-            this._geo.startAngle = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AcDbArc.prototype, "endAngle", {
-        /**
-         * Gets the end angle of this arc.
-         *
-         * @returns The end angle in radians
-         *
-         * @example
-         * ```typescript
-         * const endAngle = arc.endAngle;
-         * console.log(`Arc end angle: ${endAngle} radians (${endAngle * 180 / Math.PI} degrees)`);
-         * ```
-         */
-        get: function () {
-            return this._geo.endAngle;
-        },
-        /**
-         * Sets the end angle of this arc.
-         *
-         * @param value - The new end angle in radians (0 to 2π)
-         *
-         * @example
-         * ```typescript
-         * arc.endAngle = Math.PI; // 180 degrees
-         * ```
-         */
-        set: function (value) {
-            this._geo.endAngle = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AcDbArc.prototype, "startPoint", {
-        /**
-         * Gets the start point of this arc.
-         *
-         * The start point is calculated based on the center, radius, and start angle.
-         *
-         * @returns The start point as a 3D point
-         *
-         * @example
-         * ```typescript
-         * const startPoint = arc.startPoint;
-         * console.log(`Arc start point: ${startPoint.x}, ${startPoint.y}, ${startPoint.z}`);
-         * ```
-         */
-        get: function () {
-            return this._geo.startPoint;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AcDbArc.prototype, "endPoint", {
-        /**
-         * Gets the end point of this arc.
-         *
-         * The end point is calculated based on the center, radius, and end angle.
-         *
-         * @returns The end point as a 3D point
-         *
-         * @example
-         * ```typescript
-         * const endPoint = arc.endPoint;
-         * console.log(`Arc end point: ${endPoint.x}, ${endPoint.y}, ${endPoint.z}`);
-         * ```
-         */
-        get: function () {
-            return this._geo.endPoint;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AcDbArc.prototype, "geometricExtents", {
-        /**
-         * Gets the geometric extents (bounding box) of this arc.
-         *
-         * @returns The bounding box that encompasses the entire arc
-         *
-         * @example
-         * ```typescript
-         * const extents = arc.geometricExtents;
-         * console.log(`Arc bounds: ${extents.minPoint} to ${extents.maxPoint}`);
-         * ```
-         */
-        get: function () {
-            return this._geo.box;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AcDbArc.prototype, "closed", {
-        /**
-         * Gets whether this arc is closed.
-         *
-         * An arc is considered closed if the start and end angles are the same
-         * (forming a complete circle).
-         *
-         * @returns True if the arc is closed (forms a complete circle), false otherwise
-         */
-        get: function () {
-            return this._geo.closed;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Gets the grip points for this arc.
-     *
-     * Grip points are control points that can be used to modify the arc.
-     * For an arc, the grip points are the center point, start point, and end point.
-     *
-     * @returns Array of grip points (center, start point, end point)
-     *
-     * @example
-     * ```typescript
-     * const gripPoints = arc.subGetGripPoints();
-     * // gripPoints contains: [center, startPoint, endPoint]
-     * ```
-     */
-    AcDbArc.prototype.subGetGripPoints = function () {
-        var gripPoints = new Array();
-        gripPoints.push(this.center);
-        gripPoints.push(this.startPoint);
-        gripPoints.push(this.endPoint);
-        return gripPoints;
-    };
-    /**
-     * Transforms this arc by the specified matrix.
-     *
-     * This method applies a geometric transformation to the arc, updating
-     * the center point, radius, and angles according to the transformation matrix.
-     *
-     * @param matrix - The transformation matrix to apply
-     * @returns This arc after transformation
-     *
-     * @example
-     * ```typescript
-     * const translationMatrix = AcGeMatrix3d.translation(10, 0, 0);
-     * arc.transformBy(translationMatrix);
-     * // Arc is now translated 10 units in the X direction
-     * ```
-     */
-    AcDbArc.prototype.transformBy = function (matrix) {
-        this._geo.transform(matrix);
-        return this;
-    };
-    /**
-     * Draws this arc using the specified renderer.
-     *
-     * This method renders the arc as a circular arc using the arc's
-     * current style properties.
-     *
-     * @param renderer - The renderer to use for drawing
-     * @returns The rendered arc entity, or undefined if drawing failed
-     *
-     * @example
-     * ```typescript
-     * const renderedArc = arc.draw(renderer);
-     * ```
-     */
-    AcDbArc.prototype.draw = function (renderer) {
-        return renderer.circularArc(this._geo, this.lineStyle);
-    };
-    /** The entity type name */
-    AcDbArc.typeName = 'Arc';
-    return AcDbArc;
-}(AcDbCurve));
-export { AcDbArc };
-//# sourceMappingURL=AcDbArc.js.map

package/lib/entity/AcDbArc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AcDbArc.js","sourceRoot":"","sources":["../../src/entity/AcDbArc.ts"],"names":[],"mappings":"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"}

package/lib/entity/AcDbBlockReference.d.ts

@@ -1,190 +0,0 @@
-import { AcGeBox3d, AcGePoint3d, AcGeVector3d } from '@mlightcad/geometry-engine';
-import { AcGiEntity, AcGiRenderer } from '@mlightcad/graphic-interface';
-import { AcDbEntity } from './AcDbEntity';
-/**
- * Represents a block reference entity in AutoCAD.
- *
- * A block reference is used to place, size, and display an instance of the collection
- * of entities within the block table record that it references. Block references allow
- * you to reuse complex geometry by referencing a block definition multiple times with
- * different positions, rotations, and scales.
- *
- * @example
- * ```typescript
- * // Create a block reference
- * const blockRef = new AcDbBlockReference("MyBlock");
- * blockRef.position = new AcGePoint3d(10, 20, 0);
- * blockRef.rotation = Math.PI / 4; // 45 degrees
- * blockRef.scaleFactors = new AcGePoint3d(2, 2, 1); // 2x scale
- *
- * // Access block reference properties
- * console.log(`Block name: ${blockRef.blockTableRecord?.name}`);
- * console.log(`Position: ${blockRef.position}`);
- * console.log(`Rotation: ${blockRef.rotation}`);
- * ```
- */
-export declare class AcDbBlockReference extends AcDbEntity {
-    /** The entity type name */
-    static typeName: string;
-    /** The WCS position point (insertion point) of the block reference */
-    private _position;
-    /** The rotation value in radians */
-    private _rotation;
-    /** The X, Y, and Z scale factors for the block reference */
-    private _scaleFactors;
-    /** The normal vector of the plane containing the block reference */
-    private _normal;
-    /** The name of the referenced block */
-    private _blockName;
-    /**
-     * Creates a new block reference entity.
-     *
-     * This constructor initializes a block reference with the specified block name.
-     * The position is set to the origin, rotation to 0, normal to Z-axis, and scale factors to 1.
-     *
-     * @param blockName - The name of the block table record to reference
-     *
-     * @example
-     * ```typescript
-     * const blockRef = new AcDbBlockReference("MyBlock");
-     * blockRef.position = new AcGePoint3d(5, 10, 0);
-     * blockRef.rotation = Math.PI / 6; // 30 degrees
-     * ```
-     */
-    constructor(blockName: string);
-    /**
-     * Gets the WCS position point (insertion point) of the block reference.
-     *
-     * @returns The position point in WCS coordinates
-     *
-     * @example
-     * ```typescript
-     * const position = blockRef.position;
-     * console.log(`Block position: ${position.x}, ${position.y}, ${position.z}`);
-     * ```
-     */
-    get position(): AcGePoint3d;
-    /**
-     * Sets the WCS position point (insertion point) of the block reference.
-     *
-     * @param value - The new position point
-     *
-     * @example
-     * ```typescript
-     * blockRef.position = new AcGePoint3d(15, 25, 0);
-     * ```
-     */
-    set position(value: AcGePoint3d);
-    /**
-     * Gets the rotation value of the block reference.
-     *
-     * The rotation value is relative to the X axis of a coordinate system that is parallel
-     * to the OCS of the block reference, but has its origin at the position point of the
-     * block reference. The rotation axis is the Z axis of this coordinate system with
-     * positive rotations going counterclockwise when looking down the Z axis towards the origin.
-     *
-     * @returns The rotation value in radians
-     *
-     * @example
-     * ```typescript
-     * const rotation = blockRef.rotation;
-     * console.log(`Rotation: ${rotation} radians (${rotation * 180 / Math.PI} degrees)`);
-     * ```
-     */
-    get rotation(): number;
-    /**
-     * Sets the rotation value of the block reference.
-     *
-     * @param value - The new rotation value in radians
-     *
-     * @example
-     * ```typescript
-     * blockRef.rotation = Math.PI / 4; // 45 degrees
-     * ```
-     */
-    set rotation(value: number);
-    /**
-     * Gets the X, Y, and Z scale factors for the block reference.
-     *
-     * @returns The scale factors as a 3D point
-     *
-     * @example
-     * ```typescript
-     * const scaleFactors = blockRef.scaleFactors;
-     * console.log(`Scale factors: ${scaleFactors.x}, ${scaleFactors.y}, ${scaleFactors.z}`);
-     * ```
-     */
-    get scaleFactors(): AcGePoint3d;
-    /**
-     * Sets the X, Y, and Z scale factors for the block reference.
-     *
-     * @param value - The new scale factors
-     *
-     * @example
-     * ```typescript
-     * blockRef.scaleFactors = new AcGePoint3d(2, 1.5, 1); // 2x X scale, 1.5x Y scale
-     * ```
-     */
-    set scaleFactors(value: AcGePoint3d);
-    /**
-     * Gets the normal vector of the plane containing the block reference.
-     *
-     * @returns The normal vector
-     *
-     * @example
-     * ```typescript
-     * const normal = blockRef.normal;
-     * console.log(`Normal: ${normal.x}, ${normal.y}, ${normal.z}`);
-     * ```
-     */
-    get normal(): AcGeVector3d;
-    /**
-     * Sets the normal vector of the plane containing the block reference.
-     *
-     * @param value - The new normal vector
-     *
-     * @example
-     * ```typescript
-     * blockRef.normal = new AcGeVector3d(0, 0, 1);
-     * ```
-     */
-    set normal(value: AcGeVector3d);
-    /**
-     * Gets the block table record referenced by this block reference.
-     *
-     * The referenced block table record contains the entities that the block reference will display.
-     *
-     * @returns The block table record, or undefined if not found
-     *
-     * @example
-     * ```typescript
-     * const blockRecord = blockRef.blockTableRecord;
-     * if (blockRecord) {
-     *   console.log(`Block name: ${blockRecord.name}`);
-     * }
-     * ```
-     */
-    get blockTableRecord(): import("..").AcDbBlockTableRecord | undefined;
-    /**
-     * Gets the geometric extents (bounding box) of this block reference.
-     *
-     * This method calculates the bounding box by transforming the geometric extents
-     * of all entities in the referenced block according to the block reference's
-     * position, rotation, and scale factors.
-     *
-     * @returns The bounding box that encompasses the entire block reference
-     *
-     * @example
-     * ```typescript
-     * const extents = blockRef.geometricExtents;
-     * console.log(`Block bounds: ${extents.minPoint} to ${extents.maxPoint}`);
-     * ```
-     */
-    get geometricExtents(): AcGeBox3d;
-    /**
-     * @inheritdoc
-     */
-    draw(renderer: AcGiRenderer): AcGiEntity | undefined;
-    private computeTransformMatrix;
-}
-//# sourceMappingURL=AcDbBlockReference.d.ts.map

package/lib/entity/AcDbBlockReference.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AcDbBlockReference.d.ts","sourceRoot":"","sources":["../../src/entity/AcDbBlockReference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAGT,WAAW,EAEX,YAAY,EACb,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAGvE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,kBAAmB,SAAQ,UAAU;IAChD,2BAA2B;IAC3B,OAAgB,QAAQ,EAAE,MAAM,CAAmB;IAEnD,sEAAsE;IACtE,OAAO,CAAC,SAAS,CAAa;IAC9B,oCAAoC;IACpC,OAAO,CAAC,SAAS,CAAQ;IACzB,4DAA4D;IAC5D,OAAO,CAAC,aAAa,CAAa;IAClC,oEAAoE;IACpE,OAAO,CAAC,OAAO,CAAc;IAC7B,uCAAuC;IACvC,OAAO,CAAC,UAAU,CAAQ;IAE1B;;;;;;;;;;;;;;OAcG;gBACS,SAAS,EAAE,MAAM;IAS7B;;;;;;;;;;OAUG;IACH,IAAI,QAAQ,IAcQ,WAAW,CAZ9B;IAED;;;;;;;;;OASG;IACH,IAAI,QAAQ,CAAC,KAAK,EAAE,WAAW,EAE9B;IAED;;;;;;;;;;;;;;;OAeG;IACH,IAAI,QAAQ,IAcQ,MAAM,CAZzB;IAED;;;;;;;;;OASG;IACH,IAAI,QAAQ,CAAC,KAAK,EAAE,MAAM,EAEzB;IAED;;;;;;;;;;OAUG;IACH,IAAI,YAAY,IAcQ,WAAW,CAZlC;IAED;;;;;;;;;OASG;IACH,IAAI,YAAY,CAAC,KAAK,EAAE,WAAW,EAElC;IAED;;;;;;;;;;OAUG;IACH,IAAI,MAAM,IAcQ,YAAY,CAZ7B;IAED;;;;;;;;;OASG;IACH,IAAI,MAAM,CAAC,KAAK,EAAE,YAAY,EAE7B;IAED;;;;;;;;;;;;;;OAcG;IACH,IAAI,gBAAgB,kDAEnB;IAED;;;;;;;;;;;;;;OAcG;IACH,IAAI,gBAAgB,IAAI,SAAS,CAkBhC;IAED;;OAEG;IACH,IAAI,CAAC,QAAQ,EAAE,YAAY;IAsB3B,OAAO,CAAC,sBAAsB;CAS/B"}