@bufbuild/protobuf 1.3.1 → 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-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.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;
+};

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

@@ -0,0 +1,95 @@
+/**
+ * We use the `bigint` primitive to represent 64-bit integral types. If bigint
+ * is unavailable, we fall back to a string representation, which means that
+ * all values typed as `bigint` will actually be strings.
+ *
+ * If your code is intended to run in an environment where bigint may be
+ * unavailable, it must handle both the bigint and the string representation.
+ * For presenting values, this is straight-forward with implicit or explicit
+ * conversion to string:
+ *
+ * ```ts
+ * let el = document.createElement("span");
+ * el.innerText = message.int64Field; // assuming a protobuf int64 field
+ *
+ * console.log(`int64: ${message.int64Field}`);
+ *
+ * let str: string = message.int64Field.toString();
+ * ```
+ *
+ * If you need to manipulate 64-bit integral values and are sure the values
+ * can be safely represented as an IEEE-754 double precision number, you can
+ * convert to a JavaScript Number:
+ *
+ * ```ts
+ * console.log(message.int64Field.toString())
+ * let num = Number(message.int64Field);
+ * num = num + 1;
+ * message.int64Field = protoInt64.parse(num);
+ * ```
+ *
+ * If you need to manipulate 64-bit integral values that are outside the
+ * range of safe representation as a JavaScript Number, we recommend you
+ * use a third party library, for example the npm package "long":
+ *
+ * ```ts
+ * // convert the field value to a Long
+ * const bits = protoInt64.enc(message.int64Field);
+ * const longValue = Long.fromBits(bits.lo, bits.hi);
+ *
+ * // perform arithmetic
+ * const longResult = longValue.subtract(1);
+ *
+ * // set the result in the field
+ * message.int64Field = protoInt64.dec(longResult.low, longResult.high);
+ *
+ * // Assuming int64Field contains 9223372036854775807:
+ * console.log(message.int64Field); // 9223372036854775806
+ * ```
+ */
+interface Int64Support {
+    /**
+     * 0n if bigint is available, "0" if unavailable.
+     */
+    readonly zero: bigint;
+    /**
+     * Is bigint available?
+     */
+    readonly supported: boolean;
+    /**
+     * Parse a signed 64-bit integer.
+     * Returns a bigint if available, a string otherwise.
+     */
+    parse(value: string | number | bigint): bigint;
+    /**
+     * Parse an unsigned 64-bit integer.
+     * Returns a bigint if available, a string otherwise.
+     */
+    uParse(value: string | number | bigint): bigint;
+    /**
+     * Convert a signed 64-bit integral value to a two's complement.
+     */
+    enc(value: string | number | bigint): {
+        lo: number;
+        hi: number;
+    };
+    /**
+     * Convert an unsigned 64-bit integral value to a two's complement.
+     */
+    uEnc(value: string | number | bigint): {
+        lo: number;
+        hi: number;
+    };
+    /**
+     * Convert a two's complement to a signed 64-bit integral value.
+     * Returns a bigint if available, a string otherwise.
+     */
+    dec(lo: number, hi: number): bigint;
+    /**
+     * Convert a two's complement to an unsigned 64-bit integral value.
+     * Returns a bigint if available, a string otherwise.
+     */
+    uDec(lo: number, hi: number): bigint;
+}
+export declare const protoInt64: Int64Support;
+export {};

package/dist/esm/proto2.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Provides functionality for messages defined with the proto2 syntax.
+ */
+export declare const proto2: import("./private/proto-runtime.js").ProtoRuntime;

package/dist/esm/proto3.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Provides functionality for messages defined with the proto3 syntax.
+ */
+export declare const proto3: import("./private/proto-runtime.js").ProtoRuntime;