miniread 1.3.0 → 1.4.0

package/dist/cli/execute-transforms.d.ts

@@ -0,0 +1,9 @@
+import type PQueue from "p-queue";
+import type { Transform, ProjectGraph } from "../core/types.js";
+type TransformExecutionResult = {
+    totalTransformations: number;
+    error?: string;
+};
+type VerboseLogger = (message: string) => void;
+export declare const executeTransforms: (transforms: Transform[], projectGraph: ProjectGraph, queue: PQueue, log: VerboseLogger) => Promise<TransformExecutionResult>;
+export {};

package/dist/cli/execute-transforms.js

@@ -0,0 +1,39 @@
+export const executeTransforms = async (transforms, projectGraph, queue, log) => {
+    let totalTransformations = 0;
+    for (const transform of transforms) {
+        log(`Running transform: ${transform.id}`);
+        try {
+            if (transform.scope === "file" && transform.parallelizable) {
+                // Run transform on each file in parallel
+                const fileInfos = [...projectGraph.files.values()];
+                const statsPromises = fileInfos.map((fileInfo) => queue.add(() => transform.transform({
+                    projectGraph,
+                    currentFile: fileInfo,
+                    options: {},
+                })));
+                const allStats = await Promise.all(statsPromises);
+                const transformApplied = allStats.reduce((sum, stats) => sum + stats.transformationsApplied, 0);
+                totalTransformations += transformApplied;
+                log(`Applied ${transformApplied} transformation(s)`);
+            }
+            else {
+                // Run transform on all files at once (project-scoped or non-parallelizable)
+                const stats = await transform.transform({
+                    projectGraph,
+                    currentFile: undefined,
+                    options: {},
+                });
+                totalTransformations += stats.transformationsApplied;
+                log(`Applied ${stats.transformationsApplied} transformation(s)`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                totalTransformations,
+                error: `Transform '${transform.id}' failed: ${message}`,
+            };
+        }
+    }
+    return { totalTransformations };
+};

package/dist/cli/run-transforms.js

@@ -4,6 +4,7 @@ import PQueue from "p-queue";
 import { buildProjectGraph } from "../core/project-graph.js";
 import { printDryRunSummary, writeOutputFiles } from "./output.js";
 import { generateCode } from "./generate-code.js";
+import { executeTransforms } from "./execute-transforms.js";
 const logVerbose = (verbose, message) => {
     if (!verbose)
         return;
@@ -75,42 +76,31 @@ export const runTransforms = async (options) => {
     if (otherFilePaths.length > 0) {
         logVerbose(verbose, `Found ${otherFilePaths.length} other file(s) to copy`);
     }
-    // Read all files
+    // Read all files in parallel
     logVerbose(verbose, "Reading files...");
-    const parsedFiles = [];
-    for (const filePath of sourceFilePaths) {
+    const parsedFiles = await Promise.all(sourceFilePaths.map(async (filePath) => {
         const content = await fs.readFile(filePath, "utf8");
-        parsedFiles.push({ path: filePath, content });
-    }
+        return { path: filePath, content };
+    }));
     // Build project graph (includes parsing)
     logVerbose(verbose, "Parsing files with Babel...");
     const projectGraph = buildProjectGraph(parsedFiles);
     logVerbose(verbose, `Running ${transforms.length} transform(s) with ${workers} worker(s)...`);
     // Create a queue for parallel processing
     const queue = new PQueue({ concurrency: workers });
-    // Track results
-    let totalTransformations = 0;
-    // Run transforms sequentially - each mutates the AST in place
-    for (const transform of transforms) {
-        logVerbose(verbose, `Running transform: ${transform.id}`);
-        try {
-            const stats = await transform.transform({
-                projectGraph,
-                currentFile: undefined,
-                options: {},
-            });
-            totalTransformations += stats.transformationsApplied;
-            logVerbose(verbose, `Applied ${stats.transformationsApplied} transformation(s)`);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                filesProcessed: 0,
-                totalTransformations,
-                errors: [`Transform '${transform.id}' failed: ${message}`],
-            };
-        }
+    // Run transforms - parallelize file-scoped parallelizable transforms
+    const log = (message) => {
+        logVerbose(verbose, message);
+    };
+    const result = await executeTransforms(transforms, projectGraph, queue, log);
+    if (result.error) {
+        return {
+            filesProcessed: 0,
+            totalTransformations: result.totalTransformations,
+            errors: [result.error],
+        };
     }
+    const totalTransformations = result.totalTransformations;
     // Generate final code from ASTs using @babel/generator
     const finalFiles = new Map();
     for (const [filePath, fileInfo] of projectGraph.files) {

package/dist/core/types.d.ts

@@ -28,3 +28,9 @@ export type Transform = {
     parallelizable: boolean;
     transform: (context: TransformContext) => Promise<TransformStats>;
 };
+/**
+ * Returns the files to process based on the context.
+ * If currentFile is set, returns only that file.
+ * Otherwise, returns all files from the project graph.
+ */
+export declare const getFilesToProcess: (context: TransformContext) => SourceFileInfo[];

package/dist/core/types.js

@@ -1 +1,11 @@
-export {};
+/**
+ * Returns the files to process based on the context.
+ * If currentFile is set, returns only that file.
+ * Otherwise, returns all files from the project graph.
+ */
+export const getFilesToProcess = (context) => {
+    if (context.currentFile) {
+        return [context.currentFile];
+    }
+    return [...context.projectGraph.files.values()];
+};

package/dist/scripts/evaluate/run-evaluations.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import PQueue from "p-queue";
 import { evaluatePair } from "./pair-evaluator.js";
 import { sanitizeFileComponent } from "./sanitize.js";
 export const runEvaluations = async (options) => {
@@ -6,7 +7,10 @@ export const runEvaluations = async (options) => {
     const results = [];
     const errors = [];
     const outcomes = [];
-    for (const pair of pairs) {
+    // Run pairs in parallel with limited concurrency
+    // Each pair spawns multiple subprocesses, so limit to 2 concurrent pairs
+    const queue = new PQueue({ concurrency: 2 });
+    const evaluationPromises = pairs.map((pair) => queue.add(async () => {
         const safeFrom = sanitizeFileComponent(pair.from);
         const safeTo = sanitizeFileComponent(pair.to);
         const filePrefix = `metrics-${baselineSlug}-vs-${testSlug}_${safeFrom}_${safeTo}`;
@@ -46,6 +50,7 @@ export const runEvaluations = async (options) => {
             outcomes.push({ ok: false, pair, error: message });
             console.error(`Error evaluating ${pair.from} -> ${pair.to}: ${message}`);
         }
-    }
+    }));
+    await Promise.all(evaluationPromises);
     return { results, errors, outcomes };
 };

package/dist/transforms/expand-boolean-literals/expand-boolean-literals-transform.d.ts

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

package/dist/transforms/expand-boolean-literals/expand-boolean-literals-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -10,10 +11,9 @@ export const expandBooleanLiteralsTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 UnaryExpression(path) {
                     nodesVisited++;

package/dist/transforms/expand-return-sequence/expand-return-sequence-transform.d.ts

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

package/dist/transforms/expand-return-sequence/expand-return-sequence-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -51,10 +52,9 @@ export const expandReturnSequenceTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 ReturnStatement(path) {
                     nodesVisited++;

package/dist/transforms/expand-sequence-expressions/expand-sequence-expressions-transform.d.ts

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

package/dist/transforms/expand-sequence-expressions/expand-sequence-expressions-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 import { tryExpandExpressionStatementSequence } from "./expand-expression-statement-sequence.js";
 import { tryExpandVariableDeclarationSequenceInitializers } from "./expand-variable-declaration-sequence.js";
 const require = createRequire(import.meta.url);
@@ -10,10 +11,9 @@ export const expandSequenceExpressionsTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 ExpressionStatement(path) {
                     nodesVisited++;

package/dist/transforms/expand-sequence-expressions-v2/expand-sequence-expressions-v2-transform.d.ts

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

package/dist/transforms/expand-sequence-expressions-v2/expand-sequence-expressions-v2-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 import { tryExpandExpressionStatementSequence } from "./expand-expression-statement-sequence.js";
 import { tryExpandReturnSequence } from "./expand-return-sequence.js";
 import { tryExpandVariableDeclarationSequenceInitializers } from "./expand-variable-declaration-sequence.js";
@@ -11,10 +12,9 @@ export const expandSequenceExpressionsV2Transform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 ReturnStatement(path) {
                     nodesVisited++;

package/dist/transforms/expand-sequence-expressions-v3/expand-sequence-expressions-v3-transform.d.ts

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

package/dist/transforms/expand-sequence-expressions-v3/expand-sequence-expressions-v3-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 import { tryExpandExpressionStatementSequence } from "./expand-expression-statement-sequence.js";
 import { tryExpandReturnSequence } from "./expand-return-sequence.js";
 import { tryExpandThrowSequence } from "./expand-throw-sequence.js";
@@ -12,10 +13,9 @@ export const expandSequenceExpressionsV3Transform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 ReturnStatement(path) {
                     nodesVisited++;

package/dist/transforms/expand-special-number-literals/expand-special-number-literals-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -59,10 +60,9 @@ export const expandSpecialNumberLiteralsTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 BinaryExpression(path) {
                     nodesVisited++;

package/dist/transforms/expand-throw-sequence/expand-throw-sequence-transform.d.ts

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

package/dist/transforms/expand-throw-sequence/expand-throw-sequence-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -99,10 +100,9 @@ export const expandThrowSequenceTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 ThrowStatement(path) {
                     nodesVisited++;

package/dist/transforms/expand-undefined-literals/expand-undefined-literals-transform.d.ts

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

package/dist/transforms/expand-undefined-literals/expand-undefined-literals-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -10,10 +11,9 @@ export const expandUndefinedLiteralsTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 UnaryExpression(path) {
                     nodesVisited++;

package/dist/transforms/rename-catch-parameters/rename-catch-parameters-transform.d.ts

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

package/dist/transforms/rename-catch-parameters/rename-catch-parameters-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -36,10 +37,9 @@ export const renameCatchParametersTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             const renamedCatches = new WeakMap();
             traverse(fileInfo.ast, {
                 CatchClause(path) {

package/dist/transforms/rename-destructured-aliases/rename-destructured-aliases-transform.d.ts

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

package/dist/transforms/rename-destructured-aliases/rename-destructured-aliases-transform.js

@@ -1,5 +1,6 @@
 import { createRequire } from "node:module";
 import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
+import { getFilesToProcess, } from "../../core/types.js";
 import { isBindingContext } from "./binding-context.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -99,10 +100,9 @@ export const renameDestructuredAliasesTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         const stats = { transformationsApplied: 0 };
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 ObjectPattern(path) {
                     nodesVisited++;

package/dist/transforms/rename-event-parameters/can-rename-binding-safely.d.ts

@@ -0,0 +1,2 @@
+import type { Scope } from "@babel/traverse";
+export declare const canRenameBindingSafely: (bindingScope: Scope, fromName: string, toName: string) => boolean;

package/dist/transforms/rename-event-parameters/can-rename-binding-safely.js

@@ -0,0 +1,28 @@
+import { isValidBindingIdentifier } from "./is-valid-binding-identifier.js";
+const hasShadowingRisk = (binding, bindingScope, targetName) => binding.referencePaths.some((referencePath) => {
+    if (referencePath.scope === bindingScope)
+        return false;
+    // Only consider bindings between this reference’s scope and the binding scope.
+    // This avoids incorrectly blocking safe renames due to unrelated outer bindings.
+    const hasBindingOptions = {
+        noGlobals: true,
+        noUids: true,
+        // Present in Babel scope implementation, but missing from our TypeScript types.
+        upToScope: bindingScope,
+    };
+    return referencePath.scope.hasBinding(targetName, hasBindingOptions);
+});
+export const canRenameBindingSafely = (bindingScope, fromName, toName) => {
+    if (fromName === toName)
+        return false;
+    if (!isValidBindingIdentifier(toName))
+        return false;
+    if (bindingScope.hasOwnBinding(toName))
+        return false;
+    const binding = bindingScope.getBinding(fromName);
+    if (!binding)
+        return false;
+    if (hasShadowingRisk(binding, bindingScope, toName))
+        return false;
+    return true;
+};

package/dist/transforms/rename-event-parameters/event-parameter-usage.d.ts

@@ -0,0 +1,9 @@
+import type { Binding } from "@babel/traverse";
+export type EventParameterUsage = {
+    isSafe: boolean;
+    propertyNames: Set<string>;
+    calledMethods: Set<string>;
+    hasNonMemberUsage: boolean;
+};
+export declare const getEventParameterUsage: (binding: Binding) => EventParameterUsage;
+export declare const isHighConfidenceEventParameter: (usage: EventParameterUsage) => boolean;

package/dist/transforms/rename-event-parameters/event-parameter-usage.js

@@ -0,0 +1,72 @@
+import { allowedEventPropertyNames } from "./event-property-names.js";
+import { getMemberExpressionForReference } from "./get-member-expression-for-reference.js";
+const isUnsafeNonMemberReference = (referencePath) => {
+    const parentPath = referencePath.parentPath;
+    if ((parentPath.isCallExpression() || parentPath.isOptionalCallExpression()) &&
+        referencePath.key === "callee")
+        return true;
+    if (parentPath.isNewExpression() && referencePath.key === "callee")
+        return true;
+    if (parentPath.isTaggedTemplateExpression() && referencePath.key === "tag")
+        return true;
+    if (parentPath.isMemberExpression() && referencePath.key === "property")
+        return true;
+    if (parentPath.isOptionalMemberExpression() &&
+        referencePath.key === "property")
+        return true;
+    if (parentPath.isUpdateExpression())
+        return true;
+    if (parentPath.isUnaryExpression() &&
+        parentPath.node.operator === "delete" &&
+        referencePath.key === "argument")
+        return true;
+    if (parentPath.isAssignmentExpression() && referencePath.key === "left")
+        return true;
+    return false;
+};
+export const getEventParameterUsage = (binding) => {
+    const propertyNames = new Set();
+    const calledMethods = new Set();
+    let hasNonMemberUsage = false;
+    for (const referencePath of binding.referencePaths) {
+        if (!referencePath.isIdentifier())
+            return { isSafe: false, propertyNames, calledMethods, hasNonMemberUsage };
+        const memberPath = getMemberExpressionForReference(referencePath);
+        if (!memberPath) {
+            hasNonMemberUsage = true;
+            if (isUnsafeNonMemberReference(referencePath)) {
+                return {
+                    isSafe: false,
+                    propertyNames,
+                    calledMethods,
+                    hasNonMemberUsage,
+                };
+            }
+            continue;
+        }
+        if (memberPath.node.computed)
+            return { isSafe: false, propertyNames, calledMethods, hasNonMemberUsage };
+        if (memberPath.node.property.type !== "Identifier")
+            return { isSafe: false, propertyNames, calledMethods, hasNonMemberUsage };
+        const propertyName = memberPath.node.property.name;
+        if (!allowedEventPropertyNames.has(propertyName))
+            return { isSafe: false, propertyNames, calledMethods, hasNonMemberUsage };
+        propertyNames.add(propertyName);
+        const parentPath = memberPath.parentPath;
+        if ((parentPath.isCallExpression() ||
+            parentPath.isOptionalCallExpression()) &&
+            parentPath.node.callee === memberPath.node) {
+            calledMethods.add(propertyName);
+        }
+    }
+    return { isSafe: true, propertyNames, calledMethods, hasNonMemberUsage };
+};
+export const isHighConfidenceEventParameter = (usage) => {
+    if (!usage.isSafe)
+        return false;
+    if (usage.propertyNames.size === 0)
+        return false;
+    return (usage.calledMethods.has("preventDefault") ||
+        usage.calledMethods.has("stopPropagation") ||
+        usage.calledMethods.has("stopImmediatePropagation"));
+};

package/dist/transforms/rename-event-parameters/event-property-names.d.ts

@@ -0,0 +1,3 @@
+export declare const allowedEventPropertyNames: Set<string>;
+export declare const mouseEventPropertyNames: Set<string>;
+export declare const keyboardEventPropertyNames: Set<string>;

package/dist/transforms/rename-event-parameters/event-property-names.js

@@ -0,0 +1,43 @@
+export const allowedEventPropertyNames = new Set([
+    // Strong signals
+    "preventDefault",
+    "stopPropagation",
+    "stopImmediatePropagation",
+    // Common event properties
+    "target",
+    "currentTarget",
+    "nativeEvent",
+    "type",
+    "defaultPrevented",
+    "timeStamp",
+    // Common UIEvent / MouseEvent properties
+    "clientX",
+    "clientY",
+    "pageX",
+    "pageY",
+    "screenX",
+    "screenY",
+    "button",
+    "buttons",
+    // KeyboardEvent properties
+    "key",
+    "code",
+    "keyCode",
+    "which",
+    // Modifier keys
+    "altKey",
+    "ctrlKey",
+    "metaKey",
+    "shiftKey",
+]);
+export const mouseEventPropertyNames = new Set([
+    "clientX",
+    "clientY",
+    "pageX",
+    "pageY",
+    "screenX",
+    "screenY",
+    "button",
+    "buttons",
+]);
+export const keyboardEventPropertyNames = new Set(["key", "code", "keyCode"]);

package/dist/transforms/rename-event-parameters/get-member-expression-for-reference.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Identifier, MemberExpression, OptionalMemberExpression } from "@babel/types";
+export declare const getMemberExpressionForReference: (referencePath: NodePath<Identifier>) => NodePath<MemberExpression | OptionalMemberExpression> | undefined;

package/dist/transforms/rename-event-parameters/get-member-expression-for-reference.js

@@ -0,0 +1,10 @@
+export const getMemberExpressionForReference = (referencePath) => {
+    const parentPath = referencePath.parentPath;
+    if (parentPath.isMemberExpression() &&
+        parentPath.node.object === referencePath.node)
+        return parentPath;
+    if (parentPath.isOptionalMemberExpression() &&
+        parentPath.node.object === referencePath.node)
+        return parentPath;
+    return;
+};

package/dist/transforms/rename-event-parameters/get-target-event-name.d.ts

@@ -0,0 +1,2 @@
+import type { EventParameterUsage } from "./event-parameter-usage.js";
+export declare const getTargetEventName: (usage: EventParameterUsage) => string;

package/dist/transforms/rename-event-parameters/get-target-event-name.js

@@ -0,0 +1,20 @@
+import { keyboardEventPropertyNames, mouseEventPropertyNames, } from "./event-property-names.js";
+export const getTargetEventName = (usage) => {
+    let hasMouseProperty = false;
+    let hasKeyboardProperty = false;
+    for (const name of usage.propertyNames) {
+        if (!hasMouseProperty && mouseEventPropertyNames.has(name)) {
+            hasMouseProperty = true;
+        }
+        if (!hasKeyboardProperty && keyboardEventPropertyNames.has(name)) {
+            hasKeyboardProperty = true;
+        }
+        if (hasMouseProperty && hasKeyboardProperty)
+            break;
+    }
+    if (hasKeyboardProperty && !hasMouseProperty)
+        return "keyboardEvent";
+    if (hasMouseProperty && !hasKeyboardProperty)
+        return "mouseEvent";
+    return "event";
+};

package/dist/transforms/rename-event-parameters/is-valid-binding-identifier.d.ts

@@ -0,0 +1 @@
+export declare const isValidBindingIdentifier: (name: string) => boolean;

package/dist/transforms/rename-event-parameters/is-valid-binding-identifier.js

@@ -0,0 +1,10 @@
+import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
+export const isValidBindingIdentifier = (name) => {
+    if (!isIdentifierName(name))
+        return false;
+    if (isKeyword(name))
+        return false;
+    if (isStrictBindReservedWord(name, true))
+        return false;
+    return true;
+};

package/dist/transforms/rename-event-parameters/process-event-handler-function.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from "@babel/traverse";
+import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from "@babel/types";
+export declare const processEventHandlerFunction: (path: NodePath<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression>, stats: {
+    transformationsApplied: number;
+}) => void;

package/dist/transforms/rename-event-parameters/process-event-handler-function.js

@@ -0,0 +1,59 @@
+import { getEventParameterUsage, isHighConfidenceEventParameter, } from "./event-parameter-usage.js";
+import { getTargetEventName } from "./get-target-event-name.js";
+import { canRenameBindingSafely } from "./can-rename-binding-safely.js";
+import { wouldShadowReferencedOuterBinding } from "./would-shadow-referenced-outer-binding.js";
+const wouldShadowReferencedImplicitGlobal = (functionPath, targetName) => {
+    const programScope = functionPath.scope.getProgramParent();
+    if (!Object.hasOwn(programScope.globals, targetName))
+        return false;
+    let foundReference = false;
+    functionPath.traverse({
+        Identifier(identifierPath) {
+            if (foundReference)
+                return;
+            if (identifierPath.node.name !== targetName)
+                return;
+            if (!identifierPath.isReferencedIdentifier())
+                return;
+            if (identifierPath.scope.getBinding(targetName))
+                return;
+            foundReference = true;
+            identifierPath.stop();
+        },
+    });
+    return foundReference;
+};
+export const processEventHandlerFunction = (path, stats) => {
+    const parameters = path.node.params;
+    if (parameters.length !== 1)
+        return;
+    const parameter = parameters[0];
+    if (!parameter)
+        return;
+    if (parameter.type !== "Identifier")
+        return;
+    // 1-2 character parameter names are a strong minification signal (e.g. `e`, `t`, `WA`).
+    // Keeping this conservative avoids renaming common intentional abbreviations (e.g. `evt`).
+    if (parameter.name.length > 2)
+        return;
+    const bindingScope = path.scope;
+    const binding = bindingScope.getBinding(parameter.name);
+    if (!binding)
+        return;
+    if (!binding.constant)
+        return;
+    const usage = getEventParameterUsage(binding);
+    if (!isHighConfidenceEventParameter(usage))
+        return;
+    const targetName = getTargetEventName(usage);
+    if (parameter.name === targetName)
+        return;
+    if (wouldShadowReferencedImplicitGlobal(path, targetName))
+        return;
+    if (wouldShadowReferencedOuterBinding(path, targetName))
+        return;
+    if (!canRenameBindingSafely(bindingScope, parameter.name, targetName))
+        return;
+    bindingScope.rename(parameter.name, targetName);
+    stats.transformationsApplied++;
+};

package/dist/transforms/rename-event-parameters/rename-event-parameters-transform.d.ts

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

package/dist/transforms/rename-event-parameters/rename-event-parameters-transform.js

@@ -0,0 +1,36 @@
+import { createRequire } from "node:module";
+import { processEventHandlerFunction } from "./process-event-handler-function.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 renameEventParametersTransform = {
+    id: "rename-event-parameters",
+    description: "Renames minified single-parameter event handlers to event/mouseEvent/keyboardEvent when usage is high-confidence",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        const stats = { transformationsApplied: 0 };
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                FunctionDeclaration(path) {
+                    nodesVisited++;
+                    processEventHandlerFunction(path, stats);
+                },
+                FunctionExpression(path) {
+                    nodesVisited++;
+                    processEventHandlerFunction(path, stats);
+                },
+                ArrowFunctionExpression(path) {
+                    nodesVisited++;
+                    processEventHandlerFunction(path, stats);
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied: stats.transformationsApplied,
+        });
+    },
+};

package/dist/transforms/rename-event-parameters/would-shadow-referenced-outer-binding.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from "@babel/types";
+export declare const wouldShadowReferencedOuterBinding: (functionPath: NodePath<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression>, targetName: string) => boolean;

package/dist/transforms/rename-event-parameters/would-shadow-referenced-outer-binding.js

@@ -0,0 +1,21 @@
+export const wouldShadowReferencedOuterBinding = (functionPath, targetName) => {
+    const outerBinding = functionPath.scope.getBinding(targetName);
+    if (!outerBinding)
+        return false;
+    let foundReference = false;
+    functionPath.traverse({
+        Identifier(identifierPath) {
+            if (foundReference)
+                return;
+            if (identifierPath.node.name !== targetName)
+                return;
+            if (!identifierPath.isReferencedIdentifier())
+                return;
+            if (identifierPath.scope.getBinding(targetName) !== outerBinding)
+                return;
+            foundReference = true;
+            identifierPath.stop();
+        },
+    });
+    return foundReference;
+};

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

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

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

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -94,10 +95,9 @@ export const renameLoopIndexVariablesTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             const renamedLoops = new WeakMap();
             traverse(fileInfo.ast, {
                 ForStatement(path) {

package/dist/transforms/rename-promise-executor-parameters/rename-promise-executor-parameters-transform.d.ts

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

package/dist/transforms/rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 import { getExecutorFunctionIfEligible, isAssignedToOnHandlerProperty, isDirectCallOfBinding, wouldShadowReferencedOuterBinding, } from "./promise-executor-heuristics.js";
 import { canRenameBindingSafely, renameBindingIfSafe, } from "./rename-binding-if-safe.js";
 const require = createRequire(import.meta.url);
@@ -10,10 +11,9 @@ export const renamePromiseExecutorParametersTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 NewExpression(path) {
                     nodesVisited++;

package/dist/transforms/rename-timeout-ids/rename-timeout-ids-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess } from "../../core/types.js";
 import { getTargetName } from "../rename-binding/get-target-name.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -43,10 +44,9 @@ export const renameTimeoutIdsTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;

package/dist/transforms/rename-use-reference-guards/rename-use-reference-guards-transform.d.ts

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

package/dist/transforms/rename-use-reference-guards/rename-use-reference-guards-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 import { getReferenceUsage } from "./get-reference-usage.js";
 import { getTargetName } from "./get-target-name.js";
 import { isUseReferenceFalseInitializer } from "./is-use-reference-false-initializer.js";
@@ -11,10 +12,9 @@ const renameUseReferenceGuardsTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;

package/dist/transforms/split-variable-declarations/split-variable-declarations-transform.d.ts

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

package/dist/transforms/split-variable-declarations/split-variable-declarations-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { getFilesToProcess, } from "../../core/types.js";
 import { createVariableDeclarationFromDeclarator } from "./create-variable-declaration.js";
 import { isSafeToSplitVariableDeclaration } from "./is-safe-to-split-variable-declaration.js";
 const require = createRequire(import.meta.url);
@@ -31,10 +32,9 @@ export const splitVariableDeclarationsTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
             traverse(fileInfo.ast, {
                 ExportNamedDeclaration(path) {
                     nodesVisited++;

package/dist/transforms/transform-registry.js

@@ -8,6 +8,7 @@ import { expandThrowSequenceTransform } from "./expand-throw-sequence/expand-thr
 import { expandUndefinedLiteralsTransform } from "./expand-undefined-literals/expand-undefined-literals-transform.js";
 import { renameCatchParametersTransform } from "./rename-catch-parameters/rename-catch-parameters-transform.js";
 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 { renamePromiseExecutorParametersTransform } from "./rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
 import { renameTimeoutIdsTransform } from "./rename-timeout-ids/rename-timeout-ids-transform.js";
@@ -24,6 +25,7 @@ export const transformRegistry = {
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
+    [renameEventParametersTransform.id]: renameEventParametersTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,

package/package.json

@@ -2,7 +2,7 @@
   "name": "miniread",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",

package/transform-manifest.json

@@ -40,6 +40,15 @@
       "evaluatedAt": "2026-01-23T07:48:59.087Z",
       "notes": "Auto-added by evaluation script."
     },
+    {
+      "id": "rename-event-parameters",
+      "description": "Renames minified single-parameter event handlers to event/mouseEvent/keyboardEvent when usage is high-confidence",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "notes": "Added manually; recommended based on high-confidence heuristics (not yet evaluated)."
+    },
     {
       "id": "rename-destructured-aliases",
       "description": "Renames destructuring aliases to match property names (e.g., { foo: x } → { foo })",