miniread 1.0.0 → 1.2.0

package/dist/transforms/rename-binding/is-valid-binding-identifier.d.ts

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

package/dist/transforms/rename-binding/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-destructured-aliases/binding-context.d.ts

@@ -0,0 +1,7 @@
+import type { NodePath } from "@babel/traverse";
+import type { ObjectPattern } from "@babel/types";
+/**
+ * Check if the ObjectPattern is in a binding context (declaration, function param, catch clause)
+ * vs. an assignment context (left side of assignment expression).
+ */
+export declare const isBindingContext: (path: NodePath<ObjectPattern>) => boolean;

package/dist/transforms/rename-destructured-aliases/binding-context.js

@@ -0,0 +1,83 @@
+/**
+ * Check if an ArrayPattern is in a binding context.
+ * Used for nested destructuring like [{ id: i }].
+ */
+const isArrayPatternInBindingContext = (path) => {
+    const parent = path.parent;
+    // VariableDeclarator: const [{ a: b }] = arr
+    if (parent.type === "VariableDeclarator")
+        return true;
+    // Function parameter: function([{ a: b }]) {}
+    if (parent.type === "FunctionDeclaration" ||
+        parent.type === "FunctionExpression" ||
+        parent.type === "ArrowFunctionExpression" ||
+        parent.type === "ObjectMethod" ||
+        parent.type === "ClassMethod" ||
+        parent.type === "ClassPrivateMethod") {
+        return true;
+    }
+    // Catch clause: catch ([{ error: e }]) {}
+    if (parent.type === "CatchClause")
+        return true;
+    // AssignmentPattern (e.g., function([{ a: b }] = []) {})
+    if (parent.type === "AssignmentPattern")
+        return true;
+    // Note: for-in/for-of with declarations (for (const [x] of items)) are handled
+    // by VariableDeclarator. Direct patterns (for ([x] of items)) are assignment
+    // contexts, not binding contexts.
+    // Nested in another ArrayPattern: [[{ a: b }]]
+    if (parent.type === "ArrayPattern" && path.parentPath) {
+        return isArrayPatternInBindingContext(path.parentPath);
+    }
+    // Nested in ObjectPattern: { data: [{ a: b }] }
+    if (parent.type === "ObjectProperty" && path.parentPath?.parentPath) {
+        const grandparentPath = path.parentPath.parentPath;
+        if (grandparentPath.isObjectPattern()) {
+            return isBindingContext(grandparentPath);
+        }
+    }
+    return false;
+};
+/**
+ * Check if the ObjectPattern is in a binding context (declaration, function param, catch clause)
+ * vs. an assignment context (left side of assignment expression).
+ */
+export const isBindingContext = (path) => {
+    const parent = path.parent;
+    // VariableDeclarator: const { a: b } = obj
+    if (parent.type === "VariableDeclarator")
+        return true;
+    // Function parameter: function({ a: b }) {}
+    if (parent.type === "FunctionDeclaration" ||
+        parent.type === "FunctionExpression" ||
+        parent.type === "ArrowFunctionExpression" ||
+        parent.type === "ObjectMethod" ||
+        parent.type === "ClassMethod" ||
+        parent.type === "ClassPrivateMethod") {
+        return true;
+    }
+    // Catch clause: catch ({ error: e }) {}
+    if (parent.type === "CatchClause")
+        return true;
+    // AssignmentPattern (e.g., function({ a: b } = {}) {})
+    if (parent.type === "AssignmentPattern")
+        return true;
+    // Note: for-in/for-of with declarations (for (const {a} of items)) are handled
+    // by VariableDeclarator. Direct patterns (for ({a} of items)) are assignment
+    // contexts, not binding contexts.
+    // Nested destructuring in objects: { outer: { inner: x } }
+    // The inner ObjectPattern's parent is ObjectProperty, check grandparent
+    if (parent.type === "ObjectProperty" && path.parentPath.parentPath) {
+        const grandparentPath = path.parentPath.parentPath;
+        if (grandparentPath.isObjectPattern()) {
+            return isBindingContext(grandparentPath);
+        }
+    }
+    // Nested destructuring in arrays: [{ id: i }]
+    // The ObjectPattern's parent is ArrayPattern, check if array is in binding context
+    if (parent.type === "ArrayPattern") {
+        return isArrayPatternInBindingContext(path.parentPath);
+    }
+    // Assignment expression: { a: b } = obj (NOT a binding context)
+    return false;
+};

