@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/src/entries/build-scripts.ts

@@ -0,0 +1,292 @@
+/**
+ * The files a bundler's JavaScript API builds from, read from the build scripts a
+ * manifest's scripts run: the strings an options object passes as the bundler's entries.
+ * A script is read without running it, so a value that is not written out, a computed
+ * path or an options object built at run time among them, names nothing.
+ */
+
+import {
+  isArrowFunction,
+  isCallExpression,
+  isConstructorDeclaration,
+  isFunctionDeclaration,
+  isFunctionExpression,
+  isGetAccessorDeclaration,
+  isIdentifier,
+  isMethodDeclaration,
+  isNewExpression,
+  isSetAccessorDeclaration,
+  isVariableDeclaration,
+  type CallExpression,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/ast";
+import { declarationOf, membersNamed, staticModule, type Value } from "./static-module.ts";
+import { filesNamedBy, type ParseFile } from "./configuration-files.ts";
+import type { Host } from "../host.ts";
+import { ancestors, dirnamePath, isExplicitPath, relativePath, resolvePath } from "../paths.ts";
+import type { SourceFiles } from "../source-files.ts";
+import { bytewise } from "../text/compare.ts";
+import { unwrapped } from "../unwrap.ts";
+import { holdsManifest, inInstalledPackages, manifestAt } from "../fs/manifest.ts";
+import { globExpression } from "../text/glob.ts";
+import { pathsNamed, readCommands } from "../commands/read.ts";
+import { manifestCommands } from "../roots/manifest.ts";
+import { extensionOf, MODULE_EXTENSIONS } from "../extensions.ts";
+
+/** One bundler API: the module, the functions it exports that build, and the option naming entries. */
+interface BundlerAPI {
+  readonly module: string;
+  /** The exported names of the building functions; `default` is the module's own value called. */
+  readonly calls: readonly string[];
+  /** The option whose strings name the entries, read as `entries` states. */
+  readonly option: string;
+  /** The option that moves the directory the entries are read against. */
+  readonly base: string;
+  /** Whether an entry string is a path, glob characters matching, or a module request, only a relative one naming a file. */
+  readonly paths: boolean;
+}
+
+/**
+ * The bundlers whose build call names its entries: esbuild resolves `entryPoints` against
+ * `absWorkingDir` (https://esbuild.github.io/api/#working-directory), webpack `entry`
+ * against `context` (https://webpack.js.org/configuration/entry-context/), and Rollup
+ * `input` against the working directory, each the manifest's directory when its script runs.
+ */
+const BUNDLERS: readonly BundlerAPI[] = [
+  {
+    module: "esbuild",
+    calls: ["build", "buildSync", "context"],
+    option: "entryPoints",
+    base: "absWorkingDir",
+    paths: true,
+  },
+  { module: "webpack", calls: ["default"], option: "entry", base: "context", paths: false },
+  { module: "rollup", calls: ["rollup", "watch"], option: "input", base: "", paths: true },
+];
+
+/** One own file a build script's bundler call names as an entry. */
+interface BuildEntry {
+  readonly file: SourceFile;
+  /** The string that named it. */
+  readonly source: string;
+}
+
+/** One path an entry value writes. */
+interface EntryPath {
+  readonly path: string;
+  /** What the script writes for it. */
+  readonly text: string;
+  /** Whether it is written as neither a relative nor an absolute path. */
+  readonly request: boolean;
+}
+
+/** The one value an object writes last for a key, undefined where it writes none or may hide it. */
+function lastMember(object: Value, key: string): Value | undefined {
+  return membersNamed(object, key)?.at(-1);
+}
+
+/**
+ * The path one entry value writes, read against `dir`: a literal, or a join of the
+ * script's own directory and literals, read against that directory.
+ */
+function pathOf(value: Value, dir: string, scriptDir: string): EntryPath | undefined {
+  if (value.kind === "text") {
+    const { text } = value;
+    const request = !isExplicitPath(text);
+    return { path: resolvePath(dir, text), text, request };
+  }
+  if (value.kind === "directory") {
+    const joined = value.segments.join("/");
+    return { path: resolvePath(scriptDir, joined), text: joined, request: false };
+  }
+  return undefined;
+}
+
+/** The entry values one entries option writes: a value, an array of them, an object of them. */
+function entryValues(value: Value): readonly Value[] {
+  if (value.kind === "array") {
+    return value.elements.flatMap(entryValues);
+  }
+  if (value.kind === "object") {
+    const imported = lastMember(value, "import") ?? lastMember(value, "in");
+    if (imported !== undefined) {
+      return entryValues(imported);
+    }
+    return value.members.flatMap((member) => entryValues(member.value));
+  }
+  return [value];
+}
+
+/** The own files one entry string names, read as `api` reads it. */
+function entriesNamed(
+  files: SourceFiles,
+  api: BundlerAPI,
+  entry: EntryPath,
+): readonly SourceFile[] {
+  if (!api.paths && entry.request) {
+    return [];
+  }
+  if (api.paths && /[*?[{]/u.test(entry.text)) {
+    const expression = globExpression(entry.path);
+    return [...files.byName.values()].filter((file) => expression.test(file.fileName));
+  }
+  const dir = dirnamePath(entry.path);
+  return filesNamedBy(files, dir, entry.path.slice(dir.length + 1));
+}
+
+/** Whether one node is a function, whose body runs only where something calls it. */
+function isFunction(node: Node): boolean {
+  return (
+    isFunctionDeclaration(node) ||
+    isFunctionExpression(node) ||
+    isArrowFunction(node) ||
+    isMethodDeclaration(node) ||
+    isConstructorDeclaration(node) ||
+    isGetAccessorDeclaration(node) ||
+    isSetAccessorDeclaration(node)
+  );
+}
+
+/**
+ * The calls one build script runs: those of its top level, and those of each function a
+ * call it runs calls or passes on, as a callee, an argument or a function called where it
+ * is written, a name read through to the function it declares.
+ */
+function runCalls(file: SourceFile, each: (call: CallExpression) => void): void {
+  const ran = new Set<Node>();
+  const run = (fn: Node): void => {
+    if (!ran.has(fn)) {
+      ran.add(fn);
+      fn.forEachChild(visit);
+    }
+  };
+  const runs = (node: Node): void => {
+    const at = unwrapped(node);
+    const declared = isIdentifier(at) ? declarationOf(at) : undefined;
+    const fn =
+      declared !== undefined && isVariableDeclaration(declared) && declared.initializer
+        ? unwrapped(declared.initializer)
+        : (declared ?? at);
+    if (isFunction(fn)) {
+      run(fn);
+    }
+  };
+  const visit = (node: Node): void => {
+    if (isFunction(node)) {
+      return;
+    }
+    if (isCallExpression(node) || isNewExpression(node)) {
+      if (isCallExpression(node)) {
+        each(node);
+      }
+      runs(node.expression);
+      for (const argument of node.arguments ?? []) {
+        runs(argument);
+      }
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+}
+
+/** The entries every bundler call one build script runs names, read against `dir`. */
+function scriptEntries(file: SourceFile, dir: string, files: SourceFiles): readonly BuildEntry[] {
+  const module = staticModule(file);
+  const building = new Map<CallExpression, BundlerAPI>();
+  for (const api of BUNDLERS) {
+    for (const one of module.calls(api.module)) {
+      if (api.calls.includes(one.export)) {
+        building.set(one.call, api);
+      }
+    }
+  }
+  const scriptDir = dirnamePath(file.fileName);
+  const found: BuildEntry[] = [];
+  runCalls(file, (call) => {
+    const api = building.get(call);
+    if (api === undefined) {
+      return;
+    }
+    for (const options of module.argument(call)) {
+      const entries = lastMember(options, api.option);
+      const base = api.base === "" ? undefined : lastMember(options, api.base);
+      const against = base === undefined ? { path: dir } : pathOf(base, dir, scriptDir);
+      if (entries === undefined || against === undefined) {
+        continue;
+      }
+      for (const value of entryValues(entries)) {
+        const named = pathOf(value, against.path, scriptDir);
+        if (named === undefined) {
+          continue;
+        }
+        for (const entry of entriesNamed(files, api, named)) {
+          found.push({ file: entry, source: named.text });
+        }
+      }
+    }
+  });
+  return found;
+}
+
+/** The modules one manifest's command strings run or name, by absolute path, each below the target root. */
+function scriptModules(host: Host, root: string, dir: string): readonly string[] {
+  const manifest = manifestAt(host, dir);
+  const found = new Set<string>();
+  for (const { command } of manifest === undefined ? [] : manifestCommands(host, dir, manifest)) {
+    for (const { path } of pathsNamed(readCommands(command, dir))) {
+      if (
+        extensionOf(path, MODULE_EXTENSIONS) !== undefined &&
+        relativePath(root, path) !== undefined &&
+        !inInstalledPackages(path) &&
+        host.kindOf(path) === "file"
+      ) {
+        found.add(path);
+      }
+    }
+  }
+  return [...found].sort(bytewise);
+}
+
+/**
+ * Every own file of one project a build script names as a bundler's entry: a module a
+ * script of a manifest at or above an own file runs, below the target root, read from
+ * the program where it holds the module and parsed alone otherwise, where a parser is given.
+ */
+export function buildScriptEntries(
+  host: Host,
+  targetRoot: string,
+  files: SourceFiles,
+  parse: ParseFile | undefined,
+): readonly BuildEntry[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  const dirs = new Set<string>([root]);
+  for (const file of files.byName.values()) {
+    for (const dir of ancestors(dirnamePath(file.fileName), root)) {
+      if (dirs.has(dir)) {
+        break;
+      }
+      dirs.add(dir);
+    }
+  }
+  const found: BuildEntry[] = [];
+  for (const dir of [...dirs].sort(bytewise)) {
+    if (!holdsManifest(host, dir)) {
+      continue;
+    }
+    for (const path of scriptModules(host, root, dir)) {
+      let script = files.byName.get(path);
+      if (script === undefined && parse !== undefined) {
+        try {
+          script = parse(path, host.readFile(path));
+        } catch {
+          continue;
+        }
+      }
+      if (script !== undefined) {
+        found.push(...scriptEntries(script, dir, files));
+      }
+    }
+  }
+  return found;
+}

package/src/{configuration-files.ts → entries/configuration-files.ts}

@@ -8,37 +8,48 @@
  */
 
 import {
-  isCallExpression,
-  isExportDeclaration,
-  isIdentifier,
-  isImportDeclaration,
   isNoSubstitutionTemplateLiteral,
   isStringLiteral,
-  SyntaxKind,
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
-import type { Host } from "./host.ts";
-import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
-import type { SourceFiles } from "./source-files.ts";
-import { bytewise } from "./text/compare.ts";
-import { isRecord } from "./json-document.ts";
-import { filesIn } from "./fs/tree.ts";
+import { relativeSpecifiers } from "./static-module.ts";
+import type { Host } from "../host.ts";
+import {
+  ancestors,
+  dirnamePath,
+  isAbsolutePath,
+  joinPath,
+  relativePath,
+  resolvePath,
+  startsRelativePath,
+} from "../paths.ts";
+import type { SourceFiles } from "../source-files.ts";
+import { bytewise } from "../text/compare.ts";
+import { isRecord } from "../json-document.ts";
+import { filesIn } from "../fs/tree.ts";
 import {
   DEPENDENCY_SECTIONS,
   holdsManifest,
   inInstalledPackages,
   manifestAt,
   readJSON,
-} from "./fs/manifest.ts";
-import { readCommands } from "./commands/read.ts";
-import { manifestCommands } from "./manifest.ts";
+} from "../fs/manifest.ts";
+import { readCommands } from "../commands/read.ts";
+import { manifestCommands } from "../roots/manifest.ts";
+import { APPENDED_EXTENSIONS, extensionOf, MODULE_EXTENSIONS } from "../extensions.ts";
+
+/** The extensions of a configuration module, as an expression's alternatives. */
+const MODULE_NAME = MODULE_EXTENSIONS.map((one) => one.slice(1)).join("|");
 
 /** A configuration module's name, each form with the spelling a root reports it by. */
 const MODULE_FORMS: readonly { readonly name: RegExp; readonly form: string }[] = [
-  { name: /^[\w-]+\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u, form: "<stem>.config.<ext>" },
   {
-    name: /^[\w-]+\.[\w-]+\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u,
+    name: new RegExp(String.raw`^[\w-]+\.config\.(?:${MODULE_NAME})$`, "u"),
+    form: "<stem>.config.<ext>",
+  },
+  {
+    name: new RegExp(String.raw`^[\w-]+\.[\w-]+\.config\.(?:${MODULE_NAME})$`, "u"),
     form: "<stem>.<qualifier>.config.<ext>",
   },
   { name: /^\.[\w-]+rc\.(?:js|mjs|cjs)$/u, form: ".<stem>rc.<ext>" },
@@ -47,9 +58,6 @@ const MODULE_FORMS: readonly { readonly name: RegExp; readonly form: string }[]
 /** A JSON configuration file's name. */
 const DOCUMENT_NAME = /^(?:[\w-]+(?:\.[\w-]+)?\.config\.json|\.[\w-]+rc(?:\.json)?)$/u;
 
-/** The prefixes a string names a file with, relative to the file that writes it. */
-const RELATIVE_PREFIXES = ["./", "../"] as const;
-
 /** The JavaScript extensions a relative specifier from a configuration file stands for TypeScript under. */
 const COUNTERPARTS: readonly (readonly [string, readonly string[]])[] = [
   [".js", [".ts", ".tsx"]],
@@ -58,9 +66,6 @@ const COUNTERPARTS: readonly (readonly [string, readonly string[]])[] = [
   [".cjs", [".cts"]],
 ];
 
-/** The extensions appended to a relative specifier from a configuration file, in order. */
-const APPENDED = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"] as const;
-
 /** The extensions the program's module resolution appends to a specifier written without one. */
 export const RESOLVED_EXTENSIONS = [
   ".ts",
@@ -116,9 +121,6 @@ export interface OutsideModule {
   readonly manifestDirs: readonly string[];
 }
 
-/** The extensions of a module a configuration flag may name. */
-const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"] as const;
-
 /**
  * The files the command strings of the manifest in one directory name after a configuration
  * flag, as `commands/read.ts` reads them against the directory each command runs in, each a
@@ -143,7 +145,7 @@ function scriptConfigurations(host: Host, root: string, dir: string): readonly s
 }
 
 /** The configuration files one project holds and sits beside. */
-interface ConfigurationFiles {
+export interface ConfigurationFiles {
   /**
    * Every own file that is a configuration module, with the form its name has and the
    * directory of the manifest whose dependencies its strings are read against.
@@ -273,9 +275,7 @@ export function configurationFiles(
     }
     document.manifestDirs.push(next.manifestDir);
     for (const text of document.strings) {
-      const path = RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix))
-        ? resolvePath(dirnamePath(next.path), text)
-        : undefined;
+      const path = startsRelativePath(text) ? resolvePath(dirnamePath(next.path), text) : undefined;
       if (
         path?.endsWith(".json") === true &&
         isProjectPath(root, path) &&
@@ -295,55 +295,6 @@ export function configurationFiles(
   };
 }
 
-/** The literal module specifier one `require(...)` or `import(...)` call names, if any. */
-function calledSpecifier(node: Node): Node | undefined {
-  if (!isCallExpression(node) || node.arguments.length !== 1) {
-    return undefined;
-  }
-  const callee = node.expression;
-  const loads =
-    callee.kind === SyntaxKind.ImportKeyword || (isIdentifier(callee) && callee.text === "require");
-  return loads ? node.arguments[0] : undefined;
-}
-
-/**
- * The relative specifiers one file's imports and re-exports name, and those its
- * `require(...)` and `import(...)` calls name by a literal.
- */
-export function relativeSpecifiers(file: SourceFile): readonly string[] {
-  const known = specifiersOf.get(file);
-  if (known !== undefined) {
-    return known;
-  }
-  const found: string[] = [];
-  const named = (specifier: Node | undefined): void => {
-    if (
-      specifier !== undefined &&
-      (isStringLiteral(specifier) || isNoSubstitutionTemplateLiteral(specifier)) &&
-      RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))
-    ) {
-      found.push(specifier.text);
-    }
-  };
-  const visit = (node: Node): void => {
-    named(calledSpecifier(node));
-    node.forEachChild(visit);
-  };
-  for (const statement of file.statements) {
-    named(
-      isImportDeclaration(statement) || isExportDeclaration(statement)
-        ? statement.moduleSpecifier
-        : undefined,
-    );
-    visit(statement);
-  }
-  specifiersOf.set(file, found);
-  return found;
-}
-
-/** What {@link relativeSpecifiers} found in each file, which every project of a run reads alike. */
-const specifiersOf = new WeakMap<SourceFile, readonly string[]>();
-
 /**
  * The files no program holds that a chain from `seeds` reads: each seed, and each file
  * below the target root one imports, re-exports or loads by a relative specifier that no
@@ -371,7 +322,7 @@ export function outsideChain(
 export function specifierCandidates(dir: string, specifier: string): readonly string[] {
   const path = resolvePath(dir, specifier);
   const candidates: string[] = [];
-  if (APPENDED.some((extension) => path.endsWith(extension))) {
+  if (extensionOf(path, APPENDED_EXTENSIONS) !== undefined) {
     candidates.push(path);
   }
   for (const [extension, counterparts] of COUNTERPARTS) {
@@ -380,8 +331,8 @@ export function specifierCandidates(dir: string, specifier: string): readonly st
       candidates.push(...counterparts.map((one) => stem + one));
     }
   }
-  candidates.push(...APPENDED.map((extension) => path + extension));
-  candidates.push(...APPENDED.map((extension) => joinPath(path, `index${extension}`)));
+  candidates.push(...APPENDED_EXTENSIONS.map((extension) => path + extension));
+  candidates.push(...APPENDED_EXTENSIONS.map((extension) => joinPath(path, `index${extension}`)));
   return candidates;
 }
 
@@ -477,7 +428,7 @@ export function dependenciesNamed(text: string, declared: readonly string[]): re
  * none.
  */
 export function filesNamedBy(files: SourceFiles, dir: string, text: string): readonly SourceFile[] {
-  if (text === "" || text.startsWith("/") || /[*?[{]/u.test(text)) {
+  if (text === "" || isAbsolutePath(text) || /[*?[{]/u.test(text)) {
     return [];
   }
   const path = resolvePath(dir, text);