@bufbuild/protobuf 0.0.8 → 0.0.9

package/dist/types/enum.d.ts

@@ -1,9 +1,9 @@
 /**
- * Reflection information for a protobuf enum.
+ * Reflection information for a protobuf enumeration.
  */
 export interface EnumType {
     /**
-     * The fully qualified name of the enum.
+     * The fully qualified name of the enumeration.
      */
     readonly typeName: string;
     readonly values: readonly EnumValueInfo[];
@@ -17,15 +17,19 @@ export interface EnumType {
     findNumber(no: number): EnumValueInfo | undefined;
 }
 /**
- * Reflection information for a protobuf enum value.
+ * Reflection information for a protobuf enumeration value.
  */
 export interface EnumValueInfo {
     /**
-     * The number of the value as specified in proto.
+     * The numeric enumeration value, as specified in the protobuf source.
      */
     readonly no: number;
     /**
-     * The name of the value as specified in proto.
+     * The name of the enumeration value, as specified in the protobuf source.
      */
     readonly name: string;
+    /**
+     * The name of the enumeration value in generated code.
+     */
+    readonly localName: string;
 }

package/dist/types/index.d.ts

@@ -2,6 +2,7 @@ export { proto3 } from "./proto3.js";
 export { proto2 } from "./proto2.js";
 export { protoInt64 } from "./proto-int64.js";
 export { protoBase64 } from "./proto-base64.js";
+export { codegenInfo } from "./codegen-info.js";
 export { Message, AnyMessage, PartialMessage, PlainMessage, } from "./message.js";
 export type { FieldInfo } from "./field.js";
 export type { FieldList } from "./field-list.js";
@@ -10,13 +11,18 @@ export type { MessageType } from "./message-type.js";
 export type { EnumType, EnumValueInfo } from "./enum.js";
 export type { ServiceType, MethodInfo, MethodInfoUnary, MethodInfoServerStreaming, MethodInfoClientStreaming, MethodInfoBiDiStreaming, } from "./service-type.js";
 export { MethodKind, MethodIdempotency } from "./service-type.js";
-export { TypeRegistry, IMessageTypeRegistry } from "./type-registry.js";
-export { DescriptorRegistry } from "./descriptor-registry.js";
-export { DescriptorSet } from "./descriptor-set.js";
 export { WireType, BinaryWriter, BinaryReader } from "./binary-encoding.js";
 export type { IBinaryReader, IBinaryWriter } from "./binary-encoding.js";
 export type { BinaryFormat, BinaryWriteOptions, BinaryReadOptions, } from "./binary-format.js";
 export { JsonFormat, JsonObject, JsonValue, JsonReadOptions, JsonWriteOptions, JsonWriteStringOptions, } from "./json-format.js";
+export { DescriptorSet, DescFile, DescEnum, DescEnumValue, DescMessage, DescOneof, DescField, DescService, DescMethod, DescExtension, DescComments, } from "./descriptor-set.js";
+export { createDescriptorSet } from "./create-descriptor-set.js";
+export { IMessageTypeRegistry } from "./type-registry.js";
+export { createRegistry } from "./create-registry.js";
+export { createRegistryFromDescriptors } from "./create-registry-from-desc.js";
+export { LegacyDescriptorRegistry } from "./legacy-descriptor-registry.js";
+export { LegacyDescriptorSet } from "./legacy-descriptor-set.js";
+export { TypeRegistry } from "./legacy-type-registry.js";
 export * from "./google/protobuf/compiler/plugin_pb.js";
 export * from "./google/protobuf/api_pb.js";
 export * from "./google/protobuf/any_pb.js";

package/dist/types/{descriptor-registry.d.ts → legacy-descriptor-registry.d.ts}

@@ -1,29 +1,31 @@
 import type { FileDescriptorProto } from "./google/protobuf/descriptor_pb.js";
+import { FileDescriptorSet } from "./google/protobuf/descriptor_pb.js";
 import type { MessageType } from "./message-type.js";
 import type { EnumType } from "./enum.js";
-import { DescriptorSet } from "./descriptor-set.js";
+import { LegacyDescriptorSet } from "./legacy-descriptor-set.js";
 import type { IEnumTypeRegistry, IMessageTypeRegistry, IServiceTypeRegistry } from "./type-registry.js";
 import type { ServiceType } from "./service-type.js";
-import { FileDescriptorSet } from "./google/protobuf/descriptor_pb.js";
 import type { PartialMessage } from "./message.js";
 /**
- * DescriptorRegistry is a type registry that dynamically creates types
+ * LegacyDescriptorRegistry is a type registry that dynamically creates types
  * from a set of google.protobuf.FileDescriptorProto.
  *
  * By default, all well-known types with a specialized JSON representation
  * are replaced with their generated counterpart in this package.
+ *
+ * @deprecated
  */
-export declare class DescriptorRegistry implements IMessageTypeRegistry, IEnumTypeRegistry, IServiceTypeRegistry {
+export declare class LegacyDescriptorRegistry implements IMessageTypeRegistry, IEnumTypeRegistry, IServiceTypeRegistry {
     private readonly ds;
     private readonly enums;
     private readonly messages;
     private readonly services;
-    constructor(descriptorSet?: DescriptorSet, replaceWkt?: boolean);
+    constructor(descriptorSet?: LegacyDescriptorSet, replaceWkt?: boolean);
     /**
      * Conveniently create a DescriptorRegistry from a FileDescriptorSet
      * instance or a FileDescriptorSet in binary format.
      */
-    static fromFileDescriptorSet(bytesOrSet: Uint8Array | FileDescriptorSet | PartialMessage<FileDescriptorSet>): DescriptorRegistry;
+    static fromFileDescriptorSet(bytesOrSet: Uint8Array | FileDescriptorSet | PartialMessage<FileDescriptorSet>): LegacyDescriptorRegistry;
     /**
      * May raise an error on invalid descriptors.
      */

package/dist/types/legacy-descriptor-set.d.ts

@@ -0,0 +1,152 @@
+import type { DescriptorProto, EnumDescriptorProto, EnumValueDescriptorProto, FieldDescriptorProto, OneofDescriptorProto } from "./google/protobuf/descriptor_pb.js";
+import { FieldDescriptorProto_Type, FileDescriptorProto, MethodDescriptorProto, ServiceDescriptorProto } from "./google/protobuf/descriptor_pb.js";
+import { ScalarType } from "./field.js";
+import { MethodIdempotency, MethodKind } from "./service-type.js";
+/**
+ * LegacyDescriptorSet wraps a set of google.protobuf.FileDescriptorProto,
+ * asserting basic expectations and providing hierarchical information.
+ *
+ * Note that all types are kept by their fully qualified type name
+ * with a leading dot.
+ *
+ * @deprecated
+ */
+export declare class LegacyDescriptorSet implements UnresolvedSet {
+    readonly enums: Record<string, UnresolvedEnum | undefined>;
+    readonly messages: Record<string, UnresolvedMessage | undefined>;
+    readonly services: Record<string, UnresolvedService | undefined>;
+    /**
+     * May raise an error on invalid descriptors.
+     */
+    add(...files: FileDescriptorProto[]): void;
+    listEnums(): UnresolvedEnum[];
+    listMessages(): UnresolvedMessage[];
+    listServices(): UnresolvedService[];
+}
+interface UnresolvedSet {
+    readonly enums: Record<string, UnresolvedEnum | undefined>;
+    readonly messages: Record<string, UnresolvedMessage | undefined>;
+    readonly services: Record<string, UnresolvedService | undefined>;
+}
+interface File {
+    readonly proto: FileDescriptorProto;
+    readonly syntax: "proto3" | "proto2";
+    readonly name: string;
+    toString(): string;
+}
+interface UnresolvedEnum {
+    readonly proto: EnumDescriptorProto;
+    readonly file: File;
+    readonly parent: UnresolvedMessage | undefined;
+    readonly name: string;
+    readonly typeName: string;
+    readonly protoTypeName: string;
+    readonly values: UnresolvedEnumValue[];
+    toString(): string;
+}
+interface UnresolvedEnumValue {
+    readonly proto: EnumValueDescriptorProto;
+    readonly parent: UnresolvedEnum;
+    readonly name: string;
+    readonly number: number;
+    toString(): string;
+}
+interface UnresolvedMessage {
+    readonly proto: DescriptorProto;
+    readonly file: File;
+    readonly parent: UnresolvedMessage | undefined;
+    readonly name: string;
+    readonly typeName: string;
+    readonly protoTypeName: string;
+    readonly fields: UnresolvedField[];
+    readonly oneofs: UnresolvedOneof[];
+    readonly nestedEnums: UnresolvedEnum[];
+    readonly nestedMessages: UnresolvedMessage[];
+    readonly nestedExtensions: UnresolvedExtension[];
+    toString(): string;
+}
+interface UnresolvedField {
+    readonly proto: FieldDescriptorProto;
+    readonly number: number;
+    readonly name: string;
+    readonly type: FieldDescriptorProto_Type;
+    readonly parent: UnresolvedMessage;
+    readonly oneof: UnresolvedOneof | undefined;
+    readonly optional: boolean;
+    readonly packed: boolean;
+    toString(): string;
+    resolve(us: UnresolvedSet): ResolvedField;
+}
+declare type ResolvedField = (UnresolvedField & {
+    repeated: boolean;
+    readonly scalarType: ScalarType;
+    readonly message: undefined;
+    readonly enum: undefined;
+    readonly map: undefined;
+}) | (UnresolvedField & {
+    repeated: boolean;
+    readonly scalarType: undefined;
+    readonly message: UnresolvedMessage;
+    readonly enum: undefined;
+    readonly map: undefined;
+}) | (UnresolvedField & {
+    repeated: boolean;
+    readonly scalarType: undefined;
+    readonly message: undefined;
+    readonly enum: UnresolvedEnum;
+    readonly map: undefined;
+}) | (UnresolvedField & {
+    repeated: false;
+    readonly scalarType: undefined;
+    readonly message: undefined;
+    readonly enum: undefined;
+    readonly map: Map;
+});
+declare type Map = {
+    key: Exclude<ScalarType, ScalarType.FLOAT | ScalarType.DOUBLE | ScalarType.BYTES>;
+    value: {
+        enum: UnresolvedEnum;
+        message: undefined;
+        scalar: undefined;
+    } | {
+        enum: undefined;
+        message: UnresolvedMessage;
+        scalar: undefined;
+    } | {
+        enum: undefined;
+        message: undefined;
+        scalarType: ScalarType;
+    };
+};
+interface UnresolvedOneof {
+    readonly proto: OneofDescriptorProto;
+    readonly name: string;
+    readonly parent: UnresolvedMessage;
+    readonly file: File;
+    readonly fields: UnresolvedField[];
+    toString(): string;
+}
+interface UnresolvedExtension {
+    readonly proto: FieldDescriptorProto;
+    readonly parent: UnresolvedMessage | undefined;
+    readonly file: File;
+}
+interface UnresolvedService {
+    readonly proto: ServiceDescriptorProto;
+    readonly file: File;
+    readonly methods: UnresolvedMethod[];
+    readonly typeName: string;
+    readonly protoTypeName: string;
+    toString(): string;
+}
+interface UnresolvedMethod {
+    readonly proto: MethodDescriptorProto;
+    readonly parent: UnresolvedService;
+    readonly name: string;
+    readonly kind: MethodKind;
+    readonly inputTypeName: string;
+    readonly outputTypeName: string;
+    readonly idempotency?: MethodIdempotency;
+    toString(): string;
+}
+export {};

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

@@ -0,0 +1,44 @@
+import type { MessageType } from "./message-type.js";
+import type { EnumType } from "./enum.js";
+import type { ServiceType } from "./service-type.js";
+import type { IEnumTypeRegistry, IMessageTypeRegistry, IServiceTypeRegistry } from "./type-registry.js";
+/**
+ * @deprecated use createRegistry() instead
+ *
+ * TypeRegistry is a simple registry for all message, enum, or service types.
+ */
+export declare class TypeRegistry implements IMessageTypeRegistry, IEnumTypeRegistry, IServiceTypeRegistry {
+    private readonly messages;
+    private readonly enums;
+    private readonly services;
+    /**
+     * Find a message type by its protobuf type name.
+     */
+    findMessage(typeName: string): MessageType | undefined;
+    /**
+     * Find an enum type by its protobuf type name.
+     */
+    findEnum(typeName: string): EnumType | undefined;
+    /**
+     * Find a service type by its protobuf type name.
+     */
+    findService(typeName: string): ServiceType | undefined;
+    /**
+     * Create a new TypeRegistry from the given types.
+     */
+    static from(...types: Array<MessageType | EnumType | ServiceType>): TypeRegistry;
+    /**
+     * @deprecated use TypeRegistry.from()
+     */
+    static fromIterable(types: Iterable<MessageType>): TypeRegistry;
+    /**
+     * @deprecated use TypeRegistry.from()
+     */
+    static fromTypes(...types: MessageType[]): TypeRegistry;
+    /**
+     * Add a type to the registry. For messages, the types used in message
+     * fields are added recursively. For services, the message types used
+     * for requests and responses are added recursively.
+     */
+    add(type: MessageType | EnumType | ServiceType): void;
+}

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

@@ -15,17 +15,13 @@ export declare function getEnumType(enumObject: EnumObject): EnumType;
 /**
  * Sets reflection information on a generated enum.
  */
-export declare function setEnumType(enumObject: EnumObject, typeName: string, values: EnumValueInfo[]): void;
+export declare function setEnumType(enumObject: EnumObject, typeName: string, values: Omit<EnumValueInfo, "localName">[], opt?: {}): void;
 /**
  * Create a new EnumType with the given values.
  */
-export declare function makeEnumType(typeName: string, values: EnumValueInfo[]): EnumType;
+export declare function makeEnumType(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], _opt?: {}): EnumType;
 /**
  * Create a new enum object with the given values.
+ * Sets reflection information.
  */
-export declare function makeEnum(typeName: string, values: EnumValueInfo[], opt?: {
-    /**
-     * MY_ENUM_ for `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`, or blank string
-     */
-    sharedPrefix?: string;
-}): EnumObject;
+export declare function makeEnum(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], opt?: {}): EnumObject;

package/dist/types/private/field-wrapper.d.ts

@@ -1,5 +1,7 @@
 import type { Message } from "../message.js";
 import type { MessageType } from "../message-type.js";
+import type { DescField } from "../descriptor-set.js";
+import { ScalarType } from "../field.js";
 /**
  * A field wrapper unwraps a message to a primitive value that is more
  * ergonomic for use as a message field.
@@ -19,3 +21,8 @@ export declare function wrapField<T extends Message<T>>(type: MessageType<T>, va
  * Unwrap field values whose message type has a wrapper.
  */
 export declare function unwrapField<T extends Message<T>>(type: MessageType<T>, value: T): any;
+/**
+ * If the given field uses one of the well-known wrapper types, return
+ * the base type it wraps.
+ */
+export declare function getUnwrappedFieldType(field: DescField): ScalarType | undefined;

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

@@ -11,10 +11,7 @@ export declare function makeMessageType<T extends Message<T> = AnyMessage>(runti
      * 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.
+     * If omitted, the last part of the typeName is used.
      */
     localName?: string;
 }): MessageType<T>;

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

