miniread 1.26.0 → 1.27.0

package/dist/transforms/_generated/manifest.js

@@ -130,6 +130,12 @@ const manifestData = {
         evaluatedAt: "2026-01-22T21:39:53.578Z",
         notes: "Auto-added by evaluation script.",
     },
+    "rename-regex-builders": {
+        diffReductionImpact: 0,
+        recommended: true,
+        evaluatedAt: "2026-01-24T15:54:39.303Z",
+        notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
+    },
     "rename-replace-child-parameters": {
         diffReductionImpact: 0,
         recommended: false,
@@ -185,6 +191,12 @@ const manifestData = {
         evaluatedAt: "2026-01-23T05:45:27.981Z",
         notes: "Auto-added by evaluation script. Measured with baseline none: -0.28%. Enabled in the recommended preset for readability and to normalize variable declarations even when line diffs increase.",
     },
+    "use-object-shorthand": {
+        diffReductionImpact: 0,
+        recommended: true,
+        evaluatedAt: "2026-01-24T12:08:16.000Z",
+        notes: "Improves readability by using object shorthand for stable-renamed identifiers; no diff reduction impact expected.",
+    },
 };
 export const manifestEntries = Object.entries(transformRegistry)
     .map(([id, transform]) => {

package/dist/transforms/_generated/registry.js

@@ -21,6 +21,7 @@ import { renameLoopLengthVariablesTransform } from "../rename-loop-length-variab
 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 { renameRegexBuildersTransform } from "../rename-regex-builders/rename-regex-builders-transform.js";
 import { renameReplaceChildParametersTransform } from "../rename-replace-child-parameters/rename-replace-child-parameters-transform.js";
 import { renameRestParametersTransform } from "../rename-rest-parameters/rename-rest-parameters-transform.js";
 import { renameThisAliasesTransform } from "../rename-this-aliases/rename-this-aliases-transform.js";
@@ -31,6 +32,7 @@ import { renameUseReferenceGuardsTransform } from "../rename-use-reference-guard
 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";
 import { splitVariableDeclarationsTransform } from "../split-variable-declarations/split-variable-declarations-transform.js";
+import { useObjectShorthandTransform } from "../use-object-shorthand/use-object-shorthand-transform.js";
 export const transformRegistry = {
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
     [expandSequenceExpressionsV4Transform.id]: expandSequenceExpressionsV4Transform,
@@ -53,6 +55,7 @@ export const transformRegistry = {
     [renameParametersToMatchPropertiesTransform.id]: renameParametersToMatchPropertiesTransform,
     [renameParametersToMatchPropertiesV2Transform.id]: renameParametersToMatchPropertiesV2Transform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
+    [renameRegexBuildersTransform.id]: renameRegexBuildersTransform,
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameRestParametersTransform.id]: renameRestParametersTransform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
@@ -63,5 +66,6 @@ export const transformRegistry = {
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
+    [useObjectShorthandTransform.id]: useObjectShorthandTransform,
 };
 export const allTransformIds = Object.keys(transformRegistry);

package/dist/transforms/rename-regex-builders/is-regex-builder-object.d.ts

@@ -0,0 +1,3 @@
+import type { Binding, NodePath } from "@babel/traverse";
+import type { ObjectExpression } from "@babel/types";
+export declare const isRegexBuilderObject: (objectExpressionPath: NodePath<ObjectExpression>, bindingName: string, binding: Binding) => boolean;

package/dist/transforms/rename-regex-builders/is-regex-builder-object.js

@@ -0,0 +1,113 @@
+const getSequenceTail = (expressionPath) => {
+    let tailPath = expressionPath;
+    while (tailPath.isSequenceExpression()) {
+        const expressions = tailPath.get("expressions");
+        const lastExpression = expressions.at(-1);
+        if (!lastExpression)
+            break;
+        tailPath = lastExpression;
+    }
+    return tailPath;
+};
+const isPropertyNamed = (property, name) => {
+    if (property.key.type === "Identifier") {
+        return !property.computed && property.key.name === name;
+    }
+    if (property.key.type === "StringLiteral") {
+        return property.key.value === name;
+    }
+    return false;
+};
+const getPropertyFunctionPath = (objectExpressionPath, name) => {
+    const propertyPaths = objectExpressionPath.get("properties");
+    for (const propertyPath of propertyPaths) {
+        if (propertyPath.isSpreadElement())
+            continue;
+        if (propertyPath.isObjectMethod()) {
+            if (propertyPath.node.kind !== "method")
+                continue;
+            if (isPropertyNamed(propertyPath.node, name)) {
+                return propertyPath;
+            }
+            continue;
+        }
+        if (!propertyPath.isObjectProperty())
+            continue;
+        if (!isPropertyNamed(propertyPath.node, name))
+            continue;
+        const valuePath = propertyPath.get("value");
+        if (valuePath.isFunctionExpression() ||
+            valuePath.isArrowFunctionExpression()) {
+            return valuePath;
+        }
+    }
+    return undefined;
+};
+const returnsIdentifierBinding = (functionPath, identifierName, expectedBinding) => {
+    const bodyPath = functionPath.get("body");
+    const implicitReturnPath = getSequenceTail(bodyPath);
+    if (implicitReturnPath.isIdentifier({ name: identifierName })) {
+        return (implicitReturnPath.scope.getBinding(identifierName) === expectedBinding);
+    }
+    let found = false;
+    bodyPath.traverse({
+        Function(innerFunctionPath) {
+            innerFunctionPath.skip();
+        },
+        ReturnStatement(returnPath) {
+            const argumentPath = returnPath.get("argument");
+            if (!argumentPath.node)
+                return;
+            const returnValuePath = getSequenceTail(argumentPath);
+            if (!returnValuePath.isIdentifier({ name: identifierName }))
+                return;
+            if (returnValuePath.scope.getBinding(identifierName) !== expectedBinding)
+                return;
+            found = true;
+        },
+    });
+    return found;
+};
+const returnsNewRegExpGlobal = (functionPath) => {
+    const bodyPath = functionPath.get("body");
+    const implicitReturnPath = getSequenceTail(bodyPath);
+    if (implicitReturnPath.isNewExpression()) {
+        const calleePath = implicitReturnPath.get("callee");
+        return (calleePath.isIdentifier({ name: "RegExp" }) &&
+            !calleePath.scope.getBinding("RegExp"));
+    }
+    let found = false;
+    bodyPath.traverse({
+        Function(innerFunctionPath) {
+            innerFunctionPath.skip();
+        },
+        ReturnStatement(returnPath) {
+            const argumentPath = returnPath.get("argument");
+            if (!argumentPath.node)
+                return;
+            const returnValuePath = getSequenceTail(argumentPath);
+            if (!returnValuePath.isNewExpression())
+                return;
+            const calleePath = returnValuePath.get("callee");
+            if (!calleePath.isIdentifier({ name: "RegExp" }))
+                return;
+            if (calleePath.scope.getBinding("RegExp"))
+                return;
+            found = true;
+        },
+    });
+    return found;
+};
+export const isRegexBuilderObject = (objectExpressionPath, bindingName, binding) => {
+    const replaceFunction = getPropertyFunctionPath(objectExpressionPath, "replace");
+    if (!replaceFunction)
+        return false;
+    if (!returnsIdentifierBinding(replaceFunction, bindingName, binding))
+        return false;
+    const getRegexFunction = getPropertyFunctionPath(objectExpressionPath, "getRegex");
+    if (!getRegexFunction)
+        return false;
+    if (!returnsNewRegExpGlobal(getRegexFunction))
+        return false;
+    return true;
+};

package/dist/transforms/rename-regex-builders/manifest.json

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

package/dist/transforms/rename-regex-builders/rename-regex-builders-transform.d.ts

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

package/dist/transforms/rename-regex-builders/rename-regex-builders-transform.js

@@ -0,0 +1,51 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import * as t from "@babel/types";
+import { isRegexBuilderObject } from "./is-regex-builder-object.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 = "regexBuilder";
+export const renameRegexBuildersTransform = {
+    id: "rename-regex-builders",
+    description: "Renames fluent regex builder objects to $regexBuilder/$regexBuilder2 when they expose replace() and getRegex().",
+    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++;
+                    const id = path.node.id;
+                    if (!t.isIdentifier(id))
+                        return;
+                    if (isStableRenamed(id.name))
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    const initPath = path.get("init");
+                    if (!initPath.isObjectExpression())
+                        return;
+                    if (!isRegexBuilderObject(initPath, id.name, binding))
+                        return;
+                    if (path.scope.hasBinding("RegExp", true))
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName: BASE_NAME,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/use-object-shorthand/manifest.json

@@ -0,0 +1,6 @@
+{
+    "diffReductionImpact": 0,
+    "recommended": true,
+    "evaluatedAt": "2026-01-24T12:08:16.000Z",
+    "notes": "Improves readability by using object shorthand for stable-renamed identifiers; no diff reduction impact expected."
+}

package/dist/transforms/use-object-shorthand/use-object-shorthand-transform.d.ts

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

package/dist/transforms/use-object-shorthand/use-object-shorthand-transform.js

@@ -0,0 +1,48 @@
+import { createRequire } from "node:module";
+import { isIdentifier } from "@babel/types";
+import { isStableRenamed } 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 isShorthandCandidate = (path) => {
+    if (path.node.shorthand)
+        return false;
+    if (path.node.computed)
+        return false;
+    if (!path.parentPath.isObjectExpression() &&
+        !path.parentPath.isObjectPattern()) {
+        return false;
+    }
+    if (!isIdentifier(path.node.key))
+        return false;
+    if (path.node.key.name === "__proto__")
+        return false;
+    if (!isIdentifier(path.node.value))
+        return false;
+    if (!isStableRenamed(path.node.value.name))
+        return false;
+    return path.node.key.name === path.node.value.name;
+};
+export const useObjectShorthandTransform = {
+    id: "use-object-shorthand",
+    description: "Use object property shorthand for stable-renamed identifiers with matching keys",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            traverse(fileInfo.ast, {
+                ObjectProperty(path) {
+                    nodesVisited++;
+                    if (!isShorthandCandidate(path))
+                        return;
+                    path.node.shorthand = true;
+                    transformationsApplied++;
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/package.json

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