@bufbuild/protobuf 0.0.1-alpha.1

package/dist/cjs/private/base64.js

@@ -0,0 +1,118 @@
+"use strict";
+/* eslint-disable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-unnecessary-condition, prefer-const */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64encode = exports.base64decode = void 0;
+// lookup table from base64 character to byte
+let encTable =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+// lookup table from base64 character *code* to byte because lookup by number is fast
+let decTable = [];
+for (let i = 0; i < encTable.length; i++)
+  decTable[encTable[i].charCodeAt(0)] = i;
+// support base64url variants
+decTable["-".charCodeAt(0)] = encTable.indexOf("+");
+decTable["_".charCodeAt(0)] = encTable.indexOf("/");
+/**
+ * Decodes a base64 string to a byte array.
+ *
+ * - ignores white-space, including line breaks and tabs
+ * - allows inner padding (can decode concatenated base64 strings)
+ * - does not require padding
+ * - understands base64url encoding:
+ *   "-" instead of "+",
+ *   "_" instead of "/",
+ *   no padding
+ */
+function base64decode(base64Str) {
+  // estimate byte size, not accounting for inner padding and whitespace
+  let es = (base64Str.length * 3) / 4;
+  // if (es % 3 !== 0)
+  // throw new Error("invalid base64 string");
+  if (base64Str[base64Str.length - 2] == "=") es -= 2;
+  else if (base64Str[base64Str.length - 1] == "=") es -= 1;
+  let bytes = new Uint8Array(es),
+    bytePos = 0, // position in byte array
+    groupPos = 0, // position in base64 group
+    b, // current byte
+    p = 0; // previous byte
+  for (let i = 0; i < base64Str.length; i++) {
+    b = decTable[base64Str.charCodeAt(i)];
+    if (b === undefined) {
+      switch (base64Str[i]) {
+        // @ts-ignore TS7029: Fallthrough case in switch
+        case "=":
+          groupPos = 0; // reset state when padding found
+        // @ts-ignore TS7029: Fallthrough case in switch
+        case "\n":
+        case "\r":
+        case "\t":
+        case " ":
+          continue; // skip white-space, and padding
+        default:
+          throw Error("invalid base64 string.");
+      }
+    }
+    switch (groupPos) {
+      case 0:
+        p = b;
+        groupPos = 1;
+        break;
+      case 1:
+        bytes[bytePos++] = (p << 2) | ((b & 48) >> 4);
+        p = b;
+        groupPos = 2;
+        break;
+      case 2:
+        bytes[bytePos++] = ((p & 15) << 4) | ((b & 60) >> 2);
+        p = b;
+        groupPos = 3;
+        break;
+      case 3:
+        bytes[bytePos++] = ((p & 3) << 6) | b;
+        groupPos = 0;
+        break;
+    }
+  }
+  if (groupPos == 1) throw Error("invalid base64 string.");
+  return bytes.subarray(0, bytePos);
+}
+exports.base64decode = base64decode;
+/**
+ * Encodes a byte array to a base64 string.
+ * Adds padding at the end.
+ * Does not insert newlines.
+ */
+function base64encode(bytes) {
+  let base64 = "",
+    groupPos = 0, // position in base64 group
+    b, // current byte
+    p = 0; // carry over from previous byte
+  for (let i = 0; i < bytes.length; i++) {
+    b = bytes[i];
+    switch (groupPos) {
+      case 0:
+        base64 += encTable[b >> 2];
+        p = (b & 3) << 4;
+        groupPos = 1;
+        break;
+      case 1:
+        base64 += encTable[p | (b >> 4)];
+        p = (b & 15) << 2;
+        groupPos = 2;
+        break;
+      case 2:
+        base64 += encTable[p | (b >> 6)];
+        base64 += encTable[b & 63];
+        groupPos = 0;
+        break;
+    }
+  }
+  // padding required?
+  if (groupPos) {
+    base64 += encTable[p];
+    base64 += "=";
+    if (groupPos == 1) base64 += "=";
+  }
+  return base64;
+}
+exports.base64encode = base64encode;

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

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writePacked =
+  exports.writeScalar =
+  exports.writeMessageField =
+  exports.writeMapEntry =
+  exports.makeBinaryFormatCommon =
+    void 0;
+const binary_encoding_js_1 = require("../binary-encoding.js");
+const field_js_1 = require("../field.js");
+const field_wrapper_js_1 = require("./field-wrapper.js");
+const scalars_js_1 = require("./scalars.js");
+const assert_js_1 = require("./assert.js");
+/* eslint-disable @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unnecessary-condition, no-case-declarations, prefer-const */
+const unknownFieldsSymbol = Symbol("@bufbuild/protobuf/unknown-fields");
+// Default options for parsing binary data.
+const readDefaults = {
+  readUnknownFields: true,
+  readerFactory: (bytes) => new binary_encoding_js_1.BinaryReader(bytes),
+};
+// Default options for serializing binary data.
+const writeDefaults = {
+  writeUnknownFields: true,
+  writerFactory: () => new binary_encoding_js_1.BinaryWriter(),
+};
+function makeReadOptions(options) {
+  return options ? { ...readDefaults, ...options } : readDefaults;
+}
+function makeWriteOptions(options) {
+  return options ? { ...writeDefaults, ...options } : writeDefaults;
+}
+function makeBinaryFormatCommon() {
+  return {
+    makeReadOptions,
+    makeWriteOptions,
+    listUnknownFields(message) {
+      return message[unknownFieldsSymbol] ?? [];
+    },
+    discardUnknownFields(message) {
+      delete message[unknownFieldsSymbol];
+    },
+    writeUnknownFields(message, writer) {
+      const m = message;
+      const c = m[unknownFieldsSymbol];
+      if (c) {
+        for (const f of c) {
+          writer.tag(f.no, f.wireType).raw(f.data);
+        }
+      }
+    },
+    onUnknownField(message, no, wireType, data) {
+      const m = message;
+      if (!Array.isArray(m[unknownFieldsSymbol])) {
+        m[unknownFieldsSymbol] = [];
+      }
+      m[unknownFieldsSymbol].push({ no, wireType, data });
+    },
+    readMessage(message, reader, length, options) {
+      const type = message.getType();
+      const end = length === undefined ? reader.len : reader.pos + length;
+      while (reader.pos < end) {
+        const [fieldNo, wireType] = reader.tag(),
+          field = type.fields.find(fieldNo);
+        if (!field) {
+          const data = reader.skip(wireType);
+          if (options.readUnknownFields) {
+            this.onUnknownField(message, fieldNo, wireType, data);
+          }
+          continue;
+        }
+        let target = message,
+          repeated = field.repeated,
+          localName = field.localName;
+        if (field.oneof) {
+          target = target[field.oneof.localName];
+          if (target.case != localName) {
+            delete target.value;
+          }
+          target.case = localName;
+          localName = "value";
+        }
+        switch (field.kind) {
+          case "scalar":
+          case "enum":
+            const scalarType =
+              field.kind == "enum" ? field_js_1.ScalarType.INT32 : field.T;
+            if (repeated) {
+              let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values
+              if (
+                wireType == binary_encoding_js_1.WireType.LengthDelimited &&
+                scalarType != field_js_1.ScalarType.STRING &&
+                scalarType != field_js_1.ScalarType.BYTES
+              ) {
+                let e = reader.uint32() + reader.pos;
+                while (reader.pos < e) {
+                  arr.push(readScalar(reader, scalarType));
+                }
+              } else {
+                arr.push(readScalar(reader, scalarType));
+              }
+            } else {
+              target[localName] = readScalar(reader, scalarType);
+            }
+            break;
+          case "message":
+            const messageType = field.T;
+            if (repeated) {
+              // safe to assume presence of array, oneof cannot contain repeated values
+              target[localName].push(
+                messageType.fromBinary(reader.bytes(), options)
+              );
+            } else {
+              if (target[localName] instanceof messageType) {
+                target[localName].fromBinary(reader.bytes(), options);
+              } else {
+                target[localName] = (0, field_wrapper_js_1.unwrapField)(
+                  messageType,
+                  messageType.fromBinary(reader.bytes(), options)
+                );
+              }
+            }
+            break;
+          case "map":
+            let [mapKey, mapVal] = readMapEntry(field, reader, options);
+            // safe to assume presence of map object, oneof cannot contain repeated values
+            target[localName][mapKey] = mapVal;
+            break;
+        }
+      }
+    },
+  };
+}
+exports.makeBinaryFormatCommon = makeBinaryFormatCommon;
+// Read a map field, expecting key field = 1, value field = 2
+function readMapEntry(field, reader, options) {
+  const length = reader.uint32(),
+    end = reader.pos + length;
+  let key, val;
+  while (reader.pos < end) {
+    let [fieldNo] = reader.tag();
+    switch (fieldNo) {
+      case 1:
+        key = readScalar(reader, field.K);
+        break;
+      case 2:
+        switch (field.V.kind) {
+          case "scalar":
+            val = readScalar(reader, field.V.T);
+            break;
+          case "enum":
+            val = reader.int32();
+            break;
+          case "message":
+            val = field.V.T.fromBinary(reader.bytes(), options);
+            break;
+        }
+        break;
+    }
+  }
+  if (key === undefined) {
+    let keyRaw = (0, scalars_js_1.scalarDefaultValue)(field.K);
+    key = field.K == field_js_1.ScalarType.BOOL ? keyRaw.toString() : keyRaw;
+  }
+  if (typeof key != "string" && typeof key != "number") {
+    key = key.toString();
+  }
+  if (val === undefined) {
+    switch (field.V.kind) {
+      case "scalar":
+        val = (0, scalars_js_1.scalarDefaultValue)(field.V.T);
+        break;
+      case "enum":
+        val = 0;
+        break;
+      case "message":
+        val = new field.V.T();
+        break;
+    }
+  }
+  return [key, val];
+}
+function readScalar(reader, type) {
+  let [, method] = (0, scalars_js_1.scalarTypeInfo)(type);
+  return reader[method]();
+}
+function writeMapEntry(writer, options, field, key, value) {
+  writer.tag(field.no, binary_encoding_js_1.WireType.LengthDelimited);
+  writer.fork();
+  // javascript only allows number or string for object properties
+  // we convert from our representation to the protobuf type
+  let keyValue = key;
+  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- we deliberately handle just the special cases for map keys
+  switch (field.K) {
+    case field_js_1.ScalarType.INT32:
+    case field_js_1.ScalarType.FIXED32:
+    case field_js_1.ScalarType.UINT32:
+    case field_js_1.ScalarType.SFIXED32:
+    case field_js_1.ScalarType.SINT32:
+      keyValue = Number.parseInt(key);
+      break;
+    case field_js_1.ScalarType.BOOL:
+      (0, assert_js_1.assert)(key == "true" || key == "false");
+      keyValue = key == "true";
+      break;
+  }
+  // write key, expecting key field number = 1
+  writeScalar(writer, field.K, 1, keyValue, true);
+  // write value, expecting value field number = 2
+  switch (field.V.kind) {
+    case "scalar":
+      writeScalar(writer, field.V.T, 2, value, true);
+      break;
+    case "enum":
+      writeScalar(writer, field_js_1.ScalarType.INT32, 2, value, true);
+      break;
+    case "message":
+      writeMessageField(writer, options, field.V.T, 2, value);
+      break;
+  }
+  writer.join();
+}
+exports.writeMapEntry = writeMapEntry;
+function writeMessageField(writer, options, type, fieldNo, value) {
+  if (value !== undefined) {
+    const message = (0, field_wrapper_js_1.wrapField)(type, value);
+    writer
+      .tag(fieldNo, binary_encoding_js_1.WireType.LengthDelimited)
+      .bytes(message.toBinary(options));
+  }
+}
+exports.writeMessageField = writeMessageField;
+function writeScalar(writer, type, fieldNo, value, emitIntrinsicDefault) {
+  let [wireType, method, isIntrinsicDefault] = (0, scalars_js_1.scalarTypeInfo)(
+    type,
+    value
+  );
+  if (!isIntrinsicDefault || emitIntrinsicDefault) {
+    writer.tag(fieldNo, wireType)[method](value);
+  }
+}
+exports.writeScalar = writeScalar;
+function writePacked(writer, type, fieldNo, value) {
+  if (!value.length) {
+    return;
+  }
+  writer.tag(fieldNo, binary_encoding_js_1.WireType.LengthDelimited).fork();
+  let [, method] = (0, scalars_js_1.scalarTypeInfo)(type);
+  for (let i = 0; i < value.length; i++) {
+    writer[method](value[i]);
+  }
+  writer.join();
+}
+exports.writePacked = writePacked;

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBinaryFormatProto2 = void 0;
+const field_js_1 = require("../field.js");
+const binary_format_common_js_1 = require("./binary-format-common.js");
+/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unnecessary-condition, @typescript-eslint/strict-boolean-expressions, no-case-declarations, prefer-const */
+function makeBinaryFormatProto2() {
+  return {
+    ...(0, binary_format_common_js_1.makeBinaryFormatCommon)(),
+    writeMessage(message, writer, options) {
+      const type = message.getType();
+      let field;
+      try {
+        for (field of type.fields.byNumber()) {
+          let value, // this will be our field value, whether it is member of a oneof or not
+            repeated = field.repeated,
+            localName = field.localName;
+          if (field.oneof) {
+            const oneof = message[field.oneof.localName];
+            if (oneof.case !== localName) {
+              continue; // field is not selected, skip
+            }
+            value = oneof.value;
+          } else {
+            value = message[localName];
+            // In contrast to proto3, we raise an error if a non-optional (proto2 required)
+            // field is missing a value.
+            if (value === undefined && !field.oneof && !field.opt) {
+              throw new Error(
+                `cannot encode field ${type.typeName}.${field.name} to JSON: required field not set`
+              );
+            }
+          }
+          switch (field.kind) {
+            case "scalar":
+            case "enum":
+              let scalarType =
+                field.kind == "enum" ? field_js_1.ScalarType.INT32 : field.T;
+              if (repeated) {
+                if (field.packed) {
+                  (0, binary_format_common_js_1.writePacked)(
+                    writer,
+                    scalarType,
+                    field.no,
+                    value
+                  );
+                } else {
+                  for (const item of value) {
+                    (0, binary_format_common_js_1.writeScalar)(
+                      writer,
+                      scalarType,
+                      field.no,
+                      item,
+                      true
+                    );
+                  }
+                }
+              } else {
+                if (value !== undefined) {
+                  // In contrast to proto3, we do not skip intrinsic default values.
+                  // Explicit default values are not special cased either.
+                  (0, binary_format_common_js_1.writeScalar)(
+                    writer,
+                    scalarType,
+                    field.no,
+                    value,
+                    true
+                  );
+                }
+              }
+              break;
+            case "message":
+              if (repeated) {
+                for (const item of value) {
+                  (0, binary_format_common_js_1.writeMessageField)(
+                    writer,
+                    options,
+                    field.T,
+                    field.no,
+                    item
+                  );
+                }
+              } else {
+                (0, binary_format_common_js_1.writeMessageField)(
+                  writer,
+                  options,
+                  field.T,
+                  field.no,
+                  value
+                );
+              }
+              break;
+            case "map":
+              for (const [key, val] of Object.entries(value)) {
+                (0, binary_format_common_js_1.writeMapEntry)(
+                  writer,
+                  options,
+                  field,
+                  key,
+                  val
+                );
+              }
+              break;
+          }
+        }
+      } catch (e) {
+        let m = field
+          ? `cannot encode field ${type.typeName}.${field?.name} to binary`
+          : `cannot encode message ${type.typeName} to binary`;
+        let r = e instanceof Error ? e.message : String(e);
+        throw new Error(m + (r.length > 0 ? `: ${r}` : ""));
+      }
+      if (options.writeUnknownFields) {
+        this.writeUnknownFields(message, writer);
+      }
+      return writer;
+    },
+  };
+}
+exports.makeBinaryFormatProto2 = makeBinaryFormatProto2;

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBinaryFormatProto3 = void 0;
+const field_js_1 = require("../field.js");
+const binary_format_common_js_1 = require("./binary-format-common.js");
+/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unnecessary-condition, @typescript-eslint/strict-boolean-expressions, prefer-const, no-case-declarations */
+function makeBinaryFormatProto3() {
+  return {
+    ...(0, binary_format_common_js_1.makeBinaryFormatCommon)(),
+    writeMessage(message, writer, options) {
+      const type = message.getType();
+      for (const field of type.fields.byNumber()) {
+        let value, // this will be our field value, whether it is member of a oneof or regular field
+          repeated = field.repeated,
+          localName = field.localName;
+        if (field.oneof) {
+          const oneof = message[field.oneof.localName];
+          if (oneof.case !== localName) {
+            continue; // field is not selected, skip
+          }
+          value = oneof.value;
+        } else {
+          value = message[localName];
+        }
+        switch (field.kind) {
+          case "scalar":
+          case "enum":
+            let scalarType =
+              field.kind == "enum" ? field_js_1.ScalarType.INT32 : field.T;
+            if (repeated) {
+              if (field.packed) {
+                (0, binary_format_common_js_1.writePacked)(
+                  writer,
+                  scalarType,
+                  field.no,
+                  value
+                );
+              } else {
+                for (const item of value) {
+                  (0, binary_format_common_js_1.writeScalar)(
+                    writer,
+                    scalarType,
+                    field.no,
+                    item,
+                    true
+                  );
+                }
+              }
+            } else {
+              if (value !== undefined) {
+                (0, binary_format_common_js_1.writeScalar)(
+                  writer,
+                  scalarType,
+                  field.no,
+                  value,
+                  !!field.oneof || field.opt
+                );
+              }
+            }
+            break;
+          case "message":
+            if (repeated) {
+              for (const item of value) {
+                (0, binary_format_common_js_1.writeMessageField)(
+                  writer,
+                  options,
+                  field.T,
+                  field.no,
+                  item
+                );
+              }
+            } else {
+              (0, binary_format_common_js_1.writeMessageField)(
+                writer,
+                options,
+                field.T,
+                field.no,
+                value
+              );
+            }
+            break;
+          case "map":
+            for (const [key, val] of Object.entries(value)) {
+              (0, binary_format_common_js_1.writeMapEntry)(
+                writer,
+                options,
+                field,
+                key,
+                val
+              );
+            }
+            break;
+        }
+      }
+      if (options.writeUnknownFields) {
+        this.writeUnknownFields(message, writer);
+      }
+      return writer;
+    },
+  };
+}
+exports.makeBinaryFormatProto3 = makeBinaryFormatProto3;

