@aptre/protobuf-es-lite 0.2.7 → 0.2.8

package/dist/scalar.js

@@ -13,8 +13,73 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isScalarZeroValue = exports.scalarZeroValue = exports.scalarEquals = void 0;
-const protobuf_1 = require("@bufbuild/protobuf");
+exports.isScalarZeroValue = exports.scalarZeroValue = exports.scalarEquals = exports.LongType = exports.ScalarType = void 0;
+const proto_int64_js_1 = require("./proto-int64.js");
+/**
+ * Scalar value types. This is a subset of field types declared by protobuf
+ * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
+ * are omitted, but the numerical values are identical.
+ */
+var ScalarType;
+(function (ScalarType) {
+    // 0 is reserved for errors.
+    // Order is weird for historical reasons.
+    ScalarType[ScalarType["DOUBLE"] = 1] = "DOUBLE";
+    ScalarType[ScalarType["FLOAT"] = 2] = "FLOAT";
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+    // negative values are likely.
+    ScalarType[ScalarType["INT64"] = 3] = "INT64";
+    ScalarType[ScalarType["UINT64"] = 4] = "UINT64";
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+    // negative values are likely.
+    ScalarType[ScalarType["INT32"] = 5] = "INT32";
+    ScalarType[ScalarType["FIXED64"] = 6] = "FIXED64";
+    ScalarType[ScalarType["FIXED32"] = 7] = "FIXED32";
+    ScalarType[ScalarType["BOOL"] = 8] = "BOOL";
+    ScalarType[ScalarType["STRING"] = 9] = "STRING";
+    // Tag-delimited aggregate.
+    // Group type is deprecated and not supported in proto3. However, Proto3
+    // implementations should still be able to parse the group wire format and
+    // treat group fields as unknown fields.
+    // TYPE_GROUP = 10,
+    // TYPE_MESSAGE = 11,  // Length-delimited aggregate.
+    // New in version 2.
+    ScalarType[ScalarType["BYTES"] = 12] = "BYTES";
+    ScalarType[ScalarType["UINT32"] = 13] = "UINT32";
+    // TYPE_ENUM = 14,
+    ScalarType[ScalarType["SFIXED32"] = 15] = "SFIXED32";
+    ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64";
+    ScalarType[ScalarType["SINT32"] = 17] = "SINT32";
+    ScalarType[ScalarType["SINT64"] = 18] = "SINT64";
+})(ScalarType || (exports.ScalarType = ScalarType = {}));
+/**
+ * JavaScript representation of fields with 64 bit integral types (int64, uint64,
+ * sint64, fixed64, sfixed64).
+ *
+ * This is a subset of google.protobuf.FieldOptions.JSType, which defines JS_NORMAL,
+ * JS_STRING, and JS_NUMBER. Protobuf-ES uses BigInt by default, but will use
+ * String if `[jstype = JS_STRING]` is specified.
+ *
+ * ```protobuf
+ * uint64 field_a = 1; // BigInt
+ * uint64 field_b = 2 [jstype = JS_NORMAL]; // BigInt
+ * uint64 field_b = 2 [jstype = JS_NUMBER]; // BigInt
+ * uint64 field_b = 2 [jstype = JS_STRING]; // String
+ * ```
+ */
+var LongType;
+(function (LongType) {
+    /**
+     * Use JavaScript BigInt.
+     */
+    LongType[LongType["BIGINT"] = 0] = "BIGINT";
+    /**
+     * Use JavaScript String.
+     *
+     * Field option `[jstype = JS_STRING]`.
+     */
+    LongType[LongType["STRING"] = 1] = "STRING";
+})(LongType || (exports.LongType = LongType = {}));
 /**
  * Returns true if both scalar values are equal.
  */
@@ -24,7 +89,7 @@ function scalarEquals(type, a, b) {
         return true;
     }
     // Special case BYTES - we need to compare each byte individually
