miniread 1.37.0 → 1.38.0

package/dist/transforms/_generated/manifest.js

@@ -220,6 +220,12 @@ const manifestData = {
         evaluatedAt: "2026-01-24T15:52:58.710Z",
         notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
     },
+    "rename-url-variables": {
+        diffReductionImpact: 0.000018848364904289205,
+        recommended: true,
+        evaluatedAt: "2026-01-24T23:50:56.857Z",
+        notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
+    },
     "rename-use-reference-guards": {
         diffReductionImpact: 0,
         recommended: false,

package/dist/transforms/_generated/registry.js

@@ -37,6 +37,7 @@ import { renameTimeoutIdsTransform } from "../rename-timeout-ids/rename-timeout-
 import { renameTypeofVariablesTransform } from "../rename-typeof-variables/rename-typeof-variables-transform.js";
 import { renameUint8arrayConcatVariablesTransform } from "../rename-uint8array-concat-variables/rename-uint8array-concat-variables-transform.js";
 import { renameUrlParametersTransform } from "../rename-url-parameters/rename-url-parameters-transform.js";
+import { renameUrlVariablesTransform } from "../rename-url-variables/rename-url-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";
@@ -81,6 +82,7 @@ export const transformRegistry = {
     [renameTypeofVariablesTransform.id]: renameTypeofVariablesTransform,
     [renameUint8arrayConcatVariablesTransform.id]: renameUint8arrayConcatVariablesTransform,
     [renameUrlParametersTransform.id]: renameUrlParametersTransform,
+    [renameUrlVariablesTransform.id]: renameUrlVariablesTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,

package/dist/transforms/rename-url-parameters/rename-url-parameters-transform.js

@@ -2,59 +2,10 @@ import { createRequire } from "node:module";
 import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
 import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
+import { hasUrlDestructure } from "../url-usage-heuristics.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
-const urlPropertyNames = new Set([
-    "hash",
-    "host",
-    "hostname",
-    "href",
-    "origin",
-    "password",
-    "pathname",
-    "port",
-    "protocol",
-    "search",
-    "searchParams",
-    "username",
-]);
-const countUrlProperties = (pattern) => {
-    let count = 0;
-    for (const property of pattern.properties) {
-        if (property.type !== "ObjectProperty")
-            continue;
-        if (property.computed)
-            continue;
-        const key = property.key;
-        const keyName = key.type === "Identifier"
-            ? key.name
-            : key.type === "StringLiteral"
-                ? key.value
-                : undefined;
-        if (keyName && urlPropertyNames.has(keyName)) {
-            count += 1;
-        }
-    }
-    return count;
-};
-const hasUrlDestructure = (referencePath) => {
-    const parent = referencePath.parentPath;
-    if (!parent)
-        return false;
-    if (parent.isVariableDeclarator() &&
-        parent.node.init === referencePath.node &&
-        parent.node.id.type === "ObjectPattern") {
-        return countUrlProperties(parent.node.id) >= 2;
-    }
-    if (parent.isAssignmentExpression() &&
-        parent.node.operator === "=" &&
-        parent.node.right === referencePath.node &&
-        parent.node.left.type === "ObjectPattern") {
-        return countUrlProperties(parent.node.left) >= 2;
-    }
-    return false;
-};
 const hasUrlConstruction = (referencePath) => {
     const parent = referencePath.parentPath;
     if (!parent?.isNewExpression())

package/dist/transforms/rename-url-variables/manifest.json

@@ -0,0 +1,6 @@
+{
+    "diffReductionImpact": 0.000018848364904289205,
+    "recommended": true,
+    "evaluatedAt": "2026-01-24T23:50:56.857Z",
+    "notes": "Measured with baseline none: 0.00%. Added to recommended for readability."
+}

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

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

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

@@ -0,0 +1,94 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { hasUrlDestructure, urlPropertyNames, } from "../url-usage-heuristics.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const isUrlConstruction = (node) => {
+    if (node?.type !== "NewExpression")
+        return false;
+    if (node.callee.type !== "Identifier" || node.callee.name !== "URL") {
+        return false;
+    }
+    return true;
+};
+const isUrlPropertyAccess = (referencePath) => {
+    const parent = referencePath.parentPath;
+    if (!parent)
+        return false;
+    if (!parent.isMemberExpression())
+        return false;
+    if (parent.node.object !== referencePath.node)
+        return false;
+    if (parent.node.computed)
+        return false;
+    const key = parent.node.property;
+    const keyName = key.type === "Identifier"
+        ? key.name
+        : key.type === "StringLiteral"
+            ? key.value
+            : undefined;
+    if (!keyName)
+        return false;
+    return urlPropertyNames.has(keyName);
+};
+export const renameUrlVariablesTransform = {
+    id: "rename-url-variables",
+    description: "Renames variables initialized with new URL(...) when they are accessed via URL properties",
+    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 += 1;
+                    if (path.node.id.type !== "Identifier")
+                        return;
+                    if (!isUrlConstruction(path.node.init))
+                        return;
+                    const currentName = path.node.id.name;
+                    if (isStableRenamed(currentName))
+                        return;
+                    const binding = path.scope.getBinding(currentName);
+                    if (!binding)
+                        return;
+                    let sawUrlDestructure = false;
+                    let propertyAccesses = 0;
+                    for (const referencePath of binding.referencePaths) {
+                        const hasDestructure = hasUrlDestructure(referencePath);
+                        if (hasDestructure) {
+                            sawUrlDestructure = true;
+                        }
+                        if (propertyAccesses < 2 && isUrlPropertyAccess(referencePath)) {
+                            propertyAccesses += 1;
+                        }
+                        if (sawUrlDestructure || propertyAccesses >= 2)
+                            break;
+                    }
+                    if (!sawUrlDestructure && propertyAccesses < 2)
+                        return;
+                    const candidateName = "url";
+                    if (candidateName === currentName)
+                        return;
+                    const programScope = path.scope.getProgramParent();
+                    if (Object.hasOwn(programScope.globals, candidateName))
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName,
+                        baseName: candidateName,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/url-usage-heuristics.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+export declare const urlPropertyNames: Set<string>;
+export declare const hasUrlDestructure: (referencePath: NodePath) => boolean;

package/dist/transforms/url-usage-heuristics.js

@@ -0,0 +1,50 @@
+export const urlPropertyNames = new Set([
+    "hash",
+    "host",
+    "hostname",
+    "href",
+    "origin",
+    "password",
+    "pathname",
+    "port",
+    "protocol",
+    "search",
+    "searchParams",
+    "username",
+]);
+const countUrlProperties = (pattern) => {
+    let count = 0;
+    for (const property of pattern.properties) {
+        if (property.type !== "ObjectProperty")
+            continue;
+        if (property.computed)
+            continue;
+        const key = property.key;
+        const keyName = key.type === "Identifier"
+            ? key.name
+            : key.type === "StringLiteral"
+                ? key.value
+                : undefined;
+        if (keyName && urlPropertyNames.has(keyName)) {
+            count += 1;
+        }
+    }
+    return count;
+};
+export const hasUrlDestructure = (referencePath) => {
+    const parent = referencePath.parentPath;
+    if (!parent)
+        return false;
+    if (parent.isVariableDeclarator() &&
+        parent.node.init === referencePath.node &&
+        parent.node.id.type === "ObjectPattern") {
+        return countUrlProperties(parent.node.id) >= 2;
+    }
+    if (parent.isAssignmentExpression() &&
+        parent.node.operator === "=" &&
+        parent.node.right === referencePath.node &&
+        parent.node.left.type === "ObjectPattern") {
+        return countUrlProperties(parent.node.left) >= 2;
+    }
+    return false;
+};

package/package.json

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