@bufbuild/protoplugin 0.0.9

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

@@ -0,0 +1,300 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGeneratedFile = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const import_symbol_js_1 = require("./import-symbol.js");
+const gencommon_js_1 = require("./gencommon.js");
+function createGeneratedFile(name, createTypeImport, runtimeImports, preambleSettings) {
+    const importPath = deriveImportPath(name);
+    let preamble;
+    const el = [];
+    return {
+        preamble(file) {
+            preamble = (0, gencommon_js_1.makeFilePreamble)(file, preambleSettings.pluginName, preambleSettings.pluginVersion, preambleSettings.parameter, preambleSettings.tsNocheck);
+        },
+        print(...any) {
+            printableToEl(any, el, createTypeImport, runtimeImports);
+            el.push("\n");
+        },
+        export(name) {
+            return (0, import_symbol_js_1.createImportSymbol)(name, importPath);
+        },
+        import(typeOrName, from) {
+            if (typeof typeOrName == "string") {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                return (0, import_symbol_js_1.createImportSymbol)(name, from);
+            }
+            return createTypeImport(typeOrName);
+        },
+        toResponse(res) {
+            let content = elToContent(el, importPath);
+            if (content.length === 0) {
+                return;
+            }
+            if (preamble !== undefined) {
+                content = preamble + "\n" + content;
+            }
+            res.file.push(new protobuf_1.CodeGeneratorResponse_File({
+                name: name,
+                content,
+            }));
+        },
+    };
+}
+exports.createGeneratedFile = createGeneratedFile;
+const importPathExtension = ".js";
+const knownExtensionsRE = /\.(js|ts|d.ts)$/;
+const relativePathRE = /^\.{1,2}\//;
+function deriveImportPath(filename) {
+    let importPath = filename.replace(knownExtensionsRE, importPathExtension);
+    if (!relativePathRE.test(importPath)) {
+        importPath = "./" + importPath;
+    }
+    return importPath;
+}
+function elToContent(el, importerPath) {
+    const c = [];
+    const symbolToIdentifier = processImports(el, importerPath, (typeOnly, from, names) => {
+        const p = names.map(({ name, alias }) => alias == undefined ? name : `${name} as ${alias}`);
+        const what = `{${p.join(", ")}}`;
+        if (typeOnly) {
+            c.push(`import type ${what} from ${(0, gencommon_js_1.literalString)(from)};\n`);
+        }
+        else {
+            c.push(`import ${what} from ${(0, gencommon_js_1.literalString)(from)};\n`);
+        }
+    });
+    if (c.length > 0) {
+        c.push("\n");
+    }
+    for (const e of el) {
+        if (typeof e == "string") {
+            c.push(e);
+            continue;
+        }
+        const ident = symbolToIdentifier.get(e.id);
+        if (ident != undefined) {
+            c.push(ident);
+        }
+    }
+    return c.join("");
+}
+function printableToEl(printables, el, createTypeImport, runtimeImports) {
+    for (const p of printables) {
+        if (Array.isArray(p)) {
+            printableToEl(p, el, createTypeImport, runtimeImports);
+        }
+        else {
+            switch (typeof p) {
+                case "string":
+                    el.push(p);
+                    break;
+                case "number":
+                    el.push(literalNumber(p));
+                    break;
+                case "boolean":
+                    el.push(p.toString());
+                    break;
+                case "bigint":
+                    el.push(...literalBigint(p, runtimeImports));
+                    break;
+                case "object":
+                    if (p instanceof Uint8Array) {
+                        el.push(literalUint8Array(p));
+                        break;
+                    }
+                    switch (p.kind) {
+                        case "es_symbol":
+                            el.push(p);
+                            break;
+                        case "message":
+                        case "enum":
+                            el.push(createTypeImport(p));
+                            break;
+                    }
+                    break;
+                default:
+                    throw `cannot print ${typeof p}`;
+            }
+        }
+    }
+}
+function processImports(el, importerPath, makeImportStatement) {
+    // identifiers to use in the output
+    const symbolToIdentifier = new Map();
+    // symbols that need a value import (as opposed to a type-only import)
+    const symbolToIsValue = new Map();
+    // taken in this file
+    const identifiersTaken = new Set();
+    // foreign symbols need an import
+    const foreignSymbols = [];
+    // Walk through all symbols used and populate the collections above.
+    for (const s of el) {
+        if (typeof s == "string") {
+            continue;
+        }
+        symbolToIdentifier.set(s.id, s.name);
+        if (!s.typeOnly) {
+            // a symbol is only type-imported as long as all uses are type-only
+            symbolToIsValue.set(s.id, true);
+        }
+        if (s.from === importerPath) {
+            identifiersTaken.add(s.name);
+        }
+        else {
+            foreignSymbols.push(s);
+        }
+    }
+    // Walk through all foreign symbols and make their identifiers unique.
+    const handledSymbols = new Set();
+    for (const s of foreignSymbols) {
+        if (handledSymbols.has(s.id)) {
+            continue;
+        }
+        handledSymbols.add(s.id);
+        if (!identifiersTaken.has(s.name)) {
+            identifiersTaken.add(s.name);
+            continue;
+        }
+        let i = 1;
+        let alias;
+        for (;;) {
+            // We choose '$' because it is invalid in proto identifiers.
+            alias = `${s.name}$${i}`;
+            if (!identifiersTaken.has(alias)) {
+                break;
+            }
+            i++;
+        }
+        identifiersTaken.add(alias);
+        symbolToIdentifier.set(s.id, alias);
+    }
+    const sourceToImport = new Map();
+    for (const s of foreignSymbols) {
+        let i = sourceToImport.get(s.from);
+        if (i == undefined) {
+            i = {
+                types: new Map(),
+                values: new Map(),
+            };
+            sourceToImport.set(s.from, i);
+        }
+        let alias = symbolToIdentifier.get(s.id);
+        if (alias == s.name) {
+            alias = undefined;
+        }
+        if (symbolToIsValue.get(s.id)) {
+            i.values.set(s.name, alias);
+        }
+        else {
+            i.types.set(s.name, alias);
+        }
+    }
+    // Make import statements.
+    const handledSource = new Set();
+    const buildNames = (map) => {
+        const names = [];
+        map.forEach((value, key) => names.push({ name: key, alias: value }));
+        names.sort((a, b) => a.name.localeCompare(b.name));
+        return names;
+    };
+    for (const s of foreignSymbols) {
+        if (handledSource.has(s.from)) {
+            continue;
+        }
+        handledSource.add(s.from);
+        const i = sourceToImport.get(s.from);
+        if (i == undefined) {
+            // should never happen
+            continue;
+        }
+        const from = makeImportPathRelative(importerPath, s.from);
+        if (i.types.size > 0) {
+            makeImportStatement(true, from, buildNames(i.types));
+        }
+        if (i.values.size > 0) {
+            makeImportStatement(false, from, buildNames(i.values));
+        }
+    }
+    return symbolToIdentifier;
+}
+// makeImportPathRelative makes an import path relative to the file importing
+// it. For example, consider the following files:
+// - foo/foo.js
+// - baz.js
+// If foo.js wants to import baz.js, we return ../baz.js
+function makeImportPathRelative(importer, importPath) {
+    if (!relativePathRE.test(importPath)) {
+        // We don't touch absolute imports, like @bufbuild/protobuf
+        return importPath;
+    }
+    let a = importer
+        .replace(/^\.\//, "")
+        .split("/")
+        .filter((p) => p.length > 0)
+        .slice(0, -1);
+    let b = importPath
+        .replace(/^\.\//, "")
+        .split("/")
+        .filter((p) => p.length > 0);
+    let matchingPartCount = 0;
+    for (let l = Math.min(a.length, b.length); matchingPartCount < l; matchingPartCount++) {
+        if (a[matchingPartCount] !== b[matchingPartCount]) {
+            break;
+        }
+    }
+    a = a.slice(matchingPartCount);
+    b = b.slice(matchingPartCount);
+    const c = a
+        .map(() => "..")
+        .concat(b)
+        .join("/");
+    return relativePathRE.test(c) ? c : "./" + c;
+}
+function literalNumber(value) {
+    if (Number.isNaN(value)) {
+        return "globalThis.Number.NaN";
+    }
+    if (value === Number.POSITIVE_INFINITY) {
+        return "globalThis.Number.POSITIVE_INFINITY";
+    }
+    if (value === Number.NEGATIVE_INFINITY) {
+        return "globalThis.Number.NEGATIVE_INFINITY";
+    }
+    return value.toString(10);
+}
+function literalBigint(value, runtimeImports) {
+    // Loose comparison will match between 0n and 0.
+    if (value == 0) {
+        return [runtimeImports.protoInt64, ".zero"];
+    }
+    return [
+        runtimeImports.protoInt64,
+        ".parse(",
+        (0, gencommon_js_1.literalString)(value.toString()),
+        ")",
+    ];
+}
+function literalUint8Array(value) {
+    if (value.length === 0) {
+        return "new Uint8Array(0)";
+    }
+    const strings = [];
+    for (const n of value) {
+        strings.push("0x" + n.toString(16).toUpperCase().padStart(2, "0"));
+    }
+    return `new Uint8Array([${strings.join(", ")}])`;
+}

package/dist/cjs/ecmascript/import-symbol.js

@@ -0,0 +1,34 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createImportSymbol = void 0;
+/**
+ * Create a new import symbol.
+ */
+function createImportSymbol(name, from, typeOnly) {
+    const id = `import("${from}").${name}`;
+    const s = {
+        kind: "es_symbol",
+        name,
+        from,
+        typeOnly: false,
+        id,
+        toTypeOnly() {
+            return Object.assign(Object.assign({}, this), { typeOnly: true });
+        },
+    };
+    return typeOnly === true ? s.toTypeOnly() : s;
+}
+exports.createImportSymbol = createImportSymbol;

package/dist/cjs/ecmascript/index.js

@@ -0,0 +1,30 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.literalString = exports.makeJsDoc = exports.getFieldTyping = exports.getFieldIntrinsicDefaultValue = exports.getFieldExplicitDefaultValue = exports.createJsDocBlock = exports.localName = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+var target_js_1 = require("./target.js");
+var schema_js_1 = require("./schema.js");
+var runtime_imports_js_1 = require("./runtime-imports.js");
+var generated_file_js_1 = require("./generated-file.js");
+var import_symbol_js_1 = require("./import-symbol.js");
+exports.localName = protobuf_1.codegenInfo.localName;
+var gencommon_js_1 = require("./gencommon.js");
+Object.defineProperty(exports, "createJsDocBlock", { enumerable: true, get: function () { return gencommon_js_1.createJsDocBlock; } });
+Object.defineProperty(exports, "getFieldExplicitDefaultValue", { enumerable: true, get: function () { return gencommon_js_1.getFieldExplicitDefaultValue; } });
+Object.defineProperty(exports, "getFieldIntrinsicDefaultValue", { enumerable: true, get: function () { return gencommon_js_1.getFieldIntrinsicDefaultValue; } });
+Object.defineProperty(exports, "getFieldTyping", { enumerable: true, get: function () { return gencommon_js_1.getFieldTyping; } });
+Object.defineProperty(exports, "makeJsDoc", { enumerable: true, get: function () { return gencommon_js_1.makeJsDoc; } });
+Object.defineProperty(exports, "literalString", { enumerable: true, get: function () { return gencommon_js_1.literalString; } });

package/dist/cjs/ecmascript/runtime-imports.js

@@ -0,0 +1,46 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuntimeImports = void 0;
+const import_symbol_js_1 = require("./import-symbol.js");
+const protobuf_1 = require("@bufbuild/protobuf");
+function createRuntimeImports(bootstrapWkt) {
+    // prettier-ignore
+    return {
+        proto2: infoToSymbol("proto2", bootstrapWkt),
+        proto3: infoToSymbol("proto3", bootstrapWkt),
+        Message: infoToSymbol("Message", bootstrapWkt),
+        PartialMessage: infoToSymbol("PartialMessage", bootstrapWkt),
+        PlainMessage: infoToSymbol("PlainMessage", bootstrapWkt),
+        FieldList: infoToSymbol("FieldList", bootstrapWkt),
+        MessageType: infoToSymbol("MessageType", bootstrapWkt),
+        BinaryReadOptions: infoToSymbol("BinaryReadOptions", bootstrapWkt),
+        BinaryWriteOptions: infoToSymbol("BinaryWriteOptions", bootstrapWkt),
+        JsonReadOptions: infoToSymbol("JsonReadOptions", bootstrapWkt),
+        JsonWriteOptions: infoToSymbol("JsonWriteOptions", bootstrapWkt),
+        JsonValue: infoToSymbol("JsonValue", bootstrapWkt),
+        JsonObject: infoToSymbol("JsonObject", bootstrapWkt),
+        protoInt64: infoToSymbol("protoInt64", bootstrapWkt),
+        ScalarType: infoToSymbol("ScalarType", bootstrapWkt),
+        MethodKind: infoToSymbol("MethodKind", bootstrapWkt),
+        MethodIdempotency: infoToSymbol("MethodIdempotency", bootstrapWkt),
+    };
+}
+exports.createRuntimeImports = createRuntimeImports;
+function infoToSymbol(name, bootstrapWkt) {
+    const info = protobuf_1.codegenInfo.symbols[name];
+    const symbol = (0, import_symbol_js_1.createImportSymbol)(name, bootstrapWkt ? info.privateImportPath : info.publicImportPath);
+    return info.typeOnly ? symbol.toTypeOnly() : symbol;
+}

package/dist/cjs/ecmascript/schema.js

@@ -0,0 +1,84 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSchema = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+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");
+function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bootstrapWkt) {
+    const descriptorSet = (0, protobuf_1.createDescriptorSet)(request.protoFile);
+    const filesToGenerate = findFilesToGenerate(descriptorSet, request);
+    const runtime = (0, runtime_imports_js_1.createRuntimeImports)(bootstrapWkt);
+    const createTypeImport = (desc) => {
+        const name = protobuf_1.codegenInfo.localName(desc);
+        const from = makeImportPath(desc.file, bootstrapWkt, filesToGenerate);
+        return (0, import_symbol_js_1.createImportSymbol)(name, from);
+    };
+    const generatedFiles = [];
+    const schema = {
+        targets,
+        runtime,
+        proto: request,
+        files: filesToGenerate,
+        allFiles: descriptorSet.files,
+        generateFile(name) {
+            const genFile = (0, generated_file_js_1.createGeneratedFile)(name, createTypeImport, runtime, {
+                pluginName,
+                pluginVersion,
+                parameter: request.parameter,
+                tsNocheck,
+            });
+            generatedFiles.push(genFile);
+            return genFile;
+        },
+    };
+    return {
+        schema,
+        toResponse(res) {
+            res.supportedFeatures = protobuf_1.protoInt64.parse(protobuf_1.CodeGeneratorResponse_Feature.PROTO3_OPTIONAL);
+            for (const genFile of generatedFiles) {
+                genFile.toResponse(res);
+            }
+        },
+    };
+}
+exports.createSchema = createSchema;
+function findFilesToGenerate(descriptorSet, request) {
+    const missing = request.fileToGenerate.filter((fileToGenerate) => descriptorSet.files.every((file) => fileToGenerate !== file.name + ".proto"));
+    if (missing.length) {
+        throw `files_to_generate missing in the request: ${missing.join(", ")}`;
+    }
+    return descriptorSet.files.filter((file) => request.fileToGenerate.includes(file.name + ".proto"));
+}
+/**
+ * Returns the import path for files generated by the base type generator
+ * protoc-gen-es.
+ */
+function makeImportPath(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
+    // following exceptions:
+    // 1. We are bootstrapping the runtime package via the plugin option
+    //    "bootstrap_wkt". In that case, we cannot refer to the runtime package
+    //    itself.
+    // 2. We were explicitly asked to generate the well-known type.
+    if (!bootstrapWkt &&
+        !filesToGenerate.includes(file) &&
+        protobuf_1.codegenInfo.wktSourceFiles.includes(file.name + ".proto")) {
+        return protobuf_1.codegenInfo.packageName;
+    }
+    return "./" + file.name + "_pb.js";
+}

package/dist/cjs/ecmascript/target.js

@@ -0,0 +1,15 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/error.js

@@ -0,0 +1,34 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reasonToString = exports.PluginOptionError = void 0;
+class PluginOptionError extends Error {
+    constructor(option, reason) {
+        super(reason === undefined
+            ? `invalid option "${option}`
+            : `invalid option "${option}: ${reasonToString(reason)}`);
+    }
+}
+exports.PluginOptionError = PluginOptionError;
+function reasonToString(reason) {
+    if (reason instanceof Error) {
+        return reason.message;
+    }
+    if (typeof reason === "string") {
+        return reason;
+    }
+    return String(reason);
+}
+exports.reasonToString = reasonToString;

package/dist/cjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEcmaScriptPlugin = exports.runNodeJs = void 0;
+var plugin_js_1 = require("./plugin.js");
+var schema_js_1 = require("./ecmascript/schema.js");
+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; } });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/plugin.js

