ts-proto 2.18.5 → 2.19.0

package/README.markdown

@@ -443,6 +443,12 @@ With `--ts_proto_opt=protoJsonFormat=false`, strict proto3 compliance is disable
 
 - With `--ts_proto_opt=outputPartialMethods=false`, the `Message.fromPartial` and `Message.create` methods for accepting partially-formed objects/object literals will not be output.
 
+- With `--ts_proto_opt=outputStandaloneFunctions=true`, the message methods are output as standalone functions instead of members of a `Message` const, e.g. `Message.encode` becomes `messageEncode` and `Foo_Bar.fromJSON` becomes `foo_BarFromJSON`, following the enum functions.
+
+  This is useful if you want bundlers to tree-shake the functions you don't use.
+
+  This can't be combined with `outputTypeRegistry=true`, `outputTypeAnnotations=static-only`, `outputServices=generic-definitions`, `nestJs=true` or `useMongoObjectId=true`. `outputSchema` leaves messages out of its `references`, and files mapped with `M` options need to be generated with this option as well.
+
 - With `--ts_proto_opt=stringEnums=true`, the generated enum types will be string-based instead of int-based.
 
   This is useful if you want "only types" and are using a gRPC REST Gateway configured to serialize enums as strings.
@@ -493,7 +499,7 @@ With `--ts_proto_opt=protoJsonFormat=false`, strict proto3 compliance is disable
 
 - With `--ts_proto_opt=outputTypeAnnotations=true`, each message will be given a `$type` field containing its fully-qualified name. You can use `--ts_proto_opt=outputTypeAnnotations=static-only` to omit it from the `interface` declaration, or `--ts_proto_opt=outputTypeAnnotations=optional` to make it an optional property on the `interface` definition. The latter option may be useful if you want to use the `$type` field for runtime type checking on responses from a server.
 
-- With `--ts_proto_opt=outputTypeRegistry=true`, the type registry will be generated that can be used to resolve message types by fully-qualified name. Also, each message will be given a `$type` field containing its fully-qualified name.
+- With `--ts_proto_opt=outputTypeRegistry=true`, the type registry will be generated that can be used to resolve message types by fully-qualified name. Also, each message will be given a `$type` field containing its fully-qualified name. The registry's `MessageType` only declares the methods that are generated, so it also works with options like `outputEncodeMethods=encode-only` or `outputJsonMethods=to-only`.
 
 - With `--ts_proto_opt=outputServices=grpc-js`, ts-proto will output service definitions and server / client stubs in [grpc-js](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js) format.
 

package/build/src/encode.js

@@ -5,14 +5,13 @@ exports.generateDecoder = generateDecoder;
 const ts_poet_1 = require("ts-poet");
 const types_1 = require("./types");
 const options_1 = require("./options");
-const utils_1 = require("./utils");
 function generateEncoder(ctx, typeName) {
     const name = (0, types_1.wrapperTypeName)(typeName);
+    const encode = (0, types_1.getMessageMethod)(ctx, typeName, "encode");
     if (!name) {
-        return (0, ts_poet_1.code) `${(0, types_1.messageToTypeName)(ctx, typeName, { keepValueType: true })}.encode(value).finish()`;
+        return (0, ts_poet_1.code) `${encode}(value).finish()`;
     }
     if (name == "Timestamp") {
-        const TimestampValue = (0, utils_1.impProto)(ctx.options, "google/protobuf/timestamp", (0, utils_1.wrapTypeName)(ctx.options, name));
         let value = (0, ts_poet_1.code) `value`;
         if (ctx.options.useDate === options_1.DateOption.DATE ||
             ctx.options.useDate === options_1.DateOption.STRING ||
@@ -20,48 +19,43 @@ function generateEncoder(ctx, typeName) {
             ctx.options.useDate === options_1.DateOption.TEMPORAL) {
             value = (0, ts_poet_1.code) `${ctx.utils.toTimestamp}(${value})`;
         }
-        return (0, ts_poet_1.code) `${TimestampValue}.encode(${value}).finish()`;
+        return (0, ts_poet_1.code) `${encode}(${value}).finish()`;
     }
     if (name == "Struct" || name == "Value") {
-        const StructType = (0, utils_1.impProto)(ctx.options, "google/protobuf/struct", (0, utils_1.wrapTypeName)(ctx.options, name));
-        return (0, ts_poet_1.code) `${StructType}.encode(${StructType}.wrap(value)).finish()`;
+        return (0, ts_poet_1.code) `${encode}(${(0, types_1.getMessageMethod)(ctx, typeName, "wrap")}(value)).finish()`;
     }
     if (name == "ListValue") {
-        const ListValueType = (0, utils_1.impProto)(ctx.options, "google/protobuf/struct", (0, utils_1.wrapTypeName)(ctx.options, name));
-        return (0, ts_poet_1.code) `${ListValueType}.encode({values: value ?? []}).finish()`;
+        return (0, ts_poet_1.code) `${encode}({values: value ?? []}).finish()`;
     }
-    const TypeValue = (0, utils_1.impProto)(ctx.options, "google/protobuf/wrappers", (0, utils_1.wrapTypeName)(ctx.options, name));
     switch (name) {
         case "StringValue":
-            return (0, ts_poet_1.code) `${TypeValue}.encode({value: value ?? ""}).finish()`;
+            return (0, ts_poet_1.code) `${encode}({value: value ?? ""}).finish()`;
         case "Int32Value":
         case "UInt32Value":
         case "DoubleValue":
         case "FloatValue":
-            return (0, ts_poet_1.code) `${TypeValue}.encode({value: value ?? 0}).finish()`;
+            return (0, ts_poet_1.code) `${encode}({value: value ?? 0}).finish()`;
         case "Int64Value":
         case "UInt64Value":
             if (ctx.options.forceLong === options_1.LongOption.LONG) {
-                return (0, ts_poet_1.code) `${TypeValue}.encode({value: value ? value.toNumber(): 0}).finish()`;
+                return (0, ts_poet_1.code) `${encode}({value: value ? value.toNumber(): 0}).finish()`;
             }
-            return (0, ts_poet_1.code) `${TypeValue}.encode({value: value ?? 0 }).finish()`;
+            return (0, ts_poet_1.code) `${encode}({value: value ?? 0 }).finish()`;
         case "BoolValue":
-            return (0, ts_poet_1.code) `${TypeValue}.encode({value: value ?? false}).finish()`;
+            return (0, ts_poet_1.code) `${encode}({value: value ?? false}).finish()`;
         case "BytesValue":
-            return (0, ts_poet_1.code) `${TypeValue}.encode({value: value ?? new Uint8Array(0)}).finish()`;
+            return (0, ts_poet_1.code) `${encode}({value: value ?? new Uint8Array(0)}).finish()`;
     }
     throw new Error(`unknown wrapper type: ${name}`);
 }
 function generateDecoder(ctx, typeName) {
     const { options } = ctx;
     let name = (0, types_1.wrapperTypeName)(typeName);
+    const decoder = (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, typeName, "decode")}(value)`;
     if (!name) {
-        return (0, ts_poet_1.code) `${(0, types_1.messageToTypeName)(ctx, typeName, { keepValueType: true })}.decode(value)`;
+        return decoder;
     }
-    let TypeValue;
     if (name == "Timestamp") {
-        TypeValue = (0, utils_1.impProto)(ctx.options, "google/protobuf/timestamp", (0, utils_1.wrapTypeName)(ctx.options, name));
-        const decoder = (0, ts_poet_1.code) `${TypeValue}.decode(value)`;
         if (ctx.options.useDate === options_1.DateOption.DATE ||
             ctx.options.useDate === options_1.DateOption.STRING ||
             ctx.options.useDate === options_1.DateOption.STRING_NANO ||
@@ -71,9 +65,7 @@ function generateDecoder(ctx, typeName) {
         return decoder;
     }
     if (name == "Struct" || name == "ListValue" || name == "Value") {
-        TypeValue = (0, utils_1.impProto)(ctx.options, "google/protobuf/struct", (0, utils_1.wrapTypeName)(ctx.options, name));
-        return (0, ts_poet_1.code) `${TypeValue}.unwrap(${TypeValue}.decode(value))`;
+        return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, typeName, "unwrap")}(${decoder})`;
     }
-    TypeValue = (0, utils_1.impProto)(ctx.options, "google/protobuf/wrappers", (0, utils_1.wrapTypeName)(ctx.options, name));
-    return (0, ts_poet_1.code) `${TypeValue}.decode(value).value`;
+    return (0, ts_poet_1.code) `${decoder}.value`;
 }

package/build/src/generate-async-iterable.d.ts

@@ -1,6 +1,6 @@
 import { Code } from "ts-poet";
-import { Utils } from "./main";
+import { Context } from "./context";
 /** Creates a function to transform a message Source to a Uint8Array Source. */
-export declare function generateEncodeTransform(utils: Utils, fullName: string): Code;
+export declare function generateEncodeTransform(ctx: Context, fullName: string): Code;
 /** Creates a function to transform a Uint8Array Source to a message Source. */
