@cplieger/deadset-ts 4.0.1 → 5.0.0

package/dist/src/component-layer.js

@@ -0,0 +1,132 @@
+/**
+ * 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 { dirnamePath, joinPath } from "./paths.js";
+/** The name the mapper's manifest declares and every configuration's entry names. */
+export const MAPPER_PACKAGE = "deadset-ts-component-files";
+/** The manifest of the mapper's package, which runs `command`. */
+export function mapperManifest(command) {
+    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, from) {
+    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, from) {
+    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, from) {
+    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, mappers) {
+    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)}`;
+}
+/**
+ * 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, configFiles, mapper, written = new Map()) {
+    const mappers = mapper === undefined ? [] : [{ package: MAPPER_PACKAGE, extensions: [...mapper.extensions] }];
+    const files = {};
+    const symlinks = {};
+    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/dist/src/config.js

@@ -21,7 +21,7 @@ export function defaultConfig() {
         targetKind: "",
         analysis: {
             languages: [],
-            minConfidence: "possible",
+            minConfidence: "probable",
             generatedFiles: "exclude",
             consumerTests: "test",
             configurations: [],
@@ -47,8 +47,15 @@ export function defaultConfig() {
             ],
         },
         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/dist/src/configuration-files.js

@@ -0,0 +1,186 @@
+/**
+ * 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, } from "@typescript/native/unstable/ast";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
+const MANIFEST = "package.json";
+/** A configuration module's name, each form with the spelling a root reports it by. */
+const MODULE_FORMS = [
+    { 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",
+];
+/** The prefixes a string names a file with, relative to the file that writes it. */
+const RELATIVE_PREFIXES = ["./", "../"];
+/** 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",
+];
+/** The file's name, the last segment of its path. */
+function basename(path) {
+    return path.slice(path.lastIndexOf("/") + 1);
+}
+function isRecord(value) {
+    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) {
+    return MODULE_FORMS.find((one) => one.name.test(name))?.form;
+}
+/** Whether one file name is a JSON configuration file's. */
+export function isConfigurationDocumentName(name) {
+    return DOCUMENT_NAME.test(name);
+}
+/** Every string value one decoded JSON value holds at any depth. */
+export function documentStrings(value) {
+    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) {
+    const found = [];
+    const visit = (node) => {
+        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, targetRoot, files) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const manifests = new Map();
+    const holdsManifest = (dir) => {
+        let held = manifests.get(dir);
+        if (held === undefined) {
+            held = host.kindOf(joinPath(dir, MANIFEST)) === "file";
+            manifests.set(dir, held);
+        }
+        return held;
+    };
+    const modules = [];
+    const dirs = new Set([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 = [];
+    for (const dir of [...dirs].sort()) {
+        if (!holdsManifest(dir)) {
+            continue;
+        }
+        let names;
+        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;
+            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, dir) {
+    let value;
+    try {
+        value = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
+    }
+    catch {
+        return [];
+    }
+    if (!isRecord(value)) {
+        return [];
+    }
+    const names = new Set();
+    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, declared) {
+    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, dir, text) {
+    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/dist/src/conformance-record.js

@@ -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: [
         {