miniread 1.103.0 → 1.104.0

package/dist/transforms/_generated/catalog.js

@@ -100,6 +100,8 @@ import { renamePromiseCatchParametersTransform } from "../../transforms-by-id/re
 import renamePromiseCatchParametersManifest from "../../transforms-by-id/rename-promise-catch-parameters/manifest.json" with { type: "json" };
 import { renamePromiseExecutorParametersV2Transform } from "../../transforms-by-id/rename-promise-executor-parameters-v2/rename-promise-executor-parameters-v2-transform.js";
 import renamePromiseExecutorParametersV2Manifest from "../../transforms-by-id/rename-promise-executor-parameters-v2/manifest.json" with { type: "json" };
+import { renameProtobufEncodeParametersTransform } from "../../transforms-by-id/rename-protobuf-encode-parameters/rename-protobuf-encode-parameters-transform.js";
+import renameProtobufEncodeParametersManifest from "../../transforms-by-id/rename-protobuf-encode-parameters/manifest.json" with { type: "json" };
 import { renameQueueTraversalVariablesTransform } from "../../transforms-by-id/rename-queue-traversal-variables/rename-queue-traversal-variables-transform.js";
 import renameQueueTraversalVariablesManifest from "../../transforms-by-id/rename-queue-traversal-variables/manifest.json" with { type: "json" };
 import { renameRangeParametersTransform } from "../../transforms-by-id/rename-range-parameters/rename-range-parameters-transform.js";
@@ -423,6 +425,11 @@ export const generatedTransformCatalog = [
         transform: renamePromiseExecutorParametersV2Transform,
         manifest: renamePromiseExecutorParametersV2Manifest,
     },
+    {
+        id: renameProtobufEncodeParametersTransform.id,
+        transform: renameProtobufEncodeParametersTransform,
+        manifest: renameProtobufEncodeParametersManifest,
+    },
     {
         id: renameQueueTraversalVariablesTransform.id,
         transform: renameQueueTraversalVariablesTransform,

package/dist/transforms-by-id/rename-protobuf-encode-parameters/get-assigned-member-property-name.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ArrowFunctionExpression, FunctionExpression } from "@babel/types";
+export declare const getAssignedMemberPropertyName: (path: NodePath<FunctionExpression | ArrowFunctionExpression>) => string | undefined;

package/dist/transforms-by-id/rename-protobuf-encode-parameters/get-assigned-member-property-name.js

@@ -0,0 +1,18 @@
+export const getAssignedMemberPropertyName = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath.isAssignmentExpression({ operator: "=" }))
+        return undefined;
+    const leftPath = parentPath.get("left");
+    if (!leftPath.isMemberExpression())
+        return undefined;
+    if (leftPath.node.computed) {
+        const propertyPath = leftPath.get("property");
+        if (!propertyPath.isStringLiteral())
+            return undefined;
+        return propertyPath.node.value;
+    }
+    const propertyPath = leftPath.get("property");
+    if (!propertyPath.isIdentifier())
+        return undefined;
+    return propertyPath.node.name;
+};

package/dist/transforms-by-id/rename-protobuf-encode-parameters/get-two-identifier-parameter-names.d.ts

@@ -0,0 +1,7 @@
+import type { NodePath } from "@babel/traverse";
+import type { ArrowFunctionExpression, FunctionExpression } from "@babel/types";
+export type ProtobufEncodeParameterNames = {
+    messageParameterName: string;
+    writerParameterName: string;
+};
+export declare const getTwoIdentifierParameterNames: (path: NodePath<FunctionExpression | ArrowFunctionExpression>) => ProtobufEncodeParameterNames | undefined;

package/dist/transforms-by-id/rename-protobuf-encode-parameters/get-two-identifier-parameter-names.js

@@ -0,0 +1,15 @@
+export const getTwoIdentifierParameterNames = (path) => {
+    const parameters = path.get("params");
+    if (parameters.length !== 2)
+        return undefined;
+    const messageParameterPath = parameters[0];
+    const writerParameterPath = parameters[1];
+    if (!messageParameterPath?.isIdentifier())
+        return undefined;
+    if (!writerParameterPath?.isIdentifier())
+        return undefined;
+    return {
+        messageParameterName: messageParameterPath.node.name,
+        writerParameterName: writerParameterPath.node.name,
+    };
+};

package/dist/transforms-by-id/rename-protobuf-encode-parameters/has-protobuf-encode-body-signals.d.ts

