@bufbuild/protobuf 0.0.1-alpha.1

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

@@ -0,0 +1,243 @@
+import { BinaryReader, BinaryWriter, WireType } from "../binary-encoding.js";
+import { ScalarType } from "../field.js";
+import { unwrapField, wrapField } from "./field-wrapper.js";
+import { scalarDefaultValue, scalarTypeInfo } from "./scalars.js";
+import { assert } from "./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 BinaryReader(bytes),
+};
+// Default options for serializing binary data.
+const writeDefaults = {
+  writeUnknownFields: true,
+  writerFactory: () => new BinaryWriter(),
+};
+function makeReadOptions(options) {
+  return options ? { ...readDefaults, ...options } : readDefaults;
+}
+function makeWriteOptions(options) {
+  return options ? { ...writeDefaults, ...options } : writeDefaults;
+}
+export 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" ? ScalarType.INT32 : field.T;
+            if (repeated) {
+              let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values
+              if (
+                wireType == WireType.LengthDelimited &&
+                scalarType != ScalarType.STRING &&
+                scalarType != 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] = 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;
+        }
+      }
+    },
+  };
+}
+// 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 = scalarDefaultValue(field.K);
+    key = field.K == 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 = 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] = scalarTypeInfo(type);
+  return reader[method]();
+}
+export function writeMapEntry(writer, options, field, key, value) {
+  writer.tag(field.no, 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 ScalarType.INT32:
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32:
+      keyValue = Number.parseInt(key);
+      break;
+    case ScalarType.BOOL:
+      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, ScalarType.INT32, 2, value, true);
+      break;
+    case "message":
+      writeMessageField(writer, options, field.V.T, 2, value);
+      break;
+  }
+  writer.join();
+}
+export function writeMessageField(writer, options, type, fieldNo, value) {
+  if (value !== undefined) {
+    const message = wrapField(type, value);
+    writer
+      .tag(fieldNo, WireType.LengthDelimited)
+      .bytes(message.toBinary(options));
+  }
+}
+export function writeScalar(
+  writer,
+  type,
+  fieldNo,
+  value,
+  emitIntrinsicDefault
+) {
+  let [wireType, method, isIntrinsicDefault] = scalarTypeInfo(type, value);
+  if (!isIntrinsicDefault || emitIntrinsicDefault) {
+    writer.tag(fieldNo, wireType)[method](value);
+  }
+}
+export function writePacked(writer, type, fieldNo, value) {
+  if (!value.length) {
+    return;
+  }
+  writer.tag(fieldNo, WireType.LengthDelimited).fork();
+  let [, method] = scalarTypeInfo(type);
+  for (let i = 0; i < value.length; i++) {
+    writer[method](value[i]);
+  }
+  writer.join();
+}

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

@@ -0,0 +1,87 @@
+import { ScalarType } from "../field.js";
+import {
+  makeBinaryFormatCommon,
+  writeMapEntry,
+  writeMessageField,
+  writePacked,
+  writeScalar,
+} from "./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 */
+export function makeBinaryFormatProto2() {
+  return {
+    ...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" ? ScalarType.INT32 : field.T;
+              if (repeated) {
+                if (field.packed) {
+                  writePacked(writer, scalarType, field.no, value);
+                } else {
+                  for (const item of value) {
+                    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.
+                  writeScalar(writer, scalarType, field.no, value, true);
+                }
+              }
+              break;
+            case "message":
+              if (repeated) {
+                for (const item of value) {
+                  writeMessageField(writer, options, field.T, field.no, item);
+                }
+              } else {
+                writeMessageField(writer, options, field.T, field.no, value);
+              }
+              break;
+            case "map":
+              for (const [key, val] of Object.entries(value)) {
+                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;
+    },
+  };
+}

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

@@ -0,0 +1,74 @@
+import { ScalarType } from "../field.js";
+import {
+  makeBinaryFormatCommon,
+  writeMapEntry,
+  writeMessageField,
+  writePacked,
+  writeScalar,
+} from "./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 */
+export function makeBinaryFormatProto3() {
+  return {
+    ...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" ? ScalarType.INT32 : field.T;
+            if (repeated) {
+              if (field.packed) {
+                writePacked(writer, scalarType, field.no, value);
+              } else {
+                for (const item of value) {
+                  writeScalar(writer, scalarType, field.no, item, true);
+                }
+              }
+            } else {
+              if (value !== undefined) {
+                writeScalar(
+                  writer,
+                  scalarType,
+                  field.no,
+                  value,
+                  !!field.oneof || field.opt
+                );
+              }
+            }
+            break;
+          case "message":
+            if (repeated) {
+              for (const item of value) {
+                writeMessageField(writer, options, field.T, field.no, item);
+              }
+            } else {
+              writeMessageField(writer, options, field.T, field.no, value);
+            }
+            break;
+          case "map":
+            for (const [key, val] of Object.entries(value)) {
+              writeMapEntry(writer, options, field, key, val);
+            }
+            break;
+        }
+      }
+      if (options.writeUnknownFields) {
+        this.writeUnknownFields(message, writer);
+      }
+      return writer;
+    },
+  };
+}

package/dist/esm/private/enum.js

@@ -0,0 +1,64 @@
+import { assert } from "./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.
+ */
+export 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];
+  assert(t, "missing enum type on enum object");
+  return t; // eslint-disable-line @typescript-eslint/no-unsafe-return
+}
+/**
+ * Sets reflection information on a generated enum.
+ */
+export 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);
+}
+// 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.
+ */
+export 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];
+    },
+  };
+}

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

@@ -0,0 +1,58 @@
+export 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;
+  }
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Wrap field values whose message type has a wrapper.
+ */
+export 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`
+  );
+}
+/**
+ * Unwrap field values whose message type has a wrapper.
+ */
+export function unwrapField(type, value) {
+  return type.fieldWrapper ? type.fieldWrapper.unwrapField(value) : value;
+}

package/dist/esm/private/field.js

@@ -0,0 +1,27 @@
+import { makeOneofName } from "./names.js";
+import { assert } from "./assert.js";
+export 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 = makeOneofName(name);
+  }
+  addField(field) {
+    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];
+  }
+}