@bufbuild/protobuf 1.3.0 → 1.3.2

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

@@ -0,0 +1,13 @@
+import type { IBinaryWriter } from "../binary-encoding.js";
+import type { BinaryWriteOptions } from "../binary-format.js";
+import type { BinaryFormat } from "../binary-format.js";
+import { ScalarType } from "../field.js";
+import type { FieldInfo } from "../field.js";
+import type { MessageType } from "../message-type.js";
+export declare function makeBinaryFormatCommon(): Omit<BinaryFormat, "writeMessage">;
+export declare function writeMapEntry(writer: IBinaryWriter, options: BinaryWriteOptions, field: FieldInfo & {
+    kind: "map";
+}, key: any, value: any): void;
+export declare function writeMessageField(writer: IBinaryWriter, options: BinaryWriteOptions, type: MessageType, fieldNo: number, value: any): void;
+export declare function writeScalar(writer: IBinaryWriter, type: ScalarType, fieldNo: number, value: any, emitIntrinsicDefault: boolean): void;
+export declare function writePacked(writer: IBinaryWriter, type: ScalarType, fieldNo: number, value: any[]): void;

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

@@ -0,0 +1,2 @@
+import type { BinaryFormat } from "../binary-format.js";
+export declare function makeBinaryFormatProto2(): BinaryFormat;

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

@@ -0,0 +1,2 @@
+import type { BinaryFormat } from "../binary-format.js";
+export declare function makeBinaryFormatProto3(): BinaryFormat;

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

@@ -0,0 +1,27 @@
+import type { EnumType, EnumValueInfo } from "../enum.js";
+/**
+ * Represents a generated enum.
+ */
+export interface EnumObject {
+    [key: number]: string;
+    [k: string]: number | string;
+}
+/**
+ * Get reflection information from a generated enum.
+ * If this function is called on something other than a generated
+ * enum, it raises an error.
+ */
+export declare function getEnumType(enumObject: EnumObject): EnumType;
+/**
+ * Sets reflection information on a generated enum.
+ */
+export declare function setEnumType(enumObject: EnumObject, typeName: string, values: Omit<EnumValueInfo, "localName">[], opt?: {}): void;
+/**
+ * Create a new EnumType with the given values.
+ */
+export declare function makeEnumType(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], _opt?: {}): EnumType;
+/**
+ * Create a new enum object with the given values.
+ * Sets reflection information.
+ */
+export declare function makeEnum(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], opt?: {}): EnumObject;

package/dist/esm/private/field-list.d.ts

@@ -0,0 +1,18 @@
+import type { FieldInfo, OneofInfo, PartialFieldInfo } from "../field.js";
+import type { FieldList } from "../field-list.js";
+export type FieldListSource = readonly PartialFieldInfo[] | readonly FieldInfo[] | (() => readonly PartialFieldInfo[]) | (() => readonly FieldInfo[]);
+export declare class InternalFieldList implements FieldList {
+    private readonly _fields;
+    private readonly _normalizer;
+    private all?;
+    private numbersAsc?;
+    private jsonNames?;
+    private numbers?;
+    private members?;
+    constructor(fields: FieldListSource, normalizer: (p: FieldListSource) => FieldInfo[]);
+    findJsonName(jsonName: string): FieldInfo | undefined;
+    find(fieldNo: number): FieldInfo | undefined;
+    list(): readonly FieldInfo[];
+    byNumber(): readonly FieldInfo[];
+    byMember(): readonly (FieldInfo | OneofInfo)[];
+}

package/dist/esm/private/field-wrapper.d.ts

