@cplieger/deadset-ts 8.0.0-dev.6 → 8.0.0-dev.8

package/dist/src/report-schema.js

@@ -1,232 +1,10 @@
 /**
  * Holds a report to `contract/report.schema.json` and `contract/finding.schema.json`
  * before it is written, reading the schemas the generator copies from the Contract, so
- * this analyzer never writes a document a reader refuses. It evaluates the keywords the
- * Contract's schemas use; the schemas' patterns are written to match alike in RE2 and in
- * ECMAScript.
+ * this analyzer never writes a document a reader refuses.
  */
 import { REPORT_SCHEMAS } from "./contract/report.generated.js";
-/**
- * Every keyword the validator evaluates or knows to carry no assertion. A schema naming
- * another fails every check rather than passing values the keyword would refuse.
- */
-const KEYWORDS = new Set([
-    ...["$schema", "$id", "$comment", "$defs", "title", "description", "default", "examples"],
-    ...["$ref", "type", "enum", "const", "pattern", "minLength", "minimum", "maximum"],
-    ...["properties", "additionalProperties", "required", "minProperties"],
-    ...["items", "minItems", "maxItems", "uniqueItems"],
-    ...["allOf", "anyOf", "oneOf", "not", "if", "then", "else"],
-]);
-const patterns = new Map();
-function pattern(source) {
-    let held = patterns.get(source);
-    if (held === undefined) {
-        held = new RegExp(source, "u");
-        patterns.set(source, held);
-    }
-    return held;
-}
-function isObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function typeOf(value) {
-    if (value === null) {
-        return "null";
-    }
-    if (Array.isArray(value)) {
-        return "array";
-    }
-    if (typeof value === "number") {
-        return Number.isInteger(value) ? "integer" : "number";
-    }
-    return typeof value;
-}
-function hasType(value, name) {
-    const held = typeOf(value);
-    return held === name || (name === "number" && held === "integer");
-}
-/** One value's encoding with object members sorted, so two equal values encode alike. */
-function canonical(value) {
-    if (Array.isArray(value)) {
-        return `[${value.map(canonical).join(",")}]`;
-    }
-    if (isObject(value)) {
-        return `{${Object.keys(value)
-            .sort()
-            .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
-            .join(",")}}`;
-    }
-    return JSON.stringify(value);
-}
-/** A string's length in code points, which JSON Schema's minLength counts. */
-function codePoints(value) {
-    let counted = 0;
-    for (const _point of value) {
-        counted += 1;
-    }
-    return counted;
-}
-const escape = (name) => name.replaceAll("~", "~0").replaceAll("/", "~1");
-/** A schema evaluated in the document it is read from, so a relative `$ref` resolves there. */
-class Checker {
-    documents;
-    constructor(documents) {
-        this.documents = documents;
-    }
-    resolve(doc, ref) {
-        const [file = "", pointer = ""] = ref.split("#");
-        const target = file === "" ? doc : file;
-        let schema = this.documents[target];
-        for (const token of pointer.split("/").filter((one) => one !== "")) {
-            schema = isObject(schema)
-                ? schema[token.replaceAll("~1", "/").replaceAll("~0", "~")]
-                : undefined;
-        }
-        if (!isObject(schema)) {
-            throw new Error(`report schema: ${ref} names no schema`);
-        }
-        return [target, schema];
-    }
-    matches(doc, schema, value, at) {
-        const found = [];
-        this.check(doc, schema, value, at, found);
-        return found.length === 0;
-    }
-    check(doc, schema, value, at, found) {
-        for (const keyword of Object.keys(schema)) {
-            if (!KEYWORDS.has(keyword) && !keyword.startsWith("x-")) {
-                throw new Error(`report schema: the keyword ${keyword} is not one this validator evaluates`);
-            }
-        }
-        const refuse = (keyword, reason, pointer = at) => {
-            found.push({ pointer, keyword, reason });
-        };
-        if (typeof schema["$ref"] === "string") {
-            const [target, referenced] = this.resolve(doc, schema["$ref"]);
-            this.check(target, referenced, value, at, found);
-        }
-        const types = schema["type"];
-        const named = types === undefined ? [] : Array.isArray(types) ? types : [types];
-        if (named.length > 0 && !named.some((one) => hasType(value, String(one)))) {
-            refuse("type", `the value is ${typeOf(value)}, want ${named.join(", ")}`);
-            return;
-        }
-        this.checkValue(schema, value, refuse);
-        if (Array.isArray(value)) {
-            this.checkArray(doc, schema, value, at, found, refuse);
-        }
-        else if (isObject(value)) {
-            this.checkObject(doc, schema, value, at, found, refuse);
-        }
-        this.checkApplicators(doc, schema, value, at, found, refuse);
-    }
-    checkValue(schema, value, refuse) {
-        const values = schema["enum"];
-        if (Array.isArray(values) && !values.some((one) => canonical(one) === canonical(value))) {
-            refuse("enum", `${canonical(value)} is not one of the values the schema lists`);
-        }
-        if (schema["const"] !== undefined && canonical(schema["const"]) !== canonical(value)) {
-            refuse("const", `${canonical(value)} is not ${canonical(schema["const"])}`);
-        }
-        if (typeof value === "string") {
-            if (typeof schema["pattern"] === "string" && !pattern(schema["pattern"]).test(value)) {
-                refuse("pattern", `${JSON.stringify(value)} does not match ${schema["pattern"]}`);
-            }
-            if (typeof schema["minLength"] === "number" && codePoints(value) < schema["minLength"]) {
-                refuse("minLength", `${JSON.stringify(value)} is shorter than ${String(schema["minLength"])} characters`);
-            }
-        }
-        if (typeof value === "number") {
-            if (typeof schema["minimum"] === "number" && value < schema["minimum"]) {
-                refuse("minimum", `${String(value)} is below ${String(schema["minimum"])}`);
-            }
-            if (typeof schema["maximum"] === "number" && value > schema["maximum"]) {
-                refuse("maximum", `${String(value)} is above ${String(schema["maximum"])}`);
-            }
-        }
-    }
-    checkObject(doc, schema, value, at, found, refuse) {
-        const properties = isObject(schema["properties"]) ? schema["properties"] : {};
-        const additional = schema["additionalProperties"];
-        for (const name of Object.keys(value).sort()) {
-            const member = `${at}/${escape(name)}`;
-            const declared = properties[name];
-            if (isObject(declared)) {
-                this.check(doc, declared, value[name], member, found);
-            }
-            else if (additional === false) {
-                refuse("additionalProperties", `the member ${JSON.stringify(name)} is not one the schema declares`);
-            }
-            else if (isObject(additional)) {
-                this.check(doc, additional, value[name], member, found);
-            }
-        }
-        for (const name of Array.isArray(schema["required"]) ? schema["required"] : []) {
-            if (!Object.hasOwn(value, name)) {
-                refuse("required", `the member ${JSON.stringify(name)} is absent`);
-            }
-        }
-        const fewest = schema["minProperties"];
-        if (typeof fewest === "number" && Object.keys(value).length < fewest) {
-            refuse("minProperties", `the object holds ${String(Object.keys(value).length)} members, fewer than ${String(fewest)}`);
-        }
-    }
-    checkArray(doc, schema, value, at, found, refuse) {
-        const items = schema["items"];
-        if (isObject(items)) {
-            value.forEach((item, i) => {
-                this.check(doc, items, item, `${at}/${String(i)}`, found);
-            });
-        }
-        if (typeof schema["minItems"] === "number" && value.length < schema["minItems"]) {
-            refuse("minItems", `the array holds ${String(value.length)} items, fewer than ${String(schema["minItems"])}`);
-        }
-        if (typeof schema["maxItems"] === "number" && value.length > schema["maxItems"]) {
-            refuse("maxItems", `the array holds ${String(value.length)} items, more than ${String(schema["maxItems"])}`);
-        }
-        if (schema["uniqueItems"] === true && new Set(value.map(canonical)).size !== value.length) {
-            refuse("uniqueItems", "the array lists one value twice");
-        }
-    }
-    checkApplicators(doc, schema, value, at, found, refuse) {
-        const list = (keyword) => Array.isArray(schema[keyword]) ? schema[keyword] : [];
-        for (const each of list("allOf")) {
-            this.check(doc, each, value, at, found);
-        }
-        const matching = (keyword) => list(keyword).filter((each) => this.matches(doc, each, value, at)).length;
-        if (schema["anyOf"] !== undefined && matching("anyOf") === 0) {
-            refuse("anyOf", "the value matches none of the alternatives");
-        }
-        if (schema["oneOf"] !== undefined && matching("oneOf") !== 1) {
-            refuse("oneOf", `the value matches ${String(matching("oneOf"))} of the alternatives, want exactly one`);
-        }
-        if (isObject(schema["not"]) && this.matches(doc, schema["not"], value, at)) {
-            refuse("not", "the value matches a schema it must not match");
-        }
-        if (isObject(schema["if"])) {
-            const branch = this.matches(doc, schema["if"], value, at) ? schema["then"] : schema["else"];
-            if (isObject(branch)) {
-                this.check(doc, branch, value, at, found);
-            }
-        }
-    }
-}
-/**
- * A validator over one set of schema documents, each named as a `$ref` names it, rooted
- * at one of them: what it refuses in a value, none for an instance.
- */
-export function schemaRefusals(documents, root) {
-    const checker = new Checker(documents);
-    const top = documents[root];
-    if (top === undefined) {
-        throw new Error(`the schema set holds no document ${root}`);
-    }
-    return (value) => {
-        const found = [];
-        checker.check(root, top, value, "", found);
-        return found;
-    };
-}
+import { schemaRefusals } from "./schema.js";
 const reportSchema = schemaRefusals(REPORT_SCHEMAS, "report.schema.json");
 /**
  * What the report schema refuses in one report document, none for an instance, and, as
@@ -243,7 +21,7 @@ function listingRefusals(report) {
         return [];
     }
     const refuse = (pointer, reason) => [
-        { pointer, keyword: "components", reason },
+        { pointer, keyword: "components", reason, member: "" },
     ];
     const listed = new Set();
     for (const [i, entry] of report.components.entries()) {

package/dist/src/report.js

@@ -4,10 +4,8 @@
  * renders this document, so no two renderings disagree about which findings exist.
  */
 import { SCHEMA_VERSION, SCHEMA_VERSIONS } from "./contract/contract.generated.js";
