@bufbuild/protobuf 1.9.0 → 2.0.0-alpha.2

package/dist/esm/codegenv1/embed.js

@@ -0,0 +1,232 @@
+// 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 { protoCamelCase } from "../reflect/names.js";
+import { assert } from "../reflect/assert.js";
+import { isFieldSet, clearField } from "../fields.js";
+import { base64Encode } from "../wire/base64-encoding.js";
+import { toBinary } from "../to-binary.js";
+import { clone } from "../clone.js";
+import { Edition, FieldDescriptorProtoDesc, FieldOptionsDesc, FileDescriptorProtoDesc, } from "../wkt/gen/google/protobuf/descriptor_pb.js";
+/**
+ * Create necessary information to embed a file descriptor in
+ * generated code.
+ *
+ * @private
+ */
+export function embedFileDesc(file) {
+    const embed = {
+        bootable: false,
+        proto() {
+            const stripped = clone(FileDescriptorProtoDesc, file);
+            clearField(stripped, FileDescriptorProtoDesc.field.dependency);
+            clearField(stripped, FileDescriptorProtoDesc.field.sourceCodeInfo);
+            stripped.messageType.map(stripJsonNames);
+            return stripped;
+        },
+        base64() {
+            const bytes = toBinary(FileDescriptorProtoDesc, this.proto());
+            return base64Encode(bytes, "std_raw");
+        },
+    };
+    return file.name == "google/protobuf/descriptor.proto"
+        ? Object.assign(Object.assign({}, embed), { bootable: true, boot() {
+                return createFileDescriptorProtoBoot(this.proto());
+            } }) : embed;
+}
+function stripJsonNames(d) {
+    for (const f of d.field) {
+        if (f.jsonName === protoCamelCase(f.name)) {
+            clearField(f, FieldDescriptorProtoDesc.field.jsonName);
+        }
+    }
+    for (const n of d.nestedType) {
+        stripJsonNames(n);
+    }
+}
+/**
+ * Compute the path to a message, enumeration, extension, or service in a
+ * file descriptor.
+ *
+ * @private
+ */
+export function pathInFileDesc(desc) {
+    if (desc.kind == "service") {
+        return [desc.file.services.indexOf(desc)];
+    }
+    const parent = desc.parent;
+    if (parent == undefined) {
+        switch (desc.kind) {
+            case "enum":
+                return [desc.file.enums.indexOf(desc)];
+            case "message":
+                return [desc.file.messages.indexOf(desc)];
+            case "extension":
+                return [desc.file.extensions.indexOf(desc)];
+        }
+    }
+    function findPath(cur) {
+        const nested = [];
+        for (let parent = cur.parent; parent;) {
+            const idx = parent.nestedMessages.indexOf(cur);
+            nested.unshift(idx);
+            cur = parent;
+            parent = cur.parent;
+        }
+        nested.unshift(cur.file.messages.indexOf(cur));
+        return nested;
+    }
+    const path = findPath(parent);
+    switch (desc.kind) {
+        case "extension":
+            return [...path, parent.nestedExtensions.indexOf(desc)];
+        case "message":
+            return [...path, parent.nestedMessages.indexOf(desc)];
+        case "enum":
+            return [...path, parent.nestedEnums.indexOf(desc)];
+    }
+}
+/**
+ * The file descriptor for google/protobuf/descriptor.proto cannot be embedded
+ * in serialized form, since it is required to parse itself.
+ *
+ * This function takes an instance of the message, and returns a plain object
+ * that can be hydrated to the message again via bootFileDescriptorProto().
+ *
+ * This function only works with a message google.protobuf.FileDescriptorProto
+ * for google/protobuf/descriptor.proto, and only supports features that are
+ * relevant for the specific use case. For example, it discards file options,
+ * reserved ranges and reserved names, and field options that are unused in
+ * descriptor.proto.
+ *
+ * @private
+ */
+export function createFileDescriptorProtoBoot(proto) {
+    var _a;
+    assert(proto.name == "google/protobuf/descriptor.proto");
+    assert(proto.package == "google.protobuf");
+    assert(!proto.dependency.length);
+    assert(!proto.publicDependency.length);
+    assert(!proto.weakDependency.length);
+    assert(!proto.service.length);
+    assert(!proto.extension.length);
+    assert(proto.sourceCodeInfo === undefined);
+    assert(proto.syntax == "" || proto.syntax == "proto2");
+    assert(!((_a = proto.options) === null || _a === void 0 ? void 0 : _a.features)); // we're dropping file options
+    assert(proto.edition === Edition.EDITION_UNKNOWN);
+    return {
+        name: proto.name,
+        package: proto.package,
+        messageType: proto.messageType.map(createDescriptorBoot),
+        enumType: proto.enumType.map(createEnumDescriptorBoot),
+    };
+}
+function createDescriptorBoot(proto) {
+    assert(proto.extension.length == 0);
+    assert(!proto.oneofDecl.length);
+    assert(!proto.options);
+    assert(!proto.reservedName.length); // we're also dropping reserved_range
+    const b = {
+        name: proto.name,
+    };
+    if (proto.field.length) {
+        b.field = proto.field.map(createFieldDescriptorBoot);
+    }
+    if (proto.nestedType.length) {
+        b.nestedType = proto.nestedType.map(createDescriptorBoot);
+    }
+    if (proto.enumType.length) {
+        b.enumType = proto.enumType.map(createEnumDescriptorBoot);
+    }
+    if (proto.extensionRange.length) {
+        b.extensionRange = proto.extensionRange.map((r) => {
+            assert(!r.options);
+            return { start: r.start, end: r.end };
+        });
+    }
+    return b;
+}
+function createFieldDescriptorBoot(proto) {
+    assert(isFieldSet(proto, FieldDescriptorProtoDesc.field.name));
+    assert(isFieldSet(proto, FieldDescriptorProtoDesc.field.number));
+    assert(isFieldSet(proto, FieldDescriptorProtoDesc.field.type));
+    assert(!isFieldSet(proto, FieldDescriptorProtoDesc.field.oneofIndex));
+    assert(!isFieldSet(proto, FieldDescriptorProtoDesc.field.jsonName) ||
+        proto.jsonName === protoCamelCase(proto.name));
+    const b = {
+        name: proto.name,
+        number: proto.number,
+        type: proto.type,
+    };
+    if (isFieldSet(proto, FieldDescriptorProtoDesc.field.label)) {
+        b.label = proto.label;
+    }
+    if (isFieldSet(proto, FieldDescriptorProtoDesc.field.typeName)) {
+        b.typeName = proto.typeName;
+    }
+    if (isFieldSet(proto, FieldDescriptorProtoDesc.field.extendee)) {
+        b.extendee = proto.extendee;
+    }
+    if (isFieldSet(proto, FieldDescriptorProtoDesc.field.defaultValue)) {
+        b.defaultValue = proto.defaultValue;
+    }
+    if (proto.options) {
+        b.options = createFieldOptionsBoot(proto.options);
+    }
+    return b;
+}
+function createFieldOptionsBoot(proto) {
+    const b = {};
+    assert(!isFieldSet(proto, FieldOptionsDesc.field.ctype));
+    if (isFieldSet(proto, FieldOptionsDesc.field.packed)) {
+        b.packed = proto.packed;
+    }
+    assert(!isFieldSet(proto, FieldOptionsDesc.field.jstype));
+    assert(!isFieldSet(proto, FieldOptionsDesc.field.lazy));
+    assert(!isFieldSet(proto, FieldOptionsDesc.field.unverifiedLazy));
+    if (isFieldSet(proto, FieldOptionsDesc.field.deprecated)) {
+        b.deprecated = proto.deprecated;
+    }
+    assert(!isFieldSet(proto, FieldOptionsDesc.field.weak));
+    assert(!isFieldSet(proto, FieldOptionsDesc.field.debugRedact));
+    if (isFieldSet(proto, FieldOptionsDesc.field.retention)) {
+        b.retention = proto.retention;
+    }
+    if (proto.targets.length) {
+        b.targets = proto.targets;
+    }
+    if (proto.editionDefaults.length) {
+        b.editionDefaults = proto.editionDefaults.map((d) => ({
+            value: d.value,
+            edition: d.edition,
+        }));
+    }
+    assert(!isFieldSet(proto, FieldOptionsDesc.field.features));
+    assert(!isFieldSet(proto, FieldOptionsDesc.field.uninterpretedOption));
+    return b;
+}
+function createEnumDescriptorBoot(proto) {
+    assert(!proto.reservedName.length);
+    assert(!proto.reservedRange.length);
+    assert(!proto.options);
+    return {
+        name: proto.name,
+        value: proto.value.map((v) => {
+            assert(!v.options);
+            return {
+                name: v.name,
+                number: v.number,
+            };
+        }),
+    };
+}

