@cplieger/deadset-ts 8.0.0-dev.7 → 8.0.0-dev.9

package/dist/src/config.js

@@ -1,75 +1,18 @@
-import { CONTRACT_VERSION, } from "./contract/contract.generated.js";
-import { LANGUAGE, PRODUCT } from "./product.js";
+import { SEVERITIES } from "./contract/contract.generated.js";
+import { LANGUAGE } from "./product.js";
 /**
  * The name of the repository configuration at the target root, which is also the
  * document a finding about the configuration names where no document of the
  * target supplied the setting it is about.
  */
 export const REPOSITORY_DOCUMENT = "deadset.json";
-/** The kind a target kind setting gives one language's declarations. */
-export function kindOf(setting, language) {
-    return typeof setting === "string" ? setting : setting[language];
+/** The kind a target kind setting gives this analyzer's declarations. */
+export function kindOf(kind) {
+    return typeof kind === "string" ? kind : kind[LANGUAGE];
 }
-/** The severities ranked, the strongest highest. */
-const SEVERITY_RANK = { allow: 0, warn: 1, deny: 2 };
 /** Whether a finding at one severity fails a run under the failing severity. */
 export function fails(severity, failOn) {
-    return SEVERITY_RANK[severity] >= SEVERITY_RANK[failOn];
-}
-/**
- * The configuration every documented default states. `targetKind` is empty: the
- * field has no default and is never inferred.
- */
-export function defaultConfig() {
-    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: PRODUCT, languages: [LANGUAGE], command: PRODUCT },
-            ],
-        },
-        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);
 }
 /**
  * Renders the origin as the provenance value the Contract declares: `default`,
@@ -78,23 +21,3 @@ export function defaultConfig() {
 export function renderOrigin(origin) {
     return origin.source === "default" ? "default" : `${origin.source}: ${origin.label}`;
 }
-/**
- * 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.
- */
-export class ConfigError extends Error {
-    /** Which refusal this is. */
-    kind;
-    /**
-     * The key or field the message names, spelled as the document spells it. It is
-     * empty when the refusal names none.
-     */
-    key;
-    constructor(kind, key, message) {
-        super(message);
-        this.name = "ConfigError";
-        this.kind = kind;
-        this.key = key;
-    }
-}

package/dist/src/configuration-files.js

@@ -11,7 +11,7 @@ import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "./p
 import { bytewise } from "./text/compare.js";
 import { isRecord } from "./json-document.js";
 import { filesIn } from "./fs/tree.js";