-/** The name this analyzer writes every document under and mints every identifier with. */
-export const ANALYZER_NAME = "deadset-ts";
-/** The language this analyzer claims. */
-export const LANGUAGE = "ts";
+import { bytewise } from "./text/compare.js";
+import { LANGUAGE, PRODUCT } from "./product.js";
 /**
  * Each component the findings name, once, with the members the first finding naming it
  * carries, in the order the findings are: `findings` paired with their wire forms and
@@ -26,13 +24,6 @@ function componentsOf(findings) {
     }
     return [...listed.values()];
 }
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 function wirePosition(position) {
     return {
         path: position.path,
@@ -140,19 +131,19 @@ function wireStale(stale) {
 }
 /** The canonical key over two findings: path, line, column, code, then the symbol reference. */
 function canonical(a, b) {
-    return (compare(a.position.path, b.position.path) ||
+    return (bytewise(a.position.path, b.position.path) ||
         a.position.line - b.position.line ||
         a.position.column - b.position.column ||
-        compare(a.code, b.code) ||
-        compare(a.symbol.ref, b.symbol.ref));
+        bytewise(a.code, b.code) ||
+        bytewise(a.symbol.ref, b.symbol.ref));
 }
 /** The canonical key over two stale suppressions, each component from the record's own member. */
 function canonicalStale(a, b) {
-    return (compare(a.position.path, b.position.path) ||
+    return (bytewise(a.position.path, b.position.path) ||
         a.position.line - b.position.line ||
         a.position.column - b.position.column ||
-        compare(a.code, b.code) ||
-        compare(a.symbol, b.symbol));
+        bytewise(a.code, b.code) ||
+        bytewise(a.symbol, b.symbol));
 }
 /** One declared gap as a report carries it, its members in the schema's order. */
 function wireGap(gap) {
@@ -165,9 +156,9 @@ function wireGap(gap) {
 }
 /** Edge evaluations by edge, then side, then their compact encodings. */
 function byEdge(a, b) {
-    return (compare(a.edge, b.edge) ||
-        compare(a.side, b.side) ||
-        compare(JSON.stringify(a), JSON.stringify(b)));
+    return (bytewise(a.edge, b.edge) ||
+        bytewise(a.side, b.side) ||
+        bytewise(JSON.stringify(a), JSON.stringify(b)));
 }
 /**
  * The lines a reader deletes by acting on every finding: each distinct component a root
@@ -216,16 +207,16 @@ export function buildReport(input) {
     const findings = paired.map(([wire]) => wire);
     const evaluated = input.result.edgeEvaluations.flatMap((one) => one.finding === undefined ? [] : [[wireFinding(one.finding), one.finding]]);
     const unavailable = [...new Map(input.unavailable.map((one) => [one.id, one])).values()]
-        .sort((a, b) => compare(a.id, b.id))
+        .sort((a, b) => bytewise(a.id, b.id))
         .map((one) => ({ id: one.id, role: "consumer", reason: one.reason }));
     const loaded = [...input.loaded]
-        .sort((a, b) => compare(a.id, b.id) || compare(a.path, b.path))
+        .sort((a, b) => bytewise(a.id, b.id) || bytewise(a.path, b.path))
         .map((one) => ({ id: one.id, role: "consumer", path: one.path }));
     return {
         schema_version: SCHEMA_VERSION,
         contract_version: input.contractVersion,
         analyzer: {
-            name: ANALYZER_NAME,
+            name: PRODUCT,
             version: input.version,
             languages: [LANGUAGE],
             schema_versions_accepted: SCHEMA_VERSIONS,
@@ -237,10 +228,10 @@ export function buildReport(input) {
         },
         target: { kind: input.target.kind, root: input.target.root, identity: input.target.identity },
         configurations: [...input.configurations]
-            .sort((a, b) => compare(a.id, b.id))
+            .sort((a, b) => bytewise(a.id, b.id))
             .map((one) => ({ id: one.id, project: one.project })),
         configurations_not_built: [...input.notBuilt]
-            .sort((a, b) => compare(a.id, b.id))
+            .sort((a, b) => bytewise(a.id, b.id))
             .map((one) => ({ id: one.id, project: one.project, error: one.error })),
         consumers: { declared: loaded.length + unavailable.length, loaded, unavailable },
         findings,
@@ -253,10 +244,10 @@ export function buildReport(input) {
         // name, so the compact encodings alone order them.
         declared_gaps: input.declaredGaps
             .map(wireGap)
-            .sort((a, b) => compare(JSON.stringify(a), JSON.stringify(b))),
+            .sort((a, b) => bytewise(JSON.stringify(a), JSON.stringify(b))),
         excluded_by_cgo: [],
         test_file_rules: [...input.testFileRules]
-            .sort((a, b) => compare(a.rule, b.rule) || a.matched - b.matched)
+            .sort((a, b) => bytewise(a.rule, b.rule) || a.matched - b.matched)
             .map((one) => ({ rule: one.rule, matched: one.matched })),
         type_error_skips: [
             ...new Map(input.typeErrorSkips.map((one) => {
@@ -264,14 +255,14 @@ export function buildReport(input) {
                 return [JSON.stringify(skip), skip];
             })),
         ]
-            .sort(([a, x], [b, y]) => compare(x.path, y.path) || x.line - y.line || compare(a, b))
+            .sort(([a, x], [b, y]) => bytewise(x.path, y.path) || x.line - y.line || bytewise(a, b))
             .map(([, skip]) => skip),
         notes: [...new Map((input.notes ?? []).map((one) => [JSON.stringify(one), one])).entries()]
-            .sort(([a, x], [b, y]) => compare(x.kind, y.kind) || compare(x.path, y.path) || compare(a, b))
+            .sort(([a, x], [b, y]) => bytewise(x.kind, y.kind) || bytewise(x.path, y.path) || bytewise(a, b))
             .map(([, note]) => note),
         unanswered_questions: [...input.unanswered]
-            .sort((a, b) => compare(a.configuration, b.configuration) ||
-            compare(JSON.stringify(a), JSON.stringify(b)))
+            .sort((a, b) => bytewise(a.configuration, b.configuration) ||
+            bytewise(JSON.stringify(a), JSON.stringify(b)))
             .map((one) => ({
             configuration: one.configuration,
             questions: one.questions,

package/dist/src/reporters/sarif.js

@@ -5,6 +5,8 @@ import { lineHashes, symbolFingerprint } from "./fingerprint.js";
 import { RenderError } from "./reporter.js";
 import { utf8Bytes } from "./sha256.js";
 import { withheldLine } from "./text.js";
+import { bytewise } from "../text/compare.js";
+import { message } from "../product.js";
 const SCHEMA = "https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/schemas/sarif-schema-2.1.0.json";
 const VERSION = "2.1.0";
 /** The unit a finding's column counts. */
@@ -101,7 +103,7 @@ function lineHashCache(read) {
                 text = read(at.path);
             }
             catch (error) {
-                throw new RenderError(`read ${at.path} for its line fingerprint: ${error instanceof Error ? error.message : String(error)}`);
+                throw new RenderError(`read ${at.path} for its line fingerprint: ${message(error)}`);
             }
             hashes = lineHashes(text);
             held.set(at.path, hashes);
@@ -226,7 +228,7 @@ export function sarif(report, options) {
         ...report.findings.map((found) => findingResult(found, index, hashOf, members)),
         ...report.stale_suppressions.map((stale) => staleResult(stale, index, hashOf)),
     ];
-    const languages = [...report.analyzer.languages].sort().join("+");
+    const languages = [...report.analyzer.languages].sort(bytewise).join("+");
     const withheld = withheldLine(report.totals);
     const log = {
         $schema: SCHEMA,

package/dist/src/reporters/template.js

@@ -9,6 +9,7 @@
 import { CHUNK_LENGTH } from "../json-chunks.js";
 import { RenderError } from "./reporter.js";
 import { utf8Bytes } from "./sha256.js";
+import { bytewise } from "../text/compare.js";
 /** A template that does not parse, which refuses the invocation before any analysis. */
 export class TemplateError extends Error {
     constructor(message) {
@@ -513,7 +514,7 @@ function formatted(value, nested) {
     }
     const object = value;
     const entries = Object.keys(object)
-        .sort()
+        .sort(bytewise)
         .map((key) => `${key}:${formatted(object[key] ?? null, true)}`);
     return `map[${entries.join(" ")}]`;
 }
@@ -538,26 +539,10 @@ function compareBasic(name, a, b) {
         return Number.NaN;
     }
     if (kind === "string") {
-        return byCodePoints(a, b);
+        return bytewise(a, b);
     }
     return a < b ? -1 : 1;
 }
-/**
- * Two strings ordered by the bytes of their UTF-8 encodings, which is the order of their
- * code points: the order of their UTF-16 code units differs above U+FFFF.
- */
-function byCodePoints(a, b) {
-    let at = 0;
-    while (at < a.length && at < b.length) {
-        const x = a.codePointAt(at) ?? 0;
-        const y = b.codePointAt(at) ?? 0;
-        if (x !== y) {
-            return x < y ? -1 : 1;
-        }
-        at += x > 0xffff ? 2 : 1;
-    }
-    return a.length - b.length;
-}
 /** The escapes `%q` writes for the control characters that have one of their own. */
 const QUOTED_ESCAPES = {
     '"': '\\"',
@@ -903,7 +888,7 @@ class Execution {
             }
             else if (isObject(value)) {
                 entries = Object.keys(value)
-                    .sort()
+                    .sort(bytewise)
                     .map((key) => [key, value[key] ?? null]);
             }
             else {