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

package/src/component-files.ts

@@ -6,6 +6,8 @@
  * attribute names are appended past the file's end.
  */
 
+import { isPathRelativeURL, startsRelativePath } from "./paths.ts";
+
 /** The language one block is written in, as the module's virtual extension spells it. */
 type BlockLanguage = "ts" | "tsx" | "js" | "jsx";
 
@@ -465,10 +467,10 @@ function actionOf(text: string): string {
 /** Whether a `src` value names a file: no scheme, no root-relative path, not empty. */
 function specifierOf(value: string): string | undefined {
   const trimmed = value.trim();
-  if (trimmed === "" || trimmed.startsWith("/") || /^[A-Za-z][A-Za-z0-9+.-]*:/u.test(trimmed)) {
+  if (!isPathRelativeURL(trimmed)) {
     return undefined;
   }
-  return trimmed.startsWith("./") || trimmed.startsWith("../") ? trimmed : `./${trimmed}`;
+  return startsRelativePath(trimmed) ? trimmed : `./${trimmed}`;
 }
 
 /** The line-start `<script` tags one block's content holds. */

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/config.ts

@@ -1,4 +1,6 @@
-import { CONTRACT_VERSION } from "./version.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
@@ -7,266 +9,32 @@ import { CONTRACT_VERSION } from "./version.ts";
  */
 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];
 }
 
-/** The lowest reachability class a finding must reach to be reported. */
-export type Confidence = "certain" | "probable" | "possible";
-
-/** 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";
-
-/** One language an analysis covers. */
-export type Language = "go" | "ts";
-
-/** What a finding of one issue kind does to a run. */
-export type Severity = "allow" | "warn" | "deny";
-
-/** 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];
-}
-
-/** One rendering of the finding list. */
-export type Format = "text" | "json" | "github" | "sarif" | "template";
-
-/** 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;
@@ -281,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;
 }

package/src/conformance-record.ts

@@ -4,7 +4,7 @@ export const RECORD = {
   conformance: {
     corpusVersion: "6.0.0",
     result: "pass",
-    digest: "sha256:d65daae4b7c95050c07896b166d0250d233cca71f97de75a6086c1d80fe76232",
+    digest: "sha256:e4af2b9bcd07fd745101bf3215cd21e9df1448bdc332a791f25d5676cf15c794",
   },
   gaps: [],
 } as const;

package/src/consumers.ts

@@ -1,86 +1,36 @@
-/**
- * The consumers a scope declares, loaded beside the target: each a directory on the
- * local filesystem whose compiler configurations open as projects of the run's one
- * snapshot, and whose references to the target's declarations count against them.
- */
-
-import type { Config } from "./config.ts";
-import { consumerProjects } from "./discover.ts";
+import type { PartialConfig } from "./config.ts";
+import type { ParseFile } from "./entries/configuration-files.ts";
+import { runDirectories } from "./entries/run-directories.ts";
 import type { Host } from "./host.ts";
-import { inventory, packageScope } from "./inventory.ts";
+import { inventory } from "./inventory/enumerate.ts";
 import { relativePath } from "./paths.ts";
-import { references, type ConsumerSide, type Reference } from "./references.ts";
-import type { Module, Scope } from "./scope.ts";
-import { narrowedTo, type Engine, type ProjectView } from "./session.ts";
-
-/** One consumer the run loaded. */
-export interface LoadedConsumer {
-  /** The name the consumer publishes itself under, which every finding names it by. */
-  readonly id: string;
-  /** The consumer's directory, absolute. */
-  readonly path: string;
-}
-
-/** One declared consumer and the compiler configurations it opens as. */
-interface ConsumerLoad {
-  readonly consumer: LoadedConsumer;
-  /** The configuration files, absolute, in discovery order, none a target project's. */
-  readonly configFiles: readonly string[];
-}
-
-/** The name one module publishes itself under: the scope's, else its manifest's. */
-export function moduleIdentity(host: Host, module: Module): string {
-  return module.id === "" ? packageScope(host, module.path)("index.ts").package : module.id;
-}
-
-/**
- * Every consumer the scope declares, in its order, with the projects it opens as. A
- * configuration that is also one of the target's projects, or an earlier consumer's, is
- * that project's alone. A consumer whose directory is absent, is no directory or holds
- * no configuration ends the run naming it, before any project opens.
- */
-export function consumerLoads(
-  engine: Engine,
-  host: Host,
-  scope: Scope,
-  targetConfigFiles: readonly string[],
-): readonly ConsumerLoad[] {
-  const opened = new Set(targetConfigFiles);
-  return scope.consumers.map((module) => {
-    const configFiles = consumerProjects(engine, host, module.path).filter((configFile) => {
-      const fresh = !opened.has(configFile);
-      opened.add(configFile);
-      return fresh;
-    });
-    return { consumer: { id: moduleIdentity(host, module), path: module.path }, configFiles };
-  });
-}
+import { references, type ConsumerSide, type References } from "./references.ts";
+import { narrowedTo, type ProjectView } from "./session.ts";
+import { patternTestFile } from "./tests/file-class.ts";
 
 /**
  * Every reference one consumer project's own files make to a declaration of the target.
  * The target's declarations are enumerated over the target's files the consumer's
  * program holds, against the target root, so each carries the identifier the target's
- * own projects give it. A reference from a consumer's test file is a test reference
- * unless the configuration counts it as a production one.
+ * own projects give it. A reference from a consumer's test file is a test reference;
+ * whether the run counts it as a production one is the sweep's mode.
  */
 export function consumerReferences<Brand>(
   project: ProjectView<Brand>,
   host: Host,
   targetRoot: string,
   consumer: ConsumerSide,
-  config: Config,
-): readonly Reference[] {
+  config: PartialConfig,
+  parse: ParseFile,
+): References {
   const held = inventory(
     narrowedTo(project, (file) => relativePath(targetRoot, file.fileName) !== undefined),
     host,
     targetRoot,
   );
-  const found = references(project, held, targetRoot, {
-    testFiles: config.ts.testFiles,
+  return references(project, held, targetRoot, {
+    testFile: patternTestFile(config.ts.test_files, consumer.root),
     consumer,
-  }).references;
-  if (config.analysis.consumerTests !== "production") {
-    return found;
-  }
-  return found.map((reference) => (reference.test ? { ...reference, test: false } : reference));
+    directories: runDirectories(host, consumer.root, parse),
+  });
 }