@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/dist/src/build-scripts.js

@@ -0,0 +1,425 @@
+/**
+ * The files a bundler's JavaScript API builds from, read from the build scripts a
+ * manifest's scripts run: the strings an options object passes as the bundler's entries.
+ * A script is read without running it, so a value that is not written out, a computed
+ * path or an options object built at run time among them, names nothing.
+ */
+import { isArrayBindingPattern, isArrayLiteralExpression, isArrowFunction, isCallExpression, isConstructorDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isImportDeclaration, isMetaProperty, isMethodDeclaration, isNamedImports, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isSetAccessorDeclaration, isStringLiteral, isVariableDeclaration, isVariableStatement, NodeFlags, } from "@typescript/native/ast";
+import { filesNamedBy } from "./configuration-files.js";
+import { ancestors, dirnamePath, relativePath, resolvePath } from "./paths.js";
+import { bytewise } from "./text/compare.js";
+import { isRecord } from "./json-document.js";
+import { unwrapped } from "./unwrap.js";
+import { holdsManifest, inInstalledPackages, manifestAt } from "./fs/manifest.js";
+import { globExpression } from "./text/glob.js";
+import { scriptTokens } from "./text/shell.js";
+/**
+ * The bundlers whose build call names its entries: esbuild resolves `entryPoints` against
+ * `absWorkingDir` (https://esbuild.github.io/api/#working-directory), webpack `entry`
+ * against `context` (https://webpack.js.org/configuration/entry-context/), and Rollup
+ * `input` against the working directory, each the manifest's directory when its script runs.
+ */
+const BUNDLERS = [
+    {
+        module: "esbuild",
+        calls: ["build", "buildSync", "context"],
+        option: "entryPoints",
+        base: "absWorkingDir",
+        paths: true,
+    },
+    { module: "webpack", calls: ["default"], option: "entry", base: "context", paths: false },
+    { module: "rollup", calls: ["rollup", "watch"], option: "input", base: "", paths: true },
+];
+const MODULE_EXTENSION = /\.(?:js|mjs|cjs|ts|mts|cts)$/u;
+function literalOf(node) {
+    const at = unwrapped(node);
+    return isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at) ? at.text : undefined;
+}
+/** Whether one call is `require(<module>)`. */
+function requires(node, module) {
+    const at = unwrapped(node);
+    return (isCallExpression(at) &&
+        isIdentifier(at.expression) &&
+        at.expression.text === "require" &&
+        at.arguments.length === 1 &&
+        at.arguments[0] !== undefined &&
+        literalOf(at.arguments[0]) === module);
+}
+function bindingsOf(file, api) {
+    const functions = new Set();
+    const modules = new Set();
+    const building = (name) => api.calls.includes(name);
+    for (const statement of file.statements) {
+        if (isImportDeclaration(statement)) {
+            if (literalOf(statement.moduleSpecifier) !== api.module) {
+                continue;
+            }
+            const clause = statement.importClause;
+            if (clause?.name !== undefined) {
+                (building("default") ? functions : modules).add(clause.name.text);
+            }
+            const named = clause?.namedBindings;
+            if (named !== undefined && isNamespaceImport(named)) {
+                modules.add(named.name.text);
+            }
+            else if (named !== undefined && isNamedImports(named)) {
+                for (const element of named.elements) {
+                    if (building((element.propertyName ?? element.name).text)) {
+                        functions.add(element.name.text);
+                    }
+                }
+            }
+        }
+        else if (isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                const { name, initializer } = declaration;
+                if (initializer === undefined || !requires(initializer, api.module)) {
+                    continue;
+                }
+                if (isIdentifier(name)) {
+                    (building("default") ? functions : modules).add(name.text);
+                }
+                else if (isObjectBindingPattern(name)) {
+                    for (const element of name.elements) {
+                        const local = element.name;
+                        const key = element.propertyName ?? local;
+                        if (key !== undefined &&
+                            local !== undefined &&
+                            isIdentifier(key) &&
+                            isIdentifier(local) &&
+                            building(key.text)) {
+                            functions.add(local.text);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return { functions, modules };
+}
+/** Whether one call's callee is a building function of a bundler the file binds, `shadowed` naming none. */
+function builds(callee, api, bindings, shadowed) {
+    const at = unwrapped(callee);
+    if (isIdentifier(at)) {
+        return bindings.functions.has(at.text) && !shadowed.has(at.text);
+    }
+    if (!isPropertyAccessExpression(at) ||
+        !isIdentifier(at.name) ||
+        !api.calls.includes(at.name.text)) {
+        return false;
+    }
+    const holder = unwrapped(at.expression);
+    return ((isIdentifier(holder) && bindings.modules.has(holder.text) && !shadowed.has(holder.text)) ||
+        requires(holder, api.module));
+}
+/** The top-level `const` initializers one file declares, by name. */
+function constants(file) {
+    const found = new Map();
+    for (const statement of file.statements) {
+        if (isVariableStatement(statement) &&
+            (statement.declarationList.flags & NodeFlags.Const) !== 0) {
+            for (const { name, initializer } of statement.declarationList.declarations) {
+                if (isIdentifier(name) && initializer !== undefined) {
+                    found.set(name.text, initializer);
+                }
+            }
+        }
+    }
+    return found;
+}
+/** The value one object literal writes for one member as `name: value`. */
+function member(object, name) {
+    if (!isObjectLiteralExpression(object)) {
+        return undefined;
+    }
+    for (const property of object.properties) {
+        if (isPropertyAssignment(property) && literalOrName(property.name) === name) {
+            return property.initializer;
+        }
+    }
+    return undefined;
+}
+function literalOrName(node) {
+    return isIdentifier(node) ? node.text : literalOf(node);
+}
+/** Whether one expression is the script's own directory: `__dirname` or `import.meta.dirname`. */
+function isOwnDirectory(node) {
+    const at = unwrapped(node);
+    if (isIdentifier(at)) {
+        return at.text === "__dirname";
+    }
+    return (isPropertyAccessExpression(at) &&
+        isMetaProperty(at.expression) &&
+        isIdentifier(at.name) &&
+        at.name.text === "dirname");
+}
+/**
+ * The path one entry value writes, read against `dir`: a literal, or a `resolve` or
+ * `join` call, of `path` or bound from it, whose first argument is the script's own
+ * directory and whose others are literals.
+ */
+function pathOf(node, dir, scriptDir) {
+    const at = unwrapped(node);
+    const text = literalOf(at);
+    if (text !== undefined) {
+        const request = !text.startsWith("./") && !text.startsWith("../") && !text.startsWith("/");
+        return { path: resolvePath(dir, text), text, request };
+    }
+    if (!isCallExpression(at)) {
+        return undefined;
+    }
+    const callee = unwrapped(at.expression);
+    const name = isPropertyAccessExpression(callee) ? callee.name : callee;
+    if (!isIdentifier(name) || (name.text !== "resolve" && name.text !== "join")) {
+        return undefined;
+    }
+    const [first, ...rest] = at.arguments;
+    const parts = rest.map(literalOf);
+    if (first === undefined || !isOwnDirectory(first) || parts.some((part) => part === undefined)) {
+        return undefined;
+    }
+    const joined = parts.join("/");
+    return { path: resolvePath(scriptDir, joined), text: joined, request: false };
+}
+/** The entry values one entries option writes: a value, an array of them, an object of them. */
+function entryValues(node) {
+    const at = unwrapped(node);
+    if (isArrayLiteralExpression(at)) {
+        return at.elements.flatMap(entryValues);
+    }
+    if (isObjectLiteralExpression(at)) {
+        const imported = member(at, "import") ?? member(at, "in");
+        if (imported !== undefined) {
+            return entryValues(imported);
+        }
+        return at.properties.flatMap((property) => isPropertyAssignment(property) ? entryValues(property.initializer) : []);
+    }
+    return [at];
+}
+/** The own files one entry string names, read as `api` reads it. */
+function entriesNamed(files, api, entry) {
+    if (!api.paths && entry.request) {
+        return [];
+    }
+    if (api.paths && /[*?[{]/u.test(entry.text)) {
+        const expression = globExpression(entry.path);
+        return [...files.byName.values()].filter((file) => expression.test(file.fileName));
+    }
+    const dir = dirnamePath(entry.path);
+    return filesNamedBy(files, dir, entry.path.slice(dir.length + 1));
+}
+/** Whether one node is a function, whose body runs only where something calls it. */
+function isFunction(node) {
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isArrowFunction(node) ||
+        isMethodDeclaration(node) ||
+        isConstructorDeclaration(node) ||
+        isGetAccessorDeclaration(node) ||
+        isSetAccessorDeclaration(node));
+}
+/** The names one binding name binds: an identifier, or each name a pattern holds. */
+function boundNames(name, into) {
+    if (isIdentifier(name)) {
+        into.add(name.text);
+    }
+    else if (isObjectBindingPattern(name) || isArrayBindingPattern(name)) {
+        name.forEachChild((element) => {
+            const bound = element.name;
+            if (bound !== undefined) {
+                boundNames(bound, into);
+            }
+        });
+    }
+}
+/** The names one function binds of its own: its parameters and the declarations its body holds outside nested functions. */
+function ownBindings(fn) {
+    const found = new Set();
+    const visit = (node) => {
+        if (node !== fn && isFunction(node)) {
+            if (isFunctionDeclaration(node) && node.name !== undefined) {
+                found.add(node.name.text);
+            }
+            return;
+        }
+        if (isVariableDeclaration(node)) {
+            boundNames(node.name, found);
+        }
+        node.forEachChild(visit);
+    };
+    for (const parameter of fn
+        .parameters ?? []) {
+        boundNames(parameter.name, found);
+    }
+    fn.forEachChild(visit);
+    return found;
+}
+/** The functions one file declares under a name: a function declaration, or a variable bound to a function. */
+function namedFunctions(file) {
+    const found = new Map();
+    const add = (name, fn) => {
+        found.set(name, [...(found.get(name) ?? []), fn]);
+    };
+    const visit = (node) => {
+        if (isFunctionDeclaration(node) && node.name !== undefined) {
+            add(node.name.text, node);
+        }
+        else if (isVariableDeclaration(node) &&
+            isIdentifier(node.name) &&
+            node.initializer !== undefined &&
+            isFunction(unwrapped(node.initializer))) {
+            add(node.name.text, unwrapped(node.initializer));
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/**
+ * The calls one build script runs: those of its top level, and those of each function
+ * a call it runs calls or passes on, as a callee, an argument or a function called where
+ * it is written. `shadowed` is the names a function running them binds of its own, which
+ * hide the file's bindings of the same names.
+ */
+function runCalls(file, each) {
+    const named = namedFunctions(file);
+    const ran = new Set();
+    const run = (fn, outer) => {
+        if (ran.has(fn)) {
+            return;
+        }
+        ran.add(fn);
+        const shadowed = new Set([...outer, ...ownBindings(fn)]);
+        fn.forEachChild((child) => {
+            visit(child, shadowed);
+        });
+    };
+    const runs = (node, shadowed) => {
+        const at = unwrapped(node);
+        if (isFunction(at)) {
+            run(at, shadowed);
+        }
+        else if (isIdentifier(at) && !shadowed.has(at.text)) {
+            for (const fn of named.get(at.text) ?? []) {
+                run(fn, new Set());
+            }
+        }
+    };
+    const visit = (node, shadowed) => {
+        if (isFunction(node)) {
+            return;
+        }
+        if (isCallExpression(node) || isNewExpression(node)) {
+            if (isCallExpression(node)) {
+                each(node, shadowed);
+            }
+            runs(node.expression, shadowed);
+            for (const argument of node.arguments ?? []) {
+                runs(argument, shadowed);
+            }
+        }
+        node.forEachChild((child) => {
+            visit(child, shadowed);
+        });
+    };
+    file.forEachChild((child) => {
+        visit(child, new Set());
+    });
+}
+/** The entries every bundler call one build script runs names, read against `dir`. */
+function scriptEntries(file, dir, files) {
+    const found = [];
+    const declared = constants(file);
+    const scriptDir = dirnamePath(file.fileName);
+    const bound = BUNDLERS.map((api) => ({ api, bindings: bindingsOf(file, api) }));
+    runCalls(file, (call, shadowed) => {
+        for (const { api, bindings } of bound) {
+            if (!builds(call.expression, api, bindings, shadowed)) {
+                continue;
+            }
+            const [argument] = call.arguments;
+            let options = argument === undefined ? undefined : unwrapped(argument);
+            if (options !== undefined && isIdentifier(options)) {
+                options = shadowed.has(options.text) ? undefined : declared.get(options.text);
+                options = options === undefined ? undefined : unwrapped(options);
+            }
+            const entries = options === undefined ? undefined : member(options, api.option);
+            const base = options === undefined || api.base === "" ? undefined : member(options, api.base);
+            const against = base === undefined ? { path: dir } : pathOf(base, dir, scriptDir);
+            if (entries === undefined || against === undefined) {
+                continue;
+            }
+            for (const value of entryValues(entries)) {
+                const named = pathOf(value, against.path, scriptDir);
+                if (named === undefined) {
+                    continue;
+                }
+                for (const entry of entriesNamed(files, api, named)) {
+                    found.push({ file: entry, source: named.text });
+                }
+            }
+        }
+    });
+    return found;
+}
+/** The modules one manifest's scripts run, by absolute path, each below the target root. */
+function scriptModules(host, root, dir) {
+    const scripts = manifestAt(host, dir)?.["scripts"];
+    if (!isRecord(scripts)) {
+        return [];
+    }
+    const found = new Set();
+    for (const command of Object.values(scripts)) {
+        if (typeof command !== "string") {
+            continue;
+        }
+        for (const token of scriptTokens(command)) {
+            const path = resolvePath(dir, token);
+            if (MODULE_EXTENSION.test(path) &&
+                relativePath(root, path) !== undefined &&
+                !inInstalledPackages(path) &&
+                host.kindOf(path) === "file") {
+                found.add(path);
+            }
+        }
+    }
+    return [...found].sort(bytewise);
+}
+/**
+ * Every own file of one project a build script names as a bundler's entry: a module a
+ * script of a manifest at or above an own file runs, below the target root, read from
+ * the program where it holds the module and parsed alone otherwise, where a parser is given.
+ */
+export function buildScriptEntries(host, targetRoot, files, parse) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const dirs = new Set([root]);
+    for (const file of files.byName.values()) {
+        for (const dir of ancestors(dirnamePath(file.fileName), root)) {
+            if (dirs.has(dir)) {
+                break;
+            }
+            dirs.add(dir);
+        }
+    }
+    const found = [];
+    for (const dir of [...dirs].sort(bytewise)) {
+        if (!holdsManifest(host, dir)) {
+            continue;
+        }
+        for (const path of scriptModules(host, root, dir)) {
+            let script = files.byName.get(path);
+            if (script === undefined && parse !== undefined) {
+                try {
+                    script = parse(path, host.readFile(path));
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (script !== undefined) {
+                found.push(...scriptEntries(script, dir, files));
+            }
+        }
+    }
+    return found;
+}

package/dist/src/component-layer.js

@@ -5,9 +5,11 @@
  * member wins over one it extends. The mapper resolves as a package linked into the
  * `node_modules` beside each configuration, to a directory holding only its manifest.
  */
+import { INSTALLED_PACKAGES } from "./fs/manifest.js";
 import { dirnamePath, joinPath } from "./paths.js";
+import { PRODUCT } from "./product.js";
 /** The name the mapper's manifest declares and every configuration's entry names. */
-const MAPPER_PACKAGE = "deadset-ts-component-files";
+const MAPPER_PACKAGE = `${PRODUCT}-component-files`;
 /** The manifest of the mapper's package, which runs `command`. */
 export function mapperManifest(command) {
     return `${JSON.stringify({
@@ -122,7 +124,7 @@ export function componentLayer(host, configFiles, mapper, written = new Map()) {
     for (const configFile of configFiles) {
         files[configFile] = withContentMappers(written.get(configFile) ?? host.readFile(configFile), mappers);
         if (mapper !== undefined) {
-            symlinks[joinPath(dirnamePath(configFile), "node_modules", MAPPER_PACKAGE)] = {
+            symlinks[joinPath(dirnamePath(configFile), INSTALLED_PACKAGES, MAPPER_PACKAGE)] = {
                 target: mapper.packageDirectory,
                 host: true,
             };

package/dist/src/components.js

@@ -4,13 +4,12 @@
  * and every dead declaration that falls with them, being dead only through them.
  */
 import { OUTSIDE } from "./graph.js";
-/** The name every component identifier this analyzer mints starts with. */
-const ANALYZER = "deadset-ts";
+import { PRODUCT } from "./product.js";
 /** The fewest digits a component identifier's number is written with. */
 const ID_DIGITS = 4;
 /** The identifier of the component at one place of the run's order, counted from one. */
 export function componentId(place) {
-    return `${ANALYZER}/c-${String(place).padStart(ID_DIGITS, "0")}`;
+    return `${PRODUCT}/c-${String(place).padStart(ID_DIGITS, "0")}`;
 }
 /** The index of a declaration the component walk has not reached. */
 const UNVISITED = -1;
@@ -129,12 +128,12 @@ function linesSpanned(symbols) {
     return total;
 }
 /**
- * The dead declarations by subgraph place (`at`, and `position` per graph declaration),
- * a test file's only where it tests dead code or nothing the tests reach. `adjacent` holds
- * each reference one makes to another, except an unreferenced test-file declaration's to
- * production code, which decides nothing of its target; an edge each way between a dead
- * member and its dead container; and one back from each production target of an admitted
- * test, which puts the test in its subject's component. `references` holds the first alone.
+ * The dead declarations by subgraph place (`at`, and `position` per graph declaration), a
+ * test file's only where it tests dead code or nothing the tests reach. `adjacent` holds each
+ * reference one makes to another, but an unreferenced test-file declaration's to production
+ * code, which decides nothing; an edge each way between a dead member and its dead container;
+ * and one back from each non-ambient production target of an admitted test, which puts the
+ * test in its subject's component. `references` holds the first alone.
  */
 function deadSubgraph(graph, dead, testOfDeadCode, unreferencedTest) {
     const at = [];
@@ -158,6 +157,7 @@ function deadSubgraph(graph, dead, testOfDeadCode, unreferencedTest) {
             references[from]?.push(to);
             if (testOfDeadCode[index] === true &&
                 graph.test[edge.to] !== true &&
+                graph.ambient[edge.to] !== true &&
                 graph.subject[edge.to] === true) {
                 adjacent[to]?.push(from);
             }

package/dist/src/config.js

@@ -1,73 +1,18 @@
-import { CONTRACT_VERSION } from "./version.js";
+import { SEVERITIES } from "./contract/contract.generated.js";
+import { LANGUAGE } from "./product.js";
 /**
  * The name of the repository configuration at the target root, which is also the
  * document a finding about the configuration names where no document of the
  * target supplied the setting it is about.
  */
 export const REPOSITORY_DOCUMENT = "deadset.json";
-/** The kind a target kind setting gives one language's declarations. */
-export function kindOf(setting, language) {
-    return typeof setting === "string" ? setting : setting[language];
+/** The kind a target kind setting gives this analyzer's declarations. */
+export function kindOf(kind) {
+    return typeof kind === "string" ? kind : kind[LANGUAGE];
 }
-/** The severities ranked, the strongest highest. */
-const SEVERITY_RANK = { allow: 0, warn: 1, deny: 2 };
 /** Whether a finding at one severity fails a run under the failing severity. */
 export function fails(severity, failOn) {
-    return SEVERITY_RANK[severity] >= SEVERITY_RANK[failOn];
-}
-/**
- * The configuration every documented default states. `targetKind` is empty: the
- * field has no default and is never inferred.
- */
-export function defaultConfig() {
-    return {
-        contractVersion: CONTRACT_VERSION,
-        targetKind: "",
-        analysis: {
-            languages: [],
-            minConfidence: "probable",
-            generatedFiles: "exclude",
-            consumerTests: "test",
-            configurations: [],
-            matrixComplete: false,
-            templateDirs: [],
-            templateDelimiters: { left: "{{", right: "}}" },
-        },
-        consumersComplete: false,
-        rootPatterns: [],
-        severity: new Map(),
-        exemptionsDisabled: [],
-        reporters: {
-            formats: ["text"],
-            sort: "position",
-            cascade: "roots",
-            maxFindings: 0,
-            failOn: "deny",
-        },
-        providers: {
-            analyzers: [
-                { shape: "installed", name: "deadset-go", languages: ["go"], command: "deadset-go" },
-                { shape: "installed", name: "deadset-ts", languages: ["ts"], command: "deadset-ts" },
-            ],
-        },
-        ts: {
-            testFiles: [
-                "**/*.test.{ts,tsx,mts,cts}",
-                "**/*.test-d.{ts,tsx,mts,cts}",
-                "**/*.spec-d.{ts,tsx,mts,cts}",
-                "**/*.spec.*",
-                "**/__tests__/**",
-                "**/__mocks__/**",
-                "**/test-d/**",
-            ],
-            entryFiles: [],
-            componentExtensions: [".vue", ".svelte", ".astro"],
-            disabledConventions: [],
-            injectionRegistrations: [],
-            lifecycleContracts: [],
-            serializers: [],
-        },
-    };
+    return SEVERITIES.indexOf(severity) >= SEVERITIES.indexOf(failOn);
 }
 /**
  * Renders the origin as the provenance value the Contract declares: `default`,
@@ -76,23 +21,3 @@ export function defaultConfig() {
 export function renderOrigin(origin) {
     return origin.source === "default" ? "default" : `${origin.source}: ${origin.label}`;
 }
-/**
- * Every refusal configuration resolution makes. Each maps to the usage exit
- * code, and each is thrown rather than returned: a refusal ends the run, and the
- * one caller that turns it into an exit code is the command line.
- */
-export class ConfigError extends Error {
-    /** Which refusal this is. */
-    kind;
-    /**
-     * The key or field the message names, spelled as the document spells it. It is
-     * empty when the refusal names none.
-     */
-    key;
-    constructor(kind, key, message) {
-        super(message);
-        this.name = "ConfigError";
-        this.kind = kind;
-        this.key = key;
-    }
-}