@bufbuild/protobuf 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/esm/reflect/scalar.js

@@ -12,72 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { protoInt64 } from "../proto-int64.js";
-import { getTextEncoding } from "../wire/text-encoding.js";
-/**
- * Scalar value types. This is a subset of field types declared by protobuf
- * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
- * are omitted, but the numerical values are identical.
- */
-export var ScalarType;
-(function (ScalarType) {
-    // 0 is reserved for errors.
-    // Order is weird for historical reasons.
-    ScalarType[ScalarType["DOUBLE"] = 1] = "DOUBLE";
-    ScalarType[ScalarType["FLOAT"] = 2] = "FLOAT";
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
-    // negative values are likely.
-    ScalarType[ScalarType["INT64"] = 3] = "INT64";
-    ScalarType[ScalarType["UINT64"] = 4] = "UINT64";
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
-    // negative values are likely.
-    ScalarType[ScalarType["INT32"] = 5] = "INT32";
-    ScalarType[ScalarType["FIXED64"] = 6] = "FIXED64";
-    ScalarType[ScalarType["FIXED32"] = 7] = "FIXED32";
-    ScalarType[ScalarType["BOOL"] = 8] = "BOOL";
-    ScalarType[ScalarType["STRING"] = 9] = "STRING";
-    // Tag-delimited aggregate.
-    // Group type is deprecated and not supported in proto3. However, Proto3
-    // implementations should still be able to parse the group wire format and
-    // treat group fields as unknown fields.
-    // TYPE_GROUP = 10,
-    // TYPE_MESSAGE = 11,  // Length-delimited aggregate.
-    // New in version 2.
-    ScalarType[ScalarType["BYTES"] = 12] = "BYTES";
-    ScalarType[ScalarType["UINT32"] = 13] = "UINT32";
-    // TYPE_ENUM = 14,
-    ScalarType[ScalarType["SFIXED32"] = 15] = "SFIXED32";
-    ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64";
-    ScalarType[ScalarType["SINT32"] = 17] = "SINT32";
-    ScalarType[ScalarType["SINT64"] = 18] = "SINT64";
-})(ScalarType || (ScalarType = {}));
-/**
- * JavaScript representation of fields with 64 bit integral types (int64, uint64,
- * sint64, fixed64, sfixed64).
- *
- * This is a subset of google.protobuf.FieldOptions.JSType, which defines JS_NORMAL,
- * JS_STRING, and JS_NUMBER. Protobuf-ES uses BigInt by default, but will use
- * String if `[jstype = JS_STRING]` is specified.
- *
- * ```protobuf
- * uint64 field_a = 1; // BigInt
- * uint64 field_b = 2 [jstype = JS_NORMAL]; // BigInt
- * uint64 field_b = 2 [jstype = JS_NUMBER]; // BigInt
- * uint64 field_b = 2 [jstype = JS_STRING]; // String
- * ```
- */
-export var LongType;
-(function (LongType) {
-    /**
-     * Use JavaScript BigInt.
-     */
-    LongType[LongType["BIGINT"] = 0] = "BIGINT";
-    /**
-     * Use JavaScript String.
-     *
-     * Field option `[jstype = JS_STRING]`.
-     */
-    LongType[LongType["STRING"] = 1] = "STRING";
-})(LongType || (LongType = {}));
+import { ScalarType } from "../descriptors.js";
 /**
  * Returns true if both scalar values are equal.
  */
