@cplieger/deadset-ts 8.0.0-dev.6 → 8.0.0-dev.8

package/src/automatic-types.ts

@@ -26,8 +26,10 @@ import {
   type Statement,
 } from "@typescript/native/ast";
 import type { ParseFile } from "./configuration-files.ts";
-import type { DirectoryEntry, Host } from "./host.ts";
-import { dirnamePath, joinPath, resolvePath } from "./paths.ts";
+import type { Host } from "./host.ts";
+import { ancestors, dirnamePath, joinPath, resolvePath } from "./paths.ts";
+import { entriesOf } from "./fs/tree.ts";
+import { manifestAt } from "./fs/manifest.ts";
 
 const TYPE_ROOT = "node_modules/@types";
 
@@ -122,19 +124,11 @@ function fileDeclarations(file: SourceFile, globals: string[], modules: string[]
 
 /** The entry declaration file of one installed type package's directory. */
 function entryOf(host: Host, dir: string): string {
-  try {
-    const manifest: unknown = JSON.parse(host.readFile(joinPath(dir, "package.json")));
-    const named =
-      typeof manifest === "object" && manifest !== null
-        ? ((manifest as Record<string, unknown>)["types"] ??
-          (manifest as Record<string, unknown>)["typings"])
-        : undefined;
-    if (typeof named === "string" && named !== "") {
-      const path = resolvePath(dir, named);
-      return path.endsWith(".ts") ? path : `${path}.d.ts`;
-    }
-  } catch {
-    // A package with no readable manifest is read from its index, as the compiler reads it.
+  const manifest = manifestAt(host, dir);
+  const named = manifest?.["types"] ?? manifest?.["typings"];
+  if (typeof named === "string" && named !== "") {
+    const path = resolvePath(dir, named);
+    return path.endsWith(".ts") ? path : `${path}.d.ts`;
   }
   return joinPath(dir, "index.d.ts");
 }
@@ -201,13 +195,7 @@ export function automaticTypes(
   };
   const read = new Set<string>();
   for (const root of typeRoots(configFile, options)) {
-    let entries: readonly DirectoryEntry[];
-    try {
-      entries = host.readDirectory(root);
-    } catch {
-      entries = [];
-    }
-    for (const entry of entries) {
+    for (const entry of entriesOf(host, root)) {
       if (read.has(entry.name) || host.kindOf(joinPath(root, entry.name)) !== "directory") {
         continue;
       }
@@ -236,11 +224,5 @@ function typeRoots(configFile: string, options: Readonly<Record<string, unknown>
       (root): root is string => typeof root === "string" && root.endsWith(`/${TYPE_ROOT}`),
     );
   }
-  const roots: string[] = [];
-  for (let dir = dirnamePath(configFile); ; dir = dirnamePath(dir)) {
-    roots.push(joinPath(dir, TYPE_ROOT));
-    if (dirnamePath(dir) === dir) {
-      return roots;
-    }
-  }
+  return ancestors(dirnamePath(configFile)).map((dir) => joinPath(dir, TYPE_ROOT));
 }

package/src/build-scripts.ts

@@ -9,7 +9,6 @@ import {
   isArrayBindingPattern,
   isArrayLiteralExpression,
   isArrowFunction,
-  isAsExpression,
   isCallExpression,
   isConstructorDeclaration,
   isFunctionDeclaration,
@@ -25,10 +24,8 @@ import {
   isNoSubstitutionTemplateLiteral,
   isObjectBindingPattern,
   isObjectLiteralExpression,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isPropertyAssignment,
-  isSatisfiesExpression,
   isSetAccessorDeclaration,
   isStringLiteral,
   isVariableDeclaration,
@@ -39,11 +36,15 @@ import {
   type SourceFile,
 } from "@typescript/native/ast";
 import { filesNamedBy, type ParseFile } from "./configuration-files.ts";
-import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
-import { scriptTokens } from "./manifest.ts";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import { ancestors, dirnamePath, 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 { unwrapped } from "./unwrap.ts";
+import { holdsManifest, inInstalledPackages, manifestAt } from "./fs/manifest.ts";
+import { globExpression } from "./text/glob.ts";
+import { scriptTokens } from "./text/shell.ts";
 
 /** One bundler API: the module, the functions it exports that build, and the option naming entries. */
 interface BundlerAPI {
@@ -78,8 +79,6 @@ const BUNDLERS: readonly BundlerAPI[] = [
 
 const MODULE_EXTENSION = /\.(?:js|mjs|cjs|ts|mts|cts)$/u;
 
-const MANIFEST = "package.json";
-
 /** One own file a build script's bundler call names as an entry. */
 interface BuildEntry {
   readonly file: SourceFile;
@@ -87,19 +86,6 @@ interface BuildEntry {
   readonly source: string;
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** The expression a wrapper that changes no value holds. */
-function unwrapped(node: Node): Node {
-  let at = node;
-  while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
-    at = at.expression;
-  }
-  return at;
-}
-
 function literalOf(node: Node): string | undefined {
   const at = unwrapped(node);
   return isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at) ? at.text : undefined;
@@ -462,7 +448,7 @@ function scriptEntries(file: SourceFile, dir: string, files: SourceFiles): reado
         continue;
       }
       const [argument] = call.arguments;
-      let options = argument === undefined ? undefined : unwrapped(argument);
+      let options: Node | undefined = argument === undefined ? undefined : unwrapped(argument);
       if (options !== undefined && isIdentifier(options)) {
         options = shadowed.has(options.text) ? undefined : declared.get(options.text);
         options = options === undefined ? undefined : unwrapped(options);
@@ -489,13 +475,7 @@ function scriptEntries(file: SourceFile, dir: string, files: SourceFiles): reado
 
 /** The modules one manifest's scripts run, by absolute path, each below the target root. */
 function scriptModules(host: Host, root: string, dir: string): readonly string[] {
-  let manifest: unknown;
-  try {
-    manifest = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
-  } catch {
-    return [];
-  }
-  const scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
+  const scripts = manifestAt(host, dir)?.["scripts"];
   if (!isRecord(scripts)) {
     return [];
   }
@@ -509,14 +489,14 @@ function scriptModules(host: Host, root: string, dir: string): readonly string[]
       if (
         MODULE_EXTENSION.test(path) &&
         relativePath(root, path) !== undefined &&
-        !path.split("/").includes("node_modules") &&
+        !inInstalledPackages(path) &&
         host.kindOf(path) === "file"
       ) {
         found.add(path);
       }
     }
   }
-  return [...found].sort();
+  return [...found].sort(bytewise);
 }
 
 /**
@@ -533,17 +513,16 @@ export function buildScriptEntries(
   const root = resolvePath(host.workingDirectory(), targetRoot);
   const dirs = new Set<string>([root]);
   for (const file of files.byName.values()) {
-    for (
-      let dir = dirnamePath(file.fileName);
-      relativePath(root, dir) !== undefined && !dirs.has(dir);
-      dir = dirnamePath(dir)
-    ) {
+    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()) {
-    if (host.kindOf(joinPath(dir, MANIFEST)) !== "file") {
+  for (const dir of [...dirs].sort(bytewise)) {
+    if (!holdsManifest(host, dir)) {
       continue;
     }
     for (const path of scriptModules(host, root, dir)) {

package/src/component-layer.ts

@@ -8,10 +8,12 @@
 
 import type { CreateSnapshotParams } from "@typescript/native/sync";
 import type { Host } from "./host.ts";
+import { INSTALLED_PACKAGES } from "./fs/manifest.ts";
 import { dirnamePath, joinPath } from "./paths.ts";
+import { PRODUCT } from "./product.ts";
 
 /** The name the mapper's manifest declares and every configuration's entry names. */
-const MAPPER_PACKAGE = "deadset-ts-component-files";
+const MAPPER_PACKAGE = `${PRODUCT}-component-files`;
 
 /** The file system one snapshot is created with. */
 type SnapshotFileSystem = NonNullable<CreateSnapshotParams["fileSystem"]>;
@@ -150,7 +152,7 @@ export function componentLayer(
       mappers,
     );
     if (mapper !== undefined) {
-      symlinks[joinPath(dirnamePath(configFile), "node_modules", MAPPER_PACKAGE)] = {
+      symlinks[joinPath(dirnamePath(configFile), INSTALLED_PACKAGES, MAPPER_PACKAGE)] = {
         target: mapper.packageDirectory,
         host: true,
       };

package/src/components.ts

@@ -7,16 +7,14 @@
 import type { Cascade } from "./config.ts";
 import { OUTSIDE, type Graph } from "./graph.ts";
 import type { InventorySymbol } from "./inventory.ts";
-
-/** The name every component identifier this analyzer mints starts with. */
-const ANALYZER = "deadset-ts";
+import { PRODUCT } from "./product.ts";
 
 /** The fewest digits a component identifier's number is written with. */
 const ID_DIGITS = 4;
 
 /** The identifier of the component at one place of the run's order, counted from one. */
 export function componentId(place: number): string {
-  return `${ANALYZER}/c-${String(place).padStart(ID_DIGITS, "0")}`;
+  return `${PRODUCT}/c-${String(place).padStart(ID_DIGITS, "0")}`;
 }
 
 /** The index of a declaration the component walk has not reached. */

package/src/config.ts

@@ -1,10 +1,6 @@
-import {
-  CONTRACT_VERSION,
-  type Confidence,
-  type Format,
-  type Language,
-  type Severity,
-} from "./contract/contract.generated.ts";
+import type { ResolvedConfig } from "./contract/config.generated.ts";
+import { SEVERITIES, type Severity } from "./contract/contract.generated.ts";
+import { LANGUAGE } from "./product.ts";
 
 /**
  * The name of the repository configuration at the target root, which is also the
@@ -13,254 +9,32 @@ import {
  */
 export const REPOSITORY_DOCUMENT = "deadset.json";
 
-/**
- * Whether the target is an application, whose every caller is in the analyzed
- * graph, or a library, whose published API has callers outside it.
- */
-export type TargetKind = "application" | "library";
+export type { PartialConfig, ResolvedConfig } from "./contract/config.generated.ts";
 
-/** The target kind as a source writes it: one kind for every language, or one per language. */
-export type TargetKindSetting = TargetKind | { readonly go: TargetKind; readonly ts: TargetKind };
+/** Whether the target is an application or a library. */
+export type TargetKind = Extract<ResolvedConfig["target"]["kind"], string>;
+export type DeclarationEntry = ResolvedConfig["ts"]["serializers"][number];
+export type LifecycleContract = ResolvedConfig["ts"]["lifecycle_contracts"][number];
+export type BuildConfiguration = ResolvedConfig["analysis"]["configurations"][number];
+export type ProjectConfiguration = Extract<BuildConfiguration, { readonly project: string }>;
+export type TemplateDelimiters = ResolvedConfig["analysis"]["template_delimiters"];
+export type Sort = ResolvedConfig["reporters"]["sort"];
+export type Cascade = ResolvedConfig["reporters"]["cascade"];
 
-/** The kind a target kind setting gives one language's declarations. */
-export function kindOf(setting: TargetKindSetting, language: Language): TargetKind {
-  return typeof setting === "string" ? setting : setting[language];
+/** The kind a target kind setting gives this analyzer's declarations. */
+export function kindOf(kind: ResolvedConfig["target"]["kind"]): TargetKind {
+  return typeof kind === "string" ? kind : kind[LANGUAGE];
 }
 
-/** Whether declarations in generated files are analyzed. */
-export type GeneratedFiles = "exclude" | "include";
-
-/** How a reference from a consumer's test file counts. */
-export type ConsumerTests = "test" | "production";
-
-/** The severities ranked, the strongest highest. */
-const SEVERITY_RANK: Readonly<Record<Severity, number>> = { allow: 0, warn: 1, deny: 2 };
-
 /** Whether a finding at one severity fails a run under the failing severity. */
 export function fails(severity: Severity, failOn: Severity): boolean {
-  return SEVERITY_RANK[severity] >= SEVERITY_RANK[failOn];
-}
-
-/** The order findings are rendered in. */
-export type Sort = "position" | "size";
-
-/** How much of a dead component a rendering names. */
-export type Cascade = "roots" | "full";
-
-/**
- * A platform configuration: an operating system, an architecture and the build
- * tags in effect. It is the shape a language built under build constraints reads,
- * and this analyzer leaves it to that analysis.
- */
-interface PlatformConfiguration {
-  readonly shape: "platform";
-  readonly id: string;
-  readonly os: string;
-  readonly arch: string;
-  readonly tags: readonly string[];
-}
-
-/**
- * A project configuration: one compiler configuration file, as a path below the
- * target root with `/` between segments.
- */
-export interface ProjectConfiguration {
-  readonly shape: "project";
-  readonly id: string;
-  readonly project: string;
-}
-
-/**
- * One entry of the build matrix: a configuration the target builds under, in
- * exactly one of the two shapes the matrix admits.
- */
-export type BuildConfiguration = PlatformConfiguration | ProjectConfiguration;
-
-/**
- * The pair of action delimiters a template is parsed with. Both members are
- * required once a document names the object, so the pair is one setting rather
- * than two.
- */
-export interface TemplateDelimiters {
-  readonly left: string;
-  readonly right: string;
-}
-
-/** How the analysis is scoped and filtered. */
-export interface Analysis {
-  readonly languages: readonly Language[];
-  readonly minConfidence: Confidence;
-  readonly generatedFiles: GeneratedFiles;
-  readonly consumerTests: ConsumerTests;
-  readonly configurations: readonly BuildConfiguration[];
-  readonly matrixComplete: boolean;
-  readonly templateDirs: readonly string[];
-  readonly templateDelimiters: TemplateDelimiters;
-}
-
-/** How findings are rendered. */
-interface Reporters {
-  readonly formats: readonly Format[];
-  readonly sort: Sort;
-  readonly cascade: Cascade;
-  readonly maxFindings: number;
-  readonly failOn: Severity;
-}
-
-/**
- * One declaration a configuration entry names, in exactly one of three shapes: a
- * declaration of the analyzed program by its stable symbol reference, a declaration a
- * module exports by the bare specifier an import writes for the module and the
- * declaration's path from its exports, or a declaration of the global scope by its
- * path from that scope. A path joins the name and each member with dots and spells a
- * static member with `:static` after it.
- */
-export type DeclarationEntry =
-  | { readonly shape: "symbol"; readonly symbol: string }
-  | { readonly shape: "module"; readonly module: string; readonly name: string }
-  | { readonly shape: "global"; readonly global: string };
-
-/**
- * One framework's lifecycle contract: the declarations whose use makes a class one of
- * the framework's components, the classes whose subclasses are its components, and the
- * names of the members the framework calls on a component, each spelled as the last
- * component of a member's stable symbol reference.
- */
-export interface LifecycleContract {
-  readonly components: readonly DeclarationEntry[];
-  readonly bases: readonly DeclarationEntry[];
-  readonly members: readonly string[];
-}
-
-/**
- * One analyzer the orchestrator may run, in exactly one of two shapes: an installed
- * analyzer, named by its command alone, or an acquirable one, which also names the
- * artifact acquisition fetches and verifies. This analyzer validates and prints the
- * list and runs nothing from it.
- */
-export type Provider =
-  | {
-      readonly shape: "installed";
-      readonly name: string;
-      readonly languages: readonly Language[];
-      readonly command: string;
-    }
-  | {
-      readonly shape: "acquirable";
-      readonly name: string;
-      readonly languages: readonly Language[];
-      readonly command: string;
-      readonly source: string;
-      readonly version: string;
-      readonly digest: string;
-    };
-
-/** The analyzers the orchestrator runs. */
-interface Providers {
-  readonly analyzers: readonly Provider[];
-}
-
-/** The section the TypeScript analyzer owns. */
-export interface TSSection {
-  readonly testFiles: readonly string[];
-  readonly entryFiles: readonly string[];
-  readonly componentExtensions: readonly string[];
-  readonly disabledConventions: readonly string[];
-  readonly injectionRegistrations: readonly DeclarationEntry[];
-  readonly lifecycleContracts: readonly LifecycleContract[];
-  readonly serializers: readonly DeclarationEntry[];
-  /** Whether the maintainer declares the roots the analysis finds every root the target has. */
-  readonly rootsComplete: boolean;
-}
-
-/**
- * The resolved configuration: the closed key list of the Contract's
- * configuration schema, decoded, with every default applied.
- *
- * `targetKind` is empty exactly in the configuration every default states, which
- * is not a configuration a run may use: the field has no default and resolution
- * refuses a result that carries none.
- *
- * `severity` is a map rather than an object because its keys come from a
- * document, and an object keyed by document text answers for names it never
- * held. The order it is written in is the emitter's, not the map's.
- */
-export interface Config {
-  readonly contractVersion: string;
-  readonly targetKind: TargetKindSetting | "";
-  readonly analysis: Analysis;
-  readonly consumersComplete: boolean;
-  readonly rootPatterns: readonly string[];
-  readonly severity: ReadonlyMap<string, Severity>;
-  readonly exemptionsDisabled: readonly string[];
-  readonly reporters: Reporters;
-  readonly providers: Providers;
-  readonly ts: TSSection;
-}
-
-/**
- * The configuration every documented default states. `targetKind` is empty: the
- * field has no default and is never inferred.
- */
-export function defaultConfig(): Config {
-  return {
-    contractVersion: CONTRACT_VERSION,
-    targetKind: "",
-    analysis: {
-      languages: [],
-      minConfidence: "probable",
-      generatedFiles: "exclude",
-      consumerTests: "test",
-      configurations: [],
-      matrixComplete: false,
-      templateDirs: [],
-      templateDelimiters: { left: "{{", right: "}}" },
-    },
-    consumersComplete: false,
-    rootPatterns: [],
-    severity: new Map(),
-    exemptionsDisabled: [],
-    reporters: {
-      formats: ["text"],
-      sort: "position",
-      cascade: "roots",
-      maxFindings: 0,
-      failOn: "deny",
-    },
-    providers: {
-      analyzers: [
-        { shape: "installed", name: "deadset-go", languages: ["go"], command: "deadset-go" },
-        { shape: "installed", name: "deadset-ts", languages: ["ts"], command: "deadset-ts" },
-      ],
-    },
-    ts: {
-      testFiles: [
-        "**/*.test.{ts,tsx,mts,cts}",
-        "**/*.test-d.{ts,tsx,mts,cts}",
-        "**/*.spec-d.{ts,tsx,mts,cts}",
-        "**/*.spec.*",
-        "**/__tests__/**",
-        "**/__mocks__/**",
-        "**/test-d/**",
-      ],
-      entryFiles: [],
-      componentExtensions: [".vue", ".svelte", ".astro"],
-      disabledConventions: [],
-      injectionRegistrations: [],
-      lifecycleContracts: [],
-      serializers: [],
-      rootsComplete: false,
-    },
-  };
+  return SEVERITIES.indexOf(severity) >= SEVERITIES.indexOf(failOn);
 }
 
 /** Where a resolved setting came from, in the order the sources outrank each other. */
 export type Source = "flag" | "repository" | "central" | "default";
 
-/**
- * One setting's source together with the file or flag that supplied it. `label`
- * is empty exactly when `source` is `"default"`.
- */
+/** One setting's source with the file or flag that supplied it, empty for a default. */
 export interface Origin {
   readonly source: Source;
   readonly label: string;
@@ -275,63 +49,24 @@ export function renderOrigin(origin: Origin): string {
 }
 
 /**
- * The origin of each resolved setting, keyed by the setting's dotted path. A
- * section holds no value of its own and has no entry; the severity object
- * carries one entry per code it names, or the entry `severity` alone when it is
- * empty.
+ * The origin of each resolved setting, keyed by the setting's dotted path. A section
+ * has no entry; a keyed section carries one entry per member it names, or one for
+ * itself when it is empty.
  */
 export type Provenance = ReadonlyMap<string, Origin>;
 
-/**
- * The configuration documents one invocation reads, each the document's text or
- * absent. `repositoryLabel` names the document `repository` holds and
- * `centralLabel` the one `central` holds; `flagLabels` names the flag that
- * supplied each setting `flags` names, keyed by dotted setting path.
- */
-export interface Inputs {
-  readonly flags?: string;
-  readonly repository?: string;
-  readonly central?: string;
-  readonly repositoryLabel?: string;
-  readonly centralLabel?: string;
-  readonly flagLabels?: ReadonlyMap<string, string>;
+/** One configuration document: its text and the path it was read from. */
+export interface Document {
+  readonly text: string;
+  readonly label: string;
 }
 
-/** Which refusal a {@link ConfigError} carries. */
-type ErrorKind =
-  /**
-   * A document that is not one JSON instance of the closed key list: a syntax
-   * error, a value of the wrong type, a value outside the closed set a key
-   * declares, or a member written twice at one level.
-   */
-  | "malformed"
-  /**
-   * A key the closed key list does not declare, or a severity key naming no live
-   * kind or a kind whose severity the Contract fixes.
-   */
-  | "unimplemented-key"
-  /** A resolved configuration no source supplied a target kind for. */
-  | "missing-target-kind";
-
 /**
- * Every refusal configuration resolution makes. Each maps to the usage exit
- * code, and each is thrown rather than returned: a refusal ends the run, and the
- * one caller that turns it into an exit code is the command line.
+ * The configuration sources one invocation carries. `flags` holds the text each
+ * setting option was given, by the setting's dotted path.
  */
-export class ConfigError extends Error {
-  /** Which refusal this is. */
-  readonly kind: ErrorKind;
-
-  /**
-   * The key or field the message names, spelled as the document spells it. It is
-   * empty when the refusal names none.
-   */
-  readonly key: string;
-
-  constructor(kind: ErrorKind, key: string, message: string) {
-    super(message);
-    this.name = "ConfigError";
-    this.kind = kind;
-    this.key = key;
-  }
+export interface Inputs {
+  readonly flags?: ReadonlyMap<string, string>;
+  readonly repository?: Document;
+  readonly central?: Document;
 }