@cplieger/deadset-ts 4.0.1 → 5.1.0

package/dist/src/workspace-programs.js

@@ -0,0 +1,342 @@
+/**
+ * The programs of a workspace's configurations, each reading the members it imports
+ * from source. Each round builds the programs, answers their member imports, and gives
+ * the answers back as static resolutions, which the compiler reads as the program's own
+ * files rather than a library's, until a round adds none. A configuration with no
+ * member import keeps the project the compiler opens for it.
+ */
+import { ModuleKind, ModuleResolutionKind } from "@typescript/native/unstable/sync";
+import { isStringLiteralLikeNode } from "@typescript/native/unstable/ast";
+import { dirnamePath, joinPath, resolvePath } from "./paths.js";
+/** The most questions one round trip carries. */
+const BATCH = 2048;
+/**
+ * The options a configuration's program is built with: its own, less the ones that
+ * lay out an emitted program's inputs and outputs. The analysis emits nothing, and a
+ * member's source is outside the importer's root directory by construction, which
+ * the compiler refuses under such a layout.
+ */
+function analysisOptions(parsed) {
+    const { composite, rootDir: _rootDir, outDir: _outDir, declarationDir: _declarationDir, tsBuildInfoFile: _tsBuildInfoFile, ...kept } = parsed.options;
+    return composite === true ? { ...kept, declaration: true } : kept;
+}
+/**
+ * The references a built program can carry: only where every referenced
+ * configuration reads and is composite with output, because the compiler reports a
+ * broken reference at syntax a built program does not have.
+ */
+function carriedReferences(engine, parsed) {
+    const references = parsed.projectReferences ?? [];
+    for (const reference of references) {
+        // A reference that names a directory names the `tsconfig.json` in it.
+        const configFile = reference.path.endsWith(".json")
+            ? reference.path
+            : joinPath(reference.path, "tsconfig.json");
+        let options;
+        try {
+            options = engine.parseConfigFile(configFile).options;
+        }
+        catch {
+            return [];
+        }
+        if (options.composite !== true || options.noEmit === true) {
+            return [];
+        }
+    }
+    return references;
+}
+/** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
+function conditionsOf(parsed, mode) {
+    const resolution = parsed.options.moduleResolution;
+    const nodeLike = resolution === ModuleResolutionKind.Node16 || resolution === ModuleResolutionKind.NodeNext;
+    return new Set([
+        "types",
+        mode === ModuleKind.CommonJS ? "require" : "import",
+        ...(nodeLike ? ["node"] : []),
+        ...(parsed.options.customConditions ?? []),
+        "default",
+    ]);
+}
+function resolutionMode(kind) {
+    return kind === ModuleKind.CommonJS || kind === ModuleKind.ESNext ? kind : undefined;
+}
+/** The directories the compiler leaves out of a configuration that names no `exclude`. */
+const DEFAULT_EXCLUDES = ["node_modules", "bower_components", "jspm_packages"];
+/** Why one configuration's answers cannot be `paths`: a specifier read as two files. */
+function unstatable(reading) {
+    const answered = new Set(reading.entries.map((entry) => entry.moduleName));
+    for (const [specifier, files] of reading.bound) {
+        if (answered.has(specifier) && files.size > 1) {
+            return `the imports of ${specifier} are read as ${String(files.size)} different files, which a configuration cannot state`;
+        }
+    }
+    return undefined;
+}
+/** The path beside `configFile` its written configuration takes, which no file has. */
+function writtenPath(host, configFile) {
+    const stem = configFile.replace(/\.json$/u, "");
+    for (let counter = 0;; counter += 1) {
+        const path = `${stem}.deadset-ts${counter === 0 ? "" : `-${String(counter)}`}.json`;
+        if (host.kindOf(path) === "absent") {
+            return path;
+        }
+    }
+}
+/**
+ * The configuration that reads as one configuration's program: it extends it, lays out
+ * no output for the reason {@link analysisOptions} gives, maps each answered specifier
+ * to its file, and carries the references the program does. The compiler's default
+ * `exclude` names the output directories this drops, so where the file list moves it is
+ * restated; a list that still differs, or answers `paths` cannot state, are a reason.
+ */
+function configurationOf(engine, host, reading) {
+    const reason = unstatable(reading);
+    if (reason !== undefined) {
+        return { kind: "unread", reason };
+    }
+    const { options } = reading.parsed;
+    const raw = options["pathsBasePath"];
+    const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
+    const paths = {};
+    for (const [key, targets] of Object.entries(options.paths ?? {})) {
+        paths[key] = targets.map((target) => resolvePath(base, target));
+    }
+    for (const entry of reading.entries) {
+        const [file] = reading.bound.get(entry.moduleName) ?? [];
+        if (file !== undefined) {
+            paths[entry.moduleName] = [file];
+        }
+    }
+    const json = (exclude) => ({
+        extends: reading.configFile,
+        compilerOptions: {
+            rootDir: null,
+            outDir: null,
+            declarationDir: null,
+            tsBuildInfoFile: null,
+            ...(options.composite === true ? { composite: false, declaration: true } : {}),
+            paths,
+        },
+        ...(reading.references.length > 0
+            ? { references: reading.references.map((reference) => ({ path: reference.path })) }
+            : {}),
+        ...(exclude === undefined ? {} : { exclude }),
+    });
+    const file = writtenPath(host, reading.configFile);
+    const expected = [...reading.parsed.fileNames].sort().join("\u0000");
+    const listed = (value) => {
+        try {
+            return [...engine.parseConfigJson(value, file).fileNames].sort().join("\u0000");
+        }
+        catch {
+            return undefined;
+        }
+    };
+    let value = json(undefined);
+    if (listed(value) !== expected) {
+        value = json([
+            ...DEFAULT_EXCLUDES,
+            ...[options.outDir, options.declarationDir].filter((dir) => dir !== undefined),
+        ]);
+        if (listed(value) !== expected) {
+            return {
+                kind: "unread",
+                reason: "its file list cannot be restated without its output directories",
+            };
+        }
+    }
+    return { kind: "configuration", file, text: `${JSON.stringify(value, null, 2)}\n` };
+}
+/** The program one configuration is built as, under the answers it holds so far. */
+function programOf(engine, reading) {
+    const compilerOptions = analysisOptions(reading.parsed);
+    const resolver = engine.createModuleResolver(compilerOptions, reading.entries);
+    return {
+        resolver,
+        params: {
+            rootFiles: reading.parsed.fileNames,
+            compilerOptions,
+            options: {
+                moduleResolver: resolver,
+                configFileParsingDiagnostics: reading.parsed.errors,
+                ...(reading.references.length > 0 ? { projectReferences: reading.references } : {}),
+            },
+        },
+    };
+}
+function chunks(items) {
+    const found = [];
+    for (let at = 0; at < items.length; at += BATCH) {
+        found.push(items.slice(at, at + BATCH));
+    }
+    return found;
+}
+/** Asks one question of every item, in round trips of at most {@link BATCH}. */
+function batched(engine, items, question) {
+    return chunks(items).flatMap((run) => engine.batch(run.map(question)));
+}
+/** One round over one program: answers the member imports no earlier round asked about. */
+function scan(engine, program, reading, resolver) {
+    const names = program.getSourceFileNames().filter((name) => !name.includes("/node_modules/"));
+    const files = batched(engine, names, (name) => program.getSourceFile.gen(name));
+    const usages = [];
+    files.forEach((file, at) => {
+        const name = names[at];
+        if (file === undefined || name === undefined) {
+            return;
+        }
+        for (const node of file.imports) {
+            if (isStringLiteralLikeNode(node) && resolver.names(node.text)) {
+                usages.push({ file: name, node });
+            }
+        }
+    });
+    const modes = batched(engine, usages, (usage) => program.getModeForUsageLocation.gen(usage.file, usage.node));
+    const asked = [];
+    usages.forEach((usage, at) => {
+        const mode = resolutionMode(modes[at] ?? ModuleKind.None);
+        const key = [usage.node.text, dirnamePath(usage.file), String(mode)].join("\u0000");
+        if (!reading.seen.has(key)) {
+            reading.seen.add(key);
+            asked.push({ usage, mode });
+        }
+    });
+    const answers = batched(engine, asked, ({ usage }) => program.getResolvedModuleFromModuleSpecifier.gen(usage.node, usage.file));
+    let added = 0;
+    asked.forEach(({ usage, mode }, at) => {
+        const answered = answers[at];
+        const specifier = usage.node.text;
+        const containingDirectory = dirnamePath(usage.file);
+        const compiled = answered?.resolvedFileName === undefined || answered.resolvedFileName === ""
+            ? undefined
+            : answered;
+        const answer = resolver.resolve(specifier, containingDirectory, conditionsOf(reading.parsed, mode), compiled);
+        if (answer.kind !== "unresolved") {
+            const bound = reading.bound.get(specifier) ?? new Set();
+            bound.add(answer.kind === "source" ? answer.file : (compiled?.resolvedFileName ?? ""));
+            reading.bound.set(specifier, bound);
+        }
+        if (answer.kind === "source") {
+            reading.entries.push({
+                moduleName: specifier,
+                containingDirectory,
+                resolutionMode: mode,
+                result: { resolvedFileName: answer.file },
+            });
+            added += 1;
+        }
+        else if (answer.kind === "unresolved") {
+            reading.unresolved.push({
+                file: usage.file,
+                specifier,
+                member: answer.member,
+                subpath: answer.subpath,
+                reason: answer.reason,
+            });
+        }
+    });
+    return added;
+}
+/**
+ * Answers the member imports of every reading `build` describes, round by round, all
+ * the readings still adding answers built in one snapshot per round. A reading `build`
+ * gives no description for leaves the rounds.
+ */
+function readRounds(engine, readings, resolver, build) {
+    let pending = readings;
+    while (pending.length > 0) {
+        const built = pending.flatMap((reading) => {
+            const one = build(reading);
+            return one === undefined ? [] : [{ reading, one }];
+        });
+        const programs = built.flatMap(({ one }) => (one.kind === "program" ? [one.params] : []));
+        const written = new Map(built.flatMap(({ one }) => one.kind === "configuration" ? [[one.file, one.text]] : []));
+        const snapshot = engine.createSnapshot([...written.keys()], programs, written);
+        try {
+            const created = snapshot.operation.createdPrograms ?? [];
+            const opened = new Map(snapshot.getProjects().map((project) => [project.configFileName, project.program]));
+            let at = 0;
+            pending = built.flatMap(({ reading, one }) => {
+                const program = one.kind === "program" ? created[at++] : opened.get(one.file);
+                return program !== undefined && scan(engine, program, reading, resolver) > 0
+                    ? [reading]
+                    : [];
+            });
+        }
+        finally {
+            snapshot.dispose();
+            for (const { one } of built) {
+                if (one.kind === "program") {
+                    one.resolver[Symbol.dispose]();
+                }
+            }
+        }
+    }
+}
+/**
+ * Reads every configuration's member imports. Where the snapshots read component files,
+ * the rounds go on over each reading's configuration, which reads them, for the imports
+ * only they make.
+ */
+export function workspacePrograms(engine, host, configFiles, resolver) {
+    const readings = configFiles.flatMap((configFile) => {
+        let parsed;
+        try {
+            parsed = engine.parseConfigFile(configFile);
+        }
+        catch {
+            // A configuration that does not read is opened as a project, which states why.
+            return [];
+        }
+        return [
+            {
+                configFile,
+                parsed,
+                references: carriedReferences(engine, parsed),
+                entries: [],
+                seen: new Set(),
+                bound: new Map(),
+                unresolved: [],
+            },
+        ];
+    });
+    readRounds(engine, readings, resolver, (reading) => ({
+        kind: "program",
+        ...programOf(engine, reading),
+    }));
+    if (engine.readsComponents) {
+        readRounds(engine, readings, resolver, (reading) => {
+            const one = configurationOf(engine, host, reading);
+            return one.kind === "configuration" ? one : undefined;
+        });
+    }
+    const programs = new Map();
+    const unread = new Map();
+    for (const reading of readings) {
+        if (reading.entries.length === 0) {
+            continue;
+        }
+        const one = engine.readsComponents ? configurationOf(engine, host, reading) : undefined;
+        if (one !== undefined && one.kind !== "unread") {
+            programs.set(reading.configFile, one);
+            continue;
+        }
+        programs.set(reading.configFile, {
+            kind: "program",
+            params: programOf(engine, reading).params,
+        });
+        if (one !== undefined) {
+            unread.set(reading.configFile, one.reason);
+        }
+    }
+    return {
+        programs,
+        readings: readings.map((reading) => ({
+            configFile: reading.configFile,
+            fileNames: reading.parsed.fileNames,
+            entries: reading.entries,
+            unresolved: reading.unresolved,
+            componentsUnread: unread.get(reading.configFile),
+        })),
+    };
+}