package/dist/transforms/rename-destructured-aliases/rename-destructured-aliases-transform.d.ts

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

package/dist/transforms/rename-destructured-aliases/rename-destructured-aliases-transform.js

@@ -0,0 +1,118 @@
+import { createRequire } from "node:module";
+import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
+import { isBindingContext } from "./binding-context.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+/**
+ * Check if the name is a valid binding identifier in ES modules (strict mode).
+ * Uses Babel's built-in helpers for authoritative validation.
+ */
+const isValidBindingIdentifier = (name) => {
+    // Must be a valid identifier name (proper chars, not starting with digit, etc.)
+    if (!isIdentifierName(name))
+        return false;
+    // Must not be a keyword (return, if, etc.)
+    if (isKeyword(name))
+        return false;
+    // Must not be reserved for binding in strict mode (eval, arguments, let, etc.)
+    // The second parameter `true` indicates we're in a module context
+    if (isStrictBindReservedWord(name, true))
+        return false;
+    return true;
+};
+const processObjectPattern = (path, stats) => {
+    // Only process in binding contexts, not assignment expressions
+    if (!isBindingContext(path))
+        return;
+    for (const property of path.node.properties) {
+        // Skip rest elements
+        if (property.type === "RestElement")
+            continue;
+        // Skip computed properties (e.g., { [expr]: x })
+        if (property.computed)
+            continue;
+        // Skip shorthand properties (already in the form { foo })
+        if (property.shorthand)
+            continue;
+        // Key must be an identifier (the property name)
+        if (property.key.type !== "Identifier")
+            continue;
+        // Value can be an identifier or an AssignmentPattern (with default value)
+        // e.g., { a: b } or { a: b = 1 }
+        // Nested patterns like { a: { b: c } } are handled by visiting nested ObjectPatterns
+        let aliasIdentifier;
+        if (property.value.type === "Identifier") {
+            aliasIdentifier = property.value;
+        }
+        else if (property.value.type === "AssignmentPattern" &&
+            property.value.left.type === "Identifier") {
+            // { a: b = 1 } - the alias is in the left side of the assignment pattern
+            aliasIdentifier = property.value.left;
+        }
+        else {
+            continue;
+        }
+        const keyName = property.key.name;
+        const aliasName = aliasIdentifier.name;
+        // Skip if the alias is already the same as the property name
+        if (aliasName === keyName)
+            continue;
+        // Skip if property name is not a valid binding identifier
+        if (!isValidBindingIdentifier(keyName))
+            continue;
+        // Use parent's scope for binding checks and rename operations.
+        // path.scope for ObjectPattern returns a narrow scope that doesn't cover
+        // the function/catch body. path.parentPath.scope gives the proper scope.
+        const bindingScope = path.parentPath.scope;
+        // Skip if the target name already exists in scope or is a referenced global
+        // (e.g., don't rename to 'console' if the code uses console.log())
+        if (bindingScope.hasBinding(keyName))
+            continue;
+        const programScope = bindingScope.getProgramParent();
+        if (Object.hasOwn(programScope.globals, keyName))
+            continue;
+        // Get the binding for the alias - skip if it doesn't exist (safety check)
+        const binding = bindingScope.getBinding(aliasName);
+        if (!binding)
+            continue;
+        // Skip if any reference to aliasName is in a child scope that shadows keyName.
+        // Example: const { p: x } = obj; { const p = 1; console.log(x); }
+        // If we rename x -> p, the console.log(x) would incorrectly reference inner p.
+        const wouldBeShadowed = binding.referencePaths.some((referencePath) => referencePath.scope !== bindingScope &&
+            referencePath.scope.hasBinding(keyName));
+        if (wouldBeShadowed)
+            continue;
+        // Rename the variable in the scope
+        bindingScope.rename(aliasName, keyName);
+        // Update the destructuring to use shorthand
+        // For { a: b } -> { a }
+        // For { a: b = 1 } -> { a = 1 }
+        property.shorthand = true;
+        aliasIdentifier.name = keyName;
+        stats.transformationsApplied++;
+    }
+};
+export const renameDestructuredAliasesTransform = {
+    id: "rename-destructured-aliases",
+    description: "Renames destructuring aliases to match property names (e.g., { foo: x } → { foo })",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        const stats = { transformationsApplied: 0 };
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                ObjectPattern(path) {
+                    nodesVisited++;
+                    processObjectPattern(path, stats);
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied: stats.transformationsApplied,
+        });
+    },
+};

