@mlightcad/data-model 1.3.3 → 1.3.4

package/lib/entity/AcDbRay.d.ts

@@ -0,0 +1,150 @@
+import { AcGeBox3d, AcGePoint3d } from '@mlightcad/geometry-engine';
+import { AcGiRenderer } from '@mlightcad/graphic-interface';
+import { AcDbCurve } from './AcDbCurve';
+/**
+ * Represents a ray entity in AutoCAD.
+ *
+ * A ray is a 3D geometric object that extends infinitely in one direction from a base point.
+ * Rays are commonly used for construction lines, reference lines, and temporary geometry.
+ * Unlike lines, rays have no end point and extend to infinity.
+ *
+ * @example
+ * ```typescript
+ * // Create a ray from origin in the positive X direction
+ * const ray = new AcDbRay();
+ * ray.basePoint = new AcGePoint3d(0, 0, 0);
+ * ray.unitDir = new AcGeVector3d(1, 0, 0);
+ *
+ * // Access ray properties
+ * console.log(`Base point: ${ray.basePoint}`);
+ * console.log(`Unit direction: ${ray.unitDir}`);
+ * ```
+ */
+export declare class AcDbRay extends AcDbCurve {
+    /** The entity type name */
+    static typeName: string;
+    /** The base point of the ray */
+    private _basePoint;
+    /** The unit direction vector of the ray */
+    private _unitDir;
+    /**
+     * Creates a new ray entity.
+     *
+     * This constructor initializes a ray with default values.
+     * The base point is at the origin and the unit direction is undefined.
+     *
+     * @example
+     * ```typescript
+     * const ray = new AcDbRay();
+     * ray.basePoint = new AcGePoint3d(5, 10, 0);
+     * ray.unitDir = new AcGeVector3d(0, 1, 0); // Positive Y direction
+     * ```
+     */
+    constructor();
+    /**
+     * Gets the base point of this ray.
+     *
+     * The base point is the starting point from which the ray extends infinitely.
+     *
+     * @returns The base point as a 3D point
+     *
+     * @example
+     * ```typescript
+     * const basePoint = ray.basePoint;
+     * console.log(`Ray base point: ${basePoint.x}, ${basePoint.y}, ${basePoint.z}`);
+     * ```
+     */
+    get basePoint(): AcGePoint3d;
+    /**
+     * Sets the base point of this ray.
+     *
+     * @param value - The new base point
+     *
+     * @example
+     * ```typescript
+     * ray.basePoint = new AcGePoint3d(10, 20, 0);
+     * ```
+     */
+    set basePoint(value: AcGePoint3d);
+    /**
+     * Gets the unit direction vector of this ray.
+     *
+     * The unit direction vector defines the direction in which the ray extends
+     * infinitely from the base point.
+     *
+     * @returns The unit direction vector
+     *
+     * @example
+     * ```typescript
+     * const unitDir = ray.unitDir;
+     * console.log(`Ray direction: ${unitDir.x}, ${unitDir.y}, ${unitDir.z}`);
+     * ```
+     */
+    get unitDir(): AcGePoint3d;
+    /**
+     * Sets the unit direction vector of this ray.
+     *
+     * @param value - The new unit direction vector
+     *
+     * @example
+     * ```typescript
+     * ray.unitDir = new AcGeVector3d(0, 0, 1); // Positive Z direction
+     * ```
+     */
+    set unitDir(value: AcGePoint3d);
+    /**
+     * Gets whether this ray is closed.
+     *
+     * Rays are always open entities, so this always returns false.
+     *
+     * @returns Always false for rays
+     */
+    get closed(): boolean;
+    /**
+     * Gets the geometric extents (bounding box) of this ray.
+     *
+     * Since rays extend infinitely, this method returns a bounding box that
+     * encompasses a finite portion of the ray for practical purposes.
+     *
+     * @returns The bounding box that encompasses a portion of the ray
+     *
+     * @example
+     * ```typescript
+     * const extents = ray.geometricExtents;
+     * console.log(`Ray bounds: ${extents.minPoint} to ${extents.maxPoint}`);
+     * ```
+     */
+    get geometricExtents(): AcGeBox3d;
+    /**
+     * Gets the grip points for this ray.
+     *
+     * Grip points are control points that can be used to modify the ray.
+     * For a ray, the grip point is the base point.
+     *
+     * @returns Array of grip points (base point)
+     *
+     * @example
+     * ```typescript
+     * const gripPoints = ray.subGetGripPoints();
+     * // gripPoints contains: [basePoint]
+     * ```
+     */
+    subGetGripPoints(): AcGePoint3d[];
+    /**
+     * Draws this ray using the specified renderer.
+     *
+     * This method renders the ray as a line segment extending from the base point
+     * in the direction of the unit vector. For practical purposes, the ray is
+     * drawn with a finite length.
+     *
+     * @param renderer - The renderer to use for drawing
+     * @returns The rendered ray entity, or undefined if drawing failed
+     *
+     * @example
+     * ```typescript
+     * const renderedRay = ray.draw(renderer);
+     * ```
+     */
+    draw(renderer: AcGiRenderer): import("@mlightcad/graphic-interface").AcGiEntity;
+}
+//# sourceMappingURL=AcDbRay.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AcDbRay.d.ts","sourceRoot":"","sources":["../../src/entity/AcDbRay.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,WAAW,EAEZ,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAE3D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,OAAQ,SAAQ,SAAS;IACpC,2BAA2B;IAC3B,OAAgB,QAAQ,EAAE,MAAM,CAAQ;IAExC,gCAAgC;IAChC,OAAO,CAAC,UAAU,CAAa;IAC/B,2CAA2C;IAC3C,OAAO,CAAC,QAAQ,CAAc;IAE9B;;;;;;;;;;;;OAYG;;IAOH;;;;;;;;;;;;OAYG;IACH,IAAI,SAAS,IAcQ,WAAW,CAZ/B;IAED;;;;;;;;;OASG;IACH,IAAI,SAAS,CAAC,KAAK,EAAE,WAAW,EAE/B;IAED;;;;;;;;;;;;;OAaG;IACH,IAAI,OAAO,IAcQ,WAAW,CAZ7B;IAED;;;;;;;;;OASG;IACH,IAAI,OAAO,CAAC,KAAK,EAAE,WAAW,EAE7B;IAED;;;;;;OAMG;IACH,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED;;;;;;;;;;;;;OAaG;IACH,IAAI,gBAAgB,IAAI,SAAS,CAShC;IAED;;;;;;;;;;;;;OAaG;IACH,gBAAgB;IAMhB;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAC,QAAQ,EAAE,YAAY;CAQ5B"}