@@ -1,16 +1,34 @@
+import type { DescEnum, DescEnumValue, DescField, DescMessage, DescService } from "../descriptor-set.js";
+import type { DescMethod, DescOneof } from "../descriptor-set.js";
 /**
- * Returns the JSON name for a protobuf field, exactly like protoc does.
+ * Returns the name of a protobuf element in generated code.
+ *
+ * Field names - including oneofs - are converted to lowerCamelCase. For
+ * messages, enumerations and services, the package name is stripped from
+ * the type name. For nested messages and enumerations, the names are joined
+ * with an underscore. For methods, the first character is made lowercase.
+ */
+export declare function localName(desc: DescEnum | DescEnumValue | DescMessage | DescOneof | DescField | DescService | DescMethod): string;
+/**
+ * Returns the name of a field in generated code.
  */
-export declare function makeJsonName(protoName: string): string;
+export declare function localFieldName(protoName: string, inOneof: boolean): string;
 /**
- * Returns the local name of a field, exactly like protoc-gen-es does.
+ * Returns the name of a oneof group in generated code.
+ */
+export declare function localOneofName(protoName: string): string;
+/**
+ * Returns the JSON name for a protobuf field, exactly like protoc does.
  */
-export declare function makeFieldName(protoName: string, inOneof: boolean): string;
+export declare const fieldJsonName: typeof protoCamelCase;
 /**
- * Returns the local name of a oneof group, exactly like protoc-gen-es does.
+ * Finds a prefix shared by enum values, for example `MY_ENUM_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
  */