package/dist/transforms/rename-promise-executor-parameters/is-valid-binding-identifier.d.ts

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

package/dist/transforms/rename-promise-executor-parameters/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-promise-executor-parameters/promise-executor-heuristics.d.ts

@@ -0,0 +1,6 @@
+import type { NodePath } from "@babel/traverse";
+import type { ArrowFunctionExpression, FunctionExpression, NewExpression } from "@babel/types";
+export declare const getExecutorFunctionIfEligible: (path: NodePath<NewExpression>) => NodePath<FunctionExpression | ArrowFunctionExpression> | undefined;
+export declare const isDirectCallOfBinding: (referencePath: NodePath) => boolean;
+export declare const isAssignedToOnHandlerProperty: (referencePath: NodePath) => boolean;
+export declare const wouldShadowReferencedOuterBinding: (executorPath: NodePath<FunctionExpression | ArrowFunctionExpression>, targetName: string) => boolean;

package/dist/transforms/rename-promise-executor-parameters/promise-executor-heuristics.js

@@ -0,0 +1,88 @@
+import { isValidBindingIdentifier } from "./is-valid-binding-identifier.js";
+const allowedOnHandlerPropertyNames = new Set([
+    "onabort",
+    "onerror",
+    "ontimeout",
+]);
+const isExecutorParameterEligible = (parameter) => {
+    // 1-2 character parameter names are a strong minification signal (e.g. `r`, `e`, `WA`, `BA`).
+    // Keeping this conservative prevents renaming intentionally-named parameters in non-minified code.
+    if (parameter.name.length > 2)
+        return false;
+    if (!isValidBindingIdentifier(parameter.name))
+        return false;
+    return true;
+};
+export const getExecutorFunctionIfEligible = (path) => {
+    // Intentionally does NOT require the constructor callee to be `Promise`.
+    // Bundled/minified code frequently uses Promise polyfills like `new K((a,b)=>...)`,
+    // so we treat the executor signature + usage heuristics as the "promise-like" signal.
+    if (path.node.arguments.length !== 1)
+        return;
+    const executor = path.get("arguments.0");
+    if (!executor.isFunctionExpression() &&
+        !executor.isArrowFunctionExpression()) {
+        return;
+    }
+    const parameters = executor.node.params;
+    if (parameters.length !== 2)
+        return;
+    const [firstParameter, secondParameter] = parameters;
+    if (!firstParameter || !secondParameter)
+        return;
+    if (firstParameter.type !== "Identifier")
+        return;
+    if (secondParameter.type !== "Identifier")
+        return;
+    if (!isExecutorParameterEligible(firstParameter))
+        return;
+    if (!isExecutorParameterEligible(secondParameter))
+        return;
+    return executor;
+};
+export const isDirectCallOfBinding = (referencePath) => {
+    const parentPath = referencePath.parentPath;
+    if (!parentPath?.isCallExpression())
+        return false;
+    return referencePath.key === "callee";
+};
+export const isAssignedToOnHandlerProperty = (referencePath) => {
+    const parentPath = referencePath.parentPath;
+    if (!parentPath?.isAssignmentExpression())
+        return false;
+    if (parentPath.node.operator !== "=")
+        return false;
+    if (referencePath.key !== "right")
+        return false;
+    const left = parentPath.node.left;
+    if (left.type !== "MemberExpression")
+        return false;
+    if (left.computed)
+        return false;
+    if (left.property.type !== "Identifier")
+        return false;
+    if (!allowedOnHandlerPropertyNames.has(left.property.name))
+        return false;
+    return true;
+};
+export const wouldShadowReferencedOuterBinding = (executorPath, targetName) => {
+    const parentBinding = executorPath.scope.getBinding(targetName);
+    if (!parentBinding)
+        return false;
+    let foundReference = false;
+    executorPath.traverse({
+        Identifier(identifierPath) {
+            if (foundReference)
+                return;
+            if (identifierPath.node.name !== targetName)
+                return;
+            if (!identifierPath.isReferencedIdentifier())
+                return;
+            if (identifierPath.scope.getBinding(targetName) !== parentBinding)
+                return;
+            foundReference = true;
+            identifierPath.stop();
+        },
+    });
+    return foundReference;
+};

