tsdraft 0.1.0 → 0.2.1

package/dist/dxf-r12.js

@@ -0,0 +1,115 @@
+import { dxfText, fmt, writtenAngle } from "./format.js";
+import { layerZeroFirst } from "./layers.js";
+/**
+ * Writes an ASCII DXF (AC1009, R12). R12 is the most widely readable DXF:
+ * AutoCAD, BricsCAD, LibreCAD, QCAD and most converters open it.
+ *
+ * R12 has no header variable for drawing units, so coordinates are written as
+ * plain numbers in the drawing's units and `drawing.units` is not written.
+ * R12 predates Unicode DXF, so text outside ASCII is written as `\U+XXXX`.
+ * Layer `0` is written first, wherever it is in `drawing.layers`.
+ */
+export function toDXFR12(drawing) {
+    const out = [];
+    const g = (code, value) => {
+        out.push(String(code), typeof value === "number" ? fmt(value) : value);
+    };
+    g(0, "SECTION");
+    g(2, "HEADER");
+    g(9, "$ACADVER");
+    g(1, "AC1009");
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "TABLES");
+    g(0, "TABLE");
+    g(2, "LTYPE");
+    g(70, "1");
+    g(0, "LTYPE");
+    g(2, "CONTINUOUS");
+    g(70, "0");
+    g(3, "Solid line");
+    g(72, "65");
+    g(73, "0");
+    g(40, "0.0");
+    g(0, "ENDTAB");
+    g(0, "TABLE");
+    g(2, "LAYER");
+    g(70, String(drawing.layers.length));
+    for (const layer of layerZeroFirst(drawing.layers)) {
+        g(0, "LAYER");
+        g(2, layer.name);
+        g(70, "0");
+        g(62, String(layer.color));
+        g(6, "CONTINUOUS");
+    }
+    g(0, "ENDTAB");
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "ENTITIES");
+    for (const entity of drawing.entities)
+        writeEntity(entity, g);
+    g(0, "ENDSEC");
+    g(0, "EOF");
+    return out.join("\r\n") + "\r\n";
+}
+function writeEntity(e, g) {
+    switch (e.kind) {
+        case "line":
+            g(0, "LINE");
+            g(8, e.layer);
+            g(10, e.from[0]);
+            g(20, e.from[1]);
+            g(30, 0);
+            g(11, e.to[0]);
+            g(21, e.to[1]);
+            g(31, 0);
+            return;
+        case "polyline":
+            g(0, "POLYLINE");
+            g(8, e.layer);
+            g(66, "1");
+            g(10, 0);
+            g(20, 0);
+            g(30, 0);
+            g(70, e.closed ? "1" : "0");
+            for (const [x, y] of e.points) {
+                g(0, "VERTEX");
+                g(8, e.layer);
+                g(10, x);
+                g(20, y);
+                g(30, 0);
+            }
+            g(0, "SEQEND");
+            g(8, e.layer);
+            return;
+        case "circle":
+            g(0, "CIRCLE");
+            g(8, e.layer);
+            g(10, e.center[0]);
+            g(20, e.center[1]);
+            g(30, 0);
+            g(40, e.radius);
+            return;
+        case "arc":
+            g(0, "ARC");
+            g(8, e.layer);
+            g(10, e.center[0]);
+            g(20, e.center[1]);
+            g(30, 0);
+            g(40, e.radius);
+            g(50, writtenAngle(e.startAngle));
+            g(51, writtenAngle(e.endAngle));
+            return;
+        case "text":
+            g(0, "TEXT");
+            g(8, e.layer);
+            g(10, e.at[0]);
+            g(20, e.at[1]);
+            g(30, 0);
+            g(40, e.height);
+            g(1, dxfText(e.value, true));
+            if (e.rotation !== 0)
+                g(50, e.rotation);
+            return;
+    }
+}

package/dist/dxf-r2018.d.ts

