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

package/dist/src/dependencies.js

@@ -13,16 +13,17 @@ import { nodeKey, packageScope } from "./inventory.js";
 import { ancestors, dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath, } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
-import { manifestCommands } from "./manifest.js";
-import { workflowCommands, workflowTokens } from "./workflow-steps.js";
+import { manifestCommands, nodemonTexts } from "./manifest.js";
+import { commandFileTexts, workflowCommands } from "./workflow-steps.js";
+import { pathsNamed, preloadedPackages, readCommands, } from "./commands/read.js";
+import { heldNames } from "./text/named-files.js";
 import { bytewise } from "./text/compare.js";
 import { isRecord } from "./json-document.js";
 import { inInstalledPackages, INSTALLED_PACKAGES, MANIFEST, readDocument } from "./fs/manifest.js";
-import { commandsOf, scriptTokens } from "./text/shell.js";
 const MODULES_SEGMENT = `/${INSTALLED_PACKAGES}/`;
 const TYPES_SCOPE = "@types/";
-/** A script token naming a JavaScript file by a path no expansion changes. */
-const SCRIPT_FILE = /^[^$`{*?[~]+\.(?:js|mjs|cjs)$/u;
+/** A path a command names that is a JavaScript file's. */
+const SCRIPT_FILE = /\.(?:js|mjs|cjs)$/u;
 /** The manifest sections a dependency is declared in, each by the selector its reference spells. */
 const SECTIONS = [
     ["dependencies", "dependency"],
@@ -281,10 +282,10 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
     return { uses, at, unanswered };
 }
 /**
- * The JavaScript files no program holds that a script of a manifest at or above one of the
- * project's files runs, each with the directory of that manifest, and those a workflow
- * step or git hook runs, with the target root's: a token naming such a file below the
- * target root and in no `node_modules`, read against the manifest's directory.
+ * The JavaScript files no program holds that a command string of a manifest at or above one of
+ * the project's files runs or names, each with the directory of that manifest, and those a
+ * workflow step or git hook names, with the target root's: a path `pathsNamed` reads, below the
+ * target root and in no `node_modules`.
  */
 function scriptRunFiles(host, targetRoot, files) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
@@ -297,23 +298,28 @@ function scriptRunFiles(host, targetRoot, files) {
             dirs.add(dir);
         }
     }
-    const tokens = new Map([
-        [root, new Set(workflowTokens(host, root))],
+    const named = new Map([
+        [
+            root,
+            workflowReadings(host, root)
+                .flatMap(pathsNamed)
+                .map((one) => one.path),
+        ],
     ]);
     for (const dir of dirs) {
         const read = readDocument(host, joinPath(dir, MANIFEST));
         if (read !== undefined && isRecord(read.value)) {
-            const own = scriptTokensOf(read.value);
-            tokens.set(dir, dir === root ? new Set([...own, ...(tokens.get(root) ?? [])]) : own);
+            const own = manifestReadings(host, dir, read.value)
+                .flatMap(pathsNamed)
+                .map((one) => one.path);
+            named.set(dir, [...own, ...(named.get(dir) ?? [])]);
         }
     }
     const found = [];
-    for (const [manifestDir, held] of tokens) {
-        for (const token of held) {
-            const path = SCRIPT_FILE.test(token) ? resolvePath(manifestDir, token) : undefined;
-            const below = path === undefined ? undefined : relativePath(root, path);
-            if (path !== undefined &&
-                below !== undefined &&
+    for (const [manifestDir, paths] of named) {
+        for (const path of new Set(paths)) {
+            const below = SCRIPT_FILE.test(path) ? relativePath(root, path) : undefined;
+            if (below !== undefined &&
                 !inInstalledPackages(below) &&
                 !files.byName.has(path) &&
                 host.kindOf(path) === "file") {
@@ -323,6 +329,40 @@ function scriptRunFiles(host, targetRoot, files) {
     }
     return found;
 }
+/** What the command strings of one manifest, its scripts and nodemon's command, run. */
+function manifestReadings(host, dir, manifest) {
+    return manifestCommands(host, dir, manifest).map(({ command }) => readCommands(command, dir));
+}
+/** What one manifest's command strings use, held with the whole text of nodemon's configuration. */
+function manifestUses(host, dir, manifest) {
+    const uses = usesOf(manifestReadings(host, dir, manifest));
+    const texts = nodemonTexts(host, dir, manifest).map(({ text }) => text);
+    return { ...uses, held: [uses.held, ...texts].join("\n") };
+}
+/** What the target root's workflow steps, git hooks and recipes use, held with their files' whole text. */
+function workflowUses(host, targetRoot) {
+    const uses = usesOf(workflowReadings(host, targetRoot));
+    return { ...uses, held: [uses.held, ...commandFileTexts(host, targetRoot)].join("\n") };
+}
+/**
+ * What the target root's workflow steps, git hooks, hook managers and recipes run, each held
+ * with the directory the file writes for it.
+ */
+function workflowReadings(host, targetRoot) {
+    return workflowCommands(host, targetRoot).map(({ text, dir, writtenDirectory }) => {
+        const reading = readCommands(text, dir);
+        return { ...reading, held: [reading.held, writtenDirectory ?? ""].join("\n") };
+    });
+}
+function usesOf(readings) {
+    return {
+        words: new Set(readings.flatMap((one) => one.commands.flatMap((command) => command.words.flatMap((word) => word ?? [])))),
+        preloads: new Set(readings
+            .flatMap((one) => one.runs.flatMap(preloadedPackages))
+            .flatMap((specifier) => packageOfSpecifier(specifier) ?? [])),
+        held: readings.map((one) => one.held).join("\n"),
+    };
+}
 /** The declarations of the inventory a use written at one node belongs to. */
 function ownersOf(file, held, node) {
     const parent = node.parent;
@@ -633,95 +673,6 @@ function declaredIn(text, manifest, path, scope) {
 export function declarationKey(dependency) {
     return `${dependency.position.path}\u0000${dependency.name}`;
 }
-/** Every token of every value of one manifest's `scripts` member. */
-function scriptTokensOf(manifest) {
-    const scripts = manifest["scripts"];
-    const found = new Set();
-    if (isRecord(scripts)) {
-        for (const command of Object.values(scripts)) {
-            if (typeof command === "string") {
-                scriptTokens(command).forEach((token) => found.add(token));
-            }
-        }
-    }
-    return found;
-}
-/**
- * The runtime flags whose value is a module loaded before the entry, as `--flag value` or
- * `--flag=value`: https://nodejs.org/api/cli.html#--importmodule,
- * https://nodejs.org/api/cli.html#--experimental-loadermodule,
- * https://nodejs.org/api/cli.html#-r---require-module
- */
-const PRELOAD_FLAGS = new Set([
-    "--experimental-loader",
-    "--import",
-    "--loader",
-    "--require",
-    "-r",
-]);
-/**
- * The programs that pass a preload flag to the runtime they start: Node itself, and the
- * runners that forward Node's flags or read the same `--require`:
- * https://mochajs.org/#-require-module-r-module, https://tsx.is/node-enhancement,
- * https://typestrong.org/ts-node/docs/options#require,
- * https://github.com/remy/nodemon#running-non-node-scripts
- */
-const PRELOADING_PROGRAMS = new Set([
-    "mocha",
-    "node",
-    "nodemon",
-    "ts-node",
-    "tsx",
-]);
-/** The programs that run the command after them, and an environment assignment before it. */
-const LAUNCHERS = new Set(["cross-env", "env", "npx"]);
-const ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/u;
-/**
- * The packages `scripts` preload by a runtime flag's bare module specifier, a flag
- * counting only in a command whose program passes it to the runtime, and for Node only
- * before the script it runs, whose own arguments come after it.
- */
-function preloadsOf(scripts) {
-    const found = new Set();
-    for (const script of scripts) {
-        for (const command of commandsOf(script)) {
-            const tokens = scriptTokens(command);
-            let at = 0;
-            while (at < tokens.length &&
-                (ASSIGNMENT.test(tokens[at] ?? "") || LAUNCHERS.has(tokens[at] ?? ""))) {
-                at += 1;
-            }
-            const path = tokens[at] ?? "";
-            const program = path.slice(path.lastIndexOf("/") + 1);
-            if (!PRELOADING_PROGRAMS.has(program)) {
-                continue;
-            }
-            for (at += 1; at < tokens.length; at += 1) {
-                const token = tokens[at] ?? "";
-                if (!token.startsWith("-")) {
-                    if (program === "node") {
-                        break;
-                    }
-                    continue;
-                }
-                const equals = token.indexOf("=");
-                const flag = equals < 0 ? token : token.slice(0, equals);
-                if (!PRELOAD_FLAGS.has(flag)) {
-                    continue;
-                }
-                if (equals < 0) {
-                    at += 1;
-                }
-                const value = equals < 0 ? tokens[at] : token.slice(equals + 1);
-                const name = value === undefined ? undefined : packageOfSpecifier(value);
-                if (name !== undefined) {
-                    found.add(name);
-                }
-            }
-        }
-    }
-    return found;
-}
 /** Whether a path below the target root lies in the directory `dir` below it, `""` being the root. */
 function isInside(path, dir) {
     return dir === "" || path.startsWith(`${dir}/`);
@@ -792,8 +743,7 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
             unbuilt.add(path);
         }
     }
-    const workflow = new Set(workflowTokens(host, targetRoot));
-    const workflowPreloads = preloadsOf(workflowCommands(host, targetRoot));
+    const workflow = workflowUses(host, targetRoot);
     const declared = [];
     const ran = new Set();
     const peers = new Map();
@@ -803,23 +753,25 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
         if (read === undefined || !isRecord(read.value)) {
             continue;
         }
-        const tokens = scriptTokensOf(read.value);
-        const preloads = preloadsOf(manifestCommands(host, dir, read.value).map(({ command }) => command));
+        const own = manifestUses(host, dir, read.value);
+        const held = `${own.held}\n${workflow.held}`;
         for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
             const found = installedOf(host, dir, dependency.name);
             if (found === undefined && uninstalledHere.has(dir)) {
                 continue;
             }
             declared.push(dependency);
-            if (preloads.has(dependency.name) || workflowPreloads.has(dependency.name)) {
+            if (own.preloads.has(dependency.name) ||
+                workflow.preloads.has(dependency.name) ||
+                heldNames(held, [dependency.name]).size > 0) {
                 ran.add(declarationKey(dependency));
             }
             if (found === undefined) {
                 continue;
             }
             peers.set(declarationKey(dependency), found.peers);
-            const runs = (command) => tokens.has(command) || workflow.has(command);
-            if (found.commands.some(runs)) {
+            const runs = (command) => own.words.has(command) || workflow.words.has(command);
+            if (found.commands.some(runs) || heldNames(held, found.commands).size > 0) {
                 ran.add(declarationKey(dependency));
             }
         }

package/dist/src/load/synthesize.js

@@ -4,11 +4,13 @@
  * configuration only the snapshot holds, with the module system of the runtime its package
  * is written for.
  */
+import { readCommands } from "../commands/read.js";
 import { CONVENTION_ROWS } from "../convention-rows.js";
 import { holdsManifest, MANIFEST, readManifestAt } from "../fs/manifest.js";
 import { filesBelow } from "../fs/tree.js";
 import { JAVASCRIPT_FILE, minified, minifiedByName } from "../javascript-file.js";
 import { isRecord } from "../json-document.js";
+import { manifestCommands } from "../manifest.js";
 import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.js";
 import { bytewise } from "../text/compare.js";
 import { writtenPath } from "./workspace-programs.js";
@@ -89,11 +91,15 @@ const RUNTIME_OPTIONS = {
 };
 /** The manifest members that say a package is written for Node. */
 const NODE_MEMBERS = ["main", "exports", "bin", "type"];
-/** Whether one manifest says its package runs under Node, `engines.node` included; its scripts are not read. */
-function writtenForNode(manifest) {
+/**
+ * Whether one manifest says its package runs under Node: a Node member, `engines.node`
+ * included, or a command string of it that runs a file with `node`, as `commands/read.ts` reads it.
+ */
+function writtenForNode(host, dir, manifest) {
     const { engines } = manifest;
     return (NODE_MEMBERS.some((member) => manifest[member] !== undefined) ||
-        (isRecord(engines) && engines["node"] !== undefined));
+        (isRecord(engines) && engines["node"] !== undefined) ||
+        manifestCommands(host, dir, manifest).some(({ command }) => readCommands(command, dir).runs.some((run) => run.runtime === "node")));
 }
 /**
  * The manifests, by path as `conventions` names them, an applied row of a tool that bundles
@@ -107,7 +113,8 @@ export function bundlingManifests(conventions) {
 /**
  * Each group's program, given the module system of the runtime its package is written for: a
  * bundler's where a row of a tool that bundles applies through the group's manifest or the
- * root's, else Node's where its manifest says the package runs under Node, under which a file's
+ * root's, else Node's where its manifest says the package runs under Node or a command string of
+ * it runs a file with `node`, under which a file's
  * extension and its package's `type` decide its module format, else a bundler's, which reads a
  * file with no module syntax as a classic script, as a browser loads it.
  */
@@ -118,7 +125,7 @@ export function formedPrograms(engine, host, groups, { root, origin, bundling, i
         const runtime = !bundling.has(MANIFEST) &&
             (below === undefined || !bundling.has(below)) &&
             group.manifest.kind === "read" &&
-            writtenForNode(group.manifest.manifest)
+            writtenForNode(host, group.dir, group.manifest.manifest)
             ? "node"
             : "bundler";
         const configFile = writtenPath(host, joinPath(group.dir, GROUP_CONFIGURATION));

package/dist/src/manifest.js

@@ -7,8 +7,7 @@
 import { isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { isRecord } from "./json-document.js";
 import { MANIFEST, manifestAt, readJSON } from "./fs/manifest.js";
-import { scriptTokens } from "./text/shell.js";
-/** The manifest's own name. */
+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"];
 /**
@@ -26,6 +25,25 @@ function isTarget(value, requireDot) {
 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. Layer 3 holds it whole, 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 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`
@@ -118,20 +136,15 @@ export function readManifest(host, targetRoot) {
         }
     }
     exportTargets(manifest["exports"], "exports", found);
