miniread 1.7.0 → 1.9.0

package/bin/miniread-snapshot

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point that dynamically imports the compiled TypeScript.
+ *
+ * Uses top-level await to ensure module evaluation errors are handled
+ * properly. Without await, errors during import would surface as unhandled
+ * rejections instead of clean CLI failures with appropriate exit codes.
+ */
+try {
+  await import("../dist/scripts/snapshot.js");
+} catch (error) {
+  console.error(
+    "Failed to start miniread-snapshot:",
+    error instanceof Error ? error.message : error,
+  );
+  process.exitCode = 1;
+}

package/dist/scripts/snapshot/create-snapshot-command.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "@commander-js/extra-typings";
+export type SnapshotCliRawOptions = {
+    testcase: string;
+    transform: string;
+    expected: boolean;
+};
+export declare const createSnapshotCommand: (options: {
+    version: string;
+}) => Command;

package/dist/scripts/snapshot/create-snapshot-command.js

@@ -0,0 +1,32 @@
+import { Command } from "@commander-js/extra-typings";
+export const createSnapshotCommand = (options) => {
+    const program = new Command()
+        .name("miniread-snapshot")
+        .description("Generate test case snapshots for transform development workflow.")
+        .version(options.version)
+        .showHelpAfterError("(add --help for additional information)")
+        .showSuggestionAfterError()
+        .requiredOption("--testcase <name>", "Test case directory name (e.g., boolean-literals)")
+        .requiredOption("--transform <id>", "Transform ID to run (e.g., expand-boolean-literals)")
+        .option("--expected", "Write {transform}-expected.js, compare with actual, delete expected on success", false);
+    program.addHelpText("after", `
+Examples:
+  # Generate actual snapshot only (for updating existing snapshots)
+  pnpm run snapshot -- --testcase boolean-literals --transform expand-boolean-literals
+
+  # Full expected-file workflow (Design → Test phase)
+  pnpm run snapshot -- --testcase boolean-literals --transform expand-boolean-literals --expected
+    1. Writes {transform}-expected.js (copy of base.js for manual editing)
+    2. Writes {transform}.js (actual transform output)
+    3. Runs diff between expected and actual
+    4. Deletes expected.js on success (no diff)
+
+Workflow:
+  1. Create test-cases/{testcase}/base.js with your minified snippet
+  2. Run with --expected to generate the expected file template
+  3. Manually edit {transform}-expected.js to match your intent
+  4. Re-run with --expected to compare actual output
+  5. On success (no diff), expected file is auto-deleted
+`);
+    return program;
+};

package/dist/scripts/snapshot/run-snapshot-cli.d.ts

@@ -0,0 +1 @@
+export declare const runSnapshotCli: (argv: string[]) => Promise<number>;

package/dist/scripts/snapshot/run-snapshot-cli.js

