@bufbuild/protobuf 0.0.1-alpha.1 → 0.0.2-alpha.2

package/dist/types/private/json-format-common.d.ts

@@ -1,30 +1,8 @@
-import type {
-  JsonFormat,
-  JsonValue,
-  JsonWriteOptions,
-} from "../json-format.js";
+import type { JsonFormat, JsonValue, JsonWriteOptions } from "../json-format.js";
 import { FieldInfo, ScalarType } from "../field.js";
 import type { EnumType } from "../enum.js";
-declare type JsonFormatWriteFieldFn = (
-  field: FieldInfo,
-  value: any,
-  options: JsonWriteOptions
-) => JsonValue | undefined;
-export declare function makeJsonFormatCommon(
-  makeWriteField: (
-    writeEnumFn: typeof writeEnum,
-    writeScalarFn: typeof writeScalar
-  ) => JsonFormatWriteFieldFn
-): JsonFormat;
-declare function writeEnum(
-  type: EnumType,
-  value: number | undefined,
-  emitIntrinsicDefault: boolean,
-  enumAsInteger: boolean
-): JsonValue | undefined;
-declare function writeScalar(
-  type: ScalarType,
-  value: any,
-  emitIntrinsicDefault: boolean
-): JsonValue | undefined;
+declare type JsonFormatWriteFieldFn = (field: FieldInfo, value: any, options: JsonWriteOptions) => JsonValue | undefined;
+export declare function makeJsonFormatCommon(makeWriteField: (writeEnumFn: typeof writeEnum, writeScalarFn: typeof writeScalar) => JsonFormatWriteFieldFn): JsonFormat;
+declare function writeEnum(type: EnumType, value: number | undefined, emitIntrinsicDefault: boolean, enumAsInteger: boolean): JsonValue | undefined;
+declare function writeScalar(type: ScalarType, value: any, emitIntrinsicDefault: boolean): JsonValue | undefined;
 export {};

package/dist/types/private/message-type.d.ts

@@ -5,11 +5,16 @@ import type { ProtoRuntime } from "./proto-runtime.js";
 /**
  * Create a new message type using the given runtime.
  */
-export declare function makeMessageType<T extends Message<T> = AnyMessage>(
-  runtime: ProtoRuntime,
-  typeName: string,
-  fields: FieldListSource,
-  opt?: {
+export declare function makeMessageType<T extends Message<T> = AnyMessage>(runtime: ProtoRuntime, typeName: string, fields: FieldListSource, opt?: {
+    /**
+     * localName is the "name" property of the constructed function.
+     * It is useful in stack traces, debuggers and test frameworks,
+     * but has no other implications.
+     *
+     * This property is optional because by default, the last part
+     * from the given typeName is used. Since this does not take
+     * reserved words into account, we provide this property so that
+     * an escaped name can be given.
+     */
     localName?: string;
-  }
-): MessageType<T>;
+}): MessageType<T>;

package/dist/types/private/names.d.ts

@@ -5,10 +5,7 @@ export declare function makeJsonName(protoName: string): string;
 /**
  * Returns the local name of a field, exactly like protoc-gen-es does.
  */
-export declare function makeFieldName(
-  protoName: string,
-  inOneof: boolean
-): string;
+export declare function makeFieldName(protoName: string, inOneof: boolean): string;
 /**
  * Returns the local name of a oneof group, exactly like protoc-gen-es does.
  */

package/dist/types/private/options-map.d.ts

@@ -3,5 +3,5 @@ import type { JsonValue } from "../json-format";
  *
  */
 export declare type OptionsMap = {
-  readonly [extensionName: string]: JsonValue;
+    readonly [extensionName: string]: JsonValue;
 };

package/dist/types/private/proto-runtime.d.ts

@@ -1,4 +1,4 @@
-import type { JsonFormat, JsonValue } from "../json-format.js";
+import type { JsonFormat } from "../json-format.js";
 import type { BinaryFormat } from "../binary-format.js";
 import type { AnyMessage } from "../message.js";
 import type { Message } from "../message.js";
