@bufbuild/protobuf 0.0.8 → 0.1.0

package/dist/cjs/index.js

@@ -27,7 +27,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BinaryReader = exports.BinaryWriter = exports.WireType = exports.DescriptorSet = exports.DescriptorRegistry = exports.TypeRegistry = exports.MethodIdempotency = exports.MethodKind = exports.ScalarType = exports.Message = exports.protoBase64 = exports.protoInt64 = exports.proto2 = exports.proto3 = void 0;
+exports.createRegistryFromDescriptors = exports.createRegistry = exports.createDescriptorSet = exports.BinaryReader = exports.BinaryWriter = exports.WireType = exports.MethodIdempotency = exports.MethodKind = exports.ScalarType = exports.Message = exports.codegenInfo = exports.protoBase64 = exports.protoInt64 = exports.proto2 = exports.proto3 = void 0;
 var proto3_js_1 = require("./proto3.js");
 Object.defineProperty(exports, "proto3", { enumerable: true, get: function () { return proto3_js_1.proto3; } });
 var proto2_js_1 = require("./proto2.js");
@@ -36,6 +36,8 @@ var proto_int64_js_1 = require("./proto-int64.js");
 Object.defineProperty(exports, "protoInt64", { enumerable: true, get: function () { return proto_int64_js_1.protoInt64; } });
 var proto_base64_js_1 = require("./proto-base64.js");
 Object.defineProperty(exports, "protoBase64", { enumerable: true, get: function () { return proto_base64_js_1.protoBase64; } });
+var codegen_info_js_1 = require("./codegen-info.js");
+Object.defineProperty(exports, "codegenInfo", { enumerable: true, get: function () { return codegen_info_js_1.codegenInfo; } });
 var message_js_1 = require("./message.js");
 Object.defineProperty(exports, "Message", { enumerable: true, get: function () { return message_js_1.Message; } });
 var field_js_1 = require("./field.js");
