@bufbuild/protobuf 0.0.1-alpha.1 → 0.0.1

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

@@ -6,95 +6,84 @@ const assert_js_1 = require("./assert.js");
 const json_format_common_js_1 = require("./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 */
 function makeJsonFormatProto2() {
-  return (0, json_format_common_js_1.makeJsonFormatCommon)(
-    (writeEnum, writeScalar) => {
-      return function writeField(field, value, options) {
-        if (field.kind == "map") {
-          const jsonObj = {};
-          switch (field.V.kind) {
-            case "scalar":
-              for (const [entryKey, entryValue] of Object.entries(value)) {
-                const val = writeScalar(field.V.T, entryValue, true);
-                (0, assert_js_1.assert)(val !== undefined);
-                jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
-              }
-              break;
-            case "message":
-              for (const [entryKey, entryValue] of Object.entries(value)) {
-                // 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 Object.entries(value)) {
-                (0, assert_js_1.assert)(
-                  entryValue === undefined || typeof entryValue == "number"
-                );
-                const val = writeEnum(
-                  enumType,
-                  entryValue,
-                  true,
-                  options.enumAsInteger
-                );
-                (0, assert_js_1.assert)(val !== undefined);
-                jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
-              }
-              break;
-          }
-          return options.emitDefaultValues || Object.keys(jsonObj).length > 0
-            ? jsonObj
-            : undefined;
-        } else if (field.repeated) {
-          const jsonArr = [];
-          switch (field.kind) {
-            case "scalar":
-              for (let i = 0; i < value.length; i++) {
-                jsonArr.push(writeScalar(field.T, value[i], true));
-              }
-              break;
-            case "enum":
-              for (let i = 0; i < value.length; i++) {
-                jsonArr.push(
-                  writeEnum(field.T, value[i], true, 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;
-        } else {
-          // In contrast to proto3, we raise an error if a non-optional (proto2 required)
-          // field is missing a value.
-          if (value === undefined) {
-            if (!field.oneof && !field.opt) {
-              throw `required field not set`;
+    return (0, json_format_common_js_1.makeJsonFormatCommon)((writeEnum, writeScalar) => {
+        return function writeField(field, value, options) {
+            if (field.kind == "map") {
+                const jsonObj = {};
+                switch (field.V.kind) {
+                    case "scalar":
+                        for (const [entryKey, entryValue] of Object.entries(value)) {
+                            const val = writeScalar(field.V.T, entryValue, true);
+                            (0, assert_js_1.assert)(val !== undefined);
+                            jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+                        }
+                        break;
+                    case "message":
+                        for (const [entryKey, entryValue] of Object.entries(value)) {
+                            // 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 Object.entries(value)) {
+                            (0, assert_js_1.assert)(entryValue === undefined || typeof entryValue == "number");
+                            const val = writeEnum(enumType, entryValue, true, options.enumAsInteger);
+                            (0, assert_js_1.assert)(val !== undefined);
+                            jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+                        }
+                        break;
+                }
+                return options.emitDefaultValues || Object.keys(jsonObj).length > 0
+                    ? jsonObj
+                    : undefined;
             }
-            return undefined;
-          }
-          switch (field.kind) {
-            case "scalar":
-              // In contrast to proto3, we do not skip intrinsic default values.
-              // Explicit default values are not special cased either.
-              return writeScalar(field.T, value, true);
-            case "enum":
-              // In contrast to proto3, we do not skip intrinsic default values.
-              // Explicit default values are not special cased either.
-              return writeEnum(field.T, value, true, options.enumAsInteger);
-            case "message":
-              return (0, field_wrapper_js_1.wrapField)(field.T, value).toJson(
-                options
-              );
-          }
-        }
-      };
-    }
-  );
+            else if (field.repeated) {
+                const jsonArr = [];
+                switch (field.kind) {
+                    case "scalar":
+                        for (let i = 0; i < value.length; i++) {
+                            jsonArr.push(writeScalar(field.T, value[i], true));
+                        }
+                        break;
+                    case "enum":
+                        for (let i = 0; i < value.length; i++) {
+                            jsonArr.push(writeEnum(field.T, value[i], true, 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;
+            }
+            else {
+                // In contrast to proto3, we raise an error if a non-optional (proto2 required)
+                // field is missing a value.
+                if (value === undefined) {
+                    if (!field.oneof && !field.opt) {
+                        throw `required field not set`;
+                    }
+                    return undefined;
+                }
+                switch (field.kind) {
+                    case "scalar":
+                        // In contrast to proto3, we do not skip intrinsic default values.
+                        // Explicit default values are not special cased either.
+                        return writeScalar(field.T, value, true);
+                    case "enum":
+                        // In contrast to proto3, we do not skip intrinsic default values.
+                        // Explicit default values are not special cased either.
+                        return writeEnum(field.T, value, true, options.enumAsInteger);
+                    case "message":
+                        return (0, field_wrapper_js_1.wrapField)(field.T, value).toJson(options);
+                }
+            }
+        };
+    });
 }
 exports.makeJsonFormatProto2 = makeJsonFormatProto2;

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

@@ -6,98 +6,74 @@ const assert_js_1 = require("./assert.js");
 const json_format_common_js_1 = require("./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 */
 function makeJsonFormatProto3() {
-  return (0, json_format_common_js_1.makeJsonFormatCommon)(
-    (writeEnum, writeScalar) => {
-      return function writeField(field, value, options) {
-        if (field.kind == "map") {
-          const jsonObj = {};
-          switch (field.V.kind) {
-            case "scalar":
-              for (const [entryKey, entryValue] of Object.entries(value)) {
-                const val = writeScalar(field.V.T, entryValue, true);
-                (0, assert_js_1.assert)(val !== undefined);
-                jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
-              }
-              break;
-            case "message":
-              for (const [entryKey, entryValue] of Object.entries(value)) {
-                // 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 Object.entries(value)) {
-                (0, assert_js_1.assert)(
-                  entryValue === undefined || typeof entryValue == "number"
-                );
-                const val = writeEnum(
-                  enumType,
-                  entryValue,
-                  true,
-                  options.enumAsInteger
-                );
-                (0, assert_js_1.assert)(val !== undefined);
-                jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
-              }
-              break;
-          }
-          return options.emitDefaultValues || Object.keys(jsonObj).length > 0
-            ? jsonObj
-            : undefined;
-        } else if (field.repeated) {
-          const jsonArr = [];
-          switch (field.kind) {
-            case "scalar":
-              for (let i = 0; i < value.length; i++) {
-                jsonArr.push(writeScalar(field.T, value[i], true));
-              }
-              break;
-            case "enum":
-              for (let i = 0; i < value.length; i++) {
-                jsonArr.push(
-                  writeEnum(field.T, value[i], true, options.enumAsInteger)
-                );
-              }
-              break;
-            case "message":
-              for (let i = 0; i < value.length; i++) {
-                jsonArr.push(
-                  (0, field_wrapper_js_1.wrapField)(field.T, value[i]).toJson(
-                    options
-                  )
-                );
-              }
-              break;
-          }
-          return options.emitDefaultValues || jsonArr.length > 0
-            ? jsonArr
-            : undefined;
-        } else {
-          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
-                ? (0, field_wrapper_js_1.wrapField)(field.T, value).toJson(
-                    options
-                  )
-                : undefined;
-          }
-        }
-      };
-    }
-  );
+    return (0, json_format_common_js_1.makeJsonFormatCommon)((writeEnum, writeScalar) => {
+        return function writeField(field, value, options) {
+            if (field.kind == "map") {
+                const jsonObj = {};
+                switch (field.V.kind) {
+                    case "scalar":
+                        for (const [entryKey, entryValue] of Object.entries(value)) {
+                            const val = writeScalar(field.V.T, entryValue, true);
+                            (0, assert_js_1.assert)(val !== undefined);
+                            jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+                        }
+                        break;
+                    case "message":
+                        for (const [entryKey, entryValue] of Object.entries(value)) {
+                            // 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 Object.entries(value)) {
+                            (0, assert_js_1.assert)(entryValue === undefined || typeof entryValue == "number");
+                            const val = writeEnum(enumType, entryValue, true, options.enumAsInteger);
+                            (0, assert_js_1.assert)(val !== undefined);
+                            jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+                        }
+                        break;
+                }
+                return options.emitDefaultValues || Object.keys(jsonObj).length > 0
+                    ? jsonObj
+                    : undefined;
+            }
+            else if (field.repeated) {
+                const jsonArr = [];
+                switch (field.kind) {
+                    case "scalar":
+                        for (let i = 0; i < value.length; i++) {
+                            jsonArr.push(writeScalar(field.T, value[i], true));
+                        }
+                        break;
+                    case "enum":
+                        for (let i = 0; i < value.length; i++) {
+                            jsonArr.push(writeEnum(field.T, value[i], true, options.enumAsInteger));
+                        }
+                        break;
+                    case "message":
+                        for (let i = 0; i < value.length; i++) {
+                            jsonArr.push((0, field_wrapper_js_1.wrapField)(field.T, value[i]).toJson(options));
+                        }
+                        break;
+                }
+                return options.emitDefaultValues || jsonArr.length > 0
+                    ? jsonArr
+                    : undefined;
+            }
+            else {
+                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
+                            ? (0, field_wrapper_js_1.wrapField)(field.T, value).toJson(options)
+                            : undefined;
+                }
+            }
+        };
+    });
 }
 exports.makeJsonFormatProto3 = makeJsonFormatProto3;

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

@@ -6,32 +6,31 @@ const message_js_1 = require("../message.js");
  * Create a new message type using the given runtime.
  */
 function makeMessageType(runtime, typeName, fields, opt) {
-  const localName =
-    opt?.localName ?? typeName.substring(typeName.lastIndexOf(".") + 1);
-  const type = {
-    [localName]: function (data) {
-      runtime.util.initFields(this);
-      runtime.util.initPartial(data, this);
-    },
-  }[localName];
-  Object.setPrototypeOf(type.prototype, new message_js_1.Message());
-  Object.assign(type, {
-    runtime,
-    typeName,
-    fields: runtime.util.newFieldList(fields),
-    fromBinary(bytes, options) {
-      return new type().fromBinary(bytes, options);
-    },
-    fromJson(jsonValue, options) {
-      return new type().fromJson(jsonValue, options);
-    },
-    fromJsonString(jsonString, options) {
-      return new type().fromJsonString(jsonString, options);
-    },
-    equals(a, b) {
-      return runtime.util.equals(type, a, b);
-    },
-  });
-  return type;
+    const localName = opt?.localName ?? typeName.substring(typeName.lastIndexOf(".") + 1);
+    const type = {
+        [localName]: function (data) {
+            runtime.util.initFields(this);
+            runtime.util.initPartial(data, this);
+        },
+    }[localName];
+    Object.setPrototypeOf(type.prototype, new message_js_1.Message());
+    Object.assign(type, {
+        runtime,
+        typeName,
+        fields: runtime.util.newFieldList(fields),
+        fromBinary(bytes, options) {
+            return new type().fromBinary(bytes, options);
+        },
+        fromJson(jsonValue, options) {
+            return new type().fromJson(jsonValue, options);
+        },
+        fromJsonString(jsonString, options) {
+            return new type().fromJsonString(jsonString, options);
+        },
+        equals(a, b) {
+            return runtime.util.equals(type, a, b);
+        },
+    });
+    return type;
 }
 exports.makeMessageType = makeMessageType;

package/dist/cjs/private/names.js

@@ -1,79 +1,75 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMethodName =
-  exports.makeOneofName =
-  exports.makeFieldName =
-  exports.makeJsonName =
-    void 0;
+exports.makeMethodName = exports.makeOneofName = exports.makeFieldName = exports.makeJsonName = void 0;
 /**
  * Returns the JSON name for a protobuf field, exactly like protoc does.
  */
 function makeJsonName(protoName) {
-  return protoCamelCase(protoName);
+    return protoCamelCase(protoName);
 }
 exports.makeJsonName = makeJsonName;
 /**
  * Returns the local name of a field, exactly like protoc-gen-es does.
  */
 function makeFieldName(protoName, inOneof) {
-  const n = protoCamelCase(protoName);
-  if (inOneof) {
-    return n;
-  }
-  return rProp[n] ? n + escapeChar : n;
+    const n = protoCamelCase(protoName);
+    if (inOneof) {
+        return n;
+    }
+    return rProp[n] ? n + escapeChar : n;
 }
 exports.makeFieldName = makeFieldName;
 /**
  * Returns the local name of a oneof group, exactly like protoc-gen-es does.
  */
 function makeOneofName(protoName) {
-  return makeFieldName(protoName, false);
+    return makeFieldName(protoName, false);
 }
 exports.makeOneofName = makeOneofName;
 /**
  * Returns the local name of a rpc, exactly like protoc-gen-es does.
  */
 function makeMethodName(protoName) {
-  if (protoName.length == 0) {
-    return protoName;
-  }
-  return protoName[0].toLowerCase() + protoName.substring(1);
+    if (protoName.length == 0) {
+        return protoName;
+    }
+    return protoName[0].toLowerCase() + protoName.substring(1);
 }
 exports.makeMethodName = makeMethodName;
 // 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 = [];
-  for (let i = 0; i < snakeCase.length; i++) {
-    let c = snakeCase.charAt(i);
-    switch (c) {
-      case "_":
-        capNext = true;
-        break;
-      case "0":
-      case "1":
-      case "2":
-      case "3":
-      case "4":
-      case "5":
-      case "6":
-      case "7":
-      case "8":
-      case "9":
-        b.push(c);
-        capNext = false;
-        break;
-      default:
-        if (capNext) {
-          capNext = false;
-          c = c.toUpperCase();
+    let capNext = false;
+    const b = [];
+    for (let i = 0; i < snakeCase.length; i++) {
+        let c = snakeCase.charAt(i);
+        switch (c) {
+            case "_":
+                capNext = true;
+                break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9":
+                b.push(c);
+                capNext = false;
+                break;
+            default:
+                if (capNext) {
+                    capNext = false;
+                    c = c.toUpperCase();
+                }
+                b.push(c);
+                break;
         }
-        b.push(c);
-        break;
     }
-  }
-  return b.join("");
+    return b.join("");
 }
 // escapeChar must be appended to a reserved name.
 // We choose '$' because it is invalid in proto identifiers.
@@ -81,21 +77,21 @@ const escapeChar = "$";
 // Names that cannot be used for object properties.
 // See buf_es/protoc-gen-es/internal/protoplugin/names.go
 const rProp = {
-  // names reserved by JavaScript
-  constructor: true,
-  toString: true,
-  toJSON: true,
-  valueOf: true,
-  // names reserved by the runtime
-  getType: true,
-  clone: true,
-  equals: true,
-  fromBinary: true,
-  fromJson: true,
-  fromJsonString: true,
-  toBinary: true,
-  toJson: true,
-  toJsonString: true,
-  // names reserved by the runtime for the future
-  toObject: true,
+    // names reserved by JavaScript
+    constructor: true,
+    toString: true,
+    toJSON: true,
+    valueOf: true,
+    // names reserved by the runtime
+    getType: true,
+    clone: true,
+    equals: true,
+    fromBinary: true,
+    fromJson: true,
+    fromJsonString: true,
+    toBinary: true,
+    toJson: true,
+    toJsonString: true,
+    // names reserved by the runtime for the future
+    toObject: true,
 };

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

@@ -4,21 +4,16 @@ exports.makeProtoRuntime = void 0;
 const enum_js_1 = require("./enum.js");
 const message_type_js_1 = require("./message-type.js");
 function makeProtoRuntime(syntax, json, bin, util) {
-  return {
-    syntax,
-    json,
-    bin,
-    util,
-    makeMessageType(typeName, fields, opt) {
-      return (0, message_type_js_1.makeMessageType)(
-        this,
-        typeName,
-        fields,
-        opt
-      );
-    },
-    makeEnumType: enum_js_1.makeEnumType,
-    getEnumType: enum_js_1.getEnumType,
-  };
+    return {
+        syntax,
+        json,
+        bin,
+        util,
+        makeMessageType(typeName, fields, opt) {
+            return (0, message_type_js_1.makeMessageType)(this, typeName, fields, opt);
+        },
+        makeEnumType: enum_js_1.makeEnumType,
+        getEnumType: enum_js_1.getEnumType,
+    };
 }
 exports.makeProtoRuntime = makeProtoRuntime;