@@ -11,45 +11,37 @@ import type { Util } from "./util.js";
  * A facade that provides serialization and other internal functionality.
  */
 export interface ProtoRuntime {
-  readonly syntax: string;
-  readonly json: JsonFormat;
-  readonly bin: BinaryFormat;
-  readonly util: Util;
-  /**
-   * Create a message type at runtime, without generating code.
-   */
-  makeMessageType<T extends Message<T> = AnyMessage>(
-    typeName: string,
-    fields: FieldListSource,
-    opt?: {
-      localName?: string;
-      options?: {
-        readonly [extensionName: string]: JsonValue;
-      };
-    }
-  ): MessageType<T>;
-  /**
-   * Create an enum type at runtime, without generating code.
-   */
-  makeEnumType(
-    typeName: string,
-    values: EnumValueInfo[],
-    opt?: {
-      options?: {
-        readonly [extensionName: string]: JsonValue;
-      };
-    }
-  ): EnumType;
-  /**
-   * Get reflection information from a generated enum.
-   * If this function is called on something other than a generated
-   * enum, it raises an error.
-   */
-  getEnumType(enumObject: EnumObject): EnumType;
+    readonly syntax: string;
+    readonly json: JsonFormat;
+    readonly bin: BinaryFormat;
+    readonly util: Util;
+    /**
+     * Create a message type at runtime, without generating code.
+     */
+    makeMessageType<T extends Message<T> = AnyMessage>(typeName: string, fields: FieldListSource, opt?: {
+        localName?: string;
+    }): MessageType<T>;
+    /**
+     * Create an enum object at runtime, without generating code.
+     *
+     * The object conforms to TypeScript enums, and comes with
+     * mapping from name to value, and from value to name.
+     *
+     * The type name and other reflection information is accessible
+     * via getEnumType().
+     */
+    makeEnum(typeName: string, values: EnumValueInfo[], opt?: {}): EnumObject;
+    /**
+     * Create an enum type at runtime, without generating code.
+     * Note that this only creates the reflection information, not an
+     * actual enum object.
+     */
+    makeEnumType(typeName: string, values: EnumValueInfo[], opt?: {}): EnumType;
+    /**
+     * Get reflection information - the EnumType - from an enum object.
+     * If this function is called on something other than a generated
+     * enum, or an enum constructed with makeEnum(), it raises an error.
+     */
+    getEnumType(enumObject: EnumObject): EnumType;
 }
-export declare function makeProtoRuntime(
-  syntax: string,
-  json: JsonFormat,
-  bin: BinaryFormat,
-  util: Util
-): ProtoRuntime;
+export declare function makeProtoRuntime(syntax: string, json: JsonFormat, bin: BinaryFormat, util: Util): ProtoRuntime;

package/dist/types/private/scalars.d.ts

@@ -3,11 +3,7 @@ import { IBinaryWriter, WireType } from "../binary-encoding.js";
 /**
  * Returns true if both scalar values are equal.
  */
-export declare function scalarEquals(
-  type: ScalarType,
-  a: string | boolean | number | bigint | Uint8Array | undefined,
-  b: string | boolean | number | bigint | Uint8Array | undefined
-): boolean;
+export declare function scalarEquals(type: ScalarType, a: string | boolean | number | bigint | Uint8Array | undefined, b: string | boolean | number | bigint | Uint8Array | undefined): boolean;
 /**
  * Returns the default value for the given scalar type, following
  * proto3 semantics.
@@ -23,11 +19,8 @@ export declare function scalarDefaultValue(type: ScalarType): any;
  *
  * If argument `value` is omitted, [2] is always false.
  */
