@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.11

package/dist/src/inventory.js

@@ -3,7 +3,7 @@ import { dirnamePath, joinPath, relativePath } from "./paths.js";
 import { byPosition, positionKey, renderPosition, writtenLength, } from "./position.js";
 import { computedComponent, nameComponent, renderRef } from "./ref.js";
 import { isAnswered, UNANSWERED } from "./query.js";
-const MANIFEST = "package.json";
+import { manifestAt } from "./fs/manifest.js";
 /**
  * Resolves each file's package scope: the name of the nearest manifest at or above
  * its directory up to the target root, and the file's path below that manifest.
@@ -17,26 +17,7 @@ const MANIFEST = "package.json";
 export function packageScope(host, root) {
     const named = new Map();
     const manifestName = (dir) => {
-        let text;
-        try {
-            text = host.readFile(joinPath(root, dir, MANIFEST));
-        }
-        catch {
-            return undefined;
-        }
-        let value;
-        try {
-            value = JSON.parse(text);
-        }
-        catch {
-            // A manifest this program cannot read names no package, which is the same
-            // answer as an absent one: the file is then scoped by the target root.
-            return undefined;
-        }
-        if (typeof value !== "object" || value === null) {
-            return undefined;
-        }
-        const name = value["name"];
+        const name = manifestAt(host, joinPath(root, dir))?.["name"];
         return typeof name === "string" && name !== "" ? name : undefined;
     };
     const nearest = (dir) => {

package/dist/src/javascript-file.js

@@ -0,0 +1,33 @@
+export const JAVASCRIPT_FILE = /\.(?:js|jsx|mjs|cjs)$/u;
+/** A minified file by its name; any other is one by its size and its mean line length. */
+const MINIFIED_NAME = /\.min\.(?:js|mjs|cjs)$/u;
+const MINIFIED_BYTES = 10_240;
+const MINIFIED_LINE = 500;
+/** Whether one name is a minified file's, which decides it without its text. */
+export function minifiedByName(fileName) {
+    return MINIFIED_NAME.test(fileName);
+}
+/** Whether one JavaScript file is minified: by its name, or by its text's size and mean line length. */
+export function minified(fileName, text) {
+    if (!JAVASCRIPT_FILE.test(fileName)) {
+        return false;
+    }
+    if (minifiedByName(fileName)) {
+        return true;
+    }
+    // A UTF-16 unit encodes to at most three UTF-8 bytes, so a shorter text is below the size.
+    if (text.length * 3 < MINIFIED_BYTES) {
+        return false;
+    }
+    const lines = text.split(/\r?\n/u).length;
+    return utf8Bytes(text) >= MINIFIED_BYTES && text.length / lines > MINIFIED_LINE;
+}
+/** The length of a text in UTF-8, a lone surrogate counting as the three bytes of U+FFFD. */
+function utf8Bytes(text) {
+    let bytes = 0;
+    for (const character of text) {
+        const point = character.codePointAt(0) ?? 0;
+        bytes += point < 0x80 ? 1 : point < 0x800 ? 2 : point < 0x10000 ? 3 : 4;
+    }
+    return bytes;
+}

package/dist/src/json-document.js

@@ -1,106 +1,228 @@
 /**
- * A read of a strict JSON document beside its parse: what a parse into a value cannot
- * report, the offset of each record of one array and a member written twice.
+ * A text that is not one strict JSON document: a syntax error, data after the value, a
+ * member one object writes twice, or nesting past {@link MAX_DEPTH}. `place` is the
+ * value the fault is in, followed by the member written twice.
  */
