@bufbuild/protobuf 1.7.2 → 1.8.0

package/dist/cjs/private/{json-format-common.js → json-format.js}

@@ -13,15 +13,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeJsonFormatCommon = void 0;
-const message_js_1 = require("../message.js");
-const field_js_1 = require("../field.js");
+exports.makeJsonFormat = void 0;
 const assert_js_1 = require("./assert.js");
 const proto_int64_js_1 = require("../proto-int64.js");
 const proto_base64_js_1 = require("../proto-base64.js");
 const extensions_js_1 = require("./extensions.js");
 const extension_accessor_js_1 = require("../extension-accessor.js");
-/* eslint-disable no-case-declarations, @typescript-eslint/restrict-plus-operands,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
+const reflect_js_1 = require("./reflect.js");
+const field_wrapper_js_1 = require("./field-wrapper.js");
+const scalars_js_1 = require("./scalars.js");
+const scalars_js_2 = require("./scalars.js");
+const scalar_js_1 = require("../scalar.js");
+const is_message_js_1 = require("../is-message.js");
+/* eslint-disable no-case-declarations,@typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call */
 // Default options for parsing JSON.
 const jsonReadDefaults = {
     ignoreUnknownFields: false,
@@ -39,8 +43,9 @@ function makeReadOptions(options) {
 function makeWriteOptions(options) {
     return options ? Object.assign(Object.assign({}, jsonWriteDefaults), options) : jsonWriteDefaults;
 }
-function makeJsonFormatCommon(nullAsZeroValue, makeWriteField) {
-    const writeField = makeWriteField(writeEnum, writeScalar);
+const tokenNull = Symbol();
+const tokenIgnoredUnknownEnum = Symbol();
+function makeJsonFormat() {
     return {
         makeReadOptions,
         makeWriteOptions,
@@ -65,7 +70,7 @@ function makeJsonFormatCommon(nullAsZeroValue, makeWriteField) {
                         }
                         oneofSeen.set(field.oneof, jsonKey);
                     }
-                    readField(message, jsonValue, field, options, type, nullAsZeroValue);
+                    readField(message, jsonValue, field, options, type);
                 }
                 else {
                     let found = false;
@@ -76,7 +81,7 @@ function makeJsonFormatCommon(nullAsZeroValue, makeWriteField) {
                         if (ext && ext.extendee.typeName == type.typeName) {
                             found = true;
                             const [container, get] = (0, extensions_js_1.createExtensionContainer)(ext);
-                            readField(container, jsonValue, ext.field, options, ext, true);
+                            readField(container, jsonValue, ext.field, options, ext);
                             // We pass on the options as BinaryReadOptions/BinaryWriteOptions,
                             // so that users can bring their own binary reader and writer factories
                             // if necessary.
@@ -95,23 +100,23 @@ function makeJsonFormatCommon(nullAsZeroValue, makeWriteField) {
             const json = {};
             let field;
             try {
-                for (const member of type.fields.byMember()) {
-                    let jsonValue;
-                    if (member.kind == "oneof") {
-                        const oneof = message[member.localName];
-                        if (oneof.value === undefined) {
+                for (field of type.fields.byNumber()) {
+                    if (!(0, reflect_js_1.isFieldSet)(field, message)) {
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (field.req) {
+                            throw `required field not set`;
+                        }
+                        if (!options.emitDefaultValues) {
                             continue;
                         }
-                        field = member.findField(oneof.case);
-                        if (!field) {
-                            throw "oneof case not found: " + oneof.case;
+                        if (!canEmitFieldDefaultValue(field)) {
+                            continue;
                         }
-                        jsonValue = writeField(field, oneof.value, options);
-                    }
-                    else {
-                        field = member;
-                        jsonValue = writeField(field, message[field.localName], options);
                     }
+                    const value = field.oneof
+                        ? message[field.oneof.localName].value
+                        : message[field.localName];
+                    const jsonValue = writeField(field, value, options);
                     if (jsonValue !== undefined) {
                         json[options.useProtoFieldName ? field.name : field.jsonName] =
                             jsonValue;
@@ -142,12 +147,28 @@ function makeJsonFormatCommon(nullAsZeroValue, makeWriteField) {
             }
             return json;
         },
-        readScalar: (type, json, longType) => readScalar(type, json, longType, nullAsZeroValue), // eslint-disable-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
-        writeScalar,
+        readScalar(type, json, longType) {
+            // The signature of our internal function has changed. For backwards-
+            // compatibility, we support the old form that is part of the public API
+            // through the interface JsonFormat.
+            return readScalar(type, json, longType !== null && longType !== void 0 ? longType : scalar_js_1.LongType.BIGINT, true);
+        },
+        writeScalar(type, value, emitDefaultValues) {
+            // The signature of our internal function has changed. For backwards-
+            // compatibility, we support the old form that is part of the public API
+            // through the interface JsonFormat.
+            if (value === undefined) {
+                return undefined;
+            }
+            if (emitDefaultValues || (0, scalars_js_2.isScalarZeroValue)(type, value)) {
+                return writeScalar(type, value);
+            }
+            return undefined;
+        },
         debug: debugJsonValue,
     };
 }
-exports.makeJsonFormatCommon = makeJsonFormatCommon;
+exports.makeJsonFormat = makeJsonFormat;
 function debugJsonValue(json) {
     if (json === null) {
         return "null";
@@ -162,50 +183,38 @@ function debugJsonValue(json) {
     }
 }
 // Read a JSON value for a field.
-// The "type" argument is only used to provide context in errors.
-// The argument "nullAsZeroValue" applies to singular fields (not repeated, map,
-// or oneof). If the argument is `true`, JSON null is parsed as the fields
-// zero-value. If the argument is false, JSON null sets the field to `undefined`.
-function readField(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
-jsonValue, field, options, type, nullAsZeroValue) {
+// The "parentType" argument is only used to provide context in errors.
+function readField(target, jsonValue, field, options, parentType) {
     let localName = field.localName;
-    if (field.oneof) {
-        if (jsonValue === null && field.kind == "scalar") {
-            // see conformance test Required.Proto3.JsonInput.OneofFieldNull{First,Second}
-            return;
-        }
-        target = target[field.oneof.localName] = { case: localName };
-        localName = "value";
-    }
     if (field.repeated) {
+        (0, assert_js_1.assert)(field.kind != "map");
         if (jsonValue === null) {
             return;
         }
         if (!Array.isArray(jsonValue)) {
-            throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`);
+            throw new Error(`cannot decode field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`);
         }
         const targetArray = target[localName];
         for (const jsonItem of jsonValue) {
             if (jsonItem === null) {
-                throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: ${debugJsonValue(jsonItem)}`);
+                throw new Error(`cannot decode field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonItem)}`);
             }
-            let val;
-            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- "map" is invalid for repeated fields
             switch (field.kind) {
                 case "message":
-                    val = field.T.fromJson(jsonItem, options);
+                    targetArray.push(field.T.fromJson(jsonItem, options));
                     break;
                 case "enum":
-                    val = readEnum(field.T, jsonItem, options.ignoreUnknownFields, true);
-                    if (val === undefined)
-                        continue;
+                    const enumValue = readEnum(field.T, jsonItem, options.ignoreUnknownFields, true);
+                    if (enumValue !== tokenIgnoredUnknownEnum) {
+                        targetArray.push(enumValue);
+                    }
                     break;
                 case "scalar":
                     try {
-                        val = readScalar(field.T, jsonItem, field.L, true);
+                        targetArray.push(readScalar(field.T, jsonItem, field.L, true));
                     }
                     catch (e) {
-                        let m = `cannot decode field ${type.typeName}.${field.name} from JSON: ${debugJsonValue(jsonItem)}`;
+                        let m = `cannot decode field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonItem)}`;
                         if (e instanceof Error && e.message.length > 0) {
                             m += `: ${e.message}`;
                         }
@@ -213,7 +222,6 @@ jsonValue, field, options, type, nullAsZeroValue) {
                     }
                     break;
             }
-            targetArray.push(val);
         }
     }
     else if (field.kind == "map") {
@@ -221,29 +229,40 @@ jsonValue, field, options, type, nullAsZeroValue) {
             return;
         }
         if (typeof jsonValue != "object" || Array.isArray(jsonValue)) {
-            throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`);
+            throw new Error(`cannot decode field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`);
         }
         const targetMap = target[localName];
         for (const [jsonMapKey, jsonMapValue] of Object.entries(jsonValue)) {
             if (jsonMapValue === null) {
-                throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: map value null`);
+                throw new Error(`cannot decode field ${parentType.typeName}.${field.name} from JSON: map value null`);
+            }
+            let key;
+            try {
+                key = readMapKey(field.K, jsonMapKey);
+            }
+            catch (e) {
+                let m = `cannot decode map key for field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
+                if (e instanceof Error && e.message.length > 0) {
+                    m += `: ${e.message}`;
+                }
+                throw new Error(m);
             }
-            let val;
             switch (field.V.kind) {
                 case "message":
-                    val = field.V.T.fromJson(jsonMapValue, options);
+                    targetMap[key] = field.V.T.fromJson(jsonMapValue, options);
                     break;
                 case "enum":
-                    val = readEnum(field.V.T, jsonMapValue, options.ignoreUnknownFields, true);
-                    if (val === undefined)
-                        continue;
+                    const enumValue = readEnum(field.V.T, jsonMapValue, options.ignoreUnknownFields, true);
+                    if (enumValue !== tokenIgnoredUnknownEnum) {
+                        targetMap[key] = enumValue;
+                    }
                     break;
                 case "scalar":
                     try {
-                        val = readScalar(field.V.T, jsonMapValue, field_js_1.LongType.BIGINT, true);
+                        targetMap[key] = readScalar(field.V.T, jsonMapValue, scalar_js_1.LongType.BIGINT, true);
                     }
                     catch (e) {
-                        let m = `cannot decode map value for field ${type.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
+                        let m = `cannot decode map value for field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
                         if (e instanceof Error && e.message.length > 0) {
                             m += `: ${e.message}`;
                         }
@@ -251,57 +270,59 @@ jsonValue, field, options, type, nullAsZeroValue) {
                     }
                     break;
             }
-            try {
-                targetMap[readScalar(field.K, field.K == field_js_1.ScalarType.BOOL
-                    ? jsonMapKey == "true"
-                        ? true
-                        : jsonMapKey == "false"
-                            ? false
-                            : jsonMapKey
-                    : jsonMapKey, field_js_1.LongType.BIGINT, true).toString()] = val;
-            }
-            catch (e) {
-                let m = `cannot decode map key for field ${type.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
-                if (e instanceof Error && e.message.length > 0) {
-                    m += `: ${e.message}`;
-                }
-                throw new Error(m);
-            }
         }
     }
     else {
+        if (field.oneof) {
+            target = target[field.oneof.localName] = { case: localName };
+            localName = "value";
+        }
         switch (field.kind) {
             case "message":
                 const messageType = field.T;
                 if (jsonValue === null &&
                     messageType.typeName != "google.protobuf.Value") {
-                    if (field.oneof) {
-                        throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: null is invalid for oneof field`);
-                    }
                     return;
                 }
-                if (target[localName] instanceof message_js_1.Message) {
-                    target[localName].fromJson(jsonValue, options);
+                let currentValue = target[localName];
+                if ((0, is_message_js_1.isMessage)(currentValue)) {
+                    currentValue.fromJson(jsonValue, options);
                 }
                 else {
-                    target[localName] = messageType.fromJson(jsonValue, options);
+                    target[localName] = currentValue = messageType.fromJson(jsonValue, options);
                     if (messageType.fieldWrapper && !field.oneof) {
-                        target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
+                        target[localName] =
+                            messageType.fieldWrapper.unwrapField(currentValue);
                     }
                 }
                 break;
             case "enum":
-                const enumValue = readEnum(field.T, jsonValue, options.ignoreUnknownFields, nullAsZeroValue);
-                if (enumValue !== undefined) {
-                    target[localName] = enumValue;
+                const enumValue = readEnum(field.T, jsonValue, options.ignoreUnknownFields, false);
+                switch (enumValue) {
+                    case tokenNull:
+                        (0, reflect_js_1.clearField)(field, target);
+                        break;
+                    case tokenIgnoredUnknownEnum:
+                        break;
+                    default:
+                        target[localName] = enumValue;
+                        break;
                 }
                 break;
             case "scalar":
                 try {
-                    target[localName] = readScalar(field.T, jsonValue, field.L, nullAsZeroValue);
+                    const scalarValue = readScalar(field.T, jsonValue, field.L, false);
+                    switch (scalarValue) {
+                        case tokenNull:
+                            (0, reflect_js_1.clearField)(field, target);
+                            break;
+                        default:
+                            target[localName] = scalarValue;
+                            break;
+                    }
                 }
                 catch (e) {
-                    let m = `cannot decode field ${type.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
+                    let m = `cannot decode field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
                     if (e instanceof Error && e.message.length > 0) {
                         m += `: ${e.message}`;
                     }
@@ -311,21 +332,34 @@ jsonValue, field, options, type, nullAsZeroValue) {
         }
     }
 }
-// May throw an error. If the error message is non-blank, it should be shown.
-// It is up to the caller to provide context.
-// If the argument "nullAsZeroValue" is `true`, this function returns the zero-value
-// for JSON null. If the argument is `false`, this function returns `undefined`
-// for JSON null.
+function readMapKey(type, json) {
+    if (type === scalar_js_1.ScalarType.BOOL) {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (json) {
+            case "true":
+                json = true;
+                break;
+            case "false":
+                json = false;
+                break;
+        }
+    }
+    return readScalar(type, json, scalar_js_1.LongType.BIGINT, true).toString();
+}
 function readScalar(type, json, longType, nullAsZeroValue) {
+    if (json === null) {
+        if (nullAsZeroValue) {
+            return (0, scalars_js_1.scalarZeroValue)(type, longType);
+        }
+        return tokenNull;
+    }
     // every valid case in the switch below returns, and every fall
     // through is regarded as a failure.
     switch (type) {
         // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
         // Either numbers or strings are accepted. Exponent notation is also accepted.
-        case field_js_1.ScalarType.DOUBLE:
-        case field_js_1.ScalarType.FLOAT:
-            if (json === null)
-                return nullAsZeroValue ? 0.0 : undefined;
+        case scalar_js_1.ScalarType.DOUBLE:
+        case scalar_js_1.ScalarType.FLOAT:
             if (json === "NaN")
                 return Number.NaN;
             if (json === "Infinity")
@@ -352,17 +386,15 @@ function readScalar(type, json, longType, nullAsZeroValue) {
                 // infinity and -infinity are handled by string representation above, so this is an error
                 break;
             }
-            if (type == field_js_1.ScalarType.FLOAT)
+            if (type == scalar_js_1.ScalarType.FLOAT)
                 (0, assert_js_1.assertFloat32)(float);
             return float;
         // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
-        case field_js_1.ScalarType.INT32:
-        case field_js_1.ScalarType.FIXED32:
-        case field_js_1.ScalarType.SFIXED32:
-        case field_js_1.ScalarType.SINT32:
-        case field_js_1.ScalarType.UINT32:
-            if (json === null)
-                return nullAsZeroValue ? 0 : undefined;
+        case scalar_js_1.ScalarType.INT32:
+        case scalar_js_1.ScalarType.FIXED32:
+        case scalar_js_1.ScalarType.SFIXED32:
+        case scalar_js_1.ScalarType.SINT32:
+        case scalar_js_1.ScalarType.UINT32:
             let int32;
             if (typeof json == "number")
                 int32 = json;
@@ -372,42 +404,34 @@ function readScalar(type, json, longType, nullAsZeroValue) {
             }
             if (int32 === undefined)
                 break;
-            if (type == field_js_1.ScalarType.UINT32)
+            if (type == scalar_js_1.ScalarType.UINT32)
                 (0, assert_js_1.assertUInt32)(int32);
             else
                 (0, assert_js_1.assertInt32)(int32);
             return int32;
         // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted.
-        case field_js_1.ScalarType.INT64:
-        case field_js_1.ScalarType.SFIXED64:
-        case field_js_1.ScalarType.SINT64:
-            if (json === null)
-                return nullAsZeroValue ? proto_int64_js_1.protoInt64.zero : undefined;
+        case scalar_js_1.ScalarType.INT64:
+        case scalar_js_1.ScalarType.SFIXED64:
+        case scalar_js_1.ScalarType.SINT64:
             if (typeof json != "number" && typeof json != "string")
                 break;
             const long = proto_int64_js_1.protoInt64.parse(json);
             // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
             return longType ? long.toString() : long;
-        case field_js_1.ScalarType.FIXED64:
-        case field_js_1.ScalarType.UINT64:
-            if (json === null)
-                return nullAsZeroValue ? proto_int64_js_1.protoInt64.zero : undefined;
+        case scalar_js_1.ScalarType.FIXED64:
+        case scalar_js_1.ScalarType.UINT64:
             if (typeof json != "number" && typeof json != "string")
                 break;
             const uLong = proto_int64_js_1.protoInt64.uParse(json);
             // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
             return longType ? uLong.toString() : uLong;
         // bool:
-        case field_js_1.ScalarType.BOOL:
-            if (json === null)
-                return nullAsZeroValue ? false : undefined;
+        case scalar_js_1.ScalarType.BOOL:
             if (typeof json !== "boolean")
                 break;
             return json;
         // string:
-        case field_js_1.ScalarType.STRING:
-            if (json === null)
-                return nullAsZeroValue ? "" : undefined;
+        case scalar_js_1.ScalarType.STRING:
             if (typeof json !== "string") {
                 break;
             }
@@ -422,9 +446,7 @@ function readScalar(type, json, longType, nullAsZeroValue) {
             return json;
         // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
         // Either standard or URL-safe base64 encoding with/without paddings are accepted.
-        case field_js_1.ScalarType.BYTES:
-            if (json === null)
-                return nullAsZeroValue ? new Uint8Array(0) : undefined;
+        case scalar_js_1.ScalarType.BYTES:
             if (json === "")
                 return new Uint8Array(0);
             if (typeof json !== "string")
@@ -433,14 +455,12 @@ function readScalar(type, json, longType, nullAsZeroValue) {
     }
     throw new Error();
 }
-// If the argument "nullAsZeroValue" is `true`, this function returns the first
-// enum value for JSON null. If the argument is `false`, this function returns
-// `undefined`.
 function readEnum(type, json, ignoreUnknownFields, nullAsZeroValue) {
     if (json === null) {
-        // proto3 requires 0 to be default value for all enums (which is required to be the first value).
-        // proto2 uses the first value (at least with protoc-gen-go).
-        return nullAsZeroValue ? type.values[0].no : undefined;
+        if (type.typeName == "google.protobuf.NullValue") {
+            return 0; // google.protobuf.NullValue.NULL_VALUE = 0
+        }
+        return nullAsZeroValue ? type.values[0].no : tokenNull;
     }
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
     switch (typeof json) {
@@ -451,50 +471,126 @@ function readEnum(type, json, ignoreUnknownFields, nullAsZeroValue) {
             break;
         case "string":
             const value = type.findName(json);
-            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-            if (value || ignoreUnknownFields) {
-                return value === null || value === void 0 ? void 0 : value.no;
+            if (value !== undefined) {
+                return value.no;
+            }
+            if (ignoreUnknownFields) {
+                return tokenIgnoredUnknownEnum;
             }
             break;
     }
     throw new Error(`cannot decode enum ${type.typeName} from JSON: ${debugJsonValue(json)}`);
 }
-function writeEnum(type, value, emitZeroValue, enumAsInteger) {
-    var _a;
-    if (value === undefined) {
-        return value;
+// Decide whether an unset field should be emitted with JSON write option `emitDefaultValues`
+function canEmitFieldDefaultValue(field) {
+    if (field.repeated || field.kind == "map") {
+        // maps are {}, repeated fields are []
+        return true;
+    }
+    if (field.oneof) {
+        // oneof fields are never emitted
+        return false;
     }
-    if (!emitZeroValue && type.values[0].no === value) {
-        // proto3 requires 0 to be default value for all enums
-        return undefined;
+    if (field.kind == "message") {
+        // singular message field are allowed to emit JSON null, but we do not
+        return false;
     }
-    if (enumAsInteger) {
-        return value;
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (field.opt || field.req) {
+        // the field uses explicit presence, so we cannot emit a zero value
+        return false;
+    }
+    return true;
+}
+function writeField(field, value, options) {
+    if (field.kind == "map") {
+        (0, assert_js_1.assert)(typeof value == "object" && value != null);
+        const jsonObj = {};
+        const entries = Object.entries(value);
+        switch (field.V.kind) {
+            case "scalar":
+                for (const [entryKey, entryValue] of entries) {
+                    jsonObj[entryKey.toString()] = writeScalar(field.V.T, entryValue); // JSON standard allows only (double quoted) string as property key
+                }
+                break;
+            case "message":
+                for (const [entryKey, entryValue] of entries) {
+                    // JSON standard allows only (double quoted) string as property key
+                    jsonObj[entryKey.toString()] = entryValue.toJson(options);
+                }
+                break;
+            case "enum":
+                const enumType = field.V.T;
+                for (const [entryKey, entryValue] of entries) {
+                    // JSON standard allows only (double quoted) string as property key
+                    jsonObj[entryKey.toString()] = writeEnum(enumType, entryValue, options.enumAsInteger);
+                }
+                break;
+        }
+        return options.emitDefaultValues || entries.length > 0
+            ? jsonObj
+            : undefined;
     }
+    if (field.repeated) {
+        (0, assert_js_1.assert)(Array.isArray(value));
+        const jsonArr = [];
+        switch (field.kind) {
+            case "scalar":
+                for (let i = 0; i < value.length; i++) {
+                    jsonArr.push(writeScalar(field.T, value[i]));
+                }
+                break;
+            case "enum":
+                for (let i = 0; i < value.length; i++) {
+                    jsonArr.push(writeEnum(field.T, value[i], options.enumAsInteger));
+                }
+                break;
+            case "message":
+                for (let i = 0; i < value.length; i++) {
+                    jsonArr.push(value[i].toJson(options));
+                }
+                break;
+        }
+        return options.emitDefaultValues || jsonArr.length > 0
+            ? jsonArr
+            : undefined;
+    }
+    switch (field.kind) {
+        case "scalar":
+            return writeScalar(field.T, value);
+        case "enum":
+            return writeEnum(field.T, value, options.enumAsInteger);
+        case "message":
+            return (0, field_wrapper_js_1.wrapField)(field.T, value).toJson(options);
+    }
+}
+function writeEnum(type, value, enumAsInteger) {
+    var _a;
+    (0, assert_js_1.assert)(typeof value == "number");
     if (type.typeName == "google.protobuf.NullValue") {
         return null;
     }
+    if (enumAsInteger) {
+        return value;
+    }
     const val = type.findNumber(value);
     return (_a = val === null || val === void 0 ? void 0 : val.name) !== null && _a !== void 0 ? _a : value; // if we don't know the enum value, just return the number
 }
-function writeScalar(type, value, emitZeroValue) {
-    if (value === undefined) {
-        return undefined;
-    }
+function writeScalar(type, value) {
     switch (type) {
         // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
-        case field_js_1.ScalarType.INT32:
-        case field_js_1.ScalarType.SFIXED32:
-        case field_js_1.ScalarType.SINT32:
-        case field_js_1.ScalarType.FIXED32:
-        case field_js_1.ScalarType.UINT32:
+        case scalar_js_1.ScalarType.INT32:
+        case scalar_js_1.ScalarType.SFIXED32:
+        case scalar_js_1.ScalarType.SINT32:
+        case scalar_js_1.ScalarType.FIXED32:
+        case scalar_js_1.ScalarType.UINT32:
             (0, assert_js_1.assert)(typeof value == "number");
-            return value != 0 || emitZeroValue ? value : undefined;
+            return value;
         // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
         // Either numbers or strings are accepted. Exponent notation is also accepted.
-        case field_js_1.ScalarType.FLOAT:
+        case scalar_js_1.ScalarType.FLOAT:
         // assertFloat32(value);
-        case field_js_1.ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
+        case scalar_js_1.ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
             (0, assert_js_1.assert)(typeof value == "number");
             if (Number.isNaN(value))
                 return "NaN";
@@ -502,34 +598,29 @@ function writeScalar(type, value, emitZeroValue) {
                 return "Infinity";
             if (value === Number.NEGATIVE_INFINITY)
                 return "-Infinity";
-            return value !== 0 || emitZeroValue ? value : undefined;
+            return value;
         // string:
-        case field_js_1.ScalarType.STRING:
+        case scalar_js_1.ScalarType.STRING:
             (0, assert_js_1.assert)(typeof value == "string");
-            return value.length > 0 || emitZeroValue ? value : undefined;
+            return value;
         // bool:
-        case field_js_1.ScalarType.BOOL:
+        case scalar_js_1.ScalarType.BOOL:
             (0, assert_js_1.assert)(typeof value == "boolean");
-            return value || emitZeroValue ? value : undefined;
+            return value;
         // JSON value will be a decimal string. Either numbers or strings are accepted.
-        case field_js_1.ScalarType.UINT64:
-        case field_js_1.ScalarType.FIXED64:
-        case field_js_1.ScalarType.INT64:
-        case field_js_1.ScalarType.SFIXED64:
-        case field_js_1.ScalarType.SINT64:
+        case scalar_js_1.ScalarType.UINT64:
+        case scalar_js_1.ScalarType.FIXED64:
+        case scalar_js_1.ScalarType.INT64:
+        case scalar_js_1.ScalarType.SFIXED64:
+        case scalar_js_1.ScalarType.SINT64:
             (0, assert_js_1.assert)(typeof value == "bigint" ||
                 typeof value == "string" ||
                 typeof value == "number");
-            // We use implicit conversion with `value != 0` to catch both 0n and "0"
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            return emitZeroValue || value != 0 ? value.toString(10) : undefined;
+            return value.toString();
         // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
         // Either standard or URL-safe base64 encoding with/without paddings are accepted.
-        case field_js_1.ScalarType.BYTES:
+        case scalar_js_1.ScalarType.BYTES:
             (0, assert_js_1.assert)(value instanceof Uint8Array);
-            return emitZeroValue || value.byteLength > 0
-                ? proto_base64_js_1.protoBase64.enc(value)
-                : undefined;
+            return proto_base64_js_1.protoBase64.enc(value);
     }
 }