package/dist/esm/codegenv1/enum.d.ts

@@ -0,0 +1,17 @@
+import type { DescEnum, DescFile } from "../desc-types.js";
+import type { GenDescEnum } from "./types.js";
+/**
+ * Hydrate an enum descriptor.
+ *
+ * @private
+ */
+export declare function enumDesc<Shape>(file: DescFile, path: number, ...paths: number[]): GenDescEnum<Shape>;
+/**
+ * Construct a TypeScript enum object at runtime from a descriptor.
+ */
+export declare function tsEnum(desc: DescEnum): enumObject;
+type enumObject = {
+    [key: number]: string;
+    [k: string]: number | string;
+};
+export {};

package/dist/esm/codegenv1/enum.js

@@ -0,0 +1,36 @@
+// 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.
+/**
+ * Hydrate an enum descriptor.
+ *
+ * @private
+ */
+export function enumDesc(file, path, ...paths) {
+    if (paths.length == 0) {
+        return file.enums[path];
+    }
+    const e = paths.pop(); // we checked length above
+    return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedEnums[e];
+}
+/**
+ * Construct a TypeScript enum object at runtime from a descriptor.
+ */
+export function tsEnum(desc) {
+    const enumObject = {};
+    for (const value of desc.values) {
+        enumObject[value.localName] = value.number;
+        enumObject[value.number] = value.localName;
+    }
+    return enumObject;
+}

