@bufbuild/protoplugin 1.9.0 → 2.0.0-alpha.2

package/dist/cjs/ecmascript/schema.js

@@ -15,37 +15,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSchema = void 0;
 const protobuf_1 = require("@bufbuild/protobuf");
+const wkt_1 = require("@bufbuild/protobuf/wkt");
+const reflect_1 = require("@bufbuild/protobuf/reflect");
 const generated_file_js_1 = require("./generated-file.js");
-const runtime_imports_js_1 = require("./runtime-imports.js");
 const import_symbol_js_1 = require("./import-symbol.js");
 const import_path_js_1 = require("./import-path.js");
 const file_preamble_js_1 = require("./file-preamble.js");
-function createSchema(request, parameter, pluginName, pluginVersion, featureSetDefaults) {
-    const descriptorSet = (0, protobuf_1.createDescriptorSet)(request.protoFile, {
-        featureSetDefaults,
-    });
-    const filesToGenerate = findFilesToGenerate(descriptorSet, request);
-    const runtime = (0, runtime_imports_js_1.createRuntimeImports)(parameter.bootstrapWkt);
-    const createTypeImport = (desc) => {
-        const name = protobuf_1.codegenInfo.localName(desc);
-        const from = (0, import_path_js_1.makeImportPath)(desc.file, parameter.bootstrapWkt, filesToGenerate);
-        return (0, import_symbol_js_1.createImportSymbol)(name, from);
-    };
-    const createPreamble = (descFile) => (0, file_preamble_js_1.makeFilePreamble)(descFile, pluginName, pluginVersion, parameter.sanitizedParameter, parameter.tsNocheck);
+const names_js_1 = require("./names.js");
+const runtime_imports_js_1 = require("./runtime-imports.js");
+function createSchema(request, parameter, pluginName, pluginVersion, minimumEdition, maximumEdition) {
+    const { allFiles, filesToGenerate } = getFilesToGenerate(request, minimumEdition, maximumEdition);
     let target;
     const generatedFiles = [];
+    const runtime = (0, runtime_imports_js_1.createRuntimeImports)(parameter.bootstrapWkt);
+    const resolveDescImport = (desc, typeOnly) => (0, import_symbol_js_1.createImportSymbol)((0, names_js_1.localDescName)(desc), (0, names_js_1.generateFilePath)(desc.kind == "file" ? desc : desc.file, parameter.bootstrapWkt, filesToGenerate), typeOnly);
+    const resolveShapeImport = (desc) => (0, import_symbol_js_1.createImportSymbol)((0, names_js_1.localShapeName)(desc), (0, names_js_1.generateFilePath)(desc.file, parameter.bootstrapWkt, filesToGenerate), true);
+    const createPreamble = (descFile) => (0, file_preamble_js_1.makeFilePreamble)(descFile, pluginName, pluginVersion, parameter.sanitizedParameter, parameter.tsNocheck);
+    const rewriteImport = (importPath) => (0, import_path_js_1.rewriteImportPath)(importPath, parameter.rewriteImports, parameter.importExtension);
     return {
         targets: parameter.targets,
-        runtime,
         proto: request,
         files: filesToGenerate,
-        allFiles: descriptorSet.files,
+        allFiles: allFiles,
+        typesInFile: reflect_1.nestedTypes,
         generateFile(name) {
             if (target === undefined) {
                 throw new Error("prepareGenerate() must be called before generateFile()");
             }
             const genFile = (0, generated_file_js_1.createGeneratedFile)(name, (0, import_path_js_1.deriveImportPath)(name), target === "js" ? parameter.jsImportStyle : "module", // ts and dts always use import/export, only js may use commonjs
-            (importPath) => (0, import_path_js_1.rewriteImportPath)(importPath, parameter.rewriteImports, parameter.importExtension), createTypeImport, runtime, createPreamble);
+            rewriteImport, resolveDescImport, resolveShapeImport, createPreamble, runtime);
             generatedFiles.push(genFile);
             return genFile;
         },
@@ -60,10 +58,64 @@ function createSchema(request, parameter, pluginName, pluginVersion, featureSetD
     };
 }
 exports.createSchema = createSchema;
-function findFilesToGenerate(descriptorSet, request) {
-    const missing = request.fileToGenerate.filter((fileToGenerate) => descriptorSet.files.every((file) => fileToGenerate !== file.name + ".proto"));
+function getFilesToGenerate(request, minimumEdition, maximumEdition) {
+    if (minimumEdition > maximumEdition) {
+        throw new Error(`configured minimumEdition ${editionToString(minimumEdition)} > maximumEdition ${editionToString(maximumEdition)} - please contact plugin author`);
+    }
+    const missing = request.fileToGenerate.filter((fileToGenerate) => !request.protoFile.find((f) => f.name === fileToGenerate));
     if (missing.length) {
-        throw `files_to_generate missing in the request: ${missing.join(", ")}`;
+        throw new Error(`files_to_generate missing in the request: ${missing.join(", ")}`);
+    }
+    for (const file of request.protoFile) {
+        if (request.fileToGenerate.includes(file.name)) {
+            let edition;
+            switch (file.syntax) {
+                case "":
+                case "proto2":
+                    edition = wkt_1.Edition.EDITION_PROTO2;
+                    break;
+                case "proto3":
+                    edition = wkt_1.Edition.EDITION_PROTO3;
+                    break;
+                case "editions":
+                    edition = file.edition;
+                    break;
+                default:
+                    edition = wkt_1.Edition.EDITION_UNKNOWN;
+                    break;
+            }
+            if (edition < minimumEdition) {
+                throw new Error(`${file.name}: unsupported edition ${editionToString(edition)} - the earliest supported edition is ${editionToString(minimumEdition)}`);
+            }
+            if (edition > maximumEdition) {
+                throw new Error(`${file.name}: unsupported edition ${editionToString(edition)} - the latest supported edition is ${editionToString(maximumEdition)}`);
+            }
+        }
+    }
+    // Our goal is to provide options with source retention to plugin authors.
+    // CodeGeneratorRequest.proto_file elides options with source retention for
+    // files to generate. For these files, we take the file from source_file_descriptors,
+    // which does include options with source retention.
+    const allProtoWithSourceOptions = request.protoFile.map((protoFile) => {
+        const sourceFile = request.sourceFileDescriptors.find((s) => s.name == protoFile.name);
+        return sourceFile !== null && sourceFile !== void 0 ? sourceFile : protoFile;
+    });
+    const registry = (0, reflect_1.createFileRegistry)((0, protobuf_1.create)(wkt_1.FileDescriptorSetDesc, {
+        file: allProtoWithSourceOptions,
+    }));
+    const allFiles = [];
+    const filesToGenerate = [];
+    for (const file of registry.files) {
+        allFiles.push(file);
+        if (request.fileToGenerate.includes(file.proto.name)) {
+            filesToGenerate.push(file);
+        }
+    }
+    return { allFiles, filesToGenerate };
+}
+function editionToString(edition) {
+    if (edition in wkt_1.Edition) {
+        return wkt_1.Edition[edition].replace(/^EDITION_/, "");
     }
-    return descriptorSet.files.filter((file) => request.fileToGenerate.includes(file.name + ".proto"));
+    return `unknown (${edition})`;
 }

package/dist/cjs/index.d.ts

@@ -1,8 +1,4 @@
-import type { Schema as SchemaInternal } from "./ecmascript/schema.js";
 export type { Plugin } from "./plugin.js";
 export { runNodeJs } from "./run-node.js";
 export { createEcmaScriptPlugin } from "./create-es-plugin.js";
-/**
- * @deprecated Please use Schema from @bufbuild/protoplugin/ecmascript instead
- */
-export type Schema = SchemaInternal;
+export { getComments, getDeclarationString, getPackageComments, getSyntaxComments, } from "./source-code-info.js";

package/dist/cjs/index.js

@@ -13,8 +13,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEcmaScriptPlugin = exports.runNodeJs = void 0;
+exports.getSyntaxComments = exports.getPackageComments = exports.getDeclarationString = exports.getComments = exports.createEcmaScriptPlugin = exports.runNodeJs = void 0;
 var run_node_js_1 = require("./run-node.js");
 Object.defineProperty(exports, "runNodeJs", { enumerable: true, get: function () { return run_node_js_1.runNodeJs; } });
 var create_es_plugin_js_1 = require("./create-es-plugin.js");
 Object.defineProperty(exports, "createEcmaScriptPlugin", { enumerable: true, get: function () { return create_es_plugin_js_1.createEcmaScriptPlugin; } });
+var source_code_info_js_1 = require("./source-code-info.js");
+Object.defineProperty(exports, "getComments", { enumerable: true, get: function () { return source_code_info_js_1.getComments; } });
+Object.defineProperty(exports, "getDeclarationString", { enumerable: true, get: function () { return source_code_info_js_1.getDeclarationString; } });
+Object.defineProperty(exports, "getPackageComments", { enumerable: true, get: function () { return source_code_info_js_1.getPackageComments; } });
+Object.defineProperty(exports, "getSyntaxComments", { enumerable: true, get: function () { return source_code_info_js_1.getSyntaxComments; } });

package/dist/cjs/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { CodeGeneratorRequest, CodeGeneratorResponse } from "@bufbuild/protobuf";
+import type { CodeGeneratorRequest, CodeGeneratorResponse } from "@bufbuild/protobuf/wkt";
 /**
  * Represents any code generator plugin.
  */

package/dist/cjs/run-node.js

@@ -14,8 +14,9 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runNodeJs = void 0;
-const protobuf_1 = require("@bufbuild/protobuf");
 const error_js_1 = require("./error.js");
+const protobuf_1 = require("@bufbuild/protobuf");
+const wkt_1 = require("@bufbuild/protobuf/wkt");
 /**
  * Run a plugin with Node.js.
  *
@@ -40,9 +41,9 @@ function runNodeJs(plugin) {
     }
     readBytes(process.stdin)
         .then((data) => {
-        const req = protobuf_1.CodeGeneratorRequest.fromBinary(data);
+        const req = (0, protobuf_1.fromBinary)(wkt_1.CodeGeneratorRequestDesc, data);
         const res = plugin.run(req);
-        return writeBytes(process.stdout, res.toBinary());
+        return writeBytes(process.stdout, (0, protobuf_1.toBinary)(wkt_1.CodeGeneratorResponseDesc, res));
     })
         .then(() => process.exit(0))
         .catch((reason) => {

package/dist/cjs/source-code-info.d.ts

@@ -0,0 +1,23 @@
+import { type AnyDesc, type DescComments, type DescEnumValue, type DescExtension, type DescField, type DescFile } from "@bufbuild/protobuf";
+/**
+ * Get comments on the package element in the protobuf source.
+ */
+export declare function getPackageComments(desc: DescFile): DescComments;
+/**
+ * Get comments on the syntax element in the protobuf source.
+ */
+export declare function getSyntaxComments(desc: DescFile): DescComments;
+/**
+ * Get comments on the element in the protobuf source.
+ */
+export declare function getComments(desc: Exclude<AnyDesc, DescFile>): DescComments;
+/**
+ * Get feature options set on the element in the protobuf source. This returns
+ * compact (e.g. fields) or regular options (e.g. files) as an array of strings.
+ */
+export declare function getFeatureOptionStrings(desc: AnyDesc): string[];
+/**
+ * Return a string that matches the definition of a field in the protobuf
+ * source. Does not take custom options into account.
+ */
+export declare function getDeclarationString(desc: DescField | DescExtension | DescEnumValue): string;

package/dist/cjs/source-code-info.js

@@ -0,0 +1,286 @@
+"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.getDeclarationString = exports.getFeatureOptionStrings = exports.getComments = exports.getSyntaxComments = exports.getPackageComments = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const reflect_1 = require("@bufbuild/protobuf/reflect");
+const wkt_1 = require("@bufbuild/protobuf/wkt");
+/**
+ * Get comments on the package element in the protobuf source.
+ */
+function getPackageComments(desc) {
+    return findComments(desc.proto.sourceCodeInfo, [
+        wkt_1.FileDescriptorProtoDesc.field.package.number,
+    ]);
+}
+exports.getPackageComments = getPackageComments;
+/**
+ * Get comments on the syntax element in the protobuf source.
+ */
+function getSyntaxComments(desc) {
+    return findComments(desc.proto.sourceCodeInfo, [
+        wkt_1.FileDescriptorProtoDesc.field.syntax.number,
+    ]);
+}
+exports.getSyntaxComments = getSyntaxComments;
+/**
+ * Get comments on the element in the protobuf source.
+ */
+function getComments(desc) {
+    let path = [];
+    let file;
+    switch (desc.kind) {
+        case "enum":
+            path = desc.parent
+                ? [
+                    ...getComments(desc.parent).sourcePath,
+                    wkt_1.DescriptorProtoDesc.field.enumType.number,
+                    desc.parent.proto.enumType.indexOf(desc.proto),
+                ]
+                : [
+                    wkt_1.FileDescriptorProtoDesc.field.enumType.number,
+                    desc.file.proto.enumType.indexOf(desc.proto),
+                ];
+            file = desc.file;
+            break;
+        case "oneof":
+            path = [
+                ...getComments(desc.parent).sourcePath,
+                wkt_1.DescriptorProtoDesc.field.oneofDecl.number,
+                desc.parent.proto.oneofDecl.indexOf(desc.proto),
+            ];
+            file = desc.parent.file;
+            break;
+        case "message":
+            path = desc.parent
+                ? [
+                    ...getComments(desc.parent).sourcePath,
+                    wkt_1.DescriptorProtoDesc.field.nestedType.number,
+                    desc.parent.proto.nestedType.indexOf(desc.proto),
+                ]
+                : [
+                    wkt_1.FileDescriptorProtoDesc.field.messageType.number,
+                    desc.file.proto.messageType.indexOf(desc.proto),
+                ];
+            file = desc.file;
+            break;
+        case "enum_value":
+            path = [
+                ...getComments(desc.parent).sourcePath,
+                wkt_1.EnumDescriptorProtoDesc.field.value.number,
+                desc.parent.proto.value.indexOf(desc.proto),
+            ];
+            file = desc.parent.file;
+            break;
+        case "field":
+            path = [
+                ...getComments(desc.parent).sourcePath,
+                wkt_1.DescriptorProtoDesc.field.field.number,
+                desc.parent.proto.field.indexOf(desc.proto),
+            ];
+            file = desc.parent.file;
+            break;
+        case "extension":
+            path = desc.parent
+                ? [
+                    ...getComments(desc.parent).sourcePath,
+                    wkt_1.DescriptorProtoDesc.field.extension.number,
+                    desc.parent.proto.extension.indexOf(desc.proto),
+                ]
+                : [
+                    wkt_1.FileDescriptorProtoDesc.field.extension.number,
+                    desc.file.proto.extension.indexOf(desc.proto),
+                ];
+            file = desc.file;
+            break;
+        case "service":
+            path = [
+                wkt_1.FileDescriptorProtoDesc.field.service.number,
+                desc.file.proto.service.indexOf(desc.proto),
+            ];
+            file = desc.file;
+            break;
+        case "rpc":
+            path = [
+                ...getComments(desc.parent).sourcePath,
+                wkt_1.ServiceDescriptorProtoDesc.field.method.number,
+                desc.parent.proto.method.indexOf(desc.proto),
+            ];
+            file = desc.parent.file;
+            break;
+    }
+    return findComments(file.proto.sourceCodeInfo, path);
+}
+exports.getComments = getComments;
+/**
+ * Get feature options set on the element in the protobuf source. This returns
+ * compact (e.g. fields) or regular options (e.g. files) as an array of strings.
+ */
+function getFeatureOptionStrings(desc) {
+    var _a, _b;
+    const strings = [];
+    const features = (_a = desc.proto.options) === null || _a === void 0 ? void 0 : _a.features;
+    if (features !== undefined) {
+        const r = (0, reflect_1.reflect)(wkt_1.FeatureSetDesc, features);
+        for (const f of r.fields) {
+            if (f.fieldKind != "enum" || !r.isSet(f)) {
+                continue;
+            }
+            const val = r.get(f);
+            const name = (_b = f.enum.values.find((v) => v.number == val)) === null || _b === void 0 ? void 0 : _b.name;
+            if (name !== undefined) {
+                strings.push(`features.${f.name} = ${name}`);
+            }
+        }
+    }
+    return strings;
+}
+exports.getFeatureOptionStrings = getFeatureOptionStrings;
+/**
+ * Return a string that matches the definition of a field in the protobuf
+ * source. Does not take custom options into account.
+ */
+function getDeclarationString(desc) {
+    var _a;
+    if (desc.kind === "enum_value") {
+        let str = `${desc.name} = ${desc.number}`;
+        if (((_a = desc.proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) === true) {
+            str += " [deprecated = true]";
+        }
+        return str;
+    }
+    const parts = [];
+    function typeName(f) {
+        if (f.message) {
+            return f.message.typeName;
+        }
+        if (f.enum) {
+            return f.enum.typeName;
+        }
+        return reflect_1.ScalarType[f.scalar].toLowerCase();
+    }
+    switch (desc.fieldKind) {
+        case "scalar":
+        case "enum":
+        case "message":
+            if (fieldHasRequiredKeyword(desc)) {
+                parts.push("required");
+            }
+            if (fieldHasOptionalKeyword(desc)) {
+                parts.push("optional");
+            }
+            parts.push(typeName(desc));
+            break;
+        case "list":
+            parts.push("repeated", typeName(desc));
+            break;
+        case "map": {
+            const k = reflect_1.ScalarType[desc.mapKey].toLowerCase();
+            const v = typeName(desc);
+            parts.push(`map<${k}, ${v}>`);
+            break;
+        }
+    }
+    parts.push(desc.name, "=", desc.number.toString());
+    const options = [];
+    const protoOptions = desc.proto.options;
+    if (protoOptions !== undefined &&
+        (0, protobuf_1.isFieldSet)(protoOptions, wkt_1.FieldOptionsDesc.field.packed)) {
+        options.push(`packed = ${protoOptions.packed.toString()}`);
+    }
+    if ((0, protobuf_1.isFieldSet)(desc.proto, wkt_1.FieldDescriptorProtoDesc.field.defaultValue)) {
+        let defaultValue = desc.proto.defaultValue;
+        if (desc.proto.type == wkt_1.FieldDescriptorProto_Type.BYTES ||
+            desc.proto.type == wkt_1.FieldDescriptorProto_Type.STRING) {
+            defaultValue = '"' + defaultValue.replace('"', '\\"') + '"';
+        }
+        options.push(`default = ${defaultValue}`);
+    }
+    if (desc.kind == "field" && desc.jsonName !== (0, reflect_1.protoCamelCase)(desc.name)) {
+        options.push(`json_name = "${desc.jsonName}"`);
+    }
+    if (protoOptions !== undefined &&
+        (0, protobuf_1.isFieldSet)(protoOptions, wkt_1.FieldOptionsDesc.field.jstype)) {
+        options.push(`jstype = ${wkt_1.FieldOptions_JSType[protoOptions.jstype]}`);
+    }
+    if (protoOptions !== undefined &&
+        (0, protobuf_1.isFieldSet)(protoOptions, wkt_1.FieldOptionsDesc.field.deprecated)) {
+        options.push(`deprecated = true`);
+    }
+    options.push(...getFeatureOptionStrings(desc));
+    if (options.length > 0) {
+        parts.push("[" + options.join(", ") + "]");
+    }
+    return parts.join(" ");
+}
+exports.getDeclarationString = getDeclarationString;
+/**
+ * Whether this field was declared with `required` in the protobuf source.
+ */
+function fieldHasRequiredKeyword(field) {
+    const edition = (field.kind == "extension" ? field.file : field.parent.file)
+        .edition;
+    return (edition == wkt_1.Edition.EDITION_PROTO2 &&
+        field.proto.label == wkt_1.FieldDescriptorProto_Label.REQUIRED);
+}
+/**
+ * Whether this field was declared with `optional` in the protobuf source.
+ * Note that message fields are always optional. It is impossible to determine
+ * whether the keyword was used.
+ */
+function fieldHasOptionalKeyword(field) {
+    const edition = (field.kind == "extension" ? field.file : field.parent.file)
+        .edition;
+    if (edition == wkt_1.Edition.EDITION_PROTO2) {
+        return (!field.oneof && field.proto.label == wkt_1.FieldDescriptorProto_Label.OPTIONAL);
+    }
+    if (edition == wkt_1.Edition.EDITION_PROTO3) {
+        return field.proto.proto3Optional;
+    }
+    return false;
+}
+/**
+ * Find comments.
+ */
+function findComments(sourceCodeInfo, sourcePath) {
+    if (!sourceCodeInfo) {
+        return {
+            leadingDetached: [],
+            sourcePath,
+        };
+    }
+    for (const location of sourceCodeInfo.location) {
+        if (location.path.length !== sourcePath.length) {
+            continue;
+        }
+        if (location.path.some((value, index) => sourcePath[index] !== value)) {
+            continue;
+        }
+        return {
+            leadingDetached: location.leadingDetachedComments,
+            leading: (0, protobuf_1.isFieldSet)(location, wkt_1.SourceCodeInfo_LocationDesc.field.leadingComments)
+                ? location.leadingComments
+                : undefined,
+            trailing: (0, protobuf_1.isFieldSet)(location, wkt_1.SourceCodeInfo_LocationDesc.field.trailingComments)
+                ? location.trailingComments
+                : undefined,
+            sourcePath,
+        };
+    }
+    return {
+        leadingDetached: [],
+        sourcePath,
+    };
+}

package/dist/esm/create-es-plugin.d.ts

@@ -1,7 +1,7 @@
+import type { SupportedEdition } from "@bufbuild/protobuf";
 import type { Schema } from "./ecmascript/schema.js";
 import type { FileInfo } from "./ecmascript/generated-file.js";
 import type { Plugin } from "./plugin.js";
-import type { FeatureSetDefaults } from "@bufbuild/protobuf";
 interface PluginInit {
     /**
      * Name of this code generator plugin.
@@ -17,19 +17,15 @@ interface PluginInit {
      */
     parseOption?: (key: string, value: string) => void;
     /**
-     * Whether the plugin supports editions.
+     * The earliest edition supported by this plugin. Defaults to the minimum
+     * edition supported by @bufbuild/protobuf.
      */
-    supportsEditions?: boolean;
+    minimumEdition?: SupportedEdition;
     /**
-     * By default, plugins support all editions supported by createDescriptorSet()
-     * from @bufbuild/protobuf, if supportsEditions is enabled.
-     *
-     * This option can be used to limit support for specific editions, by providing
-     * your own google.protobuf.FeatureSetDefaults generated by protoc with the
-     * flags --experimental_edition_defaults_out, --experimental_edition_defaults_minimum,
-     * and --experimental_edition_defaults_maximum.
+     * The latest edition supported by this plugin. Defaults to the maximum
+     * edition supported by @bufbuild/protobuf.
      */
-    featureSetDefaults?: FeatureSetDefaults;
+    maximumEdition?: SupportedEdition;
     /**
      * A function which will generate TypeScript files based on proto input.
      * This function will be invoked by the plugin framework when the plugin runs.

package/dist/esm/create-es-plugin.js

@@ -11,10 +11,12 @@
 // 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 { create, protoInt64 } from "@bufbuild/protobuf";
+import { minimumEdition as minimumEditionUpstream, maximumEdition as maximumEditionUpstream, } from "@bufbuild/protobuf/reflect";
+import { CodeGeneratorResponse_Feature, CodeGeneratorResponseDesc, } from "@bufbuild/protobuf/wkt";
 import { createSchema } from "./ecmascript/schema.js";
 import { transpile } from "./ecmascript/transpile.js";
 import { parseParameter } from "./ecmascript/parameter.js";
-import { CodeGeneratorResponse, CodeGeneratorResponse_Feature, protoInt64, } from "@bufbuild/protobuf";
 /**
  * Create a new code generator plugin for ECMAScript.
  * The plugin can generate JavaScript, TypeScript, or TypeScript declaration
@@ -27,9 +29,11 @@ export function createEcmaScriptPlugin(init) {
         name: init.name,
         version: init.version,
         run(req) {
-            var _a, _b;
+            var _a, _b, _c;
+            const minimumEdition = (_a = init.minimumEdition) !== null && _a !== void 0 ? _a : minimumEditionUpstream;
+            const maximumEdition = (_b = init.maximumEdition) !== null && _b !== void 0 ? _b : maximumEditionUpstream;
             const parameter = parseParameter(req.parameter, init.parseOption);
-            const schema = createSchema(req, parameter, init.name, init.version, init.featureSetDefaults);
+            const schema = createSchema(req, parameter, init.name, init.version, minimumEdition, maximumEdition);
             const targetTs = schema.targets.includes("ts");
             const targetJs = schema.targets.includes("js");
             const targetDts = schema.targets.includes("dts");
@@ -88,23 +92,21 @@ export function createEcmaScriptPlugin(init) {
             // but no generate function was provided.  This also means that we will
             // have generated .ts files above.
             if (transpileJs || transpileDts) {
-                const transpileFn = (_a = init.transpile) !== null && _a !== void 0 ? _a : transpile;
+                const transpileFn = (_c = init.transpile) !== null && _c !== void 0 ? _c : transpile;
                 // Transpile the TypeScript files and add to the master list of files
                 const transpiledFiles = transpileFn(tsFiles, transpileJs, transpileDts, parameter.jsImportStyle);
                 files.push(...transpiledFiles);
             }
-            return toResponse(files, (_b = init.supportsEditions) !== null && _b !== void 0 ? _b : false);
+            return toResponse(files, minimumEdition, maximumEdition);
         },
     };
 }
-function toResponse(files, supportsEditions) {
-    let supportedFeatures = CodeGeneratorResponse_Feature.PROTO3_OPTIONAL;
-    if (supportsEditions) {
-        supportedFeatures =
-            supportedFeatures | CodeGeneratorResponse_Feature.SUPPORTS_EDITIONS;
-    }
-    return new CodeGeneratorResponse({
-        supportedFeatures: protoInt64.parse(supportedFeatures),
+function toResponse(files, minimumEdition, maximumEdition) {
+    return create(CodeGeneratorResponseDesc, {
+        supportedFeatures: protoInt64.parse(CodeGeneratorResponse_Feature.PROTO3_OPTIONAL |
+            CodeGeneratorResponse_Feature.SUPPORTS_EDITIONS),
+        minimumEdition,
+        maximumEdition,
         file: files.map((f) => {
             if (f.preamble !== undefined) {
                 f.content = f.preamble + "\n" + f.content;

package/dist/esm/ecmascript/file-preamble.js

@@ -11,7 +11,8 @@
 // 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 { Edition } from "@bufbuild/protobuf";
+import { Edition } from "@bufbuild/protobuf/wkt";
+import { getPackageComments, getSyntaxComments, getFeatureOptionStrings, } from "../source-code-info.js";
 export function makeFilePreamble(file, pluginName, pluginVersion, parameter, tsNoCheck) {
     const builder = [];
     const trimSuffix = (str, suffix) => str.endsWith(suffix) ? str.substring(0, str.length - suffix.length) : str;
@@ -31,14 +32,14 @@ export function makeFilePreamble(file, pluginName, pluginVersion, parameter, tsN
             builder.push("\n");
         }
     };
-    writeLeadingComments(file.getSyntaxComments());
+    writeLeadingComments(getSyntaxComments(file));
     builder.push(`// @generated by ${pluginName} ${pluginVersion}`);
     if (parameter !== "") {
         builder.push(` with parameter "${parameter}"`);
     }
     builder.push("\n");
     builder.push(`// @generated from file ${file.name}.proto (`);
-    if (file.proto.package !== undefined) {
+    if (file.proto.package.length > 0) {
         builder.push(`package ${file.proto.package}, `);
     }
     switch (file.edition) {
@@ -60,11 +61,14 @@ export function makeFilePreamble(file, pluginName, pluginVersion, parameter, tsN
             break;
         }
     }
+    for (const o of getFeatureOptionStrings(file)) {
+        builder.push(`// option ${o};\n`);
+    }
     builder.push("/* eslint-disable */\n");
     if (tsNoCheck) {
         builder.push("// @ts-nocheck\n");
     }
     builder.push("\n");
-    writeLeadingComments(file.getPackageComments());
+    writeLeadingComments(getPackageComments(file));
     return trimSuffix(builder.join(""), "\n");
 }