@bufbuild/protobuf 1.5.1 → 1.7.0

package/dist/esm/private/feature-set.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.
@@ -21,7 +21,8 @@ export const featureSetDefaults = FeatureSetDefaults.fromBinary(protoBase64.dec(
 /**
  * Create an edition feature resolver with the given feature set defaults.
  */
-export function createFeatureResolver(compiledFeatureSetDefaults) {
+export function createFeatureResolver(compiledFeatureSetDefaults, edition) {
+    var _a, _b;
     const min = compiledFeatureSetDefaults.minimumEdition;
     const max = compiledFeatureSetDefaults.maximumEdition;
     if (min === undefined ||
@@ -29,37 +30,31 @@ export function createFeatureResolver(compiledFeatureSetDefaults) {
         compiledFeatureSetDefaults.defaults.some((d) => d.edition === undefined)) {
         throw new Error("Invalid FeatureSetDefaults");
     }
-    const defaultsBinByEdition = new Map();
-    return (edition, ...rest) => {
-        var _a, _b;
-        let defaultsBin = defaultsBinByEdition.get(edition);
-        if (defaultsBin === undefined) {
-            if (edition < min) {
-                throw new Error(`Edition ${Edition[edition]} is earlier than the minimum supported edition ${Edition[min]}`);
-            }
-            if (max < edition) {
-                throw new Error(`Edition ${Edition[edition]} is later than the maximum supported edition ${Edition[max]}`);
-            }
-            let highestMatch = undefined;
-            for (const c of compiledFeatureSetDefaults.defaults) {
-                const e = (_a = c.edition) !== null && _a !== void 0 ? _a : 0;
-                if (e > edition) {
-                    continue;
-                }
-                if (highestMatch !== undefined && highestMatch.e > e) {
-                    continue;
-                }
-                highestMatch = {
-                    e,
-                    f: (_b = c.features) !== null && _b !== void 0 ? _b : new FeatureSet(),
-                };
-            }
-            if (highestMatch === undefined) {
-                throw new Error(`No valid default found for edition ${Edition[edition]}`);
-            }
-            defaultsBin = highestMatch.f.toBinary();
-            defaultsBinByEdition.set(edition, defaultsBin);
+    if (edition < min) {
+        throw new Error(`Edition ${Edition[edition]} is earlier than the minimum supported edition ${Edition[min]}`);
+    }
+    if (max < edition) {
+        throw new Error(`Edition ${Edition[edition]} is later than the maximum supported edition ${Edition[max]}`);
+    }
+    let highestMatch = undefined;
+    for (const c of compiledFeatureSetDefaults.defaults) {
+        const e = (_a = c.edition) !== null && _a !== void 0 ? _a : 0;
+        if (e > edition) {
+            continue;
+        }
+        if (highestMatch !== undefined && highestMatch.e > e) {
+            continue;
         }
+        highestMatch = {
+            e,
+            f: (_b = c.features) !== null && _b !== void 0 ? _b : new FeatureSet(),
+        };
+    }
+    if (highestMatch === undefined) {
+        throw new Error(`No valid default found for edition ${Edition[edition]}`);
+    }
+    const defaultsBin = highestMatch.f.toBinary();
+    return (...rest) => {
         const f = FeatureSet.fromBinary(defaultsBin);
         for (const c of rest) {
             if (c !== undefined) {

package/dist/esm/private/field-list.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/field-wrapper.d.ts

@@ -1,6 +1,6 @@
 import { Message } from "../message.js";
 import type { MessageType } from "../message-type.js";
-import type { DescField } from "../descriptor-set.js";
+import type { DescExtension, DescField } from "../descriptor-set.js";
 import { ScalarType } from "../field.js";
 /**
  * A field wrapper unwraps a message to a primitive value that is more
@@ -22,4 +22,4 @@ export declare function wrapField<T extends Message<T>>(type: MessageType<T>, va
  * If the given field uses one of the well-known wrapper types, return
  * the primitive type it wraps.
  */
-export declare function getUnwrappedFieldType(field: DescField): ScalarType | undefined;
+export declare function getUnwrappedFieldType(field: DescField | DescExtension): ScalarType | undefined;

package/dist/esm/private/field-wrapper.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/field.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/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 = {
@@ -41,164 +43,45 @@ export function makeJsonFormatCommon(makeWriteField) {
         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);
                 }
-                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);
+                            // 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
@@ -259,6 +157,153 @@ function debugJsonValue(json) {
             return String(json);
     }
 }
+// Read a JSON value for a field.
+// The "type" argument is only used to provide context in errors.
+function readField(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+jsonValue, field, options, type) {
+    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);
+                    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: ${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);
+                    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: ${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).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);
+                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: ${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) {
@@ -270,7 +315,7 @@ function readScalar(type, json, longType) {
         case ScalarType.DOUBLE:
         case ScalarType.FLOAT:
             if (json === null)
-                return 0.0;
+                return 0.0; // TODO field presence: this should reset the field with explicit presence
             if (json === "NaN")
                 return Number.NaN;
             if (json === "Infinity")
@@ -307,7 +352,7 @@ function readScalar(type, json, longType) {
         case ScalarType.SINT32:
         case ScalarType.UINT32:
             if (json === null)
-                return 0;
+                return 0; // TODO field presence: this should reset the field with explicit presence
             let int32;
             if (typeof json == "number")
                 int32 = json;
@@ -327,7 +372,7 @@ function readScalar(type, json, longType) {
         case ScalarType.SFIXED64:
         case ScalarType.SINT64:
             if (json === null)
-                return protoInt64.zero;
+                return protoInt64.zero; // TODO field presence: this should reset the field with explicit presence
             if (typeof json != "number" && typeof json != "string")
                 break;
             const long = protoInt64.parse(json);
@@ -336,7 +381,7 @@ function readScalar(type, json, longType) {
         case ScalarType.FIXED64:
         case ScalarType.UINT64:
             if (json === null)
-                return protoInt64.zero;
+                return protoInt64.zero; // TODO field presence: this should reset the field with explicit presence
             if (typeof json != "number" && typeof json != "string")
                 break;
             const uLong = protoInt64.uParse(json);
@@ -345,14 +390,14 @@ function readScalar(type, json, longType) {
         // bool:
         case ScalarType.BOOL:
             if (json === null)
-                return false;
+                return false; // TODO field presence: this should reset the field with explicit presence
             if (typeof json !== "boolean")
                 break;
             return json;
         // string:
         case ScalarType.STRING:
             if (json === null)
-                return "";
+                return ""; // TODO field presence: this should reset the field with explicit presence
             if (typeof json !== "string") {
                 break;
             }
@@ -369,7 +414,7 @@ function readScalar(type, json, longType) {
         // Either standard or URL-safe base64 encoding with/without paddings are accepted.
         case ScalarType.BYTES:
             if (json === null || json === "")
-                return new Uint8Array(0);
+                return new Uint8Array(0); // TODO field presence: this should reset the field with explicit presence
             if (typeof json !== "string")
                 break;
             return protoBase64.dec(json);
@@ -379,6 +424,7 @@ function readScalar(type, json, longType) {
 function readEnum(type, json, ignoreUnknownFields) {
     if (json === null) {
         // proto3 requires 0 to be default value for all enums
+        // TODO field presence: this should reset the field with explicit presence
         return 0;
     }
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check

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,6 +16,7 @@ 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() {
+    // TODO field presence: merge this function with proto2
     return makeJsonFormatCommon((writeEnum, writeScalar) => {
         return function writeField(field, value, options) {
             if (field.kind == "map") {

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,6 +16,7 @@ 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() {
+    // TODO field presence: merge this function with proto2
     return makeJsonFormatCommon((writeEnum, writeScalar) => {
         return function writeField(field, value, options) {
             if (field.kind == "map") {
@@ -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.
  */