package/dist/cjs/private/enum.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEnumType = exports.setEnumType = exports.getEnumType = void 0;
+const assert_js_1 = require("./assert.js");
+const enumTypeSymbol = Symbol("@bufbuild/protobuf/enum-type");
+/**
+ * Get reflection information from a generated enum.
+ * If this function is called on something other than a generated
+ * enum, it raises an error.
+ */
+function getEnumType(enumObject) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-explicit-any
+  const t = enumObject[enumTypeSymbol];
+  (0, assert_js_1.assert)(t, "missing enum type on enum object");
+  return t; // eslint-disable-line @typescript-eslint/no-unsafe-return
+}
+exports.getEnumType = getEnumType;
+/**
+ * Sets reflection information on a generated enum.
+ */
+function setEnumType(
+  enumObject,
+  typeName,
+  values
+  // We do not surface options at this time
+  // opt?: {
+  // options?: { readonly [extensionName: string]: JsonValue };
+  // },
+) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+  enumObject[enumTypeSymbol] = makeEnumType(typeName, values);
+}
+exports.setEnumType = setEnumType;
+// We do not surface options at this time
+// export type PartialEnumValue = Omit<EnumValueInfo, 'options'> & Partial<Pick<EnumValueInfo, "options">>;
+/**
+ * Create a new EnumType with the given values.
+ */
+function makeEnumType(
+  typeName,
+  values
+  // We do not surface options at this time
+  // opt?: {
+  // options?: { readonly [extensionName: string]: JsonValue };
+  // },
+) {
+  const names = Object.create(null);
+  const numbers = Object.create(null);
+  const normalValues = [];
+  for (const value of values) {
+    // We do not surface options at this time
+    // const value: EnumValueInfo = {...v, options: v.options ?? emptyReadonlyObject};
+    normalValues.push(value);
+    names[value.name] = value;
+    numbers[value.no] = value;
+  }
+  return {
+    typeName,
+    values: normalValues,
+    // We do not surface options at this time
+    // options: opt?.options ?? Object.create(null),
+    findName(name) {
+      return names[name];
+    },
+    findNumber(no) {
+      return numbers[no];
+    },
+  };
+}
+exports.makeEnumType = makeEnumType;