tsdraft 0.1.0 → 0.2.0

package/dist/lint.js

@@ -0,0 +1,109 @@
+import { layerColorProblem, layerNameProblem, textProblem } from "./rules.js";
+/**
+ * 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 function lint(drawing, options = {}) {
+    const version = options.version ?? drawing.dxf;
+    const out = [];
+    if (!["in", "ft", "mm", "cm", "m"].includes(drawing.units)) {
+        out.push({
+            rule: "units",
+            severity: "error",
+            message: `Unknown units: ${JSON.stringify(drawing.units)}`,
+        });
+    }
+    const seen = new Set();
+    for (const layer of drawing.layers) {
+        const error = (rule, message) => out.push({ rule, severity: "error", message, layer: layer.name });
+        const nameProblem = layerNameProblem(layer.name, version);
+        if (nameProblem)
+            error("layer-name", `Layer ${JSON.stringify(layer.name)}: ${nameProblem}`);
+        const colorProblem = layerColorProblem(layer.color);
+        if (colorProblem)
+            error("layer-color", `Layer ${JSON.stringify(layer.name)}: ${colorProblem}`);
+        const key = layer.name.toLowerCase();
+        if (seen.has(key)) {
+            error("duplicate-layer", `Layer ${JSON.stringify(layer.name)} is defined twice. CAD ignores case in layer names`);
+        }
+        seen.add(key);
+    }
+    if (!seen.has("0")) {
+        out.push({ rule: "undefined-layer", severity: "error", message: 'Layer "0" is missing' });
+    }
+    drawing.entities.forEach((entity, index) => {
+        const add = (rule, severity, problem) => out.push({ rule, severity, message: `${entity.kind} #${index}: ${problem}`, entity: index });
+        if (!seen.has(entity.layer.toLowerCase())) {
+            add("undefined-layer", "error", `layer ${JSON.stringify(entity.layer)} is not defined`);
+        }
+        for (const problem of geometryProblems(entity))
+            add("geometry", "error", problem);
+        if (entity.kind === "text") {
+            const problem = textProblem(entity.value);
+            if (problem)
+                add("text", "error", problem);
+        }
+        if (entity.kind === "line" && same(entity.from, entity.to)) {
+            add("zero-length", "warning", "the line has no length");
+        }
+    });
+    return out;
+}
+/** Thrown by `toDXF` when a drawing has lint errors for the version being written. */
+export class DrawingError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        const shown = diagnostics.slice(0, 10).map((d) => `- ${d.message}`);
+        const more = diagnostics.length > 10 ? [`- and ${diagnostics.length - 10} more`] : [];
+        super(["The drawing cannot be written as DXF:", ...shown, ...more].join("\n"));
+        this.name = "DrawingError";
+        this.diagnostics = diagnostics;
+    }
+}
+function geometryProblems(e) {
+    const out = [];
+    const finite = (label, ...values) => {
+        if (!values.every(Number.isFinite))
+            out.push(`${label} must be finite numbers`);
+    };
+    const positive = (label, value) => {
+        if (!(Number.isFinite(value) && value > 0))
+            out.push(`${label} must be greater than 0`);
+    };
+    switch (e.kind) {
+        case "line":
+            finite("its points", ...e.from, ...e.to);
+            break;
+        case "polyline":
+            if (e.points.length < 2)
+                out.push("a polyline needs at least 2 points");
+            finite("its points", ...e.points.flat());
+            break;
+        case "circle":
+            finite("its center", ...e.center);
+            positive("its radius", e.radius);
+            break;
+        case "arc":
+            finite("its center", ...e.center);
+            positive("its radius", e.radius);
+            if (![e.startAngle, e.endAngle].every((a) => Number.isFinite(a) && a >= 0 && a < 360)) {
+                out.push("its angles must be from 0 up to 360");
+            }
+            else if (e.startAngle === e.endAngle) {
+                out.push("its start and end angles must differ");
+            }
+            break;
+        case "text":
+            finite("its position and rotation", ...e.at, e.rotation);
+            positive("its height", e.height);
+            break;
+    }
+    return out;
+}
+function same(a, b) {
+    return a[0] === b[0] && a[1] === b[1];
+}

package/dist/rules.d.ts

