miniread 1.31.0 → 1.33.0

package/dist/transforms/_generated/manifest.js

@@ -87,6 +87,10 @@ const manifestData = {
         evaluatedAt: "2026-01-24T15:59:39.475Z",
         notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
     },
+    "rename-default-options-parameters": {
+        diffReductionImpact: 0,
+        recommended: true,
+    },
     "rename-destructured-aliases": {
         diffReductionImpact: 0.000943734546346775,
         recommended: true,
@@ -215,6 +219,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

@@ -14,6 +14,7 @@ import { renameCharcodeVariablesTransform } from "../rename-charcode-variables/r
 import { renameCharcodeVariablesV2Transform } from "../rename-charcode-variables-v2/rename-charcode-variables-v2-transform.js";
 import { renameComparisonFlagsTransform } from "../rename-comparison-flags/rename-comparison-flags-transform.js";
 import { renameDateNowStartTimesTransform } from "../rename-date-now-start-times/rename-date-now-start-times-transform.js";
+import { renameDefaultOptionsParametersTransform } from "../rename-default-options-parameters/rename-default-options-parameters-transform.js";
 import { renameDestructuredAliasesTransform } from "../rename-destructured-aliases/rename-destructured-aliases-transform.js";
 import { renameErrorVariablesTransform } from "../rename-error-variables/rename-error-variables-transform.js";
 import { renameEventParametersTransform } from "../rename-event-parameters/rename-event-parameters-transform.js";
@@ -36,6 +37,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,
@@ -52,6 +54,7 @@ export const transformRegistry = {
     [renameCharcodeVariablesV2Transform.id]: renameCharcodeVariablesV2Transform,
     [renameComparisonFlagsTransform.id]: renameComparisonFlagsTransform,
     [renameDateNowStartTimesTransform.id]: renameDateNowStartTimesTransform,
+    [renameDefaultOptionsParametersTransform.id]: renameDefaultOptionsParametersTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
     [renameErrorVariablesTransform.id]: renameErrorVariablesTransform,
     [renameEventParametersTransform.id]: renameEventParametersTransform,
@@ -74,6 +77,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-default-options-parameters/manifest.json

@@ -0,0 +1,4 @@
+{
+    "diffReductionImpact": 0,
+    "recommended": true
+}

package/dist/transforms/rename-default-options-parameters/rename-default-options-parameters-transform.d.ts

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

package/dist/transforms/rename-default-options-parameters/rename-default-options-parameters-transform.js

@@ -0,0 +1,110 @@
+import { createRequire } from "node:module";
+import * as t from "@babel/types";
+import { isStableRenamed, RenameGroup } 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 BASE_NAME = "options";
+const getSingleAssignmentExpression = (statement) => {
+    if (t.isExpressionStatement(statement)) {
+        const { expression } = statement;
+        return t.isAssignmentExpression(expression, { operator: "=" })
+            ? expression
+            : undefined;
+    }
+    if (t.isBlockStatement(statement)) {
+        const [firstStatement] = statement.body;
+        if (!firstStatement)
+            return undefined;
+        if (!t.isExpressionStatement(firstStatement))
+            return undefined;
+        const { expression } = firstStatement;
+        return t.isAssignmentExpression(expression, { operator: "=" })
+            ? expression
+            : undefined;
+    }
+    return undefined;
+};
+const getDefaultOptionsParameterNames = (path) => {
+    if (path.scope.hasBinding("undefined", true))
+        return [];
+    const body = path.node.body;
+    if (!t.isBlockStatement(body))
+        return [];
+    const parameterNames = new Set();
+    for (const parameter of path.node.params) {
+        if (!t.isIdentifier(parameter))
+            continue;
+        parameterNames.add(parameter.name);
+    }
+    const matches = [];
+    for (const statement of body.body) {
+        if (t.isExpressionStatement(statement) &&
+            t.isStringLiteral(statement.expression)) {
+            continue;
+        }
+        if (!t.isIfStatement(statement))
+            break;
+        if (statement.alternate)
+            break;
+        if (!t.isBinaryExpression(statement.test, { operator: "===" }))
+            break;
+        const { left, right } = statement.test;
+        const parameterName = t.isIdentifier(left) && t.isIdentifier(right, { name: "undefined" })
+            ? left.name
+            : t.isIdentifier(left, { name: "undefined" }) && t.isIdentifier(right)
+                ? right.name
+                : undefined;
+        if (!parameterName || parameterName === "undefined")
+            break;
+        if (!parameterNames.has(parameterName))
+            break;
+        const assignment = getSingleAssignmentExpression(statement.consequent);
+        if (!assignment)
+            break;
+        if (!t.isIdentifier(assignment.left, { name: parameterName }))
+            break;
+        if (!t.isObjectExpression(assignment.right))
+            break;
+        if (assignment.right.properties.length > 0)
+            break;
+        matches.push(parameterName);
+    }
+    return [...new Set(matches)];
+};
+export const renameDefaultOptionsParametersTransform = {
+    id: "rename-default-options-parameters",
+    description: "Renames parameters defaulted to {} into $options (or options/options2 when multiple)",
+    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, {
+                Function(path) {
+                    nodesVisited++;
+                    const parameterNames = getDefaultOptionsParameterNames(path);
+                    for (const parameterName of parameterNames) {
+                        if (parameterName === BASE_NAME)
+                            continue;
+                        if (isStableRenamed(parameterName))
+                            continue;
+                        group.add({
+                            scope: path.scope,
+                            currentName: parameterName,
+                            baseName: BASE_NAME,
+                        });
+                    }
+                },
+            });
+            transformationsApplied += group.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.31.0",
+  "version": "1.33.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",