@bufbuild/protobuf 1.6.0 → 1.7.1

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

@@ -1,21 +1,19 @@
 import { Edition, FeatureSet, FeatureSetDefaults } from "../google/protobuf/descriptor_pb.js";
-/**
- * Static edition feature defaults supported by @bufbuild/protobuf.
- */
-export declare const featureSetDefaults: FeatureSetDefaults;
+import type { BinaryReadOptions, BinaryWriteOptions } from "../binary-format.js";
 /**
  * A merged google.protobuf.FeaturesSet, with all fields guaranteed to be set.
  */
 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.
+ * Create an edition feature resolver with the given feature set defaults, or
+ * the feature set defaults supported by @bufbuild/protobuf.
  */
-export declare function createFeatureResolver(compiledFeatureSetDefaults: FeatureSetDefaults): FeatureResolverFn;
+export declare function createFeatureResolver(edition: Edition, compiledFeatureSetDefaults?: FeatureSetDefaults, serializationOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>): FeatureResolverFn;

package/dist/esm/private/feature-set.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.
@@ -14,56 +14,55 @@
 import { Edition, FeatureSet, FeatureSetDefaults, } from "../google/protobuf/descriptor_pb.js";
 import { protoBase64 } from "../proto-base64.js";
 /**
- * Static edition feature defaults supported by @bufbuild/protobuf.
+ * Return the edition feature defaults supported by @bufbuild/protobuf.
  */
-export const featureSetDefaults = FeatureSetDefaults.fromBinary(protoBase64.dec(
-/*upstream-inject-feature-defaults-start*/ "ChESDAgBEAIYAiABKAEwAhjmBwoREgwIAhABGAEgAigBMAEY5wcKERIMCAEQARgBIAIoATABGOgHIOYHKOgH" /*upstream-inject-feature-defaults-end*/));
+function getFeatureSetDefaults(options) {
+    return FeatureSetDefaults.fromBinary(protoBase64.dec(
+    /*upstream-inject-feature-defaults-start*/ "ChESDAgBEAIYAiABKAEwAhjmBwoREgwIAhABGAEgAigBMAEY5wcKERIMCAEQARgBIAIoATABGOgHIOYHKOgH" /*upstream-inject-feature-defaults-end*/), options);
+}
 /**
- * Create an edition feature resolver with the given feature set defaults.
+ * Create an edition feature resolver with the given feature set defaults, or
+ * the feature set defaults supported by @bufbuild/protobuf.
  */
