@bufbuild/protoplugin 0.1.0 → 0.2.0

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

@@ -11,25 +11,85 @@
 // 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 { createSchema } from "./ecmascript/schema.js";
-import { CodeGeneratorResponse } from "@bufbuild/protobuf";
+import { createSchema, toResponse } from "./ecmascript/schema.js";
+import { transpile } from "./ecmascript/transpile.js";
 import { PluginOptionError } from "./error.js";
 /**
  * Create a new code generator plugin for ECMAScript.
  * The plugin can generate JavaScript, TypeScript, or TypeScript declaration
  * files.
  */
-export function createEcmaScriptPlugin(init, generateFn) {
+export function createEcmaScriptPlugin(init) {
+    let transpileJs = false;
+    let transpileDts = false;
     return {
         name: init.name,
         version: init.version,
         run(req) {
-            const { targets, tsNocheck, bootstrapWkt, rewriteImports } = parseParameter(req.parameter, init.parseOption);
-            const { schema, toResponse } = createSchema(req, targets, init.name, init.version, tsNocheck, bootstrapWkt, rewriteImports);
-            generateFn(schema);
-            const res = new CodeGeneratorResponse();
-            toResponse(res);
-            return res;
+            var _a;
+            const { targets, tsNocheck, bootstrapWkt, rewriteImports, keepEmptyFiles, } = parseParameter(req.parameter, init.parseOption);
+            const { schema, getFileInfo } = createSchema(req, targets, init.name, init.version, tsNocheck, bootstrapWkt, rewriteImports, keepEmptyFiles);
+            const targetTs = schema.targets.includes("ts");
+            const targetJs = schema.targets.includes("js");
+            const targetDts = schema.targets.includes("dts");
+            // Generate TS files under the following conditions:
+            // - if they are explicitly specified as a target.
+            // - if js is specified as a target but no js generator is provided.
+            // - if dts is specified as a target, but no dts generator is provided.
+            // In the latter two cases, it is because we need the generated TS files
+            // to use for transpiling js and/or dts.
+            let tsFiles = [];
+            if (targetTs ||
+                (targetJs && !init.generateJs) ||
+                (targetDts && !init.generateDts)) {
+                init.generateTs(schema, "ts");
+                // Save off the generated TypeScript files so that we can pass these
+                // to the transpilation process if necessary.  We do not want to pass
+                // JavaScript files for a few reasons:
+                // 1.  Our usage of allowJs in the compiler options will cause issues
+                // with attempting to transpile .ts and .js files to the same location.
+                // 2.  There should be no reason to transpile JS because generateTs
+                // functions are required, so users would never be able to only specify
+                // a generateJs function and expect to transpile declarations.
+                // 3.  Transpiling is somewhat expensive and situations with an
+                // extremely large amount of files could have performance impacts.
+                tsFiles = getFileInfo();
+            }
+            if (targetJs) {
+                if (init.generateJs) {
+                    init.generateJs(schema, "js");
+                }
+                else {
+                    transpileJs = true;
+                }
+            }
+            if (targetDts) {
+                if (init.generateDts) {
+                    init.generateDts(schema, "dts");
+                }
+                else {
+                    transpileDts = true;
+                }
+            }
+            // Get generated files.  If ts was specified as a target, then we want
+            // all generated files.  If ts was not specified, we still may have
+            // generated TypeScript files to assist in transpilation.  If they were
+            // generated but not specified in the target out, we shouldn't produce
+            // these files in the CodeGeneratorResponse.
+            let files = getFileInfo();
+            if (!targetTs && tsFiles.length > 0) {
+                files = files.filter((file) => !tsFiles.some((tsFile) => tsFile.name === file.name));
+            }
+            // If either boolean is true, it means it was specified in the target out
+            // 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;
+                // Transpile the TypeScript files and add to the master list of files
+                const transpiledFiles = transpileFn(tsFiles, transpileJs, transpileDts);
+                files.push(...transpiledFiles);
+            }
+            return toResponse(files);
         },
     };
 }