@@ -0,0 +1,10 @@
+import type { Drawing } from "./drawing.ts";
+/**
+ * Writes an ASCII DXF for AutoCAD 2018 and later (AC1032), the newest DXF
+ * version Autodesk has published. AutoCAD 2027 still reads and writes AC1032.
+ *
+ * Unlike R12, this version has handles, owner links, an OBJECTS section and the
+ * `$INSUNITS` header, so the drawing's units reach CAD and xref and block
+ * insertion scale correctly. Text is UTF-8.
+ */
+export declare function toDXFR2018(drawing: Drawing): string;

package/dist/dxf-r2018.js

@@ -0,0 +1,344 @@
+import { extents } from "./extents.js";
+import { dxfText, fmt, readable, writtenAngle } from "./format.js";
+import { layerZeroFirst } from "./layers.js";
+/** `$INSUNITS` codes from the DXF Reference. */
+const INSUNITS = { in: 1, ft: 2, mm: 4, cm: 5, m: 6 };
+/**
+ * Writes an ASCII DXF for AutoCAD 2018 and later (AC1032), the newest DXF
+ * version Autodesk has published. AutoCAD 2027 still reads and writes AC1032.
+ *
+ * Unlike R12, this version has handles, owner links, an OBJECTS section and the
+ * `$INSUNITS` header, so the drawing's units reach CAD and xref and block
+ * insertion scale correctly. Text is UTF-8.
+ */
+export function toDXFR2018(drawing) {
+    let seed = 1;
+    const handle = () => (seed++).toString(16).toUpperCase();
+    const body = [];
+    const g = groupWriter(body);
+    const rootDictionary = handle();
+    const groupDictionary = handle();
+    const plotStyleDictionary = handle();
+    const normalPlotStyle = handle();
+    const modelSpace = handle();
+    const paperSpace = handle();
+    // The extents are worked out here, so they are brought into the range AutoCAD reads.
+    const [left, bottom, right, top] = extents(drawing.entities);
+    const [minX, minY, maxX, maxY] = [
+        readable(left),
+        readable(bottom),
+        readable(right),
+        readable(top),
+    ];
+    g(0, "SECTION");
+    g(2, "CLASSES");
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "TABLES");
+    writeTable(g, handle, "VPORT", [
+        {
+            type: "VPORT",
+            subclass: "AcDbViewportTableRecord",
+            name: "*Active",
+            handle: handle(),
+            fields: (g) => writeActiveViewport(g, minX, minY, maxX, maxY),
+        },
+    ]);
+    writeTable(g, handle, "LTYPE", [
+        ["ByBlock", ""],
+        ["ByLayer", ""],
+        ["Continuous", "Solid line"],
+    ].map(([name = "", description = ""]) => ({
+        type: "LTYPE",
+        subclass: "AcDbLinetypeTableRecord",
+        name,
+        handle: handle(),
+        fields: (g) => {
+            g(3, description);
+            g(72, 65);
+            g(73, 0);
+            g(40, 0);
+        },
+    })));
+    writeTable(g, handle, "LAYER", 
+    // AUDIT reports "Layer zero name found at incorrect index" unless layer 0 comes first.
+    layerZeroFirst(drawing.layers).map((layer) => ({
+        type: "LAYER",
+        subclass: "AcDbLayerTableRecord",
+        name: layer.name,
+        handle: handle(),
+        fields: (g) => {
+            g(62, layer.color);
+            g(6, "Continuous");
+            g(370, -3); // lineweight: default
+            g(390, normalPlotStyle); // AutoCAD rejects a layer without a plot style
+        },
+    })));
+    writeTable(g, handle, "STYLE", [
+        {
+            type: "STYLE",
+            subclass: "AcDbTextStyleTableRecord",
+            name: "Standard",
+            handle: handle(),
+            fields: (g) => {
+                g(40, 0); // fixed height: none
+                g(41, 1); // width factor
+                g(50, 0); // oblique angle
+                g(71, 0); // generation flags
+                g(42, 0.2); // last height used
+                g(3, "txt");
+                g(4, "");
+            },
+        },
+    ]);
+    writeTable(g, handle, "VIEW", []);
+    writeTable(g, handle, "UCS", []);
+    writeTable(g, handle, "APPID", [
+        { type: "APPID", subclass: "AcDbRegAppTableRecord", name: "ACAD", handle: handle() },
+    ]);
+    writeTable(g, handle, "DIMSTYLE", [
+        { type: "DIMSTYLE", subclass: "AcDbDimStyleTableRecord", name: "Standard", handle: handle() },
+    ]);
+    const blockRecordFields = (g) => {
+        g(280, 1); // explodable
+        g(281, 0); // scale uniformly: no
+    };
+    writeTable(g, handle, "BLOCK_RECORD", [
+        {
+            type: "BLOCK_RECORD",
+            subclass: "AcDbBlockTableRecord",
+            name: "*Model_Space",
+            handle: modelSpace,
+            fields: blockRecordFields,
+        },
+        {
+            type: "BLOCK_RECORD",
+            subclass: "AcDbBlockTableRecord",
+            name: "*Paper_Space",
+            handle: paperSpace,
+            fields: blockRecordFields,
+        },
+    ]);
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "BLOCKS");
+    writeBlock(g, handle, "*Model_Space", modelSpace, false);
+    writeBlock(g, handle, "*Paper_Space", paperSpace, true);
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "ENTITIES");
+    for (const entity of drawing.entities)
+        writeEntity(g, entity, handle(), modelSpace);
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "OBJECTS");
+    g(0, "DICTIONARY");
+    g(5, rootDictionary);
+    g(330, "0");
+    g(100, "AcDbDictionary");
+    g(281, 1); // duplicate records: keep existing
+    g(3, "ACAD_GROUP");
+    g(350, groupDictionary);
+    g(3, "ACAD_PLOTSTYLENAME");
+    g(350, plotStyleDictionary);
+    g(0, "DICTIONARY");
+    ownedBy(g, groupDictionary, rootDictionary);
+    g(100, "AcDbDictionary");
+    g(281, 1);
+    // Plot style names: a dictionary with a default, holding the "Normal" placeholder.
+    g(0, "ACDBDICTIONARYWDFLT");
+    ownedBy(g, plotStyleDictionary, rootDictionary);
+    g(100, "AcDbDictionary");
+    g(281, 1);
+    g(3, "Normal");
+    g(350, normalPlotStyle);
+    g(100, "AcDbDictionaryWithDefault");
+    g(340, normalPlotStyle);
+    g(0, "ACDBPLACEHOLDER");
+    ownedBy(g, normalPlotStyle, plotStyleDictionary);
+    g(0, "ENDSEC");
+    g(0, "EOF");
+    // The header goes first in the file but is written last, once every handle is assigned.
+    const header = [];
+    const h = groupWriter(header);
+    h(0, "SECTION");
+    h(2, "HEADER");
+    h(9, "$ACADVER");
+    h(1, "AC1032");
+    h(9, "$DWGCODEPAGE");
+    h(3, "ANSI_1252");
+    h(9, "$INSBASE");
+    point(h, 10, 0, 0);
+    h(9, "$EXTMIN");
+    point(h, 10, minX, minY);
+    h(9, "$EXTMAX");
+    point(h, 10, maxX, maxY);
+    h(9, "$INSUNITS");
+    h(70, INSUNITS[drawing.units]);
+    h(9, "$MEASUREMENT");
+    h(70, drawing.units === "in" || drawing.units === "ft" ? 0 : 1);
+    h(9, "$CLAYER");
+    h(8, "0");
+    h(9, "$HANDSEED");
+    h(5, handle());
+    h(0, "ENDSEC");
+    return [...header, ...body].join("\r\n") + "\r\n";
+}
+function groupWriter(out) {
+    return (code, value) => {
+        out.push(String(code), typeof value === "number" ? fmt(value) : value);
+    };
+}
+/** Handle, reactor and owner fields for an object owned by a dictionary. */
+function ownedBy(g, handle, owner) {
+    g(5, handle);
+    g(102, "{ACAD_REACTORS");
+    g(330, owner);
+    g(102, "}");
+    g(330, owner);
+}
+function point(g, code, x, y) {
+    g(code, x);
+    g(code + 10, y);
+    g(code + 20, 0);
+}
+function writeTable(g, handle, name, records) {
+    const table = handle();
+    g(0, "TABLE");
+    g(2, name);
+    g(5, table);
+    g(330, "0");
+    g(100, "AcDbSymbolTable");
+    g(70, records.length);
+    if (name === "DIMSTYLE") {
+        g(100, "AcDbDimStyleTable");
+        g(71, records.length);
+        for (const r of records)
+            g(340, r.handle);
+    }
+    for (const r of records) {
+        g(0, r.type);
+        // DIMSTYLE records use 105 for their handle, because 5 is DIMBLK's code there.
+        g(r.type === "DIMSTYLE" ? 105 : 5, r.handle);
+        g(330, table);
+        g(100, "AcDbSymbolTableRecord");
+        g(100, r.subclass);
+        g(2, r.name);
+        g(70, 0);
+        r.fields?.(g);
+    }
+    g(0, "ENDTAB");
+}
+/** The *Active viewport, zoomed to the drawing's extents so the file opens on the drawing. */
+function writeActiveViewport(g, minX, minY, maxX, maxY) {
+    const aspect = 1.6;
+    // A drawing can span more than AutoCAD can read as one number, so the height is capped.
+    const height = readable(Math.max(maxY - minY, (maxX - minX) / aspect, 1) * 1.1);
+    g(10, 0); // lower-left corner of the viewport on screen
+    g(20, 0);
+    g(11, 1); // upper-right corner
+    g(21, 1);
+    g(12, (minX + maxX) / 2); // view center
+    g(22, (minY + maxY) / 2);
+    g(13, 0); // snap base
+    g(23, 0);
+    g(14, 0.5); // snap spacing
+    g(24, 0.5);
+    g(15, 0.5); // grid spacing
+    g(25, 0.5);
+    g(16, 0); // view direction
+    g(26, 0);
+    g(36, 1);
+    g(17, 0); // view target
+    g(27, 0);
+    g(37, 0);
+    g(40, height);
+    g(41, aspect);
+    g(42, 50); // lens length
+    g(43, 0); // front clip
+    g(44, 0); // back clip
+    g(50, 0); // snap rotation
+    g(51, 0); // view twist
+    g(71, 0); // view mode
+    g(72, 1000); // circle zoom percent
+    g(73, 1); // fast zoom
+    g(74, 3); // UCS icon
+    g(75, 0); // snap off
+    g(76, 0); // grid off
+    g(77, 0); // snap style
+    g(78, 0); // snap isopair
+}
+function writeBlock(g, handle, name, owner, paper) {
+    g(0, "BLOCK");
+    g(5, handle());
+    g(330, owner);
+    g(100, "AcDbEntity");
+    if (paper)
+        g(67, 1);
+    g(8, "0");
+    g(100, "AcDbBlockBegin");
+    g(2, name);
+    g(70, 0);
+    point(g, 10, 0, 0);
+    g(3, name);
+    g(1, "");
+    g(0, "ENDBLK");
+    g(5, handle());
+    g(330, owner);
+    g(100, "AcDbEntity");
+    if (paper)
+        g(67, 1);
+    g(8, "0");
+    g(100, "AcDbBlockEnd");
+}
+function writeEntity(g, e, handle, owner) {
+    const begin = (type, subclass) => {
+        g(0, type);
+        g(5, handle);
+        g(330, owner);
+        g(100, "AcDbEntity");
+        g(8, e.layer);
+        g(100, subclass);
+    };
+    switch (e.kind) {
+        case "line":
+            begin("LINE", "AcDbLine");
+            point(g, 10, ...e.from);
+            point(g, 11, ...e.to);
+            return;
+        case "polyline":
+            begin("LWPOLYLINE", "AcDbPolyline");
+            g(90, e.points.length);
+            g(70, e.closed ? 1 : 0);
+            g(43, 0); // constant width
+            for (const [x, y] of e.points) {
+                g(10, x);
+                g(20, y);
+            }
+            return;
+        case "circle":
+            begin("CIRCLE", "AcDbCircle");
+            point(g, 10, ...e.center);
+            g(40, e.radius);
+            return;
+        case "arc":
+            begin("ARC", "AcDbCircle");
+            point(g, 10, ...e.center);
+            g(40, e.radius);
+            g(100, "AcDbArc");
+            g(50, writtenAngle(e.startAngle));
+            g(51, writtenAngle(e.endAngle));
+            return;
+        case "text":
+            begin("TEXT", "AcDbText");
+            point(g, 10, ...e.at);
+            g(40, e.height);
+            g(1, dxfText(e.value));
+            if (e.rotation !== 0)
+                g(50, e.rotation);
+            g(7, "Standard");
+            // TEXT repeats its subclass marker before the vertical alignment fields.
+            g(100, "AcDbText");
+            return;
+    }
+}