package/lib/entity/AcDbRay.js

@@ -0,0 +1,208 @@
+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 { AcGeBox3d, AcGePoint3d, AcGeVector3d } from '@mlightcad/geometry-engine';
+import { AcDbCurve } from './AcDbCurve';
+/**
+ * Represents a ray entity in AutoCAD.
+ *
+ * A ray is a 3D geometric object that extends infinitely in one direction from a base point.
+ * Rays are commonly used for construction lines, reference lines, and temporary geometry.
+ * Unlike lines, rays have no end point and extend to infinity.
+ *
+ * @example
+ * ```typescript
+ * // Create a ray from origin in the positive X direction
+ * const ray = new AcDbRay();
+ * ray.basePoint = new AcGePoint3d(0, 0, 0);
+ * ray.unitDir = new AcGeVector3d(1, 0, 0);
+ *
+ * // Access ray properties
+ * console.log(`Base point: ${ray.basePoint}`);
+ * console.log(`Unit direction: ${ray.unitDir}`);
+ * ```
+ */
+var AcDbRay = /** @class */ (function (_super) {
+    __extends(AcDbRay, _super);
+    /**
+     * Creates a new ray entity.
+     *
+     * This constructor initializes a ray with default values.
+     * The base point is at the origin and the unit direction is undefined.
+     *
+     * @example
+     * ```typescript
+     * const ray = new AcDbRay();
+     * ray.basePoint = new AcGePoint3d(5, 10, 0);
+     * ray.unitDir = new AcGeVector3d(0, 1, 0); // Positive Y direction
+     * ```
+     */
+    function AcDbRay() {
+        var _this = _super.call(this) || this;
+        _this._basePoint = new AcGePoint3d();
+        _this._unitDir = new AcGeVector3d();
+        return _this;
+    }
+    Object.defineProperty(AcDbRay.prototype, "basePoint", {
+        /**
+         * Gets the base point of this ray.
+         *
+         * The base point is the starting point from which the ray extends infinitely.
+         *
+         * @returns The base point as a 3D point
+         *
+         * @example
+         * ```typescript
+         * const basePoint = ray.basePoint;
+         * console.log(`Ray base point: ${basePoint.x}, ${basePoint.y}, ${basePoint.z}`);
+         * ```
+         */
+        get: function () {
+            return this._basePoint;
+        },
+        /**
+         * Sets the base point of this ray.
+         *
+         * @param value - The new base point
+         *
+         * @example
+         * ```typescript
+         * ray.basePoint = new AcGePoint3d(10, 20, 0);
+         * ```
+         */
+        set: function (value) {
+            this._basePoint.copy(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbRay.prototype, "unitDir", {
+        /**
+         * Gets the unit direction vector of this ray.
+         *
+         * The unit direction vector defines the direction in which the ray extends
+         * infinitely from the base point.
+         *
+         * @returns The unit direction vector
+         *
+         * @example
+         * ```typescript
+         * const unitDir = ray.unitDir;
+         * console.log(`Ray direction: ${unitDir.x}, ${unitDir.y}, ${unitDir.z}`);
+         * ```
+         */
+        get: function () {
+            return this._unitDir;
+        },
+        /**
+         * Sets the unit direction vector of this ray.
+         *
+         * @param value - The new unit direction vector
+         *
+         * @example
+         * ```typescript
+         * ray.unitDir = new AcGeVector3d(0, 0, 1); // Positive Z direction
+         * ```
+         */
+        set: function (value) {
+            this._unitDir.copy(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbRay.prototype, "closed", {
+        /**
+         * Gets whether this ray is closed.
+         *
+         * Rays are always open entities, so this always returns false.
+         *
+         * @returns Always false for rays
+         */
+        get: function () {
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbRay.prototype, "geometricExtents", {
+        /**
+         * Gets the geometric extents (bounding box) of this ray.
+         *
+         * Since rays extend infinitely, this method returns a bounding box that
+         * encompasses a finite portion of the ray for practical purposes.
+         *
+         * @returns The bounding box that encompasses a portion of the ray
+         *
+         * @example
+         * ```typescript
+         * const extents = ray.geometricExtents;
+         * console.log(`Ray bounds: ${extents.minPoint} to ${extents.maxPoint}`);
+         * ```
+         */
+        get: function () {
+            var extents = new AcGeBox3d();
+            extents.expandByPoint(this._unitDir.clone().multiplyScalar(10).add(this._basePoint));
+            extents.expandByPoint(this._unitDir.clone().multiplyScalar(-10).add(this._basePoint));
+            return extents;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Gets the grip points for this ray.
+     *
+     * Grip points are control points that can be used to modify the ray.
+     * For a ray, the grip point is the base point.
+     *
+     * @returns Array of grip points (base point)
+     *
+     * @example
+     * ```typescript
+     * const gripPoints = ray.subGetGripPoints();
+     * // gripPoints contains: [basePoint]
+     * ```
+     */
+    AcDbRay.prototype.subGetGripPoints = function () {
+        var gripPoints = new Array();
+        gripPoints.push(this.basePoint);
+        return gripPoints;
+    };
+    /**
+     * Draws this ray using the specified renderer.
+     *
+     * This method renders the ray as a line segment extending from the base point
+     * in the direction of the unit vector. For practical purposes, the ray is
+     * drawn with a finite length.
+     *
+     * @param renderer - The renderer to use for drawing
+     * @returns The rendered ray entity, or undefined if drawing failed
+     *
+     * @example
+     * ```typescript
+     * const renderedRay = ray.draw(renderer);
+     * ```
+     */
+    AcDbRay.prototype.draw = function (renderer) {
+        var points = [];
+        points.push(this.basePoint);
+        points.push(this._unitDir.clone().multiplyScalar(1000000).add(this._basePoint));
+        return renderer.lines(points, this.lineStyle);
+    };
+    /** The entity type name */
+    AcDbRay.typeName = 'Ray';
+    return AcDbRay;
+}(AcDbCurve));
+export { AcDbRay };
+//# sourceMappingURL=AcDbRay.js.map

package/lib/entity/AcDbRay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcDbRay.js","sourceRoot":"","sources":["../../src/entity/AcDbRay.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EACL,SAAS,EACT,WAAW,EACX,YAAY,EACb,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAA6B,2BAAS;IASpC;;;;;;;;;;;;OAYG;IACH;QACE,YAAA,MAAK,WAAE,SAAA;QACP,KAAI,CAAC,UAAU,GAAG,IAAI,WAAW,EAAE,CAAA;QACnC,KAAI,CAAC,QAAQ,GAAG,IAAI,YAAY,EAAE,CAAA;;IACpC,CAAC;IAeD,sBAAI,8BAAS;QAbb;;;;;;;;;;;;WAYG;aACH;YACE,OAAO,IAAI,CAAC,UAAU,CAAA;QACxB,CAAC;QAED;;;;;;;;;WASG;aACH,UAAc,KAAkB;YAC9B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAC7B,CAAC;;;OAdA;IA8BD,sBAAI,4BAAO;QAdX;;;;;;;;;;;;;WAaG;aACH;YACE,OAAO,IAAI,CAAC,QAAQ,CAAA;QACtB,CAAC;QAED;;;;;;;;;WASG;aACH,UAAY,KAAkB;YAC5B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC;;;OAdA;IAuBD,sBAAI,2BAAM;QAPV;;;;;;WAMG;aACH;YACE,OAAO,KAAK,CAAA;QACd,CAAC;;;OAAA;IAgBD,sBAAI,qCAAgB;QAdpB;;;;;;;;;;;;;WAaG;aACH;YACE,IAAM,OAAO,GAAG,IAAI,SAAS,EAAE,CAAA;YAC/B,OAAO,CAAC,aAAa,CACnB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAC9D,CAAA;YACD,OAAO,CAAC,aAAa,CACnB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAC/D,CAAA;YACD,OAAO,OAAO,CAAA;QAChB,CAAC;;;OAAA;IAED;;;;;;;;;;;;;OAaG;IACH,kCAAgB,GAAhB;QACE,IAAM,UAAU,GAAG,IAAI,KAAK,EAAe,CAAA;QAC3C,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QAC/B,OAAO,UAAU,CAAA;IACnB,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,sBAAI,GAAJ,UAAK,QAAsB;QACzB,IAAM,MAAM,GAAkB,EAAE,CAAA;QAChC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QAC3B,MAAM,CAAC,IAAI,CACT,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CACnE,CAAA;QACD,OAAO,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IAC/C,CAAC;IAxKD,2BAA2B;IACX,gBAAQ,GAAW,KAAK,CAAA;IAwK1C,cAAC;CAAA,AA1KD,CAA6B,SAAS,GA0KrC;SA1KY,OAAO"}

package/lib/entity/AcDbSpline.d.ts

@@ -0,0 +1,135 @@
+import { AcGeKnotParameterizationType, AcGePoint3dLike } from '@mlightcad/geometry-engine';
+import { AcGiRenderer } from '@mlightcad/graphic-interface';
+import { AcDbCurve } from './AcDbCurve';
+/**
+ * Represents a spline entity in AutoCAD.
+ *
+ * A spline is a 3D geometric object defined by control points or fit points.
+ * Splines are smooth curves that can be used to create complex curved shapes
+ * in drawings. They can be either open or closed curves.
+ *
+ * @example
+ * ```typescript
+ * // Create a spline from control points
+ * const controlPoints = [
+ *   new AcGePoint3d(0, 0, 0),
+ *   new AcGePoint3d(5, 5, 0),
+ *   new AcGePoint3d(10, 0, 0)
+ * ];
+ * const knots = [0, 0, 0, 1, 1, 1];
+ * const spline = new AcDbSpline(controlPoints, knots);
+ *
+ * // Create a spline from fit points
+ * const fitPoints = [
+ *   new AcGePoint3d(0, 0, 0),
+ *   new AcGePoint3d(5, 5, 0),
+ *   new AcGePoint3d(10, 0, 0)
+ * ];
+ * const spline2 = new AcDbSpline(fitPoints, AcGeKnotParameterizationType.Uniform);
+ * ```
+ */
+export declare class AcDbSpline extends AcDbCurve {
+    /** The entity type name */
+    static typeName: string;
+    /** The underlying geometric spline object */
+    private _geo;
+    /**
+     * Creates a new spline entity from control points.
+     *
+     * This constructor creates a spline using the specified control points, knots,
+     * and optional weights. The control points must be in World Coordinate System (WCS) coordinates.
+     *
+     * @param controlPoints - Array of control points in WCS coordinates
+     * @param knots - Array of knot values that define the spline's parameterization
+     * @param weights - Optional array of weights for each control point (default: 1 for all)
+     * @param degree - Optional degree of the spline (default: 3)
+     * @param closed - Whether the spline should be closed (default: false)
+     *
+     * @example
+     * ```typescript
+     * const controlPoints = [
+     *   new AcGePoint3d(0, 0, 0),
+     *   new AcGePoint3d(5, 5, 0),
+     *   new AcGePoint3d(10, 0, 0)
+     * ];
+     * const knots = [0, 0, 0, 1, 1, 1];
+     * const spline = new AcDbSpline(controlPoints, knots);
+     * ```
+     */
+    constructor(controlPoints: AcGePoint3dLike[], knots: number[], weights?: number[], degree?: number, closed?: boolean);
+    /**
+     * Creates a new spline entity from fit points.
+     *
+     * This constructor creates a spline that passes through the specified fit points.
+     * The fit points must be in World Coordinate System (WCS) coordinates.
+     *
+     * @param fitPoints - Array of fit points in WCS coordinates
+     * @param knotParam - Knot parameterization type that defines how knots are generated
+     * @param degree - Optional degree of the spline (default: 3)
+     * @param closed - Whether the spline should be closed (default: false)
+     *
+     * @example
+     * ```typescript
+     * const fitPoints = [
+     *   new AcGePoint3d(0, 0, 0),
+     *   new AcGePoint3d(5, 5, 0),
+     *   new AcGePoint3d(10, 0, 0)
+     * ];
+     * const spline = new AcDbSpline(fitPoints, AcGeKnotParameterizationType.Uniform);
+     * ```
+     */
+    constructor(fitPoints: AcGePoint3dLike[], knotParam: AcGeKnotParameterizationType, degree?: number, closed?: boolean);
+    /**
+     * Gets the geometric extents (bounding box) of this spline.
+     *
+     * @returns The bounding box that encompasses the entire spline
+     *
+     * @example
+     * ```typescript
+     * const extents = spline.geometricExtents;
+     * console.log(`Spline bounds: ${extents.minPoint} to ${extents.maxPoint}`);
+     * ```
+     */
+    get geometricExtents(): import("@mlightcad/geometry-engine").AcGeBox3d;
+    /**
+     * Gets whether this spline is closed.
+     *
+     * A closed spline forms a complete loop where the end point connects to the start point.
+     *
+     * @returns True if the spline is closed, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const isClosed = spline.closed;
+     * console.log(`Spline is closed: ${isClosed}`);
+     * ```
+     */
+    get closed(): boolean;
+    /**
+     * Sets whether this spline is closed.
+     *
+     * @param value - True to close the spline, false to open it
+     *
+     * @example
+     * ```typescript
+     * spline.closed = true; // Close the spline
+     * ```
+     */
+    set closed(value: boolean);
+    /**
+     * Draws this spline using the specified renderer.
+     *
+     * This method renders the spline as a series of connected line segments
+     * using the spline's current style properties.
+     *
+     * @param renderer - The renderer to use for drawing
+     * @returns The rendered spline entity, or undefined if drawing failed
+     *
+     * @example
+     * ```typescript
+     * const renderedSpline = spline.draw(renderer);
+     * ```
+     */
+    draw(renderer: AcGiRenderer): import("@mlightcad/graphic-interface").AcGiEntity;
+}
+//# sourceMappingURL=AcDbSpline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AcDbSpline.d.ts","sourceRoot":"","sources":["../../src/entity/AcDbSpline.ts"],"names":[],"mappings":"AACA,OAAO,EACL,4BAA4B,EAC5B,eAAe,EAEhB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAE3D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,UAAW,SAAQ,SAAS;IACvC,2BAA2B;IAC3B,OAAgB,QAAQ,EAAE,MAAM,CAAW;IAE3C,6CAA6C;IAC7C,OAAO,CAAC,IAAI,CAAc;IAE1B;;;;;;;;;;;;;;;;;;;;;;OAsBG;gBAED,aAAa,EAAE,eAAe,EAAE,EAChC,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,CAAC,EAAE,MAAM,EAAE,EAClB,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,OAAO;IAElB;;;;;;;;;;;;;;;;;;;;OAoBG;gBAED,SAAS,EAAE,eAAe,EAAE,EAC5B,SAAS,EAAE,4BAA4B,EACvC,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,OAAO;IAoClB;;;;;;;;;;OAUG;IACH,IAAI,gBAAgB,mDAEnB;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED;;;;;;;;;OASG;IACH,IAAI,MAAM,CAAC,KAAK,EAAE,OAAO,EAExB;IAED;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,QAAQ,EAAE,YAAY;CAI5B"}

package/lib/entity/AcDbSpline.js

@@ -0,0 +1,142 @@
+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 { AcCmErrors } from '@mlightcad/common';
+import { AcGeSpline3d } from '@mlightcad/geometry-engine';
+import { AcDbCurve } from './AcDbCurve';
+/**
+ * Represents a spline entity in AutoCAD.
+ *
+ * A spline is a 3D geometric object defined by control points or fit points.
+ * Splines are smooth curves that can be used to create complex curved shapes
+ * in drawings. They can be either open or closed curves.
+ *
+ * @example
+ * ```typescript
+ * // Create a spline from control points
+ * const controlPoints = [
+ *   new AcGePoint3d(0, 0, 0),
+ *   new AcGePoint3d(5, 5, 0),
+ *   new AcGePoint3d(10, 0, 0)
+ * ];
+ * const knots = [0, 0, 0, 1, 1, 1];
+ * const spline = new AcDbSpline(controlPoints, knots);
+ *
+ * // Create a spline from fit points
+ * const fitPoints = [
+ *   new AcGePoint3d(0, 0, 0),
+ *   new AcGePoint3d(5, 5, 0),
+ *   new AcGePoint3d(10, 0, 0)
+ * ];
+ * const spline2 = new AcDbSpline(fitPoints, AcGeKnotParameterizationType.Uniform);
+ * ```
+ */
+var AcDbSpline = /** @class */ (function (_super) {
+    __extends(AcDbSpline, _super);
+    function AcDbSpline(a, b, c, d, e) {
+        var _this = _super.call(this) || this;
+        var argsLength = +(a !== undefined) +
+            +(b !== undefined) +
+            +(c !== undefined) +
+            +(d !== undefined) +
+            +(e !== undefined);
+        if (argsLength < 2 || argsLength > 5) {
+            throw AcCmErrors.ILLEGAL_PARAMETERS;
+        }
+        // Determine if this is the fitPoints constructor (second arg is not an array)
+        var isFitPointsConstructor = !Array.isArray(b);
+        if (isFitPointsConstructor) {
+            _this._geo = new AcGeSpline3d(a, b, c, d);
+        }
+        else {
+            _this._geo = new AcGeSpline3d(a, b, c, d, e);
+        }
+        return _this;
+    }
+    Object.defineProperty(AcDbSpline.prototype, "geometricExtents", {
+        /**
+         * Gets the geometric extents (bounding box) of this spline.
+         *
+         * @returns The bounding box that encompasses the entire spline
+         *
+         * @example
+         * ```typescript
+         * const extents = spline.geometricExtents;
+         * console.log(`Spline bounds: ${extents.minPoint} to ${extents.maxPoint}`);
+         * ```
+         */
+        get: function () {
+            return this._geo.box;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbSpline.prototype, "closed", {
+        /**
+         * Gets whether this spline is closed.
+         *
+         * A closed spline forms a complete loop where the end point connects to the start point.
+         *
+         * @returns True if the spline is closed, false otherwise
+         *
+         * @example
+         * ```typescript
+         * const isClosed = spline.closed;
+         * console.log(`Spline is closed: ${isClosed}`);
+         * ```
+         */
+        get: function () {
+            return this._geo.closed;
+        },
+        /**
+         * Sets whether this spline is closed.
+         *
+         * @param value - True to close the spline, false to open it
+         *
+         * @example
+         * ```typescript
+         * spline.closed = true; // Close the spline
+         * ```
+         */
+        set: function (value) {
+            this._geo.closed = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Draws this spline using the specified renderer.
+     *
+     * This method renders the spline as a series of connected line segments
+     * using the spline's current style properties.
+     *
+     * @param renderer - The renderer to use for drawing
+     * @returns The rendered spline entity, or undefined if drawing failed
+     *
+     * @example
+     * ```typescript
+     * const renderedSpline = spline.draw(renderer);
+     * ```
+     */
+    AcDbSpline.prototype.draw = function (renderer) {
+        var points = this._geo.getPoints(100);
+        return renderer.lines(points, this.lineStyle);
+    };
+    /** The entity type name */
+    AcDbSpline.typeName = 'Spline';
+    return AcDbSpline;
+}(AcDbCurve));
+export { AcDbSpline };
+//# sourceMappingURL=AcDbSpline.js.map

package/lib/entity/AcDbSpline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcDbSpline.js","sourceRoot":"","sources":["../../src/entity/AcDbSpline.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAGL,YAAY,EACb,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAAgC,8BAAS;IAgEvC,oBAAY,CAAW,EAAE,CAAW,EAAE,CAAW,EAAE,CAAW,EAAE,CAAW;QACzE,YAAA,MAAK,WAAE,SAAA;QACP,IAAM,UAAU,GACd,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC;YAClB,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC;YAClB,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC;YAClB,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC;YAClB,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAA;QAEpB,IAAI,UAAU,GAAG,CAAC,IAAI,UAAU,GAAG,CAAC,EAAE,CAAC;YACrC,MAAM,UAAU,CAAC,kBAAkB,CAAA;QACrC,CAAC;QAED,8EAA8E;QAC9E,IAAM,sBAAsB,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;QAEhD,IAAI,sBAAsB,EAAE,CAAC;YAC3B,KAAI,CAAC,IAAI,GAAG,IAAI,YAAY,CAC1B,CAAsB,EACtB,CAAiC,EACjC,CAAuB,EACvB,CAAwB,CACzB,CAAA;QACH,CAAC;aAAM,CAAC;YACN,KAAI,CAAC,IAAI,GAAG,IAAI,YAAY,CAC1B,CAAsB,EACtB,CAAa,EACb,CAAyB,EACzB,CAAuB,EACvB,CAAwB,CACzB,CAAA;QACH,CAAC;;IACH,CAAC;IAaD,sBAAI,wCAAgB;QAXpB;;;;;;;;;;WAUG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAA;QACtB,CAAC;;;OAAA;IAeD,sBAAI,8BAAM;QAbV;;;;;;;;;;;;WAYG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAA;QACzB,CAAC;QAED;;;;;;;;;WASG;aACH,UAAW,KAAc;YACvB,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QAC1B,CAAC;;;OAdA;IAgBD;;;;;;;;;;;;;OAaG;IACH,yBAAI,GAAJ,UAAK,QAAsB;QACzB,IAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;QACvC,OAAO,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IAC/C,CAAC;IAhKD,2BAA2B;IACX,mBAAQ,GAAW,QAAQ,CAAA;IAgK7C,iBAAC;CAAA,AAlKD,CAAgC,SAAS,GAkKxC;SAlKY,UAAU"}