@bufbuild/protobuf 1.6.0 → 1.7.0

package/dist/esm/message-type.js

@@ -1,4 +1,4 @@
-// Copyright 2021-2023 Buf Technologies, Inc.
+// Copyright 2021-2024 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.

package/dist/esm/message.js

@@ -1,4 +1,4 @@
-// Copyright 2021-2023 Buf Technologies, Inc.
+// Copyright 2021-2024 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.

package/dist/esm/private/assert.js

@@ -1,4 +1,4 @@
-// Copyright 2021-2023 Buf Technologies, Inc.
+// Copyright 2021-2024 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.

package/dist/esm/private/binary-format-common.d.ts

@@ -1,9 +1,8 @@
-import type { IBinaryReader, IBinaryWriter } from "../binary-encoding.js";
+import type { IBinaryWriter } from "../binary-encoding.js";
 import type { BinaryFormat, BinaryWriteOptions } from "../binary-format.js";
 import type { FieldInfo } from "../field.js";
 import { ScalarType } from "../field.js";
-export declare function makeBinaryFormatCommon(): Omit<BinaryFormat, "writeMessage">;
-export declare function readScalarLTString(reader: IBinaryReader, type: ScalarType): any;
+export declare function makeBinaryFormatCommon(): Omit<BinaryFormat, "writeMessage" | "writeField">;
 export declare function writeMapEntry(writer: IBinaryWriter, options: BinaryWriteOptions, field: FieldInfo & {
     kind: "map";
 }, key: any, value: any): void;

package/dist/esm/private/binary-format-common.js

@@ -1,4 +1,4 @@
-// Copyright 2021-2023 Buf Technologies, Inc.
+// Copyright 2021-2024 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.
@@ -82,76 +82,80 @@ export function makeBinaryFormatCommon() {
                     }
                     continue;
                 }
-                let target = message, repeated = field.repeated, localName = field.localName;
-                if (field.oneof) {
-                    target = target[field.oneof.localName];
-                    if (target.case != localName) {
-                        delete target.value;
-                    }
-                    target.case = localName;
-                    localName = "value";
-                }
-                switch (field.kind) {
-                    case "scalar":
-                    case "enum":
-                        const scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
-                        let read = readScalar;
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- acceptable since it's covered by tests
-                        if (field.kind == "scalar" && field.L > 0) {
-                            read = readScalarLTString;
-                        }
-                        if (repeated) {
-                            let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values
-                            if (wireType == WireType.LengthDelimited &&
-                                scalarType != ScalarType.STRING &&
-                                scalarType != ScalarType.BYTES) {
-                                let e = reader.uint32() + reader.pos;
-                                while (reader.pos < e) {
-                                    arr.push(read(reader, scalarType));
-                                }
-                            }
-                            else {
-                                arr.push(read(reader, scalarType));
-                            }
-                        }
-                        else {
-                            target[localName] = read(reader, scalarType);
-                        }
-                        break;
-                    case "message":
-                        const messageType = field.T;
-                        if (repeated) {
-                            // safe to assume presence of array, oneof cannot contain repeated values
-                            target[localName].push(readMessageField(reader, new messageType(), options, field));
-                        }
-                        else {
-                            if (target[localName] instanceof Message) {
-                                readMessageField(reader, target[localName], options, field);
-                            }
-                            else {
-                                target[localName] = readMessageField(reader, new messageType(), options, field);
-                                if (messageType.fieldWrapper &&
-                                    !field.oneof &&
-                                    !field.repeated) {
-                                    target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
-                                }
-                            }
-                        }
-                        break;
-                    case "map":
-                        let [mapKey, mapVal] = readMapEntry(field, reader, options);
-                        // safe to assume presence of map object, oneof cannot contain repeated values
-                        target[localName][mapKey] = mapVal;
-                        break;
-                }
+                readField(message, reader, field, wireType, options);
             }
             if (delimitedMessageEncoding && // eslint-disable-line @typescript-eslint/strict-boolean-expressions
                 (wireType != WireType.EndGroup || fieldNo !== lengthOrEndTagFieldNo)) {
                 throw new Error(`invalid end group tag`);
             }
         },
+        readField,
     };
 }
