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

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

@@ -1,47 +1,34 @@
 /**
  * The workspace a target sits in: the packages `pnpm-workspace.yaml` or a manifest's
- * `workspaces` declares in the nearest directory at or above the target root, up to
- * its repository root, where its patterns name the package the target is in, each
- * with the compiler configurations in its directory. A
- * member is the workspace root or a directory the patterns name that holds a named
- * manifest, never one below `node_modules`.
+ * `workspaces` declares in the nearest directory at or above the target root, up to its
+ * repository root, where its patterns name the package the target is in, each with the
+ * compiler configurations in its directory.
  */
-import { DiscoveryError } from "./discover.js";
+import { configFilesIn } from "./discover.js";
+import { failureExit } from "../failure.js";
 import { commonDirectory } from "./emit-map.js";
-import { dirnamePath, joinPath, relativePath } from "./paths.js";
-import { pnpmPackages } from "./pnpm-workspace.js";
-const MANIFEST = "package.json";
+import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { isRecord } from "../json-document.js";
+import { directoriesIn, repositoryOf } from "../fs/tree.js";
+import { holdsManifest, inInstalledPackages, INSTALLED_PACKAGES, MANIFEST, manifestAt, } from "../fs/manifest.js";
+import { braceExpanded, pathMatches, segmentMatches } from "../text/glob.js";
+import { yamlKey } from "../text/yaml.js";
 const PNPM_WORKSPACE = "pnpm-workspace.yaml";