-export function createFeatureResolver(compiledFeatureSetDefaults) {
-    const min = compiledFeatureSetDefaults.minimumEdition;
-    const max = compiledFeatureSetDefaults.maximumEdition;
+export function createFeatureResolver(edition, compiledFeatureSetDefaults, serializationOptions) {
+    var _a, _b;
+    const fds = compiledFeatureSetDefaults !== null && compiledFeatureSetDefaults !== void 0 ? compiledFeatureSetDefaults : getFeatureSetDefaults(serializationOptions);
+    const min = fds.minimumEdition;
+    const max = fds.maximumEdition;
     if (min === undefined ||
         max === undefined ||
-        compiledFeatureSetDefaults.defaults.some((d) => d.edition === undefined)) {
+        fds.defaults.some((d) => d.edition === undefined)) {
         throw new Error("Invalid FeatureSetDefaults");
     }
-    const defaultsBinByEdition = new Map();
-    return (edition, ...rest) => {
-        var _a, _b;
-        let defaultsBin = defaultsBinByEdition.get(edition);
-        if (defaultsBin === undefined) {
-            if (edition < min) {
-                throw new Error(`Edition ${Edition[edition]} is earlier than the minimum supported edition ${Edition[min]}`);
-            }
-            if (max < edition) {
-                throw new Error(`Edition ${Edition[edition]} is later than the maximum supported edition ${Edition[max]}`);
-            }
-            let highestMatch = undefined;
-            for (const c of compiledFeatureSetDefaults.defaults) {
-                const e = (_a = c.edition) !== null && _a !== void 0 ? _a : 0;
-                if (e > edition) {
-                    continue;
-                }
-                if (highestMatch !== undefined && highestMatch.e > e) {
-                    continue;
-                }
-                highestMatch = {
-                    e,
-                    f: (_b = c.features) !== null && _b !== void 0 ? _b : new FeatureSet(),
-                };
-            }
-            if (highestMatch === undefined) {
-                throw new Error(`No valid default found for edition ${Edition[edition]}`);
-            }
-            defaultsBin = highestMatch.f.toBinary();
-            defaultsBinByEdition.set(edition, defaultsBin);
+    if (edition < min) {
+        throw new Error(`Edition ${Edition[edition]} is earlier than the minimum supported edition ${Edition[min]}`);
+    }
+    if (max < edition) {
+        throw new Error(`Edition ${Edition[edition]} is later than the maximum supported edition ${Edition[max]}`);
+    }
+    let highestMatch = undefined;
+    for (const c of fds.defaults) {
+        const e = (_a = c.edition) !== null && _a !== void 0 ? _a : 0;
+        if (e > edition) {
+            continue;
+        }
+        if (highestMatch !== undefined && highestMatch.e > e) {
+            continue;
         }
-        const f = FeatureSet.fromBinary(defaultsBin);
+        highestMatch = {
+            e,
+            f: (_b = c.features) !== null && _b !== void 0 ? _b : new FeatureSet(),
+        };
+    }
+    if (highestMatch === undefined) {
+        throw new Error(`No valid default found for edition ${Edition[edition]}`);
+    }
+    const featureSetBin = highestMatch.f.toBinary(serializationOptions);
+    return (...rest) => {
+        const f = FeatureSet.fromBinary(featureSetBin, serializationOptions);
         for (const c of rest) {
             if (c !== undefined) {
-                f.fromBinary(c.toBinary());
+                f.fromBinary(c.toBinary(serializationOptions), serializationOptions);
             }
         }
         if (!validateMergedFeatures(f)) {

package/dist/esm/private/field-list.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/field-wrapper.d.ts

@@ -1,6 +1,6 @@
 import { Message } from "../message.js";
 import type { MessageType } from "../message-type.js";
-import type { DescField } from "../descriptor-set.js";
+import type { DescExtension, DescField } from "../descriptor-set.js";
 import { ScalarType } from "../field.js";
 /**
  * A field wrapper unwraps a message to a primitive value that is more
@@ -22,4 +22,4 @@ export declare function wrapField<T extends Message<T>>(type: MessageType<T>, va
  * If the given field uses one of the well-known wrapper types, return
  * the primitive type it wraps.
  */
-export declare function getUnwrappedFieldType(field: DescField): ScalarType | undefined;
+export declare function getUnwrappedFieldType(field: DescField | DescExtension): ScalarType | undefined;

package/dist/esm/private/field-wrapper.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/field.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/json-format-common.d.ts

@@ -3,7 +3,7 @@ import type { FieldInfo } from "../field.js";
 import { ScalarType } from "../field.js";
 import type { EnumType } from "../enum.js";
 type JsonFormatWriteFieldFn = (field: FieldInfo, value: any, options: JsonWriteOptions) => JsonValue | undefined;
-export declare function makeJsonFormatCommon(makeWriteField: (writeEnumFn: typeof writeEnum, writeScalarFn: typeof writeScalar) => JsonFormatWriteFieldFn): JsonFormat;
-declare function writeEnum(type: EnumType, value: number | undefined, emitIntrinsicDefault: boolean, enumAsInteger: boolean): JsonValue | undefined;
-declare function writeScalar(type: ScalarType, value: any, emitIntrinsicDefault: boolean): JsonValue | undefined;
+export declare function makeJsonFormatCommon(nullAsZeroValue: boolean, makeWriteField: (writeEnumFn: typeof writeEnum, writeScalarFn: typeof writeScalar) => JsonFormatWriteFieldFn): JsonFormat;
+declare function writeEnum(type: EnumType, value: number | undefined, emitZeroValue: boolean, enumAsInteger: boolean): JsonValue | undefined;
+declare function writeScalar(type: ScalarType, value: any, emitZeroValue: boolean): JsonValue | undefined;
 export {};