@bufbuild/protobuf 1.9.0 → 2.0.0-alpha.1

package/dist/esm/private/reify-wkt.js

@@ -1,168 +0,0 @@
-// 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 { ScalarType } from "../scalar.js";
-/**
- * @deprecated please use reifyWkt from @bufbuild/protoplugin/ecmascript instead
- *
- * 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 function reifyWkt(message) {
-    switch (message.typeName) {
-        case "google.protobuf.Any": {
-            const typeUrl = message.fields.find((f) => f.number == 1 &&
-                f.fieldKind == "scalar" &&
-                f.scalar === ScalarType.STRING);
-            const value = message.fields.find((f) => f.number == 2 &&
-                f.fieldKind == "scalar" &&
-                f.scalar === ScalarType.BYTES);
-            if (typeUrl && value) {
-                return {
-                    typeName: message.typeName,
-                    typeUrl,
-                    value,
-                };
-            }
-            break;
-        }
-        case "google.protobuf.Timestamp": {
-            const seconds = message.fields.find((f) => f.number == 1 &&
-                f.fieldKind == "scalar" &&
-                f.scalar === ScalarType.INT64);
-            const nanos = message.fields.find((f) => f.number == 2 &&
-                f.fieldKind == "scalar" &&
-                f.scalar === ScalarType.INT32);
-            if (seconds && nanos) {
-                return {
-                    typeName: message.typeName,
-                    seconds,
-                    nanos,
-                };
-            }
-            break;
-        }
-        case "google.protobuf.Duration": {
-            const seconds = message.fields.find((f) => f.number == 1 &&
-                f.fieldKind == "scalar" &&
-                f.scalar === ScalarType.INT64);
-            const nanos = message.fields.find((f) => f.number == 2 &&
-                f.fieldKind == "scalar" &&
-                f.scalar === ScalarType.INT32);
-            if (seconds && nanos) {
-                return {
-                    typeName: message.typeName,
-                    seconds,
-                    nanos,
-                };
-            }
-            break;
-        }
-        case "google.protobuf.Struct": {
-            const fields = message.fields.find((f) => f.number == 1 && !f.repeated);
-            if ((fields === null || fields === void 0 ? void 0 : fields.fieldKind) !== "map" ||
-                fields.mapValue.kind !== "message" ||
-                fields.mapValue.message.typeName !== "google.protobuf.Value") {
-                break;
-            }
-            return { typeName: message.typeName, fields };
-        }
-        case "google.protobuf.Value": {
-            const kind = message.oneofs.find((o) => o.name === "kind");
-            const nullValue = message.fields.find((f) => f.number == 1 && f.oneof === kind);
-            if ((nullValue === null || nullValue === void 0 ? void 0 : nullValue.fieldKind) !== "enum" ||
-                nullValue.enum.typeName !== "google.protobuf.NullValue") {
-                return undefined;
-            }
-            const numberValue = message.fields.find((f) => f.number == 2 &&
-                f.fieldKind == "scalar" &&
-                f.scalar === ScalarType.DOUBLE &&
-                f.oneof === kind);
-            const stringValue = message.fields.find((f) => f.number == 3 &&
-                f.fieldKind == "scalar" &&
-                f.scalar === ScalarType.STRING &&
-                f.oneof === kind);
-            const boolValue = message.fields.find((f) => f.number == 4 &&
-                f.fieldKind == "scalar" &&
-                f.scalar === ScalarType.BOOL &&
-                f.oneof === kind);
-            const structValue = message.fields.find((f) => f.number == 5 && f.oneof === kind);
-            if ((structValue === null || structValue === void 0 ? void 0 : structValue.fieldKind) !== "message" ||
-                structValue.message.typeName !== "google.protobuf.Struct") {
-                return undefined;
-            }
-            const listValue = message.fields.find((f) => f.number == 6 && f.oneof === kind);
-            if ((listValue === null || listValue === void 0 ? void 0 : listValue.fieldKind) !== "message" ||
-                listValue.message.typeName !== "google.protobuf.ListValue") {
-                return undefined;
-            }
-            if (kind && numberValue && stringValue && boolValue) {
-                return {
-                    typeName: message.typeName,
-                    kind,
-                    nullValue,
-                    numberValue,
-                    stringValue,
-                    boolValue,
-                    structValue,
-                    listValue,
-                };
-            }
-            break;
-        }
-        case "google.protobuf.ListValue": {
-            const values = message.fields.find((f) => f.number == 1 && f.repeated);
-            if ((values === null || values === void 0 ? void 0 : values.fieldKind) != "message" ||
-                values.message.typeName !== "google.protobuf.Value") {
-                break;
-            }
-            return { typeName: message.typeName, values };
-        }
-        case "google.protobuf.FieldMask": {
-            const paths = message.fields.find((f) => f.number == 1 &&
-                f.fieldKind == "scalar" &&
-                f.scalar === ScalarType.STRING &&
-                f.repeated);
-            if (paths) {
-                return { typeName: message.typeName, paths };
-            }
-            break;
-        }
-        case "google.protobuf.DoubleValue":
-        case "google.protobuf.FloatValue":
-        case "google.protobuf.Int64Value":
-        case "google.protobuf.UInt64Value":
-        case "google.protobuf.Int32Value":
-        case "google.protobuf.UInt32Value":
-        case "google.protobuf.BoolValue":
-        case "google.protobuf.StringValue":
-        case "google.protobuf.BytesValue": {
-            const value = message.fields.find((f) => f.number == 1 && f.name == "value");
-            if (!value) {
-                break;
-            }
-            if (value.fieldKind !== "scalar") {
-                break;
-            }
-            return { typeName: message.typeName, value };
-        }
-    }
-    return undefined;
-}

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

@@ -1,18 +0,0 @@
-import { LongType, ScalarType } from "../scalar.js";
-import type { ScalarValue } from "../scalar.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 zero value for the given scalar type.
- */
-export declare function scalarZeroValue<T extends ScalarType, L extends LongType>(type: T, longType: L): ScalarValue<T, L>;
-/**
- * Returns true for a zero-value. For example, an integer has the zero-value `0`,
- * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array.
- *
- * In proto3, zero-values are not written to the wire, unless the field is
- * optional or repeated.
- */
-export declare function isScalarZeroValue(type: ScalarType, value: unknown): boolean;

