@mittwald/flow-codemods 1.1.0-next.10 → 1.1.0-next.11

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Mittwald CM Service GmbH & Co. KG and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/flow-codemods",
-  "version": "1.1.0-next.10",
+  "version": "1.1.0-next.11",
   "type": "module",
   "description": "Codemods and an upgrade CLI for consumers of Flow, mittwald's design system",
   "homepage": "https://flow.mittwald.de",
@@ -37,5 +37,6 @@
     "typescript": "^6.0.3",
     "vitest": "^4.1.11",
     "yaml": "^2.8.1"
-  }
+  },
+  "gitHead": "bc0ae71617e1e8da950269f0c5a0e765fae2c7aa"
 }

package/dist/checks/context.d.ts

@@ -1,16 +0,0 @@
-import type { CheckContext } from "./types.js";
-/**
- * Ripgrep's `-t ts` type: `.ts`, `.tsx`, `.cts`, `.mts`. Named once here so the
- * 21 detect/verify modules that translate a `rg -t ts '...'` field do not each
- * repeat the list.
- */
-export declare const tsExtensions: string[];
-/**
- * The shared `CheckContext` implementation — the only place under `src/checks`,
- * `src/detect` or `src/verify` that touches the filesystem. Pure Node
- * (`node:fs/promises`, regexes): no `rg`, `grep`, `tsc`, or any other
- * subprocess, so this runs the same on Windows, in a minimal CI container, or
- * without ripgrep installed.
- */
-export declare const createCheckContext: (path: string) => CheckContext;
-//# sourceMappingURL=context.d.ts.map

package/dist/checks/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/checks/context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAW,MAAM,YAAY,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,YAAY,UAAkC,CAAC;AA0B5D;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,SAAU,MAAM,KAAG,YA0CjD,CAAC"}

package/dist/checks/context.js

@@ -1,72 +0,0 @@
-import { readFile, readdir } from "node:fs/promises";
-import { extname, join } from "node:path";
-/**
- * Ripgrep's `-t ts` type: `.ts`, `.tsx`, `.cts`, `.mts`. Named once here so the
- * 21 detect/verify modules that translate a `rg -t ts '...'` field do not each
- * repeat the list.
- */
-export const tsExtensions = [".ts", ".tsx", ".cts", ".mts"];
-/**
- * Directories a check must never walk into.
- *
- * Not optional: `upgrade` runs `verify` after an install, so a walk without
- * this excludes a freshly populated `node_modules` — the exact omission that
- * was a Critical on this branch for the codemod runner (see `ignorePattern` in
- * `src/run/jscodeshift.ts`). `dist` and `.git` are excluded for the same
- * reason: build output and VCS internals are not the consumer's code.
- */
-const excludedDirs = new Set(["node_modules", "dist", ".git"]);
-const walk = async (dir) => {
-    const entries = await readdir(dir, { withFileTypes: true });
-    const found = await Promise.all(entries.map(async (entry) => {
-        if (entry.isDirectory()) {
-            return excludedDirs.has(entry.name) ? [] : walk(join(dir, entry.name));
-        }
-        return entry.isFile() ? [join(dir, entry.name)] : [];
-    }));
-    return found.flat();
-};
-/**
- * The shared `CheckContext` implementation — the only place under `src/checks`,
- * `src/detect` or `src/verify` that touches the filesystem. Pure Node
- * (`node:fs/promises`, regexes): no `rg`, `grep`, `tsc`, or any other
- * subprocess, so this runs the same on Windows, in a minimal CI container, or
- * without ripgrep installed.
- */
-export const createCheckContext = (path) => {
-    const files = async (extensions) => {
-        const all = await walk(path);
-        return extensions === undefined
-            ? all
-            : all.filter((file) => extensions.includes(extname(file)));
-    };
-    const read = (file) => readFile(file, "utf8");
-    const search = async (pattern, extensions) => {
-        const candidates = await files(extensions);
-        // A fresh, non-global copy of `pattern`: `.test()` on a `g`-flagged regex
-        // is stateful (it advances `lastIndex`), which would silently skip matches
-        // on later lines of the same file, or later files, depending on what the
-        // caller passed in.
-        const matcher = new RegExp(pattern.source, pattern.flags.replace("g", ""));
-        const findings = [];
-        for (const file of candidates) {
-            let content;
-            try {
-                content = await read(file);
-            }
-            catch {
-                // Unreadable — permissions, a broken symlink, binary content a strict
-                // decode chokes on. A check skips that one file rather than failing
-                // the whole run over it.
-                continue;
-            }
-            content.split("\n").forEach((line, index) => {
-                if (matcher.test(line)) {
-                    findings.push({ file, line: index + 1, text: line.trim() });
-                }
-            });
-        }
-        return findings;
-    };
-    return { path, files, read, search };
-};

