@bufbuild/protobuf 0.0.1-alpha.1

package/dist/esm/private/names.js

@@ -0,0 +1,90 @@
+/**
+ * Returns the JSON name for a protobuf field, exactly like protoc does.
+ */
+export function makeJsonName(protoName) {
+  return protoCamelCase(protoName);
+}
+/**
+ * Returns the local name of a field, exactly like protoc-gen-es does.
+ */
+export function makeFieldName(protoName, inOneof) {
+  const n = protoCamelCase(protoName);
+  if (inOneof) {
+    return n;
+  }
+  return rProp[n] ? n + escapeChar : n;
+}
+/**
+ * Returns the local name of a oneof group, exactly like protoc-gen-es does.
+ */
+export function makeOneofName(protoName) {
+  return makeFieldName(protoName, false);
+}
+/**
+ * Returns the local name of a rpc, exactly like protoc-gen-es does.
+ */
+export function makeMethodName(protoName) {
+  if (protoName.length == 0) {
+    return protoName;
+  }
+  return protoName[0].toLowerCase() + protoName.substring(1);
+}
+// 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/esm/private/options-map.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,15 @@
+import { getEnumType, makeEnumType } from "./enum.js";
+import { makeMessageType } from "./message-type.js";
+export function makeProtoRuntime(syntax, json, bin, util) {
+  return {
+    syntax,
+    json,
+    bin,
+    util,
+    makeMessageType(typeName, fields, opt) {
+      return makeMessageType(this, typeName, fields, opt);
+    },
+    makeEnumType,
+    getEnumType,
+  };
+}

package/dist/esm/private/scalars.js

@@ -0,0 +1,129 @@
+import { ScalarType } from "../field.js";
+import { WireType } from "../binary-encoding.js";
+import { protoInt64 } from "../proto-int64.js";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Returns true if both scalar values are equal.
+ */
+export 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 == 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 ScalarType.UINT64:
+    case ScalarType.FIXED64:
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case 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;
+}
+/**
+ * Returns the default value for the given scalar type, following
+ * proto3 semantics.
+ */
+export function scalarDefaultValue(type) {
+  switch (type) {
+    case ScalarType.BOOL:
+      return false;
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      return protoInt64.zero;
+    case ScalarType.DOUBLE:
+    case ScalarType.FLOAT:
+      return 0.0;
+    case ScalarType.BYTES:
+      return new Uint8Array(0);
+    case 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;
+  }
+}
+/**
+ * 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.
+ */
+export function scalarTypeInfo(type, value) {
+  const isUndefined = value === undefined;
+  let wireType = 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 ScalarType.STRING:
+      isIntrinsicDefault = isUndefined || !value.length;
+      wireType = WireType.LengthDelimited;
+      break;
+    case ScalarType.BOOL:
+      isIntrinsicDefault = value === false;
+      break;
+    case ScalarType.DOUBLE:
+      wireType = WireType.Bit64;
+      break;
+    case ScalarType.FLOAT:
+      wireType = WireType.Bit32;
+      break;
+    case ScalarType.INT64:
+      isIntrinsicDefault = isUndefined || value == 0;
+      break;
+    case ScalarType.UINT64:
+      isIntrinsicDefault = isUndefined || value == 0;
+      break;
+    case ScalarType.FIXED64:
+      isIntrinsicDefault = isUndefined || value == 0;
+      wireType = WireType.Bit64;
+      break;
+    case ScalarType.BYTES:
+      isIntrinsicDefault = isUndefined || !value.byteLength;
+      wireType = WireType.LengthDelimited;
+      break;
+    case ScalarType.FIXED32:
+      wireType = WireType.Bit32;
+      break;
+    case ScalarType.SFIXED32:
+      wireType = WireType.Bit32;
+      break;
+    case ScalarType.SFIXED64:
+      isIntrinsicDefault = isUndefined || value == 0;
+      wireType = WireType.Bit64;
+      break;
+    case ScalarType.SINT64:
+      isIntrinsicDefault = isUndefined || value == 0;
+      break;
+  }
+  const method = ScalarType[type].toLowerCase();
+  return [wireType, method, isUndefined || isIntrinsicDefault];
+}

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

@@ -0,0 +1,207 @@
+import { setEnumType } from "./enum.js";
+import { ScalarType } from "../field.js";
+import { scalarEquals } from "./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 */
+export function makeUtilCommon() {
+  return {
+    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) => scalarEquals(m.T, a, vb[i]));
+            case "enum":
+              return va.every((a, i) =>
+                scalarEquals(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 scalarEquals(ScalarType.INT32, va, vb);
+          case "scalar":
+            return 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 scalarEquals(ScalarType.INT32, va, vb);
+              case "scalar":
+                return 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) =>
+                  scalarEquals(ScalarType.INT32, va[k], vb[k])
+                );
+              case "scalar":
+                const scalarType = m.V.T;
+                return keys.every((k) =>
+                  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;
+    },
+  };
+}
+// 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 === 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/esm/private/util.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/proto-int64.js

@@ -0,0 +1,118 @@
+import { int64fromString, int64toString } from "./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] = 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] = 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 "-" + int64toString(lo, hi);
+      }
+      return int64toString(lo, hi);
+    },
+    uDec(lo, hi) {
+      return int64toString(lo, hi);
+    },
+  };
+}
+export const protoInt64 = makeInt64Support();

package/dist/esm/proto2.js

@@ -0,0 +1,77 @@
+import { makeProtoRuntime } from "./private/proto-runtime.js";
+import { makeBinaryFormatProto2 } from "./private/binary-format-proto2.js";
+import { makeUtilCommon } from "./private/util-common.js";
+import { InternalFieldList } from "./private/field-list.js";
+import { InternalOneofInfo } from "./private/field.js";
+import { makeFieldName, makeJsonName } from "./private/names.js";
+import { makeJsonFormatProto2 } from "./private/json-format-proto2.js";
+/**
+ * Provides functionality for messages defined with the proto2 syntax.
+ */
+export const proto2 = makeProtoRuntime(
+  "proto2",
+  makeJsonFormatProto2(),
+  makeBinaryFormatProto2(),
+  {
+    ...makeUtilCommon(),
+    newFieldList(fields) {
+      return new 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 = makeFieldName(field.name, field.oneof !== undefined);
+    f.jsonName = field.jsonName ?? 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 InternalOneofInfo(ooname);
+      }
+      f.oneof = o;
+      o.addField(f);
+    }
+    r.push(f);
+  }
+  return r;
+}