@@ -0,0 +1,25 @@
+import { Message } from "../message.js";
+import type { MessageType } from "../message-type.js";
+import type { DescField } from "../descriptor-set.js";
+import { ScalarType } from "../field.js";
+/**
+ * A field wrapper unwraps a message to a primitive value that is more
+ * ergonomic for use as a message field.
+ *
+ * Note that this feature exists for google/protobuf/wrappers.proto
+ * and cannot be used to arbitrarily modify types in generated code.
+ */
+export interface FieldWrapper<T extends Message<T> = any, U = any> {
+    wrapField(value: U): T;
+    unwrapField(value: T): U;
+}
+/**
+ * Wrap a primitive message field value in its corresponding wrapper
+ * message. This function is idempotent.
+ */
+export declare function wrapField<T extends Message<T>>(type: MessageType<T>, value: any): T;
+/**
+ * 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;

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

@@ -0,0 +1,15 @@
+import type { FieldInfo, OneofInfo } from "../field.js";
+export declare class InternalOneofInfo implements OneofInfo {
+    readonly kind = "oneof";
+    readonly name: string;
+    readonly localName: string;
+    readonly repeated = false;
+    readonly packed = false;
+    readonly opt = false;
+    readonly default: undefined;
+    readonly fields: FieldInfo[];
+    private _lookup?;
+    constructor(name: string);
+    addField(field: FieldInfo): void;
+    findField(localName: string): FieldInfo | undefined;
+}

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

@@ -0,0 +1,9 @@
+import type { JsonFormat, JsonValue, JsonWriteOptions } from "../json-format.js";
+import { ScalarType } from "../field.js";
+import type { FieldInfo } 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 {};

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

@@ -256,7 +256,7 @@ function debugJsonValue(json) {
         case "string":
             return json.length > 100 ? "string" : `"${json.split('"').join('\\"')}"`;
         default:
-            return json.toString();
+            return String(json);
     }
 }
 // May throw an error. If the error message is non-blank, it should be shown.
@@ -386,6 +386,7 @@ function readEnum(type, json, ignoreUnknownFields) {
             break;
         case "string":
             const value = type.findName(json);
+            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
             if (value || ignoreUnknownFields) {
                 return value === null || value === void 0 ? void 0 : value.no;
             }

package/dist/esm/private/json-format-proto2.d.ts

@@ -0,0 +1,2 @@
+import type { JsonFormat } from "../json-format.js";
+export declare function makeJsonFormatProto2(): JsonFormat;

package/dist/esm/private/json-format-proto3.d.ts

@@ -0,0 +1,2 @@
+import type { JsonFormat } from "../json-format.js";
+export declare function makeJsonFormatProto3(): JsonFormat;

package/dist/esm/private/message-type.d.ts

@@ -0,0 +1,18 @@
+import { Message } from "../message.js";
+import type { AnyMessage } from "../message.js";
+import type { FieldListSource } from "./field-list.js";
+import type { MessageType } from "../message-type.js";
+import type { ProtoRuntime } from "./proto-runtime.js";
+/**
+ * Create a new message type using the given runtime.
+ */
+export declare function makeMessageType<T extends Message<T> = AnyMessage>(runtime: ProtoRuntime, typeName: string, fields: FieldListSource, opt?: {
+    /**
+     * localName is the "name" property of the constructed function.
+     * It is useful in stack traces, debuggers and test frameworks,
+     * but has no other implications.
+     *
+     * If omitted, the last part of the typeName is used.
+     */
+    localName?: string;
+}): MessageType<T>;

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

@@ -0,0 +1,43 @@
+import type { DescEnum, DescEnumValue, DescField, DescMessage, DescService } from "../descriptor-set.js";
+import type { DescMethod, DescOneof } from "../descriptor-set.js";
+/**
+ * Returns the name of a protobuf element in generated code.
+ *
+ * Field names - including oneofs - are converted to lowerCamelCase. For
+ * messages, enumerations and services, the package name is stripped from
+ * the type name. For nested messages and enumerations, the names are joined
+ * with an underscore. For methods, the first character is made lowercase.
+ */
+export declare function localName(desc: DescEnum | DescEnumValue | DescMessage | DescOneof | DescField | DescService | DescMethod): string;
+/**
+ * Returns the name of a field in generated code.
+ */
+export declare function localFieldName(protoName: string, inOneof: boolean): string;
+/**
+ * Returns the name of a oneof group in generated code.
+ */
+export declare function localOneofName(protoName: string): string;
+/**
+ * Returns the JSON name for a protobuf field, exactly like protoc does.
+ */
+export declare const fieldJsonName: typeof protoCamelCase;
+/**
+ * Finds a prefix shared by enum values, for example `MY_ENUM_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+export declare function findEnumSharedPrefix(enumName: string, valueNames: string[]): string | undefined;
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
+declare function protoCamelCase(snakeCase: string): string;
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+export declare const safeObjectProperty: (name: string) => string;
+/**
+ * Names that can be used for identifiers or class properties
+ */
+export declare const safeIdentifier: (name: string) => string;
+export {};

package/dist/esm/private/options-map.d.ts

@@ -0,0 +1,7 @@
+import type { JsonValue } from "../json-format";
+/**
+ *
+ */
+export type OptionsMap = {
+    readonly [extensionName: string]: JsonValue;
+};