@@ -119,27 +54,27 @@ export function scalarEquals(type, a, b) {
 /**
  * Returns the zero value for the given scalar type.
  */
-export function scalarZeroValue(type, longType) {
+export function scalarZeroValue(type, longAsString) {
     switch (type) {
+        case ScalarType.STRING:
+            return "";
         case ScalarType.BOOL:
             return false;
-        case ScalarType.UINT64:
-        case ScalarType.FIXED64:
-        case ScalarType.INT64:
-        case ScalarType.SFIXED64:
-        case ScalarType.SINT64:
-            return (longType == 0 ? protoInt64.zero : "0");
+        default:
+            // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32.
+            // We do not use individual cases to save a few bytes code size.
+            return 0;
         case ScalarType.DOUBLE:
         case ScalarType.FLOAT:
             return 0.0;
+        case ScalarType.INT64:
+        case ScalarType.UINT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.FIXED64:
+        case ScalarType.SINT64:
+            return (longAsString ? "0" : protoInt64.zero);
         case ScalarType.BYTES:
             return new Uint8Array(0);
-        case ScalarType.STRING:
-            return "";
-        default:
-            // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32.
-            // We do not use individual cases to save a few bytes code size.
-            return 0;
     }
 }
 /**
@@ -161,129 +96,3 @@ export function isScalarZeroValue(type, value) {
             return value == 0; // Loose comparison matches 0n, 0 and "0"
     }
 }
-const FLOAT32_MAX = 3.4028234663852886e38, FLOAT32_MIN = -3.4028234663852886e38, UINT32_MAX = 0xffffffff, INT32_MAX = 0x7fffffff, INT32_MIN = -0x80000000;
-// TODO this checks UTF-8 validity
-export function checkScalarValue(value, scalar) {
-    switch (scalar) {
-        case ScalarType.DOUBLE:
-            return typeof value == "number";
-        case ScalarType.FLOAT:
-            if (typeof value != "number") {
-                return false;
-            }
-            if (Number.isNaN(value) || !Number.isFinite(value)) {
-                return true;
-            }
-            if (value > FLOAT32_MAX || value < FLOAT32_MIN) {
-                return `${value.toFixed()} out of range`;
-            }
-            return true;
-        case ScalarType.INT32:
-        case ScalarType.SFIXED32:
-        case ScalarType.SINT32:
-            // signed
-            if (typeof value !== "number" || !Number.isInteger(value)) {
-                return false;
-            }
-            if (value > INT32_MAX || value < INT32_MIN) {
-                return `${value.toFixed()} out of range`;
-            }
-            return true;
-        case ScalarType.FIXED32:
-        case ScalarType.UINT32:
-            // unsigned
-            if (typeof value !== "number" || !Number.isInteger(value)) {
-                return false;
-            }
-            if (value > UINT32_MAX || value < 0) {
-                return `${value.toFixed()} out of range`;
-            }
-            return true;
-        case ScalarType.BOOL:
-            return typeof value == "boolean";
-        case ScalarType.STRING:
-            if (typeof value != "string") {
-                return false;
-            }
-            return getTextEncoding().checkUtf8(value) || "invalid UTF8";
-        case ScalarType.BYTES:
-            return value instanceof Uint8Array;
-        case ScalarType.INT64:
-        case ScalarType.SFIXED64:
-        case ScalarType.SINT64:
-            // signed
-            if (typeof value != "string" &&
-                typeof value !== "bigint" &&
-                typeof value !== "number") {
-                return false;
-            }
-            try {
-                protoInt64.parse(value);
-            }
-            catch (e) {
-                return `${value} out of range`;
-            }
-            return true;
-        case ScalarType.FIXED64:
-        case ScalarType.UINT64:
-            // unsigned
-            if (typeof value != "string" &&
-                typeof value !== "bigint" &&
-                typeof value !== "number") {
-                return false;
-            }
-            try {
-                protoInt64.uParse(value);
-            }
-            catch (e) {
-                return `${value} out of range`;
-            }
-            return true;
-    }
-}
-export function scalarTypeDescription(scalar) {
-    switch (scalar) {
-        case ScalarType.STRING:
-            return "string";
-        case ScalarType.BOOL:
-            return "boolean";
-        case ScalarType.INT64:
-        case ScalarType.SINT64:
-        case ScalarType.SFIXED64:
-            return "bigint (int64)";
-        case ScalarType.UINT64:
-        case ScalarType.FIXED64:
-            return "bigint (uint64)";
-        case ScalarType.BYTES:
-            return "Uint8Array";
-        case ScalarType.DOUBLE:
-            return "number (float64)";
-        case ScalarType.FLOAT:
-            return "number (float32)";
-        case ScalarType.FIXED32:
-        case ScalarType.UINT32:
-            return "number (uint32)";
-        case ScalarType.INT32:
-        case ScalarType.SFIXED32:
-        case ScalarType.SINT32:
-            return "number (int32)";
-    }
-}
-export function scalarTypeScriptType(scalar, long) {
-    switch (scalar) {
-        case ScalarType.STRING:
-            return "string";
-        case ScalarType.BOOL:
-            return "boolean";
-        case ScalarType.UINT64:
-        case ScalarType.SFIXED64:
-        case ScalarType.FIXED64:
-        case ScalarType.SINT64:
-        case ScalarType.INT64:
-            return long == LongType.STRING ? "string" : "bigint";
-        case ScalarType.BYTES:
-            return "Uint8Array";
-        default:
-            return "number";
-    }
-}

package/dist/esm/reflect/unsafe.d.ts

@@ -1,4 +1,4 @@
-import type { DescField, DescOneof } from "../desc-types.js";
+import type { DescField, DescOneof } from "../descriptors.js";
 export declare const unsafeLocal: unique symbol;
 /**
  * Return the selected field of a oneof group.
@@ -40,19 +40,3 @@ export declare function unsafeSet(target: Record<string, unknown>, field: DescFi
  */
 export declare function unsafeClear(target: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
 field: DescField): void;
-/**
- * Add an item to a list field.
- *
- * @private
- */
-export declare function unsafeAddListItem(target: Record<string, unknown>, field: DescField & {
-    fieldKind: "list";
-}, value: unknown): void;
-/**
- * Set a map entry.
- *
- * @private
- */
-export declare function unsafeSetMapEntry(target: Record<string, unknown>, field: DescField & {
-    fieldKind: "map";
-}, key: string | number, value: unknown): void;

package/dist/esm/reflect/unsafe.js

@@ -132,24 +132,8 @@ field) {
                 target[name] = field.enum.values[0].number;
                 break;
             case "scalar":
-                target[name] = scalarZeroValue(field.scalar, field.longType);
+                target[name] = scalarZeroValue(field.scalar, field.longAsString);
                 break;
         }
     }
 }