@@ -0,0 +1,162 @@
+import * as fs from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import * as prettier from "prettier";
+import packageJson from "../../../package.json" with { type: "json" };
+import { buildProjectGraph } from "../../core/project-graph.js";
+import { transformPresets } from "../../transforms/transform-presets.js";
+import { transformRegistry } from "../../transforms/transform-registry.js";
+import { createSnapshotCommand, } from "./create-snapshot-command.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const generate = require("@babel/generator").default;
+const TEST_CASES_DIR = path.resolve(import.meta.dirname, "../../../test-cases");
+const formatCode = async (code) => prettier.format(code, { parser: "babel" });
+const runTransform = async (inputPath, transformId) => {
+    const content = await fs.readFile(inputPath, "utf8");
+    // Handle "recommended" as a special case that runs all recommended transforms
+    const transformIds = transformId === "recommended"
+        ? transformPresets.recommended
+        : [transformId];
+    const transforms = transformIds.map((id) => {
+        const transform = transformRegistry[id];
+        if (!transform) {
+            throw new Error(`Unknown transform: ${id}. Run 'miniread --list-transforms' to see available transforms.`);
+        }
+        return transform;
+    });
+    const projectGraph = buildProjectGraph([{ path: inputPath, content }]);
+    for (const transform of transforms) {
+        await transform.transform({
+            projectGraph,
+            currentFile: undefined,
+            options: {},
+        });
+    }
+    const fileInfo = projectGraph.files.get(inputPath);
+    if (!fileInfo) {
+        return content;
+    }
+    return generate(fileInfo.ast).code;
+};
+export const runSnapshotCli = async (argv) => {
+    const program = createSnapshotCommand({ version: packageJson.version });
+    program.parse(argv.filter((argument) => argument !== "--"));
+    const rawOptions = program.opts();
+    const { testcase, transform, expected } = rawOptions;
+    // Validate test case directory exists
+    const testCaseDirectory = path.join(TEST_CASES_DIR, testcase);
+    try {
+        const stats = await fs.stat(testCaseDirectory);
+        if (!stats.isDirectory()) {
+            console.error(`Error: ${testcase} is not a directory`);
+            return 1;
+        }
+    }
+    catch {
+        console.error(`Error: Test case directory not found: test-cases/${testcase}`);
+        console.error(`Create it first: mkdir -p test-cases/${testcase}`);
+        return 1;
+    }
+    // Validate base.js exists
+    const basePath = path.join(testCaseDirectory, "base.js");
+    try {
+        await fs.access(basePath);
+    }
+    catch {
+        console.error(`Error: base.js not found in test-cases/${testcase}/`);
+        console.error(`Create test-cases/${testcase}/base.js with your minified snippet first.`);
+        return 1;
+    }
+    const expectedPath = path.join(testCaseDirectory, `${transform}-expected.js`);
+    const actualPath = path.join(testCaseDirectory, `${transform}.js`);
+    // Run the transform and format
+    let actualOutput;
+    try {
+        const rawOutput = await runTransform(basePath, transform);
+        actualOutput = await formatCode(rawOutput);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error running transform: ${message}`);
+        return 1;
+    }
+    if (expected) {
+        // Expected-file workflow
+        // Step 1: Check if expected file exists, create from base.js if not
+        let expectedExists = false;
+        try {
+            await fs.access(expectedPath);
+            expectedExists = true;
+        }
+        catch {
+            // Expected file doesn't exist, create it from base.js
+            const baseContent = await fs.readFile(basePath, "utf8");
+            const formattedBase = await formatCode(baseContent);
+            await fs.writeFile(expectedPath, formattedBase);
+            console.log(`Created: test-cases/${testcase}/${transform}-expected.js`);
+            console.log("Edit this file to match your expected output, then re-run.");
+        }
+        // Step 2: Write actual output
+        await fs.writeFile(actualPath, actualOutput);
+        console.log(`Created: test-cases/${testcase}/${transform}.js`);
+        if (!expectedExists) {
+            // First run - just created expected file, user needs to edit it
+            return 0;
+        }
+        // Step 3: Compare expected vs actual
+        const expectedContent = await fs.readFile(expectedPath, "utf8");
+        if (expectedContent === actualOutput) {
+            // Success! Delete expected file
+            await fs.unlink(expectedPath);
+            console.log(`\nSuccess: Output matches expected.`);
+            console.log(`Deleted: test-cases/${testcase}/${transform}-expected.js`);
+            console.log(`\nSnapshot ready: test-cases/${testcase}/${transform}.js`);
+            return 0;
+        }
+        else {
+            // Diff - show the difference
+            console.log(`\nDiff: expected vs actual`);
+            console.log("---");
+            // Simple line-by-line diff output
+            const expectedLines = expectedContent.split("\n");
+            const actualLines = actualOutput.split("\n");
+            const maxLines = Math.max(expectedLines.length, actualLines.length);
+            let hasDiff = false;
+            for (let lineIndex = 0; lineIndex < maxLines; lineIndex++) {
+                const exp = expectedLines[lineIndex];
+                const act = actualLines[lineIndex];
+                if (exp !== act) {
+                    hasDiff = true;
+                    if (exp !== undefined && act === undefined) {
+                        console.log(`Line ${lineIndex + 1}:`);
+                        console.log(`  - ${exp}`);
+                    }
+                    else if (exp === undefined && act !== undefined) {
+                        console.log(`Line ${lineIndex + 1}:`);
+                        console.log(`  + ${act}`);
+                    }
+                    else {
+                        console.log(`Line ${lineIndex + 1}:`);
+                        console.log(`  - ${exp}`);
+                        console.log(`  + ${act}`);
+                    }
+                }
+            }
+            if (!hasDiff) {
+                // Shouldn't happen since we already checked equality, but just in case
+                console.log("(no visible differences)");
+            }
+            console.log("---");
+            console.log(`\nExpected file preserved: test-cases/${testcase}/${transform}-expected.js`);
+            console.log("Fix the implementation or update the expected file, then re-run.");
+            return 1;
+        }
+    }
+    else {
+        // Simple mode: just write actual output
+        await fs.writeFile(actualPath, actualOutput);
+        console.log(`Created: test-cases/${testcase}/${transform}.js`);
+        return 0;
+    }
+};

package/dist/scripts/snapshot.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/scripts/snapshot.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { runSnapshotCli } from "./snapshot/run-snapshot-cli.js";
+try {
+    const exitCode = await runSnapshotCli(process.argv);
+    if (exitCode !== 0) {
+        process.exitCode = exitCode;
+    }
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exitCode = 1;
+}

package/dist/transforms/rename-loop-index-variables-v2/get-loop-counter-name.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from "@babel/traverse";
+import type { ForStatement } from "@babel/types";
+export declare const LOOP_INDEX_BASE_NAME = "index";
+export declare const getStableRenamedIndexLoopCounterName: (path: NodePath<ForStatement>) => string | undefined;
+export declare const getLoopCounterNameIfEligible: (path: NodePath<ForStatement>) => string | undefined;

package/dist/transforms/rename-loop-index-variables-v2/get-loop-counter-name.js

@@ -0,0 +1,123 @@
+import { isStableRenamed } from "../../core/stable-naming.js";
+export const LOOP_INDEX_BASE_NAME = "index";
+const isEligibleVariableDeclarationKind = (kind) => {
+    return kind === "let" || kind === "var";
+};
+const isStableRenamedIndexLoopCounterName = (name) => {
+    if (!isStableRenamed(name))
+        return false;
+    return name.startsWith(`$${LOOP_INDEX_BASE_NAME}`);
+};
+const isLoopCounterDeclarator = (loopCounterName, path) => {
+    const test = path.node.test;
+    if (!test)
+        return false;
+    if (test.type !== "BinaryExpression")
+        return false;
+    if (test.operator !== "<" && test.operator !== "<=")
+        return false;
+    if (test.left.type !== "Identifier")
+        return false;
+    if (test.left.name !== loopCounterName)
+        return false;
+    if (test.right.type !== "MemberExpression")
+        return false;
+    if (test.right.computed)
+        return false;
+    if (test.right.property.type !== "Identifier")
+        return false;
+    if (test.right.property.name !== "length")
+        return false;
+    const update = path.node.update;
+    if (!update)
+        return false;
+    if (update.type === "UpdateExpression") {
+        if (update.operator !== "++")
+            return false;
+        if (update.argument.type !== "Identifier")
+            return false;
+        if (update.argument.name !== loopCounterName)
+            return false;
+    }
+    else if (update.type === "AssignmentExpression") {
+        if (update.operator !== "+=")
+            return false;
+        if (update.left.type !== "Identifier")
+            return false;
+        if (update.left.name !== loopCounterName)
+            return false;
+        if (update.right.type !== "NumericLiteral")
+            return false;
+        if (update.right.value <= 0)
+            return false;
+    }
+    else {
+        return false;
+    }
+    return true;
+};
+export const getStableRenamedIndexLoopCounterName = (path) => {
+    const init = path.node.init;
+    if (!init)
+        return;
+    if (init.type !== "VariableDeclaration")
+        return;
+    if (!isEligibleVariableDeclarationKind(init.kind))
+        return;
+    if (init.declarations.length === 0)
+        return;
+    let stableName;
+    for (const declarator of init.declarations) {
+        if (declarator.id.type !== "Identifier")
+            continue;
+        const loopCounterName = declarator.id.name;
+        if (!isStableRenamedIndexLoopCounterName(loopCounterName))
+            continue;
+        if (!declarator.init)
+            continue;
+        if (declarator.init.type !== "NumericLiteral")
+            continue;
+        if (declarator.init.value !== 0)
+            continue;
+        if (!isLoopCounterDeclarator(loopCounterName, path))
+            continue;
+        if (stableName !== undefined)
+            return;
+        stableName = loopCounterName;
+    }
+    return stableName;
+};
+export const getLoopCounterNameIfEligible = (path) => {
+    const init = path.node.init;
+    if (!init)
+        return;
+    if (init.type !== "VariableDeclaration")
+        return;
+    if (!isEligibleVariableDeclarationKind(init.kind))
+        return;
+    if (init.declarations.length === 0)
+        return;
+    if (init.kind === "let" && init.declarations.length < 2)
+        return;
+    const eligibleNames = [];
+    for (const declarator of init.declarations) {
+        if (declarator.id.type !== "Identifier")
+            continue;
+        if (!declarator.init)
+            continue;
+        if (declarator.init.type !== "NumericLiteral")
+            continue;
+        if (declarator.init.value !== 0)
+            continue;
+        const loopCounterName = declarator.id.name;
+        if (!isLoopCounterDeclarator(loopCounterName, path))
+            continue;
+        eligibleNames.push(loopCounterName);
+        if (eligibleNames.length > 1)
+            return;
+    }
+    const name0 = eligibleNames[0];
+    if (!name0)
+        return;
+    return name0;
+};

package/dist/transforms/rename-loop-index-variables-v2/get-renamed-ancestor-loop-count.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ForStatement } from "@babel/types";
+export declare const getRenamedAncestorLoopCount: (path: NodePath<ForStatement>, renamedLoops: WeakMap<ForStatement, string>) => number;

package/dist/transforms/rename-loop-index-variables-v2/get-renamed-ancestor-loop-count.js

@@ -0,0 +1,19 @@
+import { getStableRenamedIndexLoopCounterName } from "./get-loop-counter-name.js";
+export const getRenamedAncestorLoopCount = (path, renamedLoops) => {
+    let count = 0;
+    for (const ancestor of path.getAncestry()) {
+        if (ancestor === path)
+            continue;
+        if (!ancestor.isForStatement())
+            continue;
+        if (renamedLoops.has(ancestor.node)) {
+            count++;
+            continue;
+        }
+        const stableName = getStableRenamedIndexLoopCounterName(ancestor);
+        if (!stableName)
+            continue;
+        count++;
+    }
+    return count;
+};

package/dist/transforms/rename-loop-index-variables-v2/get-target-index-base-name.d.ts

@@ -0,0 +1 @@
+export declare const getTargetIndexBaseName: (renamedAncestorLoopCount: number) => string;

package/dist/transforms/rename-loop-index-variables-v2/get-target-index-base-name.js

@@ -0,0 +1,6 @@
+import { LOOP_INDEX_BASE_NAME } from "./get-loop-counter-name.js";
+export const getTargetIndexBaseName = (renamedAncestorLoopCount) => {
+    if (renamedAncestorLoopCount === 0)
+        return LOOP_INDEX_BASE_NAME;
+    return `${LOOP_INDEX_BASE_NAME}${renamedAncestorLoopCount + 1}`;
+};

package/dist/transforms/rename-loop-index-variables-v2/rename-loop-index-variables-v2-transform.d.ts

@@ -0,0 +1,2 @@
+import { type Transform } from "../../core/types.js";
+export declare const renameLoopIndexVariablesV2Transform: Transform;

package/dist/transforms/rename-loop-index-variables-v2/rename-loop-index-variables-v2-transform.js

@@ -0,0 +1,47 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { getLoopCounterNameIfEligible } from "./get-loop-counter-name.js";
+import { getRenamedAncestorLoopCount } from "./get-renamed-ancestor-loop-count.js";
+import { getTargetIndexBaseName } from "./get-target-index-base-name.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+export const renameLoopIndexVariablesV2Transform = {
+    id: "rename-loop-index-variables-v2",
+    description: "Renames numeric for-loop counters in `for (var ...)` (single or multi-declarator) and `for (let ...)` (multi-declarator) to $index/$index2/...",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            const eligibleLoops = new WeakMap();
+            traverse(fileInfo.ast, {
+                ForStatement(path) {
+                    nodesVisited++;
+                    const loopCounterName = getLoopCounterNameIfEligible(path);
+                    if (!loopCounterName)
+                        return;
+                    // Skip already-stable names
+                    if (isStableRenamed(loopCounterName))
+                        return;
+                    const renamedAncestorLoopCount = getRenamedAncestorLoopCount(path, eligibleLoops);
+                    const baseName = getTargetIndexBaseName(renamedAncestorLoopCount);
+                    eligibleLoops.set(path.node, baseName);
+                    group.add({
+                        scope: path.scope,
+                        currentName: loopCounterName,
+                        baseName,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/rename-loop-index-variables-v3/get-loop-counter-name.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from "@babel/traverse";
+import type { ForStatement } from "@babel/types";
+export declare const LOOP_INDEX_BASE_NAME = "index";
+export declare const getStableRenamedIndexLoopCounterName: (path: NodePath<ForStatement>) => string | undefined;
+export declare const getLoopCounterNameIfEligible: (path: NodePath<ForStatement>) => string | undefined;

package/dist/transforms/rename-loop-index-variables-v3/get-loop-counter-name.js

@@ -0,0 +1,121 @@
+import { isStableRenamed } from "../../core/stable-naming.js";
+export const LOOP_INDEX_BASE_NAME = "index";
+const isEligibleVariableDeclarationKind = (kind) => {
+    return kind === "let" || kind === "var";
+};
+const isStableRenamedIndexLoopCounterName = (name) => {
+    if (!isStableRenamed(name))
+        return false;
+    return name.startsWith(`$${LOOP_INDEX_BASE_NAME}`);
+};
+const isLoopCounterDeclarator = (loopCounterName, path) => {
+    const test = path.node.test;
+    if (!test)
+        return false;
+    if (test.type !== "BinaryExpression")
+        return false;
+    if (test.operator !== "<" && test.operator !== "<=")
+        return false;
+    if (test.left.type !== "Identifier")
+        return false;
+    if (test.left.name !== loopCounterName)
+        return false;
+    if (test.right.type !== "MemberExpression")
+        return false;
+    if (test.right.computed)
+        return false;
+    if (test.right.property.type !== "Identifier")
+        return false;
+    if (test.right.property.name !== "length")
+        return false;
+    const update = path.node.update;
+    if (!update)
+        return false;
+    if (update.type === "UpdateExpression") {
+        if (update.operator !== "++")
+            return false;
+        if (update.argument.type !== "Identifier")
+            return false;
+        if (update.argument.name !== loopCounterName)
+            return false;
+    }
+    else if (update.type === "AssignmentExpression") {
+        if (update.operator !== "+=")
+            return false;
+        if (update.left.type !== "Identifier")
+            return false;
+        if (update.left.name !== loopCounterName)
+            return false;
+        if (update.right.type !== "NumericLiteral")
+            return false;
+        if (update.right.value <= 0)
+            return false;
+    }
+    else {
+        return false;
+    }
+    return true;
+};
+export const getStableRenamedIndexLoopCounterName = (path) => {
+    const init = path.node.init;
+    if (!init)
+        return;
+    if (init.type !== "VariableDeclaration")
+        return;
+    if (!isEligibleVariableDeclarationKind(init.kind))
+        return;
+    if (init.declarations.length === 0)
+        return;
+    let stableName;
+    for (const declarator of init.declarations) {
+        if (declarator.id.type !== "Identifier")
+            continue;
+        const loopCounterName = declarator.id.name;
+        if (!isStableRenamedIndexLoopCounterName(loopCounterName))
+            continue;
+        if (!declarator.init)
+            continue;
+        if (declarator.init.type !== "NumericLiteral")
+            continue;
+        if (declarator.init.value !== 0)
+            continue;
+        if (!isLoopCounterDeclarator(loopCounterName, path))
+            continue;
+        if (stableName !== undefined)
+            return;
+        stableName = loopCounterName;
+    }
+    return stableName;
+};
+export const getLoopCounterNameIfEligible = (path) => {
+    const init = path.node.init;
+    if (!init)
+        return;
+    if (init.type !== "VariableDeclaration")
+        return;
+    if (!isEligibleVariableDeclarationKind(init.kind))
+        return;
+    if (init.declarations.length === 0)
+        return;
+    const eligibleNames = [];
+    for (const declarator of init.declarations) {
+        if (declarator.id.type !== "Identifier")
+            continue;
+        if (!declarator.init)
+            continue;
+        if (declarator.init.type !== "NumericLiteral")
+            continue;
+        if (declarator.init.value !== 0)
+            continue;
+        const loopCounterName = declarator.id.name;
+        if (!isLoopCounterDeclarator(loopCounterName, path))
+            continue;
+        eligibleNames.push(loopCounterName);
+        if (eligibleNames.length > 1)
+            return;
+    }
+    const name0 = eligibleNames[0];
+    if (!name0)
+        return;
+    return name0;
+};

package/dist/transforms/rename-loop-index-variables-v3/get-renamed-ancestor-loop-count.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ForStatement } from "@babel/types";
+export declare const getRenamedAncestorLoopCount: (path: NodePath<ForStatement>, renamedLoops: WeakMap<ForStatement, string>) => number;

package/dist/transforms/rename-loop-index-variables-v3/get-renamed-ancestor-loop-count.js

@@ -0,0 +1,19 @@
+import { getStableRenamedIndexLoopCounterName } from "./get-loop-counter-name.js";
+export const getRenamedAncestorLoopCount = (path, renamedLoops) => {
+    let count = 0;
+    for (const ancestor of path.getAncestry()) {
+        if (ancestor === path)
+            continue;
+        if (!ancestor.isForStatement())
+            continue;
+        if (renamedLoops.has(ancestor.node)) {
+            count++;
+            continue;
+        }
+        const stableName = getStableRenamedIndexLoopCounterName(ancestor);
+        if (!stableName)
+            continue;
+        count++;
+    }
+    return count;
+};

package/dist/transforms/rename-loop-index-variables-v3/get-target-index-base-name.d.ts

@@ -0,0 +1 @@
+export declare const getTargetIndexBaseName: (renamedAncestorLoopCount: number) => string;

package/dist/transforms/rename-loop-index-variables-v3/get-target-index-base-name.js

@@ -0,0 +1,6 @@
+import { LOOP_INDEX_BASE_NAME } from "./get-loop-counter-name.js";
+export const getTargetIndexBaseName = (renamedAncestorLoopCount) => {
+    if (renamedAncestorLoopCount === 0)
+        return LOOP_INDEX_BASE_NAME;
+    return `${LOOP_INDEX_BASE_NAME}${renamedAncestorLoopCount + 1}`;
+};

package/dist/transforms/rename-loop-index-variables-v3/rename-loop-index-variables-v3-transform.d.ts

@@ -0,0 +1,2 @@
+import { type Transform } from "../../core/types.js";
+export declare const renameLoopIndexVariablesV3Transform: Transform;

package/dist/transforms/rename-loop-index-variables-v3/rename-loop-index-variables-v3-transform.js

@@ -0,0 +1,47 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { getLoopCounterNameIfEligible } from "./get-loop-counter-name.js";
+import { getRenamedAncestorLoopCount } from "./get-renamed-ancestor-loop-count.js";
+import { getTargetIndexBaseName } from "./get-target-index-base-name.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+export const renameLoopIndexVariablesV3Transform = {
+    id: "rename-loop-index-variables-v3",
+    description: "Renames numeric for-loop counters (single or multi-declarator `for (var/let ...)`) to $index/$index2/... based on nesting depth",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            const eligibleLoops = new WeakMap();
+            traverse(fileInfo.ast, {
+                ForStatement(path) {
+                    nodesVisited++;
+                    const loopCounterName = getLoopCounterNameIfEligible(path);
+                    if (!loopCounterName)
+                        return;
+                    // Skip already-stable names
+                    if (isStableRenamed(loopCounterName))
+                        return;
+                    const renamedAncestorLoopCount = getRenamedAncestorLoopCount(path, eligibleLoops);
+                    const baseName = getTargetIndexBaseName(renamedAncestorLoopCount);
+                    eligibleLoops.set(path.node, baseName);
+                    group.add({
+                        scope: path.scope,
+                        currentName: loopCounterName,
+                        baseName,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/transform-registry.js

@@ -6,6 +6,8 @@ import { renameCatchParametersTransform } from "./rename-catch-parameters/rename
 import { renameDestructuredAliasesTransform } from "./rename-destructured-aliases/rename-destructured-aliases-transform.js";
 import { renameEventParametersTransform } from "./rename-event-parameters/rename-event-parameters-transform.js";
 import { renameLoopIndexVariablesTransform } from "./rename-loop-index-variables/rename-loop-index-variables-transform.js";
+import { renameLoopIndexVariablesV2Transform } from "./rename-loop-index-variables-v2/rename-loop-index-variables-v2-transform.js";
+import { renameLoopIndexVariablesV3Transform } from "./rename-loop-index-variables-v3/rename-loop-index-variables-v3-transform.js";
 import { renamePromiseExecutorParametersTransform } from "./rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
 import { renameTimeoutIdsTransform } from "./rename-timeout-ids/rename-timeout-ids-transform.js";
 import { renameUseReferenceGuardsTransform } from "./rename-use-reference-guards/rename-use-reference-guards-transform.js";
@@ -20,6 +22,8 @@ export const transformRegistry = {
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
     [renameEventParametersTransform.id]: renameEventParametersTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,
+    [renameLoopIndexVariablesV2Transform.id]: renameLoopIndexVariablesV2Transform,
+    [renameLoopIndexVariablesV3Transform.id]: renameLoopIndexVariablesV3Transform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,

package/package.json

@@ -2,7 +2,7 @@
   "name": "miniread",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",
@@ -24,7 +24,8 @@
   "bin": {
     "miniread": "bin/miniread",
     "miniread-evaluate": "bin/miniread-evaluate",
-    "miniread-sample": "bin/miniread-sample"
+    "miniread-sample": "bin/miniread-sample",
+    "miniread-snapshot": "bin/miniread-snapshot"
   },
   "files": [
     "bin/",
@@ -47,6 +48,7 @@
     "miniread": "pnpm -s run rebuild && node bin/miniread",
     "miniread-evaluate": "pnpm -s run rebuild && node bin/miniread-evaluate",
     "miniread-sample": "pnpm -s run rebuild && node bin/miniread-sample",
+    "snapshot": "pnpm -s run rebuild && node bin/miniread-snapshot",
     "rebuild": "pnpm run clean && pnpm run build",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",

package/transform-manifest.json

@@ -26,9 +26,31 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "recommended": true,
+      "recommended": false,
       "evaluatedAt": "2026-01-21T21:06:19.512Z",
-      "notes": "Auto-added by evaluation script."
+      "notes": "Superseded by rename-loop-index-variables-v3.",
+      "supersededBy": "rename-loop-index-variables-v3"
+    },
+    {
+      "id": "rename-loop-index-variables-v2",
+      "description": "Renames numeric for-loop counters in `for (var ...)` (single or multi-declarator) and `for (let ...)` (multi-declarator) inits to index/index2/...",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": false,
+      "evaluatedAt": "2026-01-23T16:34:06.000Z",
+      "notes": "Superseded by rename-loop-index-variables-v3.",
+      "supersededBy": "rename-loop-index-variables-v3"
+    },
+    {
+      "id": "rename-loop-index-variables-v3",
+      "description": "Renames numeric for-loop counters (single or multi-declarator `for (var/let ...)`) to index/index2/... based on nesting depth",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T17:09:04.000Z",
+      "notes": "Unifies rename-loop-index-variables and rename-loop-index-variables-v2 without modifying older transforms. Measured with baseline none: 0.00%."
     },
     {
       "id": "rename-catch-parameters",