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

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

@@ -7,18 +7,34 @@
  */
 import { ModuleKind, ModuleResolutionKind } from "@typescript/native/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/ast";
-import { dirnamePath, resolvePath } from "./paths.js";
-/** The most questions one round trip carries. */
-const BATCH = 2048;
+import { JAVASCRIPT_FILE } from "../javascript-file.js";
+import { isRecord } from "../json-document.js";
+import { dirnamePath, resolvePath } from "../paths.js";
+import { batched } from "../session.js";
+import { bytewise } from "../text/compare.js";
+import { PRODUCT } from "../product.js";
 /**
- * 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.
+ * The options a configuration's program is built with: the plan's, 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;
+function analysisOptions(options, readsJavaScript) {
+    const { composite, rootDir: _rootDir, outDir: _outDir, declarationDir: _declarationDir, tsBuildInfoFile: _tsBuildInfoFile, ...kept } = options;
+    const read = readsJavaScript ? { ...kept, allowJs: true } : kept;
+    return composite === true ? { ...read, declaration: true } : read;
+}
+/**
+ * Whether one reading answers a member import with a JavaScript file, which its program reads
+ * as source only where it allows JavaScript, a program formed for a JavaScript member being the
+ * member's source.
+ */
+function readsJavaScript(reading) {
+    return (reading.options.allowJs !== true &&
+        reading.entries.some((entry) => {
+            const file = entry.result.resolvedFileName;
+            return typeof file === "string" && JAVASCRIPT_FILE.test(file);
+        }));
 }
 /** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
 function conditionsOf(parsed, mode) {
@@ -47,29 +63,41 @@ function unstatable(reading) {
     }
     return undefined;
 }
-/** The path beside `configFile` its written configuration takes, which no file has. */
-export function writtenPath(host, configFile) {
+/** The path beside `configFile` its written configuration takes, which no file and none of `taken` has. */
+export function writtenPath(host, configFile, taken = new Set()) {
     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") {
+        const path = `${stem}.${PRODUCT}${counter === 0 ? "" : `-${String(counter)}`}.json`;
+        if (host.kindOf(path) === "absent" && !taken.has(path)) {
             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.
+ * The path the snapshot holds one configuration's written form at: a formed configuration's
+ * own path, else a free one beside it that no configuration of `formed` holds, because a formed
+ * program in a directory with a `jsconfig.json` takes the name that file's written form would.
+ */
+export function writtenFileOf(host, configuration, formed) {
+    return configuration.written === undefined
+        ? writtenPath(host, configuration.configFile, formed)
+        : configuration.configFile;
+}
+/**
+ * The configuration that reads as one configuration's program: it extends it, lays out no output
+ * ({@link analysisOptions}), maps each answered specifier to its file and keeps its references.
+ * Where the file list moves, the default `exclude` the dropped output directories are named in is
+ * restated, and one that {@link readsJavaScript} lists its files outright, as `allowJs` widens its
+ * `include` to JavaScript; a list that still differs, or answers `paths` cannot state, are a
+ * reason. A formed configuration, which no file holds to extend, is its own value with `paths`.
  */
-function configurationOf(engine, host, reading) {
+function configurationOf(engine, host, reading, formed) {
     const reason = unstatable(reading);
     if (reason !== undefined) {
         return { kind: "unread", reason };
     }
-    const { options, projectReferences: references = [] } = reading.parsed;
+    const { options } = reading;
+    const references = reading.parsed.projectReferences ?? [];
     const raw = options["pathsBasePath"];
     const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
     const paths = {};
@@ -82,6 +110,17 @@ function configurationOf(engine, host, reading) {
             paths[entry.moduleName] = [file];
         }
     }
+    if (reading.written !== undefined) {
+        const held = reading.written["compilerOptions"];
+        return {
+            kind: "configuration",
+            value: {
+                ...reading.written,
+                compilerOptions: { ...(isRecord(held) ? held : {}), paths },
+            },
+        };
+    }
+    const javascript = readsJavaScript(reading);
     const json = (exclude) => ({
         extends: reading.configFile,
         compilerOptions: {
@@ -90,18 +129,20 @@ function configurationOf(engine, host, reading) {
             declarationDir: null,
             tsBuildInfoFile: null,
             ...(options.composite === true ? { composite: false, declaration: true } : {}),
+            ...(javascript ? { allowJs: true } : {}),
             paths,
         },
         ...(references.length > 0
             ? { references: references.map((reference) => ({ path: reference.path })) }
             : {}),
+        ...(javascript ? { files: [...reading.parsed.fileNames], include: [] } : {}),
         ...(exclude === undefined ? {} : { exclude }),
     });
-    const file = writtenPath(host, reading.configFile);
-    const expected = [...reading.parsed.fileNames].sort().join("\u0000");
+    const file = writtenFileOf(host, reading, formed);
+    const expected = [...reading.parsed.fileNames].sort(bytewise).join("\u0000");
     const listed = (value) => {
         try {
-            return [...engine.parseConfigJson(value, file).fileNames].sort().join("\u0000");
+            return [...engine.parseConfigJson(value, file).fileNames].sort(bytewise).join("\u0000");
         }
         catch {
             return undefined;
@@ -120,11 +161,11 @@ function configurationOf(engine, host, reading) {
             };
         }
     }
-    return { kind: "configuration", file, text: `${JSON.stringify(value, null, 2)}\n` };
+    return { kind: "configuration", value };
 }
 /** The program one configuration is built as, under the answers it holds so far. */
 function programOf(engine, reading) {
-    const compilerOptions = analysisOptions(reading.parsed);
+    const compilerOptions = analysisOptions(reading.options, readsJavaScript(reading));
     const references = reading.parsed.projectReferences ?? [];
     const resolver = engine.createModuleResolver(compilerOptions, reading.entries);
     return {
@@ -140,17 +181,6 @@ function programOf(engine, reading) {
         },
     };
 }
-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/"));
@@ -211,6 +241,13 @@ function scan(engine, program, reading, resolver) {
     });
     return added;
 }
+function configurationText(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+/** One configuration value as the snapshot holds it, at `file`, which no file on disk holds. */
+export function writtenConfiguration(file, value) {
+    return { kind: "configuration", file, text: configurationText(value) };
+}
 /**
  * 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`
@@ -252,35 +289,25 @@ function readRounds(engine, readings, resolver, build) {
  * 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,
-                entries: [],
-                seen: new Set(),
-                bound: new Map(),
-                unresolved: [],
-            },
-        ];
-    });
+export function workspacePrograms(engine, host, configurations, resolver) {
+    const readings = configurations.map((configuration) => ({
+        ...configuration,
+        entries: [],
+        seen: new Set(),
+        bound: new Map(),
+        unresolved: [],
+    }));
+    const formed = new Set(configurations.filter((one) => one.written !== undefined).map((one) => one.configFile));
     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 one = configurationOf(engine, host, reading, formed);
+            return one.kind === "configuration"
+                ? writtenConfiguration(writtenFileOf(host, reading, formed), one.value)
+                : undefined;
         });
     }
     const programs = new Map();
@@ -289,7 +316,7 @@ export function workspacePrograms(engine, host, configFiles, resolver) {
         if (reading.entries.length === 0) {
             continue;
         }
-        const one = engine.readsComponents ? configurationOf(engine, host, reading) : undefined;
+        const one = engine.readsComponents ? configurationOf(engine, host, reading, formed) : undefined;
         if (one !== undefined && one.kind !== "unread") {
             programs.set(reading.configFile, one);
             continue;

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

@@ -1,43 +1,22 @@
 /**
- * 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.
+ * Which file an import of a workspace package's name is read from: the package
+ * `node_modules` links the importer to or, with no link, the one its manifest depends on.
+ * A source file the compiler reaches stands; any other file reads back to its source or to
+ * a manifest target that is source, an ignored file to the source its path mirrors, a file
+ * the package neither compiles nor writes is read as installed, and the rest is unresolved.
  */
 import { emittedFrom } from "./emit-map.js";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
-import { satisfies } from "./version-range.js";
+import { packageOfSpecifier } from "../dependencies.js";
+import { gitIgnored } from "../git-ignore.js";
+import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "../paths.js";
+import { satisfies } from "../version-range.js";
+import { isRecord } from "../json-document.js";
+import { MANIFEST } from "../fs/manifest.js";
+import { dependencySpecifiers, installedPackage, manifestsAbove, } from "./module-lookup.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 relativePath(dir, path) !== undefined;
 }
@@ -140,28 +119,32 @@ function dependsOn(specifier, member, fromDir) {
 /** 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. */
+    /** The directory the package `name` installed for one directory is, 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 {
+        if (!links.has(key)) {
+            const installed = installedPackage(host, dir, name);
+            let found;
             try {
-                found = host.realPath(candidate);
+                found = installed === undefined ? undefined : host.realPath(installed);
             }
             catch {
                 found = undefined;
             }
+            links.set(key, found);
+        }
+        return links.get(key);
+    };
+    const root = workspace.members[0]?.dir;
+    const ignored = root === undefined ? () => false : gitIgnored(host, root);
+    const manifests = new Map();
+    /** The nearest manifest at or above one directory, up to the workspace's root. */
+    const nearestManifest = (dir) => {
+        if (!manifests.has(dir)) {
+            const [nearest] = manifestsAbove(host, dir, root ?? dir);
+            manifests.set(dir, nearest);
         }
-        links.set(key, found);
-        return found;
+        return manifests.get(dir);
     };
     const linkOf = (candidates, fromDir) => {
         const name = candidates[0]?.name ?? "";
@@ -170,17 +153,15 @@ export function workspaceResolver(host, workspace) {
             const member = candidates.find((one) => one.dir === linked);
             return member === undefined ? { kind: "none" } : { kind: "member", member };
         }
-        const scope = workspace.memberOf(joinPath(fromDir, "package.json"));
+        const scope = workspace.memberOf(joinPath(fromDir, MANIFEST));
         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)));
+        // A package below the root that no workspace lists depends on a member as a member does.
+        const owner = scope ?? nearestManifest(fromDir);
+        const manifest = owner?.manifest;
+        const declared = (manifest === undefined ? [] : dependencySpecifiers(manifest, name)).filter((specifier) => typeof specifier === "string");
+        const matched = candidates.filter((member) => declared.some((specifier) => dependsOn(specifier, member, owner?.dir ?? fromDir)));
         const [one, two] = matched;
         if (one === undefined) {
             return { kind: "none" };
@@ -191,6 +172,21 @@ export function workspaceResolver(host, workspace) {
     };
     /** 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 an ignored output path mirrors: the path below one of its
+     * directories, the deepest first, read below the member's own directory as an output
+     * directory's tree mirrors its root directory's, which a build leaves in an ignored
+     * directory however its configuration writes it.
+     */
+    const mirrored = (member, path) => {
+        for (const dir of ancestors(dirnamePath(path), member.dir).filter((at) => at !== member.dir)) {
+            const found = emittedFrom(path, { outDir: dir, sourceDirs: [member.dir] }).find((candidate) => SOURCE.test(candidate) && !ignored(candidate) && host.kindOf(candidate) === "file");
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        return undefined;
+    };
     /**
      * 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
@@ -212,6 +208,9 @@ export function workspaceResolver(host, workspace) {
         if (found !== undefined) {
             return found;
         }
+        if (ignored(path)) {
+            return mirrored(member, path);
+        }
         return compiled(member, path) && host.kindOf(path) === "file" ? path : undefined;
     };
     /** The targets a member's manifest names for one subpath, the selected one first. */
@@ -247,11 +246,11 @@ export function workspaceResolver(host, workspace) {
         workspace,
         sourceOf,
         names: (specifier) => {
-            const name = packageNameOf(specifier);
+            const name = packageOfSpecifier(specifier);
             return name !== undefined && workspace.named.has(name);
         },
         resolve(specifier, fromDir, conditions, answered) {
-            const name = packageNameOf(specifier);
+            const name = packageOfSpecifier(specifier);
             const candidates = name === undefined ? undefined : workspace.named.get(name);
             if (name === undefined || candidates === undefined) {
                 return { kind: "default" };
@@ -270,9 +269,11 @@ export function workspaceResolver(host, workspace) {
             }
             const { member } = linked;
             // A member no compiler configuration builds is read as the package manager
-            // installed it, wherever the compiler's resolution found it.
+            // installed it, wherever the compiler's resolution found it, unless what it found is
+            // a file the tree ignores, which no install wrote.
             if (answered !== undefined &&
-                (member.configurations.length === 0 || !inside(member.dir, answered.resolvedFileName))) {
+                ((member.configurations.length === 0 && !ignored(answered.resolvedFileName)) ||
+                    !inside(member.dir, answered.resolvedFileName))) {
                 return { kind: "default" };
             }
             if (answered !== undefined) {

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

@@ -4,12 +4,13 @@
  * the files each configuration holds only for their references, and the entry points
  * the members' manifests name. A target in no workspace reads none of it.
  */
-import { relativePath } from "./paths.js";
-import { findWorkspace, referenceOnlyIn } from "./workspace.js";
+import { relativePath } from "../paths.js";
+import { referenceOnlyIn } from "./workspace.js";
 import { memberEntries, targetManifestIn } from "./workspace-manifests.js";
 import { workspacePrograms, } from "./workspace-programs.js";
 import { workspaceResolver } from "./workspace-resolution.js";
-function layoutOf(engine, configFile) {
+/** What one member's configuration file says of its layout, or `undefined` where it does not parse. */
+export function layoutOf(engine, configFile) {
     try {
         const parsed = engine.parseConfigFile(configFile);
         return {
@@ -42,16 +43,16 @@ function unbuildableReason(reading, referenceOnly, targetRoot) {
  * The workspace the target at `targetRoot` sits in, read for the configurations named,
  * or `undefined` where the target sits in none.
  */
-export function workspaceRun(engine, host, targetRoot, configFiles, manifest) {
-    const workspace = findWorkspace(host, targetRoot, (configFile) => layoutOf(engine, configFile));
+export function workspaceRun(engine, host, targetRoot, configurations, manifest, workspace) {
     if (workspace === undefined) {
         return undefined;
     }
     const resolver = workspaceResolver(host, workspace);
-    const read = workspacePrograms(engine, host, configFiles, resolver);
+    const read = workspacePrograms(engine, host, configurations, resolver);
     const readings = new Map(read.readings.map((reading) => [reading.configFile, reading]));
     const referenceOnly = (configFile, compiled = []) => referenceOnlyIn(workspace, new Set([...(readings.get(configFile)?.fileNames ?? []), ...compiled]));
     return {
+        workspace,
         programs: read.programs,
         componentsUnread: read.readings.flatMap(({ configFile, componentsUnread }) => componentsUnread === undefined ? [] : [{ configFile, reason: componentsUnread }]),
         unbuildable: (configFile) => {
@@ -66,7 +67,6 @@ export function workspaceRun(engine, host, targetRoot, configFiles, manifest) {
             : !fromExternalLibrary,
         manifest: targetManifestIn(resolver, targetRoot, manifest),
         entries: memberEntries(host, resolver, targetRoot),
-        memberDirs: workspace.members.map((member) => member.dir),
     };
 }
 /** The errors one configuration answers for: none in a file it holds only for its references. */