@cplieger/deadset-ts 4.0.1 → 5.1.0

package/dist/src/workspace-run.js

@@ -0,0 +1,75 @@
+/**
+ * What one run reads of the workspace its target sits in: the programs that read
+ * member imports from source, the configurations whose member imports have no source,
+ * 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 { memberEntries, targetManifestIn } from "./workspace-manifests.js";
+import { workspacePrograms, } from "./workspace-programs.js";
+import { workspaceResolver } from "./workspace-resolution.js";
+function layoutOf(engine, configFile) {
+    try {
+        const parsed = engine.parseConfigFile(configFile);
+        return {
+            fileNames: parsed.fileNames,
+            outDir: parsed.options.outDir,
+            declarationDir: parsed.options.declarationDir,
+            rootDir: parsed.options.rootDir,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The setup failure one configuration's unresolved member imports state, with the fix.
+ * An import in a file the configuration holds only for its references is that file's
+ * own configuration's to answer for, like any other error there.
+ */
+function unbuildableReason(reading, referenceOnly, targetRoot) {
+    const own = reading.unresolved.filter((one) => !referenceOnly(one.file));
+    const [first] = own;
+    if (first === undefined) {
+        return undefined;
+    }
+    const where = relativePath(targetRoot, first.file) ?? first.file;
+    const more = own.length > 1 ? ` (and ${String(own.length - 1)} more)` : "";
+    return `${where} imports ${first.specifier}, a package of the workspace with no source to read: ${first.reason}${more}`;
+}
+/**
+ * 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));
+    if (workspace === undefined) {
+        return undefined;
+    }
+    const resolver = workspaceResolver(host, workspace);
+    const read = workspacePrograms(engine, host, configFiles, 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 {
+        programs: read.programs,
+        componentsUnread: read.readings.flatMap(({ configFile, componentsUnread }) => componentsUnread === undefined ? [] : [{ configFile, reason: componentsUnread }]),
+        unbuildable: (configFile) => {
+            const reading = readings.get(configFile);
+            return reading === undefined
+                ? undefined
+                : unbuildableReason(reading, referenceOnly(configFile), targetRoot);
+        },
+        referenceOnly,
+        ownFile: (file, fromExternalLibrary) => workspace.memberOf(file) !== undefined
+            ? relativePath(targetRoot, file) !== undefined
+            : !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. */
+export function ownErrors(errors, referenceOnly) {
+    return errors.filter(({ diagnostic }) => diagnostic.fileName === undefined || !referenceOnly(diagnostic.fileName));
+}

package/dist/src/workspace.js