@@ -43,17 +45,19 @@ Object.defineProperty(exports, "ScalarType", { enumerable: true, get: function (
 var service_type_js_1 = require("./service-type.js");
 Object.defineProperty(exports, "MethodKind", { enumerable: true, get: function () { return service_type_js_1.MethodKind; } });
 Object.defineProperty(exports, "MethodIdempotency", { enumerable: true, get: function () { return service_type_js_1.MethodIdempotency; } });
-var type_registry_js_1 = require("./type-registry.js");
-Object.defineProperty(exports, "TypeRegistry", { enumerable: true, get: function () { return type_registry_js_1.TypeRegistry; } });
-var descriptor_registry_js_1 = require("./descriptor-registry.js");
-Object.defineProperty(exports, "DescriptorRegistry", { enumerable: true, get: function () { return descriptor_registry_js_1.DescriptorRegistry; } });
-var descriptor_set_js_1 = require("./descriptor-set.js");
-Object.defineProperty(exports, "DescriptorSet", { enumerable: true, get: function () { return descriptor_set_js_1.DescriptorSet; } });
 var binary_encoding_js_1 = require("./binary-encoding.js");
 Object.defineProperty(exports, "WireType", { enumerable: true, get: function () { return binary_encoding_js_1.WireType; } });
 Object.defineProperty(exports, "BinaryWriter", { enumerable: true, get: function () { return binary_encoding_js_1.BinaryWriter; } });
 Object.defineProperty(exports, "BinaryReader", { enumerable: true, get: function () { return binary_encoding_js_1.BinaryReader; } });
 var json_format_js_1 = require("./json-format.js");
+var descriptor_set_js_1 = require("./descriptor-set.js");
+var create_descriptor_set_js_1 = require("./create-descriptor-set.js");
+Object.defineProperty(exports, "createDescriptorSet", { enumerable: true, get: function () { return create_descriptor_set_js_1.createDescriptorSet; } });
+var type_registry_js_1 = require("./type-registry.js");
+var create_registry_js_1 = require("./create-registry.js");
+Object.defineProperty(exports, "createRegistry", { enumerable: true, get: function () { return create_registry_js_1.createRegistry; } });
+var create_registry_from_desc_js_1 = require("./create-registry-from-desc.js");
+Object.defineProperty(exports, "createRegistryFromDescriptors", { enumerable: true, get: function () { return create_registry_from_desc_js_1.createRegistryFromDescriptors; } });
 // ideally, we would export these types with sub-path exports:
 __exportStar(require("./google/protobuf/compiler/plugin_pb.js"), exports);
 __exportStar(require("./google/protobuf/api_pb.js"), exports);

package/dist/cjs/private/enum.js

@@ -31,36 +31,31 @@ exports.getEnumType = getEnumType;
 /**
  * Sets reflection information on a generated enum.
  */
-function setEnumType(enumObject, typeName, values
-// We do not surface options at this time
-// opt?: {
-// options?: { readonly [extensionName: string]: JsonValue };
-// },
-) {
+function setEnumType(enumObject, typeName, values, opt) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-    enumObject[enumTypeSymbol] = makeEnumType(typeName, values);
+    enumObject[enumTypeSymbol] = makeEnumType(typeName, values.map((v) => ({
+        no: v.no,
+        name: v.name,
+        localName: enumObject[v.no],
+    })), opt);
 }
 exports.setEnumType = setEnumType;
-// We do not surface options at this time
-// export type PartialEnumValue = Omit<EnumValueInfo, 'options'> & Partial<Pick<EnumValueInfo, "options">>;
 /**
  * Create a new EnumType with the given values.
  */
-function makeEnumType(typeName, values
-// We do not surface options at this time
-// opt?: {
-// options?: { readonly [extensionName: string]: JsonValue };
-// },
-) {
+function makeEnumType(typeName, values, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_opt) {
     const names = Object.create(null);
     const numbers = Object.create(null);
     const normalValues = [];
     for (const value of values) {
         // We do not surface options at this time
         // const value: EnumValueInfo = {...v, options: v.options ?? emptyReadonlyObject};
-        normalValues.push(value);
-        names[value.name] = value;
-        numbers[value.no] = value;
+        const n = normalizeEnumValue(value);
+        normalValues.push(n);
+        names[value.name] = n;
+        numbers[value.no] = n;
     }
     return {
         typeName,
@@ -78,26 +73,22 @@ function makeEnumType(typeName, values
 exports.makeEnumType = makeEnumType;
 /**
  * Create a new enum object with the given values.
+ * Sets reflection information.
  */
 function makeEnum(typeName, values, opt) {
     const enumObject = {};
     for (const value of values) {
-        const name = makeEnumValueName(value, opt === null || opt === void 0 ? void 0 : opt.sharedPrefix);
-        enumObject[name] = value.no;
-        enumObject[value.no] = name;
+        const n = normalizeEnumValue(value);
+        enumObject[n.localName] = n.no;
+        enumObject[n.no] = n.localName;
     }
-    setEnumType(enumObject, typeName, values);
+    setEnumType(enumObject, typeName, values, opt);
     return enumObject;
 }
 exports.makeEnum = makeEnum;
-// Construct a local name for an enum value.
-// This logic matches the Go function with the same name in private/protoplugin/names.go
-function makeEnumValueName(value, sharedPrefix) {
-    if (sharedPrefix === undefined) {
-        return value.name;
+function normalizeEnumValue(value) {
+    if ("localName" in value) {
+        return value;
     }
-    if (!value.name.startsWith(sharedPrefix)) {
-        return value.name;
-    }
-    return value.name.substring(sharedPrefix.length);
+    return Object.assign(Object.assign({}, value), { localName: value.name });
 }

package/dist/cjs/private/field-wrapper.js

@@ -13,7 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unwrapField = exports.wrapField = void 0;
+exports.getUnwrappedFieldType = exports.unwrapField = exports.wrapField = void 0;
+const field_js_1 = require("../field.js");
 /**
  * Wrap field values whose message type has a wrapper.
  */
@@ -34,3 +35,31 @@ function unwrapField(type, value) {
     return type.fieldWrapper ? type.fieldWrapper.unwrapField(value) : value;
 }
 exports.unwrapField = unwrapField;
+/**
+ * If the given field uses one of the well-known wrapper types, return
+ * the base type it wraps.
+ */
+function getUnwrappedFieldType(field) {
+    if (field.kind !== "message_field") {
+        return undefined;
+    }
+    if (field.repeated) {
+        return undefined;
+    }
+    if (field.oneof != undefined) {
+        return undefined;
+    }
+    return wktWrapperToScalarType[field.message.typeName];
+}
+exports.getUnwrappedFieldType = getUnwrappedFieldType;
+const wktWrapperToScalarType = {
+    "google.protobuf.DoubleValue": field_js_1.ScalarType.DOUBLE,
+    "google.protobuf.FloatValue": field_js_1.ScalarType.FLOAT,
+    "google.protobuf.Int64Value": field_js_1.ScalarType.INT64,
+    "google.protobuf.UInt64Value": field_js_1.ScalarType.UINT64,
+    "google.protobuf.Int32Value": field_js_1.ScalarType.INT32,
+    "google.protobuf.UInt32Value": field_js_1.ScalarType.UINT32,
+    "google.protobuf.BoolValue": field_js_1.ScalarType.BOOL,
+    "google.protobuf.StringValue": field_js_1.ScalarType.STRING,
+    "google.protobuf.BytesValue": field_js_1.ScalarType.BYTES,
+};

package/dist/cjs/private/field.js

@@ -25,7 +25,7 @@ class InternalOneofInfo {
         this.default = undefined;
         this.fields = [];
         this.name = name;
-        this.localName = (0, names_js_1.makeOneofName)(name);
+        this.localName = (0, names_js_1.localOneofName)(name);
     }
     addField(field) {
         (0, assert_js_1.assert)(field.oneof === this, `field ${field.name} not one of ${this.name}`);

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

@@ -76,12 +76,12 @@ function makeJsonFormatCommon(makeWriteField) {
                         continue;
                     }
                     if (!Array.isArray(jsonValue)) {
-                        throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: "${this.debug(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)}"`);
+                            throw new Error(`cannot decode field ${type.typeName}.${field.name} from JSON: ${this.debug(jsonItem)}`);
                         }
                         let val;
                         // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- "map" is invalid for repeated fields
@@ -99,7 +99,7 @@ function makeJsonFormatCommon(makeWriteField) {
                                     val = readScalar(field.T, jsonItem);
                                 }
                                 catch (e) {
-                                    let m = `cannot decode field ${type.typeName}.${field.name} from JSON: "${this.debug(jsonItem)}"`;
+                                    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}`;
                                     }
@@ -137,7 +137,7 @@ function makeJsonFormatCommon(makeWriteField) {
                                     val = readScalar(field.V.T, jsonMapValue);
                                 }
                                 catch (e) {
-                                    let m = `cannot decode map value for field ${type.typeName}.${field.name} from JSON: "${this.debug(jsonValue)}"`;
+                                    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}`;
                                     }
@@ -155,7 +155,7 @@ function makeJsonFormatCommon(makeWriteField) {
                                 : jsonMapKey).toString()] = val;
                         }
                         catch (e) {
-                            let m = `cannot decode map key for field ${type.typeName}.${field.name} from JSON: "${this.debug(jsonValue)}"`;
+                            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}`;
                             }
@@ -190,7 +190,7 @@ function makeJsonFormatCommon(makeWriteField) {
                                 target[localName] = readScalar(field.T, jsonValue);
                             }
                             catch (e) {
-                                let m = `cannot decode field ${type.typeName}.${field.name} from JSON: "${this.debug(jsonValue)}"`;
+                                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}`;
                                 }

package/dist/cjs/private/names.js

@@ -13,44 +13,119 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMethodName = exports.makeOneofName = exports.makeFieldName = exports.makeJsonName = void 0;
+exports.findEnumSharedPrefix = exports.fieldJsonName = exports.localOneofName = exports.localFieldName = exports.localName = void 0;
 /**
- * Returns the JSON name for a protobuf field, exactly like protoc does.
+ * Returns the name of a protobuf element in generated code.
+ *
+ * Field names - including oneofs - are converted to lowerCamelCase. For
+ * messages, enumerations and services, the package name is stripped from
+ * the type name. For nested messages and enumerations, the names are joined
+ * with an underscore. For methods, the first character is made lowercase.
  */
-function makeJsonName(protoName) {
-    return protoCamelCase(protoName);
+function localName(desc) {
+    switch (desc.kind) {
+        case "enum_field":
+        case "message_field":
+        case "map_field":
+        case "scalar_field":
+            return localFieldName(desc.name, desc.oneof !== undefined);
+        case "oneof":
+            return localOneofName(desc.name);
+        case "enum":
+        case "message":
+        case "service": {
+            const pkg = desc.file.proto.package;
+            const offset = pkg === undefined ? 0 : pkg.length + 1;
+            const name = desc.typeName.substring(offset).replace(/\./g, "_");
+            if (reservedIdent[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+        case "enum_value": {
+            const sharedPrefix = desc.parent.sharedPrefix;
+            if (sharedPrefix === undefined) {
+                return desc.name;
+            }
+            const name = desc.name.substring(sharedPrefix.length);
+            if (reservedObjectProperties[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+        case "rpc": {
+            let name = desc.name;
+            if (name.length == 0) {
+                return name;
+            }
+            name = name[0].toLowerCase() + name.substring(1);
+            if (reservedObjectProperties[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+    }
 }
-exports.makeJsonName = makeJsonName;
+exports.localName = localName;
 /**
- * Returns the local name of a field, exactly like protoc-gen-es does.
+ * Returns the name of a field in generated code.
  */
-function makeFieldName(protoName, inOneof) {
-    const n = protoCamelCase(protoName);
+function localFieldName(protoName, inOneof) {
+    let name = protoCamelCase(protoName);
     if (inOneof) {
-        return n;
+        // oneof member names are not properties, but values of the `case` property.
+        return name;
     }
-    return rProp[n] ? n + escapeChar : n;
+    if (reservedObjectProperties[name] || reservedMessageProperties[name]) {
+        name = name + "$";
+    }
+    return name;
 }
-exports.makeFieldName = makeFieldName;
+exports.localFieldName = localFieldName;
 /**
- * Returns the local name of a oneof group, exactly like protoc-gen-es does.
+ * Returns the name of a oneof group in generated code.
  */
-function makeOneofName(protoName) {
-    return makeFieldName(protoName, false);
+function localOneofName(protoName) {
+    return localFieldName(protoName, false);
 }
-exports.makeOneofName = makeOneofName;
+exports.localOneofName = localOneofName;
 /**
- * Returns the local name of a rpc, exactly like protoc-gen-es does.
+ * Returns the JSON name for a protobuf field, exactly like protoc does.
  */
-function makeMethodName(protoName) {
-    if (protoName.length == 0) {
-        return protoName;
+exports.fieldJsonName = protoCamelCase;
+/**
+ * Finds a prefix shared by enum values, for example `MY_ENUM_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+function findEnumSharedPrefix(enumName, valueNames) {
+    const prefix = camelToSnakeCase(enumName) + "_";
+    for (const name of valueNames) {
+        if (!name.toLowerCase().startsWith(prefix)) {
+            return undefined;
+        }
+        const shortName = name.substring(prefix.length);
+        if (shortName.length == 0) {
+            return undefined;
+        }
+        if (/^\d/.test(shortName)) {
+            // identifiers must not start with numbers
+            return undefined;
+        }
     }
-    return protoName[0].toLowerCase() + protoName.substring(1);
+    return prefix;
+}
+exports.findEnumSharedPrefix = findEnumSharedPrefix;
+/**
+ * Converts lowerCamelCase or UpperCamelCase into lower_snake_case.
+ * This is used to find shared prefixes in an enum.
+ */
+function camelToSnakeCase(camel) {
+    return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase();
 }
-exports.makeMethodName = makeMethodName;
-// Converts snake_case to protoCamelCase according to the convention
-// used by protoc to convert a field name to a JSON name.
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
 function protoCamelCase(snakeCase) {
     let capNext = false;
     const b = [];
@@ -84,17 +159,81 @@ function protoCamelCase(snakeCase) {
     }
     return b.join("");
 }
-// escapeChar must be appended to a reserved name.
-// We choose '$' because it is invalid in proto identifiers.
-const escapeChar = "$";
-// Names that cannot be used for object properties.
-// See buf_es/protoc-gen-es/internal/protoplugin/names.go
-const rProp = {
+// Names that cannot be used for identifiers, such as class names,
+// but _can_ be used for object properties.
+const reservedIdent = {
+    // ECMAScript 2015 keywords
+    break: true,
+    case: true,
+    catch: true,
+    class: true,
+    const: true,
+    continue: true,
+    debugger: true,
+    default: true,
+    delete: true,
+    do: true,
+    else: true,
+    export: true,
+    extends: true,
+    false: true,
+    finally: true,
+    for: true,
+    function: true,
+    if: true,
+    import: true,
+    in: true,
+    instanceof: true,
+    new: true,
+    null: true,
+    return: true,
+    super: true,
+    switch: true,
+    this: true,
+    throw: true,
+    true: true,
+    try: true,
+    typeof: true,
+    var: true,
+    void: true,
+    while: true,
+    with: true,
+    yield: true,
+    // ECMAScript 2015 future reserved keywords
+    enum: true,
+    implements: true,
+    interface: true,
+    let: true,
+    package: true,
+    private: true,
+    protected: true,
+    public: true,
+    static: true,
+    // Class name cannot be 'Object' when targeting ES5 with module CommonJS
+    Object: true,
+    // TypeScript keywords that cannot be used for types (as opposed to variables)
+    bigint: true,
+    number: true,
+    boolean: true,
+    string: true,
+    object: true,
+    // Identifiers reserved for the runtime, so we can generate legible code
+    globalThis: true,
+    Uint8Array: true,
+    Partial: true,
+};
+// Names that cannot be used for object properties because they are reserved
+// by built-in JavaScript properties.
+const reservedObjectProperties = {
     // names reserved by JavaScript
     constructor: true,
     toString: true,
     toJSON: true,
     valueOf: true,
+};
+// Names that cannot be used for object properties because they are reserved
+// by the runtime.
+const reservedMessageProperties = {
     // names reserved by the runtime
     getType: true,
     clone: true,

package/dist/cjs/proto-int64.js

@@ -14,6 +14,7 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.protoInt64 = void 0;
+const assert_js_1 = require("./private/assert.js");
 const varint_js_1 = require("./google/varint.js");
 function makeInt64Support() {
     const dv = new DataView(new ArrayBuffer(8));
@@ -22,7 +23,10 @@ function makeInt64Support() {
         typeof dv.getBigInt64 === "function" &&
         typeof dv.getBigUint64 === "function" &&
         typeof dv.setBigInt64 === "function" &&
-        typeof dv.setBigUint64 === "function";
+        typeof dv.setBigUint64 === "function" &&
+        (typeof process != "object" ||
+            typeof process.env != "object" ||
+            process.env.BUF_BIGINT_DISABLE !== "1");
     if (ok) {
         const MIN = BigInt("-9223372036854775808"), MAX = BigInt("9223372036854775807"), UMIN = BigInt("0"), UMAX = BigInt("18446744073709551615");
         return {
@@ -68,65 +72,44 @@ function makeInt64Support() {
             },
         };
     }
+    const assertInt64String = (value) => (0, assert_js_1.assert)(/^-?[0-9]+$/.test(value), `int64 invalid: ${value}`);
+    const assertUInt64String = (value) => (0, assert_js_1.assert)(/^[0-9]+$/.test(value), `uint64 invalid: ${value}`);
     return {
         zero: "0",
         supported: false,
         parse(value) {
-            if (!/^-?[0-9]+$/.test(value)) {
-                throw new Error(`int64 invalid: ${value}`);
+            if (typeof value != "string") {
+                value = value.toString();
             }
+            assertInt64String(value);
             return value;
         },
         uParse(value) {
-            if (!/^-?[0-9]+$/.test(value)) {
-                throw new Error(`uint64 invalid: ${value}`);
+            if (typeof value != "string") {
+                value = value.toString();
             }
+            assertUInt64String(value);
             return value;
         },
         enc(value) {
-            if (typeof value == "string") {
-                if (!/^-?[0-9]+$/.test(value)) {
-                    throw new Error(`int64 invalid: ${value}`);
-                }
-            }
-            else {
-                value = value.toString(10);
+            if (typeof value != "string") {
+                value = value.toString();
             }
-            const [, lo, hi] = (0, varint_js_1.int64fromString)(value);
-            return { lo, hi };
+            assertInt64String(value);
+            return (0, varint_js_1.int64FromString)(value);
         },
         uEnc(value) {
-            if (typeof value == "string") {
-                if (!/^-?[0-9]+$/.test(value)) {
-                    throw new Error(`uint64 invalid: ${value}`);
-                }
+            if (typeof value != "string") {
+                value = value.toString();
             }
-            else {
-                value = value.toString(10);
-            }
-            const [minus, lo, hi] = (0, varint_js_1.int64fromString)(value);
-            if (minus) {
-                throw new Error(`uint64 invalid: ${value}`);
-            }
-            return { lo, hi };
+            assertUInt64String(value);
+            return (0, varint_js_1.int64FromString)(value);
         },
         dec(lo, hi) {
-            const minus = (hi & 0x80000000) !== 0;
-            if (minus) {
-                // negate
-                hi = ~hi;
-                if (lo) {
-                    lo = ~lo + 1;
-                }
-                else {
-                    hi += 1;
-                }
-                return ("-" + (0, varint_js_1.int64toString)(lo, hi));
-            }
-            return (0, varint_js_1.int64toString)(lo, hi);
+            return (0, varint_js_1.int64ToString)(lo, hi);
         },
         uDec(lo, hi) {
-            return (0, varint_js_1.int64toString)(lo, hi);
+            return (0, varint_js_1.uInt64ToString)(lo, hi);
         },
     };
 }

package/dist/cjs/proto2.js

@@ -63,8 +63,8 @@ function normalizeFieldInfosProto2(fieldInfos) {
         ? fieldInfos()
         : fieldInfos) {
         const f = field;
-        f.localName = (0, names_js_1.makeFieldName)(field.name, field.oneof !== undefined);
-        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : (0, names_js_1.makeJsonName)(field.name);
+        f.localName = (0, names_js_1.localFieldName)(field.name, field.oneof !== undefined);
+        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : (0, names_js_1.fieldJsonName)(field.name);
         f.repeated = (_b = field.repeated) !== null && _b !== void 0 ? _b : false;
         // In contrast to proto3, repeated fields are unpacked except when explicitly specified.
         f.packed = (_c = field.packed) !== null && _c !== void 0 ? _c : false;

package/dist/cjs/proto3.js

@@ -67,8 +67,8 @@ function normalizeFieldInfosProto3(fieldInfos) {
         ? fieldInfos()
         : fieldInfos) {
         const f = field;
-        f.localName = (0, names_js_1.makeFieldName)(field.name, field.oneof !== undefined);
-        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : (0, names_js_1.makeJsonName)(field.name);
+        f.localName = (0, names_js_1.localFieldName)(field.name, field.oneof !== undefined);
+        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : (0, names_js_1.fieldJsonName)(field.name);
         f.repeated = (_b = field.repeated) !== null && _b !== void 0 ? _b : false;
         // From the proto3 language guide:
         // > In proto3, repeated fields of scalar numeric types are packed by default.