@bufbuild/protobuf 1.8.0 → 2.0.0-alpha.1

package/dist/esm/equals.js

@@ -0,0 +1,129 @@
+// 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 { scalarEquals } from "./reflect/scalar.js";
+import { reflect } from "./reflect/reflect.js";
+/**
+ * Compare two messages of the same type.
+ *
+ * Note that this function disregards extensions and unknown fields, and that
+ * NaN is not equal NaN, following the IEEE standard.
+ */
+export function equals(messageDesc, a, b) {
+    if (a.$typeName != messageDesc.typeName ||
+        b.$typeName != messageDesc.typeName) {
+        return false;
+    }
+    if (a === b) {
+        return true;
+    }
+    return reflectEquals(reflect(messageDesc, a), reflect(messageDesc, b));
+}
+function reflectEquals(a, b) {
+    for (const f of a.fields) {
+        if (!fieldEquals(f, a, b)) {
+            return false;
+        }
+    }
+    return true;
+}
+function fieldEquals(f, a, b) {
+    if (!a.isSet(f) && !b.isSet(f)) {
+        return true;
+    }
+    if (!a.isSet(f) || !b.isSet(f)) {
+        return false;
+    }
+    switch (f.fieldKind) {
+        case "scalar":
+            return scalarEquals(f.scalar, a.get(f), b.get(f));
+        case "enum":
+            return a.get(f) === b.get(f);
+        case "message":
+            return reflectEquals(a.get(f), b.get(f));
+        case "map": {
+            const ma = a.get(f);
+            const mb = b.get(f);
+            const keysA = [];
+            for (const k of ma.keys()) {
+                if (!mb.has(k)) {
+                    return false;
+                }
+                keysA.push(k);
+            }
+            for (const k of mb.keys()) {
+                if (!ma.has(k)) {
+                    return false;
+                }
+            }
+            for (const key of keysA) {
+                const va = ma.get(key);
+                const vb = mb.get(key);
+                if (va === vb) {
+                    continue;
+                }
+                switch (f.mapKind) {
+                    case "enum":
+                        return false;
+                    case "message":
+                        // TODO fix type error
+                        // @ts-expect-error TODO
+                        if (!reflectEquals(va, vb)) {
+                            return false;
+                        }
+                        break;
+                    case "scalar":
+                        // TODO fix type error
+                        // @ts-expect-error TODO
+                        if (!scalarEquals(f.scalar, va, vb)) {
+                            return false;
+                        }
+                        break;
+                }
+            }
+            break;
+        }
+        case "list": {
+            const la = a.get(f);
+            const lb = b.get(f);
+            if (la.size != lb.size) {
+                return false;
+            }
+            for (let i = 0; i < la.size; i++) {
+                if (la.get(i) === lb.get(i)) {
+                    continue;
+                }
+                switch (f.listKind) {
+                    case "enum":
+                        return false;
+                    case "message":
+                        // TODO fix type error
+                        // @ts-expect-error TODO
+                        if (!reflectEquals(la.get(i), lb.get(i))) {
+                            return false;
+                        }
+                        break;
+                    case "scalar":
+                        // TODO fix type error
+                        // @ts-expect-error TODO
+                        if (!scalarEquals(f.scalar, la.get(i), lb.get(i))) {
+                            return false;
+                        }
+                        break;
+                }
+            }
+            break;
+        }
+    }
+    return true;
+}

package/dist/esm/{extension-accessor.d.ts → extensions.d.ts}

@@ -1,6 +1,6 @@
-import type { Message } from "./message.js";
-import type { BinaryReadOptions, BinaryWriteOptions } from "./binary-format.js";
-import type { Extension } from "./extension.js";
+import type { DescExtension, DescField } from "./desc-types.js";
+import type { ReflectMessage } from "./reflect/reflect-types.js";
+import type { Extendee, ExtensionValueShape } from "./types.js";
 /**
  * Retrieve an extension value from a message.
  *
@@ -15,21 +15,25 @@ import type { Extension } from "./extension.js";
  *
  * If the extension does not extend the given message, an error is raised.
  */
