@bufbuild/protobuf 0.0.1-alpha.1

package/dist/esm/proto3.js

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

package/dist/esm/service-type.js

@@ -0,0 +1,37 @@
+/**
+ * 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)
+ */
+export 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 || (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.
+ */
+export 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 || (MethodIdempotency = {}));

package/dist/esm/type-registry.js

@@ -0,0 +1,38 @@
+/**
+ * TypeRegistry is a basic type registry
+ */
+export 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);
+  }
+}

package/dist/types/binary-encoding.d.ts

@@ -0,0 +1,421 @@
+/**
+ * Protobuf binary format wire types.
+ *
+ * A wire type provides just enough information to find the length of the
+ * following value.
+ *
+ * See https://developers.google.com/protocol-buffers/docs/encoding#structure
+ */
+export declare enum WireType {
+  /**
+   * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum
+   */
+  Varint = 0,
+  /**
+   * Used for fixed64, sfixed64, double.
+   * Always 8 bytes with little-endian byte order.
+   */
+  Bit64 = 1,
+  /**
+   * Used for string, bytes, embedded messages, packed repeated fields
+   *
+   * Only repeated numeric types (types which use the varint, 32-bit,
+   * or 64-bit wire types) can be packed. In proto3, such fields are
+   * packed by default.
+   */
+  LengthDelimited = 2,
+  /**
+   * Used for groups
+   * @deprecated
+   */
+  StartGroup = 3,
+  /**
+   * Used for groups
+   * @deprecated
+   */
+  EndGroup = 4,
+  /**
+   * Used for fixed32, sfixed32, float.
+   * Always 4 bytes with little-endian byte order.
+   */
+  Bit32 = 5,
+}
+declare type TextEncoderLike = {
+  encode(input?: string): Uint8Array;
+};
+declare type TextDecoderLike = {
+  decode(input?: Uint8Array): string;
+};
+export interface IBinaryReader {
+  /**
+   * Current position.
+   */
+  readonly pos: number;
+  /**
+   * Number of bytes available in this reader.
+   */
+  readonly len: number;
+  /**
+   * Reads a tag - field number and wire type.
+   */
+  tag(): [number, WireType];
+  /**
+   * Skip one element on the wire and return the skipped data.
+   */
+  skip(wireType: WireType): Uint8Array;
+  /**
+   * Read a `int32` field, a signed 32 bit varint.
+   */
+  uint32(): number;
+  /**
+   * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+   */
+  int32(): number;
+  /**
+   * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32(): number;
+  /**
+   * Read a `int64` field, a signed 64-bit varint.
+   */
+  int64(): bigint | string;
+  /**
+   * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64(): bigint | string;
+  /**
+   * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64(): bigint | string;
+  /**
+   * Read a `uint64` field, an unsigned 64-bit varint.
+   */
+  uint64(): bigint | string;
+  /**
+   * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64(): bigint | string;
+  /**
+   * Read a `bool` field, a variant.
+   */
+  bool(): boolean;
+  /**
+   * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32(): number;
+  /**
+   * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32(): number;
+  /**
+   * Read a `float` field, 32-bit floating point number.
+   */
+  float(): number;
+  /**
+   * Read a `double` field, a 64-bit floating point number.
+   */
+  double(): number;
+  /**
+   * Read a `bytes` field, length-delimited arbitrary data.
+   */
+  bytes(): Uint8Array;
+  /**
+   * Read a `string` field, length-delimited data converted to UTF-8 text.
+   */
+  string(): string;
+}
+export interface IBinaryWriter {
+  /**
+   * Return all bytes written and reset this writer.
+   */
+  finish(): Uint8Array;
+  /**
+   * Start a new fork for length-delimited data like a message
+   * or a packed repeated field.
+   *
+   * Must be joined later with `join()`.
+   */
+  fork(): IBinaryWriter;
+  /**
+   * Join the last fork. Write its length and bytes, then
+   * return to the previous state.
+   */
+  join(): IBinaryWriter;
+  /**
+   * Writes a tag (field number and wire type).
+   *
+   * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`
+   *
+   * Generated code should compute the tag ahead of time and call `uint32()`.
+   */
+  tag(fieldNo: number, type: WireType): IBinaryWriter;
+  /**
+   * Write a chunk of raw bytes.
+   */
+  raw(chunk: Uint8Array): IBinaryWriter;
+  /**
+   * Write a `uint32` value, an unsigned 32 bit varint.
+   */
+  uint32(value: number): IBinaryWriter;
+  /**
+   * Write a `int32` value, a signed 32 bit varint.
+   */
+  int32(value: number): IBinaryWriter;
+  /**
+   * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32(value: number): IBinaryWriter;
+  /**
+   * Write a `int64` value, a signed 64-bit varint.
+   */
+  int64(value: string | number | bigint): IBinaryWriter;
+  /**
+   * Write a `uint64` value, an unsigned 64-bit varint.
+   */
+  uint64(value: string | number | bigint): IBinaryWriter;
+  /**
+   * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64(value: string | number | bigint): IBinaryWriter;
+  /**
+   * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64(value: string | number | bigint): IBinaryWriter;
+  /**
+   * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64(value: string | number | bigint): IBinaryWriter;
+  /**
+   * Write a `bool` value, a variant.
+   */
+  bool(value: boolean): IBinaryWriter;
+  /**
+   * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32(value: number): IBinaryWriter;
+  /**
+   * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32(value: number): IBinaryWriter;
+  /**
+   * Write a `float` value, 32-bit floating point number.
+   */
+  float(value: number): IBinaryWriter;
+  /**
+   * Write a `double` value, a 64-bit floating point number.
+   */
+  double(value: number): IBinaryWriter;
+  /**
+   * Write a `bytes` value, length-delimited arbitrary data.
+   */
+  bytes(value: Uint8Array): IBinaryWriter;
+  /**
+   * Write a `string` value, length-delimited data converted to UTF-8 text.
+   */
+  string(value: string): IBinaryWriter;
+}
+export declare class BinaryWriter implements IBinaryWriter {
+  /**
+   * We cannot allocate a buffer for the entire output
+   * because we don't know it's size.
+   *
+   * So we collect smaller chunks of known size and
+   * concat them later.
+   *
+   * Use `raw()` to push data to this array. It will flush
+   * `buf` first.
+   */
+  private chunks;
+  /**
+   * A growing buffer for byte values. If you don't know
+   * the size of the data you are writing, push to this
+   * array.
+   */
+  protected buf: number[];
+  /**
+   * Previous fork states.
+   */
+  private stack;
+  /**
+   * Text encoder instance to convert UTF-8 to bytes.
+   */
+  private readonly textEncoder;
+  constructor(textEncoder?: TextEncoderLike);
+  /**
+   * Return all bytes written and reset this writer.
+   */
+  finish(): Uint8Array;
+  /**
+   * Start a new fork for length-delimited data like a message
+   * or a packed repeated field.
+   *
+   * Must be joined later with `join()`.
+   */
+  fork(): IBinaryWriter;
+  /**
+   * Join the last fork. Write its length and bytes, then
+   * return to the previous state.
+   */
+  join(): IBinaryWriter;
+  /**
+   * Writes a tag (field number and wire type).
+   *
+   * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
+   *
+   * Generated code should compute the tag ahead of time and call `uint32()`.
+   */
+  tag(fieldNo: number, type: WireType): IBinaryWriter;
+  /**
+   * Write a chunk of raw bytes.
+   */
+  raw(chunk: Uint8Array): IBinaryWriter;
+  /**
+   * Write a `uint32` value, an unsigned 32 bit varint.
+   */
+  uint32(value: number): IBinaryWriter;
+  /**
+   * Write a `int32` value, a signed 32 bit varint.
+   */
+  int32(value: number): IBinaryWriter;
+  /**
+   * Write a `bool` value, a variant.
+   */
+  bool(value: boolean): IBinaryWriter;
+  /**
+   * Write a `bytes` value, length-delimited arbitrary data.
+   */
+  bytes(value: Uint8Array): IBinaryWriter;
+  /**
+   * Write a `string` value, length-delimited data converted to UTF-8 text.
+   */
+  string(value: string): IBinaryWriter;
+  /**
+   * Write a `float` value, 32-bit floating point number.
+   */
+  float(value: number): IBinaryWriter;
+  /**
+   * Write a `double` value, a 64-bit floating point number.
+   */
+  double(value: number): IBinaryWriter;
+  /**
+   * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32(value: number): IBinaryWriter;
+  /**
+   * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32(value: number): IBinaryWriter;
+  /**
+   * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32(value: number): IBinaryWriter;
+  /**
+   * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64(value: string | number | bigint): IBinaryWriter;
+  /**
+   * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64(value: string | number | bigint): IBinaryWriter;
+  /**
+   * Write a `int64` value, a signed 64-bit varint.
+   */
+  int64(value: string | number | bigint): IBinaryWriter;
+  /**
+   * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64(value: string | number | bigint): IBinaryWriter;
+  /**
+   * Write a `uint64` value, an unsigned 64-bit varint.
+   */
+  uint64(value: string | number | bigint): IBinaryWriter;
+}
+export declare class BinaryReader implements IBinaryReader {
+  /**
+   * Current position.
+   */
+  pos: number;
+  /**
+   * Number of bytes available in this reader.
+   */
+  readonly len: number;
+  private readonly buf;
+  private readonly view;
+  private readonly textDecoder;
+  constructor(buf: Uint8Array, textDecoder?: TextDecoderLike);
+  /**
+   * Reads a tag - field number and wire type.
+   */
+  tag(): [number, WireType];
+  /**
+   * Skip one element on the wire and return the skipped data.
+   * Supports WireType.StartGroup since v2.0.0-alpha.23.
+   */
+  skip(wireType: WireType): Uint8Array;
+  protected varint64: () => [number, number];
+  /**
+   * Throws error if position in byte array is out of range.
+   */
+  protected assertBounds(): void;
+  /**
+   * Read a `uint32` field, an unsigned 32 bit varint.
+   */
+  uint32: () => number;
+  /**
+   * Read a `int32` field, a signed 32 bit varint.
+   */
+  int32(): number;
+  /**
+   * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32(): number;
+  /**
+   * Read a `int64` field, a signed 64-bit varint.
+   */
+  int64(): bigint | string;
+  /**
+   * Read a `uint64` field, an unsigned 64-bit varint.
+   */
+  uint64(): bigint | string;
+  /**
+   * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64(): bigint | string;
+  /**
+   * Read a `bool` field, a variant.
+   */
+  bool(): boolean;
+  /**
+   * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32(): number;
+  /**
+   * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32(): number;
+  /**
+   * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64(): bigint | string;
+  /**
+   * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64(): bigint | string;
+  /**
+   * Read a `float` field, 32-bit floating point number.
+   */
+  float(): number;
+  /**
+   * Read a `double` field, a 64-bit floating point number.
+   */
+  double(): number;
+  /**
+   * Read a `bytes` field, length-delimited arbitrary data.
+   */
+  bytes(): Uint8Array;
+  /**
+   * Read a `string` field, length-delimited data converted to UTF-8 text.
+   */
+  string(): string;
+}
+export {};

