@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/dist/src/generated-file.js

@@ -2,9 +2,13 @@
  * The generated-file class on TypeScript: every declaration in a file that marks itself
  * generated, below a directory an applied convention row names as generated, or minified,
  * is retained, because a generator owns the file and a deletion there is undone at the next
- * generation.
+ * generation. The same decision is each `generated` entry of the facts document.
  */
-import { minified } from "./javascript-file.js";
+import { isIdentifier, isImportDeclaration, isPropertyAssignment, isStringLiteralLikeNode, isVariableStatement, NodeFlags, } from "@typescript/native/ast";
+import { GENERATORS } from "./contract/contract.generated.js";
+import { minifiedBy } from "./javascript-file.js";
+import { bytewise } from "./text/compare.js";
+import { satisfies } from "./version-range.js";
 /** The generated-code header, matched against each line of a leading comment. */
 const HEADER_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/u;
 /** The documentation tag `@generated` as a word of a comment. */
@@ -15,9 +19,17 @@ const GENERATED_BY = /^\/\/ Generated by \S/u;
 const GENERATED_WORD = /\bgenerated\b/iu;
 /** The phrases a generator's notice asks a reader not to edit the file by. */
 const KEEP_OUT = /\b(?:do not edit|will be overwritten|should not make any changes)\b/iu;
