@modern-js/app-tools 2.0.0-beta.0 → 2.0.0-beta.1

package/dist/js/treeshaking/builder/createSourceConfig.js

@@ -4,17 +4,15 @@ import { dirname, isAbsolute, posix, sep } from 'path';
 import { globby, mergeAlias, findMonorepoRoot, isModernjsMonorepo } from '@modern-js/utils';
 export function createSourceConfig(normalizedConfig, appContext) {
   var _normalizedConfig$sou = normalizedConfig.source,
-      alias = _normalizedConfig$sou.alias,
-      envVars = _normalizedConfig$sou.envVars,
-      globalVars = _normalizedConfig$sou.globalVars,
-      include = _normalizedConfig$sou.include,
-      moduleScopes = _normalizedConfig$sou.moduleScopes,
-      preEntry = _normalizedConfig$sou.preEntry;
+    alias = _normalizedConfig$sou.alias,
+    envVars = _normalizedConfig$sou.envVars,
+    globalVars = _normalizedConfig$sou.globalVars,
+    include = _normalizedConfig$sou.include,
+    moduleScopes = _normalizedConfig$sou.moduleScopes,
+    preEntry = _normalizedConfig$sou.preEntry;
   var builderGlobalVars = globalVars || {};
-
   var _iterator = _createForOfIteratorHelper(envVars || []),
-      _step;
-
+    _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var envVar = _step.value;
@@ -26,7 +24,6 @@ export function createSourceConfig(normalizedConfig, appContext) {
   } finally {
     _iterator.f();
   }
-
   var builderModuleScope = createBuilderModuleScope(moduleScopes);
   var builderInclude = createBuilderInclude(include, appContext);
   return {
@@ -46,21 +43,16 @@ export function createBuilderInclude(include, appContext) {
       if (isAbsolute(include)) {
         return include;
       }
-
       return new RegExp(include);
     }
-
     return include;
   }).concat(defaultInclude); // concat default Include
 
   var root = findMonorepoRoot(appContext.appDirectory);
-
   if (!root) {
     return transformInclude;
   }
-
   var modernjsMonorepo = isModernjsMonorepo(root);
