miniread 1.5.0 → 1.6.0

package/dist/transforms/rename-use-reference-guards-v2/get-member-expression-for-reference.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Identifier, MemberExpression, OptionalMemberExpression } from "@babel/types";
+export declare const getMemberExpressionForReference: (referencePath: NodePath<Identifier>) => NodePath<MemberExpression | OptionalMemberExpression> | undefined;

package/dist/transforms/rename-use-reference-guards-v2/get-member-expression-for-reference.js

@@ -0,0 +1,10 @@
+export const getMemberExpressionForReference = (referencePath) => {
+    const parentPath = referencePath.parentPath;
+    if (parentPath.isMemberExpression() &&
+        parentPath.node.object === referencePath.node)
+        return parentPath;
+    if (parentPath.isOptionalMemberExpression() &&
+        parentPath.node.object === referencePath.node)
+        return parentPath;
+    return;
+};

package/dist/transforms/rename-use-reference-guards-v2/get-reference-usage.d.ts

@@ -0,0 +1,8 @@
+import type { Binding } from "@babel/traverse";
+type ReferenceUsage = {
+    isSafe: boolean;
+    hasRead: boolean;
+    hasTrueWrite: boolean;
+};
+export declare const getReferenceUsage: (binding: Binding) => ReferenceUsage;
+export {};

package/dist/transforms/rename-use-reference-guards-v2/get-reference-usage.js

