@bufbuild/protoplugin 2.0.0-alpha.3 → 2.0.0-beta.1

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

@@ -2,7 +2,8 @@ import { type SupportedEdition } from "@bufbuild/protobuf";
 import type { Schema } from "./schema.js";
 import type { FileInfo } from "./generated-file.js";
 import type { Plugin } from "./plugin.js";
-interface PluginInit {
+import type { RawPluginOptions } from "./parameter.js";
+interface PluginInit<Options extends object> {
     /**
      * Name of this code generator plugin.
      */
@@ -15,7 +16,7 @@ interface PluginInit {
      * An optional parsing function which can be used to parse your own plugin
      * options.
      */
-    parseOption?: (key: string, value: string) => void;
+    parseOptions?: (rawOptions: RawPluginOptions) => Options;
     /**
      * The earliest edition supported by this plugin. Defaults to the minimum
      * edition supported by @bufbuild/protobuf.
@@ -32,7 +33,7 @@ interface PluginInit {
      *
      * Note that this is required to be provided for plugin initialization.
      */
-    generateTs: (schema: Schema, target: "ts") => void;
+    generateTs: (schema: Schema<Options>, target: "ts") => void;
     /**
      * A optional function which will generate JavaScript files based on proto
      * input.  This function will be invoked by the  plugin framework when the
@@ -43,7 +44,7 @@ interface PluginInit {
      * JavaScript files.  If not, the plugin framework will transpile the files
      * itself.
      */
-    generateJs?: (schema: Schema, target: "js") => void;
+    generateJs?: (schema: Schema<Options>, target: "js") => void;
     /**
      * A optional function which will generate TypeScript declaration files
      * based on proto input.  This function will be invoked by the plugin
@@ -54,7 +55,7 @@ interface PluginInit {
      * declaration files.  If not, the plugin framework will transpile the files
      * itself.
      */
-    generateDts?: (schema: Schema, target: "dts") => void;
+    generateDts?: (schema: Schema<Options>, target: "dts") => void;
     /**
      * An optional function which will transpile a given set of files.
      *
@@ -75,5 +76,5 @@ interface PluginInit {
  * The plugin can generate JavaScript, TypeScript, or TypeScript declaration
  * files.
  */
-export declare function createEcmaScriptPlugin(init: PluginInit): Plugin;
+export declare function createEcmaScriptPlugin<Options extends object = object>(init: PluginInit<Options>): Plugin;
 export {};

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

@@ -35,7 +35,7 @@ function createEcmaScriptPlugin(init) {
             var _a, _b, _c;
             const minimumEdition = (_a = init.minimumEdition) !== null && _a !== void 0 ? _a : protobuf_2.minimumEdition;
             const maximumEdition = (_b = init.maximumEdition) !== null && _b !== void 0 ? _b : protobuf_2.maximumEdition;
-            const parameter = (0, parameter_js_1.parseParameter)(req.parameter, init.parseOption);
+            const parameter = (0, parameter_js_1.parseParameter)(req.parameter, init.parseOptions);
             const schema = (0, schema_js_1.createSchema)(req, parameter, init.name, init.version, minimumEdition, maximumEdition);
             const targetTs = schema.targets.includes("ts");
             const targetJs = schema.targets.includes("js");
@@ -97,7 +97,7 @@ function createEcmaScriptPlugin(init) {
             if (transpileJs || transpileDts) {
                 const transpileFn = (_c = init.transpile) !== null && _c !== void 0 ? _c : transpile_js_1.transpile;
                 // Transpile the TypeScript files and add to the master list of files
-                const transpiledFiles = transpileFn(tsFiles, transpileJs, transpileDts, parameter.jsImportStyle);
+                const transpiledFiles = transpileFn(tsFiles, transpileJs, transpileDts, parameter.parsed.jsImportStyle);
                 files.push(...transpiledFiles);
             }
             return toResponse(files, minimumEdition, maximumEdition);
@@ -106,7 +106,7 @@ function createEcmaScriptPlugin(init) {
 }
 exports.createEcmaScriptPlugin = createEcmaScriptPlugin;
 function toResponse(files, minimumEdition, maximumEdition) {
-    return (0, protobuf_1.create)(wkt_1.CodeGeneratorResponseDesc, {
+    return (0, protobuf_1.create)(wkt_1.CodeGeneratorResponseSchema, {
         supportedFeatures: protobuf_1.protoInt64.parse(wkt_1.CodeGeneratorResponse_Feature.PROTO3_OPTIONAL |
             wkt_1.CodeGeneratorResponse_Feature.SUPPORTS_EDITIONS),
         minimumEdition,

package/dist/cjs/generated-file.d.ts

@@ -58,7 +58,7 @@ export interface GeneratedFile {
      * descriptor. The comment block will contain the original comments from the
      * protobuf source, and annotations such as `@generated from message MyMessage`.
      */
-    jsDoc(desc: Exclude<AnyDesc, DescFile>, indentation?: string): Printable;
+    jsDoc(schema: Exclude<AnyDesc, DescFile>, indentation?: string): Printable;
     /**
      * Create a printable export statement. For example:
      *
@@ -79,11 +79,18 @@ export interface GeneratedFile {
     /**
      * Import a message or enumeration generated by protoc-gen-es.
      */
-    importShape(desc: DescMessage | DescEnum): ImportSymbol;
+    importShape(schema: DescMessage | DescEnum): ImportSymbol;
+    /**
+     * Import a message or enumeration JSON type generated by protoc-gen-es.
+     *
+     * Note that protoc-gen-es only generates JSON types with the plugin option
+     * `json_types=true`.
+     */
+    importJson(desc: DescMessage | DescEnum): ImportSymbol;
     /**
      * Import a descriptor generated by protoc-gen-es.
      */
-    importDesc(desc: DescMessage | DescEnum | DescExtension | DescService | DescFile, typeOnly?: boolean): ImportSymbol;
+    importSchema(schema: DescMessage | DescEnum | DescExtension | DescService | DescFile, typeOnly?: boolean): ImportSymbol;
     /**
      * Import any symbol from a file or package.
      *
@@ -94,10 +101,15 @@ export interface GeneratedFile {
      * relative to the project root. The import path is automatically made
      * relative to the current file.
      */
-    import(name: string, from: string): ImportSymbol;
+    import(name: string, from: string, typeOnly?: boolean): ImportSymbol;
     /**
      * In case you need full control over exports and imports, use print() and
      * formulate your own imports and exports based on this property.
+     *
+     * With the plugin option `js_import_style=legacy_commonjs`, this property
+     * reports "legacy_commonjs", but only if the current target is "js".
+     * This matches the behavior of import(), which also only generates CommonJS
+     * under this condition.
      */
     readonly jsImportStyle: "module" | "legacy_commonjs";
     /**
@@ -112,4 +124,4 @@ export type ResolveDescImportFn = (desc: DescMessage | DescEnum | DescExtension
 export type ResolveShapeImportFn = (desc: DescMessage | DescEnum) => ImportSymbol;
 export type RewriteImportFn = (path: string) => string;
 export type CreatePreambleFn = (descFile: DescFile) => string;
-export declare function createGeneratedFile(name: string, importPath: string, jsImportStyle: "module" | "legacy_commonjs", rewriteImport: RewriteImportFn, resolveDescImport: ResolveDescImportFn, resolveShapeImport: ResolveShapeImportFn, createPreamble: CreatePreambleFn, runtime: RuntimeImports): GeneratedFileController;
+export declare function createGeneratedFile(name: string, importPath: string, jsImportStyle: "module" | "legacy_commonjs", rewriteImport: RewriteImportFn, resolveDescImport: ResolveDescImportFn, resolveShapeImport: ResolveShapeImportFn, resolveJsonImport: ResolveShapeImportFn, createPreamble: CreatePreambleFn, runtime: RuntimeImports): GeneratedFileController;

package/dist/cjs/generated-file.js

@@ -18,7 +18,7 @@ const protobuf_1 = require("@bufbuild/protobuf");
 const import_symbol_js_1 = require("./import-symbol.js");
 const import_path_js_1 = require("./import-path.js");
 const jsdoc_js_1 = require("./jsdoc.js");
-function createGeneratedFile(name, importPath, jsImportStyle, rewriteImport, resolveDescImport, resolveShapeImport, createPreamble, runtime) {
+function createGeneratedFile(name, importPath, jsImportStyle, rewriteImport, resolveDescImport, resolveShapeImport, resolveJsonImport, createPreamble, runtime) {
     let preamble;
     const el = [];
     return {
@@ -44,6 +44,7 @@ function createGeneratedFile(name, importPath, jsImportStyle, rewriteImport, res
                 runtime,
                 resolveDescImport,
                 resolveShapeImport,
+                resolveJsonImport,
             }, printables);
             el.push("\n");
         },
@@ -60,23 +61,26 @@ function createGeneratedFile(name, importPath, jsImportStyle, rewriteImport, res
                 value: string,
             };
         },
-        jsDoc(textOrDesc, indentation) {
+        jsDoc(textOrSchema, indentation) {
             return {
                 kind: "es_jsdoc",
-                text: typeof textOrDesc == "string"
-                    ? textOrDesc
-                    : (0, jsdoc_js_1.createJsDocTextFromDesc)(textOrDesc),
+                text: typeof textOrSchema == "string"
+                    ? textOrSchema
+                    : (0, jsdoc_js_1.createJsDocTextFromDesc)(textOrSchema),
                 indentation,
             };
         },
-        importDesc(desc, typeOnly = false) {
-            return resolveDescImport(desc, typeOnly);
+        importSchema(schema, typeOnly = false) {
+            return resolveDescImport(schema, typeOnly);
         },
-        importShape(desc) {
-            return resolveShapeImport(desc);
+        importShape(schema) {
+            return resolveShapeImport(schema);
         },
-        import(name, from) {
-            return (0, import_symbol_js_1.createImportSymbol)(name, from);
+        importJson(desc) {
+            return resolveJsonImport(desc);
+        },
+        import(name, from, typeOnly = false) {
+            return (0, import_symbol_js_1.createImportSymbol)(name, from, typeOnly);
         },
         jsImportStyle,
         runtime,
@@ -223,6 +227,9 @@ function printableToEl(opt, printables) {
                         case "es_shape_ref":
                             el.push(opt.resolveShapeImport(p.desc));
                             break;
+                        case "es_json_type_ref":
+                            el.push(opt.resolveJsonImport(p.desc));
+                            break;
                         case "es_jsdoc":
                             el.push((0, jsdoc_js_1.formatJsDocBlock)(p.text, p.indentation));
                             break;

package/dist/cjs/index.d.ts

@@ -4,6 +4,7 @@ export { createEcmaScriptPlugin } from "./create-es-plugin.js";
 export { getComments, getDeclarationString, getPackageComments, getSyntaxComments, } from "./source-code-info.js";
 export type { Target } from "./target.js";
 export type { Schema } from "./schema.js";
+export type { EcmaScriptPluginOptions } from "./parameter.js";
 export type { GeneratedFile, FileInfo } from "./generated-file.js";
 export type { ImportSymbol } from "./import-symbol.js";
 export { createImportSymbol } from "./import-symbol.js";

package/dist/cjs/names.d.ts

@@ -1,4 +1,17 @@
 import type { DescEnum, DescExtension, DescFile, DescMessage, DescService } from "@bufbuild/protobuf";
+/**
+ * Return a file path for the give file descriptor.
+ */
 export declare function generateFilePath(file: DescFile, bootstrapWkt: boolean, filesToGenerate: DescFile[]): string;
-export declare function localDescName(desc: DescFile | DescEnum | DescMessage | DescExtension | DescService): string;
-export declare function localShapeName(desc: DescEnum | DescMessage): string;
+/**
+ * Return a safe identifier for a generated descriptor.
+ */
+export declare function generatedDescName(desc: DescFile | DescEnum | DescMessage | DescExtension | DescService): string;
+/**
+ * Return a safe identifier for a generated shape.
+ */
+export declare function generatedShapeName(desc: DescEnum | DescMessage): string;
+/**
+ * Return a safe identifier for a generated JSON type.
+ */
+export declare function generatedJsonTypeName(desc: DescEnum | DescMessage): string;

package/dist/cjs/names.js

@@ -13,10 +13,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.localShapeName = exports.localDescName = exports.generateFilePath = void 0;
+exports.generatedJsonTypeName = exports.generatedShapeName = exports.generatedDescName = exports.generateFilePath = void 0;
 const codegenv1_1 = require("@bufbuild/protobuf/codegenv1");
 const reflect_1 = require("@bufbuild/protobuf/reflect");
 const safe_identifier_js_1 = require("./safe-identifier.js");
+/**
+ * Return a file path for the give file descriptor.
+ */
 function generateFilePath(file, bootstrapWkt, filesToGenerate) {
     // Well-known types are published with the runtime package. We usually want
     // the generated code to import them from the runtime package, with the
@@ -34,86 +37,158 @@ function generateFilePath(file, bootstrapWkt, filesToGenerate) {
     return "./" + file.name + "_pb.js";
 }
 exports.generateFilePath = generateFilePath;
-function localDescName(desc) {
+/**
+ * Return a safe identifier for a generated descriptor.
+ */
+function generatedDescName(desc) {
     const file = desc.kind == "file" ? desc : desc.file;
     const { descNames } = allNames(file);
     const name = descNames.get(desc);
     if (name === undefined) {
-        throw new Error(`unable to determine unique identifier for ${desc.toString()}`);
+        throw new Error(`unable to determine unique descriptor name for ${desc.toString()}`);
     }
     return name;
 }
-exports.localDescName = localDescName;
-function localShapeName(desc) {
+exports.generatedDescName = generatedDescName;
+/**
+ * Return a safe identifier for a generated shape.
+ */
+function generatedShapeName(desc) {
     const { shapeNames } = allNames(desc.file);
     const name = shapeNames.get(desc);
     if (name === undefined) {
-        throw new Error(`unable to determine unique identifier for ${desc.toString()}`);
+        throw new Error(`unable to determine unique shape name for ${desc.toString()}`);
     }
     return name;
 }
-exports.localShapeName = localShapeName;
+exports.generatedShapeName = generatedShapeName;
+/**
+ * Return a safe identifier for a generated JSON type.
+ */
+function generatedJsonTypeName(desc) {
+    const { jsonTypeNames } = allNames(desc.file);
+    const name = jsonTypeNames.get(desc);
+    if (name === undefined) {
+        throw new Error(`unable to determine unique json type name for ${desc.toString()}`);
+    }
+    return name;
+}
+exports.generatedJsonTypeName = generatedJsonTypeName;
+/**
+ * Compute the ideal name for a generated descriptor.
+ */
 function idealDescName(desc, i) {
     const escape = i === 0 ? "" : i === 1 ? "$" : `$${i - 1}`;
+    if (desc.kind == "file") {
+        const name = "file_" + desc.name.replace(/[^a-zA-Z0-9_]+/g, "_");
+        return (0, safe_identifier_js_1.safeIdentifier)(name + escape);
+    }
     switch (desc.kind) {
-        case "file":
-            return ((0, safe_identifier_js_1.safeIdentifier)("fileDesc_" + desc.name.replace(/[^a-zA-Z0-9_]+/g, "_")) + escape);
         case "enum":
-            return baseName(desc) + "Desc" + escape;
+            return (0, safe_identifier_js_1.safeIdentifier)(identifier(desc) + "Schema" + escape);
         case "message":
-            return baseName(desc) + "Desc" + escape;
+            return (0, safe_identifier_js_1.safeIdentifier)(identifier(desc) + "Schema" + escape);
         case "extension":
-            return baseName(desc) + escape;
+            return (0, safe_identifier_js_1.safeIdentifier)(identifier(desc) + escape);
         case "service":
-            return baseName(desc) + escape;
+            return (0, safe_identifier_js_1.safeIdentifier)(identifier(desc) + escape);
     }
 }
+/**
+ * Compute the ideal name for a generated shape.
+ */
 function idealShapeName(desc, i) {
     const escape = i === 0 ? "" : i === 1 ? "$" : `$${i - 1}`;
-    return baseName(desc) + escape;
+    return (0, safe_identifier_js_1.safeIdentifier)(identifier(desc) + escape);
 }
-function baseName(desc) {
+/**
+ * Compute the ideal name for a generated JSON type.
+ */
+function idealJsonTypeName(desc, i) {
+    const escape = i === 0 ? "" : i === 1 ? "$" : `$${i - 1}`;
+    return (0, safe_identifier_js_1.safeIdentifier)(identifier(desc) + "Json" + escape);
+}
+/**
+ * Return an identifier for the given descriptor based on its type name.
+ *
+ * The type name for a protobuf message is the package name (if any), plus
+ * the names of parent messages it is nested in (if any), plus the name of
+ * the element, separated by dots. For example: foo.bar.ParentMsg.MyEnum.
+ *
+ * ECMAScript does not have packages or namespaces, so we need a single
+ * identifier. Our convention is to drop the package name, and to join other
+ * parts of the name with an underscore. For example: ParentMsg_MyEnum.
+ */
+function identifier(desc) {
     const pkg = desc.file.proto.package;
     const offset = pkg.length > 0 ? pkg.length + 1 : 0;
-    const name = desc.typeName.substring(offset).replace(/\./g, "_");
-    return (0, safe_identifier_js_1.safeIdentifier)(name);
+    const nameWithoutPkg = desc.typeName.substring(offset);
+    return nameWithoutPkg.replace(/\./g, "_");
 }
+/**
+ * Compute all ideal names for the elements in the file, resolving name clashes.
+ */
 function allNames(file) {
     const taken = new Set();
+    // In the first pass, register shape names
     const shapeNames = new Map();
+    for (const desc of (0, reflect_1.nestedTypes)(file)) {
+        if (desc.kind != "enum" && desc.kind != "message") {
+            continue;
+        }
+        let name;
+        for (let i = 0;; i++) {
+            name = idealShapeName(desc, i);
+            if (!taken.has(name)) {
+                break;
+            }
+        }
+        taken.add(name);
+        shapeNames.set(desc, name);
+    }
+    // In the second pass, register desc names
     const descNames = new Map();
     for (const desc of [file, ...(0, reflect_1.nestedTypes)(file)]) {
+        let name;
         switch (desc.kind) {
             case "enum":
             case "message": {
-                let descName;
-                let shapeName;
                 for (let i = 0;; i++) {
-                    descName = idealDescName(desc, i);
-                    shapeName = idealShapeName(desc, i);
-                    if (!taken.has(descName) && !taken.has(shapeName)) {
+                    name = idealDescName(desc, i);
+                    if (!taken.has(name)) {
                         break;
                     }
                 }
-                taken.add(descName);
-                taken.add(shapeName);
-                descNames.set(desc, descName);
-                shapeNames.set(desc, shapeName);
                 break;
             }
             default: {
-                let descName;
                 for (let i = 0;; i++) {
-                    descName = idealDescName(desc, i);
-                    if (!taken.has(descName)) {
+                    name = idealDescName(desc, i);
+                    if (!taken.has(name)) {
                         break;
                     }
                 }
-                taken.add(descName);
-                descNames.set(desc, descName);
                 break;
             }
         }
+        taken.add(name);
+        descNames.set(desc, name);
+    }
+    // In the third pass, register json type names
+    const jsonTypeNames = new Map();
+    for (const desc of (0, reflect_1.nestedTypes)(file)) {
+        if (desc.kind != "enum" && desc.kind != "message") {
+            continue;
+        }
+        let name;
+        for (let i = 0;; i++) {
+            name = idealJsonTypeName(desc, i);
+            if (!taken.has(name)) {
+                break;
+            }
+        }
+        taken.add(name);
+        jsonTypeNames.set(desc, name);
     }
-    return { shapeNames, descNames };
+    return { shapeNames, jsonTypeNames, descNames };
 }

package/dist/cjs/parameter.d.ts

@@ -1,13 +1,74 @@
 import type { Target } from "./target.js";
 import type { RewriteImports } from "./import-path.js";
-export interface ParsedParameter {
+/**
+ * Standard plugin options that every ECMAScript plugin supports.
+ */
+export interface EcmaScriptPluginOptions {
+    /**
+     * Controls whether the plugin generates JavaScript, TypeScript,
+     * or TypeScript declaration files.
+     *
+     * The default is ["js", "dts].
+     */
     targets: Target[];
+    /**
+     * Add an extension to every import, for example ".js" or ".ts".
+     *
+     * The default is "".
+     */
+    importExtension: string;
+    /**
+     * Generate `import` statements or `require()` calls.
+     *
+     * The default is "module".
+     */
+    jsImportStyle: "module" | "legacy_commonjs";
+    /**
+     * Generate an annotation at the top of each file to skip type checks:
+     * `// @ts-nocheck`.
+     *
+     * The default is false.
+     */
     tsNocheck: boolean;
-    bootstrapWkt: boolean;
+    /**
+     * Prune empty files from the output.
+     *
+     * The default is false.
+     */
     keepEmptyFiles: boolean;
+    /**
+     * @private
+     */
+    bootstrapWkt: boolean;
+    /**
+     * @private
+     */
     rewriteImports: RewriteImports;
-    importExtension: string;
-    jsImportStyle: "module" | "legacy_commonjs";
-    sanitizedParameter: string;
 }
-export declare function parseParameter(parameter: string, parseExtraOption: ((key: string, value: string) => void) | undefined): ParsedParameter;
+export interface ParsedParameter<T> {
+    parsed: T & EcmaScriptPluginOptions;
+    sanitized: string;
+}
+/**
+ * Raw options to parse.
+ *
+ * For example, if a plugin is run with the options foo=123,bar,baz=a,baz=b
+ * the raw options are:
+ *
+ * ```ts
+ * [
+ *   { key: "foo", value: "123" },
+ *   { key: "bar", value: "" },
+ *   { key: "baz", value: "a" },
+ *   { key: "baz", value: "b" },
+ * ]
+ * ```
+ *
+ * If your plugin does not recognize an option, it must throw an Error in
+ * parseOptions.
+ */
+export type RawPluginOptions = {
+    key: string;
+    value: string;
+}[];
+export declare function parseParameter<T extends object>(parameter: string, parseExtraOptions: ((rawOptions: RawPluginOptions) => T) | undefined): ParsedParameter<T>;

package/dist/cjs/parameter.js

@@ -15,7 +15,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseParameter = void 0;
 const error_js_1 = require("./error.js");
-function parseParameter(parameter, parseExtraOption) {
+function parseParameter(parameter, parseExtraOptions) {
     let targets = ["js", "dts"];
     let tsNocheck = false;
     let bootstrapWkt = false;
@@ -23,6 +23,8 @@ function parseParameter(parameter, parseExtraOption) {
     const rewriteImports = [];
     let importExtension = "";
     let jsImportStyle = "module";
+    const extraParameters = [];
+    const extraParametersRaw = [];
     const rawParameters = [];
     for (const { key, value, raw } of splitParameter(parameter)) {
         // Whether this key/value plugin parameter pair should be
@@ -118,23 +120,19 @@ function parseParameter(parameter, parseExtraOption) {
                 break;
             }
             default:
-                if (parseExtraOption === undefined) {
+                if (parseExtraOptions === undefined) {
                     throw new error_js_1.PluginOptionError(raw);
                 }
-                try {
-                    parseExtraOption(key, value);
-                }
-                catch (e) {
-                    throw new error_js_1.PluginOptionError(raw, e);
-                }
+                extraParameters.push({ key, value });
+                extraParametersRaw.push(raw);
                 break;
         }
         if (!sanitize) {
             rawParameters.push(raw);
         }
     }
-    const sanitizedParameter = rawParameters.join(",");
-    return {
+    const sanitizedParameters = rawParameters.join(",");
+    const ecmaScriptPluginOptions = {
         targets,
         tsNocheck,
         bootstrapWkt,
@@ -142,8 +140,22 @@ function parseParameter(parameter, parseExtraOption) {
         importExtension,
         jsImportStyle,
         keepEmptyFiles,
-        sanitizedParameter,
     };
+    if (parseExtraOptions === undefined || extraParameters.length === 0) {
+        return {
+            parsed: ecmaScriptPluginOptions,
+            sanitized: sanitizedParameters,
+        };
+    }
+    try {
+        return {
+            parsed: Object.assign(ecmaScriptPluginOptions, parseExtraOptions(extraParameters)),
+            sanitized: sanitizedParameters,
+        };
+    }
+    catch (err) {
+        throw new error_js_1.PluginOptionError(extraParametersRaw.join(","), err);
+    }
 }
 exports.parseParameter = parseParameter;
 function splitParameter(parameter) {

package/dist/cjs/printable.d.ts

@@ -3,7 +3,7 @@ import type { ImportSymbol } from "./import-symbol.js";
 /**
  * All types that can be passed to GeneratedFile.print()
  */
-export type Printable = string | number | boolean | bigint | Uint8Array | ImportSymbol | ExportStatement | JSDocBlock | LiteralString | LiteralProtoInt64 | DescImport | ShapeImport | Printable[];
+export type Printable = string | number | boolean | bigint | Uint8Array | ImportSymbol | ExportStatement | JSDocBlock | LiteralString | LiteralProtoInt64 | DescImport | ShapeImport | JsonTypeImport | Printable[];
 export type ExportStatement = {
     kind: "es_export_stmt";
     name: string;
@@ -28,6 +28,10 @@ export type ShapeImport = {
     readonly kind: "es_shape_ref";
     desc: DescMessage | DescEnum;
 };
+export type JsonTypeImport = {
+    readonly kind: "es_json_type_ref";
+    desc: DescMessage | DescEnum;
+};
 export type JSDocBlock = {
     readonly kind: "es_jsdoc";
     text: string;

package/dist/cjs/run-node.js

@@ -41,9 +41,9 @@ function runNodeJs(plugin) {
     }
     readBytes(process.stdin)
         .then((data) => {
-        const req = (0, protobuf_1.fromBinary)(wkt_1.CodeGeneratorRequestDesc, data);
+        const req = (0, protobuf_1.fromBinary)(wkt_1.CodeGeneratorRequestSchema, data);
         const res = plugin.run(req);
-        return writeBytes(process.stdout, (0, protobuf_1.toBinary)(wkt_1.CodeGeneratorResponseDesc, res));
+        return writeBytes(process.stdout, (0, protobuf_1.toBinary)(wkt_1.CodeGeneratorResponseSchema, res));
     })
         .then(() => process.exit(0))
         .catch((reason) => {

package/dist/cjs/schema.d.ts

@@ -3,12 +3,12 @@ import type { CodeGeneratorRequest } from "@bufbuild/protobuf/wkt";
 import { Edition } from "@bufbuild/protobuf/wkt";
 import type { FileInfo, GeneratedFile } from "./generated-file.js";
 import type { Target } from "./target.js";
-import type { ParsedParameter } from "./parameter.js";
+import type { EcmaScriptPluginOptions, ParsedParameter } from "./parameter.js";
 /**
  * Schema describes the files and types that the plugin is requested to
  * generate.
  */
-export interface Schema {
+export interface Schema<Options extends object = object> {
     /**
      * The files we are asked to generate.
      */
@@ -21,6 +21,11 @@ export interface Schema {
      * The plugin option `target`. A code generator should support all targets.
      */
     readonly targets: readonly Target[];
+    /**
+     * Parsed plugin options. They include the standard options for all
+     * plugins, and options parsed by your plugin.
+     */
+    readonly options: Options & EcmaScriptPluginOptions;
     /**
      * Generate a new file with the given name.
      */
@@ -35,9 +40,9 @@ export interface Schema {
      */
     readonly proto: CodeGeneratorRequest;
 }
-interface SchemaController extends Schema {
+interface SchemaController<Options extends object> extends Schema<Options> {
     getFileInfo: () => FileInfo[];
     prepareGenerate(target: Target): void;
 }
-export declare function createSchema(request: CodeGeneratorRequest, parameter: ParsedParameter, pluginName: string, pluginVersion: string, minimumEdition: Edition, maximumEdition: Edition): SchemaController;
+export declare function createSchema<T extends object>(request: CodeGeneratorRequest, parameter: ParsedParameter<T>, pluginName: string, pluginVersion: string, minimumEdition: Edition, maximumEdition: Edition): SchemaController<T>;
 export {};