-export declare function makeOneofName(protoName: string): string;
+export declare function findEnumSharedPrefix(enumName: string, valueNames: string[]): string | undefined;
 /**
- * Returns the local name of a rpc, exactly like protoc-gen-es does.
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
  */
-export declare function makeMethodName(protoName: string): string;
+declare function protoCamelCase(snakeCase: string): string;
+export {};

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

@@ -30,13 +30,13 @@ export interface ProtoRuntime {
      * The type name and other reflection information is accessible
      * via getEnumType().
      */
-    makeEnum(typeName: string, values: EnumValueInfo[], opt?: {}): EnumObject;
+    makeEnum(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], 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;
+    makeEnumType(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], opt?: {}): EnumType;
     /**
      * Get reflection information - the EnumType - from an enum object.
      * If this function is called on something other than a generated

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

@@ -1,7 +1,6 @@
 import type { FieldListSource } from "./field-list.js";
 import type { FieldList } from "../field-list.js";
 import type { EnumObject } from "./enum.js";
-import type { JsonValue } from "../json-format.js";
 import type { Message, PartialMessage, PlainMessage } from "../message.js";
 import type { MessageType } from "../message-type.js";
 import type { EnumValueInfo } from "../enum.js";
@@ -18,11 +17,7 @@ export interface Util {
     /**
      * Sets reflection information on a generated enum.
      */
