@cplieger/deadset-ts 4.0.1 → 5.0.0

package/dist/src/conventions.js

@@ -0,0 +1,456 @@
+/**
+ * The convention rows a run applies, and the files they root. A row applies to a
+ * manifest that declares its enabling package when the installed package's version is
+ * in the row's range; its globs are read against that manifest's directory, with every
+ * directory a configuration property moves read from the property's literal value.
+ * No configuration file is run.
+ */
+import { isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { lineOf } from "./component-files.js";
+import { CONVENTION_ROWS, } from "./convention-rows.js";
+import { globExpression } from "./glob.js";
+import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
+import { satisfies } from "./version-range.js";
+const DEPENDENCY_SECTIONS = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readJSON(host, path) {
+    try {
+        return JSON.parse(host.readFile(path));
+    }
+    catch {
+        return undefined;
+    }
+}
+function declares(manifest, name) {
+    if (!isRecord(manifest)) {
+        return false;
+    }
+    return DEPENDENCY_SECTIONS.some((section) => {
+        const held = manifest[section];
+        return isRecord(held) && Object.hasOwn(held, name);
+    });
+}
+/**
+ * The version the installed package's manifest names, read from the nearest
+ * `node_modules` at or above `dir` that holds it, `""` where that manifest names
+ * none, or `undefined` where no `node_modules` holds it.
+ */
+function installedVersion(host, dir, name) {
+    for (let at = normalizePath(dir);; at = dirnamePath(at)) {
+        const path = joinPath(at, "node_modules", name, "package.json");
+        if (host.kindOf(path) === "file") {
+            const manifest = readJSON(host, path);
+            const version = isRecord(manifest) ? manifest["version"] : undefined;
+            return typeof version === "string" ? version : "";
+        }
+        if (dirnamePath(at) === at) {
+            return undefined;
+        }
+    }
+}
+/** Whether one node wraps an expression without changing its value. */
+function isWrapper(node) {
+    return (isParenthesizedExpression(node) ||
+        isAsExpression(node) ||
+        isSatisfiesExpression(node) ||
+        isNonNullExpression(node));
+}
+/** The expression a wrapper that changes no value holds. */
+function unwrapped(node) {
+    let at = node;
+    while (isWrapper(at)) {
+        at = at.expression;
+    }
+    return at;
+}
+/** The key one property is written with, where it is written as a name or a literal. */
+function keyOf(property) {
+    if (!isPropertyAssignment(property) && !isShorthandPropertyAssignment(property)) {
+        return undefined;
+    }
+    const { name } = property;
+    if (isComputedPropertyName(name)) {
+        return undefined;
+    }
+    if (isIdentifier(name) || isStringLiteral(name) || isNoSubstitutionTemplateLiteral(name)) {
+        return name.text;
+    }
+    return undefined;
+}
+/** The values one file's top-level variable declarations bind, by name. */
+function declaredValues(file) {
+    const values = new Map();
+    for (const statement of file.statements) {
+        if (isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (isIdentifier(declaration.name) && declaration.initializer !== undefined) {
+                    values.set(declaration.name.text, declaration.initializer);
+                }
+            }
+        }
+    }
+    return values;
+}
+function isModuleExports(node) {
+    return (isPropertyAccessExpression(node) &&
+        isIdentifier(node.expression) &&
+        node.expression.text === "module" &&
+        node.name.text === "exports");
+}
+/** Every expression or declaration one file exports as its default, in any module syntax. */
+function defaultExports(file) {
+    const found = [];
+    for (const statement of file.statements) {
+        if (isExportAssignment(statement)) {
+            found.push(statement.expression);
+        }
+        else if ((isFunctionDeclaration(statement) || isClassDeclaration(statement)) &&
+            statement.modifiers?.some((one) => one.kind === SyntaxKind.DefaultKeyword) === true) {
+            found.push(statement);
+        }
+        else if (isExportDeclaration(statement) &&
+            statement.moduleSpecifier === undefined &&
+            statement.exportClause !== undefined &&
+            isNamedExports(statement.exportClause)) {
+            for (const element of statement.exportClause.elements) {
+                if (element.name.text === "default") {
+                    found.push(element.propertyName ?? element.name);
+                }
+            }
+        }
+        else if (isExpressionStatement(statement) &&
+            isBinaryExpression(statement.expression) &&
+            statement.expression.operatorToken.kind === SyntaxKind.EqualsToken &&
+            isModuleExports(statement.expression.left)) {
+            found.push(statement.expression.right);
+        }
+    }
+    return found;
+}
+/**
+ * The first argument of every call one file makes to one module's export, through a
+ * named or a namespace import; `undefined` for a call with no argument.
+ */
+function optionsArguments(file, call) {
+    const names = new Set();
+    const namespaces = new Set();
+    for (const statement of file.statements) {
+        const bindings = isImportDeclaration(statement)
+            ? statement.importClause?.namedBindings
+            : undefined;
+        if (bindings === undefined ||
+            !isImportDeclaration(statement) ||
+            !isStringLiteral(statement.moduleSpecifier) ||
+            statement.moduleSpecifier.text !== call.module) {
+            continue;
+        }
+        if (isNamespaceImport(bindings)) {
+            namespaces.add(bindings.name.text);
+            continue;
+        }
+        for (const element of bindings.elements) {
+            if ((element.propertyName ?? element.name).text === call.export) {
+                names.add(element.name.text);
+            }
+        }
+    }
+    const found = [];
+    const visit = (node) => {
+        if (isCallExpression(node)) {
+            const callee = unwrapped(node.expression);
+            const named = isIdentifier(callee) && names.has(callee.text);
+            const throughNamespace = isPropertyAccessExpression(callee) &&
+                isIdentifier(callee.expression) &&
+                namespaces.has(callee.expression.text) &&
+                callee.name.text === call.export;
+            if (named || throughNamespace) {
+                found.push(node.arguments[0]);
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/**
+ * The object literal one expression stands for, read through the file's top-level
+ * declarations and, where `throughCalls`, through a call's first argument: `undefined`
+ * for a call with no argument, and any other node where the expression is not written
+ * out as an object literal.
+ */
+function objectOf(node, declared, throughCalls, seen = new Set()) {
+    const at = unwrapped(node);
+    if (isIdentifier(at)) {
+        const value = declared.get(at.text);
+        if (value !== undefined && !seen.has(at.text)) {
+            return objectOf(value, declared, throughCalls, new Set([...seen, at.text]));
+        }
+    }
+    else if (throughCalls && isCallExpression(at)) {
+        const [first] = at.arguments;
+        return first === undefined ? undefined : objectOf(first, declared, throughCalls, seen);
+    }
+    return at;
+}
+/**
+ * Reads the values at one path of keys below one object literal into `values`, and
+ * answers the first member that does not write its value out: a spread, a value that is
+ * not a literal at the path's end, or one that is not an object literal before it.
+ */
+function readPath(object, keys, values) {
+    const [key, ...rest] = keys;
+    for (const member of object.properties) {
+        if (isSpreadAssignment(member)) {
+            return member;
+        }
+        if (keyOf(member) !== key) {
+            continue;
+        }
+        const held = isPropertyAssignment(member) ? unwrapped(member.initializer) : undefined;
+        if (rest.length === 0) {
+            if (held === undefined || !(isStringLiteral(held) || isNoSubstitutionTemplateLiteral(held))) {
+                return member;
+            }
+            values.push(held.text);
+        }
+        else {
+            if (held === undefined || !isObjectLiteralExpression(held)) {
+                return member;
+            }
+            const failed = readPath(held, rest, values);
+            if (failed !== undefined) {
+                return failed;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Every value one file writes at one property's path inside the object it is read from:
+ * the options argument of every call `call` names, or the file's default export. A string
+ * literal or a template literal with no substitution is the value. A read object, or an
+ * object along the path, that is not written out as an object literal, or that spreads
+ * another object into itself, is not a literal, and neither is any other value at the path.
+ */
+export function readProperty(file, property, call) {
+    const declared = declaredValues(file);
+    const objects = call === undefined
+        ? defaultExports(file).map((one) => objectOf(one, declared, true))
+        : optionsArguments(file, call).map((one) => one === undefined ? undefined : objectOf(one, declared, false));
+    const values = [];
+    for (const object of objects) {
+        if (object === undefined) {
+            continue;
+        }
+        const notLiteral = isObjectLiteralExpression(object)
+            ? readPath(object, property.split("."), values)
+            : object;
+        if (notLiteral !== undefined) {
+            return { values, notLiteral };
+        }
+    }
+    return { values };
+}
+/** A directory below a manifest's, `.` for the directory itself, `undefined` outside it. */
+function below(dir, path) {
+    return normalizePath(path) === normalizePath(dir) ? "." : relativePath(dir, path);
+}
+/**
+ * Every text a template stands for, each placeholder replaced by every directory its move
+ * resolved to. A placeholder whose move resolved outside the manifest's directory leaves
+ * the text standing for nothing.
+ */
+function expand(template, resolved) {
+    const match = /<([A-Za-z]+)>/u.exec(template);
+    if (match === null) {
+        return [template];
+    }
+    const [placeholder, id = ""] = match;
+    const out = [];
+    for (const value of resolved.get(id) ?? []) {
+        if (value === undefined) {
+            continue;
+        }
+        const replaced = value === "." && template.startsWith(`${placeholder}/`, match.index)
+            ? template.replace(`${placeholder}/`, "")
+            : template.replace(placeholder, value);
+        out.push(...expand(replaced, resolved));
+    }
+    return out;
+}
+/** The configuration files in one directory that one glob names, by name. */
+function configurationFiles(host, dir, glob) {
+    const expression = globExpression(glob);
+    let entries;
+    try {
+        entries = host.readDirectory(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => !entry.directory && expression.test(entry.name))
+        .map((entry) => entry.name)
+        .sort();
+}
+function resolveMove(host, parse, dir, row, move, resolved) {
+    const set = [];
+    for (const reading of move.readings) {
+        for (const glob of reading.files) {
+            for (const name of configurationFiles(host, dir, glob)) {
+                const path = joinPath(dir, name);
+                let text;
+                try {
+                    text = host.readFile(path);
+                }
+                catch {
+                    continue;
+                }
+                const file = parse(path, text);
+                const read = readProperty(file, reading.property, reading.call);
+                if (read.notLiteral !== undefined) {
+                    const line = lineOf(text, read.notLiteral.getStart());
+                    return {
+                        failure: `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
+                            `the convention row ${row.name} reads, to a value that is not a string literal: ` +
+                            `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
+                            `files in ts.entry_files`,
+                    };
+                }
+                set.push(...read.values);
+            }
+        }
+    }
+    const dirs = [];
+    for (const base of expand(move.base ?? ".", resolved)) {
+        const against = joinPath(dir, base);
+        const texts = set.length > 0 ? set : move.defaults.flatMap((one) => expand(one, resolved));
+        for (const text of texts) {
+            dirs.push(below(dir, resolvePath(against, text)));
+        }
+    }
+    return { dirs: [...new Set(dirs)] };
+}
+/** Two strings ordered bytewise. */
+function compare(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    return a < b ? -1 : 1;
+}
+/**
+ * What the rows decide over the manifests the analysis reads. A row `disabled` names
+ * is skipped before anything is read for it.
+ */
+export function readConventions(host, parse, manifests, disabled, rows = CONVENTION_ROWS) {
+    const applied = [];
+    const globs = [];
+    const failures = [];
+    for (const manifest of manifests) {
+        const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
+        const versions = new Map();
+        const missing = new Set();
+        for (const row of rows) {
+            if (disabled.includes(row.name) || !declares(declared, row.package)) {
+                continue;
+            }
+            if (!versions.has(row.package)) {
+                versions.set(row.package, installedVersion(host, manifest.dir, row.package));
+            }
+            const version = versions.get(row.package);
+            if (version === undefined) {
+                if (missing.has(row.package)) {
+                    continue;
+                }
+                missing.add(row.package);
+                failures.push({
+                    dir: manifest.dir,
+                    failure: {
+                        setupClass: "missing-module",
+                        detail: `${manifest.path} declares ${row.package}, which no node_modules at or ` +
+                            `above its directory holds: run the package manager's install`,
+                    },
+                });
+                continue;
+            }
+            if (!satisfies(version, row.range)) {
+                continue;
+            }
+            const resolved = new Map();
+            let failed;
+            for (const move of row.moves) {
+                const result = resolveMove(host, parse, manifest.dir, row, move, resolved);
+                if ("failure" in result) {
+                    failed = result.failure;
+                    break;
+                }
+                resolved.set(move.id, result.dirs);
+            }
+            if (failed !== undefined) {
+                const where = dirnamePath(manifest.path);
+                failures.push({
+                    dir: manifest.dir,
+                    failure: {
+                        setupClass: "convention-not-literal",
+                        detail: where === "." ? failed : `${where}/${failed}`,
+                    },
+                });
+                continue;
+            }
+            applied.push({
+                name: row.name,
+                package: row.package,
+                version,
+                manifest: manifest.path,
+            });
+            const excludes = [
+                ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
+            ].map(globExpression);
+            for (const glob of new Set(row.entries.flatMap((entry) => expand(entry, resolved)))) {
+                globs.push({
+                    dir: manifest.dir,
+                    row: row.name,
+                    expression: globExpression(glob),
+                    excludes,
+                });
+            }
+        }
+    }
+    const unique = [...new Map(applied.map((one) => [JSON.stringify(one), one])).values()];
+    unique.sort((a, b) => compare(a.name, b.name) ||
+        compare(a.manifest, b.manifest) ||
+        compare(JSON.stringify(a), JSON.stringify(b)));
+    return { applied: unique, globs, failures };
+}
+/** Every own file of one project an applied row's globs match, once per row. */
+export function conventionEntries(conventions, files) {
+    const found = new Map();
+    for (const glob of conventions.globs) {
+        for (const file of files.byName.values()) {
+            const path = relativePath(glob.dir, file.fileName);
+            if (path !== undefined &&
+                glob.expression.test(path) &&
+                !glob.excludes.some((one) => one.test(path))) {
+                found.set(`${file.fileName}\u0000${glob.row}`, { file, row: glob.row });
+            }
+        }
+    }
+    return [...found.values()];
+}
+/**
+ * The failures the rows met that hold for one configuration: those of a manifest whose
+ * directory holds the configuration file or one of the files the project owns.
+ */
+export function conventionFailuresFor(conventions, configFile, ownFiles) {
+    return conventions.failures
+        .filter(({ dir }) => below(dir, dirnamePath(configFile)) !== undefined ||
+        ownFiles.some((file) => relativePath(dir, file) !== undefined))
+        .map(({ failure }) => failure);
+}

package/dist/src/dependencies.js

@@ -2,13 +2,16 @@
  * The dependencies the target's manifest declares, and what the projects' own files
  * need from outside the target. A file needs a package it imports, re-exports from,
  * augments or references the types of, by name or through the file the specifier
- * resolves to; a configuration needs one it names. A package one dependency pulls in
+ * resolves to; a compiler configuration needs one it names, and a configuration file a
+ * tool loads needs each dependency its strings spell. A package one dependency pulls in
  * for itself is that dependency's need, not the target's.
  */
 import { isExportDeclaration, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { configurationFiles, declaredIn as declaredBeside, dependenciesNamed, moduleStrings, } from "./configuration-files.js";
 import { nodeKey, packageScope } from "./inventory.js";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
+import { sourceFilesOf } from "./source-files.js";
 const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
 const MODULES_SEGMENT = `/${MODULES_DIR}/`;
@@ -181,9 +184,10 @@ function bindingsOf(node) {
  * Every package one project needs, and which declaration each use is written in.
  * One local walk and one batched resolution per file: a use of an import binding is
  * an identifier resolving to the binding's own symbol, so a local declaration that
- * shadows the name is not one.
+ * shadows the name is not one. A string of a configuration file uses each dependency
+ * the manifest beside the file declares that it spells.
  */
-export function projectNeeds(project, held, host) {
+export function projectNeeds(project, held, host, targetRoot) {
     const programPackages = new Set();
     for (const name of project.program.getSourceFileNames()) {
         const named = packageOfPath(name);
@@ -211,6 +215,29 @@ export function projectNeeds(project, held, host) {
     for (const file of project.ownSourceFiles()) {
         unanswered = fileNeeds(project, held, file, programPackages, use) || unanswered;
     }
+    const beside = new Map();
+    const declaredAt = (path) => {
+        const dir = dirnamePath(path);
+        let names = beside.get(dir);
+        if (names === undefined) {
+            names = declaredBeside(host, dir);
+            beside.set(dir, names);
+        }
+        return names;
+    };
+    const configuration = configurationFiles(host, targetRoot, sourceFilesOf(project, targetRoot));
+    for (const { file } of configuration.modules) {
+        const names = declaredAt(file.fileName);
+        for (const { node, text } of moduleStrings(file)) {
+            use(ownersOf(file, held, node), dependenciesNamed(text, names));
+        }
+    }
+    for (const document of configuration.documents) {
+        const names = declaredAt(document.path);
+        for (const text of document.strings) {
+            use([PROJECT_OWNER], dependenciesNamed(text, names));
+        }
+    }
     return { packages, uses, unanswered };
 }
 /** The declarations of the inventory a use written at one node belongs to. */

package/dist/src/discover.js

@@ -1,5 +1,6 @@
 import { DiagnosticCategory } from "@typescript/native/unstable/sync";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { SetupError } from "./setup-failure.js";
 /** Directory names discovery does not descend into. */
 export const IGNORED_DIRECTORIES = new Set(["node_modules", ".git"]);
 /** A compiler configuration file discovery recognises under a root. */
@@ -217,10 +218,16 @@ function derivedFrom(engine, host, pending, unreadable) {
  */
 export function consumerProjects(engine, host, root) {
     const kind = host.kindOf(root);
+    if (kind === "absent") {
+        throw new SetupError([
+            {
+                setupClass: "missing-consumer",
+                detail: `the scope declares the consumer ${root}, and nothing is at that path: check the consumer out at ${root} and install its dependencies`,
+            },
+        ]);
+    }
     if (kind !== "directory") {
-        throw new DiscoveryError(kind === "absent"
-            ? `the consumer ${root} does not exist`
-            : `the consumer ${root} is not a directory`, []);
+        throw new DiscoveryError(`the consumer ${root} is not a directory`, []);
     }
     const found = derivedFrom(engine, host, configFilesUnder(host, root));
     if (found.length === 0) {

package/dist/src/emit-map.js

@@ -0,0 +1,72 @@
+/**
+ * Where the compiler writes what it compiles: the output extension each source
+ * extension becomes, and the output path one source path is written to. A path a
+ * manifest or a document names is read back to its source through this one rule,
+ * whether the path is the target's own or a workspace package's.
+ */
+import { dirnamePath, joinPath, relativePath } from "./paths.js";
+/** The source extensions the compiler emits each output extension from. */
+const EMITTED = [
+    { emitted: ".d.ts", sources: [".ts", ".tsx"] },
+    { emitted: ".d.mts", sources: [".mts"] },
+    { emitted: ".d.cts", sources: [".cts"] },
+    { emitted: ".js", sources: [".ts", ".tsx"] },
+    { emitted: ".jsx", sources: [".tsx"] },
+    { emitted: ".mjs", sources: [".mts"] },
+    { emitted: ".cjs", sources: [".cts"] },
+];
+/** One path with its extension replaced, where it carries the one named. */
+function reExtended(path, emitted, source) {
+    return path.endsWith(emitted) ? path.slice(0, path.length - emitted.length) + source : undefined;
+}
+/**
+ * The longest directory every path shares, which is where the compiler roots its
+ * output when the configuration declares no root directory and its directory is not
+ * the root.
+ */
+export function commonDirectory(paths) {
+    const first = paths[0];
+    if (first === undefined) {
+        return "";
+    }
+    let common = dirnamePath(first).split("/");
+    for (const path of paths.slice(1)) {
+        const segments = dirnamePath(path).split("/");
+        let shared = 0;
+        while (shared < common.length &&
+            shared < segments.length &&
+            common[shared] === segments[shared]) {
+            shared += 1;
+        }
+        common = common.slice(0, shared);
+    }
+    return common.join("/");
+}
+/**
+ * The source paths one written path may be compiled from, in the order they are
+ * tried: for each output extension the path carries, the path re-extended where it
+ * stands, then read below each source directory where it is below the directory that
+ * output is written to.
+ */
+export function emittedFrom(path, layout) {
+    const found = [];
+    for (const { emitted, sources } of EMITTED) {
+        if (!path.endsWith(emitted)) {
+            continue;
+        }
+        const emitDir = emitted.startsWith(".d.")
+            ? (layout.declarationDir ?? layout.outDir)
+            : layout.outDir;
+        const below = emitDir === undefined ? undefined : relativePath(emitDir, path);
+        const mapped = below === undefined ? [] : layout.sourceDirs.map((dir) => joinPath(dir, below));
+        for (const source of sources) {
+            for (const from of [path, ...mapped]) {
+                const candidate = reExtended(from, emitted, source);
+                if (candidate !== undefined) {
+                    found.push(candidate);
+                }
+            }
+        }
+    }
+    return found;
+}