@bufbuild/protobuf 1.4.2 → 1.5.1

package/dist/cjs/private/text-format.js

@@ -0,0 +1,189 @@
+"use strict";
+// Copyright 2021-2023 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTextFormatScalarValue = exports.parseTextFormatEnumValue = void 0;
+const assert_js_1 = require("./assert.js");
+const field_js_1 = require("../field.js");
+const proto_int64_js_1 = require("../proto-int64.js");
+function parseTextFormatEnumValue(descEnum, value) {
+    const enumValue = descEnum.values.find((v) => v.name === value);
+    (0, assert_js_1.assert)(enumValue, `cannot parse ${descEnum.name} default value: ${value}`);
+    return enumValue.number;
+}
+exports.parseTextFormatEnumValue = parseTextFormatEnumValue;
+function parseTextFormatScalarValue(type, value) {
+    switch (type) {
+        case field_js_1.ScalarType.STRING:
+            return value;
+        case field_js_1.ScalarType.BYTES: {
+            const u = unescapeBytesDefaultValue(value);
+            if (u === false) {
+                throw new Error(`cannot parse ${field_js_1.ScalarType[type]} default value: ${value}`);
+            }
+            return u;
+        }
+        case field_js_1.ScalarType.INT64:
+        case field_js_1.ScalarType.SFIXED64:
+        case field_js_1.ScalarType.SINT64:
+            return proto_int64_js_1.protoInt64.parse(value);
+        case field_js_1.ScalarType.UINT64:
+        case field_js_1.ScalarType.FIXED64:
+            return proto_int64_js_1.protoInt64.uParse(value);
+        case field_js_1.ScalarType.DOUBLE:
+        case field_js_1.ScalarType.FLOAT:
+            switch (value) {
+                case "inf":
+                    return Number.POSITIVE_INFINITY;
+                case "-inf":
+                    return Number.NEGATIVE_INFINITY;
+                case "nan":
+                    return Number.NaN;
+                default:
+                    return parseFloat(value);
+            }
+        case field_js_1.ScalarType.BOOL:
+            return value === "true";
+        case field_js_1.ScalarType.INT32:
+        case field_js_1.ScalarType.UINT32:
+        case field_js_1.ScalarType.SINT32:
+        case field_js_1.ScalarType.FIXED32:
+        case field_js_1.ScalarType.SFIXED32:
+            return parseInt(value, 10);
+    }
+}
+exports.parseTextFormatScalarValue = parseTextFormatScalarValue;
+/**
+ * Parses a text-encoded default value (proto2) of a BYTES field.
+ */
+function unescapeBytesDefaultValue(str) {
+    const b = [];
+    const input = {
+        tail: str,
+        c: "",
+        next() {
+            if (this.tail.length == 0) {
+                return false;
+            }
+            this.c = this.tail[0];
+            this.tail = this.tail.substring(1);
+            return true;
+        },
+        take(n) {
+            if (this.tail.length >= n) {
+                const r = this.tail.substring(0, n);
+                this.tail = this.tail.substring(n);
+                return r;
+            }
+            return false;
+        },
+    };
+    while (input.next()) {
+        switch (input.c) {
+            case "\\":
+                if (input.next()) {
+                    switch (input.c) {
+                        case "\\":
+                            b.push(input.c.charCodeAt(0));
+                            break;
+                        case "b":
+                            b.push(0x08);
+                            break;
+                        case "f":
+                            b.push(0x0c);
+                            break;
+                        case "n":
+                            b.push(0x0a);
+                            break;
+                        case "r":
+                            b.push(0x0d);
+                            break;
+                        case "t":
+                            b.push(0x09);
+                            break;
+                        case "v":
+                            b.push(0x0b);
+                            break;
+                        case "0":
+                        case "1":
+                        case "2":
+                        case "3":
+                        case "4":
+                        case "5":
+                        case "6":
+                        case "7": {
+                            const s = input.c;
+                            const t = input.take(2);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 8);
+                            if (isNaN(n)) {
+                                return false;
+                            }
+                            b.push(n);
+                            break;
+                        }
+                        case "x": {
+                            const s = input.c;
+                            const t = input.take(2);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 16);
+                            if (isNaN(n)) {
+                                return false;
+                            }
+                            b.push(n);
+                            break;
+                        }
+                        case "u": {
+                            const s = input.c;
+                            const t = input.take(4);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 16);
+                            if (isNaN(n)) {
+                                return false;
+                            }
+                            const chunk = new Uint8Array(4);
+                            const view = new DataView(chunk.buffer);
+                            view.setInt32(0, n, true);
+                            b.push(chunk[0], chunk[1], chunk[2], chunk[3]);
+                            break;
+                        }
+                        case "U": {
+                            const s = input.c;
+                            const t = input.take(8);
+                            if (t === false) {
+                                return false;
+                            }
+                            const tc = proto_int64_js_1.protoInt64.uEnc(s + t);
+                            const chunk = new Uint8Array(8);
+                            const view = new DataView(chunk.buffer);
+                            view.setInt32(0, tc.lo, true);
+                            view.setInt32(4, tc.hi, true);
+                            b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]);
+                            break;
+                        }
+                    }
+                }
+                break;
+            default:
+                b.push(input.c.charCodeAt(0));
+        }
+    }
+    return new Uint8Array(b);
+}

