@bufbuild/protobuf 0.0.1-alpha.1

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalFieldList = void 0;
+class InternalFieldList {
+  constructor(fields, normalizer) {
+    this._fields = fields;
+    this._normalizer = normalizer;
+  }
+  findJsonName(jsonName) {
+    if (!this.jsonNames) {
+      const t = {};
+      for (const f of this.list()) {
+        t[f.jsonName] = t[f.name] = f;
+      }
+      this.jsonNames = t;
+    }
+    return this.jsonNames[jsonName];
+  }
+  find(fieldNo) {
+    if (!this.numbers) {
+      const t = {};
+      for (const f of this.list()) {
+        t[f.no] = f;
+      }
+      this.numbers = t;
+    }
+    return this.numbers[fieldNo];
+  }
+  list() {
+    if (!this.all) {
+      this.all = this._normalizer(this._fields);
+    }
+    return this.all;
+  }
+  byNumber() {
+    if (!this.numbersAsc) {
+      this.numbersAsc = this.list()
+        .concat()
+        .sort((a, b) => a.no - b.no);
+    }
+    return this.numbersAsc;
+  }
+  byMember() {
+    if (!this.members) {
+      this.members = [];
+      const a = this.members;
+      let o;
+      for (const f of this.list()) {
+        if (f.oneof) {
+          if (f.oneof !== o) {
+            o = f.oneof;
+            a.push(o);
+          }
+        } else {
+          a.push(f);
+        }
+      }
+    }
+    return this.members;
+  }
+}
+exports.InternalFieldList = InternalFieldList;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapField = exports.wrapField = void 0;
+/**
+ * Wrap field values whose message type has a wrapper.
+ */
+function wrapField(type, value) {
+  if (value instanceof type) {
+    return value;
+  }
+  if (type.fieldWrapper) {
+    return type.fieldWrapper.wrapField(value);
+  }
+  throw new Error(
+    `cannot unwrap field value, ${type.typeName} does not define a field wrapper`
+  );
+}
+exports.wrapField = wrapField;
+/**
+ * Unwrap field values whose message type has a wrapper.
+ */
+function unwrapField(type, value) {
+  return type.fieldWrapper ? type.fieldWrapper.unwrapField(value) : value;
+}
+exports.unwrapField = unwrapField;

package/dist/cjs/private/field.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalOneofInfo = void 0;
+const names_js_1 = require("./names.js");
+const assert_js_1 = require("./assert.js");
+class InternalOneofInfo {
+  constructor(name) {
+    this.kind = "oneof";
+    this.repeated = false;
+    this.packed = false;
+    this.opt = false;
+    this.default = undefined;
+    this.fields = [];
+    this.name = name;
+    this.localName = (0, names_js_1.makeOneofName)(name);
+  }
+  addField(field) {
+    (0, assert_js_1.assert)(
+      field.oneof === this,
+      `field ${field.name} not one of ${this.name}`
+    );
+    this.fields.push(field);
+  }
+  findField(localName) {
+    if (!this._lookup) {
+      this._lookup = Object.create(null);
+      for (let i = 0; i < this.fields.length; i++) {
+        this._lookup[this.fields[i].localName] = this.fields[i];
+      }
+    }
+    return this._lookup[localName];
+  }
+}
+exports.InternalOneofInfo = InternalOneofInfo;

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