@@ -0,0 +1,4 @@
+import type { NodePath } from "@babel/traverse";
+import type { BlockStatement } from "@babel/types";
+import type { ProtobufEncodeParameterNames } from "./get-two-identifier-parameter-names.js";
+export declare const hasProtobufEncodeBodySignals: (bodyPath: NodePath<BlockStatement>, parameters: ProtobufEncodeParameterNames) => boolean;

package/dist/transforms-by-id/rename-protobuf-encode-parameters/has-protobuf-encode-body-signals.js

@@ -0,0 +1,94 @@
+const isObjectHasOwnPropertyCallForMessage = (callExpression, messageParameterName) => {
+    const callee = callExpression.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (callee.property.type !== "Identifier")
+        return false;
+    if (callee.property.name !== "call")
+        return false;
+    const object = callee.object;
+    if (object.type !== "MemberExpression")
+        return false;
+    if (object.computed)
+        return false;
+    if (object.object.type !== "Identifier")
+        return false;
+    if (object.object.name !== "Object")
+        return false;
+    if (object.property.type !== "Identifier")
+        return false;
+    if (object.property.name !== "hasOwnProperty")
+        return false;
+    if (callExpression.arguments.length < 2)
+        return false;
+    const [firstArgument, secondArgument] = callExpression.arguments;
+    if (!firstArgument || !secondArgument)
+        return false;
+    if (firstArgument.type !== "Identifier")
+        return false;
+    if (firstArgument.name !== messageParameterName)
+        return false;
+    return secondArgument.type === "StringLiteral";
+};
+const isWriterUint32Call = (callee, writerParameterName) => {
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (callee.object.type !== "Identifier")
+        return false;
+    if (callee.object.name !== writerParameterName)
+        return false;
+    if (callee.property.type !== "Identifier")
+        return false;
+    return callee.property.name === "uint32";
+};
+const collectProtobufEncodeBodySignals = (bodyPath, parameters) => {
+    const signals = {
+        hasWriterUint32Call: false,
+        hasMessageOwnPropertyGuard: false,
+        hasReturnWriter: false,
+    };
+    bodyPath.traverse({
+        Function(path) {
+            path.skip();
+        },
+        CallExpression(path) {
+            if (!signals.hasWriterUint32Call) {
+                signals.hasWriterUint32Call = isWriterUint32Call(path.node.callee, parameters.writerParameterName);
+            }
+            if (!signals.hasMessageOwnPropertyGuard) {
+                signals.hasMessageOwnPropertyGuard =
+                    isObjectHasOwnPropertyCallForMessage(path.node, parameters.messageParameterName);
+            }
+            if (signals.hasWriterUint32Call &&
+                signals.hasMessageOwnPropertyGuard &&
+                signals.hasReturnWriter) {
+                path.stop();
+            }
+        },
+        ReturnStatement(path) {
+            if (!signals.hasReturnWriter) {
+                const argument = path.node.argument;
+                if (argument?.type === "Identifier" &&
+                    argument.name === parameters.writerParameterName) {
+                    signals.hasReturnWriter = true;
+                }
+            }
+            if (signals.hasWriterUint32Call &&
+                signals.hasMessageOwnPropertyGuard &&
+                signals.hasReturnWriter) {
+                path.stop();
+            }
+        },
+    });
+    return signals;
+};
+export const hasProtobufEncodeBodySignals = (bodyPath, parameters) => {
+    const signals = collectProtobufEncodeBodySignals(bodyPath, parameters);
+    return (signals.hasWriterUint32Call &&
+        signals.hasMessageOwnPropertyGuard &&
+        signals.hasReturnWriter);
+};

package/dist/transforms-by-id/rename-protobuf-encode-parameters/is-encode-delimited-function-candidate.d.ts

@@ -0,0 +1,4 @@
+import type { NodePath } from "@babel/traverse";
+import type { ArrowFunctionExpression, FunctionExpression } from "@babel/types";
+import type { ProtobufEncodeParameterNames } from "./get-two-identifier-parameter-names.js";
+export declare const isEncodeDelimitedFunctionCandidate: (path: NodePath<FunctionExpression | ArrowFunctionExpression>, parameters: ProtobufEncodeParameterNames) => boolean;

package/dist/transforms-by-id/rename-protobuf-encode-parameters/is-encode-delimited-function-candidate.js

