@cplieger/deadset-ts 4.0.1 → 5.0.0

package/src/component-layer.ts

@@ -0,0 +1,160 @@
+/**
+ * How a snapshot reads component files: a file-system layer that never reaches the disk gives
+ * every configuration the snapshot opens a `contentMappers` member naming this analyzer's own
+ * mapper, or none, in place of any the configuration declares, because a configuration's own
+ * member wins over one it extends. The mapper resolves as a package linked into the
+ * `node_modules` beside each configuration, to a directory holding only its manifest.
+ */
+
+import type { CreateSnapshotParams } from "@typescript/native/unstable/sync";
+import type { Host } from "./host.ts";
+import { dirnamePath, joinPath } from "./paths.ts";
+
+/** The name the mapper's manifest declares and every configuration's entry names. */
+export const MAPPER_PACKAGE = "deadset-ts-component-files";
+
+/** The file system one snapshot is created with. */
+export type SnapshotFileSystem = NonNullable<CreateSnapshotParams["fileSystem"]>;
+
+/** The manifest of the mapper's package, which runs `command`. */
+export function mapperManifest(command: readonly string[]): string {
+  return `${JSON.stringify(
+    {
+      name: MAPPER_PACKAGE,
+      version: "0.0.0",
+      private: true,
+      typescript: { contentMapper: { exec: command } },
+    },
+    null,
+    2,
+  )}\n`;
+}
+
+/** The offset past the white space and comments from `at`. */
+function pastTrivia(text: string, from: number): number {
+  let at = from;
+  for (;;) {
+    if (/\s/u.test(text[at] ?? "x")) {
+      at += 1;
+    } else if (text.startsWith("//", at)) {
+      const end = text.slice(at).search(/[\n\r]/u);
+      at = end < 0 ? text.length : at + end;
+    } else if (text.startsWith("/*", at)) {
+      const end = text.indexOf("*/", at + 2);
+      at = end < 0 ? text.length : end + 2;
+    } else {
+      return at;
+    }
+  }
+}
+
+/** The offset past the string opening at `from`. */
+function pastString(text: string, from: number): number {
+  let at = from + 1;
+  while (at < text.length && text[at] !== '"') {
+    at += text[at] === "\\" ? 2 : 1;
+  }
+  return at + 1;
+}
+
+/** The offset past the value starting at `from`: a string, a bracketed value, or a bare word. */
+function pastValue(text: string, from: number): number {
+  const first = text[from];
+  if (first === '"') {
+    return pastString(text, from);
+  }
+  if (first !== "{" && first !== "[") {
+    let at = from;
+    while (at < text.length && /[^\s,}\]/]/u.test(text[at] ?? "")) {
+      at += 1;
+    }
+    return at;
+  }
+  let depth = 0;
+  let at = from;
+  while (at < text.length) {
+    at = pastTrivia(text, at);
+    const char = text[at];
+    if (char === '"') {
+      at = pastString(text, at);
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      depth += 1;
+    } else if (char === "}" || char === "]") {
+      depth -= 1;
+      if (depth === 0) {
+        return at + 1;
+      }
+    }
+    at += 1;
+  }
+  return at;
+}
+
+/**
+ * One configuration's text with its top-level `contentMappers` member set to `mappers`,
+ * the member's own value replaced where it has one and the member written first
+ * otherwise. Every line keeps its number. Text that holds no object is returned as is,
+ * for the compiler to refuse.
+ */
+export function withContentMappers(text: string, mappers: unknown): string {
+  const value = JSON.stringify(mappers);
+  const open = pastTrivia(text, 0);
+  if (text[open] !== "{") {
+    return text;
+  }
+  let at = pastTrivia(text, open + 1);
+  const empty = text[at] === "}";
+  while (at < text.length && text[at] === '"') {
+    const keyEnd = pastString(text, at);
+    const key = text.slice(at, keyEnd);
+    const valueStart = pastTrivia(text, pastTrivia(text, keyEnd) + 1);
+    const valueEnd = pastValue(text, valueStart);
+    if (key === '"contentMappers"') {
+      return text.slice(0, valueStart) + value + text.slice(valueEnd);
+    }
+    at = pastTrivia(text, valueEnd);
+    if (text[at] !== ",") {
+      break;
+    }
+    at = pastTrivia(text, at + 1);
+  }
+  return `${text.slice(0, open + 1)}"contentMappers":${value}${empty ? "" : ","}${text.slice(open + 1)}`;
+}
+
+/** This analyzer's mapper: the extensions it reads and the directory of its package. */
+interface ComponentMapper {
+  readonly extensions: readonly string[];
+  readonly packageDirectory: string;
+}
+
+/**
+ * The layer one snapshot is created with: every configuration named carrying `mapper`, its
+ * package linked beside it, or no mapper at all where `mapper` is absent. A configuration
+ * `written` holds is that text, which exists nowhere else; any other is read through the host.
+ */
+export function componentLayer(
+  host: Host,
+  configFiles: readonly string[],
+  mapper: ComponentMapper | undefined,
+  written: ReadonlyMap<string, string> = new Map(),
+): SnapshotFileSystem {
+  const mappers =
+    mapper === undefined ? [] : [{ package: MAPPER_PACKAGE, extensions: [...mapper.extensions] }];
+  const files: Record<string, string> = {};
+  const symlinks: Record<string, { target: string; host: boolean }> = {};
+  for (const configFile of configFiles) {
+    files[configFile] = withContentMappers(
+      written.get(configFile) ?? host.readFile(configFile),
+      mappers,
+    );
+    if (mapper !== undefined) {
+      symlinks[joinPath(dirnamePath(configFile), "node_modules", MAPPER_PACKAGE)] = {
+        target: mapper.packageDirectory,
+        host: true,
+      };
+    }
+  }
+  return { kind: "layer", files, symlinks };
+}

