@bufbuild/protobuf 1.7.2 → 1.8.0

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

@@ -12,13 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { Message } from "../message.js";
-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 */
+import { clearField, isFieldSet } from "./reflect.js";
+import { wrapField } from "./field-wrapper.js";
+import { scalarZeroValue } from "./scalars.js";
+import { isScalarZeroValue } from "./scalars.js";
+import { LongType, ScalarType } from "../scalar.js";
+import { isMessage } from "../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,
@@ -36,8 +41,9 @@ function makeReadOptions(options) {
 function makeWriteOptions(options) {
     return options ? Object.assign(Object.assign({}, jsonWriteDefaults), options) : jsonWriteDefaults;
 }
-export function makeJsonFormatCommon(nullAsZeroValue, makeWriteField) {
-    const writeField = makeWriteField(writeEnum, writeScalar);
+const tokenNull = Symbol();
+const tokenIgnoredUnknownEnum = Symbol();
+export function makeJsonFormat() {
     return {
         makeReadOptions,
         makeWriteOptions,
@@ -62,7 +68,7 @@ export 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;
@@ -73,7 +79,7 @@ export function makeJsonFormatCommon(nullAsZeroValue, makeWriteField) {
                         if (ext && ext.extendee.typeName == type.typeName) {
                             found = true;
                             const [container, get] = 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.
@@ -92,23 +98,23 @@ export 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 (!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;
@@ -139,8 +145,24 @@ export 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 : 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 || isScalarZeroValue(type, value)) {
+                return writeScalar(type, value);
+            }
+            return undefined;
+        },
         debug: debugJsonValue,
     };
 }
@@ -158,50 +180,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) {
+        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}`;
                         }
@@ -209,7 +219,6 @@ jsonValue, field, options, type, nullAsZeroValue) {
                     }
                     break;
             }
-            targetArray.push(val);
         }
     }
     else if (field.kind == "map") {
@@ -217,29 +226,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, LongType.BIGINT, true);
+                        targetMap[key] = 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)}`;
+                        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}`;
                         }
@@ -247,57 +267,59 @@ jsonValue, field, options, type, nullAsZeroValue) {
                     }
                     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 {
+        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) {
-                    target[localName].fromJson(jsonValue, options);
+                let currentValue = target[localName];
+                if (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:
+                        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:
+                            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}`;
                     }
