@bufbuild/protobuf 0.0.7 → 0.0.10

package/dist/cjs/private/field.js

@@ -25,7 +25,7 @@ class InternalOneofInfo {
         this.default = undefined;
         this.fields = [];
         this.name = name;
-        this.localName = (0, names_js_1.makeOneofName)(name);
+        this.localName = (0, names_js_1.localOneofName)(name);
     }
     addField(field) {
         (0, assert_js_1.assert)(field.oneof === this, `field ${field.name} not one of ${this.name}`);

package/dist/cjs/private/names.js

@@ -13,44 +13,119 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMethodName = exports.makeOneofName = exports.makeFieldName = exports.makeJsonName = void 0;
+exports.findEnumSharedPrefix = exports.fieldJsonName = exports.localOneofName = exports.localFieldName = exports.localName = void 0;
 /**
- * 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.
  */
-function makeJsonName(protoName) {
-    return protoCamelCase(protoName);
+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;
+        }
+    }
 }
-exports.makeJsonName = makeJsonName;
+exports.localName = localName;
 /**
- * Returns the local name of a field, exactly like protoc-gen-es does.
+ * Returns the name of a field in generated code.
  */
-function makeFieldName(protoName, inOneof) {
-    const n = protoCamelCase(protoName);
+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;
 }
-exports.makeFieldName = makeFieldName;
+exports.localFieldName = localFieldName;
 /**
- * Returns the local name of a oneof group, exactly like protoc-gen-es does.
+ * Returns the name of a oneof group in generated code.
  */
-function makeOneofName(protoName) {
-    return makeFieldName(protoName, false);
+function localOneofName(protoName) {
+    return localFieldName(protoName, false);
 }
-exports.makeOneofName = makeOneofName;
+exports.localOneofName = localOneofName;
 /**
- * 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.
  */
-function makeMethodName(protoName) {
-    if (protoName.length == 0) {
-        return protoName;
+exports.fieldJsonName = protoCamelCase;
+/**
+ * Finds a prefix shared by enum values, for example `MY_ENUM_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+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;
+}
+exports.findEnumSharedPrefix = findEnumSharedPrefix;
+/**
+ * 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();
 }
-exports.makeMethodName = makeMethodName;
-// 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 = [];
@@ -84,17 +159,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/cjs/proto2.js

@@ -63,8 +63,8 @@ function normalizeFieldInfosProto2(fieldInfos) {
         ? fieldInfos()
         : fieldInfos) {
         const f = field;
-        f.localName = (0, names_js_1.makeFieldName)(field.name, field.oneof !== undefined);
-        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : (0, names_js_1.makeJsonName)(field.name);
+        f.localName = (0, names_js_1.localFieldName)(field.name, field.oneof !== undefined);
+        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : (0, names_js_1.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/cjs/proto3.js

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

@@ -13,90 +13,3 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeRegistry = void 0;
-/**
- * TypeRegistry is a simple registry for all message, enum, or service types.
- */
-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;
-        }
-    }
-}
-exports.TypeRegistry = TypeRegistry;

package/dist/esm/codegen-info.js

@@ -0,0 +1,57 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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.
+import { localName } from "./private/names.js";
+import { getUnwrappedFieldType } from "./private/field-wrapper.js";
+import { scalarDefaultValue } from "./private/scalars.js";
+const packageName = "@bufbuild/protobuf";
+export const codegenInfo = {
+    packageName,
+    localName,
+    getUnwrappedFieldType,
+    scalarDefaultValue,
+    // prettier-ignore
+    symbols: {
+        proto2: { typeOnly: false, privateImportPath: "./proto2.js", publicImportPath: packageName },
+        proto3: { typeOnly: false, privateImportPath: "./proto3.js", publicImportPath: packageName },
+        Message: { typeOnly: false, privateImportPath: "./message.js", publicImportPath: packageName },
+        PartialMessage: { typeOnly: true, privateImportPath: "./message.js", publicImportPath: packageName },
+        PlainMessage: { typeOnly: true, privateImportPath: "./message.js", publicImportPath: packageName },
+        FieldList: { typeOnly: true, privateImportPath: "./field-list.js", publicImportPath: packageName },
+        MessageType: { typeOnly: true, privateImportPath: "./message-type.js", publicImportPath: packageName },
+        BinaryReadOptions: { typeOnly: true, privateImportPath: "./binary-format.js", publicImportPath: packageName },
+        BinaryWriteOptions: { typeOnly: true, privateImportPath: "./binary-format.js", publicImportPath: packageName },
+        JsonReadOptions: { typeOnly: true, privateImportPath: "./json-format.js", publicImportPath: packageName },
+        JsonWriteOptions: { typeOnly: true, privateImportPath: "./json-format.js", publicImportPath: packageName },
+        JsonValue: { typeOnly: true, privateImportPath: "./json-format.js", publicImportPath: packageName },
+        JsonObject: { typeOnly: true, privateImportPath: "./json-format.js", publicImportPath: packageName },
+        protoInt64: { typeOnly: false, privateImportPath: "./proto-int64.js", publicImportPath: packageName },
+        ScalarType: { typeOnly: false, privateImportPath: "./field.js", publicImportPath: packageName },
+        MethodKind: { typeOnly: false, privateImportPath: "./service-type.js", publicImportPath: packageName },
+        MethodIdempotency: { typeOnly: false, privateImportPath: "./service-type.js", publicImportPath: packageName },
+    },
+    wktSourceFiles: [
+        "google/protobuf/compiler/plugin.proto",
+        "google/protobuf/any.proto",
+        "google/protobuf/api.proto",
+        "google/protobuf/descriptor.proto",
+        "google/protobuf/duration.proto",
+        "google/protobuf/empty.proto",
+        "google/protobuf/field_mask.proto",
+        "google/protobuf/source_context.proto",
+        "google/protobuf/struct.proto",
+        "google/protobuf/timestamp.proto",
+        "google/protobuf/type.proto",
+        "google/protobuf/wrappers.proto",
+    ],
+};