package/dist/transforms/rename-promise-executor-parameters/rename-binding-if-safe.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+export declare const canRenameBindingSafely: (bindingScope: NodePath["scope"], fromName: string, toName: string) => boolean;
+export declare const renameBindingIfSafe: (bindingScope: NodePath["scope"], fromName: string, toName: string) => boolean;

package/dist/transforms/rename-promise-executor-parameters/rename-binding-if-safe.js

@@ -0,0 +1,40 @@
+import { isValidBindingIdentifier } from "./is-valid-binding-identifier.js";
+const hasShadowingRisk = (binding, bindingScope, targetName) => binding.referencePaths.some((referencePath) => {
+    if (referencePath.scope === bindingScope)
+        return false;
+    // Only consider bindings between this reference’s scope and the executor’s binding scope.
+    // This avoids incorrectly blocking safe renames due to unrelated outer bindings (e.g., an
+    // outer `resolve` that is never referenced inside the executor).
+    const hasBindingOptions = {
+        noGlobals: true,
+        noUids: true,
+        // Present in Babel scope implementation, but missing from our TypeScript types.
+        upToScope: bindingScope,
+    };
+    return referencePath.scope.hasBinding(targetName, hasBindingOptions);
+});
+export const canRenameBindingSafely = (bindingScope, fromName, toName) => {
+    if (fromName === toName)
+        return false;
+    if (!isValidBindingIdentifier(toName))
+        return false;
+    if (bindingScope.hasOwnBinding(toName))
+        return false;
+    const programScope = bindingScope.getProgramParent();
+    // `globals` contains only referenced (unbound) globals for this file, so this does not block
+    // in files where the identifier is never used.
+    if (Object.hasOwn(programScope.globals, toName))
+        return false;
+    const binding = bindingScope.getBinding(fromName);
+    if (!binding)
+        return false;
+    if (hasShadowingRisk(binding, bindingScope, toName))
+        return false;
+    return true;
+};
+export const renameBindingIfSafe = (bindingScope, fromName, toName) => {
+    if (!canRenameBindingSafely(bindingScope, fromName, toName))
+        return false;
+    bindingScope.rename(fromName, toName);
+    return true;
+};

package/dist/transforms/rename-promise-executor-parameters/rename-promise-executor-parameters-transform.d.ts

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

package/dist/transforms/rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js