package/dist/esm/codegenv1/extension.d.ts

@@ -0,0 +1,9 @@
+import type { Message } from "../types.js";
+import type { DescFile } from "../desc-types.js";
+import type { GenDescExtension } from "./types.js";
+/**
+ * Hydrate an extension descriptor.
+ *
+ * @private
+ */
+export declare function extDesc<Extendee extends Message, Value>(file: DescFile, path: number, ...paths: number[]): GenDescExtension<Extendee, Value>;

package/dist/esm/codegenv1/extension.js

@@ -0,0 +1,25 @@
+// 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.
+/**
+ * Hydrate an extension descriptor.
+ *
+ * @private
+ */
+export function extDesc(file, path, ...paths) {
+    if (paths.length == 0) {
+        return file.extensions[path];
+    }
+    const e = paths.pop(); // we checked length above
+    return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedExtensions[e];
+}

package/dist/esm/codegenv1/file.d.ts

@@ -0,0 +1,7 @@
+import type { DescFile } from "../desc-types.js";
+/**
+ * Hydrate a file descriptor.
+ *
+ * @private
+ */
+export declare function fileDesc(b64: string, imports?: DescFile[]): DescFile;

package/dist/esm/codegenv1/file.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 { base64Decode } from "../wire/index.js";
+import { FileDescriptorProtoDesc } from "../wkt/gen/google/protobuf/descriptor_pb.js";
+import { createFileRegistry } from "../reflect/registry.js";
+import { assert } from "../reflect/assert.js";
+import { restoreJsonNames } from "./restore-json-names.js";
+import { fromBinary } from "../from-binary.js";
+/**
+ * Hydrate a file descriptor.
+ *
+ * @private
+ */
+export function fileDesc(b64, imports) {
+    var _a;
+    const root = fromBinary(FileDescriptorProtoDesc, base64Decode(b64));
+    root.messageType.forEach(restoreJsonNames);
+    root.dependency = (_a = imports === null || imports === void 0 ? void 0 : imports.map((f) => f.proto.name)) !== null && _a !== void 0 ? _a : [];
+    const reg = createFileRegistry(root, (protoFileName) => imports === null || imports === void 0 ? void 0 : imports.find((f) => f.proto.name === protoFileName));
+    const file = reg.getFile(root.name);
+    assert(file);
+    return file;
+}

package/dist/esm/codegenv1/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./boot.js";
+export * from "./embed.js";
+export * from "./enum.js";
+export * from "./extension.js";
+export * from "./file.js";
+export * from "./message.js";
+export * from "./service.js";
+export * from "./symbols.js";
+export * from "./types.js";

package/dist/esm/codegenv1/index.js

@@ -0,0 +1,22 @@
+// 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 * from "./boot.js";
+export * from "./embed.js";
+export * from "./enum.js";
+export * from "./extension.js";
+export * from "./file.js";
+export * from "./message.js";
+export * from "./service.js";
+export * from "./symbols.js";
+export * from "./types.js";

package/dist/esm/codegenv1/message.d.ts

