@bufbuild/protobuf 0.0.1-alpha.1

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeJsonFormatProto2 = void 0;
+const field_wrapper_js_1 = require("./field-wrapper.js");
+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 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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeJsonFormatProto3 = void 0;
+const field_wrapper_js_1 = require("./field-wrapper.js");
+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;
+          }
+        }
+      };
+    }
+  );
+}
+exports.makeJsonFormatProto3 = makeJsonFormatProto3;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMessageType = void 0;
+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;
+}
+exports.makeMessageType = makeMessageType;

package/dist/cjs/private/names.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+}
+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;
+}
+exports.makeFieldName = makeFieldName;
+/**
+ * Returns the local name of a oneof group, exactly like protoc-gen-es does.
+ */
+function makeOneofName(protoName) {
+  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);
+}
+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();
+        }
+        b.push(c);
+        break;
+    }
+  }
+  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 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/options-map.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,
+  };
+}
+exports.makeProtoRuntime = makeProtoRuntime;

package/dist/cjs/private/scalars.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scalarTypeInfo =
+  exports.scalarDefaultValue =
+  exports.scalarEquals =
+    void 0;
+const field_js_1 = require("../field.js");
+const binary_encoding_js_1 = require("../binary-encoding.js");
+const proto_int64_js_1 = require("../proto-int64.js");
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Returns true if both scalar values are equal.
+ */
+function scalarEquals(type, a, b) {
+  if (a === b) {
+    // This correctly matches equal values except BYTES and (possibly) 64-bit integers.
+    return true;
+  }
+  // Special case BYTES - we need to compare each byte individually
+  if (type == field_js_1.ScalarType.BYTES) {
+    if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) {
+      return false;
+    }
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // Special case 64-bit integers - we support number, string and bigint representation.
+  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+  switch (type) {
+    case field_js_1.ScalarType.UINT64:
+    case field_js_1.ScalarType.FIXED64:
+    case field_js_1.ScalarType.INT64:
+    case field_js_1.ScalarType.SFIXED64:
+    case field_js_1.ScalarType.SINT64:
+      // Loose comparison will match between 0n, 0 and "0".
+      return a == b;
+  }
+  // Anything that hasn't been caught by strict comparison or special cased
+  // BYTES and 64-bit integers is not equal.
+  return false;
+}
+exports.scalarEquals = scalarEquals;
+/**
+ * Returns the default value for the given scalar type, following
+ * proto3 semantics.
+ */
+function scalarDefaultValue(type) {
+  switch (type) {
+    case field_js_1.ScalarType.BOOL:
+      return false;
+    case field_js_1.ScalarType.UINT64:
+    case field_js_1.ScalarType.FIXED64:
+    case field_js_1.ScalarType.INT64:
+    case field_js_1.ScalarType.SFIXED64:
+    case field_js_1.ScalarType.SINT64:
+      return proto_int64_js_1.protoInt64.zero;
+    case field_js_1.ScalarType.DOUBLE:
+    case field_js_1.ScalarType.FLOAT:
+      return 0.0;
+    case field_js_1.ScalarType.BYTES:
+      return new Uint8Array(0);
+    case field_js_1.ScalarType.STRING:
+      return "";
+    default:
+      // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32.
+      // We do not use individual cases to save a few bytes code size.
+      return 0;
+  }
+}
+exports.scalarDefaultValue = scalarDefaultValue;
+/**
+ * Get information for writing a scalar value.
+ *
+ * Returns tuple:
+ * [0]: appropriate WireType
+ * [1]: name of the appropriate method of IBinaryWriter
+ * [2]: whether the given value is a default value for proto3 semantics
+ *
+ * If argument `value` is omitted, [2] is always false.
+ */
+function scalarTypeInfo(type, value) {
+  const isUndefined = value === undefined;
+  let wireType = binary_encoding_js_1.WireType.Varint;
+  let isIntrinsicDefault = value === 0;
+  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- INT32, UINT32, SINT32 are covered by the defaults
+  switch (type) {
+    case field_js_1.ScalarType.STRING:
+      isIntrinsicDefault = isUndefined || !value.length;
+      wireType = binary_encoding_js_1.WireType.LengthDelimited;
+      break;
+    case field_js_1.ScalarType.BOOL:
+      isIntrinsicDefault = value === false;
+      break;
+    case field_js_1.ScalarType.DOUBLE:
+      wireType = binary_encoding_js_1.WireType.Bit64;
+      break;
+    case field_js_1.ScalarType.FLOAT:
+      wireType = binary_encoding_js_1.WireType.Bit32;
+      break;
+    case field_js_1.ScalarType.INT64:
+      isIntrinsicDefault = isUndefined || value == 0;
+      break;
+    case field_js_1.ScalarType.UINT64:
+      isIntrinsicDefault = isUndefined || value == 0;
+      break;
+    case field_js_1.ScalarType.FIXED64:
+      isIntrinsicDefault = isUndefined || value == 0;
+      wireType = binary_encoding_js_1.WireType.Bit64;
+      break;
+    case field_js_1.ScalarType.BYTES:
+      isIntrinsicDefault = isUndefined || !value.byteLength;
+      wireType = binary_encoding_js_1.WireType.LengthDelimited;
+      break;
+    case field_js_1.ScalarType.FIXED32:
+      wireType = binary_encoding_js_1.WireType.Bit32;
+      break;
+    case field_js_1.ScalarType.SFIXED32:
+      wireType = binary_encoding_js_1.WireType.Bit32;
+      break;
+    case field_js_1.ScalarType.SFIXED64:
+      isIntrinsicDefault = isUndefined || value == 0;
+      wireType = binary_encoding_js_1.WireType.Bit64;
+      break;
+    case field_js_1.ScalarType.SINT64:
+      isIntrinsicDefault = isUndefined || value == 0;
+      break;
+  }
+  const method = field_js_1.ScalarType[type].toLowerCase();
+  return [wireType, method, isUndefined || isIntrinsicDefault];
+}
+exports.scalarTypeInfo = scalarTypeInfo;