@bufbuild/protoplugin 0.1.1 → 0.2.1

package/README.md

@@ -1,38 +1,32 @@
 # @bufbuild/protoplugin
 
-This package helps to create your own code generator plugin.
+This package helps to create your own code generator plugin using the 
+Protobuf-ES plugin framework.
 
-## Protocol Buffers for ECMAScript
+Protobuf-ES is a complete implementation of [Protocol Buffers](https://developers.google.com/protocol-buffers) in TypeScript, suitable for web browsers and Node.js.  
 
-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).
+In addition to a full Protobuf runtime library, it also provides a code generator
+`protoc-gen-es`, which utilizes a plugin framework to generate base types from
+your Protobuf schema.  It is fully compatible with both Buf and protoc compilers.
 
+And now, you can write your own Protobuf-ES compatible plugins using this same
+plugin framework with the `@bufbuild/protoplugin` package.
 
-It is a complete implementation of [Protocol Buffers](https://developers.google.com/protocol-buffers)
-in TypeScript, suitable for web browsers and Node.js.
+With `@bufbuild/protoplugin`, you can generate your own TypeScript code tailored 
+to your project or needs.  You also have various options for producing 
+JavaScript and TypeScript declaration files:
 
-For example, the following definition:
+- Exercise full control by writing your own JavaScript and declaration file
+generators in addition to TypeScript.
 
-```protobuf
-message Person {
-  string name = 1;
-  int32 id = 2;  // Unique ID number for this person.
-  string email = 3;
-}
-```
+- Generate TypeScript files only and let the framework generate JavaScript and
+declaration files automatically using our internal TypeScript compiler.
 
-Is compiled to an ECMAScript class that can be used like this:
+- Generate TypeScript files only and bring your own TypeScript compiler, using
+it to generate JavaScript and declaration files with your own version of 
+TypeScript and your own compiler options.
 
-```typescript
-let pete = new Person({
-  name: "pete",
-  id: 123
-});
+With `protoplugin`, you have all the tools at your disposal to produce ECMAScript-compliant
+code.  
 
-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).
+Get started now with our [plugin documentation](https://github.com/bufbuild/protobuf-es/blob/main/docs/writing_plugins.md). 

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

@@ -15,24 +15,84 @@
 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 transpile_js_1 = require("./ecmascript/transpile.js");
 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) {
+function createEcmaScriptPlugin(init) {
+    let transpileJs = false;
+    let transpileDts = false;
     return {
         name: init.name,
         version: init.version,
         run(req) {
-            const { targets, tsNocheck, bootstrapWkt, rewriteImports } = parseParameter(req.parameter, init.parseOption);
-            const { schema, toResponse } = (0, schema_js_1.createSchema)(req, targets, init.name, init.version, tsNocheck, bootstrapWkt, rewriteImports);
-            generateFn(schema);
-            const res = new protobuf_1.CodeGeneratorResponse();
-            toResponse(res);
-            return res;
+            var _a;
+            const { targets, tsNocheck, bootstrapWkt, rewriteImports, keepEmptyFiles, } = parseParameter(req.parameter, init.parseOption);
+            const { schema, getFileInfo } = (0, schema_js_1.createSchema)(req, targets, init.name, init.version, tsNocheck, bootstrapWkt, rewriteImports, keepEmptyFiles);
+            const targetTs = schema.targets.includes("ts");
+            const targetJs = schema.targets.includes("js");
+            const targetDts = schema.targets.includes("dts");
+            // Generate TS files under the following conditions:
+            // - if they are explicitly specified as a target.
+            // - if js is specified as a target but no js generator is provided.
+            // - if dts is specified as a target, but no dts generator is provided.
+            // In the latter two cases, it is because we need the generated TS files
+            // to use for transpiling js and/or dts.
+            let tsFiles = [];
+            if (targetTs ||
+                (targetJs && !init.generateJs) ||
+                (targetDts && !init.generateDts)) {
+                init.generateTs(schema, "ts");
+                // Save off the generated TypeScript files so that we can pass these
+                // to the transpilation process if necessary.  We do not want to pass
+                // JavaScript files for a few reasons:
+                // 1.  Our usage of allowJs in the compiler options will cause issues
+                // with attempting to transpile .ts and .js files to the same location.
+                // 2.  There should be no reason to transpile JS because generateTs
+                // functions are required, so users would never be able to only specify
+                // a generateJs function and expect to transpile declarations.
+                // 3.  Transpiling is somewhat expensive and situations with an
+                // extremely large amount of files could have performance impacts.
+                tsFiles = getFileInfo();
+            }
+            if (targetJs) {
+                if (init.generateJs) {
+                    init.generateJs(schema, "js");
+                }
+                else {
+                    transpileJs = true;
+                }
+            }
+            if (targetDts) {
+                if (init.generateDts) {
+                    init.generateDts(schema, "dts");
+                }
+                else {
+                    transpileDts = true;
+                }
+            }
+            // Get generated files.  If ts was specified as a target, then we want
+            // all generated files.  If ts was not specified, we still may have
+            // generated TypeScript files to assist in transpilation.  If they were
+            // generated but not specified in the target out, we shouldn't produce
+            // these files in the CodeGeneratorResponse.
+            let files = getFileInfo();
+            if (!targetTs && tsFiles.length > 0) {
+                files = files.filter((file) => !tsFiles.some((tsFile) => tsFile.name === file.name));
+            }
+            // If either boolean is true, it means it was specified in the target out
+            // but no generate function was provided.  This also means that we will
+            // have generated .ts files above.
+            if (transpileJs || transpileDts) {
+                const transpileFn = (_a = init.transpile) !== null && _a !== void 0 ? _a : transpile_js_1.transpile;
+                // Transpile the TypeScript files and add to the master list of files
+                const transpiledFiles = transpileFn(tsFiles, transpileJs, transpileDts);
+                files.push(...transpiledFiles);
+            }
+            return (0, schema_js_1.toResponse)(files);
         },
     };
 }
@@ -41,6 +101,7 @@ function parseParameter(parameter, parseOption) {
     let targets = ["js", "dts"];
     let tsNocheck = true;
     let bootstrapWkt = false;
+    let keepEmptyFiles = false;
     const rewriteImports = [];
     for (const { key, value } of splitParameter(parameter)) {
         switch (key) {
@@ -98,6 +159,21 @@ function parseParameter(parameter, parseOption) {
                 rewriteImports.push({ pattern, target });
                 break;
             }
+            case "keep_empty_files": {
+                switch (value) {
+                    case "true":
+                    case "1":
+                        keepEmptyFiles = true;
+                        break;
+                    case "false":
+                    case "0":
+                        keepEmptyFiles = false;
+                        break;
+                    default:
+                        throw new error_js_1.PluginOptionError(`${key}=${value}`);
+                }
+                break;
+            }
             default:
                 if (parseOption === undefined) {
                     throw new error_js_1.PluginOptionError(`${key}=${value}`);
@@ -111,7 +187,7 @@ function parseParameter(parameter, parseOption) {
                 break;
         }
     }
-    return { targets, tsNocheck, bootstrapWkt, rewriteImports };
+    return { targets, tsNocheck, bootstrapWkt, rewriteImports, keepEmptyFiles };
 }
 function splitParameter(parameter) {
     if (parameter == undefined) {

package/dist/cjs/ecmascript/custom-options.js

@@ -0,0 +1,115 @@
+"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.findCustomEnumOption = exports.findCustomMessageOption = exports.findCustomScalarOption = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+/**
+ * Returns the value of a custom option with a scalar type.
+ *
+ * If no option is found, returns undefined.
+ */
+function findCustomScalarOption(desc, extensionNumber, scalarType) {
+    const reader = createBinaryReader(desc, extensionNumber);
+    if (reader) {
+        switch (scalarType) {
+            case protobuf_1.ScalarType.INT32:
+                return reader.int32();
+            case protobuf_1.ScalarType.UINT32:
+                return reader.uint32();
+            case protobuf_1.ScalarType.SINT32:
+                return reader.sint32();
+            case protobuf_1.ScalarType.FIXED32:
+                return reader.fixed32();
+            case protobuf_1.ScalarType.SFIXED32:
+                return reader.sfixed32();
+            case protobuf_1.ScalarType.FLOAT:
+                return reader.float();
+            case protobuf_1.ScalarType.DOUBLE:
+                return reader.double();
+            case protobuf_1.ScalarType.INT64:
+                return reader.int64();
+            case protobuf_1.ScalarType.SINT64:
+                return reader.sint64();
+            case protobuf_1.ScalarType.SFIXED64:
+                return reader.sfixed64();
+            case protobuf_1.ScalarType.UINT64:
+                return reader.uint64();
+            case protobuf_1.ScalarType.FIXED64:
+                return reader.fixed64();
+            case protobuf_1.ScalarType.BOOL:
+                return reader.bool();
+            case protobuf_1.ScalarType.BYTES:
+                return reader.bytes();
+            case protobuf_1.ScalarType.STRING:
+                return reader.string();
+            default: {
+                break;
+            }
+        }
+    }
+    return undefined;
+}
+exports.findCustomScalarOption = findCustomScalarOption;
+/**
+ * Returns the value of a custom message option for the given descriptor and
+ * extension number.
+ * The msgType param is then used to deserialize the message for returning to
+ * the caller.
+ *
+ * If no options are found, returns undefined.
+ *
+ * If the message option is unable to be read or deserialized, an error will
+ * be thrown.
+ */
+function findCustomMessageOption(desc, extensionNumber, msgType) {
+    const reader = createBinaryReader(desc, extensionNumber);
+    if (reader) {
+        try {
+            const data = reader.bytes();
+            return msgType.fromBinary(data);
+        }
+        catch (e) {
+            const innerMessage = e instanceof Error ? e.message : String(e);
+            throw new Error(`failed to access message option: ${innerMessage}`);
+        }
+    }
+    return undefined;
+}
+exports.findCustomMessageOption = findCustomMessageOption;
+/**
+ * Returns the value of a custom enum option for the given descriptor and
+ * extension number.
+ *
+ * If no options are found, returns undefined.
+ */
+function findCustomEnumOption(desc, extensionNumber) {
+    return findCustomScalarOption(desc, extensionNumber, protobuf_1.ScalarType.INT32);
+}
+exports.findCustomEnumOption = findCustomEnumOption;
+/**
+ * Returns a binary reader for the given descriptor and extension number.
+ */
+function createBinaryReader(desc, extensionNumber) {
+    const opt = desc.proto.options;
+    let reader = undefined;
+    if (opt !== undefined) {
+        const unknownFields = protobuf_1.proto3.bin.listUnknownFields(opt);
+        const field = unknownFields.find((f) => f.no === extensionNumber);
+        if (field) {
+            reader = new protobuf_1.BinaryReader(field.data);
+        }
+    }
+    return reader;
+}

package/dist/cjs/ecmascript/gencommon.js

@@ -103,10 +103,7 @@ function makeJsDoc(desc, indentation = "") {
         case "enum_value":
             text += `@generated from enum value: ${desc.declarationString()};`;
             break;
-        case "scalar_field":
-        case "enum_field":
-        case "message_field":
-        case "map_field":
+        case "field":
             text += `@generated from field: ${desc.declarationString()};`;
             break;
         default:
@@ -139,12 +136,12 @@ exports.makeJsDoc = makeJsDoc;
 function getFieldTyping(field, file) {
     const typing = [];
     let optional = false;
-    switch (field.kind) {
-        case "scalar_field":
+    switch (field.fieldKind) {
+        case "scalar":
             typing.push(scalarTypeScriptType(field.scalar));
             optional = field.optional;
             break;
-        case "message_field": {
+        case "message": {
             const baseType = getUnwrappedFieldType(field);
             if (baseType !== undefined) {
                 typing.push(scalarTypeScriptType(baseType));
@@ -155,11 +152,11 @@ function getFieldTyping(field, file) {
             optional = true;
             break;
         }
-        case "enum_field":
+        case "enum":
             typing.push(file.import(field.enum).toTypeOnly());
             optional = field.optional;
             break;
-        case "map_field": {
+        case "map": {
             let keyType;
             switch (field.mapKey) {
                 case protobuf_1.ScalarType.INT32:
@@ -231,15 +228,15 @@ function literalString(value) {
 }
 exports.literalString = literalString;
 function getFieldExplicitDefaultValue(field, protoInt64Symbol) {
-    switch (field.kind) {
-        case "enum_field": {
+    switch (field.fieldKind) {
+        case "enum": {
             const value = field.enum.values.find((v) => v.number === field.getDefaultValue());
             if (value !== undefined) {
                 return [value.parent, ".", localName(value)];
             }
             break;
         }
-        case "scalar_field": {
+        case "scalar": {
             const defaultValue = field.getDefaultValue();
             if (defaultValue === undefined) {
                 break;
@@ -293,7 +290,7 @@ function getFieldIntrinsicDefaultValue(field) {
             typingInferrable: false,
         };
     }
-    if (field.kind == "map_field") {
+    if (field.fieldKind == "map") {
         return {
             defaultValue: "{}",
             typingInferrable: false,
@@ -302,8 +299,8 @@ function getFieldIntrinsicDefaultValue(field) {
     let defaultValue = undefined;
     let typingInferrable = false;
     if (field.parent.file.syntax == "proto3") {
-        switch (field.kind) {
-            case "enum_field": {
+        switch (field.fieldKind) {
+            case "enum": {
                 if (!field.optional) {
                     const zeroValue = field.enum.values.find((v) => v.number === 0);
                     if (zeroValue === undefined) {
@@ -314,7 +311,7 @@ function getFieldIntrinsicDefaultValue(field) {
                 }
                 break;
             }
-            case "scalar_field":
+            case "scalar":
                 if (!field.optional) {
                     typingInferrable = true;
                     if (field.scalar === protobuf_1.ScalarType.STRING) {

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

@@ -14,11 +14,10 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGeneratedFile = void 0;
-const protobuf_1 = require("@bufbuild/protobuf");
 const import_symbol_js_1 = require("./import-symbol.js");
 const gencommon_js_1 = require("./gencommon.js");
 const import_path_js_1 = require("./import-path.js");
-function createGeneratedFile(name, importPath, createTypeImport, runtimeImports, preambleSettings) {
+function createGeneratedFile(name, importPath, createTypeImport, runtimeImports, preambleSettings, keepEmpty) {
     let preamble;
     const el = [];
     return {
@@ -35,22 +34,20 @@ function createGeneratedFile(name, importPath, createTypeImport, runtimeImports,
         import(typeOrName, from) {
             if (typeof typeOrName == "string") {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                return (0, import_symbol_js_1.createImportSymbol)(name, from);
+                return (0, import_symbol_js_1.createImportSymbol)(typeOrName, from);
             }
             return createTypeImport(typeOrName);
         },
-        toResponse(res) {
-            let content = elToContent(el, importPath);
-            if (content.length === 0) {
+        getFileInfo() {
+            const content = elToContent(el, importPath);
+            if (!keepEmpty && content.length === 0) {
                 return;
             }
-            if (preamble !== undefined) {
-                content = preamble + "\n" + content;
-            }
-            res.file.push(new protobuf_1.CodeGeneratorResponse_File({
-                name: name,
+            return {
+                name,
                 content,
-            }));
+                preamble,
+            };
         },
     };
 }

package/dist/cjs/ecmascript/index.js

@@ -13,14 +13,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.literalString = exports.makeJsDoc = exports.getFieldTyping = exports.getFieldIntrinsicDefaultValue = exports.getFieldExplicitDefaultValue = exports.createJsDocBlock = exports.localName = void 0;
+exports.findCustomEnumOption = exports.findCustomMessageOption = exports.findCustomScalarOption = exports.literalString = exports.makeJsDoc = exports.getFieldTyping = exports.getFieldIntrinsicDefaultValue = exports.getFieldExplicitDefaultValue = exports.createJsDocBlock = exports.reifyWkt = exports.localName = void 0;
 const protobuf_1 = require("@bufbuild/protobuf");
 var target_js_1 = require("./target.js");
 var schema_js_1 = require("./schema.js");
 var runtime_imports_js_1 = require("./runtime-imports.js");
 var generated_file_js_1 = require("./generated-file.js");
 var import_symbol_js_1 = require("./import-symbol.js");
-exports.localName = protobuf_1.codegenInfo.localName;
+exports.localName = protobuf_1.codegenInfo.localName, exports.reifyWkt = protobuf_1.codegenInfo.reifyWkt;
 var gencommon_js_1 = require("./gencommon.js");
 Object.defineProperty(exports, "createJsDocBlock", { enumerable: true, get: function () { return gencommon_js_1.createJsDocBlock; } });
 Object.defineProperty(exports, "getFieldExplicitDefaultValue", { enumerable: true, get: function () { return gencommon_js_1.getFieldExplicitDefaultValue; } });
@@ -28,3 +28,7 @@ Object.defineProperty(exports, "getFieldIntrinsicDefaultValue", { enumerable: tr
 Object.defineProperty(exports, "getFieldTyping", { enumerable: true, get: function () { return gencommon_js_1.getFieldTyping; } });
 Object.defineProperty(exports, "makeJsDoc", { enumerable: true, get: function () { return gencommon_js_1.makeJsDoc; } });
 Object.defineProperty(exports, "literalString", { enumerable: true, get: function () { return gencommon_js_1.literalString; } });
+var custom_options_js_1 = require("./custom-options.js");
+Object.defineProperty(exports, "findCustomScalarOption", { enumerable: true, get: function () { return custom_options_js_1.findCustomScalarOption; } });
+Object.defineProperty(exports, "findCustomMessageOption", { enumerable: true, get: function () { return custom_options_js_1.findCustomMessageOption; } });
+Object.defineProperty(exports, "findCustomEnumOption", { enumerable: true, get: function () { return custom_options_js_1.findCustomEnumOption; } });

package/dist/cjs/ecmascript/schema.js

@@ -13,13 +13,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSchema = void 0;
+exports.toResponse = exports.createSchema = void 0;
 const protobuf_1 = require("@bufbuild/protobuf");
 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");
-function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bootstrapWkt, rewriteImports) {
+function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bootstrapWkt, rewriteImports, keepEmptyFiles) {
     const descriptorSet = (0, protobuf_1.createDescriptorSet)(request.protoFile);
     const filesToGenerate = findFilesToGenerate(descriptorSet, request);
     const runtime = (0, runtime_imports_js_1.createRuntimeImports)(bootstrapWkt);
@@ -42,22 +42,38 @@ function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bo
                 pluginVersion,
                 parameter: request.parameter,
                 tsNocheck,
-            });
+            }, keepEmptyFiles);
             generatedFiles.push(genFile);
             return genFile;
         },
     };
     return {
         schema,
-        toResponse(res) {
-            res.supportedFeatures = protobuf_1.protoInt64.parse(protobuf_1.CodeGeneratorResponse_Feature.PROTO3_OPTIONAL);
-            for (const genFile of generatedFiles) {
-                genFile.toResponse(res);
-            }
+        getFileInfo() {
+            return generatedFiles.flatMap((file) => {
+                const fileInfo = file.getFileInfo();
+                // undefined is returned if the file has no content
+                if (!fileInfo) {
+                    return [];
+                }
+                return [fileInfo];
+            });
         },
     };
 }
 exports.createSchema = createSchema;
+function toResponse(files) {
+    return new protobuf_1.CodeGeneratorResponse({
+        supportedFeatures: protobuf_1.protoInt64.parse(protobuf_1.CodeGeneratorResponse_Feature.PROTO3_OPTIONAL),
+        file: files.map((f) => {
+            if (f.preamble !== undefined) {
+                f.content = f.preamble + "\n" + f.content;
+            }
+            return f;
+        }),
+    });
+}
+exports.toResponse = toResponse;
 function findFilesToGenerate(descriptorSet, request) {
     const missing = request.fileToGenerate.filter((fileToGenerate) => descriptorSet.files.every((file) => fileToGenerate !== file.name + ".proto"));
     if (missing.length) {

package/dist/cjs/ecmascript/transpile.js

@@ -0,0 +1,122 @@
+"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.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transpile = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const vfs_1 = require("@typescript/vfs");
+/* eslint-disable import/no-named-as-default-member */
+// The default options used to auto-transpile if needed.
+const defaultOptions = {
+    // Type checking
+    strict: false,
+    // modules
+    module: typescript_1.default.ModuleKind.ES2020,
+    moduleResolution: typescript_1.default.ModuleResolutionKind.NodeJs,
+    noResolve: true,
+    resolveJsonModule: false,
+    // emit
+    emitBOM: false,
+    importsNotUsedAsValues: typescript_1.default.ImportsNotUsedAsValues.Preserve,
+    newLine: typescript_1.default.NewLineKind.LineFeed,
+    preserveValueImports: false,
+    // JavaScript Support
+    allowJs: true,
+    checkJs: false,
+    // Language and Environment
+    lib: [],
+    moduleDetection: "force",
+    target: typescript_1.default.ScriptTarget.ES2017,
+    // Completeness
+    skipLibCheck: true,
+    skipDefaultLibCheck: false,
+};
+/**
+ * Create a transpiler using the given compiler options, which will compile the
+ * content provided in the files array.
+ *
+ * Note:  this library intentionally transpiles with a pinned older version of
+ * TypeScript for stability.  This version is denoted in this workspace's
+ * package.json.  For the default set of compiler options, we use a lenient
+ * set of options because the general goal is to emit code as best as we can.
+ * For a list of the options used, see `defaultOptions` above.
+ *
+ * If this is not desirable for plugin authors, they are free to provide their
+ * own transpile function as part of the plugin initialization.  If one is
+ * provided, it will be invoked instead and the framework's auto-transpilation
+ * will be bypassed.
+ *
+ * In addition, note that there is a dependency on @typescript/vfs in the
+ * top-level package as well as this package.  This is to avoid npm hoisting
+ * @typescript/vfs to the top-level node_modules directory, which then causes
+ * type mismatches when trying to use it with this package's version of
+ * TypeScript.  Ideally we would use something like Yarn's nohoist here, but
+ * npm does not support that yet.
+ */
+function createTranspiler(options, files) {
+    const fsMap = (0, vfs_1.createDefaultMapFromNodeModules)({
+        target: options.target,
+    });
+    files.forEach((file) => {
+        fsMap.set(file.name, file.content);
+    });
+    const system = (0, vfs_1.createSystem)(fsMap);
+    const host = (0, vfs_1.createVirtualCompilerHost)(system, options, typescript_1.default);
+    return typescript_1.default.createProgram({
+        rootNames: [...fsMap.keys()],
+        options,
+        host: host.compilerHost,
+    });
+}
+function transpile(files, transpileJs, transpileDts) {
+    const options = Object.assign(Object.assign({}, defaultOptions), { declaration: transpileDts, emitDeclarationOnly: transpileDts && !transpileJs });
+    // Create the transpiler (a ts.Program object)
+    const program = createTranspiler(options, files);
+    const results = [];
+    let err;
+    const result = program.emit(undefined, (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
+        // We have to go through some hoops here because the header we add to each
+        // file is not part of the AST. So we find the TypeScript file we
+        // generated for each emitted file and add the header to each output ourselves.
+        if (!sourceFiles) {
+            err = new Error(`unable to map emitted file "${fileName}" to a source file: missing source files`);
+            return;
+        }
+        if (sourceFiles.length !== 1) {
+            err = new Error(`unable to map emitted file "${fileName}" to a source file: expected 1 source file, got ${sourceFiles.length}`);
+            return;
+        }
+        const file = files.find((x) => sourceFiles[0].fileName === x.name);
+        if (!file) {
+            err = new Error(`unable to map emitted file "${fileName}" to a source file: not found`);
+            return;
+        }
+        results.push({
+            name: fileName,
+            preamble: file.preamble,
+            content: data,
+        });
+    });
+    if (err) {
+        throw err;
+    }
+    if (result.emitSkipped) {
+        throw Error("An problem occurred during transpilation and files were not generated.  Contact the plugin author for support.");
+    }
+    return results;
+}
+exports.transpile = transpile;