@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/load/specifiers.js

@@ -0,0 +1,113 @@
+/**
+ * The module specifiers of the JavaScript files a configuration does not check, read for what
+ * the compiler leaves unresolved. Unchecked JavaScript reports no unfound module, and a
+ * JavaScript file may name a file that is absent on purpose, so an unresolved one is no failure
+ * of the program: a relative one is noted, and only a configuration whose imported dependencies
+ * are none of them installed fails, because its program is not the one the project runs.
+ */
+import { isBinaryExpression, isCallExpression, isParenthesizedExpression, isStringLiteralLikeNode, isTryStatement, SyntaxKind, } from "@typescript/native/ast";
+import { packageOfSpecifier } from "../dependencies.js";
+import { readManifestAt } from "../fs/manifest.js";
+import { JAVASCRIPT_FILE } from "../javascript-file.js";
+import { ancestors, dirnamePath, isRelativeSpecifier, relativePath, resolvePath, } from "../paths.js";
+import { renderPosition } from "../position.js";
+import { batched } from "../session.js";
+import { dependencySpecifiers } from "./module-lookup.js";
+/**
+ * Whether one specifier is loaded optionally: written inside a `try` block, or as a call whose
+ * result an `||` or a `??` falls back from, so the program is written for its absence.
+ */
+function optional(node) {
+    const call = node.parent;
+    let operand = call;
+    let parent = call.parent;
+    while (parent !== undefined && isParenthesizedExpression(parent)) {
+        operand = parent;
+        parent = parent.parent;
+    }
+    if (isCallExpression(call) &&
+        parent !== undefined &&
+        isBinaryExpression(parent) &&
+        parent.left === operand &&
+        (parent.operatorToken.kind === SyntaxKind.BarBarToken ||
+            parent.operatorToken.kind === SyntaxKind.QuestionQuestionToken)) {
+        return true;
+    }
+    for (let at = node; at !== undefined; at = at.parent) {
+        const above = at.parent;
+        if (above !== undefined && isTryStatement(above) && above.tryBlock === at) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Whether a manifest at or above `dir`, no higher than `root`, declares the package `name`. A
+ * manifest that does not parse or cannot be read ends the search, because what it declares is
+ * unanswered and a manifest above it is another package's.
+ */
+function declared(host, dir, root, name) {
+    for (const at of ancestors(dir, root)) {
+        const read = readManifestAt(host, at);
+        if (read.kind === "malformed" || read.kind === "unread") {
+            return false;
+        }
+        if (read.kind === "read" && dependencySpecifiers(read.manifest, name).length > 0) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * The specifiers of every JavaScript file of `project`, where its options do not check
+ * JavaScript, each asked of the compiler in batched round trips. A relative one naming a path
+ * below one of the run's output directories names build output, which a build writes later.
+ */
+export function readSpecifiers(engine, host, project, { checked, root, outputs }) {
+    if (checked) {
+        return { unresolved: [], uninstalled: undefined };
+    }
+    const usages = [];
+    for (const file of project.ownSourceFiles()) {
+        if (JAVASCRIPT_FILE.test(file.fileName)) {
+            for (const node of file.imports) {
+                if (isStringLiteralLikeNode(node) && !optional(node)) {
+                    usages.push({ file, node });
+                }
+            }
+        }
+    }
+    const answers = batched(engine, usages, ({ file, node }) => project.program.getResolvedModuleFromModuleSpecifier.gen(node, file.fileName));
+    const unresolved = [];
+    let missing;
+    let installed = false;
+    for (const [at, usage] of usages.entries()) {
+        const resolved = (answers[at]?.resolvedFileName ?? "") !== "";
+        const specifier = usage.node.text;
+        const name = packageOfSpecifier(specifier);
+        if (isRelativeSpecifier(specifier)) {
+            const named = resolvePath(dirnamePath(usage.file.fileName), specifier);
+            if (!resolved && !outputs.some((dir) => relativePath(dir, named) !== undefined)) {
+                unresolved.push({
+                    specifier,
+                    position: renderPosition(usage.file, root, usage.node.getStart()),
+                });
+            }
+        }
+        else if (name !== undefined && declared(host, dirnamePath(usage.file.fileName), root, name)) {
+            installed ||= resolved;
+            missing ??= resolved ? undefined : usage;
+        }
+    }
+    if (installed || missing === undefined) {
+        return { unresolved, uninstalled: undefined };
+    }
+    const { path, line } = renderPosition(missing.file, root, missing.node.getStart());
+    return {
+        unresolved,
+        uninstalled: {
+            failureClass: "missing-module",
+            detail: `${path}:${String(line)}: ${path} imports ${JSON.stringify(missing.node.text)}, a declared dependency, and no dependency the configuration's JavaScript files import is installed: run the package manager's install`,
+        },
+    };
+}

package/dist/src/load/synthesize.js

@@ -0,0 +1,152 @@
+/**
+ * The programs a run forms for the JavaScript files no compiler configuration lists: one per
+ * package, over the files git would track that are no build output, each written as a
+ * configuration only the snapshot holds, with the module system of the runtime its package
+ * is written for.
+ */
+import { readCommands } from "../commands/read.js";
+import { CONVENTION_ROWS } from "../entries/convention-rows.js";
+import { holdsManifest, MANIFEST, readManifestAt } from "../fs/manifest.js";
+import { filesBelow } from "../fs/tree.js";
+import { JAVASCRIPT_FILE, minifiedBy, minifiedByName } from "../javascript-file.js";
+import { isRecord } from "../json-document.js";
+import { manifestCommands } from "../roots/manifest.js";
+import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { writtenPath } from "./workspace-programs.js";
+/** The name a package's program is written beside, made free by {@link writtenPath}. */
+const GROUP_CONFIGURATION = "jsconfig.json";
+/**
+ * The options of a formed program before its runtime is chosen: unchecked JavaScript, no
+ * emit, no installed package's JavaScript, which is not the target's code and grows the
+ * program with the depth of `node_modules`, and every type package visible.
+ */
+const FORMED_OPTIONS = {
+    allowJs: true,
+    checkJs: false,
+    noEmit: true,
+    skipLibCheck: true,
+    maxNodeModuleJsDepth: 0,
+    target: "esnext",
+    jsx: "preserve",
+    resolveJsonModule: true,
+};
+/** Whether one file is minified build output; one that cannot be read is left to the compiler. */
+function minifiedFile(host, file) {
+    if (minifiedByName(file) !== undefined) {
+        return true;
+    }
+    try {
+        return minifiedBy(file, host.readFile(file)) !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The JavaScript files below `root` a program may be formed over: none in a skipped
+ * directory, none git ignores, none minified, none `context` covers and none below one of
+ * its output directories. A convention row's generated directory leaves out more, once the
+ * rows are read: {@link formedGroups}.
+ */
+export function candidateFiles(host, root, { covered, outputs, ignored }) {
+    return filesBelow(host, root, (name) => JAVASCRIPT_FILE.test(name))
+        .map((path) => joinPath(root, path))
+        .filter((file) => !covered.has(file) &&
+        !outputs.some((dir) => relativePath(dir, file) !== undefined) &&
+        !ignored(file) &&
+        !minifiedFile(host, file));
+}
+/**
+ * The candidates below `root` grouped by package, in directory order, less every file below a
+ * directory an applied row of `conventions` names as generated: each file belongs to the
+ * nearest directory at or above it, up to `root`, that holds a `package.json`, a manifest that
+ * does not parse included, and to `root` where none does.
+ */
+export function formedGroups(host, root, candidates, conventions) {
+    const generated = conventions.generated.map(({ dir, below }) => joinPath(dir, below));
+    const groups = new Map();
+    for (const file of candidates) {
+        if (generated.some((dir) => relativePath(dir, file) !== undefined)) {
+            continue;
+        }
+        const dir = packageOf(host, root, file);
+        groups.set(dir, [...(groups.get(dir) ?? []), file]);
+    }
+    return [...groups]
+        .sort(([a], [b]) => bytewise(a, b))
+        .map(([dir, files]) => ({
+        dir,
+        manifest: readManifestAt(host, dir),
+        files: files.sort(bytewise),
+    }));
+}
+/** The directory whose `package.json` groups one file: the nearest at or above it, up to `root`. */
+export function packageOf(host, root, file) {
+    return ancestors(dirnamePath(file), root).find((at) => holdsManifest(host, at)) ?? root;
+}
+const RUNTIME_OPTIONS = {
+    bundler: { module: "preserve", moduleResolution: "bundler" },
+    node: { module: "nodenext", moduleResolution: "nodenext" },
+};
+/** Whether one configuration is a program the run formed to resolve its modules as Node does. */
+export function formedForNode(configuration) {
+    const options = configuration.written?.["compilerOptions"];
+    return isRecord(options) && options["moduleResolution"] === RUNTIME_OPTIONS.node.moduleResolution;
+}
+/** The manifest members that say a package is written for Node. */
+const NODE_MEMBERS = ["main", "exports", "bin", "type"];
+/**
+ * Whether one manifest says its package runs under Node: a Node member, `engines.node`
+ * included, or a command string of it that runs a file with `node`, as `commands/read.ts` reads it.
+ */
+function writtenForNode(host, dir, manifest) {
+    const { engines } = manifest;
+    return (NODE_MEMBERS.some((member) => manifest[member] !== undefined) ||
+        (isRecord(engines) && engines["node"] !== undefined) ||
+        manifestCommands(host, dir, manifest).some(({ command }) => readCommands(command, dir).runs.some((run) => run.runtime === "node")));
+}
+/**
+ * The manifests, by path as `conventions` names them, an applied row of a tool that bundles
+ * applies through.
+ */
+export function bundlingManifests(conventions) {
+    return new Set(conventions.applied
+        .filter((one) => CONVENTION_ROWS.some((row) => row.name === one.name && row.bundles === true))
+        .map((one) => one.manifest));
+}
+/**
+ * Each group's program, given the module system of the runtime its package is written for: a
+ * bundler's where a row of a tool that bundles applies through the group's manifest or the
+ * root's, else Node's where its manifest says the package runs under Node or a command string of
+ * it runs a file with `node`, under which a file's
+ * extension and its package's `type` decide its module format, else a bundler's, which reads a
+ * file with no module syntax as a classic script, as a browser loads it.
+ */
+export function formedPrograms(engine, host, groups, { root, origin, bundling, idOf }) {
+    return groups.map((group) => {
+        const manifest = group.manifest.kind === "absent" ? undefined : joinPath(group.dir, MANIFEST);
+        const below = manifest === undefined ? undefined : relativePath(root, manifest);
+        const runtime = !bundling.has(MANIFEST) &&
+            (below === undefined || !bundling.has(below)) &&
+            group.manifest.kind === "read" &&
+            writtenForNode(host, group.dir, group.manifest.manifest)
+            ? "node"
+            : "bundler";
+        const configFile = writtenPath(host, joinPath(group.dir, GROUP_CONFIGURATION));
+        const written = {
+            compilerOptions: { ...FORMED_OPTIONS, ...RUNTIME_OPTIONS[runtime] },
+            files: group.files,
+        };
+        return {
+            group,
+            configuration: {
+                id: idOf(manifest),
+                configFile,
+                origin,
+                parsed: engine.parseConfigJson(written, configFile),
+                written,
+            },
+        };
+    });
+}

package/dist/src/load/test-globals.js

@@ -0,0 +1,207 @@
+/**
+ * The globals a test runner injects into every file it runs, which no import names: a
+ * Vitest configuration whose `test.globals` is `true` gives each test and each file it
+ * loads `describe`, `it`, `expect` and `vi` (https://vitest.dev/config/globals). A program
+ * analyzed without the runner's declarations of them reads every use as an error, so a
+ * configuration under such a runner is read with them; and a file that calls one is
+ * written for the runner, as one that imports it is.
+ */
+import { isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isExpressionStatement, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isRecord } from "../json-document.js";
+import { ancestors, dirnamePath, joinPath } from "../paths.js";
+import { UNANSWERED } from "../query.js";
+import { filesIn } from "../fs/tree.js";
+import { holdsManifest, INSTALLED_PACKAGES } from "../fs/manifest.js";
+import { isTargetConfiguration } from "./discover.js";
+/** The test runner whose configuration injects the globals, and the `types` entry declaring them. */
+export const GLOBALS_RUNNER = "vitest";
+const GLOBALS_TYPES = "vitest/globals";
+/** The configuration files the runner reads its settings from, by name. */
+const RUNNER_CONFIG = /^(?:vitest|vite)\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u;
+/** The globals `vitest/globals` declares that a test or a helper calls or reads a member of. */
+const GLOBAL_NAMES = new Set([
+    "afterAll",
+    "afterEach",
+    "assert",
+    "assertType",
+    "beforeAll",
+    "beforeEach",
+    "bench",
+    "describe",
+    "expect",
+    "expectTypeOf",
+    "it",
+    "onTestFailed",
+    "onTestFinished",
+    "suite",
+    "test",
+    "vi",
+    "vitest",
+]);
+/** The expression one wrapper that changes no value holds, and a call's first argument. */
+function configObject(node) {
+    let at = node;
+    while (at !== undefined) {
+        if (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
+            at = at.expression;
+        }
+        else if (isCallExpression(at)) {
+            at = at.arguments[0];
+        }
+        else {
+            return at;
+        }
+    }
+    return undefined;
+}
+/** The value one object literal writes for one member as `name: value`. */
+function member(object, name) {
+    if (object === undefined || !isObjectLiteralExpression(object)) {
+        return undefined;
+    }
+    for (const property of object.properties) {
+        if (isPropertyAssignment(property) &&
+            isIdentifier(property.name) &&
+            property.name.text === name) {
+            return configObject(property.initializer);
+        }
+    }
+    return undefined;
+}
+/** Whether one runner configuration's default export sets `test.globals` to `true`. */
+function setsGlobals(file) {
+    for (const statement of file.statements) {
+        let exported;
+        if (isExportAssignment(statement)) {
+            exported = statement.expression;
+        }
+        else if (isExpressionStatement(statement) && isBinaryExpression(statement.expression)) {
+            const { left, operatorToken, right } = statement.expression;
+            if (operatorToken.kind === SyntaxKind.EqualsToken &&
+                isPropertyAccessExpression(left) &&
+                isIdentifier(left.expression) &&
+                left.expression.text === "module" &&
+                isIdentifier(left.name) &&
+                left.name.text === "exports") {
+                exported = right;
+            }
+        }
+        const object = exported === undefined ? undefined : configObject(exported);
+        const globals = member(member(object, "test"), "globals");
+        if (globals?.kind === SyntaxKind.TrueKeyword) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Whether the runner's configuration in one manifest's directory injects the globals. */
+function injectsGlobals(host, parse, dir) {
+    return filesIn(host, dir, (name) => RUNNER_CONFIG.test(name)).some((name) => {
+        const path = joinPath(dir, name);
+        try {
+            return setsGlobals(parse(path, host.readFile(path)));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Whether a file declaring the globals is installed where the configuration resolves packages from. */
+function globalsInstalled(host, configFile) {
+    return ancestors(dirnamePath(configFile)).some((dir) => host.kindOf(joinPath(dir, INSTALLED_PACKAGES, GLOBALS_RUNNER, "globals.d.ts")) === "file");
+}
+/** The directory of the manifest nearest one configuration file, at or above its own. */
+function manifestDir(host, configFile) {
+    return ancestors(dirnamePath(configFile)).find((dir) => holdsManifest(host, dir));
+}
+function typesOf(value) {
+    return Array.isArray(value) && value.every((one) => typeof one === "string") ? value : undefined;
+}
+/**
+ * The plans with the globals' declarations added to the `types` of each target configuration
+ * whose nearest manifest's runner configuration injects them and that can resolve them.
+ */
+export function testGlobals(host, parse, plans) {
+    const injects = new Map();
+    return plans.map((plan) => {
+        const dir = manifestDir(host, plan.configFile);
+        if (!isTargetConfiguration(plan) ||
+            dir === undefined ||
+            !globalsInstalled(host, plan.configFile)) {
+            return plan;
+        }
+        if (!injects.has(dir)) {
+            injects.set(dir, injectsGlobals(host, parse, dir));
+        }
+        const base = typesOf(plan.options.types) ?? [];
+        const { build } = plan;
+        if (injects.get(dir) !== true) {
+            return plan;
+        }
+        if (build.kind === "program") {
+            const listed = typesOf(build.params.compilerOptions.types) ?? base;
+            return listed.includes(GLOBALS_TYPES)
+                ? plan
+                : {
+                    ...plan,
+                    build: {
+                        kind: "program",
+                        params: {
+                            ...build.params,
+                            compilerOptions: {
+                                ...build.params.compilerOptions,
+                                types: [...listed, GLOBALS_TYPES],
+                            },
+                        },
+                    },
+                };
+        }
+        const written = build.kind === "configuration" ? build.value : { extends: plan.configFile };
+        const held = written["compilerOptions"];
+        const options = isRecord(held) ? held : {};
+        const listed = typesOf(options["types"]) ?? base;
+        return listed.includes(GLOBALS_TYPES)
+            ? plan
+            : {
+                ...plan,
+                build: {
+                    kind: "configuration",
+                    value: {
+                        ...written,
+                        compilerOptions: { ...options, types: [...listed, GLOBALS_TYPES] },
+                    },
+                },
+            };
+    });
+}
+/**
+ * Whether one file names a global the runner injects, which is how a file written for the
+ * runner's globals reads: a call of one of the names or a read of a member of it that
+ * resolves to a declaration outside the project's own files, the runner's declaration
+ * file. A name the file binds, imported, declared or a parameter, resolves to its own.
+ */
+export function namesTestGlobals(project, file) {
+    const named = [];
+    const visit = (node) => {
+        const callee = isCallExpression(node)
+            ? node.expression
+            : isPropertyAccessExpression(node)
+                ? node.expression
+                : undefined;
+        if (callee !== undefined && isIdentifier(callee) && GLOBAL_NAMES.has(callee.text)) {
+            named.push(callee);
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    if (named.length === 0) {
+        return false;
+    }
+    const own = project.ownPaths();
+    return project
+        .symbolsAt(named.map((node) => project.handle(node)))
+        .some((symbol) => symbol === UNANSWERED ||
+        (symbol !== undefined &&
+            symbol.declarations.length > 0 &&
+            symbol.declarations.every((handle) => !own.has(handle.path))));
+}

package/dist/src/load/test-joins.js

@@ -0,0 +1,82 @@
+/**
+ * The test files a derived matrix holds although no configuration's file list names them.
+ * The test runner compiles such a file with the options of the nearest compiler
+ * configuration at or above it, so the file joins that configuration's program as a file
+ * its list names, unless a `package.json` below that configuration's directory makes the
+ * file another package's, which its own test runner compiles.
+ */
+import { sourcePaths } from "../file-facts.js";
+import { ancestors, dirnamePath, joinPath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { holdsManifest } from "../fs/manifest.js";
+const PREFERRED = "/tsconfig.json";
+/** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
+function byPreference(a, b) {
+    const first = a.endsWith(PREFERRED) ? 0 : 1;
+    const second = b.endsWith(PREFERRED) ? 0 : 1;
+    return first - second || bytewise(a, b);
+}
+/**
+ * Per configuration of `configurations`, the absolute paths of the test files that join it:
+ * each file below `root` a pattern of `patterns` names, that no configuration's file list
+ * holds, joins the configuration nearest at or above its directory when no `package.json`
+ * sits between them.
+ */
+export function joinedTestFiles(host, root, configurations, patterns) {
+    const listed = new Set();
+    const byDir = new Map();
+    for (const { configFile, parsed } of configurations) {
+        parsed.fileNames.forEach((name) => listed.add(name));
+        const dir = dirnamePath(configFile);
+        byDir.set(dir, [...(byDir.get(dir) ?? []), configFile].sort(byPreference));
+    }
+    const joins = new Map();
+    for (const path of sourcePaths(host, root)) {
+        const file = joinPath(root, path);
+        if (listed.has(file) || !patterns.some((pattern) => pattern.test(path))) {
+            continue;
+        }
+        for (const dir of ancestors(dirnamePath(file), root)) {
+            const [nearest] = byDir.get(dir) ?? [];
+            if (nearest !== undefined) {
+                joins.set(nearest, [...(joins.get(nearest) ?? []), file]);
+                break;
+            }
+            if (holdsManifest(host, dir)) {
+                break;
+            }
+        }
+    }
+    return joins;
+}
+/**
+ * The plans with each joined test file added to the configuration it joins: to a described
+ * program's root files, or to the file list of a configuration only the snapshot holds, which
+ * lists every file the configuration lists and the joined ones.
+ */
+export function joinedTests(plans, joins) {
+    return plans.map((plan) => {
+        const files = joins.get(plan.configFile);
+        const { build } = plan;
+        if (files === undefined) {
+            return plan;
+        }
+        if (build.kind === "program") {
+            return {
+                ...plan,
+                build: {
+                    kind: "program",
+                    params: { ...build.params, rootFiles: [...(build.params.rootFiles ?? []), ...files] },
+                },
+            };
+        }
+        const written = build.kind === "configuration" ? build.value : { extends: plan.configFile };
+        return {
+            ...plan,
+            build: {
+                kind: "configuration",
+                value: { ...written, files: [...plan.parsed.fileNames, ...files], include: [] },
+            },
+        };
+    });
+}

package/dist/src/{workspace-manifests.js → load/workspace-manifests.js}

@@ -6,8 +6,9 @@
  * workspace imports, so only its commands are entry points.
  */
 import { emittedFrom } from "./emit-map.js";
-import { readManifest } from "./manifest.js";
-import { joinPath, relativePath } from "./paths.js";
+import { readManifest } from "../roots/manifest.js";
+import { joinPath, relativePath } from "../paths.js";
+import { MANIFEST } from "../fs/manifest.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
 /** The paths one written target stands for in its member's sources, itself included. */
@@ -53,8 +54,7 @@ export function memberEntries(host, resolver, targetRoot) {
             return [];
         }
         const manifest = readManifest(host, member.dir);
-        const where = relativePath(targetRoot, joinPath(member.dir, "package.json")) ??
-            joinPath(member.dir, "package.json");
+        const where = relativePath(targetRoot, joinPath(member.dir, MANIFEST)) ?? joinPath(member.dir, MANIFEST);
         const kept = manifest.entries.flatMap((entry) => {
             const exported = entry.member.startsWith("exports");
             if (member.private && exported) {