@bufbuild/protoplugin 1.7.1 → 1.8.0

package/dist/{esm/ecmascript/export-declaration.js → cjs/ecmascript/opaque-printables.js}

@@ -1,3 +1,4 @@
+"use strict";
 // Copyright 2021-2024 Buf Technologies, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -11,10 +12,4 @@
 // 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 createExportDeclaration(declaration, name) {
-    return {
-        kind: "es_export_decl",
-        declaration,
-        name,
-    };
-}
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -3,7 +3,7 @@ import { FeatureSetDefaults } from "@bufbuild/protobuf";
 import type { FileInfo, GeneratedFile } from "./generated-file.js";
 import { RuntimeImports } from "./runtime-imports.js";
 import type { Target } from "./target.js";
-import { ParsedParameter } from "./parameter";
+import { ParsedParameter } from "./parameter.js";
 /**
  * Schema describes the files and types that the plugin is requested to
  * generate.

package/dist/cjs/ecmascript/schema.js

@@ -19,7 +19,7 @@ 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");
 const import_path_js_1 = require("./import-path.js");
-const gencommon_1 = require("./gencommon");
+const file_preamble_js_1 = require("./file-preamble.js");
 function createSchema(request, parameter, pluginName, pluginVersion, featureSetDefaults) {
     const descriptorSet = (0, protobuf_1.createDescriptorSet)(request.protoFile, {
         featureSetDefaults,
@@ -31,7 +31,7 @@ function createSchema(request, parameter, pluginName, pluginVersion, featureSetD
         const from = (0, import_path_js_1.makeImportPath)(desc.file, parameter.bootstrapWkt, filesToGenerate);
         return (0, import_symbol_js_1.createImportSymbol)(name, from);
     };
-    const createPreamble = (descFile) => (0, gencommon_1.makeFilePreamble)(descFile, pluginName, pluginVersion, parameter.sanitizedParameter, parameter.tsNocheck);
+    const createPreamble = (descFile) => (0, file_preamble_js_1.makeFilePreamble)(descFile, pluginName, pluginVersion, parameter.sanitizedParameter, parameter.tsNocheck);
     let target;
     const generatedFiles = [];
     return {

package/dist/cjs/error.d.ts

@@ -1,4 +1,6 @@
 export declare class PluginOptionError extends Error {
+    name: string;
     constructor(option: string, reason?: unknown);
 }
 export declare function reasonToString(reason: unknown): string;
+export declare function isPluginOptionError(arg: unknown): arg is PluginOptionError;

package/dist/cjs/error.js

@@ -13,13 +13,14 @@
 // 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;
+exports.isPluginOptionError = exports.reasonToString = exports.PluginOptionError = void 0;
 class PluginOptionError extends Error {
     constructor(option, reason) {
         const detail = reason !== undefined ? reasonToString(reason) : "";
         super(detail.length > 0
             ? `invalid option "${option}": ${detail}`
             : `invalid option "${option}"`);
+        this.name = "PluginOptionError";
     }
 }
 exports.PluginOptionError = PluginOptionError;
@@ -33,3 +34,10 @@ function reasonToString(reason) {
     return String(reason);
 }
 exports.reasonToString = reasonToString;
+function isPluginOptionError(arg) {
+    if (!(arg instanceof Error)) {
+        return false;
+    }
+    return arg.name === "PluginOptionError";
+}
+exports.isPluginOptionError = isPluginOptionError;

package/dist/cjs/run-node.js

@@ -46,7 +46,7 @@ function runNodeJs(plugin) {
     })
         .then(() => process.exit(0))
         .catch((reason) => {
-        const message = reason instanceof error_js_1.PluginOptionError
+        const message = (0, error_js_1.isPluginOptionError)(reason)
             ? reason.message
             : (0, error_js_1.reasonToString)(reason);
         process.stderr.write(`${plugin.name}: ${message}\n`);

package/dist/esm/ecmascript/file-preamble.d.ts

@@ -0,0 +1,2 @@
+import type { DescFile } from "@bufbuild/protobuf";
+export declare function makeFilePreamble(file: DescFile, pluginName: string, pluginVersion: string, parameter: string, tsNoCheck: boolean): string;

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

@@ -0,0 +1,70 @@
+// Copyright 2021-2024 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 { Edition } from "@bufbuild/protobuf";
+export function makeFilePreamble(file, pluginName, pluginVersion, parameter, tsNoCheck) {
+    const builder = [];
+    const trimSuffix = (str, suffix) => str.endsWith(suffix) ? str.substring(0, str.length - suffix.length) : str;
+    const writeLeadingComments = (comments) => {
+        for (let comment of comments.leadingDetached) {
+            comment = trimSuffix(comment, "\n");
+            for (const line of comment.split("\n")) {
+                builder.push(`//${line}\n`);
+            }
+            builder.push("\n");
+        }
+        if (comments.leading !== undefined) {
+            const comment = trimSuffix(comments.leading, "\n");
+            for (const line of comment.split("\n")) {
+                builder.push(`//${line}\n`);
+            }
+            builder.push("\n");
+        }
+    };
+    writeLeadingComments(file.getSyntaxComments());
+    builder.push(`// @generated by ${pluginName} ${pluginVersion}`);
+    if (parameter !== "") {
+        builder.push(` with parameter "${parameter}"`);
+    }
+    builder.push("\n");
+    builder.push(`// @generated from file ${file.name}.proto (`);
+    if (file.proto.package !== undefined) {
+        builder.push(`package ${file.proto.package}, `);
+    }
+    switch (file.edition) {
+        case Edition.EDITION_PROTO2:
+            builder.push(`syntax proto2)\n`);
+            break;
+        case Edition.EDITION_PROTO3:
+            builder.push(`syntax proto3)\n`);
+            break;
+        default: {
+            const editionString = Edition[file.edition];
+            if (typeof editionString == "string") {
+                const e = editionString.replace("EDITION_", "").toLowerCase();
+                builder.push(`edition ${e})\n`);
+            }
+            else {
+                builder.push(`unknown edition\n`);
+            }
+            break;
+        }
+    }
+    builder.push("/* eslint-disable */\n");
+    if (tsNoCheck) {
+        builder.push("// @ts-nocheck\n");
+    }
+    builder.push("\n");
+    writeLeadingComments(file.getPackageComments());
+    return trimSuffix(builder.join(""), "\n");
+}

