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

package/dist/src/{configured-declarations.js → roots/configured-declarations.js}

@@ -6,10 +6,10 @@
  */
 import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { resolvedTargets } from "./calls.js";
-import { declaredComponent } from "./inventory.js";
-import { must, Unanswerable } from "./query.js";
-import { nameComponent } from "./ref.js";
+import { resolvedTargets } from "../calls.js";
+import { declaredComponent } from "../inventory.js";
+import { must, Unanswerable } from "../query.js";
+import { nameComponent } from "../ref.js";
 /** The meanings a name of the global scope is looked up under: any of them. */
 const ANY_MEANING = SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace;
 /** The suffix that marks a static member at the end of a path. */
@@ -140,6 +140,9 @@ function specifierOf(node) {
  * import resolves. A specifier no file writes resolves to no module.
  */
 function modulesNamed(project, specifiers) {
+    if (specifiers.size === 0) {
+        return new Map();
+    }
     const written = new Map();
     for (const file of project.ownSourceFiles()) {
         const visit = (node) => {
@@ -179,19 +182,19 @@ export function resolveEntries(project, held, entries) {
     for (const symbol of held.symbols) {
         byRef.set(symbol.ref, [...(byRef.get(symbol.ref) ?? []), symbol.id]);
     }
-    const modules = modulesNamed(project, new Set(entries.flatMap((entry) => (entry.shape === "module" ? [entry.module] : []))));
+    const modules = modulesNamed(project, new Set(entries.flatMap((entry) => ("module" in entry ? [entry.module] : []))));
     return entries.map((entry) => {
-        if (entry.shape === "symbol") {
+        if ("symbol" in entry) {
             return { entry, handles: new Set(), ids: new Set(byRef.get(entry.symbol) ?? []) };
         }
-        const { components, static: isStatic } = componentsOf(entry.shape === "module" ? entry.name : entry.global);
+        const { components, static: isStatic } = componentsOf("module" in entry ? entry.name : entry.global);
         const [first = "", ...rest] = components;
         let start;
         if (isStatic && rest.length === 0) {
             // Only a member is static, and a path of one component names no member.
             start = undefined;
         }
-        else if (entry.shape === "module") {
+        else if ("module" in entry) {
             const module = modules.get(entry.module);
             start = module === undefined ? undefined : memberOf(project, module, first, false);
         }
@@ -246,14 +249,10 @@ export function entriesAt(project, chains, nodes, resolved) {
  * program the display name the inventory gives it.
  */
 export function spelledEntry(entry, held) {
-    switch (entry.shape) {
-        case "symbol":
-            return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
-        case "module":
-            return entry.name;
-        case "global":
-            return entry.global;
+    if ("symbol" in entry) {
+        return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
     }
+    return "module" in entry ? entry.name : entry.global;
 }
 /** The key under which a lifecycle contract's declarations are configured. */
 const LIFECYCLE_KEY = "ts.lifecycle_contracts";
@@ -264,11 +263,14 @@ const LIFECYCLE_KEY = "ts.lifecycle_contracts";
  */
 export function configuredDeclarations(config) {
     return [
-        ...config.ts.injectionRegistrations.map((entry) => ({
+        ...config.ts.injection_registrations.map((entry) => ({
             key: "ts.injection_registrations",
             entry,
         })),
-        ...config.ts.lifecycleContracts.flatMap((contract) => [...contract.components, ...contract.bases].map((entry) => ({ key: LIFECYCLE_KEY, entry }))),
+        ...config.ts.lifecycle_contracts.flatMap((contract) => [...(contract.components ?? []), ...(contract.bases ?? [])].map((entry) => ({
+            key: LIFECYCLE_KEY,
+            entry,
+        }))),
         ...config.ts.serializers.map((entry) => ({ key: "ts.serializers", entry })),
     ];
 }
@@ -294,12 +296,8 @@ export function declarationsNamed(project, held, configured) {
  * sign and its name, and a global entry's path after a number sign.
  */
 export function configuredRef(entry) {
-    switch (entry.shape) {
-        case "symbol":
-            return entry.symbol;
-        case "module":
-            return `${entry.module}#${entry.name}`;
-        case "global":
-            return `#${entry.global}`;
+    if ("symbol" in entry) {
+        return entry.symbol;
     }
+    return "module" in entry ? `${entry.module}#${entry.name}` : `#${entry.global}`;
 }

package/dist/src/{entry-point-gaps.js → roots/entry-point-gaps.js}

@@ -1,12 +1,10 @@
 /**
- * Every entry-point convention this analyzer declines, each with the tool it belongs
- * to and why. A file only a declined convention enters is reported as never
- * imported, so a project that relies on one names the file in `ts.entry_files` or
- * `roots.patterns`, and this list is what tells it to.
- *
- * Every row carries a reason, because the list is read where the rows are shown
- * one at a time: beside a finding, or in a report's declared gaps.
+ * Every entry-point convention this analyzer declines, each with its tool and why. A file only
+ * a declined convention enters is reported as never imported, so a project relying on one names
+ * the file in `ts.entry_files` or `roots.patterns`, and this list tells it to. Every row carries
+ * a reason, since rows are shown one at a time, beside a finding or in a report's declared gaps.
  */
+import { bytewise } from "../text/compare.js";
 /** What is declined for a tool whose own conventions are entered only through its configuration files. */
 const EVERY_CONVENTION = "every file it loads by its own convention beyond its configuration files";
 /** Why a tool whose own conventions are not read declines them. */
@@ -291,15 +289,8 @@ const PARTLY_ENTERED = [
         reason: NOT_LITERAL,
     },
 ];
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /** Every declined entry-point convention, ordered by tool and then by convention. */
 export const DECLINED_CONVENTIONS = [
     ...UNREAD_TOOLS.map((tool) => ({ tool, convention: EVERY_CONVENTION, reason: UNREAD })),
     ...PARTLY_ENTERED,
-].sort((a, b) => compare(a.tool, b.tool) || compare(a.convention, b.convention));
+].sort((a, b) => bytewise(a.tool, b.tool) || bytewise(a.convention, b.convention));

package/dist/src/roots/manifest.js

@@ -0,0 +1,216 @@
+/**
+ * The entry points a package manifest names, which are roots because something
+ * outside the analyzed program reaches them: a consumer importing the package, or a
+ * shell running its command or one of its scripts. {@link readManifest} reads one
+ * directory's manifest, {@link packageEntries} those of the packages below the target root.
+ */
+import { isAbsolutePath, joinPath, relativePath, resolvePath } from "../paths.js";
+import { isRecord } from "../json-document.js";
+import { MANIFEST, manifestAt, readJSON } from "../fs/manifest.js";
+import { pathsNamed, readCommands } from "../commands/read.js";
+/** The three members that name an entry point beside `exports` and `bin`. */
+const LEGACY_MEMBERS = ["main", "module", "types"];
+/**
+ * Whether one member's value names a file of this package rather than another
+ * package or a URL. A target written with no leading dot is a path too, which is
+ * how the members that preceded `exports` are written.
+ */
+function isTarget(value, requireDot) {
+    if (value === "" || isAbsolutePath(value) || value.includes("://")) {
+        return false;
+    }
+    return !requireDot || value.startsWith("./");
+}
+/** One member's spelling below another: `exports` then `exports["."]`. */
+function below(member, key) {
+    return `${member}[${JSON.stringify(key)}]`;
+}
+/**
+ * The whole text of nodemon's configuration, the manifest's `nodemonConfig` member and the
+ * `nodemon.json` beside it, by the member each is. The dependency rule reads it whole, and
+ * layer 3 each of its values, because nodemon runs commands from keys besides `exec`, `events`
+ * among them: https://github.com/remy/nodemon#config-files
+ */
+export function nodemonTexts(host, dir, manifest) {
+    const member = manifest["nodemonConfig"];
+    let file;
+    try {
+        file = host.readFile(joinPath(dir, "nodemon.json"));
+    }
+    catch {
+        file = undefined;
+    }
+    return [
+        ...(member === undefined ? [] : [{ member: "nodemonConfig", text: JSON.stringify(member) }]),
+        ...(file === undefined ? [] : [{ member: "nodemon.json", text: file }]),
+    ];
+}
+/**
+ * The texts layer 3 reads of one text of nodemon's configuration: each value of it but its
+ * `exec` command, which is read as a command string of its own, those under `events` read as
+ * command strings too, and the whole text where it does not parse. Its keys are never read.
+ */
+function nodemonValues(text) {
+    let config;
+    try {
+        config = JSON.parse(text);
+    }
+    catch {
+        return [{ text, shell: false }];
+    }
+    const found = [];
+    const visit = (value, shell) => {
+        if (Array.isArray(value) || isRecord(value)) {
+            for (const one of Object.values(value)) {
+                visit(one, shell);
+            }
+        }
+        else if (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean") {
+            found.push({ text: String(value), shell });
+        }
+    };
+    for (const [key, value] of Object.entries(isRecord(config) ? config : { "": config })) {
+        if (key !== "exec" || typeof value !== "string") {
+            visit(value, key === "events");
+        }
+    }
+    return found;
+}
+/**
+ * The command strings one manifest runs, each at the member it is written under: each of its
+ * `scripts`, and the `exec` command of nodemon's configuration, in the manifest's `nodemonConfig`
+ * or the `nodemon.json` beside it, which nodemon runs the watched script with:
+ * https://github.com/remy/nodemon#config-files
+ */
+export function manifestCommands(host, dir, manifest) {
+    const scripts = manifest["scripts"];
+    const nodemon = {
+        nodemonConfig: manifest["nodemonConfig"],
+        "nodemon.json": readJSON(host, joinPath(dir, "nodemon.json")),
+    };
+    const written = [
+        ...Object.entries(isRecord(scripts) ? scripts : {}).map(([name, value]) => [below("scripts", name), value]),
+        ...Object.entries(nodemon).map(([member, config]) => [below(member, "exec"), isRecord(config) ? config["exec"] : undefined]),
+    ];
+    return written.flatMap(([member, command]) => typeof command === "string" ? [{ member, command }] : []);
+}
+/**
+ * Every target one `exports` value carries, at the member each is written under. Every level of
+ * strings, subpath or condition objects and alternative arrays is walked, because each condition
+ * names its own entry file; a `null` blocks a subpath, and a key's meaning is never read.
+ */
+function exportTargets(value, member, found) {
+    if (typeof value === "string") {
+        if (isTarget(value, true)) {
+            found.push({ member, path: value, role: "import", published: true });
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((alternative, index) => {
+            exportTargets(alternative, below(member, String(index)), found);
+        });
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const [key, held] of Object.entries(value)) {
+        exportTargets(held, below(member, key), found);
+    }
+}
+/**
+ * What the manifest in `targetRoot` declares about where its package is entered.
+ *
+ * A target is taken as written. It is not resolved to a source file here, because
+ * which file a target names is a fact about the compiler configuration that emits
+ * it and there is one such configuration per project, while there is one manifest.
+ */
+export function readManifest(host, targetRoot) {
+    const manifest = manifestAt(host, targetRoot);
+    if (manifest === undefined) {
+        return { entries: [], declaresExports: false };
+    }
+    const found = [];
+    for (const member of LEGACY_MEMBERS) {
+        const value = manifest[member];
+        if (typeof value === "string" && isTarget(value, false)) {
+            found.push({ member, path: value, role: "import", published: true });
+        }
+    }
+    // A `browser` string replaces `main` in a browser bundle, and an object replaces each
+    // module it maps with the file it names: https://github.com/defunctzombie/package-browser-field-spec
+    const browser = manifest["browser"];
+    if (typeof browser === "string" && isTarget(browser, false)) {
+        found.push({ member: "browser", path: browser, role: "import", published: true });
+    }
+    else if (isRecord(browser)) {
+        for (const [replaced, value] of Object.entries(browser)) {
+            if (typeof value === "string" && isTarget(value, true)) {
+                found.push({
+                    member: below("browser", replaced),
+                    path: value,
+                    role: "import",
+                    published: true,
+                });
+            }
+        }
+    }
+    const bin = manifest["bin"];
+    if (typeof bin === "string" && isTarget(bin, false)) {
+        found.push({ member: "bin", path: bin, role: "run", published: false });
+    }
+    else if (isRecord(bin)) {
+        for (const [command, value] of Object.entries(bin)) {
+            if (typeof value === "string" && isTarget(value, false)) {
+                found.push({ member: below("bin", command), path: value, role: "run", published: false });
+            }
+        }
+    }
+    exportTargets(manifest["exports"], "exports", found);
+    for (const { member, command } of manifestCommands(host, targetRoot, manifest)) {
+        // Read against ".", so each path stays relative until the entries are resolved below.
+        for (const path of new Set(pathsNamed(readCommands(command, ".")).map((one) => one.path))) {
+            found.push({ member, path, role: "script", published: false });
+        }
+        found.push({
+            member,
+            path: ".",
+            role: "script",
+            published: false,
+            held: [{ text: command, shell: true, tested: member.startsWith("scripts[") }],
+        });
+    }
+    for (const { member, text } of nodemonTexts(host, targetRoot, manifest)) {
+        const held = nodemonValues(text);
+        if (held.length > 0) {
+            found.push({ member, path: ".", role: "script", published: false, held });
+        }
+    }
+    return {
+        entries: found.map((entry) => ({
+            ...entry,
+            path: resolvePath(targetRoot, entry.path),
+            dir: targetRoot,
+        })),
+        declaresExports: manifest["exports"] !== undefined,
+    };
+}
+/**
+ * The entry points the manifests of the nested packages in `dirs` name. Each entry is
+ * spelled under its manifest's path below the target root, and is published by its own
+ * manifest's rule, as the target's own entries are.
+ */
+export function packageEntries(host, targetRoot, dirs) {
+    return dirs.flatMap((dir) => {
+        const manifest = readManifest(host, dir);
+        const where = `${relativePath(targetRoot, dir) ?? dir}/${MANIFEST}`;
+        return manifest.entries.map((entry) => ({
+            ...entry,
+            member: `${where} ${entry.member}`,
+            published: entry.published && (!manifest.declaresExports || entry.member.startsWith("exports")),
+        }));
+    });
+}