@cplieger/deadset-ts 8.0.0-dev.7 → 8.0.0-dev.9

package/dist/src/discover.js

@@ -1,374 +0,0 @@
-import { DiagnosticCategory } from "@typescript/native/sync";
-import { baseUrlPaths } from "./base-url.js";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
-import { SetupError } from "./setup-failure.js";
-import { writtenPath } from "./workspace-programs.js";
-import { filesBelow } from "./fs/tree.js";
-import { LANGUAGE, message } from "./product.js";
-import { LANGUAGE_ROWS } from "./contract/contract.generated.js";
-import { globExpression } from "./text/glob.js";
-const MARKERS = LANGUAGE_ROWS[LANGUAGE].markers.map(globExpression);
-/** Whether one file name is a compiler configuration's: one of the language row's markers. */
-export function isConfigFile(name) {
-    return MARKERS.some((marker) => marker.test(name));
-}
-/**
- * A run that cannot read what it was asked to analyze. It ends the run with the
- * failure code and no finding list: a configuration file the compiler cannot read,
- * or a project carrying an error, leaves the analysis without the type information
- * every answer rests on, and a partial answer is never printed as a complete one.
- */
-export class DiscoveryError extends Error {
-    /** The diagnostics the compiler reported, in the order it reported them. */
-    diagnostics;
-    constructor(message, diagnostics) {
-        super(message);
-        this.name = "DiscoveryError";
-        this.diagnostics = diagnostics;
-    }
-}
-/** The category an error diagnostic carries, which the protocol sends as a number. */
-const ERROR_CATEGORY = DiagnosticCategory.Error;
-/** Whether one diagnostic is an error, which is what fails a run closed. */
-function isError(diagnostic) {
-    return diagnostic.category === ERROR_CATEGORY;
-}
-/**
- * One diagnostic as a line naming its file, its line and column, its code and its
- * message: `path:line:column: TScode: message`, the position left out where the
- * diagnostic names none and the file where it names none. `display` spells the
- * file's path; it answers the path itself where it is not given.
- */
-export function renderDiagnostic(located, display = (path) => path) {
-    const { diagnostic, at } = located;
-    const message = `TS${String(diagnostic.code)}: ${diagnostic.text}`;
-    if (diagnostic.fileName === undefined) {
-        return message;
-    }
-    const where = display(diagnostic.fileName);
-    return at === undefined
-        ? `${where}: ${message}`
-        : `${where}:${String(at.line)}:${String(at.column)}: ${message}`;
-}
-/** Each diagnostic with the line and column its offset falls on. */
-function locatedIn(diagnostics, locate) {
-    return diagnostics.map((diagnostic) => ({
-        diagnostic,
-        at: diagnostic.fileName === undefined ? undefined : locate(diagnostic.fileName, diagnostic.pos),
-    }));
-}
-/**
- * Every error a project's three diagnostic sets carry, in the order the compiler
- * reported them: a configuration whose options do not parse, a file whose syntax
- * does not, and a program that does not type-check. A resolved configuration
- * carries no diagnostics of its own, so a configuration written with an unreadable
- * option resolves and is refused here, once its project is open.
- */
-export function diagnosticErrors(sets) {
-    return [...sets.configParsing, ...sets.syntactic, ...sets.semantic].filter(isError);
-}
-/**
- * The codes of a type library and a lib the configuration names that the compiler
- * cannot find, which it reports while it gathers the program's files,
- * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/compiler/processingDiagnostic.go,
- * and {@link MISSING_GLOBAL_TYPE}, which the checker reports.
- */
-const UNFOUND_LIBRARY = new Set([2318, 2688, 2726, 2727]);
-/**
- * The code of a global type the checker finds in no library the program holds. The checker
- * types every use of one against nothing and places no error in the file, so the analysis
- * skips each file of such a project whole.
- */
-export const MISSING_GLOBAL_TYPE = 2318;
-/** The errors one open project carries, each located in the file it names. */
-export function projectErrors(sets) {
-    // The compiler numbers its semantic messages from 2000 and its option messages from
-    // 5000. A file-less option error, a removed option or an output layout, leaves the
-    // program whole, and the compiler checks it all the same:
-    // https://github.com/microsoft/TypeScript/wiki/Coding-guidelines#diagnostic-message-codes
-    const semantic = sets.unplaced.filter((diagnostic) => isError(diagnostic) && diagnostic.code >= 2000 && diagnostic.code < 3000);
-    const unfound = semantic.filter(({ code }) => UNFOUND_LIBRARY.has(code));
-    const load = [
-        ...sets.configParsing.filter(isError),
-        ...semantic.filter(({ code }) => !UNFOUND_LIBRARY.has(code)),
-    ];
-    return {
-        load: locatedIn(load, sets.locate),
-        check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
-        unfound: load.length > 0 ? [] : locatedIn(unfound, sets.locate),
-    };
-}
-/**
- * The first line of one error about the target, every mention of the target root
- * spelled relative to it: a path below the root loses the root and its separator, and
- * the root itself is `.`.
- */
-export function targetRelative(text, targetRoot) {
-    const root = targetRoot.endsWith("/") ? targetRoot.slice(0, -1) : targetRoot;
-    const [first = ""] = text.split(/\r?\n/u);
-    const spelled = first.split(`${root}/`).join("").split(root).join(".").trim();
-    return spelled === "" ? "the configuration could not be built" : spelled;
-}
-/**
- * Whether one configuration is the analyzer's own guess: discovery derived it and the
- * scope did not name it. A guess that does not load is dropped; any other ends the run.
- */
-export function isGuess(discovery, configFile) {
-    return discovery.derived && !discovery.fromScope.includes(configFile);
-}
-/** The configuration files below `root`, by absolute path in ascending order. */
-function configFilesUnder(host, root) {
-    return filesBelow(host, root, isConfigFile).map((path) => joinPath(root, path));
-}
-/**
- * The configuration file the scope names for the target directly, where its path
- * names one rather than a directory. A target naming a directory is reached by the
- * walk over that directory instead. A consumer's projects are a consumer's, never the
- * target's, so no consumer path is read here.
- */
-function scopeConfigFiles(host, scope) {
-    return [scope.target.path]
-        .filter((path) => path.endsWith(".json"))
-        .map((path) => resolvePath(host.workingDirectory(), path));
-}
-/**
- * Every configuration file reached from `pending`, in the order discovery reads them:
- * each once, each followed by the configurations it references that `follows` admits,
- * transitively. A configuration the compiler cannot read ends the run naming it, unless
- * `unreadable` is given, which is then told the configuration and why, and the walk
- * goes on without it.
- */
-function derivedFrom(engine, host, pending, follows, unreadable) {
-    const seen = new Set();
-    const found = [];
-    while (pending.length > 0) {
-        const configFile = pending.shift();
-        if (configFile === undefined) {
-            break;
-        }
-        const path = resolvePath(host.workingDirectory(), configFile);
-        if (seen.has(path)) {
-            continue;
-        }
-        seen.add(path);
-        const read = readConfiguration(engine, path);
-        if ("reason" in read) {
-            if (unreadable === undefined) {
-                throw new DiscoveryError(`${path} cannot be read as a compiler configuration: ${read.reason}`, []);
-            }
-            unreadable(path, read.reason);
-            continue;
-        }
-        found.push(path);
-        pending.push(...read.references.filter(follows));
-    }
-    return found;
-}
-/**
- * The compiler configurations one consumer is loaded through: every one under its
- * root that is not inside an ignored directory, and the configurations each of those
- * references, transitively, in that order. A root that is absent, that is no
- * directory, or that holds no configuration ends the run naming it, because a
- * finding computed without a declared consumer would claim a reference set the run
- * never read.
- */
-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(`the consumer ${root} is not a directory`, []);
-    }
-    const found = derivedFrom(engine, host, [...configFilesUnder(host, root)], () => true);
-    if (found.length === 0) {
-        throw new DiscoveryError(`the consumer ${root} holds no compiler configuration, so none of its references can be read`, []);
-    }
-    return found;
-}
-/**
- * The name a derived project carries: its configuration file's path below the target
- * root, or the absolute path of a file outside it.
- */
-function derivedId(targetRoot, configFile) {
-    return relativePath(targetRoot, configFile) ?? configFile;
-}
-/** The configuration files one parsed configuration's `references` name. */
-function referencesOf(parsed) {
-    // The parse answers a directory reference as the directory; the compiler reads a
-    // path not ending `.json` as its `tsconfig.json`:
-    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/core/projectreference.go#L18
-    return (parsed.projectReferences ?? []).map(({ path }) => path.endsWith(".json") ? path : joinPath(path, "tsconfig.json"));
-}
-/**
- * The code of a configuration whose `extends` chain returns to a configuration it already
- * passed. A snapshot that opens two configurations whose `extends` chains reach one such
- * cycle panics (`OwnerCache.AddOwner: entry not found`, typescript 7.1.0-dev.20261014.1),
- * so the analysis refuses one before any snapshot is asked to open it.
- */
-const CIRCULAR_EXTENDS = 18000;
-/**
- * The configurations one configuration file's `references` name, or why it cannot be read:
- * the compiler throws, or its parse reports the `extends` chain circular.
- */
-function readConfiguration(engine, configFile) {
-    try {
-        const parsed = engine.parseConfigFile(configFile);
-        const circular = parsed.errors.find(({ code }) => code === CIRCULAR_EXTENDS);
-        // The compiler leaves the message's `{0}` unfilled:
-        // https://github.com/microsoft/TypeScript/pull/64755
-        return circular === undefined
-            ? { references: referencesOf(parsed) }
-            : { reason: `TS${String(circular.code)}: ${circular.text.replace("{0}", () => configFile)}` };
-    }
-    catch (error) {
-        return { reason: message(error) };
-    }
-}
-/**
- * The references of one compiler configuration file, or ends the run naming it: a
- * project opened from a configuration the compiler cannot read would be analyzed with
- * no type information.
- */
-function parseOrRefuse(engine, configFile, named) {
-    const read = readConfiguration(engine, configFile);
-    if ("reason" in read) {
-        throw new DiscoveryError(`${named} cannot be read as a compiler configuration: ${read.reason}`, []);
-    }
-    return read.references;
-}
-/**
- * The projects a build matrix declares, in its order, each entry a file below the target
- * root: an entry naming an absent file, a directory or a file the compiler cannot read
- * ends the run naming it, and one naming an earlier entry's file adds nothing. A
- * reference below the root the matrix does not name ends the run naming both, because the
- * compiler builds a referenced project's sources into the referencing program without
- * reporting their diagnostics. A reference outside the root is an outside project.
- */
-function declaredProjects(engine, host, targetRoot, entries) {
-    const seen = new Set();
-    const projects = [];
-    const references = new Map();
-    for (const entry of entries) {
-        const configFile = joinPath(targetRoot, entry.project);
-        const named = `the project ${JSON.stringify(entry.id)} (${configFile})`;
-        const kind = host.kindOf(configFile);
-        if (kind !== "file") {
-            throw new DiscoveryError(kind === "absent"
-                ? `${named} does not exist`
-                : `${named} is a directory, and a project names its compiler configuration file`, []);
-        }
-        if (seen.has(configFile)) {
-            continue;
-        }
-        seen.add(configFile);
-        references.set(configFile, parseOrRefuse(engine, configFile, named));
-        projects.push({ id: entry.id, configFile });
-    }
-    for (const project of projects) {
-        const unnamed = references
-            .get(project.configFile)
-            ?.find((path) => !seen.has(path) && relativePath(targetRoot, path) !== undefined);
-        if (unnamed !== undefined) {
-            throw new DiscoveryError(`the project ${JSON.stringify(project.id)} (${project.configFile}) references ` +
-                `${unnamed}, which the build matrix does not name. A referenced project is built ` +
-                "into the program that references it, so the matrix names it too", []);
-        }
-    }
-    return {
-        projects,
-        derived: false,
-        notBuilt: [],
-        configFiles: projects.map((project) => project.configFile),
-        fromScope: [],
-    };
-}
-/**
- * The projects a run derives where the matrix declares none, in discovery order: the
- * paths the scope names, every compiler configuration under the target root outside an
- * ignored directory, then each configuration below the root those reference,
- * transitively, each once. A reference outside the root is an outside project, whose
- * sources the compiler builds into the referencing program. A configuration the scope
- * names ends the run where it cannot be read; one the walk found is dropped and named.
- */
-function derivedProjects(engine, host, scope) {
-    const targetRoot = scope.target.path;
-    const fromScope = scopeConfigFiles(host, scope);
-    const notBuilt = [];
-    const rootDir = resolvePath(host.workingDirectory(), fromScope.length > 0 ? dirnamePath(targetRoot) : targetRoot);
-    const configFiles = derivedFrom(engine, host, [...fromScope, ...configFilesUnder(host, targetRoot)], (reference) => relativePath(rootDir, reference) !== undefined, (configFile, reason) => {
-        if (fromScope.includes(configFile)) {
-            throw new DiscoveryError(`${configFile} cannot be read as a compiler configuration: ${reason}`, []);
-        }
-        notBuilt.push({
-            id: derivedId(targetRoot, configFile),
-            configFile,
-            error: targetRelative(reason, resolvePath(host.workingDirectory(), targetRoot)),
-        });
-    });
-    const projects = configFiles.map((configFile) => ({
-        id: derivedId(targetRoot, configFile),
-        configFile,
-    }));
-    return { projects, derived: true, notBuilt, configFiles, fromScope };
-}
-/**
- * Every project one run analyzes.
- *
- * The project entries of the build matrix, where it holds any, are the projects:
- * exactly those, in the order the matrix lists them, each named by its declared
- * identifier, as {@link declaredProjects} reads them. A matrix holding no project
- * entry, the empty one included, leaves discovery to derive the projects from the
- * scope and the target tree. A platform entry names a configuration of another
- * language and plays no part here.
- *
- * A configuration file the compiler cannot read is never analyzed. One the matrix or
- * the scope names ends the run with the failure code; a guess is dropped and named in
- * {@link Discovery.notBuilt}. What a configuration's own contents say is read once its
- * project is open, by {@link diagnosticErrors}, because a resolution carries none.
- *
- * Nothing reads a build output: a project is the files its configuration names, so a
- * package whose sources ship as TypeScript is analyzed as it stands.
- */
-export function discoverProjects(engine, host, scope, configurations = []) {
-    const declared = configurations.filter((entry) => entry.shape === "project");
-    if (declared.length > 0) {
-        return declaredProjects(engine, host, scope.target.path, declared);
-    }
-    return derivedProjects(engine, host, scope);
-}
-/**
- * How the snapshot reads each configuration of `configFiles` that sets `baseUrl` and
- * `programs` does not already describe: a configuration only the snapshot holds, which
- * extends it and states the `paths` {@link baseUrlPaths} gives, so its imports resolve as
- * the compilers before version 7 resolve them. A configuration the compiler cannot read is
- * left for its project to refuse.
- */
-export function withBaseUrlPaths(engine, host, configFiles, programs) {
-    const found = new Map(programs);
-    for (const configFile of configFiles) {
-        if (found.has(configFile)) {
-            continue;
-        }
-        let paths;
-        try {
-            paths = baseUrlPaths(engine.parseConfigFile(configFile).options);
-        }
-        catch {
-            continue;
-        }
-        if (paths !== undefined) {
-            found.set(configFile, {
-                kind: "configuration",
-                file: writtenPath(host, configFile),
-                text: `${JSON.stringify({ extends: configFile, compilerOptions: { paths } }, null, 2)}\n`,
-            });
-        }
-    }
-    return found;
-}

