@bufbuild/protoplugin 0.0.9

package/dist/esm/create-es-plugin.js

@@ -0,0 +1,113 @@
+// 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 { createSchema } from "./ecmascript/schema.js";
+import { CodeGeneratorResponse } from "@bufbuild/protobuf";
+import { PluginOptionError } from "./error.js";
+/**
+ * Create a new code generator plugin for ECMAScript.
+ * The plugin can generate JavaScript, TypeScript, or TypeScript declaration
+ * files.
+ */
+export function createEcmaScriptPlugin(init, generateFn) {
+    return {
+        name: init.name,
+        version: init.version,
+        run(req) {
+            const { targets, tsNocheck, bootstrapWkt } = parseParameter(req.parameter, init.parseOption);
+            const { schema, toResponse } = createSchema(req, targets, init.name, init.version, tsNocheck, bootstrapWkt);
+            generateFn(schema);
+            const res = new CodeGeneratorResponse();
+            toResponse(res);
+            return res;
+        },
+    };
+}
+function parseParameter(parameter, parseOption) {
+    let targets = ["js", "dts"];
+    let tsNocheck = true;
+    let bootstrapWkt = false;
+    for (const { key, value } of splitParameter(parameter)) {
+        switch (key) {
+            case "target":
+                targets = [];
+                for (const rawTarget of value.split("+")) {
+                    switch (rawTarget) {
+                        case "js":
+                        case "ts":
+                        case "dts":
+                            if (targets.indexOf(rawTarget) < 0) {
+                                targets.push(rawTarget);
+                            }
+                            break;
+                        default:
+                            throw new PluginOptionError(`${key}=${value}`);
+                    }
+                }
+                value.split("+");
+                break;
+            case "ts_nocheck":
+                switch (value) {
+                    case "true":
+                    case "1":
+                        tsNocheck = true;
+                        break;
+                    case "false":
+                    case "0":
+                        tsNocheck = false;
+                        break;
+                    default:
+                        throw new PluginOptionError(`${key}=${value}`);
+                }
+                break;
+            case "bootstrap_wkt":
+                switch (value) {
+                    case "true":
+                    case "1":
+                        bootstrapWkt = true;
+                        break;
+                    case "false":
+                    case "0":
+                        bootstrapWkt = false;
+                        break;
+                    default:
+                        throw new PluginOptionError(`${key}=${value}`);
+                }
+                break;
+            default:
+                if (parseOption === undefined) {
+                    throw new PluginOptionError(`${key}=${value}`);
+                }
+                try {
+                    parseOption(key, value);
+                }
+                catch (e) {
+                    throw new PluginOptionError(`${key}=${value}`, e);
+                }
+                break;
+        }
+    }
+    return { targets, tsNocheck, bootstrapWkt };
+}
+function splitParameter(parameter) {
+    if (parameter == undefined) {
+        return [];
+    }
+    return parameter.split(",").map((pair) => {
+        const i = pair.indexOf("=");
+        return {
+            key: i === -1 ? pair : pair.substring(0, i),
+            value: i === -1 ? "" : pair.substring(i + 1),
+        };
+    });
+}

package/dist/esm/ecmascript/gencommon.js

