tsdraft 0.2.2 → 0.4.0

package/dist/rules.js

@@ -1,39 +1,85 @@
 import { isTooLarge, written, writtenAngle } from "./format.js";
+import { BUILT_IN_LINETYPES, builtInLinetype, LINEWEIGHTS, patternLength } from "./linetypes.js";
 import { layerAuditKey, layerKey, rejectedNameCharacter, } from "./layers.js";
-const NAME_EMPTY = "Layer names cannot be empty";
-const NAME_CHARS = 'Layer names cannot contain < > / \\ " : ; ? * | = ` ^ , or line breaks';
-const NAME_REJECTED = "Layer names cannot contain a character AutoCAD rejects or replaces in names, such as a zero-width space or the ohm sign U+2126. The README lists them";
-const NAME_EDGE = "Layer names cannot start or end with a space";
-const NAME_LENGTH = "Layer names cannot be longer than 255 characters";
+// AutoCAD holds layer names and linetype names to the same rules, so each rule has a message
+// for each kind of name.
+const LAYER_NAMES = {
+    empty: "Layer names cannot be empty",
+    chars: 'Layer names cannot contain < > / \\ " : ; ? * | = ` ^ , or line breaks',
+    rejected: "Layer names cannot contain a character AutoCAD rejects or replaces in names, such as a zero-width space or the ohm sign U+2126. docs/layer-names.md in the tsdraft repository lists them",
+    edge: "Layer names cannot start or end with a space",
+    length: "Layer names cannot be longer than 255 characters",
+};
+const LINETYPE_NAMES = {
+    empty: "Linetype names cannot be empty",
+    chars: 'Linetype names cannot contain < > / \\ " : ; ? * | = ` ^ , or line breaks',
+    rejected: "Linetype names cannot contain a character AutoCAD rejects or replaces in names, such as a zero-width space or the ohm sign U+2126. docs/layer-names.md in the tsdraft repository lists them",
+    edge: "Linetype names cannot start or end with a space",
+    length: "Linetype 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";
 const WRITTEN_AS_ZERO = "This value is written as 0, because tsdraft writes 6 decimals. Use 0.000001 or more";
 const TOO_LARGE = "This value must be under 1e100, because AutoCAD reads only two exponent digits from DXF and would take 1e+100 for 1e+10";
+const PAPER_LENGTH = "The paper length must be greater than 0";
+const RATIO = "The ratio must be greater than 0";
 const ARC_LOST = "An arc of nearly a full turn cannot be written: its angles are the same once rounded to 6 decimals, so AutoCAD would hold an arc of no length. Draw a circle instead";
+const TEXT_CONTROL = "Text must be a single line with no control characters";
 const TEXT_PRIVATE_USE = "Text cannot contain the private-use characters U+E800 to U+E8FF, because AutoCAD replaces them when it reads DXF";
+const R12_LINETYPES = 'R12 drawings have no linetypes but Continuous, and no linetype scale. Use DXF version "R2018" for linetypes';
+const R12_LINEWEIGHTS = 'R12 drawings have no lineweights. Use DXF version "R2018" for lineweights';
+const R12_ENTITY_STYLE = 'R12 entities take no linetype or lineweight of their own. Use DXF version "R2018" for an entity linetype or lineweight';
+const R12_LAYER_STATES = 'tsdraft writes no layer states to R12 drawings. Use DXF version "R2018" for layers that are off, frozen, locked or not plotted';
+const LINEWEIGHT = "A lineweight must be one of AutoCAD's, in millimetres: 0, 0.05, 0.09, 0.13, 0.15, 0.18, 0.2, 0.25, 0.3, 0.35, 0.4, 0.5, 0.53, 0.6, 0.7, 0.8, 0.9, 1, 1.06, 1.2, 1.4, 1.58, 2 or 2.11";
+const LAYER_LINEWEIGHT = `${LINEWEIGHT}, or "Default"`;
+const ENTITY_LINEWEIGHT = `${LINEWEIGHT}, or "ByLayer", "ByBlock" or "Default"`;
+const FROZEN_CURRENT = 'Layer "0" cannot be frozen: it is the current layer, and AutoCAD does not freeze the current layer';
+const LAYER_LINETYPE = "A layer's linetype cannot be ByLayer or ByBlock. AutoCAD's AUDIT reports a layer with either";
+const BUILT_IN = "Continuous, ByLayer and ByBlock are in every drawing and cannot be defined. AutoCAD keeps its own and drops the definition";
+const PATTERN_COUNT = "A linetype pattern has 2 to 12 lengths, or none for a solid line. AutoCAD's AUDIT reports a pattern of one length, and AutoCAD discards a drawing with a pattern of more than 12";
+const PATTERN_WRITTEN_AS_ZERO = "A dash or gap of this length is written as 0, because tsdraft writes 6 decimals, and would draw as a dot. Use 0 for a dot, or a length of 0.000001 or more";
+const PATTERN_TOTAL = "A linetype pattern's lengths, added up without their signs, must be under 1e100. The total is written too, and AutoCAD reads only two exponent digits from DXF";
+const PATTERN_TYPE = "A linetype's pattern must be an array of finite numbers";
+const DESCRIPTION_LENGTH = "A linetype description cannot be longer than 249 characters, because AutoCAD cuts it there when it reads DXF";
+const ID_EMPTY = "An id cannot be empty";
+const ID_CHARS = "An id can only use the letters A to Z and a to z, digits, ., - and _";
+const ID_LENGTH = "An id cannot be longer than 64 characters";
 const TEXT_PERCENT = 'AutoCAD reads "%%" in text as the start of a control code: it draws "%%d" as a degree sign and "%%%" as one percent sign. The text is stored as written';
 /** Returns what is wrong with a layer name for a DXF version, or undefined when it is valid. */
 export function layerNameProblem(name, version) {
+    const problem = nameProblem(name, LAYER_NAMES);
+    if (problem)
+        return problem;
+    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 linetype name, or undefined when it is valid.
+ * The name may be one of the linetypes every drawing has.
+ */
+export function linetypeNameProblem(name) {
+    return nameProblem(name, LINETYPE_NAMES);
+}
+function nameProblem(name, messages) {
     if (name.length === 0)
-        return NAME_EMPTY;
+        return messages.empty;
     if (/[<>/\\":;?*|=`^,]/.test(name) || hasControl(name) || hasAstral(name))
-        return NAME_CHARS;
+        return messages.chars;
     const rejected = rejectedNameCharacter(name);
     if (rejected !== undefined)
-        return `${NAME_REJECTED}. This name has ${codePoint(rejected)}`;
+        return `${messages.rejected}. This name has ${codePoint(rejected)}`;
     // Only the ASCII space: AutoCAD takes a no-break space or any other at either end.
     if (name.startsWith(" ") || name.endsWith(" "))
-        return NAME_EDGE;
+        return messages.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 messages.length;
     return undefined;
 }
 /**
@@ -43,20 +89,120 @@ export function layerNameProblem(name, version) {
  * layers to AutoCAD and one duplicate name to AUDIT: `ΟΔΟΣ` and `οδος`,
  * `straße` and `strasse`, a composed é and a decomposed one, and a name with
  * and without a soft hyphen. `layerAuditKey` lists the kinds this covers,
- * which are those measured in AutoCAD and not all that AUDIT reports. Names
- * that are one layer to AutoCAD are not this function's concern. The rule
- * compares two names, so it has no type.
+ * which are not all that AUDIT reports. Names that are one layer to AutoCAD
+ * are not this function's concern. The rule compares two names, so it has no
+ * type.
  *
  * @param name - The name of the layer being checked.
  * @param other - The name of another layer in the drawing.
+ * @param kind - Whether the names are of layers or of linetypes, which AutoCAD compares alike.
  * @returns The problem, or undefined.
  */
-export function layerTwinProblem(name, other) {
+export function layerTwinProblem(name, other, kind = "layer") {
     if (layerKey(name) === layerKey(other) || layerAuditKey(name) !== layerAuditKey(other)) {
         return undefined;
     }
-    return `AutoCAD keeps this layer and ${JSON.stringify(other)} as two layers, but its AUDIT reports them as one duplicate name`;
+    return `AutoCAD keeps this ${kind} and ${JSON.stringify(other)} as two ${kind}s, but its AUDIT reports them as one duplicate name`;
+}
+/**
+ * Returns what is wrong with a linetype definition, or undefined when it is
+ * valid. It takes `unknown`s so that `lint` can report a drawing built by hand
+ * with a field of the wrong type.
+ */
+export function linetypeProblem(name, description, pattern) {
+    if (typeof name !== "string")
+        return "A linetype's name must be a string";
+    const nameError = linetypeNameProblem(name);
+    if (nameError)
+        return nameError;
+    if (builtInLinetype(name))
+        return BUILT_IN;
+    if (typeof description !== "string")
+        return "A linetype's description must be a string";
+    const descriptionError = textProblem(description);
+    if (descriptionError)
+        return `its description: ${descriptionError}`;
+    if (description.length > 249)
+        return DESCRIPTION_LENGTH;
+    if (!Array.isArray(pattern))
+        return PATTERN_TYPE;
+    if (pattern.length === 1 || pattern.length > 12)
+        return PATTERN_COUNT;
+    for (const length of pattern) {
+        if (typeof length !== "number" || !Number.isFinite(length))
+            return PATTERN_TYPE;
+        if (length !== 0 && written(length) === 0)
+            return `its pattern: ${PATTERN_WRITTEN_AS_ZERO}`;
+        const problem = magnitudeProblem(length);
+        if (problem)
+            return `its pattern: ${problem}`;
+    }
+    // The writers write the total of the lengths as they write each one, rounded.
+    if (isTooLarge(patternLength(pattern.map(written)))) {
+        return `its pattern: ${PATTERN_TOTAL}`;
+    }
+    return undefined;
+}
+/**
+ * Returns what is wrong with a layer or an entity that names a linetype the
+ * drawing does not have. The rule depends on the drawing, so it has no type.
+ */
+export function undefinedLinetypeProblem(name) {
+    return `Linetype ${JSON.stringify(name)} is not defined, and AutoCAD discards a drawing that uses a linetype it does not have`;
+}
+/** Returns what is wrong with the linetype a layer names, or undefined when it can be a layer's. */
+export function layerLinetypeProblem(name) {
+    const builtInName = builtInLinetype(name);
+    return builtInName === "ByLayer" || builtInName === "ByBlock" ? LAYER_LINETYPE : undefined;
+}
+/**
+ * Returns what is wrong with a lineweight, or undefined when it is valid. A
+ * layer's lineweight may also be "Default", and an entity's "ByLayer",
+ * "ByBlock" or "Default". AutoCAD discards a drawing with an entity of any
+ * other lineweight, and gives a layer of another lineweight the default.
+ *
+ * @param value - The lineweight, in millimetres or by name.
+ * @param of - Whose lineweight it is.
+ * @returns The problem, or undefined.
+ */
+export function lineweightProblem(value, of) {
+    if (value === "Default" || (of === "entity" && (value === "ByLayer" || value === "ByBlock"))) {
+        return undefined;
+    }
+    if (typeof value === "number" && LINEWEIGHTS.includes(value))
+        return undefined;
+    return of === "layer" ? LAYER_LINEWEIGHT : ENTITY_LINEWEIGHT;
+}
+/**
+ * Returns what is wrong with a layer's states, or undefined when AutoCAD takes
+ * them. tsdraft writes layer "0" as the current layer, and AutoCAD's AUDIT
+ * reports a drawing whose current layer is frozen.
+ */
+export function layerStateProblem(name, frozen) {
+    return frozen && name === "0" ? FROZEN_CURRENT : undefined;
+}
+/** Returns what is wrong with the value of a layer's `off`, `frozen`, `locked` or `plot`. */
+export function layerFlagProblem(state, value) {
+    return value === undefined || typeof value === "boolean"
+        ? undefined
+        : `${state} must be true or false`;
 }
+/**
+ * Returns what is wrong with the global linetype scale, or undefined when it is
+ * valid. AutoCAD reads a scale of 0 or less, or one written as 0, as 1.
+ */
+export function linetypeScaleProblem(value) {
+    if (!Number.isFinite(value))
+        return "This value must be a finite number";
+    return sizeProblem(value);
+}
+/** The R12 message for a feature, for `lint` and the builder. */
+export const R12_ONLY = {
+    linetypes: R12_LINETYPES,
+    lineweights: R12_LINEWEIGHTS,
+    layerStates: R12_LAYER_STATES,
+    entityStyle: R12_ENTITY_STYLE,
+};
 /** 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;
@@ -76,6 +222,29 @@ export function sizeProblem(value) {
         return POSITIVE;
     return written(value) === 0 ? WRITTEN_AS_ZERO : magnitudeProblem(value);
 }
+/**
+ * Returns what is wrong with a paper length, the ratio it plots at, or the
+ * length in drawing units they give, or undefined when the result can be
+ * written. The result is a size, so it is held to the limits of `sizeProblem`.
+ *
+ * @param length - The length on paper, which must be a finite number.
+ * @param ratio - The scale ratio, which must be a finite number.
+ * @param result - The length in drawing units.
+ * @returns The problem, or undefined.
+ */
+export function paperLengthProblem(length, ratio, result) {
+    if (!(length > 0))
+        return PAPER_LENGTH;
+    if (!(ratio > 0))
+        return RATIO;
+    if (written(result) === 0) {
+        return `The result, ${result} drawing units, is written as 0, because tsdraft writes 6 decimals. Use a longer paper length or a larger ratio`;
+    }
+    if (isTooLarge(result)) {
+        return "The result is 1e100 drawing units or more, and AutoCAD reads only two exponent digits from DXF. Use a shorter paper length or a smaller ratio";
+    }
+    return undefined;
+}
 /**
  * Returns what is wrong with the size of a number a drawing holds, or
  * undefined when AutoCAD can read it. This goes for every number that is
@@ -117,10 +286,58 @@ export function arcProblem(startAngle, endAngle) {
 export function arcIsWrittenAsPoint(startAngle, endAngle) {
     return roundsToOneAngle(startAngle, endAngle) && isShortArc(startAngle, endAngle);
 }
+/**
+ * Returns what is wrong with an entity id, or undefined when it is valid. It takes `unknown` so
+ * that `lint` can report a drawing built by hand with an id of the wrong type.
+ */
+export function idProblem(id) {
+    if (typeof id !== "string")
+        return "An id must be a string";
+    if (id.length === 0)
+        return ID_EMPTY;
+    if (!/^[A-Za-z0-9._-]+$/.test(id))
+        return ID_CHARS;
+    return id.length > 64 ? ID_LENGTH : undefined;
+}
+/** The form two ids are compared in: `Door-1` and `door-1` are one id. */
+export function idKey(id) {
+    return id.toLowerCase();
+}
+/**
+ * Returns what is wrong with a second entity that has an id the drawing already has. The rule
+ * depends on the drawing, so it has no type.
+ *
+ * @param id - The id of the second entity.
+ * @param first - The id as the first entity spells it.
+ */
+export function duplicateIdProblem(id, first) {
+    const spelled = first === id ? "" : `, as ${JSON.stringify(first)}`;
+    return `The id ${JSON.stringify(id)} is already used${spelled}. An id names one entity, and ids are compared without regard to case`;
+}
+/** Returns what is wrong with a drawing's format version, or undefined when tsdraft reads it. */
+export function formatProblem(format) {
+    // Negative zero is refused: it would be written as -0, and so change the drawing's JSON.
+    if (Object.is(format, 0))
+        return undefined;
+    return format === undefined
+        ? "The drawing has no format version. A Drawing has format: 0"
+        : `Unknown Drawing format ${shown(format)}. This version of tsdraft reads format 0`;
+}
+/** A value of any type for a message: a string quoted, a number as it is, anything else by kind. */
+export function shown(value) {
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (Object.is(value, -0))
+        return "-0";
+    if (typeof value === "number" || typeof value === "boolean" || value == null) {
+        return String(value);
+    }
+    return Array.isArray(value) ? "an array" : `a value of type ${typeof value}`;
+}
 /** 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";
+        return TEXT_CONTROL;
     if (hasAstral(value)) {
         return "Text cannot contain emoji or other characters above U+FFFF, because AutoCAD cannot read them from DXF";
     }

package/dist/svg.d.ts

@@ -2,8 +2,17 @@ import { type Drawing } from "./drawing.ts";
 export interface SvgOptions {
     /** Margin around the drawing's extents, in drawing units. Defaults to 2% of the larger side. */
     readonly margin?: number;
-    /** Stroke width in screen pixels; it stays constant when the SVG scales. */
+    /**
+     * Stroke width in screen pixels of a line of the default lineweight, 0.25 mm. Other
+     * lineweights are drawn in proportion. It stays constant when the SVG scales.
+     */
     readonly strokeWidth?: number;
 }
-/** Renders a preview SVG. Model Y points up, so the drawing group flips Y. */
+/**
+ * Renders a preview SVG. Model Y points up, so the drawing group flips Y. Entities on layers
+ * that are off or frozen are left out. Dashed lines are cut into their dashes, scaled by the
+ * drawing's linetype scale, and each line is as wide as its lineweight. Each entity's element
+ * has its layer in `data-layer`, its index in `drawing.entities` in `data-entity`, and its `id`,
+ * when it has one, in `data-id`.
+ */
 export declare function toSVG(drawing: Drawing, options?: SvgOptions): string;

package/dist/svg.js

@@ -2,6 +2,7 @@ import { sweep } from "./drawing.js";
 import { extents } from "./extents.js";
 import { fmt } from "./format.js";
 import { layerKey } from "./layers.js";
+import { builtInLinetype, lineweightCode } from "./linetypes.js";
 /** Screen colors for the standard ACI colors 1 to 7. Other indexes draw in currentColor. */
 const ACI = {
     1: "#ff0000",
@@ -12,20 +13,53 @@ const ACI = {
     6: "#ff00ff",
     7: "currentColor",
 };
-/** Renders a preview SVG. Model Y points up, so the drawing group flips Y. */
+/** AutoCAD draws a lineweight of "Default" at its LWDEFAULT, 0.25 mm. */
+const DEFAULT_LINEWEIGHT = 25;
+/**
+ * The most dashes one entity is cut into. AutoCAD draws a line solid when its pattern is too
+ * fine to show, and so does the preview.
+ */
+const MAX_DASHES = 10000;
+/**
+ * Renders a preview SVG. Model Y points up, so the drawing group flips Y. Entities on layers
+ * that are off or frozen are left out. Dashed lines are cut into their dashes, scaled by the
+ * drawing's linetype scale, and each line is as wide as its lineweight. Each entity's element
+ * has its layer in `data-layer`, its index in `drawing.entities` in `data-entity`, and its `id`,
+ * when it has one, in `data-id`.
+ */
 export function toSVG(drawing, options = {}) {
-    const [minX, minY, maxX, maxY] = extents(drawing.entities);
+    // Keyed as AutoCAD looks layers up, so an entity on `wall` takes the color of layer `WALL`.
+    const layers = new Map(drawing.layers.map((l) => [layerKey(l.name), l]));
+    // Each entity keeps its index in `drawing.entities`, for its element's data-entity.
+    const shown = [...drawing.entities.entries()].filter(([, e]) => {
+        const layer = layers.get(layerKey(e.layer));
+        return !layer?.off && !layer?.frozen;
+    });
+    const [minX, minY, maxX, maxY] = extents(shown.map(([, e]) => e));
     const margin = options.margin ?? Math.max(maxX - minX, maxY - minY, 1) * 0.02;
     const x = minX - margin;
     const y = -(maxY + margin);
     const w = maxX - minX + margin * 2;
     const h = maxY - minY + margin * 2;
-    // Keyed as AutoCAD looks layers up, so an entity on `wall` takes the color of layer `WALL`.
-    const colors = new Map(drawing.layers.map((l) => [layerKey(l.name), ACI[l.color] ?? "currentColor"]));
+    const patterns = new Map((drawing.linetypes ?? []).map((t) => [layerKey(t.name), alternating(t.pattern)]));
+    const scale = drawing.linetypeScale ?? 1;
     const stroke = options.strokeWidth ?? 1;
-    const body = drawing.entities
-        .map((e) => entityToSvg(e, colors.get(layerKey(e.layer)) ?? "currentColor"))
-        .join("\n    ");
+    const pen = (e) => {
+        const layer = layers.get(layerKey(e.layer));
+        const byLayer = e.linetype === undefined || builtInLinetype(e.linetype) === "ByLayer";
+        const linetype = byLayer ? layer?.linetype : e.linetype;
+        const pattern = linetype === undefined ? undefined : patterns.get(layerKey(linetype));
+        const weight = e.lineweight === undefined || e.lineweight === "ByLayer"
+            ? (layer?.lineweight ?? "Default")
+            : e.lineweight;
+        const code = lineweightCode(weight);
+        return {
+            color: ACI[layer?.color ?? 7] ?? "currentColor",
+            dashes: pattern?.map((length) => length * scale),
+            lineweight: code < 0 ? DEFAULT_LINEWEIGHT : code,
+        };
+    };
+    const body = shown.map(([i, e]) => entityToSvg(e, i, pen(e), stroke)).join("\n    ");
     return [
         `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${fmt(x)} ${fmt(y)} ${fmt(w)} ${fmt(h)}">`,
         `  <g transform="scale(1 -1)" fill="none" stroke-width="${fmt(stroke)}" vector-effect="non-scaling-stroke">`,
@@ -35,8 +69,20 @@ export function toSVG(drawing, options = {}) {
         ``,
     ].join("\n");
 }
-function entityToSvg(e, color) {
-    const s = `stroke="${color}" vector-effect="non-scaling-stroke" data-layer="${esc(e.layer)}"`;
+function entityToSvg(e, index, pen, stroke) {
+    // A lineweight of 0 draws as the thinnest line, as in AutoCAD.
+    const width = pen.lineweight === DEFAULT_LINEWEIGHT
+        ? ""
+        : ` stroke-width="${fmt((stroke * Math.max(pen.lineweight, 5)) / DEFAULT_LINEWEIGHT)}"`;
+    const mark = `data-layer="${esc(e.layer)}" data-entity="${index}"${e.id === undefined ? "" : ` data-id="${esc(e.id)}"`}`;
+    const s = `stroke="${pen.color}"${width} vector-effect="non-scaling-stroke" ${mark}`;
+    if (e.kind !== "text" && pen.dashes) {
+        const d = dashedPath(e, pen.dashes);
+        // A pattern with a dot draws it as a round cap on a path of no length.
+        const cap = pen.dashes.includes(0) ? ` stroke-linecap="round"` : "";
+        if (d !== undefined)
+            return `<path d="${d}"${cap} ${s}/>`;
+    }
     switch (e.kind) {
         case "line":
             return `<line x1="${fmt(e.from[0])}" y1="${fmt(e.from[1])}" x2="${fmt(e.to[0])}" y2="${fmt(e.to[1])}" ${s}/>`;
@@ -65,9 +111,96 @@ function entityToSvg(e, color) {
         case "text": {
             // Undo the group's Y flip so the text reads upright, then apply CAD rotation.
             const t = `translate(${fmt(e.at[0])} ${fmt(e.at[1])}) scale(1 -1)${e.rotation ? ` rotate(${fmt(-e.rotation)})` : ""}`;
-            return `<text transform="${t}" font-size="${fmt(e.height)}" font-family="monospace" fill="${color}" stroke="none" data-layer="${esc(e.layer)}">${esc(e.value)}</text>`;
+            return `<text transform="${t}" font-size="${fmt(e.height)}" font-family="monospace" fill="${pen.color}" stroke="none" ${mark}>${esc(e.value)}</text>`;
+        }
+    }
+}
+/**
+ * A linetype pattern as SVG thinks of dashes: dash, gap, dash, gap, starting with a dash and
+ * of even length. Dashes or gaps side by side are joined, and a pattern that starts with a gap
+ * is turned to start with the dash after it. Undefined for a pattern with no gap, with no dash
+ * or dot, or with no length, and the caller then draws the entity solid.
+ */
+function alternating(pattern) {
+    const first = pattern.findIndex((length) => length >= 0);
+    if (first < 0)
+        return undefined;
+    const runs = [];
+    // A dot is a dash of no length. Runs alternate dash, gap, so an odd index is a gap.
+    for (const length of [...pattern.slice(first), ...pattern.slice(0, first)]) {
+        if (runs.length % 2 === (length < 0 ? 0 : 1))
+            runs[runs.length - 1] += Math.abs(length);
+        else
+            runs.push(Math.abs(length));
+    }
+    if (runs.length < 2)
+        return undefined;
+    if (runs.length % 2 === 1)
+        runs[0] += runs.pop();
+    return runs.reduce((a, b) => a + b, 0) > 0 ? runs : undefined;
+}
+/**
+ * An entity cut into the dashes of its pattern, as path data, or undefined when the pattern
+ * is too fine for the entity and it draws solid. A polyline starts the pattern again at each
+ * vertex, as AutoCAD does unless told otherwise.
+ */
+function dashedPath(e, dashes) {
+    const total = dashes.reduce((a, b) => a + b, 0);
+    const out = [];
+    /** Cuts a stretch of the given length, and draws each dash from `from` to `to` along it. */
+    const cut = (length, draw) => {
+        if (length / total > MAX_DASHES)
+            return false;
+        let at = 0;
+        for (let i = 0; at < length; i = (i + 1) % dashes.length) {
+            const end = Math.min(at + dashes[i], length);
+            if (i % 2 === 0)
+                out.push(draw(at, end));
+            at += dashes[i];
         }
+        return true;
+    };
+    const straight = (a, b) => {
+        const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        const along = (t) => `${fmt(a[0] + ((b[0] - a[0]) * t) / length)} ${fmt(a[1] + ((b[1] - a[1]) * t) / length)}`;
+        return length === 0 || cut(length, (from, to) => `M ${along(from)} L ${along(to)}`);
+    };
+    const round = (center, radius, start, turn) => {
+        const along = (t) => {
+            const angle = rad(start) + t / radius;
+            return `${fmt(center[0] + radius * Math.cos(angle))} ${fmt(center[1] + radius * Math.sin(angle))}`;
+        };
+        return cut(radius * rad(turn), (from, to) => {
+            // SVG draws no arc between two equal points, so a dot is a line of no length.
+            if (to === from)
+                return `M ${along(from)} L ${along(to)}`;
+            const arc = `A ${fmt(radius)} ${fmt(radius)} 0`;
+            // A dash of a full turn ends where it starts, so it is drawn as two halves.
+            if ((to - from) / radius > Math.PI && along(from) === along(to)) {
+                return `M ${along(from)} ${arc} 0 1 ${along((from + to) / 2)} ${arc} 0 1 ${along(to)}`;
+            }
+            const large = (to - from) / radius > Math.PI ? 1 : 0;
+            return `M ${along(from)} ${arc} ${large} 1 ${along(to)}`;
+        });
+    };
+    let ok;
+    switch (e.kind) {
+        case "line":
+            ok = straight(e.from, e.to);
+            break;
+        case "polyline": {
+            const points = e.closed ? [...e.points, e.points[0]] : e.points;
+            ok = points.slice(1).every((p, i) => straight(points[i], p));
+            break;
+        }
+        case "circle":
+            ok = round(e.center, e.radius, 0, 360);
+            break;
+        case "arc":
+            ok = round(e.center, e.radius, e.startAngle, sweep(e.startAngle, e.endAngle));
+            break;
     }
+    return ok && out.length > 0 ? out.join(" ") : undefined;
 }
 function rad(degrees) {
     return (degrees * Math.PI) / 180;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsdraft",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "2D CAD drawings as TypeScript: write the drawing in code, export DXF and SVG.",
   "keywords": [
     "2d",
@@ -9,7 +9,9 @@
     "cad",
     "drafting",
     "drawing",
-    "dxf"
+    "dxf",
+    "svg",
+    "typescript"
   ],
   "homepage": "https://github.com/Surfside-Software/tsdraft#readme",
   "bugs": {
@@ -45,8 +47,8 @@
     "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",
+    "example": "node examples/site-plan.ts && node examples/outdoor-kitchen.ts",
+    "readme:drawing": "node scripts/readme-drawing.ts",
     "verify": "pnpm fmt:check && pnpm lint && pnpm check && pnpm test && pnpm test:package"
   },
   "devDependencies": {