miniread 1.50.0 → 1.51.0

package/dist/transforms/_generated/manifest.js

@@ -103,6 +103,11 @@ const manifestData = {
         notes: "Auto-added by evaluation script. Measured with baseline none: 0.09%.",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T19:59:48.188Z", "changedLines": 38927, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 97.80020410477378 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 97.80020410477378, "evaluatedAt": "2026-01-25T23:15:44.243Z", "changedLines": 38927, "durationSeconds": 76.61873741599999, "stableNames": 4505 } },
     },
+    "rename-error-first-callback-parameters": {
+        recommended: true,
+        notes: "Measured with baseline none: 0.00%.",
+        evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T21:27:50.901Z", "changedLines": 448, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 100 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-27T06:34:23.332Z", "changedLines": 440, "durationSeconds": 50.931335125000004, "stableNames": 1360 } },
+    },
     "rename-error-variables": {
         recommended: true,
         notes: "Auto-added by evaluation script.",

package/dist/transforms/_generated/registry.js

@@ -20,6 +20,7 @@ import { renameDateNowStartTimesTransform } from "../rename-date-now-start-times
 import { renameDefaultOptionsParametersTransform } from "../rename-default-options-parameters/rename-default-options-parameters-transform.js";
 import { renameDeferredResolveParametersTransform } from "../rename-deferred-resolve-parameters/rename-deferred-resolve-parameters-transform.js";
 import { renameDestructuredAliasesTransform } from "../rename-destructured-aliases/rename-destructured-aliases-transform.js";
+import { renameErrorFirstCallbackParametersTransform } from "../rename-error-first-callback-parameters/rename-error-first-callback-parameters-transform.js";
 import { renameErrorVariablesTransform } from "../rename-error-variables/rename-error-variables-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";
@@ -75,6 +76,7 @@ export const transformRegistry = {
     [renameDefaultOptionsParametersTransform.id]: renameDefaultOptionsParametersTransform,
     [renameDeferredResolveParametersTransform.id]: renameDeferredResolveParametersTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
+    [renameErrorFirstCallbackParametersTransform.id]: renameErrorFirstCallbackParametersTransform,
     [renameErrorVariablesTransform.id]: renameErrorVariablesTransform,
     [renameEventParametersTransform.id]: renameEventParametersTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,

package/dist/transforms/rename-error-first-callback-parameters/manifest.json

@@ -0,0 +1,20 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "legacy:evaluation": {
+            "evaluatedAt": "2026-01-25T21:27:50.901Z",
+            "changedLines": 448,
+            "durationSeconds": 0,
+            "stableNames": 0,
+            "diffSizePercent": 100
+        },
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-01-27T06:34:23.332Z",
+            "changedLines": 440,
+            "durationSeconds": 50.931335125000004,
+            "stableNames": 1360
+        }
+    },
+    "notes": "Measured with baseline none: 0.00%."
+}

package/dist/transforms/rename-error-first-callback-parameters/rename-error-first-callback-parameters-transform.d.ts

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

package/dist/transforms/rename-error-first-callback-parameters/rename-error-first-callback-parameters-transform.js

@@ -0,0 +1,117 @@
+import { createRequire } from "node:module";
+import { RenameGroup } from "../../core/stable-naming.js";
+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;
+const BASE_NAME = "error";
+const getReturnCallExpression = (statement) => {
+    if (statement.type === "ReturnStatement") {
+        return statement.argument?.type === "CallExpression"
+            ? statement.argument
+            : undefined;
+    }
+    if (statement.type !== "BlockStatement")
+        return undefined;
+    if (statement.body.length !== 1)
+        return undefined;
+    const firstStatement = statement.body[0];
+    if (firstStatement?.type !== "ReturnStatement")
+        return undefined;
+    return firstStatement.argument?.type === "CallExpression"
+        ? firstStatement.argument
+        : undefined;
+};
+const getErrorFirstIfStatement = (path) => {
+    const body = path.node.body;
+    if (body.type !== "BlockStatement")
+        return undefined;
+    // Avoid false positives like `function f(x) { if (x) return cb(x); }` where the
+    // guard is the only statement and the function has no "success path" code.
+    if (body.body.length < 2)
+        return undefined;
+    const firstStatement = body.body[0];
+    if (firstStatement?.type !== "IfStatement")
+        return undefined;
+    if (firstStatement.alternate)
+        return undefined;
+    return firstStatement;
+};
+const matchesErrorFirstGuard = (path) => {
+    const firstParameter = path.node.params[0];
+    if (firstParameter?.type !== "Identifier")
+        return undefined;
+    const firstBinding = path.scope.getBinding(firstParameter.name);
+    if (!firstBinding)
+        return undefined;
+    if (firstBinding.kind !== "param")
+        return undefined;
+    if (firstBinding.referencePaths.length !== 2)
+        return undefined;
+    const ifStatement = getErrorFirstIfStatement(path);
+    if (!ifStatement)
+        return undefined;
+    if (ifStatement.test.type !== "Identifier")
+        return undefined;
+    if (ifStatement.test.name !== firstParameter.name)
+        return undefined;
+    const returnCall = getReturnCallExpression(ifStatement.consequent);
+    if (!returnCall)
+        return undefined;
+    if (returnCall.callee.type !== "Identifier")
+        return undefined;
+    const callbackBinding = path.scope.getBinding(returnCall.callee.name);
+    if (!callbackBinding)
+        return undefined;
+    if (callbackBinding.kind !== "param")
+        return undefined;
+    const callbackOwner = callbackBinding.scope.path.node;
+    if (callbackOwner.type !== "FunctionDeclaration" &&
+        callbackOwner.type !== "FunctionExpression" &&
+        callbackOwner.type !== "ArrowFunctionExpression") {
+        return undefined;
+    }
+    const callbackOwnerParameters = callbackOwner.params;
+    const lastCallbackOwnerParameter = callbackOwnerParameters.at(-1);
+    if (lastCallbackOwnerParameter?.type !== "Identifier")
+        return undefined;
+    if (lastCallbackOwnerParameter.name !== returnCall.callee.name)
+        return undefined;
+    const firstArgument = returnCall.arguments[0];
+    if (firstArgument?.type !== "Identifier")
+        return undefined;
+    if (firstArgument.name !== firstParameter.name)
+        return undefined;
+    return firstParameter.name;
+};
+export const renameErrorFirstCallbackParametersTransform = {
+    id: "rename-error-first-callback-parameters",
+    description: "Renames error-first callback parameters used in leading `if (err) return cb(err)` guards to $error/$error2/...",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            traverse(fileInfo.ast, {
+                Function(path) {
+                    nodesVisited++;
+                    const currentName = matchesErrorFirstGuard(path);
+                    if (!currentName)
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName,
+                        baseName: BASE_NAME,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/package.json

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