package/src/config.ts

@@ -162,6 +162,8 @@ export interface Providers {
 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[];
@@ -202,7 +204,7 @@ export function defaultConfig(): Config {
     targetKind: "",
     analysis: {
       languages: [],
-      minConfidence: "possible",
+      minConfidence: "probable",
       generatedFiles: "exclude",
       consumerTests: "test",
       configurations: [],
@@ -228,8 +230,15 @@ export function defaultConfig(): Config {
       ],
     },
     ts: {
-      testFiles: ["**/*.test.{ts,tsx,mts,cts}"],
+      testFiles: [
+        "**/*.test.{ts,tsx,mts,cts}",
+        "**/*.spec.*",
+        "**/__tests__/**",
+        "**/__mocks__/**",
+      ],
       entryFiles: [],
+      componentExtensions: [".vue", ".svelte", ".astro"],
+      disabledConventions: [],
       injectionRegistrations: [],
       lifecycleContracts: [],
       serializers: [],

package/src/configuration-files.ts

@@ -0,0 +1,235 @@
+/**
+ * The configuration files a tool loads by name, and the strings they hold. A file in a
+ * directory that holds a `package.json` is a configuration module when its name is
+ * `<stem>.config.<ext>`, `<stem>.<qualifier>.config.<ext>` or `.<stem>rc.<ext>`, and a
+ * JSON configuration file when its name is the JSON form of one of them. A tool reads
+ * every string either holds as it likes, so each one that spells a declared dependency
+ * uses it and each relative one that names a source file of the program roots the file.
+ */
+
+import {
+  isNoSubstitutionTemplateLiteral,
+  isStringLiteral,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/unstable/ast";
+import type { Host } from "./host.ts";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import type { SourceFiles } from "./source-files.ts";
+
+const MANIFEST = "package.json";
+
+/** 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,
+    form: "<stem>.<qualifier>.config.<ext>",
+  },
+  { name: /^\.[\w-]+rc\.(?:js|mjs|cjs)$/u, form: ".<stem>rc.<ext>" },
+];
+
+/** A JSON configuration file's name. */
+const DOCUMENT_NAME = /^(?:[\w-]+(?:\.[\w-]+)?\.config\.json|\.[\w-]+rc(?:\.json)?)$/u;
+
+/** The manifest members a dependency is declared in. */
+const DEPENDENCY_MEMBERS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies",
+] as const;
+
+/** The prefixes a string names a file with, relative to the file that writes it. */
+const RELATIVE_PREFIXES = ["./", "../"] as const;
+
+/** The extensions the program's module resolution appends to a specifier written without one. */
+const RESOLVED_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".d.ts",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+] as const;
+
+/** The file's name, the last segment of its path. */
+function basename(path: string): string {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** The form one file name is as a configuration module, or undefined where it is none. */
+export function configurationModuleForm(name: string): string | undefined {
+  return MODULE_FORMS.find((one) => one.name.test(name))?.form;
+}
+
+/** Whether one file name is a JSON configuration file's. */
+export function isConfigurationDocumentName(name: string): boolean {
+  return DOCUMENT_NAME.test(name);
+}
+
+/** One JSON configuration file, with every string value it holds. */
+interface ConfigurationDocument {
+  /** The file, absolute. */
+  readonly path: string;
+  /** Every string value at any depth, in document order; a member's name is no value. */
+  readonly strings: readonly string[];
+}
+
+/** The configuration files one project holds and sits beside. */
+interface ConfigurationFiles {
+  /** Every own file that is a configuration module, with the form its name has. */
+  readonly modules: readonly { readonly file: SourceFile; readonly form: string }[];
+  /** Every JSON configuration file in a directory of the project's files or above one. */
+  readonly documents: readonly ConfigurationDocument[];
+}
+
+/** Every string value one decoded JSON value holds at any depth. */
+export function documentStrings(value: unknown): string[] {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap(documentStrings);
+  }
+  return isRecord(value) ? Object.values(value).flatMap(documentStrings) : [];
+}
+
+/** Every string literal and every template literal with no substitution one file writes. */
+export function moduleStrings(
+  file: SourceFile,
+): readonly { readonly node: Node; readonly text: string }[] {
+  const found: { node: Node; text: string }[] = [];
+  const visit = (node: Node): void => {
+    if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
+      found.push({ node, text: node.text });
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  return found;
+}
+
+/**
+ * The configuration files of one project's own files below the target root. A module
+ * is an own file; a JSON configuration file is read from each directory below the
+ * target root, the root included, that holds an own file or is above one. Either sits
+ * in a directory that holds a manifest. A document that cannot be read or parsed as
+ * JSON holds no string.
+ */
+export function configurationFiles(
+  host: Host,
+  targetRoot: string,
+  files: SourceFiles,
+): ConfigurationFiles {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  const manifests = new Map<string, boolean>();
+  const holdsManifest = (dir: string): boolean => {
+    let held = manifests.get(dir);
+    if (held === undefined) {
+      held = host.kindOf(joinPath(dir, MANIFEST)) === "file";
+      manifests.set(dir, held);
+    }
+    return held;
+  };
+
+  const modules: { file: SourceFile; form: string }[] = [];
+  const dirs = new Set<string>([root]);
+  for (const file of files.byPath.values()) {
+    const form = configurationModuleForm(basename(file.fileName));
+    if (form !== undefined && holdsManifest(dirnamePath(file.fileName))) {
+      modules.push({ file, form });
+    }
+    for (
+      let dir = dirnamePath(file.fileName);
+      relativePath(root, dir) !== undefined && !dirs.has(dir);
+      dir = dirnamePath(dir)
+    ) {
+      dirs.add(dir);
+    }
+  }
+
+  const documents: ConfigurationDocument[] = [];
+  for (const dir of [...dirs].sort()) {
+    if (!holdsManifest(dir)) {
+      continue;
+    }
+    let names: readonly string[];
+    try {
+      names = host
+        .readDirectory(dir)
+        .filter((entry) => !entry.directory && isConfigurationDocumentName(entry.name))
+        .map((entry) => entry.name)
+        .sort();
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      const path = joinPath(dir, name);
+      let value: unknown;
+      try {
+        value = JSON.parse(host.readFile(path));
+      } catch {
+        continue;
+      }
+      documents.push({ path, strings: documentStrings(value) });
+    }
+  }
+  return { modules, documents };
+}
+
+/** Every dependency the manifest in one directory declares, or none where it holds none to read. */
+export function declaredIn(host: Host, dir: string): readonly string[] {
+  let value: unknown;
+  try {
+    value = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
+  } catch {
+    return [];
+  }
+  if (!isRecord(value)) {
+    return [];
+  }
+  const names = new Set<string>();
+  for (const member of DEPENDENCY_MEMBERS) {
+    const section = value[member];
+    if (isRecord(section)) {
+      Object.keys(section).forEach((name) => names.add(name));
+    }
+  }
+  return [...names];
+}
+
+/** The dependencies one string uses: each it equals, or is followed by `/` and a subpath in. */
+export function dependenciesNamed(text: string, declared: readonly string[]): readonly string[] {
+  return declared.filter((name) => text === name || text.startsWith(`${name}/`));
+}
+
+/**
+ * The own files one string names read against a directory: none unless it starts with
+ * `./` or `../`, else the file it names directly or through the emit mapping, or the
+ * file it names with an extension the module resolution appends.
+ */
+export function filesNamedBy(files: SourceFiles, dir: string, text: string): readonly SourceFile[] {
+  if (!RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix)) || text.includes("*")) {
+    return [];
+  }
+  const path = resolvePath(dir, text);
+  const direct = files.named(path);
+  if (direct.length > 0) {
+    return direct;
+  }
+  for (const extension of RESOLVED_EXTENSIONS) {
+    const held = files.byName.get(path + extension);
+    if (held !== undefined) {
+      return [held];
+    }
+  }
+  return [];
+}

package/src/conformance-record.ts

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
   conformance: {
-    corpusVersion: "2.0.0",
+    corpusVersion: "2.1.1",
     result: "pass",
-    digest: "sha256:1274315595d7b944d22eb0126081e24cf293c9fe53a236f4d263c714644f32ee",
+    digest: "sha256:e5e456bf3a706f1fa9f906ae71e10ea98a78da52d7d99a5ed59dca8a72bbe927",
   },
   gaps: [
     {