miniread 1.56.0 → 1.57.0

package/dist/transforms/_generated/manifest.js

@@ -307,6 +307,10 @@ const manifestData = {
         recommended: true,
         notes: "Improves readability by using object shorthand for stable-renamed identifiers; no diff reduction impact expected.",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-24T12:08:16.000Z", "changedLines": 0, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 100 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-25T23:42:52.520Z", "changedLines": 0, "durationSeconds": 44.329058792000005, "stableNames": 1357 } },
+    },
+    "use-optional-chaining": {
+        recommended: true,
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-01T22:32:15.450Z", "changedLines": 0, "durationSeconds": 146.893061276, "stableNames": 1357 } },
     }
 };
 export const manifestEntries = Object.entries(transformRegistry)
@@ -372,6 +376,7 @@ export const recommendedTransformIds = [
     "simplify-boolean-negations",
     "simplify-string-trim",
     "split-variable-declarations",
+    "use-optional-chaining",
     "use-object-property-shorthand",
     "use-object-shorthand",
     "replace-dynamic-require-eval"

package/dist/transforms/_generated/registry.js

@@ -61,6 +61,7 @@ import { splitVariableDeclarationsTransform } from "../split-variable-declaratio
 import { stabilizeTopLevelBindingsTransform } from "../stabilize-top-level-bindings/stabilize-top-level-bindings-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";
+import { useOptionalChainingTransform } from "../use-optional-chaining/use-optional-chaining-transform.js";
 export const transformRegistry = {
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
     [expandSequenceExpressionsV4Transform.id]: expandSequenceExpressionsV4Transform,
@@ -123,5 +124,6 @@ export const transformRegistry = {
     [stabilizeTopLevelBindingsTransform.id]: stabilizeTopLevelBindingsTransform,
     [useObjectPropertyShorthandTransform.id]: useObjectPropertyShorthandTransform,
     [useObjectShorthandTransform.id]: useObjectShorthandTransform,
+    [useOptionalChainingTransform.id]: useOptionalChainingTransform,
 };
 export const allTransformIds = Object.keys(transformRegistry);

package/dist/transforms/recommended-transform-order.d.ts

@@ -4,4 +4,4 @@
  * This lets us tune transform interactions intentionally instead of relying on
  * alphabetical ID sorting.
  */
-export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "expand-boolean-literals", "expand-sequence-expressions-v5", "expand-special-number-literals", "expand-typeof-undefined-comparisons", "expand-undefined-literals", "remove-redundant-else", "rename-arguments-length-flags", "rename-asap-wrappers", "rename-awaiter-parameters", "rename-buffer-variables", "rename-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-comparison-flags", "rename-date-now-start-times", "rename-default-options-parameters", "rename-deferred-resolve-parameters", "rename-destructured-aliases", "rename-error-first-callback-parameters", "rename-error-variables", "rename-event-parameters", "rename-interval-ids", "rename-loop-index-variables-v3", "rename-loop-length-variables", "rename-object-keys-variables", "rename-parameters-to-match-properties-v2", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-rest-parameters", "rename-search-parameters-variables", "rename-string-split-variables", "rename-this-aliases", "rename-timeout-ids", "rename-typeof-variables", "rename-typescript-helper-aliases", "rename-uint8array-concat-variables", "rename-url-parameters", "rename-url-variables", "rename-use-reference-guards-v2", "rename-use-reference-sets", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];
+export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "expand-boolean-literals", "expand-sequence-expressions-v5", "expand-special-number-literals", "expand-typeof-undefined-comparisons", "expand-undefined-literals", "remove-redundant-else", "rename-arguments-length-flags", "rename-asap-wrappers", "rename-awaiter-parameters", "rename-buffer-variables", "rename-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-comparison-flags", "rename-date-now-start-times", "rename-default-options-parameters", "rename-deferred-resolve-parameters", "rename-destructured-aliases", "rename-error-first-callback-parameters", "rename-error-variables", "rename-event-parameters", "rename-interval-ids", "rename-loop-index-variables-v3", "rename-loop-length-variables", "rename-object-keys-variables", "rename-parameters-to-match-properties-v2", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-rest-parameters", "rename-search-parameters-variables", "rename-string-split-variables", "rename-this-aliases", "rename-timeout-ids", "rename-typeof-variables", "rename-typescript-helper-aliases", "rename-uint8array-concat-variables", "rename-url-parameters", "rename-url-variables", "rename-use-reference-guards-v2", "rename-use-reference-sets", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-optional-chaining", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];

package/dist/transforms/recommended-transform-order.js

@@ -54,6 +54,7 @@ export const recommendedTransformOrder = [
     "simplify-boolean-negations",
     "simplify-string-trim",
     "split-variable-declarations",
+    "use-optional-chaining",
     "use-object-property-shorthand",
     "use-object-shorthand",
     "replace-dynamic-require-eval",

package/dist/transforms/use-optional-chaining/build-optional-access.d.ts

@@ -0,0 +1,2 @@
+import type { Expression, Identifier } from "@babel/types";
+export declare const buildOptionalAccess: (target: Identifier, alternate: Expression) => Expression | undefined;

package/dist/transforms/use-optional-chaining/build-optional-access.js

@@ -0,0 +1,51 @@
+import { cloneNode, isCallExpression, isIdentifier, isMemberExpression, isPrivateName, optionalCallExpression, optionalMemberExpression, } from "@babel/types";
+export const buildOptionalAccess = (target, alternate) => {
+    const buildOptionalMemberChain = (member) => {
+        if (!isMemberExpression(member))
+            return;
+        const property = member.property;
+        if (isPrivateName(property))
+            return;
+        const object = member.object;
+        if (isIdentifier(object)) {
+            if (object.name !== target.name)
+                return;
+            return optionalMemberExpression(cloneNode(object), cloneNode(property), member.computed, true);
+        }
+        const optionalObject = buildOptionalMemberChain(object);
+        if (!optionalObject)
+            return;
+        return optionalMemberExpression(optionalObject, cloneNode(property), member.computed, false);
+    };
+    if (isMemberExpression(alternate)) {
+        return buildOptionalMemberChain(alternate);
+    }
+    if (!isCallExpression(alternate))
+        return;
+    if (isMemberExpression(alternate.callee)) {
+        const optionalCallee = buildOptionalMemberChain(alternate.callee);
+        if (!optionalCallee)
+            return;
+        const optionalCall = optionalCallExpression(optionalCallee, alternate.arguments.map((argument) => cloneNode(argument)), false);
+        if (alternate.typeParameters) {
+            optionalCall.typeParameters = cloneNode(alternate.typeParameters);
+        }
+        if ("typeArguments" in alternate && alternate.typeArguments) {
+            optionalCall.typeArguments = cloneNode(alternate.typeArguments);
+        }
+        return optionalCall;
+    }
+    if (isIdentifier(alternate.callee)) {
+        if (alternate.callee.name !== target.name)
+            return;
+        const optionalCall = optionalCallExpression(cloneNode(alternate.callee), alternate.arguments.map((argument) => cloneNode(argument)), true);
+        if (alternate.typeParameters) {
+            optionalCall.typeParameters = cloneNode(alternate.typeParameters);
+        }
+        if ("typeArguments" in alternate && alternate.typeArguments) {
+            optionalCall.typeArguments = cloneNode(alternate.typeArguments);
+        }
+        return optionalCall;
+    }
+    return undefined;
+};

package/dist/transforms/use-optional-chaining/is-nullish-check.d.ts

@@ -0,0 +1,2 @@
+import type { Expression } from "@babel/types";
+export declare const isNullishCheck: (test: Expression, identifierName: string) => boolean;

package/dist/transforms/use-optional-chaining/is-nullish-check.js

@@ -0,0 +1,61 @@
+import { isBinaryExpression, isIdentifier, isLogicalExpression, isNullLiteral, isPrivateName, } from "@babel/types";
+import { isUndefinedExpression } from "./is-undefined-expression.js";
+import { unwrapParentheses } from "./unwrap-parentheses.js";
+const noCoverage = {
+    coversNull: false,
+    coversUndefined: false,
+};
+const mergeCoverage = (left, right) => {
+    return {
+        coversNull: left.coversNull || right.coversNull,
+        coversUndefined: left.coversUndefined || right.coversUndefined,
+    };
+};
+const getNullishCoverage = (test, identifierName) => {
+    const unwrapped = unwrapParentheses(test);
+    if (isBinaryExpression(unwrapped)) {
+        if (unwrapped.operator !== "===")
+            return noCoverage;
+        const getValueCoverage = (value) => {
+            if (isPrivateName(value))
+                return noCoverage;
+            const unwrappedValue = unwrapParentheses(value);
+            if (isNullLiteral(unwrappedValue)) {
+                return { coversNull: true, coversUndefined: false };
+            }
+            if (isUndefinedExpression(unwrappedValue)) {
+                return { coversNull: false, coversUndefined: true };
+            }
+            return noCoverage;
+        };
+        const left = unwrapped.left;
+        const right = unwrapped.right;
+        if (isPrivateName(left))
+            return noCoverage;
+        if (isIdentifier(left) && left.name === identifierName) {
+            return getValueCoverage(right);
+        }
+        if (!isPrivateName(right) &&
+            isIdentifier(right) &&
+            right.name === identifierName) {
+            return getValueCoverage(left);
+        }
+        return noCoverage;
+    }
+    if (isLogicalExpression(unwrapped) && unwrapped.operator === "||") {
+        const leftCoverage = getNullishCoverage(unwrapped.left, identifierName);
+        if (!leftCoverage.coversNull && !leftCoverage.coversUndefined) {
+            return noCoverage;
+        }
+        const rightCoverage = getNullishCoverage(unwrapped.right, identifierName);
+        if (!rightCoverage.coversNull && !rightCoverage.coversUndefined) {
+            return noCoverage;
+        }
+        return mergeCoverage(leftCoverage, rightCoverage);
+    }
+    return noCoverage;
+};
+export const isNullishCheck = (test, identifierName) => {
+    const coverage = getNullishCoverage(test, identifierName);
+    return coverage.coversNull && coverage.coversUndefined;
+};

package/dist/transforms/use-optional-chaining/is-undefined-expression.d.ts

@@ -0,0 +1,2 @@
+import type { Expression } from "@babel/types";
+export declare const isUndefinedExpression: (expression: Expression) => boolean;

package/dist/transforms/use-optional-chaining/is-undefined-expression.js

@@ -0,0 +1,12 @@
+import { isIdentifier, isNumericLiteral, isUnaryExpression, } from "@babel/types";
+import { unwrapParentheses } from "./unwrap-parentheses.js";
+export const isUndefinedExpression = (expression) => {
+    const unwrapped = unwrapParentheses(expression);
+    if (isIdentifier(unwrapped) && unwrapped.name === "undefined")
+        return true;
+    if (isUnaryExpression(unwrapped) && unwrapped.operator === "void") {
+        const argument = unwrapParentheses(unwrapped.argument);
+        return isNumericLiteral(argument);
+    }
+    return false;
+};

package/dist/transforms/use-optional-chaining/manifest.json

@@ -0,0 +1,12 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-01T22:32:15.450Z",
+            "changedLines": 0,
+            "durationSeconds": 146.893061276,
+            "stableNames": 1357
+        }
+    }
+}