+function readField(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+reader, field, wireType, options) {
+    let { repeated, localName } = field;
+    if (field.oneof) {
+        target = target[field.oneof.localName];
+        if (target.case != localName) {
+            delete target.value;
+        }
+        target.case = localName;
+        localName = "value";
+    }
+    switch (field.kind) {
+        case "scalar":
+        case "enum":
+            const scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
+            let read = readScalar;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- acceptable since it's covered by tests
+            if (field.kind == "scalar" && field.L > 0) {
+                read = readScalarLTString;
+            }
+            if (repeated) {
+                let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values
+                const isPacked = wireType == WireType.LengthDelimited &&
+                    scalarType != ScalarType.STRING &&
+                    scalarType != ScalarType.BYTES;
+                if (isPacked) {
+                    let e = reader.uint32() + reader.pos;
+                    while (reader.pos < e) {
+                        arr.push(read(reader, scalarType));
+                    }
+                }
+                else {
+                    arr.push(read(reader, scalarType));
+                }
+            }
+            else {
+                target[localName] = read(reader, scalarType);
+            }
+            break;
+        case "message":
+            const messageType = field.T;
+            if (repeated) {
+                // safe to assume presence of array, oneof cannot contain repeated values
+                target[localName].push(readMessageField(reader, new messageType(), options, field));
+            }
+            else {
+                if (target[localName] instanceof Message) {
+                    readMessageField(reader, target[localName], options, field);
+                }
+                else {
+                    target[localName] = readMessageField(reader, new messageType(), options, field);
+                    if (messageType.fieldWrapper && !field.oneof && !field.repeated) {
+                        target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
+                    }
+                }
+            }
+            break;
+        case "map":
+            let [mapKey, mapVal] = readMapEntry(field, reader, options);
+            // safe to assume presence of map object, oneof cannot contain repeated values
+            target[localName][mapKey] = mapVal;
+            break;
+    }
+}
 // Read a message, avoiding MessageType.fromBinary() to re-use the
 // BinaryReadOptions and the IBinaryReader.
 function readMessageField(reader, message, options, field) {
@@ -213,7 +217,7 @@ function readMapEntry(field, reader, options) {
 }
 // Read a scalar value, but return 64 bit integral types (int64, uint64,
 // sint64, fixed64, sfixed64) as string instead of bigint.
-export function readScalarLTString(reader, type) {
+function readScalarLTString(reader, type) {
     const v = readScalar(reader, type);
     return typeof v == "bigint" ? v.toString() : v;
 }
@@ -288,20 +292,19 @@ export function writeMapEntry(writer, options, field, key, value) {
     }
     writer.join();
 }
+// Value must not be undefined
 export function writeMessageField(writer, options, field, value) {
-    if (value !== undefined) {
-        const message = wrapField(field.T, value);
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (field === null || field === void 0 ? void 0 : field.delimited)
-            writer
-                .tag(field.no, WireType.StartGroup)
-                .raw(message.toBinary(options))
-                .tag(field.no, WireType.EndGroup);
-        else
-            writer
-                .tag(field.no, WireType.LengthDelimited)
-                .bytes(message.toBinary(options));
-    }
+    const message = wrapField(field.T, value);
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (field === null || field === void 0 ? void 0 : field.delimited)
+        writer
+            .tag(field.no, WireType.StartGroup)
+            .raw(message.toBinary(options))
+            .tag(field.no, WireType.EndGroup);
+    else
+        writer
+            .tag(field.no, WireType.LengthDelimited)
+            .bytes(message.toBinary(options));
 }
 export function writeScalar(writer, type, fieldNo, value, emitIntrinsicDefault) {
     let [wireType, method, isIntrinsicDefault] = scalarTypeInfo(type, value);

package/dist/esm/private/binary-format-proto2.js

@@ -1,4 +1,4 @@
-// Copyright 2021-2023 Buf Technologies, Inc.
+// Copyright 2021-2024 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.
@@ -15,74 +15,28 @@ import { ScalarType } from "../field.js";
 import { makeBinaryFormatCommon, writeMapEntry, writeMessageField, writePacked, writeScalar, } from "./binary-format-common.js";
 /* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unnecessary-condition, @typescript-eslint/strict-boolean-expressions, no-case-declarations, prefer-const */
 export function makeBinaryFormatProto2() {
-    return Object.assign(Object.assign({}, makeBinaryFormatCommon()), { writeMessage(message, writer, options) {
+    return Object.assign(Object.assign({}, makeBinaryFormatCommon()), { writeField,
+        writeMessage(message, writer, options) {
             const type = message.getType();
             let field;
-            try {
-                for (field of type.fields.byNumber()) {
-                    let value, // this will be our field value, whether it is member of a oneof or not
-                    repeated = field.repeated, localName = field.localName;
-                    if (field.oneof) {
-                        const oneof = message[field.oneof.localName];
-                        if (oneof.case !== localName) {
-                            continue; // field is not selected, skip
-                        }
-                        value = oneof.value;
+            for (field of type.fields.byNumber()) {
+                let value, localName = field.localName;
+                if (field.oneof) {
+                    const oneof = message[field.oneof.localName];
+                    if (oneof.case !== localName) {
+                        continue; // field is not selected, skip
                     }
-                    else {
-                        value = message[localName];
-                        // In contrast to proto3, we raise an error if a non-optional (proto2 required)
-                        // field is missing a value.
-                        if (value === undefined && !field.oneof && !field.opt) {
-                            throw new Error(`cannot encode field ${type.typeName}.${field.name} to binary: required field not set`);
-                        }
-                    }
-                    switch (field.kind) {
-                        case "scalar":
-                        case "enum":
-                            let scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
-                            if (repeated) {
-                                if (field.packed) {
-                                    writePacked(writer, scalarType, field.no, value);
-                                }
-                                else {
-                                    for (const item of value) {
-                                        writeScalar(writer, scalarType, field.no, item, true);
-                                    }
-                                }
-                            }
-                            else {
-                                if (value !== undefined) {
-                                    // In contrast to proto3, we do not skip intrinsic default values.
-                                    // Explicit default values are not special cased either.
-                                    writeScalar(writer, scalarType, field.no, value, true);
-                                }
-                            }
-                            break;
-                        case "message":
-                            if (repeated) {
-                                for (const item of value) {
-                                    writeMessageField(writer, options, field, item);
-                                }
-                            }
-                            else {
-                                writeMessageField(writer, options, field, value);
-                            }
-                            break;
-                        case "map":
-                            for (const [key, val] of Object.entries(value)) {
-                                writeMapEntry(writer, options, field, key, val);
-                            }
-                            break;
+                    value = oneof.value;
+                }
+                else {
+                    value = message[localName];
+                    // In contrast to proto3, we raise an error if a non-optional (proto2 required)
+                    // field is missing a value.
+                    if (value === undefined && !field.oneof && !field.opt) {
+                        throw new Error(`cannot encode field ${type.typeName}.${field === null || field === void 0 ? void 0 : field.name} to binary: required field not set`);
                     }
                 }
-            }
-            catch (e) {
-                let m = field
-                    ? `cannot encode field ${type.typeName}.${field === null || field === void 0 ? void 0 : field.name} to binary`
-                    : `cannot encode message ${type.typeName} to binary`;
-                let r = e instanceof Error ? e.message : String(e);
-                throw new Error(m + (r.length > 0 ? `: ${r}` : ""));
+                writeField(field, value, writer, options);
             }
             if (options.writeUnknownFields) {
                 this.writeUnknownFields(message, writer);
@@ -90,3 +44,44 @@ export function makeBinaryFormatProto2() {
             return writer;
         } });
 }
+// TODO field presence: merge this function with proto3
+function writeField(field, value, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+writer, options) {
+    const repeated = field.repeated;
+    switch (field.kind) {
+        case "scalar":
+        case "enum":
+            let scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
+            if (repeated) {
+                if (field.packed) {
+                    writePacked(writer, scalarType, field.no, value);
+                }
+                else {
+                    for (const item of value) {
+                        writeScalar(writer, scalarType, field.no, item, true);
+                    }
+                }
+            }
+            else if (value !== undefined) {
+                // In contrast to proto3, we do not skip intrinsic default values.
+                // Explicit default values are not special cased either.
+                writeScalar(writer, scalarType, field.no, value, true);
+            }
+            break;
+        case "message":
+            if (repeated) {
+                for (const item of value) {
+                    writeMessageField(writer, options, field, item);
+                }
+            }
+            else if (value !== undefined) {
+                writeMessageField(writer, options, field, value);
+            }
+            break;
+        case "map":
+            for (const [key, val] of Object.entries(value)) {
+                writeMapEntry(writer, options, field, key, val);
+            }
+            break;
+    }
+}

package/dist/esm/private/binary-format-proto3.js

@@ -1,4 +1,4 @@
-// Copyright 2021-2023 Buf Technologies, Inc.
+// Copyright 2021-2024 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.
@@ -15,11 +15,11 @@ import { ScalarType } from "../field.js";
 import { makeBinaryFormatCommon, writeMapEntry, writeMessageField, writePacked, writeScalar, } from "./binary-format-common.js";
 /* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unnecessary-condition, @typescript-eslint/strict-boolean-expressions, prefer-const, no-case-declarations */
 export function makeBinaryFormatProto3() {
-    return Object.assign(Object.assign({}, makeBinaryFormatCommon()), { writeMessage(message, writer, options) {
+    return Object.assign(Object.assign({}, makeBinaryFormatCommon()), { writeField,
+        writeMessage(message, writer, options) {
             const type = message.getType();
             for (const field of type.fields.byNumber()) {
-                let value, // this will be our field value, whether it is member of a oneof or regular field
-                repeated = field.repeated, localName = field.localName;
+                let value, localName = field.localName;
                 if (field.oneof) {
                     const oneof = message[field.oneof.localName];
                     if (oneof.case !== localName) {
@@ -30,42 +30,7 @@ export function makeBinaryFormatProto3() {
                 else {
                     value = message[localName];
                 }
-                switch (field.kind) {
-                    case "scalar":
-                    case "enum":
-                        let scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
-                        if (repeated) {
-                            if (field.packed) {
-                                writePacked(writer, scalarType, field.no, value);
-                            }
-                            else {
-                                for (const item of value) {
-                                    writeScalar(writer, scalarType, field.no, item, true);
-                                }
-                            }
-                        }
-                        else {
-                            if (value !== undefined) {
-                                writeScalar(writer, scalarType, field.no, value, !!field.oneof || field.opt);
-                            }
-                        }
-                        break;
-                    case "message":
-                        if (repeated) {
-                            for (const item of value) {
-                                writeMessageField(writer, options, field, item);
-                            }
-                        }
-                        else {
-                            writeMessageField(writer, options, field, value);
-                        }
-                        break;
-                    case "map":
-                        for (const [key, val] of Object.entries(value)) {
-                            writeMapEntry(writer, options, field, key, val);
-                        }
-                        break;
-                }
+                writeField(field, value, writer, options);
             }
             if (options.writeUnknownFields) {
                 this.writeUnknownFields(message, writer);
@@ -73,3 +38,42 @@ export function makeBinaryFormatProto3() {
             return writer;
         } });
 }
+// TODO field presence: merge this function with proto2
+function writeField(field, value, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+writer, options) {
+    const repeated = field.repeated;
+    switch (field.kind) {
+        case "scalar":
+        case "enum":
+            let scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
+            if (repeated) {
+                if (field.packed) {
+                    writePacked(writer, scalarType, field.no, value);
+                }
+                else {
+                    for (const item of value) {
+                        writeScalar(writer, scalarType, field.no, item, true);
+                    }
+                }
+            }
+            else if (value !== undefined) {
+                writeScalar(writer, scalarType, field.no, value, !!field.oneof || field.opt);
+            }
+            break;
+        case "message":
+            if (repeated) {
+                for (const item of value) {
+                    writeMessageField(writer, options, field, item);
+                }
+            }
+            else if (value !== undefined) {
+                writeMessageField(writer, options, field, value);
+            }
+            break;
+        case "map":
+            for (const [key, val] of Object.entries(value)) {
+                writeMapEntry(writer, options, field, key, val);
+            }
+            break;
+    }
+}

package/dist/esm/private/enum.js

@@ -1,4 +1,4 @@
-// Copyright 2021-2023 Buf Technologies, Inc.
+// Copyright 2021-2024 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.

package/dist/esm/private/extensions.d.ts

@@ -0,0 +1,34 @@
+import type { Extension } from "../extension.js";
+import type { AnyMessage, Message } from "../message.js";
+import type { FieldInfo, OneofInfo, PartialFieldInfo } from "../field.js";
+import { WireType } from "../binary-encoding.js";
+import type { ProtoRuntime } from "./proto-runtime.js";
+import type { MessageType } from "../message-type.js";
+export type ExtensionFieldSource = extensionFieldRules<FieldInfo> | extensionFieldRules<PartialFieldInfo> | (() => extensionFieldRules<FieldInfo>) | (() => extensionFieldRules<PartialFieldInfo>);
+type extensionFieldRules<T extends FieldInfo | PartialFieldInfo> = T extends {
+    kind: "map";
+} ? never : T extends {
+    oneof: string;
+} ? never : T extends {
+    oneof: OneofInfo;
+} ? never : Omit<T, "name"> & Partial<Pick<T, "name">>;
+/**
+ * Create a new extension using the given runtime.
+ */
+export declare function makeExtension<E extends Message<E> = AnyMessage, V = unknown>(runtime: ProtoRuntime, typeName: string, extendee: MessageType<E>, field: ExtensionFieldSource): Extension<E, V>;
+/**
+ * Create a container that allows us to read extension fields into it with the
+ * same logic as regular fields.
+ */
+export declare function createExtensionContainer<E extends Message<E> = AnyMessage, V = unknown>(extension: Extension<E, V>): [Record<string, V>, () => V];
+type UnknownField = {
+    no: number;
+    wireType: WireType;
+    data: Uint8Array;
+};
+type UnknownFields = ReadonlyArray<UnknownField>;
+/**
+ * Helper to filter unknown fields, optimized based on field type.
+ */
+export declare function filterUnknownFields(unknownFields: UnknownFields, field: Pick<FieldInfo, "no" | "kind" | "repeated">): UnknownField[];
+export {};

package/dist/esm/private/extensions.js

@@ -0,0 +1,81 @@
+// Copyright 2021-2024 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 { scalarDefaultValue } from "./scalars.js";
+import { WireType } from "../binary-encoding.js";
+/**
+ * Create a new extension using the given runtime.
+ */
+export function makeExtension(runtime, typeName, extendee, field) {
+    let fi;
+    return {
+        typeName,
+        extendee,
+        get field() {
+            if (!fi) {
+                const i = (typeof field == "function" ? field() : field);
+                i.name = typeName.split(".").pop();
+                i.jsonName = `[${typeName}]`;
+                fi = runtime.util.newFieldList([i]).list()[0];
+            }
+            return fi;
+        },
+        runtime,
+    };
+}
+/**
+ * Create a container that allows us to read extension fields into it with the
+ * same logic as regular fields.
+ */
+export function createExtensionContainer(extension) {
+    const localName = extension.field.localName;
+    const container = Object.create(null);
+    container[localName] = initExtensionField(extension);
+    return [container, () => container[localName]];
+}
+function initExtensionField(ext) {
+    const field = ext.field;
+    if (field.repeated) {
+        return [];
+    }
+    if (field.default !== undefined) {
+        return field.default;
+    }
+    switch (field.kind) {
+        case "enum":
+            return field.T.values[0].no;
+        case "scalar":
+            return scalarDefaultValue(field.T, field.L);
+        case "message":
+            // eslint-disable-next-line no-case-declarations
+            const T = field.T, value = new T();
+            return T.fieldWrapper ? T.fieldWrapper.unwrapField(value) : value;
+        case "map":
+            throw "map fields are not allowed to be extensions";
+    }
+}
+/**
+ * Helper to filter unknown fields, optimized based on field type.
+ */
+export function filterUnknownFields(unknownFields, field) {
+    if (!field.repeated && (field.kind == "enum" || field.kind == "scalar")) {
+        // singular scalar fields do not merge, we pick the last
+        for (let i = unknownFields.length - 1; i >= 0; --i) {
+            if (unknownFields[i].no == field.no) {
+                return [unknownFields[i]];
+            }
+        }
+        return [];
+    }
+    return unknownFields.filter((uf) => uf.no === field.no);
+}

package/dist/esm/private/feature-set.d.ts

@@ -8,14 +8,14 @@ export declare const featureSetDefaults: FeatureSetDefaults;
  */
 export type MergedFeatureSet = FeatureSet & Required<FeatureSet>;
 /**
- * A function that resolves features for the given edition.
+ * A function that resolves features.
  *
  * If no feature set is provided, the default feature set for the edition is
  * returned. If features are provided, they are merged into the edition default
  * features.
  */
-export type FeatureResolverFn = (edition: Edition, a?: FeatureSet, b?: FeatureSet) => MergedFeatureSet;
+export type FeatureResolverFn = (a?: FeatureSet, b?: FeatureSet) => MergedFeatureSet;
 /**
  * Create an edition feature resolver with the given feature set defaults.
  */
-export declare function createFeatureResolver(compiledFeatureSetDefaults: FeatureSetDefaults): FeatureResolverFn;
+export declare function createFeatureResolver(compiledFeatureSetDefaults: FeatureSetDefaults, edition: Edition): FeatureResolverFn;