@bufbuild/protobuf 1.6.0 → 1.7.1

package/dist/esm/private/json-format-common.js

@@ -1,4 +1,4 @@
-// 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.
@@ -16,6 +16,8 @@ import { LongType, ScalarType } from "../field.js";
 import { assert, assertFloat32, assertInt32, assertUInt32 } from "./assert.js";
 import { protoInt64 } from "../proto-int64.js";
 import { protoBase64 } from "../proto-base64.js";
+import { createExtensionContainer } from "./extensions.js";
+import { getExtension, hasExtension, setExtension, } from "../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 */
 // Default options for parsing JSON.
 const jsonReadDefaults = {
@@ -34,171 +36,52 @@ function makeReadOptions(options) {
 function makeWriteOptions(options) {
     return options ? Object.assign(Object.assign({}, jsonWriteDefaults), options) : jsonWriteDefaults;
 }
-export function makeJsonFormatCommon(makeWriteField) {
+export function makeJsonFormatCommon(nullAsZeroValue, makeWriteField) {
     const writeField = makeWriteField(writeEnum, writeScalar);
     return {
         makeReadOptions,
         makeWriteOptions,
         readMessage(type, json, options, message) {
             if (json == null || Array.isArray(json) || typeof json != "object") {
-                throw new Error(`cannot decode message ${type.typeName} from JSON: ${this.debug(json)}`);
+                throw new Error(`cannot decode message ${type.typeName} from JSON: ${debugJsonValue(json)}`);
             }
             message = message !== null && message !== void 0 ? message : new type();
-            const oneofSeen = {};
+            const oneofSeen = new Map();
+            const registry = options.typeRegistry;
             for (const [jsonKey, jsonValue] of Object.entries(json)) {
                 const field = type.fields.findJsonName(jsonKey);
-                if (!field) {
-                    if (!options.ignoreUnknownFields) {
-                        throw new Error(`cannot decode message ${type.typeName} from JSON: key "${jsonKey}" is unknown`);
-                    }
-                    continue;
-                }
-                let localName = field.localName;
-                let target = message;
-                if (field.oneof) {
-                    if (jsonValue === null && field.kind == "scalar") {
-                        // see conformance test Required.Proto3.JsonInput.OneofFieldNull{First,Second}
-                        continue;
-                    }
-                    const seen = oneofSeen[field.oneof.localName];
-                    if (seen) {
-                        throw new Error(`cannot decode message ${type.typeName} from JSON: multiple keys for oneof "${field.oneof.name}" present: "${seen}", "${jsonKey}"`);
-                    }
-                    oneofSeen[field.oneof.localName] = jsonKey;
-                    target = target[field.oneof.localName] = { case: localName };
-                    localName = "value";
-                }
-                if (field.repeated) {
-                    if (jsonValue === null) {
-                        continue;
-                    }
-                    if (!Array.isArray(jsonValue)) {
-                        throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: ${this.debug(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: ${this.debug(jsonItem)}`);
+                if (field) {
+                    if (field.oneof) {
+                        if (jsonValue === null && field.kind == "scalar") {
+                            // see conformance test Required.Proto3.JsonInput.OneofFieldNull{First,Second}
+                            continue;
                         }
-                        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);
-                                break;
-                            case "enum":
-                                val = readEnum(field.T, jsonItem, options.ignoreUnknownFields);
-                                if (val === undefined)
-                                    continue;
-                                break;
-                            case "scalar":
-                                try {
-                                    val = readScalar(field.T, jsonItem, field.L);
-                                }
-                                catch (e) {
-                                    let m = `cannot decode field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonItem)}`;
-                                    if (e instanceof Error && e.message.length > 0) {
-                                        m += `: ${e.message}`;
-                                    }
-                                    throw new Error(m);
-                                }
-                                break;
+                        const seen = oneofSeen.get(field.oneof);
+                        if (seen !== undefined) {
+                            throw new Error(`cannot decode message ${type.typeName} from JSON: multiple keys for oneof "${field.oneof.name}" present: "${seen}", "${jsonKey}"`);
                         }
-                        targetArray.push(val);
+                        oneofSeen.set(field.oneof, jsonKey);
                     }
+                    readField(message, jsonValue, field, options, type, nullAsZeroValue);
                 }
-                else if (field.kind == "map") {
-                    if (jsonValue === null) {
-                        continue;
-                    }
-                    if (Array.isArray(jsonValue) || typeof jsonValue != "object") {
-                        throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: ${this.debug(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`);
-                        }
-                        let val;
-                        switch (field.V.kind) {
-                            case "message":
-                                val = field.V.T.fromJson(jsonMapValue, options);
-                                break;
-                            case "enum":
-                                val = readEnum(field.V.T, jsonMapValue, options.ignoreUnknownFields);
-                                if (val === undefined)
-                                    continue;
-                                break;
-                            case "scalar":
-                                try {
-                                    val = readScalar(field.V.T, jsonMapValue, LongType.BIGINT);
-                                }
-                                catch (e) {
-                                    let m = `cannot decode map value for field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonValue)}`;
-                                    if (e instanceof Error && e.message.length > 0) {
-                                        m += `: ${e.message}`;
-                                    }
-                                    throw new Error(m);
-                                }
-                                break;
-                        }
-                        try {
-                            targetMap[readScalar(field.K, field.K == ScalarType.BOOL
-                                ? jsonMapKey == "true"
-                                    ? true
-                                    : jsonMapKey == "false"
-                                        ? false
-                                        : jsonMapKey
-                                : jsonMapKey, LongType.BIGINT).toString()] = val;
-                        }
-                        catch (e) {
-                            let m = `cannot decode map key for field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonValue)}`;
-                            if (e instanceof Error && e.message.length > 0) {
-                                m += `: ${e.message}`;
-                            }
-                            throw new Error(m);
+                else {
+                    let found = false;
+                    if ((registry === null || registry === void 0 ? void 0 : registry.findExtension) &&
+                        jsonKey.startsWith("[") &&
+                        jsonKey.endsWith("]")) {
+                        const ext = registry.findExtension(jsonKey.substring(1, jsonKey.length - 1));
+                        if (ext && ext.extendee.typeName == type.typeName) {
+                            found = true;
+                            const [container, get] = createExtensionContainer(ext);
+                            readField(container, jsonValue, ext.field, options, ext, true);
+                            // We pass on the options as BinaryReadOptions/BinaryWriteOptions,
+                            // so that users can bring their own binary reader and writer factories
+                            // if necessary.
+                            setExtension(message, ext, get(), options);
                         }
                     }
-                }
-                else {
-                    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 "${jsonKey}"`);
-                                }
-                                continue;
-                            }
-                            if (target[localName] instanceof Message) {
-                                target[localName].fromJson(jsonValue, options);
-                            }
-                            else {
-                                target[localName] = messageType.fromJson(jsonValue, options);
-                                if (messageType.fieldWrapper && !field.oneof) {
-                                    target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
-                                }
-                            }
-                            break;
-                        case "enum":
-                            const enumValue = readEnum(field.T, jsonValue, options.ignoreUnknownFields);
-                            if (enumValue !== undefined) {
-                                target[localName] = enumValue;
-                            }
-                            break;
-                        case "scalar":
-                            try {
-                                target[localName] = readScalar(field.T, jsonValue, field.L);
-                            }
-                            catch (e) {
-                                let m = `cannot decode field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonValue)}`;
-                                if (e instanceof Error && e.message.length > 0) {
-                                    m += `: ${e.message}`;
-                                }
-                                throw new Error(m);
-                            }
-                            break;
+                    if (!found && !options.ignoreUnknownFields) {
+                        throw new Error(`cannot decode message ${type.typeName} from JSON: key "${jsonKey}" is unknown`);
                     }
                 }
             }
@@ -231,6 +114,21 @@ export function makeJsonFormatCommon(makeWriteField) {
                             jsonValue;
                     }
                 }
+                const registry = options.typeRegistry;
+                if (registry === null || registry === void 0 ? void 0 : registry.findExtensionFor) {
+                    for (const uf of type.runtime.bin.listUnknownFields(message)) {
+                        const ext = registry.findExtensionFor(type.typeName, uf.no);
+                        if (ext && hasExtension(message, ext)) {
+                            // We pass on the options as BinaryReadOptions, so that users can bring their own
+                            // binary reader factory if necessary.
+                            const value = getExtension(message, ext, options);
+                            const jsonValue = writeField(ext.field, value, options);
+                            if (jsonValue !== undefined) {
+                                json[ext.field.jsonName] = jsonValue;
+                            }
+                        }
+                    }
+                }
             }
             catch (e) {
                 const m = field
@@ -241,7 +139,7 @@ export function makeJsonFormatCommon(makeWriteField) {
             }
             return json;
         },
-        readScalar,
+        readScalar: (type, json, longType) => readScalar(type, json, longType, nullAsZeroValue), // eslint-disable-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
         writeScalar,
         debug: debugJsonValue,
     };
@@ -259,9 +157,162 @@ function debugJsonValue(json) {
             return String(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) {
+    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) {
+        if (jsonValue === null) {
+            return;
+        }
+        if (!Array.isArray(jsonValue)) {
+            throw new Error(`cannot decode field ${type.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)}`);
+            }
+            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);
+                    break;
+                case "enum":
+                    val = readEnum(field.T, jsonItem, options.ignoreUnknownFields, true);
+                    if (val === undefined)
+                        continue;
+                    break;
+                case "scalar":
+                    try {
+                        val = readScalar(field.T, jsonItem, field.L, true);
+                    }
+                    catch (e) {
+                        let m = `cannot decode field ${type.typeName}.${field.name} from JSON: ${debugJsonValue(jsonItem)}`;
+                        if (e instanceof Error && e.message.length > 0) {
+                            m += `: ${e.message}`;
+                        }
+                        throw new Error(m);
+                    }
+                    break;
+            }
+            targetArray.push(val);
+        }
+    }
+    else if (field.kind == "map") {
+        if (jsonValue === null) {
+            return;
+        }
+        if (typeof jsonValue != "object" || Array.isArray(jsonValue)) {
+            throw new Error(`cannot decode field ${type.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`);
+            }
+            let val;
+            switch (field.V.kind) {
+                case "message":
+                    val = field.V.T.fromJson(jsonMapValue, options);
+                    break;
+                case "enum":
+                    val = readEnum(field.V.T, jsonMapValue, options.ignoreUnknownFields, true);
+                    if (val === undefined)
+                        continue;
+                    break;
+                case "scalar":
+                    try {
+                        val = readScalar(field.V.T, jsonMapValue, LongType.BIGINT, true);
+                    }
+                    catch (e) {
+                        let m = `cannot decode map value 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);
+                    }
+                    break;
+            }
+            try {
+                targetMap[readScalar(field.K, field.K == ScalarType.BOOL
+                    ? jsonMapKey == "true"
+                        ? true
+                        : jsonMapKey == "false"
+                            ? false
+                            : jsonMapKey
+                    : jsonMapKey, 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 {
+        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) {
+                    target[localName].fromJson(jsonValue, options);
+                }
+                else {
+                    target[localName] = messageType.fromJson(jsonValue, options);
+                    if (messageType.fieldWrapper && !field.oneof) {
+                        target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
+                    }
+                }
+                break;
+            case "enum":
+                const enumValue = readEnum(field.T, jsonValue, options.ignoreUnknownFields, nullAsZeroValue);
+                if (enumValue !== undefined) {
+                    target[localName] = enumValue;
+                }
+                break;
+            case "scalar":
+                try {
+                    target[localName] = readScalar(field.T, jsonValue, field.L, nullAsZeroValue);
+                }
+                catch (e) {
+                    let m = `cannot decode field ${type.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
+                    if (e instanceof Error && e.message.length > 0) {
+                        m += `: ${e.message}`;
+                    }
+                    throw new Error(m);
+                }
+                break;
+        }
+    }
+}
 // May throw an error. If the error message is non-blank, it should be shown.
 // It is up to the caller to provide context.
-function readScalar(type, json, longType) {
+// 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 readScalar(type, json, longType, nullAsZeroValue) {
     // every valid case in the switch below returns, and every fall
     // through is regarded as a failure.
     switch (type) {
@@ -270,7 +321,7 @@ function readScalar(type, json, longType) {
         case ScalarType.DOUBLE:
         case ScalarType.FLOAT:
             if (json === null)
-                return 0.0;
+                return nullAsZeroValue ? 0.0 : undefined;
             if (json === "NaN")
                 return Number.NaN;
             if (json === "Infinity")
@@ -307,7 +358,7 @@ function readScalar(type, json, longType) {
         case ScalarType.SINT32:
         case ScalarType.UINT32:
             if (json === null)
-                return 0;
+                return nullAsZeroValue ? 0 : undefined;
             let int32;
             if (typeof json == "number")
                 int32 = json;
@@ -327,7 +378,7 @@ function readScalar(type, json, longType) {
         case ScalarType.SFIXED64:
         case ScalarType.SINT64:
             if (json === null)
-                return protoInt64.zero;
+                return nullAsZeroValue ? protoInt64.zero : undefined;
             if (typeof json != "number" && typeof json != "string")
                 break;
             const long = protoInt64.parse(json);
@@ -336,7 +387,7 @@ function readScalar(type, json, longType) {
         case ScalarType.FIXED64:
         case ScalarType.UINT64:
             if (json === null)
-                return protoInt64.zero;
+                return nullAsZeroValue ? protoInt64.zero : undefined;
             if (typeof json != "number" && typeof json != "string")
                 break;
             const uLong = protoInt64.uParse(json);
@@ -345,14 +396,14 @@ function readScalar(type, json, longType) {
         // bool:
         case ScalarType.BOOL:
             if (json === null)
-                return false;
+                return nullAsZeroValue ? false : undefined;
             if (typeof json !== "boolean")
                 break;
             return json;
         // string:
         case ScalarType.STRING:
             if (json === null)
-                return "";
+                return nullAsZeroValue ? "" : undefined;
             if (typeof json !== "string") {
                 break;
             }
@@ -368,7 +419,9 @@ function readScalar(type, json, longType) {
         // 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 ScalarType.BYTES:
-            if (json === null || json === "")
+            if (json === null)
+                return nullAsZeroValue ? new Uint8Array(0) : undefined;
+            if (json === "")
                 return new Uint8Array(0);
             if (typeof json !== "string")
                 break;
@@ -376,10 +429,14 @@ function readScalar(type, json, longType) {
     }
     throw new Error();
 }
-function readEnum(type, json, ignoreUnknownFields) {
+// 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
-        return 0;
+        // 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;
     }
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
     switch (typeof json) {
@@ -398,12 +455,12 @@ function readEnum(type, json, ignoreUnknownFields) {
     }
     throw new Error(`cannot decode enum ${type.typeName} from JSON: ${debugJsonValue(json)}`);
 }
-function writeEnum(type, value, emitIntrinsicDefault, enumAsInteger) {
+function writeEnum(type, value, emitZeroValue, enumAsInteger) {
     var _a;
     if (value === undefined) {
         return value;
     }
-    if (value === 0 && !emitIntrinsicDefault) {
+    if (!emitZeroValue && type.values[0].no === value) {
         // proto3 requires 0 to be default value for all enums
         return undefined;
     }
@@ -416,7 +473,7 @@ function writeEnum(type, value, emitIntrinsicDefault, enumAsInteger) {
     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, emitIntrinsicDefault) {
+function writeScalar(type, value, emitZeroValue) {
     if (value === undefined) {
         return undefined;
     }
@@ -428,7 +485,7 @@ function writeScalar(type, value, emitIntrinsicDefault) {
         case ScalarType.FIXED32:
         case ScalarType.UINT32:
             assert(typeof value == "number");
-            return value != 0 || emitIntrinsicDefault ? value : undefined;
+            return value != 0 || emitZeroValue ? value : undefined;
         // 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 ScalarType.FLOAT:
@@ -441,15 +498,15 @@ function writeScalar(type, value, emitIntrinsicDefault) {
                 return "Infinity";
             if (value === Number.NEGATIVE_INFINITY)
                 return "-Infinity";
-            return value !== 0 || emitIntrinsicDefault ? value : undefined;
+            return value !== 0 || emitZeroValue ? value : undefined;
         // string:
         case ScalarType.STRING:
             assert(typeof value == "string");
-            return value.length > 0 || emitIntrinsicDefault ? value : undefined;
+            return value.length > 0 || emitZeroValue ? value : undefined;
         // bool:
         case ScalarType.BOOL:
             assert(typeof value == "boolean");
-            return value || emitIntrinsicDefault ? value : undefined;
+            return value || emitZeroValue ? value : undefined;
         // JSON value will be a decimal string. Either numbers or strings are accepted.
         case ScalarType.UINT64:
         case ScalarType.FIXED64:
@@ -462,14 +519,12 @@ function writeScalar(type, value, emitIntrinsicDefault) {
             // 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 emitIntrinsicDefault || value != 0
-                ? value.toString(10)
-                : undefined;
+            return emitZeroValue || value != 0 ? value.toString(10) : undefined;
         // 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 ScalarType.BYTES:
             assert(value instanceof Uint8Array);
-            return emitIntrinsicDefault || value.byteLength > 0
+            return emitZeroValue || value.byteLength > 0
                 ? protoBase64.enc(value)
                 : undefined;
     }

package/dist/esm/private/json-format-proto2.js

@@ -1,4 +1,4 @@
-// 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.
@@ -16,7 +16,8 @@ import { assert } from "./assert.js";
 import { makeJsonFormatCommon } from "./json-format-common.js";
 /* eslint-disable no-case-declarations, @typescript-eslint/restrict-plus-operands,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
 export function makeJsonFormatProto2() {
-    return makeJsonFormatCommon((writeEnum, writeScalar) => {
+    // TODO field presence: merge this function with proto3. the reading side already switches behavior on the nullAsZeroValue argument.
+    return makeJsonFormatCommon(false, (writeEnum, writeScalar) => {
         return function writeField(field, value, options) {
             if (field.kind == "map") {
                 const jsonObj = {};

package/dist/esm/private/json-format-proto3.js

@@ -1,4 +1,4 @@
-// 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.
@@ -16,7 +16,8 @@ import { assert } from "./assert.js";
 import { makeJsonFormatCommon } from "./json-format-common.js";
 /* eslint-disable no-case-declarations, @typescript-eslint/restrict-plus-operands,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
 export function makeJsonFormatProto3() {
-    return makeJsonFormatCommon((writeEnum, writeScalar) => {
+    // TODO field presence: merge this function with proto2. the reading side already switches behavior on the nullAsZeroValue argument.
+    return makeJsonFormatCommon(true, (writeEnum, writeScalar) => {
         return function writeField(field, value, options) {
             if (field.kind == "map") {
                 const jsonObj = {};
@@ -63,7 +64,7 @@ export function makeJsonFormatProto3() {
                         break;
                     case "message":
                         for (let i = 0; i < value.length; i++) {
-                            jsonArr.push(wrapField(field.T, value[i]).toJson(options));
+                            jsonArr.push(value[i].toJson(options));
                         }
                         break;
                 }
@@ -72,15 +73,16 @@ export function makeJsonFormatProto3() {
                     : undefined;
             }
             else {
+                if (value === undefined) {
+                    return undefined;
+                }
                 switch (field.kind) {
                     case "scalar":
                         return writeScalar(field.T, value, !!field.oneof || field.opt || options.emitDefaultValues);
                     case "enum":
                         return writeEnum(field.T, value, !!field.oneof || field.opt || options.emitDefaultValues, options.enumAsInteger);
                     case "message":
-                        return value !== undefined
-                            ? wrapField(field.T, value).toJson(options)
-                            : undefined;
+                        return wrapField(field.T, value).toJson(options);
                 }
             }
         };

package/dist/esm/private/message-type.js

@@ -1,4 +1,4 @@
-// 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/dist/esm/private/names.d.ts

@@ -1,4 +1,4 @@
-import type { DescEnum, DescEnumValue, DescField, DescMessage, DescService } from "../descriptor-set.js";
+import type { DescEnum, DescEnumValue, DescExtension, DescField, DescMessage, DescService } from "../descriptor-set.js";
 import type { DescMethod, DescOneof } from "../descriptor-set.js";
 /**
  * Returns the name of a protobuf element in generated code.
@@ -8,7 +8,7 @@ import type { DescMethod, DescOneof } from "../descriptor-set.js";
  * the type name. For nested messages and enumerations, the names are joined
  * with an underscore. For methods, the first character is made lowercase.
  */
-export declare function localName(desc: DescEnum | DescEnumValue | DescMessage | DescOneof | DescField | DescService | DescMethod): string;
+export declare function localName(desc: DescEnum | DescEnumValue | DescMessage | DescExtension | DescOneof | DescField | DescService | DescMethod): string;
 /**
  * Returns the name of a field in generated code.
  */

package/dist/esm/private/names.js

@@ -1,4 +1,4 @@
-// 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.
@@ -27,7 +27,8 @@ export function localName(desc) {
             return localOneofName(desc.name);
         case "enum":
         case "message":
-        case "service": {
+        case "service":
+        case "extension": {
             const pkg = desc.file.proto.package;
             const offset = pkg === undefined ? 0 : pkg.length + 1;
             const name = desc.typeName.substring(offset).replace(/\./g, "_");