ts-proto 2.4.1 → 2.5.0

package/README.markdown

@@ -408,6 +408,14 @@ Generated code will be placed in the Gradle build directory.
 
   This is useful if you want "only types".
 
+- With `--ts_proto_opt=outputEncodeIncludeTypes=regex`, the `Message.encode` method will only be output for types whose name matches the provided regular expression.
+
+  This is useful if you want to limit `encode` methods to only select types.
+
+- With `--ts_proto_opt=outputDecodeIncludeTypes=regex`, the `Message.decode` method will only be output for types whose name matches the provided regular expression.
+
+  This is useful if you want to limit `decode` methods to only select types.
+
 - With `--ts_proto_opt=outputJsonMethods=false`, the `Message.fromJSON` and `Message.toJSON` methods for working with JSON-coded data will not be output.
 
   This is also useful if you want "only types".

package/build/src/main.js

@@ -90,7 +90,11 @@ function generateFile(ctx, fileDesc) {
             const fullTypeName = (0, utils_1.maybePrefixPackage)(fileDesc, fullProtoTypeName);
             const outputWrapAndUnwrap = (0, generate_struct_wrappers_1.isWrapperType)(fullTypeName);
             // Only decode, fromPartial, and wrap use the createBase method
-            if ((options.outputEncodeMethods && options.outputEncodeMethods !== "encode-no-creation") ||
+            if ((options.outputEncodeMethods &&
+                options.outputEncodeMethods !== "encode-no-creation" &&
+                options.outputEncodeMethods !== "encode-only" &&
+                (options.outputDecodeIncludeTypes === "" ||
+                    new RegExp(options.outputDecodeIncludeTypes).test(fullTypeName))) ||
                 options.outputPartialMethods ||
                 outputWrapAndUnwrap) {
                 chunks.push(generateBaseInstanceFactory(ctx, fullName, message, fullTypeName));
@@ -110,15 +114,27 @@ function generateFile(ctx, fileDesc) {
                 if (options.outputEncodeMethods === true ||
                     options.outputEncodeMethods === "encode-only" ||
                     options.outputEncodeMethods === "encode-no-creation") {
-                    staticMembers.push(generateEncode(ctx, fullName, message));
-                    if (options.outputExtensions && options.unknownFields && message.extensionRange.length) {
-                        staticMembers.push(generateSetExtension(ctx, fullName));
+                    if (options.outputEncodeIncludeTypes === "" ||
+                        new RegExp(options.outputEncodeIncludeTypes).test(fullTypeName)) {
+                        staticMembers.push(generateEncode(ctx, fullName, message));
+                        if (options.outputExtensions && options.unknownFields && message.extensionRange.length) {
+                            staticMembers.push(generateSetExtension(ctx, fullName));
+                        }
+                    }
+                    else if (options.outputEncodeMethods === true) {
+                        staticMembers.push(generateEmptyEncode(fullName));
                     }
                 }
                 if (options.outputEncodeMethods === true || options.outputEncodeMethods === "decode-only") {
-                    staticMembers.push(generateDecode(ctx, fullName, message));
-                    if (options.outputExtensions && options.unknownFields && message.extensionRange.length) {
-                        staticMembers.push(generateGetExtension(ctx, fullName));
+                    if (options.outputDecodeIncludeTypes === "" ||
+                        new RegExp(options.outputDecodeIncludeTypes).test(fullTypeName)) {
+                        staticMembers.push(generateDecode(ctx, fullName, message));
+                        if (options.outputExtensions && options.unknownFields && message.extensionRange.length) {
+                            staticMembers.push(generateGetExtension(ctx, fullName));
+                        }
+                    }
+                    else if (options.outputEncodeMethods === true) {
+                        staticMembers.push(generateEmptyDecode(fullName));
                     }
                 }
             }
@@ -992,6 +1008,17 @@ function getDecodeReadSnippet(ctx, field) {
     }
     return readSnippet;
 }
+function generateEmptyDecode(fullName) {
+    const BinaryReader = (0, ts_poet_1.imp)("BinaryReader@@bufbuild/protobuf/wire");
+    return (0, ts_poet_1.code) `
+    decode(
+      _: ${BinaryReader} | Uint8Array,
+      length?: number,
+    ): ${fullName} {
+      throw new Error('decode not generated for ${fullName}');
+    }
+  `;
+}
 /** Creates a function to decode a message by loop overing the tags. */
 function generateDecode(ctx, fullName, messageDesc) {
     const { options, currentFile } = ctx;
@@ -1251,6 +1278,17 @@ function getEncodeWriteSnippet(ctx, field) {
         throw new Error(`Unhandled field ${field}`);
     }
 }
+function generateEmptyEncode(fullName) {
+    const BinaryWriter = (0, ts_poet_1.imp)("BinaryWriter@@bufbuild/protobuf/wire");
+    return (0, ts_poet_1.code) `
+  encode(
+    _: ${fullName},
+    writer: ${BinaryWriter} = new ${BinaryWriter}(),
+  ): ${BinaryWriter} {
+    throw new Error('encode not generated for ${fullName}');
+  }
+  `;
+}
 /** Creates a function to encode a message by loop overing the tags. */
 function generateEncode(ctx, fullName, messageDesc) {
     const { options, utils, typeMap, currentFile } = ctx;
@@ -2178,12 +2216,17 @@ function generateFromPartial(ctx, fullName, messageDesc) {
         createBase = (0, ts_poet_1.code) `Object.create(${createBase}) as ${fullName}`;
     }
     chunks.push((0, ts_poet_1.code) `const message = ${createBase}${maybeAsAny(options)};`);
-    let currentIfTarget = "";
+    let currentSwitchTarget;
     // add a check for each incoming field
     messageDesc.field.forEach((field) => {
         const fieldName = (0, utils_1.getFieldName)(field, options);
         const messageProperty = (0, utils_1.getPropertyAccessor)("message", fieldName);
         const objectProperty = (0, utils_1.getPropertyAccessor)("object", fieldName);
+        if (currentSwitchTarget && !(0, types_1.isWithinOneOfThatShouldBeUnion)(options, field)) {
+            // We are exiting a switch, we need to close it
+            chunks.push((0, ts_poet_1.code) `}`);
+            currentSwitchTarget = undefined;
+        }
         const readSnippet = (from) => {
             if (((0, types_1.isLong)(field) || (0, types_1.isLongValueType)(field)) &&
                 options.forceLong === options_1.LongOption.LONG &&
@@ -2300,16 +2343,24 @@ function generateFromPartial(ctx, fullName, messageDesc) {
             const oneofNameWithObject = (0, utils_1.getPropertyAccessor)("object", oneofName);
             const valueName = (0, utils_1.oneofValueName)(fieldName, options);
             const v = readSnippet(`${oneofNameWithObject}.${valueName}`);
+            // If we are entering a new switch, close the previous one
+            if (currentSwitchTarget !== undefined && currentSwitchTarget !== oneofNameWithObject) {
+                chunks.push((0, ts_poet_1.code) `}`);
+                currentSwitchTarget = undefined;
+            }
+            if (currentSwitchTarget === undefined) {
+                chunks.push((0, ts_poet_1.code) `switch (${oneofNameWithObject}?.$case) {`);
+            }
             chunks.push((0, ts_poet_1.code) `
-        ${currentIfTarget === oneofNameWithObject ? "else " : ""}if (
-          ${oneofNameWithObject}?.$case === '${fieldName}'
-          && ${oneofNameWithObject}?.${valueName} !== undefined
-          && ${oneofNameWithObject}?.${valueName} !== null
-        ) {
-          ${oneofNameWithMessage} = { $case: '${fieldName}', ${valueName}: ${v} };
+        case '${fieldName}': {
+          if (${oneofNameWithObject}?.${valueName} !== undefined
+              && ${oneofNameWithObject}?.${valueName} !== null) {
+            ${oneofNameWithMessage} = { $case: '${fieldName}', ${valueName}: ${v} };
+          }
+          break;
         }
       `);
-            currentIfTarget = oneofNameWithObject;
+            currentSwitchTarget = oneofNameWithObject;
         }
         else if (readSnippet(`x`).toCodeString([]) == "x") {
             // An optimized case of the else below that works when `readSnippet` returns the plain input
@@ -2325,6 +2376,11 @@ function generateFromPartial(ctx, fullName, messageDesc) {
       `);
         }
     });
+    if (currentSwitchTarget) {
+        // We are exiting a switch, we need to close it
+        chunks.push((0, ts_poet_1.code) `}`);
+        currentSwitchTarget = "";
+    }
     // and then wrap up the switch/while/return
     chunks.push((0, ts_poet_1.code) `return message;`);
     chunks.push((0, ts_poet_1.code) `}`);

package/build/src/options.d.ts

@@ -53,6 +53,8 @@ export type Options = {
     fileSuffix: string;
     importSuffix: string;
     outputEncodeMethods: true | false | "encode-only" | "decode-only" | "encode-no-creation";
+    outputEncodeIncludeTypes: string;
+    outputDecodeIncludeTypes: string;
     outputJsonMethods: true | false | "to-only" | "from-only";
     outputPartialMethods: boolean;
     outputTypeAnnotations: boolean | "static-only" | "optional";

package/build/src/options.js

@@ -68,6 +68,8 @@ function defaultOptions() {
         importSuffix: "",
         lowerCaseServiceMethods: false,
         outputEncodeMethods: true,
+        outputEncodeIncludeTypes: "",
+        outputDecodeIncludeTypes: "",
         outputJsonMethods: true,
         outputPartialMethods: true,
         outputTypeAnnotations: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-proto",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "",
   "main": "build/src/plugin.js",
   "repository": "github:stephenh/ts-proto",