miniread 1.12.0 → 1.14.0

package/dist/transforms/rename-comparison-flags/rename-comparison-flags-transform.d.ts

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

package/dist/transforms/rename-comparison-flags/rename-comparison-flags-transform.js

@@ -0,0 +1,86 @@
+import { createRequire } from "node:module";
+import { RenameGroup, isStableRenamed } 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;
+export const renameComparisonFlagsTransform = {
+    id: "rename-comparison-flags",
+    description: "Rename boolean variables assigned from string comparisons to descriptive flag names",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const renameGroup = new RenameGroup();
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const { id, init } = path.node;
+                    if (!init || id.type !== "Identifier") {
+                        return;
+                    }
+                    if (init.type !== "BinaryExpression" ||
+                        (init.operator !== "===" &&
+                            init.operator !== "!==" &&
+                            init.operator !== "==" &&
+                            init.operator !== "!=")) {
+                        return;
+                    }
+                    let stringValue;
+                    if (init.right.type === "StringLiteral" &&
+                        init.left.type === "Identifier") {
+                        stringValue = init.right.value;
+                    }
+                    else if (init.left.type === "StringLiteral" &&
+                        init.right.type === "Identifier") {
+                        stringValue = init.left.value;
+                    }
+                    if (stringValue === undefined) {
+                        return;
+                    }
+                    const currentName = id.name;
+                    if (isStableRenamed(currentName)) {
+                        return;
+                    }
+                    const operator = init.operator;
+                    const parts = stringValue.split(/[^\dA-Za-z]+/u).filter(Boolean);
+                    const capitalizedValue = parts.length === 0
+                        ? stringValue === ""
+                            ? "EmptyString"
+                            : "Flag"
+                        : parts
+                            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+                            .join("");
+                    let baseName;
+                    switch (operator) {
+                        case "===": {
+                            baseName = `is${capitalizedValue}`;
+                            break;
+                        }
+                        case "!==": {
+                            baseName = `isNot${capitalizedValue}`;
+                            break;
+                        }
+                        case "==": {
+                            baseName = `equals${capitalizedValue}`;
+                            break;
+                        }
+                        case "!=": {
+                            baseName = `notEquals${capitalizedValue}`;
+                            break;
+                        }
+                    }
+                    renameGroup.add({
+                        scope: path.scope,
+                        currentName,
+                        baseName,
+                    });
+                },
+            });
+            transformationsApplied += renameGroup.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-parameters-to-match-properties/rename-parameters-to-match-properties-transform.d.ts

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

package/dist/transforms/rename-parameters-to-match-properties/rename-parameters-to-match-properties-transform.js