package/dist/types/binary-format.d.ts

@@ -0,0 +1,109 @@
+import type { Message } from "./message.js";
+import type {
+  IBinaryReader,
+  IBinaryWriter,
+  WireType,
+} from "./binary-encoding.js";
+/**
+ * BinaryFormat is the contract for serializing messages to and from binary
+ * data. Implementations may be specific to a proto syntax, and can be
+ * reflection based, or delegate to speed optimized generated code.
+ */
+export interface BinaryFormat {
+  /**
+   * Provide options for parsing binary data.
+   */
+  makeReadOptions(
+    options?: Partial<BinaryReadOptions>
+  ): Readonly<BinaryReadOptions>;
+  /**
+   * Provide options for serializing binary data.
+   */
+  makeWriteOptions(
+    options?: Partial<BinaryWriteOptions>
+  ): Readonly<BinaryWriteOptions>;
+  /**
+   * Parse a message from binary data, merging fields.
+   */
+  readMessage<T extends Message>(
+    message: T,
+    reader: IBinaryReader,
+    length: number,
+    options: BinaryReadOptions
+  ): void;
+  /**
+   * Serialize a message to binary data.
+   */
+  writeMessage(
+    message: Message,
+    writer: IBinaryWriter,
+    options: BinaryWriteOptions
+  ): void;
+  /**
+   * Retrieve the unknown fields for the given message.
+   *
+   * Unknown fields are well-formed protocol buffer serialized data for
+   * fields that the parserdoes not recognize.
+   *
+   * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns
+   */
+  listUnknownFields(message: Message): ReadonlyArray<{
+    no: number;
+    wireType: WireType;
+    data: Uint8Array;
+  }>;
+  /**
+   * Discard unknown fields for the given message.
+   */
+  discardUnknownFields(message: Message): void;
+  /**
+   * Retrieve the unknown fields for the given message and write them to
+   * the given writer. This method is called when a message is serialized,
+   * so the fields that are unknown to the parser persist through a round
+   * trip.
+   */
+  writeUnknownFields(message: Message, writer: IBinaryWriter): void;
+  /**
+   * Store an unknown field for the given message. The parser will use this
+   * method if it does not recognize a field, unless the option
+   * `readUnknownFields` has been disabled.
+   */
+  onUnknownField(
+    message: Message,
+    no: number,
+    wireType: WireType,
+    data: Uint8Array
+  ): void;
+}
+/**
+ * Options for parsing binary data.
+ */
+export interface BinaryReadOptions {
+  /**
+   * Retain unknown fields during parsing? The default behavior is to retain
+   * unknown fields and include them in the serialized output.
+   *
+   * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns
+   */
+  readUnknownFields: boolean;
+  /**
+   * Allows to use a custom implementation to decode binary data.
+   */
+  readerFactory: (bytes: Uint8Array) => IBinaryReader;
+}
+/**
+ * Options for serializing to binary data.
+ */
+export interface BinaryWriteOptions {
+  /**
+   * Include unknown fields in the serialized output? The default behavior
+   * is to retain unknown fields and include them in the serialized output.
+   *
+   * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns
+   */
+  writeUnknownFields: boolean;
+  /**
+   * Allows to use a custom implementation to encode binary data.
+   */
+  writerFactory: () => IBinaryWriter;
+}