package/dist/esm/ecmascript/generated-file.d.ts

@@ -1,12 +1,12 @@
-import type { AnyDesc, DescEnum, DescExtension, DescFile, DescMessage } from "@bufbuild/protobuf";
+import { AnyDesc, DescEnum, DescExtension, DescFile, DescMessage } from "@bufbuild/protobuf";
 import type { ImportSymbol } from "./import-symbol.js";
 import type { RuntimeImports } from "./runtime-imports.js";
-import type { ExportDeclaration } from "./export-declaration.js";
 import type { JSDocBlock } from "./jsdoc.js";
+import { ExportDeclaration, LiteralProtoInt64, LiteralString, RefDescEnum, RefDescMessage } from "./opaque-printables.js";
 /**
  * All types that can be passed to GeneratedFile.print()
  */
-export type Printable = string | number | boolean | bigint | Uint8Array | ImportSymbol | ExportDeclaration | JSDocBlock | DescMessage | DescEnum | DescExtension | Printable[];
+export type Printable = string | number | boolean | bigint | Uint8Array | ImportSymbol | ExportDeclaration | JSDocBlock | LiteralString | LiteralProtoInt64 | RefDescMessage | RefDescEnum | DescMessage | DescEnum | DescExtension | Printable[];
 /**
  * FileInfo represents an intermediate type using for transpiling TypeScript internally.
  */

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

@@ -11,10 +11,9 @@
 // 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 { LongType, protoInt64, ScalarType, } from "@bufbuild/protobuf";
 import { createImportSymbol } from "./import-symbol.js";
-import { literalString } from "./gencommon.js";
 import { makeImportPathRelative } from "./import-path.js";