@@ -0,0 +1,76 @@
+import { createRequire } from "node:module";
+import { getExecutorFunctionIfEligible, isAssignedToOnHandlerProperty, isDirectCallOfBinding, wouldShadowReferencedOuterBinding, } from "./promise-executor-heuristics.js";
+import { canRenameBindingSafely, renameBindingIfSafe, } from "./rename-binding-if-safe.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 renamePromiseExecutorParametersTransform = {
+    id: "rename-promise-executor-parameters",
+    description: "Renames promise-like executor parameters in `new X(executor)` to resolve/reject when usage is high-confidence",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                NewExpression(path) {
+                    nodesVisited++;
+                    const executorPath = getExecutorFunctionIfEligible(path);
+                    if (!executorPath)
+                        return;
+                    const [resolveParameter, rejectParameter] = executorPath.node
+                        .params;
+                    const bindingScope = executorPath.scope;
+                    const resolveBinding = bindingScope.getBinding(resolveParameter.name);
+                    const rejectBinding = bindingScope.getBinding(rejectParameter.name);
+                    if (!resolveBinding || !rejectBinding)
+                        return;
+                    const resolveIsCalled = resolveBinding.referencePaths.some((referencePath) => isDirectCallOfBinding(referencePath));
+                    if (!resolveIsCalled)
+                        return;
+                    const resolveIsOnlyCalled = resolveBinding.referencePaths.every((referencePath) => isDirectCallOfBinding(referencePath));
+                    if (!resolveIsOnlyCalled)
+                        return;
+                    const rejectIsCalled = rejectBinding.referencePaths.some((referencePath) => isDirectCallOfBinding(referencePath));
+                    const rejectIsOnHandler = rejectBinding.referencePaths.some((referencePath) => isAssignedToOnHandlerProperty(referencePath));
+                    if (!rejectIsCalled && !rejectIsOnHandler)
+                        return;
+                    const rejectIsOnlyCalledOrHandlerAssigned = rejectBinding.referencePaths.every((referencePath) => isDirectCallOfBinding(referencePath) ||
+                        isAssignedToOnHandlerProperty(referencePath));
+                    if (!rejectIsOnlyCalledOrHandlerAssigned)
+                        return;
+                    const resolveWouldShadow = wouldShadowReferencedOuterBinding(executorPath, "resolve");
+                    const rejectWouldShadow = wouldShadowReferencedOuterBinding(executorPath, "reject");
+                    const targetResolveName = "resolve";
+                    const targetRejectName = "reject";
+                    const wantsResolveRename = resolveParameter.name !== targetResolveName;
+                    const wantsRejectRename = rejectParameter.name !== targetRejectName;
+                    const canRenameResolve = !wantsResolveRename ||
+                        (!resolveWouldShadow &&
+                            canRenameBindingSafely(bindingScope, resolveParameter.name, targetResolveName));
+                    const canRenameReject = !wantsRejectRename ||
+                        (!rejectWouldShadow &&
+                            canRenameBindingSafely(bindingScope, rejectParameter.name, targetRejectName));
+                    // Avoid ending up with inconsistent executor signatures like `(WA, reject)` —
+                    // only rename when both parameters are already correct or can be renamed safely.
+                    if (!canRenameResolve || !canRenameReject)
+                        return;
+                    const renamedResolve = wantsResolveRename
+                        ? renameBindingIfSafe(bindingScope, resolveParameter.name, targetResolveName)
+                        : false;
+                    const renamedReject = wantsRejectRename
+                        ? renameBindingIfSafe(bindingScope, rejectParameter.name, targetRejectName)
+                        : false;
+                    if (!renamedResolve && !renamedReject)
+                        return;
+                    // Metrics represent renamed bindings, not "executors processed".
+                    transformationsApplied +=
+                        Number(renamedResolve) + Number(renamedReject);
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-timeout-ids/rename-timeout-ids-transform.d.ts

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

package/dist/transforms/rename-timeout-ids/rename-timeout-ids-transform.js

@@ -0,0 +1,86 @@
+import { createRequire } from "node:module";
+import { getTargetName } from "../rename-binding/get-target-name.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 = "timeoutId";
+const isSetTimeoutCall = (path, init) => {
+    if (init.callee.type !== "Identifier")
+        return false;
+    if (init.callee.name !== "setTimeout")
+        return false;
+    // If setTimeout is locally bound (imported or declared), semantics may differ.
+    if (path.scope.hasBinding("setTimeout", true))
+        return false;
+    return true;
+};
+const isClearTimeoutCallArgument = (referencePath, bindingName) => {
+    if (!referencePath.isIdentifier())
+        return false;
+    const callPath = referencePath.parentPath;
+    if (!callPath.isCallExpression())
+        return false;
+    const call = callPath.node;
+    if (call.callee.type !== "Identifier")
+        return false;
+    if (call.callee.name !== "clearTimeout")
+        return false;
+    // If clearTimeout is locally bound (imported or declared), semantics may differ.
+    if (callPath.scope.hasBinding("clearTimeout", true))
+        return false;
+    const argument0 = call.arguments[0];
+    if (argument0?.type !== "Identifier")
+        return false;
+    if (argument0 !== referencePath.node)
+        return false;
+    if (argument0.name !== bindingName)
+        return false;
+    return true;
+};
+export const renameTimeoutIdsTransform = {
+    id: "rename-timeout-ids",
+    description: "Renames setTimeout handle variables to timeoutId/timeoutId2/... when usage is only clearTimeout(...)",
+    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;
+                    const init = path.node.init;
+                    if (init?.type !== "CallExpression")
+                        return;
+                    if (!isSetTimeoutCall(path, init))
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    if (binding.referencePaths.length === 0)
+                        return;
+                    if (!binding.referencePaths.every((referencePath) => isClearTimeoutCallArgument(referencePath, id.name)))
+                        return;
+                    const targetName = getTargetName(path.scope, binding, {
+                        baseName: BASE_NAME,
+                    });
+                    if (!targetName)
+                        return;
+                    if (id.name === targetName)
+                        return;
+                    path.scope.rename(id.name, targetName);
+                    transformationsApplied++;
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-use-reference-guards/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/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/get-reference-usage.d.ts

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

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

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

package/dist/transforms/rename-use-reference-guards/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;