tsdraft 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.2.2
+
+Found by opening tsdraft's output in AutoCAD 2025.
+
+- Fixed: AutoCAD keeps two layers such as `straße` and `STRASSE` apart, but its
+  `AUDIT` reports them as a duplicate name. `lint` now reports the second layer
+  as a duplicate, and the builder throws at the `layer()` call. It does so for
+  the kinds of pair measured in AutoCAD, in either letter case and inside longer
+  names:
+  - a letter and the letters it stands for, such as `ß` and `ss`, `æ` and `ae`,
+    `œ` and `oe`, `ij` and `ij`, `fi` and `fi`, `dž` and `dž`, and `þ` and `th`;
+  - a composed character and its decomposed form, such as `é`;
+  - a name with a soft hyphen inside it or in front of it and the same name
+    without.
+
+  This is not all that `AUDIT` reports. The README lists what is covered and
+  what is left out.
+
+- When an entity names its layer by the other spelling of such a pair, the
+  undefined-layer error now says which declared layer AutoCAD does not take it
+  for. AutoCAD adds a layer for the entity, and `AUDIT` reports a duplicate name.
+- `pnpm test:cad` checks each kind of pair against AutoCAD, and 600 longer names
+  beside respellings of themselves.
+
 ## 0.2.1
 
 Every fix below was found by opening tsdraft's output in AutoCAD 2025.

package/README.md

@@ -162,18 +162,48 @@ entity's layer as undefined:
 - Georgian, Cherokee and most other letters that gained a case after Unicode
   5.1.
 
-Declaring both spellings as layers is an error too for some of these pairs,
-among them `ΟΔΟΣ` and `οδος`, `Ÿ` and `ÿ`, and `ß` and `ẞ`. AutoCAD keeps two
-layers, and its `AUDIT` then reports a duplicate name.
-
-`AUDIT` compares names more loosely than `lint` can follow in full. It reports
-each of these pairs as a duplicate name while AutoCAD keeps both layers, and
-`lint` does not catch them:
-
-- A letter and the two letters it stands for: `ß` and `ss`, `æ` and `ae`, `œ`
-  and `oe`, `ij` and `ij`, `fi` and `fi`, `dž` and `dž`, `þ` and `th`.
-- A composed letter such as `é` and its decomposed form.
-- Names that differ only by a soft hyphen.
+Where `AUDIT` would take the entity's spelling for the declared layer's, as it
+does for `STRASSE` and `straße`, the message says so. AutoCAD adds a layer for
+the entity, and `AUDIT` then reports a duplicate name.
+
+### Layer names that AUDIT calls duplicates
+
+AutoCAD's `AUDIT` compares layer names another way than AutoCAD looks them up.
+It reports "Duplicate name" for some pairs of layers that AutoCAD keeps as two.
+`lint` reports the second layer of such a pair as a duplicate, which is an
+error, for these kinds of pair. Each kind holds in either letter case and
+inside a longer name, so `Hauptstraße 12` and `HAUPTSTRASSE 12` are a pair.
+
+- Single letters: `σ` and `ς`, `Ÿ` and `ÿ`, `ß` and `ẞ`, a title-case digraph
+  such as `Dž` and `dž`, and a few others.
+- A letter and the letters it stands for: `ß` and `ss`, `æ` and `ae`, `œ` and
+  `oe`, `ij` and `ij`, `þ` and `th`, `dž` and `dž`, `lj` and `lj`, `nj` and `nj`,
+  `dz` and `dz`, the ligatures `ff`, `fi`, `fl`, `ffi`, `ffl` and `st`, and `ȸ`, `ȹ`,
+  `ʪ`, `ʫ`, `ꜳ`, `ꜵ`, `ꜷ`, `ꜹ`, `ꜽ`, `ꝏ` and `ᴂ`.
+- A composed character and its decomposed form, such as `é` and an `e` with a
+  combining acute accent, with its marks in any order Unicode counts as the
+  same, such as a dot below before or after a circumflex. Hangul syllables are
+  an exception, and so are 40 Arabic, Indic, Myanmar, kana, Hebrew and CJK
+  compatibility characters: `AUDIT` keeps those apart from their decomposed
+  forms.
+- A name with a soft hyphen, U+00AD, inside it or in front of it, and the same
+  name without.
+
+This is what was measured in AutoCAD 2025. It is not AutoCAD's whole comparison,
+so a drawing that passes `lint` can still get a "Duplicate name" from `AUDIT`.
+The rule is kept narrow so that it does not go the other way: in over 20,000
+pairs tried, `lint` reported none that `AUDIT` accepts. What it leaves out:
+
+- A name that ends with a soft hyphen and the same name without it, and a soft
+  hyphen in front of a combining mark or a Hangul jamo. `AUDIT` reports some of
+  those pairs and not others. It does not report `coop` and `coop` followed by a
+  soft hyphen. Two names that both end with a soft hyphen are compared like any
+  others.
+- Compatibility characters that `AUDIT` takes for their plain forms, such as a
+  modifier letter `ʰ` and `h`, `㎏` and `kg`, and Arabic presentation forms.
+- Characters that `AUDIT` cannot tell from an unassigned one, such as `Ԥ`,
+  U+0524, and `Ꙡ`, U+A660. Two names that differ only in such characters are
+  duplicates to it.
 
 ### Layer name characters
 

