miniread 1.110.0 → 1.111.0

package/dist/transforms/_generated/catalog.js

@@ -130,6 +130,8 @@ import { renameRestPopCallbacksTransform } from "../../transforms-by-id/rename-r
 import renameRestPopCallbacksManifest from "../../transforms-by-id/rename-rest-pop-callbacks/manifest.json" with { type: "json" };
 import { renameReturnObjectBindingsTransform } from "../../transforms-by-id/rename-return-object-bindings/rename-return-object-bindings-transform.js";
 import renameReturnObjectBindingsManifest from "../../transforms-by-id/rename-return-object-bindings/manifest.json" with { type: "json" };
+import { renameSanitizedStringVariablesTransform } from "../../transforms-by-id/rename-sanitized-string-variables/rename-sanitized-string-variables-transform.js";
+import renameSanitizedStringVariablesManifest from "../../transforms-by-id/rename-sanitized-string-variables/manifest.json" with { type: "json" };
 import { renameSearchParametersVariablesTransform } from "../../transforms-by-id/rename-search-parameters-variables/rename-search-parameters-variables-transform.js";
 import renameSearchParametersVariablesManifest from "../../transforms-by-id/rename-search-parameters-variables/manifest.json" with { type: "json" };
 import { renameSetstateUpdaterParametersTransform } from "../../transforms-by-id/rename-setstate-updater-parameters/rename-setstate-updater-parameters-transform.js";
@@ -514,6 +516,11 @@ export const generatedTransformCatalog = [
         transform: renameReturnObjectBindingsTransform,
         manifest: renameReturnObjectBindingsManifest,
     },
+    {
+        id: renameSanitizedStringVariablesTransform.id,
+        transform: renameSanitizedStringVariablesTransform,
+        manifest: renameSanitizedStringVariablesManifest,
+    },
     {
         id: renameSearchParametersVariablesTransform.id,
         transform: renameSearchParametersVariablesTransform,

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 26.281324413198774,
-        "notes": "Measured with baseline none: 26.28% of original diff."
+        "diffSizePercent": 26.062100767282757,
+        "notes": "Measured with baseline none: 26.06% of original diff."
     }
 }

package/dist/transforms-by-id/rename-object-keys-iterator-variables/manifest.json

@@ -1,13 +1,13 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:15:39.757Z",
-            "changedLines": 606,
-            "durationSeconds": 249.25496743300002,
+            "evaluatedAt": "2026-02-12T13:18:42.927Z",
+            "changedLines": 1240,
+            "durationSeconds": 37.765023916,
             "stableNames": 1359
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-object-keys-iterator-variables/rename-object-keys-iterator-variables-transform.js

@@ -50,9 +50,40 @@ const getKeysIteratorIdentifier = (node) => {
         return undefined;
     return declaration.id;
 };
+const getForInIteratorIdentifier = (node) => {
+    if (node.left.type !== "VariableDeclaration")
+        return undefined;
+    if (node.left.declarations.length !== 1)
+        return undefined;
+    const declaration = node.left.declarations[0];
+    if (!declaration)
+        return undefined;
+    if (declaration.id.type !== "Identifier")
+        return undefined;
+    if (declaration.init)
+        return undefined;
+    return declaration.id;
+};
+const renameIteratorBinding = (path, identifier, group, options) => {
+    const currentName = identifier.name;
+    if (isStableRenamed(currentName))
+        return;
+    if (options.skipWhenObjectShadowed && path.scope.getBinding("Object"))
+        return;
+    const binding = path.scope.getBinding(currentName);
+    if (!binding)
+        return;
+    if (!binding.constant)
+        return;
+    group.add({
+        scope: binding.scope,
+        currentName,
+        baseName: BASE_NAME,
+    });
+};
 export const renameObjectKeysIteratorVariablesTransform = {
     id: "rename-object-keys-iterator-variables",
-    description: "Renames for-of iterator variables that loop over Object.keys(...) to stable $key (or readable key/key2/...) when safe",
+    description: "Renames for-of Object.keys(...) and for-in iterator variables to stable $key (or readable key/key2/...) when safe",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -66,20 +97,17 @@ export const renameObjectKeysIteratorVariablesTransform = {
                     const identifier = getKeysIteratorIdentifier(path.node);
                     if (!identifier)
                         return;
-                    const currentName = identifier.name;
-                    if (isStableRenamed(currentName))
-                        return;
-                    if (path.scope.getBinding("Object"))
-                        return;
-                    const binding = path.scope.getBinding(currentName);
-                    if (!binding)
-                        return;
-                    if (!binding.constant)
+                    renameIteratorBinding(path, identifier, group, {
+                        skipWhenObjectShadowed: true,
+                    });
+                },
+                ForInStatement(path) {
+                    nodesVisited++;
+                    const identifier = getForInIteratorIdentifier(path.node);
+                    if (!identifier)
                         return;
-                    group.add({
-                        scope: binding.scope,
-                        currentName,
-                        baseName: BASE_NAME,
+                    renameIteratorBinding(path, identifier, group, {
+                        skipWhenObjectShadowed: false,
                     });
                 },
             });

package/dist/transforms-by-id/rename-sanitized-string-variables/manifest.json

@@ -0,0 +1,14 @@
+{
+    "notes": "Renames local sanitized string pipeline variables to stable semantic names like $sanitizedText.",
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-13T06:07:03.949Z",
+            "changedLines": 76,
+            "durationSeconds": 29.482188958,
+            "stableNames": 1358
+        }
+    },
+    "recommended": true,
+    "recommendedOrder": 101
+}