-
   if (modernjsMonorepo) {
     var paths = globby.sync(posix.join(root, 'features', '**', 'package.json'), {
       ignore: ['**/node_modules/**/*']
@@ -69,14 +61,12 @@ export function createBuilderInclude(include, appContext) {
     });
     return [].concat(_toConsumableArray(paths), _toConsumableArray(transformInclude));
   }
-
   return transformInclude;
 }
 export function createBuilderModuleScope(moduleScopes) {
   if (moduleScopes) {
     var builderModuleScope = [];
     var DEFAULT_SCOPES = ['./src', './shared', /node_modules/];
-
     if (Array.isArray(moduleScopes)) {
       if (isPrimitiveScope(moduleScopes)) {
         builderModuleScope = DEFAULT_SCOPES.concat(moduleScopes);
@@ -86,12 +76,10 @@ export function createBuilderModuleScope(moduleScopes) {
     } else {
       builderModuleScope = [DEFAULT_SCOPES, moduleScopes];
     }
-
     return builderModuleScope;
   } else {
     return undefined;
   }
-
   function isPrimitiveScope(items) {
     return items.every(function (item) {
       return typeof item === 'string' || Object.prototype.toString.call(item) === '[object RegExp]';

package/dist/js/treeshaking/builder/createToolsConfig.js

@@ -4,22 +4,22 @@ import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import { applyOptionsChain } from '@modern-js/utils';
 export function createToolsConfig(normalizedConfig) {
   var _normalizedConfig$out = normalizedConfig.output,
-      disableCssExtract = _normalizedConfig$out.disableCssExtract,
-      enableTsLoader = _normalizedConfig$out.enableTsLoader;
+    disableCssExtract = _normalizedConfig$out.disableCssExtract,
+    enableTsLoader = _normalizedConfig$out.enableTsLoader;
   var _normalizedConfig$too = normalizedConfig.tools,
-      autoprefixer = _normalizedConfig$too.autoprefixer,
-      babel = _normalizedConfig$too.babel,
-      minifyCss = _normalizedConfig$too.minifyCss,
-      terser = _normalizedConfig$too.terser,
-      webpack = _normalizedConfig$too.webpack,
-      webpackChain = _normalizedConfig$too.webpackChain,
-      tsLoader = _normalizedConfig$too.tsLoader,
-      styledComponents = _normalizedConfig$too.styledComponents,
-      sass = _normalizedConfig$too.sass,
-      postcss = _normalizedConfig$too.postcss,
-      less = _normalizedConfig$too.less,
-      htmlPlugin = _normalizedConfig$too.htmlPlugin,
-      lodash = _normalizedConfig$too.lodash;
+    autoprefixer = _normalizedConfig$too.autoprefixer,
+    babel = _normalizedConfig$too.babel,
+    minifyCss = _normalizedConfig$too.minifyCss,
+    terser = _normalizedConfig$too.terser,
+    webpack = _normalizedConfig$too.webpack,
+    webpackChain = _normalizedConfig$too.webpackChain,
+    tsLoader = _normalizedConfig$too.tsLoader,
+    styledComponents = _normalizedConfig$too.styledComponents,
+    sass = _normalizedConfig$too.sass,
+    postcss = _normalizedConfig$too.postcss,
+    less = _normalizedConfig$too.less,
+    htmlPlugin = _normalizedConfig$too.htmlPlugin,
+    lodash = _normalizedConfig$too.lodash;
   var builderTsLoader = createBuilderTsLoader(tsLoader, enableTsLoader);
   var builderTsChecker = createBuilderTsChecker(normalizedConfig.output);
   return {
@@ -48,14 +48,11 @@ export function createToolsConfig(normalizedConfig) {
     }].concat(_toConsumableArray(Array.isArray(htmlPlugin) ? htmlPlugin : htmlPlugin ? [htmlPlugin] : []))
   };
 }
-
 function createBuilderTsLoader(tsLoader, enableTsLoader) {
   var useTsLoader = Boolean(enableTsLoader);
-
   if (!useTsLoader) {
     return undefined;
   }
-
   var defaultTsLoader = {
     compilerOptions: {
       target: 'es5',
@@ -68,12 +65,10 @@ function createBuilderTsLoader(tsLoader, enableTsLoader) {
     return applyOptionsChain(defaultTsLoader, tsLoader, utils);
   };
 }
-
 export function createBuilderTsChecker(output) {
-  if (output.enableTsLoader || output.disableTsChecker) {
+  if (output.enableTsLoader) {
     return false;
   }
-
   var defaultTsChecker = {
     issue: {
       include: [{

package/dist/js/treeshaking/builder/index.js

@@ -1,59 +1,58 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { createBuilder } from '@modern-js/builder';
 import { builderWebpackProvider } from '@modern-js/builder-webpack-provider';
-import { applyOptionsChain } from '@modern-js/utils';
+import { applyOptionsChain, isUseSSRBundle } from '@modern-js/utils';
 import { PluginCompatModern } from "./builderPlugins/compatModern";
 import { createHtmlConfig } from "./createHtmlConfig";
 import { createOutputConfig } from "./createOutputConfig";
 import { createSourceConfig } from "./createSourceConfig";
 import { createToolsConfig } from "./createToolsConfig";
-export default /*#__PURE__*/(function () {
-  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
-    var _ref$target, target, normalizedConfig, appContext, compatPluginConfig, targets, builderConfig, webpackProvider, builderOptions, builder;
-
+function getBuilderTargets(normalizedConfig) {
+  var targets = ['web'];
+  if (normalizedConfig.output.enableModernMode && !targets.includes('modern-web')) {
+    targets.push('modern-web');
+  }
+  if (isUseSSRBundle(normalizedConfig)) {
+    targets.push('node');
+  }
+  return targets;
+}
+export function createBuilderForEdenX(_x) {
+  return _createBuilderForEdenX.apply(this, arguments);
+}
+function _createBuilderForEdenX() {
+  _createBuilderForEdenX = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+    var normalizedConfig, appContext, compatPluginConfig, builderConfig, webpackProvider, target, builderOptions, builder;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            _ref$target = _ref.target, target = _ref$target === void 0 ? 'web' : _ref$target, normalizedConfig = _ref.normalizedConfig, appContext = _ref.appContext, compatPluginConfig = _ref.compatPluginConfig;
-            targets = Array.isArray(target) ? target : [target];
-
-            if (normalizedConfig.output.enableModernMode && !targets.includes('modern-web')) {
-              targets.push('modern-web');
-            }
-
+            normalizedConfig = _ref.normalizedConfig, appContext = _ref.appContext, compatPluginConfig = _ref.compatPluginConfig;
             builderConfig = createBuilderProviderConfig(normalizedConfig, appContext); // create webpack provider
-
             webpackProvider = builderWebpackProvider({
               builderConfig: builderConfig
             });
+            target = getBuilderTargets(normalizedConfig);
             builderOptions = createBuilderOptions(target, appContext);
-            _context.next = 8;
+            _context.next = 7;
             return createBuilder(webpackProvider, builderOptions);
-
-          case 8:
+          case 7:
             builder = _context.sent;
-            _context.next = 11;
+            _context.next = 10;
             return applyBuilderPlugins(builder, normalizedConfig, appContext, compatPluginConfig);
-
-          case 11:
+          case 10:
             return _context.abrupt("return", builder);
-
-          case 12:
+          case 11:
           case "end":
             return _context.stop();
         }
       }
     }, _callee);
   }));
-
-  return function (_x) {
-    return _ref2.apply(this, arguments);
-  };
-})();
-
+  return _createBuilderForEdenX.apply(this, arguments);
+}
 function createBuilderProviderConfig(normalizedConfig, appContext) {
   var source = createSourceConfig(normalizedConfig, appContext);
   var html = createHtmlConfig(normalizedConfig, appContext);
@@ -64,33 +63,33 @@ function createBuilderProviderConfig(normalizedConfig, appContext) {
     html: html,
     output: output,
     tools: tools,
+    dev: {
+      https: normalizedConfig.dev.https,
+      assetPrefix: normalizedConfig.dev.assetPrefix
+    },
     performance: {
       // `@modern-js/webpack` used to remove moment locale by default
       removeMomentLocale: true
     }
   };
 }
-
 export function createBuilderOptions(target, appContext) {
   // create entries
+
   var entries = {};
   var _appContext$entrypoin = appContext.entrypoints,
-      entrypoints = _appContext$entrypoin === void 0 ? [] : _appContext$entrypoin,
-      checkedEntries = appContext.checkedEntries;
-
+    entrypoints = _appContext$entrypoin === void 0 ? [] : _appContext$entrypoin,
+    checkedEntries = appContext.checkedEntries;
   var _iterator = _createForOfIteratorHelper(entrypoints),
-      _step;
-
+    _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var _step$value = _step.value,
-          entryName = _step$value.entryName,
-          entry = _step$value.entry;
-
+        entryName = _step$value.entryName,
+        entry = _step$value.entry;
       if (checkedEntries && !checkedEntries.includes(entryName)) {
         continue;
       }
-
       if (entryName in entries) {
         entries[entryName].push(entry);
       } else {
@@ -102,7 +101,6 @@ export function createBuilderOptions(target, appContext) {
   } finally {
     _iterator.f();
   }
-
   return {
     cwd: appContext.appDirectory,
     target: target,
@@ -111,18 +109,16 @@ export function createBuilderOptions(target, appContext) {
     framework: appContext.metaName
   };
 }
+
 /**
  * register builder Plugin by condition
  */
-
 function applyBuilderPlugins(_x2, _x3, _x4, _x5) {
   return _applyBuilderPlugins.apply(this, arguments);
 }
-
 function _applyBuilderPlugins() {
   _applyBuilderPlugins = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(builder, normalizedConfig, appContext, compatPluginConfig) {
     var _yield$import, PluginNodePolyfill, esbuildOptions, _yield$import2, PluginEsbuild;
-
     return _regeneratorRuntime().wrap(function _callee2$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
@@ -131,25 +127,20 @@ function _applyBuilderPlugins() {
               _context2.next = 6;
               break;
             }
-
             _context2.next = 3;
             return import('@modern-js/builder-plugin-node-polyfill');
-
           case 3:
             _yield$import = _context2.sent;
             PluginNodePolyfill = _yield$import.PluginNodePolyfill;
             builder.addPlugins([PluginNodePolyfill()]);
-
           case 6:
             if (!normalizedConfig.tools.esbuild) {
               _context2.next = 13;
               break;
             }
-
             esbuildOptions = normalizedConfig.tools.esbuild;
             _context2.next = 10;
             return import('@modern-js/builder-plugin-esbuild');
-
           case 10:
             _yield$import2 = _context2.sent;
             PluginEsbuild = _yield$import2.PluginEsbuild;
@@ -157,10 +148,8 @@ function _applyBuilderPlugins() {
               loader: false,
               minimize: applyOptionsChain({}, esbuildOptions)
             })]);
-
           case 13:
             builder.addPlugins([PluginCompatModern(appContext, normalizedConfig, compatPluginConfig)]);
-
           case 14:
           case "end":
             return _context2.stop();

package/dist/js/treeshaking/builder/share.js

@@ -6,7 +6,6 @@ export function createCopyPattern(appContext, config, patternsType, chain) {
   var uploadDir = path.posix.join(configDir.replace(/\\/g, '/'), 'upload');
   var publicDir = path.posix.join(configDir.replace(/\\/g, '/'), 'public');
   var minifiedJsRexExp = /\.min\.js/;
-
   var info = function info(file) {
     return {
       // If the file name ends with `.min.js`, we assume it's a compressed file.
@@ -15,12 +14,10 @@ export function createCopyPattern(appContext, config, patternsType, chain) {
       minimized: minifiedJsRexExp.test(file.sourceFilename)
     };
   };
-
   if (patternsType === 'public') {
     if (!chain) {
       throw new Error("expect get a webpackChain, but receive 'undefined'");
     }
-
     return {
       info: info,
       from: '**/*',
@@ -32,7 +29,6 @@ export function createCopyPattern(appContext, config, patternsType, chain) {
         if (!/\.html?$/.test(absoluteFrom)) {
           return content;
         }
-
         return lodashTemplate(content.toString('utf8'))({
           assetPrefix: removeTailSlash(chain.output.get('publicPath'))
         });

package/dist/js/treeshaking/builder/webpackPlugins/htmlAsyncChunkPlugin.js

@@ -6,36 +6,26 @@ import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 export var HtmlAsyncChunkPlugin = /*#__PURE__*/function () {
   function HtmlAsyncChunkPlugin(htmlWebpackPlugin) {
     _classCallCheck(this, HtmlAsyncChunkPlugin);
-
     _defineProperty(this, "name", void 0);
-
     _defineProperty(this, "htmlWebpackPlugin", void 0);
-
     this.name = 'HtmlAsyncChunkPlugin';
     this.htmlWebpackPlugin = htmlWebpackPlugin;
   }
-
   _createClass(HtmlAsyncChunkPlugin, [{
     key: "apply",
     value: function apply(compiler) {
       var _this = this;
-
       compiler.hooks.compilation.tap(this.name, function (compilation) {
         var hooks = _this.htmlWebpackPlugin.getHooks(compilation);
-
         hooks.alterAssetTagGroups.tap(_this.name, function (assets) {
           var tags = [].concat(_toConsumableArray(assets.headTags), _toConsumableArray(assets.bodyTags));
-
           var _iterator = _createForOfIteratorHelper(tags),
-              _step;
-
+            _step;
           try {
             for (_iterator.s(); !(_step = _iterator.n()).done;) {
               var tag = _step.value;
-
               if (tag.tagName === 'script') {
                 var attributes = tag.attributes;
-
                 if (attributes && attributes.defer === true) {
                   attributes.async = true;
                   delete attributes.defer;
@@ -47,12 +37,10 @@ export var HtmlAsyncChunkPlugin = /*#__PURE__*/function () {
           } finally {
             _iterator.f();
           }
-
           return assets;
         });
       });
     }
   }]);
-
   return HtmlAsyncChunkPlugin;
 }();

package/dist/js/treeshaking/builder/webpackPlugins/htmlBottomTemplate.js

@@ -4,50 +4,38 @@ import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 export var BottomTemplatePlugin = /*#__PURE__*/function () {
   function BottomTemplatePlugin(htmlWebpackPlugin) {
     _classCallCheck(this, BottomTemplatePlugin);
-
     _defineProperty(this, "htmlWebpackPlugin", void 0);
-
     _defineProperty(this, "bottomTemplateReg", /<!--<\?-\s*bottomTemplate\s*\?>-->/);
-
     _defineProperty(this, "bodyRegExp", /(<\/\s*body\s*>)/i);
-
     _defineProperty(this, "name", void 0);
-
     this.htmlWebpackPlugin = htmlWebpackPlugin;
     this.name = 'bottom-template';
   }
-
   _createClass(BottomTemplatePlugin, [{
     key: "apply",
     value: function apply(compiler) {
       var _this = this;
-
       compiler.hooks.compilation.tap(this.name, function (compilation) {
         _this.htmlWebpackPlugin.getHooks(compilation).beforeEmit.tap(_this.name, function (data) {
           var _data$plugin$options;
-
           if (!((_data$plugin$options = data.plugin.options) !== null && _data$plugin$options !== void 0 && _data$plugin$options.__internal__)) {
             return data;
-          } // 含有 <!--<?- bottomTemplate ?>--> 占位符时才需要注入 bottom.html
-
-
+          }
+          // 含有 <!--<?- bottomTemplate ?>--> 占位符时才需要注入 bottom.html
           if (_this.bottomTemplateReg.test(data.html)) {
             // 清空占位符
             data.html = data.html.replace(_this.bottomTemplateReg, '');
             var bottomTemplate = data.plugin.options.bottomTemplate;
-
             if (bottomTemplate) {
               data.html = data.html.replace(_this.bodyRegExp, function (match) {
                 return "\n".concat(bottomTemplate, "\n").concat(match);
               });
             }
           }
-
           return data;
         });
       });
     }
   }]);
-
   return BottomTemplatePlugin;
 }();

package/dist/js/treeshaking/builder/webpackPlugins/routerPlugin.js

@@ -0,0 +1,121 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import path from 'path';
+import { fs, ROUTE_MANIFEST, logger, ROUTE_MINIFEST_FILE } from '@modern-js/utils';
+var PLUGIN_NAME = 'ModernjsRoutePlugin';
+var RouterPlugin = /*#__PURE__*/function () {
+  function RouterPlugin(options) {
+    _classCallCheck(this, RouterPlugin);
+    _defineProperty(this, "existNestedRoutes", void 0);
+    this.existNestedRoutes = options.existNestedRoutes;
+  }
+  _createClass(RouterPlugin, [{
+    key: "apply",
+    value: function apply(compiler) {
+      var existNestedRoutes = this.existNestedRoutes;
+      var target = compiler.options.target;
+      if (target === 'node' || Array.isArray(target) && target.includes('node')) {
+        return;
+      }
+      if (!existNestedRoutes) {
+        return;
+      }
+      var webpack = compiler.webpack;
+      var Compilation = webpack.Compilation,
+        sources = webpack.sources;
+      var RawSource = sources.RawSource;
+      var PROCESS_ASSETS_STAGE_REPORT = Compilation.PROCESS_ASSETS_STAGE_REPORT;
+      var outputPath = compiler.options.output.path;
+      var newAssetsMap = new Map();
+      var normalizePath = function normalizePath(path) {
+        if (!path.endsWith('/')) {
+          return "".concat(path, "/");
+        }
+        return path;
+      };
+      compiler.hooks.thisCompilation.tap(PLUGIN_NAME, function (compilation) {
+        compilation.hooks.processAssets.tapPromise({
+          name: PLUGIN_NAME,
+          stage: PROCESS_ASSETS_STAGE_REPORT
+        }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+          var stats, publicPath, routeAssets, namedChunkGroups, assetsByChunkName, _i, _Object$entries, _Object$entries$_i, name, chunkGroup, manifest, injectedContent, entrypointsArray, entryChunkIds, entryChunks, entryChunkFiles, _iterator, _step, file, asset, newContent, filename;
+          return _regeneratorRuntime().wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  stats = compilation.getStats().toJson({
+                    chunkGroups: true,
+                    chunks: true
+                  });
+                  publicPath = stats.publicPath;
+                  routeAssets = {};
+                  namedChunkGroups = stats.namedChunkGroups, assetsByChunkName = stats.assetsByChunkName;
+                  if (!(!namedChunkGroups || !assetsByChunkName)) {
+                    _context.next = 7;
+                    break;
+                  }
+                  logger.warn('Route manifest does not exist, performance will be affected');
+                  return _context.abrupt("return");
+                case 7:
+                  for (_i = 0, _Object$entries = Object.entries(namedChunkGroups); _i < _Object$entries.length; _i++) {
+                    _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), name = _Object$entries$_i[0], chunkGroup = _Object$entries$_i[1];
+                    routeAssets[name] = {
+                      chunkIds: chunkGroup.chunks,
+                      assets: assetsByChunkName[name].map(function (item) {
+                        return publicPath ? normalizePath(publicPath) + item : item;
+                      })
+                    };
+                  }
+                  manifest = {
+                    routeAssets: routeAssets
+                  };
+                  injectedContent = "\n            ;(function(){\n              window.".concat(ROUTE_MANIFEST, " = ").concat(JSON.stringify(manifest), ";\n            })();\n          ");
+                  entrypointsArray = Array.from(compilation.entrypoints.entries());
+                  entryChunkIds = entrypointsArray.map(function (entrypoint) {
+                    return entrypoint[0];
+                  });
+                  entryChunks = _toConsumableArray(compilation.chunks).filter(function (chunk) {
+                    return entryChunkIds.includes(chunk.name);
+                  });
+                  entryChunkFiles = entryChunks.map(function (chunk) {
+                    return _toConsumableArray(chunk.files)[0];
+                  });
+                  _iterator = _createForOfIteratorHelper(entryChunkFiles);
+                  try {
+                    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                      file = _step.value;
+                      asset = compilation.assets[file];
+                      newContent = "".concat(injectedContent).concat(asset.source().toString());
+                      newAssetsMap.set(path.join(outputPath, file), newContent);
+                      compilation.updateAsset(file, new RawSource(newContent));
+                    }
+                  } catch (err) {
+                    _iterator.e(err);
+                  } finally {
+                    _iterator.f();
+                  }
+                  filename = path.join(outputPath, ROUTE_MINIFEST_FILE);
+                  _context.next = 19;
+                  return fs.ensureFile(filename);
+                case 19:
+                  _context.next = 21;
+                  return fs.writeFile(filename, JSON.stringify(manifest, null, 2));
+                case 21:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee);
+        })));
+      });
+    }
+  }]);
+  return RouterPlugin;
+}();
+export { RouterPlugin as default };