package/dist/layers.d.ts

@@ -33,13 +33,24 @@ export declare function rejectedNameCharacter(name: string): string | undefined;
 export declare function layerKey(name: string): string;
 /**
  * The form of a layer name that AutoCAD's AUDIT compares when it looks for
- * duplicate names. AUDIT takes a few more letters for the same than the layer
- * table does, so two layers can have different `layerKey`s and still be an
- * AUDIT error.
+ * duplicate names. AUDIT takes more names for the same than the layer table
+ * does, so two layers can have different `layerKey`s and still be an AUDIT
+ * error. Two names with the same key here are such a pair, unless they have
+ * the same `layerKey` too.
  *
- * This covers the single letters AUDIT adds, and not everything it reports:
- * it also calls `straße` and `strasse`, `æ` and `ae`, and a composed é and its
- * decomposed form duplicates, which this key keeps apart.
+ * The key follows the kinds of pair measured in AutoCAD 2025:
+ *
+ * - A few single letters, such as σ and ς.
+ * - A letter and the letters it stands for, such as ß and `ss`.
+ * - A composed character and its decomposed form, such as é and `e` with a
+ *   combining acute accent, with its marks in any order Unicode counts as the
+ *   same, such as a dot below before or after a circumflex.
+ * - A name with a soft hyphen inside it or in front of it and the same name
+ *   without.
+ *
+ * It is not AUDIT's whole comparison. AUDIT also takes some compatibility
+ * characters for their plain forms, and cannot tell two characters apart when
+ * it knows neither.
  *
  * @param name - The layer name.
  * @returns The key to find AUDIT's duplicate names by.

package/dist/layers.js

@@ -118,8 +118,7 @@ const FOLDED = new Set(FOLDED_RANGES.split(" ").flatMap((range) => {
 /**
  * Pairs of letters that AutoCAD keeps as two layers but its AUDIT reports as a
  * duplicate name, written `from>to` in hexadecimal after `layerKey` has
- * lower-cased the name. They include ÿ and Ÿ, the two lower-case sigmas σ and
- * ς, and ß and ẞ.
+ * lower-cased the name. They include the two lower-case sigmas σ and ς.
  */
 const AUDIT_SAME_PAIRS = "178>ff 1c6>1c5 1c9>1c8 1cc>1cb 1f3>1f2 3c3>3c2 3f5>3b5 527>526 1e9e>df 1fbe>3b9 " +
     "2c7e>23f 2c7f>240 2cec>2ceb 2cee>2ced a791>a790 a7a1>a7a0 a7a3>a7a2 a7a5>a7a4 " +
@@ -128,6 +127,60 @@ const AUDIT_SAME = new Map(AUDIT_SAME_PAIRS.split(" ").map((pair) => {
     const [from = "", to = ""] = pair.split(">");
     return [String.fromCharCode(parseInt(from, 16)), String.fromCharCode(parseInt(to, 16))];
 }));
