@cplieger/deadset-ts 4.0.1 → 5.1.0

package/src/dependencies.ts

@@ -2,7 +2,8 @@
  * The dependencies the target's manifest declares, and what the projects' own files
  * need from outside the target. A file needs a package it imports, re-exports from,
  * augments or references the types of, by name or through the file the specifier
- * resolves to; a configuration needs one it names. A package one dependency pulls in
+ * resolves to; a compiler configuration needs one it names, and a configuration file a
+ * tool loads needs each dependency its strings spell. A package one dependency pulls in
  * for itself is that dependency's need, not the target's.
  */
 
@@ -21,6 +22,13 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/unstable/ast";
+import {
+  configurationFiles,
+  declaredIn as declaredBeside,
+  dependenciesNamed,
+  moduleStrings,
+  type ParseFile,
+} from "./configuration-files.ts";
 import type { FindingPosition } from "./finding.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, packageScope, type Inventory } from "./inventory.ts";
@@ -28,6 +36,7 @@ import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.ts";
 import type { DependencySection, Module } from "./ref.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
+import { sourceFilesOf } from "./source-files.ts";
 
 const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
@@ -268,12 +277,15 @@ function bindingsOf(node: Node | undefined): readonly Texted[] {
  * Every package one project needs, and which declaration each use is written in.
  * One local walk and one batched resolution per file: a use of an import binding is
  * an identifier resolving to the binding's own symbol, so a local declaration that
- * shadows the name is not one.
+ * shadows the name is not one. A string of a configuration file uses each dependency
+ * the manifest beside the file declares that it spells.
  */
 export function projectNeeds<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
   host: Host,
+  targetRoot: string,
+  parse?: ParseFile,
 ): ProjectNeeds {
   const programPackages = new Set<string>();
   for (const name of project.program.getSourceFileNames()) {
@@ -308,6 +320,41 @@ export function projectNeeds<Brand>(
   for (const file of project.ownSourceFiles()) {
     unanswered = fileNeeds(project, held, file, programPackages, use) || unanswered;
   }
+
+  const beside = new Map<string, readonly string[]>();
+  const declaredAt = (path: string): readonly string[] => {
+    const dir = dirnamePath(path);
+    let names = beside.get(dir);
+    if (names === undefined) {
+      names = declaredBeside(host, dir);
+      beside.set(dir, names);
+    }
+    return names;
+  };
+  const configuration = configurationFiles(
+    host,
+    targetRoot,
+    sourceFilesOf(project, targetRoot),
+    parse,
+  );
+  for (const { file } of configuration.modules) {
+    const names = declaredAt(file.fileName);
+    for (const { node, text } of moduleStrings(file)) {
+      use(ownersOf(file, held, node), dependenciesNamed(text, names));
+    }
+  }
+  for (const document of configuration.documents) {
+    const names = declaredAt(document.path);
+    for (const text of document.strings) {
+      use([PROJECT_OWNER], dependenciesNamed(text, names));
+    }
+  }
+  for (const { file, manifestDir } of configuration.outside) {
+    const names = declaredAt(joinPath(manifestDir, "package.json"));
+    for (const { text } of moduleStrings(file)) {
+      use([PROJECT_OWNER], dependenciesNamed(text, names));
+    }
+  }
   return { packages, uses, unanswered };
 }
 

package/src/destructuring.ts

@@ -25,7 +25,13 @@ import {
   type Node,
 } from "@typescript/native/unstable/ast";
 import { TypeFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/unstable/sync";
-import { isAnswered, UNANSWERED, type Answer } from "./query.ts";
+import {
+  isAnswered,
+  propertyTables,
+  UNANSWERED,
+  type Answer,
+  type PropertyTables,
+} from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** One property one object pattern reads. */
@@ -228,7 +234,11 @@ type Found = Answer<Type | undefined>;
  * read once per type for the whole project, since one type is destructured in many
  * places and a table answers every name of it.
  */
-export function destructuring<Brand>(project: ProjectView<Brand>, cap: number): Destructuring {
+export function destructuring<Brand>(
+  project: ProjectView<Brand>,
+  cap: number,
+  properties: PropertyTables = propertyTables(project.queries),
+): Destructuring {
   const queries = project.queries;
   const tables = new Map<number, Answer<ReadonlyMap<string, TSSymbol>>>();
   let patternBatches = 0;
@@ -241,10 +251,10 @@ export function destructuring<Brand>(project: ProjectView<Brand>, cap: number):
     }
     let table: Answer<ReadonlyMap<string, TSSymbol>> = new Map<string, TSSymbol>();
     if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
-      patternLookups += 1;
-      const properties = queries.propertiesOf(type);
-      table = isAnswered(properties)
-        ? new Map(properties.map((property) => [property.name, property]))
+      const read = properties.of(type);
+      patternLookups += read.asked ? 1 : 0;
+      table = isAnswered(read.properties)
+        ? new Map(read.properties.map((property) => [property.name, property]))
         : UNANSWERED;
     }
     tables.set(type.id, table);

package/src/discover.ts

@@ -4,6 +4,7 @@ import type { BuildConfiguration, ProjectConfiguration } from "./config.ts";
 import type { Host } from "./host.ts";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { Scope } from "./scope.ts";
+import { SetupError } from "./setup-failure.ts";
 import type { Engine, ProjectDiagnostics } from "./session.ts";
 
 /** Directory names discovery does not descend into. */
@@ -323,13 +324,16 @@ function derivedFrom(
  */
 export function consumerProjects(engine: Engine, host: Host, root: string): readonly string[] {
   const kind = host.kindOf(root);
+  if (kind === "absent") {
+    throw new SetupError([
+      {
+        setupClass: "missing-consumer",
+        detail: `the scope declares the consumer ${root}, and nothing is at that path: check the consumer out at ${root} and install its dependencies`,
+      },
+    ]);
+  }
   if (kind !== "directory") {
-    throw new DiscoveryError(
-      kind === "absent"
-        ? `the consumer ${root} does not exist`
-        : `the consumer ${root} is not a directory`,
-      [],
-    );
+    throw new DiscoveryError(`the consumer ${root} is not a directory`, []);
   }
   const found = derivedFrom(engine, host, configFilesUnder(host, root));
   if (found.length === 0) {

package/src/emit-map.ts

@@ -0,0 +1,93 @@
+/**
+ * Where the compiler writes what it compiles: the output extension each source
+ * extension becomes, and the output path one source path is written to. A path a
+ * manifest or a document names is read back to its source through this one rule,
+ * whether the path is the target's own or a workspace package's.
+ */
+
+import { dirnamePath, joinPath, relativePath } from "./paths.ts";
+
+/** The source extensions the compiler emits each output extension from. */
+const EMITTED: readonly { readonly emitted: string; readonly sources: readonly string[] }[] = [
+  { emitted: ".d.ts", sources: [".ts", ".tsx"] },
+  { emitted: ".d.mts", sources: [".mts"] },
+  { emitted: ".d.cts", sources: [".cts"] },
+  { emitted: ".js", sources: [".ts", ".tsx"] },
+  { emitted: ".jsx", sources: [".tsx"] },
+  { emitted: ".mjs", sources: [".mts"] },
+  { emitted: ".cjs", sources: [".cts"] },
+];
+
+/** Where one compiler configuration writes its output, and the directories it writes it from. */
+export interface EmitLayout {
+  /** The directory every output is written below, absolute. */
+  readonly outDir?: string | undefined;
+  /** The directory declaration outputs are written below where it differs, absolute. */
+  readonly declarationDir?: string | undefined;
+  /**
+   * The directories an output path below the output directory is read below, in the
+   * order they are tried: the one the configuration declares, or the ones the
+   * compiler's default may be.
+   */
+  readonly sourceDirs: readonly string[];
+}
+
+/** One path with its extension replaced, where it carries the one named. */
+function reExtended(path: string, emitted: string, source: string): string | undefined {
+  return path.endsWith(emitted) ? path.slice(0, path.length - emitted.length) + source : undefined;
+}
+
+/**
+ * The longest directory every path shares, which is where the compiler roots its
+ * output when the configuration declares no root directory and its directory is not
+ * the root.
+ */
+export function commonDirectory(paths: readonly string[]): string {
+  const first = paths[0];
+  if (first === undefined) {
+    return "";
+  }
+  let common = dirnamePath(first).split("/");
+  for (const path of paths.slice(1)) {
+    const segments = dirnamePath(path).split("/");
+    let shared = 0;
+    while (
+      shared < common.length &&
+      shared < segments.length &&
+      common[shared] === segments[shared]
+    ) {
+      shared += 1;
+    }
+    common = common.slice(0, shared);
+  }
+  return common.join("/");
+}
+
+/**
+ * The source paths one written path may be compiled from, in the order they are
+ * tried: for each output extension the path carries, the path re-extended where it
+ * stands, then read below each source directory where it is below the directory that
+ * output is written to.
+ */
+export function emittedFrom(path: string, layout: EmitLayout): readonly string[] {
+  const found: string[] = [];
+  for (const { emitted, sources } of EMITTED) {
+    if (!path.endsWith(emitted)) {
+      continue;
+    }
+    const emitDir = emitted.startsWith(".d.")
+      ? (layout.declarationDir ?? layout.outDir)
+      : layout.outDir;
+    const below = emitDir === undefined ? undefined : relativePath(emitDir, path);
+    const mapped = below === undefined ? [] : layout.sourceDirs.map((dir) => joinPath(dir, below));
+    for (const source of sources) {
+      for (const from of [path, ...mapped]) {
+        const candidate = reExtended(from, emitted, source);
+        if (candidate !== undefined) {
+          found.push(candidate);
+        }
+      }
+    }
+  }
+  return found;
+}

package/src/entry-point-gaps.ts

@@ -17,18 +17,23 @@ export interface DeclinedConvention {
   readonly reason: string;
 }
 
-/** What is declined for a tool none of whose conventions is entered. */
-const EVERY_CONVENTION = "its configuration and every file it loads by its own convention";
+/** 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 none of whose conventions is entered declines them. */
+/** Why a tool whose own conventions are not read declines them. */
 const UNREAD =
-  "No rule reads it, so a file only it loads is reported as never imported unless " +
-  "ts.entry_files or roots.patterns names it.";
+  "No rule reads it beyond a configuration file the file-name form or a string enters, so a " +
+  "file only it loads is reported as never imported unless ts.entry_files or roots.patterns " +
+  "names it.";
 
-/** The tools none of whose conventions is entered. */
+/** Why a configuration's file names that are not relative literals are declined. */
+const NOT_RELATIVE =
+  "A string of a configuration file names a file only where it is a literal starting with ./ " +
+  "or ../, so a file named otherwise is reported as never imported.";
+
+/** The tools whose own conventions are not read. */
 const UNREAD_TOOLS: readonly string[] = [
   "angular",
-  "astro",
   "astro-db",
   "astro-markdoc",
   "astro-og-canvas",
@@ -61,7 +66,6 @@ const UNREAD_TOOLS: readonly string[] = [
   "esbuild",
   "eve",
   "execa",
-  "expo",
   "expressive-code",
   "fast",
   "fumadocs",
@@ -98,7 +102,6 @@ const UNREAD_TOOLS: readonly string[] = [
   "nano-staged",
   "nest",
   "netlify",
-  "next",
   "next-intl",
   "next-mdx",
   "nitro",
@@ -106,7 +109,6 @@ const UNREAD_TOOLS: readonly string[] = [
   "node-modules-inspector",
   "nodemon",
   "npm-package-json-lint",
-  "nuxt",
   "nuxtjs-i18n",
   "nx",
   "nyc",
@@ -131,17 +133,14 @@ const UNREAD_TOOLS: readonly string[] = [
   "prettier",
   "prisma",
   "quasar",
-  "qwik",
   "railway",
   "raycast",
   "react-cosmos",
   "react-email",
   "react-native",
-  "react-router",
   "relay",
   "release-it",
   "remark",
-  "remix",
   "rolldown",
   "rollup",
   "rsbuild",
@@ -157,11 +156,9 @@ const UNREAD_TOOLS: readonly string[] = [
   "sst",
   "starlight",
   "stencil",
-  "storybook",
   "stylelint",
   "svelte",
   "sveltejs-package",
-  "sveltekit",
   "svgo",
   "svgr",
   "swc",
@@ -184,7 +181,6 @@ const UNREAD_TOOLS: readonly string[] = [
   "typescript-content-mapper",
   "unbuild",
   "unocss",
-  "unplugin-auto-import",
   "unplugin-icons",
   "unplugin-vue-components",
   "unplugin-vue-i18n",
@@ -215,10 +211,17 @@ const UNREAD_TOOLS: readonly string[] = [
 const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   {
     tool: "eslint",
-    convention: "the legacy .eslintrc configuration files",
+    convention: "a legacy configuration written in YAML or in JSON with comments",
+    reason:
+      "Only a configuration module and a strict JSON configuration file are read, so a " +
+      "dependency only such a file names is reported as unused.",
+  },
+  {
+    tool: "eslint",
+    convention: "a plugin or shareable configuration named without its package's prefix",
     reason:
-      "Only the flat configuration's file names are entered, so a legacy configuration " +
-      "file the program holds is reported as never imported.",
+      "A string uses a dependency only where it spells the dependency's name, so a " +
+      "dependency only a shortened name loads is reported as unused.",
   },
   {
     tool: "playwright",
@@ -229,9 +232,8 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   },
   {
     tool: "playwright",
-    convention: "the globalSetup and globalTeardown files",
-    reason:
-      "No rule enters them, so a setup file only the runner loads is reported as never imported.",
+    convention: "a globalSetup or globalTeardown file named without a leading ./ or ../",
+    reason: NOT_RELATIVE,
   },
   {
     tool: "playwright",
@@ -240,17 +242,73 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
       "Only the configuration object's own testDir and testMatch are read, so a test " +
       "directory a project entry moves is not entered.",
   },
+  {
+    tool: "expo",
+    convention: "an app directory the expo-router entry of an app configuration moves",
+    reason:
+      "The convention row reads the app directory at its default places only, so a route " +
+      "below a moved directory is reported as never imported unless ts.entry_files names it.",
+  },
+  {
+    tool: "next",
+    convention: "a page extension next.config adds through pageExtensions",
+    reason:
+      "The convention row roots the default extensions only, so a route file of another " +
+      "extension is reported as never imported unless ts.entry_files names it.",
+  },
+  {
+    tool: "nuxt",
+    convention: "the files of a layer below layers/ beyond its nuxt.config",
+    reason:
+      "The convention row reads the project's own directories, so a layer's pages, plugins " +
+      "and server routes are reported as never imported unless ts.entry_files names them.",
+  },
+  {
+    tool: "qwik",
+    convention: "the routes of @qwik.dev/router",
+    reason:
+      "No convention row holds for that package, so its route files are reported as " +
+      "never imported unless ts.entry_files names them.",
+  },
+  {
+    tool: "react-router",
+    convention: "a route module app/routes.ts names outside the routes directory",
+    reason:
+      "The convention row roots the routes directory, and a string of routes.ts names no " +
+      "file, so a route module elsewhere is reported as never imported unless " +
+      "ts.entry_files names it.",
+  },
+  {
+    tool: "storybook",
+    convention: "a story the stories member of .storybook/main names outside *.stories.* files",
+    reason:
+      "The convention row roots *.stories.* files, so a story file named otherwise is " +
+      "reported as never imported unless ts.entry_files names it.",
+  },
   {
     tool: "stryker",
-    convention: "a configuration file named on the command line",
-    reason: "Only the file names the tool looks for by default are entered.",
+    convention: "a configuration file named on a command line no package.json script writes",
+    reason:
+      "Only the file names the tool looks for by default and the files a script names are entered.",
+  },
+  {
+    tool: "unplugin-auto-import",
+    convention: "an import its generated declarations add for a component's template alone",
+    reason:
+      "Only a global declared as an alias of an export is read, so an export the generated " +
+      "declarations name only for templates is reported as unused.",
+  },
+  {
+    tool: "vite",
+    convention: "an entry point its configuration names without a leading ./ or ../, or computes",
+    reason: NOT_RELATIVE,
   },
   {
     tool: "vite",
-    convention: "its configuration and every entry point it names",
+    convention: "the module scripts an index.html loads",
     reason:
-      "Only a worker a call addresses by a literal is entered. No rule reads the " +
-      "configuration, so a file only it names is reported as never imported.",
+      "No rule reads an HTML file, so a script only index.html loads is reported as never " +
+      "imported unless ts.entry_files names it.",
   },
   {
     tool: "vitest",
@@ -261,17 +319,15 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   },
   {
     tool: "vitest",
-    convention: "the mock files below a __mocks__ directory",
+    convention: "the setup files of a configuration that moves its root",
     reason:
-      "No rule enters a file by its directory, so a mock only the runner's module mocking " +
-      "loads is reported as never imported.",
+      "A string is read against the configuration file's directory, so a setup file named " +
+      "against a root the configuration moves is not entered.",
   },
   {
     tool: "vitest",
-    convention: "the setup files of a configuration that moves its root",
-    reason:
-      "A configuration writing root reads its setup files against a directory its text " +
-      "may not state, so none of them is entered.",
+    convention: "a setup file named without a leading ./ or ../",
+    reason: NOT_RELATIVE,
   },
   {
     tool: "vitest",
@@ -282,10 +338,8 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   },
   {
     tool: "webpack",
-    convention: "its configuration and every entry point it names",
-    reason:
-      "Only a worker a call addresses by a literal is entered. No rule reads the " +
-      "configuration, so a file only it names is reported as never imported.",
+    convention: "an entry point its configuration names without a leading ./ or ../, or computes",
+    reason: NOT_RELATIVE,
   },
 ];