package/dist/checks/load.d.ts

@@ -1,13 +0,0 @@
-import type { Detector, Verifier } from "./types.js";
-/**
- * Loads the detector for a catalogue id, or `undefined` when none exists yet.
- *
- * Only a fraction of the catalogue has a module so far — the rest follow in
- * later work. `detect`/`verify` (the CLI commands) must treat a missing module
- * as "nothing to run for this id" rather than a failure, so callers can loop
- * over the whole catalogue without special-casing which ids are covered.
- */
-export declare const loadDetector: (id: string) => Promise<Detector | undefined>;
-/** The `verify` counterpart of {@link loadDetector}. */
-export declare const loadVerifier: (id: string) => Promise<Verifier | undefined>;
-//# sourceMappingURL=load.d.ts.map

package/dist/checks/load.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/checks/load.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAuBrD;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,OACnB,MAAM,KACT,OAAO,CAAC,QAAQ,GAAG,SAAS,CAiB9B,CAAC;AAEF,wDAAwD;AACxD,eAAO,MAAM,YAAY,OACnB,MAAM,KACT,OAAO,CAAC,QAAQ,GAAG,SAAS,CAW9B,CAAC"}

package/dist/checks/load.js

@@ -1,53 +0,0 @@
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-/**
- * `<packageRoot>/{src,dist}/detect` and `.../verify`, resolved from wherever
- * this module itself runs — `src/checks/load.ts` under vitest (the `.ts`
- * sources), `dist/checks/load.js` from the built binary (the compiled `.js`).
- * Both mirror the same directory depth, so one relative path serves both.
- *
- * Unlike `src/transforms` (see the equivalent comment on `transformsDir` in
- * `src/run/jscodeshift.ts`), detect and verify modules compile into `dist`
- * normally: nothing here needs jscodeshift's babel pipeline, so there is no
- * reason to keep them as raw `.ts`.
- */
-const detectDir = fileURLToPath(new URL("../detect", import.meta.url));
-const verifyDir = fileURLToPath(new URL("../verify", import.meta.url));
-/**
- * Whether `<dir>/<id>` exists as either a compiled `.js` (the built binary) or
- * a source `.ts` (running under vitest, straight from `src`).
- */
-const exists = (dir, id) => existsSync(`${dir}/${id}.js`) || existsSync(`${dir}/${id}.ts`);
-/**
- * Loads the detector for a catalogue id, or `undefined` when none exists yet.
- *
- * Only a fraction of the catalogue has a module so far — the rest follow in
- * later work. `detect`/`verify` (the CLI commands) must treat a missing module
- * as "nothing to run for this id" rather than a failure, so callers can loop
- * over the whole catalogue without special-casing which ids are covered.
- */
-export const loadDetector = async (id) => {
-    if (!exists(detectDir, id)) {
-        return undefined;
-    }
-    // `@vite-ignore`: the id is only known at runtime, so this can never be a
-    // static specifier a bundler could pre-resolve — under plain Node (the
-    // built binary) that is a non-issue, but vitest runs test files through
-    // Vite's own module graph, and without the comment Vite tries to rewrite
-    // this into a glob import and fails with "Unknown variable dynamic
-    // import". The comment tells it to leave the import alone and let Node's
-    // loader resolve it, same as the built binary does.
-    const detectModule = (await import(
-    /* @vite-ignore */ `../detect/${id}.js`));
-    return detectModule.detector;
-};
-/** The `verify` counterpart of {@link loadDetector}. */
-export const loadVerifier = async (id) => {
-    if (!exists(verifyDir, id)) {
-        return undefined;
-    }
-    // See the matching comment in `loadDetector` above.
-    const verifyModule = (await import(
-    /* @vite-ignore */ `../verify/${id}.js`));
-    return verifyModule.verifier;
-};