-export declare function getExtension<E extends Message<E>, V>(message: E, extension: Extension<E, V>, options?: Partial<BinaryReadOptions>): V;
+export declare function getExtension<Desc extends DescExtension>(message: Extendee<Desc>, extension: Desc): ExtensionValueShape<Desc>;
 /**
  * Set an extension value on a message. If the message already has a value for
  * this extension, the value is replaced.
  *
  * If the extension does not extend the given message, an error is raised.
  */
-export declare function setExtension<E extends Message<E>, V>(message: E, extension: Extension<E, V>, value: V, options?: Partial<BinaryReadOptions & BinaryWriteOptions>): void;
+export declare function setExtension<Desc extends DescExtension>(message: Extendee<Desc>, extension: Desc, value: ExtensionValueShape<Desc>): void;
 /**
  * Remove an extension value from a message.
  *
  * If the extension does not extend the given message, an error is raised.
  */
-export declare function clearExtension<E extends Message<E>, V>(message: E, extension: Extension<E, V>): void;
+export declare function clearExtension<Desc extends DescExtension>(message: Extendee<Desc>, extension: Desc): void;
 /**
  * Check whether an extension is set on a message.
  */
-export declare function hasExtension<E extends Message<E>, V>(message: E, extension: Extension<E, V>): boolean;
+export declare function hasExtension<Desc extends DescExtension>(message: Extendee<Desc>, extension: Desc): boolean;
+/**
+ * @private
+ */
+export declare function createExtensionContainer<Desc extends DescExtension>(extension: Desc, value?: ExtensionValueShape<Desc>): [ReflectMessage, DescField, () => ExtensionValueShape<Desc>];

package/dist/esm/extensions.js

@@ -0,0 +1,130 @@
+// 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 { assert } from "./reflect/assert.js";
+import { create } from "./create.js";
+import { readField } from "./from-binary.js";
+import { localName } from "./reflect/names.js";
+import { reflect } from "./reflect/reflect.js";
+import { scalarZeroValue } from "./reflect/scalar.js";
+import { writeField } from "./to-binary.js";
+import { BinaryReader, BinaryWriter } from "./wire/binary-encoding.js";
+import { isWrapperDesc } from "./wkt/wrappers.js";
+/**
+ * Retrieve an extension value from a message.
+ *
+ * The function never returns undefined. Use hasExtension() to check whether an
+ * extension is set. If the extension is not set, this function returns the
+ * default value (if one was specified in the protobuf source), or the zero value
+ * (for example `0` for numeric types, `[]` for repeated extension fields, and
+ * an empty message instance for message fields).
+ *
+ * Extensions are stored as unknown fields on a message. To mutate an extension
+ * value, make sure to store the new value with setExtension() after mutating.
+ *
+ * If the extension does not extend the given message, an error is raised.
+ */
+export function getExtension(message, extension) {
+    assertExtendee(extension, message);
+    const ufs = filterUnknownFields(message.$unknown, extension);
+    const [container, field, get] = createExtensionContainer(extension);
+    for (const uf of ufs) {
+        readField(container, new BinaryReader(uf.data), field, uf.wireType, {
+            readUnknownFields: false,
+        });
+    }
+    return get();
+}
+/**
+ * Set an extension value on a message. If the message already has a value for
+ * this extension, the value is replaced.
+ *
+ * If the extension does not extend the given message, an error is raised.
+ */
+export function setExtension(message, extension, value) {
+    var _a;
+    assertExtendee(extension, message);
+    const ufs = ((_a = message.$unknown) !== null && _a !== void 0 ? _a : []).filter((uf) => uf.no !== extension.number);
+    const [container, field] = createExtensionContainer(extension, value);
+    const writer = new BinaryWriter();
+    writeField(writer, { writeUnknownFields: false }, container, field);
+    const reader = new BinaryReader(writer.finish());
+    while (reader.pos < reader.len) {
+        const [no, wireType] = reader.tag();
+        const data = reader.skip(wireType);
+        ufs.push({ no, wireType, data });
+    }
+    message.$unknown = ufs;
+}
+/**
+ * Remove an extension value from a message.
+ *
+ * If the extension does not extend the given message, an error is raised.
+ */
+export function clearExtension(message, extension) {
+    assertExtendee(extension, message);
+    if (message.$unknown === undefined) {
+        return;
+    }
+    message.$unknown = message.$unknown.filter((uf) => uf.no !== extension.number);
+}
+/**
+ * Check whether an extension is set on a message.
+ */
+export function hasExtension(message, extension) {
+    var _a;
+    return (extension.extendee.typeName === message.$typeName &&
+        !!((_a = message.$unknown) === null || _a === void 0 ? void 0 : _a.find((uf) => uf.no === extension.number)));
+}
+function filterUnknownFields(unknownFields, extension) {
+    if (unknownFields === undefined)
+        return [];
+    if (extension.fieldKind === "enum" || extension.fieldKind === "scalar") {
+        // singular scalar fields do not merge, we pick the last
+        for (let i = unknownFields.length - 1; i >= 0; --i) {
+            if (unknownFields[i].no == extension.number) {
+                return [unknownFields[i]];
+            }
+        }
+        return [];
+    }
+    return unknownFields.filter((uf) => uf.no === extension.number);
+}
+/**
+ * @private
+ */
+export function createExtensionContainer(extension, value) {
+    const field = Object.assign(Object.assign({}, extension), { kind: "field", parent: extension.extendee });
+    const desc = Object.assign(Object.assign({}, extension.extendee), { fields: [field], members: [field], oneofs: [] });
+    const fieldName = localName(field);
+    const container = create(desc, value !== undefined ? { [fieldName]: value } : undefined);
+    return [
+        reflect(desc, container),
+        field,
+        () => {
+            const value = container[fieldName];
+            if (value === undefined) {
+                // Only message fields are undefined, rest will have a zero value.
+                const desc = extension.message;
+                if (isWrapperDesc(desc)) {
+                    return scalarZeroValue(desc.fields[0].scalar, desc.fields[0].longType);
+                }
+                return create(desc);
+            }
+            return value;
+        },
+    ];
+}
+function assertExtendee(extension, message) {
+    assert(extension.extendee.typeName == message.$typeName, `extension ${extension.typeName} can only be applied to message ${extension.extendee.typeName}`);
+}

