@bufbuild/protobuf 0.0.10 → 0.1.0

package/dist/cjs/legacy-descriptor-registry.js

@@ -1,468 +0,0 @@
-"use strict";
-// Copyright 2021-2022 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.LegacyDescriptorRegistry = void 0;
-const descriptor_pb_js_1 = require("./google/protobuf/descriptor_pb.js");
-const assert_js_1 = require("./private/assert.js");
-const proto3_js_1 = require("./proto3.js");
-const proto2_js_1 = require("./proto2.js");
-const field_js_1 = require("./field.js");
-const legacy_descriptor_set_js_1 = require("./legacy-descriptor-set.js");
-const proto_int64_js_1 = require("./proto-int64.js");
-const timestamp_pb_js_1 = require("./google/protobuf/timestamp_pb.js");
-const duration_pb_js_1 = require("./google/protobuf/duration_pb.js");
-const any_pb_js_1 = require("./google/protobuf/any_pb.js");
-const empty_pb_js_1 = require("./google/protobuf/empty_pb.js");
-const field_mask_pb_js_1 = require("./google/protobuf/field_mask_pb.js");
-const struct_pb_js_1 = require("./google/protobuf/struct_pb.js");
-const enum_js_1 = require("./private/enum.js");
-const wrappers_pb_js_1 = require("./google/protobuf/wrappers_pb.js");
-// well-known message types with specialized JSON representation
-const wkMessages = [
-    any_pb_js_1.Any,
-    duration_pb_js_1.Duration,
-    empty_pb_js_1.Empty,
-    field_mask_pb_js_1.FieldMask,
-    struct_pb_js_1.Struct,
-    struct_pb_js_1.Value,
-    struct_pb_js_1.ListValue,
-    timestamp_pb_js_1.Timestamp,
-    duration_pb_js_1.Duration,
-    wrappers_pb_js_1.DoubleValue,
-    wrappers_pb_js_1.FloatValue,
-    wrappers_pb_js_1.Int64Value,
-    wrappers_pb_js_1.Int32Value,
-    wrappers_pb_js_1.UInt32Value,
-    wrappers_pb_js_1.UInt64Value,
-    wrappers_pb_js_1.BoolValue,
-    wrappers_pb_js_1.StringValue,
-    wrappers_pb_js_1.BytesValue,
-];
-// well-known enum types with specialized JSON representation
-const wkEnums = [(0, enum_js_1.getEnumType)(struct_pb_js_1.NullValue)];
-/**
- * LegacyDescriptorRegistry is a type registry that dynamically creates types
- * from a set of google.protobuf.FileDescriptorProto.
- *
- * By default, all well-known types with a specialized JSON representation
- * are replaced with their generated counterpart in this package.
- *
- * @deprecated
- */
-class LegacyDescriptorRegistry {
-    constructor(descriptorSet, replaceWkt = true) {
-        this.enums = {};
-        this.messages = {};
-        this.services = {};
-        this.ds = descriptorSet !== null && descriptorSet !== void 0 ? descriptorSet : new legacy_descriptor_set_js_1.LegacyDescriptorSet();
-        if (replaceWkt) {
-            for (const mt of wkMessages) {
-                this.messages["." + mt.typeName] = mt;
-            }
-            for (const et of wkEnums) {
-                this.enums["." + et.typeName] = et;
-            }
-        }
-    }
-    /**
-     * Conveniently create a DescriptorRegistry from a FileDescriptorSet
-     * instance or a FileDescriptorSet in binary format.
-     */
-    static fromFileDescriptorSet(bytesOrSet) {
-        const set = bytesOrSet instanceof Uint8Array
-            ? descriptor_pb_js_1.FileDescriptorSet.fromBinary(bytesOrSet)
-            : new descriptor_pb_js_1.FileDescriptorSet(bytesOrSet);
-        const dr = new LegacyDescriptorRegistry();
-        dr.add(...set.file);
-        return dr;
-    }
-    /**
-     * May raise an error on invalid descriptors.
-     */
-    add(...files) {
-        this.ds.add(...files);
-    }
-    /**
-     * May raise an error on invalid descriptors.
-     */
-    findEnum(typeName) {
-        const protoTypeName = "." + typeName;
-        const existing = this.enums[protoTypeName];
-        if (existing) {
-            return existing;
-        }
-        const raw = this.ds.enums[protoTypeName];
-        if (!raw) {
-            return undefined;
-        }
-        const runtime = raw.file.syntax == "proto3" ? proto3_js_1.proto3 : proto2_js_1.proto2;
-        const type = runtime.makeEnumType(typeName, raw.values.map((u) => ({
-            no: u.number,
-            name: u.name,
-            localName: u.name,
-        })), {});
-        this.enums[protoTypeName] = type;
-        return type;
-    }
-    /**
-     * May raise an error on invalid descriptors.
-     */
-    findMessage(typeName) {
-        const protoTypeName = "." + typeName;
-        const existing = this.messages[protoTypeName];
-        if (existing) {
-            return existing;
-        }
-        const raw = this.ds.messages[protoTypeName];
-        if (!raw) {
-            return undefined;
-        }
-        const runtime = raw.file.syntax == "proto3" ? proto3_js_1.proto3 : proto2_js_1.proto2;
-        const fields = [];
-        const type = runtime.makeMessageType(typeName, () => fields, {
-            localName: makeTypeLocalName(raw),
-        });
-        this.messages[protoTypeName] = type;
-        for (const field of raw.fields.map((f) => f.resolve(this.ds))) {
-            const fieldInfo = makeFieldInfo(field, this);
-            fields.push(fieldInfo);
-        }
-        return type;
-    }
-    /**
-     * May raise an error on invalid descriptors.
-     */
-    findService(typeName) {
-        const protoTypeName = "." + typeName;
-        const existing = this.services[protoTypeName];
-        if (existing) {
-            return existing;
-        }
-        const raw = this.ds.services[protoTypeName];
-        if (!raw) {
-            return undefined;
-        }
-        const methods = {};
-        for (const u of raw.methods) {
-            const it = this.findMessage(u.inputTypeName);
-            const ot = this.findMessage(u.outputTypeName);
-            (0, assert_js_1.assert)(it, `message "${u.inputTypeName}" for ${u.toString()} not found`);
-            (0, assert_js_1.assert)(ot, `output message "${u.outputTypeName}" for ${u.toString()} not found`);
-            const m = {
-                name: u.name,
-                localName: localMethodName(u.name),
-                I: it,
-                O: ot,
-                kind: u.kind,
-                idempotency: u.idempotency,
-                options: {},
-            };
-            methods[m.localName] = m;
-        }
-        return (this.services[protoTypeName] = {
-            typeName: raw.typeName,
-            methods,
-        });
-    }
-}
-exports.LegacyDescriptorRegistry = LegacyDescriptorRegistry;
-function localMethodName(protoName) {
-    if (protoName.length == 0) {
-        return protoName;
-    }
-    return protoName[0].toLowerCase() + protoName.substring(1);
-}
-function makeTypeLocalName(type) {
-    var _a;
-    const typeName = type.typeName;
-    const packagePrefix = ((_a = type.file.proto.package) !== null && _a !== void 0 ? _a : "") + ".";
-    if (!typeName.startsWith(packagePrefix)) {
-        return type.name;
-    }
-    return typeName.substring(packagePrefix.length).split(".").join("_");
-}
-function makeFieldInfo(field, resolver) {
-    if (field.map !== undefined) {
-        return makeMapFieldInfo(field, resolver);
-    }
-    if (field.message) {
-        return makeMessageFieldInfo(field, resolver);
-    }
-    const fi = field.enum
-        ? makeEnumFieldInfo(field, resolver)
-        : makeScalarFieldInfo(field);
-    fi.default = parseDefaultValue(field);
-    return fi;
-}
-function makeMapFieldInfo(field, resolver) {
-    const base = {
-        kind: "map",
-        name: field.name,
-        no: field.number,
-        K: field.map.key,
-    };
-    if (field.map.value.message) {
-        const messageType = resolver.findMessage(field.map.value.message.typeName);
-        (0, assert_js_1.assert)(messageType, `message "${field.map.value.message.typeName}" for ${field.toString()} not found`);
-        return Object.assign(Object.assign({}, base), { V: {
-                kind: "message",
-                T: messageType,
-            } });
-    }
-    if (field.map.value.enum) {
-        const enumType = resolver.findEnum(field.map.value.enum.typeName);
-        (0, assert_js_1.assert)(enumType, `enum "${field.map.value.enum.typeName}" for ${field.toString()} not found`);
-        return Object.assign(Object.assign({}, base), { V: {
-                kind: "enum",
-                T: enumType,
-            } });
-    }
-    return Object.assign(Object.assign({}, base), { V: {
-            kind: "scalar",
-            T: field.map.value.scalarType,
-        } });
-}
-function makeScalarFieldInfo(field) {
-    const base = {
-        no: field.number,
-        name: field.name,
-        kind: "scalar",
-        T: field.scalarType,
-    };
-    if (field.repeated) {
-        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined, T: field.scalarType });
-    }
-    if (field.oneof) {
-        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
-    }
-    if (field.optional) {
-        return Object.assign(Object.assign({}, base), { opt: true });
-    }
-    return base;
-}
-function makeMessageFieldInfo(field, resolver) {
-    const messageType = resolver.findMessage(field.message.typeName);
-    (0, assert_js_1.assert)(messageType, `message "${field.message.typeName}" for ${field.toString()} not found`);
-    const base = {
-        no: field.number,
-        name: field.name,
-        kind: "message",
-        T: messageType,
-    };
-    if (field.repeated) {
-        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined });
-    }
-    if (field.oneof) {
-        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
-    }
-    if (field.optional) {
-        return Object.assign(Object.assign({}, base), { opt: true });
-    }
-    return base;
-}
-function makeEnumFieldInfo(field, resolver) {
-    const enumType = resolver.findEnum(field.enum.typeName);
-    (0, assert_js_1.assert)(enumType, `message "${field.enum.typeName}" for ${field.toString()} not found`);
-    const base = {
-        no: field.number,
-        name: field.name,
-        kind: "enum",
-        T: enumType,
-    };
-    if (field.repeated) {
-        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined });
-    }
-    if (field.oneof) {
-        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
-    }
-    if (field.optional) {
-        return Object.assign(Object.assign({}, base), { opt: true });
-    }
-    return base;
-}
-function parseDefaultValue(field) {
-    const d = field.proto.defaultValue;
-    if (d === undefined) {
-        return undefined;
-    }
-    if (field.enum) {
-        const enumValue = field.enum.values.find((v) => v.name === d);
-        (0, assert_js_1.assert)(enumValue, `cannot parse ${field.toString()} default value: ${d}`);
-        return enumValue.number;
-    }
-    if (field.scalarType) {
-        switch (field.scalarType) {
-            case field_js_1.ScalarType.STRING:
-                return d;
-            case field_js_1.ScalarType.BYTES: {
-                const u = unescapeBytesDefaultValue(d);
-                if (u === false) {
-                    throw new Error(`cannot parse ${field.toString()} default value: ${d}`);
-                }
-                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(d);
-            case field_js_1.ScalarType.UINT64:
-            case field_js_1.ScalarType.FIXED64:
-                return proto_int64_js_1.protoInt64.uParse(d);
-            case field_js_1.ScalarType.DOUBLE:
-            case field_js_1.ScalarType.FLOAT:
-                switch (d) {
-                    case "inf":
-                        return Number.POSITIVE_INFINITY;
-                    case "-inf":
-                        return Number.NEGATIVE_INFINITY;
-                    case "nan":
-                        return Number.NaN;
-                    default:
-                        return parseFloat(d);
-                }
-            case field_js_1.ScalarType.BOOL:
-                return Boolean(d);
-            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(d, 10);
-        }
-    }
-    return undefined;
-}
-// unescapeBytesDefaultValue 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);
-}