-/** The token walk over a document `JSON.parse` accepted, so every token is well formed. */
-class Walk {
-    starts = [];
-    /** The member written twice, where one is, as the offset of its name. */
-    twice;
-    text;
-    array;
+export class StrictJSONError extends Error {
+    offset;
+    place;
+    constructor(reason, offset, place) {
+        super(reason);
+        this.name = "StrictJSONError";
+        this.offset = offset;
+        this.place = place;
+    }
+}
+/**
+ * How deep values may nest. A document this analyzer reads nests a few levels, and a
+ * bound turns a document built to exhaust the stack into a refusal.
+ */
+const MAX_DEPTH = 1000;
+const SPACE = /[ \t\n\r]*/uy;
+const STRING = /"(?:[ !#$%&'()*+,\-./0-9:;<=>?@A-Z[\]-\u{10FFFF}]|\\(?:["\\/bfnrt]|u[0-9A-Fa-f]{4}))*"/uy;
+const NUMBER = /-?(?:0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/uy;
+const LITERALS = new Map([
+    ["true", true],
+    ["false", false],
+    ["null", null],
+]);
+/** One member name spelled as a JSON Pointer token. */
+const escaped = (name) => name.replaceAll("~", "~0").replaceAll("/", "~1");
+/** The member names and indexes a JSON Pointer holds, unescaped. */
+export function pointerSegments(pointer) {
+    return pointer === ""
+        ? []
+        : pointer
+            .slice(1)
+            .split("/")
+            .map((token) => token.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+/** The JSON Pointer of a place written as segments. */
+export function pointerOf(segments) {
+    return segments.map((segment) => `/${escaped(segment)}`).join("");
+}
+/**
+ * The place a JSON Pointer names inside `value`, followed by `member` where it is not
+ * empty: a pointer's text does not say whether a segment of digits is an index, so the
+ * value it points into does.
+ */
+export function placeIn(value, pointer, member = "") {
+    const place = [];
+    let held = value;
+    for (const segment of pointerSegments(pointer)) {
+        if (Array.isArray(held)) {
+            place.push(Number(segment));
+            held = held[Number(segment)];
+        }
+        else {
+            place.push(segment);
+            held = isRecord(held) ? held[segment] : undefined;
+        }
+    }
+    return member === "" ? place : [...place, member];
+}
+/**
+ * A place as a refusal names it: member names joined by full stops and an index in
+ * square brackets, as `ts.serializers[0].returns`.
+ */
+export function dotted(place) {
+    let path = "";
+    for (const segment of place) {
+        path +=
+            typeof segment === "number" ? `[${String(segment)}]` : path === "" ? segment : `.${segment}`;
+    }
+    return path;
+}
+class Reader {
     at = 0;
-    constructor(text, array) {
+    path = [];
+    fractions = new Map();
+    starts = new Map();
+    text;
+    records;
+    constructor(text, records) {
         this.text = text;
-        this.array = array;
-    }
-    run() {
-        this.value("document");
+        this.records = records;
     }
-    skip() {
-        while (/[ \t\r\n]/u.test(this.text[this.at] ?? "")) {
-            this.at += 1;
+    read() {
+        const value = this.value(0);
+        this.match(SPACE);
+        if (this.at < this.text.length) {
+            this.fail("data follows the document's value");
         }
+        return value;
     }
-    string() {
-        const start = this.at;
-        this.at += 1;
-        while (this.text[this.at] !== '"') {
-            this.at += this.text[this.at] === "\\" ? 2 : 1;
+    fail(reason, offset = this.at, member = "") {
+        throw new StrictJSONError(reason, offset, member === "" ? [...this.path] : [...this.path, member]);
+    }
+    match(pattern) {
+        pattern.lastIndex = this.at;
+        const found = pattern.exec(this.text)?.[0];
+        this.at = found === undefined ? this.at : pattern.lastIndex;
+        return found;
+    }
+    expect(char, what) {
+        this.match(SPACE);
+        if (this.text[this.at] !== char) {
+            this.fail(`${what} is expected`);
         }
         this.at += 1;
-        return JSON.parse(this.text.slice(start, this.at));
     }
-    value(role) {
-        this.skip();
-        if (role === "record") {
-            this.starts.push(this.at);
+    value(depth) {
+        this.match(SPACE);
+        if (depth > MAX_DEPTH) {
+            this.fail(`values nest deeper than ${String(MAX_DEPTH)} levels`);
         }
         const char = this.text[this.at];
         if (char === "{") {
-            this.object(role);
+            return this.object(depth);
         }
-        else if (char === "[") {
-            this.list(role === "array" ? "record" : "other");
+        if (char === "[") {
+            return this.array(depth);
         }
-        else if (char === '"') {
-            this.string();
+        const string = this.match(STRING);
+        if (string !== undefined) {
+            return JSON.parse(string);
         }
-        else {
-            while (this.at < this.text.length && !/[,\]} \t\r\n]/u.test(this.text[this.at] ?? "")) {
-                this.at += 1;
+        NUMBER.lastIndex = this.at;
+        const number = NUMBER.exec(this.text);
+        if (number !== null) {
+            this.at = NUMBER.lastIndex;
+            if (number[1] !== undefined || number[2] !== undefined) {
+                this.fractions.set(pointerOf(this.path.map(String)), number[0]);
             }
+            return Number(number[0]);
         }
+        for (const [literal, held] of LITERALS) {
+            if (this.text.startsWith(literal, this.at)) {
+                this.at += literal.length;
+                return held;
+            }
+        }
+        return this.fail(char === undefined ? "the document ends where a value is expected" : "a value is expected");
     }
-    object(role) {
-        const seen = new Set();
+    object(depth) {
+        const held = {};
         this.at += 1;
+        this.match(SPACE);
+        if (this.text[this.at] === "}") {
+            this.at += 1;
+            return held;
+        }
         for (;;) {
-            this.skip();
-            if (this.text[this.at] === "}") {
-                this.at += 1;
-                return;
+            this.match(SPACE);
+            const offset = this.at;
+            const spelled = this.match(STRING);
+            if (spelled === undefined) {
+                return this.fail("a member name is expected");
             }
-            if (this.text[this.at] === ",") {
-                this.at += 1;
-                this.skip();
+            const name = JSON.parse(spelled);
+            if (Object.hasOwn(held, name)) {
+                this.fail(`the member ${JSON.stringify(name)} is written twice, so neither value is chosen`, offset, name);
             }
-            const offset = this.at;
-            const name = this.string();
-            if (seen.has(name) && this.twice === undefined) {
-                this.twice = { name, offset };
+            this.expect(":", "a colon after the member name");
+            if (depth === 1 && this.path[0] === this.records) {
+                this.match(SPACE);
+                this.starts.set(name, this.at);
             }
-            seen.add(name);
-            this.skip();
+            this.path.push(name);
+            Object.defineProperty(held, name, {
+                value: this.value(depth + 1),
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+            this.path.pop();
+            this.match(SPACE);
+            const next = this.text[this.at];
             this.at += 1;
-            this.value(role === "document" && name === this.array ? "array" : "other");
+            if (next === "}") {
+                return held;
+            }
+            if (next !== ",") {
+                this.at -= 1;
+                this.fail("a comma or a closing brace is expected");
+            }
         }
     }
-    list(element) {
+    array(depth) {
+        const held = [];
+        const records = depth === 1 && this.path[0] === this.records;
         this.at += 1;
+        this.match(SPACE);
+        if (this.text[this.at] === "]") {
+            this.at += 1;
+            return held;
+        }
         for (;;) {
-            this.skip();
-            if (this.text[this.at] === "]") {
-                this.at += 1;
-                return;
+            this.match(SPACE);
+            if (records) {
+                this.starts.set(held.length, this.at);
             }
-            if (this.text[this.at] === ",") {
-                this.at += 1;
+            this.path.push(held.length);
+            held.push(this.value(depth + 1));
+            this.path.pop();
+            this.match(SPACE);
+            const next = this.text[this.at];
+            this.at += 1;
+            if (next === "]") {
+                return held;
+            }
+            if (next !== ",") {
+                this.at -= 1;
+                this.fail("a comma or a closing bracket is expected");
             }
-            this.value(element);
         }
     }
 }
 /**
- * Walks a document `JSON.parse` accepted, whose top-level member `array` holds the
- * records. A member one object writes twice reads as though it were written once, its
- * later value silently replacing the earlier one, so a document holding one is one a
- * reader names rather than reads.
+ * Reads `text` as one strict JSON document, or throws a {@link StrictJSONError}.
+ * `records` names the top-level member whose values' offsets the read keeps.
  */
-export function walkDocument(text, array) {
-    const walk = new Walk(text, array);
-    walk.run();
-    return { starts: walk.starts, twice: walk.twice };
+export function readStrict(text, records) {
+    const reader = new Reader(text, records);
+    const value = reader.read();
+    return { value, fractions: reader.fractions, starts: reader.starts };
 }
 /**
  * One offset of a document as a finding carries it: the line counted from one, and the
@@ -111,3 +233,12 @@ export function positionAt(text, file, offset) {
     const lineStart = before.lastIndexOf("\n") + 1;
     return { path: file, line: before.split("\n").length, column: offset - lineStart + 1 };
 }
+/** A strict read's fault with the line and column it is at, as a refusal states it. */
+export function locatedFault(text, error) {
+    const { line, column } = positionAt(text, "", error.offset);
+    return `line ${String(line)}, column ${String(column)}: ${error.message}`;
+}
+/** Whether a decoded JSON value is an object: not `null` and not an array. */
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/keyof-comparisons.js

@@ -4,11 +4,12 @@
  * that holds `keyof X`, the literal the other side has names the member of `X` under that
  * key, because deleting the member makes the comparison a type error.
  */
-import { isBinaryExpression, isCaseClause, isElementAccessExpression, isIdentifier, isParenthesizedExpression, isPropertyAccessExpression, isSwitchStatement, isTypeOperatorNode, SyntaxKind, } from "@typescript/native/ast";
+import { isBinaryExpression, isCaseClause, isElementAccessExpression, isIdentifier, isPropertyAccessExpression, isSwitchStatement, isTypeOperatorNode, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
+import { parenthesesRemoved } from "./unwrap.js";
 /** The operators that compare their operands for equality. */
 const EQUALITIES = new Set([
     SyntaxKind.EqualsEqualsEqualsToken,
@@ -16,12 +17,9 @@ const EQUALITIES = new Set([
     SyntaxKind.EqualsEqualsToken,
     SyntaxKind.ExclamationEqualsToken,
 ]);
-function unwrapped(node) {
-    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
 /** The name node an operand's symbol is read at: an identifier, or a property access's name. */
 function nameOf(node) {
-    const at = unwrapped(node);
+    const at = parenthesesRemoved(node);
     if (isIdentifier(at)) {
         return at;
     }
@@ -96,7 +94,7 @@ export function keyofComparisonReferences(project, held, chains, root, testFiles
     }
     const named = comparisons.flatMap((one) => {
         const name = nameOf(one.keyed);
-        return name === undefined || isElementAccessExpression(unwrapped(one.other))
+        return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
             ? []
             : [{ ...one, name }];
     });