tsdraft 0.1.0 → 0.2.0

package/dist/dxf-r2018.js

@@ -0,0 +1,333 @@
+import { extents } from "./extents.js";
+import { dxfText, fmt } from "./format.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();
+    const [minX, minY, maxX, maxY] = extents(drawing.entities);
+    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", 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;
+    const height = 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, e.startAngle);
+            g(51, 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;
+}

package/dist/format.d.ts

@@ -1,2 +1,11 @@
 /** Formats a coordinate with at most 6 decimals, no float noise, and no "-0". */
 export declare function fmt(value: number): string;
+/**
+ * Escapes a string value for DXF. A caret starts a control-character escape in
+ * DXF, and AutoCAD discards the drawing when it meets a bare one, so a literal
+ * caret is written as a caret and a space.
+ *
+ * With `ascii`, characters outside ASCII become `\U+XXXX`, which is how DXF
+ * versions before 2007 carry them. Later versions are UTF-8 and need no escape.
+ */
+export declare function dxfText(value: string, ascii?: boolean): string;

package/dist/format.js

@@ -3,3 +3,22 @@ export function fmt(value) {
     const rounded = Number(value.toFixed(6));
     return Object.is(rounded, -0) ? "0" : String(rounded);
 }
+/**
+ * Escapes a string value for DXF. A caret starts a control-character escape in
+ * DXF, and AutoCAD discards the drawing when it meets a bare one, so a literal
+ * caret is written as a caret and a space.
+ *
+ * With `ascii`, characters outside ASCII become `\U+XXXX`, which is how DXF
+ * versions before 2007 carry them. Later versions are UTF-8 and need no escape.
+ */
+export function dxfText(value, ascii = false) {
+    const escaped = value.replaceAll("^", "^ ");
+    if (!ascii)
+        return escaped;
+    let out = "";
+    for (let i = 0; i < escaped.length; i++) {
+        const code = escaped.charCodeAt(i);
+        out += code < 0x80 ? escaped[i] : `\\U+${code.toString(16).toUpperCase().padStart(4, "0")}`;
+    }
+    return out;
+}

package/dist/index.d.ts

@@ -1,3 +1,5 @@
-export { createDrawing, DrawingBuilder, sweep, type Arc, type Circle, type Drawing, type DrawingOptions, type Entity, type Layer, type LayerOptions, type Line, type Point, type Polyline, type Text, type TextOptions, type Units, } from "./drawing.ts";
-export { toDXF } from "./dxf.ts";
+export { createDrawing, DrawingBuilder, sweep, type Arc, type Circle, type Drawing, type DrawingOptions, type DxfVersion, type Entity, type Layer, type LayerOptions, type Line, type Point, type Polyline, type Text, type TextOptions, type Units, } from "./drawing.ts";
+export { toDXF, type DxfOptions } from "./dxf.ts";
+export { DrawingError, lint, type Diagnostic, type LintOptions, type LintRule } from "./lint.ts";
+export type { Aci, LayerColor, LayerName, Positive } from "./rules.ts";
 export { toSVG, type SvgOptions } from "./svg.ts";

package/dist/index.js

@@ -1,3 +1,4 @@
 export { createDrawing, DrawingBuilder, sweep, } from "./drawing.js";
 export { toDXF } from "./dxf.js";
+export { DrawingError, lint } from "./lint.js";
 export { toSVG } from "./svg.js";

package/dist/lint.d.ts

@@ -0,0 +1,30 @@
+import type { Drawing, DxfVersion } from "./drawing.ts";
+export type LintRule = "units" | "layer-name" | "duplicate-layer" | "layer-color" | "undefined-layer" | "geometry" | "text" | "zero-length";
+export interface Diagnostic {
+    readonly rule: LintRule;
+    /** An error means AutoCAD rejects, repairs or garbles the output. `toDXF` refuses to write it. */
+    readonly severity: "error" | "warning";
+    readonly message: string;
+    /** The layer the problem is in, when it is a layer problem. */
+    readonly layer?: string;
+    /** Index into `drawing.entities`, when it is an entity problem. */
+    readonly entity?: number;
+}
+export interface LintOptions {
+    /** The DXF version to check against. Defaults to the drawing's own. */
+    readonly version?: DxfVersion;
+}
+/**
+ * Checks a drawing against the rules AutoCAD enforces when it opens DXF.
+ *
+ * A drawing made with `createDrawing()` already passes the error rules for its
+ * own DXF version, because the builder throws at the offending call. `lint`
+ * matters when a `Drawing` was built by hand or by other code, when it is
+ * exported as a different version than it was built for, and for warnings.
+ */
+export declare function lint(drawing: Drawing, options?: LintOptions): Diagnostic[];
+/** Thrown by `toDXF` when a drawing has lint errors for the version being written. */
+export declare class DrawingError extends Error {
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(diagnostics: readonly Diagnostic[]);
+}