package/dist/cjs/proto-delimited.js

@@ -23,8 +23,9 @@ var __await = (this && this.__await) || function (v) { return this instanceof __
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
     function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
     function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
     function fulfill(value) { resume("next", value); }

package/dist/cjs/proto2.js

@@ -57,7 +57,7 @@ exports.proto2 = (0, proto_runtime_js_1.makeProtoRuntime)("proto2", (0, json_for
     } }));
 /* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
 function normalizeFieldInfosProto2(fieldInfos) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const r = [];
     let o;
     for (const field of typeof fieldInfos == "function"
@@ -70,8 +70,6 @@ function normalizeFieldInfosProto2(fieldInfos) {
         if (field.kind == "scalar") {
             f.L = (_c = field.L) !== null && _c !== void 0 ? _c : field_js_2.LongType.BIGINT;
         }
-        // In contrast to proto3, repeated fields are unpacked except when explicitly specified.
-        f.packed = (_d = field.packed) !== null && _d !== void 0 ? _d : false;
         // We do not surface options at this time
         // f.options = field.options ?? emptyReadonlyObject;
         if (field.oneof !== undefined) {
@@ -82,6 +80,12 @@ function normalizeFieldInfosProto2(fieldInfos) {
             f.oneof = o;
             o.addField(f);
         }
+        // proto2 specific:
+        if (field.kind == "message") {
+            f.delimited = (_d = field.delimited) !== null && _d !== void 0 ? _d : false;
+        }
+        // In contrast to proto3, repeated fields are unpacked except when explicitly specified.
+        f.packed = (_e = field.packed) !== null && _e !== void 0 ? _e : false;
         r.push(f);
     }
     return r;

package/dist/cjs/proto3.js

@@ -73,16 +73,6 @@ function normalizeFieldInfosProto3(fieldInfos) {
         if (field.kind == "scalar") {
             f.L = (_c = field.L) !== null && _c !== void 0 ? _c : field_js_1.LongType.BIGINT;
         }
-        // From the proto3 language guide:
-        // > In proto3, repeated fields of scalar numeric types are packed by default.
-        // This information is incomplete - according to the conformance tests, BOOL
-        // and ENUM are packed by default as well. This means only STRING and BYTES
-        // are not packed by default, which makes sense because they are length-delimited.
-        f.packed =
-            (_d = field.packed) !== null && _d !== void 0 ? _d : (field.kind == "enum" ||
-                (field.kind == "scalar" &&
-                    field.T != field_js_1.ScalarType.BYTES &&
-                    field.T != field_js_1.ScalarType.STRING));
         // We do not surface options at this time
         // f.options = field.options ?? emptyReadonlyObject;
         if (field.oneof !== undefined) {
@@ -93,6 +83,20 @@ function normalizeFieldInfosProto3(fieldInfos) {
             f.oneof = o;
             o.addField(f);
         }
+        // proto3 specific:
+        if (field.kind == "message") {
+            f.delimited = false;
+        }
+        // From the proto3 language guide:
+        // > In proto3, repeated fields of scalar numeric types are packed by default.
+        // This information is incomplete - according to the conformance tests, BOOL
+        // and ENUM are packed by default as well. This means only STRING and BYTES
+        // are not packed by default, which makes sense because they are length-delimited.
+        f.packed =
+            (_d = field.packed) !== null && _d !== void 0 ? _d : (field.kind == "enum" ||
+                (field.kind == "scalar" &&
+                    field.T != field_js_1.ScalarType.BYTES &&
+                    field.T != field_js_1.ScalarType.STRING));
         r.push(f);
     }
     return r;

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

@@ -25,13 +25,12 @@ export declare enum WireType {
      */
     LengthDelimited = 2,
     /**
-     * Used for groups
-     * @deprecated
+     * Start of a tag-delimited aggregate, such as a proto2 group, or a message
+     * in editions with message_encoding = DELIMITED.
      */
     StartGroup = 3,
     /**
-     * Used for groups
-     * @deprecated
+     * End of a tag-delimited aggregate.
      */
     EndGroup = 4,
     /**

package/dist/esm/binary-encoding.js

@@ -43,13 +43,12 @@ export var WireType;
      */
     WireType[WireType["LengthDelimited"] = 2] = "LengthDelimited";
     /**
-     * Used for groups
-     * @deprecated
+     * Start of a tag-delimited aggregate, such as a proto2 group, or a message
+     * in editions with message_encoding = DELIMITED.
      */
     WireType[WireType["StartGroup"] = 3] = "StartGroup";
     /**
-     * Used for groups
-     * @deprecated
+     * End of a tag-delimited aggregate.
      */
     WireType[WireType["EndGroup"] = 4] = "EndGroup";
     /**

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

@@ -16,8 +16,17 @@ export interface BinaryFormat {
     makeWriteOptions(options?: Partial<BinaryWriteOptions>): Readonly<BinaryWriteOptions>;
     /**
      * Parse a message from binary data, merging fields.
+     *
+     * Supports two message encodings:
+     * - length-prefixed: delimitedMessageEncoding is false or omitted, and
+     *   lengthOrEndTagFieldNo is the expected length of the message in the reader.
+     * - delimited: delimitedMessageEncoding is true, and lengthOrEndTagFieldNo is
+     *   the field number in a tag with wire type end-group signalling the end of
+     *   the message in the reader.
+     *
+     * delimitedMessageEncoding is optional for backwards compatibility.
      */