package/dist/esm/private/proto-runtime.d.ts

@@ -0,0 +1,47 @@
+import type { JsonFormat } from "../json-format.js";
+import type { BinaryFormat } from "../binary-format.js";
+import type { AnyMessage } from "../message.js";
+import type { Message } from "../message.js";
+import type { EnumType, EnumValueInfo } from "../enum.js";
+import type { MessageType } from "../message-type.js";
+import type { FieldListSource } from "./field-list.js";
+import type { EnumObject } from "./enum.js";
+import type { Util } from "./util.js";
+/**
+ * A facade that provides serialization and other internal functionality.
+ */
+export interface ProtoRuntime {
+    readonly syntax: string;
+    readonly json: JsonFormat;
+    readonly bin: BinaryFormat;
+    readonly util: Util;
+    /**
+     * Create a message type at runtime, without generating code.
+     */
+    makeMessageType<T extends Message<T> = AnyMessage>(typeName: string, fields: FieldListSource, opt?: {
+        localName?: string;
+    }): MessageType<T>;
+    /**
+     * Create an enum object at runtime, without generating code.
+     *
+     * The object conforms to TypeScript enums, and comes with
+     * mapping from name to value, and from value to name.
+     *
+     * The type name and other reflection information is accessible
+     * via getEnumType().
+     */
+    makeEnum(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], opt?: {}): EnumObject;
+    /**
+     * Create an enum type at runtime, without generating code.
+     * Note that this only creates the reflection information, not an
+     * actual enum object.
+     */
+    makeEnumType(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], opt?: {}): EnumType;
+    /**
+     * Get reflection information - the EnumType - from an enum object.
+     * If this function is called on something other than a generated
+     * enum, or an enum constructed with makeEnum(), it raises an error.
+     */
+    getEnumType(enumObject: EnumObject): EnumType;
+}
+export declare function makeProtoRuntime(syntax: string, json: JsonFormat, bin: BinaryFormat, util: Util): ProtoRuntime;

package/dist/esm/private/reify-wkt.d.ts

@@ -0,0 +1,100 @@
+import type { DescField, DescMessage, DescOneof } from "../descriptor-set.js";
+type DescWkt = {
+    typeName: "google.protobuf.Any";
+    typeUrl: DescField;
+    value: DescField;
+} | {
+    typeName: "google.protobuf.Timestamp";
+    seconds: DescField;
+    nanos: DescField;
+} | {
+    typeName: "google.protobuf.Duration";
+    seconds: DescField;
+    nanos: DescField;
+} | {
+    typeName: "google.protobuf.Struct";
+    fields: DescField & {
+        fieldKind: "map";
+    };
+} | {
+    typeName: "google.protobuf.Value";
+    kind: DescOneof;
+    nullValue: DescField & {
+        fieldKind: "enum";
+    };
+    numberValue: DescField;
+    stringValue: DescField;
+    boolValue: DescField;
+    structValue: DescField & {
+        fieldKind: "message";
+    };
+    listValue: DescField & {
+        fieldKind: "message";
+    };
+} | {
+    typeName: "google.protobuf.ListValue";
+    values: DescField & {
+        fieldKind: "message";
+    };
+} | {
+    typeName: "google.protobuf.FieldMask";
+    paths: DescField;
+} | {
+    typeName: "google.protobuf.DoubleValue";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.FloatValue";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.Int64Value";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.UInt64Value";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.Int32Value";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.UInt32Value";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.BoolValue";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.StringValue";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.BytesValue";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+};
+/**
+ * Reifies a given DescMessage into a more concrete object representing its
+ * respective well-known type.  The returned object will contain properties
+ * representing the WKT's defined fields.
+ *
+ * Useful during code generation when immediate access to a particular field
+ * is needed without having to search the object's typename and DescField list.
+ *
+ * Returns undefined if the WKT cannot be completely constructed via the
+ * DescMessage.
+ */
+export declare function reifyWkt(message: DescMessage): DescWkt | undefined;
+export {};

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