@@ -0,0 +1,15 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/run-node.js

@@ -0,0 +1,84 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNodeJs = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const error_js_1 = require("./error.js");
+/**
+ * Run a plugin with Node.js.
+ *
+ * ```
+ * #!/usr/bin/env node
+ * const {runNodeJs} = require("@bufbuild/protoplugin");
+ * const {myPlugin} = require("./protoc-gen-x-plugin.js");
+ * runNodeJs(myPlugin);
+ * ```
+ */
+function runNodeJs(plugin) {
+    setBlockingStdout();
+    const args = process.argv.slice(2);
+    if ((args.length === 1 && args[0] === "-v") || args[0] === "--version") {
+        process.stdout.write(`${plugin.name} ${plugin.version}\n`);
+        process.exit(0);
+        return;
+    }
+    if (args.length !== 0) {
+        process.stderr.write(`${plugin.name} accepts a google.protobuf.compiler.CodeGeneratorRequest on stdin and writes a CodeGeneratorResponse to stdout\n`);
+        process.exit(1);
+        return;
+    }
+    readBytes(process.stdin)
+        .then((data) => {
+        const req = protobuf_1.CodeGeneratorRequest.fromBinary(data);
+        const res = plugin.run(req);
+        process.stdout.write(res.toBinary());
+        process.exit(0);
+    })
+        .catch((reason) => {
+        const message = reason instanceof error_js_1.PluginOptionError
+            ? reason.message
+            : (0, error_js_1.reasonToString)(reason);
+        process.stderr.write(`${plugin.name}: ${message}\n`);
+        process.exit(1);
+        return;
+    });
+}
+exports.runNodeJs = runNodeJs;
+/**
+ * Read a stream to the end.
+ */
+function readBytes(stream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on("data", (chunk) => chunks.push(chunk));
+        stream.on("end", () => {
+            resolve(Buffer.concat(chunks));
+        });
+        stream.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+/**
+ * Node.js buffers stdout, and process.exit() will truncate output.
+ * As a workaround, we set the stream to blocking via a private API.
+ * See https://github.com/timostamm/protobuf-ts/issues/134
+ * See https://github.com/nodejs/node/issues/6456
+ */
+function setBlockingStdout() {
+    var _a, _b;
+    const stdout = process.stdout;
+    (_b = (_a = stdout._handle) === null || _a === void 0 ? void 0 : _a.setBlocking) === null || _b === void 0 ? void 0 : _b.call(_a, true);
+}