package/dist/dxf.d.ts

@@ -1,9 +1,11 @@
-import type { Drawing } from "./drawing.ts";
+import type { Drawing, DxfVersion } from "./drawing.ts";
+export interface DxfOptions {
+    /** Defaults to the version the drawing was created for, which is `"R12"` unless set. */
+    readonly version?: DxfVersion;
+}
 /**
- * Writes an ASCII DXF (AC1009, R12). R12 is the most widely readable DXF:
- * AutoCAD, BricsCAD, LibreCAD, QCAD and most converters open it.
- *
- * R12 has no header variable for drawing units, so coordinates are written as
- * plain numbers in the drawing's units and `drawing.units` is not written.
+ * Writes the drawing as ASCII DXF. Throws a `DrawingError` listing every lint
+ * error when the drawing breaks a rule of the version being written, because
+ * AutoCAD would reject or garble the file.
  */
-export declare function toDXF(drawing: Drawing): string;
+export declare function toDXF(drawing: Drawing, options?: DxfOptions): string;

package/dist/dxf.js

@@ -1,112 +1,18 @@
-import { fmt } from "./format.js";
+import { toDXFR12 } from "./dxf-r12.js";
+import { toDXFR2018 } from "./dxf-r2018.js";
+import { DrawingError, lint } from "./lint.js";
 /**
- * Writes an ASCII DXF (AC1009, R12). R12 is the most widely readable DXF:
- * AutoCAD, BricsCAD, LibreCAD, QCAD and most converters open it.
- *
- * R12 has no header variable for drawing units, so coordinates are written as
- * plain numbers in the drawing's units and `drawing.units` is not written.
+ * Writes the drawing as ASCII DXF. Throws a `DrawingError` listing every lint
+ * error when the drawing breaks a rule of the version being written, because
+ * AutoCAD would reject or garble the file.
  */
