@bufbuild/protoplugin 1.5.1 → 1.6.0

package/dist/esm/ecmascript/jsdoc.js

@@ -0,0 +1,86 @@
+// Copyright 2021-2023 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 function createJsDocBlock(textOrDesc, indentation) {
+    const text = typeof textOrDesc == "string" ? textOrDesc : createTextForDesc(textOrDesc);
+    return {
+        kind: "es_jsdoc",
+        text,
+        indentation,
+        toString() {
+            if (text.trim().length == 0) {
+                return "";
+            }
+            let lines = text.split("\n");
+            if (lines.length === 0) {
+                return "";
+            }
+            lines = lines.map((l) => l.split("*/").join("*\\/"));
+            lines = lines.map((l) => (l.length > 0 ? " " + l : l));
+            const i = indentation !== null && indentation !== void 0 ? indentation : "";
+            return [`${i}/**\n`, ...lines.map((l) => `${i} *${l}\n`), `${i} */`].join("");
+        },
+    };
+}
+function createTextForDesc(desc) {
+    var _a, _b;
+    const comments = desc.getComments();
+    let text = "";
+    if (comments.leading !== undefined) {
+        text += comments.leading;
+        if (text.endsWith("\n")) {
+            text = text.substring(0, text.length - 1);
+        }
+    }
+    if (comments.trailing !== undefined) {
+        if (text.length > 0) {
+            text += "\n\n";
+        }
+        text += comments.trailing;
+        if (text.endsWith("\n")) {
+            text = text.substring(0, text.length - 1);
+        }
+    }
+    if (text.length > 0) {
+        text += "\n\n";
+    }
+    text = text
+        .split("\n")
+        .map((line) => (line.startsWith(" ") ? line.substring(1) : line))
+        .join("\n");
+    switch (desc.kind) {
+        case "enum_value":
+            text += `@generated from enum value: ${desc.declarationString()};`;
+            break;
+        case "field":
+            text += `@generated from field: ${desc.declarationString()};`;
+            break;
+        default:
+            text += `@generated from ${desc.toString()}`;
+            break;
+    }
+    let deprecated = desc.deprecated;
+    switch (desc.kind) {
+        case "enum":
+        case "message":
+        case "service":
+            deprecated = deprecated || ((_b = (_a = desc.file.proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false);
+            break;
+        default:
+            break;
+    }
+    if (deprecated) {
+        text += "\n@deprecated";
+    }
+    return text;
+}

package/dist/esm/ecmascript/parameter.d.ts

@@ -0,0 +1,13 @@
+import { Target } from "./target.js";
+import { RewriteImports } from "./import-path.js";
+export interface ParsedParameter {
+    targets: Target[];
+    tsNocheck: boolean;
+    bootstrapWkt: boolean;
+    keepEmptyFiles: boolean;
+    rewriteImports: RewriteImports;
+    importExtension: string;
+    jsImportStyle: "module" | "legacy_commonjs";
+    sanitizedParameter: string;
+}
+export declare function parseParameter(parameter: string | undefined, parseExtraOption: ((key: string, value: string) => void) | undefined): ParsedParameter;

package/dist/esm/ecmascript/parameter.js

@@ -0,0 +1,157 @@
+// Copyright 2021-2023 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 { PluginOptionError } from "../error.js";
+export function parseParameter(parameter, parseExtraOption) {
+    let targets = ["js", "dts"];
+    let tsNocheck = true;
+    let bootstrapWkt = false;
+    let keepEmptyFiles = false;
+    const rewriteImports = [];
+    let importExtension = ".js";
+    let jsImportStyle = "module";
+    const rawParameters = [];
+    for (const { key, value, raw } of splitParameter(parameter)) {
+        // Whether this key/value plugin parameter pair should be
+        // printed to the generated file preamble
+        let sanitize = false;
+        switch (key) {
+            case "target":
+                targets = [];
+                for (const rawTarget of value.split("+")) {
+                    switch (rawTarget) {
+                        case "js":
+                        case "ts":
+                        case "dts":
+                            if (targets.indexOf(rawTarget) < 0) {
+                                targets.push(rawTarget);
+                            }
+                            break;
+                        default:
+                            throw new PluginOptionError(raw);
+                    }
+                }
+                value.split("+");
+                break;
+            case "ts_nocheck":
+                switch (value) {
+                    case "true":
+                    case "1":
+                        tsNocheck = true;
+                        break;
+                    case "false":
+                    case "0":
+                        tsNocheck = false;
+                        break;
+                    default:
+                        throw new PluginOptionError(raw);
+                }
+                break;
+            case "bootstrap_wkt":
+                switch (value) {
+                    case "true":
+                    case "1":
+                        bootstrapWkt = true;
+                        break;
+                    case "false":
+                    case "0":
+                        bootstrapWkt = false;
+                        break;
+                    default:
+                        throw new PluginOptionError(raw);
+                }
+                break;
+            case "rewrite_imports": {
+                const parts = value.split(":");
+                if (parts.length !== 2) {
+                    throw new PluginOptionError(raw, "must be in the form of <pattern>:<target>");
+                }
+                const [pattern, target] = parts;
+                rewriteImports.push({ pattern, target });
+                // rewrite_imports can be noisy and is more of an implementation detail
+                // so we strip it out of the preamble
+                sanitize = true;
+                break;
+            }
+            case "import_extension": {
+                importExtension = value === "none" ? "" : value;
+                break;
+            }
+            case "js_import_style":
+                switch (value) {
+                    case "module":
+                        jsImportStyle = value;
+                        break;
+                    case "legacy_commonjs":
+                        jsImportStyle = value;
+                        break;
+                    default:
+                        throw new PluginOptionError(raw);
+                }
+                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(raw);
+                }
+                break;
+            }
+            default:
+                if (parseExtraOption === undefined) {
+                    throw new PluginOptionError(raw);
+                }
+                try {
+                    parseExtraOption(key, value);
+                }
+                catch (e) {
+                    throw new PluginOptionError(raw, e);
+                }
+                break;
+        }
+        if (!sanitize) {
+            rawParameters.push(raw);
+        }
+    }
+    const sanitizedParameter = rawParameters.join(",");
+    return {
+        targets,
+        tsNocheck,
+        bootstrapWkt,
+        rewriteImports,
+        importExtension,
+        jsImportStyle,
+        keepEmptyFiles,
+        sanitizedParameter,
+    };
+}
+function splitParameter(parameter) {
+    if (parameter == undefined) {
+        return [];
+    }
+    return parameter.split(",").map((raw) => {
+        const i = raw.indexOf("=");
+        return {
+            key: i === -1 ? raw : raw.substring(0, i),
+            value: i === -1 ? "" : raw.substring(i + 1),
+            raw,
+        };
+    });
+}