-import { holdsManifest, inInstalledPackages, manifestAt, readJSON } from "./fs/manifest.js";
+import { DEPENDENCY_SECTIONS, holdsManifest, inInstalledPackages, manifestAt, readJSON, } from "./fs/manifest.js";
 import { shellWords } from "./text/shell.js";
 /** A configuration module's name, each form with the spelling a root reports it by. */
 const MODULE_FORMS = [
@@ -24,13 +24,6 @@ const MODULE_FORMS = [
 ];
 /** 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 JavaScript extensions a relative specifier from a configuration file stands for TypeScript under. */
@@ -351,7 +344,7 @@ export function declaredIn(host, dir) {
         return [];
     }
     const names = new Set();
-    for (const member of DEPENDENCY_MEMBERS) {
+    for (const member of DEPENDENCY_SECTIONS) {
         const section = value[member];
         if (isRecord(section)) {
             Object.keys(section).forEach((name) => names.add(name));

package/dist/src/configured-declarations.js

@@ -179,19 +179,19 @@ export function resolveEntries(project, held, entries) {
     for (const symbol of held.symbols) {
         byRef.set(symbol.ref, [...(byRef.get(symbol.ref) ?? []), symbol.id]);
     }
-    const modules = modulesNamed(project, new Set(entries.flatMap((entry) => (entry.shape === "module" ? [entry.module] : []))));
+    const modules = modulesNamed(project, new Set(entries.flatMap((entry) => ("module" in entry ? [entry.module] : []))));
     return entries.map((entry) => {
-        if (entry.shape === "symbol") {
+        if ("symbol" in entry) {
             return { entry, handles: new Set(), ids: new Set(byRef.get(entry.symbol) ?? []) };
         }
-        const { components, static: isStatic } = componentsOf(entry.shape === "module" ? entry.name : entry.global);
+        const { components, static: isStatic } = componentsOf("module" in entry ? entry.name : entry.global);
         const [first = "", ...rest] = components;
         let start;
         if (isStatic && rest.length === 0) {
             // Only a member is static, and a path of one component names no member.
             start = undefined;
         }
-        else if (entry.shape === "module") {
+        else if ("module" in entry) {
             const module = modules.get(entry.module);
             start = module === undefined ? undefined : memberOf(project, module, first, false);
         }
@@ -246,14 +246,10 @@ export function entriesAt(project, chains, nodes, resolved) {
  * program the display name the inventory gives it.
  */
 export function spelledEntry(entry, held) {
-    switch (entry.shape) {
-        case "symbol":
-            return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
-        case "module":
-            return entry.name;
-        case "global":
-            return entry.global;
+    if ("symbol" in entry) {
+        return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
     }
+    return "module" in entry ? entry.name : entry.global;
 }
 /** The key under which a lifecycle contract's declarations are configured. */
 const LIFECYCLE_KEY = "ts.lifecycle_contracts";
@@ -264,11 +260,14 @@ const LIFECYCLE_KEY = "ts.lifecycle_contracts";
  */
 export function configuredDeclarations(config) {
     return [
-        ...config.ts.injectionRegistrations.map((entry) => ({
+        ...config.ts.injection_registrations.map((entry) => ({
             key: "ts.injection_registrations",
             entry,
         })),
-        ...config.ts.lifecycleContracts.flatMap((contract) => [...contract.components, ...contract.bases].map((entry) => ({ key: LIFECYCLE_KEY, entry }))),
+        ...config.ts.lifecycle_contracts.flatMap((contract) => [...(contract.components ?? []), ...(contract.bases ?? [])].map((entry) => ({
+            key: LIFECYCLE_KEY,
+            entry,
+        }))),
         ...config.ts.serializers.map((entry) => ({ key: "ts.serializers", entry })),
     ];
 }
@@ -294,12 +293,8 @@ export function declarationsNamed(project, held, configured) {
  * sign and its name, and a global entry's path after a number sign.
  */
 export function configuredRef(entry) {
-    switch (entry.shape) {
-        case "symbol":
-            return entry.symbol;
-        case "module":
-            return `${entry.module}#${entry.name}`;
-        case "global":
-            return `#${entry.global}`;
+    if ("symbol" in entry) {
+        return entry.symbol;
     }
+    return "module" in entry ? `${entry.module}#${entry.name}` : `#${entry.global}`;
 }

package/dist/src/consumers.js

@@ -1,34 +1,7 @@
-/**
- * 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 { consumerProjects } from "./discover.js";
-import { inventory, packageScope } from "./inventory.js";
+import { inventory } from "./inventory.js";
 import { relativePath } from "./paths.js";
 import { references } from "./references.js";
 import { narrowedTo } from "./session.js";
-/** The name one module publishes itself under: the scope's, else its manifest's. */
-export function moduleIdentity(host, module) {
-    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, host, scope, targetConfigFiles) {
-    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 };
-    });
-}
 /**
  * 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
@@ -39,10 +12,10 @@ export function consumerLoads(engine, host, scope, targetConfigFiles) {
 export function consumerReferences(project, host, targetRoot, consumer, config) {
     const held = inventory(narrowedTo(project, (file) => relativePath(targetRoot, file.fileName) !== undefined), host, targetRoot);
     const found = references(project, held, targetRoot, {
-        testFiles: config.ts.testFiles,
+        testFiles: config.ts.test_files,
         consumer,
     }).references;
-    if (config.analysis.consumerTests !== "production") {
+    if (config.analysis.consumer_tests !== "production") {
         return found;
     }
     return found.map((reference) => (reference.test ? { ...reference, test: false } : reference));