package/dist/checks/types.d.ts

@@ -1,49 +0,0 @@
-/** Where a check found something, so the reader can go look. */
-export interface Finding {
-    file: string;
-    line: number;
-    text: string;
-}
-/**
- * What a check gets. Pure Node — no subprocess, so this works on Windows, in a
- * minimal container, and without ripgrep installed.
- */
-export interface CheckContext {
-    /** Absolute path to the consumer's sources. */
-    path: string;
-    /** Files under `path`, with node_modules / dist / .git excluded. */
-    files(extensions?: string[]): Promise<string[]>;
-    read(file: string): Promise<string>;
-    /** Every match across those files. Most checks need only this. */
-    search(pattern: RegExp, extensions?: string[]): Promise<Finding[]>;
-}
-export interface Detector {
-    detect(context: CheckContext): Promise<Finding[]>;
-}
-export interface VerifyResult {
-    /** False when something the check _can_ decide is still wrong. */
-    ok: boolean;
-    findings: Finding[];
-    /**
-     * What a person must still judge — beyond just running the typechecker.
-     * Printed under the migration's name. An empty array means this module's own
-     * check is the whole story (aside from the typecheck below): nothing further
-     * for a person to weigh.
-     */
-    hints: string[];
-    /**
-     * The `tsc --noEmit` reminder, kept separate from `hints` so a command can
-     * tell "still needs a person's judgement" apart from "still needs the routine
-     * typecheck" instead of string-sniffing prose. Running it is a global check
-     * and this CLI wraps no commands, so it never becomes a `Finding`. Present
-     * whenever this migration's correctness depends in some way on the
-     * typechecker — including to explain that it does _not_ catch a particular
-     * class of mistake here, which is itself worth telling a person running `tsc
-     * --noEmit` out of habit.
-     */
-    typecheckHint?: string;
-}
-export interface Verifier {
-    verify(context: CheckContext): Promise<VerifyResult>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/checks/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/checks/types.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,KAAK,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAChD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACpC,kEAAkE;IAClE,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CACpE;AAED,MAAM,WAAW,QAAQ;IACvB,MAAM,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CACnD;AAED,MAAM,WAAW,YAAY;IAC3B,kEAAkE;IAClE,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB;;;;;OAKG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,QAAQ;IACvB,MAAM,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CACtD"}

package/dist/cli/detect.d.ts

@@ -1,35 +0,0 @@
-import { type CatalogEntry } from "../catalog/entries.js";
-import { loadDetector } from "../checks/load.js";
-import type { Finding } from "../checks/types.js";
-export interface DetectEntryResult {
-    entry: CatalogEntry;
-    findings: Finding[];
-}
-export interface RunDetectDeps {
-    /** Which entries to try. Defaults to the whole catalogue. */
-    entries?: CatalogEntry[];
-    /** Injectable for tests — defaults to the real module loader. */
-    load?: typeof loadDetector;
-}
-/**
- * Runs every available detector over `path` and returns only the entries that
- * found something.
- *
- * Only a fraction of the catalogue has a detector module so far (see
- * `checks/load.ts`); an id with none is skipped rather than treated as a
- * failure — the remaining detectors are mechanical follow-up work, not a bug in
- * this command.
- */
-export declare const runDetect: (path: string, { entries, load }?: RunDetectDeps) => Promise<DetectEntryResult[]>;
-/**
- * Renders `runDetect`'s result as text — the presentation half kept separate
- * from the async file-reading half, the same split `renderList` uses, so
- * formatting is testable without touching a file. Reuses `renderList`'s
- * vocabulary (`painter`, `wrap`, `indent`) rather than a second
- * implementation.
- */
-export declare const renderDetect: (results: DetectEntryResult[], path: string, { color, width }?: {
-    color?: boolean;
-    width?: number;
-}) => string;
-//# sourceMappingURL=detect.d.ts.map

package/dist/cli/detect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../src/cli/detect.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAGlD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,6DAA6D;IAC7D,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,iEAAiE;IACjE,IAAI,CAAC,EAAE,OAAO,YAAY,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,SACd,MAAM,sBACmC,aAAa,KAC3D,OAAO,CAAC,iBAAiB,EAAE,CAgB7B,CAAC;AAeF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,YACd,iBAAiB,EAAE,QACtB,MAAM,qBACmB;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,KACjE,MAuBF,CAAC"}

package/dist/cli/detect.js

@@ -1,62 +0,0 @@
-import colors from "picocolors";
-import { allEntries } from "../catalog/entries.js";
-import { createCheckContext } from "../checks/context.js";
-import { loadDetector } from "../checks/load.js";
-import { indent, painter, wrap } from "./list.js";
-/**
- * Runs every available detector over `path` and returns only the entries that
- * found something.
- *
- * Only a fraction of the catalogue has a detector module so far (see
- * `checks/load.ts`); an id with none is skipped rather than treated as a
- * failure — the remaining detectors are mechanical follow-up work, not a bug in
- * this command.
- */
-export const runDetect = async (path, { entries = allEntries, load = loadDetector } = {}) => {
-    const context = createCheckContext(path);
-    const results = [];
-    for (const entry of entries) {
-        const detector = await load(entry.id);
-        if (detector === undefined) {
-            continue;
-        }
-        const findings = await detector.detect(context);
-        if (findings.length > 0) {
-            results.push({ entry, findings });
-        }
-    }
-    return results;
-};
-/** One `file:line text` row, wrapped and indented like `renderList`'s rows. */
-const findingLine = (finding, width, paint) => {
-    const location = paint.dim(`${finding.file}:${finding.line}`);
-    const body = wrap(finding.text, Math.max(width - indent.length, 20));
-    return body.map((line, index) => index === 0 ? `${indent}${location}  ${line}` : `${indent}  ${line}`);
-};
-/**
- * Renders `runDetect`'s result as text — the presentation half kept separate
- * from the async file-reading half, the same split `renderList` uses, so
- * formatting is testable without touching a file. Reuses `renderList`'s
- * vocabulary (`painter`, `wrap`, `indent`) rather than a second
- * implementation.
- */
-export const renderDetect = (results, path, { color = false, width = 80 } = {}) => {
-    const paint = painter(color);
-    if (results.length === 0) {
-        return `No migrations under ${path} were found by the available detectors.\n`;
-    }
-    const noun = results.length === 1 ? "migration" : "migrations";
-    const verb = results.length === 1 ? "touches" : "touch";
-    const header = `${paint.bold(`${results.length} ${noun}`)} ${verb} ${path}\n`;
-    const body = results
-        .map(({ entry, findings }) => {
-        const mark = color ? colors.green("●") : "*";
-        const lines = [
-            `${mark} ${paint.bold(entry.id)}`,
-            ...findings.flatMap((finding) => findingLine(finding, width, paint)),
-        ];
-        return lines.join("\n");
-    })
-        .join("\n\n");
-    return `${header}\n${body}\n`;
-};

package/dist/cli/verify.d.ts

@@ -1,77 +0,0 @@
-import { type CatalogEntry } from "../catalog/entries.js";
-import { loadVerifier } from "../checks/load.js";
-import type { VerifyResult } from "../checks/types.js";
-export interface VerifyEntryResult {
-    entry: CatalogEntry;
-    result: VerifyResult;
-}
-export interface RunVerifyDeps {
-    /** Which entries to try. Defaults to the whole catalogue. */
-    entries?: CatalogEntry[];
-    /** Injectable for tests — defaults to the real module loader. */
-    load?: typeof loadVerifier;
-}
-/**
- * Runs every available verifier over `path`.
- *
- * Only a fraction of the catalogue has a verifier module so far (see
- * `checks/load.ts`); an id with none is skipped, not reported as a failure —
- * the remaining verifiers are follow-up work, not something this run got
- * wrong.
- */
-export declare const runVerify: (path: string, { entries, load }?: RunVerifyDeps) => Promise<VerifyEntryResult[]>;
-/**
- * Three counts, not one pass/fail verdict — conflating them is exactly the "23
- * entries still need a person" problem this replaces: with every verifier in
- * place, almost all of them would carry at least the typecheck reminder, so
- * counting "has a hint" swamps the entries that actually need a person's
- * judgement with the ones that only need the same routine `tsc --noEmit` run.
- *
- * - `failed` — `ok: false`: this run found something concretely wrong.
- * - `needsReview` — `ok: true` but `hints` is non-empty: nothing this module
- *   could decide is wrong, but a person still has to judge something no
- *   compiler check can catch.
- * - `verified` — `ok: true` and `hints` is empty: nothing left for a person to
- *   judge here (the typecheck below may still apply). Deliberately not
- *   "done"/"complete": see `checks/types.ts`'s doc comment on `VerifyResult`
- *   for why `ok: true` never means the migration is finished.
- *
- * `typecheckCount` is tallied separately again: it is not a judgement call like
- * `needsReview`, and `tsc --noEmit` is one command a person runs once for the
- * whole project, not once per entry — so it is reported as a single closing
- * line, not folded into any of the three per-entry buckets.
- */
-export declare const summarize: (results: VerifyEntryResult[]) => {
-    failed: number;
-    needsReview: number;
-    verified: number;
-    typecheckCount: number;
-};
-/**
- * Renders `runVerify`'s result as text — the presentation half kept separate
- * from the async file-reading half, the same split `renderList` uses.
- *
- * Prints only what needs attention. An entry that is `ok: true` with no hints
- * has nothing left for a person to judge (the closing typecheck line still
- * covers it if it relies on one) — it swells the count in the header and
- * nothing else, the same way `verified` is counted but never itself printed.
- * That is the fix for the four problems the maintainer called out: a passing
- * entry whose only hint was the typecheck reminder no longer earns a block at
- * all, the reminder itself moves out of the loop to one line at the end,
- * hints stop repeating their own label, and findings show a path relative to
- * `path` instead of the absolute one the header already established.
- */
-export declare const renderVerify: (results: VerifyEntryResult[], path: string, { color, width }?: {
-    color?: boolean;
-    width?: number;
-}) => string;
-/**
- * Whether a `verify` run should exit non-zero: exactly when at least one
- * verifier decided `ok: false`. A hint alone — even every entry carrying one —
- * is the normal "a person still has to look" state, not a failure, so it must
- * never flip this. Kept as its own pure function (over `results`, not
- * `process.exitCode` directly) so a test can drive it with injected fakes
- * instead of spawning the CLI.
- */
-export declare const verifyExitCode: (results: VerifyEntryResult[]) => number;
-//# sourceMappingURL=verify.d.ts.map

package/dist/cli/verify.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../src/cli/verify.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,YAAY,CAAC;IACpB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,6DAA6D;IAC7D,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,iEAAiE;IACjE,IAAI,CAAC,EAAE,OAAO,YAAY,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,SACd,MAAM,sBACmC,aAAa,KAC3D,OAAO,CAAC,iBAAiB,EAAE,CAa7B,CAAC;AA2DF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS,YACX,iBAAiB,EAAE,KAC3B;IACD,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;CAqBxB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,YACd,iBAAiB,EAAE,QACtB,MAAM,qBACmB;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,KACjE,MA8BF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,YAAa,iBAAiB,EAAE,KAAG,MACZ,CAAC"}

package/dist/cli/verify.js

@@ -1,148 +0,0 @@
-import { relative } from "node:path";
-import colors from "picocolors";
-import { allEntries } from "../catalog/entries.js";
-import { createCheckContext } from "../checks/context.js";
-import { loadVerifier } from "../checks/load.js";
-import { indent, painter, wrap } from "./list.js";
-/**
- * Runs every available verifier over `path`.
- *
- * Only a fraction of the catalogue has a verifier module so far (see
- * `checks/load.ts`); an id with none is skipped, not reported as a failure —
- * the remaining verifiers are follow-up work, not something this run got
- * wrong.
- */
-export const runVerify = async (path, { entries = allEntries, load = loadVerifier } = {}) => {
-    const context = createCheckContext(path);
-    const results = [];
-    for (const entry of entries) {
-        const verifier = await load(entry.id);
-        if (verifier === undefined) {
-            continue;
-        }
-        results.push({ entry, result: await verifier.verify(context) });
-    }
-    return results;
-};
-/** One `path:line  text` row, path shown relative to the search root. */
-const findingLine = (finding, width, paint, root) => {
-    const location = paint.dim(`${relative(root, finding.file)}:${finding.line}`);
-    const body = wrap(finding.text, Math.max(width - indent.length, 20));
-    return body.map((line, index) => index === 0 ? `${indent}${location}  ${line}` : `${indent}  ${line}`);
-};
-/**
- * One hint, wrapped and indented under its migration. No repeated label — a
- * hint that wraps to several lines said "hint" once per line before this,
- * which is the label, not the content, taking up the repetition.
- */
-const hintLine = (hint, width) => wrap(hint, Math.max(width - indent.length, 20)).map((line) => `${indent}${line}`);
-/**
- * Renders one migration's block: `!` for `ok: false`, `?` for `ok: true` with
- * a hint — the only two states this function is ever called for, see
- * `renderVerify`'s filter. Findings first, then hints; the `typecheckHint`
- * never appears here — it is one global action, folded into the closing line
- * instead of repeated under every entry that relies on it.
- */
-const renderEntry = ({ entry, result }, width, color, root) => {
-    const paint = painter(color);
-    const mark = result.ok
-        ? color
-            ? colors.yellow("?")
-            : "?"
-        : color
-            ? colors.red("!")
-            : "!";
-    const lines = [
-        `${mark} ${paint.bold(entry.id)}`,
-        ...result.findings.flatMap((finding) => findingLine(finding, width, paint, root)),
-        ...result.hints.flatMap((hint) => hintLine(hint, width)),
-    ];
-    return lines.join("\n");
-};
-/**
- * Three counts, not one pass/fail verdict — conflating them is exactly the "23
- * entries still need a person" problem this replaces: with every verifier in
- * place, almost all of them would carry at least the typecheck reminder, so
- * counting "has a hint" swamps the entries that actually need a person's
- * judgement with the ones that only need the same routine `tsc --noEmit` run.
- *
- * - `failed` — `ok: false`: this run found something concretely wrong.
- * - `needsReview` — `ok: true` but `hints` is non-empty: nothing this module
- *   could decide is wrong, but a person still has to judge something no
- *   compiler check can catch.
- * - `verified` — `ok: true` and `hints` is empty: nothing left for a person to
- *   judge here (the typecheck below may still apply). Deliberately not
- *   "done"/"complete": see `checks/types.ts`'s doc comment on `VerifyResult`
- *   for why `ok: true` never means the migration is finished.
- *
- * `typecheckCount` is tallied separately again: it is not a judgement call like
- * `needsReview`, and `tsc --noEmit` is one command a person runs once for the
- * whole project, not once per entry — so it is reported as a single closing
- * line, not folded into any of the three per-entry buckets.
- */
-export const summarize = (results) => {
-    let failed = 0;
-    let needsReview = 0;
-    let verified = 0;
-    let typecheckCount = 0;
-    for (const { result } of results) {
-        if (!result.ok) {
-            failed++;
-        }
-        else if (result.hints.length > 0) {
-            needsReview++;
-        }
-        else {
-            verified++;
-        }
-        if (result.typecheckHint !== undefined) {
-            typecheckCount++;
-        }
-    }
-    return { failed, needsReview, verified, typecheckCount };
-};
-/**
- * Renders `runVerify`'s result as text — the presentation half kept separate
- * from the async file-reading half, the same split `renderList` uses.
- *
- * Prints only what needs attention. An entry that is `ok: true` with no hints
- * has nothing left for a person to judge (the closing typecheck line still
- * covers it if it relies on one) — it swells the count in the header and
- * nothing else, the same way `verified` is counted but never itself printed.
- * That is the fix for the four problems the maintainer called out: a passing
- * entry whose only hint was the typecheck reminder no longer earns a block at
- * all, the reminder itself moves out of the loop to one line at the end,
- * hints stop repeating their own label, and findings show a path relative to
- * `path` instead of the absolute one the header already established.
- */
-export const renderVerify = (results, path, { color = false, width = 80 } = {}) => {
-    const paint = painter(color);
-    if (results.length === 0) {
-        return `No verifiers are available yet for anything under ${path}.\n`;
-    }
-    const { failed, needsReview, typecheckCount } = summarize(results);
-    const header = [
-        `${paint.bold(String(results.length))} checked`,
-        `${paint.bold(String(failed))} failed`,
-        `${paint.bold(String(needsReview))} needs review`,
-    ].join(" · ");
-    const needsAttention = results.filter(({ result }) => !result.ok || result.hints.length > 0);
-    const body = needsAttention.length === 0
-        ? "Nothing needs attention."
-        : needsAttention
-            .map((entryResult) => renderEntry(entryResult, width, color, path))
-            .join("\n\n");
-    const typecheckLine = typecheckCount === 0
-        ? ""
-        : `\n\nThen run \`tsc --noEmit\` once — ${typecheckCount} of these rely on it.`;
-    return `${header}\n\n${body}${typecheckLine}\n`;
-};
-/**
- * Whether a `verify` run should exit non-zero: exactly when at least one
- * verifier decided `ok: false`. A hint alone — even every entry carrying one —
- * is the normal "a person still has to look" state, not a failure, so it must
- * never flip this. Kept as its own pure function (over `results`, not
- * `process.exitCode` directly) so a test can drive it with injected fakes
- * instead of spawning the CLI.
- */
-export const verifyExitCode = (results) => results.some(({ result }) => !result.ok) ? 1 : 0;

package/dist/detect/align-to-combine.d.ts

@@ -1,8 +0,0 @@
-import type { Detector } from "../checks/types.js";
-/**
- * Translated from the catalogue's `detect: rg -t ts '\bAlign(Props)?\b'` — see
- * the translation rule in the plan: `rg -t ts 'PATTERN'` becomes
- * `search(/PATTERN/, tsExtensions)`.
- */
-export declare const detector: Detector;
-//# sourceMappingURL=align-to-combine.d.ts.map

package/dist/detect/align-to-combine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"align-to-combine.d.ts","sourceRoot":"","sources":["../../src/detect/align-to-combine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,QAEtB,CAAC"}

package/dist/detect/align-to-combine.js

@@ -1,9 +0,0 @@
-import { tsExtensions } from "../checks/context.js";
-/**
- * Translated from the catalogue's `detect: rg -t ts '\bAlign(Props)?\b'` — see
- * the translation rule in the plan: `rg -t ts 'PATTERN'` becomes
- * `search(/PATTERN/, tsExtensions)`.
- */
-export const detector = {
-    detect: (context) => context.search(/\bAlign(Props)?\b/, tsExtensions),
-};

package/dist/detect/overlay-controller-add-on-close-return-type.d.ts

@@ -1,9 +0,0 @@
-import type { Detector } from "../checks/types.js";
-/**
- * Translated from the catalogue's `detect: rg -t ts 'addOnClose|addOnOpen'`.
- * Every call site needs a by-hand look at its handler — see
- * `src/verify/overlay-controller-add-on-close-return-type.ts` for why no
- * compiler check can narrow this list further.
- */
-export declare const detector: Detector;
-//# sourceMappingURL=overlay-controller-add-on-close-return-type.d.ts.map

package/dist/detect/overlay-controller-add-on-close-return-type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"overlay-controller-add-on-close-return-type.d.ts","sourceRoot":"","sources":["../../src/detect/overlay-controller-add-on-close-return-type.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,EAAE,QAEtB,CAAC"}

package/dist/detect/overlay-controller-add-on-close-return-type.js

@@ -1,10 +0,0 @@
-import { tsExtensions } from "../checks/context.js";
-/**
- * Translated from the catalogue's `detect: rg -t ts 'addOnClose|addOnOpen'`.
- * Every call site needs a by-hand look at its handler — see
- * `src/verify/overlay-controller-add-on-close-return-type.ts` for why no
- * compiler check can narrow this list further.
- */
-export const detector = {
-    detect: (context) => context.search(/addOnClose|addOnOpen/, tsExtensions),
-};