@@ -0,0 +1,33 @@
+import type { DxfVersion } from "./drawing.ts";
+declare const NAME_EMPTY = "Layer names cannot be empty";
+declare const NAME_CHARS = "Layer names cannot contain < > / \\ \" : ; ? * | = ` ^ , or line breaks";
+declare const NAME_EDGE = "Layer names cannot start or end with a space";
+declare const NAME_R12_CHARS = "R12 layer names can only use letters, digits, $, - and _. Use DXF version \"R2018\" for other characters";
+declare const NAME_R12_LENGTH = "R12 layer names cannot be longer than 31 characters. Use DXF version \"R2018\" for longer names";
+declare const COLOR = "A layer color must be an AutoCAD Color Index integer from 1 to 255";
+declare const POSITIVE = "This value must be greater than 0";
+type ForbiddenChar = "<" | ">" | "/" | "\\" | '"' | ":" | ";" | "?" | "*" | "|" | "=" | "`" | "^" | "," | "\n" | "\r" | "\t";
+type Chars<S extends string, Found = never> = S extends `${infer C}${infer Rest}` ? Chars<Rest, Found | C> : Found;
+type R12Char = Chars<"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$_-">;
+/** Walks the name one character at a time, counting, so it can check both the characters and the length. */
+type R12Name<N extends string, Rest extends string = N, Count extends 0[] = []> = Count["length"] extends 32 ? typeof NAME_R12_LENGTH : Rest extends `${infer C}${infer Tail}` ? C extends R12Char ? R12Name<N, Tail, [...Count, 0]> : typeof NAME_R12_CHARS : N;
+/**
+ * Resolves to `N` when it is a valid layer name for DXF version `V`, and to the
+ * error message otherwise, so the compiler reports the reason. Names that are
+ * not literals pass the compiler and are checked when the code runs.
+ */
+export type LayerName<N extends string, V extends DxfVersion> = string extends N ? N : N extends "" ? typeof NAME_EMPTY : N extends `${string}${ForbiddenChar}${string}` ? typeof NAME_CHARS : N extends ` ${string}` | `${string} ` ? typeof NAME_EDGE : V extends "R12" ? R12Name<N> : N;
+type Enumerate<N extends number, A extends number[] = []> = A["length"] extends N ? A[number] : Enumerate<N, [...A, A["length"]]>;
+/** AutoCAD Color Index: an integer from 1 to 255. */
+export type Aci = Exclude<Enumerate<256>, 0>;
+/** Resolves to `C` when it is a valid layer color, and to the error message otherwise. */
+export type LayerColor<C extends number> = number extends C ? C : C extends Aci ? C : typeof COLOR;
+/** Resolves to `N` when it is greater than 0, and to the error message otherwise. */
+export type Positive<N extends number> = number extends N ? N : `${N}` extends `-${string}` | "0" ? typeof POSITIVE : N;
+/** Returns what is wrong with a layer name for a DXF version, or undefined when it is valid. */
+export declare function layerNameProblem(name: string, version: DxfVersion): string | undefined;
+/** Returns what is wrong with a layer color, or undefined when it is valid. */
+export declare function layerColorProblem(color: number): string | undefined;
+/** Returns what is wrong with a single-line text value, or undefined when it is valid. */
+export declare function textProblem(value: string): string | undefined;
+export {};

package/dist/rules.js

@@ -0,0 +1,56 @@
+const NAME_EMPTY = "Layer names cannot be empty";
+const NAME_CHARS = 'Layer names cannot contain < > / \\ " : ; ? * | = ` ^ , or line breaks';
+const NAME_EDGE = "Layer names cannot start or end with a space";
+const NAME_LENGTH = "Layer names cannot be longer than 255 characters";
+const NAME_R12_CHARS = 'R12 layer names can only use letters, digits, $, - and _. Use DXF version "R2018" for other characters';
+const NAME_R12_LENGTH = 'R12 layer names cannot be longer than 31 characters. Use DXF version "R2018" for longer names';
+const COLOR = "A layer color must be an AutoCAD Color Index integer from 1 to 255";
+const POSITIVE = "This value must be greater than 0";
+/** Returns what is wrong with a layer name for a DXF version, or undefined when it is valid. */
+export function layerNameProblem(name, version) {
+    if (name.length === 0)
+        return NAME_EMPTY;
+    if (/[<>/\\":;?*|=`^,]/.test(name) || hasControl(name) || hasAstral(name))
+        return NAME_CHARS;
+    if (name !== name.trim())
+        return NAME_EDGE;
+    if (name.length > 255)
+        return NAME_LENGTH;
+    if (version === "R12") {
+        if (!/^[A-Za-z0-9$_-]+$/.test(name))
+            return NAME_R12_CHARS;
+        if (name.length > 31)
+            return NAME_R12_LENGTH;
+    }
+    return undefined;
+}
+/** Returns what is wrong with a layer color, or undefined when it is valid. */
+export function layerColorProblem(color) {
+    return Number.isInteger(color) && color >= 1 && color <= 255 ? undefined : COLOR;
+}
+/** Returns what is wrong with a single-line text value, or undefined when it is valid. */
+export function textProblem(value) {
+    if (hasControl(value))
+        return "Text must be a single line with no control characters";
+    if (hasAstral(value)) {
+        return "Text cannot contain emoji or other characters above U+FFFF, because AutoCAD cannot read them from DXF";
+    }
+    return undefined;
+}
+function hasControl(value) {
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x20 || code === 0x7f)
+            return true;
+    }
+    return false;
+}
+/** True when the string has a character above U+FFFF, which JavaScript stores as a surrogate pair. */
+function hasAstral(value) {
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code >= 0xd800 && code <= 0xdfff)
+            return true;
+    }
+    return false;
+}

package/dist/svg.js

@@ -1,4 +1,5 @@
 import { sweep } from "./drawing.js";
+import { extents } from "./extents.js";
 import { fmt } from "./format.js";
 /** Screen colors for the standard ACI colors 1 to 7. Other indexes draw in currentColor. */
 const ACI = {
@@ -61,45 +62,6 @@ function entityToSvg(e, color) {
         }
     }
 }
-/** Approximate extents. Arcs use their full circle; text assumes 0.6 × height per character. */
-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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsdraft",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "2D CAD drawings as TypeScript: write the drawing in code, export DXF and SVG.",
   "keywords": [
     "2d",
@@ -22,7 +22,8 @@
     "url": "git+https://github.com/Surfside-Software/tsdraft.git"
   },
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "type": "module",
   "sideEffects": false,
@@ -30,7 +31,8 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
     "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
@@ -43,6 +45,7 @@
     "fmt:check": "oxfmt --check",
     "test": "node --test test/*.test.ts",
     "test:package": "node scripts/package-smoke.ts",
+    "test:cad": "node scripts/cad-check.ts",
     "example": "node examples/site-plan.ts",
     "verify": "pnpm fmt:check && pnpm lint && pnpm check && pnpm test && pnpm test:package"
   },