package/dist/src/workspace-resolution.js

@@ -0,0 +1,307 @@
+/**
+ * Which file an import of a workspace package's name is read from. The package is the
+ * one `node_modules` links the importer to or, with no link, the one the importer's
+ * manifest depends on. A source file the compiler reaches stands; any other file is read
+ * back to the source it is compiled from or to a manifest target that is source, a file
+ * the package's configurations neither compile nor write is read as installed, and an
+ * import nothing answers for is unresolved.
+ */
+import { emittedFrom } from "./emit-map.js";
+import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { satisfies } from "./version-range.js";
+/** The manifest members that name an entry point for the subpath `.` without `exports`. */
+const LEGACY_MEMBERS = ["types", "typings", "module", "main"];
+/** The dependency members a manifest declares other packages under. */
+const DEPENDENCY_MEMBERS = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+];
+const SOURCE = /(?<!\.d)\.(?:[mc]?ts|tsx)$/u;
+const OUTPUT = /(?:\.d\.[mc]?ts|\.[mc]?js|\.jsx)$/u;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The package name a bare specifier names, or `undefined` for any other specifier. */
+export function packageNameOf(specifier) {
+    if (specifier === "" ||
+        specifier.startsWith(".") ||
+        specifier.startsWith("#") ||
+        isAbsolutePath(specifier) ||
+        specifier.includes(":")) {
+        return undefined;
+    }
+    const [first, second] = specifier.split("/");
+    if (specifier.startsWith("@")) {
+        return second === undefined || second === "" ? undefined : `${first ?? ""}/${second}`;
+    }
+    return first;
+}
+function inside(dir, path) {
+    return path === dir || relativePath(dir, path) !== undefined;
+}
+/** The `exports` entry one subpath selects, with what a pattern's `*` matched. */
+function exportsEntry(exportsField, subpath) {
+    const map = isRecord(exportsField) && Object.keys(exportsField).some((key) => key.startsWith("."))
+        ? exportsField
+        : { ".": exportsField };
+    if (Object.hasOwn(map, subpath)) {
+        return { value: map[subpath] };
+    }
+    let best;
+    for (const key of Object.keys(map)) {
+        const star = key.indexOf("*");
+        if (star < 0 || key.slice(star + 1).includes("*")) {
+            continue;
+        }
+        const prefix = key.slice(0, star);
+        const suffix = key.slice(star + 1);
+        if (subpath.length >= key.length &&
+            subpath.startsWith(prefix) &&
+            subpath.endsWith(suffix) &&
+            (best === undefined ||
+                prefix.length > best.prefix ||
+                (prefix.length === best.prefix && key.length > best.key.length))) {
+            best = {
+                key,
+                prefix: prefix.length,
+                match: subpath.slice(prefix.length, subpath.length - suffix.length),
+            };
+        }
+    }
+    return best === undefined ? undefined : { value: map[best.key], match: best.match };
+}
+/** The leaf a condition set selects from one `exports` value, in the order Node reads it. */
+function selected(value, conditions) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        for (const alternative of value) {
+            const found = selected(alternative, conditions);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    for (const [key, held] of Object.entries(value)) {
+        if (conditions.has(key)) {
+            return selected(held, conditions);
+        }
+    }
+    return undefined;
+}
+/** Every leaf one `exports` value carries, in document order. */
+function leaves(value) {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap(leaves);
+    }
+    return isRecord(value) ? Object.values(value).flatMap(leaves) : [];
+}
+/** Whether one dependency specifier names one member, written from one directory. */
+function dependsOn(specifier, member, fromDir) {
+    const atPath = (path) => resolvePath(fromDir, path) === member.dir;
+    const inRange = (range) => member.version !== undefined && satisfies(member.version, range);
+    if (specifier.startsWith("workspace:")) {
+        const rest = specifier.slice("workspace:".length);
+        if (rest.startsWith(".") || rest.startsWith("/")) {
+            return atPath(rest);
+        }
+        const alias = /^((?:@[^/@]+\/)?[^/@]+)@(.*)$/u.exec(rest);
+        const range = alias === null ? rest : (alias[2] ?? "");
+        if (alias !== null && alias[1] !== member.name) {
+            return false;
+        }
+        return range === "*" || range === "^" || range === "~" || inRange(range);
+    }
+    for (const protocol of ["file:", "link:"]) {
+        if (specifier.startsWith(protocol)) {
+            return atPath(specifier.slice(protocol.length));
+        }
+    }
+    return inRange(specifier);
+}
+/** The member imports of one workspace, read from the members' sources. */
+export function workspaceResolver(host, workspace) {
+    const links = new Map();
+    /** The directory `node_modules/<name>` names from one directory, links followed. */
+    const linkedFrom = (name, dir) => {
+        const key = `${name}\u0000${dir}`;
+        if (links.has(key)) {
+            return links.get(key);
+        }
+        const candidate = joinPath(dir, "node_modules", name);
+        let found;
+        if (host.kindOf(candidate) === "absent") {
+            const up = dirnamePath(dir);
+            found = up === dir ? undefined : linkedFrom(name, up);
+        }
+        else {
+            try {
+                found = host.realPath(candidate);
+            }
+            catch {
+                found = undefined;
+            }
+        }
+        links.set(key, found);
+        return found;
+    };
+    const linkOf = (candidates, fromDir) => {
+        const name = candidates[0]?.name ?? "";
+        const linked = linkedFrom(name, fromDir);
+        if (linked !== undefined) {
+            const member = candidates.find((one) => one.dir === linked);
+            return member === undefined ? { kind: "none" } : { kind: "member", member };
+        }
+        const scope = workspace.memberOf(joinPath(fromDir, "package.json"));
+        if (scope?.name === name) {
+            return { kind: "member", member: scope };
+        }
+        const manifest = scope?.manifest;
+        const declared = DEPENDENCY_MEMBERS.flatMap((field) => {
+            const held = manifest?.[field];
+            const specifier = isRecord(held) ? held[name] : undefined;
+            return typeof specifier === "string" ? [specifier] : [];
+        });
+        const matched = candidates.filter((member) => declared.some((specifier) => dependsOn(specifier, member, scope?.dir ?? fromDir)));
+        const [one, two] = matched;
+        if (one === undefined) {
+            return { kind: "none" };
+        }
+        return two === undefined
+            ? { kind: "member", member: one }
+            : { kind: "ambiguous", dirs: matched.map((member) => member.dir) };
+    };
+    /** The files a member's configurations compile, which is what makes a file there source. */
+    const compiled = (member, path) => member.configurations.some((configuration) => configuration.fileNames.has(path));
+    /**
+     * The member's source one of its paths is, or is compiled from: a TypeScript source
+     * file, the source an output path maps back to, or a file one of the member's
+     * configurations compiles. `undefined` where none is.
+     */
+    const sourceOf = (member, path) => {
+        if (SOURCE.test(path) && host.kindOf(path) === "file") {
+            return path;
+        }
+        for (const { layout } of member.configurations) {
+            const candidates = layout === undefined ? [] : emittedFrom(path, layout);
+            const found = candidates.find((candidate) => host.kindOf(candidate) === "file");
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        if (OUTPUT.test(path)) {
+            const beside = emittedFrom(path, { sourceDirs: [] });
+            const found = beside.find((candidate) => host.kindOf(candidate) === "file");
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        return compiled(member, path) && host.kindOf(path) === "file" ? path : undefined;
+    };
+    /** The targets a member's manifest names for one subpath, the selected one first. */
+    const targetsOf = (member, subpath, conditions) => {
+        const exportsField = member.manifest["exports"];
+        if (exportsField !== undefined) {
+            const entry = exportsEntry(exportsField, subpath);
+            if (entry === undefined) {
+                return [];
+            }
+            const first = selected(entry.value, conditions);
+            const written = [...(first === undefined ? [] : [first]), ...leaves(entry.value)];
+            const found = written
+                .filter((target) => target.startsWith("./"))
+                .map((target) => entry.match === undefined ? target : target.replaceAll("*", entry.match));
+            return [...new Set(found)];
+        }
+        if (subpath === ".") {
+            return LEGACY_MEMBERS.flatMap((field) => {
+                const value = member.manifest[field];
+                return typeof value === "string" ? [value] : [];
+            });
+        }
+        return [
+            subpath,
+            `${subpath}.d.ts`,
+            `${subpath}.js`,
+            `${subpath}/index.d.ts`,
+            `${subpath}/index.js`,
+        ];
+    };
+    return {
+        workspace,
+        sourceOf,
+        names: (specifier) => {
+            const name = packageNameOf(specifier);
+            return name !== undefined && workspace.named.has(name);
+        },
+        resolve(specifier, fromDir, conditions, answered) {
+            const name = packageNameOf(specifier);
+            const candidates = name === undefined ? undefined : workspace.named.get(name);
+            if (name === undefined || candidates === undefined) {
+                return { kind: "default" };
+            }
+            const subpath = specifier === name ? "." : `.${specifier.slice(name.length)}`;
+            const linked = linkOf(candidates, fromDir);
+            if (linked.kind === "none") {
+                return { kind: "default" };
+            }
+            if (linked.kind === "ambiguous") {
+                return {
+                    kind: "unresolved",
+                    member: name,
+                    subpath,
+                    reason: `${String(linked.dirs.length)} workspace packages are named ${name} (${linked.dirs.join(", ")}) and nothing links the importer to one of them; install the workspace, or declare the dependency with a range only one of them satisfies`,
+                };
+            }
+            const { member } = linked;
+            // A member no compiler configuration builds is read as the package manager
+            // installed it, wherever the compiler's resolution found it.
+            if (answered !== undefined &&
+                (member.configurations.length === 0 || !inside(member.dir, answered.resolvedFileName))) {
+                return { kind: "default" };
+            }
+            if (answered !== undefined) {
+                const source = sourceOf(member, answered.resolvedFileName);
+                if (source !== undefined) {
+                    return source === answered.resolvedFileName && answered.isExternalLibraryImport !== true
+                        ? { kind: "default" }
+                        : { kind: "source", file: source, member: member.name };
+                }
+            }
+            const targets = targetsOf(member, subpath, conditions);
+            for (const target of targets) {
+                const source = sourceOf(member, joinPath(member.dir, target));
+                if (source !== undefined) {
+                    return { kind: "source", file: source, member: member.name };
+                }
+            }
+            // A file the member's configurations neither compile nor write, a hand-written
+            // declaration file or a bundler's output, is read as the package manager installed it.
+            if (answered !== undefined) {
+                return { kind: "default" };
+            }
+            const named = targets.length === 0 ? "no target" : targets.join(", ");
+            const built = targets.some((target) => host.kindOf(joinPath(member.dir, target)) === "file");
+            return {
+                kind: "unresolved",
+                member: name,
+                subpath,
+                reason: built
+                    ? `its manifest names ${named}, output no tsconfig*.json of the package maps back to source, and nothing installed links the importer to it; install the workspace, or point an exports condition the importing configuration's customConditions lists at its source`
+                    : member.configurations.length === 0
+                        ? `the package has no tsconfig*.json and its manifest names ${named}, which does not exist; build the package`
+                        : `its manifest names ${named}, which does not exist and which no tsconfig*.json of the package compiles to; build the package, give the tsconfig.json that compiles it an outDir and rootDir that map those targets, or point an exports condition the importing configuration's customConditions lists at its source`,
+            };
+        },
+    };
+}