@aptre/protobuf-es-lite 0.2.15 → 0.3.1

package/LICENSE

@@ -188,7 +188,7 @@
       identification within third-party archives.
 
    Copyright 2024 Aperture Robotics, LLC.
-   Copyright 2021-2023 Buf Technologies, Inc.
+   Copyright 2021-2024 Buf Technologies, Inc.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -1,11 +1,7 @@
 ## protobuf-es-lite
 
-[![GoDoc Widget]][GoDoc] [![Go Report Card Widget]][Go Report Card]
-
-[GoDoc]: https://godoc.org/github.com/aperturerobotics/protobuf-es-lite
-[GoDoc Widget]: https://godoc.org/github.com/aperturerobotics/protobuf-es-lite?status.svg
-[Go Report Card Widget]: https://goreportcard.com/badge/github.com/aperturerobotics/protobuf-es-lite
-[Go Report Card]: https://goreportcard.com/report/github.com/aperturerobotics/protobuf-es-lite
+[![npm version](https://img.shields.io/npm/v/@aptre/protobuf-es-lite.svg)](https://www.npmjs.com/package/@aptre/protobuf-es-lite)
+[![npm downloads](https://img.shields.io/npm/dm/@aptre/protobuf-es-lite.svg)](https://www.npmjs.com/package/@aptre/protobuf-es-lite)
 
 protobuf-es-lite is a TypeScript and JavaScript protobuf implementation.
 
@@ -33,11 +29,12 @@ Lightweight Protobuf 3 RPCs are implemented in [StaRPC] for Go and TypeScript.
 
 ## Purpose
 
-The main protoc-gen-es generates a class for each message type. Partial messages
-or plain messages are available with the PartialMessage and PlainMessage
-typescript types. The problem with this is that most js applications would
-usually construct and pass around PlainMessage in most cases, so we end up
-having to write the PlainMessage type very frequently:
+[protobuf-es] generates a class for each message with interfaces for partial or
+plain messages. It is significantly easier to construct and pass around plain
+and partial messages as opposed to using classes, and plain messages work better
+when used in React props/state. This ends up looking like:
+
+[protobuf-es]: https://github.com/bufbuild/protobuf-es
 
 ```typescript
 const myMessage: PlainMessage<MyMessage> = {body: "Hello world"}
@@ -46,12 +43,10 @@ const myMessageBin = new MyMessage(myMessage).toBinary()
 
 [ts-proto] generates an interface for each protobuf message and a const message
 declaration object containing the marshal and unmarshal functions. This allows
-using interfaces and plain messages everywhere and does not need classes.
+using interfaces and plain messages everywhere:
 
 [ts-proto]: https://github.com/stephenh/ts-proto
 
-This fork generates the ts-proto style with the protoc-gen-es tools:
-
 ```typescript
 // Create a partial MyMessage with just one field sets.
 const myMessage: MyMessage = {body: "Hello world"}
@@ -61,7 +56,7 @@ const myCompleteMessage: MyMessage = MyMessage.create(myMessage)
 const myMessageBin = MyMessage.toBinary(myCompleteMessage)
 ```
 
-**Note that the default Message is equivalent to PartialMessage<T> from protobuf-es.**
+This fork generates the ts-proto style with the protobuf-es code generator.
 
 ## Installation
 

package/dist/binary.d.ts

@@ -33,7 +33,9 @@ export interface BinaryWriteOptions {
      */
     writerFactory: () => IBinaryWriter;
 }
-export declare function readField(target: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+declare function makeReadOptions(options?: Partial<BinaryReadOptions>): Readonly<BinaryReadOptions>;
+declare function makeWriteOptions(options?: Partial<BinaryWriteOptions>): Readonly<BinaryWriteOptions>;
+declare function readField(target: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
 reader: IBinaryReader, field: FieldInfo, wireType: WireType, options: BinaryReadOptions): void;
 /**
  * AnyMessage is an interface implemented by all messages. If you need to
@@ -43,19 +45,20 @@ reader: IBinaryReader, field: FieldInfo, wireType: WireType, options: BinaryRead
 type AnyMessage = {
     [k: string]: any;
 };
-export declare function readMapEntry(field: FieldInfo & {
+declare function readMapEntry(field: FieldInfo & {
     kind: "map";
 }, reader: IBinaryReader, options: BinaryReadOptions): [string | number, ScalarValue | AnyMessage | undefined];
-export declare function readScalar(reader: IBinaryReader, type: ScalarType): ScalarValue;
-export declare function readScalarLTString(reader: IBinaryReader, type: ScalarType): Exclude<ScalarValue, bigint>;
-export declare function makeReadOptions(options?: Partial<BinaryReadOptions>): Readonly<BinaryReadOptions>;
-export declare function makeWriteOptions(options?: Partial<BinaryWriteOptions>): Readonly<BinaryWriteOptions>;
-export declare function readMessage<T>(message: T, fields: FieldList, reader: IBinaryReader, lengthOrEndTagFieldNo: number, options: BinaryReadOptions, delimitedMessageEncoding?: boolean): void;
+declare function readScalar(reader: IBinaryReader, type: ScalarType): ScalarValue;
+declare function readScalarLTString(reader: IBinaryReader, type: ScalarType): Exclude<ScalarValue, bigint>;
+declare function readMessage<T>(message: T, fields: FieldList, reader: IBinaryReader, lengthOrEndTagFieldNo: number, options: BinaryReadOptions, delimitedMessageEncoding?: boolean): void;
 /**
  * Serialize a message to binary data.
  */
-export declare function writeMessage<T>(message: T, fields: FieldList, writer: IBinaryWriter, options: BinaryWriteOptions): void;
-export declare function writeMapEntry(writer: IBinaryWriter, options: BinaryWriteOptions, field: FieldInfo & {
+declare function writeMessage<T>(message: T, fields: FieldList, writer: IBinaryWriter, options: BinaryWriteOptions): void;
+declare function writeField<T>(field: FieldInfo, value: T, writer: IBinaryWriter, options: BinaryWriteOptions): void;
+declare function writeScalar(writer: IBinaryWriter, type: ScalarType, fieldNo: number, value: unknown): void;
+declare function writePacked<T>(writer: IBinaryWriter, type: ScalarType, fieldNo: number, value: T[]): void;
+declare function writeMapEntry(writer: IBinaryWriter, options: BinaryWriteOptions, field: FieldInfo & {
     kind: "map";
 }, key: string, value: any): void;
-export {};
+export { readField as binaryReadField, readMapEntry as binaryReadMapEntry, readScalar as binaryReadScalar, readScalarLTString as binaryReadScalarLTString, readMessage as binaryReadMessage, writeField as binaryWriteField, writeScalar as binaryWriteScalar, writePacked as binaryWritePacked, writeMapEntry as binaryWriteMapEntry, writeMessage as binaryWriteMessage, makeReadOptions as binaryMakeReadOptions, makeWriteOptions as binaryMakeWriteOptions, };

package/dist/binary.js

@@ -4,7 +4,23 @@ import { wrapField } from "./field-wrapper.js";
 import { LongType, ScalarType, scalarZeroValue, } from "./scalar.js";
 import { assert } from "./assert.js";
 import { BinaryReader, BinaryWriter, WireType, } from "./binary-encoding.js";
-export function readField(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+// Default options for parsing binary data.
+const readDefaults = {
+    readUnknownFields: true,
+    readerFactory: (bytes) => new BinaryReader(bytes),
+};
+// Default options for serializing binary data.
+const writeDefaults = {
+    writeUnknownFields: true,
+    writerFactory: () => new BinaryWriter(),
+};
+function makeReadOptions(options) {
+    return options ? { ...readDefaults, ...options } : readDefaults;
+}
+function makeWriteOptions(options) {
+    return options ? { ...writeDefaults, ...options } : writeDefaults;
+}
+function readField(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
 reader, field, wireType, options) {
     let { repeated, localName } = field;
     if (field.oneof) {
@@ -78,7 +94,7 @@ reader, field, wireType, options) {
     }
 }
 // Read a map field, expecting key field = 1, value field = 2
-export function readMapEntry(field, reader, options) {
+function readMapEntry(field, reader, options) {
     const length = reader.uint32(), end = reader.pos + length;
     let key, val;
     while (reader.pos < end) {
@@ -125,7 +141,7 @@ export function readMapEntry(field, reader, options) {
     }
     return [key, val];
 }
-export function readScalar(reader, type) {
+function readScalar(reader, type) {
     switch (type) {
         case ScalarType.STRING:
             return reader.string();
@@ -161,7 +177,7 @@ export function readScalar(reader, type) {
 }
 // Read a scalar value, but return 64 bit integral types (int64, uint64,
 // sint64, fixed64, sfixed64) as string instead of bigint.
-export function readScalarLTString(reader, type) {
+function readScalarLTString(reader, type) {
     const v = readScalar(reader, type);
     return typeof v == "bigint" ? v.toString() : v;
 }
@@ -173,23 +189,7 @@ function readMessageField(reader, message, fields, options, field) {
     options, delimited);
     return message;
 }
-// Default options for parsing binary data.
-const readDefaults = {
-    readUnknownFields: true,
-    readerFactory: (bytes) => new BinaryReader(bytes),
-};
-// Default options for serializing binary data.
-const writeDefaults = {
-    writeUnknownFields: true,
-    writerFactory: () => new BinaryWriter(),
-};
-export function makeReadOptions(options) {
-    return options ? { ...readDefaults, ...options } : readDefaults;
-}
-export function makeWriteOptions(options) {
-    return options ? { ...writeDefaults, ...options } : writeDefaults;
-}
-export function readMessage(message, fields, reader, lengthOrEndTagFieldNo, options, delimitedMessageEncoding) {
+function readMessage(message, fields, reader, lengthOrEndTagFieldNo, options, delimitedMessageEncoding) {
     // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     const end = delimitedMessageEncoding ? reader.len : reader.pos + lengthOrEndTagFieldNo;
     let fieldNo, wireType;
@@ -216,7 +216,7 @@ export function readMessage(message, fields, reader, lengthOrEndTagFieldNo, opti
 /**
  * Serialize a message to binary data.
  */
-export function writeMessage(message, fields, writer, options) {
+function writeMessage(message, fields, writer, options) {
     for (const field of fields.byNumber()) {
         if (!isFieldSet(field, message)) {
             if (field.req) {
@@ -347,7 +347,7 @@ function scalarTypeInfo(type) {
     const method = ScalarType[type].toLowerCase();
     return [wireType, method];
 }
-export function writeMapEntry(writer, options, field, key, value) {
+function writeMapEntry(writer, options, field, key, value) {
     writer.tag(field.no, WireType.LengthDelimited);
     writer.fork();
     // javascript only allows number or string for object properties
@@ -387,3 +387,4 @@ export function writeMapEntry(writer, options, field, key, value) {
     }
     writer.join();
 }
+export { readField as binaryReadField, readMapEntry as binaryReadMapEntry, readScalar as binaryReadScalar, readScalarLTString as binaryReadScalarLTString, readMessage as binaryReadMessage, writeField as binaryWriteField, writeScalar as binaryWriteScalar, writePacked as binaryWritePacked, writeMapEntry as binaryWriteMapEntry, writeMessage as binaryWriteMessage, makeReadOptions as binaryMakeReadOptions, makeWriteOptions as binaryMakeWriteOptions, };

package/dist/codegen-info.d.ts

@@ -20,16 +20,24 @@ export declare const codegenInfo: {
         readonly PartialFieldInfo: RuntimeSymbolInfo;
         readonly MessageType: RuntimeSymbolInfo;
         readonly Extension: RuntimeSymbolInfo;
+        readonly IMessageTypeRegistry: RuntimeSymbolInfo;
         readonly BinaryReadOptions: RuntimeSymbolInfo;
         readonly BinaryWriteOptions: RuntimeSymbolInfo;
         readonly JsonReadOptions: RuntimeSymbolInfo;
         readonly JsonWriteOptions: RuntimeSymbolInfo;
         readonly JsonValue: RuntimeSymbolInfo;
         readonly JsonObject: RuntimeSymbolInfo;
+        readonly jsonReadEnum: RuntimeSymbolInfo;
+        readonly jsonReadScalar: RuntimeSymbolInfo;
+        readonly jsonWriteEnum: RuntimeSymbolInfo;
+        readonly jsonWriteScalar: RuntimeSymbolInfo;
+        readonly jsonDebugValue: RuntimeSymbolInfo;
         readonly protoDouble: RuntimeSymbolInfo;
         readonly protoInt64: RuntimeSymbolInfo;
+        readonly applyPartialMessage: RuntimeSymbolInfo;
         readonly ScalarType: RuntimeSymbolInfo;
         readonly LongType: RuntimeSymbolInfo;
+        readonly ScalarValue: RuntimeSymbolInfo;
         readonly MethodKind: RuntimeSymbolInfo;
         readonly MethodIdempotency: RuntimeSymbolInfo;
         readonly createEnumType: RuntimeSymbolInfo;

package/dist/codegen-info.js

@@ -27,16 +27,24 @@ const symbols = {
     PartialFieldInfo: symbolInfo(true, "./field.js"),
     MessageType: symbolInfo(true, "./message-type.js"),
     Extension: symbolInfo(true, "./extension.js"),
+    IMessageTypeRegistry: symbolInfo(true, "./type-registry.js"),
     BinaryReadOptions: symbolInfo(true, "./binary-format.js"),
     BinaryWriteOptions: symbolInfo(true, "./binary-format.js"),
-    JsonReadOptions: symbolInfo(true, "./json-format.js"),
-    JsonWriteOptions: symbolInfo(true, "./json-format.js"),
-    JsonValue: symbolInfo(true, "./json-format.js"),
-    JsonObject: symbolInfo(true, "./json-format.js"),
+    JsonReadOptions: symbolInfo(true, "./json.js"),
+    JsonWriteOptions: symbolInfo(true, "./json.js"),
+    JsonValue: symbolInfo(true, "./json.js"),
+    JsonObject: symbolInfo(true, "./json.js"),
+    jsonReadEnum: symbolInfo(false, "./json.js"),
+    jsonReadScalar: symbolInfo(false, "./json.js"),
+    jsonWriteEnum: symbolInfo(false, "./json.js"),
+    jsonWriteScalar: symbolInfo(false, "./json.js"),
+    jsonDebugValue: symbolInfo(false, "./json.js"),
     protoDouble: symbolInfo(false, "./proto-double.js"),
     protoInt64: symbolInfo(false, "./proto-int64.js"),
+    applyPartialMessage: symbolInfo(false, "./partial.js"),
     ScalarType: symbolInfo(false, "./scalar.js"),
     LongType: symbolInfo(false, "./scalar.js"),
+    ScalarValue: symbolInfo(false, "./scalar.js"),
     MethodKind: symbolInfo(false, "./service-type.js"),
     MethodIdempotency: symbolInfo(false, "./service-type.js"),
     createEnumType: symbolInfo(false, "./enum.js"),

package/dist/descriptor-set.d.ts

@@ -294,7 +294,7 @@ export type DescExtension = DescFieldCommon & (DescFieldScalar | DescFieldMessag
      */
     readonly extendee: DescMessage;
 };
-interface DescFieldCommon {
+export interface DescFieldCommon {
     /**
      * The field name, as specified in the protobuf source
      */
@@ -354,7 +354,7 @@ interface DescFieldCommon {
     getFeatures(): MergedFeatureSet;
     toString(): string;
 }
-interface DescFieldScalar {
+export interface DescFieldScalar {
     readonly fieldKind: "scalar";
     /**
      * Is the field repeated?
@@ -391,7 +391,7 @@ interface DescFieldScalar {
      */
     getDefaultValue(): number | boolean | string | bigint | Uint8Array | undefined;
 }
-interface DescFieldMessage {
+export interface DescFieldMessage {
     readonly fieldKind: "message";
     /**
      * Is the field repeated?
@@ -423,7 +423,7 @@ interface DescFieldMessage {
      */
     readonly mapValue: undefined;
 }
-interface DescFieldEnum {
+export interface DescFieldEnum {
     readonly fieldKind: "enum";
     /**
      * Is the field repeated?
@@ -460,7 +460,7 @@ interface DescFieldEnum {
      */
     getDefaultValue(): number | boolean | string | bigint | Uint8Array | undefined;
 }
-interface DescFieldMap {
+export interface DescFieldMap {
     readonly fieldKind: "map";
     /**
      * Is the field repeated?
@@ -492,7 +492,7 @@ interface DescFieldMap {
      */
     readonly mapValue: DescFieldMapValueEnum | DescFieldMapValueMessage | DescFieldMapValueScalar;
 }
-interface DescFieldMapValueEnum {
+export interface DescFieldMapValueEnum {
     readonly kind: "enum";
     /**
      * The enum type, if this is a map field with enum values.
@@ -507,7 +507,7 @@ interface DescFieldMapValueEnum {
      */
     readonly scalar: undefined;
 }
-interface DescFieldMapValueMessage {
+export interface DescFieldMapValueMessage {
     readonly kind: "message";
     /**
      * The enum type, if this is a map field with enum values.
@@ -522,7 +522,7 @@ interface DescFieldMapValueMessage {
      */
     readonly scalar: undefined;
 }
-interface DescFieldMapValueScalar {
+export interface DescFieldMapValueScalar {
     readonly kind: "scalar";
     /**
      * The enum type, if this is a map field with enum values.
@@ -669,4 +669,3 @@ export interface DescComments {
     readonly trailing?: string;
     readonly sourcePath: readonly number[];
 }
-export {};

package/dist/field-wrapper.d.ts

@@ -5,8 +5,8 @@ import { ScalarType } from "./scalar.js";
  * ergonomic for use as a message field.
  */
 export interface FieldWrapper<T = any, U = any> {
-    wrapField(value: U): T;
-    unwrapField(value: T): U;
+    wrapField(value: U | null | undefined): T;
+    unwrapField(value: T): U | null | undefined;
 }
 /**
  * Wrap a primitive message field value in its corresponding wrapper

package/dist/google/protobuf/any.pb.d.ts

@@ -1,4 +1,4 @@
-import type { MessageType } from "../../index.js";
+import type { IMessageTypeRegistry, JsonReadOptions, JsonValue, JsonWriteOptions, MessageType } from "../../index.js";
 import { Message } from "../../index.js";
 export declare const protobufPackage = "google.protobuf";
 /**
@@ -133,4 +133,57 @@ export type Any = Message<{
      */
     value?: Uint8Array;
 }>;
-export declare const Any: MessageType<Any>;
+declare const Any_Wkt: {
+    toJson(msg: Any, options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): Message<{
+        /**
+         * A URL/resource name that uniquely identifies the type of the serialized
+         * protocol buffer message. This string must contain at least
+         * one "/" character. The last segment of the URL's path must represent
+         * the fully qualified name of the type (as in
+         * `path/google.protobuf.Duration`). The name should be in a canonical form
+         * (e.g., leading "." is not accepted).
+         *
+         * In practice, teams usually precompile into the binary all types that they
+         * expect it to use in the context of Any. However, for URLs which use the
+         * scheme `http`, `https`, or no scheme, one can optionally set up a type
+         * server that maps type URLs to message definitions as follows:
+         *
+         * * If no scheme is provided, `https` is assumed.
+         * * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+         *   value in binary format, or produce an error.
+         * * Applications are allowed to cache lookup results based on the
+         *   URL, or have them precompiled into a binary to avoid any
+         *   lookup. Therefore, binary compatibility needs to be preserved
+         *   on changes to types. (Use versioned type names to manage
+         *   breaking changes.)
+         *
+         * Note: this functionality is not currently available in the official
+         * protobuf release, and it is not used for type URLs beginning with
+         * type.googleapis.com. As of May 2023, there are no widely used type server
+         * implementations and no plans to implement one.
+         *
+         * Schemes other than `http`, `https` (or the empty scheme) might be
+         * used with implementation specific semantics.
+         *
+         *
+         * @generated from field: string type_url = 1;
+         */
+        typeUrl?: string | undefined;
+        /**
+         * Must be a valid serialized protocol buffer of the above specified type.
+         *
+         * @generated from field: bytes value = 2;
+         */
+        value?: Uint8Array | undefined;
+    }>;
+    packFrom<T extends Message<T>>(out: Any, message: Message<T>, messageType: MessageType<T>): void;
+    unpackTo<T_1 extends Message<T_1>>(msg: Any, target: Message<T_1>, targetMessageType: MessageType<T_1>): boolean;
+    unpack<T_2 extends Message<T_2>>(msg: Any, registry: IMessageTypeRegistry): {
+        message: Message<T_2>;
+        messageType: MessageType<T_2>;
+    } | undefined;
+    is(msg: Any, msgType: MessageType | string): boolean;
+};
+export declare const Any: MessageType<Any> & typeof Any_Wkt;
+export {};

package/dist/google/protobuf/any.pb.js

@@ -27,13 +27,94 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-import { createMessageType } from "../../index.js";
+import { applyPartialMessage, createMessageType, ScalarType, } from "../../index.js";
 export const protobufPackage = "google.protobuf";
+// Any_Wkt contains the well-known-type overrides for Any.
+const Any_Wkt = {
+    toJson(msg, options) {
+        const typeName = msg?.typeUrl;
+        if (!typeName) {
+            return {};
+        }
+        const messageType = options?.typeRegistry?.findMessage(typeName);
+        if (!messageType) {
+            throw new Error(`cannot encode message google.protobuf.Any to JSON: "${typeName}" is not in the type registry`);
+        }
+        const message = messageType.fromBinary(msg.value);
+        let json = messageType.toJson(message, options);
+        if (typeName.startsWith("google.protobuf.") ||
+            json === null ||
+            Array.isArray(json) ||
+            typeof json !== "object") {
+            json = { value: json };
+        }
+        json["@type"] = typeName;
+        return json;
+    },
+    fromJson(json, options) {
+        if (json === null || Array.isArray(json) || typeof json != "object") {
+            throw new Error(`cannot decode message google.protobuf.Any from JSON: expected object but got ${json === null ? "null"
+                : Array.isArray(json) ? "array"
+                    : typeof json}`);
+        }
+        if (Object.keys(json).length == 0) {
+            return {};
+        }
+        const typeUrl = json["@type"];
+        if (typeof typeUrl != "string" || typeUrl == "") {
+            throw new Error(`cannot decode message google.protobuf.Any from JSON: "@type" is empty`);
+        }
+        const typeName = typeUrl, messageType = options?.typeRegistry?.findMessage(typeName);
+        if (!messageType) {
+            throw new Error(`cannot decode message google.protobuf.Any from JSON: ${typeUrl} is not in the type registry`);
+        }
+        let message;
+        if (typeName.startsWith("google.protobuf.") &&
+            Object.prototype.hasOwnProperty.call(json, "value")) {
+            message = messageType.fromJson(json["value"], options);
+        }
+        else {
+            const copy = Object.assign({}, json);
+            delete copy["@type"];
+            message = messageType.fromJson(copy, options);
+        }
+        const out = {};
+        Any.packFrom(out, message, messageType);
+        return out;
+    },
+    packFrom(out, message, messageType) {
+        out.value = messageType.toBinary(message);
+        out.typeUrl = messageType.typeName;
+    },
+    unpackTo(msg, target, targetMessageType) {
+        if (!Any.is(msg, targetMessageType)) {
+            return false;
+        }
+        const partial = targetMessageType.fromBinary(msg.value);
+        applyPartialMessage(partial, target, targetMessageType.fields);
+        return true;
+    },
+    unpack(msg, registry) {
+        const typeUrl = msg.typeUrl;
+        const messageType = !!typeUrl && registry.findMessage(typeUrl);
+        return messageType ?
+            { message: messageType.fromBinary(msg.value), messageType }
+            : undefined;
+    },
+    is(msg, msgType) {
+        const name = msg.typeUrl;
+        return (!!name &&
+            (typeof msgType === "string" ?
+                name === msgType
+                : name === msgType.typeName));
+    },
+};
+// Any contains the message type declaration for Any.
 export const Any = createMessageType({
     typeName: "google.protobuf.Any",
     fields: [
-        { no: 1, name: "type_url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 2, name: "value", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
+        { no: 1, name: "type_url", kind: "scalar", T: ScalarType.STRING },
+        { no: 2, name: "value", kind: "scalar", T: ScalarType.BYTES },
     ],
     packedByDefault: true,
-});
+}, Any_Wkt);

package/dist/google/protobuf/api.pb.js

@@ -27,38 +27,59 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-import { createMessageType } from "../../index.js";
+import { createMessageType, ScalarType } from "../../index.js";
 import { Option, Syntax_Enum } from "./type.pb.js";
 import { SourceContext } from "./source_context.pb.js";
 export const protobufPackage = "google.protobuf";
+// Method contains the message type declaration for Method.
 export const Method = createMessageType({
     typeName: "google.protobuf.Method",
     fields: [
-        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 2, name: "request_type_url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 3, name: "request_streaming", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
-        { no: 4, name: "response_type_url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 5, name: "response_streaming", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
-        { no: 6, name: "options", kind: "message", T: () => Option, repeated: true },
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
+        { no: 2, name: "request_type_url", kind: "scalar", T: ScalarType.STRING },
+        { no: 3, name: "request_streaming", kind: "scalar", T: ScalarType.BOOL },
+        { no: 4, name: "response_type_url", kind: "scalar", T: ScalarType.STRING },
+        { no: 5, name: "response_streaming", kind: "scalar", T: ScalarType.BOOL },
+        {
+            no: 6,
+            name: "options",
+            kind: "message",
+            T: () => Option,
+            repeated: true,
+        },
         { no: 7, name: "syntax", kind: "enum", T: Syntax_Enum },
     ],
     packedByDefault: true,
 });
+// Mixin contains the message type declaration for Mixin.
 export const Mixin = createMessageType({
     typeName: "google.protobuf.Mixin",
     fields: [
-        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 2, name: "root", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
+        { no: 2, name: "root", kind: "scalar", T: ScalarType.STRING },
     ],
     packedByDefault: true,
 });
+// Api contains the message type declaration for Api.
 export const Api = createMessageType({
     typeName: "google.protobuf.Api",
     fields: [
-        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 2, name: "methods", kind: "message", T: () => Method, repeated: true },
-        { no: 3, name: "options", kind: "message", T: () => Option, repeated: true },
-        { no: 4, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
+        {
+            no: 2,
+            name: "methods",
+            kind: "message",
+            T: () => Method,
+            repeated: true,
+        },
+        {
+            no: 3,
+            name: "options",
+            kind: "message",
+            T: () => Option,
+            repeated: true,
+        },
+        { no: 4, name: "version", kind: "scalar", T: ScalarType.STRING },
         { no: 5, name: "source_context", kind: "message", T: () => SourceContext },
         { no: 6, name: "mixins", kind: "message", T: () => Mixin, repeated: true },
         { no: 7, name: "syntax", kind: "enum", T: Syntax_Enum },