@bufbuild/protobuf 0.0.6 → 0.0.9

package/dist/esm/proto3.js

@@ -19,13 +19,11 @@ 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";
+import { localFieldName, fieldJsonName } from "./private/names.js";
 /**
  * Provides functionality for messages defined with the proto3 syntax.
  */
-export const proto3 = makeProtoRuntime("proto3", makeJsonFormatProto3(), makeBinaryFormatProto3(), {
-    ...makeUtilCommon(),
-    newFieldList(fields) {
+export const proto3 = makeProtoRuntime("proto3", makeJsonFormatProto3(), makeBinaryFormatProto3(), Object.assign(Object.assign({}, makeUtilCommon()), { newFieldList(fields) {
         return new InternalFieldList(fields, normalizeFieldInfosProto3);
     },
     initFields(target) {
@@ -56,30 +54,29 @@ export const proto3 = makeProtoRuntime("proto3", makeJsonFormatProto3(), makeBin
                     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) {
+    var _a, _b, _c;
     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;
+        f.localName = localFieldName(field.name, field.oneof !== undefined);
+        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : fieldJsonName(field.name);
+        f.repeated = (_b = field.repeated) !== null && _b !== void 0 ? _b : 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));
+            (_c = field.packed) !== null && _c !== void 0 ? _c : (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) {

package/dist/esm/type-registry.js

@@ -11,88 +11,4 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-/**
- * TypeRegistry is a simple registry for all message, enum, or service types.
- */
-export class TypeRegistry {
-    constructor() {
-        this.messages = {};
-        this.enums = {};
-        this.services = {};
-    }
-    /**
-     * Find a message type by its protobuf type name.
-     */
-    findMessage(typeName) {
-        return this.messages[typeName];
-    }
-    /**
-     * Find an enum type by its protobuf type name.
-     */
-    findEnum(typeName) {
-        return this.enums[typeName];
-    }
-    /**
-     * Find a service type by its protobuf type name.
-     */
-    findService(typeName) {
-        return this.services[typeName];
-    }
-    /**
-     * Create a new TypeRegistry from the given types.
-     */
-    static from(...types) {
-        const registry = new TypeRegistry();
-        for (const type of types) {
-            registry.add(type);
-        }
-        return registry;
-    }
-    /**
-     * @deprecated use TypeRegistry.from()
-     */
-    static fromIterable(types) {
-        return TypeRegistry.from(...types);
-    }
-    /**
-     * @deprecated use TypeRegistry.from()
-     */
-    static fromTypes(...types) {
-        return TypeRegistry.from(...types);
-    }
-    /**
-     * 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) {
-        if ("fields" in type) {
-            if (!this.findMessage(type.typeName)) {
-                this.messages[type.typeName] = type;
-                for (const field of type.fields.list()) {
-                    if (field.kind == "message") {
-                        this.add(field.T);
-                    }
-                    else if (field.kind == "map" && field.V.kind == "message") {
-                        this.add(field.V.T);
-                    }
-                    else if (field.kind == "enum") {
-                        this.add(field.T);
-                    }
-                }
-            }
-        }
-        else if ("methods" in type) {
-            if (!this.findService(type.typeName)) {
-                this.services[type.typeName] = type;
-                for (const method of Object.values(type.methods)) {
-                    this.add(method.I);
-                    this.add(method.O);
-                }
-            }
-        }
-        else {
-            this.enums[type.typeName] = type;
-        }
-    }
-}
+export {};

package/dist/types/codegen-info.d.ts

@@ -0,0 +1,19 @@
+import { localName } from "./private/names.js";
+import { getUnwrappedFieldType } from "./private/field-wrapper.js";
+import { scalarDefaultValue } from "./private/scalars.js";
+interface CodegenInfo {
+    readonly packageName: string;
+    readonly localName: typeof localName;
+    readonly symbols: Record<RuntimeSymbolName, RuntimeSymbolInfo>;
+    readonly getUnwrappedFieldType: typeof getUnwrappedFieldType;
+    readonly wktSourceFiles: readonly string[];
+    readonly scalarDefaultValue: typeof scalarDefaultValue;
+}
+declare type RuntimeSymbolName = "proto2" | "proto3" | "Message" | "PartialMessage" | "PlainMessage" | "FieldList" | "MessageType" | "BinaryReadOptions" | "BinaryWriteOptions" | "JsonReadOptions" | "JsonWriteOptions" | "JsonValue" | "JsonObject" | "protoInt64" | "ScalarType" | "MethodKind" | "MethodIdempotency";
+declare type RuntimeSymbolInfo = {
+    typeOnly: boolean;
+    publicImportPath: string;
+    privateImportPath: string;
+};
+export declare const codegenInfo: CodegenInfo;
+export {};

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

@@ -0,0 +1,16 @@
+import type { FieldDescriptorProto } from "./google/protobuf/descriptor_pb.js";
+import { FileDescriptorProto, FileDescriptorSet } from "./google/protobuf/descriptor_pb.js";
+import type { DescriptorSet } from "./descriptor-set.js";
+/**
+ * Create a DescriptorSet, a convenient interface for working with a set of
+ * google.protobuf.FileDescriptorProto.
+ *
+ * Note that files must be given in topological order, so each file appears
+ * before any file that imports it. Protocol buffer compilers always produce
+ * files in topological order.
+ */
+export declare function createDescriptorSet(input: FileDescriptorProto[] | FileDescriptorSet | Uint8Array): DescriptorSet;
+/**
+ * Get the default `packed` state of a repeated field.
+ */
+export declare function isPackedFieldByDefault(proto: FieldDescriptorProto, syntax: "proto2" | "proto3"): boolean;

package/dist/types/create-registry-from-desc.d.ts

@@ -0,0 +1,49 @@
+import type { MessageType } from "./message-type.js";
+import type { EnumType } from "./enum.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 { DescriptorSet } from "./descriptor-set.js";
+/**
+ * Create a registry from a set of descriptors. The types returned by this
+ * registry behave exactly like types from generated code.
+ *
+ * This function accepts google.protobuf.FileDescriptorSet in serialized or
+ * deserialized form. Alternatively, it also accepts a DescriptorSet (see
+ * createDescriptorSet()).
+ *
+ * By default, all well-known types with a specialized JSON representation
+ * are replaced with their generated counterpart in this package.
+ */
+export declare function createRegistryFromDescriptors(input: DescriptorSet | FileDescriptorSet | Uint8Array, replaceWkt?: boolean): IMessageTypeRegistry & IEnumTypeRegistry & IServiceTypeRegistry;
+/**
+ * DescriptorRegistry 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.
+ */
+export declare class DescriptorRegistry implements IMessageTypeRegistry, IEnumTypeRegistry, IServiceTypeRegistry {
+    private readonly desc;
+    private readonly enums;
+    private readonly messages;
+    private readonly services;
+    constructor(descriptorSet: DescriptorSet, replaceWkt?: boolean);
+    /**
+     * Conveniently create a DescriptorRegistry from a FileDescriptorSet,
+     * or a FileDescriptorSet in binary format.
+     */
+    static fromFileDescriptorSet(input: FileDescriptorSet | Uint8Array): DescriptorRegistry;
+    /**
+     * May raise an error on invalid descriptors.
+     */
+    findEnum(typeName: string): EnumType | undefined;
+    /**
+     * May raise an error on invalid descriptors.
+     */
+    findMessage(typeName: string): MessageType | undefined;
+    /**
+     * May raise an error on invalid descriptors.
+     */
+    findService(typeName: string): ServiceType | undefined;
+}

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

@@ -0,0 +1,8 @@
+import type { MessageType } from "./message-type.js";
+import type { EnumType } from "./enum.js";
+import type { ServiceType } from "./service-type.js";
+import type { IMessageTypeRegistry, IEnumTypeRegistry, IServiceTypeRegistry } from "./type-registry.js";
+/**
+ * Create a new registry from the given types. Note that
+ */
+export declare function createRegistry(...types: Array<MessageType | EnumType | ServiceType>): IMessageTypeRegistry & IEnumTypeRegistry & IServiceTypeRegistry;