-/**
- * Add an item to a list field.
- *
- * @private
- */
-export function unsafeAddListItem(target, field, value) {
-    target[field.localName].push(value);
-}
-/**
- * Set a map entry.
- *
- * @private
- */
-export function unsafeSetMapEntry(target, field, key, value) {
-    target[field.localName][key] = value;
-}

package/dist/esm/{reflect/registry.d.ts → registry.d.ts}

@@ -1,5 +1,5 @@
-import type { FileDescriptorProto, FileDescriptorSet } from "../wkt/gen/google/protobuf/descriptor_pb.js";
-import type { DescEnum, DescExtension, DescFile, DescMessage, DescService, SupportedEdition } from "../desc-types.js";
+import type { FileDescriptorProto, FileDescriptorSet } from "./wkt/gen/google/protobuf/descriptor_pb.js";
+import { type DescEnum, type DescExtension, type DescFile, type DescMessage, type DescService, type SupportedEdition } from "./descriptors.js";
 /**
  * A set of descriptors for messages, enumerations, extensions,
  * and services.

package/dist/esm/{reflect/registry.js → registry.js}

@@ -11,12 +11,11 @@
 // 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 { assert } from "./assert.js";
-import { parseTextFormatEnumValue, parseTextFormatScalarValue, } from "../wire/text-format.js";
-import { LongType, ScalarType } from "./scalar.js";
-import { nestedTypes } from "./nested-types.js";
-import { unsafeIsSetExplicit } from "./unsafe.js";
-import { protoCamelCase, safeObjectProperty } from "./names.js";
+import { ScalarType, } from "./descriptors.js";
+import { parseTextFormatEnumValue, parseTextFormatScalarValue, } from "./wire/text-format.js";
+import { nestedTypes } from "./reflect/nested-types.js";
+import { unsafeIsSetExplicit } from "./reflect/unsafe.js";
+import { protoCamelCase, safeObjectProperty } from "./reflect/names.js";
 /**
  * Create a registry from the given inputs.
  *
@@ -221,7 +220,7 @@ const DELIMITED = 2;
 const OPEN = 1;
 // prettier-ignore
 // bootstrap-inject defaults: EDITION_PROTO2 to EDITION_2023: export const minimumEdition: SupportedEdition = $minimumEdition, maximumEdition: SupportedEdition = $maximumEdition;
-// generated from protoc v27.0-rc2
+// generated from protoc v27.0
 export const minimumEdition = 998, maximumEdition = 1000;
 const featureDefaults = {
     // EDITION_PROTO2
@@ -455,6 +454,7 @@ function addService(proto, file, reg) {
         name: proto.name,
         typeName: makeTypeName(proto, undefined, file),
         methods: [],
+        method: {},
         toString() {
             return `service ${this.typeName}`;
         },
@@ -462,7 +462,9 @@ function addService(proto, file, reg) {
     file.services.push(desc);
     reg.add(desc);
     for (const methodProto of proto.method) {
-        desc.methods.push(newMethod(methodProto, desc, reg));
+        const method = newMethod(methodProto, desc, reg);
+        desc.methods.push(method);
+        desc.method[method.localName] = method;
     }
 }
 /**
@@ -541,7 +543,7 @@ function newField(proto, parentOrFile, reg, oneof, mapEntries) {
         mapKey: undefined,
         delimitedEncoding: undefined,
         packed: undefined,
-        longType: undefined,
+        longAsString: false,
         getDefaultValue: undefined,
     };
     if (isExtension) {
@@ -583,21 +585,13 @@ function newField(proto, parentOrFile, reg, oneof, mapEntries) {
         if (mapEntry) {
             // map field
             field.fieldKind = "map";
-            const keyField = mapEntry.fields.find((f) => f.number === 1);
-            assert(keyField);
-            assert(keyField.fieldKind == "scalar");
-            assert(keyField.scalar != ScalarType.BYTES &&
-                keyField.scalar != ScalarType.FLOAT &&
-                keyField.scalar != ScalarType.DOUBLE);
-            const valueField = mapEntry.fields.find((f) => f.number === 2);
-            assert(valueField);
-            assert(valueField.fieldKind != "list" && valueField.fieldKind != "map");
-            field.mapKey = keyField.scalar;
-            field.mapKind = valueField.fieldKind;
-            field.message = valueField.message;
+            const { key, value } = findMapEntryFields(mapEntry);
+            field.mapKey = key.scalar;
+            field.mapKind = value.fieldKind;
+            field.message = value.message;
             field.delimitedEncoding = false; // map fields are always LENGTH_PREFIXED
-            field.enum = valueField.enum;
-            field.scalar = valueField.scalar;
+            field.enum = value.enum;
+            field.scalar = value.scalar;
             return field;
         }
         // list field
@@ -618,8 +612,7 @@ function newField(proto, parentOrFile, reg, oneof, mapEntries) {
             default:
                 field.listKind = "scalar";
                 field.scalar = type;
-                field.longType =
-                    jstype == JS_STRING ? LongType.STRING : LongType.BIGINT;
+                field.longAsString = jstype == JS_STRING;
                 break;
         }
         field.packed = isPackedField(proto, parentOrFile);
@@ -650,7 +643,7 @@ function newField(proto, parentOrFile, reg, oneof, mapEntries) {
         default: {
             field.fieldKind = "scalar";
             field.scalar = type;
-            field.longType = jstype == JS_STRING ? LongType.STRING : LongType.BIGINT;
+            field.longAsString = jstype == JS_STRING;
             field.getDefaultValue = () => {
                 return unsafeIsSetExplicit(proto, "defaultValue")
                     ? parseTextFormatScalarValue(type, proto.defaultValue)
@@ -825,6 +818,22 @@ function isPackedField(proto, parent) {
             parent,
         }));
 }
+/**
+ * Find the key and value fields of a synthetic map entry message.
+ */
+function findMapEntryFields(mapEntry) {
+    const key = mapEntry.fields.find((f) => f.number === 1);
+    const value = mapEntry.fields.find((f) => f.number === 2);
+    assert(key &&
+        key.fieldKind == "scalar" &&
+        key.scalar != ScalarType.BYTES &&
+        key.scalar != ScalarType.FLOAT &&
+        key.scalar != ScalarType.DOUBLE &&
+        value &&
+        value.fieldKind != "list" &&
+        value.fieldKind != "map");
+    return { key, value };
+}
 /**
  * Enumerations can be open or closed.
  * See https://protobuf.dev/programming-guides/enum/
@@ -872,3 +881,12 @@ function resolveFeature(name, ref) {
     }
     return resolveFeature(name, ref.parent);
 }
+/**
+ * Assert that condition is truthy or throw error (with message)
+ */
+function assert(condition, msg) {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- we want the implicit conversion to boolean
+    if (!condition) {
+        throw new Error(msg);
+    }
+}