@@ -0,0 +1,27 @@
+import { ScalarType } from "../field.js";
+import type { IBinaryWriter } from "../binary-encoding.js";
+import { WireType } from "../binary-encoding.js";
+/**
+ * Returns true if both scalar values are equal.
+ */
+export declare function scalarEquals(type: ScalarType, a: string | boolean | number | bigint | Uint8Array | undefined, b: string | boolean | number | bigint | Uint8Array | undefined): boolean;
+/**
+ * Returns the default value for the given scalar type, following
+ * proto3 semantics.
+ */
+export declare function scalarDefaultValue(type: ScalarType): any;
+/**
+ * Get information for writing a scalar value.
+ *
+ * Returns tuple:
+ * [0]: appropriate WireType
+ * [1]: name of the appropriate method of IBinaryWriter
+ * [2]: whether the given value is a default value for proto3 semantics
+ *
+ * If argument `value` is omitted, [2] is always false.
+ */
+export declare function scalarTypeInfo(type: ScalarType, value?: any): [
+    WireType,
+    Exclude<keyof IBinaryWriter, "tag" | "raw" | "fork" | "join" | "finish">,
+    boolean
+];

package/dist/esm/private/util-common.d.ts

@@ -0,0 +1,2 @@
+import type { Util } from "./util.js";
+export declare function makeUtilCommon(): Omit<Util, "newFieldList" | "initFields">;

package/dist/esm/private/util-common.js

@@ -42,17 +42,35 @@ export function makeUtilCommon() {
                             !(val instanceof sourceField.T)) {
                             val = new sourceField.T(val);
                         }
+                        else if (sourceField &&
+                            sourceField.kind === "scalar" &&
+                            sourceField.T === ScalarType.BYTES) {
+                            val = toU8Arr(val);
+                        }
                         t[localName] = { case: sk, value: val };
                         break;
                     case "scalar":
                     case "enum":
