@bufbuild/protobuf 1.4.1 → 1.5.0

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

@@ -1,5 +1,4 @@
-import type { FieldDescriptorProto } from "./google/protobuf/descriptor_pb.js";
-import { FileDescriptorProto, FileDescriptorSet } from "./google/protobuf/descriptor_pb.js";
+import { FeatureSetDefaults, 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
@@ -9,8 +8,23 @@ import type { DescriptorSet } from "./descriptor-set.js";
  * before any file that imports it. Protocol buffer compilers always produce
  * files in topological order.
  */
-export declare function createDescriptorSet(input: FileDescriptorProto[] | FileDescriptorSet | Uint8Array): DescriptorSet;
+export declare function createDescriptorSet(input: FileDescriptorProto[] | FileDescriptorSet | Uint8Array, options?: CreateDescriptorSetOptions): DescriptorSet;
 /**
- * Get the default `packed` state of a repeated field.
+ * Options to createDescriptorSet()
  */
-export declare function isPackedFieldByDefault(proto: FieldDescriptorProto, syntax: "proto2" | "proto3"): boolean;
+interface CreateDescriptorSetOptions {
+    /**
+     * Editions support language-specific features with extensions to
+     * google.protobuf.FeatureSet. They can define defaults, and specify on
+     * which targets the features can be set.
+     *
+     * To create a DescriptorSet that provides your language-specific features,
+     * you have to provide a google.protobuf.FeatureSetDefaults message in this
+     * option.
+     *
+     * The defaults can be generated with `protoc` - see the flag
+     * `--experimental_edition_defaults_out`.
+     */
+    featureSetDefaults?: FeatureSetDefaults;
+}
+export {};

package/dist/esm/create-descriptor-set.js

@@ -11,12 +11,13 @@
 // 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 { FieldDescriptorProto_Label, FieldDescriptorProto_Type, FieldOptions_JSType, FileDescriptorProto, FileDescriptorSet, MethodDescriptorProto, MethodOptions_IdempotencyLevel, ServiceDescriptorProto, SourceCodeInfo, } from "./google/protobuf/descriptor_pb.js";
+import { Edition, FeatureSet_RepeatedFieldEncoding, FeatureSetDefaults, FieldDescriptorProto_Label, FieldDescriptorProto_Type, FieldOptions_JSType, FileDescriptorProto, FileDescriptorSet, MethodDescriptorProto, MethodOptions_IdempotencyLevel, ServiceDescriptorProto, SourceCodeInfo, } from "./google/protobuf/descriptor_pb.js";
 import { assert } from "./private/assert.js";
 import { LongType, ScalarType } from "./field.js";
 import { MethodIdempotency, MethodKind } from "./service-type.js";
 import { fieldJsonName, findEnumSharedPrefix } from "./private/names.js";
-import { protoInt64 } from "./proto-int64.js";
+import { parseTextFormatEnumValue, parseTextFormatScalarValue, } from "./private/text-format.js";
+import { createFeatureResolver, featureSetDefaults, } from "./private/feature-set.js";
 /**
  * Create a DescriptorSet, a convenient interface for working with a set of
  * google.protobuf.FileDescriptorProto.
@@ -25,13 +26,15 @@ import { protoInt64 } from "./proto-int64.js";
  * before any file that imports it. Protocol buffer compilers always produce
  * files in topological order.
  */
-export function createDescriptorSet(input) {
+export function createDescriptorSet(input, options) {
+    var _a;
     const cart = {
         enums: new Map(),
         messages: new Map(),
         services: new Map(),
         extensions: new Map(),
         mapEntries: new Map(),
+        resolveFeatures: createFeatureResolver((_a = options === null || options === void 0 ? void 0 : options.featureSetDefaults) !== null && _a !== void 0 ? _a : featureSetDefaults),
     };
     const fileDescriptors = input instanceof FileDescriptorSet
         ? input.file
@@ -45,20 +48,9 @@ export function createDescriptorSet(input) {
  * Create a descriptor for a file.
  */
 function newFile(proto, cart) {
-    var _a, _b, _c;
+    var _a, _b;
     assert(proto.name, `invalid FileDescriptorProto: missing name`);
-    assert(proto.syntax === undefined || proto.syntax === "proto3", `invalid FileDescriptorProto: unsupported syntax: ${(_a = proto.syntax) !== null && _a !== void 0 ? _a : "undefined"}`);
-    const file = {
-        kind: "file",
-        proto,
-        deprecated: (_c = (_b = proto.options) === null || _b === void 0 ? void 0 : _b.deprecated) !== null && _c !== void 0 ? _c : false,
-        syntax: proto.syntax === "proto3" ? "proto3" : "proto2",
-        name: proto.name.replace(/\.proto/, ""),
-        enums: [],
-        messages: [],
-        extensions: [],
-        services: [],
-        toString() {
+    const file = Object.assign(Object.assign({ kind: "file", proto, deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false }, parseFileSyntax(proto.syntax, proto.edition)), { name: proto.name.replace(/\.proto/, ""), enums: [], messages: [], extensions: [], services: [], toString() {
             // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
             return `file ${this.proto.name}`;
         },
@@ -72,7 +64,10 @@ function newFile(proto, cart) {
                 FieldNumber.FileDescriptorProto_Package,
             ]);
         },
-    };
+        getFeatures() {
+            var _a;
+            return cart.resolveFeatures(this.edition, (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+        } });
     cart.mapEntries.clear(); // map entries are local to the file, we can safely discard
     for (const enumProto of proto.enumType) {
         addEnum(enumProto, file, undefined, cart);
@@ -125,7 +120,7 @@ function addExtensions(desc, cart) {
  * Recurses into nested types.
  */
 function addFields(message, cart) {
-    const allOneofs = message.proto.oneofDecl.map((proto) => newOneof(proto, message));
+    const allOneofs = message.proto.oneofDecl.map((proto) => newOneof(proto, message, cart));
     const oneofsSeen = new Set();
     for (const proto of message.proto.field) {
         const oneof = findOneof(proto, allOneofs);
@@ -182,6 +177,11 @@ function addEnum(proto, file, parent, cart) {
                 ];
             return findComments(file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a, _b, _c;
+            const parentFeatures = (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getFeatures()) !== null && _b !== void 0 ? _b : this.file.getFeatures();
+            return cart.resolveFeatures(this.file.edition, parentFeatures, (_c = this.proto.options) === null || _c === void 0 ? void 0 : _c.features);
+        },
     };
     cart.enums.set(desc.typeName, desc);
     proto.value.forEach((proto) => {
@@ -214,6 +214,10 @@ function addEnum(proto, file, parent, cart) {
                 ];
                 return findComments(file.proto.sourceCodeInfo, path);
             },
+            getFeatures() {
+                var _a;
+                return cart.resolveFeatures(this.parent.file.edition, this.parent.getFeatures(), (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+            },
         });
     });
     ((_c = parent === null || parent === void 0 ? void 0 : parent.nestedEnums) !== null && _c !== void 0 ? _c : file.enums).push(desc);
@@ -255,6 +259,11 @@ function addMessage(proto, file, parent, cart) {
                 ];
             return findComments(file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a, _b, _c;
+            const parentFeatures = (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getFeatures()) !== null && _b !== void 0 ? _b : this.file.getFeatures();
+            return cart.resolveFeatures(this.file.edition, parentFeatures, (_c = this.proto.options) === null || _c === void 0 ? void 0 : _c.features);
+        },
     };
     if (((_c = proto.options) === null || _c === void 0 ? void 0 : _c.mapEntry) === true) {
         cart.mapEntries.set(desc.typeName, desc);
@@ -295,6 +304,10 @@ function addService(proto, file, cart) {
             ];
             return findComments(file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a;
+            return cart.resolveFeatures(this.file.edition, this.file.getFeatures(), (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+        },
     };
     file.services.push(desc);
     cart.services.set(desc.typeName, desc);
@@ -362,12 +375,16 @@ function newMethod(proto, parent, cart) {
             ];
             return findComments(parent.file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a;
+            return cart.resolveFeatures(this.parent.file.edition, this.parent.getFeatures(), (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+        },
     };
 }
 /**
  * Create a descriptor for a oneof group.
  */
-function newOneof(proto, parent) {
+function newOneof(proto, parent, cart) {
     assert(proto.name, `invalid OneofDescriptorProto: missing name`);
     return {
         kind: "oneof",
@@ -387,17 +404,20 @@ function newOneof(proto, parent) {
             ];
             return findComments(parent.file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a;
+            return cart.resolveFeatures(this.parent.file.edition, this.parent.getFeatures(), (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+        },
     };
 }
 /**
  * Create a descriptor for a field.
  */
 function newField(proto, file, parent, oneof, cart) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c;
     assert(proto.name, `invalid FieldDescriptorProto: missing name`);
     assert(proto.number, `invalid FieldDescriptorProto: missing number`);
     assert(proto.type, `invalid FieldDescriptorProto: missing type`);
-    const packedByDefault = isPackedFieldByDefault(proto, file.syntax);
     const common = {
         proto,
         deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
@@ -406,8 +426,8 @@ function newField(proto, file, parent, oneof, cart) {
         parent,
         oneof,
         optional: isOptionalField(proto, file.syntax),
-        packed: (_d = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.packed) !== null && _d !== void 0 ? _d : packedByDefault,
-        packedByDefault,
+        packedByDefault: isPackedFieldByDefault(file, proto, cart.resolveFeatures),
+        packed: isPackedField(file, parent, proto, cart.resolveFeatures),
         jsonName: proto.jsonName === fieldJsonName(proto.name) ? undefined : proto.jsonName,
         scalar: undefined,
         longType: undefined,
@@ -415,11 +435,11 @@ function newField(proto, file, parent, oneof, cart) {
         enum: undefined,
         mapKey: undefined,
         mapValue: undefined,
+        declarationString,
+        // toString, getComments, getFeatures are overridden in newExtension
         toString() {
-            // note that newExtension() calls us with parent = null
             return `field ${this.parent.typeName}.${this.name}`;
         },
-        declarationString,
         getComments() {
             const path = [
                 ...this.parent.getComments().sourcePath,
@@ -428,6 +448,10 @@ function newField(proto, file, parent, oneof, cart) {
             ];
             return findComments(file.proto.sourceCodeInfo, path);
         },
+        getFeatures() {
+            var _a;
+            return cart.resolveFeatures(file.edition, this.parent.getFeatures(), (_a = this.proto.options) === null || _a === void 0 ? void 0 : _a.features);
+        },
     };
     const repeated = proto.label === FieldDescriptorProto_Label.REPEATED;
     switch (proto.type) {
@@ -456,7 +480,7 @@ function newField(proto, file, parent, oneof, cart) {
             assert(scalar, `invalid FieldDescriptorProto: unknown type ${proto.type}`);
             return Object.assign(Object.assign({}, common), { kind: "field", fieldKind: "scalar", getDefaultValue,
                 repeated,
-                scalar, longType: ((_e = proto.options) === null || _e === void 0 ? void 0 : _e.jstype) == FieldOptions_JSType.JS_STRING
+                scalar, longType: ((_c = proto.options) === null || _c === void 0 ? void 0 : _c.jstype) == FieldOptions_JSType.JS_STRING
                     ? LongType.STRING
                     : LongType.BIGINT });
         }
@@ -474,6 +498,8 @@ function newExtension(proto, file, parent, cart) {
     return Object.assign(Object.assign({}, field), { kind: "extension", typeName: makeTypeName(proto, parent, file), parent,
         file,
         extendee,
+        // Must override toString, getComments, getFeatures from newField, because we
+        // call newField with parent undefined.
         toString() {
             return `extension ${this.typeName}`;
         },
@@ -489,8 +515,56 @@ function newExtension(proto, file, parent, cart) {
                     this.file.proto.extension.indexOf(proto),
                 ];
             return findComments(file.proto.sourceCodeInfo, path);
+        },
+        getFeatures() {
+            var _a, _b;
+            return cart.resolveFeatures(this.file.edition, ((_a = this.parent) !== null && _a !== void 0 ? _a : this.file).getFeatures(), (_b = this.proto.options) === null || _b === void 0 ? void 0 : _b.features);
         } });
 }
+/**
+ * Parse the "syntax" and "edition" fields, stripping test editions.
+ */
+function parseFileSyntax(syntax, edition) {
+    let e;
+    let s;
+    switch (syntax) {
+        case undefined:
+        case "proto2":
+            s = "proto2";
+            e = Edition.EDITION_PROTO2;
+            break;
+        case "proto3":
+            s = "proto3";
+            e = Edition.EDITION_PROTO3;
+            break;
+        case "editions":
+            s = "editions";
+            switch (edition) {
+                case undefined:
+                case Edition.EDITION_1_TEST_ONLY:
+                case Edition.EDITION_2_TEST_ONLY:
+                case Edition.EDITION_99997_TEST_ONLY:
+                case Edition.EDITION_99998_TEST_ONLY:
+                case Edition.EDITION_99999_TEST_ONLY:
+                case Edition.EDITION_UNKNOWN:
+                    e = Edition.EDITION_UNKNOWN;
+                    break;
+                default:
+                    e = edition;
+                    break;
+            }
+            break;
+        default:
+            throw new Error(`invalid FileDescriptorProto: unsupported syntax: ${syntax}`);
+    }
+    if (syntax === "editions" && edition === Edition.EDITION_UNKNOWN) {
+        throw new Error(`invalid FileDescriptorProto: syntax ${syntax} cannot have edition ${String(edition)}`);
+    }
+    return {
+        syntax: s,
+        edition: e,
+    };
+}
 /**
  * Create a fully qualified name for a protobuf type or extension field.
  *
@@ -588,40 +662,65 @@ function isOptionalField(proto, syntax) {
                 proto.label === FieldDescriptorProto_Label.OPTIONAL);
         case "proto3":
             return proto.proto3Optional === true;
+        case "editions":
+            return false;
     }
 }
 /**
- * Get the default `packed` state of a repeated field.
+ * Is this field packed by default? Only valid for repeated enum fields, and
+ * for repeated scalar fields except BYTES and STRING.
+ *
+ * In proto3 syntax, fields are packed by default. In proto2 syntax, fields
+ * are unpacked by default. With editions, the default is whatever the edition
+ * specifies as a default. In edition 2023, fields are packed by default.
  */
-export function isPackedFieldByDefault(proto, syntax) {
-    assert(proto.type, `invalid FieldDescriptorProto: missing type`);
-    if (syntax === "proto3") {
-        switch (proto.type) {
-            case FieldDescriptorProto_Type.DOUBLE:
-            case FieldDescriptorProto_Type.FLOAT:
-            case FieldDescriptorProto_Type.INT64:
-            case FieldDescriptorProto_Type.UINT64:
-            case FieldDescriptorProto_Type.INT32:
-            case FieldDescriptorProto_Type.FIXED64:
-            case FieldDescriptorProto_Type.FIXED32:
-            case FieldDescriptorProto_Type.UINT32:
-            case FieldDescriptorProto_Type.SFIXED32:
-            case FieldDescriptorProto_Type.SFIXED64:
-            case FieldDescriptorProto_Type.SINT32:
-            case FieldDescriptorProto_Type.SINT64:
-            case FieldDescriptorProto_Type.BOOL:
-            case FieldDescriptorProto_Type.ENUM:
-                // 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.
-                return true;
-            default:
-                return false;
-        }
+function isPackedFieldByDefault(file, proto, resolveFeatures) {
+    const { repeatedFieldEncoding } = resolveFeatures(file.edition);
+    if (repeatedFieldEncoding != FeatureSet_RepeatedFieldEncoding.PACKED) {
+        return 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.
+    switch (proto.type) {
+        case FieldDescriptorProto_Type.STRING:
+        case FieldDescriptorProto_Type.BYTES:
+        case FieldDescriptorProto_Type.GROUP:
+        case FieldDescriptorProto_Type.MESSAGE:
+            return false;
+        default:
+            return true;
+    }
+}
+/**
+ * Pack this repeated field?
+ *
+ * Respects field type, proto2/proto3 defaults and the `packed` option, or
+ * edition defaults and the edition features.repeated_field_encoding options.
+ */
+function isPackedField(file, parent, proto, resolveFeatures) {
+    var _a, _b, _c, _d, _e, _f;
+    switch (proto.type) {
+        case FieldDescriptorProto_Type.STRING:
+        case FieldDescriptorProto_Type.BYTES:
+        case FieldDescriptorProto_Type.GROUP:
+        case FieldDescriptorProto_Type.MESSAGE:
+            // length-delimited types cannot be packed
+            return false;
+        default:
+            switch (file.edition) {
+                case Edition.EDITION_PROTO2:
+                    return (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.packed) !== null && _b !== void 0 ? _b : false;
+                case Edition.EDITION_PROTO3:
+                    return (_d = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.packed) !== null && _d !== void 0 ? _d : true;
+                default: {
+                    const { repeatedFieldEncoding } = resolveFeatures(file.edition, (_e = parent === null || parent === void 0 ? void 0 : parent.getFeatures()) !== null && _e !== void 0 ? _e : file.getFeatures(), (_f = proto.options) === null || _f === void 0 ? void 0 : _f.features);
+                    return (repeatedFieldEncoding == FeatureSet_RepeatedFieldEncoding.PACKED);
+                }
+            }
     }
-    return false;
 }
 /**
  * Map from a compiler-generated field type to our ScalarType, which is a
@@ -779,175 +878,11 @@ function getDefaultValue() {
         return undefined;
     }
     switch (this.fieldKind) {
-        case "enum": {
-            const enumValue = this.enum.values.find((v) => v.name === d);
-            assert(enumValue, `cannot parse ${this.toString()} default value: ${d}`);
-            return enumValue.number;
-        }
+        case "enum":
+            return parseTextFormatEnumValue(this.enum, d);
         case "scalar":
-            switch (this.scalar) {
-                case ScalarType.STRING:
-                    return d;
-                case ScalarType.BYTES: {
-                    const u = unescapeBytesDefaultValue(d);
-                    if (u === false) {
-                        throw new Error(`cannot parse ${this.toString()} default value: ${d}`);
-                    }
-                    return u;
-                }
-                case ScalarType.INT64:
-                case ScalarType.SFIXED64:
-                case ScalarType.SINT64:
-                    return protoInt64.parse(d);
-                case ScalarType.UINT64:
-                case ScalarType.FIXED64:
-                    return protoInt64.uParse(d);
-                case ScalarType.DOUBLE:
-                case ScalarType.FLOAT:
-                    switch (d) {
-                        case "inf":
-                            return Number.POSITIVE_INFINITY;
-                        case "-inf":
-                            return Number.NEGATIVE_INFINITY;
-                        case "nan":
-                            return Number.NaN;
-                        default:
-                            return parseFloat(d);
-                    }
-                case ScalarType.BOOL:
-                    return d === "true";
-                case ScalarType.INT32:
-                case ScalarType.UINT32:
-                case ScalarType.SINT32:
-                case ScalarType.FIXED32:
-                case ScalarType.SFIXED32:
-                    return parseInt(d, 10);
-            }
-            break;
+            return parseTextFormatScalarValue(this.scalar, d);
         default:
             return undefined;
     }
 }
-/**
- * Parses a text-encoded default value (proto2) of a BYTES field.
- */
-function unescapeBytesDefaultValue(str) {
-    const b = [];
-    const input = {
-        tail: str,
-        c: "",
-        next() {
-            if (this.tail.length == 0) {
-                return false;
-            }
-            this.c = this.tail[0];
-            this.tail = this.tail.substring(1);
-            return true;
-        },
-        take(n) {
-            if (this.tail.length >= n) {
-                const r = this.tail.substring(0, n);
-                this.tail = this.tail.substring(n);
-                return r;
-            }
-            return false;
-        },
-    };
-    while (input.next()) {
-        switch (input.c) {
-            case "\\":
-                if (input.next()) {
-                    switch (input.c) {
-                        case "\\":
-                            b.push(input.c.charCodeAt(0));
-                            break;
-                        case "b":
-                            b.push(0x08);
-                            break;
-                        case "f":
-                            b.push(0x0c);
-                            break;
-                        case "n":
-                            b.push(0x0a);
-                            break;
-                        case "r":
-                            b.push(0x0d);
-                            break;
-                        case "t":
-                            b.push(0x09);
-                            break;
-                        case "v":
-                            b.push(0x0b);
-                            break;
-                        case "0":
-                        case "1":
-                        case "2":
-                        case "3":
-                        case "4":
-                        case "5":
-                        case "6":
-                        case "7": {
-                            const s = input.c;
-                            const t = input.take(2);
-                            if (t === false) {
-                                return false;
-                            }
-                            const n = parseInt(s + t, 8);
-                            if (isNaN(n)) {
-                                return false;
-                            }
-                            b.push(n);
-                            break;
-                        }
-                        case "x": {
-                            const s = input.c;
-                            const t = input.take(2);
-                            if (t === false) {
-                                return false;
-                            }
-                            const n = parseInt(s + t, 16);
-                            if (isNaN(n)) {
-                                return false;
-                            }
-                            b.push(n);
-                            break;
-                        }
-                        case "u": {
-                            const s = input.c;
-                            const t = input.take(4);
-                            if (t === false) {
-                                return false;
-                            }
-                            const n = parseInt(s + t, 16);
-                            if (isNaN(n)) {
-                                return false;
-                            }
-                            const chunk = new Uint8Array(4);
-                            const view = new DataView(chunk.buffer);
-                            view.setInt32(0, n, true);
-                            b.push(chunk[0], chunk[1], chunk[2], chunk[3]);
-                            break;
-                        }
-                        case "U": {
-                            const s = input.c;
-                            const t = input.take(8);
-                            if (t === false) {
-                                return false;
-                            }
-                            const tc = protoInt64.uEnc(s + t);
-                            const chunk = new Uint8Array(8);
-                            const view = new DataView(chunk.buffer);
-                            view.setInt32(0, tc.lo, true);
-                            view.setInt32(4, tc.hi, true);
-                            b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]);
-                            break;
-                        }
-                    }
-                }
-                break;
-            default:
-                b.push(input.c.charCodeAt(0));
-        }
-    }
-    return new Uint8Array(b);
-}