@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/src/{html-entries.ts → entries/html-entries.ts}

@@ -11,9 +11,19 @@ import {
   type SourceFile,
 } from "@typescript/native/ast";
 import { resolveRelativeSpecifier, type ParseFile } from "./configuration-files.ts";
-import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
-import type { SourceFiles } from "./source-files.ts";
+import type { Host } from "../host.ts";
+import {
+  ancestors,
+  dirnamePath,
+  hasURLScheme,
+  isAbsolutePath,
+  isExplicitPath,
+  joinPath,
+  resolvePath,
+} from "../paths.ts";
+import type { SourceFiles } from "../source-files.ts";
+import { filesBelow } from "../fs/tree.ts";
+import { holdsManifest } from "../fs/manifest.ts";
 
 /** One file a script loads, and the value or specifier that named it. */
 interface HTMLEntry {
@@ -21,9 +31,6 @@ interface HTMLEntry {
   readonly source: string;
 }
 
-/** The directory no HTML file is read below. */
-const SKIPPED = "node_modules";
-
 /** A `<script` start tag, its attribute text captured. */
 const SCRIPT_TAG = /<script(?=[\s>/])([^>]*)>/giu;
 
@@ -33,37 +40,9 @@ const SCRIPT_END = /<\/script\s*>/iu;
 /** One attribute: a name, then a double-quoted, single-quoted or unquoted value. */
 const ATTRIBUTE = /([^\s"'=<>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/gu;
 
-/** A value that names a resource on another origin, or by another scheme. */
-const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
-
 /** The `type` values a classic script carries, compared in lowercase. */
 const CLASSIC_TYPES: ReadonlySet<string> = new Set(["text/javascript", "application/javascript"]);
 
-/** The prefixes an inline script's specifier names a file of the target with. */
-const FILE_PREFIXES = ["/", "./", "../"] as const;
-
-/** Every HTML file below `dir`, outside every `node_modules` directory, by absolute path. */
-function htmlFiles(host: Host, dir: string): readonly string[] {
-  let entries;
-  try {
-    entries = host.readDirectory(dir);
-  } catch {
-    return [];
-  }
-  const found: string[] = [];
-  for (const entry of entries) {
-    const path = joinPath(dir, entry.name);
-    if (entry.directory) {
-      if (entry.name !== SKIPPED) {
-        found.push(...htmlFiles(host, path));
-      }
-    } else if (entry.name.endsWith(".html")) {
-      found.push(path);
-    }
-  }
-  return found.sort();
-}
-
 /** Each attribute of one start tag's attribute text, by its lowercase name. */
 function attributes(text: string): ReadonlyMap<string, string> {
   const found = new Map<string, string>();
@@ -117,9 +96,7 @@ function scriptValues(parse: ParseFile | undefined, path: string, text: string):
     const end = rest.search(SCRIPT_END);
     const content = end === -1 ? rest : rest.slice(0, end);
     values.push(
-      ...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter((specifier) =>
-        FILE_PREFIXES.some((prefix) => specifier.startsWith(prefix)),
-      ),
+      ...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter(isExplicitPath),
     );
   }
   return values;
@@ -127,12 +104,7 @@ function scriptValues(parse: ParseFile | undefined, path: string, text: string):
 
 /** The directory of the nearest `package.json` at or above `dir`, inside `root`, else `root`. */
 function manifestDirectory(host: Host, root: string, dir: string): string {
-  for (let at = dir; relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-    if (host.kindOf(joinPath(at, "package.json")) === "file") {
-      return at;
-    }
-  }
-  return root;
+  return ancestors(dir, root).find((at) => holdsManifest(host, at)) ?? root;
 }
 
 /**
@@ -150,7 +122,8 @@ export function htmlEntries(
 ): readonly HTMLEntry[] {
   const root = resolvePath(host.workingDirectory(), targetRoot);
   const found: HTMLEntry[] = [];
-  for (const path of htmlFiles(host, root)) {
+  for (const below of filesBelow(host, root, (name) => name.endsWith(".html"))) {
+    const path = joinPath(root, below);
     let text: string;
     try {
       text = host.readFile(path);
@@ -159,18 +132,19 @@ export function htmlEntries(
     }
     const dir = dirnamePath(path);
     for (const value of scriptValues(parse, path, text)) {
-      if (ELSEWHERE.test(value)) {
+      // A value with a scheme, or one starting `//`, names a resource on another origin.
+      if (value.startsWith("//") || hasURLScheme(value)) {
         continue;
       }
-      const base = value.startsWith("/") ? manifestDirectory(host, root, dir) : dir;
-      const relative = value.startsWith("/") ? `.${value}` : value;
+      const base = isAbsolutePath(value) ? manifestDirectory(host, root, dir) : dir;
+      const relative = isAbsolutePath(value) ? `.${value}` : value;
       const reached = resolveRelativeSpecifier(host, base, relative);
       const file = reached === undefined ? undefined : files.byName.get(reached);
       if (file !== undefined) {
         found.push({ file, source: value });
         continue;
       }
-      const served = value.startsWith("/")
+      const served = isAbsolutePath(value)
         ? files.outputDirs.filter((outDir) => outDir === dir)
         : [];
       const emitting = [base, ...served].flatMap((against) =>

package/src/{mdx-entries.ts → entries/mdx-entries.ts}

@@ -6,9 +6,10 @@
 
 import type { SourceFile } from "@typescript/native/ast";
 import { resolveRelativeSpecifier } from "./configuration-files.ts";
-import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, resolvePath } from "./paths.ts";
-import type { SourceFiles } from "./source-files.ts";
+import type { Host } from "../host.ts";
+import { dirnamePath, joinPath, resolvePath, startsRelativePath } from "../paths.ts";
+import type { SourceFiles } from "../source-files.ts";
+import { filesBelow } from "../fs/tree.ts";
 
 /** One file a document imports, the specifier that named it, and the export names it reads. */
 interface DocumentEntry {
@@ -18,9 +19,6 @@ interface DocumentEntry {
   readonly names: readonly string[] | undefined;
 }
 
-/** The directories no document is read below. */
-const SKIPPED: ReadonlySet<string> = new Set(["node_modules", ".git"]);
-
 /** The extensions of a document whose imports an MDX compiler reads. */
 const DOCUMENT = /\.mdx?$/u;
 
@@ -129,28 +127,6 @@ function clauseNames(clause: string): readonly string[] | undefined {
   return names;
 }
 
-/** Every document below `dir`, outside every skipped directory, by absolute path. */
-function documents(host: Host, dir: string): readonly string[] {
-  let entries;
-  try {
-    entries = host.readDirectory(dir);
-  } catch {
-    return [];
-  }
-  const found: string[] = [];
-  for (const entry of entries) {
-    const path = joinPath(dir, entry.name);
-    if (entry.directory) {
-      if (!SKIPPED.has(entry.name)) {
-        found.push(...documents(host, path));
-      }
-    } else if (DOCUMENT.test(entry.name)) {
-      found.push(path);
-    }
-  }
-  return found.sort();
-}
-
 /** The relative specifiers one document's import lines name, its fenced code blocks skipped. */
 function importedBy(
   text: string,
@@ -178,7 +154,7 @@ function importedBy(
     }
     const matched = open === undefined ? IMPORT_LINE.exec(line) : null;
     const specifier = matched?.[2];
-    if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+    if (specifier !== undefined && startsRelativePath(specifier)) {
       found.push({ specifier, names: clauseNames(matched?.[1] ?? "") });
     }
   }
@@ -205,7 +181,8 @@ function documentImports(host: Host, root: string): readonly DocumentImports[] {
   if (known !== undefined) {
     return known;
   }
-  const found = documents(host, root).flatMap((path) => {
+  const found = filesBelow(host, root, (name) => DOCUMENT.test(name)).flatMap((below) => {
+    const path = joinPath(root, below);
     try {
       return [{ path, imports: importedBy(host.readFile(path)) }];
     } catch {

package/src/entries/run-directories.ts

@@ -0,0 +1,108 @@
+import type { ParseFile } from "./configuration-files.ts";
+import { membersNamed, staticModule, textsOf } from "./static-module.ts";
+import { holdsManifest } from "../fs/manifest.ts";
+import type { Host } from "../host.ts";
+import { ancestors, dirnamePath, joinPath, resolvePath } from "../paths.ts";
+
+/** The directories a tool run over one file starts from, read before any of its loads is resolved. */
+export interface RunDirectories {
+  /**
+   * The directory a package manager runs the scripts of the file's package in, the package's
+   * root (https://docs.npmjs.com/cli/v11/using-npm/scripts#best-practices): the nearest
+   * directory at or above the file, up to the run's top, holding a manifest, else the top.
+   */
+  workingDirectoryOf(fileName: string): string;
+  /**
+   * The bundler's project root a `/` glob is read against
+   * (https://vite.dev/guide/features.html#glob-import): the directory of the nearest bundler
+   * configuration at or above the file, moved by a literal `root` it writes, else the
+   * working directory. Undefined where a configuration there may move it to a place its
+   * text does not state.
+   */
+  bundlerRootOf(fileName: string): string | undefined;
+}
+
+/** The configuration file names the bundler and its test runner read their root from. */
+const BUNDLER_CONFIGS = ["vite.config", "vitest.config"].flatMap((stem) =>
+  ["js", "mjs", "cjs", "ts", "mts", "cts"].map((extension) => `${stem}.${extension}`),
+);
+
+/**
+ * The root the configurations of one directory state: the directory where none writes a
+ * `root`, the one literal they all write, or undefined where one cannot be read, writes a
+ * value that is not a literal, or two disagree.
+ */
+function statedRoot(
+  host: Host,
+  parse: ParseFile,
+  dir: string,
+  configs: readonly string[],
+): string | undefined {
+  const roots = new Set<string>();
+  for (const name of configs) {
+    const path = joinPath(dir, name);
+    let text: string;
+    try {
+      text = host.readFile(path);
+    } catch {
+      return undefined;
+    }
+    const objects = staticModule(parse(path, text)).defaultExport;
+    if (objects.length === 0) {
+      return undefined;
+    }
+    for (const object of objects) {
+      const values = object.kind === "object" ? membersNamed(object, "root") : undefined;
+      if (values === undefined) {
+        return undefined;
+      }
+      for (const value of values) {
+        const [root] = textsOf(value, false) ?? [];
+        if (root === undefined) {
+          return undefined;
+        }
+        roots.add(resolvePath(dir, root));
+      }
+    }
+  }
+  if (roots.size > 1) {
+    return undefined;
+  }
+  return [...roots][0] ?? dir;
+}
+
+/** The directories of one run below `top`, each read once per directory. */
+export function runDirectories(host: Host, top: string, parse: ParseFile): RunDirectories {
+  const working = new Map<string, string>();
+  const bundler = new Map<string, string | undefined>();
+  const workingDirectoryOf = (fileName: string): string => {
+    const dir = dirnamePath(fileName);
+    let found = working.get(dir);
+    if (found === undefined) {
+      found = ancestors(dir, top).find((at) => holdsManifest(host, at)) ?? top;
+      working.set(dir, found);
+    }
+    return found;
+  };
+  return {
+    workingDirectoryOf,
+    bundlerRootOf: (fileName) => {
+      const dir = dirnamePath(fileName);
+      if (bundler.has(dir)) {
+        return bundler.get(dir);
+      }
+      let found: string | undefined = workingDirectoryOf(fileName);
+      for (const at of ancestors(dir, top)) {
+        const configs = BUNDLER_CONFIGS.filter(
+          (name) => host.kindOf(joinPath(at, name)) === "file",
+        );
+        if (configs.length > 0) {
+          found = statedRoot(host, parse, at, configs);
+          break;
+        }
+      }
+      bundler.set(dir, found);
+      return found;
+    },
+  };
+}

package/src/entries/sources.ts

@@ -0,0 +1,266 @@
+/**
+ * The sources that enter a project's files with no import naming them, read once per
+ * project into one record every stage reads: the roots stage reads the files they enter,
+ * the dependency stage the configuration files' strings, and the reference pass the test
+ * files. A value a source does not find written out names nothing.
+ */
+
+import type { SourceFile } from "@typescript/native/ast";
+import { buildScriptEntries } from "./build-scripts.ts";
+import {
+  configurationFiles,
+  filesNamedBy,
+  moduleStrings,
+  type ConfigurationFiles,
+  type ParseFile,
+} from "./configuration-files.ts";
+import {
+  conventionEntries,
+  conventionTestFiles,
+  generatedFiles,
+  type Conventions,
+  type Selected,
+} from "./conventions.ts";
+import type { Host } from "../host.ts";
+import { htmlEntries } from "./html-entries.ts";
+import { documentEntries } from "./mdx-entries.ts";
+import { dirnamePath } from "../paths.ts";
+import type { SourceFiles } from "../source-files.ts";
+import { globExpression } from "../text/glob.ts";
+import { workflowEntries, type Workflows } from "./workflow-steps.ts";
+
+/** Which source entered a file. */
+export type EntryRule =
+  /** A configuration module, by the form of its name. */
+  | "configuration-file"
+  /** A file a relative string of a configuration module or a JSON configuration file names. */
+  | "configuration-string"
+  /** An entry a build script's bundler call names, whose exports the bundle exposes. */
+  | "bundler-entry"
+  /** A test file `ts.test_files` or an applied convention row names. */
+  | "test-runner"
+  /** A file an applied convention row's globs match. */
+  | "convention"
+  /** A file a module script of an HTML file below the target root loads. */
+  | "html-entry"
+  /** A file a `run:` step of a workflow in the target root's `.github/workflows` names. */
+  | "workflow-step"
+  /** A file an import line of a Markdown or MDX document below the target root names. */
+  | "document-import";
+
+/** One file a source enters. */
+interface EntryPoint {
+  readonly file: SourceFile;
+  readonly rule: EntryRule;
+  /**
+   * What named the file: the file-name convention the tool looks for, the row, the
+   * test-file pattern or string that classified it, or the literal a configuration or a
+   * call writes.
+   */
+  readonly source: string;
+  /**
+   * Whether what the file exports is read too. A tool loading a configuration reads its
+   * default export; a runtime executing a test file runs its top level and names none of
+   * its exports.
+   */
+  readonly exports: boolean;
+  /** Where the file is entered for some of its exports only, their export names. */
+  readonly names?: readonly string[];
+}
+
+/** What the sources of one project are read from. */
+interface SourceContext {
+  readonly host: Host;
+  readonly targetRoot: string;
+  readonly files: SourceFiles;
+  /** The parser the files no program holds are read with, where they are read. */
+  readonly parse?: ParseFile | undefined;
+  /** `ts.test_files` from the resolved configuration. */
+  readonly testFiles: readonly string[];
+  /** The convention rows the run applied. */
+  readonly conventions?: Conventions | undefined;
+  /** The target root's workflow steps, git hooks and makefile, read once per run. */
+  readonly workflows: Workflows;
+}
+
+/** What the sources of one project enter and name. */
+export interface SourceFacts {
+  /** Every file a source enters, once per source and string that enters it. */
+  readonly entered: readonly EntryPoint[];
+  /** The files, absolute, a test runner loads. */
+  readonly testFiles: ReadonlySet<string>;
+  /** The own files below a directory an applied row generates, by path below the target root, each with the row. */
+  readonly generated: ReadonlyMap<string, string>;
+  /** The configuration files, whose strings name files and dependencies. */
+  readonly configuration: ConfigurationFiles;
+  /** The target root's workflow steps, git hooks and makefile the entries were read from. */
+  readonly workflows: Workflows;
+}
+
+/** One file a test runner loads, and the pattern or string naming it. */
+interface TestFile {
+  readonly file: SourceFile;
+  readonly source: string;
+}
+
+/** What every source reads: the context, and the configuration files and test files read once. */
+interface SourceInput extends SourceContext {
+  readonly configuration: ConfigurationFiles;
+  readonly tests: readonly TestFile[];
+}
+
+/** One source: the files it enters in one project. */
+type EntrySource = (input: SourceInput) => readonly EntryPoint[];
+
+/**
+ * Each configuration module, with what it exports, and each own file a relative string of
+ * a configuration module or a JSON configuration file names, read against that file's
+ * directory. A string at a selection key of an applied convention row, or naming a test
+ * file, names no file here.
+ */
+const configurationSource: EntrySource = ({ files, configuration, conventions }) => {
+  const selected: ReadonlyMap<string, Selected> = conventions?.selected ?? new Map();
+  const found: EntryPoint[] = [];
+  const unselected = (file: SourceFile): readonly string[] => {
+    const starts = selected.get(file.fileName)?.starts;
+    return moduleStrings(file)
+      .filter((one) => starts?.has(one.node.getStart()) !== true)
+      .map((one) => one.text);
+  };
+  const unselectedIn = (path: string, texts: readonly string[]): readonly string[] => {
+    const left = [...(selected.get(path)?.texts ?? [])];
+    return texts.filter((text) => {
+      const at = left.indexOf(text);
+      if (at < 0) {
+        return true;
+      }
+      left.splice(at, 1);
+      return false;
+    });
+  };
+  const strings = (dir: string, texts: readonly string[]): void => {
+    for (const text of texts) {
+      for (const file of filesNamedBy(files, dir, text)) {
+        found.push({ file, rule: "configuration-string", source: text, exports: true });
+      }
+    }
+  };
+  for (const { file, form } of configuration.modules) {
+    found.push({ file, rule: "configuration-file", source: form, exports: true });
+    strings(dirnamePath(file.fileName), unselected(file));
+  }
+  for (const document of configuration.documents) {
+    strings(dirnamePath(document.path), unselectedIn(document.path, document.strings));
+  }
+  for (const { file } of configuration.outside) {
+    strings(dirnamePath(file.fileName), unselected(file));
+  }
+  return found;
+};
+
+const testSource: EntrySource = ({ tests }) =>
+  tests.map(({ file, source }) => ({ file, rule: "test-runner", source, exports: false }));
+
+const conventionSource: EntrySource = ({ files, conventions }) =>
+  conventions === undefined
+    ? []
+    : conventionEntries(conventions, files).map(({ file, row }) => ({
+        file,
+        rule: "convention",
+        source: row,
+        exports: true,
+      }));
+
+const htmlSource: EntrySource = ({ host, targetRoot, files, parse }) =>
+  htmlEntries(host, targetRoot, files, parse).map(({ file, source }) => ({
+    file,
+    rule: "html-entry",
+    source,
+    exports: true,
+  }));
+
+const documentSource: EntrySource = ({ host, targetRoot, files }) =>
+  documentEntries(host, targetRoot, files).map(({ file, source, names }) => ({
+    file,
+    rule: "document-import",
+    source,
+    exports: true,
+    ...(names === undefined ? {} : { names }),
+  }));
+
+const buildScriptSource: EntrySource = ({ host, targetRoot, files, parse }) =>
+  buildScriptEntries(host, targetRoot, files, parse).map(({ file, source }) => ({
+    file,
+    rule: "bundler-entry",
+    source,
+    exports: true,
+  }));
+
+const workflowSource: EntrySource = ({ workflows, files }) =>
+  workflowEntries(workflows, files).map(({ file, source }) => ({
+    file,
+    rule: "workflow-step",
+    source,
+    exports: true,
+  }));
+
+/** Every source, each read once per project. */
+const ENTRY_SOURCES: readonly EntrySource[] = [
+  configurationSource,
+  conventionSource,
+  testSource,
+  htmlSource,
+  documentSource,
+  buildScriptSource,
+  workflowSource,
+];
+
+/**
+ * The files a test runner loads in one project: each `ts.test_files` pattern's matches
+ * below the target root, then each file an applied row names, once per pattern or row
+ * string that names it.
+ */
+function testFilesOf(context: SourceContext): readonly TestFile[] {
+  const found: TestFile[] = [];
+  for (const pattern of context.testFiles) {
+    const expression = globExpression(pattern);
+    for (const [path, file] of context.files.byPath) {
+      if (expression.test(path)) {
+        found.push({ file, source: pattern });
+      }
+    }
+  }
+  const named =
+    context.conventions === undefined
+      ? []
+      : conventionTestFiles(context.conventions, context.files);
+  for (const [name, source] of named) {
+    const file = context.files.byName.get(name);
+    if (file !== undefined) {
+      found.push({ file, source });
+    }
+  }
+  return found;
+}
+
+/** Reads every source of one project once. */
+export function readSources(context: SourceContext): SourceFacts {
+  const configuration = configurationFiles(
+    context.host,
+    context.targetRoot,
+    context.files,
+    context.parse,
+  );
+  const tests = testFilesOf(context);
+  const input: SourceInput = { ...context, configuration, tests };
+  return {
+    entered: ENTRY_SOURCES.flatMap((source) => source(input)),
+    testFiles: new Set(tests.map(({ file }) => file.fileName)),
+    generated:
+      context.conventions === undefined
+        ? new Map()
+        : generatedFiles(context.conventions, context.files),
+    configuration,
+    workflows: context.workflows,
+  };
+}