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

package/src/version-range.ts

@@ -66,10 +66,12 @@ function partialOf(text: string): Partial | undefined {
     parts.push(Number(part));
   }
   const prerelease = prereleaseOf(match[4]);
-  if (prerelease === undefined || (prerelease.length > 0 && wild)) {
+  if (prerelease === undefined) {
     return undefined;
   }
-  return { major: parts[0], minor: parts[1], patch: parts[2], prerelease };
+  // node-semver drops the prerelease of a version with a wildcard part (`1.2.x-beta` is `1.2.x`):
+  // https://github.com/npm/node-semver/blob/v7.8.5/classes/range.js#L409-L430
+  return { major: parts[0], minor: parts[1], patch: parts[2], prerelease: wild ? [] : prerelease };
 }
 
 /** One exact version, or `undefined` where the text is not one. */
@@ -152,11 +154,14 @@ function passes(version: Version, comparator: Comparator): boolean {
   }
 }
 
-/** The comparators a version with missing parts stands for: any value of each. */
+/**
+ * The comparators a version with missing parts stands for: any value of each. A wildcard
+ * major is no comparator, so it never refuses a 0.0.0 prerelease another comparator admits.
+ */
 function anyOf(partial: Partial): Comparator[] {
   const { major, minor } = partial;
   if (major === undefined) {
-    return [{ operator: ">=", version: exact(0, 0, 0) }];
+    return [];
   }
   if (minor === undefined) {
     return [
@@ -210,7 +215,7 @@ function primitive(operator: "<" | "<=" | ">" | ">=", partial: Partial): Compara
   if (major === undefined) {
     return operator === "<" || operator === ">"
       ? [{ operator: "<", version: floorOf(0, 0, 0) }]
-      : [{ operator: ">=", version: exact(0, 0, 0) }];
+      : [];
   }
   if (minor !== undefined && patch !== undefined) {
     return [{ operator, version: lowest(partial) }];

package/src/version.ts

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "7.2.0";
+export const CONTRACT_VERSION = "8.0.0";

package/src/workflow-steps.ts

@@ -1,12 +1,13 @@
 /**
- * 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 type { SourceFile } from "@typescript/native/ast";
 import type { Host } from "./host.ts";
 import { scriptTokens } from "./manifest.ts";
-import { joinPath, resolvePath } from "./paths.ts";
+import { joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { SourceFiles } from "./source-files.ts";
 
 /** One file a workflow step names. */
@@ -21,6 +22,23 @@ 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"] as const;
+
+/** The hook manager files whose commands are written under a key, with that key. */
+const HOOK_MANAGERS: readonly (readonly [string, RegExp])[] = [
+  [".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"] as const;
+
+/** The operators that end one shell command of a recipe line. */
+const COMMAND_SEPARATORS = /&&|\|\||;|\|/u;
+
 const BLOCK_SCALAR = /^[|>][+-]?$/u;
 
 const QUOTED = /^(["'])(.*)\1$/su;
@@ -30,7 +48,8 @@ const COMPUTED = /[${*?[]/u;
 
 const INDENT = /^\s*/u;
 
-function workflowFiles(host: Host, dir: string): readonly string[] {
+/** The files directly in one directory whose name `accepts`, in name order. */
+function filesIn(host: Host, dir: string, accepts: (name: string) => boolean): readonly string[] {
   let entries;
   try {
     entries = host.readDirectory(dir);
@@ -38,17 +57,25 @@ function workflowFiles(host: Host, dir: string): readonly string[] {
     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: string): readonly string[] {
+function readText(host: Host, path: string): string | undefined {
+  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: string, key: RegExp = RUN_LINE): readonly string[] {
   const lines = text.split(/\r?\n/u);
   const found: string[] = [];
   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;
     }
@@ -69,28 +96,95 @@ export function runCommands(text: string): readonly string[] {
   return found;
 }
 
-/** Every token the `run:` steps of the workflow files in the target root's `.github/workflows` hold. */
-export function workflowTokens(host: Host, targetRoot: string): readonly string[] {
-  const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
-  const found: string[] = [];
-  for (const path of workflowFiles(host, dir)) {
-    let text: string;
-    try {
-      text = host.readFile(path);
-    } catch {
+/**
+ * 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: Host, root: string): readonly { token: string; dir: string }[] {
+  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: { token: string; dir: string }[] = [];
+  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: string): string {
+  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;
+}
+
 /**
- * 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.
+ * 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: Host, targetRoot: string): readonly string[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  const commands: string[] = [];
+  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 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: Host,
@@ -107,5 +201,16 @@ export function workflowEntries(
       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/src/workspace-programs.ts

@@ -16,6 +16,7 @@ import type {
 } from "@typescript/native/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/ast";
 import type { StringLiteralLikeNode } from "@typescript/native/ast";
+import { baseUrlPaths } from "./base-url.ts";
 import type { Host } from "./host.ts";
 import { dirnamePath, resolvePath } from "./paths.ts";
 import type { Engine } from "./session.ts";
@@ -62,7 +63,8 @@ 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.
  */
@@ -75,7 +77,9 @@ function analysisOptions(parsed: Parsed): CreateSnapshotProgramParams["compilerO
     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. */
@@ -152,7 +156,7 @@ function configurationOf(
   const raw: unknown = (options as Record<string, unknown>)["pathsBasePath"];
   const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
   const paths: Record<string, string[]> = {};
-  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/src/workspace-resolution.ts

@@ -1,13 +1,13 @@
 /**
- * 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.ts";
+import { gitIgnored } from "./git-ignore.ts";
 import type { Host } from "./host.ts";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import { satisfies } from "./version-range.ts";
@@ -45,6 +45,7 @@ const DEPENDENCY_MEMBERS = [
 ] as const;
 
 const SOURCE = /(?<!\.d)\.(?:[mc]?ts|tsx)$/u;
+const OUTPUT = /(?:\.d\.[mc]?ts|\.[mc]?js|\.jsx)$/u;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -77,10 +78,17 @@ function exportsEntry(
   exportsField: unknown,
   subpath: string,
 ): { readonly value: unknown; readonly match?: string } | undefined {
-  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] };
   }
@@ -224,6 +232,32 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     return found;
   };
 
+  const root = workspace.members[0]?.dir;
+  const ignored = root === undefined ? () => false : gitIgnored(host, root);
+  const manifests = new Map<
+    string,
+    { dir: string; manifest: Record<string, unknown> } | undefined
+  >();
+  /** The nearest manifest at or above one directory, up to the workspace's root. */
+  const nearestManifest = (
+    dir: string,
+  ): { dir: string; manifest: Record<string, unknown> } | undefined => {
+    if (manifests.has(dir)) {
+      return manifests.get(dir);
+    }
+    let found: { dir: string; manifest: Record<string, unknown> } | undefined;
+    try {
+      const value: unknown = 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: readonly WorkspaceMember[], fromDir: string): Linked => {
     const name = candidates[0]?.name ?? "";
     const linked = linkedFrom(name, fromDir);
@@ -235,14 +269,16 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     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)),
+      declared.some((specifier) => dependsOn(specifier, member, owner?.dir ?? fromDir)),
     );
     const [one, two] = matched;
     if (one === undefined) {
@@ -257,6 +293,25 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
   const compiled = (member: WorkspaceMember, path: string): boolean =>
     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: WorkspaceMember, path: string): string | undefined => {
+    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
@@ -278,6 +333,9 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     if (found !== undefined) {
       return found;
     }
+    if (ignored(path)) {
+      return mirrored(member, path);
+    }
     return compiled(member, path) && host.kindOf(path) === "file" ? path : undefined;
   };
 
@@ -344,10 +402,12 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
       }
       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" };
       }
@@ -371,6 +431,18 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
       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/src/workspace.ts

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