-import { createExportDeclaration } from "./export-declaration.js";
 import { createJsDocBlock } from "./jsdoc.js";
 export function createGeneratedFile(name, importPath, jsImportStyle, rewriteImportPath, createTypeImport, runtimeImports, createPreamble) {
     let preamble;
@@ -44,10 +43,15 @@ export function createGeneratedFile(name, importPath, jsImportStyle, rewriteImpo
             return createImportSymbol(name, importPath);
         },
         exportDecl(declaration, name) {
-            return createExportDeclaration(declaration, name);
+            return {
+                kind: "es_export_decl",
+                declaration,
+                name,
+            };
         },
         string(string) {
-            return literalString(string);
+            // We do not use LiteralString, which was added later, to maintain backwards compatibility
+            return escapeString(string);
         },
         jsDoc(textOrDesc, indentation) {
             return createJsDocBlock(textOrDesc, indentation);
@@ -83,16 +87,16 @@ function elToContent(el, importerPath, rewriteImportPath, legacyCommonJs) {
         if (legacyCommonJs) {
             const p = names.map(({ name, alias }) => alias == undefined ? name : `${name}: ${alias}`);
             const what = `{ ${p.join(", ")} }`;
-            c.push(`const ${what} = require(${literalString(from)});\n`);
+            c.push(`const ${what} = require(${escapeString(from)});\n`);
         }
         else {
             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`);
+                c.push(`import type ${what} from ${escapeString(from)};\n`);
             }
             else {
-                c.push(`import ${what} from ${literalString(from)};\n`);
+                c.push(`import ${what} from ${escapeString(from)};\n`);
             }
         }
     });
@@ -149,17 +153,17 @@ function printableToEl(printables, el, createTypeImport, runtimeImports) {
                     el.push(p);
                     break;
                 case "number":
-                    el.push(...literalNumber(p, runtimeImports));
+                    elNumber(el, p, runtimeImports);
                     break;
                 case "boolean":
                     el.push(p.toString());
                     break;
                 case "bigint":
-                    el.push(...literalBigint(p, runtimeImports));
+                    elBigint(el, p, runtimeImports);
                     break;
                 case "object":
                     if (p instanceof Uint8Array) {
-                        el.push(literalUint8Array(p));
+                        elUint8Array(el, p);
                         break;
                     }
                     switch (p.kind) {
@@ -169,6 +173,12 @@ function printableToEl(printables, el, createTypeImport, runtimeImports) {
                         case "es_jsdoc":
                             el.push(p.toString());
                             break;
+                        case "es_string":
+                            el.push(escapeString(p.value));
+                            break;
+                        case "es_proto_int64":
+                            elProtoInt64(el, p, runtimeImports);
+                            break;
                         case "es_export_decl":
                             el.push({
                                 kind: "es_export_stmt",
@@ -178,6 +188,12 @@ function printableToEl(printables, el, createTypeImport, runtimeImports) {
                                     : createTypeImport(p.name).name,
                             });
                             break;
+                        case "es_ref_message":
+                        case "es_ref_enum":
+                            el.push(p.typeOnly
+                                ? createTypeImport(p.type).toTypeOnly()
+                                : createTypeImport(p.type));
+                            break;
                         case "message":
                         case "extension":
                         case "enum":
@@ -212,19 +228,26 @@ function processImports(el, importerPath, rewriteImportPath, makeImportStatement
     const foreignSymbols = [];
     // Walk through all symbols used and populate the collections above.
     for (const s of el) {
-        if (typeof s != "object" || s.kind !== "es_symbol") {
+        if (typeof s != "object") {
             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);
+        switch (s.kind) {
+            case "es_symbol":
+                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);
+                }
+                break;
+            case "es_export_stmt":
+                identifiersTaken.add(s.name);
+                break;
         }
     }
     // Walk through all foreign symbols and make their identifiers unique.
@@ -300,37 +323,80 @@ function processImports(el, importerPath, rewriteImportPath, makeImportStatement
     }
     return symbolToIdentifier;
 }
-function literalNumber(value, runtimeImports) {
+function elBigint(el, value, runtimeImports) {
+    if (value == protoInt64.zero) {
+        // Loose comparison will match between 0n and 0.
+        el.push(runtimeImports.protoInt64, ".zero");
+    }
+    else {
+        el.push(runtimeImports.protoInt64, value > 0 ? ".uParse(" : ".parse(", escapeString(value.toString()), ")");
+    }
+}
+function elNumber(el, value, runtimeImports) {
     if (Number.isNaN(value)) {
-        return [runtimeImports.protoDouble, ".NaN"];
+        el.push(runtimeImports.protoDouble, ".NaN");
     }
-    if (value === Number.POSITIVE_INFINITY) {
-        return [runtimeImports.protoDouble, ".POSITIVE_INFINITY"];
+    else if (value === Number.POSITIVE_INFINITY) {
+        el.push(runtimeImports.protoDouble, ".POSITIVE_INFINITY");
     }
-    if (value === Number.NEGATIVE_INFINITY) {
-        return [runtimeImports.protoDouble, ".NEGATIVE_INFINITY"];
+    else if (value === Number.NEGATIVE_INFINITY) {
+        el.push(runtimeImports.protoDouble, ".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"];
+    else {
+        el.push(value.toString(10));
     }
-    return [
-        runtimeImports.protoInt64,
-        value > 0 ? ".uParse(" : ".parse(",
-        literalString(value.toString()),
-        ")",
-    ];
 }
-function literalUint8Array(value) {
+function elUint8Array(el, value) {
     if (value.length === 0) {
-        return "new Uint8Array(0)";
+        el.push("new Uint8Array(0)");
+        return;
     }
+    el.push("new Uint8Array([");
     const strings = [];
     for (const n of value) {
         strings.push("0x" + n.toString(16).toUpperCase().padStart(2, "0"));
     }
-    return `new Uint8Array([${strings.join(", ")}])`;
+    el.push(strings.join(", "));
+    el.push("])");
+}
+function elProtoInt64(el, literal, runtimeImports) {
+    switch (literal.longType) {
+        case LongType.STRING:
+            el.push(escapeString(literal.value.toString()));
+            break;
+        case LongType.BIGINT:
+            if (literal.value == protoInt64.zero) {
+                // Loose comparison will match between 0n and 0.
+                el.push(runtimeImports.protoInt64, ".zero");
+                break;
+            }
+            switch (literal.type) {
+                case ScalarType.UINT64:
+                case ScalarType.FIXED64:
+                    el.push(runtimeImports.protoInt64);
+                    el.push(".uParse(");
+                    el.push(escapeString(literal.value.toString()));
+                    el.push(")");
+                    break;
+                default:
+                    el.push(runtimeImports.protoInt64);
+                    el.push(".parse(");
+                    el.push(escapeString(literal.value.toString()));
+                    el.push(")");
+                    break;
+            }
+    }
+}
+function escapeString(value) {
+    return ('"' +
+        value
+            .split("\\")
+            .join("\\\\")
+            .split('"')
+            .join('\\"')
+            .split("\r")
+            .join("\\r")
+            .split("\n")
+            .join("\\n") +
+        '"');
 }

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

@@ -8,12 +8,8 @@ export type { GeneratedFile, FileInfo, Printable } from "./generated-file.js";
 export type { ImportSymbol } from "./import-symbol.js";
 export { createImportSymbol } from "./import-symbol.js";
 export declare const localName: (desc: import("@bufbuild/protobuf").DescEnum | import("@bufbuild/protobuf").DescMessage | import("@bufbuild/protobuf").DescService | DescExtension | import("@bufbuild/protobuf").DescEnumValue | import("@bufbuild/protobuf").DescField | import("@bufbuild/protobuf").DescOneof | import("@bufbuild/protobuf").DescMethod) => string;
-export { getFieldExplicitDefaultValue, getFieldIntrinsicDefaultValue, getFieldTyping, } from "./gencommon.js";
-export { findCustomScalarOption, findCustomMessageOption, findCustomEnumOption, } from "./custom-options.js";
-/**
- * @deprecated Please use GeneratedFile.string() instead
- */
-export declare function literalString(value: string): string;
+export { getFieldExplicitDefaultValue, getFieldIntrinsicDefaultValue, getFieldTyping, literalString, } from "./legacy-gencommon.js";
+export { findCustomScalarOption, findCustomMessageOption, findCustomEnumOption, } from "./legacy-custom-options.js";
 /**
  * @deprecated Please use GeneratedFile.jsDoc() instead
  */

package/dist/esm/ecmascript/index.js

@@ -13,18 +13,11 @@
 // limitations under the License.
 import { codegenInfo, } from "@bufbuild/protobuf";
 import { createJsDocBlock as createJsDocBlockInternal } from "./jsdoc.js";
-import { literalString as literalStringInternal } from "./gencommon.js";
 export { reifyWkt } from "./reify-wkt.js";
 export { createImportSymbol } from "./import-symbol.js";
 export const { localName } = codegenInfo;
-export { getFieldExplicitDefaultValue, getFieldIntrinsicDefaultValue, getFieldTyping, } from "./gencommon.js";
-export { findCustomScalarOption, findCustomMessageOption, findCustomEnumOption, } from "./custom-options.js";
-/**
- * @deprecated Please use GeneratedFile.string() instead
- */
-export function literalString(value) {
-    return literalStringInternal(value);
-}
+export { getFieldExplicitDefaultValue, getFieldIntrinsicDefaultValue, getFieldTyping, literalString, } from "./legacy-gencommon.js";
+export { findCustomScalarOption, findCustomMessageOption, findCustomEnumOption, } from "./legacy-custom-options.js";
 /**
  * @deprecated Please use GeneratedFile.jsDoc() instead
  */

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

@@ -1,8 +1,14 @@
 import type { AnyDesc, DescFile } from "@bufbuild/protobuf";
 export type JSDocBlock = {
     readonly kind: "es_jsdoc";
+    /**
+     * @deprecated In a future release, we will make this property optional.
+     */
     text: string;
     indentation?: string;
+    /**
+     * @deprecated In a future release, we will remove this method.
+     */
     toString(): string;
 };
 export declare function createJsDocBlock(textOrDesc: string | Exclude<AnyDesc, DescFile>, indentation?: string): JSDocBlock;

package/dist/esm/ecmascript/jsdoc.js

@@ -11,6 +11,7 @@
 // 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.
+// TODO simplify type JSDocBlock to bring it in line with others in opaque-printables.ts
 export function createJsDocBlock(textOrDesc, indentation) {
     const text = typeof textOrDesc == "string" ? textOrDesc : createTextForDesc(textOrDesc);
     return {

package/dist/esm/ecmascript/{gencommon.d.ts → legacy-gencommon.d.ts}

@@ -1,19 +1,25 @@
 import type { DescExtension } from "@bufbuild/protobuf";
-import { DescField, DescFile, LongType, ScalarType } from "@bufbuild/protobuf";
+import { DescField } from "@bufbuild/protobuf";
 import type { GeneratedFile, Printable } from "./generated-file.js";
 import type { ImportSymbol } from "./import-symbol.js";
-export declare function makeFilePreamble(file: DescFile, pluginName: string, pluginVersion: string, parameter: string, tsNoCheck: boolean): string;
 /**
- * Returns an expression for the TypeScript typing of a field,
- * and whether the property should be optional.
+ * @deprecated Please use GeneratedFile.string() instead
+ */
+export declare function literalString(value: string): string;
+/**
+ * @deprecated
  */
 export declare function getFieldTyping(field: DescField | DescExtension, file: GeneratedFile): {
     typing: Printable;
     optional: boolean;
 };
-export declare function scalarTypeScriptType(type: ScalarType, longType: LongType): Printable;
-export declare function literalString(value: string): string;
+/**
+ * @deprecated
+ */
 export declare function getFieldExplicitDefaultValue(field: DescField | DescExtension, protoInt64Symbol: ImportSymbol): Printable | undefined;
+/**
+ * @deprecated
+ */
 export declare function getFieldIntrinsicDefaultValue(field: DescField): {
     defaultValue: Printable | undefined;
     typingInferrable: boolean;