@bufbuild/protobuf 0.0.1-alpha.1

package/dist/cjs/private/util-common.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUtilCommon = void 0;
+const enum_js_1 = require("./enum.js");
+const field_js_1 = require("../field.js");
+const scalars_js_1 = require("./scalars.js");
+/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-argument,no-case-declarations */
+function makeUtilCommon() {
+  return {
+    setEnumType: enum_js_1.setEnumType,
+    initPartial(source, target) {
+      if (source === undefined) {
+        return;
+      }
+      const type = target.getType();
+      for (const member of type.fields.byMember()) {
+        const localName = member.localName,
+          t = target,
+          s = source;
+        if (s[localName] === undefined) {
+          continue;
+        }
+        switch (member.kind) {
+          case "oneof":
+            const sk = s[localName].case;
+            if (sk === undefined) {
+              continue;
+            }
+            const sourceField = member.findField(sk);
+            let val = s[localName].value;
+            if (
+              sourceField &&
+              sourceField.kind == "message" &&
+              !(val instanceof sourceField.T)
+            ) {
+              val = new sourceField.T(val);
+            }
+            t[localName] = { case: sk, value: val };
+            break;
+          case "scalar":
+          case "enum":
+            t[localName] = s[localName];
+            break;
+          case "map":
+            switch (member.V.kind) {
+              case "scalar":
+              case "enum":
+                Object.assign(t[localName], s[localName]);
+                break;
+              case "message":
+                const messageType = member.V.T;
+                for (const k of Object.keys(s[localName])) {
+                  let val = s[localName][k];
+                  if (!messageType.fieldWrapper) {
+                    // We only take partial input for messages that are not a wrapper type.
+                    // For those messages, we recursively normalize the partial input.
+                    val = new messageType(val);
+                  }
+                  t[localName][k] = val;
+                }
+                break;
+            }
+            break;
+          case "message":
+            const mt = member.T;
+            if (member.repeated) {
+              t[localName] = s[localName].map((val) =>
+                val instanceof mt ? val : new mt(val)
+              );
+            } else if (s[localName] !== undefined) {
+              const val = s[localName];
+              if (mt.fieldWrapper) {
+                t[localName] = val;
+              } else {
+                t[localName] = val instanceof mt ? mt : new mt(val);
+              }
+            }
+            break;
+        }
+      }
+    },
+    equals(type, a, b) {
+      if (a === b) {
+        return true;
+      }
+      if (!a || !b) {
+        return false;
+      }
+      return type.fields.byMember().every((m) => {
+        const va = a[m.localName];
+        const vb = b[m.localName];
+        if (m.repeated) {
+          if (va.length !== vb.length) {
+            return false;
+          }
+          // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- repeated fields are never "map"
+          switch (m.kind) {
+            case "message":
+              return va.every((a, i) => m.T.equals(a, vb[i]));
+            case "scalar":
+              return va.every((a, i) =>
+                (0, scalars_js_1.scalarEquals)(m.T, a, vb[i])
+              );
+            case "enum":
+              return va.every((a, i) =>
+                (0, scalars_js_1.scalarEquals)(
+                  field_js_1.ScalarType.INT32,
+                  a,
+                  vb[i]
+                )
+              );
+          }
+          throw new Error(`repeated cannot contain ${m.kind}`);
+        }
+        switch (m.kind) {
+          case "message":
+            return m.T.equals(va, vb);
+          case "enum":
+            return (0, scalars_js_1.scalarEquals)(
+              field_js_1.ScalarType.INT32,
+              va,
+              vb
+            );
+          case "scalar":
+            return (0, scalars_js_1.scalarEquals)(m.T, va, vb);
+          case "oneof":
+            if (va.case !== vb.case) {
+              return false;
+            }
+            const k = va.case,
+              s = m.findField(k);
+            if (s === undefined) {
+              return true;
+            }
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- oneof fields are never "map"
+            switch (s.kind) {
+              case "message":
+                return s.T.equals(va[k], vb[k]);
+              case "enum":
+                return (0, scalars_js_1.scalarEquals)(
+                  field_js_1.ScalarType.INT32,
+                  va,
+                  vb
+                );
+              case "scalar":
+                return (0, scalars_js_1.scalarEquals)(s.T, va, vb);
+            }
+            throw new Error(`oneof cannot contain ${s.kind}`);
+          case "map":
+            const keys = Object.keys(va);
+            if (keys.some((k) => vb[k] === undefined)) {
+              return false;
+            }
+            switch (m.V.kind) {
+              case "message":
+                const messageType = m.V.T;
+                return keys.every((k) => messageType.equals(va[k], vb[k]));
+              case "enum":
+                return keys.every((k) =>
+                  (0, scalars_js_1.scalarEquals)(
+                    field_js_1.ScalarType.INT32,
+                    va[k],
+                    vb[k]
+                  )
+                );
+              case "scalar":
+                const scalarType = m.V.T;
+                return keys.every((k) =>
+                  (0, scalars_js_1.scalarEquals)(scalarType, va[k], vb[k])
+                );
+            }
+            break;
+        }
+      });
+    },
+    clone(message) {
+      const type = message.getType(),
+        target = new type(),
+        any = target;
+      for (const member of type.fields.byMember()) {
+        const source = message[member.localName];
+        let copy;
+        if (member.repeated) {
+          copy = source.map((e) => cloneSingularField(member, e));
+        } else if (member.kind == "map") {
+          copy = any[member.localName];
+          for (const [key, v] of Object.entries(source)) {
+            copy[key] = cloneSingularField(member.V, v);
+          }
+        } else if (member.kind == "oneof") {
+          const f = member.findField(source.case);
+          copy = f
+            ? { case: source.case, value: cloneSingularField(f, source.value) }
+            : { case: undefined };
+        } else {
+          copy = cloneSingularField(member, source);
+        }
+        any[member.localName] = copy;
+      }
+      return target;
+    },
+  };
+}
+exports.makeUtilCommon = makeUtilCommon;
+// clone a single field value - i.e. the element type of repeated fields, the value type of maps
+function cloneSingularField(field, value) {
+  if (value === undefined) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- unmatched "map" is unsupported
+  switch (field.kind) {
+    case "enum":
+      return value;
+    case "scalar":
+      if (field.T === field_js_1.ScalarType.BYTES) {
+        const c = new Uint8Array(value.byteLength);
+        c.set(value);
+        return c;
+      }
+      return value;
+    case "message":
+      if (field.T.fieldWrapper) {
+        return field.T.fieldWrapper.unwrapField(
+          field.T.fieldWrapper.wrapField(value).clone()
+        );
+      }
+      return value.clone();
+  }
+}