-    const scripts = manifest["scripts"];
-    if (isRecord(scripts)) {
-        for (const [name, command] of Object.entries(scripts)) {
-            if (typeof command !== "string") {
-                continue;
-            }
-            const member = below("scripts", name);
-            for (const path of new Set(scriptTokens(command))) {
-                found.push({ member, path, role: "script", published: false });
-            }
+    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: command });
     }
-    for (const { member, command } of manifestCommands(host, targetRoot, manifest)) {
-        found.push({ member, path: ".", role: "script", published: false, command });
+    for (const { member, text } of nodemonTexts(host, targetRoot, manifest)) {
+        found.push({ member, path: ".", role: "script", published: false, held: text });
     }
     return {
         entries: found.map((entry) => ({

package/dist/src/roots.js

@@ -20,7 +20,8 @@ import { bytewise } from "./text/compare.js";
 import { holdsManifest } from "./fs/manifest.js";
 import { globExpression } from "./text/glob.js";
 import { spelledFiles } from "./text/named-files.js";
-import { commandDirectories, workflowCommands } from "./workflow-steps.js";
+import { commandFileTexts, workflowCommands } from "./workflow-steps.js";
+import { readCommands } from "./commands/read.js";
 /** Whether one declaration is written below the directory of a published workspace member. */
 function inPublishedMember(held, id, root, members) {
     const path = held.symbols.find((symbol) => symbol.id === id)?.position.path;
@@ -174,11 +175,11 @@ function childrenOf(held) {
     return byParent;
 }
 /**
- * Per package, the own files its command strings name as plain text, but those a root enters
- * with all they export: a command can use no more of such a file than the root keeps live. A
- * manifest's are its entries' whole command strings, and the target root's package has the
- * workflow steps, git hooks and makefile recipes beside its own, with the directories its
- * workflow steps and lefthook commands run in, where a `.` names that directory's index file.
+ * Per package, the own files its held texts name, as `spelledFiles` reads them, but those a
+ * root enters with all they export: a command can use no more of such a file than the root
+ * keeps live. A manifest's are its entries' held texts, and the target root's package has the
+ * workflow steps, git hooks and makefile recipes beside its own, with the whole text of each
+ * file `commandFileTexts` reads.
  */
 function scriptHolds(entries, files, entered, host, targetRoot) {
     const rooted = new Set(entered.filter((one) => one.exports && one.names === undefined).map((one) => one.file.fileName));
@@ -189,13 +190,19 @@ function scriptHolds(entries, files, entered, host, targetRoot) {
     const commands = new Map([
         [
             resolvePath(cwd, targetRoot),
-            [...workflowCommands(host, targetRoot), ...commandDirectories(host, targetRoot)],
+            [
+                ...workflowCommands(host, targetRoot).flatMap(({ text, dir, writtenDirectory }) => [
+                    readCommands(text, dir).held,
+                    ...(writtenDirectory === undefined ? [] : [writtenDirectory]),
+                ]),
+                ...commandFileTexts(host, targetRoot),
+            ],
         ],
     ]);
     for (const entry of entries) {
-        if (entry.command !== undefined) {
+        if (entry.held !== undefined) {
             const dir = resolvePath(cwd, entry.dir);
-            commands.set(dir, [...(commands.get(dir) ?? []), entry.command]);
+            commands.set(dir, [...(commands.get(dir) ?? []), entry.held]);
         }
     }
     const held = [];
@@ -249,7 +256,7 @@ export function roots(project, held, targetRoot, options) {
                 (options.publishedAPI || options.publishedMembers?.has(entry.dir) === true),
         })),
     ];
-    const scripted = entries.flatMap(({ entry }) => entry.role === "script" && entry.command === undefined ? files.named(entry.path) : []);
+    const scripted = entries.flatMap(({ entry }) => entry.role === "script" && entry.held === undefined ? files.named(entry.path) : []);
     const readBackTo = [
         ...scripted,
         ...points.filter((point) => READ_BACK_RULES.has(point.rule)).map((point) => point.file),
@@ -299,7 +306,7 @@ export function roots(project, held, targetRoot, options) {
     const unmapped = [];
     const mapped = patterned.map(({ file }) => file);
     for (const { entry } of entries) {
-        if (entry.command !== undefined) {
+        if (entry.held !== undefined) {
             continue;
         }
         const named = entryFiles(entry);

package/dist/src/text/named-files.js

@@ -1,7 +1,7 @@
 /**
- * The files a command's text names, read as plain text: the text is searched for each file's
- * names, which every spelling of its path contains, so no part of it is split, unquoted or
- * skipped first.
+ * Layer 3 of the command reader: the files and the package names a command's text names, read
+ * as plain text. The text is searched for each name, which every spelling of what it names
+ * contains, so no part of it is split, unquoted or skipped first.
  */
 import { dirnamePath, normalizePath, relativePath } from "../paths.js";
 /** The extension a source or an emitted file carries: a JavaScript or TypeScript one, or a declaration's. */
@@ -52,3 +52,24 @@ export function spelledFiles(text, dir, files) {
     }
     return [...found];
 }
+/** A character a package's or a command's name may hold, so one beside a name makes it part of a longer one. */
+const NAME_CHARACTER = /[\w.@-]/u;
+/**
+ * Each of `names`, a package's or a command's name, that `text` holds with no name character
+ * before it and no character after it but one a path or a version may go on with, `/`, `.` or
+ * `@` among them: `module-alias/register` holds `module-alias`, and `tsxx` holds no `tsx`.
+ */
+export function heldNames(text, names) {
+    const found = new Set();
+    for (const name of names) {
+        for (let at = text.indexOf(name); at >= 0 && name !== ""; at = text.indexOf(name, at + 1)) {
+            const before = text.charAt(at - 1);
+            const after = text.charAt(at + name.length);
+            if (!NAME_CHARACTER.test(before) && !/[\w-]/u.test(after)) {
+                found.add(name);
+                break;
+            }
+        }
+    }
+    return found;
+}