@bufbuild/protobuf 0.0.8 → 0.0.9

package/dist/esm/private/names.js

@@ -12,38 +12,113 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 /**
- * 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 function makeJsonName(protoName) {
-    return protoCamelCase(protoName);
+export function localName(desc) {
+    switch (desc.kind) {
+        case "enum_field":
+        case "message_field":
+        case "map_field":
+        case "scalar_field":
+            return localFieldName(desc.name, desc.oneof !== undefined);
+        case "oneof":
+            return localOneofName(desc.name);
+        case "enum":
+        case "message":
+        case "service": {
+            const pkg = desc.file.proto.package;
+            const offset = pkg === undefined ? 0 : pkg.length + 1;
+            const name = desc.typeName.substring(offset).replace(/\./g, "_");
+            if (reservedIdent[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+        case "enum_value": {
+            const sharedPrefix = desc.parent.sharedPrefix;
+            if (sharedPrefix === undefined) {
+                return desc.name;
+            }
+            const name = desc.name.substring(sharedPrefix.length);
+            if (reservedObjectProperties[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+        case "rpc": {
+            let name = desc.name;
+            if (name.length == 0) {
+                return name;
+            }
+            name = name[0].toLowerCase() + name.substring(1);
+            if (reservedObjectProperties[name]) {
+                return name + "$";
+            }
+            return name;
+        }
+    }
 }
 /**
- * Returns the local name of a field, exactly like protoc-gen-es does.
+ * Returns the name of a field in generated code.
  */
-export function makeFieldName(protoName, inOneof) {
-    const n = protoCamelCase(protoName);
+export function localFieldName(protoName, inOneof) {
+    let name = protoCamelCase(protoName);
     if (inOneof) {
-        return n;
+        // oneof member names are not properties, but values of the `case` property.
+        return name;
     }
-    return rProp[n] ? n + escapeChar : n;
+    if (reservedObjectProperties[name] || reservedMessageProperties[name]) {
+        name = name + "$";
+    }
+    return name;
 }
 /**
- * Returns the local name of a oneof group, exactly like protoc-gen-es does.
+ * Returns the name of a oneof group in generated code.
  */
-export function makeOneofName(protoName) {
-    return makeFieldName(protoName, false);
+export function localOneofName(protoName) {
+    return localFieldName(protoName, false);
 }
 /**
- * Returns the local name of a rpc, exactly like protoc-gen-es does.
+ * Returns the JSON name for a protobuf field, exactly like protoc does.
  */
-export function makeMethodName(protoName) {
-    if (protoName.length == 0) {
-        return protoName;
+export const fieldJsonName = protoCamelCase;
+/**
+ * Finds a prefix shared by enum values, for example `MY_ENUM_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+export function findEnumSharedPrefix(enumName, valueNames) {
+    const prefix = camelToSnakeCase(enumName) + "_";
+    for (const name of valueNames) {
+        if (!name.toLowerCase().startsWith(prefix)) {
+            return undefined;
+        }
+        const shortName = name.substring(prefix.length);
+        if (shortName.length == 0) {
+            return undefined;
+        }
+        if (/^\d/.test(shortName)) {
+            // identifiers must not start with numbers
+            return undefined;
+        }
     }
-    return protoName[0].toLowerCase() + protoName.substring(1);
+    return prefix;
+}
+/**
+ * Converts lowerCamelCase or UpperCamelCase into lower_snake_case.
+ * This is used to find shared prefixes in an enum.
+ */
+function camelToSnakeCase(camel) {
+    return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase();
 }
-// Converts snake_case to protoCamelCase according to the convention
-// used by protoc to convert a field name to a JSON name.
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
 function protoCamelCase(snakeCase) {
     let capNext = false;
     const b = [];
@@ -77,17 +152,81 @@ function protoCamelCase(snakeCase) {
     }
     return b.join("");
 }
-// escapeChar must be appended to a reserved name.
-// We choose '$' because it is invalid in proto identifiers.
-const escapeChar = "$";
-// Names that cannot be used for object properties.
-// See buf_es/protoc-gen-es/internal/protoplugin/names.go
-const rProp = {
+// Names that cannot be used for identifiers, such as class names,
+// but _can_ be used for object properties.
+const reservedIdent = {
+    // ECMAScript 2015 keywords
+    break: true,
+    case: true,
+    catch: true,
+    class: true,
+    const: true,
+    continue: true,
+    debugger: true,
+    default: true,
+    delete: true,
+    do: true,
+    else: true,
+    export: true,
+    extends: true,
+    false: true,
+    finally: true,
+    for: true,
+    function: true,
+    if: true,
+    import: true,
+    in: true,
+    instanceof: true,
+    new: true,
+    null: true,
+    return: true,
+    super: true,
+    switch: true,
+    this: true,
+    throw: true,
+    true: true,
+    try: true,
+    typeof: true,
+    var: true,
+    void: true,
+    while: true,
+    with: true,
+    yield: true,
+    // ECMAScript 2015 future reserved keywords
+    enum: true,
+    implements: true,
+    interface: true,
+    let: true,
+    package: true,
+    private: true,
+    protected: true,
+    public: true,
+    static: true,
+    // Class name cannot be 'Object' when targeting ES5 with module CommonJS
+    Object: true,
+    // TypeScript keywords that cannot be used for types (as opposed to variables)
+    bigint: true,
+    number: true,
+    boolean: true,
+    string: true,
+    object: true,
+    // Identifiers reserved for the runtime, so we can generate legible code
+    globalThis: true,
+    Uint8Array: true,
+    Partial: true,
+};
+// Names that cannot be used for object properties because they are reserved
+// by built-in JavaScript properties.
+const reservedObjectProperties = {
     // names reserved by JavaScript
     constructor: true,
     toString: true,
     toJSON: true,
     valueOf: true,
+};
+// Names that cannot be used for object properties because they are reserved
+// by the runtime.
+const reservedMessageProperties = {
     // names reserved by the runtime
     getType: true,
     clone: true,

package/dist/esm/proto2.js

@@ -16,7 +16,7 @@ import { makeBinaryFormatProto2 } from "./private/binary-format-proto2.js";
 import { makeUtilCommon } from "./private/util-common.js";
 import { InternalFieldList } from "./private/field-list.js";
 import { InternalOneofInfo } from "./private/field.js";
-import { makeFieldName, makeJsonName } from "./private/names.js";
+import { localFieldName, fieldJsonName } from "./private/names.js";
 import { makeJsonFormatProto2 } from "./private/json-format-proto2.js";
 /**
  * Provides functionality for messages defined with the proto2 syntax.
@@ -60,8 +60,8 @@ function normalizeFieldInfosProto2(fieldInfos) {
         ? fieldInfos()
         : fieldInfos) {
         const f = field;
-        f.localName = makeFieldName(field.name, field.oneof !== undefined);
-        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : makeJsonName(field.name);
+        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;
         // In contrast to proto3, repeated fields are unpacked except when explicitly specified.
         f.packed = (_c = field.packed) !== null && _c !== void 0 ? _c : false;

package/dist/esm/proto3.js

@@ -19,7 +19,7 @@ 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.
  */
@@ -64,8 +64,8 @@ function normalizeFieldInfosProto3(fieldInfos) {
         ? fieldInfos()
         : fieldInfos) {
         const f = field;
-        f.localName = makeFieldName(field.name, field.oneof !== undefined);
-        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : makeJsonName(field.name);
+        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.

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;