@@ -0,0 +1,358 @@
+/**
+ * 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`.
+ */
+import { DiscoveryError } from "./discover.js";
+import { commonDirectory } from "./emit-map.js";
+import { dirnamePath, joinPath, relativePath } from "./paths.js";
+import { pnpmPackages } from "./pnpm-workspace.js";
+const MANIFEST = "package.json";
+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`, []);
+        }
+        return { file: pnpm, patterns: read.kind === "listed" ? read.patterns : [] };
+    }
+    const manifest = manifestAt(host, dir);
+    if (manifest === undefined || !Object.hasOwn(manifest, "workspaces")) {
+        return undefined;
+    }
+    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`, []);
+    }
+    return { file: joinPath(dir, MANIFEST), patterns: list };
+}
+/** Whether one directory declares a workspace of its own. */
+function declaresWorkspace(host, dir) {
+    if (host.kindOf(joinPath(dir, PNPM_WORKSPACE)) === "file") {
+        return true;
+    }
+    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.
+ */
+function segmentsOf(pattern) {
+    const segments = [];
+    for (const segment of pattern.split("/")) {
+        if (segment === "" || segment === ".") {
+            continue;
+        }
+        if (segment === "..") {
+            if (segments.pop() === undefined) {
+                return undefined;
+            }
+            continue;
+        }
+        segments.push(segment);
+    }
+    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
+ * workspace's to declare.
+ */
+function expand(host, dir, pattern, into) {
+    const [head, ...rest] = pattern;
+    if (head === undefined) {
+        into.add(dir);
+        return;
+    }
+    if (head === "**") {
+        expand(host, dir, rest, into);
+        for (const name of subdirectories(host, dir)) {
+            if (name.startsWith(".")) {
+                continue;
+            }
+            const child = joinPath(dir, name);
+            expand(host, child, declaresWorkspace(host, child) ? rest : pattern, into);
+        }
+        return;
+    }
+    if (!head.includes("*") && !head.includes("?")) {
+        const child = joinPath(dir, head);
+        if (head !== "node_modules" && host.kindOf(child) === "directory") {
+            expand(host, child, rest, into);
+        }
+        return;
+    }
+    for (const name of subdirectories(host, dir)) {
+        if (segmentMatches(head, name)) {
+            expand(host, joinPath(dir, name), rest, into);
+        }
+    }
+}
+/** The directories a workspace's patterns name, every `!` pattern applied after the rest. */
+function memberDirectories(host, root, patterns) {
+    const included = new Set([root]);
+    const excluded = [];
+    for (const written of patterns) {
+        const negated = written.startsWith("!");
+        for (const pattern of braceExpanded(negated ? written.slice(1) : written)) {
+            const segments = segmentsOf(pattern);
+            if (segments === undefined) {
+                continue;
+            }
+            if (negated) {
+                excluded.push(segments);
+            }
+            else {
+                expand(host, root, segments, included);
+            }
+        }
+    }
+    return [...included].filter((dir) => {
+        const below = relativePath(root, dir);
+        const segments = below === undefined || below === "." || below === "" ? [] : below.split("/");
+        return dir === root || !excluded.some((pattern) => pathMatches(pattern, segments));
+    });
+}
+/** 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 === "" || below.startsWith("..")) {
+        return false;
+    }
+    const path = below.split("/");
+    if (path.includes("node_modules")) {
+        return false;
+    }
+    let named = false;
+    for (const written of patterns) {
+        const negated = written.startsWith("!");
+        const matched = braceExpanded(negated ? written.slice(1) : written).some((pattern) => {
+            const segments = segmentsOf(pattern);
+            return segments !== undefined && pathMatches(segments, path);
+        });
+        if (matched && negated) {
+            return false;
+        }
+        named ||= matched;
+    }
+    return named;
+}
+/** The layout one parsed configuration writes with, where it writes any output. */
+function layoutOf(configFile, parsed) {
+    if (parsed.outDir === undefined && parsed.declarationDir === undefined) {
+        return undefined;
+    }
+    const inputs = parsed.fileNames.filter((file) => !/\.d\.[mc]?ts$/u.test(file));
+    const sourceDirs = parsed.rootDir === undefined
+        ? [...new Set([dirnamePath(configFile), commonDirectory(inputs)])].filter((dir) => dir !== "")
+        : [parsed.rootDir];
+    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) => {
+        const configFile = joinPath(dir, name);
+        const parsed = parse(configFile);
+        return parsed === undefined
+            ? []
+            : [
+                {
+                    configFile,
+                    fileNames: new Set(parsed.fileNames),
+                    layout: layoutOf(configFile, parsed),
+                },
+            ];
+    });
+}
+/**
+ * The directory declaring the workspace nearest the target root, its patterns, and the
+ * highest directory below it, at or above the target root, that holds a manifest.
+ */
+function nearestDeclaration(host, targetRoot) {
+    let dir = targetRoot;
+    let highestPackage;
+    for (;;) {
+        const declared = declarationAt(host, dir);
+        if (declared !== undefined) {
+            return { root: dir, ...declared, highestPackage };
+        }
+        if (host.kindOf(joinPath(dir, MANIFEST)) === "file") {
+            highestPackage = dir;
+        }
+        const up = dirnamePath(dir);
+        if (up === dir || host.kindOf(joinPath(dir, ".git")) !== "absent") {
+            return undefined;
+        }
+        dir = up;
+    }
+}
+/**
+ * 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.
+ */
+export function findWorkspace(host, targetRoot, parse) {
+    const declared = nearestDeclaration(host, targetRoot);
+    if (declared === undefined) {
+        return undefined;
+    }
+    if (declared.highestPackage !== undefined &&
+        !namesDirectory(declared.root, declared.patterns, declared.highestPackage)) {
+        return undefined;
+    }
+    const members = [];
+    for (const dir of memberDirectories(host, declared.root, declared.patterns)) {
+        const manifest = manifestAt(host, dir);
+        const name = manifest?.["name"];
+        if (manifest === undefined || typeof name !== "string" || name === "") {
+            continue;
+        }
+        const version = manifest["version"];
+        members.push({
+            name,
+            dir,
+            version: typeof version === "string" ? version : undefined,
+            private: manifest["private"] === true,
+            manifest,
+            configurations: configurationsOf(host, dir, 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);
+    const named = new Map();
+    for (const member of members) {
+        named.set(member.name, [...(named.get(member.name) ?? []), member]);
+    }
+    const byDir = new Map(members.map((member) => [member.dir, member]));
+    const scopes = new Map();
+    const scopeOf = (dir) => {
+        if (scopes.has(dir)) {
+            return scopes.get(dir);
+        }
+        const up = dirnamePath(dir);
+        const found = host.kindOf(joinPath(dir, MANIFEST)) === "file" ? dir : up === dir ? undefined : scopeOf(up);
+        scopes.set(dir, found);
+        return found;
+    };
+    return {
+        root: declared.root,
+        declaredIn: declared.file,
+        members,
+        named,
+        memberOf: (path) => {
+            const scope = scopeOf(dirnamePath(path));
+            return scope === undefined ? undefined : byDir.get(scope);
+        },
+    };
+}
+/**
+ * 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
+ * compile it itself. `compiles` is the configuration's own file list.
+ */
+export function referenceOnlyIn(workspace, compiles) {
+    return (file) => !compiles.has(file) && workspace.memberOf(file) !== undefined;
+}

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "4.0.1",
+  "version": "5.1.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -23,6 +23,7 @@
     "typecheck": "tsc -p tsconfig.json",
     "typecheck:tests": "tsc -p tsconfig.test.json",
     "test": "vitest --run",
+    "test:starters": "vitest --run --config starters/vitest.config.ts",
     "lint": "eslint .",
     "lint:prettier": "prettier --check .",
     "lint:fix": "eslint . --fix && prettier --write ."
@@ -32,7 +33,7 @@
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
-    "@types/node": "24.19.0",
+    "@types/node": "24.19.1",
     "eslint": "10.11.0",
     "fast-check": "4.10.2",
     "prettier": "3.9.9",