miniread 1.20.0 → 1.22.0

package/dist/transforms/_generated/manifest.js

@@ -101,9 +101,16 @@ const manifestData = {
         notes: "Unifies rename-loop-index-variables and rename-loop-index-variables-v2 without modifying older transforms. Measured with baseline none: 0.00%.",
     },
     "rename-parameters-to-match-properties": {
-        diffReductionImpact: 0.00003774938185385768,
+        diffReductionImpact: 0,
+        recommended: false,
+        notes: "Superseded by rename-parameters-to-match-properties-v2.",
+        supersededBy: "rename-parameters-to-match-properties-v2",
+    },
+    "rename-parameters-to-match-properties-v2": {
+        diffReductionImpact: 0.00009424182452166807,
         recommended: true,
-        notes: "Added manually based on high-confidence heuristic.",
+        evaluatedAt: "2026-01-24T09:58:42.363Z",
+        notes: "Extends v1 to also handle this.property = param assignments.",
     },
     "rename-promise-executor-parameters": {
         diffReductionImpact: 0,
@@ -129,6 +136,10 @@ const manifestData = {
         evaluatedAt: "2026-01-23T10:29:23.279Z",
         notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
     },
+    "rename-typeof-variables": {
+        diffReductionImpact: 0,
+        recommended: true,
+    },
     "rename-use-reference-guards": {
         diffReductionImpact: 0,
         recommended: false,

package/dist/transforms/_generated/registry.js

@@ -17,10 +17,12 @@ import { renameLoopIndexVariablesTransform } from "../rename-loop-index-variable
 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 { renameParametersToMatchPropertiesTransform } from "../rename-parameters-to-match-properties/rename-parameters-to-match-properties-transform.js";
+import { renameParametersToMatchPropertiesV2Transform } from "../rename-parameters-to-match-properties-v2/rename-parameters-to-match-properties-v2-transform.js";
 import { renamePromiseExecutorParametersTransform } from "../rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
 import { renameReplaceChildParametersTransform } from "../rename-replace-child-parameters/rename-replace-child-parameters-transform.js";
 import { renameThisAliasesTransform } from "../rename-this-aliases/rename-this-aliases-transform.js";
 import { renameTimeoutIdsTransform } from "../rename-timeout-ids/rename-timeout-ids-transform.js";
+import { renameTypeofVariablesTransform } from "../rename-typeof-variables/rename-typeof-variables-transform.js";
 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 { simplifyBooleanNegationsTransform } from "../simplify-boolean-negations/simplify-boolean-negations-transform.js";
@@ -43,10 +45,12 @@ export const transformRegistry = {
     [renameLoopIndexVariablesV2Transform.id]: renameLoopIndexVariablesV2Transform,
     [renameLoopIndexVariablesV3Transform.id]: renameLoopIndexVariablesV3Transform,
     [renameParametersToMatchPropertiesTransform.id]: renameParametersToMatchPropertiesTransform,
+    [renameParametersToMatchPropertiesV2Transform.id]: renameParametersToMatchPropertiesV2Transform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
+    [renameTypeofVariablesTransform.id]: renameTypeofVariablesTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffReductionImpact": 0.003690002076215948,
-        "notes": "Measured with baseline none: 0.37%."
+        "diffReductionImpact": 0.001470172462538888,
+        "notes": "Measured with baseline none: 0.15%."
     }
 }

package/dist/transforms/rename-parameters-to-match-properties/manifest.json

@@ -1,5 +1,6 @@
 {
-    "diffReductionImpact": 0.00003774938185385768,
-    "recommended": true,
-    "notes": "Added manually based on high-confidence heuristic."
+    "diffReductionImpact": 0,
+    "recommended": false,
+    "notes": "Superseded by rename-parameters-to-match-properties-v2.",
+    "supersededBy": "rename-parameters-to-match-properties-v2"
 }

package/dist/transforms/rename-parameters-to-match-properties-v2/manifest.json

@@ -0,0 +1,6 @@
+{
+    "diffReductionImpact": 0.00009424182452166807,
+    "recommended": true,
+    "notes": "Extends v1 to also handle this.property = param assignments.",
+    "evaluatedAt": "2026-01-24T09:58:42.363Z"
+}

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

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

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

@@ -0,0 +1,121 @@
+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 renameParametersToMatchPropertiesV2Transform = {
+    id: "rename-parameters-to-match-properties-v2",
+    description: "Renames parameters assigned to object properties or this.property",
+    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;
+                            // Pattern 1: Value in object property { propName: param }
+                            if (parent?.isObjectProperty()) {
+                                // Ensure the param is the value, not the key
+                                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;
+                                    }
+                                }
+                            }
+                            // Pattern 2: Assignment to this.property - this.propName = param
+                            // Only match simple assignment (=), not compound (+=, -=, etc.)
+                            if (parent?.isAssignmentExpression() &&
+                                parent.node.operator === "=") {
+                                // Ensure the param is the right-hand side
+                                if (parent.node.right !== referencePath.node)
+                                    continue;
+                                const left = parent.node.left;
+                                // Check if left side is this.propName (non-computed)
+                                if (left.type === "MemberExpression" &&
+                                    !left.computed &&
+                                    left.object.type === "ThisExpression" &&
+                                    left.property.type === "Identifier") {
+                                    const propertyName = left.property.name;
+                                    if (candidateName === undefined) {
+                                        candidateName = propertyName;
+                                    }
+                                    else if (candidateName !== propertyName) {
+                                        // Conflicting property names (e.g. this.x = a; this.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/rename-typeof-variables/manifest.json

@@ -0,0 +1,4 @@
+{
+    "diffReductionImpact": 0,
+    "recommended": true
+}

package/dist/transforms/rename-typeof-variables/rename-typeof-variables-transform.d.ts

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

package/dist/transforms/rename-typeof-variables/rename-typeof-variables-transform.js

@@ -0,0 +1,132 @@
+import { createRequire } from "node:module";
+import { isArrayPattern, isAssignmentPattern, isClassDeclaration, isExportNamedDeclaration, isExportSpecifier, isFunctionDeclaration, isIdentifier, isObjectPattern, isObjectProperty, isRestElement, isVariableDeclaration, } from "@babel/types";
+import { isStableRenamed, 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 = "type";
+const addBindingNamesFromNode = (node, out) => {
+    const babelNode = node;
+    if (!babelNode)
+        return;
+    if (babelNode.type === "VoidPattern")
+        return;
+    if (isIdentifier(babelNode)) {
+        out.add(babelNode.name);
+        return;
+    }
+    if (isObjectPattern(babelNode)) {
+        for (const property of babelNode.properties) {
+            if (isRestElement(property)) {
+                addBindingNamesFromNode(property.argument, out);
+                continue;
+            }
+            if (!isObjectProperty(property))
+                continue;
+            addBindingNamesFromNode(property.value, out);
+        }
+        return;
+    }
+    if (isArrayPattern(babelNode)) {
+        for (const element of babelNode.elements) {
+            addBindingNamesFromNode(element, out);
+        }
+        return;
+    }
+    if (isRestElement(babelNode)) {
+        addBindingNamesFromNode(babelNode.argument, out);
+        return;
+    }
+    if (isAssignmentPattern(babelNode)) {
+        addBindingNamesFromNode(babelNode.left, out);
+    }
+};
+const collectExportedNames = (program) => {
+    const exportedNames = new Set();
+    for (const statement of program.body) {
+        if (!isExportNamedDeclaration(statement))
+            continue;
+        const declaration = statement.declaration;
+        if (declaration) {
+            if (isVariableDeclaration(declaration)) {
+                for (const declarator of declaration.declarations) {
+                    addBindingNamesFromNode(declarator.id, exportedNames);
+                }
+            }
+            else if (isFunctionDeclaration(declaration) ||
+                isClassDeclaration(declaration)) {
+                const id = declaration.id;
+                if (!id)
+                    continue;
+                exportedNames.add(id.name);
+            }
+        }
+        for (const specifier of statement.specifiers) {
+            if (!isExportSpecifier(specifier))
+                continue;
+            const local = specifier.local;
+            if (!isIdentifier(local))
+                continue;
+            exportedNames.add(local.name);
+        }
+    }
+    return exportedNames;
+};
+export const renameTypeofVariablesTransform = {
+    id: "rename-typeof-variables",
+    description: "Renames variables assigned from typeof expressions to $type (stable when unique) or type/type2/...",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            const exportedNames = collectExportedNames(fileInfo.ast.program);
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    const init = path.node.init;
+                    if (!init)
+                        return;
+                    if (init.type !== "UnaryExpression")
+                        return;
+                    if (init.operator !== "typeof")
+                        return;
+                    const currentName = id.name;
+                    // Skip already-stable names
+                    if (isStableRenamed(currentName))
+                        return;
+                    // Skip non-minified names (more than 1 character)
+                    if (currentName.length > 1)
+                        return;
+                    const binding = path.scope.getBinding(currentName);
+                    if (!binding)
+                        return;
+                    // Skip reassigned variables (name would be misleading)
+                    if (!binding.constant)
+                        return;
+                    // Skip exported names at program scope
+                    if (binding.scope.block.type === "Program" &&
+                        exportedNames.has(currentName)) {
+                        return;
+                    }
+                    group.add({
+                        scope: binding.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.20.0",
+  "version": "1.22.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",