package/dist/esm/private/scalars.js

@@ -1,99 +0,0 @@
-// 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 { protoInt64 } from "../proto-int64.js";
-import { LongType, ScalarType } from "../scalar.js";
-/**
- * Returns true if both scalar values are equal.
- */
-export function scalarEquals(type, a, b) {
-    if (a === b) {
-        // This correctly matches equal values except BYTES and (possibly) 64-bit integers.
-        return true;
-    }
-    // Special case BYTES - we need to compare each byte individually
-    if (type == ScalarType.BYTES) {
-        if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) {
-            return false;
-        }
-        if (a.length !== b.length) {
-            return false;
-        }
-        for (let i = 0; i < a.length; i++) {
-            if (a[i] !== b[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    // Special case 64-bit integers - we support number, string and bigint representation.
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-    switch (type) {
-        case ScalarType.UINT64:
-        case ScalarType.FIXED64:
-        case ScalarType.INT64:
-        case ScalarType.SFIXED64:
-        case ScalarType.SINT64:
-            // Loose comparison will match between 0n, 0 and "0".
-            return a == b;
-    }
-    // Anything that hasn't been caught by strict comparison or special cased
-    // BYTES and 64-bit integers is not equal.
-    return false;
-}
-/**
- * Returns the zero value for the given scalar type.
- */
-export function scalarZeroValue(type, longType) {
-    switch (type) {
-        case ScalarType.BOOL:
-            return false;
-        case ScalarType.UINT64:
-        case ScalarType.FIXED64:
-        case ScalarType.INT64:
-        case ScalarType.SFIXED64:
-        case ScalarType.SINT64:
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- acceptable since it's covered by tests
-            return (longType == 0 ? protoInt64.zero : "0");
-        case ScalarType.DOUBLE:
-        case ScalarType.FLOAT:
-            return 0.0;
-        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;
-    }
-}
-/**
- * Returns true for a zero-value. For example, an integer has the zero-value `0`,
- * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array.
- *
- * In proto3, zero-values are not written to the wire, unless the field is
- * optional or repeated.
- */
-export function isScalarZeroValue(type, value) {
-    switch (type) {
-        case ScalarType.BOOL:
-            return value === false;
-        case ScalarType.STRING:
-            return value === "";
-        case ScalarType.BYTES:
-            return value instanceof Uint8Array && !value.byteLength;
-        default:
-            return value == 0; // Loose comparison matches 0n, 0 and "0"
-    }
-}

package/dist/esm/private/text-format.d.ts

@@ -1,4 +0,0 @@
-import type { DescEnum } from "../descriptor-set.js";
-import { ScalarType } from "../scalar.js";
-export declare function parseTextFormatEnumValue(descEnum: DescEnum, value: string): number;
-export declare function parseTextFormatScalarValue(type: ScalarType, value: string): number | boolean | string | bigint | Uint8Array;

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

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

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

@@ -1,234 +0,0 @@
-// 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 { setEnumType } from "./enum.js";
-import { Message } from "../message.js";
-import { scalarEquals } from "./scalars.js";
-import { ScalarType } from "../scalar.js";
-import { isMessage } from "../is-message.js";
-/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-argument,no-case-declarations */
-export function makeUtilCommon() {
-    return {
-        setEnumType,
-        initPartial(source, target) {
-            if (source === undefined) {
-                return;
-            }
-            const type = target.getType();
-            for (const member of type.fields.byMember()) {
-                const localName = member.localName, t = target, s = source;
-                if (s[localName] === undefined) {
-                    // TODO if source is a Message instance, we should use isFieldSet() here to support future field presence
-                    continue;
-                }
-                switch (member.kind) {
-                    case "oneof":
-                        const sk = s[localName].case;
-                        if (sk === undefined) {
-                            continue;
-                        }
-                        const sourceField = member.findField(sk);
-                        let val = s[localName].value;
-                        if (sourceField &&
-                            sourceField.kind == "message" &&
-                            !isMessage(val, 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":
-                        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":
-                                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;
-                                for (const k of Object.keys(s[localName])) {
-                                    let val = s[localName][k];
-                                    if (!messageType.fieldWrapper) {
-                                        // We only take partial input for messages that are not a wrapper type.
-                                        // For those messages, we recursively normalize the partial input.
-                                        val = new messageType(val);
-                                    }
-                                    t[localName][k] = val;
-                                }
-                                break;
-                        }
-                        break;
-                    case "message":
-                        const mt = member.T;
-                        if (member.repeated) {
-                            t[localName] = s[localName].map((val) => isMessage(val, mt) ? val : new mt(val));
-                        }
-                        else {
-                            const val = s[localName];
-                            if (mt.fieldWrapper) {
-                                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] = isMessage(val, mt) ? val : new mt(val);
-                            }
-                        }
-                        break;
-                }
-            }
-        },
-        // TODO use isFieldSet() here to support future field presence
-        equals(type, a, b) {
-            if (a === b) {
-                return true;
-            }
-            if (!a || !b) {
-                return false;
-            }
-            return type.fields.byMember().every((m) => {
-                const va = a[m.localName];
-                const vb = b[m.localName];
-                if (m.repeated) {
-                    if (va.length !== vb.length) {
-                        return false;
-                    }
-                    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- repeated fields are never "map"
-                    switch (m.kind) {
-                        case "message":
-                            return va.every((a, i) => m.T.equals(a, vb[i]));
-                        case "scalar":
-                            return va.every((a, i) => scalarEquals(m.T, a, vb[i]));
-                        case "enum":
-                            return va.every((a, i) => scalarEquals(ScalarType.INT32, a, vb[i]));
-                    }
-                    throw new Error(`repeated cannot contain ${m.kind}`);
-                }
-                switch (m.kind) {
-                    case "message":
-                        return m.T.equals(va, vb);
-                    case "enum":
-                        return scalarEquals(ScalarType.INT32, va, vb);
-                    case "scalar":
-                        return scalarEquals(m.T, va, vb);
-                    case "oneof":
-                        if (va.case !== vb.case) {
-                            return false;
-                        }
-                        const s = m.findField(va.case);
-                        if (s === undefined) {
-                            return true;
-                        }
-                        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- oneof fields are never "map"
-                        switch (s.kind) {
-                            case "message":
-                                return s.T.equals(va.value, vb.value);
-                            case "enum":
-                                return scalarEquals(ScalarType.INT32, va.value, vb.value);
-                            case "scalar":
-                                return scalarEquals(s.T, va.value, vb.value);
-                        }
-                        throw new Error(`oneof cannot contain ${s.kind}`);
-                    case "map":
-                        const keys = Object.keys(va).concat(Object.keys(vb));
-                        switch (m.V.kind) {
-                            case "message":
-                                const messageType = m.V.T;
-                                return keys.every((k) => messageType.equals(va[k], vb[k]));
-                            case "enum":
-                                return keys.every((k) => scalarEquals(ScalarType.INT32, va[k], vb[k]));
-                            case "scalar":
-                                const scalarType = m.V.T;
-                                return keys.every((k) => scalarEquals(scalarType, va[k], vb[k]));
-                        }
-                        break;
-                }
-            });
-        },
-        // TODO use isFieldSet() here to support future field presence
-        clone(message) {
-            const type = message.getType(), target = new type(), any = target;
-            for (const member of type.fields.byMember()) {
-                const source = message[member.localName];
-                let copy;
-                if (member.repeated) {
-                    copy = source.map(cloneSingularField);
-                }
-                else if (member.kind == "map") {
-                    copy = any[member.localName];
-                    for (const [key, v] of Object.entries(source)) {
-                        copy[key] = cloneSingularField(v);
-                    }
-                }
-                else if (member.kind == "oneof") {
-                    const f = member.findField(source.case);
-                    copy = f
-                        ? { case: source.case, value: cloneSingularField(source.value) }
-                        : { case: undefined };
-                }
-                else {
-                    copy = cloneSingularField(source);
-                }
-                any[member.localName] = copy;
-            }
-            for (const uf of type.runtime.bin.listUnknownFields(message)) {
-                type.runtime.bin.onUnknownField(any, uf.no, uf.wireType, uf.data);
-            }
-            return target;
-        },
-    };
-}
-// clone a single field value - i.e. the element type of repeated fields, the value type of maps
-function cloneSingularField(value) {
-    if (value === undefined) {
-        return value;
-    }
-    if (isMessage(value)) {
-        return value.clone();
-    }
-    if (value instanceof Uint8Array) {
-        const c = new Uint8Array(value.byteLength);
-        c.set(value);
-        return c;
-    }
-    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

@@ -1,38 +0,0 @@
-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/private/util.js

@@ -1,14 +0,0 @@
-// 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.
-export {};

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

@@ -1,18 +0,0 @@
-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;
-};