package/dist/transforms/use-optional-chaining/unwrap-parentheses.d.ts

@@ -0,0 +1,2 @@
+import type { Expression } from "@babel/types";
+export declare const unwrapParentheses: (expression: Expression) => Expression;

package/dist/transforms/use-optional-chaining/unwrap-parentheses.js

@@ -0,0 +1,8 @@
+import { isParenthesizedExpression } from "@babel/types";
+export const unwrapParentheses = (expression) => {
+    let unwrapped = expression;
+    while (isParenthesizedExpression(unwrapped)) {
+        unwrapped = unwrapped.expression;
+    }
+    return unwrapped;
+};

package/dist/transforms/use-optional-chaining/use-optional-chaining-transform.d.ts

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

package/dist/transforms/use-optional-chaining/use-optional-chaining-transform.js

@@ -0,0 +1,70 @@
+import { createRequire } from "node:module";
+import { isCallExpression, isIdentifier, isMemberExpression, } from "@babel/types";
+import { getFilesToProcess, } from "../../core/types.js";
+import { buildOptionalAccess } from "./build-optional-access.js";
+import { isNullishCheck } from "./is-nullish-check.js";
+import { isUndefinedExpression } from "./is-undefined-expression.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const shouldSkipUndefinedBinding = (path) => Boolean(path.scope.getBinding("undefined"));
+export const useOptionalChainingTransform = {
+    id: "use-optional-chaining",
+    description: "Replace explicit null/undefined ternaries with optional chaining",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            traverse(fileInfo.ast, {
+                ConditionalExpression(path) {
+                    nodesVisited++;
+                    if (shouldSkipUndefinedBinding(path))
+                        return;
+                    const alternate = path.node.alternate;
+                    const target = (() => {
+                        if (isMemberExpression(alternate)) {
+                            let object = alternate.object;
+                            while (isMemberExpression(object)) {
+                                object = object.object;
+                            }
+                            if (!isIdentifier(object))
+                                return;
+                            return object;
+                        }
+                        if (!isCallExpression(alternate))
+                            return;
+                        const callee = alternate.callee;
+                        if (isIdentifier(callee))
+                            return callee;
+                        if (isMemberExpression(callee)) {
+                            let object = callee.object;
+                            while (isMemberExpression(object)) {
+                                object = object.object;
+                            }
+                            if (!isIdentifier(object))
+                                return;
+                            return object;
+                        }
+                        return;
+                    })();
+                    if (!target)
+                        return;
+                    if (!path.scope.getBinding(target.name))
+                        return;
+                    if (!isNullishCheck(path.node.test, target.name))
+                        return;
+                    if (!isUndefinedExpression(path.node.consequent))
+                        return;
+                    const replacement = buildOptionalAccess(target, path.node.alternate);
+                    if (!replacement)
+                        return;
+                    path.replaceWith(replacement);
+                    transformationsApplied++;
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/package.json

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