@bufbuild/protoplugin 1.7.2 → 1.8.0

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":
@@ -307,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;

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

@@ -11,67 +11,26 @@
 // 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, Edition, LongType, ScalarType, } from "@bufbuild/protobuf";
-const { localName, getUnwrappedFieldType, scalarDefaultValue } = codegenInfo;
-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");
+import { codegenInfo, LongType, ScalarType, } from "@bufbuild/protobuf";
+const { localName, getUnwrappedFieldType, scalarZeroValue } = codegenInfo;
+/**
+ * @deprecated Please use GeneratedFile.string() instead
+ */
+export function literalString(value) {
+    return ('"' +
+        value
+            .split("\\")
+            .join("\\\\")
+            .split('"')
+            .join('\\"')
+            .split("\r")
+            .join("\\r")
+            .split("\n")
+            .join("\\n") +
+        '"');
 }
 /**
- * Returns an expression for the TypeScript typing of a field,
- * and whether the property should be optional.
+ * @deprecated
  */
 export function getFieldTyping(field, file) {
     const typing = [];
@@ -133,40 +92,9 @@ export function getFieldTyping(field, file) {
     }
     return { typing, optional };
 }
-export function scalarTypeScriptType(type, longType) {
-    switch (type) {
-        case ScalarType.STRING:
-            return "string";
-        case ScalarType.BOOL:
-            return "boolean";
-        case ScalarType.UINT64:
-        case ScalarType.SFIXED64:
-        case ScalarType.FIXED64:
-        case ScalarType.SINT64:
-        case ScalarType.INT64:
-            if (longType === LongType.STRING) {
-                return "string";
-            }
-            return "bigint";
-        case ScalarType.BYTES:
-            return "Uint8Array";
-        default:
-            return "number";
-    }
-}
-export function literalString(value) {
-    return ('"' +
-        value
-            .split("\\")
-            .join("\\\\")
-            .split('"')
-            .join('\\"')
-            .split("\r")
-            .join("\\r")
-            .split("\n")
-            .join("\\n") +
-        '"');
-}
+/**
+ * @deprecated
+ */
 export function getFieldExplicitDefaultValue(field, protoInt64Symbol) {
     switch (field.fieldKind) {
         case "enum": {
@@ -222,6 +150,9 @@ export function getFieldExplicitDefaultValue(field, protoInt64Symbol) {
     }
     return undefined;
 }
+/**
+ * @deprecated
+ */
 export function getFieldIntrinsicDefaultValue(field) {
     if (field.repeated) {
         return {
@@ -257,8 +188,7 @@ export function getFieldIntrinsicDefaultValue(field) {
                         defaultValue = literalString("");
                     }
                     else {
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-assignment
-                        defaultValue = scalarDefaultValue(field.scalar, field.longType);
+                        defaultValue = scalarZeroValue(field.scalar, field.longType);
                         if (typeof defaultValue === "string") {
                             defaultValue = literalString(defaultValue);
                         }
@@ -274,3 +204,27 @@ export function getFieldIntrinsicDefaultValue(field) {
         typingInferrable,
     };
 }
+/**
+ * @deprecated
+ */
+function scalarTypeScriptType(type, longType) {
+    switch (type) {
+        case ScalarType.STRING:
+            return "string";
+        case ScalarType.BOOL:
+            return "boolean";
+        case ScalarType.UINT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.FIXED64:
+        case ScalarType.SINT64:
+        case ScalarType.INT64:
+            if (longType === LongType.STRING) {
+                return "string";
+            }
+            return "bigint";
+        case ScalarType.BYTES:
+            return "Uint8Array";
+        default:
+            return "number";
+    }
+}

package/dist/esm/ecmascript/opaque-printables.d.ts

@@ -0,0 +1,26 @@
+import { DescEnum, DescExtension, DescMessage, LongType, ScalarType } from "@bufbuild/protobuf";
+export type LiteralProtoInt64 = {
+    readonly kind: "es_proto_int64";
+    type: ScalarType.INT64 | ScalarType.SINT64 | ScalarType.SFIXED64 | ScalarType.UINT64 | ScalarType.FIXED64;
+    longType: LongType;
+    value: bigint | string;
+};
+export type LiteralString = {
+    readonly kind: "es_string";
+    value: string;
+};
+export type RefDescMessage = {
+    readonly kind: "es_ref_message";
+    type: DescMessage;
+    typeOnly: boolean;
+};
+export type RefDescEnum = {
+    readonly kind: "es_ref_enum";
+    type: DescEnum;
+    typeOnly: boolean;
+};
+export type ExportDeclaration = {
+    readonly kind: "es_export_decl";
+    declaration: string;
+    name: string | DescMessage | DescEnum | DescExtension;
+};