-    readMessage(message: Message, reader: IBinaryReader, length: number, options: BinaryReadOptions): void;
+    readMessage(message: Message, reader: IBinaryReader, lengthOrEndTagFieldNo: number, options: BinaryReadOptions, delimitedMessageEncoding?: boolean): void;
     /**
      * Serialize a message to binary data.
      */

package/dist/esm/create-descriptor-set.d.ts

@@ -1,5 +1,4 @@
-import type { FieldDescriptorProto } from "./google/protobuf/descriptor_pb.js";
-import { FileDescriptorProto, FileDescriptorSet } from "./google/protobuf/descriptor_pb.js";
+import { FeatureSetDefaults, FileDescriptorProto, FileDescriptorSet } from "./google/protobuf/descriptor_pb.js";
 import type { DescriptorSet } from "./descriptor-set.js";
 /**
  * Create a DescriptorSet, a convenient interface for working with a set of
@@ -9,8 +8,23 @@ import type { DescriptorSet } from "./descriptor-set.js";
  * before any file that imports it. Protocol buffer compilers always produce
  * files in topological order.
  */
-export declare function createDescriptorSet(input: FileDescriptorProto[] | FileDescriptorSet | Uint8Array): DescriptorSet;
+export declare function createDescriptorSet(input: FileDescriptorProto[] | FileDescriptorSet | Uint8Array, options?: CreateDescriptorSetOptions): DescriptorSet;
 /**
- * Get the default `packed` state of a repeated field.
+ * Options to createDescriptorSet()
  */
-export declare function isPackedFieldByDefault(proto: FieldDescriptorProto, syntax: "proto2" | "proto3"): boolean;
+interface CreateDescriptorSetOptions {
+    /**
+     * Editions support language-specific features with extensions to
+     * google.protobuf.FeatureSet. They can define defaults, and specify on
+     * which targets the features can be set.
+     *
+     * To create a DescriptorSet that provides your language-specific features,
+     * you have to provide a google.protobuf.FeatureSetDefaults message in this
+     * option.
+     *
+     * The defaults can be generated with `protoc` - see the flag
+     * `--experimental_edition_defaults_out`.
+     */
+    featureSetDefaults?: FeatureSetDefaults;
+}
+export {};