miniread 1.30.0 → 1.32.0

package/dist/transforms/_generated/manifest.js

@@ -38,6 +38,12 @@ const manifestData = {
         evaluatedAt: "2026-01-23T18:15:00.000Z",
         notes: "Added manually; improves readability by reducing nesting.",
     },
+    "rename-arguments-length-flags": {
+        diffReductionImpact: 0,
+        recommended: true,
+        evaluatedAt: "2026-01-24T15:56:12.512Z",
+        notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
+    },
     "rename-awaiter-parameters": {
         diffReductionImpact: 0,
         recommended: true,
@@ -209,6 +215,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-property-shorthand": {
+        diffReductionImpact: 0,
+        recommended: true,
+        evaluatedAt: "2026-01-24T12:47:30.495Z",
+        notes: "Auto-added by evaluation script.",
+    },
     "use-object-shorthand": {
         diffReductionImpact: 0,
         recommended: true,

package/dist/transforms/_generated/registry.js

@@ -6,6 +6,7 @@ import { expandSequenceExpressionsV5Transform } from "../expand-sequence-express
 import { expandSpecialNumberLiteralsTransform } from "../expand-special-number-literals/expand-special-number-literals-transform.js";
 import { expandUndefinedLiteralsTransform } from "../expand-undefined-literals/expand-undefined-literals-transform.js";
 import { removeRedundantElseTransform } from "../remove-redundant-else/remove-redundant-else-transform.js";
+import { renameArgumentsLengthFlagsTransform } from "../rename-arguments-length-flags/rename-arguments-length-flags-transform.js";
 import { renameAwaiterParametersTransform } from "../rename-awaiter-parameters/rename-awaiter-parameters-transform.js";
 import { renameCatchParametersTransform } from "../rename-catch-parameters/rename-catch-parameters-transform.js";
 import { renameCharCodeAtTransform } from "../rename-char-code-at/rename-char-code-at-transform.js";
@@ -35,6 +36,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 { useObjectPropertyShorthandTransform } from "../use-object-property-shorthand/use-object-property-shorthand-transform.js";
 import { useObjectShorthandTransform } from "../use-object-shorthand/use-object-shorthand-transform.js";
 export const transformRegistry = {
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
@@ -43,6 +45,7 @@ export const transformRegistry = {
     [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [removeRedundantElseTransform.id]: removeRedundantElseTransform,
+    [renameArgumentsLengthFlagsTransform.id]: renameArgumentsLengthFlagsTransform,
     [renameAwaiterParametersTransform.id]: renameAwaiterParametersTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
     [renameCharCodeAtTransform.id]: renameCharCodeAtTransform,
@@ -72,6 +75,7 @@ export const transformRegistry = {
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
+    [useObjectPropertyShorthandTransform.id]: useObjectPropertyShorthandTransform,
     [useObjectShorthandTransform.id]: useObjectShorthandTransform,
 };
 export const allTransformIds = Object.keys(transformRegistry);

package/dist/transforms/rename-arguments-length-flags/manifest.json

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

package/dist/transforms/rename-arguments-length-flags/rename-arguments-length-flags-transform.d.ts

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

package/dist/transforms/rename-arguments-length-flags/rename-arguments-length-flags-transform.js

@@ -0,0 +1,106 @@
+import { createRequire } from "node:module";
+import { isIdentifier, isMemberExpression, isNumericLiteral, isPrivateName, } from "@babel/types";
+import { RenameGroup, 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 isArgumentsLengthExpression = (expression) => {
+    if (!isMemberExpression(expression))
+        return false;
+    if (expression.computed)
+        return false;
+    if (!isIdentifier(expression.object))
+        return false;
+    if (!isIdentifier(expression.property))
+        return false;
+    return (expression.object.name === "arguments" &&
+        expression.property.name === "length");
+};
+const getExpression = (node) => {
+    if (isPrivateName(node))
+        return undefined;
+    return node;
+};
+const getNumericLiteralValue = (node) => {
+    if (!isNumericLiteral(node))
+        return undefined;
+    if (!Number.isInteger(node.value))
+        return undefined;
+    return node.value;
+};
+const getAtLeastArgumentsThreshold = (init) => {
+    if (init.operator === ">" || init.operator === ">=") {
+        const left = getExpression(init.left);
+        const right = getExpression(init.right);
+        if (!left || !right)
+            return undefined;
+        if (!isArgumentsLengthExpression(left))
+            return undefined;
+        const value = getNumericLiteralValue(right);
+        if (value === undefined)
+            return undefined;
+        return init.operator === ">" ? value + 1 : value;
+    }
+    if (init.operator === "<" || init.operator === "<=") {
+        const left = getExpression(init.left);
+        const right = getExpression(init.right);
+        if (!left || !right)
+            return undefined;
+        if (!isArgumentsLengthExpression(right))
+            return undefined;
+        const value = getNumericLiteralValue(left);
+        if (value === undefined)
+            return undefined;
+        return init.operator === "<" ? value + 1 : value;
+    }
+    return undefined;
+};
+const getBaseName = (threshold) => {
+    if (threshold === 1)
+        return "hasAtLeast1Arg";
+    return `hasAtLeast${threshold}Args`;
+};
+export const renameArgumentsLengthFlagsTransform = {
+    id: "rename-arguments-length-flags",
+    description: "Rename arguments.length guards (>= N) to $hasAtLeastNArgs when stable",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const renameGroup = new RenameGroup();
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    if (isStableRenamed(id.name))
+                        return;
+                    if (id.name.length > 1)
+                        return;
+                    const init = path.node.init;
+                    if (init?.type !== "BinaryExpression")
+                        return;
+                    if (path.scope.getBinding("arguments"))
+                        return;
+                    const threshold = getAtLeastArgumentsThreshold(init);
+                    if (threshold === undefined || threshold < 1)
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding?.constant)
+                        return;
+                    renameGroup.add({
+                        scope: binding.scope,
+                        currentName: id.name,
+                        baseName: getBaseName(threshold),
+                    });
+                },
+            });
+            transformationsApplied += renameGroup.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

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

@@ -0,0 +1,6 @@
+{
+    "diffReductionImpact": 0,
+    "recommended": true,
+    "evaluatedAt": "2026-01-24T12:47:30.495Z",
+    "notes": "Auto-added by evaluation script."
+}

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

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

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

@@ -0,0 +1,45 @@
+import { createRequire } from "node:module";
+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) => {
+    const isObjectExpression = path.parentPath.isObjectExpression();
+    const isObjectPattern = path.parentPath.isObjectPattern();
+    if (!isObjectExpression && !isObjectPattern)
+        return false;
+    const { node } = path;
+    if (node.computed || node.shorthand)
+        return false;
+    if (node.key.type !== "Identifier")
+        return false;
+    if (node.value.type !== "Identifier")
+        return false;
+    // `{ __proto__: x }` has special prototype-setting semantics in object literals,
+    // while `{ __proto__ }` is a normal data property. Avoid changing runtime shape.
+    if (isObjectExpression && node.key.name === "__proto__")
+        return false;
+    return node.key.name === node.value.name;
+};
+export const useObjectPropertyShorthandTransform = {
+    id: "use-object-property-shorthand",
+    description: "Converts object properties with identical key/value identifiers to shorthand",
+    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.30.0",
+  "version": "1.32.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",