package/dist/src/setup-failure.js

@@ -1,19 +0,0 @@
-import { SETUP_FAILURE_PREFIX } from "./contract/contract.generated.js";
-/** The failure as the one line of the error stream that names it. */
-export function setupLine(failure) {
-    return `${SETUP_FAILURE_PREFIX}${failure.setupClass}: ${failure.detail}`;
-}
-/**
- * A run that met a setup failure where none may be dropped: in a configuration the
- * configuration document or the scope declares, in a declared consumer, or in every
- * configuration discovery derived. It ends the run with the failure code and no finding
- * list.
- */
-export class SetupError extends Error {
-    failures;
-    constructor(failures) {
-        super(failures.map(setupLine).join("\n"));
-        this.name = "SetupError";
-        this.failures = failures;
-    }
-}

package/dist/src/test-joins.js

@@ -1,101 +0,0 @@
-/**
- * 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 { writtenPath } from "./workspace-programs.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 `configFiles`, 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. A configuration the compiler cannot read lists nothing and is joined
- * by nothing.
- */
-export function joinedTestFiles(engine, host, root, configFiles, patterns) {
-    const listed = new Set();
-    const byDir = new Map();
-    for (const configFile of configFiles) {
-        let fileNames;
-        try {
-            fileNames = engine.parseConfigFile(configFile).fileNames;
-        }
-        catch {
-            continue;
-        }
-        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;
-}
-/**
- * How the snapshot reads each configuration a test file joins: the program `programs`
- * describes with the files added to its root files, or a configuration only the snapshot
- * holds that extends the one `programs` writes, or the configuration itself, and lists
- * every file the configuration lists and the joined ones.
- */
-export function withJoinedTests(engine, host, programs, joins) {
-    const found = new Map(programs);
-    for (const [configFile, files] of joins) {
-        const program = programs.get(configFile);
-        if (program?.kind === "program") {
-            found.set(configFile, {
-                kind: "program",
-                params: {
-                    ...program.params,
-                    rootFiles: [...(program.params.rootFiles ?? []), ...files],
-                },
-            });
-            continue;
-        }
-        let listed;
-        try {
-            listed =
-                program?.kind === "configuration"
-                    ? engine.parseConfigJson(JSON.parse(program.text), program.file).fileNames
-                    : engine.parseConfigFile(configFile).fileNames;
-        }
-        catch {
-            continue;
-        }
-        const value = program?.kind === "configuration"
-            ? { ...JSON.parse(program.text), files: [...listed, ...files] }
-            : { extends: configFile, files: [...listed, ...files] };
-        found.set(configFile, {
-            kind: "configuration",
-            file: program?.kind === "configuration" ? program.file : writtenPath(host, configFile),
-            text: `${JSON.stringify({ ...value, include: [] }, null, 2)}\n`,
-        });
-    }
-    return found;
-}

package/src/base-url.ts

@@ -1,24 +0,0 @@
-import { resolvePath } from "./paths.ts";
-import type { Engine } from "./session.ts";
-
-type CompilerOptions = ReturnType<Engine["parseConfigFile"]>["options"];
-
-/**
- * The `paths` one configuration's resolved options map under the compilers before version
- * 7, each target absolute: a target is read against the effective `baseUrl`, and a specifier
- * no other pattern maps is looked up below it. Undefined where no `baseUrl` is set, so the
- * options' own `paths` stand. Version 7 reads no `baseUrl`:
- * https://github.com/microsoft/TypeScript/issues/62207
- */
-export function baseUrlPaths(options: CompilerOptions): Record<string, string[]> | undefined {
-  const baseUrl: unknown = Reflect.get(options, "baseUrl");
-  if (typeof baseUrl !== "string") {
-    return undefined;
-  }
-  return Object.fromEntries(
-    Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
-      key,
-      targets.map((target) => resolvePath(baseUrl, target)),
-    ]),
-  );
-}