-    if (type == protobuf_1.ScalarType.BYTES) {
+    if (type == ScalarType.BYTES) {
         if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) {
             return false;
         }
@@ -41,11 +106,11 @@ function scalarEquals(type, a, b) {
     // Special case 64-bit integers - we support number, string and bigint representation.
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
     switch (type) {
-        case protobuf_1.ScalarType.UINT64:
-        case protobuf_1.ScalarType.FIXED64:
-        case protobuf_1.ScalarType.INT64:
-        case protobuf_1.ScalarType.SFIXED64:
-        case protobuf_1.ScalarType.SINT64:
+        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;
     }
@@ -59,21 +124,21 @@ exports.scalarEquals = scalarEquals;
  */
 function scalarZeroValue(type, longType) {
     switch (type) {
-        case protobuf_1.ScalarType.BOOL:
+        case ScalarType.BOOL:
             return false;
-        case protobuf_1.ScalarType.UINT64:
-        case protobuf_1.ScalarType.FIXED64:
-        case protobuf_1.ScalarType.INT64:
-        case protobuf_1.ScalarType.SFIXED64:
-        case protobuf_1.ScalarType.SINT64:
+        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 ? protobuf_1.protoInt64.zero : "0");
-        case protobuf_1.ScalarType.DOUBLE:
-        case protobuf_1.ScalarType.FLOAT:
+            return (longType == 0 ? proto_int64_js_1.protoInt64.zero : "0");
+        case ScalarType.DOUBLE:
+        case ScalarType.FLOAT:
             return 0.0;
-        case protobuf_1.ScalarType.BYTES:
+        case ScalarType.BYTES:
             return new Uint8Array(0);
-        case protobuf_1.ScalarType.STRING:
+        case ScalarType.STRING:
             return "";
         default:
             // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32.
@@ -91,11 +156,11 @@ exports.scalarZeroValue = scalarZeroValue;
  */
 function isScalarZeroValue(type, value) {
     switch (type) {
-        case protobuf_1.ScalarType.BOOL:
+        case ScalarType.BOOL:
             return value === false;
-        case protobuf_1.ScalarType.STRING:
+        case ScalarType.STRING:
             return value === "";
-        case protobuf_1.ScalarType.BYTES:
+        case ScalarType.BYTES:
             return value instanceof Uint8Array && !value.byteLength;
         default:
             return value == 0; // Loose comparison matches 0n, 0 and "0"

package/dist/service-type.d.ts

@@ -0,0 +1,95 @@
+import type { AnyMessage, Message, MessageType } from "./message.js";
+/**
+ * ServiceType represents a protobuf services. It provides metadata for
+ * reflection-based operations.
+ */
+export interface ServiceType {
+    /**
+     * The fully qualified name of the service.
+     */
+    readonly typeName: string;
+    /**
+     * A map of local name (safe to use in ECMAScript) to method.
+     */
+    readonly methods: {
+        [localName: string]: MethodInfo;
+    };
+}
+/**
+ * MethodInfo represents a method of a protobuf service, a remote procedure
+ * call. All methods provide the following properties:
+ *
+ * - "name": The original name of the protobuf rpc.
+ * - "I": The input message type.
+ * - "O": The output message type.
+ * - "kind": The method type.
+ * - "idempotency": User-provided indication whether the method will cause
+ *   the same effect every time it is called.
+ */
+export type MethodInfo<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> = MethodInfoUnary<I, O> | MethodInfoServerStreaming<I, O> | MethodInfoClientStreaming<I, O> | MethodInfoBiDiStreaming<I, O>;
+/**
+ * A unary method: rpc (Input) returns (Output)
+ */
+export interface MethodInfoUnary<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.Unary;
+}
+/**
+ * A server streaming method: rpc (Input) returns (stream Output)
+ */
+export interface MethodInfoServerStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.ServerStreaming;
+}
+/**
+ * A client streaming method: rpc (stream Input) returns (Output)
+ */
+export interface MethodInfoClientStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.ClientStreaming;
+}
+/**
+ * A method that streams bi-directionally: rpc (stream Input) returns (stream Output)
+ */
+export interface MethodInfoBiDiStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
+    readonly kind: MethodKind.BiDiStreaming;
+}
+interface miShared<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> {
+    readonly name: string;
+    readonly I: MessageType<I>;
+    readonly O: MessageType<O>;
+    readonly idempotency?: MethodIdempotency;
+}
+/**
+ * MethodKind represents the four method types that can be declared in
+ * protobuf with the `stream` keyword:
+ *
+ * 1. Unary:           rpc (Input) returns (Output)
+ * 2. ServerStreaming: rpc (Input) returns (stream Output)
+ * 3. ClientStreaming: rpc (stream Input) returns (Output)
+ * 4. BiDiStreaming:   rpc (stream Input) returns (stream Output)
+ */
+export declare enum MethodKind {
+    Unary = 0,
+    ServerStreaming = 1,
+    ClientStreaming = 2,
+    BiDiStreaming = 3
+}
+/**
+ * Is this method side-effect-free (or safe in HTTP parlance), or just
+ * idempotent, or neither? HTTP based RPC implementation may choose GET verb
+ * for safe methods, and PUT verb for idempotent methods instead of the
+ * default POST.
+ *
+ * This enum matches the protobuf enum google.protobuf.MethodOptions.IdempotencyLevel,
+ * defined in the well-known type google/protobuf/descriptor.proto, but
+ * drops UNKNOWN.
+ */
+export declare enum MethodIdempotency {
+    /**
+     * Idempotent, no side effects.
+     */
+    NoSideEffects = 1,
+    /**
+     * Idempotent, but may have side effects.
+     */
+    Idempotent = 2
+}
+export {};

package/dist/service-type.js

@@ -0,0 +1,53 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodIdempotency = exports.MethodKind = void 0;
+/**
+ * MethodKind represents the four method types that can be declared in
+ * protobuf with the `stream` keyword:
+ *
+ * 1. Unary:           rpc (Input) returns (Output)
+ * 2. ServerStreaming: rpc (Input) returns (stream Output)
+ * 3. ClientStreaming: rpc (stream Input) returns (Output)
+ * 4. BiDiStreaming:   rpc (stream Input) returns (stream Output)
+ */
+var MethodKind;
+(function (MethodKind) {
+    MethodKind[MethodKind["Unary"] = 0] = "Unary";
+    MethodKind[MethodKind["ServerStreaming"] = 1] = "ServerStreaming";
+    MethodKind[MethodKind["ClientStreaming"] = 2] = "ClientStreaming";
+    MethodKind[MethodKind["BiDiStreaming"] = 3] = "BiDiStreaming";
+})(MethodKind || (exports.MethodKind = MethodKind = {}));
+/**
+ * Is this method side-effect-free (or safe in HTTP parlance), or just
+ * idempotent, or neither? HTTP based RPC implementation may choose GET verb
+ * for safe methods, and PUT verb for idempotent methods instead of the
+ * default POST.
+ *
+ * This enum matches the protobuf enum google.protobuf.MethodOptions.IdempotencyLevel,
+ * defined in the well-known type google/protobuf/descriptor.proto, but
+ * drops UNKNOWN.
+ */
+var MethodIdempotency;
+(function (MethodIdempotency) {
+    /**
+     * Idempotent, no side effects.
+     */
+    MethodIdempotency[MethodIdempotency["NoSideEffects"] = 1] = "NoSideEffects";
+    /**
+     * Idempotent, but may have side effects.
+     */
+    MethodIdempotency[MethodIdempotency["Idempotent"] = 2] = "Idempotent";
+})(MethodIdempotency || (exports.MethodIdempotency = MethodIdempotency = {}));

package/dist/text-format.d.ts

@@ -0,0 +1,4 @@
+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/text-format.js

@@ -0,0 +1,189 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTextFormatScalarValue = exports.parseTextFormatEnumValue = void 0;
+const assert_js_1 = require("./assert.js");
+const proto_int64_js_1 = require("./proto-int64.js");
+const scalar_js_1 = require("./scalar.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 scalar_js_1.ScalarType.STRING:
+            return value;
+        case scalar_js_1.ScalarType.BYTES: {
+            const u = unescapeBytesDefaultValue(value);
+            if (u === false) {
+                throw new Error(`cannot parse ${scalar_js_1.ScalarType[type]} default value: ${value}`);
+            }
+            return u;
+        }
+        case scalar_js_1.ScalarType.INT64:
+        case scalar_js_1.ScalarType.SFIXED64:
+        case scalar_js_1.ScalarType.SINT64:
+            return proto_int64_js_1.protoInt64.parse(value);
+        case scalar_js_1.ScalarType.UINT64:
+        case scalar_js_1.ScalarType.FIXED64:
+            return proto_int64_js_1.protoInt64.uParse(value);
+        case scalar_js_1.ScalarType.DOUBLE:
+        case scalar_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 scalar_js_1.ScalarType.BOOL:
+            return value === "true";
+        case scalar_js_1.ScalarType.INT32:
+        case scalar_js_1.ScalarType.UINT32:
+        case scalar_js_1.ScalarType.SINT32:
+        case scalar_js_1.ScalarType.FIXED32:
+        case scalar_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/type-registry.d.ts

@@ -0,0 +1,43 @@
+import type { AnyMessage, Message, MessageType } from "./message.js";
+import type { EnumType } from "./enum.js";
+import type { ServiceType } from "./service-type.js";
+/**
+ * IMessageTypeRegistry provides look-up for message types.
+ *
+ * You can conveniently create a registry using the createRegistry()
+ * function:
+ *
+ * ```ts
+ * import { createRegistry } from "@bufbuild/protobuf";
+ * import { MyMessage, MyOtherMessage } from "./gen/my_message.pb.js";
+ *
+ * const reg: IMessageTypeRegistry = createRegistry(
+ *   MyMessage,
+ *   MyOtherMessage,
+ * );
+ * ```
+ */
+export interface IMessageTypeRegistry {
+    /**
+     * Find a message type by its protobuf type name.
+     */
+    findMessage<T extends Message<T> = AnyMessage>(typeName: string): MessageType<T> | undefined;
+}
+/**
+ * IEnumTypeRegistry provides look-up for enum types.
+ */
+export interface IEnumTypeRegistry {
+    /**
+     * Find an enum type by its protobuf type name.
+     */
+    findEnum(typeName: string): EnumType | undefined;
+}
+/**
+ * IServiceTypeRegistry provides look-up for service types.
+ */
+export interface IServiceTypeRegistry {
+    /**
+     * Find a service type by its protobuf type name.
+     */
+    findService(typeName: string): ServiceType | undefined;
+}

package/dist/type-registry.js

@@ -0,0 +1,15 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/unknown.d.ts

@@ -1,4 +1,4 @@
-import { WireType } from "@bufbuild/protobuf";
+import { WireType } from "./binary-encoding.js";
 export declare const unknownFieldsSymbol: unique symbol;
 export declare function listUnknownFields(message: any): ReadonlyArray<{
     no: number;

package/dist/util.d.ts

@@ -1,5 +1,5 @@
-import { DescExtension, DescField } from "@bufbuild/protobuf";
-import type { Printable } from "@bufbuild/protoplugin/ecmascript";
+import type { Printable } from "./protoplugin/ecmascript";
+import { DescExtension, DescField } from "./descriptor-set.js";
 export declare function getFieldTypeInfo(field: DescField | DescExtension): {
     typing: Printable;
     optional: boolean;