@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.11

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

@@ -7,22 +7,34 @@
  */
 import { ModuleKind, ModuleResolutionKind } from "@typescript/native/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/ast";
-import { baseUrlPaths } from "./base-url.js";
-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, and with `paths` read against the
- * effective `baseUrl` as {@link baseUrlPaths} states. 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;
-    const paths = baseUrlPaths(parsed.options);
-    const options = paths === undefined ? kept : { ...kept, paths };
-    return composite === true ? { ...options, declaration: true } : options;
+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) {
@@ -51,33 +63,45 @@ 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 = {};
-    for (const [key, targets] of Object.entries(baseUrlPaths(options) ?? options.paths ?? {})) {
+    for (const [key, targets] of Object.entries(options.paths ?? {})) {
         paths[key] = targets.map((target) => resolvePath(base, target));
     }
     for (const entry of reading.entries) {
@@ -86,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: {
@@ -94,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;
@@ -124,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 {
@@ -144,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/"));
@@ -215,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`
@@ -256,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();
@@ -293,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}

@@ -6,38 +6,17 @@
  * the package neither compiles nor writes is read as installed, and the rest is unresolved.
  */
 import { emittedFrom } from "./emit-map.js";
-import { gitIgnored } from "./git-ignore.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,49 +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);
         }
-        links.set(key, found);
-        return 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)) {
-            return manifests.get(dir);
-        }
-        let found;
-        try {
-            const value = JSON.parse(host.readFile(joinPath(dir, "package.json")));
-            found = isRecord(value) ? { dir, manifest: value } : undefined;
-        }
-        catch {
-            const up = dirnamePath(dir);
-            found =
-                up === dir || root === undefined || !inside(root, up) ? undefined : nearestManifest(up);
+        if (!manifests.has(dir)) {
+            const [nearest] = manifestsAbove(host, dir, root ?? dir);
+            manifests.set(dir, nearest);
         }
-        manifests.set(dir, found);
-        return found;
+        return manifests.get(dir);
     };
     const linkOf = (candidates, fromDir) => {
         const name = candidates[0]?.name ?? "";
@@ -191,18 +153,14 @@ 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 };
         }
         // 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 = DEPENDENCY_MEMBERS.flatMap((field) => {
-            const held = manifest?.[field];
-            const specifier = isRecord(held) ? held[name] : undefined;
-            return typeof specifier === "string" ? [specifier] : [];
-        });
+        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) {
@@ -221,7 +179,7 @@ export function workspaceResolver(host, workspace) {
      * directory however its configuration writes it.
      */
     const mirrored = (member, path) => {
-        for (let dir = dirnamePath(path); inside(member.dir, dir); dir = dirnamePath(dir)) {
+        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;
@@ -288,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" };

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. */