@bitbybit-dev/base 0.20.8 → 0.20.9

package/lib/api/inputs/base-inputs.d.ts

@@ -62,17 +62,17 @@ export declare namespace Base {
     type TransformMatrix = [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
     type TransformMatrixes = TransformMatrix[];
     enum horizontalAlignEnum {
-        /**
-         * Aligns to the left
-         */
         left = "left",
-        /**
-         * Aligns to the center
-         */
         center = "center",
-        /**
-         * Aligns to the right
-         */
         right = "right"
     }
+    enum verticalAlignmentEnum {
+        top = "top",
+        middle = "middle",
+        bottom = "bottom"
+    }
+    enum topBottomEnum {
+        top = "top",
+        bottom = "bottom"
+    }
 }

package/lib/api/inputs/base-inputs.js

@@ -3,17 +3,19 @@ export var Base;
 (function (Base) {
     let horizontalAlignEnum;
     (function (horizontalAlignEnum) {
-        /**
-         * Aligns to the left
-         */
         horizontalAlignEnum["left"] = "left";
-        /**
-         * Aligns to the center
-         */
         horizontalAlignEnum["center"] = "center";
-        /**
-         * Aligns to the right
-         */
         horizontalAlignEnum["right"] = "right";
     })(horizontalAlignEnum = Base.horizontalAlignEnum || (Base.horizontalAlignEnum = {}));
+    let verticalAlignmentEnum;
+    (function (verticalAlignmentEnum) {
+        verticalAlignmentEnum["top"] = "top";
+        verticalAlignmentEnum["middle"] = "middle";
+        verticalAlignmentEnum["bottom"] = "bottom";
+    })(verticalAlignmentEnum = Base.verticalAlignmentEnum || (Base.verticalAlignmentEnum = {}));
+    let topBottomEnum;
+    (function (topBottomEnum) {
+        topBottomEnum["top"] = "top";
+        topBottomEnum["bottom"] = "bottom";
+    })(topBottomEnum = Base.topBottomEnum || (Base.topBottomEnum = {}));
 })(Base || (Base = {}));

package/lib/api/inputs/index.d.ts

@@ -11,3 +11,4 @@ export * from "./dates-inputs";
 export * from "./line-inputs";
 export * from "./polyline-inputs";
 export * from "./mesh-inputs";
+export * from "./io-inputs";

package/lib/api/inputs/index.js

@@ -11,3 +11,4 @@ export * from "./dates-inputs";
 export * from "./line-inputs";
 export * from "./polyline-inputs";
 export * from "./mesh-inputs";
+export * from "./io-inputs";

package/lib/api/inputs/inputs.d.ts

@@ -11,3 +11,4 @@ export * from "./dates-inputs";
 export * from "./line-inputs";
 export * from "./polyline-inputs";
 export * from "./mesh-inputs";
+export * from "./io-inputs";

package/lib/api/inputs/inputs.js

@@ -11,3 +11,4 @@ export * from "./dates-inputs";
 export * from "./line-inputs";
 export * from "./polyline-inputs";
 export * from "./mesh-inputs";
+export * from "./io-inputs";

package/lib/api/inputs/io-inputs.d.ts

@@ -0,0 +1,153 @@
+import { Base } from "./base-inputs";
+export declare namespace IO {
+    /**
+     * Line segment defined by start and end points
+     */
+    class DxfLineSegmentDto {
+        constructor(start?: Base.Point2, end?: Base.Point2);
+        /**
+         * Start point of the line
+         * @default undefined
+         */
+        start: Base.Point2;
+        /**
+         * End point of the line
+         * @default undefined
+         */
+        end: Base.Point2;
+    }
+    /**
+     * Arc segment defined by center, radius, and start/end angles in degrees
+     */
+    class DxfArcSegmentDto {
+        constructor(center?: Base.Point2, radius?: number, startAngle?: number, endAngle?: number);
+        /**
+         * Center point of the arc
+         * @default undefined
+         */
+        center: Base.Point2;
+        /**
+         * Radius of the arc
+         * @default undefined
+         */
+        radius: number;
+        /**
+         * Start angle in degrees
+         * @default undefined
+         */
+        startAngle: number;
+        /**
+         * End angle in degrees (counter-clockwise from start angle)
+         * @default undefined
+         */
+        endAngle: number;
+    }
+    /**
+     * Circle defined by center and radius
+     */
+    class DxfCircleSegmentDto {
+        constructor(center?: Base.Point2, radius?: number);
+        /**
+         * Center point of the circle
+         * @default undefined
+         */
+        center: Base.Point2;
+        /**
+         * Radius of the circle
+         * @default undefined
+         */
+        radius: number;
+    }
+    /**
+     * Polyline segment defined by multiple points
+     * Can include bulge values to create arc segments between vertices
+     */
+    class DxfPolylineSegmentDto {
+        constructor(points?: Base.Point2[], closed?: boolean, bulges?: number[]);
+        /**
+         * Points defining the polyline vertices
+         * @default undefined
+         */
+        points: Base.Point2[];
+        /**
+         * Whether the polyline is closed
+         * @default false
+         */
+        closed?: boolean;
+        /**
+         * Bulge values for each vertex (optional)
+         * Bulge = tan(angle/4) where angle is the arc angle in radians
+         * Positive = counterclockwise, Negative = clockwise
+         * 0 = straight line segment
+         * Array length should match points length (or be undefined for all straight segments)
+         * @default undefined
+         */
+        bulges?: number[];
+    }
+    /**
+     * Spline/B-spline segment defined by control points and degree
+     */
+    class DxfSplineSegmentDto {
+        constructor(controlPoints?: Base.Point2[], degree?: number, closed?: boolean);
+        /**
+         * Control points defining the spline
+         * @default undefined
+         */
+        controlPoints: Base.Point2[];
+        /**
+         * Degree of the spline (typically 2 or 3)
+         * @default 3
+         */
+        degree?: number;
+        /**
+         * Whether the spline is closed
+         * @default false
+         */
+        closed?: boolean;
+    }
+    /**
+     * A path can contain multiple segments of different types (lines, arcs, polylines, circles, splines)
+     * Similar to OCCT wires that can combine different edge types
+     */
+    class DxfPathDto {
+        constructor(segments?: (DxfLineSegmentDto | DxfArcSegmentDto | DxfCircleSegmentDto | DxfPolylineSegmentDto | DxfSplineSegmentDto)[]);
+        /**
+         * Array of segments that make up this path
+         * Can include lines, arcs, circles, polylines, and splines
+         * @default undefined
+         */
+        segments: (DxfLineSegmentDto | DxfArcSegmentDto | DxfCircleSegmentDto | DxfPolylineSegmentDto | DxfSplineSegmentDto)[];
+    }
+    /**
+     * A part containing multiple paths on the same layer with the same color
+     */
+    class DxfPathsPartDto {
+        constructor(layer?: string, color?: Base.Color, paths?: DxfPathDto[]);
+        /**
+         * Layer name for all paths in this part
+         * @default Default
+         */
+        layer: string;
+        /**
+         * Color for all paths in this part
+         * @default #000000
+         */
+        color: Base.Color;
+        /**
+         * Array of paths, each containing multiple segments
+         * @default undefined
+         */
+        paths: DxfPathDto[];
+    }
+    /**
+     * Main DXF model containing all path parts
+     */
+    class DxfModelDto {
+        constructor(dxfPathsParts?: DxfPathsPartDto[]);
+        /**
+         * Array of path parts, each containing paths with segments
+         * @default undefined
+         */
+        dxfPathsParts: DxfPathsPartDto[];
+    }
+}

package/lib/api/inputs/io-inputs.js

@@ -0,0 +1,152 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+export var IO;
+(function (IO) {
+    /**
+     * Line segment defined by start and end points
+     */
+    class DxfLineSegmentDto {
+        constructor(start, end) {
+            if (start !== undefined) {
+                this.start = start;
+            }
+            if (end !== undefined) {
+                this.end = end;
+            }
+        }
+    }
+    IO.DxfLineSegmentDto = DxfLineSegmentDto;
+    /**
+     * Arc segment defined by center, radius, and start/end angles in degrees
+     */
+    class DxfArcSegmentDto {
+        constructor(center, radius, startAngle, endAngle) {
+            if (center !== undefined) {
+                this.center = center;
+            }
+            if (radius !== undefined) {
+                this.radius = radius;
+            }
+            if (startAngle !== undefined) {
+                this.startAngle = startAngle;
+            }
+            if (endAngle !== undefined) {
+                this.endAngle = endAngle;
+            }
+        }
+    }
+    IO.DxfArcSegmentDto = DxfArcSegmentDto;
+    /**
+     * Circle defined by center and radius
+     */
+    class DxfCircleSegmentDto {
+        constructor(center, radius) {
+            if (center !== undefined) {
+                this.center = center;
+            }
+            if (radius !== undefined) {
+                this.radius = radius;
+            }
+        }
+    }
+    IO.DxfCircleSegmentDto = DxfCircleSegmentDto;
+    /**
+     * Polyline segment defined by multiple points
+     * Can include bulge values to create arc segments between vertices
+     */
+    class DxfPolylineSegmentDto {
+        constructor(points, closed, bulges) {
+            /**
+             * Whether the polyline is closed
+             * @default false
+             */
+            this.closed = false;
+            if (points !== undefined) {
+                this.points = points;
+            }
+            if (closed !== undefined) {
+                this.closed = closed;
+            }
+            if (bulges !== undefined) {
+                this.bulges = bulges;
+            }
+        }
+    }
+    IO.DxfPolylineSegmentDto = DxfPolylineSegmentDto;
+    /**
+     * Spline/B-spline segment defined by control points and degree
+     */
+    class DxfSplineSegmentDto {
+        constructor(controlPoints, degree, closed) {
+            /**
+             * Degree of the spline (typically 2 or 3)
+             * @default 3
+             */
+            this.degree = 3;
+            /**
+             * Whether the spline is closed
+             * @default false
+             */
+            this.closed = false;
+            if (controlPoints !== undefined) {
+                this.controlPoints = controlPoints;
+            }
+            if (degree !== undefined) {
+                this.degree = degree;
+            }
+            if (closed !== undefined) {
+                this.closed = closed;
+            }
+        }
+    }
+    IO.DxfSplineSegmentDto = DxfSplineSegmentDto;
+    /**
+     * A path can contain multiple segments of different types (lines, arcs, polylines, circles, splines)
+     * Similar to OCCT wires that can combine different edge types
+     */
+    class DxfPathDto {
+        constructor(segments) {
+            if (segments !== undefined) {
+                this.segments = segments;
+            }
+        }
+    }
+    IO.DxfPathDto = DxfPathDto;
+    /**
+     * A part containing multiple paths on the same layer with the same color
+     */
+    class DxfPathsPartDto {
+        constructor(layer, color, paths) {
+            /**
+             * Layer name for all paths in this part
+             * @default Default
+             */
+            this.layer = "Default";
+            /**
+             * Color for all paths in this part
+             * @default #000000
+             */
+            this.color = "#000000";
+            if (layer !== undefined) {
+                this.layer = layer;
+            }
+            if (color !== undefined) {
+                this.color = color;
+            }
+            if (paths !== undefined) {
+                this.paths = paths;
+            }
+        }
+    }
+    IO.DxfPathsPartDto = DxfPathsPartDto;
+    /**
+     * Main DXF model containing all path parts
+     */
+    class DxfModelDto {
+        constructor(dxfPathsParts) {
+            if (dxfPathsParts !== undefined) {
+                this.dxfPathsParts = dxfPathsParts;
+            }
+        }
+    }
+    IO.DxfModelDto = DxfModelDto;
+})(IO || (IO = {}));

package/lib/api/models/simplex.d.ts

@@ -95,6 +95,33 @@ export declare const simplex: {
     124: number[];
     125: number[];
     126: number[];
+    176: number[];
+    178: number[];
+    179: number[];
+    181: number[];
+    185: number[];
+    188: number[];
+    189: number[];
+    190: number[];
+    215: number[];
+    247: number[];
+    177: number[];
+    8304: number[];
+    8308: number[];
+    8309: number[];
+    8310: number[];
+    8311: number[];
+    8312: number[];
+    8313: number[];
+    8320: number[];
+    8321: number[];
+    8322: number[];
+    8323: number[];
+    8324: number[];
+    8776: number[];
+    8730: number[];
+    8731: number[];
+    8732: number[];
 };
 export declare const defaultsVectorParams: {
     xOffset: number;
@@ -198,6 +225,33 @@ export declare const defaultsVectorParams: {
         124: number[];
         125: number[];
         126: number[];
+        176: number[];
+        178: number[];
+        179: number[];
+        181: number[];
+        185: number[];
+        188: number[];
+        189: number[];
+        190: number[];
+        215: number[];
+        247: number[];
+        177: number[];
+        8304: number[];
+        8308: number[];
+        8309: number[];
+        8310: number[];
+        8311: number[];
+        8312: number[];
+        8313: number[];
+        8320: number[];
+        8321: number[];
+        8322: number[];
+        8323: number[];
+        8324: number[];
+        8776: number[];
+        8730: number[];
+        8731: number[];
+        8732: number[];
     };
     height: number;
     lineSpacing: number;

package/lib/api/models/simplex.js

@@ -97,7 +97,63 @@ export const simplex = {
     123: [14, 9, 25, 7, 24, 6, 23, 5, 21, 5, 19, 6, 17, 7, 16, 8, 14, 8, 12, 6, 10, undefined, 7, 24, 6, 22, 6, 20, 7, 18, 8, 17, 9, 15, 9, 13, 8, 11, 4, 9, 8, 7, 9, 5, 9, 3, 8, 1, 7, 0, 6, -2, 6, -4, 7, -6, undefined, 6, 8, 8, 6, 8, 4, 7, 2, 6, 1, 5, -1, 5, -3, 6, -5, 7, -6, 9, -7],
     124: [8, 4, 25, 4, -7],
     125: [14, 5, 25, 7, 24, 8, 23, 9, 21, 9, 19, 8, 17, 7, 16, 6, 14, 6, 12, 8, 10, undefined, 7, 24, 8, 22, 8, 20, 7, 18, 6, 17, 5, 15, 5, 13, 6, 11, 10, 9, 6, 7, 5, 5, 5, 3, 6, 1, 7, 0, 8, -2, 8, -4, 7, -6, undefined, 8, 8, 6, 6, 6, 4, 7, 2, 8, 1, 9, -1, 9, -3, 8, -5, 7, -6, 5, -7],
-    126: [24, 3, 6, 3, 8, 4, 11, 6, 12, 8, 12, 10, 11, 14, 8, 16, 7, 18, 7, 20, 8, 21, 10, undefined, 3, 8, 4, 10, 6, 11, 8, 11, 10, 10, 14, 7, 16, 6, 18, 6, 20, 7, 21, 10, 21, 12]
+    126: [24, 3, 6, 3, 8, 4, 11, 6, 12, 8, 12, 10, 11, 14, 8, 16, 7, 18, 7, 20, 8, 21, 10, undefined, 3, 8, 4, 10, 6, 11, 8, 11, 10, 10, 14, 7, 16, 6, 18, 6, 20, 7, 21, 10, 21, 12],
+    // Extended characters for units and measurements
+    // 176: ° (degree symbol)
+    176: [14, 7, 21, 5, 20, 4, 18, 4, 16, 5, 14, 7, 13, 9, 14, 10, 16, 10, 18, 9, 20, 7, 21],
+    // 178: ² (superscript 2) - positioned at top, same size as other superscripts
+    178: [14, 5, 17, 5, 18, 6, 19, 7, 20, 9, 21, 10, 21, 11, 20, 12, 19, 12, 18, 11, 17, 10, 16, 6, 14, 12, 14],
+    // 179: ³ (superscript 3) - cleaner design matching ²
+    179: [14, 5, 21, 11, 21, 8, 18, 9, 18, 10, 17, 11, 16, 11, 15, 10, 14, 8, 14, 6, 15, 5, 16],
+    // 181: µ (micro symbol)
+    181: [19, 4, 14, 4, -7, undefined, 4, 14, 4, 4, 5, 1, 7, 0, 10, 0, 12, 1, 15, 4, undefined, 15, 14, 15, 0],
+    // 185: ¹ (superscript 1) - same size and position as ²
+    185: [14, 7, 19, 8, 20, 10, 21, 10, 14],
+    // 188: ¼ (one quarter) - slash going / direction (bottom-left to top-right)
+    188: [26, 4, 19, 5, 20, 7, 21, 7, 14, undefined, 6, 0, 18, 21, undefined, 16, 11, 16, 7, 22, 7, undefined, 18, 11, 18, 0, undefined, 16, 0, 22, 0],
+    // 189: ½ (one half) - slash going / direction (bottom-left to top-right)
+    189: [26, 4, 19, 5, 20, 7, 21, 7, 14, undefined, 6, 0, 18, 21, undefined, 15, 4, 15, 5, 16, 6, 17, 7, 19, 7, 20, 6, 20, 5, 19, 4, 17, 2, 15, 0, 21, 0],
+    // 190: ¾ (three quarters) - slash going / direction (bottom-left to top-right)
+    190: [26, 4, 21, 10, 21, 8, 18, 9, 18, 10, 17, 11, 16, 11, 15, 10, 14, 8, 14, 6, 15, 5, 16, undefined, 6, 0, 18, 21, undefined, 16, 11, 16, 7, 22, 7, undefined, 18, 11, 18, 0, undefined, 16, 0, 22, 0],
+    // 215: × (multiplication sign)
+    215: [18, 3, 15, 15, 3, undefined, 15, 15, 3, 3],
+    // 247: ÷ (division sign)
+    247: [22, 4, 9, 18, 9, undefined, 11, 15, 10, 14, 11, 13, 12, 14, 11, 15, undefined, 11, 5, 10, 4, 11, 3, 12, 4, 11, 5],
+    // Additional useful characters
+    // 177: ± (plus-minus) - better proportions
+    177: [26, 13, 18, 13, 6, undefined, 4, 12, 22, 12, undefined, 4, 3, 22, 3],
+    // 8304: ⁰ (superscript 0) - same size and position as other superscripts
+    8304: [14, 8, 21, 7, 20, 6, 19, 5, 17, 5, 15, 6, 14, 8, 14, 9, 14, 11, 15, 12, 17, 12, 19, 11, 20, 9, 21, 8, 21],
+    // 8308: ⁴ (superscript 4) - same size and position
+    8308: [14, 10, 21, 6, 17, 12, 17, undefined, 10, 21, 10, 14],
+    // 8309: ⁵ (superscript 5) - cleaner design
+    8309: [14, 11, 21, 6, 21, 5, 17, 6, 17, 7, 18, 9, 18, 10, 17, 11, 16, 11, 15, 10, 14, 8, 14, 6, 15, 5, 16],
+    // 8310: ⁶ (superscript 6) - same size and position
+    8310: [14, 11, 19, 10, 20, 9, 21, 7, 21, 6, 20, 5, 18, 5, 15, 6, 14, 8, 14, 9, 14, 10, 15, 11, 16, 11, 17, 10, 18, 9, 18, 8, 17, 7, 16, 6, 15],
+    // 8311: ⁷ (superscript 7) - same size and position
+    8311: [14, 11, 21, 7, 14, undefined, 5, 21, 11, 21],
+    // 8312: ⁸ (superscript 8) - same size and position
+    8312: [14, 8, 21, 7, 20, 6, 19, 6, 18, 7, 17, 8, 17, 9, 18, 10, 19, 10, 20, 9, 21, 8, 21, 7, 20, undefined, 8, 17, 7, 16, 6, 15, 6, 14, 7, 13, 8, 13, 9, 14, 10, 15, 10, 16, 9, 17],
+    // 8313: ⁹ (superscript 9) - same size and position
+    8313: [14, 10, 17, 9, 16, 8, 16, 7, 17, 6, 18, 6, 19, 7, 20, 8, 20, 9, 19, 10, 18, 10, 15, 9, 14, 7, 14, 6, 15, 5, 16],
+    // 8320: ₀ (subscript 0)
+    8320: [14, 8, 7, 7, 6, 6, 5, 5, 3, 5, 1, 6, 0, 8, 0, 9, 0, 11, 1, 12, 3, 12, 5, 11, 6, 9, 7, 8, 7],
+    // 8321: ₁ (subscript 1)
+    8321: [14, 7, 5, 8, 6, 10, 7, 10, 0],
+    // 8322: ₂ (subscript 2)
+    8322: [14, 5, 4, 5, 5, 6, 6, 7, 7, 9, 7, 10, 6, 11, 5, 11, 4, 10, 3, 9, 2, 6, 0, 12, 0],
+    // 8323: ₃ (subscript 3)
+    8323: [14, 5, 7, 11, 7, 8, 4, 10, 4, 11, 3, 12, 2, 12, 1, 11, 0, 9, 0, 7, 1, 6, 2, 5, 3],
+    // 8324: ₄ (subscript 4)
+    8324: [14, 10, 7, 6, 3, 12, 3, undefined, 10, 7, 10, 0],
+    // 8776: ≈ (approximately equal)
+    8776: [24, 3, 11, 4, 13, 6, 14, 8, 14, 10, 13, 14, 10, 16, 9, 18, 9, 20, 10, 21, 12, undefined, 3, 5, 4, 7, 6, 8, 8, 8, 10, 7, 14, 4, 16, 3, 18, 3, 20, 4, 21, 6],
+    // 8730: √ (square root) - fixed to look like a proper check mark with extension
+    8730: [20, 4, 12, 6, 8, 8, 0, undefined, 8, 0, 10, 21, undefined, 10, 21, 20, 21],
+    // 8731: ∛ (cube root) - with cleaner 3 indicator
+    8731: [24, 2, 21, 5, 21, 4, 19, 5, 18, 6, 17, 6, 16, 5, 15, 3, 15, 2, 16, undefined, 8, 12, 10, 8, 12, 0, undefined, 12, 0, 14, 21, undefined, 14, 21, 24, 21],
+    // 8732: ∜ (fourth root) - with 4 indicator same size as 3
+    8732: [24, 5, 21, 3, 18, 6, 18, undefined, 5, 21, 5, 15, undefined, 8, 12, 10, 8, 12, 0, undefined, 12, 0, 14, 21, undefined, 14, 21, 24, 21]
 };
 export const defaultsVectorParams = {
     xOffset: 0,

package/lib/api/services/helpers/dxf/dxf-generator.d.ts

@@ -0,0 +1,82 @@
+import * as Inputs from "../../../inputs";
+export declare class DxfGenerator {
+    private entityHandle;
+    /**
+     * Generate a complete DXF file content from path-based entities
+     */
+    generateDxf(dxfInputs: Inputs.IO.DxfModelDto): string;
+    /**
+     * Generate DXF header section
+     */
+    private generateHeader;
+    /**
+     * Generate DXF tables section (layers, line types, etc.)
+     */
+    private generateTables;
+    /**
+     * Generate layer table based on unique layers in all parts
+     */
+    private generateLayerTable;
+    /**
+     * Generate DXF entities section with all path segments
+     */
+    private generateEntities;
+    /**
+     * Generate entity for a single segment based on its type
+     */
+    private generateSegmentEntity;
+    /**
+     * Type guard for line segments
+     */
+    private isLineSegment;
+    /**
+     * Type guard for arc segments
+     */
+    private isArcSegment;
+    /**
+     * Type guard for circle segments
+     */
+    private isCircleSegment;
+    /**
+     * Type guard for polyline segments
+     */
+    private isPolylineSegment;
+    /**
+     * Type guard for spline segments
+     */
+    private isSplineSegment;
+    /**
+     * Generate a LINE entity
+     */
+    private generateLineEntity;
+    /**
+     * Generate a CIRCLE entity
+     */
+    private generateCircleEntity;
+    /**
+     * Generate an ARC entity
+     */
+    private generateArcEntity;
+    /**
+     * Generate a LWPOLYLINE entity
+     */
+    private generatePolylineEntity;
+    /**
+     * Generate a SPLINE entity
+     */
+    private generateSplineEntity;
+    /**
+     * Check if polyline should be closed (first and last points are the same)
+     */
+    private isClosedPolyline;
+    /**
+     * Get next entity handle as hex string
+     */
+    private getNextHandle;
+    /**
+     * Convert color to DXF format
+     * Accepts hex color (#RRGGBB) or ACI color index (1-255)
+     * Returns appropriate DXF color codes
+     */
+    private convertColorToDxf;
+}

package/lib/api/services/helpers/dxf/dxf-generator.js

@@ -0,0 +1,371 @@
+export class DxfGenerator {
+    constructor() {
+        this.entityHandle = 1;
+    }
+    /**
+     * Generate a complete DXF file content from path-based entities
+     */
+    generateDxf(dxfInputs) {
+        const dxfContent = [];
+        // Header section
+        dxfContent.push(...this.generateHeader());
+        // Tables section
+        dxfContent.push(...this.generateTables(dxfInputs));
+        // Entities section
+        dxfContent.push(...this.generateEntities(dxfInputs));
+        // End of file
+        dxfContent.push("0", "EOF");
+        return dxfContent.join("\n");
+    }
+    /**
+     * Generate DXF header section
+     */
+    generateHeader() {
+        return [
+            "0",
+            "SECTION",
+            "2",
+            "HEADER",
+            "9",
+            "$ACADVER",
+            "1",
+            "AC1015",
+            "9",
+            "$DWGCODEPAGE",
+            "3",
+            "ANSI_1252",
+            "9",
+            "$LASTSAVEDBY",
+            "1",
+            "bitbybit.dev",
+            "9",
+            "$HANDSEED",
+            "5",
+            "20000",
+            "0",
+            "ENDSEC"
+        ];
+    }
+    /**
+     * Generate DXF tables section (layers, line types, etc.)
+     */
+    generateTables(dxfInputs) {
+        const tables = [
+            "0",
+            "SECTION",
+            "2",
+            "TABLES"
+        ];
+        // Layer table
+        tables.push(...this.generateLayerTable(dxfInputs));
+        tables.push("0", "ENDSEC");
+        return tables;
+    }
+    /**
+     * Generate layer table based on unique layers in all parts
+     */
+    generateLayerTable(dxfInputs) {
+        const layers = new Set();
+        // Collect all unique layer names
+        if (dxfInputs.dxfPathsParts) {
+            dxfInputs.dxfPathsParts.forEach(part => {
+                if (part.layer) {
+                    layers.add(part.layer);
+                }
+            });
+        }
+        // Add default layer if no layers specified
+        if (layers.size === 0) {
+            layers.add("0");
+        }
+        const layerTable = [
+            "0",
+            "TABLE",
+            "2",
+            "LAYER",
+            "5",
+            "2",
+            "100",
+            "AcDbSymbolTable",
+            "70",
+            layers.size.toString()
+        ];
+        // Generate layer entries
+        layers.forEach(layerName => {
+            layerTable.push("0", "LAYER", "5", this.getNextHandle(), "100", "AcDbSymbolTableRecord", "100", "AcDbLayerTableRecord", "2", layerName, "70", "0", "62", "7", // Default color (white)
+            "6", "CONTINUOUS" // Line type
+            );
+        });
+        layerTable.push("0", "ENDTAB");
+        return layerTable;
+    }
+    /**
+     * Generate DXF entities section with all path segments
+     */
+    generateEntities(dxfInputs) {
+        const entities = [
+            "0",
+            "SECTION",
+            "2",
+            "ENTITIES"
+        ];
+        if (dxfInputs.dxfPathsParts) {
+            dxfInputs.dxfPathsParts.forEach(part => {
+                if (part.paths) {
+                    part.paths.forEach(path => {
+                        if (path.segments) {
+                            path.segments.forEach(segment => {
+                                entities.push(...this.generateSegmentEntity(segment, part));
+                            });
+                        }
+                    });
+                }
+            });
+        }
+        entities.push("0", "ENDSEC");
+        return entities;
+    }
+    /**
+     * Generate entity for a single segment based on its type
+     */
+    generateSegmentEntity(segment, part) {
+        // Check segment type and generate appropriate entity
+        if (this.isLineSegment(segment)) {
+            return this.generateLineEntity(segment, part);
+        }
+        else if (this.isArcSegment(segment)) {
+            return this.generateArcEntity(segment, part);
+        }
+        else if (this.isCircleSegment(segment)) {
+            return this.generateCircleEntity(segment, part);
+        }
+        else if (this.isPolylineSegment(segment)) {
+            return this.generatePolylineEntity(segment, part);
+        }
+        else if (this.isSplineSegment(segment)) {
+            return this.generateSplineEntity(segment, part);
+        }
+        return [];
+    }
+    /**
+     * Type guard for line segments
+     */
+    isLineSegment(segment) {
+        return segment.start !== undefined && segment.end !== undefined && segment.radius === undefined;
+    }
+    /**
+     * Type guard for arc segments
+     */
+    isArcSegment(segment) {
+        return segment.center !== undefined && segment.radius !== undefined && segment.startAngle !== undefined && segment.endAngle !== undefined;
+    }
+    /**
+     * Type guard for circle segments
+     */
+    isCircleSegment(segment) {
+        return segment.center !== undefined && segment.radius !== undefined && segment.startAngle === undefined;
+    }
+    /**
+     * Type guard for polyline segments
+     */
+    isPolylineSegment(segment) {
+        return segment.points !== undefined && Array.isArray(segment.points);
+    }
+    /**
+     * Type guard for spline segments
+     */
+    isSplineSegment(segment) {
+        return segment.controlPoints !== undefined && Array.isArray(segment.controlPoints);
+    }
+    /**
+     * Generate a LINE entity
+     */
+    generateLineEntity(line, part) {
+        const entity = [
+            "0",
+            "LINE",
+            "5",
+            this.getNextHandle(),
+            "100",
+            "AcDbEntity"
+        ];
+        // Add layer
+        entity.push("8", part.layer || "0");
+        // Add color if specified
+        if (part.color !== undefined) {
+            const colorCodes = this.convertColorToDxf(part.color);
+            colorCodes.forEach(cc => entity.push(cc.code, cc.value));
+        }
+        entity.push("100", "AcDbLine", "10", line.start[0].toString(), "20", line.start[1].toString(), "30", "0", // Z coordinate (2D)
+        "11", line.end[0].toString(), "21", line.end[1].toString(), "31", "0" // Z coordinate (2D)
+        );
+        return entity;
+    }
+    /**
+     * Generate a CIRCLE entity
+     */
+    generateCircleEntity(circle, part) {
+        const entity = [
+            "0",
+            "CIRCLE",
+            "5",
+            this.getNextHandle(),
+            "100",
+            "AcDbEntity"
+        ];
+        // Add layer
+        entity.push("8", part.layer || "0");
+        // Add color if specified
+        if (part.color !== undefined) {
+            const colorCodes = this.convertColorToDxf(part.color);
+            colorCodes.forEach(cc => entity.push(cc.code, cc.value));
+        }
+        entity.push("100", "AcDbCircle", "10", circle.center[0].toString(), "20", circle.center[1].toString(), "30", "0", // Z coordinate (2D)
+        "40", circle.radius.toString());
+        return entity;
+    }
+    /**
+     * Generate an ARC entity
+     */
+    generateArcEntity(arc, part) {
+        const entity = [
+            "0",
+            "ARC",
+            "5",
+            this.getNextHandle(),
+            "100",
+            "AcDbEntity"
+        ];
+        // Add layer
+        entity.push("8", part.layer || "0");
+        // Add color if specified
+        if (part.color !== undefined) {
+            const colorCodes = this.convertColorToDxf(part.color);
+            colorCodes.forEach(cc => entity.push(cc.code, cc.value));
+        }
+        entity.push("100", "AcDbCircle", "10", arc.center[0].toString(), "20", arc.center[1].toString(), "30", "0", // Z coordinate (2D)
+        "40", arc.radius.toString(), "100", "AcDbArc", "50", arc.startAngle.toString(), "51", arc.endAngle.toString());
+        return entity;
+    }
+    /**
+     * Generate a LWPOLYLINE entity
+     */
+    generatePolylineEntity(polyline, part) {
+        const entity = [
+            "0",
+            "LWPOLYLINE",
+            "5",
+            this.getNextHandle(),
+            "100",
+            "AcDbEntity"
+        ];
+        // Add layer
+        entity.push("8", part.layer || "0");
+        // Add color if specified
+        if (part.color !== undefined) {
+            const colorCodes = this.convertColorToDxf(part.color);
+            colorCodes.forEach(cc => entity.push(cc.code, cc.value));
+        }
+        const isClosed = polyline.closed || (polyline.points.length > 2 && this.isClosedPolyline(polyline.points));
+        entity.push("100", "AcDbPolyline", "90", polyline.points.length.toString(), "70", isClosed ? "1" : "0");
+        // Add vertices
+        polyline.points.forEach((point, index) => {
+            entity.push("10", point[0].toString(), "20", point[1].toString());
+            // Add bulge value if specified (for arc segments)
+            if (polyline.bulges && polyline.bulges.length > index) {
+                const bulge = polyline.bulges[index];
+                if (bulge !== 0) {
+                    entity.push("42", bulge.toString());
+                }
+            }
+        });
+        return entity;
+    }
+    /**
+     * Generate a SPLINE entity
+     */
+    generateSplineEntity(spline, part) {
+        const entity = [
+            "0",
+            "SPLINE",
+            "5",
+            this.getNextHandle(),
+            "100",
+            "AcDbEntity"
+        ];
+        // Add layer
+        entity.push("8", part.layer || "0");
+        // Add color if specified
+        if (part.color !== undefined) {
+            const colorCodes = this.convertColorToDxf(part.color);
+            colorCodes.forEach(cc => entity.push(cc.code, cc.value));
+        }
+        const degree = spline.degree || 3;
+        const numControlPoints = spline.controlPoints.length;
+        const numKnots = numControlPoints + degree + 1;
+        // Spline flags: 1 = closed, 2 = periodic, 4 = rational, 8 = planar, 16 = linear
+        const flags = spline.closed ? 1 : 0;
+        entity.push("100", "AcDbSpline", "210", "0", "220", "0", "230", "1", // Normal vector (Z-axis for 2D)
+        "70", flags.toString(), "71", degree.toString(), "72", numKnots.toString(), "73", numControlPoints.toString(), "74", "0" // Number of fit points (we're using control points)
+        );
+        // Generate knot values (uniform knot vector)
+        for (let i = 0; i < numKnots; i++) {
+            entity.push("40", i.toString());
+        }
+        // Add control points
+        spline.controlPoints.forEach(point => {
+            entity.push("10", point[0].toString(), "20", point[1].toString(), "30", "0" // Z coordinate (2D)
+            );
+        });
+        return entity;
+    }
+    /**
+     * Check if polyline should be closed (first and last points are the same)
+     */
+    isClosedPolyline(points) {
+        if (points.length < 3)
+            return false;
+        const first = points[0];
+        const last = points[points.length - 1];
+        return Math.abs(first[0] - last[0]) < 1e-10 &&
+            Math.abs(first[1] - last[1]) < 1e-10;
+    }
+    /**
+     * Get next entity handle as hex string
+     */
+    getNextHandle() {
+        return (++this.entityHandle).toString(16).toUpperCase();
+    }
+    /**
+     * Convert color to DXF format
+     * Accepts hex color (#RRGGBB) or ACI color index (1-255)
+     * Returns appropriate DXF color codes
+     */
+    convertColorToDxf(color) {
+        // If it's already a number (ACI index), use it directly
+        if (/^\d+$/.test(color)) {
+            const colorIndex = parseInt(color, 10);
+            if (colorIndex >= 1 && colorIndex <= 255) {
+                return [{ code: "62", value: color }];
+            }
+        }
+        // If it's a hex color, convert to true color (24-bit RGB)
+        if (color.startsWith("#")) {
+            const hex = color.substring(1);
+            if (hex.length === 6) {
+                const r = parseInt(hex.substring(0, 2), 16);
+                const g = parseInt(hex.substring(2, 4), 16);
+                const b = parseInt(hex.substring(4, 6), 16);
+                // True color value = (R * 65536) + (G * 256) + B
+                const trueColor = (r * 65536) + (g * 256) + b;
+                // Use group code 420 for true color (24-bit)
+                return [
+                    { code: "62", value: "256" },
+                    { code: "420", value: trueColor.toString() }
+                ];
+            }
+        }
+        // Default to white (7) if color can't be parsed
+        return [{ code: "62", value: "7" }];
+    }
+}

package/lib/api/services/helpers/dxf/dxf.d.ts

@@ -0,0 +1,77 @@
+import * as Inputs from "../../../inputs";
+export declare class Dxf {
+    private dxfGenerator;
+    /**
+     * Creates a line segment for DXF paths
+     * @param inputs Line segment definition
+     * @returns Line segment DTO
+     * @group dxf
+     * @shortname line segment
+     * @drawable false
+     */
+    lineSegment(inputs: Inputs.IO.DxfLineSegmentDto): Inputs.IO.DxfLineSegmentDto;
+    /**
+     * Creates an arc segment for DXF paths
+     * @param inputs Arc segment definition
+     * @returns Arc segment DTO
+     * @group dxf
+     * @shortname arc segment
+     * @drawable false
+     */
+    arcSegment(inputs: Inputs.IO.DxfArcSegmentDto): Inputs.IO.DxfArcSegmentDto;
+    /**
+     * Creates a circle segment for DXF paths
+     * @param inputs Circle segment definition
+     * @returns Circle segment DTO
+     * @group dxf
+     * @shortname circle segment
+     * @drawable false
+     */
+    circleSegment(inputs: Inputs.IO.DxfCircleSegmentDto): Inputs.IO.DxfCircleSegmentDto;
+    /**
+     * Creates a polyline segment for DXF paths
+     * @param inputs Polyline segment definition
+     * @returns Polyline segment DTO
+     * @group dxf
+     * @shortname polyline segment
+     * @drawable false
+     */
+    polylineSegment(inputs: Inputs.IO.DxfPolylineSegmentDto): Inputs.IO.DxfPolylineSegmentDto;
+    /**
+     * Creates a spline segment for DXF paths
+     * @param inputs Spline segment definition
+     * @returns Spline segment DTO
+     * @group dxf
+     * @shortname spline segment
+     * @drawable false
+     */
+    splineSegment(inputs: Inputs.IO.DxfSplineSegmentDto): Inputs.IO.DxfSplineSegmentDto;
+    /**
+     * Creates a path from segments
+     * @param inputs Path definition with segments
+     * @returns Path DTO
+     * @group dxf
+     * @shortname path
+     * @drawable false
+     */
+    path(inputs: Inputs.IO.DxfPathDto): Inputs.IO.DxfPathDto;
+    /**
+     * Creates a paths part with layer and color
+     * @param inputs Paths part definition
+     * @returns Paths part DTO
+     * @group dxf
+     * @shortname paths part
+     * @drawable false
+     */
+    pathsPart(inputs: Inputs.IO.DxfPathsPartDto): Inputs.IO.DxfPathsPartDto;
+    /**
+     * DXF generator that supports lines, arcs, circles, polylines, and splines organized in paths.
+     * Paths can combine multiple segment types similar to OCCT wires.
+     * @param inputs DXF model definition
+     * @returns DXF file content as string
+     * @group dxf
+     * @shortname dxf create
+     * @drawable false
+     */
+    dxfCreate(inputs: Inputs.IO.DxfModelDto): string;
+}

package/lib/api/services/helpers/dxf/dxf.js

@@ -0,0 +1,95 @@
+import { DxfGenerator } from "./dxf-generator";
+export class Dxf {
+    constructor() {
+        this.dxfGenerator = new DxfGenerator();
+    }
+    /**
+     * Creates a line segment for DXF paths
+     * @param inputs Line segment definition
+     * @returns Line segment DTO
+     * @group dxf
+     * @shortname line segment
+     * @drawable false
+     */
+    lineSegment(inputs) {
+        return inputs;
+    }
+    /**
+     * Creates an arc segment for DXF paths
+     * @param inputs Arc segment definition
+     * @returns Arc segment DTO
+     * @group dxf
+     * @shortname arc segment
+     * @drawable false
+     */
+    arcSegment(inputs) {
+        return inputs;
+    }
+    /**
+     * Creates a circle segment for DXF paths
+     * @param inputs Circle segment definition
+     * @returns Circle segment DTO
+     * @group dxf
+     * @shortname circle segment
+     * @drawable false
+     */
+    circleSegment(inputs) {
+        return inputs;
+    }
+    /**
+     * Creates a polyline segment for DXF paths
+     * @param inputs Polyline segment definition
+     * @returns Polyline segment DTO
+     * @group dxf
+     * @shortname polyline segment
+     * @drawable false
+     */
+    polylineSegment(inputs) {
+        return inputs;
+    }
+    /**
+     * Creates a spline segment for DXF paths
+     * @param inputs Spline segment definition
+     * @returns Spline segment DTO
+     * @group dxf
+     * @shortname spline segment
+     * @drawable false
+     */
+    splineSegment(inputs) {
+        return inputs;
+    }
+    /**
+     * Creates a path from segments
+     * @param inputs Path definition with segments
+     * @returns Path DTO
+     * @group dxf
+     * @shortname path
+     * @drawable false
+     */
+    path(inputs) {
+        return inputs;
+    }
+    /**
+     * Creates a paths part with layer and color
+     * @param inputs Paths part definition
+     * @returns Paths part DTO
+     * @group dxf
+     * @shortname paths part
+     * @drawable false
+     */
+    pathsPart(inputs) {
+        return inputs;
+    }
+    /**
+     * DXF generator that supports lines, arcs, circles, polylines, and splines organized in paths.
+     * Paths can combine multiple segment types similar to OCCT wires.
+     * @param inputs DXF model definition
+     * @returns DXF file content as string
+     * @group dxf
+     * @shortname dxf create
+     * @drawable false
+     */
+    dxfCreate(inputs) {
+        return this.dxfGenerator.generateDxf(inputs);
+    }
+}

package/lib/api/services/index.d.ts

@@ -11,3 +11,4 @@ export * from "./geometry-helper";
 export * from "./line";
 export * from "./polyline";
 export * from "./mesh";
+export * from "./io";

package/lib/api/services/index.js

@@ -11,3 +11,4 @@ export * from "./geometry-helper";
 export * from "./line";
 export * from "./polyline";
 export * from "./mesh";
+export * from "./io";

package/lib/api/services/io.d.ts

@@ -0,0 +1,5 @@
+import { Dxf } from "./helpers/dxf/dxf";
+export declare class IoBitByBit {
+    dxf: Dxf;
+    constructor();
+}

package/lib/api/services/io.js

@@ -0,0 +1,6 @@
+import { Dxf } from "./helpers/dxf/dxf";
+export class IoBitByBit {
+    constructor() {
+        this.dxf = new Dxf();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitbybit-dev/base",
-  "version": "0.20.8",
+  "version": "0.20.9",
   "description": "Bit By Bit Developers Base CAD Library to Program Geometry",
   "main": "index.js",
   "repository": {