@@ -307,12 +329,27 @@ 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 === 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, LongType.BIGINT, true).toString();
+}
 function readScalar(type, json, longType, nullAsZeroValue) {
+    if (json === null) {
+        if (nullAsZeroValue) {
+            return scalarZeroValue(type, longType);
+        }
+        return tokenNull;
+    }
     // every valid case in the switch below returns, and every fall
     // through is regarded as a failure.
     switch (type) {
@@ -320,8 +357,6 @@ function readScalar(type, json, longType, nullAsZeroValue) {
         // Either numbers or strings are accepted. Exponent notation is also accepted.
         case ScalarType.DOUBLE:
         case ScalarType.FLOAT:
-            if (json === null)
-                return nullAsZeroValue ? 0.0 : undefined;
             if (json === "NaN")
                 return Number.NaN;
             if (json === "Infinity")
@@ -357,8 +392,6 @@ function readScalar(type, json, longType, nullAsZeroValue) {
         case ScalarType.SFIXED32:
         case ScalarType.SINT32:
         case ScalarType.UINT32:
-            if (json === null)
-                return nullAsZeroValue ? 0 : undefined;
             let int32;
             if (typeof json == "number")
                 int32 = json;
@@ -377,8 +410,6 @@ function readScalar(type, json, longType, nullAsZeroValue) {
         case ScalarType.INT64:
         case ScalarType.SFIXED64:
         case ScalarType.SINT64:
-            if (json === null)
-                return nullAsZeroValue ? protoInt64.zero : undefined;
             if (typeof json != "number" && typeof json != "string")
                 break;
             const long = protoInt64.parse(json);
@@ -386,8 +417,6 @@ function readScalar(type, json, longType, nullAsZeroValue) {
             return longType ? long.toString() : long;
         case ScalarType.FIXED64:
         case ScalarType.UINT64:
-            if (json === null)
-                return nullAsZeroValue ? protoInt64.zero : undefined;
             if (typeof json != "number" && typeof json != "string")
                 break;
             const uLong = protoInt64.uParse(json);
@@ -395,15 +424,11 @@ function readScalar(type, json, longType, nullAsZeroValue) {
             return longType ? uLong.toString() : uLong;
         // bool:
         case ScalarType.BOOL:
-            if (json === null)
-                return nullAsZeroValue ? false : undefined;
             if (typeof json !== "boolean")
                 break;
             return json;
         // string:
         case ScalarType.STRING:
-            if (json === null)
-                return nullAsZeroValue ? "" : undefined;
             if (typeof json !== "string") {
                 break;
             }
@@ -419,8 +444,6 @@ function readScalar(type, json, longType, nullAsZeroValue) {
         // 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)
-                return nullAsZeroValue ? new Uint8Array(0) : undefined;
             if (json === "")
                 return new Uint8Array(0);
             if (typeof json !== "string")
@@ -429,14 +452,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) {
@@ -447,36 +468,112 @@ 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") {
+        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) {
+        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 wrapField(field.T, value).toJson(options);
+    }
+}
+function writeEnum(type, value, enumAsInteger) {
+    var _a;
+    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 ScalarType.INT32:
@@ -485,7 +582,7 @@ function writeScalar(type, value, emitZeroValue) {
         case ScalarType.FIXED32:
         case ScalarType.UINT32:
             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 ScalarType.FLOAT:
@@ -498,15 +595,15 @@ function writeScalar(type, value, emitZeroValue) {
                 return "Infinity";
             if (value === Number.NEGATIVE_INFINITY)
                 return "-Infinity";
-            return value !== 0 || emitZeroValue ? value : undefined;
+            return value;
         // string:
         case ScalarType.STRING:
             assert(typeof value == "string");
-            return value.length > 0 || emitZeroValue ? value : undefined;
+            return value;
         // bool:
         case ScalarType.BOOL:
             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 ScalarType.UINT64:
         case ScalarType.FIXED64:
@@ -516,16 +613,11 @@ function writeScalar(type, value, emitZeroValue) {
             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 ScalarType.BYTES:
             assert(value instanceof Uint8Array);
-            return emitZeroValue || value.byteLength > 0
-                ? protoBase64.enc(value)
-                : undefined;
+            return protoBase64.enc(value);
     }
 }

package/dist/esm/private/proto-runtime.d.ts

@@ -50,4 +50,4 @@ export interface ProtoRuntime {
      */
     makeExtension<E extends Message<E> = AnyMessage, V = unknown>(typeName: string, extendee: MessageType<E>, field: ExtensionFieldSource): Extension<E, V>;
 }
-export declare function makeProtoRuntime(syntax: string, json: JsonFormat, bin: BinaryFormat, util: Util): ProtoRuntime;
+export declare function makeProtoRuntime(syntax: string, newFieldList: Util["newFieldList"], initFields: Util["initFields"]): ProtoRuntime;

package/dist/esm/private/proto-runtime.js

@@ -14,12 +14,16 @@
 import { getEnumType, makeEnum, makeEnumType } from "./enum.js";
 import { makeMessageType } from "./message-type.js";
 import { makeExtension } from "./extensions.js";
-export function makeProtoRuntime(syntax, json, bin, util) {
+import { makeJsonFormat } from "./json-format.js";
+import { makeBinaryFormat } from "./binary-format.js";
+import { makeUtilCommon } from "./util-common.js";
+export function makeProtoRuntime(syntax, newFieldList, initFields) {
     return {
         syntax,
-        json,
-        bin,
-        util,
+        json: makeJsonFormat(),
+        bin: makeBinaryFormat(),
+        util: Object.assign(Object.assign({}, makeUtilCommon()), { newFieldList,
+            initFields }),
         makeMessageType(typeName, fields, opt) {
             return makeMessageType(this, typeName, fields, opt);
         },

package/dist/esm/private/reflect.d.ts

@@ -0,0 +1,9 @@
+import type { FieldInfo } from "../field.js";
+/**
+ * Returns true if the field is set.
+ */
+export declare function isFieldSet(field: FieldInfo, target: Record<string, any>): boolean;
+/**
+ * Resets the field, so that isFieldSet() will return false.
+ */
+export declare function clearField(field: FieldInfo, target: Record<string, any>): void;