+/**
+ * Letters that AUDIT takes for the two or three letters they stand for, in
+ * either letter case: it reports `straße` and `STRASSE` as a duplicate name,
+ * and `Þórr` and `Thórr`. Each is listed in lower case, as `layerKey` leaves
+ * it, with a title-case digraph beside its lower-case form.
+ */
+const AUDIT_SPELLED_OUT = new Map(Object.entries({
+    ß: "ss",
+    ẞ: "ss",
+    æ: "ae",
+    ᴂ: "ae",
+    œ: "oe",
+    ij: "ij",
+    þ: "th",
+    dž: "dž",
+    Dž: "dž",
+    lj: "lj",
+    Lj: "lj",
+    nj: "nj",
+    Nj: "nj",
+    dz: "dz",
+    Dz: "dz",
+    ff: "ff",
+    fi: "fi",
+    fl: "fl",
+    ffi: "ffi",
+    ffl: "ffl",
+    st: "st",
+    ȸ: "db",
+    ȹ: "qp",
+    ʪ: "ls",
+    ʫ: "lz",
+    ꜳ: "aa",
+    ꜵ: "ao",
+    ꜷ: "au",
+    ꜹ: "av",
+    ꜽ: "ay",
+    ꝏ: "oo",
+    // The key is compared in decomposed form, so `ž` is spelled as it decomposes.
+}).map(([letter, spelling]) => [letter, spelling.normalize("NFD")]));
+/**
+ * Composed characters that AUDIT does not take for their decomposed forms,
+ * though Unicode calls the two equivalent: Hangul syllables, and some Arabic,
+ * Indic, Myanmar, kana, Hebrew and CJK compatibility characters. AUDIT takes
+ * every other composed character below U+10000 for its decomposed form.
+ */
+const KEPT_COMPOSED = /([\u0622-\u0624\u0626\u06c0\u06c2\u06d3\u09cb\u09cc\u09df\u0b48\u0b4b\u0b4c\u0b94\u0bca-\u0bcc\u0c48\u0cc0\u0cc7\u0cc8\u0cca\u0ccb\u0d4a-\u0d4c\u0dda\u0ddc-\u0dde\u1026\u309e\u30fe\ufa2e\ufa2f\ufa6b\ufa6d\ufb1f\ufb2c\ufb2d\uac00-\ud7a3])/;
+const SOFT_HYPHEN = "\u00ad";
+/**
+ * Soft hyphens that AUDIT ignores. It does not ignore one in front of a
+ * combining mark or a Hangul jamo: `E`, a soft hyphen and a combining acute
+ * accent are not É to it.
+ */
+const IGNORED_SOFT_HYPHENS = /\u00ad+(?![\u00ad\p{M}\u1100-\u11ff\ua960-\ua97f\ud7b0-\ud7ff])/gu;
 /**
  * The form of a layer name that AutoCAD looks layers up by. Two names with the
  * same key are one layer to AutoCAD: an entity on `wall` goes on a layer
@@ -149,22 +202,46 @@ export function layerKey(name) {
 }
 /**
  * The form of a layer name that AutoCAD's AUDIT compares when it looks for
- * duplicate names. AUDIT takes a few more letters for the same than the layer
- * table does, so two layers can have different `layerKey`s and still be an
- * AUDIT error.
+ * duplicate names. AUDIT takes more names for the same than the layer table
+ * does, so two layers can have different `layerKey`s and still be an AUDIT
+ * error. Two names with the same key here are such a pair, unless they have
+ * the same `layerKey` too.
  *
- * This covers the single letters AUDIT adds, and not everything it reports:
- * it also calls `straße` and `strasse`, `æ` and `ae`, and a composed é and its
- * decomposed form duplicates, which this key keeps apart.
+ * The key follows the kinds of pair measured in AutoCAD 2025:
+ *
+ * - A few single letters, such as σ and ς.
+ * - A letter and the letters it stands for, such as ß and `ss`.
+ * - A composed character and its decomposed form, such as é and `e` with a
+ *   combining acute accent, with its marks in any order Unicode counts as the
+ *   same, such as a dot below before or after a circumflex.
+ * - A name with a soft hyphen inside it or in front of it and the same name
+ *   without.
+ *
+ * It is not AUDIT's whole comparison. AUDIT also takes some compatibility
+ * characters for their plain forms, and cannot tell two characters apart when
+ * it knows neither.
  *
  * @param name - The layer name.
  * @returns The key to find AUDIT's duplicate names by.
  */
 export function layerAuditKey(name) {
     let key = "";
-    for (const character of layerKey(name))
-        key += AUDIT_SAME.get(character) ?? character;
-    return key;
+    for (const character of layerKey(decomposed(name.replace(IGNORED_SOFT_HYPHENS, "")))) {
+        key += AUDIT_SPELLED_OUT.get(character) ?? AUDIT_SAME.get(character) ?? character;
+    }
+    // AUDIT does not report `coop` and `coop` with a soft hyphen after it as duplicates, though it
+    // does report some other pairs that differ by a soft hyphen at the end. A mark for one at the
+    // end keeps a name that ends with a soft hyphen apart from every name that does not. Two names
+    // that both end with one are compared like any others, as the pairs in `auditPairs` in
+    // `scripts/cad-check.ts` check.
+    return name.endsWith(SOFT_HYPHEN) ? key + SOFT_HYPHEN : key;
+}
+/** Decomposes every composed character that AUDIT takes for its decomposed form. */
+function decomposed(name) {
+    return name
+        .split(KEPT_COMPOSED)
+        .map((part, i) => (i % 2 === 1 ? part : part.normalize("NFD")))
+        .join("");
 }
 /**
  * Orders layers for a DXF layer table. AutoCAD's AUDIT reports "Layer zero name

package/dist/lint.js

@@ -49,7 +49,13 @@ export function lint(drawing, options = {}) {
     drawing.entities.forEach((entity, index) => {
         const add = (rule, severity, problem) => out.push({ rule, severity, message: `${entity.kind} #${index}: ${problem}`, entity: index });
         if (!seen.has(layerKey(entity.layer))) {
-            add("undefined-layer", "error", `layer ${JSON.stringify(entity.layer)} is not defined`);
+            // AutoCAD adds a layer for a name it does not know. When AUDIT takes that name for a
+            // declared layer's, it then reports the new layer as a duplicate of it.
+            const twin = audited.get(layerAuditKey(entity.layer));
+            const hint = twin
+                ? `. AutoCAD does not take it for layer ${JSON.stringify(twin)}: it would add a layer, and its AUDIT would report a duplicate name`
+                : "";
+            add("undefined-layer", "error", `layer ${JSON.stringify(entity.layer)} is not defined${hint}`);
         }
         const problems = geometryProblems(entity);
         for (const problem of problems)

package/dist/rules.d.ts

@@ -47,10 +47,13 @@ export declare function layerNameProblem(name: string, version: DxfVersion): str
 /**
  * Returns what is wrong with a drawing that has both names as layers, or
  * undefined when the two can stand together. AutoCAD looks layers up one way
- * and its AUDIT compares their names another, so a few pairs of names, such
- * as `ΟΔΟΣ` and `οδος`, are two layers to AutoCAD and one duplicate name to
- * AUDIT. Names that are one layer to AutoCAD are not this function's concern.
- * The rule compares two names, so it has no type.
+ * and its AUDIT compares their names another, so some pairs of names are two
+ * 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.
  *
  * @param name - The name of the layer being checked.
  * @param other - The name of another layer in the drawing.

package/dist/rules.js

@@ -39,10 +39,13 @@ export function layerNameProblem(name, version) {
 /**
  * Returns what is wrong with a drawing that has both names as layers, or
  * undefined when the two can stand together. AutoCAD looks layers up one way
- * and its AUDIT compares their names another, so a few pairs of names, such
- * as `ΟΔΟΣ` and `οδος`, are two layers to AutoCAD and one duplicate name to
- * AUDIT. Names that are one layer to AutoCAD are not this function's concern.
- * The rule compares two names, so it has no type.
+ * and its AUDIT compares their names another, so some pairs of names are two
+ * 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.
  *
  * @param name - The name of the layer being checked.
  * @param other - The name of another layer in the drawing.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsdraft",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "2D CAD drawings as TypeScript: write the drawing in code, export DXF and SVG.",
   "keywords": [
     "2d",