-export function toDXF(drawing) {
-    const out = [];
-    const g = (code, value) => {
-        out.push(String(code), typeof value === "number" ? fmt(value) : value);
-    };
-    g(0, "SECTION");
-    g(2, "HEADER");
-    g(9, "$ACADVER");
-    g(1, "AC1009");
-    g(0, "ENDSEC");
-    g(0, "SECTION");
-    g(2, "TABLES");
-    g(0, "TABLE");
-    g(2, "LTYPE");
-    g(70, "1");
-    g(0, "LTYPE");
-    g(2, "CONTINUOUS");
-    g(70, "0");
-    g(3, "Solid line");
-    g(72, "65");
-    g(73, "0");
-    g(40, "0.0");
-    g(0, "ENDTAB");
-    g(0, "TABLE");
-    g(2, "LAYER");
-    g(70, String(drawing.layers.length));
-    for (const layer of drawing.layers) {
-        g(0, "LAYER");
-        g(2, layer.name);
-        g(70, "0");
-        g(62, String(layer.color));
-        g(6, "CONTINUOUS");
-    }
-    g(0, "ENDTAB");
-    g(0, "ENDSEC");
-    g(0, "SECTION");
-    g(2, "ENTITIES");
-    for (const entity of drawing.entities)
-        writeEntity(entity, g);
-    g(0, "ENDSEC");
-    g(0, "EOF");
-    return out.join("\r\n") + "\r\n";
-}
-function writeEntity(e, g) {
-    switch (e.kind) {
-        case "line":
-            g(0, "LINE");
-            g(8, e.layer);
-            g(10, e.from[0]);
-            g(20, e.from[1]);
-            g(30, 0);
-            g(11, e.to[0]);
-            g(21, e.to[1]);
-            g(31, 0);
-            return;
-        case "polyline":
-            g(0, "POLYLINE");
-            g(8, e.layer);
-            g(66, "1");
-            g(10, 0);
-            g(20, 0);
-            g(30, 0);
-            g(70, e.closed ? "1" : "0");
-            for (const [x, y] of e.points) {
-                g(0, "VERTEX");
-                g(8, e.layer);
-                g(10, x);
-                g(20, y);
-                g(30, 0);
-            }
-            g(0, "SEQEND");
-            g(8, e.layer);
-            return;
-        case "circle":
-            g(0, "CIRCLE");
-            g(8, e.layer);
-            g(10, e.center[0]);
-            g(20, e.center[1]);
-            g(30, 0);
-            g(40, e.radius);
-            return;
-        case "arc":
-            g(0, "ARC");
-            g(8, e.layer);
-            g(10, e.center[0]);
-            g(20, e.center[1]);
-            g(30, 0);
-            g(40, e.radius);
-            g(50, e.startAngle);
-            g(51, e.endAngle);
-            return;
-        case "text":
-            g(0, "TEXT");
-            g(8, e.layer);
-            g(10, e.at[0]);
-            g(20, e.at[1]);
-            g(30, 0);
-            g(40, e.height);
-            g(1, e.value);
-            if (e.rotation !== 0)
-                g(50, e.rotation);
-            return;
+export function toDXF(drawing, options = {}) {
+    const version = options.version ?? drawing.dxf;
+    if (version !== "R12" && version !== "R2018") {
+        throw new Error(`Unsupported DXF version: ${JSON.stringify(version)}`);
     }
+    const errors = lint(drawing, { version }).filter((d) => d.severity === "error");
+    if (errors.length > 0)
+        throw new DrawingError(errors);
+    return version === "R12" ? toDXFR12(drawing) : toDXFR2018(drawing);
 }

package/dist/extents.d.ts

@@ -0,0 +1,3 @@
+import type { Entity } from "./drawing.ts";
+/** Approximate extents. Arcs use their full circle; text assumes 0.6 × height per character. */
+export declare function extents(entities: readonly Entity[]): [number, number, number, number];

package/dist/extents.js

@@ -0,0 +1,42 @@
+/** Approximate extents. Arcs use their full circle; text assumes 0.6 × height per character. */
+export function extents(entities) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    const add = (x, y) => {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    };
+    for (const e of entities) {
+        switch (e.kind) {
+            case "line":
+                add(...e.from);
+                add(...e.to);
+                break;
+            case "polyline":
+                for (const p of e.points)
+                    add(...p);
+                break;
+            case "circle":
+            case "arc":
+                add(e.center[0] - e.radius, e.center[1] - e.radius);
+                add(e.center[0] + e.radius, e.center[1] + e.radius);
+                break;
+            case "text": {
+                const len = e.value.length * e.height * 0.6;
+                const r = rad(e.rotation);
+                add(...e.at);
+                add(e.at[0] + len * Math.cos(r), e.at[1] + len * Math.sin(r));
+                add(e.at[0] - e.height * Math.sin(r), e.at[1] + e.height * Math.cos(r));
+                break;
+            }
+        }
+    }
+    return minX === Infinity ? [0, 0, 1, 1] : [minX, minY, maxX, maxY];
+}
+function rad(degrees) {
+    return (degrees * Math.PI) / 180;
+}