@@ -0,0 +1,98 @@
+import { createRequire } from "node:module";
+import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
+import { getFilesToProcess, } from "../../core/types.js";
+import { isStableRenamed } from "../../core/stable-naming.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 renameParametersToMatchPropertiesTransform = {
+    id: "rename-parameters-to-match-properties",
+    description: "Renames parameters that are assigned to object properties of the same name",
+    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.get("params");
+                    for (const parameterPath of parameters) {
+                        if (!parameterPath.isIdentifier())
+                            continue;
+                        const currentName = parameterPath.node.name;
+                        if (isStableRenamed(currentName))
+                            continue;
+                        const binding = path.scope.getBinding(currentName);
+                        if (!binding)
+                            continue;
+                        let candidateName;
+                        let isConsistent = true;
+                        // Analyze all references to this parameter
+                        for (const referencePath of binding.referencePaths) {
+                            const parent = referencePath.parentPath;
+                            // Check if reference is a value in an ObjectProperty
+                            if (parent?.isObjectProperty()) {
+                                // Ensure the param is the value, not the key (unless computed, but standard key is non-computed identifier)
+                                // Note: referencePath.node is the specific node instance.
+                                if (parent.node.value !== referencePath.node)
+                                    continue;
+                                // Get the key name
+                                const key = parent.node.key;
+                                if (key.type === "Identifier" && !parent.node.computed) {
+                                    const propertyName = key.name;
+                                    if (candidateName === undefined) {
+                                        candidateName = propertyName;
+                                    }
+                                    else if (candidateName !== propertyName) {
+                                        // Conflicting property names (e.g. { x: a, y: a })
+                                        isConsistent = false;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        if (candidateName) {
+                            // Check global references (conservative: if file uses 'console', don't use 'console')
+                            const programScope = path.scope.getProgramParent();
+                            if (Object.hasOwn(programScope.globals, candidateName)) {
+                                isConsistent = false;
+                            }
+                            // Check for nested scope shadowing
+                            // If we rename `a` -> `b`, and a nested scope has `b` bound,
+                            // and we use `a` in that nested scope, it will become `b` (referring to inner `b`).
+                            const wouldBeShadowed = binding.referencePaths.some((referencePath) => referencePath.scope !== path.scope &&
+                                referencePath.scope.hasBinding(candidateName));
+                            if (wouldBeShadowed) {
+                                isConsistent = false;
+                            }
+                        }
+                        // Constraints:
+                        // 1. New name must be valid identifier
+                        // 2. New name must not be a keyword/reserved word
+                        // 3. New name must be longer than current, OR current is very short (<= 2 chars)
+                        // 4. New name must be different from current
+                        // 5. New name must not already exist in the scope
+                        if (isConsistent &&
+                            candidateName &&
+                            candidateName !== currentName &&
+                            (candidateName.length > currentName.length ||
+                                currentName.length <= 2) &&
+                            isIdentifierName(candidateName) &&
+                            !isKeyword(candidateName) &&
+                            !isStrictBindReservedWord(candidateName, true) &&
+                            !path.scope.hasBinding(candidateName)) {
+                            path.scope.rename(currentName, candidateName);
+                            transformationsApplied++;
+                        }
+                    }
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/transform-registry.js

@@ -4,6 +4,7 @@ import { expandSequenceExpressionsV4Transform } from "./expand-sequence-expressi
 import { expandSequenceExpressionsV5Transform } from "./expand-sequence-expressions-v5/expand-sequence-expressions-v5-transform.js";
 import { expandUndefinedLiteralsTransform } from "./expand-undefined-literals/expand-undefined-literals-transform.js";
 import { renameCatchParametersTransform } from "./rename-catch-parameters/rename-catch-parameters-transform.js";
+import { renameComparisonFlagsTransform } from "./rename-comparison-flags/rename-comparison-flags-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";
@@ -16,6 +17,7 @@ import { renameTimeoutIdsTransform } from "./rename-timeout-ids/rename-timeout-i
 import { renameUseReferenceGuardsTransform } from "./rename-use-reference-guards/rename-use-reference-guards-transform.js";
 import { renameUseReferenceGuardsV2Transform } from "./rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js";
 import { splitVariableDeclarationsTransform } from "./split-variable-declarations/split-variable-declarations-transform.js";
+import { renameParametersToMatchPropertiesTransform } from "./rename-parameters-to-match-properties/rename-parameters-to-match-properties-transform.js";
 export const transformRegistry = {
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
     [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
@@ -23,6 +25,7 @@ export const transformRegistry = {
     [expandSequenceExpressionsV5Transform.id]: expandSequenceExpressionsV5Transform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
+    [renameComparisonFlagsTransform.id]: renameComparisonFlagsTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
     [renameEventParametersTransform.id]: renameEventParametersTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,
@@ -35,5 +38,6 @@ export const transformRegistry = {
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
+    [renameParametersToMatchPropertiesTransform.id]: renameParametersToMatchPropertiesTransform,
 };
 export const allTransformIds = Object.keys(transformRegistry);

package/package.json

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

package/transform-manifest.json

@@ -141,6 +141,16 @@
       "evaluatedAt": "2026-01-23T10:29:23.279Z",
       "notes": "Measured with baseline none: 0.00%. Added to recommended for readability."
     },
+    {
+      "id": "rename-comparison-flags",
+      "description": "Rename boolean variables assigned from string comparisons to descriptive flag names",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T17:54:14.000Z",
+      "notes": "Measured with baseline none: 0%. Improves readability by renaming minified variables like 'saA === \"darwin\"' to '$isDarwin'."
+    },
     {
       "id": "split-variable-declarations",
       "description": "Splits multi-declarator variable declarations into separate statements",
@@ -180,6 +190,15 @@
       "recommended": true,
       "evaluatedAt": "2026-01-23T08:17:45.579Z",
       "notes": "Auto-added by evaluation script."
+    },
+    {
+      "id": "rename-parameters-to-match-properties",
+      "description": "Renames parameters that are assigned to object properties of the same name",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0.00003774938185385768,
+      "recommended": true,
+      "notes": "Added manually based on high-confidence heuristic."
     }
   ],
   "presetStats": {