@@ -0,0 +1,9 @@
+import type { Message } from "../types.js";
+import type { DescFile } from "../desc-types.js";
+import type { GenDescMessage } from "./types.js";
+/**
+ * Hydrate a message descriptor.
+ *
+ * @private
+ */
+export declare function messageDesc<Shape extends Message>(file: DescFile, path: number, ...paths: number[]): GenDescMessage<Shape>;

package/dist/esm/codegenv1/message.js

@@ -0,0 +1,21 @@
+// 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.
+/**
+ * Hydrate a message descriptor.
+ *
+ * @private
+ */
+export function messageDesc(file, path, ...paths) {
+    return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]);
+}

package/dist/esm/codegenv1/restore-json-names.d.ts

@@ -0,0 +1,5 @@
+import type { DescriptorProto } from "../wkt/gen/google/protobuf/descriptor_pb.js";
+/**
+ * @private
+ */
+export declare function restoreJsonNames(message: DescriptorProto): void;

package/dist/esm/codegenv1/restore-json-names.js

@@ -0,0 +1,26 @@
+// 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 { protoCamelCase } from "../reflect/names.js";
+import { unsafeIsSetExplicit } from "../reflect/unsafe.js";
+/**
+ * @private
+ */
+export function restoreJsonNames(message) {
+    for (const f of message.field) {
+        if (!unsafeIsSetExplicit(f, "jsonName")) {
+            f.jsonName = protoCamelCase(f.name);
+        }
+    }
+    message.nestedType.forEach(restoreJsonNames);
+}

package/dist/esm/codegenv1/service.d.ts

@@ -0,0 +1,8 @@
+import type { GenDescService, GenDescServiceShape } from "./types.js";
+import type { DescFile } from "../desc-types.js";
+/**
+ * Hydrate a service descriptor.
+ *
+ * @private
+ */
+export declare function serviceDesc<T extends GenDescServiceShape>(file: DescFile, path: number, ...paths: number[]): GenDescService<T>;

package/dist/esm/codegenv1/service.js

@@ -0,0 +1,24 @@
+// 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.
+/**
+ * Hydrate a service descriptor.
+ *
+ * @private
+ */
+export function serviceDesc(file, path, ...paths) {
+    if (paths.length > 0) {
+        throw new Error();
+    }
+    return file.services[path];
+}

package/dist/esm/codegenv1/symbols.d.ts

@@ -0,0 +1,125 @@
+/**
+ * @private
+ */
+export declare const packageName = "@bufbuild/protobuf";
+/**
+ * @private
+ */
+export declare const wktPublicImportPaths: Readonly<Record<string, string>>;
+/**
+ * @private
+ */
+export declare const symbols: {
+    readonly isMessage: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../is-message.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly Message: {
+        readonly typeOnly: true;
+        readonly bootstrapWktFrom: "../../types.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly create: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../create.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly fromJson: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../from-json.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly fromJsonString: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../from-json.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly fromBinary: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../from-binary.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly toBinary: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../to-binary.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly toJson: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../to-json.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly toJsonString: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../to-json.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly protoInt64: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../proto-int64.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly codegen: {
+        readonly boot: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/boot.js";
+            readonly from: string;
+        };
+        readonly fileDesc: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/file.js";
+            readonly from: string;
+        };
+        readonly enumDesc: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/enum.js";
+            readonly from: string;
+        };
+        readonly extDesc: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/extension.js";
+            readonly from: string;
+        };
+        readonly messageDesc: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/message.js";
+            readonly from: string;
+        };
+        readonly serviceDesc: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/service.js";
+            readonly from: string;
+        };
+        readonly tsEnum: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/enum.js";
+            readonly from: string;
+        };
+        readonly GenDescFile: {
+            readonly typeOnly: true;
+            readonly bootstrapWktFrom: "../../codegenv1/types.js";
+            readonly from: string;
+        };
+        readonly GenDescEnum: {
+            readonly typeOnly: true;
+            readonly bootstrapWktFrom: "../../codegenv1/types.js";
+            readonly from: string;
+        };
+        readonly GenDescExtension: {
+            readonly typeOnly: true;
+            readonly bootstrapWktFrom: "../../codegenv1/types.js";
+            readonly from: string;
+        };
+        readonly GenDescMessage: {
+            readonly typeOnly: true;
+            readonly bootstrapWktFrom: "../../codegenv1/types.js";
+            readonly from: string;
+        };
+        readonly GenDescService: {
+            readonly typeOnly: true;
+            readonly bootstrapWktFrom: "../../codegenv1/types.js";
+            readonly from: string;
+        };
+    };
+};