-const CONFIG_FILE = /^tsconfig.*\.json$/u;
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/** One manifest, decoded, or `undefined` where there is none to read. */
-function manifestAt(host, dir) {
-    let text;
-    try {
-        text = host.readFile(joinPath(dir, MANIFEST));
-    }
-    catch {
-        return undefined;
-    }
-    try {
-        const value = JSON.parse(text);
-        return isRecord(value) ? value : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 /** The patterns one directory declares a workspace with, or `undefined` where it declares none. */
 function declarationAt(host, dir) {
     const pnpm = joinPath(dir, PNPM_WORKSPACE);
     if (host.kindOf(pnpm) === "file") {
-        const read = pnpmPackages(host.readFile(pnpm));
-        if (read.kind === "refused") {
-            throw new DiscoveryError(`${pnpm}: ${read.reason}; the workspace's packages are read from a sequence of strings`, []);
+        const read = yamlKey(host.readFile(pnpm), "packages");
+        if (read.kind === "absent") {
+            return { file: pnpm, patterns: [] };
         }
-        return { file: pnpm, patterns: read.kind === "listed" ? read.patterns : [] };
+        const listed = read.kind === "value" ? read.value : undefined;
+        if (!Array.isArray(listed) || !listed.every((entry) => typeof entry === "string")) {
+            const reason = read.kind === "refused" ? read.reason : "packages is not a sequence of strings";
+            throw failureExit("no-program", `${pnpm}: ${reason}; the workspace's packages are read from a sequence of strings: correct the declaration`);
+        }
+        return { file: pnpm, patterns: listed };
     }
     const manifest = manifestAt(host, dir);
     if (manifest === undefined || !Object.hasOwn(manifest, "workspaces")) {
@@ -50,7 +37,7 @@ function declarationAt(host, dir) {
     const declared = manifest["workspaces"];
     const list = isRecord(declared) ? declared["packages"] : declared;
     if (!Array.isArray(list) || !list.every((entry) => typeof entry === "string")) {
-        throw new DiscoveryError(`${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one`, []);
+        throw failureExit("no-program", `${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one: correct the declaration`);
     }
     return { file: joinPath(dir, MANIFEST), patterns: list };
 }
@@ -62,20 +49,6 @@ function declaresWorkspace(host, dir) {
     const manifest = manifestAt(host, dir);
     return manifest !== undefined && Object.hasOwn(manifest, "workspaces");
 }
-/** A pattern with every brace list expanded into its alternatives. */
-function braceExpanded(pattern) {
-    const open = pattern.indexOf("{");
-    const close = open < 0 ? -1 : pattern.indexOf("}", open);
-    if (close < 0) {
-        return [pattern];
-    }
-    const before = pattern.slice(0, open);
-    const after = pattern.slice(close + 1);
-    return pattern
-        .slice(open + 1, close)
-        .split(",")
-        .flatMap((member) => braceExpanded(before + member + after));
-}
 /**
  * The segments of one pattern below the workspace root, `.` and empty segments
  * dropped and `..` taken back, or `undefined` where it leaves the root.
@@ -96,52 +69,6 @@ function segmentsOf(pattern) {
     }
     return segments;
 }
-/**
- * Whether one directory name matches one pattern segment: `*` stands for any run of
- * characters and `?` for one, and neither matches a leading dot.
- */
-function segmentMatches(segment, name) {
-    if (name.startsWith(".") && !segment.startsWith(".")) {
-        return false;
-    }
-    const source = Array.from(segment)
-        .map((character) => {
-        if (character === "*") {
-            return ".*";
-        }
-        if (character === "?") {
-            return ".";
-        }
-        return character.replaceAll(/[.+^${}()|[\]\\/]/gu, (c) => `\\${c}`);
-    })
-        .join("");
-    return new RegExp(`^${source}$`, "u").test(name);
-}
-/** Whether one path's segments match one pattern's, `**` standing for any run of segments. */
-function pathMatches(pattern, path) {
-    const [head, ...rest] = pattern;
-    if (head === undefined) {
-        return path.length === 0;
-    }
-    if (head === "**") {
-        return (pathMatches(rest, path) ||
-            (path.length > 0 && !(path[0] ?? "").startsWith(".") && pathMatches(pattern, path.slice(1))));
-    }
-    const [name, ...below] = path;
-    return name !== undefined && segmentMatches(head, name) && pathMatches(rest, below);
-}
-function subdirectories(host, dir) {
-    try {
-        return host
-            .readDirectory(dir)
-            .filter((entry) => entry.directory && entry.name !== "node_modules" && entry.name !== ".git")
-            .map((entry) => entry.name)
-            .sort();
-    }
-    catch {
-        return [];
-    }
-}
 /**
  * Every directory below `dir` one pattern names. `**` does not descend into a
  * directory that declares a workspace of its own, whose packages are that
@@ -155,7 +82,7 @@ function expand(host, dir, pattern, into) {
     }
     if (head === "**") {
         expand(host, dir, rest, into);
-        for (const name of subdirectories(host, dir)) {
+        for (const name of directoriesIn(host, dir)) {
             if (name.startsWith(".")) {
                 continue;
             }
@@ -166,12 +93,12 @@ function expand(host, dir, pattern, into) {
     }
     if (!head.includes("*") && !head.includes("?")) {
         const child = joinPath(dir, head);
-        if (head !== "node_modules" && host.kindOf(child) === "directory") {
+        if (head !== INSTALLED_PACKAGES && host.kindOf(child) === "directory") {
             expand(host, child, rest, into);
         }
         return;
     }
-    for (const name of subdirectories(host, dir)) {
+    for (const name of directoriesIn(host, dir)) {
         if (segmentMatches(head, name)) {
             expand(host, joinPath(dir, name), rest, into);
         }
@@ -208,10 +135,10 @@ function namesDirectory(root, patterns, dir) {
     if (below === undefined) {
         return false;
     }
-    const path = below.split("/");
-    if (path.includes("node_modules")) {
+    if (inInstalledPackages(below)) {
         return false;
     }
+    const path = below.split("/");
     let named = false;
     for (const written of patterns) {
         const negated = written.startsWith("!");
@@ -238,18 +165,7 @@ function layoutOf(configFile, parsed) {
     return { outDir: parsed.outDir, declarationDir: parsed.declarationDir, sourceDirs };
 }
 function configurationsOf(host, dir, parse) {
-    let names;
-    try {
-        names = host
-            .readDirectory(dir)
-            .filter((entry) => !entry.directory && CONFIG_FILE.test(entry.name))
-            .map((entry) => entry.name)
-            .sort();
-    }
-    catch {
-        return [];
-    }
-    return names.flatMap((name) => {
+    return configFilesIn(host, dir).flatMap((name) => {
         const configFile = joinPath(dir, name);
         const parsed = parse(configFile);
         return parsed === undefined
@@ -267,31 +183,27 @@ function configurationsOf(host, dir, parse) {
  * highest directory below it, at or above the target root, that holds a manifest.
  */
 function nearestDeclaration(host, targetRoot) {
-    let dir = targetRoot;
     let highestPackage;
-    for (;;) {
+    for (const dir of ancestors(targetRoot, repositoryOf(host, targetRoot)?.root)) {
         const declared = declarationAt(host, dir);
         if (declared !== undefined) {
             return { root: dir, ...declared, highestPackage };
         }
-        if (host.kindOf(joinPath(dir, MANIFEST)) === "file") {
+        if (holdsManifest(host, dir)) {
             highestPackage = dir;
         }
-        const up = dirnamePath(dir);
-        if (up === dir || host.kindOf(joinPath(dir, ".git")) !== "absent") {
-            return undefined;
-        }
-        dir = up;
     }
+    return undefined;
 }
 /**
  * The workspace the target sits in, or `undefined` where none holds it: no directory
  * from the target root up to its repository root declares one with a member beside
  * its root, or the nearest one does not name the highest package below it, at or
  * above the target root, among its members. `parse` reads one compiler configuration,
- * or answers `undefined` where it does not read.
+ * or answers `undefined` where it does not read. `known`, a workspace already read, is the
+ * answer where the nearest declaration is its own, so its members are not listed again.
  */
-export function findWorkspace(host, targetRoot, parse) {
+export function findWorkspace(host, targetRoot, parse, known) {
     const declared = nearestDeclaration(host, targetRoot);
     if (declared === undefined) {
         return undefined;
@@ -300,6 +212,9 @@ export function findWorkspace(host, targetRoot, parse) {
         !namesDirectory(declared.root, declared.patterns, declared.highestPackage)) {
         return undefined;
     }
+    if (known?.root === declared.root) {
+        return known;
+    }
     const members = [];
     for (const dir of memberDirectories(host, declared.root, declared.patterns)) {
         const manifest = manifestAt(host, dir);
@@ -320,7 +235,10 @@ export function findWorkspace(host, targetRoot, parse) {
     if (members.length < 2) {
         return undefined;
     }
-    members.sort((a, b) => a.dir === declared.root ? -1 : b.dir === declared.root ? 1 : a.dir < b.dir ? -1 : 1);
+    members.sort((a, b) => a.dir === declared.root ? -1 : b.dir === declared.root ? 1 : bytewise(a.dir, b.dir));
+    return assembled(host, declared.root, members);
+}
+function assembled(host, root, members) {
     const named = new Map();
     for (const member of members) {
         named.set(member.name, [...(named.get(member.name) ?? []), member]);
@@ -332,11 +250,12 @@ export function findWorkspace(host, targetRoot, parse) {
             return scopes.get(dir);
         }
         const up = dirnamePath(dir);
-        const found = host.kindOf(joinPath(dir, MANIFEST)) === "file" ? dir : up === dir ? undefined : scopeOf(up);
+        const found = holdsManifest(host, dir) ? dir : up === dir ? undefined : scopeOf(up);
         scopes.set(dir, found);
         return found;
     };
     return {
+        root,
         members,
         named,
         memberOf: (path) => {
@@ -345,6 +264,25 @@ export function findWorkspace(host, targetRoot, parse) {
         },
     };
 }
+/**
+ * The workspace with the programs the run forms put first among each member's configurations,
+ * by the member's directory: a formed program has no file on disk to list, so its file list
+ * is what makes a member's JavaScript its source.
+ */
+export function withFormed(host, workspace, formed) {
+    return assembled(host, workspace.root, workspace.members.map((member) => {
+        const own = formed.get(member.dir) ?? [];
+        return own.length === 0
+            ? member
+            : {
+                ...member,
+                configurations: [
+                    ...own.map((layout) => ({ fileNames: new Set(layout.fileNames) })),
+                    ...member.configurations,
+                ],
+            };
+    }));
+}
 /**
  * Whether one configuration holds one file only for the references it makes: the file
  * belongs to a workspace package, the root included, and the configuration does not

package/dist/src/module-declarations.js

@@ -5,11 +5,12 @@
  * to the same module. One that names it by name or pattern also reads the members it
  * imports, whatever file the specifier resolves to, as a compiler reading no such file does.
  */
-import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isImportTypeNode, isLiteralTypeNode, isModuleDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isImportTypeNode, isLiteralTypeNode, isModuleDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { namesImported } from "./import-bindings.js";
 import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { aliasFragment, nameComponent } from "./ref.js";
+import { isPathSpecifier } from "./paths.js";
 /** Whether a node is a specifier's text: a string literal or a template with no substitution. */
 function literalText(node) {
     return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
@@ -36,32 +37,12 @@ function specifierOf(node) {
     }
     return undefined;
 }
-/**
- * The export names an import or a re-export reads from the module it names: none for a
- * namespace, a star or a bare form.
- */
-export function namesImported(node) {
-    if (isImportDeclaration(node)) {
-        const clause = node.importClause;
-        const bindings = clause?.namedBindings;
-        return [
-            ...(clause?.name === undefined ? [] : ["default"]),
-            ...(bindings === undefined || isNamespaceImport(bindings)
-                ? []
-                : bindings.elements.map((one) => (one.propertyName ?? one.name).text)),
-        ];
-    }
-    const clause = isExportDeclaration(node) ? node.exportClause : undefined;
-    return clause === undefined || isNamespaceExport(clause)
-        ? []
-        : clause.elements.map((one) => (one.propertyName ?? one.name).text);
-}
 /**
  * Whether a specifier matches a declaration's name, the name's one `*` standing for any run.
  * A relative name is resolved against its own file, so no specifier names it by its text.
  */
 function namesModule(specifier, name) {
-    if (/^(?:\.{1,2}(?:\/|$)|\/)/u.test(name)) {
+    if (isPathSpecifier(name)) {
         return false;
     }
     const star = name.indexOf("*");
@@ -107,67 +88,71 @@ function namedBy(held) {
     });
 }
 /**
- * The references the imports of one project's own files make to the module declarations
- * they name, each at the import's specifier.
+ * The reads the imports of a side's files make of the module declarations of the target they
+ * name, each at the import's specifier. A specifier the checker leaves unanswered still names
+ * a declaration by its name or pattern.
  */
-export function moduleDeclarationReferences(project, held, root, testFiles) {
-    const imports = [];
-    const declared = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
-        }
-        const visit = (node, from) => {
-            const own = held.declarations.get(nodeKey(file, node));
-            if (isModuleDeclaration(node) && literalText(node.name) && own !== undefined) {
-                declared.push({ id: own, name: node.name });
-            }
-            const specifier = specifierOf(node);
-            if (specifier !== undefined) {
-                imports.push({ file, from, specifier, names: namesImported(node) });
-            }
-            node.forEachChild((child) => {
-                visit(child, own ?? from);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId);
-        });
-    }
-    if (declared.length === 0 || imports.length === 0) {
-        return [];
-    }
-    const asked = [...declared.map((one) => one.name), ...imports.map((one) => one.specifier)];
-    const answers = project.symbolsAt(asked.map((node) => project.handle(node)));
-    const moduleOf = (at) => {
-        const symbol = answers[at];
-        return symbol === undefined || symbol === UNANSWERED ? undefined : symbol.id;
-    };
-    const named = namedBy(held);
-    const found = [];
-    imports.forEach((one, index) => {
-        const resolved = moduleOf(declared.length + index);
-        const position = renderPosition(one.file, root, one.specifier.getStart());
-        const read = (to, resolution, test) => {
-            found.push({ from: one.from, to, position, use: "read", resolution, test });
-        };
-        const test = testFiles.has(position.path);
-        const same = new Set(declared
-            .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
-            .map((declaration) => declaration.id));
-        for (const id of same) {
-            read(id, "batch", test);
-        }
-        for (const declaration of named(one.specifier.text, one.names)) {
-            // A wildcard declaration is how the compiler types the file a matching specifier
-            // names, so the import uses it whoever writes it, a test included.
-            if (declaration.wildcard || !same.has(declaration.id)) {
-                for (const to of [declaration.id, ...declaration.members]) {
-                    read(to, "syntax", test && !declaration.wildcard);
+export const moduleDeclarations = {
+    start() {
+        const imports = [];
+        return {
+            visit(node, { file, from }) {
+                const specifier = specifierOf(node);
+                if (specifier !== undefined) {
+                    imports.push({ file, from, specifier, names: namesImported(node) });
                 }
-            }
-        }
-    });
-    return found;
-}
+            },
+            reads({ project, held }) {
+                const found = [];
+                // A module declaration whose name is a string is written at a file's top level.
+                const declared = project.ownSourceFiles().flatMap((file) => file.statements.flatMap((statement) => {
+                    const id = held.declarations.get(nodeKey(file, statement));
+                    return isModuleDeclaration(statement) && literalText(statement.name) && id !== undefined
+                        ? [{ id, name: statement.name }]
+                        : [];
+                }));
+                if (declared.length === 0 || imports.length === 0) {
+                    return found;
+                }
+                const asked = [...declared.map((one) => one.name), ...imports.map((one) => one.specifier)];
+                const answers = project.symbolsAt(asked.map((node) => project.handle(node)));
+                const moduleOf = (at) => {
+                    const symbol = answers[at];
+                    return symbol === undefined || symbol === UNANSWERED ? undefined : symbol.id;
+                };
+                const named = namedBy(held);
+                imports.forEach((one, index) => {
+                    const resolved = moduleOf(declared.length + index);
+                    const read = (to, via, production) => {
+                        found.push({
+                            kind: "named",
+                            from: one.from,
+                            to,
+                            file: one.file,
+                            at: one.specifier,
+                            use: "read",
+                            via,
+                            ...(production ? { production: true } : {}),
+                        });
+                    };
+                    const same = new Set(declared
+                        .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
+                        .map((declaration) => declaration.id));
+                    for (const id of same) {
+                        read(id, "batch", false);
+                    }
+                    for (const declaration of named(one.specifier.text, one.names)) {
+                        // A wildcard declaration is how the compiler types the file a matching specifier
+                        // names, so the import uses it whoever writes it, a test included.
+                        if (declaration.wildcard || !same.has(declaration.id)) {
+                            for (const to of [declaration.id, ...declaration.members]) {
+                                read(to, "syntax", declaration.wildcard);
+                            }
+                        }
+                    }
+                });
+                return found;
+            },
+        };
+    },
+};