package/dist/cjs/private/util.js

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

package/dist/cjs/proto-int64.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protoInt64 = void 0;
+const varint_js_1 = require("./google/varint.js");
+function makeInt64Support() {
+  const dv = new DataView(new ArrayBuffer(8));
+  // note that Safari 14 implements BigInt, but not the DataView methods
+  const ok =
+    globalThis.BigInt !== undefined && // eslint-disable-line @typescript-eslint/no-unnecessary-condition -- conditional for BigInt is very much necessary
+    typeof dv.getBigInt64 === "function" &&
+    typeof dv.getBigUint64 === "function" &&
+    typeof dv.setBigInt64 === "function" &&
+    typeof dv.setBigUint64 === "function";
+  if (ok) {
+    const MIN = BigInt("-9223372036854775808"),
+      MAX = BigInt("9223372036854775807"),
+      UMIN = BigInt("0"),
+      UMAX = BigInt("18446744073709551615");
+    return {
+      zero: BigInt(0),
+      supported: true,
+      parse(value) {
+        const bi = typeof value == "bigint" ? value : BigInt(value);
+        if (bi > MAX || bi < MIN) {
+          throw new Error(`int64 invalid: ${value}`);
+        }
+        return bi;
+      },
+      uParse(value) {
+        const bi = typeof value == "bigint" ? value : BigInt(value);
+        if (bi > UMAX || bi < UMIN) {
+          throw new Error(`uint64 invalid: ${value}`);
+        }
+        return bi;
+      },
+      enc(value) {
+        dv.setBigInt64(0, this.parse(value), true);
+        return {
+          lo: dv.getInt32(0, true),
+          hi: dv.getInt32(4, true),
+        };
+      },
+      uEnc(value) {
+        dv.setBigInt64(0, this.uParse(value), true);
+        return {
+          lo: dv.getInt32(0, true),
+          hi: dv.getInt32(4, true),
+        };
+      },
+      dec(lo, hi) {
+        dv.setInt32(0, lo, true);
+        dv.setInt32(4, hi, true);
+        return dv.getBigInt64(0, true);
+      },
+      uDec(lo, hi) {
+        dv.setInt32(0, lo, true);
+        dv.setInt32(4, hi, true);
+        return dv.getBigUint64(0, true);
+      },
+    };
+  }
+  return {
+    zero: "0",
+    supported: false,
+    parse(value) {
+      if (!/^-?[0-9]+$/.test(value)) {
+        throw new Error(`int64 invalid: ${value}`);
+      }
+      return value;
+    },
+    uParse(value) {
+      if (!/^-?[0-9]+$/.test(value)) {
+        throw new Error(`uint64 invalid: ${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);
+      }
+      const [, lo, hi] = (0, varint_js_1.int64fromString)(value);
+      return { lo, hi };
+    },
+    uEnc(value) {
+      if (typeof value == "string") {
+        if (!/^-?[0-9]+$/.test(value)) {
+          throw new Error(`uint64 invalid: ${value}`);
+        }
+      } 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 };
+    },
+    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);
+    },
+    uDec(lo, hi) {
+      return (0, varint_js_1.int64toString)(lo, hi);
+    },
+  };
+}
+exports.protoInt64 = makeInt64Support();

package/dist/cjs/proto2.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proto2 = void 0;
+const proto_runtime_js_1 = require("./private/proto-runtime.js");
+const binary_format_proto2_js_1 = require("./private/binary-format-proto2.js");
+const util_common_js_1 = require("./private/util-common.js");
+const field_list_js_1 = require("./private/field-list.js");
+const field_js_1 = require("./private/field.js");
+const names_js_1 = require("./private/names.js");
+const json_format_proto2_js_1 = require("./private/json-format-proto2.js");
+/**
+ * Provides functionality for messages defined with the proto2 syntax.
+ */
+exports.proto2 = (0, proto_runtime_js_1.makeProtoRuntime)(
+  "proto2",
+  (0, json_format_proto2_js_1.makeJsonFormatProto2)(),
+  (0, binary_format_proto2_js_1.makeBinaryFormatProto2)(),
+  {
+    ...(0, util_common_js_1.makeUtilCommon)(),
+    newFieldList(fields) {
+      return new field_list_js_1.InternalFieldList(
+        fields,
+        normalizeFieldInfosProto2
+      );
+    },
+    initFields(target) {
+      for (const member of target.getType().fields.byMember()) {
+        const name = member.localName,
+          t = target;
+        if (member.repeated) {
+          t[name] = [];
+          continue;
+        }
+        switch (member.kind) {
+          case "oneof":
+            t[name] = { case: undefined };
+            break;
+          case "map":
+            t[name] = {};
+            break;
+          case "scalar":
+          case "enum":
+          case "message":
+            // In contrast to proto3, enum and scalar fields have no intrinsic default value,
+            // only an optional explicit default value.
+            // Unlike proto3 intrinsic default values, proto2 explicit default values are not
+            // set on construction, because they are not omitted on the wire. If we did set
+            // default values on construction, a deserialize-serialize round-trip would add
+            // fields to a message.
+            break;
+        }
+      }
+    },
+  }
+);
+/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
+function normalizeFieldInfosProto2(fieldInfos) {
+  const r = [];
+  let o;
+  for (const field of typeof fieldInfos == "function"
+    ? fieldInfos()
+    : fieldInfos) {
+    const f = field;
+    f.localName = (0, names_js_1.makeFieldName)(
+      field.name,
+      field.oneof !== undefined
+    );
+    f.jsonName = field.jsonName ?? (0, names_js_1.makeJsonName)(field.name);
+    f.repeated = field.repeated ?? false;
+    // In contrast to proto3, repeated fields are unpacked except when explicitly specified.
+    f.packed = field.packed ?? false;
+    // We do not surface options at this time
+    // f.options = field.options ?? emptyReadonlyObject;
+    if (field.oneof !== undefined) {
+      const ooname =
+        typeof field.oneof == "string" ? field.oneof : field.oneof.name;
+      if (!o || o.name != ooname) {
+        o = new field_js_1.InternalOneofInfo(ooname);
+      }
+      f.oneof = o;
+      o.addField(f);
+    }
+    r.push(f);
+  }
+  return r;
+}

package/dist/cjs/proto3.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proto3 = void 0;
+const proto_runtime_js_1 = require("./private/proto-runtime.js");
+const binary_format_proto3_js_1 = require("./private/binary-format-proto3.js");
+const json_format_proto3_js_1 = require("./private/json-format-proto3.js");
+const util_common_js_1 = require("./private/util-common.js");
+const field_list_js_1 = require("./private/field-list.js");
+const scalars_js_1 = require("./private/scalars.js");
+const field_js_1 = require("./field.js");
+const field_js_2 = require("./private/field.js");
+const names_js_1 = require("./private/names.js");
+/**
+ * Provides functionality for messages defined with the proto3 syntax.
+ */
+exports.proto3 = (0, proto_runtime_js_1.makeProtoRuntime)(
+  "proto3",
+  (0, json_format_proto3_js_1.makeJsonFormatProto3)(),
+  (0, binary_format_proto3_js_1.makeBinaryFormatProto3)(),
+  {
+    ...(0, util_common_js_1.makeUtilCommon)(),
+    newFieldList(fields) {
+      return new field_list_js_1.InternalFieldList(
+        fields,
+        normalizeFieldInfosProto3
+      );
+    },
+    initFields(target) {
+      for (const member of target.getType().fields.byMember()) {
+        if (member.opt) {
+          continue;
+        }
+        const name = member.localName,
+          t = target;
+        if (member.repeated) {
+          t[name] = [];
+          continue;
+        }
+        switch (member.kind) {
+          case "oneof":
+            t[name] = { case: undefined };
+            break;
+          case "enum":
+            t[name] = 0;
+            break;
+          case "map":
+            t[name] = {};
+            break;
+          case "scalar":
+            t[name] = (0, scalars_js_1.scalarDefaultValue)(member.T); // eslint-disable-line @typescript-eslint/no-unsafe-assignment
+            break;
+          case "message":
+            // message fields are always optional in proto3
+            break;
+        }
+      }
+    },
+  }
+);
+/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
+function normalizeFieldInfosProto3(fieldInfos) {
+  const r = [];
+  let o;
+  for (const field of typeof fieldInfos == "function"
+    ? fieldInfos()
+    : fieldInfos) {
+    const f = field;
+    f.localName = (0, names_js_1.makeFieldName)(
+      field.name,
+      field.oneof !== undefined
+    );
+    f.jsonName = field.jsonName ?? (0, names_js_1.makeJsonName)(field.name);
+    f.repeated = field.repeated ?? false;
+    // From the proto3 language guide:
+    // > In proto3, repeated fields of scalar numeric types are packed by default.
+    // This information is incomplete - according to the conformance tests, BOOL
+    // and ENUM are packed by default as well. This means only STRING and BYTES
+    // are not packed by default, which makes sense because they are length-delimited.
+    f.packed =
+      field.packed ??
+      (field.kind == "enum" ||
+        (field.kind == "scalar" &&
+          field.T != field_js_1.ScalarType.BYTES &&
+          field.T != field_js_1.ScalarType.STRING));
+    // We do not surface options at this time
+    // f.options = field.options ?? emptyReadonlyObject;
+    if (field.oneof !== undefined) {
+      const ooname =
+        typeof field.oneof == "string" ? field.oneof : field.oneof.name;
+      if (!o || o.name != ooname) {
+        o = new field_js_2.InternalOneofInfo(ooname);
+      }
+      f.oneof = o;
+      o.addField(f);
+    }
+    r.push(f);
+  }
+  return r;
+}

package/dist/cjs/service-type.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodIdempotency = exports.MethodKind = void 0;
+/**
+ * MethodKind represents the four method types that can be declared in
+ * protobuf with the `stream` keyword:
+ *
+ * 1. Unary:           rpc (Input) returns (Output)
+ * 2. ServerStreaming: rpc (Input) returns (stream Output)
+ * 3. ClientStreaming: rpc (stream Input) returns (Output)
+ * 4. BiDiStreaming:   rpc (stream Input) returns (stream Output)
+ */
+var MethodKind;
+(function (MethodKind) {
+  MethodKind[(MethodKind["Unary"] = 0)] = "Unary";
+  MethodKind[(MethodKind["ServerStreaming"] = 1)] = "ServerStreaming";
+  MethodKind[(MethodKind["ClientStreaming"] = 2)] = "ClientStreaming";
+  MethodKind[(MethodKind["BiDiStreaming"] = 3)] = "BiDiStreaming";
+})((MethodKind = exports.MethodKind || (exports.MethodKind = {})));
+/**
+ * Is this method side-effect-free (or safe in HTTP parlance), or just
+ * idempotent, or neither? HTTP based RPC implementation may choose GET verb
+ * for safe methods, and PUT verb for idempotent methods instead of the
+ * default POST.
+ *
+ * This enum matches the protobuf enum google.protobuf.MethodOptions.IdempotencyLevel,
+ * defined in the well-known type google/protobuf/descriptor.proto, but
+ * drops UNKNOWN.
+ */
+var MethodIdempotency;
+(function (MethodIdempotency) {
+  /**
+   * Idempotent, no side effects.
+   */
+  MethodIdempotency[(MethodIdempotency["NoSideEffects"] = 1)] = "NoSideEffects";
+  /**
+   * Idempotent, but may have side effects.
+   */
+  MethodIdempotency[(MethodIdempotency["Idempotent"] = 2)] = "Idempotent";
+})(
+  (MethodIdempotency =
+    exports.MethodIdempotency || (exports.MethodIdempotency = {}))
+);

package/dist/cjs/type-registry.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeRegistry = void 0;
+/**
+ * TypeRegistry is a basic type registry
+ */
+class TypeRegistry {
+  constructor() {
+    this.messages = {};
+    this.enums = {};
+    this.services = {};
+  }
+  findMessage(typeName) {
+    return this.messages[typeName];
+  }
+  findEnum(typeName) {
+    return this.enums[typeName];
+  }
+  findService(typeName) {
+    return this.services[typeName];
+  }
+  add(type) {
+    if ("fields" in type) {
+      this.messages[type.typeName] = type;
+    } else if ("methods" in type) {
+      this.services[type.typeName] = type;
+    } else {
+      this.enums[type.typeName] = type;
+    }
+  }
+  static fromIterable(types) {
+    const r = new TypeRegistry();
+    for (const t of types) {
+      r.add(t);
+    }
+    return r;
+  }
+  static fromTypes(...types) {
+    return TypeRegistry.fromIterable(types);
+  }
+}
+exports.TypeRegistry = TypeRegistry;