package/dist/esm/ecmascript/schema.d.ts

@@ -1,9 +1,8 @@
 import type { CodeGeneratorRequest, DescFile } from "@bufbuild/protobuf";
-import { CodeGeneratorResponse } from "@bufbuild/protobuf";
 import type { FileInfo, GeneratedFile } from "./generated-file.js";
 import { RuntimeImports } from "./runtime-imports.js";
 import type { Target } from "./target.js";
-import { RewriteImports } from "./import-path.js";
+import { ParsedParameter } from "./parameter";
 /**
  * Schema describes the files and types that the plugin is requested to
  * generate.
@@ -34,10 +33,9 @@ export interface Schema {
      */
     readonly proto: CodeGeneratorRequest;
 }
-interface SchemaController {
-    schema: Schema;
+interface SchemaController extends Schema {
     getFileInfo: () => FileInfo[];
+    prepareGenerate(target: Target): void;
 }
-export declare function createSchema(request: CodeGeneratorRequest, targets: Target[], tsNocheck: boolean, bootstrapWkt: boolean, rewriteImports: RewriteImports, importExtension: string, keepEmptyFiles: boolean, pluginName: string, pluginVersion: string, pluginParameter: string): SchemaController;
-export declare function toResponse(files: FileInfo[]): CodeGeneratorResponse;
+export declare function createSchema(request: CodeGeneratorRequest, parameter: ParsedParameter, pluginName: string, pluginVersion: string): SchemaController;
 export {};

package/dist/esm/ecmascript/schema.js

@@ -11,63 +11,52 @@
 // 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, CodeGeneratorResponse_Feature, codegenInfo, createDescriptorSet, protoInt64, } from "@bufbuild/protobuf";
+import { codegenInfo, createDescriptorSet } 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, tsNocheck, bootstrapWkt, rewriteImports, importExtension, keepEmptyFiles, pluginName, pluginVersion, pluginParameter) {
+export function createSchema(request, parameter, pluginName, pluginVersion) {
     const descriptorSet = createDescriptorSet(request.protoFile);
     const filesToGenerate = findFilesToGenerate(descriptorSet, request);
-    const runtime = createRuntimeImports(bootstrapWkt);
+    const runtime = createRuntimeImports(parameter.bootstrapWkt);
     const createTypeImport = (desc) => {
         const name = codegenInfo.localName(desc);
-        const from = makeImportPath(desc.file, bootstrapWkt, filesToGenerate);
+        const from = makeImportPath(desc.file, parameter.bootstrapWkt, filesToGenerate);
         return createImportSymbol(name, from);
     };
+    let target;
     const generatedFiles = [];
-    const schema = {
-        targets,
+    return {
+        targets: parameter.targets,
         runtime,
         proto: request,
         files: filesToGenerate,
         allFiles: descriptorSet.files,
         generateFile(name) {
-            const genFile = createGeneratedFile(name, deriveImportPath(name), (importPath) => rewriteImportPath(importPath, rewriteImports, importExtension), createTypeImport, runtime, {
+            if (target === undefined) {
+                throw new Error("prepareGenerate() must be called before generateFile()");
+            }
+            const genFile = createGeneratedFile(name, deriveImportPath(name), target === "js" ? parameter.jsImportStyle : "module", // ts and dts always use import/export, only js may use commonjs
+            (importPath) => rewriteImportPath(importPath, parameter.rewriteImports, parameter.importExtension), createTypeImport, runtime, {
                 pluginName,
                 pluginVersion,
-                pluginParameter,
-                tsNocheck,
-            }, keepEmptyFiles);
+                pluginParameter: parameter.sanitizedParameter,
+                tsNocheck: parameter.tsNocheck,
+            });
             generatedFiles.push(genFile);
             return genFile;
         },
-    };
-    return {
-        schema,
         getFileInfo() {
-            return generatedFiles.flatMap((file) => {
-                const fileInfo = file.getFileInfo();
-                // undefined is returned if the file has no content
-                if (!fileInfo) {
-                    return [];
-                }
-                return [fileInfo];
-            });
+            return generatedFiles
+                .map((f) => f.getFileInfo())
+                .filter((fi) => parameter.keepEmptyFiles || fi.content.length > 0);
+        },
+        prepareGenerate(newTarget) {
+            target = newTarget;
         },
     };
 }
-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.d.ts

@@ -1,2 +1,2 @@
 import type { FileInfo } from "./generated-file.js";
-export declare function transpile(files: FileInfo[], transpileJs: boolean, transpileDts: boolean): FileInfo[];
+export declare function transpile(files: FileInfo[], transpileJs: boolean, transpileDts: boolean, jsImportStyle: "module" | "legacy_commonjs"): FileInfo[];

package/dist/esm/ecmascript/transpile.js

@@ -76,8 +76,11 @@ function createTranspiler(options, files) {
         host: host.compilerHost,
     });
 }
-export function transpile(files, transpileJs, transpileDts) {
+export function transpile(files, transpileJs, transpileDts, jsImportStyle) {
     const options = Object.assign(Object.assign({}, defaultOptions), { declaration: transpileDts, emitDeclarationOnly: transpileDts && !transpileJs });
+    if (jsImportStyle == "legacy_commonjs") {
+        options.module = ts.ModuleKind.CommonJS;
+    }
     // Create the transpiler (a ts.Program object)
     const program = createTranspiler(options, files);
     const results = [];

package/dist/esm/index.d.ts

@@ -1,4 +1,8 @@
+import { Schema as SchemaInternal } from "./ecmascript/schema.js";
 export { Plugin } from "./plugin.js";
-export { Schema } from "./ecmascript/schema.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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bufbuild/protoplugin",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "license": "(Apache-2.0 AND BSD-3-Clause)",
   "description": "Helps to create your own Protocol Buffers code generators.",
   "repository": {
@@ -47,7 +47,7 @@
     }
   },
   "dependencies": {
-    "@bufbuild/protobuf": "1.5.1",
+    "@bufbuild/protobuf": "1.6.0",
     "@typescript/vfs": "^1.4.0",
     "typescript": "4.5.2"
   },