@@ -0,0 +1,69 @@
+const isEncodeDelimitedReturnExpression = (expression, messageParameterName, writerParameterName) => {
+    if (expression.type !== "CallExpression")
+        return false;
+    const ldelimCallee = expression.callee;
+    if (ldelimCallee.type !== "MemberExpression")
+        return false;
+    if (ldelimCallee.computed)
+        return false;
+    if (ldelimCallee.property.type !== "Identifier")
+        return false;
+    if (ldelimCallee.property.name !== "ldelim")
+        return false;
+    const encodeCall = ldelimCallee.object;
+    if (encodeCall.type !== "CallExpression")
+        return false;
+    if (encodeCall.arguments.length !== 2)
+        return false;
+    const [firstArgument, secondArgument] = encodeCall.arguments;
+    if (!firstArgument || !secondArgument)
+        return false;
+    if (firstArgument.type !== "Identifier")
+        return false;
+    if (secondArgument.type !== "Identifier")
+        return false;
+    if (firstArgument.name !== messageParameterName)
+        return false;
+    // Intentionally strict for high-confidence matching: require direct pass-through.
+    if (secondArgument.name !== writerParameterName)
+        return false;
+    const encodeCallee = encodeCall.callee;
+    if (encodeCallee.type !== "MemberExpression")
+        return false;
+    if (encodeCallee.computed)
+        return false;
+    if (encodeCallee.property.type !== "Identifier")
+        return false;
+    if (encodeCallee.property.name !== "encode")
+        return false;
+    // Restrict to the same object contract (`this.encode(...)`) to avoid
+    // misclassifying wrappers like `other.encode(...).ldelim()`.
+    return encodeCallee.object.type === "ThisExpression";
+};
+const getSingleReturnedExpression = (path) => {
+    if (path.isArrowFunctionExpression()) {
+        const bodyPath = path.get("body");
+        if (!bodyPath.isExpression())
+            return undefined;
+        return bodyPath.node;
+    }
+    const bodyPath = path.get("body");
+    if (!bodyPath.isBlockStatement())
+        return undefined;
+    const statements = bodyPath.get("body");
+    if (statements.length !== 1)
+        return undefined;
+    const onlyStatement = statements[0];
+    if (!onlyStatement?.isReturnStatement())
+        return undefined;
+    const argument = onlyStatement.node.argument;
+    if (!argument)
+        return undefined;
+    return argument;
+};
+export const isEncodeDelimitedFunctionCandidate = (path, parameters) => {
+    const returnedExpression = getSingleReturnedExpression(path);
+    if (!returnedExpression)
+        return false;
+    return isEncodeDelimitedReturnExpression(returnedExpression, parameters.messageParameterName, parameters.writerParameterName);
+};

package/dist/transforms-by-id/rename-protobuf-encode-parameters/is-encode-function-candidate.d.ts

@@ -0,0 +1,4 @@
+import type { NodePath } from "@babel/traverse";
+import type { ArrowFunctionExpression, FunctionExpression } from "@babel/types";
+import type { ProtobufEncodeParameterNames } from "./get-two-identifier-parameter-names.js";
+export declare const isEncodeFunctionCandidate: (path: NodePath<FunctionExpression | ArrowFunctionExpression>, parameters: ProtobufEncodeParameterNames) => boolean;

package/dist/transforms-by-id/rename-protobuf-encode-parameters/is-encode-function-candidate.js