-/** The comments before a text's first token, a leading hashbang line skipped. */
+/** The comments before a text's first token, a leading hashbang line skipped, each as its lines. */
 function leadingComments(text) {
     const comments = [];
+    const lineAt = (offset) => text.slice(0, offset).split(/\r\n|[\n\r\u2028\u2029]/u).length;
+    const lines = (from, to) => {
+        const first = lineAt(from);
+        return text
+            .slice(from, to)
+            .split(/\r\n|[\n\r\u2028\u2029]/u)
+            .map((one, index) => ({ text: one, line: first + index }));
+    };
     let at = text.startsWith("\uFEFF") ? 1 : 0;
     if (text.startsWith("#!", at)) {
         const end = text.indexOf("\n", at);
@@ -30,7 +42,7 @@ function leadingComments(text) {
         if (text.startsWith("//", at)) {
             const end = text.slice(at).search(/[\r\n\u2028\u2029]/u);
             const stop = end === -1 ? text.length : at + end;
-            comments.push(text.slice(at, stop));
+            comments.push(lines(at, stop));
             at = stop;
         }
         else if (text.startsWith("/*", at)) {
@@ -38,7 +50,7 @@ function leadingComments(text) {
             if (end === -1) {
                 return comments;
             }
-            comments.push(text.slice(at, end + 2));
+            comments.push(lines(at, end + 2));
             at = end + 2;
         }
         else {
@@ -46,43 +58,168 @@ function leadingComments(text) {
         }
     }
 }
-/** The detail a file's leading comments mark it generated by, or undefined where they mark nothing. */
-export function generatedByComment(text) {
-    const comments = leadingComments(text);
-    if (comments.some((one) => one.split(/\r?\n/u).some((line) => HEADER_LINE.test(line)))) {
-        return "generated by the header line its leading comments hold";
+/** The mark one file's leading comments make it generated by, or undefined where they mark nothing. */
+export function generatedMark(text) {
+    const lines = leadingComments(text).flat();
+    const header = lines.find((one) => HEADER_LINE.test(one.text));
+    if (header !== undefined) {
+        return { evidence: "header", line: header.line, detail: header.text };
     }
-    if (comments.some((one) => GENERATED_TAG.test(one))) {
-        return "generated by the @generated tag its leading comments hold";
+    const tag = lines.find((one) => GENERATED_TAG.test(one.text));
+    if (tag !== undefined) {
+        return { evidence: "tag", line: tag.line, detail: tag.text };
     }
-    const notice = comments.join("\n");
-    if (GENERATED_BY.test(comments[0] ?? "") ||
-        (GENERATED_WORD.test(notice) && KEEP_OUT.test(notice))) {
-        return "generated by the notice its leading comments hold";
+    const [first] = lines;
+    if (first !== undefined && GENERATED_BY.test(first.text)) {
+        return { evidence: "notice", line: first.line, detail: first.text };
+    }
+    const notice = lines.map((one) => one.text).join("\n");
+    if (GENERATED_WORD.test(notice) && KEEP_OUT.test(notice)) {
+        const marked = lines.find((one) => GENERATED_WORD.test(one.text) || KEEP_OUT.test(one.text));
+        return marked === undefined
+            ? undefined
+            : { evidence: "notice", line: marked.line, detail: marked.text };
+    }
+    return undefined;
+}
+/** What one form's first group captures, for each line the form matches. */
+function after(lines, form) {
+    return lines.flatMap((one) => form.exec(one.text)?.[1] ?? []);
+}
+/**
+ * Where each plugin's output states its version and its schema files, as `references-ts.36`
+ * states: a plugin missing here states no version, and one with no schema form names none.
+ */
+const STATEMENTS = {
+    "protoc-gen-es": {
+        version: /^\/\/ @generated by protoc-gen-es (\S+)/u,
+        schemaFiles: /^\/\/ @generated from file (\S+)/u,
+    },
+    "protoc-gen-connect-es": {
+        version: /^\/\/ @generated by protoc-gen-connect-es (\S+)/u,
+        schemaFiles: /^\/\/ @generated from file (\S+)/u,
+    },
+    "protobuf-ts": {
+        version: /^\/\/ @generated by protobuf-ts (\S+)/u,
+        schemaFiles: /^\/\/ @generated from protobuf file "([^"]+)"/u,
+    },
+    "ts-proto": {
+        version: /^\/\/\s+protoc-gen-ts_proto\s+(\S+)$/u,
+        schemaFiles: /^\/\/ source: (.+)$/u,
+    },
+    "protoc-gen-grpc-web": {
+        version: /^\/\/\s+protoc-gen-grpc-web\s+(\S+)$/u,
+        schemaFiles: /^\/\/ source: (.+)$/u,
+    },
+    "protoc-gen-js": { schemaFiles: /^\/\/ source: (.+)$/u },
+    "ts-protoc-gen": { schemaFiles: /^\/\/ file: (.+)$/u },
+};
+/** A ts-proto service path literal: `/<package>.<service>/<method>`. */
+const SERVICE_PATH = /^\/(?:\w+\.)+\w+\/\w+$/u;
+/** Whether one ts-proto file writes a service path, as `references-ts.36` reads one. */
+function writesServicePath(file) {
+    const named = file.statements.some((statement) => isVariableStatement(statement) &&
+        (statement.declarationList.flags & NodeFlags.Const) !== 0 &&
+        statement.declarationList.declarations.some((one) => isIdentifier(one.name) &&
+            one.name.text.endsWith("ServiceName") &&
+            one.initializer !== undefined &&
+            isStringLiteralLikeNode(one.initializer)));
+    let found = named;
+    const visit = (node) => {
+        if (found) {
+            return;
+        }
+        if (isPropertyAssignment(node) &&
+            isIdentifier(node.name) &&
+            node.name.text === "path" &&
+            isStringLiteralLikeNode(node.initializer) &&
+            SERVICE_PATH.test(node.initializer.text)) {
+            found = true;
+            return;
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/** Whether one file imports a module by its specifier. */
+function imports(file, module) {
+    return file.statements.some((statement) => isImportDeclaration(statement) &&
+        isStringLiteralLikeNode(statement.moduleSpecifier) &&
+        statement.moduleSpecifier.text === module);
+}
+/** The option sets the rows of `references-ts.36` name, by row; every other row's is met by any output. */
+const OPTION_SETS = {
+    "ts-proto-2-output-schema": (file) => imports(file, "ts-proto-descriptors"),
+    "ts-proto-2": writesServicePath,
+    "ts-proto-2-types": (file) => !writesServicePath(file),
+};
+/** The first generator row one file matches, in `generators.json`'s order, as `bindings.3` reads it. */
+export function generatorOf(file) {
+    const lines = leadingComments(file.text).flat();
+    for (const row of GENERATORS) {
+        const header = new RegExp(row.header, "u");
+        if (!lines.some((one) => header.test(one.text))) {
+            continue;
+        }
+        const statements = STATEMENTS[row.plugin] ?? {};
+        const [version] = statements.version === undefined ? [] : after(lines, statements.version);
+        if ("versions" in row &&
+            (version === undefined ||
+                !satisfies(version.replace(/^v/u, ""), `>=${row.versions.min.replace(/^v/u, "")} <=${row.versions.max.replace(/^v/u, "")}`))) {
+            continue;
+        }
+        if (OPTION_SETS[row.id]?.(file) === false) {
+            continue;
+        }
+        const schemaFiles = statements.schemaFiles === undefined
+            ? []
+            : [
+                ...new Set(after(lines, statements.schemaFiles).filter((one) => one.endsWith(".proto"))),
+            ].sort(bytewise);
+        return { row: row.id, ...(version === undefined ? {} : { version }), schemaFiles };
     }
     return undefined;
 }
 /**
- * Every own file of one project that is generated, by its path below the target root,
- * with the detail a retention in it names: its leading comments' mark, else the row
- * naming its directory as generated, else its minified text.
+ * Every own file of one project that is generated, by its path below the target root, with
+ * what decided it: its leading comments' mark, else the row naming its directory as
+ * generated, else its minified name or text; and the generator row it matches.
  */
 export function generatedFilesOf(files, byRow) {
     const found = new Map();
     for (const [path, file] of files.byPath) {
         const row = byRow.get(path);
-        const detail = generatedByComment(file.text) ??
+        const minified = row === undefined ? minifiedBy(file.fileName, file.text) : undefined;
+        const fact = generatedMark(file.text) ??
             (row === undefined
-                ? minified(file.fileName, file.text)
-                    ? "generated as a minified JavaScript file"
-                    : undefined
-                : `generated below a directory the convention row ${row} names`);
-        if (detail !== undefined) {
-            found.set(path, detail);
+                ? minified === undefined
+                    ? undefined
+                    : { evidence: "minified", line: 1, detail: minified }
+                : { evidence: "convention", line: 1, detail: row });
+        if (fact === undefined) {
+            continue;
         }
+        const generator = generatorOf(file);
+        found.set(path, generator === undefined ? fact : { ...fact, generator });
     }
     return found;
 }
+/** The detail a retention in a generated file names, from what decided the file. */
+function retentionDetail(fact) {
+    switch (fact.evidence) {
+        case "header":
+            return "generated by the header line its leading comments hold";
+        case "tag":
+            return "generated by the @generated tag its leading comments hold";
+        case "notice":
+            return "generated by the notice its leading comments hold";
+        case "convention":
+            return `generated below a directory the convention row ${fact.detail} names`;
+        case "minified":
+            return "generated as a minified JavaScript file";
+    }
+}
 /** The generated-file detector, recording each file's first line. */
 export function generatedFile(input) {
     const generated = input.generated;
@@ -90,9 +227,15 @@ export function generatedFile(input) {
         return [];
     }
     return input.held.symbols.flatMap((symbol) => {
-        const detail = generated.get(symbol.position.path);
-        return symbol.kind === "file" || detail === undefined
+        const fact = generated.get(symbol.position.path);
+        return symbol.kind === "file" || fact === undefined
             ? []
-            : [{ id: symbol.id, detail, site: { path: symbol.position.path, line: 1, column: 1 } }];
+            : [
+                {
+                    id: symbol.id,
+                    detail: retentionDetail(fact),
+                    site: { path: symbol.position.path, line: 1, column: 1 },
+                },
+            ];
     });
 }

package/dist/src/graph.js

@@ -4,6 +4,7 @@
  * nothing, so a sweep over it is a function of the values it was built from, and the
  * inventory's order is the order every set a sweep answers reads in.
  */
+import { madeByTestCode } from "./tests/file-class.js";
 /** The position of a declaration the inventory does not hold. */
 export const OUTSIDE = -1;
 /**
@@ -32,8 +33,8 @@ const SWEPT = {
 };
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
- * tool reads what it loads and what its strings name, a runtime runs a test, setup or
- * worker file, a page's module script, a command, a script or a workflow step, the manifest
+ * tool reads what it loads and what its strings name, a runtime runs a test or setup
+ * file, a page's module script, a command, a script or a workflow step, the manifest
  * names what enters the package, an alias global stands for its export, an outside
  * declaration names a global interface merging into it, and an entry file, a configured root
  * and a pattern assert a caller. A published API supposes a consumer: reachability alone.
@@ -54,8 +55,6 @@ const NAMES_A_CALLER = {
     "configuration-string": true,
     "bundler-entry": true,
     "test-runner": true,
-    "browser-tests": true,
-    worker: true,
     "html-entry": true,
     "workflow-step": true,
     "document-import": true,
@@ -81,24 +80,31 @@ export function graphOf(symbols, references, roots, testFiles, supportFiles = []
     const at = (id) => index.get(id) ?? OUTSIDE;
     const tests = new Set(testFiles);
     const out = symbols.map(() => []);
-    const made = symbols.map(() => ({ production: 0, test: 0 }));
+    const made = symbols.map(() => ({ production: 0, test: 0, consumerTest: 0 }));
     const consumed = [];
     for (const reference of references) {
         const to = at(reference.to);
         if (to === OUTSIDE) {
             continue;
         }
+        const test = madeByTestCode(reference, supports);
         const counts = made[to];
         if (counts !== undefined) {
-            if (reference.test) {
+            if (test) {
                 counts.test += 1;
+                counts.consumerTest += reference.consumer === undefined ? 0 : 1;
             }
             else {
                 counts.production += 1;
             }
         }
-        const edge = { to, test: reference.test, evaluation: reference.use === "evaluation" };
-        if (reference.consumer !== undefined || reference.unheld === true) {
+        const edge = {
+            to,
+            test,
+            evaluation: reference.use === "evaluation",
+            consumer: reference.consumer !== undefined,
+        };
+        if (edge.consumer || reference.unheld === true) {
             consumed.push(edge);
             continue;
         }

package/dist/src/import-bindings.js

@@ -2,7 +2,7 @@
  * The import bindings of one file: the names its import declarations bind, which only
  * the file itself can read.
  */
-import { isExportSpecifier, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isJsxElement, isJsxFragment, isJsxSelfClosingElement, isNamespaceImport, SyntaxKind, } from "@typescript/native/ast";
+import { isExportDeclaration, isExportSpecifier, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isJsxElement, isJsxFragment, isJsxSelfClosingElement, isNamedExports, isNamespaceImport, SyntaxKind, } from "@typescript/native/ast";
 /** The extensions of the files whose import bindings are judged: no markup can read them. */
 const JUDGED = /\.(?:[mc]?ts|tsx|[mc]?js|jsx)$/u;
 /** The compiler's `jsx` settings whose emit calls no factory the file must hold. */
@@ -13,41 +13,86 @@ const DOC_COMMENT = /\/\*\*[\s\S]*?\*\//gu;
 const DOC_REFERENCE = /\{[^{}]*\}|@see\s+[A-Za-z_$][\w$.]*/gu;
 /** The factory a pragma comment names: `@jsx h` or `@jsxFrag Fragment`. */
 const PRAGMA = /@jsx(?:Frag)?\s+([A-Za-z_$][\w$]*)/gu;
+const bindingsCache = new WeakMap();
 /**
- * The names one file's import declarations bind: the default, named and namespace names of
- * an `import` declaration, and the name of an `import x = require()` declaration that is
- * not exported. None is judged in a declaration file or a component file.
+ * Every name one import declaration binds, in source order: the default, named and
+ * namespace names of an `import` declaration and the name of an `import x = …` declaration.
+ * A namespace import and an import assignment bind a whole module.
  */
-export function importBindings(file) {
-    if (file.isDeclarationFile || !JUDGED.test(file.fileName)) {
-        return [];
+export function declarationBindings(declaration) {
+    if (isImportEqualsDeclaration(declaration)) {
+        return [
+            {
+                name: declaration.name,
+                equals: {
+                    exported: (declaration.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.ExportKeyword),
+                    external: isExternalModuleReference(declaration.moduleReference),
+                },
+            },
+        ];
     }
+    const clause = declaration.importClause;
     const found = [];
-    for (const statement of file.statements) {
-        if (isImportDeclaration(statement)) {
-            const clause = statement.importClause;
-            if (clause?.name !== undefined) {
-                found.push(clause.name);
-            }
-            const named = clause?.namedBindings;
-            if (named !== undefined && isNamespaceImport(named)) {
-                found.push(named.name);
-            }
-            else if (named !== undefined) {
-                for (const element of named.elements) {
-                    found.push(element.name);
-                }
-            }
-        }
-        else if (isImportEqualsDeclaration(statement) &&
-            isExternalModuleReference(statement.moduleReference) &&
-            isIdentifier(statement.name) &&
-            !(statement.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.ExportKeyword)) {
-            found.push(statement.name);
+    if (clause?.name !== undefined) {
+        found.push({ name: clause.name, imported: "default" });
+    }
+    const named = clause?.namedBindings;
+    if (named !== undefined && isNamespaceImport(named)) {
+        found.push({ name: named.name });
+    }
+    else if (named !== undefined) {
+        for (const element of named.elements) {
+            found.push({ name: element.name, imported: element.propertyName?.text ?? element.name.text });
         }
     }
     return found;
 }
+/** Every name one file's top-level import declarations bind, in source order. */
+export function bindingsOf(file) {
+    const known = bindingsCache.get(file);
+    if (known !== undefined) {
+        return known;
+    }
+    const found = file.statements.flatMap((statement) => isImportDeclaration(statement) || isImportEqualsDeclaration(statement)
+        ? declarationBindings(statement)
+        : []);
+    bindingsCache.set(file, found);
+    return found;
+}
+/**
+ * The export names an import or a re-export declaration reads from the module it names,
+ * `undefined` standing for the whole module where a namespace or a star reads it; none for
+ * any other node.
+ */
+export function importedNames(node) {
+    if (isImportDeclaration(node)) {
+        return declarationBindings(node).map((binding) => binding.imported);
+    }
+    if (!isExportDeclaration(node)) {
+        return [];
+    }
+    const clause = node.exportClause;
+    return clause === undefined || !isNamedExports(clause)
+        ? [undefined]
+        : clause.elements.map((one) => (one.propertyName ?? one.name).text);
+}
+/** The export names {@link importedNames} gives one node, without the whole module. */
+export function namesImported(node) {
+    return importedNames(node).flatMap((name) => name ?? []);
+}
+/**
+ * The bindings of one file that are judged as imports: those of {@link bindingsOf} but an
+ * `import x = …` that is exported or names no external module. None is judged in a
+ * declaration file or a component file.
+ */
+export function importBindings(file) {
+    if (file.isDeclarationFile || !JUDGED.test(file.fileName)) {
+        return [];
+    }
+    return bindingsOf(file).flatMap((binding) => binding.equals !== undefined && (binding.equals.exported || !binding.equals.external)
+        ? []
+        : [binding.name]);
+}
 /** Whether one identifier names a binding in a local export, which reads it whatever it resolves to. */
 export function exportsLocally(use) {
     return isExportSpecifier(use.parent);