package/dist/esm/fields.d.ts

@@ -0,0 +1,22 @@
+import type { Message, MessageShape } from "./types.js";
+import type { DescMessage } from "./desc-types.js";
+/**
+ * Returns true if the field is set.
+ */
+export declare function isFieldSet<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>, fieldName: MessageFieldNames<MessageShape<Desc>>): boolean;
+/**
+ * Resets the field, so that isFieldSet() will return false.
+ */
+export declare function clearField<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>, fieldName: MessageFieldNames<MessageShape<Desc>>): void;
+/**
+ * Union of the property names of all fields, including oneof members.
+ * For an anonymous message (no generated message shape), it's simply a string.
+ */
+type MessageFieldNames<T extends Message> = Message extends T ? string : Exclude<keyof {
+    [P in keyof T as P extends ("$typeName" | "$unknown") ? never : T[P] extends Oneof<infer K> ? K : P]-?: true;
+}, number | symbol>;
+type Oneof<K extends string> = {
+    case: K | undefined;
+    value?: unknown;
+};
+export {};

package/dist/esm/fields.js

@@ -0,0 +1,34 @@
+// 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 { localName } from "./reflect/names.js";
+import { unsafeClear, unsafeIsSet } from "./reflect/unsafe.js";
+/**
+ * Returns true if the field is set.
+ */
+export function isFieldSet(messageDesc, message, fieldName) {
+    const field = messageDesc.fields.find((f) => localName(f) === fieldName);
+    if (field) {
+        return unsafeIsSet(message, field);
+    }
+    return false;
+}
+/**
+ * Resets the field, so that isFieldSet() will return false.
+ */
+export function clearField(messageDesc, message, fieldName) {
+    const field = messageDesc.fields.find((f) => localName(f) === fieldName);
+    if (field) {
+        unsafeClear(message, field);
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { DescField, DescMessage } from "./desc-types.js";
+import type { MessageShape } from "./types.js";
+import type { ReflectMessage } from "./reflect/index.js";
+import { BinaryReader, WireType } from "./wire/binary-encoding.js";
+/**
+ * Options for parsing binary data.
+ */
+export interface BinaryReadOptions {
+    /**
+     * Retain unknown fields during parsing? The default behavior is to retain
+     * unknown fields and include them in the serialized output.
+     *
+     * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns
+     */
+    readUnknownFields: boolean;
+}
+/**
+ * Parse serialized binary data.
+ */
+export declare function fromBinary<Desc extends DescMessage>(messageDesc: Desc, bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MessageShape<Desc>;
+/**
+ * Parse from binary data, merging fields.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ */
+export declare function mergeFromBinary<Desc extends DescMessage>(messageDesc: Desc, target: MessageShape<Desc>, bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MessageShape<Desc>;
+/**
+ * @private
+ */
+export declare function readField(message: ReflectMessage, reader: BinaryReader, field: DescField, wireType: WireType, options: BinaryReadOptions): void;

package/dist/esm/from-binary.js

@@ -0,0 +1,215 @@
+// 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 { LongType, ScalarType, scalarZeroValue } from "./reflect/scalar.js";
+import { reflect } from "./reflect/reflect.js";
+import { BinaryReader, WireType } from "./wire/binary-encoding.js";
+// Default options for parsing binary data.
+const readDefaults = {
+    readUnknownFields: true,
+};
+function makeReadOptions(options) {
+    return options ? Object.assign(Object.assign({}, readDefaults), options) : readDefaults;
+}
+/**
+ * Parse serialized binary data.
+ */
+export function fromBinary(messageDesc, bytes, options) {
+    const msg = reflect(messageDesc);
+    readMessage(msg, new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
+    return msg.message;
+}
+/**
+ * Parse from binary data, merging fields.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ */
+export function mergeFromBinary(messageDesc, target, bytes, options) {
+    readMessage(reflect(messageDesc, target), new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
+    return target;
+}
+/**
+ * If `delimited` is false, read the length given in `lengthOrDelimitedFieldNo`.
+ *
+ * If `delimited` is true, read until an EndGroup tag. `lengthOrDelimitedFieldNo`
+ * is the expected field number.
+ *
+ * @private
+ */
+function readMessage(message, reader, options, delimited, lengthOrDelimitedFieldNo) {
+    var _a;
+    const end = delimited ? reader.len : reader.pos + lengthOrDelimitedFieldNo;
+    let fieldNo, wireType;
+    const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : [];
+    while (reader.pos < end) {
+        [fieldNo, wireType] = reader.tag();
+        if (wireType == WireType.EndGroup) {
+            break;
+        }
+        const field = message.findNumber(fieldNo);
+        if (!field) {
+            const data = reader.skip(wireType);
+            if (options.readUnknownFields) {
+                unknownFields.push({ no: fieldNo, wireType, data });
+            }
+            continue;
+        }
+        readField(message, reader, field, wireType, options);
+    }
+    if (delimited) {
+        if (wireType != WireType.EndGroup || fieldNo !== lengthOrDelimitedFieldNo) {
+            throw new Error(`invalid end group tag`);
+        }
+    }
+    if (unknownFields.length > 0) {
+        message.setUnknown(unknownFields);
+    }
+}
+/**
+ * @private
+ */
+export function readField(message, reader, field, wireType, options) {
+    switch (field.fieldKind) {
+        case "scalar":
+            message.set(field, readScalar(reader, field.scalar, field.longType));
+            break;
+        case "enum":
+            message.set(field, readScalar(reader, ScalarType.INT32));
+            break;
+        case "message":
+            message.set(field, readMessageField(reader, options, field, message.get(field)));
+            break;
+        case "list":
+            readListField(message, reader, options, field, wireType);
+            break;
+        case "map":
+            // eslint-disable-next-line no-case-declarations
+            const [key, val] = readMapEntry(field, reader, options);
+            message.setMapEntry(field, key, val);
+            break;
+    }
+}
+// Read a map field, expecting key field = 1, value field = 2
+function readMapEntry(field, reader, options) {
+    let key, val;
+    const end = reader.pos + reader.uint32();
+    while (reader.pos < end) {
+        const [fieldNo] = reader.tag();
+        switch (fieldNo) {
+            case 1:
+                key = readScalar(reader, field.mapKey);
+                break;
+            case 2:
+                switch (field.mapKind) {
+                    case "scalar":
+                        val = readScalar(reader, field.scalar);
+                        break;
+                    case "enum":
+                        val = reader.int32();
+                        break;
+                    case "message":
+                        val = readMessageField(reader, options, field);
+                        break;
+                }
+                break;
+        }
+    }
+    if (key === undefined) {
+        key = scalarZeroValue(field.mapKey, LongType.BIGINT);
+    }
+    if (val === undefined) {
+        switch (field.mapKind) {
+            case "scalar":
+                val = scalarZeroValue(field.scalar, LongType.BIGINT);
+                break;
+            case "enum":
+                val = field.enum.values[0].number;
+                break;
+            case "message":
+                val = reflect(field.message);
+                break;
+        }
+    }
+    return [key, val];
+}
+function readListField(message, reader, options, field, wireType) {
+    var _a;
+    if (field.listKind === "message") {
+        message.addListItem(field, readMessageField(reader, options, field));
+        return;
+    }
+    const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32;
+    const longType = field.listKind == "scalar" ? field.longType : undefined;
+    const packed = wireType == WireType.LengthDelimited &&
+        scalarType != ScalarType.STRING &&
+        scalarType != ScalarType.BYTES;
+    if (!packed) {
+        message.addListItem(field, readScalar(reader, scalarType, longType));
+        return;
+    }
+    const e = reader.uint32() + reader.pos;
+    while (reader.pos < e) {
+        message.addListItem(field, readScalar(reader, scalarType, longType));
+    }
+}
+function readMessageField(reader, options, field, mergeMessage) {
+    const delimited = field.delimitedEncoding;
+    const message = mergeMessage !== null && mergeMessage !== void 0 ? mergeMessage : reflect(field.message);
+    readMessage(message, reader, options, delimited, delimited ? field.number : reader.uint32());
+    return message;
+}
+function readScalar(reader, type, longType) {
+    let v = readScalarValue(reader, type);
+    if (longType === LongType.STRING) {
+        v = typeof v == "bigint" ? v.toString() : v;
+    }
+    return v;
+}
+function readScalarValue(reader, type) {
+    switch (type) {
+        case ScalarType.STRING:
+            return reader.string();
+        case ScalarType.BOOL:
+            return reader.bool();
+        case ScalarType.DOUBLE:
+            return reader.double();
+        case ScalarType.FLOAT:
+            return reader.float();
+        case ScalarType.INT32:
+            return reader.int32();
+        case ScalarType.INT64:
+            return reader.int64();
+        case ScalarType.UINT64:
+            return reader.uint64();
+        case ScalarType.FIXED64:
+            return reader.fixed64();
+        case ScalarType.BYTES:
+            return reader.bytes();
+        case ScalarType.FIXED32:
+            return reader.fixed32();
+        case ScalarType.SFIXED32:
+            return reader.sfixed32();
+        case ScalarType.SFIXED64:
+            return reader.sfixed64();
+        case ScalarType.SINT64:
+            return reader.sint64();
+        case ScalarType.UINT32:
+            return reader.uint32();
+        case ScalarType.SINT32:
+            return reader.sint32();
+    }
+}

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

@@ -0,0 +1,48 @@
+import type { DescMessage } from "./desc-types.js";
+import type { JsonValue } from "./json-value.js";
+import type { Registry } from "./reflect/registry.js";
+import type { MessageShape } from "./types.js";
+/**
+ * Options for parsing JSON data.
+ */
+export interface JsonReadOptions {
+    /**
+     * Ignore unknown fields: Proto3 JSON parser should reject unknown fields
+     * by default. This option ignores unknown fields in parsing, as well as
+     * unrecognized enum string representations.
+     */
+    ignoreUnknownFields: boolean;
+    /**
+     * This option is required to read `google.protobuf.Any` and extensions
+     * from JSON format.
+     */
+    registry?: Registry;
+}
+/**
+ * Parse a message from a JSON string.
+ */
+export declare function fromJsonString<Desc extends DescMessage>(messageDesc: Desc, json: string, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parse a message from a JSON string, merging fields.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ */
+export declare function mergeFromJsonString<Desc extends DescMessage>(messageDesc: Desc, target: MessageShape<Desc>, json: string, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parse a message from a JSON value.
+ */
+export declare function fromJson<Desc extends DescMessage>(messageDesc: Desc, json: JsonValue, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parse a message from a JSON value, merging fields.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ */
+export declare function mergeFromJson<Desc extends DescMessage>(messageDesc: Desc, target: MessageShape<Desc>, json: JsonValue, options?: Partial<JsonReadOptions>): MessageShape<Desc>;