-    setEnumType(enumObject: EnumObject, typeName: string, values: EnumValueInfo[], opt?: {
-        options?: {
-            readonly [extensionName: string]: JsonValue;
-        };
-    }): void;
+    setEnumType(enumObject: EnumObject, typeName: string, values: Omit<EnumValueInfo, "localName">[], opt?: {}): void;
     /**
      * Set default field values on the target message.
      */

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

@@ -28,41 +28,3 @@ export interface IServiceTypeRegistry {
      */
     findService(typeName: string): ServiceType | undefined;
 }
-/**
- * TypeRegistry is a simple registry for all message, enum, or service types.
- */
-export declare class TypeRegistry implements IMessageTypeRegistry, IEnumTypeRegistry, IServiceTypeRegistry {
-    private readonly messages;
-    private readonly enums;
-    private readonly services;
-    /**
-     * Find a message type by its protobuf type name.
-     */
-    findMessage(typeName: string): MessageType | undefined;
-    /**
-     * Find an enum type by its protobuf type name.
-     */
-    findEnum(typeName: string): EnumType | undefined;
-    /**
-     * Find a service type by its protobuf type name.
-     */
-    findService(typeName: string): ServiceType | undefined;
-    /**
-     * Create a new TypeRegistry from the given types.
-     */
-    static from(...types: Array<MessageType | EnumType | ServiceType>): TypeRegistry;
-    /**
-     * @deprecated use TypeRegistry.from()
-     */
-    static fromIterable(types: Iterable<MessageType>): TypeRegistry;
-    /**
-     * @deprecated use TypeRegistry.from()
-     */
-    static fromTypes(...types: MessageType[]): TypeRegistry;
-    /**
-     * Add a type to the registry. For messages, the types used in message
-     * fields are added recursively. For services, the message types used
-     * for requests and responses are added recursively.
-     */
-    add(type: MessageType | EnumType | ServiceType): void;
-}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@bufbuild/protobuf",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "license": "(Apache-2.0 AND BSD-3-Clause)",
-  "description": "A complete implementation of protocol buffers in TypeScript, suitable for web browsers and Node.js.",
+  "description": "A complete implementation of Protocol Buffers in TypeScript, suitable for web browsers and Node.js.",
   "repository": {
     "type": "git",
     "url": "https://github.com/bufbuild/protobuf-es.git",