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

package/dist/src/roots.js

@@ -13,13 +13,15 @@ import { isGlobalBlock } from "./augmentations.js";
 import { filesNamedBy, outsideChain, relativeSpecifiers, } from "./configuration-files.js";
 import { conventionEntries } from "./conventions.js";
 import { entryPoints } from "./entry-points.js";
-import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { ancestors, dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { byPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
 import { typeQueryAliases } from "./type-query-alias.js";
+import { bytewise } from "./text/compare.js";
+import { holdsManifest } from "./fs/manifest.js";
+import { globExpression } from "./text/glob.js";
 /** Whether one declaration is written below the directory of a published workspace member. */
 function inPublishedMember(held, id, root, members) {
     const path = held.symbols.find((symbol) => symbol.id === id)?.position.path;
@@ -47,13 +49,8 @@ const OUTPUT_EXTENSION = /\.(?:d\.ts|d\.mts|d\.cts|js|mjs|cjs|jsx)$/u;
 const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
 /** Whether no `package.json` sits between one file and the manifest's directory, which holds it. */
 function ofPackage(host, dir, file) {
-    for (let at = dirnamePath(file); at !== dir; at = dirnamePath(at)) {
-        if (relativePath(dir, at) === undefined ||
-            host.kindOf(joinPath(at, "package.json")) === "file") {
-            return false;
-        }
-    }
-    return true;
+    const between = ancestors(dirnamePath(file), dir);
+    return between.length > 0 && !between.slice(0, -1).some((at) => holdsManifest(host, at));
 }
 /**
  * The rooted files one manifest target reads back to by name: its path below the
@@ -163,13 +160,6 @@ export function matchRef(pattern, ref) {
     }
     return matchGlob(Array.from(pattern), Array.from(ref));
 }
-/** Two strings ordered bytewise, which is the order every set of a run is read in. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /** The members of one declaration, indexed by the container that holds them. */
 function childrenOf(held) {
     const byParent = new Map();
@@ -344,7 +334,7 @@ export function roots(project, held, targetRoot, options) {
         const left = sites.get(a.id);
         const right = sites.get(b.id);
         const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
-        return site || compare(a.kind, b.kind) || compare(a.source, b.source);
+        return site || bytewise(a.kind, b.kind) || bytewise(a.source, b.source);
     });
     return {
         liveUnderReachability: ordered,

package/dist/src/run.js

@@ -1,9 +1,12 @@
+import { CONFIG_MAX_BYTES, SETTINGS } from "./contract/config.generated.js";
 import { EXIT_FAILURE, EXIT_USAGE } from "./contract/contract.generated.js";
-import { ConfigError, REPOSITORY_DOCUMENT } from "./config.js";
+import { REPOSITORY_DOCUMENT } from "./config.js";
 import { DiscoveryError, renderDiagnostic } from "./discover.js";
+import { readTargetDocument, TargetDocumentError } from "./fs/document.js";
 import { joinPath, resolvePath } from "./paths.js";
 import { readScope, ScopeError, scopeForDir } from "./scope.js";
 import { SetupError, setupLine } from "./setup-failure.js";
+import { UsageError } from "./usage.js";
 import { openEngine } from "./session.js";
 import { printConfigVerb } from "./verbs/print-config.js";
 import { printProjectsVerb } from "./verbs/print-projects.js";
@@ -14,6 +17,7 @@ import { describeVerb } from "./verbs/describe.js";
 import { EXPLAIN_OPTIONS, explainVerb } from "./verbs/explain.js";
 import {} from "./verbs/verb.js";
 import { versionVerb } from "./verbs/version.js";
+import { diagnose, message, PRODUCT } from "./product.js";
 /** Every verb this command answers, in the order the usage text lists them. */
 const VERBS = [
     { name: "analyze", run: analyzeVerb, options: ANALYZE_OPTIONS },
@@ -25,7 +29,7 @@ const VERBS = [
     { name: "describe", run: describeVerb },
     { name: "version", run: versionVerb },
 ];
-const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
+const USAGE = `usage: ${PRODUCT} <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
 /**
  * The tokens whose presence in an option's name makes that option a request to
  * edit a source file. The set is closed, and a token is matched in any position of
@@ -33,29 +37,12 @@ const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) =>
  */
 const SOURCE_EDIT_TOKENS = ["fix", "edit", "delete", "rewrite"];
 /**
- * Maps an option name to the setting of the Contract's configuration schema it supplies,
- * so one entry registers the option, supplies the document resolution reads, and gives
- * the spelling the setting's provenance names. The name is this command's vocabulary and
- * is never derived from the path: a setting reaches the command line only by an entry,
- * and a path names a key the schema declares.
+ * Maps an option name to the setting of the Contract's configuration schema it supplies:
+ * the options contract/settings.json names for a setting this analyzer reads.
  */
-export const SETTING_OPTIONS = new Map([
-    ["min-confidence", "analysis.min_confidence"],
-    ["sort", "reporters.sort"],
-    ["cascade", "reporters.cascade"],
-    ["max-findings", "reporters.max_findings"],
-    ["fail-on", "reporters.fail_on"],
-]);
+export const SETTING_OPTIONS = new Map(SETTINGS.flatMap((row) => (row.option === undefined ? [] : [[row.option, row.key]])));
 /** The options that take a value and are not settings. */
 const PLAIN_OPTIONS = new Set(["target", "config", "central", "scope"]);
-/**
- * The setting options whose value is an integer rather than a string. A value
- * written other than as digits is passed on as the string it is, so resolution
- * refuses it by its type rather than reading `1e2` as 100.
- */
-const INTEGER_OPTIONS = new Set(["max-findings"]);
-/** An integer as an option writes it: an optional minus sign and digits alone. */
-const INTEGER_TEXT = /^-?[0-9]+$/u;
 /** No option beyond the ones every verb takes. */
 const NO_OPTIONS = { plain: [], repeatable: [] };
 /**
@@ -82,7 +69,7 @@ function readOptions(args, own) {
     const repeated = new Map();
     for (const arg of args) {
         if (!arg.startsWith("-")) {
-            throw new ConfigError("malformed", "", `unexpected argument ${JSON.stringify(arg)}`);
+            throw new UsageError(`unexpected argument ${JSON.stringify(arg)}`);
         }
         const [spelled, ...rest] = arg.split("=");
         const name = (spelled ?? "").replace(/^-+/u, "");
@@ -90,10 +77,10 @@ function readOptions(args, own) {
             !SETTING_OPTIONS.has(name) &&
             !own.plain.includes(name) &&
             !own.repeatable.includes(name)) {
-            throw new ConfigError("malformed", "", `unknown option ${JSON.stringify(spelled ?? arg)}`);
+            throw new UsageError(`unknown option ${JSON.stringify(spelled ?? arg)}`);
         }
         if (rest.length === 0) {
-            throw new ConfigError("malformed", "", `option ${JSON.stringify(spelled ?? arg)} takes a value`);
+            throw new UsageError(`option ${JSON.stringify(spelled ?? arg)} takes a value`);
         }
         const value = rest.join("=");
         named.set(name, value);
@@ -101,45 +88,54 @@ function readOptions(args, own) {
     }
     return { named, repeated };
 }
-function readFileOr(host, path, orUndefined) {
+/** The document an option names. */
+function documentAt(host, label) {
     try {
-        return host.readFile(resolvePath(host.workingDirectory(), path));
+        const path = resolvePath(host.workingDirectory(), label);
+        // A file past the bound reads as one byte more than it, which resolution refuses.
+        return { text: host.readFile(path, CONFIG_MAX_BYTES + 1), label };
     }
     catch (error) {
-        if (orUndefined) {
-            return undefined;
-        }
-        throw new ConfigError("malformed", "", `${path}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new UsageError(`${label}: ${message(error)}`);
     }
 }
 /**
- * The configuration documents one invocation reads: the repository configuration
- * at the target root or the path an option named, the central configuration, and
- * the settings the options supply as one flag document.
+ * The repository configuration at the target root, none where it is absent. One that
+ * cannot be read is a configuration document that cannot be, refused with the usage code.
+ */
+function repositoryAt(host, target) {
+    const label = joinPath(target, REPOSITORY_DOCUMENT);
+    const root = resolvePath(host.workingDirectory(), target);
+    try {
+        const text = readTargetDocument(host, root, REPOSITORY_DOCUMENT, label);
+        return text === undefined ? undefined : { text, label };
+    }
+    catch (error) {
+        throw error instanceof TargetDocumentError ? new UsageError(error.message) : error;
+    }
+}
+/**
+ * The configuration sources one invocation carries: the repository configuration at
+ * the target root or the path an option named, the central configuration, and the
+ * text each setting option was given.
  */
 function inputsOf(host, options) {
-    const target = options.named.get("target") ?? ".";
     const named = options.named.get("config");
-    const repositoryLabel = named ?? joinPath(target, REPOSITORY_DOCUMENT);
-    const repository = readFileOr(host, repositoryLabel, named === undefined);
+    const target = options.named.get("target") ?? ".";
+    const repository = named === undefined ? repositoryAt(host, target) : documentAt(host, named);
     const centralLabel = options.named.get("central");
-    const central = centralLabel === undefined ? undefined : readFileOr(host, centralLabel, false);
-    const flat = {};
-    const flagLabels = new Map();
-    for (const [name, path] of SETTING_OPTIONS) {
+    const central = centralLabel === undefined ? undefined : documentAt(host, centralLabel);
+    const flags = new Map();
+    for (const [name, key] of SETTING_OPTIONS) {
         const value = options.named.get(name);
-        if (value === undefined) {
-            continue;
+        if (value !== undefined) {
+            flags.set(key, value);
         }
-        flat[path] = INTEGER_OPTIONS.has(name) && INTEGER_TEXT.test(value) ? Number(value) : value;
-        flagLabels.set(path, `--${name}`);
     }
-    const flags = Object.keys(flat).length === 0 ? undefined : JSON.stringify(flat);
     return {
-        ...(flags === undefined ? {} : { flags }),
-        ...(repository === undefined ? {} : { repository, repositoryLabel }),
-        ...(central === undefined || centralLabel === undefined ? {} : { central, centralLabel }),
-        flagLabels,
+        flags,
+        ...(repository === undefined ? {} : { repository }),
+        ...(central === undefined ? {} : { central }),
     };
 }
 /** The scope one invocation analyzes: the document an option named, or the target. */
@@ -155,14 +151,12 @@ function scopeOf(host, options) {
  * the exit code: 0 for a completed verb, 1 for a finding that fails the run, 2 for a
  * usage error, a requested source edit or a refused configuration, 3 for a failure that
  * produced no answer. It writes nothing outside `out` and `err` and never exits the
- * process. `host` is the platform the run reads, the version it reports included, and
- * `openClient` opens the compiler client; a caller that watches what a run reads
- * supplies its own of either.
+ * process. A caller that watches what a run reads supplies its own `host` or `openClient`.
  */
 export function run(args, out, err, host, openClient = openEngine) {
     const editing = sourceEditOption(args);
     if (editing !== undefined) {
-        err.write(`deadset-ts: ${editing} is not supported: deadset-ts reports and never edits a source file\n`);
+        diagnose(err, `${editing} is not supported: ${PRODUCT} reports and never edits a source file`);
         err.write(USAGE);
         return EXIT_USAGE;
     }
@@ -172,7 +166,7 @@ export function run(args, out, err, host, openClient = openEngine) {
         return invoke(verb.run, verb.options ?? NO_OPTIONS, args.slice(1), { out, err, host }, openClient);
     }
     if (name !== undefined) {
-        err.write(`deadset-ts: unknown verb ${JSON.stringify(name)}\n`);
+        diagnose(err, `unknown verb ${JSON.stringify(name)}`);
     }
     err.write(USAGE);
     return EXIT_USAGE;
@@ -197,7 +191,7 @@ function invoke(verb, own, args, streams, openClient) {
             openClient: (config) => {
                 opened = openClient({
                     collectTiming: false,
-                    components: { extensions: config.ts.componentExtensions, host: streams.host },
+                    components: { extensions: config.ts.component_extensions, host: streams.host },
                 });
                 return opened;
             },
@@ -210,8 +204,8 @@ function invoke(verb, own, args, streams, openClient) {
 }
 /** Turns one refusal into the exit code the Contract's table gives it. */
 function refuse(error, err) {
-    if (error instanceof ConfigError) {
-        err.write(`deadset-ts: ${error.message}\n`);
+    if (error instanceof UsageError) {
+        diagnose(err, error.message);
         err.write(USAGE);
         return EXIT_USAGE;
     }
@@ -219,7 +213,7 @@ function refuse(error, err) {
         for (const diagnostic of error.diagnostics) {
             err.write(`${renderDiagnostic(diagnostic)}\n`);
         }
-        err.write(`deadset-ts: ${error.message}\n`);
+        diagnose(err, error.message);
         return EXIT_FAILURE;
     }
     if (error instanceof SetupError) {
@@ -228,8 +222,8 @@ function refuse(error, err) {
         }
         return EXIT_FAILURE;
     }
-    if (error instanceof ScopeError) {
-        err.write(`deadset-ts: ${error.message}\n`);
+    if (error instanceof ScopeError || error instanceof TargetDocumentError) {
+        diagnose(err, error.message);
         return EXIT_FAILURE;
     }
     throw error;