-export declare function generateDecodeTransform(utils: Utils, fullName: string): Code;
+export declare function generateDecodeTransform(ctx: Context, fullName: string): Code;

package/build/src/generate-async-iterable.js

@@ -3,41 +3,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateEncodeTransform = generateEncodeTransform;
 exports.generateDecodeTransform = generateDecodeTransform;
 const ts_poet_1 = require("ts-poet");
+const utils_1 = require("./utils");
 /** Creates a function to transform a message Source to a Uint8Array Source. */
-function generateEncodeTransform(utils, fullName) {
+function generateEncodeTransform(ctx, fullName) {
     return (0, ts_poet_1.code) `
     // encodeTransform encodes a source of message objects.
     // Transform<${fullName}, Uint8Array>
-    async *encodeTransform(
+    ${(0, utils_1.messageMethodHead)(ctx.options, fullName, "encodeTransform", true)}(
       source: AsyncIterable<${fullName} | ${fullName}[]> | Iterable<${fullName} | ${fullName}[]>
     ): AsyncIterable<Uint8Array> {
       for await (const pkt of source) {
-        if (${utils.globalThis}.Array.isArray(pkt)) {
+        if (${ctx.utils.globalThis}.Array.isArray(pkt)) {
           for (const p of (pkt as any)) {
-            yield* [${fullName}.encode(p).finish()]
+            yield* [${(0, utils_1.localMessageMethod)(ctx.options, fullName, "encode")}(p).finish()]
           }
         } else {
-          yield* [${fullName}.encode(pkt as any).finish()]
+          yield* [${(0, utils_1.localMessageMethod)(ctx.options, fullName, "encode")}(pkt as any).finish()]
         }
       }
     }
   `;
 }
 /** Creates a function to transform a Uint8Array Source to a message Source. */
-function generateDecodeTransform(utils, fullName) {
+function generateDecodeTransform(ctx, fullName) {
     return (0, ts_poet_1.code) `
     // decodeTransform decodes a source of encoded messages.
     // Transform<Uint8Array, ${fullName}>
-    async *decodeTransform(
+    ${(0, utils_1.messageMethodHead)(ctx.options, fullName, "decodeTransform", true)}(
       source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>
     ): AsyncIterable<${fullName}> {
       for await (const pkt of source) {
-        if (${utils.globalThis}.Array.isArray(pkt)) {
+        if (${ctx.utils.globalThis}.Array.isArray(pkt)) {
           for (const p of (pkt as any)) {
-            yield* [${fullName}.decode(p)]
+            yield* [${(0, utils_1.localMessageMethod)(ctx.options, fullName, "decode")}(p)]
           }
         } else {
-          yield* [${fullName}.decode(pkt as any)]
+          yield* [${(0, utils_1.localMessageMethod)(ctx.options, fullName, "decode")}(pkt as any)]
         }
       }
     }

package/build/src/generate-grpc-web.js

@@ -43,7 +43,6 @@ function generateRpcMethod(ctx, serviceDesc, methodDesc) {
     (0, utils_1.assertInstanceOf)(methodDesc, utils_1.FormattedMethodDescriptor);
     const { options } = ctx;
     const { useAbortSignal } = options;
-    const requestMessage = (0, types_1.requestType)(ctx, methodDesc, false);
     const inputType = (0, types_1.requestType)(ctx, methodDesc, true);
     const returns = (0, types_1.responsePromiseOrObservable)(ctx, methodDesc);
     if (methodDesc.clientStreaming) {
@@ -66,7 +65,7 @@ function generateRpcMethod(ctx, serviceDesc, methodDesc) {
     ): ${returns} {
       return this.rpc.${method}(
         ${methodDescName(serviceDesc, methodDesc)},
-        ${requestMessage}.fromPartial(request),
+        ${(0, types_1.getMessageMethod)(ctx, methodDesc.inputType, "fromPartial")}(request),
         metadata,
         ${useAbortSignal ? "abortSignal," : ""}
       );
@@ -89,8 +88,6 @@ function generateGrpcServiceDesc(fileDesc, serviceDesc) {
  * implementation.
  */
 function generateGrpcMethodDesc(ctx, serviceDesc, methodDesc) {
-    const inputType = (0, types_1.requestType)(ctx, methodDesc);
-    const outputType = (0, types_1.responseType)(ctx, methodDesc);
     // grpc-web expects this to be a class, but the ts-proto messages are just interfaces.
     //
     // That said, grpc-web's runtime doesn't really use this (at least so far for what ts-proto
@@ -104,7 +101,7 @@ function generateGrpcMethodDesc(ctx, serviceDesc, methodDesc) {
     // This makes our data look enough like an object/class that grpc-web works just fine.
     const requestFn = (0, ts_poet_1.code) `{
     serializeBinary() {
-      return ${inputType}.encode(this).finish();
+      return ${(0, types_1.getMessageMethod)(ctx, methodDesc.inputType, "encode")}(this).finish();
     },
   }`;
     // grpc-web also expects this to be a class, but with a static `deserializeBinary` method to
@@ -113,7 +110,7 @@ function generateGrpcMethodDesc(ctx, serviceDesc, methodDesc) {
     // we want/what grpc-web's runtime needs.
     const responseFn = (0, ts_poet_1.code) `{
     deserializeBinary(data: Uint8Array) {
-      const value = ${outputType}.decode(data);
+      const value = ${(0, types_1.getMessageMethod)(ctx, methodDesc.outputType, "decode")}(data);
       return {
         ...value,
         toObject() { return value; },

package/build/src/generate-services.js

@@ -78,9 +78,7 @@ function generateRegularRpcMethod(ctx, methodDesc) {
     (0, utils_1.assertInstanceOf)(methodDesc, utils_1.FormattedMethodDescriptor);
     const { options } = ctx;
     const BinaryReader = (0, ts_poet_1.imp)("BinaryReader@@bufbuild/protobuf/wire");
-    const rawInputType = (0, types_1.rawRequestType)(ctx, methodDesc, { keepValueType: true });
     const inputType = (0, types_1.requestType)(ctx, methodDesc);
-    const rawOutputType = (0, types_1.responseType)(ctx, methodDesc, { keepValueType: true });
     const metadataType = options.metadataType ? (0, ts_poet_1.imp)(options.metadataType) : (0, ts_poet_1.imp)("t:Metadata@@grpc/grpc-js");
     const params = [
         ...(options.context ? [(0, ts_poet_1.code) `ctx: Context`] : []),
@@ -100,7 +98,7 @@ function generateRegularRpcMethod(ctx, methodDesc) {
       return Promise.reject(error);
     `;
     }
-    let encode = (0, ts_poet_1.code) `${rawInputType}.encode(request).finish()`;
+    let encode = (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, methodDesc.inputType, "encode")}(request).finish()`;
     let beforeRequest;
     if (options.rpcBeforeRequest && !methodDesc.clientStreaming) {
         beforeRequest = generateBeforeRequest(methodDesc.name);
@@ -108,10 +106,10 @@ function generateRegularRpcMethod(ctx, methodDesc) {
     else if (methodDesc.clientStreaming && options.rpcBeforeRequest) {
         encode = (0, ts_poet_1.code) `{const encodedRequest = ${encode}; ${generateBeforeRequest(methodDesc.name, "encodedRequest")}; return encodedRequest}`;
     }
-    let decode = (0, ts_poet_1.code) `${rawOutputType}.decode(new ${BinaryReader}(data))`;
+    let decode = (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, methodDesc.outputType, "decode")}(new ${BinaryReader}(data))`;
     if (options.rpcAfterResponse) {
         decode = (0, ts_poet_1.code) `
-      const response = ${rawOutputType}.decode(new ${BinaryReader}(data));
+      const response = ${decode};
       if (this.rpc.afterResponse) {
         this.rpc.afterResponse(this.service, "${methodDesc.name}", response);
       }
@@ -123,7 +121,7 @@ function generateRegularRpcMethod(ctx, methodDesc) {
     // }
     if (methodDesc.clientStreaming) {
         if (options.useAsyncIterable) {
-            encode = (0, ts_poet_1.code) `${rawInputType}.encodeTransform(request)`;
+            encode = (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, methodDesc.inputType, "encodeTransform")}(request)`;
         }
         else {
             encode = (0, ts_poet_1.code) `request.pipe(${(0, ts_poet_1.imp)("map@rxjs/operators")}(request => ${encode}))`;
@@ -175,11 +173,10 @@ function generateBeforeRequest(methodName, requestVariableName = "request") {
 }
 function createDefaultServiceReturn(ctx, methodDesc, decode, errorHandler) {
     const { options } = ctx;
-    const rawOutputType = (0, types_1.responseType)(ctx, methodDesc, { keepValueType: true });
     const returnStatement = (0, utils_1.arrowFunction)("data", decode, !options.rpcAfterResponse);
     if (options.returnObservable || methodDesc.serverStreaming) {
         if (options.useAsyncIterable) {
-            return (0, ts_poet_1.code) `${rawOutputType}.decodeTransform(result)`;
+            return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, methodDesc.outputType, "decodeTransform")}(result)`;
         }
         else {
             if (errorHandler) {
@@ -302,9 +299,9 @@ function generateCachingRpcMethod(ctx, fileDesc, serviceDesc, methodDesc) {
     const lambda = (0, ts_poet_1.code) `
     (requests) => {
       const responses = requests.map(async request => {
-        const data = ${inputType}.encode(request).finish()
+        const data = ${(0, types_1.getMessageMethod)(ctx, methodDesc.inputType, "encode")}(request).finish()
         const response = await this.rpc.request(ctx, "${(0, utils_1.maybePrefixPackage)(fileDesc, serviceDesc.name)}", "${methodDesc.name}", data);
-        return ${outputType}.decode(new ${BinaryReader}(response));
+        return ${(0, types_1.getMessageMethod)(ctx, methodDesc.outputType, "decode")}(new ${BinaryReader}(response));
       });
       return Promise.all(responses);
     }

package/build/src/generate-struct-wrappers.js

@@ -164,7 +164,7 @@ function generateWrapShallow(ctx, fullProtoTypeName, fieldNames) {
         }
         if (ctx.options.useOptionals !== "all")
             defaultFields = "";
-        chunks.push((0, ts_poet_1.code) `wrap(object: {[key: string]: any} | undefined): ${(0, utils_1.wrapTypeName)(ctx.options, "Struct")} {
+        chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "Struct", "wrap")}(object: {[key: string]: any} | undefined): ${(0, utils_1.wrapTypeName)(ctx.options, "Struct")} {
       const struct = createBase${(0, utils_1.wrapTypeName)(ctx.options, "Struct")}();
       ${defaultFields}
       if (object !== undefined) {
@@ -177,7 +177,7 @@ function generateWrapShallow(ctx, fullProtoTypeName, fieldNames) {
     }
     if ((0, types_1.isAnyValueTypeName)(fullProtoTypeName)) {
         if (ctx.options.oneof === options_1.OneofOption.UNIONS) {
-            chunks.push((0, ts_poet_1.code) `wrap(value: any): ${(0, utils_1.wrapTypeName)(ctx.options, "Value")} {
+            chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "Value", "wrap")}(value: any): ${(0, utils_1.wrapTypeName)(ctx.options, "Value")} {
         const result = createBase${(0, utils_1.wrapTypeName)(ctx.options, "Value")}()${maybeAsAny(ctx.options)};
         if (value === null) {
           result.kind = {$case: '${fieldNames.nullValue}', ${fieldNames.nullValue}: ${(0, utils_1.wrapTypeName)(ctx.options, "NullValue", "enum")}.NULL_VALUE};
@@ -198,7 +198,7 @@ function generateWrapShallow(ctx, fullProtoTypeName, fieldNames) {
     }`);
         }
         else if (ctx.options.oneof === options_1.OneofOption.UNIONS_VALUE) {
-            chunks.push((0, ts_poet_1.code) `wrap(value: any): ${(0, utils_1.wrapTypeName)(ctx.options, "Value")} {
+            chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "Value", "wrap")}(value: any): ${(0, utils_1.wrapTypeName)(ctx.options, "Value")} {
         const result = createBase${(0, utils_1.wrapTypeName)(ctx.options, "Value")}()${maybeAsAny(ctx.options)};
         if (value === null) {
           result.kind = {$case: '${fieldNames.nullValue}', value: ${(0, utils_1.wrapTypeName)(ctx.options, "NullValue", "enum")}.NULL_VALUE};
@@ -219,7 +219,7 @@ function generateWrapShallow(ctx, fullProtoTypeName, fieldNames) {
     }`);
         }
         else {
-            chunks.push((0, ts_poet_1.code) `wrap(value: any): ${(0, utils_1.wrapTypeName)(ctx.options, "Value")} {
+            chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "Value", "wrap")}(value: any): ${(0, utils_1.wrapTypeName)(ctx.options, "Value")} {
         const result = createBase${(0, utils_1.wrapTypeName)(ctx.options, "Value")}()${maybeAsAny(ctx.options)};
         if (value === null) {
           result.${fieldNames.nullValue} = ${(0, utils_1.wrapTypeName)(ctx.options, "NullValue", "enum")}.NULL_VALUE;
@@ -242,14 +242,14 @@ function generateWrapShallow(ctx, fullProtoTypeName, fieldNames) {
     }
     if ((0, types_1.isListValueTypeName)(fullProtoTypeName)) {
         const maybeReadyOnly = ctx.options.useReadonlyTypes ? "Readonly" : "";
-        chunks.push((0, ts_poet_1.code) `wrap(array: ${maybeReadyOnly}Array<any> | undefined): ${(0, utils_1.wrapTypeName)(ctx.options, "ListValue")} {
+        chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "ListValue", "wrap")}(array: ${maybeReadyOnly}Array<any> | undefined): ${(0, utils_1.wrapTypeName)(ctx.options, "ListValue")} {
       const result = createBase${(0, utils_1.wrapTypeName)(ctx.options, "ListValue")}()${maybeAsAny(ctx.options)};
       result.values = array ?? [];
       return result;
     }`);
     }
     if ((0, types_1.isFieldMaskTypeName)(fullProtoTypeName)) {
-        chunks.push((0, ts_poet_1.code) `wrap(paths: ${maybeReadonly(ctx.options)} string[]): ${(0, utils_1.wrapTypeName)(ctx.options, "FieldMask")} {
+        chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "FieldMask", "wrap")}(paths: ${maybeReadonly(ctx.options)} string[]): ${(0, utils_1.wrapTypeName)(ctx.options, "FieldMask")} {
       const result = createBase${(0, utils_1.wrapTypeName)(ctx.options, "FieldMask")}()${maybeAsAny(ctx.options)};
       result.paths = paths;
       return result;
@@ -266,7 +266,7 @@ function generateUnwrapShallow(ctx, fullProtoTypeName, fieldNames) {
     const chunks = [];
     if ((0, types_1.isStructTypeName)(fullProtoTypeName)) {
         if (ctx.options.useMapType) {
-            chunks.push((0, ts_poet_1.code) `unwrap(message: ${(0, utils_1.wrapTypeName)(ctx.options, "Struct")}): {[key: string]: any} {
+            chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "Struct", "unwrap")}(message: ${(0, utils_1.wrapTypeName)(ctx.options, "Struct")}): {[key: string]: any} {
         const object: { [key: string]: any } = {};
         if (message.fields) {
           for (const key of message.fields.keys()) {
@@ -277,7 +277,7 @@ function generateUnwrapShallow(ctx, fullProtoTypeName, fieldNames) {
       }`);
         }
         else {
-            chunks.push((0, ts_poet_1.code) `unwrap(message: ${(0, utils_1.wrapTypeName)(ctx.options, "Struct")}): {[key: string]: any} {
+            chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "Struct", "unwrap")}(message: ${(0, utils_1.wrapTypeName)(ctx.options, "Struct")}): {[key: string]: any} {
         const object: { [key: string]: any } = {};
         if (message.fields) {
           for (const key of ${ctx.utils.globalThis}.Object.keys(message.fields)) {
@@ -290,7 +290,7 @@ function generateUnwrapShallow(ctx, fullProtoTypeName, fieldNames) {
     }
     if ((0, types_1.isAnyValueTypeName)(fullProtoTypeName)) {
         if (ctx.options.oneof === options_1.OneofOption.UNIONS) {
-            chunks.push((0, ts_poet_1.code) `unwrap(message: ${(0, utils_1.wrapTypeName)(ctx.options, "Value")}): string | number | boolean | Object | null | Array<any> | undefined {
+            chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "Value", "unwrap")}(message: ${(0, utils_1.wrapTypeName)(ctx.options, "Value")}): string | number | boolean | Object | null | Array<any> | undefined {
         if (message.kind?.$case === '${fieldNames.nullValue}') {
           return null;
         } else if (message.kind?.$case === '${fieldNames.numberValue}') {
@@ -309,12 +309,12 @@ function generateUnwrapShallow(ctx, fullProtoTypeName, fieldNames) {
       }`);
         }
         else if (ctx.options.oneof === options_1.OneofOption.UNIONS_VALUE) {
-            chunks.push((0, ts_poet_1.code) `unwrap(message: ${(0, utils_1.wrapTypeName)(ctx.options, "Value")}): string | number | boolean | Object | null | Array<any> | undefined {
+            chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "Value", "unwrap")}(message: ${(0, utils_1.wrapTypeName)(ctx.options, "Value")}): string | number | boolean | Object | null | Array<any> | undefined {
         return (message.kind?.$case === '${fieldNames.nullValue}') ? null : message.kind?.value;
       }`);
         }
         else {
-            chunks.push((0, ts_poet_1.code) `unwrap(message: any): string | number | boolean | Object | null | Array<any> | undefined {
+            chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "Value", "unwrap")}(message: any): string | number | boolean | Object | null | Array<any> | undefined {
         if (message.${fieldNames.stringValue} !== undefined) {
           return message.${fieldNames.stringValue};
         } else if (message?.${fieldNames.numberValue} !== undefined) {
@@ -333,7 +333,7 @@ function generateUnwrapShallow(ctx, fullProtoTypeName, fieldNames) {
         }
     }
     if ((0, types_1.isListValueTypeName)(fullProtoTypeName)) {
-        chunks.push((0, ts_poet_1.code) `unwrap(message: ${ctx.options.useReadonlyTypes ? "any" : (0, utils_1.wrapTypeName)(ctx.options, "ListValue")}): Array<any> {
+        chunks.push((0, ts_poet_1.code) `${methodHead(ctx, "ListValue", "unwrap")}(message: ${ctx.options.useReadonlyTypes ? "any" : (0, utils_1.wrapTypeName)(ctx.options, "ListValue")}): Array<any> {
       if (message?.hasOwnProperty('values') && ${ctx.utils.globalThis}.Array.isArray(message.values)) {
         return message.values;
       } else {
@@ -349,10 +349,13 @@ function generateUnwrapShallow(ctx, fullProtoTypeName, fieldNames) {
 function generateFieldMaskUnwrap(ctx) {
     const returnType = ctx.options.useOptionals === "all" ? "string[] | undefined" : "string[]";
     const pathModifier = ctx.options.useOptionals === "all" ? "?" : "";
-    return (0, ts_poet_1.code) `unwrap(message: ${ctx.options.useReadonlyTypes ? "any" : (0, utils_1.wrapTypeName)(ctx.options, "FieldMask")}): ${returnType} {
+    return (0, ts_poet_1.code) `${methodHead(ctx, "FieldMask", "unwrap")}(message: ${ctx.options.useReadonlyTypes ? "any" : (0, utils_1.wrapTypeName)(ctx.options, "FieldMask")}): ${returnType} {
     return message${pathModifier}.paths;
   }`;
 }
+function methodHead(ctx, name, method) {
+    return (0, utils_1.messageMethodHead)(ctx.options, (0, utils_1.wrapTypeName)(ctx.options, name), method);
+}
 function maybeReadonly(options) {
     return options.useReadonlyTypes ? "readonly " : "";
 }

package/build/src/generate-type-registry.js

@@ -33,14 +33,25 @@ function generateMessageType(ctx) {
     else {
         chunks.push((0, ts_poet_1.code) `$type: string;`);
     }
-    if (ctx.options.outputEncodeMethods) {
-        const BinaryReader = (0, ts_poet_1.imp)("t:BinaryReader@@bufbuild/protobuf/wire");
-        const BinaryWriter = (0, ts_poet_1.imp)("t:BinaryWriter@@bufbuild/protobuf/wire");
+    // Only declare the methods that are actually generated on each message, e.g. with
+    // `outputJsonMethods=to-only` the messages have no `fromJSON` to register.
+    const { outputEncodeMethods, outputJsonMethods } = ctx.options;
+    const hasEncode = outputEncodeMethods === true ||
+        outputEncodeMethods === "encode-only" ||
+        outputEncodeMethods === "encode-no-creation";
+    const hasDecode = outputEncodeMethods === true || outputEncodeMethods === "decode-only";
+    const BinaryReader = (0, ts_poet_1.imp)("t:BinaryReader@@bufbuild/protobuf/wire");
+    const BinaryWriter = (0, ts_poet_1.imp)("t:BinaryWriter@@bufbuild/protobuf/wire");
+    if (hasEncode) {
         chunks.push((0, ts_poet_1.code) `encode(message: Message, writer?: ${BinaryWriter}): ${BinaryWriter};`);
+    }
+    if (hasDecode) {
         chunks.push((0, ts_poet_1.code) `decode(input: ${BinaryReader} | Uint8Array, length?: number): Message;`);
     }
-    if (ctx.options.outputJsonMethods) {
+    if (outputJsonMethods === true || outputJsonMethods === "from-only") {
         chunks.push((0, ts_poet_1.code) `fromJSON(object: any): Message;`);
+    }
+    if (outputJsonMethods === true || outputJsonMethods === "to-only") {
         chunks.push((0, ts_poet_1.code) `toJSON(message: Message): unknown;`);
     }
     if (ctx.options.outputPartialMethods) {

package/build/src/main.js

@@ -103,13 +103,18 @@ function generateFile(ctx, fileDesc) {
             }
             const staticMembers = [];
             const hasTypeMember = options.outputTypeAnnotations || options.outputTypeRegistry;
-            if (hasTypeMember) {
+            if (hasTypeMember && !options.outputStandaloneFunctions) {
                 staticMembers.push((0, ts_poet_1.code) `$type: '${fullTypeName}' as const`);
             }
             if (options.outputExtensions) {
                 for (const extension of message.extension) {
                     const { name, type, extensionInfo } = generateExtension(ctx, message, extension);
-                    staticMembers.push((0, ts_poet_1.code) `${name}: <${ctx.utils.Extension}<${type}>> ${extensionInfo}`);
+                    if (options.outputStandaloneFunctions) {
+                        staticMembers.push((0, ts_poet_1.code) `export const ${(0, ts_poet_1.def)((0, utils_1.messageFunctionName)(fullName, name))}: ${ctx.utils.Extension}<${type}> = ${extensionInfo};`);
+                    }
+                    else {
+                        staticMembers.push((0, ts_poet_1.code) `${name}: <${ctx.utils.Extension}<${type}>> ${extensionInfo}`);
+                    }
                 }
             }
             if (options.outputEncodeMethods) {
@@ -124,7 +129,7 @@ function generateFile(ctx, fileDesc) {
                         }
                     }
                     else if (options.outputEncodeMethods === true) {
-                        staticMembers.push(generateEmptyEncode(fullName));
+                        staticMembers.push(generateEmptyEncode(ctx, fullName));
                     }
                 }
                 if (options.outputEncodeMethods === true || options.outputEncodeMethods === "decode-only") {
@@ -136,13 +141,13 @@ function generateFile(ctx, fileDesc) {
                         }
                     }
                     else if (options.outputEncodeMethods === true) {
-                        staticMembers.push(generateEmptyDecode(fullName));
+                        staticMembers.push(generateEmptyDecode(ctx, fullName));
                     }
                 }
             }
             if (options.useAsyncIterable) {
-                staticMembers.push((0, generate_async_iterable_1.generateEncodeTransform)(ctx.utils, fullName));
-                staticMembers.push((0, generate_async_iterable_1.generateDecodeTransform)(ctx.utils, fullName));
+                staticMembers.push((0, generate_async_iterable_1.generateEncodeTransform)(ctx, fullName));
+                staticMembers.push((0, generate_async_iterable_1.generateDecodeTransform)(ctx, fullName));
             }
             if (options.outputJsonMethods) {
                 if (options.outputJsonMethods === true || options.outputJsonMethods === "from-only") {
@@ -171,7 +176,10 @@ function generateFile(ctx, fileDesc) {
                 staticMembers.push(...(0, generate_struct_wrappers_1.generateWrapShallow)(ctx, fullTypeName, structFieldNames));
                 staticMembers.push(...(0, generate_struct_wrappers_1.generateUnwrapShallow)(ctx, fullTypeName, structFieldNames));
             }
-            if (staticMembers.length > 0) {
+            if (options.outputStandaloneFunctions) {
+                chunks.push(...staticMembers);
+            }
+            else if (staticMembers.length > 0) {
                 const messageFnsTypeParameters = [fullName, hasTypeMember && `'${fullTypeName}'`]
                     .filter((p) => !!p)
                     .join(", ");
@@ -694,7 +702,7 @@ function makeObjectIdMethods() {
     return { fromJsonObjectId, fromProtoObjectId, toProtoObjectId };
 }
 function makeTimestampMethods(options, longs, bytes) {
-    const Timestamp = (0, utils_1.impProto)(options, "google/protobuf/timestamp", (0, utils_1.wrapTypeName)(options, "Timestamp"));
+    const Timestamp = (0, utils_1.impProto)(options, "google/protobuf/timestamp", (0, utils_1.wrapTypeName)(options, "Timestamp"), options.outputStandaloneFunctions);
     const NanoDate = (0, ts_poet_1.imp)("NanoDate=nano-date");
     let seconds = "Math.trunc(date.getTime() / 1_000)";
     let toNumberCode = "t.seconds";
@@ -800,6 +808,7 @@ function makeTimestampMethods(options, longs, bytes) {
         `);
     // Declared once per file, so the regex isn't compiled on each fromJsonTimestamp call
     const timestampFractionRegex = (0, ts_poet_1.conditionalOutput)("timestampFractionRegex", (0, ts_poet_1.code) `const timestampFractionRegex = /:\\d{2}\\.\\d+/;`);
+    const timestampMessageFromJson = (0, utils_1.impProtoMethod)(options, "google/protobuf/timestamp", (0, utils_1.wrapTypeName)(options, "Timestamp"), "fromJSON");
     const fromJsonTimestamp = (0, ts_poet_1.conditionalOutput)("fromJsonTimestamp", options.useDate === options_1.DateOption.DATE
         ? (0, ts_poet_1.code) `
         function fromJsonTimestamp(o: any): Date {
@@ -808,7 +817,7 @@ function makeTimestampMethods(options, longs, bytes) {
           } else if (typeof o === "string") {
             return new ${bytes.globalThis}.Date(o);
           } else {
-            return ${fromTimestamp}(${(0, utils_1.wrapTypeName)(options, "Timestamp")}.fromJSON(o));
+            return ${fromTimestamp}(${timestampMessageFromJson}(o));
           }
         }
       `
@@ -820,7 +829,7 @@ function makeTimestampMethods(options, longs, bytes) {
             } else if (typeof o === "string") {
               return ${bytes.globalThis}.Temporal.Instant.from(o);
             } else {
-              return ${fromTimestamp}(${(0, utils_1.wrapTypeName)(options, "Timestamp")}.fromJSON(o));
+              return ${fromTimestamp}(${timestampMessageFromJson}(o));
             }
           }
         `
@@ -842,7 +851,7 @@ function makeTimestampMethods(options, longs, bytes) {
             );
             return { ...timestamp, nanos: (timestamp.nanos ?? 0) + (fractionNanos % 1_000_000) };
           } else {
-            return ${options.typePrefix}Timestamp${options.typeSuffix}.fromJSON(o);
+            return ${timestampMessageFromJson}(o);
           }
         }
       `);
@@ -1123,14 +1132,13 @@ function getDecodeReadSnippet(ctx, field) {
         }
     }
     else if ((0, types_1.isValueType)(ctx, field)) {
-        const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
         const unwrap = (decodedValue) => {
             if ((0, types_1.isListValueType)(field) || (0, types_1.isStructType)(field) || (0, types_1.isAnyValueType)(field) || (0, types_1.isFieldMaskType)(field)) {
-                return (0, ts_poet_1.code) `${type}.unwrap(${decodedValue})`;
+                return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, field.typeName, "unwrap")}(${decodedValue})`;
             }
             return (0, ts_poet_1.code) `${decodedValue}.value`;
         };
-        const decoder = (0, ts_poet_1.code) `${type}.decode(reader, reader.uint32())`;
+        const decoder = (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, field.typeName, "decode")}(reader, reader.uint32())`;
         readSnippet = (0, ts_poet_1.code) `${unwrap(decoder)}`;
     }
     else if ((0, types_1.isTimestamp)(field) &&
@@ -1138,20 +1146,20 @@ function getDecodeReadSnippet(ctx, field) {
             options.useDate === options_1.DateOption.STRING ||
             options.useDate === options_1.DateOption.STRING_NANO ||
             options.useDate === options_1.DateOption.TEMPORAL)) {
-        const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-        readSnippet = (0, ts_poet_1.code) `${utils.fromTimestamp}(${type}.decode(reader, reader.uint32()))`;
+        const decode = (0, types_1.getMessageMethod)(ctx, field.typeName, "decode");
+        readSnippet = (0, ts_poet_1.code) `${utils.fromTimestamp}(${decode}(reader, reader.uint32()))`;
     }
     else if ((0, types_1.isObjectId)(field) && options.useMongoObjectId) {
         const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
         readSnippet = (0, ts_poet_1.code) `${utils.fromProtoObjectId}(${type}.decode(reader, reader.uint32()))`;
     }
     else if ((0, types_1.isMessage)(field)) {
-        const type = (0, types_1.basicTypeName)(ctx, field);
+        const decode = (0, types_1.getMessageMethod)(ctx, field.typeName, "decode");
         if (field.type == ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP) {
-            readSnippet = (0, ts_poet_1.code) `${type}.decode(reader)`;
+            readSnippet = (0, ts_poet_1.code) `${decode}(reader)`;
         }
         else {
-            readSnippet = (0, ts_poet_1.code) `${type}.decode(reader, reader.uint32())`;
+            readSnippet = (0, ts_poet_1.code) `${decode}(reader, reader.uint32())`;
         }
     }
     else {
@@ -1159,10 +1167,10 @@ function getDecodeReadSnippet(ctx, field) {
     }
     return readSnippet;
 }
-function generateEmptyDecode(fullName) {
+function generateEmptyDecode(ctx, fullName) {
     const BinaryReader = (0, ts_poet_1.imp)("t:BinaryReader@@bufbuild/protobuf/wire");
     return (0, ts_poet_1.code) `
-    decode(
+    ${(0, utils_1.messageMethodHead)(ctx.options, fullName, "decode")}(
       _: ${BinaryReader} | Uint8Array,
       length?: number,
     ): ${fullName} {
@@ -1181,7 +1189,7 @@ function generateDecode(ctx, fullName, messageDesc) {
     const BinaryReader = (0, ts_poet_1.imp)("BinaryReader@@bufbuild/protobuf/wire");
     // create the basic function declaration
     chunks.push((0, ts_poet_1.code) `
-    decode(
+    ${(0, utils_1.messageMethodHead)(options, fullName, "decode")}(
       input: ${BinaryReader} | Uint8Array,
       length?: number,
     ): ${fullName} {
@@ -1411,38 +1419,38 @@ function getEncodeWriteSnippet(ctx, field) {
             options.useDate === options_1.DateOption.STRING_NANO ||
             options.useDate === options_1.DateOption.TEMPORAL)) {
         const tag = ((field.number << 3) | 2) >>> 0;
-        const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-        return (place) => (0, ts_poet_1.code) `${type}.encode(${utils.toTimestamp}(${place}), writer.uint32(${tag}).fork()).join()`;
+        const encode = (0, types_1.getMessageMethod)(ctx, field.typeName, "encode");
+        return (place) => (0, ts_poet_1.code) `${encode}(${utils.toTimestamp}(${place}), writer.uint32(${tag}).fork()).join()`;
     }
     else if ((0, types_1.isValueType)(ctx, field)) {
         const maybeTypeField = (0, options_1.addTypeToMessages)(options) ? `$type: '${field.typeName.slice(1)}',` : "";
-        const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
+        const encode = (0, types_1.getMessageMethod)(ctx, field.typeName, "encode");
         const wrappedValue = (place) => {
             if ((0, types_1.isAnyValueType)(field) || (0, types_1.isListValueType)(field) || (0, types_1.isStructType)(field) || (0, types_1.isFieldMaskType)(field)) {
-                return (0, ts_poet_1.code) `${type}.wrap(${place})`;
+                return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, field.typeName, "wrap")}(${place})`;
             }
             return (0, ts_poet_1.code) `{${maybeTypeField} value: ${place}!}`;
         };
         const tag = ((field.number << 3) | 2) >>> 0;
-        return (place) => (0, ts_poet_1.code) `${type}.encode(${wrappedValue(place)}, writer.uint32(${tag}).fork()).join()`;
+        return (place) => (0, ts_poet_1.code) `${encode}(${wrappedValue(place)}, writer.uint32(${tag}).fork()).join()`;
     }
     else if ((0, types_1.isMessage)(field)) {
-        const type = (0, types_1.basicTypeName)(ctx, field);
+        const encode = (0, types_1.getMessageMethod)(ctx, field.typeName, "encode");
         if (field.type == ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP) {
             const startTag = ((field.number << 3) | 3) >>> 0, endTag = ((field.number << 3) | 4) >>> 0;
-            return (place) => (0, ts_poet_1.code) `${type}.encode(${place}, writer.uint32(${startTag})).uint32(${endTag})`;
+            return (place) => (0, ts_poet_1.code) `${encode}(${place}, writer.uint32(${startTag})).uint32(${endTag})`;
         }
         const tag = ((field.number << 3) | 2) >>> 0;
-        return (place) => (0, ts_poet_1.code) `${type}.encode(${place}, writer.uint32(${tag}).fork()).join()`;
+        return (place) => (0, ts_poet_1.code) `${encode}(${place}, writer.uint32(${tag}).fork()).join()`;
     }
     else {
         throw new Error(`Unhandled field ${field}`);
     }
 }
-function generateEmptyEncode(fullName) {
+function generateEmptyEncode(ctx, fullName) {
     const BinaryWriter = (0, ts_poet_1.imp)("BinaryWriter@@bufbuild/protobuf/wire");
     return (0, ts_poet_1.code) `
-  encode(
+  ${(0, utils_1.messageMethodHead)(ctx.options, fullName, "encode")}(
     _: ${fullName},
     writer: ${BinaryWriter} = new ${BinaryWriter}(),
   ): ${BinaryWriter} {
@@ -1457,7 +1465,7 @@ function generateEncode(ctx, fullName, messageDesc) {
     const BinaryWriter = (0, ts_poet_1.imp)("BinaryWriter@@bufbuild/protobuf/wire");
     // create the basic function declaration
     chunks.push((0, ts_poet_1.code) `
-    encode(
+    ${(0, utils_1.messageMethodHead)(options, fullName, "encode")}(
       ${messageDesc.field.length > 0 || options.unknownFields ? "message" : "_"}: ${fullName},
       writer: ${BinaryWriter} = new ${BinaryWriter}(),
     ): ${BinaryWriter} {
@@ -1673,7 +1681,7 @@ function generateEncode(ctx, fullName, messageDesc) {
 }
 function generateSetExtension(ctx, fullName) {
     return (0, ts_poet_1.code) `
-    setExtension <T> (message: ${fullName}, extension: ${ctx.utils.Extension}<T>, value: T): void {
+    ${(0, utils_1.messageMethodHead)(ctx.options, fullName, "setExtension")} <T> (message: ${fullName}, extension: ${ctx.utils.Extension}<T>, value: T): void {
       const encoded = extension.encode!(value);
 
       if (message._unknownFields !== undefined) {
@@ -1699,7 +1707,7 @@ function generateSetExtension(ctx, fullName) {
 }
 function generateGetExtension(ctx, fullName) {
     return (0, ts_poet_1.code) `
-    getExtension <T> (message: ${fullName}, extension: ${ctx.utils.Extension}<T>): T | undefined {
+    ${(0, utils_1.messageMethodHead)(ctx.options, fullName, "getExtension")} <T> (message: ${fullName}, extension: ${ctx.utils.Extension}<T>): T | undefined {
       let results: T | undefined = undefined;
 
       if (message._unknownFields === undefined) {
@@ -1787,27 +1795,27 @@ function generateExtension(ctx, message, extension) {
                     options.useDate === options_1.DateOption.STRING ||
                     options.useDate === options_1.DateOption.STRING_NANO ||
                     options.useDate === options_1.DateOption.TEMPORAL)) {
-                const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-                return (place) => (0, ts_poet_1.code) `${type}.encode(${utils.toTimestamp}(${place}), writer.fork()).join()`;
+                const encode = (0, types_1.getMessageMethod)(ctx, field.typeName, "encode");
+                return (place) => (0, ts_poet_1.code) `${encode}(${utils.toTimestamp}(${place}), writer.fork()).join()`;
             }
             else if ((0, types_1.isValueType)(ctx, field)) {
                 const maybeTypeField = (0, options_1.addTypeToMessages)(options) ? `$type: '${field.typeName.slice(1)}',` : "";
-                const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
+                const encode = (0, types_1.getMessageMethod)(ctx, field.typeName, "encode");
                 const wrappedValue = (place) => {
                     if ((0, types_1.isAnyValueType)(field) || (0, types_1.isListValueType)(field) || (0, types_1.isStructType)(field) || (0, types_1.isFieldMaskType)(field)) {
-                        return (0, ts_poet_1.code) `${type}.wrap(${place})`;
+                        return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, field.typeName, "wrap")}(${place})`;
                     }
                     return (0, ts_poet_1.code) `{${maybeTypeField} value: ${place}!}`;
                 };
-                return (place) => (0, ts_poet_1.code) `${type}.encode(${wrappedValue(place)}, writer.fork()).join()`;
+                return (place) => (0, ts_poet_1.code) `${encode}(${wrappedValue(place)}, writer.fork()).join()`;
             }
             else if ((0, types_1.isMessage)(field)) {
-                const type = (0, types_1.basicTypeName)(ctx, field);
+                const encode = (0, types_1.getMessageMethod)(ctx, field.typeName, "encode");
                 if (field.type == ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP) {
                     const endTag = ((field.number << 3) | 4) >>> 0;
-                    return (place) => (0, ts_poet_1.code) `${type}.encode(${place}, writer).uint32(${endTag})`;
+                    return (place) => (0, ts_poet_1.code) `${encode}(${place}, writer).uint32(${endTag})`;
                 }
-                return (place) => (0, ts_poet_1.code) `${type}.encode(${place}, writer.fork()).join()`;
+                return (place) => (0, ts_poet_1.code) `${encode}(${place}, writer.fork()).join()`;
             }
             else {
                 throw new Error(`Unhandled field ${field}`);
@@ -1962,7 +1970,7 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
                 break;
         }
         return (0, ts_poet_1.code) `
-      fromJSON(object: string): ${fullName} {
+      ${(0, utils_1.messageMethodHead)(options, fullName, "fromJSON")}(object: string): ${fullName} {
         if (!object.endsWith("s")) throw new Error("Invalid duration string");
         const body = object.slice(0, -1);
         const negative = body.startsWith("-");
@@ -1982,21 +1990,21 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
     if (fullTypeName === "google.protobuf.Timestamp") {
         // The canonical JSON of a Timestamp is an RFC 3339 string; the object form is still accepted.
         chunks.push((0, ts_poet_1.code) `
-      fromJSON(object: any): ${fullName} {
+      ${(0, utils_1.messageMethodHead)(options, fullName, "fromJSON")}(object: any): ${fullName} {
         if (typeof object === "string") {
-          return ${fullName}.fromJSON(${utils.timestampFromJson}(object));
+          return ${(0, utils_1.localMessageMethod)(options, fullName, "fromJSON")}(${utils.timestampFromJson}(object));
         }
         return {
     `);
     }
     else {
         chunks.push((0, ts_poet_1.code) `
-      fromJSON(${messageDesc.field.length > 0 ? "object" : "_"}: any): ${fullName} {
+      ${(0, utils_1.messageMethodHead)(options, fullName, "fromJSON")}(${messageDesc.field.length > 0 ? "object" : "_"}: any): ${fullName} {
         return {
     `);
     }
     if ((0, options_1.addTypeToMessages)(options)) {
-        chunks.push((0, ts_poet_1.code) `$type: ${fullName}.$type,`);
+        chunks.push(options.outputStandaloneFunctions ? (0, ts_poet_1.code) `$type: '${fullTypeName}',` : (0, ts_poet_1.code) `$type: ${fullName}.$type,`);
     }
     const oneofFieldsCases = messageDesc.oneofDecl.map((oneof, oneofIndex) => messageDesc.field.filter(types_1.isWithinOneOf).filter((field) => field.oneofIndex === oneofIndex));
     const canonicalFromJson = {
@@ -2065,8 +2073,9 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
                 return (0, ts_poet_1.code) `${from}`;
             }
             else if ((0, types_1.isFieldMaskType)(field)) {
-                const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-                return (0, ts_poet_1.code) `${type}.unwrap(${type}.fromJSON(${from}))`;
+                const unwrap = (0, types_1.getMessageMethod)(ctx, field.typeName, "unwrap");
+                const fromJson = (0, types_1.getMessageMethod)(ctx, field.typeName, "fromJSON");
+                return (0, ts_poet_1.code) `${unwrap}(${fromJson}(${from}))`;
             }
             else if ((0, types_1.isListValueType)(field)) {
                 return (0, ts_poet_1.code) `[...${from}]`;
@@ -2125,12 +2134,11 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
                         return (0, ts_poet_1.code) `${from}`;
                     }
                     else {
-                        return (0, ts_poet_1.code) `${valueType}.fromJSON(${from})`;
+                        return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, valueField.typeName, "fromJSON")}(${from})`;
                     }
                 }
                 else {
-                    const type = (0, types_1.basicTypeName)(ctx, field);
-                    return (0, ts_poet_1.code) `${type}.fromJSON(${from})`;
+                    return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, field.typeName, "fromJSON")}(${from})`;
                 }
             }
             else {
@@ -2300,12 +2308,13 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
     chunks.push((0, ts_poet_1.code) `}`);
     return (0, ts_poet_1.joinCode)(chunks, { on: "\n" });
 }
-function generateCanonicalToJson(fullName, fullProtobufTypeName, { useOptionals, useNullAsOptional, useDuration, useJsonTimestamp, forceLong }, utils) {
+function generateCanonicalToJson(fullName, fullProtobufTypeName, options, utils) {
+    const { useOptionals, useNullAsOptional, useDuration, useJsonTimestamp, forceLong } = options;
     if ((0, types_1.isFieldMaskTypeName)(fullProtobufTypeName)) {
         const returnType = useOptionals === "all" ? `string | ${(0, utils_1.nullOrUndefined)({ useNullAsOptional })}` : "string";
         const pathModifier = useOptionals === "all" ? "?" : "";
         return (0, ts_poet_1.code) `
-    toJSON(message: ${fullName}): ${returnType} {
+    ${(0, utils_1.messageMethodHead)(options, fullName, "toJSON")}(message: ${fullName}): ${returnType} {
       return message.paths${pathModifier}.join(',');
     }
   `;
@@ -2334,7 +2343,7 @@ function generateCanonicalToJson(fullName, fullProtobufTypeName, { useOptionals,
                 break;
         }
         return (0, ts_poet_1.code) `
-    toJSON(message: ${fullName}): string {
+    ${(0, utils_1.messageMethodHead)(options, fullName, "toJSON")}(message: ${fullName}): string {
       const negative = ${isNegSeconds} || message.nanos < 0;
       const sign = negative ? "-" : "";
       const absSeconds = ${absSeconds};
@@ -2351,7 +2360,7 @@ function generateCanonicalToJson(fullName, fullProtobufTypeName, { useOptionals,
             ? (0, ts_poet_1.code) `message.seconds?.toNumber() ?? 0`
             : (0, ts_poet_1.code) `${utils.globalThis}.Number(message.seconds ?? 0)`;
         return (0, ts_poet_1.code) `
-    toJSON(message: ${fullName}): string {
+    ${(0, utils_1.messageMethodHead)(options, fullName, "toJSON")}(message: ${fullName}): string {
       return ${utils.timestampToJson}(${seconds}, message.nanos ?? 0);
     }
     `;
@@ -2381,7 +2390,7 @@ function generateCanonicalAnyToJson(ctx, fullName, messageDesc) {
     const typeUrl = (0, utils_1.getPropertyAccessor)("message", (0, utils_1.getFieldName)(typeUrlField, options));
     const value = (0, utils_1.getPropertyAccessor)("message", (0, utils_1.getFieldName)(valueField, options));
     return (0, ts_poet_1.code) `
-    toJSON(message: ${fullName}): unknown {
+    ${(0, utils_1.messageMethodHead)(options, fullName, "toJSON")}(message: ${fullName}): unknown {
       const typeUrl = ${typeUrl} ?? "";
       if (typeUrl === "") {
         return {};
@@ -2408,7 +2417,7 @@ function generateCanonicalAnyFromJson(ctx, fullName, messageDesc) {
     const typeField = (0, options_1.addTypeToMessages)(options) ? (0, ts_poet_1.code) `$type: ${fullName}.$type,` : "";
     const bytes = options.env === options_1.EnvOption.NODE ? (0, ts_poet_1.code) `Buffer.from(bytes)` : (0, ts_poet_1.code) `bytes`;
     return (0, ts_poet_1.code) `
-    fromJSON(object: any): ${fullName} {
+    ${(0, utils_1.messageMethodHead)(options, fullName, "fromJSON")}(object: any): ${fullName} {
       const typeUrl = ${utils.isSet}(object?.["@type"]) ? ${utils.globalThis}.String(object["@type"]) : "";
       if (typeUrl === "") {
         return { ${typeField} ${typeUrlKey}: ${(0, types_1.defaultValue)(ctx, typeUrlField)}, ${valueKey}: ${(0, types_1.defaultValue)(ctx, valueField)} };
@@ -2442,7 +2451,7 @@ function generateToJson(ctx, fullName, fullProtobufTypeName, messageDesc) {
     }
     // create the basic function declaration
     chunks.push((0, ts_poet_1.code) `
-    toJSON(${messageDesc.field.length > 0 ? "message" : "_"}: ${fullName}): unknown {
+    ${(0, utils_1.messageMethodHead)(options, fullName, "toJSON")}(${messageDesc.field.length > 0 ? "message" : "_"}: ${fullName}): unknown {
       const obj: any = {};
   `);
     let currentIfTarget = "";
@@ -2528,20 +2537,19 @@ function generateToJson(ctx, fullName, fullProtobufTypeName, messageDesc) {
                     return (0, ts_poet_1.code) `${from}`;
                 }
                 else {
-                    const type = (0, types_1.basicTypeName)(ctx, valueType);
-                    return (0, ts_poet_1.code) `${type}.toJSON(${from})`;
+                    return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, valueType.typeName, "toJSON")}(${from})`;
                 }
             }
             else if ((0, types_1.isAnyValueType)(field)) {
                 return (0, ts_poet_1.code) `${from}`;
             }
             else if ((0, types_1.isFieldMaskType)(field)) {
-                const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-                return (0, ts_poet_1.code) `${type}.toJSON(${type}.wrap(${from}))`;
+                const toJson = (0, types_1.getMessageMethod)(ctx, field.typeName, "toJSON");
+                const wrap = (0, types_1.getMessageMethod)(ctx, field.typeName, "wrap");
+                return (0, ts_poet_1.code) `${toJson}(${wrap}(${from}))`;
             }
             else if ((0, types_1.isMessage)(field) && !(0, types_1.isValueType)(ctx, field) && !(0, types_1.isMapType)(ctx, messageDesc, field)) {
-                const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-                return (0, ts_poet_1.code) `${type}.toJSON(${from})`;
+                return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, field.typeName, "toJSON")}(${from})`;
             }
             else if ((0, types_1.isBytes)(field)) {
                 return (0, ts_poet_1.code) `${utils.base64FromBytes}(${from})`;
@@ -2641,31 +2649,32 @@ function generateToJson(ctx, fullName, fullProtobufTypeName, messageDesc) {
 function generateFromPartial(ctx, fullName, messageDesc) {
     const { options, utils } = ctx;
     const chunks = [];
+    const maybeComma = options.outputStandaloneFunctions ? "" : ",";
     // create the create function definition
     if (ctx.options.useExactTypes) {
         chunks.push((0, ts_poet_1.code) `
-      create<I extends ${utils.Exact}<${utils.DeepPartial}<${fullName}>, I>>(base?: I): ${fullName} {
-        return ${fullName}.fromPartial(base ?? ({} as any));
-      },
+      ${(0, utils_1.messageMethodHead)(options, fullName, "create")}<I extends ${utils.Exact}<${utils.DeepPartial}<${fullName}>, I>>(base?: I): ${fullName} {
+        return ${(0, utils_1.localMessageMethod)(options, fullName, "fromPartial")}(base ?? ({} as any));
+      }${maybeComma}
     `);
     }
     else {
         chunks.push((0, ts_poet_1.code) `
-      create(base?: ${utils.DeepPartial}<${fullName}>): ${fullName} {
-        return ${fullName}.fromPartial(base ?? {});
-      },
+      ${(0, utils_1.messageMethodHead)(options, fullName, "create")}(base?: ${utils.DeepPartial}<${fullName}>): ${fullName} {
+        return ${(0, utils_1.localMessageMethod)(options, fullName, "fromPartial")}(base ?? {});
+      }${maybeComma}
     `);
     }
     // create the fromPartial function declaration
     const paramName = messageDesc.field.length > 0 ? "object" : "_";
     if (ctx.options.useExactTypes) {
         chunks.push((0, ts_poet_1.code) `
-      fromPartial<I extends ${utils.Exact}<${utils.DeepPartial}<${fullName}>, I>>(${paramName}: I): ${fullName} {
+      ${(0, utils_1.messageMethodHead)(options, fullName, "fromPartial")}<I extends ${utils.Exact}<${utils.DeepPartial}<${fullName}>, I>>(${paramName}: I): ${fullName} {
     `);
     }
     else {
         chunks.push((0, ts_poet_1.code) `
-      fromPartial(${paramName}: ${utils.DeepPartial}<${fullName}>): ${fullName} {
+      ${(0, utils_1.messageMethodHead)(options, fullName, "fromPartial")}(${paramName}: ${utils.DeepPartial}<${fullName}>): ${fullName} {
     `);
     }
     let createBase = (0, ts_poet_1.code) `createBase${fullName}()`;
@@ -2745,16 +2754,14 @@ function generateFromPartial(ctx, fullName, messageDesc) {
                         return (0, ts_poet_1.code) `${from}`;
                     }
                     else {
-                        const type = (0, types_1.basicTypeName)(ctx, valueField);
-                        return (0, ts_poet_1.code) `${type}.fromPartial(${from})`;
+                        return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, valueField.typeName, "fromPartial")}(${from})`;
                     }
                 }
                 else if ((0, types_1.isAnyValueType)(field)) {
                     return (0, ts_poet_1.code) `${from}`;
                 }
                 else {
-                    const type = (0, types_1.basicTypeName)(ctx, field);
-                    return (0, ts_poet_1.code) `${type}.fromPartial(${from})`;
+                    return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, field.typeName, "fromPartial")}(${from})`;
                 }
             }
             else {

package/build/src/options.d.ts

@@ -69,6 +69,7 @@ export type Options = {
     outputDecodeIncludeTypes: string;
     outputJsonMethods: true | false | "to-only" | "from-only";
     outputPartialMethods: boolean;
+    outputStandaloneFunctions: boolean;
     outputTypeAnnotations: boolean | "static-only" | "optional";
     outputTypeRegistry: boolean;
     stringEnums: boolean;

package/build/src/options.js

@@ -86,6 +86,7 @@ function defaultOptions() {
         outputDecodeIncludeTypes: "",
         outputJsonMethods: true,
         outputPartialMethods: true,
+        outputStandaloneFunctions: false,
         outputTypeAnnotations: false,
         outputTypeRegistry: false,
         stringEnums: false,
@@ -262,6 +263,14 @@ function optionsFromParameter(parameter) {
         // Make sure to cast number options to an actual number
         options.unrecognizedEnumValue = Number(options.unrecognizedEnumValue);
     }
+    if (options.outputStandaloneFunctions &&
+        (options.outputTypeRegistry ||
+            options.outputTypeAnnotations === "static-only" ||
+            options.outputServices.includes(ServiceOption.GENERIC) ||
+            options.nestJs ||
+            options.useMongoObjectId)) {
+        throw new Error("outputStandaloneFunctions=true can't be used with outputTypeRegistry=true, outputTypeAnnotations=static-only, outputServices=generic-definitions, nestJs=true, or useMongoObjectId=true");
+    }
     return options;
 }
 // A very naive parse function, eventually could/should use iots/runtypes

package/build/src/schema.js

@@ -61,7 +61,7 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
         references.push((0, ts_poet_1.code) `'.${(0, utils_1.maybePrefixPackage)(fileDesc, localName.replace(/_/g, "."))}': ${symbol}`);
     }
     (0, visit_1.visit)(fileDesc, sourceInfo, (fullName) => {
-        if (options.outputEncodeMethods) {
+        if (options.outputEncodeMethods && !options.outputStandaloneFunctions) {
             addReference(fullName, fullName);
         }
     }, options, (fullName) => {
@@ -147,7 +147,7 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
 }
 function getExtensionValue(ctx, extension, data) {
     if (extension.type == ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE) {
-        const typeName = (0, types_1.basicTypeName)(ctx, extension);
+        const decode = (0, types_1.getMessageMethod)(ctx, extension.typeName, "decode");
         const resultBuffer = Buffer.concat(data.map((d) => {
             // Skip length byte
             const bytes = new wire_1.BinaryReader(d).bytes();
@@ -157,7 +157,7 @@ function getExtensionValue(ctx, extension, data) {
         const encoded = ctx.options.env === options_1.EnvOption.NODE
             ? (0, ts_poet_1.code) `Buffer.from('${result}', 'base64')`
             : (0, ts_poet_1.code) `${ctx.utils.bytesFromBase64}("${result}")`;
-        return (0, ts_poet_1.code) `'${extension.name}': ${typeName}.decode(${encoded})`;
+        return (0, ts_poet_1.code) `'${extension.name}': ${decode}(${encoded})`;
     }
     else {
         const reader = new wire_1.BinaryReader(data[0]);

package/build/src/types.d.ts

@@ -59,6 +59,7 @@ export declare function messageToTypeName(ctx: Context, protoType: string, typeO
     repeated?: boolean;
 }): Code;
 export declare function getEnumMethod(ctx: Context, enumProtoType: string, methodSuffix: string): Import;
+export declare function getMessageMethod(ctx: Context, messageProtoType: string, method: string): Code;
 /** Return the TypeName for any field (primitive/message/etc.) as exposed in the interface. */
 export declare function toTypeName(ctx: Context, messageDesc: DescriptorProto | undefined, field: FieldDescriptorProto, ensureOptional?: boolean): Code;
 /**

package/build/src/types.js

@@ -41,6 +41,7 @@ exports.valueTypeName = valueTypeName;
 exports.wrapperTypeName = wrapperTypeName;
 exports.messageToTypeName = messageToTypeName;
 exports.getEnumMethod = getEnumMethod;
+exports.getMessageMethod = getMessageMethod;
 exports.toTypeName = toTypeName;
 exports.shouldGenerateJSMapType = shouldGenerateJSMapType;
 exports.detectMapType = detectMapType;
@@ -645,8 +646,8 @@ function messageToTypeName(ctx, protoType, typeOptions = {}) {
     if (!typeOptions.keepValueType && options.useMongoObjectId && protoType.endsWith(".ObjectId")) {
         return (0, ts_poet_1.code) `mongodb.ObjectId`;
     }
-    const [module, type] = toModuleAndType(typeMap, protoType);
-    return (0, ts_poet_1.code) `${(0, utils_1.impProto)(options, module, type)}`;
+    const [module, type, descriptor] = toModuleAndType(typeMap, protoType);
+    return (0, ts_poet_1.code) `${(0, utils_1.impProto)(options, module, type, options.outputStandaloneFunctions && "field" in descriptor)}`;
 }
 /** Breaks `.some_proto_namespace.Some.Message` into `['some_proto_namespace', 'Some_Message', Descriptor]. */
 function toModuleAndType(typeMap, protoType) {
@@ -656,6 +657,10 @@ function getEnumMethod(ctx, enumProtoType, methodSuffix) {
     const [module, type] = toModuleAndType(ctx.typeMap, enumProtoType);
     return (0, utils_1.impProto)(ctx.options, module, `${(0, case_1.uncapitalize)(type)}${methodSuffix}`);
 }
+function getMessageMethod(ctx, messageProtoType, method) {
+    const [module, type] = toModuleAndType(ctx.typeMap, messageProtoType);
+    return (0, utils_1.impProtoMethod)(ctx.options, module, type, method);
+}
 /** Return the TypeName for any field (primitive/message/etc.) as exposed in the interface. */
 function toTypeName(ctx, messageDesc, field, ensureOptional = false) {
     function finalize(type, isOptional) {

package/build/src/utils.d.ts

@@ -65,7 +65,11 @@ export declare function safeAccessor(propertyName: string): string;
  */
 export declare function getPropertyAccessor(objectName: string, propertyName: string, optional?: boolean): string;
 export declare function impFile(options: Options, spec: string): Import;
-export declare function impProto(options: Options, module: string, type: string): Import;
+export declare function impProto(options: Options, module: string, type: string, typeOnly?: boolean): Import;
+export declare function messageFunctionName(type: string, method: string): string;
+export declare function impProtoMethod(options: Options, module: string, type: string, method: string): Code;
+export declare function localMessageMethod(options: Options, type: string, method: string): string;
+export declare function messageMethodHead(options: Options, type: string, method: string, isAsyncGenerator?: boolean): Code;
 export declare function tryCatchBlock(tryBlock: Code | string, handleErrorBlock: Code | string): Code;
 export declare function arrowFunction(params: string, body: Code | string, isOneLine?: boolean): Code;
 export declare function nullOrUndefined(options: Pick<Options, "useNullAsOptional">, hasProto3Optional?: boolean): string;

package/build/src/utils.js

@@ -17,6 +17,10 @@ exports.safeAccessor = safeAccessor;
 exports.getPropertyAccessor = getPropertyAccessor;
 exports.impFile = impFile;
 exports.impProto = impProto;
+exports.messageFunctionName = messageFunctionName;
+exports.impProtoMethod = impProtoMethod;
+exports.localMessageMethod = localMessageMethod;
+exports.messageMethodHead = messageMethodHead;
 exports.tryCatchBlock = tryCatchBlock;
 exports.arrowFunction = arrowFunction;
 exports.nullOrUndefined = nullOrUndefined;
@@ -243,14 +247,32 @@ function getPropertyAccessor(objectName, propertyName, optional = false) {
 function impFile(options, spec) {
     return (0, ts_poet_1.imp)(`${spec}${options.importSuffix}`);
 }
-function impProto(options, module, type) {
-    const prefix = options.onlyTypes ? "t:" : "";
+function impProto(options, module, type, typeOnly = false) {
+    const prefix = options.onlyTypes || typeOnly ? "t:" : "";
     const protoFile = `${module}.proto`;
     if (options.M[protoFile]) {
         return (0, ts_poet_1.imp)(`${prefix}${type}@${options.M[protoFile]}`);
     }
     return (0, ts_poet_1.imp)(`${prefix}${type}@./${module}${options.fileSuffix}${options.importSuffix}`);
 }
+function messageFunctionName(type, method) {
+    return (0, case_1.uncapitalize)(type) + (0, case_1.capitalize)(method);
+}
+function impProtoMethod(options, module, type, method) {
+    if (options.outputStandaloneFunctions) {
+        return (0, ts_poet_1.code) `${impProto(options, module, messageFunctionName(type, method))}`;
+    }
+    return (0, ts_poet_1.code) `${impProto(options, module, type)}.${method}`;
+}
+function localMessageMethod(options, type, method) {
+    return options.outputStandaloneFunctions ? messageFunctionName(type, method) : `${type}.${method}`;
+}
+function messageMethodHead(options, type, method, isAsyncGenerator = false) {
+    if (options.outputStandaloneFunctions) {
+        return (0, ts_poet_1.code) `export ${isAsyncGenerator ? "async function*" : "function"} ${(0, ts_poet_1.def)(messageFunctionName(type, method))}`;
+    }
+    return (0, ts_poet_1.code) `${isAsyncGenerator ? "async *" : ""}${method}`;
+}
 function tryCatchBlock(tryBlock, handleErrorBlock) {
     return (0, ts_poet_1.code) `try {
     ${tryBlock}

package/package.json

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