@@ -37,6 +97,7 @@ function parseParameter(parameter, parseOption) {
     let targets = ["js", "dts"];
     let tsNocheck = true;
     let bootstrapWkt = false;
+    let keepEmptyFiles = false;
     const rewriteImports = [];
     for (const { key, value } of splitParameter(parameter)) {
         switch (key) {
@@ -94,6 +155,21 @@ function parseParameter(parameter, parseOption) {
                 rewriteImports.push({ pattern, target });
                 break;
             }
+            case "keep_empty_files": {
+                switch (value) {
+                    case "true":
+                    case "1":
+                        keepEmptyFiles = true;
+                        break;
+                    case "false":
+                    case "0":
+                        keepEmptyFiles = false;
+                        break;
+                    default:
+                        throw new PluginOptionError(`${key}=${value}`);
+                }
+                break;
+            }
             default:
                 if (parseOption === undefined) {
                     throw new PluginOptionError(`${key}=${value}`);
@@ -107,7 +183,7 @@ function parseParameter(parameter, parseOption) {
                 break;
         }
     }
-    return { targets, tsNocheck, bootstrapWkt, rewriteImports };
+    return { targets, tsNocheck, bootstrapWkt, rewriteImports, keepEmptyFiles };
 }
 function splitParameter(parameter) {
     if (parameter == undefined) {

package/dist/esm/ecmascript/custom-options.js

@@ -0,0 +1,105 @@
+// 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.
+import { proto3, BinaryReader, ScalarType, } from "@bufbuild/protobuf";
+/**
+ * Returns the value of a custom option with a scalar type.
+ *
+ * If no option is found, returns undefined.
+ */
+export function findCustomScalarOption(desc, id, scalarType) {
+    const reader = createBinaryReader(desc, id);
+    if (reader) {
+        switch (scalarType) {
+            case ScalarType.INT32:
+                return reader.int32();
+            case ScalarType.UINT32:
+                return reader.uint32();
+            case ScalarType.SINT32:
+                return reader.sint32();
+            case ScalarType.FIXED32:
+                return reader.fixed32();
+            case ScalarType.SFIXED32:
+                return reader.sfixed32();
+            case ScalarType.FLOAT:
+                return reader.float();
+            case ScalarType.DOUBLE:
+                return reader.double();
+            case ScalarType.INT64:
+                return reader.int64();
+            case ScalarType.SINT64:
+                return reader.sint64();
+            case ScalarType.SFIXED64:
+                return reader.sfixed64();
+            case ScalarType.UINT64:
+                return reader.uint64();
+            case ScalarType.FIXED64:
+                return reader.fixed64();
+            case ScalarType.BOOL:
+                return reader.bool();
+            case ScalarType.BYTES:
+                return reader.bytes();
+            case ScalarType.STRING:
+                return reader.string();
+            default: {
+                break;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns the value of a custom message option for the given descriptor and ID.
+ * The msgType param is then used to deserialize the message for returning to the caller.
+ *
+ * If no options are found, returns undefined.
+ *
+ * If the message option is unable to be read or deserialized, an error will be thrown.
+ */
+export function findCustomMessageOption(desc, id, msgType) {
+    const reader = createBinaryReader(desc, id);
+    if (reader) {
+        try {
+            const data = reader.bytes();
+            return msgType.fromBinary(data);
+        }
+        catch (e) {
+            const innerMessage = e instanceof Error ? e.message : String(e);
+            throw new Error(`failed to access message option: ${innerMessage}`);
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns the value of a custom enum option for the given descriptor and ID.
+ *
+ * If no options are found, returns undefined.
+ */
+export function findCustomEnumOption(desc, id) {
+    return findCustomScalarOption(desc, id, ScalarType.INT32);
+}
+/**
+ * Returns a binary reader for the given descriptor and field ID.
+ */
+function createBinaryReader(desc, id) {
+    const opt = desc.proto.options;
+    let reader = undefined;
+    if (opt !== undefined) {
+        const unknownFields = proto3.bin.listUnknownFields(opt);
+        const field = unknownFields.find((f) => f.no === id);
+        if (field) {
+            reader = new BinaryReader(field.data);
+        }
+    }
+    return reader;
+}

package/dist/esm/ecmascript/gencommon.js

@@ -98,10 +98,7 @@ export function makeJsDoc(desc, indentation = "") {
         case "enum_value":
             text += `@generated from enum value: ${desc.declarationString()};`;
             break;
-        case "scalar_field":
-        case "enum_field":
-        case "message_field":
-        case "map_field":
+        case "field":
             text += `@generated from field: ${desc.declarationString()};`;
             break;
         default:
@@ -133,12 +130,12 @@ export function makeJsDoc(desc, indentation = "") {
 export function getFieldTyping(field, file) {
     const typing = [];
     let optional = false;
-    switch (field.kind) {
-        case "scalar_field":
+    switch (field.fieldKind) {
+        case "scalar":
             typing.push(scalarTypeScriptType(field.scalar));
             optional = field.optional;
             break;
-        case "message_field": {
+        case "message": {
             const baseType = getUnwrappedFieldType(field);
             if (baseType !== undefined) {
                 typing.push(scalarTypeScriptType(baseType));
@@ -149,11 +146,11 @@ export function getFieldTyping(field, file) {
             optional = true;
             break;
         }
-        case "enum_field":
+        case "enum":
             typing.push(file.import(field.enum).toTypeOnly());
             optional = field.optional;
             break;
-        case "map_field": {
+        case "map": {
             let keyType;
             switch (field.mapKey) {
                 case ScalarType.INT32:
@@ -222,15 +219,15 @@ export function literalString(value) {
         '"');
 }
 export function getFieldExplicitDefaultValue(field, protoInt64Symbol) {
-    switch (field.kind) {
-        case "enum_field": {
+    switch (field.fieldKind) {
+        case "enum": {
             const value = field.enum.values.find((v) => v.number === field.getDefaultValue());
             if (value !== undefined) {
                 return [value.parent, ".", localName(value)];
             }
             break;
         }
-        case "scalar_field": {
+        case "scalar": {
             const defaultValue = field.getDefaultValue();
             if (defaultValue === undefined) {
                 break;
@@ -283,7 +280,7 @@ export function getFieldIntrinsicDefaultValue(field) {
             typingInferrable: false,
         };
     }
-    if (field.kind == "map_field") {
+    if (field.fieldKind == "map") {
         return {
             defaultValue: "{}",
             typingInferrable: false,
@@ -292,8 +289,8 @@ export function getFieldIntrinsicDefaultValue(field) {
     let defaultValue = undefined;
     let typingInferrable = false;
     if (field.parent.file.syntax == "proto3") {
-        switch (field.kind) {
-            case "enum_field": {
+        switch (field.fieldKind) {
+            case "enum": {
                 if (!field.optional) {
                     const zeroValue = field.enum.values.find((v) => v.number === 0);
                     if (zeroValue === undefined) {
@@ -304,7 +301,7 @@ export function getFieldIntrinsicDefaultValue(field) {
                 }
                 break;
             }
-            case "scalar_field":
+            case "scalar":
                 if (!field.optional) {
                     typingInferrable = true;
                     if (field.scalar === ScalarType.STRING) {

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

@@ -11,11 +11,10 @@
 // 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 { CodeGeneratorResponse_File, } from "@bufbuild/protobuf";
 import { createImportSymbol } from "./import-symbol.js";
 import { literalString, makeFilePreamble } from "./gencommon.js";
 import { makeImportPathRelative } from "./import-path.js";
-export function createGeneratedFile(name, importPath, createTypeImport, runtimeImports, preambleSettings) {
+export function createGeneratedFile(name, importPath, createTypeImport, runtimeImports, preambleSettings, keepEmpty) {
     let preamble;
     const el = [];
     return {
@@ -32,22 +31,20 @@ export function createGeneratedFile(name, importPath, createTypeImport, runtimeI
         import(typeOrName, from) {
             if (typeof typeOrName == "string") {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                return createImportSymbol(name, from);
+                return createImportSymbol(typeOrName, from);
             }
             return createTypeImport(typeOrName);
         },
-        toResponse(res) {
-            let content = elToContent(el, importPath);
-            if (content.length === 0) {
+        getFileInfo() {
+            const content = elToContent(el, importPath);
+            if (!keepEmpty && content.length === 0) {
                 return;
             }
-            if (preamble !== undefined) {
-                content = preamble + "\n" + content;
-            }
-            res.file.push(new CodeGeneratorResponse_File({
-                name: name,
+            return {
+                name,
                 content,
-            }));
+                preamble,
+            };
         },
     };
 }

package/dist/esm/ecmascript/index.js

@@ -19,3 +19,4 @@ export {} from "./generated-file.js";
 export {} from "./import-symbol.js";
 export const { localName } = codegenInfo;
 export { createJsDocBlock, getFieldExplicitDefaultValue, getFieldIntrinsicDefaultValue, getFieldTyping, makeJsDoc, literalString, } from "./gencommon.js";
+export { findCustomScalarOption, findCustomMessageOption, findCustomEnumOption, } from "./custom-options.js";

package/dist/esm/ecmascript/schema.js

@@ -11,12 +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 { codegenInfo, CodeGeneratorResponse_Feature, createDescriptorSet, protoInt64, } from "@bufbuild/protobuf";
+import { codegenInfo, CodeGeneratorResponse, CodeGeneratorResponse_Feature, createDescriptorSet, protoInt64, } from "@bufbuild/protobuf";
 import { createGeneratedFile } from "./generated-file.js";
 import { createRuntimeImports } from "./runtime-imports.js";
 import { createImportSymbol } from "./import-symbol.js";
 import { deriveImportPath, makeImportPath, rewriteImportPath, } from "./import-path.js";
-export function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bootstrapWkt, rewriteImports) {
+export function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bootstrapWkt, rewriteImports, keepEmptyFiles) {
     const descriptorSet = createDescriptorSet(request.protoFile);
     const filesToGenerate = findFilesToGenerate(descriptorSet, request);
     const runtime = createRuntimeImports(bootstrapWkt);
@@ -39,21 +39,36 @@ export function createSchema(request, targets, pluginName, pluginVersion, tsNoch
                 pluginVersion,
                 parameter: request.parameter,
                 tsNocheck,
-            });
+            }, keepEmptyFiles);
             generatedFiles.push(genFile);
             return genFile;
         },
     };
     return {
         schema,
-        toResponse(res) {
-            res.supportedFeatures = protoInt64.parse(CodeGeneratorResponse_Feature.PROTO3_OPTIONAL);
-            for (const genFile of generatedFiles) {
-                genFile.toResponse(res);
-            }
+        getFileInfo() {
+            return generatedFiles.flatMap((file) => {
+                const fileInfo = file.getFileInfo();
+                // undefined is returned if the file has no content
+                if (!fileInfo) {
+                    return [];
+                }
+                return [fileInfo];
+            });
         },
     };
 }
+export function toResponse(files) {
+    return new CodeGeneratorResponse({
+        supportedFeatures: protoInt64.parse(CodeGeneratorResponse_Feature.PROTO3_OPTIONAL),
+        file: files.map((f) => {
+            if (f.preamble !== undefined) {
+                f.content = f.preamble + "\n" + f.content;
+            }
+            return f;
+        }),
+    });
+}
 function findFilesToGenerate(descriptorSet, request) {
     const missing = request.fileToGenerate.filter((fileToGenerate) => descriptorSet.files.every((file) => fileToGenerate !== file.name + ".proto"));
     if (missing.length) {

package/dist/esm/ecmascript/transpile.js

@@ -0,0 +1,115 @@
+// 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.
+import ts from "typescript";
+import { createDefaultMapFromNodeModules, createSystem, createVirtualCompilerHost, } from "@typescript/vfs";
+/* eslint-disable import/no-named-as-default-member */
+// The default options used to auto-transpile if needed.
+const defaultOptions = {
+    // Type checking
+    strict: false,
+    // modules
+    module: ts.ModuleKind.ES2020,
+    moduleResolution: ts.ModuleResolutionKind.NodeJs,
+    noResolve: true,
+    resolveJsonModule: false,
+    // emit
+    emitBOM: false,
+    importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Preserve,
+    newLine: ts.NewLineKind.LineFeed,
+    preserveValueImports: false,
+    // JavaScript Support
+    allowJs: true,
+    checkJs: false,
+    // Language and Environment
+    lib: [],
+    moduleDetection: "force",
+    target: ts.ScriptTarget.ES2017,
+    // Completeness
+    skipLibCheck: true,
+    skipDefaultLibCheck: false,
+};
+/**
+ * Create a transpiler using the given compiler options, which will compile the
+ * content provided in the files array.
+ *
+ * Note:  this library intentionally transpiles with a pinned older version of
+ * TypeScript for stability.  This version is denoted in this workspace's
+ * package.json.  For the default set of compiler options, we use a lenient
+ * set of options because the general goal is to emit code as best as we can.
+ * For a list of the options used, see `defaultOptions` above.
+ *
+ * If this is not desirable for plugin authors, they are free to provide their
+ * own transpile function as part of the plugin initialization.  If one is
+ * provided, it will be invoked instead and the framework's auto-transpilation
+ * will be bypassed.
+ *
+ * In addition, note that there is a dependency on @typescript/vfs in the
+ * top-level package as well as this package.  This is to avoid npm hoisting
+ * @typescript/vfs to the top-level node_modules directory, which then causes
+ * type mismatches when trying to use it with this package's version of
+ * TypeScript.  Ideally we would use something like Yarn's nohoist here, but
+ * npm does not support that yet.
+ */
+function createTranspiler(options, files) {
+    const fsMap = createDefaultMapFromNodeModules({
+        target: options.target,
+    });
+    files.forEach((file) => {
+        fsMap.set(file.name, file.content);
+    });
+    const system = createSystem(fsMap);
+    const host = createVirtualCompilerHost(system, options, ts);
+    return ts.createProgram({
+        rootNames: [...fsMap.keys()],
+        options,
+        host: host.compilerHost,
+    });
+}
+export function transpile(files, transpileJs, transpileDts) {
+    const options = Object.assign(Object.assign({}, defaultOptions), { declaration: transpileDts, emitDeclarationOnly: transpileDts && !transpileJs });
+    // Create the transpiler (a ts.Program object)
+    const program = createTranspiler(options, files);
+    const results = [];
+    let err;
+    const result = program.emit(undefined, (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
+        // We have to go through some hoops here because the header we add to each
+        // file is not part of the AST. So we find the TypeScript file we
+        // generated for each emitted file and add the header to each output ourselves.
+        if (!sourceFiles) {
+            err = new Error(`unable to map emitted file "${fileName}" to a source file: missing source files`);
+            return;
+        }
+        if (sourceFiles.length !== 1) {
+            err = new Error(`unable to map emitted file "${fileName}" to a source file: expected 1 source file, got ${sourceFiles.length}`);
+            return;
+        }
+        const file = files.find((x) => sourceFiles[0].fileName === x.name);
+        if (!file) {
+            err = new Error(`unable to map emitted file "${fileName}" to a source file: not found`);
+            return;
+        }
+        results.push({
+            name: fileName,
+            preamble: file.preamble,
+            content: data,
+        });
+    });
+    if (err) {
+        throw err;
+    }
+    if (result.emitSkipped) {
+        throw Error("An problem occurred during transpilation and files were not generated.  Contact the plugin author for support.");
+    }
+    return results;
+}

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

@@ -1,4 +1,5 @@
-import type { Schema } from "./ecmascript";
+import { Schema } from "./ecmascript/schema.js";
+import type { FileInfo } from "./ecmascript/generated-file.js";
 import type { Plugin } from "./plugin.js";
 interface PluginInit {
     /**
@@ -9,7 +10,49 @@ interface PluginInit {
      * Version of this code generator plugin.
      */
     version: string;
+    /**
+     * A optional parsing function which can be used to customize parameter
+     * parsing of the plugin.
+     */
     parseOption?: PluginOptionParseFn;
+    /**
+     * A function which will generate TypeScript files based on proto input.
+     * This function will be invoked by the plugin framework when the plugin runs.
+     *
+     * Note that this is required to be provided for plugin initialization.
+     */
+    generateTs: (schema: Schema, 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
+     * plugin runs.
+     *
+     * If this function is not provided, the plugin framework will then check if
+     * a transpile function is provided.  If so, it will be invoked to transpile
+     * JavaScript files.  If not, the plugin framework will transpile the files
+     * itself.
+     */
+    generateJs?: (schema: Schema, target: "js") => void;
+    /**
+     * A optional function which will generate TypeScript declaration files
+     * based on proto input.  This function will be invoked by the plugin
+     * framework when the plugin runs.
+     *
+     * If this function is not provided, the plugin framework will then check if
+     * a transpile function is provided.  If so, it will be invoked to transpile
+     * declaration files.  If not, the plugin framework will transpile the files
+     * itself.
+     */
+    generateDts?: (schema: Schema, target: "dts") => void;
+    /**
+     * A optional function which will transpile a given set of files.
+     *
+     * This funcion is meant to be used in place of either generateJs,
+     * generateDts, or both.  However, those functions will take precedence.
+     * This means that if generateJs, generateDts, and this transpile function
+     * are all provided, this transpile function will be ignored.
+     */
+    transpile?: (files: FileInfo[], transpileJs: boolean, transpileDts: boolean) => FileInfo[];
 }
 declare type PluginOptionParseFn = (key: string, value: string | undefined) => void;
 /**
@@ -17,5 +60,5 @@ declare type PluginOptionParseFn = (key: string, value: string | undefined) => v
  * The plugin can generate JavaScript, TypeScript, or TypeScript declaration
  * files.
  */
-export declare function createEcmaScriptPlugin(init: PluginInit, generateFn: (schema: Schema) => void): Plugin;
+export declare function createEcmaScriptPlugin(init: PluginInit): Plugin;
 export {};

package/dist/types/ecmascript/custom-options.d.ts

@@ -0,0 +1,28 @@
+import type { AnyDesc } from "@bufbuild/protobuf";
+import { Message, MessageType, ScalarType } from "@bufbuild/protobuf";
+/**
+ * Returns the value of a custom option with a scalar type.
+ *
+ * If no option is found, returns undefined.
+ */
+export declare function findCustomScalarOption<T extends ScalarType>(desc: AnyDesc, id: number, scalarType: T): ScalarValue<T> | undefined;
+/**
+ * Returns the value of a custom message option for the given descriptor and ID.
+ * The msgType param is then used to deserialize the message for returning to the caller.
+ *
+ * If no options are found, returns undefined.
+ *
+ * If the message option is unable to be read or deserialized, an error will be thrown.
+ */
+export declare function findCustomMessageOption<T extends Message<T>>(desc: AnyDesc, id: number, msgType: MessageType<T>): T | undefined;
+/**
+ * Returns the value of a custom enum option for the given descriptor and ID.
+ *
+ * If no options are found, returns undefined.
+ */
+export declare function findCustomEnumOption(desc: AnyDesc, id: number): number | undefined;
+/**
+ * ScalarValue is a conditional type that pairs a ScalarType value with its concrete type.
+ */
+declare type ScalarValue<T> = T extends ScalarType.STRING ? string : T extends ScalarType.INT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.SINT32 ? number : T extends ScalarType.FIXED32 ? number : T extends ScalarType.SFIXED32 ? number : T extends ScalarType.FLOAT ? number : T extends ScalarType.DOUBLE ? number : T extends ScalarType.INT64 ? bigint | string : T extends ScalarType.SINT64 ? bigint | string : T extends ScalarType.SFIXED64 ? bigint | string : T extends ScalarType.UINT64 ? bigint | string : T extends ScalarType.FIXED64 ? bigint | string : T extends ScalarType.BOOL ? boolean : T extends ScalarType.BYTES ? Uint8Array : never;
+export {};

package/dist/types/ecmascript/gencommon.d.ts

@@ -1,7 +1,6 @@
 import { DescEnum, DescEnumValue, DescField, DescFile, DescMessage, DescMethod, DescOneof, DescService, ScalarType } from "@bufbuild/protobuf";
-import type { GeneratedFile } from "./generated-file.js";
+import type { GeneratedFile, Printable } from "./generated-file.js";
 import type { ImportSymbol } from "./import-symbol.js";
-declare type Printable = Parameters<GeneratedFile["print"]>[number];
 export declare function makeFilePreamble(file: DescFile, pluginName: string, pluginVersion: string, parameter: string | undefined, tsNoCheck: boolean): string;
 export declare function createJsDocBlock(text: string, indentation?: string): Printable;
 export declare function makeJsDoc(desc: DescEnum | DescEnumValue | DescMessage | DescOneof | DescField | DescService | DescMethod, indentation?: string): Printable;
@@ -20,4 +19,3 @@ export declare function getFieldIntrinsicDefaultValue(field: DescField): {
     defaultValue: Printable | undefined;
     typingInferrable: boolean;
 };
-export {};