-                        t[localName] = s[localName];
+                        let copy = s[localName];
+                        if (member.T === ScalarType.BYTES) {
+                            copy = member.repeated
+                                ? copy.map(toU8Arr)
+                                : toU8Arr(copy);
+                        }
+                        t[localName] = copy;
                         break;
                     case "map":
                         switch (member.V.kind) {
                             case "scalar":
                             case "enum":
-                                Object.assign(t[localName], s[localName]);
+                                if (member.V.T === ScalarType.BYTES) {
+                                    for (const [k, v] of Object.entries(s[localName])) {
+                                        t[localName][k] = toU8Arr(v);
+                                    }
+                                }
+                                else {
+                                    Object.assign(t[localName], s[localName]);
+                                }
                                 break;
                             case "message":
                                 const messageType = member.V.T;
@@ -76,7 +94,14 @@ export function makeUtilCommon() {
                         else if (s[localName] !== undefined) {
                             const val = s[localName];
                             if (mt.fieldWrapper) {
-                                t[localName] = val;
+                                if (
+                                // We can't use BytesValue.typeName as that will create a circular import
+                                mt.typeName === "google.protobuf.BytesValue") {
+                                    t[localName] = toU8Arr(val);
+                                }
+                                else {
+                                    t[localName] = val;
+                                }
                             }
                             else {
                                 t[localName] = val instanceof mt ? val : new mt(val);
@@ -158,22 +183,22 @@ export function makeUtilCommon() {
                 const source = message[member.localName];
                 let copy;
                 if (member.repeated) {
-                    copy = source.map((e) => cloneSingularField(member, e));
+                    copy = source.map(cloneSingularField);
                 }
                 else if (member.kind == "map") {
                     copy = any[member.localName];
                     for (const [key, v] of Object.entries(source)) {
-                        copy[key] = cloneSingularField(member.V, v);
+                        copy[key] = cloneSingularField(v);
                     }
                 }
                 else if (member.kind == "oneof") {
                     const f = member.findField(source.case);
                     copy = f
-                        ? { case: source.case, value: cloneSingularField(f, source.value) }
+                        ? { case: source.case, value: cloneSingularField(source.value) }
                         : { case: undefined };
                 }
                 else {
-                    copy = cloneSingularField(member, source);
+                    copy = cloneSingularField(source);
                 }
                 any[member.localName] = copy;
             }
@@ -182,7 +207,7 @@ export function makeUtilCommon() {
     };
 }
 // clone a single field value - i.e. the element type of repeated fields, the value type of maps
-function cloneSingularField(field, value) {
+function cloneSingularField(value) {
     if (value === undefined) {
         return value;
     }
@@ -196,3 +221,7 @@ function cloneSingularField(field, value) {
     }
     return value;
 }
+// converts any ArrayLike<number> to Uint8Array if necessary.
+function toU8Arr(input) {
+    return input instanceof Uint8Array ? input : new Uint8Array(input);
+}

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

@@ -0,0 +1,38 @@
+import type { FieldListSource } from "./field-list.js";
+import type { FieldList } from "../field-list.js";
+import type { EnumObject } from "./enum.js";
+import type { Message, PartialMessage, PlainMessage } from "../message.js";
+import type { MessageType } from "../message-type.js";
+import type { EnumValueInfo } from "../enum.js";
+/**
+ * Provides utilities used by generated code.
+ * All methods are internal and are not safe to use, they may break with a
+ * future release.
+ */
+export interface Util {
+    /**
+     * Create a field list
+     */
+    newFieldList(fields: FieldListSource): FieldList;
+    /**
+     * Sets reflection information on a generated enum.
+     */
+    setEnumType(enumObject: EnumObject, typeName: string, values: Omit<EnumValueInfo, "localName">[], opt?: {}): void;
+    /**
+     * Set default field values on the target message.
+     */
+    initFields(target: Message): void;
+    /**
+     * Set specified field values on the target message, recursively.
+     */
+    initPartial<T extends Message<T>>(source: PartialMessage<T> | undefined, target: T): void;
+    /**
+     * Compares two messages of the same type recursively.
+     * Will also return true if both messages are `undefined` or `null`.
+     */
+    equals<T extends Message<T>>(type: MessageType<T>, a: T | PlainMessage<T> | undefined | null, b: T | PlainMessage<T> | undefined | null): boolean;
+    /**
+     * Create a deep copy.
+     */
+    clone<T extends Message<T>>(message: T): T;
+}

package/dist/esm/proto-base64.d.ts

@@ -0,0 +1,18 @@
+export declare const protoBase64: {
+    /**
+     * Decodes a base64 string to a byte array.
+     *
+     * - ignores white-space, including line breaks and tabs
+     * - allows inner padding (can decode concatenated base64 strings)
+     * - does not require padding
+     * - understands base64url encoding:
+     *   "-" instead of "+",
+     *   "_" instead of "/",
+     *   no padding
+     */
+    readonly dec: (base64Str: string) => Uint8Array;
+    /**
+     * Encode a byte array to a base64 string.
+     */
+    readonly enc: (bytes: Uint8Array) => string;
+};

package/dist/esm/proto-delimited.d.ts

@@ -0,0 +1,54 @@
+import type { BinaryReadOptions, BinaryWriteOptions } from "./binary-format.js";
+import type { Message } from "./message.js";
+import type { MessageType } from "./message-type.js";
+/**
+ * protoDelimited provides functions to serialize and parse size-delimited
+ * messages.
+ *
+ * A size-delimited message is a varint size in bytes, followed by exactly
+ * that many bytes of a message serialized with the binary format.
+ *
+ * This size-delimited format is compatible with other implementations.
+ * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
+ */
+export declare const protoDelimited: {
+    /**
+     * Serialize a message, prefixing it with its size.
+     */
+    enc(message: Message, options?: BinaryWriteOptions): Uint8Array;
+    /**
+     * Parse a size-delimited message, ignoring extra bytes.
+     */
+    dec<T extends Message<T>>(type: MessageType<T>, bytes: Uint8Array, options?: BinaryReadOptions): T;
+    /**
+     * Parse a stream of size-delimited messages.
+     */
+    decStream<T_1 extends Message<T_1>>(type: MessageType<T_1>, iterable: AsyncIterable<Uint8Array>): AsyncGenerator<T_1, void, unknown>;
+    /**
+     * Decodes the size from the given size-delimited message, which may be
+     * incomplete.
+     *
+     * Returns an object with the following properties:
+     * - size: The size of the delimited message in bytes
+     * - offset: The offset in the given byte array where the message starts
+     * - eof: true
+     *
+     * If the size-delimited data does not include all bytes of the varint size,
+     * the following object is returned:
+     * - size: null
+     * - offset: null
+     * - eof: false
+     *
+     * This function can be used to implement parsing of size-delimited messages
+     * from a stream.
+     */
+    peekSize(data: Uint8Array): {
+        readonly eof: false;
+        readonly size: number;
+        readonly offset: number;
+    } | {
+        readonly eof: true;
+        readonly size: null;
+        readonly offset: null;
+    };
+};

package/dist/esm/proto-double.d.ts

@@ -0,0 +1,5 @@
+export declare const protoDouble: {
+    readonly NaN: number;
+    readonly POSITIVE_INFINITY: number;
+    readonly NEGATIVE_INFINITY: number;
+};