@cplieger/deadset-ts 7.2.0-dev.3 → 8.0.0-dev.1

package/dist/src/workflow-steps.js

@@ -1,18 +1,33 @@
 /**
- * The source files a CI workflow's `run:` steps name by their path from the target root.
- * A workflow file is read as text, line by line, with no YAML parsed.
+ * The source files a CI workflow's `run:` steps and the repository's git hooks name by their
+ * path from the target root. A workflow or hook file is read as text, line by line, with no
+ * YAML parsed.
  */
 import { scriptTokens } from "./manifest.js";
-import { joinPath, resolvePath } from "./paths.js";
+import { joinPath, relativePath, resolvePath } from "./paths.js";
 const WORKFLOWS = ".github/workflows";
 /** A line holding a run command: indentation and one sequence marker before `run:`. */
 const RUN_LINE = /^(\s*(?:- )?)run:(.*)$/u;
+/** The directories whose every file is a git hook script, run as the shell runs it. */
+const HOOK_DIRS = [".husky", ".githooks"];
+/** The hook manager files whose commands are written under a key, with that key. */
+const HOOK_MANAGERS = [
+    [".pre-commit-config.yaml", /^(\s*(?:- )?)entry:(.*)$/u],
+    ["lefthook.yml", RUN_LINE],
+    ["lefthook.yaml", RUN_LINE],
+    [".lefthook.yml", RUN_LINE],
+];
+/** The names GNU make reads a makefile under, in the order it tries them. */
+const MAKEFILES = ["GNUmakefile", "makefile", "Makefile"];
+/** The operators that end one shell command of a recipe line. */
+const COMMAND_SEPARATORS = /&&|\|\||;|\|/u;
 const BLOCK_SCALAR = /^[|>][+-]?$/u;
 const QUOTED = /^(["'])(.*)\1$/su;
 /** A token holding one of these is computed or a pattern, so it names no file. */
 const COMPUTED = /[${*?[]/u;
 const INDENT = /^\s*/u;
-function workflowFiles(host, dir) {
+/** The files directly in one directory whose name `accepts`, in name order. */
+function filesIn(host, dir, accepts) {
     let entries;
     try {
         entries = host.readDirectory(dir);
@@ -21,16 +36,24 @@ function workflowFiles(host, dir) {
         return [];
     }
     return entries
-        .filter((entry) => !entry.directory && /\.ya?ml$/u.test(entry.name))
+        .filter((entry) => !entry.directory && accepts(entry.name))
         .map((entry) => joinPath(dir, entry.name))
         .sort();
 }
-/** Every command line one workflow file's `run:` steps hold. */
-export function runCommands(text) {
+function readText(host, path) {
+    try {
+        return host.readFile(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Every command line one workflow file's `run:` steps, or the steps under `key`, hold. */
+export function runCommands(text, key = RUN_LINE) {
     const lines = text.split(/\r?\n/u);
     const found = [];
     for (let at = 0; at < lines.length; at += 1) {
-        const match = RUN_LINE.exec(lines[at] ?? "");
+        const match = key.exec(lines[at] ?? "");
         if (match === null) {
             continue;
         }
@@ -50,28 +73,92 @@ export function runCommands(text) {
     }
     return found;
 }
-/** Every token the `run:` steps of the workflow files in the target root's `.github/workflows` hold. */
-export function workflowTokens(host, targetRoot) {
-    const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
+/**
+ * Every token the recipe lines of the target root's makefile hold, each with the directory
+ * below the root it is read against: a recipe line is one that starts with a tab, joined
+ * with the lines a trailing `\` continues it onto, and make runs each in a shell of its
+ * own, so a `cd` moves the directory of the later commands of its line alone.
+ */
+function recipeTokens(host, root) {
+    const path = MAKEFILES.map((name) => joinPath(root, name)).find((candidate) => host.kindOf(candidate) === "file");
+    const text = path === undefined ? undefined : readText(host, path);
+    if (text === undefined) {
+        return [];
+    }
     const found = [];
-    for (const path of workflowFiles(host, dir)) {
-        let text;
-        try {
-            text = host.readFile(path);
-        }
-        catch {
+    for (const line of text.replace(/\\\r?\n/gu, " ").split(/\r?\n/u)) {
+        if (!line.startsWith("\t")) {
             continue;
         }
-        for (const command of runCommands(text)) {
-            found.push(...scriptTokens(command));
+        let dir = root;
+        for (const command of withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(COMMAND_SEPARATORS)) {
+            const tokens = scriptTokens(command);
+            const [first, target, ...rest] = tokens;
+            if (first === "cd" && target !== undefined && rest.length === 0 && !COMPUTED.test(target)) {
+                dir = resolvePath(dir, target);
+                continue;
+            }
+            for (const token of tokens) {
+                found.push({ token, dir: relativePath(root, dir) ?? "" });
+            }
         }
     }
     return found;
 }
+/** One shell line up to its comment: a `#` that starts a word outside quotes. */
+function withoutComment(line) {
+    let quote = "";
+    for (let at = 0; at < line.length; at += 1) {
+        const char = line[at];
+        if (quote !== "") {
+            if (char === quote) {
+                quote = "";
+            }
+            else if (char === "\\" && quote === '"') {
+                at += 1;
+            }
+        }
+        else if (char === "'" || char === '"') {
+            quote = char;
+        }
+        else if (char === "\\") {
+            at += 1;
+        }
+        else if (char === "#" && (at === 0 || /\s/u.test(line[at - 1] ?? ""))) {
+            return line.slice(0, at);
+        }
+    }
+    return line;
+}
+/**
+ * Every token the target root's workflow steps, git hooks and makefile hold: the `run:`
+ * steps of the workflow files in `.github/workflows`, every line of each file in `.husky`
+ * and `.githooks`, the `entry:` commands of `.pre-commit-config.yaml`, the `run:` commands
+ * of a lefthook file and the makefile's recipe lines.
+ */
+export function workflowTokens(host, targetRoot) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const commands = [];
+    for (const path of filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name))) {
+        commands.push(...runCommands(readText(host, path) ?? ""));
+    }
+    for (const dir of HOOK_DIRS) {
+        for (const path of filesIn(host, joinPath(root, dir), () => true)) {
+            commands.push(...(readText(host, path) ?? "").split(/\r?\n/u).map(withoutComment));
+        }
+    }
+    for (const [name, key] of HOOK_MANAGERS) {
+        commands.push(...runCommands(readText(host, joinPath(root, name)) ?? "", key));
+    }
+    return [
+        ...commands.flatMap((command) => scriptTokens(command)),
+        ...recipeTokens(host, root).map(({ token }) => token),
+    ];
+}
 /**
- * The own files the `run:` steps of every workflow file in the target root's
- * `.github/workflows` name: a token equal to a file's path below the target root, with or
- * without a leading `./`, whatever directory the step runs in.
+ * The own files the target root's workflow steps and git hooks name, as
+ * {@link workflowTokens} reads them: a token equal to a file's path below the target root,
+ * with or without a leading `./`, whatever directory the step runs in.
  */
 export function workflowEntries(host, targetRoot, files) {
     const found = [];
@@ -84,5 +171,15 @@ export function workflowEntries(host, targetRoot, files) {
             found.push({ file, source: token });
         }
     }
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    for (const { token, dir } of recipeTokens(host, root)) {
+        const below = COMPUTED.test(token) || dir === ""
+            ? undefined
+            : relativePath(root, resolvePath(joinPath(root, dir), token));
+        const file = below === undefined ? undefined : files.byPath.get(below);
+        if (file !== undefined) {
+            found.push({ file, source: token });
+        }
+    }
     return found;
 }

package/dist/src/workspace-programs.js

@@ -7,18 +7,22 @@
  */
 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;
 /**
  * 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
+ * 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.
  */
 function analysisOptions(parsed) {
     const { composite, rootDir: _rootDir, outDir: _outDir, declarationDir: _declarationDir, tsBuildInfoFile: _tsBuildInfoFile, ...kept } = parsed.options;
-    return composite === true ? { ...kept, declaration: true } : kept;
+    const paths = baseUrlPaths(parsed.options);
+    const options = paths === undefined ? kept : { ...kept, paths };
+    return composite === true ? { ...options, declaration: true } : options;
 }
 /** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
 function conditionsOf(parsed, mode) {
@@ -73,7 +77,7 @@ function configurationOf(engine, host, reading) {
     const raw = options["pathsBasePath"];
     const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
     const paths = {};
-    for (const [key, targets] of Object.entries(options.paths ?? {})) {
+    for (const [key, targets] of Object.entries(baseUrlPaths(options) ?? options.paths ?? {})) {
         paths[key] = targets.map((target) => resolvePath(base, target));
     }
     for (const entry of reading.entries) {

package/dist/src/workspace-resolution.js

@@ -1,12 +1,12 @@
 /**
- * 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 { gitIgnored } from "./git-ignore.js";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { satisfies } from "./version-range.js";
 /** The manifest members that name an entry point for the subpath `.` without `exports`. */
@@ -19,6 +19,7 @@ const DEPENDENCY_MEMBERS = [
     "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);
 }
@@ -42,9 +43,17 @@ function inside(dir, path) {
 }
 /** The `exports` entry one subpath selects, with what a pattern's `*` matched. */
 function exportsEntry(exportsField, subpath) {
-    const map = isRecord(exportsField) && Object.keys(exportsField).some((key) => key.startsWith("."))
-        ? exportsField
-        : { ".": exportsField };
+    const keys = isRecord(exportsField) ? Object.keys(exportsField) : [];
+    const dotted = keys.filter((key) => key.startsWith(".")).length;
+    // An object mixing subpath keys with others is invalid to Node; the compiler still
+    // answers `.` from its `"."` key and no other subpath:
+    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L673-L695
+    if (isRecord(exportsField) && dotted > 0 && dotted < keys.length) {
+        return subpath === "." && Object.hasOwn(exportsField, ".")
+            ? { value: exportsField["."] }
+            : undefined;
+    }
+    const map = isRecord(exportsField) && dotted > 0 ? exportsField : { ".": exportsField };
     if (Object.hasOwn(map, subpath)) {
         return { value: map[subpath] };
     }
@@ -154,6 +163,27 @@ export function workspaceResolver(host, workspace) {
         links.set(key, found);
         return found;
     };
+    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);
+        }
+        manifests.set(dir, found);
+        return found;
+    };
     const linkOf = (candidates, fromDir) => {
         const name = candidates[0]?.name ?? "";
         const linked = linkedFrom(name, fromDir);
@@ -165,13 +195,15 @@ export function workspaceResolver(host, workspace) {
         if (scope?.name === name) {
             return { kind: "member", member: scope };
         }
-        const manifest = scope?.manifest;
+        // 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 matched = candidates.filter((member) => declared.some((specifier) => dependsOn(specifier, member, scope?.dir ?? fromDir)));
+        const matched = candidates.filter((member) => declared.some((specifier) => dependsOn(specifier, member, owner?.dir ?? fromDir)));
         const [one, two] = matched;
         if (one === undefined) {
             return { kind: "none" };
@@ -182,6 +214,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 (let dir = dirnamePath(path); inside(member.dir, dir); dir = dirnamePath(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
@@ -203,6 +250,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. */
@@ -261,9 +311,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) {
@@ -286,6 +338,13 @@ export function workspaceResolver(host, workspace) {
             if (answered !== undefined) {
                 return { kind: "default" };
             }
+            // A stylesheet or another asset is no module with a source, so the import of one
+            // keeps the compiler's resolution.
+            if (targets.some((target) => !SOURCE.test(target) &&
+                !OUTPUT.test(target) &&
+                host.kindOf(joinPath(member.dir, target)) === "file")) {
+                return { kind: "default" };
+            }
             const named = targets.length === 0 ? "no target" : targets.join(", ");
             const built = targets.some((target) => host.kindOf(joinPath(member.dir, target)) === "file");
             return {

package/dist/src/workspace.js

@@ -205,7 +205,7 @@ function memberDirectories(host, root, patterns) {
 /** Whether a workspace's patterns name one directory below its root, read without listing any. */
 function namesDirectory(root, patterns, dir) {
     const below = relativePath(root, dir);
-    if (below === undefined || below.startsWith("..")) {
+    if (below === undefined) {
         return false;
     }
     const path = below.split("/");

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.2.0-dev.3",
+  "version": "8.0.0-dev.1",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.2.0-dev.3",
+  "version": "8.0.0-dev.1",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -43,7 +43,7 @@
     "@types/node": "24.19.2",
     "eslint": "10.12.0",
     "fast-check": "4.10.2",
-    "prettier": "3.9.9",
+    "prettier": "3.9.10",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "typescript-eslint": "8.71.1",
     "vitest": "5.0.4"