@@ -0,0 +1,79 @@
+import { hasProtobufEncodeBodySignals } from "./has-protobuf-encode-body-signals.js";
+const getBlockStatementPath = (path) => {
+    const bodyPath = path.get("body");
+    if (!bodyPath.isBlockStatement())
+        return undefined;
+    return bodyPath;
+};
+const getSingleExpressionStatement = (statement) => {
+    if (statement.type === "ExpressionStatement")
+        return statement;
+    if (statement.type !== "BlockStatement")
+        return undefined;
+    if (statement.body.length !== 1)
+        return undefined;
+    const onlyStatement = statement.body[0];
+    if (!onlyStatement)
+        return undefined;
+    if (onlyStatement.type !== "ExpressionStatement")
+        return undefined;
+    return onlyStatement;
+};
+const isCreateCallExpression = (expression) => {
+    if (expression.type !== "CallExpression")
+        return false;
+    if (expression.arguments.length > 0)
+        return false;
+    const callee = expression.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (callee.property.type !== "Identifier")
+        return false;
+    return callee.property.name === "create";
+};
+const isWriterCreateGuard = (statement, writerParameterName) => {
+    if (statement.alternate)
+        return false;
+    const test = statement.test;
+    if (test.type !== "UnaryExpression")
+        return false;
+    if (test.operator !== "!")
+        return false;
+    if (test.argument.type !== "Identifier")
+        return false;
+    if (test.argument.name !== writerParameterName)
+        return false;
+    const expressionStatement = getSingleExpressionStatement(statement.consequent);
+    if (!expressionStatement)
+        return false;
+    const expression = expressionStatement.expression;
+    if (expression.type !== "AssignmentExpression")
+        return false;
+    if (expression.operator !== "=")
+        return false;
+    if (expression.left.type !== "Identifier")
+        return false;
+    if (expression.left.name !== writerParameterName)
+        return false;
+    return isCreateCallExpression(expression.right);
+};
+export const isEncodeFunctionCandidate = (path, parameters) => {
+    const bodyPath = getBlockStatementPath(path);
+    if (!bodyPath)
+        return false;
+    const statements = bodyPath.get("body");
+    if (statements.length === 0)
+        return false;
+    const hasWriterGuard = statements.some((statementPath) => {
+        if (!statementPath.isIfStatement())
+            return false;
+        return isWriterCreateGuard(statementPath.node, parameters.writerParameterName);
+    });
+    if (!hasWriterGuard)
+        return false;
+    if (!hasProtobufEncodeBodySignals(bodyPath, parameters))
+        return false;
+    return true;
+};

package/dist/transforms-by-id/rename-protobuf-encode-parameters/manifest.json

@@ -0,0 +1,14 @@
+{
+    "notes": "Renames protobufjs encode/encodeDelimited parameters to stable $message/$writer names when writer/create and hasOwnProperty guards indicate generated serializer code.",
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-11T09:32:46.513Z",
+            "changedLines": 690,
+            "durationSeconds": 28.264948625000002,
+            "stableNames": 1359
+        }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
+}

package/dist/transforms-by-id/rename-protobuf-encode-parameters/rename-protobuf-encode-parameters-transform.d.ts

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

package/dist/transforms-by-id/rename-protobuf-encode-parameters/rename-protobuf-encode-parameters-transform.js

@@ -0,0 +1,69 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { getAssignedMemberPropertyName } from "./get-assigned-member-property-name.js";
+import { getTwoIdentifierParameterNames } from "./get-two-identifier-parameter-names.js";
+import { isEncodeDelimitedFunctionCandidate } from "./is-encode-delimited-function-candidate.js";
+import { isEncodeFunctionCandidate } from "./is-encode-function-candidate.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const MESSAGE_BASE_NAME = "message";
+const WRITER_BASE_NAME = "writer";
+const addRenameCandidates = (path, group, nodesVisited) => {
+    nodesVisited.value++;
+    const propertyName = getAssignedMemberPropertyName(path);
+    if (propertyName !== "encode" && propertyName !== "encodeDelimited")
+        return;
+    const parameters = getTwoIdentifierParameterNames(path);
+    if (!parameters)
+        return;
+    if (propertyName === "encode" &&
+        !isEncodeFunctionCandidate(path, parameters)) {
+        return;
+    }
+    if (propertyName === "encodeDelimited" &&
+        !isEncodeDelimitedFunctionCandidate(path, parameters)) {
+        return;
+    }
+    if (!isStableRenamed(parameters.messageParameterName)) {
+        group.add({
+            scope: path.scope,
+            currentName: parameters.messageParameterName,
+            baseName: MESSAGE_BASE_NAME,
+        });
+    }
+    if (!isStableRenamed(parameters.writerParameterName)) {
+        group.add({
+            scope: path.scope,
+            currentName: parameters.writerParameterName,
+            baseName: WRITER_BASE_NAME,
+        });
+    }
+};
+export const renameProtobufEncodeParametersTransform = {
+    id: "rename-protobuf-encode-parameters",
+    description: "Renames protobufjs encode/encodeDelimited parameters to $message/$writer when pattern confidence is high",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const nodesVisited = { value: 0 };
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            traverse(fileInfo.ast, {
+                FunctionExpression(path) {
+                    addRenameCandidates(path, group, nodesVisited);
+                },
+                ArrowFunctionExpression(path) {
+                    addRenameCandidates(path, group, nodesVisited);
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited: nodesVisited.value,
+            transformationsApplied,
+        });
+    },
+};

package/package.json

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