ts-proto 2.4.2 → 2.5.1

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));
                     }
                 }
             }
@@ -737,7 +753,7 @@ function makeTimestampMethods(options, longs, bytes) {
           } else if (typeof o === "string") {
             return ${toTimestamp}(new ${bytes.globalThis}.Date(o));
           } else {
-            return Timestamp.fromJSON(o);
+            return ${options.typePrefix}Timestamp${options.typeSuffix}.fromJSON(o);
           }
         }
       `);
@@ -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;

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.2",
+  "version": "2.5.1",
   "description": "",
   "main": "build/src/plugin.js",
   "repository": "github:stephenh/ts-proto",