@@ -0,0 +1,482 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeJsonFormatCommon = void 0;
+const field_wrapper_js_1 = require("./field-wrapper.js");
+const field_js_1 = require("../field.js");
+const assert_js_1 = require("./assert.js");
+const proto_int64_js_1 = require("../proto-int64.js");
+const base64_js_1 = require("./base64.js");
+/* eslint-disable no-case-declarations, @typescript-eslint/restrict-plus-operands,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
+// Default options for parsing JSON.
+const jsonReadDefaults = {
+  ignoreUnknownFields: false,
+};
+// Default options for serializing to JSON.
+const jsonWriteDefaults = {
+  emitDefaultValues: false,
+  enumAsInteger: false,
+  useProtoFieldName: false,
+  prettySpaces: 0,
+};
+function makeReadOptions(options) {
+  return options ? { ...jsonReadDefaults, ...options } : jsonReadDefaults;
+}
+function makeWriteOptions(options) {
+  return options ? { ...jsonWriteDefaults, ...options } : jsonWriteDefaults;
+}
+function makeJsonFormatCommon(makeWriteField) {
+  const writeField = makeWriteField(writeEnum, writeScalar);
+  return {
+    makeReadOptions,
+    makeWriteOptions,
+    readMessage(type, json, options, message) {
+      if (json == null || Array.isArray(json) || typeof json != "object") {
+        throw new Error(
+          `cannot decode message ${type.typeName} from JSON: ${this.debug(
+            json
+          )}`
+        );
+      }
+      message = message ?? new type();
+      const oneofSeen = {};
+      for (const [jsonKey, jsonValue] of Object.entries(json)) {
+        const field = type.fields.findJsonName(jsonKey);
+        if (!field) {
+          if (!options.ignoreUnknownFields) {
+            throw new Error(
+              `cannot decode message ${type.typeName} from JSON: key "${jsonKey}" is unknown`
+            );
+          }
+          continue;
+        }
+        let localName = field.localName;
+        let target = message;
+        if (field.oneof) {
+          if (jsonValue === null && field.kind == "scalar") {
+            // see conformance test Required.Proto3.JsonInput.OneofFieldNull{First,Second}
+            continue;
+          }
+          const seen = oneofSeen[field.oneof.localName];
+          if (seen) {
+            throw new Error(
+              `cannot decode message ${type.typeName} from JSON: multiple keys for oneof "${field.oneof.name}" present: "${seen}", "${jsonKey}"`
+            );
+          }
+          oneofSeen[field.oneof.localName] = jsonKey;
+          target = target[field.oneof.localName] = { case: localName };
+          localName = "value";
+        }
+        if (field.repeated) {
+          if (jsonValue === null) {
+            continue;
+          }
+          if (!Array.isArray(jsonValue)) {
+            throw new Error(
+              `cannot decode field ${type.typeName}.${
+                field.name
+              } from JSON: "${this.debug(jsonValue)}"`
+            );
+          }
+          const targetArray = target[localName];
+          for (const jsonItem of jsonValue) {
+            if (jsonItem === null) {
+              throw new Error(
+                `cannot decode field ${type.typeName}.${
+                  field.name
+                } from JSON: "${this.debug(jsonItem)}"`
+              );
+            }
+            let val;
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- "map" is invalid for repeated fields
+            switch (field.kind) {
+              case "message":
+                val = field.T.fromJson(jsonItem, options);
+                break;
+              case "enum":
+                val = readEnum(field.T, jsonItem, options.ignoreUnknownFields);
+                if (val === undefined) continue;
+                break;
+              case "scalar":
+                try {
+                  val = readScalar(field.T, jsonItem);
+                } catch (e) {
+                  let m = `cannot decode field ${type.typeName}.${
+                    field.name
+                  } from JSON: "${this.debug(jsonItem)}"`;
+                  if (e instanceof Error && e.message.length > 0) {
+                    m += `: ${e.message}`;
+                  }
+                  throw new Error(m);
+                }
+                break;
+            }
+            targetArray.push(val);
+          }
+        } else if (field.kind == "map") {
+          if (jsonValue === null) {
+            continue;
+          }
+          if (Array.isArray(jsonValue) || typeof jsonValue != "object") {
+            throw new Error(
+              `cannot decode field ${type.typeName}.${
+                field.name
+              } from JSON: ${this.debug(jsonValue)}`
+            );
+          }
+          const targetMap = target[localName];
+          for (const [jsonMapKey, jsonMapValue] of Object.entries(jsonValue)) {
+            if (jsonMapValue === null) {
+              throw new Error(
+                `cannot decode field ${type.typeName}.${field.name} from JSON: map value null`
+              );
+            }
+            let val;
+            switch (field.V.kind) {
+              case "message":
+                val = field.V.T.fromJson(jsonMapValue, options);
+                break;
+              case "enum":
+                val = readEnum(
+                  field.V.T,
+                  jsonMapValue,
+                  options.ignoreUnknownFields
+                );
+                if (val === undefined) continue;
+                break;
+              case "scalar":
+                try {
+                  val = readScalar(field.V.T, jsonMapValue);
+                } catch (e) {
+                  let m = `cannot decode map value for field ${type.typeName}.${
+                    field.name
+                  } from JSON: "${this.debug(jsonValue)}"`;
+                  if (e instanceof Error && e.message.length > 0) {
+                    m += `: ${e.message}`;
+                  }
+                  throw new Error(m);
+                }
+                break;
+            }
+            try {
+              targetMap[
+                readScalar(
+                  field.K,
+                  field.K == field_js_1.ScalarType.BOOL
+                    ? jsonMapKey == "true"
+                      ? true
+                      : jsonMapKey == "false"
+                      ? false
+                      : jsonMapKey
+                    : jsonMapKey
+                ).toString()
+              ] = val;
+            } catch (e) {
+              let m = `cannot decode map key for field ${type.typeName}.${
+                field.name
+              } from JSON: "${this.debug(jsonValue)}"`;
+              if (e instanceof Error && e.message.length > 0) {
+                m += `: ${e.message}`;
+              }
+              throw new Error(m);
+            }
+          }
+        } else {
+          switch (field.kind) {
+            case "message":
+              const messageType = field.T;
+              if (
+                jsonValue === null &&
+                messageType.typeName != "google.protobuf.Value"
+              ) {
+                if (field.oneof) {
+                  throw new Error(
+                    `cannot decode field ${type.typeName}.${field.name} from JSON: null is invalid for oneof field "${jsonKey}"`
+                  );
+                }
+                continue;
+              }
+              const targetMessage =
+                target[localName] === undefined
+                  ? new messageType()
+                  : (0, field_wrapper_js_1.wrapField)(
+                      messageType,
+                      target[localName]
+                    );
+              target[localName] = (0, field_wrapper_js_1.unwrapField)(
+                messageType,
+                targetMessage.fromJson(jsonValue, options)
+              );
+              break;
+            case "enum":
+              const enumValue = readEnum(
+                field.T,
+                jsonValue,
+                options.ignoreUnknownFields
+              );
+              if (enumValue !== undefined) {
+                target[localName] = enumValue;
+              }
+              break;
+            case "scalar":
+              try {
+                target[localName] = readScalar(field.T, jsonValue);
+              } catch (e) {
+                let m = `cannot decode field ${type.typeName}.${
+                  field.name
+                } from JSON: "${this.debug(jsonValue)}"`;
+                if (e instanceof Error && e.message.length > 0) {
+                  m += `: ${e.message}`;
+                }
+                throw new Error(m);
+              }
+              break;
+          }
+        }
+      }
+      return message;
+    },
+    writeMessage(message, options) {
+      const type = message.getType();
+      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) {
+              continue;
+            }
+            field = member.findField(oneof.case);
+            if (!field) {
+              throw "oneof case not found: " + oneof.case;
+            }
+            jsonValue = writeField(field, oneof.value, options);
+          } else {
+            field = member;
+            jsonValue = writeField(field, message[field.localName], options);
+          }
+          if (jsonValue !== undefined) {
+            json[options.useProtoFieldName ? field.name : field.jsonName] =
+              jsonValue;
+          }
+        }
+      } catch (e) {
+        const m = field
+          ? `cannot encode field ${type.typeName}.${field.name} to JSON`
+          : `cannot encode message ${type.typeName} to JSON`;
+        const r = e instanceof Error ? e.message : String(e);
+        throw new Error(m + (r.length > 0 ? `: ${r}` : ""));
+      }
+      return json;
+    },
+    readScalar,
+    writeScalar,
+    debug: debugJsonValue,
+  };
+}
+exports.makeJsonFormatCommon = makeJsonFormatCommon;
+function debugJsonValue(json) {
+  if (json === null) {
+    return "null";
+  }
+  switch (typeof json) {
+    case "object":
+      return Array.isArray(json) ? "array" : "object";
+    case "string":
+      return json.length > 100 ? "string" : `"${json.split('"').join('\\"')}"`;
+    default:
+      return json.toString();
+  }
+}
+// May throw an error. If the error message is non-blank, it should be shown.
+// It is up to the caller to provide context.
+function readScalar(type, json) {
+  // every valid case in the switch below returns, and every fall
+  // through is regarded as a failure.
+  switch (type) {
+    // 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 field_js_1.ScalarType.DOUBLE:
+    case field_js_1.ScalarType.FLOAT:
+      if (json === null) return 0.0;
+      if (json === "NaN") return Number.NaN;
+      if (json === "Infinity") return Number.POSITIVE_INFINITY;
+      if (json === "-Infinity") return Number.NEGATIVE_INFINITY;
+      if (json === "") {
+        // empty string is not a number
+        break;
+      }
+      if (typeof json == "string" && json.trim().length !== json.length) {
+        // extra whitespace
+        break;
+      }
+      if (typeof json != "string" && typeof json != "number") {
+        break;
+      }
+      const float = Number(json);
+      if (Number.isNaN(float)) {
+        // not a number
+        break;
+      }
+      if (!Number.isFinite(float)) {
+        // infinity and -infinity are handled by string representation above, so this is an error
+        break;
+      }
+      if (type == field_js_1.ScalarType.FLOAT)
+        (0, assert_js_1.assertFloat32)(float);
+      return float;
+    // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+    case field_js_1.ScalarType.INT32:
+    case field_js_1.ScalarType.FIXED32:
+    case field_js_1.ScalarType.SFIXED32:
+    case field_js_1.ScalarType.SINT32:
+    case field_js_1.ScalarType.UINT32:
+      if (json === null) return 0;
+      let int32;
+      if (typeof json == "number") int32 = json;
+      else if (typeof json == "string" && json.length > 0) {
+        if (json.trim().length === json.length) int32 = Number(json);
+      }
+      if (int32 === undefined) break;
+      if (type == field_js_1.ScalarType.UINT32)
+        (0, assert_js_1.assertUInt32)(int32);
+      else (0, assert_js_1.assertInt32)(int32);
+      return int32;
+    // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted.
+    case field_js_1.ScalarType.INT64:
+    case field_js_1.ScalarType.SFIXED64:
+    case field_js_1.ScalarType.SINT64:
+      if (json === null) return proto_int64_js_1.protoInt64.zero;
+      if (typeof json != "number" && typeof json != "string") break;
+      return proto_int64_js_1.protoInt64.parse(json);
+    case field_js_1.ScalarType.FIXED64:
+    case field_js_1.ScalarType.UINT64:
+      if (json === null) return proto_int64_js_1.protoInt64.zero;
+      if (typeof json != "number" && typeof json != "string") break;
+      return proto_int64_js_1.protoInt64.uParse(json);
+    // bool:
+    case field_js_1.ScalarType.BOOL:
+      if (json === null) return false;
+      if (typeof json !== "boolean") break;
+      return json;
+    // string:
+    case field_js_1.ScalarType.STRING:
+      if (json === null) return "";
+      if (typeof json !== "string") {
+        break;
+      }
+      // A string must always contain UTF-8 encoded or 7-bit ASCII.
+      // We validate with encodeURIComponent, which appears to be the fastest widely available option.
+      try {
+        encodeURIComponent(json);
+      } catch (e) {
+        throw new Error("invalid UTF8");
+      }
+      return json;
+    // 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 field_js_1.ScalarType.BYTES:
+      if (json === null || json === "") return new Uint8Array(0);
+      if (typeof json !== "string") break;
+      return (0, base64_js_1.base64decode)(json);
+  }
+  throw new Error();
+}
+function readEnum(type, json, ignoreUnknownFields) {
+  if (json === null) {
+    // proto3 requires 0 to be default value for all enums
+    return 0;
+  }
+  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+  switch (typeof json) {
+    case "number":
+      if (Number.isInteger(json)) {
+        return json;
+      }
+      break;
+    case "string":
+      const value = type.findName(json);
+      if (value || ignoreUnknownFields) {
+        return value?.no;
+      }
+      break;
+  }
+  throw new Error(
+    `cannot decode enum ${type.typeName} from JSON: ${debugJsonValue(json)}`
+  );
+}
+function writeEnum(type, value, emitIntrinsicDefault, enumAsInteger) {
+  if (value === undefined) {
+    return value;
+  }
+  if (value === 0 && !emitIntrinsicDefault) {
+    // proto3 requires 0 to be default value for all enums
+    return undefined;
+  }
+  if (enumAsInteger) {
+    return value;
+  }
+  if (type.typeName == "google.protobuf.NullValue") {
+    return null;
+  }
+  const val = type.findNumber(value);
+  return val?.name ?? value; // if we don't know the enum value, just return the number
+}
+function writeScalar(type, value, emitIntrinsicDefault) {
+  if (value === undefined) {
+    return undefined;
+  }
+  switch (type) {
+    // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+    case field_js_1.ScalarType.INT32:
+    case field_js_1.ScalarType.SFIXED32:
+    case field_js_1.ScalarType.SINT32:
+    case field_js_1.ScalarType.FIXED32:
+    case field_js_1.ScalarType.UINT32:
+      (0, assert_js_1.assert)(typeof value == "number");
+      return value != 0 || emitIntrinsicDefault ? value : undefined;
+    // 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 field_js_1.ScalarType.FLOAT:
+    // assertFloat32(value);
+    case field_js_1.ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
+      (0, assert_js_1.assert)(typeof value == "number");
+      if (Number.isNaN(value)) return "NaN";
+      if (value === Number.POSITIVE_INFINITY) return "Infinity";
+      if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+      return value !== 0 || emitIntrinsicDefault ? value : undefined;
+    // string:
+    case field_js_1.ScalarType.STRING:
+      (0, assert_js_1.assert)(typeof value == "string");
+      return value.length > 0 || emitIntrinsicDefault ? value : undefined;
+    // bool:
+    case field_js_1.ScalarType.BOOL:
+      (0, assert_js_1.assert)(typeof value == "boolean");
+      return value || emitIntrinsicDefault ? value : undefined;
+    // JSON value will be a decimal string. Either numbers or strings are accepted.
+    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:
+      (0, assert_js_1.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 emitIntrinsicDefault || value != 0
+        ? value.toString(10)
+        : undefined;
+    // 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 field_js_1.ScalarType.BYTES:
+      (0, assert_js_1.assert)(value instanceof Uint8Array);
+      return emitIntrinsicDefault || value.byteLength > 0
+        ? (0, base64_js_1.base64encode)(value)
+        : undefined;
+  }
+}