package/dist/esm/to-binary.d.ts

@@ -1,6 +1,6 @@
 import type { MessageShape } from "./types.js";
 import { BinaryWriter } from "./wire/binary-encoding.js";
-import type { DescField, DescMessage } from "./desc-types.js";
+import { type DescField, type DescMessage } from "./descriptors.js";
 import type { ReflectMessage } from "./reflect/index.js";
 /**
  * Options for serializing to binary data.

package/dist/esm/to-binary.js

@@ -13,7 +13,7 @@
 // limitations under the License.
 import { reflect } from "./reflect/reflect.js";
 import { BinaryWriter, WireType } from "./wire/binary-encoding.js";
-import { ScalarType } from "./reflect/scalar.js";
+import { ScalarType } from "./descriptors.js";
 // bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number;
 const LEGACY_REQUIRED = 3;
 // Default options for serializing binary data.

package/dist/esm/to-json.d.ts

@@ -1,17 +1,18 @@
-import type { DescMessage } from "./desc-types.js";
+import { type DescMessage } from "./descriptors.js";
 import type { JsonValue } from "./json-value.js";
-import type { Registry } from "./reflect/registry.js";
+import type { Registry } from "./registry.js";
 import type { MessageShape } from "./types.js";
 /**
  * Options for serializing to JSON.
  */
 export interface JsonWriteOptions {
     /**
-     * Emit fields with default values: Fields with default values are omitted
-     * by default in proto3 JSON output. This option overrides this behavior
-     * and outputs fields with their default values.
+     * By default, fields with implicit presence are not serialized if they are
+     * unset. For example, an empty list field or a proto3 int32 field with 0 is
+     * not serialized. With this option enabled, such fields are included in the
+     * output.
      */
-    emitDefaultValues: boolean;
+    alwaysEmitImplicit: boolean;
     /**
      * Emit enum values as integers instead of strings: The name of an enum
      * value is used by default in JSON output. An option may be provided to