@bufbuild/protoplugin 0.0.9

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

@@ -0,0 +1,296 @@
+// 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 { CodeGeneratorResponse_File, } from "@bufbuild/protobuf";
+import { createImportSymbol } from "./import-symbol.js";
+import { literalString, makeFilePreamble } from "./gencommon.js";
+export function createGeneratedFile(name, createTypeImport, runtimeImports, preambleSettings) {
+    const importPath = deriveImportPath(name);
+    let preamble;
+    const el = [];
+    return {
+        preamble(file) {
+            preamble = makeFilePreamble(file, preambleSettings.pluginName, preambleSettings.pluginVersion, preambleSettings.parameter, preambleSettings.tsNocheck);
+        },
+        print(...any) {
+            printableToEl(any, el, createTypeImport, runtimeImports);
+            el.push("\n");
+        },
+        export(name) {
+            return createImportSymbol(name, importPath);
+        },
+        import(typeOrName, from) {
+            if (typeof typeOrName == "string") {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                return 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 CodeGeneratorResponse_File({
+                name: name,
+                content,
+            }));
+        },
+    };
+}
+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 ${literalString(from)};\n`);
+        }
+        else {
+            c.push(`import ${what} from ${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(",
+        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/esm/ecmascript/import-symbol.js

@@ -0,0 +1,30 @@
+// 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.
+/**
+ * Create a new import symbol.
+ */
+export 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;
+}

package/dist/esm/ecmascript/index.js

@@ -0,0 +1,21 @@
+// 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 { codegenInfo } from "@bufbuild/protobuf";
+export {} from "./target.js";
+export {} from "./schema.js";
+export {} from "./runtime-imports.js";
+export {} from "./generated-file.js";
+export {} from "./import-symbol.js";
+export const { localName } = codegenInfo;
+export { createJsDocBlock, getFieldExplicitDefaultValue, getFieldIntrinsicDefaultValue, getFieldTyping, makeJsDoc, literalString, } from "./gencommon.js";

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

@@ -0,0 +1,42 @@
+// 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 { createImportSymbol } from "./import-symbol.js";
+import { codegenInfo } from "@bufbuild/protobuf";
+export 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),
+    };
+}
+function infoToSymbol(name, bootstrapWkt) {
+    const info = codegenInfo.symbols[name];
+    const symbol = createImportSymbol(name, bootstrapWkt ? info.privateImportPath : info.publicImportPath);
+    return info.typeOnly ? symbol.toTypeOnly() : symbol;
+}

package/dist/esm/ecmascript/schema.js

@@ -0,0 +1,80 @@
+// 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 { codegenInfo, 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";
+export function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bootstrapWkt) {
+    const descriptorSet = createDescriptorSet(request.protoFile);
+    const filesToGenerate = findFilesToGenerate(descriptorSet, request);
+    const runtime = createRuntimeImports(bootstrapWkt);
+    const createTypeImport = (desc) => {
+        const name = codegenInfo.localName(desc);
+        const from = makeImportPath(desc.file, bootstrapWkt, filesToGenerate);
+        return createImportSymbol(name, from);
+    };
+    const generatedFiles = [];
+    const schema = {
+        targets,
+        runtime,
+        proto: request,
+        files: filesToGenerate,
+        allFiles: descriptorSet.files,
+        generateFile(name) {
+            const genFile = createGeneratedFile(name, createTypeImport, runtime, {
+                pluginName,
+                pluginVersion,
+                parameter: request.parameter,
+                tsNocheck,
+            });
+            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);
+            }
+        },
+    };
+}
+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) &&
+        codegenInfo.wktSourceFiles.includes(file.name + ".proto")) {
+        return codegenInfo.packageName;
+    }
+    return "./" + file.name + "_pb.js";
+}

package/dist/esm/ecmascript/target.js

@@ -0,0 +1,14 @@
+// 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.
+export {};

package/dist/esm/error.js

@@ -0,0 +1,29 @@
+// 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.
+export class PluginOptionError extends Error {
+    constructor(option, reason) {
+        super(reason === undefined
+            ? `invalid option "${option}`
+            : `invalid option "${option}: ${reasonToString(reason)}`);
+    }
+}
+export function reasonToString(reason) {
+    if (reason instanceof Error) {
+        return reason.message;
+    }
+    if (typeof reason === "string") {
+        return reason;
+    }
+    return String(reason);
+}

package/dist/esm/index.js

@@ -0,0 +1,17 @@
+// 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.
+export {} from "./plugin.js";
+export {} from "./ecmascript/schema.js";
+export { runNodeJs } from "./run-node.js";
+export { createEcmaScriptPlugin } from "./create-es-plugin.js";

package/dist/esm/plugin.js

@@ -0,0 +1,14 @@
+// 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.
+export {};

package/dist/esm/run-node.js

@@ -0,0 +1,80 @@
+// 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 { CodeGeneratorRequest } from "@bufbuild/protobuf";
+import { PluginOptionError, reasonToString } from "./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);
+ * ```
+ */
+export 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 = CodeGeneratorRequest.fromBinary(data);
+        const res = plugin.run(req);
+        process.stdout.write(res.toBinary());
+        process.exit(0);
+    })
+        .catch((reason) => {
+        const message = reason instanceof PluginOptionError
+            ? reason.message
+            : reasonToString(reason);
+        process.stderr.write(`${plugin.name}: ${message}\n`);
+        process.exit(1);
+        return;
+    });
+}
+/**
+ * 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);
+}

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

@@ -0,0 +1,21 @@
+import type { Schema } from "./ecmascript";
+import type { Plugin } from "./plugin.js";
+interface PluginInit {
+    /**
+     * Name of this code generator plugin.
+     */
+    name: string;
+    /**
+     * Version of this code generator plugin.
+     */
+    version: string;
+    parseOption?: PluginOptionParseFn;
+}
+declare type PluginOptionParseFn = (key: string, value: string | undefined) => void;
+/**
+ * Create a new code generator plugin for ECMAScript.
+ * The plugin can generate JavaScript, TypeScript, or TypeScript declaration
+ * files.
+ */
+export declare function createEcmaScriptPlugin(init: PluginInit, generateFn: (schema: Schema) => void): Plugin;
+export {};

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

@@ -0,0 +1,23 @@
+import { DescEnum, DescEnumValue, DescField, DescFile, DescMessage, DescMethod, DescOneof, DescService, ScalarType } from "@bufbuild/protobuf";
+import type { GeneratedFile } 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;
+/**
+ * Returns an expression for the TypeScript typing of a field,
+ * and whether the property should be optional.
+ */
+export declare function getFieldTyping(field: DescField, file: GeneratedFile): {
+    typing: Printable;
+    optional: boolean;
+};
+export declare function scalarTypeScriptType(type: ScalarType): Printable;
+export declare function literalString(value: string): string;
+export declare function getFieldExplicitDefaultValue(field: DescField, protoInt64Symbol: ImportSymbol): Printable | undefined;
+export declare function getFieldIntrinsicDefaultValue(field: DescField): {
+    defaultValue: Printable | undefined;
+    typingInferrable: boolean;
+};
+export {};