@bufbuild/protoplugin 0.0.9

package/README.md

@@ -0,0 +1,38 @@
+# @bufbuild/protoplugin
+
+This package helps to create your own code generator plugin.
+
+## Protocol Buffers for ECMAScript
+
+A complete implementation of [Protocol Buffers](https://developers.google.com/protocol-buffers)
+in TypeScript, suitable for web browsers and Node.js.  
+Learn more at [github.com/bufbuild/protobuf-es](https://github.com/bufbuild/protobuf-es).
+
+
+It is a complete implementation of [Protocol Buffers](https://developers.google.com/protocol-buffers)
+in TypeScript, suitable for web browsers and Node.js.
+
+For example, the following definition:
+
+```protobuf
+message Person {
+  string name = 1;
+  int32 id = 2;  // Unique ID number for this person.
+  string email = 3;
+}
+```
+
+Is compiled to an ECMAScript class that can be used like this:
+
+```typescript
+let pete = new Person({
+  name: "pete",
+  id: 123
+});
+
+let bytes = pete.toBinary();
+pete = Person.fromBinary(bytes);
+pete = Person.fromJsonString('{"name": "pete", "id": 123}');
+```
+
+Learn more at [github.com/bufbuild/protobuf-es](https://github.com/bufbuild/protobuf-es).

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

@@ -0,0 +1,117 @@
+"use strict";
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEcmaScriptPlugin = void 0;
+const schema_js_1 = require("./ecmascript/schema.js");
+const protobuf_1 = require("@bufbuild/protobuf");
+const error_js_1 = require("./error.js");
+/**
+ * Create a new code generator plugin for ECMAScript.
+ * The plugin can generate JavaScript, TypeScript, or TypeScript declaration
+ * files.
+ */
+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 } = (0, schema_js_1.createSchema)(req, targets, init.name, init.version, tsNocheck, bootstrapWkt);
+            generateFn(schema);
+            const res = new protobuf_1.CodeGeneratorResponse();
+            toResponse(res);
+            return res;
+        },
+    };
+}
+exports.createEcmaScriptPlugin = createEcmaScriptPlugin;
+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 error_js_1.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 error_js_1.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 error_js_1.PluginOptionError(`${key}=${value}`);
+                }
+                break;
+            default:
+                if (parseOption === undefined) {
+                    throw new error_js_1.PluginOptionError(`${key}=${value}`);
+                }
+                try {
+                    parseOption(key, value);
+                }
+                catch (e) {
+                    throw new error_js_1.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/cjs/ecmascript/gencommon.js

@@ -0,0 +1,338 @@
+"use strict";
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldIntrinsicDefaultValue = exports.getFieldExplicitDefaultValue = exports.literalString = exports.scalarTypeScriptType = exports.getFieldTyping = exports.makeJsDoc = exports.createJsDocBlock = exports.makeFilePreamble = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const { localName, getUnwrappedFieldType, scalarDefaultValue } = protobuf_1.codegenInfo;
+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");
+}
+exports.makeFilePreamble = makeFilePreamble;
+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} */`
+    ];
+}
+exports.createJsDocBlock = createJsDocBlock;
+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 [];
+}
+exports.makeJsDoc = makeJsDoc;
+/**
+ * Returns an expression for the TypeScript typing of a field,
+ * and whether the property should be optional.
+ */
+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 protobuf_1.ScalarType.INT32:
+                case protobuf_1.ScalarType.FIXED32:
+                case protobuf_1.ScalarType.UINT32:
+                case protobuf_1.ScalarType.SFIXED32:
+                case protobuf_1.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 };
+}
+exports.getFieldTyping = getFieldTyping;
+function scalarTypeScriptType(type) {
+    switch (type) {
+        case protobuf_1.ScalarType.STRING:
+            return "string";
+        case protobuf_1.ScalarType.BOOL:
+            return "boolean";
+        case protobuf_1.ScalarType.UINT64:
+        case protobuf_1.ScalarType.SFIXED64:
+        case protobuf_1.ScalarType.FIXED64:
+        case protobuf_1.ScalarType.SINT64:
+        case protobuf_1.ScalarType.INT64:
+            return "bigint";
+        case protobuf_1.ScalarType.BYTES:
+            return "Uint8Array";
+        default:
+            return "number";
+    }
+}
+exports.scalarTypeScriptType = scalarTypeScriptType;
+function literalString(value) {
+    return ('"' +
+        value
+            .split("\\")
+            .join("\\\\")
+            .split('"')
+            .join('\\"')
+            .split("\r")
+            .join("\\r")
+            .split("\n")
+            .join("\\n") +
+        '"');
+}
+exports.literalString = literalString;
+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 protobuf_1.ScalarType.FLOAT:
+                case protobuf_1.ScalarType.DOUBLE: {
+                    return defaultValue;
+                }
+                case protobuf_1.ScalarType.INT64:
+                case protobuf_1.ScalarType.SINT64:
+                case protobuf_1.ScalarType.SFIXED64:
+                    return [protoInt64Symbol, `.parse("${defaultValue.toString()}")`];
+                case protobuf_1.ScalarType.UINT64:
+                case protobuf_1.ScalarType.FIXED64:
+                    return [protoInt64Symbol, `.uParse("${defaultValue.toString()}")`];
+                case protobuf_1.ScalarType.INT32:
+                case protobuf_1.ScalarType.FIXED32:
+                case protobuf_1.ScalarType.UINT32:
+                case protobuf_1.ScalarType.SFIXED32:
+                case protobuf_1.ScalarType.SINT32:
+                    return defaultValue;
+                case protobuf_1.ScalarType.BOOL: {
+                    return defaultValue;
+                }
+                case protobuf_1.ScalarType.STRING: {
+                    if (typeof defaultValue == "string") {
+                        return literalString(defaultValue);
+                    }
+                    break;
+                }
+                case protobuf_1.ScalarType.BYTES: {
+                    if (defaultValue instanceof Uint8Array) {
+                        return defaultValue;
+                    }
+                    break;
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return undefined;
+}
+exports.getFieldExplicitDefaultValue = getFieldExplicitDefaultValue;
+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 === protobuf_1.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,
+    };
+}
+exports.getFieldIntrinsicDefaultValue = getFieldIntrinsicDefaultValue;