@@ -0,0 +1,327 @@
+// 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, 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 !== undefined) {
+        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}, `);
+    }
+    builder.push(`syntax ${file.syntax})\n`);
+    builder.push("/* eslint-disable */\n");
+    if (tsNoCheck) {
+        builder.push("/* @ts-nocheck */\n");
+    }
+    builder.push("\n");
+    writeLeadingComments(file.getPackageComments());
+    return trimSuffix(builder.join(""), "\n");
+}
+export function createJsDocBlock(text, indentation = "") {
+    if (text.trim().length == 0) {
+        return [];
+    }
+    let lines = text.split("\n");
+    if (lines.length === 0) {
+        return [];
+    }
+    lines = lines.map((l) => l.split("*/").join("*\\/"));
+    lines = lines.map((l) => (l.length > 0 ? " " + l : l));
+    // prettier-ignore
+    return [
+        `${indentation}/**\n`,
+        ...lines.map((l) => `${indentation} *${l}\n`),
+        `${indentation} */`
+    ];
+}
+export function makeJsDoc(desc, indentation = "") {
+    var _a, _b;
+    const comments = desc.getComments();
+    let text = "";
+    if (comments.leading !== undefined) {
+        text += comments.leading;
+        if (text.endsWith("\n")) {
+            text = text.substring(0, text.length - 1);
+        }
+    }
+    if (comments.trailing !== undefined) {
+        if (text.length > 0) {
+            text += "\n\n";
+        }
+        text += comments.trailing;
+        if (text.endsWith("\n")) {
+            text = text.substring(0, text.length - 1);
+        }
+    }
+    if (text.length > 0) {
+        text += "\n\n";
+    }
+    text = text
+        .split("\n")
+        .map((line) => (line.startsWith(" ") ? line.substring(1) : line))
+        .join("\n");
+    switch (desc.kind) {
+        case "enum_value":
+            text += `@generated from enum value: ${desc.declarationString()};`;
+            break;
+        case "scalar_field":
+        case "enum_field":
+        case "message_field":
+        case "map_field":
+            text += `@generated from field: ${desc.declarationString()};`;
+            break;
+        default:
+            text += `@generated from ${desc.toString()}`;
+            break;
+    }
+    let deprecated = desc.deprecated;
+    switch (desc.kind) {
+        case "enum":
+        case "message":
+        case "service":
+            deprecated = deprecated || ((_b = (_a = desc.file.proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false);
+            break;
+        default:
+            break;
+    }
+    if (deprecated) {
+        text += "\n@deprecated";
+    }
+    if (text.length > 0) {
+        return createJsDocBlock(text, indentation);
+    }
+    return [];
+}
+/**
+ * Returns an expression for the TypeScript typing of a field,
+ * and whether the property should be optional.
+ */
+export function getFieldTyping(field, file) {
+    const typing = [];
+    let optional = false;
+    switch (field.kind) {
+        case "scalar_field":
+            typing.push(scalarTypeScriptType(field.scalar));
+            optional = field.optional;
+            break;
+        case "message_field": {
+            const baseType = getUnwrappedFieldType(field);
+            if (baseType !== undefined) {
+                typing.push(scalarTypeScriptType(baseType));
+            }
+            else {
+                typing.push(file.import(field.message).toTypeOnly());
+            }
+            optional = true;
+            break;
+        }
+        case "enum_field":
+            typing.push(file.import(field.enum).toTypeOnly());
+            optional = field.optional;
+            break;
+        case "map_field": {
+            let keyType;
+            switch (field.mapKey) {
+                case ScalarType.INT32:
+                case ScalarType.FIXED32:
+                case ScalarType.UINT32:
+                case ScalarType.SFIXED32:
+                case ScalarType.SINT32:
+                    keyType = "number";
+                    break;
+                default:
+                    keyType = "string";
+                    break;
+            }
+            let valueType;
+            switch (field.mapValue.kind) {
+                case "scalar":
+                    valueType = scalarTypeScriptType(field.mapValue.scalar);
+                    break;
+                case "message":
+                    valueType = file.import(field.mapValue.message).toTypeOnly();
+                    break;
+                case "enum":
+                    valueType = file.import(field.mapValue.enum).toTypeOnly();
+                    break;
+            }
+            typing.push("{ [key: ", keyType, "]: ", valueType, " }");
+            optional = false;
+            break;
+        }
+    }
+    if (field.repeated) {
+        typing.push("[]");
+        optional = false;
+    }
+    return { typing, optional };
+}
+export function scalarTypeScriptType(type) {
+    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:
+            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") +
+        '"');
+}
+export function getFieldExplicitDefaultValue(field, protoInt64Symbol) {
+    switch (field.kind) {
+        case "enum_field": {
+            const value = field.enum.values.find((v) => v.number === field.getDefaultValue());
+            if (value !== undefined) {
+                return [value.parent, ".", localName(value)];
+            }
+            break;
+        }
+        case "scalar_field": {
+            const defaultValue = field.getDefaultValue();
+            if (defaultValue === undefined) {
+                break;
+            }
+            switch (field.scalar) {
+                case ScalarType.FLOAT:
+                case ScalarType.DOUBLE: {
+                    return defaultValue;
+                }
+                case ScalarType.INT64:
+                case ScalarType.SINT64:
+                case ScalarType.SFIXED64:
+                    return [protoInt64Symbol, `.parse("${defaultValue.toString()}")`];
+                case ScalarType.UINT64:
+                case ScalarType.FIXED64:
+                    return [protoInt64Symbol, `.uParse("${defaultValue.toString()}")`];
+                case ScalarType.INT32:
+                case ScalarType.FIXED32:
+                case ScalarType.UINT32:
+                case ScalarType.SFIXED32:
+                case ScalarType.SINT32:
+                    return defaultValue;
+                case ScalarType.BOOL: {
+                    return defaultValue;
+                }
+                case ScalarType.STRING: {
+                    if (typeof defaultValue == "string") {
+                        return literalString(defaultValue);
+                    }
+                    break;
+                }
+                case ScalarType.BYTES: {
+                    if (defaultValue instanceof Uint8Array) {
+                        return defaultValue;
+                    }
+                    break;
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return undefined;
+}
+export function getFieldIntrinsicDefaultValue(field) {
+    if (field.repeated) {
+        return {
+            defaultValue: "[]",
+            typingInferrable: false,
+        };
+    }
+    if (field.kind == "map_field") {
+        return {
+            defaultValue: "{}",
+            typingInferrable: false,
+        };
+    }
+    let defaultValue = undefined;
+    let typingInferrable = false;
+    if (field.parent.file.syntax == "proto3") {
+        switch (field.kind) {
+            case "enum_field": {
+                if (!field.optional) {
+                    const zeroValue = field.enum.values.find((v) => v.number === 0);
+                    if (zeroValue === undefined) {
+                        throw new Error("invalid proto3 enum: missing 0 value");
+                    }
+                    defaultValue = [field.enum, ".", localName(zeroValue)];
+                    typingInferrable = true;
+                }
+                break;
+            }
+            case "scalar_field":
+                if (!field.optional) {
+                    typingInferrable = true;
+                    if (field.scalar === ScalarType.STRING) {
+                        defaultValue = literalString("");
+                    }
+                    else {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-assignment
+                        defaultValue = scalarDefaultValue(field.scalar);
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return {
+        defaultValue,
+        typingInferrable,
+    };
+}