package/dist/transforms-by-id/rename-sanitized-string-variables/rename-sanitized-string-variables-transform.d.ts

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

package/dist/transforms-by-id/rename-sanitized-string-variables/rename-sanitized-string-variables-transform.js

@@ -0,0 +1,109 @@
+import { createRequire } from "node:module";
+import * as t 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 STRING_CLEANUP_METHODS = new Set([
+    "replace",
+    "replaceAll",
+    "trim",
+    "trimStart",
+    "trimEnd",
+]);
+const isIdentifierParameter = (functionPath, name) => functionPath.node.params.some((parameter) => t.isIdentifier(parameter) && parameter.name === name);
+const isCleanupAssignment = (assignmentPath, variableName) => {
+    if (assignmentPath.node.operator !== "=")
+        return false;
+    if (!assignmentPath.get("left").isIdentifier({ name: variableName }))
+        return false;
+    const rightPath = assignmentPath.get("right");
+    if (!rightPath.isCallExpression())
+        return false;
+    const calleePath = rightPath.get("callee");
+    if (!calleePath.isMemberExpression())
+        return false;
+    const objectPath = calleePath.get("object");
+    if (!objectPath.isIdentifier({ name: variableName }))
+        return false;
+    if (calleePath.node.computed)
+        return false;
+    const property = calleePath.node.property;
+    if (!t.isIdentifier(property))
+        return false;
+    return STRING_CLEANUP_METHODS.has(property.name);
+};
+const isReturnedInFunctionBody = (functionPath, variableName) => {
+    const bodyPath = functionPath.get("body");
+    if (!bodyPath.isBlockStatement())
+        return false;
+    return bodyPath.get("body").some((statementPath) => {
+        if (!statementPath.isReturnStatement())
+            return false;
+        const returnArgument = statementPath.get("argument");
+        return returnArgument.isIdentifier({ name: variableName });
+    });
+};
+const isSanitizedStringVariable = (declaratorPath) => {
+    const idPath = declaratorPath.get("id");
+    if (!idPath.isIdentifier())
+        return false;
+    const initPath = declaratorPath.get("init");
+    if (!initPath.isIdentifier())
+        return false;
+    const identifier = idPath.node;
+    if (isStableRenamed(identifier.name))
+        return false;
+    const functionPath = declaratorPath.getFunctionParent();
+    if (!functionPath)
+        return false;
+    const binding = declaratorPath.scope.getBinding(identifier.name);
+    if (!binding)
+        return false;
+    if (binding.constantViolations.length === 0)
+        return false;
+    const startsFromParameter = isIdentifierParameter(functionPath, initPath.node.name);
+    const isReturned = isReturnedInFunctionBody(functionPath, identifier.name);
+    const allCleanupAssignments = binding.constantViolations.every((violationPath) => {
+        if (!violationPath.isAssignmentExpression())
+            return false;
+        return isCleanupAssignment(violationPath, identifier.name);
+    });
+    if (!allCleanupAssignments)
+        return false;
+    return startsFromParameter || isReturned;
+};
+export const renameSanitizedStringVariablesTransform = {
+    id: "rename-sanitized-string-variables",
+    description: "Renames local variables that repeatedly sanitize a string parameter before returning it.",
+    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, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    if (!isSanitizedStringVariable(path))
+                        return;
+                    const idPath = path.get("id");
+                    if (!idPath.isIdentifier())
+                        return;
+                    const binding = path.scope.getBinding(idPath.node.name);
+                    if (!binding)
+                        return;
+                    group.add({
+                        scope: binding.scope,
+                        currentName: idPath.node.name,
+                        baseName: "sanitizedText",
+                    });
+                },
+            });
+            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.110.0",
+  "version": "1.111.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",