@bufbuild/protoc-gen-es 1.7.1 → 1.8.0

package/README.md

@@ -118,7 +118,6 @@ Possible values:
   the default behavior.
 - `js_import_style=legacy_commonjs` generate CommonJS `require()` calls.
 
-
 ### `keep_empty_files=true`
 
 By default, [protoc-gen-es](https://www.npmjs.com/package/@bufbuild/protoc-gen-es)
@@ -127,3 +126,14 @@ omit empty files from the plugin output. This option disables pruning of
 empty files, to allow for smooth interoperation with Bazel and similar
 tooling that requires all output files to be declared ahead of time.
 Unless you use Bazel, it is very unlikely that you need this option.
+
+### `ts_nocheck=false`
+
+By default, [protoc-gen-es](https://www.npmjs.com/package/@bufbuild/protoc-gen-es)
+(and all other plugins based on [@bufbuild/protoplugin](https://www.npmjs.com/package/@bufbuild/protoplugin))
+generate an annotation at the top of each file: `// @ts-nocheck`.
+
+We generate the annotation to support a wide range of compiler configurations and
+future changes to the language. But there can be situations where the annotation
+shadows an underlying problem, for example an unresolvable import. To remove 
+the annotation and to enable type checks, set the plugin option `ts_nocheck=false`.

package/dist/cjs/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bufbuild/protoc-gen-es",
-    "version": "1.7.1",
+    "version": "1.8.0",
     "description": "Protocol Buffers code generator for ECMAScript",
     "license": "Apache-2.0",
     "repository": {
@@ -20,11 +20,11 @@
     },
     "preferUnplugged": true,
     "dependencies": {
-        "@bufbuild/protobuf": "^1.7.1",
-        "@bufbuild/protoplugin": "1.7.1"
+        "@bufbuild/protobuf": "^1.8.0",
+        "@bufbuild/protoplugin": "1.8.0"
     },
     "peerDependencies": {
-        "@bufbuild/protobuf": "1.7.1"
+        "@bufbuild/protobuf": "1.8.0"
     },
     "peerDependenciesMeta": {
         "@bufbuild/protobuf": {

package/dist/cjs/src/declaration.js

@@ -16,6 +16,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDts = void 0;
 const ecmascript_1 = require("@bufbuild/protoplugin/ecmascript");
 const editions_js_1 = require("./editions.js");
+const util_js_1 = require("./util.js");
 function generateDts(schema) {
     for (const file of schema.files) {
         const f = schema.generateFile(file.name + "_pb.d.ts");
@@ -102,29 +103,28 @@ function generateOneof(schema, f, oneof) {
             f.print(`  } | {`);
         }
         f.print(f.jsDoc(field, "    "));
-        const { typing } = (0, ecmascript_1.getFieldTyping)(field, f);
+        const { typing } = (0, util_js_1.getFieldTypeInfo)(field);
         f.print(`    value: `, typing, `;`);
         f.print(`    case: "`, (0, ecmascript_1.localName)(field), `";`);
     }
     f.print(`  } | { case: undefined; value?: undefined };`);
 }
+// prettier-ignore
 function generateField(schema, f, field) {
     f.print(f.jsDoc(field, "  "));
     const e = [];
-    e.push("  ", (0, ecmascript_1.localName)(field));
-    const { typing, optional } = (0, ecmascript_1.getFieldTyping)(field, f);
-    if (optional) {
-        e.push("?: ", typing);
+    const { typing, optional } = (0, util_js_1.getFieldTypeInfo)(field);
+    if (!optional) {
+        e.push("  ", (0, ecmascript_1.localName)(field), ": ", typing, ";");
     }
     else {
-        e.push(": ", typing);
+        e.push("  ", (0, ecmascript_1.localName)(field), "?: ", typing, ";");
     }
-    e.push(";");
     f.print(e);
 }
 // prettier-ignore
 function generateExtension(schema, f, ext) {
-    const { typing } = (0, ecmascript_1.getFieldTyping)(ext, f);
+    const { typing } = (0, util_js_1.getFieldTypeInfo)(ext);
     f.print(f.jsDoc(ext));
     f.print(f.exportDecl("declare const", ext), ": ", schema.runtime.Extension, "<", ext.extendee, ", ", typing, ">;");
     f.print();
@@ -198,7 +198,7 @@ function generateWktStaticMethods(schema, f, message) {
         case "google.protobuf.BoolValue":
         case "google.protobuf.StringValue":
         case "google.protobuf.BytesValue": {
-            const { typing } = (0, ecmascript_1.getFieldTyping)(ref.value, f);
+            const { typing } = (0, util_js_1.getFieldTypeInfo)(ref.value);
             f.print("  static readonly fieldWrapper: {");
             f.print("    wrapField(value: ", typing, "): ", message, ",");
             f.print("    unwrapField(value: ", message, "): ", typing, ",");

package/dist/cjs/src/javascript.js

@@ -15,8 +15,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFieldInfoLiteral = exports.generateFieldInfo = exports.generateJs = void 0;
 const protobuf_1 = require("@bufbuild/protobuf");
+const protobuf_2 = require("@bufbuild/protobuf");
 const ecmascript_1 = require("@bufbuild/protoplugin/ecmascript");
 const editions_js_1 = require("./editions.js");
+const util_js_1 = require("./util.js");
 function generateJs(schema) {
     for (const file of schema.files) {
         const f = schema.generateFile(file.name + "_pb.js");
@@ -38,7 +40,7 @@ exports.generateJs = generateJs;
 function generateEnum(schema, f, enumeration) {
     const protoN = (0, editions_js_1.getNonEditionRuntime)(schema, enumeration.file);
     f.print(f.jsDoc(enumeration));
-    f.print(f.exportDecl("const", enumeration), " = ", protoN, ".makeEnum(");
+    f.print(f.exportDecl("const", enumeration), " = /*@__PURE__*/ ", protoN, ".makeEnum(");
     f.print(`  "`, enumeration.typeName, `",`);
     f.print(`  [`);
     if (enumeration.sharedPrefix === undefined) {
@@ -60,7 +62,7 @@ function generateEnum(schema, f, enumeration) {
 function generateMessage(schema, f, message) {
     const protoN = (0, editions_js_1.getNonEditionRuntime)(schema, message.file);
     f.print(f.jsDoc(message));
-    f.print(f.exportDecl("const", message), " = ", protoN, ".makeMessageType(");
+    f.print(f.exportDecl("const", message), " = /*@__PURE__*/ ", protoN, ".makeMessageType(");
     f.print(`  `, f.string(message.typeName), `,`);
     if (message.fields.length == 0) {
         f.print("  [],");
@@ -73,7 +75,7 @@ function generateMessage(schema, f, message) {
         f.print("  ],");
     }
     const needsLocalName = (0, ecmascript_1.localName)(message) !==
-        (message.file.syntax == "proto3" ? protobuf_1.proto2 : protobuf_1.proto3)
+        (message.file.syntax == "proto3" ? protobuf_2.proto2 : protobuf_2.proto3)
             .makeMessageType(message.typeName, []).name;
     if (needsLocalName) {
         // local name is not inferrable from the type name, we need to provide it
@@ -111,16 +113,16 @@ function getFieldInfoLiteral(schema, field) {
     }
     switch (field.fieldKind) {
         case "scalar":
-            e.push(`kind: "scalar", T: `, field.scalar, ` /* ScalarType.`, protobuf_1.ScalarType[field.scalar], ` */, `);
-            if (field.longType != protobuf_1.LongType.BIGINT) {
-                e.push(`L: `, field.longType, ` /* LongType.`, protobuf_1.LongType[field.longType], ` */, `);
+            e.push(`kind: "scalar", T: `, field.scalar, ` /* ScalarType.`, protobuf_2.ScalarType[field.scalar], ` */, `);
+            if (field.longType != protobuf_2.LongType.BIGINT) {
+                e.push(`L: `, field.longType, ` /* LongType.`, protobuf_2.LongType[field.longType], ` */, `);
             }
             break;
         case "map":
-            e.push(`kind: "map", K: `, field.mapKey, ` /* ScalarType.`, protobuf_1.ScalarType[field.mapKey], ` */, `);
+            e.push(`kind: "map", K: `, field.mapKey, ` /* ScalarType.`, protobuf_2.ScalarType[field.mapKey], ` */, `);
             switch (field.mapValue.kind) {
                 case "scalar":
-                    e.push(`V: {kind: "scalar", T: `, field.mapValue.scalar, ` /* ScalarType.`, protobuf_1.ScalarType[field.mapValue.scalar], ` */}, `);
+                    e.push(`V: {kind: "scalar", T: `, field.mapValue.scalar, ` /* ScalarType.`, protobuf_2.ScalarType[field.mapValue.scalar], ` */}, `);
                     break;
                 case "message":
                     e.push(`V: {kind: "message", T: `, field.mapValue.message, `}, `);
@@ -132,7 +134,7 @@ function getFieldInfoLiteral(schema, field) {
             break;
         case "message":
             e.push(`kind: "message", T: `, field.message, `, `);
-            if (field.proto.type === protobuf_1.FieldDescriptorProto_Type.GROUP) {
+            if (field.proto.type === protobuf_2.FieldDescriptorProto_Type.GROUP) {
                 e.push(`delimited: true, `);
             }
             break;
@@ -149,7 +151,10 @@ function getFieldInfoLiteral(schema, field) {
     if (field.optional) {
         e.push(`opt: true, `);
     }
-    const defaultValue = (0, ecmascript_1.getFieldExplicitDefaultValue)(field, schema.runtime.protoInt64);
+    else if (field.proto.label === protobuf_1.FieldDescriptorProto_Label.REQUIRED) {
+        e.push(`req: true, `);
+    }
+    const defaultValue = (0, util_js_1.getFieldDefaultValueExpression)(field);
     if (defaultValue !== undefined) {
         e.push(`default: `, defaultValue, `, `);
     }
@@ -544,12 +549,12 @@ function generateWktMethods(schema, f, message) {
         case "google.protobuf.StringValue":
         case "google.protobuf.BytesValue":
             f.print(message, ".prototype.toJson = function toJson(options) {");
-            f.print("  return proto3.json.writeScalar(", rtScalarType, ".", protobuf_1.ScalarType[ref.value.scalar], ", this.value, true);");
+            f.print("  return proto3.json.writeScalar(", rtScalarType, ".", protobuf_2.ScalarType[ref.value.scalar], ", this.value, true);");
             f.print("}");
             f.print();
             f.print(message, ".prototype.fromJson = function fromJson(json, options) {");
             f.print("  try {");
-            f.print("    this.value = ", protoN, ".json.readScalar(", rtScalarType, ".", protobuf_1.ScalarType[ref.value.scalar], ", json);");
+            f.print("    this.value = ", protoN, ".json.readScalar(", rtScalarType, ".", protobuf_2.ScalarType[ref.value.scalar], ", json);");
             f.print("  } catch (e) {");
             f.print("    let m = `cannot decode message ", message.typeName, " from JSON\"`;");
             f.print("    if (e instanceof Error && e.message.length > 0) {");

package/dist/cjs/src/typescript.js

@@ -18,6 +18,7 @@ const protobuf_1 = require("@bufbuild/protobuf");
 const ecmascript_1 = require("@bufbuild/protoplugin/ecmascript");
 const javascript_js_1 = require("./javascript.js");
 const editions_js_1 = require("./editions.js");
+const util_js_1 = require("./util.js");
 function generateTs(schema) {
     for (const file of schema.files) {
         const f = schema.generateFile(file.name + "_pb.ts");
@@ -126,34 +127,39 @@ function generateOneof(schema, f, oneof) {
             f.print(`  } | {`);
         }
         f.print(f.jsDoc(field, "    "));
-        const { typing } = (0, ecmascript_1.getFieldTyping)(field, f);
+        const { typing } = (0, util_js_1.getFieldTypeInfo)(field);
         f.print(`    value: `, typing, `;`);
         f.print(`    case: "`, (0, ecmascript_1.localName)(field), `";`);
     }
     f.print(`  } | { case: undefined; value?: undefined } = { case: undefined };`);
 }
+// prettier-ignore
 function generateField(schema, f, field) {
     f.print(f.jsDoc(field, "  "));
     const e = [];
-    e.push("  ", (0, ecmascript_1.localName)(field));
-    const { defaultValue, typingInferrable } = (0, ecmascript_1.getFieldIntrinsicDefaultValue)(field);
-    const { typing, optional } = (0, ecmascript_1.getFieldTyping)(field, f);
-    if (optional || defaultValue === undefined) {
-        e.push("?: ", typing);
-    }
-    else if (!typingInferrable) {
-        e.push(": ", typing);
+    const { typing, optional, typingInferrableFromZeroValue } = (0, util_js_1.getFieldTypeInfo)(field);
+    if (optional) {
+        e.push("  ", (0, ecmascript_1.localName)(field), "?: ", typing, ";");
     }
-    if (defaultValue !== undefined) {
-        e.push(" = ", defaultValue);
+    else {
+        if (typingInferrableFromZeroValue) {
+            e.push("  ", (0, ecmascript_1.localName)(field));
+        }
+        else {
+            e.push("  ", (0, ecmascript_1.localName)(field), ": ", typing);
+        }
+        const zeroValue = (0, util_js_1.getFieldZeroValueExpression)(field);
+        if (zeroValue !== undefined) {
+            e.push(" = ", zeroValue);
+        }
+        e.push(";");
     }
-    e.push(";");
     f.print(e);
 }
 // prettier-ignore
 function generateExtension(schema, f, ext) {
     const protoN = (0, editions_js_1.getNonEditionRuntime)(schema, ext.file);
-    const { typing } = (0, ecmascript_1.getFieldTyping)(ext, f);
+    const { typing } = (0, util_js_1.getFieldTypeInfo)(ext);
     f.print(f.jsDoc(ext));
     f.print(f.exportDecl("const", ext), " = ", protoN, ".makeExtension<", ext.extendee, ", ", typing, ">(");
     f.print("  ", f.string(ext.typeName), ", ");
@@ -611,7 +617,7 @@ function generateWktStaticMethods(schema, f, message) {
         case "google.protobuf.BoolValue":
         case "google.protobuf.StringValue":
         case "google.protobuf.BytesValue": {
-            const { typing } = (0, ecmascript_1.getFieldTyping)(ref.value, f);
+            const { typing } = (0, util_js_1.getFieldTypeInfo)(ref.value);
             f.print("  static readonly fieldWrapper = {");
             f.print("    wrapField(value: ", typing, "): ", message, " {");
             f.print("      return new ", message, "({value});");

package/dist/cjs/src/util.js

@@ -0,0 +1,260 @@
+"use strict";
+// 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.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldZeroValueExpression = exports.getFieldDefaultValueExpression = exports.getFieldTypeInfo = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const ecmascript_1 = require("@bufbuild/protoplugin/ecmascript");
+function getFieldTypeInfo(field) {
+    const typing = [];
+    let typingInferrableFromZeroValue;
+    let optional = false;
+    switch (field.fieldKind) {
+        case "scalar":
+            typing.push(scalarTypeScriptType(field.scalar, field.longType));
+            optional =
+                field.optional ||
+                    field.proto.label === protobuf_1.FieldDescriptorProto_Label.REQUIRED;
+            typingInferrableFromZeroValue = true;
+            break;
+        case "message": {
+            const baseType = protobuf_1.codegenInfo.getUnwrappedFieldType(field);
+            if (baseType !== undefined) {
+                typing.push(scalarTypeScriptType(baseType, protobuf_1.LongType.BIGINT));
+            }
+            else {
+                typing.push({
+                    kind: "es_ref_message",
+                    type: field.message,
+                    typeOnly: true,
+                });
+            }
+            optional = true;
+            typingInferrableFromZeroValue = true;
+            break;
+        }
+        case "enum":
+            typing.push({
+                kind: "es_ref_enum",
+                type: field.enum,
+                typeOnly: true,
+            });
+            optional =
+                field.optional ||
+                    field.proto.label === protobuf_1.FieldDescriptorProto_Label.REQUIRED;
+            typingInferrableFromZeroValue = true;
+            break;
+        case "map": {
+            let keyType;
+            switch (field.mapKey) {
+                case protobuf_1.ScalarType.INT32:
+                case protobuf_1.ScalarType.FIXED32:
+                case protobuf_1.ScalarType.UINT32:
+                case protobuf_1.ScalarType.SFIXED32:
+                case protobuf_1.ScalarType.SINT32:
+                    keyType = "number";
+                    break;
+                default:
+                    keyType = "string";
+                    break;
+            }
+            let valueType;
+            switch (field.mapValue.kind) {
+                case "scalar":
+                    valueType = scalarTypeScriptType(field.mapValue.scalar, protobuf_1.LongType.BIGINT);
+                    break;
+                case "message":
+                    valueType = {
+                        kind: "es_ref_message",
+                        type: field.mapValue.message,
+                        typeOnly: true,
+                    };
+                    break;
+                case "enum":
+                    valueType = {
+                        kind: "es_ref_enum",
+                        type: field.mapValue.enum,
+                        typeOnly: true,
+                    };
+                    break;
+            }
+            typing.push("{ [key: ", keyType, "]: ", valueType, " }");
+            typingInferrableFromZeroValue = false;
+            optional = false;
+            break;
+        }
+    }
+    if (field.repeated) {
+        typing.push("[]");
+        optional = false;
+        typingInferrableFromZeroValue = false;
+    }
+    return { typing, optional, typingInferrableFromZeroValue };
+}
+exports.getFieldTypeInfo = getFieldTypeInfo;
+/**
+ * Return a printable expression for the default value of a field.
+ * Only applicable for singular scalar and enum fields.
+ */
+function getFieldDefaultValueExpression(field, enumAs = "enum_value_as_is") {
+    if (field.repeated) {
+        return undefined;
+    }
+    if (field.fieldKind !== "enum" && field.fieldKind !== "scalar") {
+        return undefined;
+    }
+    const defaultValue = field.getDefaultValue();
+    if (defaultValue === undefined) {
+        return undefined;
+    }
+    switch (field.fieldKind) {
+        case "enum": {
+            const enumValue = field.enum.values.find((value) => value.number === defaultValue);
+            if (enumValue === undefined) {
+                throw new Error(`invalid enum default value: ${String(defaultValue)} for ${enumValue}`);
+            }
+            return literalEnumValue(enumValue, enumAs);
+        }
+        case "scalar":
+            return literalScalarValue(defaultValue, field);
+    }
+}
+exports.getFieldDefaultValueExpression = getFieldDefaultValueExpression;
+/**
+ * Return a printable expression for the zero value of a field.
+ *
+ * Returns either:
+ * - empty array literal for repeated fields
+ * - empty object literal for maps
+ * - undefined for message fields
+ * - an enums first value
+ * - scalar zero value
+ */
+function getFieldZeroValueExpression(field, enumAs = "enum_value_as_is") {
+    if (field.repeated) {
+        return "[]";
+    }
+    switch (field.fieldKind) {
+        case "message":
+            return undefined;
+        case "map":
+            return "{}";
+        case "enum": {
+            // In proto3, the first enum value must be zero.
+            // In proto2, protobuf-go returns the first value as the default.
+            if (field.enum.values.length < 1) {
+                throw new Error("invalid enum: missing at least one value");
+            }
+            const zeroValue = field.enum.values[0];
+            return literalEnumValue(zeroValue, enumAs);
+        }
+        case "scalar": {
+            const defaultValue = protobuf_1.codegenInfo.scalarZeroValue(field.scalar, field.longType);
+            return literalScalarValue(defaultValue, field);
+        }
+    }
+}
+exports.getFieldZeroValueExpression = getFieldZeroValueExpression;
+function literalScalarValue(value, field) {
+    switch (field.scalar) {
+        case protobuf_1.ScalarType.DOUBLE:
+        case protobuf_1.ScalarType.FLOAT:
+        case protobuf_1.ScalarType.INT32:
+        case protobuf_1.ScalarType.FIXED32:
+        case protobuf_1.ScalarType.UINT32:
+        case protobuf_1.ScalarType.SFIXED32:
+        case protobuf_1.ScalarType.SINT32:
+            if (typeof value != "number") {
+                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
+            }
+            return value;
+        case protobuf_1.ScalarType.BOOL:
+            if (typeof value != "boolean") {
+                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
+            }
+            return value;
+        case protobuf_1.ScalarType.STRING:
+            if (typeof value != "string") {
+                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
+            }
+            return { kind: "es_string", value };
+        case protobuf_1.ScalarType.BYTES:
+            if (!(value instanceof Uint8Array)) {
+                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
+            }
+            return value;
+        case protobuf_1.ScalarType.INT64:
+        case protobuf_1.ScalarType.SINT64:
+        case protobuf_1.ScalarType.SFIXED64:
+        case protobuf_1.ScalarType.UINT64:
+        case protobuf_1.ScalarType.FIXED64:
+            if (typeof value != "bigint" && typeof value != "string") {
+                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
+            }
+            return {
+                kind: "es_proto_int64",
+                type: field.scalar,
+                longType: field.longType,
+                value,
+            };
+    }
+}
+function literalEnumValue(value, enumAs) {
+    switch (enumAs) {
+        case "enum_value_as_is":
+            return [
+                { kind: "es_ref_enum", type: value.parent, typeOnly: false },
+                ".",
+                (0, ecmascript_1.localName)(value),
+            ];
+        case "enum_value_as_integer":
+            return [
+                value.number,
+                " /* ",
+                value.parent.typeName,
+                ".",
+                value.name,
+                " */",
+            ];
+        case "enum_value_as_cast_integer":
+            return [
+                value.number,
+                " as ",
+                { kind: "es_ref_enum", type: value.parent, typeOnly: true },
+                ".",
+                (0, ecmascript_1.localName)(value),
+            ];
+    }
+}
+function scalarTypeScriptType(type, longType) {
+    switch (type) {
+        case protobuf_1.ScalarType.STRING:
+            return "string";
+        case protobuf_1.ScalarType.BOOL:
+            return "boolean";
+        case protobuf_1.ScalarType.UINT64:
+        case protobuf_1.ScalarType.SFIXED64:
+        case protobuf_1.ScalarType.FIXED64:
+        case protobuf_1.ScalarType.SINT64:
+        case protobuf_1.ScalarType.INT64:
+            if (longType === protobuf_1.LongType.STRING) {
+                return "string";
+            }
+            return "bigint";
+        case protobuf_1.ScalarType.BYTES:
+            return "Uint8Array";
+        default:
+            return "number";
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bufbuild/protoc-gen-es",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "Protocol Buffers code generator for ECMAScript",
   "license": "Apache-2.0",
   "repository": {
@@ -20,11 +20,11 @@
   },
   "preferUnplugged": true,
   "dependencies": {
-    "@bufbuild/protobuf": "^1.7.1",
-    "@bufbuild/protoplugin": "1.7.1"
+    "@bufbuild/protobuf": "^1.8.0",
+    "@bufbuild/protoplugin": "1.8.0"
   },
   "peerDependencies": {
-    "@bufbuild/protobuf": "1.7.1"
+    "@bufbuild/protobuf": "1.8.0"
   },
   "peerDependenciesMeta": {
     "@bufbuild/protobuf": {

package/src/declaration.ts

@@ -24,12 +24,9 @@ import type {
   Printable,
   Schema,
 } from "@bufbuild/protoplugin/ecmascript";
-import {
-  getFieldTyping,
-  localName,
-  reifyWkt,
-} from "@bufbuild/protoplugin/ecmascript";
+import { localName, reifyWkt } from "@bufbuild/protoplugin/ecmascript";
 import { getNonEditionRuntime } from "./editions.js";
+import { getFieldTypeInfo } from "./util.js";
 
 export function generateDts(schema: Schema) {
   for (const file of schema.files) {
@@ -127,25 +124,24 @@ function generateOneof(schema: Schema, f: GeneratedFile, oneof: DescOneof) {
       f.print(`  } | {`);
     }
     f.print(f.jsDoc(field, "    "));
-    const { typing } = getFieldTyping(field, f);
+    const { typing } = getFieldTypeInfo(field);
     f.print(`    value: `, typing, `;`);
     f.print(`    case: "`, localName(field), `";`);
   }
   f.print(`  } | { case: undefined; value?: undefined };`);
 }
 
+// prettier-ignore
 function generateField(schema: Schema, f: GeneratedFile, field: DescField) {
-  f.print(f.jsDoc(field, "  "));
-  const e: Printable = [];
-  e.push("  ", localName(field));
-  const { typing, optional } = getFieldTyping(field, f);
-  if (optional) {
-    e.push("?: ", typing);
-  } else {
-    e.push(": ", typing);
-  }
-  e.push(";");
-  f.print(e);
+    f.print(f.jsDoc(field, "  "));
+    const e: Printable = [];
+    const { typing, optional } = getFieldTypeInfo(field);
+    if (!optional) {
+        e.push("  ", localName(field), ": ", typing, ";");
+    } else {
+        e.push("  ", localName(field), "?: ", typing, ";");
+    }
+    f.print(e);
 }
 
 // prettier-ignore
@@ -154,7 +150,7 @@ function generateExtension(
   f: GeneratedFile,
   ext: DescExtension,
 ) {
-  const { typing } = getFieldTyping(ext, f);
+  const { typing } = getFieldTypeInfo(ext);
   f.print(f.jsDoc(ext));
   f.print(f.exportDecl("declare const", ext), ": ", schema.runtime.Extension, "<", ext.extendee, ", ", typing, ">;");
   f.print();
@@ -234,7 +230,7 @@ function generateWktStaticMethods(schema: Schema, f: GeneratedFile, message: Des
     case "google.protobuf.BoolValue":
     case "google.protobuf.StringValue":
     case "google.protobuf.BytesValue": {
-      const {typing} = getFieldTyping(ref.value, f);
+      const {typing} = getFieldTypeInfo(ref.value);
       f.print("  static readonly fieldWrapper: {")
       f.print("    wrapField(value: ", typing, "): ", message, ",")
       f.print("    unwrapField(value: ", message, "): ", typing, ",")

package/src/javascript.ts

@@ -12,11 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import type {
+import {
   DescEnum,
   DescExtension,
   DescField,
   DescMessage,
+  FieldDescriptorProto_Label,
 } from "@bufbuild/protobuf";
 import {
   FieldDescriptorProto_Type,
@@ -30,12 +31,9 @@ import type {
   Printable,
   Schema,
 } from "@bufbuild/protoplugin/ecmascript";
-import {
-  getFieldExplicitDefaultValue,
-  localName,
-  reifyWkt,
-} from "@bufbuild/protoplugin/ecmascript";
+import { localName, reifyWkt } from "@bufbuild/protoplugin/ecmascript";
 import { getNonEditionRuntime } from "./editions.js";
+import { getFieldDefaultValueExpression } from "./util.js";
 
 export function generateJs(schema: Schema) {
   for (const file of schema.files) {
@@ -58,7 +56,7 @@ export function generateJs(schema: Schema) {
 function generateEnum(schema: Schema, f: GeneratedFile, enumeration: DescEnum) {
   const protoN = getNonEditionRuntime(schema, enumeration.file);
   f.print(f.jsDoc(enumeration));
-  f.print(f.exportDecl("const", enumeration), " = ", protoN, ".makeEnum(")
+  f.print(f.exportDecl("const", enumeration), " = /*@__PURE__*/ ", protoN, ".makeEnum(")
   f.print(`  "`, enumeration.typeName, `",`)
   f.print(`  [`)
   if (enumeration.sharedPrefix === undefined) {
@@ -80,7 +78,7 @@ function generateEnum(schema: Schema, f: GeneratedFile, enumeration: DescEnum) {
 function generateMessage(schema: Schema, f: GeneratedFile, message: DescMessage) {
   const protoN = getNonEditionRuntime(schema, message.file);
   f.print(f.jsDoc(message));
-  f.print(f.exportDecl("const", message), " = ", protoN, ".makeMessageType(")
+  f.print(f.exportDecl("const", message), " = /*@__PURE__*/ ", protoN, ".makeMessageType(")
   f.print(`  `, f.string(message.typeName), `,`)
   if (message.fields.length == 0) {
     f.print("  [],")
@@ -168,8 +166,10 @@ export function getFieldInfoLiteral(schema: Schema, field: DescField | DescExten
   }
   if (field.optional) {
     e.push(`opt: true, `);
+  } else if (field.proto.label === FieldDescriptorProto_Label.REQUIRED) {
+    e.push(`req: true, `);
   }
-  const defaultValue = getFieldExplicitDefaultValue(field, schema.runtime.protoInt64);
+  const defaultValue = getFieldDefaultValueExpression(field);
   if (defaultValue !== undefined) {
     e.push(`default: `, defaultValue, `, `);
   }

package/src/typescript.ts

@@ -25,14 +25,10 @@ import type {
   Printable,
   Schema,
 } from "@bufbuild/protoplugin/ecmascript";
-import {
-  getFieldIntrinsicDefaultValue,
-  getFieldTyping,
-  localName,
-  reifyWkt,
-} from "@bufbuild/protoplugin/ecmascript";
+import { localName, reifyWkt } from "@bufbuild/protoplugin/ecmascript";
 import { generateFieldInfo, getFieldInfoLiteral } from "./javascript.js";
 import { getNonEditionRuntime } from "./editions.js";
+import { getFieldTypeInfo, getFieldZeroValueExpression } from "./util.js";
 
 export function generateTs(schema: Schema) {
   for (const file of schema.files) {
@@ -152,29 +148,32 @@ function generateOneof(schema: Schema, f: GeneratedFile, oneof: DescOneof) {
       f.print(`  } | {`);
     }
     f.print(f.jsDoc(field, "    "));
-    const { typing } = getFieldTyping(field, f);
+    const { typing } = getFieldTypeInfo(field);
     f.print(`    value: `, typing, `;`);
     f.print(`    case: "`, localName(field), `";`);
   }
   f.print(`  } | { case: undefined; value?: undefined } = { case: undefined };`);
 }
 
+// prettier-ignore
 function generateField(schema: Schema, f: GeneratedFile, field: DescField) {
   f.print(f.jsDoc(field, "  "));
   const e: Printable = [];
-  e.push("  ", localName(field));
-  const { defaultValue, typingInferrable } =
-    getFieldIntrinsicDefaultValue(field);
-  const { typing, optional } = getFieldTyping(field, f);
-  if (optional || defaultValue === undefined) {
-    e.push("?: ", typing);
-  } else if (!typingInferrable) {
-    e.push(": ", typing);
-  }
-  if (defaultValue !== undefined) {
-    e.push(" = ", defaultValue);
+  const { typing, optional, typingInferrableFromZeroValue } = getFieldTypeInfo(field);
+  if (optional) {
+    e.push("  ", localName(field), "?: ", typing, ";");
+  } else {
+    if (typingInferrableFromZeroValue) {
+      e.push("  ", localName(field));
+    } else {
+      e.push("  ", localName(field), ": ", typing);
+    }
+    const zeroValue = getFieldZeroValueExpression(field);
+    if (zeroValue !== undefined) {
+      e.push(" = ", zeroValue);
+    }
+    e.push(";");
   }
-  e.push(";");
   f.print(e);
 }
 
@@ -185,7 +184,7 @@ function generateExtension(
   ext: DescExtension,
 ) {
   const protoN = getNonEditionRuntime(schema, ext.file);
-  const { typing } = getFieldTyping(ext, f);
+  const { typing } = getFieldTypeInfo(ext);
   f.print(f.jsDoc(ext));
   f.print(f.exportDecl("const", ext), " = ", protoN, ".makeExtension<", ext.extendee, ", ", typing, ">(");
   f.print("  ", f.string(ext.typeName), ", ");
@@ -652,7 +651,7 @@ function generateWktStaticMethods(schema: Schema, f: GeneratedFile, message: Des
     case "google.protobuf.BoolValue":
     case "google.protobuf.StringValue":
     case "google.protobuf.BytesValue": {
-      const {typing} = getFieldTyping(ref.value, f);
+      const {typing} = getFieldTypeInfo(ref.value);
       f.print("  static readonly fieldWrapper = {")
       f.print("    wrapField(value: ", typing, "): ", message, " {")
       f.print("      return new ", message, "({value});")

package/src/util.ts

@@ -0,0 +1,315 @@
+// 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.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import {
+  codegenInfo,
+  DescEnumValue,
+  DescExtension,
+  DescField,
+  FieldDescriptorProto_Label,
+  LongType,
+  ScalarType,
+  ScalarValue,
+} from "@bufbuild/protobuf";
+import type { Printable } from "@bufbuild/protoplugin/ecmascript";
+import { localName } from "@bufbuild/protoplugin/ecmascript";
+
+export function getFieldTypeInfo(field: DescField | DescExtension): {
+  typing: Printable;
+  optional: boolean;
+  typingInferrableFromZeroValue: boolean;
+} {
+  const typing: Printable = [];
+  let typingInferrableFromZeroValue: boolean;
+  let optional = false;
+  switch (field.fieldKind) {
+    case "scalar":
+      typing.push(scalarTypeScriptType(field.scalar, field.longType));
+      optional =
+        field.optional ||
+        field.proto.label === FieldDescriptorProto_Label.REQUIRED;
+      typingInferrableFromZeroValue = true;
+      break;
+    case "message": {
+      const baseType = codegenInfo.getUnwrappedFieldType(field);
+      if (baseType !== undefined) {
+        typing.push(scalarTypeScriptType(baseType, LongType.BIGINT));
+      } else {
+        typing.push({
+          kind: "es_ref_message",
+          type: field.message,
+          typeOnly: true,
+        });
+      }
+      optional = true;
+      typingInferrableFromZeroValue = true;
+      break;
+    }
+    case "enum":
+      typing.push({
+        kind: "es_ref_enum",
+        type: field.enum,
+        typeOnly: true,
+      });
+      optional =
+        field.optional ||
+        field.proto.label === FieldDescriptorProto_Label.REQUIRED;
+      typingInferrableFromZeroValue = true;
+      break;
+    case "map": {
+      let keyType: string;
+      switch (field.mapKey) {
+        case ScalarType.INT32:
+        case ScalarType.FIXED32:
+        case ScalarType.UINT32:
+        case ScalarType.SFIXED32:
+        case ScalarType.SINT32:
+          keyType = "number";
+          break;
+        default:
+          keyType = "string";
+          break;
+      }
+      let valueType: Printable;
+      switch (field.mapValue.kind) {
+        case "scalar":
+          valueType = scalarTypeScriptType(
+            field.mapValue.scalar,
+            LongType.BIGINT,
+          );
+          break;
+        case "message":
+          valueType = {
+            kind: "es_ref_message",
+            type: field.mapValue.message,
+            typeOnly: true,
+          };
+          break;
+        case "enum":
+          valueType = {
+            kind: "es_ref_enum",
+            type: field.mapValue.enum,
+            typeOnly: true,
+          };
+          break;
+      }
+      typing.push("{ [key: ", keyType, "]: ", valueType, " }");
+      typingInferrableFromZeroValue = false;
+      optional = false;
+      break;
+    }
+  }
+  if (field.repeated) {
+    typing.push("[]");
+    optional = false;
+    typingInferrableFromZeroValue = false;
+  }
+  return { typing, optional, typingInferrableFromZeroValue };
+}
+
+/**
+ * Return a printable expression for the default value of a field.
+ * Only applicable for singular scalar and enum fields.
+ */
+export function getFieldDefaultValueExpression(
+  field: DescField | DescExtension,
+  enumAs:
+    | "enum_value_as_is"
+    | "enum_value_as_integer"
+    | "enum_value_as_cast_integer" = "enum_value_as_is",
+): Printable | undefined {
+  if (field.repeated) {
+    return undefined;
+  }
+  if (field.fieldKind !== "enum" && field.fieldKind !== "scalar") {
+    return undefined;
+  }
+  const defaultValue = field.getDefaultValue();
+  if (defaultValue === undefined) {
+    return undefined;
+  }
+  switch (field.fieldKind) {
+    case "enum": {
+      const enumValue = field.enum.values.find(
+        (value) => value.number === defaultValue,
+      );
+      if (enumValue === undefined) {
+        throw new Error(
+          `invalid enum default value: ${String(defaultValue)} for ${enumValue}`,
+        );
+      }
+      return literalEnumValue(enumValue, enumAs);
+    }
+    case "scalar":
+      return literalScalarValue(defaultValue, field);
+  }
+}
+
+/**
+ * Return a printable expression for the zero value of a field.
+ *
+ * Returns either:
+ * - empty array literal for repeated fields
+ * - empty object literal for maps
+ * - undefined for message fields
+ * - an enums first value
+ * - scalar zero value
+ */
+export function getFieldZeroValueExpression(
+  field: DescField | DescExtension,
+  enumAs:
+    | "enum_value_as_is"
+    | "enum_value_as_integer"
+    | "enum_value_as_cast_integer" = "enum_value_as_is",
+): Printable | undefined {
+  if (field.repeated) {
+    return "[]";
+  }
+  switch (field.fieldKind) {
+    case "message":
+      return undefined;
+    case "map":
+      return "{}";
+    case "enum": {
+      // In proto3, the first enum value must be zero.
+      // In proto2, protobuf-go returns the first value as the default.
+      if (field.enum.values.length < 1) {
+        throw new Error("invalid enum: missing at least one value");
+      }
+      const zeroValue = field.enum.values[0];
+      return literalEnumValue(zeroValue, enumAs);
+    }
+    case "scalar": {
+      const defaultValue = codegenInfo.scalarZeroValue(
+        field.scalar,
+        field.longType,
+      );
+      return literalScalarValue(defaultValue, field);
+    }
+  }
+}
+
+function literalScalarValue(
+  value: ScalarValue,
+  field: (DescField | DescExtension) & { fieldKind: "scalar" },
+): Printable {
+  switch (field.scalar) {
+    case ScalarType.DOUBLE:
+    case ScalarType.FLOAT:
+    case ScalarType.INT32:
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32:
+      if (typeof value != "number") {
+        throw new Error(
+          `Unexpected value for ${ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`,
+        );
+      }
+      return value;
+    case ScalarType.BOOL:
+      if (typeof value != "boolean") {
+        throw new Error(
+          `Unexpected value for ${ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`,
+        );
+      }
+      return value;
+    case ScalarType.STRING:
+      if (typeof value != "string") {
+        throw new Error(
+          `Unexpected value for ${ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`,
+        );
+      }
+      return { kind: "es_string", value };
+    case ScalarType.BYTES:
+      if (!(value instanceof Uint8Array)) {
+        throw new Error(
+          `Unexpected value for ${ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`,
+        );
+      }
+      return value;
+    case ScalarType.INT64:
+    case ScalarType.SINT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+      if (typeof value != "bigint" && typeof value != "string") {
+        throw new Error(
+          `Unexpected value for ${ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`,
+        );
+      }
+      return {
+        kind: "es_proto_int64",
+        type: field.scalar,
+        longType: field.longType,
+        value,
+      };
+  }
+}
+
+function literalEnumValue(
+  value: DescEnumValue,
+  enumAs:
+    | "enum_value_as_is"
+    | "enum_value_as_integer"
+    | "enum_value_as_cast_integer",
+): Printable {
+  switch (enumAs) {
+    case "enum_value_as_is":
+      return [
+        { kind: "es_ref_enum", type: value.parent, typeOnly: false },
+        ".",
+        localName(value),
+      ];
+    case "enum_value_as_integer":
+      return [
+        value.number,
+        " /* ",
+        value.parent.typeName,
+        ".",
+        value.name,
+        " */",
+      ];
+    case "enum_value_as_cast_integer":
+      return [
+        value.number,
+        " as ",
+        { kind: "es_ref_enum", type: value.parent, typeOnly: true },
+        ".",
+        localName(value),
+      ];
+  }
+}
+
+function scalarTypeScriptType(type: ScalarType, longType: LongType): Printable {
+  switch (type) {
+    case ScalarType.STRING:
+      return "string";
+    case ScalarType.BOOL:
+      return "boolean";
+    case ScalarType.UINT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.FIXED64:
+    case ScalarType.SINT64:
+    case ScalarType.INT64:
+      if (longType === LongType.STRING) {
+        return "string";
+      }
+      return "bigint";
+    case ScalarType.BYTES:
+      return "Uint8Array";
+    default:
+      return "number";
+  }
+}