@@ -0,0 +1,58 @@
+import { getMemberExpressionForReference } from "./get-member-expression-for-reference.js";
+const getKnownBooleanValue = (expression) => {
+    if (expression.type === "BooleanLiteral")
+        return expression.value;
+    if (expression.type === "UnaryExpression" &&
+        expression.operator === "!" &&
+        expression.argument.type === "NumericLiteral" &&
+        (expression.argument.value === 0 || expression.argument.value === 1)) {
+        return !expression.argument.value;
+    }
+    return;
+};
+export const getReferenceUsage = (binding) => {
+    let hasRead = false;
+    let hasTrueWrite = false;
+    for (const referencePath of binding.referencePaths) {
+        if (!referencePath.isIdentifier())
+            return { isSafe: false, hasRead, hasTrueWrite };
+        const memberPath = getMemberExpressionForReference(referencePath);
+        if (!memberPath)
+            return { isSafe: false, hasRead, hasTrueWrite };
+        const memberNode = memberPath.node;
+        if (memberNode.computed)
+            return { isSafe: false, hasRead, hasTrueWrite };
+        if (memberNode.property.type !== "Identifier" ||
+            memberNode.property.name !== "current") {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        const parentPath = memberPath.parentPath;
+        if (parentPath.isAssignmentExpression() &&
+            parentPath.node.left === memberNode) {
+            if (parentPath.node.operator !== "=")
+                return { isSafe: false, hasRead, hasTrueWrite };
+            const right = parentPath.node.right;
+            const value = getKnownBooleanValue(right);
+            if (value === undefined)
+                return { isSafe: false, hasRead, hasTrueWrite };
+            if (value) {
+                hasTrueWrite = true;
+            }
+            continue;
+        }
+        if (parentPath.isUpdateExpression() &&
+            parentPath.node.argument === memberNode) {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        if (parentPath.isUnaryExpression() &&
+            parentPath.node.operator === "delete" &&
+            parentPath.node.argument === memberNode) {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        if (!memberPath.isReferenced()) {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        hasRead = true;
+    }
+    return { isSafe: true, hasRead, hasTrueWrite };
+};

package/dist/transforms/rename-use-reference-guards-v2/get-target-name.d.ts

@@ -0,0 +1,2 @@
+import type { Binding, Scope } from "@babel/traverse";
+export declare const getTargetName: (bindingScope: Scope, binding: Binding) => string | undefined;

package/dist/transforms/rename-use-reference-guards-v2/get-target-name.js

@@ -0,0 +1,23 @@
+import { isValidBindingIdentifier } from "./is-valid-binding-identifier.js";
+const BASE_NAME = "hasRunRef";
+// Cap retries to avoid pathological loops while handling large bundles.
+const MAX_CANDIDATES = 1000;
+export const getTargetName = (bindingScope, binding) => {
+    const programScope = bindingScope.getProgramParent();
+    for (let index = 0; index < MAX_CANDIDATES; index++) {
+        const candidate = index === 0 ? BASE_NAME : `${BASE_NAME}${index + 1}`;
+        if (!isValidBindingIdentifier(candidate))
+            continue;
+        // Avoid shadowing bindings in parent scopes.
+        if (bindingScope.hasBinding(candidate))
+            continue;
+        if (Object.hasOwn(programScope.globals, candidate))
+            continue;
+        const wouldBeShadowed = binding.referencePaths.some((referencePath) => referencePath.scope !== bindingScope &&
+            referencePath.scope.hasBinding(candidate));
+        if (wouldBeShadowed)
+            continue;
+        return candidate;
+    }
+    return;
+};

package/dist/transforms/rename-use-reference-guards-v2/is-use-reference-false-initializer.d.ts

@@ -0,0 +1,2 @@
+import type { VariableDeclarator } from "@babel/types";
+export declare const isUseReferenceFalseInitializer: (declarator: VariableDeclarator) => boolean;

package/dist/transforms/rename-use-reference-guards-v2/is-use-reference-false-initializer.js

@@ -0,0 +1,40 @@
+const isKnownFalseValue = (expression) => {
+    if (expression.type === "BooleanLiteral")
+        return !expression.value;
+    if (expression.type === "UnaryExpression" &&
+        expression.operator === "!" &&
+        expression.argument.type === "NumericLiteral" &&
+        expression.argument.value === 1) {
+        return true;
+    }
+    return false;
+};
+export const isUseReferenceFalseInitializer = (declarator) => {
+    const init = declarator.init;
+    if (!init)
+        return false;
+    if (init.type !== "CallExpression")
+        return false;
+    if (init.arguments.length !== 1)
+        return false;
+    const argument = init.arguments[0];
+    if (!argument)
+        return false;
+    if (argument.type === "SpreadElement")
+        return false;
+    if (argument.type === "ArgumentPlaceholder")
+        return false;
+    if (!isKnownFalseValue(argument))
+        return false;
+    const callee = init.callee;
+    if (callee.type === "Identifier") {
+        return callee.name === "useRef";
+    }
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (callee.property.type !== "Identifier")
+        return false;
+    return callee.property.name === "useRef";
+};

package/dist/transforms/rename-use-reference-guards-v2/is-valid-binding-identifier.d.ts

@@ -0,0 +1 @@
+export declare const isValidBindingIdentifier: (name: string) => boolean;

package/dist/transforms/rename-use-reference-guards-v2/is-valid-binding-identifier.js

@@ -0,0 +1,10 @@
+import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
+export const isValidBindingIdentifier = (name) => {
+    if (!isIdentifierName(name))
+        return false;
+    if (isKeyword(name))
+        return false;
+    if (isStrictBindReservedWord(name, true))
+        return false;
+    return true;
+};

package/dist/transforms/rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.d.ts

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

package/dist/transforms/rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js

@@ -0,0 +1,52 @@
+import { createRequire } from "node:module";
+import { getReferenceUsage } from "./get-reference-usage.js";
+import { getTargetName } from "./get-target-name.js";
+import { isUseReferenceFalseInitializer } from "./is-use-reference-false-initializer.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const renameUseReferenceGuardsV2Transform = {
+    id: "rename-use-reference-guards-v2",
+    description: "Renames boolean useRef(false) guard variables (including reset-to-false guards) to hasRunRef/hasRunRef2/...",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    if (id.name.length > 2)
+                        return;
+                    if (!isUseReferenceFalseInitializer(path.node))
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    const usage = getReferenceUsage(binding);
+                    if (!usage.isSafe || !usage.hasRead || !usage.hasTrueWrite)
+                        return;
+                    const targetName = getTargetName(path.scope, binding);
+                    if (!targetName)
+                        return;
+                    if (id.name === targetName)
+                        return;
+                    path.scope.rename(id.name, targetName);
+                    transformationsApplied++;
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};
+export { renameUseReferenceGuardsV2Transform };

package/dist/transforms/transform-registry.js

@@ -14,6 +14,7 @@ import { renameLoopIndexVariablesTransform } from "./rename-loop-index-variables
 import { renamePromiseExecutorParametersTransform } from "./rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
 import { renameTimeoutIdsTransform } from "./rename-timeout-ids/rename-timeout-ids-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 { splitVariableDeclarationsTransform } from "./split-variable-declarations/split-variable-declarations-transform.js";
 export const transformRegistry = {
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
@@ -32,6 +33,7 @@ export const transformRegistry = {
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
+    [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
 };
 export const allTransformIds = Object.keys(transformRegistry);

package/package.json

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

package/transform-manifest.json

@@ -115,9 +115,19 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "recommended": true,
+      "recommended": false,
       "evaluatedAt": "2026-01-22T17:03:19.826Z",
-      "notes": "Auto-added by evaluation script."
+      "notes": "Superseded by rename-use-reference-guards-v2.",
+      "supersededBy": "rename-use-reference-guards-v2"
+    },
+    {
+      "id": "rename-use-reference-guards-v2",
+      "description": "Renames boolean useRef(false) guard variables (including reset-to-false guards) to hasRunRef/hasRunRef2/...",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "notes": "Supersedes rename-use-reference-guards and also covers guards that reset to false."
     },
     {
       "id": "rename-timeout-ids",