miniread 1.27.0 → 1.28.0

package/dist/transforms/_generated/manifest.js

@@ -38,6 +38,12 @@ const manifestData = {
         evaluatedAt: "2026-01-23T18:15:00.000Z",
         notes: "Added manually; improves readability by reducing nesting.",
     },
+    "rename-awaiter-parameters": {
+        diffReductionImpact: 0,
+        recommended: true,
+        evaluatedAt: "2026-01-24T12:40:34.000Z",
+        notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
+    },
     "rename-catch-parameters": {
         diffReductionImpact: 0.0007738623280043599,
         recommended: true,

package/dist/transforms/_generated/registry.js

@@ -6,6 +6,7 @@ import { expandSequenceExpressionsV5Transform } from "../expand-sequence-express
 import { expandSpecialNumberLiteralsTransform } from "../expand-special-number-literals/expand-special-number-literals-transform.js";
 import { expandUndefinedLiteralsTransform } from "../expand-undefined-literals/expand-undefined-literals-transform.js";
 import { removeRedundantElseTransform } from "../remove-redundant-else/remove-redundant-else-transform.js";
+import { renameAwaiterParametersTransform } from "../rename-awaiter-parameters/rename-awaiter-parameters-transform.js";
 import { renameCatchParametersTransform } from "../rename-catch-parameters/rename-catch-parameters-transform.js";
 import { renameCharCodeAtTransform } from "../rename-char-code-at/rename-char-code-at-transform.js";
 import { renameCharcodeVariablesTransform } from "../rename-charcode-variables/rename-charcode-variables-transform.js";
@@ -40,6 +41,7 @@ export const transformRegistry = {
     [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [removeRedundantElseTransform.id]: removeRedundantElseTransform,
+    [renameAwaiterParametersTransform.id]: renameAwaiterParametersTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
     [renameCharCodeAtTransform.id]: renameCharCodeAtTransform,
     [renameCharcodeVariablesTransform.id]: renameCharcodeVariablesTransform,

package/dist/transforms/rename-awaiter-parameters/awaiter-pattern.d.ts

@@ -0,0 +1,12 @@
+import type { NodePath } from "@babel/traverse";
+import type { Function as BabelFunction, Identifier } from "@babel/types";
+type AwaiterParameterNames = {
+    thisArg: string;
+    args: string;
+    promiseCtor: string;
+    generator: string;
+};
+declare const isIdentifierParameters: (parameters: BabelFunction["params"]) => parameters is [Identifier, Identifier, Identifier, Identifier];
+declare const hasAwaiterPattern: (path: NodePath<BabelFunction>, names: AwaiterParameterNames) => boolean;
+export { hasAwaiterPattern, isIdentifierParameters };
+export type { AwaiterParameterNames };

package/dist/transforms/rename-awaiter-parameters/awaiter-pattern.js

@@ -0,0 +1,101 @@
+import { isIdentifier } from "@babel/types";
+const isIdentifierParameters = (parameters) => {
+    if (parameters.length !== 4)
+        return false;
+    return parameters.every((parameter) => parameter.type === "Identifier");
+};
+const isIdentifierNamed = (node, name) => isIdentifier(node) && node.name === name;
+const isEmptyArrayExpression = (node) => node.elements.length === 0;
+const isArgumentsFallback = (node, argumentsName) => node.operator === "||" &&
+    isIdentifierNamed(node.left, argumentsName) &&
+    node.right.type === "ArrayExpression" &&
+    isEmptyArrayExpression(node.right);
+const isGeneratorApplyCall = (node, generatorName, thisArgumentName, argumentsName) => {
+    const callee = node.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (!isIdentifierNamed(callee.object, generatorName))
+        return false;
+    if (!isIdentifierNamed(callee.property, "apply"))
+        return false;
+    if (node.arguments.length !== 2)
+        return false;
+    const [thisArgument, argumentsValue] = node.arguments;
+    if (!thisArgument || !argumentsValue)
+        return false;
+    if (!isIdentifierNamed(thisArgument, thisArgumentName))
+        return false;
+    if (argumentsValue.type === "Identifier") {
+        return argumentsValue.name === argumentsName;
+    }
+    if (argumentsValue.type !== "LogicalExpression")
+        return false;
+    return isArgumentsFallback(argumentsValue, argumentsName);
+};
+const isGeneratorMethodCall = (node, generatorName, methodName) => {
+    const callee = node.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (!isIdentifierNamed(callee.object, generatorName))
+        return false;
+    return isIdentifierNamed(callee.property, methodName);
+};
+const isPromiseCtorNewExpression = (node, promiseCtorName) => {
+    const callee = node.callee;
+    if (callee.type === "Identifier") {
+        return callee.name === promiseCtorName;
+    }
+    if (callee.type !== "LogicalExpression")
+        return false;
+    if (callee.operator !== "||")
+        return false;
+    if (!isIdentifierNamed(callee.left, promiseCtorName))
+        return false;
+    const right = callee.right;
+    if (right.type !== "AssignmentExpression")
+        return false;
+    if (right.operator !== "=")
+        return false;
+    if (!isIdentifierNamed(right.left, promiseCtorName))
+        return false;
+    return isIdentifierNamed(right.right, "Promise");
+};
+const isPromiseCtorInstanceof = (node, promiseCtorName) => node.operator === "instanceof" &&
+    isIdentifierNamed(node.right, promiseCtorName);
+const hasAwaiterPattern = (path, names) => {
+    let hasApplyCall = false;
+    let hasNextCall = false;
+    let hasThrowCall = false;
+    let hasPromiseCtorUsage = false;
+    path.traverse({
+        CallExpression(innerPath) {
+            const node = innerPath.node;
+            if (isGeneratorApplyCall(node, names.generator, names.thisArg, names.args)) {
+                hasApplyCall = true;
+            }
+            if (isGeneratorMethodCall(node, names.generator, "next")) {
+                hasNextCall = true;
+            }
+            if (isGeneratorMethodCall(node, names.generator, "throw")) {
+                hasThrowCall = true;
+            }
+        },
+        NewExpression(innerPath) {
+            if (isPromiseCtorNewExpression(innerPath.node, names.promiseCtor)) {
+                hasPromiseCtorUsage = true;
+            }
+        },
+        BinaryExpression(innerPath) {
+            if (isPromiseCtorInstanceof(innerPath.node, names.promiseCtor)) {
+                hasPromiseCtorUsage = true;
+            }
+        },
+    });
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return hasApplyCall && hasNextCall && hasThrowCall && hasPromiseCtorUsage;
+};
+export { hasAwaiterPattern, isIdentifierParameters };

package/dist/transforms/rename-awaiter-parameters/manifest.json

@@ -0,0 +1,6 @@
+{
+    "diffReductionImpact": 0,
+    "recommended": true,
+    "evaluatedAt": "2026-01-24T12:40:34.000Z",
+    "notes": "Measured with baseline none: 0.00%. Added to recommended for readability."
+}

package/dist/transforms/rename-awaiter-parameters/rename-awaiter-bindings.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from "@babel/traverse";
+import type { Function as BabelFunction } from "@babel/types";
+import type { AwaiterParameterNames } from "./awaiter-pattern.js";
+declare const renameAwaiterParameters: (path: NodePath<BabelFunction>, names: AwaiterParameterNames) => number;
+export { renameAwaiterParameters };

package/dist/transforms/rename-awaiter-parameters/rename-awaiter-bindings.js

@@ -0,0 +1,49 @@
+import { RenameGroup } from "../../core/stable-naming.js";
+const PARAM_BASE_NAMES = {
+    thisArg: "thisArg",
+    args: "args",
+    promiseCtor: "promiseCtor",
+    generator: "generator",
+};
+const renameAwaiterParameters = (path, names) => {
+    const thisArgumentBinding = path.scope.getBinding(names.thisArg);
+    const argumentsBinding = path.scope.getBinding(names.args);
+    const promiseCtorBinding = path.scope.getBinding(names.promiseCtor);
+    const generatorBinding = path.scope.getBinding(names.generator);
+    if (!thisArgumentBinding ||
+        !argumentsBinding ||
+        !promiseCtorBinding ||
+        !generatorBinding) {
+        return 0;
+    }
+    const isOwnedByFunctionScope = (binding) => binding.scope === path.scope;
+    if (!isOwnedByFunctionScope(thisArgumentBinding) ||
+        !isOwnedByFunctionScope(argumentsBinding) ||
+        !isOwnedByFunctionScope(promiseCtorBinding) ||
+        !isOwnedByFunctionScope(generatorBinding)) {
+        return 0;
+    }
+    const group = new RenameGroup();
+    group.add({
+        scope: path.scope,
+        currentName: names.thisArg,
+        baseName: PARAM_BASE_NAMES.thisArg,
+    });
+    group.add({
+        scope: path.scope,
+        currentName: names.args,
+        baseName: PARAM_BASE_NAMES.args,
+    });
+    group.add({
+        scope: path.scope,
+        currentName: names.promiseCtor,
+        baseName: PARAM_BASE_NAMES.promiseCtor,
+    });
+    group.add({
+        scope: path.scope,
+        currentName: names.generator,
+        baseName: PARAM_BASE_NAMES.generator,
+    });
+    return group.apply();
+};
+export { renameAwaiterParameters };

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

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

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

@@ -0,0 +1,48 @@
+import { createRequire } from "node:module";
+import { isStableRenamed } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { hasAwaiterPattern, isIdentifierParameters, } from "./awaiter-pattern.js";
+import { renameAwaiterParameters } from "./rename-awaiter-bindings.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 renameAwaiterParametersTransform = {
+    id: "rename-awaiter-parameters",
+    description: "Renames TypeScript __awaiter helper parameters to $thisArg/$args/$promiseCtor/$generator",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            traverse(fileInfo.ast, {
+                Function(path) {
+                    nodesVisited++;
+                    const parameters = path.node.params;
+                    if (!isIdentifierParameters(parameters))
+                        return;
+                    const [thisArgument, argumentsValue, promiseCtor, generator] = parameters;
+                    const names = {
+                        thisArg: thisArgument.name,
+                        args: argumentsValue.name,
+                        promiseCtor: promiseCtor.name,
+                        generator: generator.name,
+                    };
+                    if (isStableRenamed(names.thisArg) ||
+                        isStableRenamed(names.args) ||
+                        isStableRenamed(names.promiseCtor) ||
+                        isStableRenamed(names.generator)) {
+                        return;
+                    }
+                    if (!hasAwaiterPattern(path, names))
+                        return;
+                    transformationsApplied += renameAwaiterParameters(path, names);
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/package.json

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