-export declare function scalarTypeInfo(
-  type: ScalarType,
-  value?: any
-): [
-  WireType,
-  Exclude<keyof IBinaryWriter, "tag" | "raw" | "fork" | "join" | "finish">,
-  boolean
+export declare function scalarTypeInfo(type: ScalarType, value?: any): [
+    WireType,
+    Exclude<keyof IBinaryWriter, "tag" | "raw" | "fork" | "join" | "finish">,
+    boolean
 ];

package/dist/types/private/util-common.d.ts

@@ -1,5 +1,2 @@
 import type { Util } from "./util.js";
-export declare function makeUtilCommon(): Omit<
-  Util,
-  "newFieldList" | "initFields"
->;
+export declare function makeUtilCommon(): Omit<Util, "newFieldList" | "initFields">;

package/dist/types/private/util.d.ts

@@ -11,45 +11,33 @@ import type { EnumValueInfo } from "../enum.js";
  * future release.
  */
 export interface Util {
-  /**
-   * Create a field list
-   */
-  newFieldList(fields: FieldListSource): FieldList;
-  /**
-   * Sets reflection information on a generated enum.
-   */
-  setEnumType(
-    enumObject: EnumObject,
-    typeName: string,
-    values: EnumValueInfo[],
-    opt?: {
-      options?: {
-        readonly [extensionName: string]: JsonValue;
-      };
-    }
-  ): void;
-  /**
-   * Set default field values on the target message.
-   */
-  initFields(target: Message): void;
-  /**
-   * Set specified field values on the target message, recursively.
-   */
-  initPartial<T extends Message<T>>(
-    source: PartialMessage<T> | undefined,
-    target: T
-  ): void;
-  /**
-   * Compares two messages of the same type recursively.
-   * Will also return true if both messages are `undefined`.
-   */
-  equals<T extends Message<T>>(
-    type: MessageType,
-    a: T | PlainMessage<T> | undefined,
-    b: T | PlainMessage<T> | undefined
-  ): boolean;
-  /**
-   * Create a deep copy.
-   */
-  clone<T extends Message<T>>(message: T): T;
+    /**
+     * Create a field list
+     */
+    newFieldList(fields: FieldListSource): FieldList;
+    /**
+     * Sets reflection information on a generated enum.
+     */
+    setEnumType(enumObject: EnumObject, typeName: string, values: EnumValueInfo[], opt?: {
+        options?: {
+            readonly [extensionName: string]: JsonValue;
+        };
+    }): void;
+    /**
+     * Set default field values on the target message.
+     */
+    initFields(target: Message): void;
+    /**
+     * Set specified field values on the target message, recursively.
+     */
+    initPartial<T extends Message<T>>(source: PartialMessage<T> | undefined, target: T): void;
+    /**
+     * Compares two messages of the same type recursively.
+     * Will also return true if both messages are `undefined`.
+     */
+    equals<T extends Message<T>>(type: MessageType, a: T | PlainMessage<T> | undefined, b: T | PlainMessage<T> | undefined): boolean;
+    /**
+     * Create a deep copy.
+     */
+    clone<T extends Message<T>>(message: T): T;
 }

package/dist/types/proto-int64.d.ts

@@ -47,48 +47,48 @@
  * on a two's complement, for example the npm package "long".
  */
 interface Int64Support {
-  /**
-   * 0n if bigint is available, "0" if unavailable.
-   */
-  readonly zero: bigint;
-  /**
-   * Is bigint available?
-   */
-  readonly supported: boolean;
-  /**
-   * Parse a signed 64-bit integer.
-   * Returns a bigint if available, a string otherwise.
-   */
-  parse(value: string | number | bigint): bigint;
-  /**
-   * Parse an unsigned 64-bit integer.
-   * Returns a bigint if available, a string otherwise.
-   */
-  uParse(value: string | number | bigint): bigint;
-  /**
-   * Convert a signed 64-bit integral value to a two's complement.
-   */
-  enc(value: string | number | bigint): {
-    lo: number;
-    hi: number;
-  };
-  /**
-   * Convert an unsigned 64-bit integral value to a two's complement.
-   */
-  uEnc(value: string | number | bigint): {
-    lo: number;
-    hi: number;
-  };
-  /**
-   * Convert a two's complement to a signed 64-bit integral value.
-   * Returns a bigint if available, a string otherwise.
-   */
-  dec(lo: number, hi: number): bigint;
-  /**
-   * Convert a two's complement to an unsigned 64-bit integral value.
-   * Returns a bigint if available, a string otherwise.
-   */
-  uDec(lo: number, hi: number): bigint;
+    /**
+     * 0n if bigint is available, "0" if unavailable.
+     */
+    readonly zero: bigint;
+    /**
+     * Is bigint available?
+     */
+    readonly supported: boolean;
+    /**
+     * Parse a signed 64-bit integer.
+     * Returns a bigint if available, a string otherwise.
+     */
+    parse(value: string | number | bigint): bigint;
+    /**
+     * Parse an unsigned 64-bit integer.
+     * Returns a bigint if available, a string otherwise.
+     */
+    uParse(value: string | number | bigint): bigint;
+    /**
+     * Convert a signed 64-bit integral value to a two's complement.
+     */
+    enc(value: string | number | bigint): {
+        lo: number;
+        hi: number;
+    };
+    /**
+     * Convert an unsigned 64-bit integral value to a two's complement.
+     */
+    uEnc(value: string | number | bigint): {
+        lo: number;
+        hi: number;
+    };
+    /**
+     * Convert a two's complement to a signed 64-bit integral value.
+     * Returns a bigint if available, a string otherwise.
+     */
+    dec(lo: number, hi: number): bigint;
+    /**
+     * Convert a two's complement to an unsigned 64-bit integral value.
+     * Returns a bigint if available, a string otherwise.
+     */
+    uDec(lo: number, hi: number): bigint;
 }
 export declare const protoInt64: Int64Support;
 export {};

package/dist/types/service-type.d.ts

@@ -5,16 +5,16 @@ import type { MessageType } from "./message-type.js";
  * reflection-based operations.
  */
 export interface ServiceType {
-  /**
-   * The fully qualified name of the service.
-   */
-  readonly typeName: string;
-  /**
-   * A map of local name (safe to use in ECMAScript) to method.
-   */
-  readonly methods: {
-    [localName: string]: MethodInfo;
-  };
+    /**
+     * The fully qualified name of the service.
+     */
+    readonly typeName: string;
+    /**
+     * A map of local name (safe to use in ECMAScript) to method.
+     */
+    readonly methods: {
+        [localName: string]: MethodInfo;
+    };
 }
 /**
  * MethodInfo represents a method of a protobuf service, a remote procedure
@@ -29,56 +29,36 @@ export interface ServiceType {
  * - "idempotency": User-provided indication whether the method will cause
  *   the same effect every time it is called.
  */
-export declare type MethodInfo<
-  I extends Message<I> = AnyMessage,
-  O extends Message<O> = AnyMessage
-> =
-  | MethodInfoUnary<I, O>
-  | MethodInfoServerStreaming<I, O>
-  | MethodInfoClientStreaming<I, O>
-  | MethodInfoBiDiStreaming<I, O>;
+export declare type MethodInfo<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> = MethodInfoUnary<I, O> | MethodInfoServerStreaming<I, O> | MethodInfoClientStreaming<I, O> | MethodInfoBiDiStreaming<I, O>;
 /**
  * A unary method: rpc (Input) returns (Output)
  */
-export interface MethodInfoUnary<I extends Message<I>, O extends Message<O>>
-  extends miShared<I, O> {
-  readonly kind: MethodKind.Unary;
+export interface MethodInfoUnary<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.Unary;
 }
 /**
  * A server streaming method: rpc (Input) returns (stream Output)
  */
-export interface MethodInfoServerStreaming<
-  I extends Message<I>,
-  O extends Message<O>
-> extends miShared<I, O> {
-  readonly kind: MethodKind.ServerStreaming;
+export interface MethodInfoServerStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.ServerStreaming;
 }
 /**
  * A client streaming method: rpc (stream Input) returns (Output)
  */
-export interface MethodInfoClientStreaming<
-  I extends Message<I>,
-  O extends Message<O>
-> extends miShared<I, O> {
-  readonly kind: MethodKind.ClientStreaming;
+export interface MethodInfoClientStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.ClientStreaming;
 }
 /**
  * A method that streams bi-directionally: rpc (stream Input) returns (stream Output)
  */
-export interface MethodInfoBiDiStreaming<
-  I extends Message<I>,
-  O extends Message<O>
-> extends miShared<I, O> {
-  readonly kind: MethodKind.BiDiStreaming;
+export interface MethodInfoBiDiStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.BiDiStreaming;
 }
-interface miShared<
-  I extends Message<I> = AnyMessage,
-  O extends Message<O> = AnyMessage
-> {
-  readonly name: string;
-  readonly I: MessageType<I>;
-  readonly O: MessageType<O>;
-  readonly idempotency?: MethodIdempotency;
+interface miShared<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> {
+    readonly name: string;
+    readonly I: MessageType<I>;
+    readonly O: MessageType<O>;
+    readonly idempotency?: MethodIdempotency;
 }
 /**
  * MethodKind represents the four method types that can be declared in
@@ -90,10 +70,10 @@ interface miShared<
  * 4. BiDiStreaming:   rpc (stream Input) returns (stream Output)
  */
 export declare enum MethodKind {
-  Unary = 0,
-  ServerStreaming = 1,
-  ClientStreaming = 2,
-  BiDiStreaming = 3,
+    Unary = 0,
+    ServerStreaming = 1,
+    ClientStreaming = 2,
+    BiDiStreaming = 3
 }
 /**
  * Is this method side-effect-free (or safe in HTTP parlance), or just
@@ -106,13 +86,13 @@ export declare enum MethodKind {
  * drops UNKNOWN.
  */
 export declare enum MethodIdempotency {
-  /**
-   * Idempotent, no side effects.
-   */
-  NoSideEffects = 1,
-  /**
-   * Idempotent, but may have side effects.
-   */
-  Idempotent = 2,
+    /**
+     * Idempotent, no side effects.
+     */
+    NoSideEffects = 1,
+    /**
+     * Idempotent, but may have side effects.
+     */
+    Idempotent = 2
 }
 export {};

package/dist/types/type-registry.d.ts

@@ -5,33 +5,31 @@ import type { ServiceType } from "./service-type.js";
  * IMessageTypeRegistry provides look-up for message types.
  */
 export interface IMessageTypeRegistry {
-  findMessage(typeName: string): MessageType | undefined;
+    findMessage(typeName: string): MessageType | undefined;
 }
 /**
  * IEnumTypeRegistry provides look-up for enum types.
  */
 export interface IEnumTypeRegistry {
-  findEnum(typeName: string): EnumType | undefined;
+    findEnum(typeName: string): EnumType | undefined;
 }
 /**
  * IServiceTypeRegistry provides look-up for service types.
  */
 export interface IServiceTypeRegistry {
-  findService(typeName: string): ServiceType | undefined;
+    findService(typeName: string): ServiceType | undefined;
 }
 /**
  * TypeRegistry is a basic type registry
  */
-export declare class TypeRegistry
-  implements IMessageTypeRegistry, IEnumTypeRegistry, IServiceTypeRegistry
-{
-  private readonly messages;
-  private readonly enums;
-  private readonly services;
-  findMessage(typeName: string): MessageType | undefined;
-  findEnum(typeName: string): EnumType | undefined;
-  findService(typeName: string): ServiceType | undefined;
-  private add;
-  static fromIterable(types: Iterable<MessageType>): TypeRegistry;
-  static fromTypes(...types: MessageType[]): TypeRegistry;
+export declare class TypeRegistry implements IMessageTypeRegistry, IEnumTypeRegistry, IServiceTypeRegistry {
+    private readonly messages;
+    private readonly enums;
+    private readonly services;
+    findMessage(typeName: string): MessageType | undefined;
+    findEnum(typeName: string): EnumType | undefined;
+    findService(typeName: string): ServiceType | undefined;
+    private add;
+    static fromIterable(types: Iterable<MessageType>): TypeRegistry;
+    static fromTypes(...types: MessageType[]): TypeRegistry;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bufbuild/protobuf",
-  "version": "0.0.1-alpha.1",
+  "version": "0.0.2-alpha.2",
   "license": "(Apache-2.0 AND BSD-3-Clause)",
   "description": "A complete implementation of protocol buffers in TypeScript, suitable for web browsers and Node.js.",
   "repository": {
@@ -15,7 +15,6 @@
     "build:esm+types": "npx tsc --project tsconfig.json --module ES2015 --outDir ./dist/esm --declaration --declarationDir ./dist/types"
   },
   "type": "module",
-  "main": "./dist/cjs/index.js",
   "types": "./dist/types/index.d.ts",
   "exports": {
     "import": "./dist/esm/index.js",
@@ -23,7 +22,7 @@
     "default": "./dist/esm/index.js"
   },
   "devDependencies": {
-    "typescript": "^4.5.4"
+    "typescript": "^4.6.3"
   },
   "files": [
     "dist/**/"