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

package/dist/js/treeshaking/analyze/getHtmlTemplate.js

@@ -0,0 +1,129 @@
+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 path from 'path';
+import { fs, findExists, MAIN_ENTRY_NAME } from '@modern-js/utils';
+import { HTML_PARTIALS_EXTENSIONS, HTML_PARTIALS_FOLDER } from "./constants";
+import * as templates from "./templates";
+var PartialPosition;
+(function (PartialPosition) {
+  PartialPosition["TOP"] = "top";
+  PartialPosition["HEAD"] = "head";
+  PartialPosition["BODY"] = "body";
+  PartialPosition["BOTTOM"] = "bottom";
+  PartialPosition["INDEX"] = "index";
+})(PartialPosition || (PartialPosition = {}));
+var findPartials = function findPartials(dir, entryName, position) {
+  if (fs.existsSync(dir)) {
+    var base = findExists(HTML_PARTIALS_EXTENSIONS.map(function (ext) {
+      return path.resolve(dir, "".concat(position).concat(ext));
+    }));
+    var file = entryName ? findExists(HTML_PARTIALS_EXTENSIONS.map(function (ext) {
+      return path.resolve(dir, entryName, "".concat(position).concat(ext));
+    })) || base : base;
+    return file ? {
+      file: file,
+      content: fs.readFileSync(file, 'utf8')
+    } : null;
+  }
+  return null;
+};
+
+// generate html template for
+export var getHtmlTemplate = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(entrypoints, api, _ref) {
+    var appContext, config, appDirectory, internalDirectory, configDir, htmlDir, htmlTemplates, _iterator, _step, _loop;
+    return _regeneratorRuntime().wrap(function _callee$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            appContext = _ref.appContext, config = _ref.config;
+            appDirectory = appContext.appDirectory, internalDirectory = appContext.internalDirectory;
+            configDir = config.source.configDir;
+            htmlDir = path.resolve(appDirectory, configDir, HTML_PARTIALS_FOLDER);
+            htmlTemplates = {};
+            _iterator = _createForOfIteratorHelper(entrypoints);
+            _context2.prev = 6;
+            _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
+              var entrypoint, entryName, name, customIndexTemplate, hookRunners, _yield$hookRunners$ht, partials, templatePath, bottomTemplate;
+              return _regeneratorRuntime().wrap(function _loop$(_context) {
+                while (1) {
+                  switch (_context.prev = _context.next) {
+                    case 0:
+                      entrypoint = _step.value;
+                      entryName = entrypoint.entryName;
+                      name = entrypoints.length === 1 && entryName === MAIN_ENTRY_NAME ? '' : entryName;
+                      customIndexTemplate = findPartials(htmlDir, name, PartialPosition.INDEX);
+                      if (!customIndexTemplate) {
+                        _context.next = 8;
+                        break;
+                      }
+                      htmlTemplates[entryName] = customIndexTemplate.file;
+                      _context.next = 18;
+                      break;
+                    case 8:
+                      hookRunners = api.useHookRunners();
+                      _context.next = 11;
+                      return hookRunners.htmlPartials({
+                        entrypoint: entrypoint,
+                        partials: [PartialPosition.TOP, PartialPosition.HEAD, PartialPosition.BODY].reduce(function (previous, position) {
+                          var found = findPartials(htmlDir, name, position);
+                          previous[position] = found ? [found.content] : [];
+                          return previous;
+                        }, {
+                          top: [],
+                          head: [],
+                          body: []
+                        })
+                      });
+                    case 11:
+                      _yield$hookRunners$ht = _context.sent;
+                      partials = _yield$hookRunners$ht.partials;
+                      templatePath = path.resolve(internalDirectory, entryName, 'index.html');
+                      fs.outputFileSync(templatePath, templates.html(partials), 'utf8');
+                      htmlTemplates[entryName] = templatePath;
+                      bottomTemplate = findPartials(htmlDir, name, PartialPosition.BOTTOM);
+                      if (bottomTemplate) {
+                        htmlTemplates["__".concat(entryName, "-bottom__")] = bottomTemplate.content;
+                      }
+                    case 18:
+                    case "end":
+                      return _context.stop();
+                  }
+                }
+              }, _loop);
+            });
+            _iterator.s();
+          case 9:
+            if ((_step = _iterator.n()).done) {
+              _context2.next = 13;
+              break;
+            }
+            return _context2.delegateYield(_loop(), "t0", 11);
+          case 11:
+            _context2.next = 9;
+            break;
+          case 13:
+            _context2.next = 18;
+            break;
+          case 15:
+            _context2.prev = 15;
+            _context2.t1 = _context2["catch"](6);
+            _iterator.e(_context2.t1);
+          case 18:
+            _context2.prev = 18;
+            _iterator.f();
+            return _context2.finish(18);
+          case 21:
+            return _context2.abrupt("return", htmlTemplates);
+          case 22:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee, null, [[6, 15, 18, 21]]);
+  }));
+  return function getHtmlTemplate(_x, _x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/analyze/getServerRoutes.js

@@ -0,0 +1,157 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+var _excluded = ["path"],
+  _excluded2 = ["path"];
+import path from 'path';
+import fs from 'fs';
+import { urlJoin, isPlainObject, removeLeadingSlash, getEntryOptions, SERVER_BUNDLE_DIRECTORY, MAIN_ENTRY_NAME, removeTailSlash } from '@modern-js/utils';
+import { walkDirectory } from "./utils";
+
+/**
+ * Add base url for each server route.
+ * @param baseUrl - Base url from server.baseUrl
+ * @param routes - Server routes.
+ * @returns Server routes with baseUrl prefixed.
+ */
+var applyBaseUrl = function applyBaseUrl(baseUrl, routes) {
+  if (baseUrl) {
+    if (Array.isArray(baseUrl)) {
+      return baseUrl.reduce(function (previous, current) {
+        return [].concat(_toConsumableArray(previous), _toConsumableArray(applyBaseUrl(current, routes)));
+      }, []);
+    } else {
+      return routes.map(function (route) {
+        var urlPath = urlJoin(baseUrl, route.urlPath);
+        return _objectSpread(_objectSpread({}, route), {}, {
+          urlPath: urlPath === '/' ? urlPath : removeTailSlash(urlPath)
+        });
+      });
+    }
+  }
+  return routes;
+};
+
+/**
+ *
+ * @param original - Original entrypoint route info.
+ * @param routeOptions - Custom entrypoint route config from server.routes.
+ * @returns
+ */
+var applyRouteOptions = function applyRouteOptions(original, routeOptions) {
+  var route = routeOptions.route,
+    disableSpa = routeOptions.disableSpa;
+  original.isSPA = !disableSpa;
+
+  // set entryPath as dir
+  !original.isSPA && (original.entryPath = path.dirname(original.entryPath));
+  var routes;
+  if (route) {
+    if (Array.isArray(route)) {
+      routes = route.map(function (url) {
+        if (isPlainObject(url)) {
+          var _ref = url,
+            urlPath = _ref.path,
+            other = _objectWithoutProperties(_ref, _excluded);
+          return _objectSpread(_objectSpread(_objectSpread({}, original), other), {}, {
+            urlPath: urlPath
+          });
+        } else {
+          return _objectSpread(_objectSpread({}, original), {}, {
+            urlPath: url
+          });
+        }
+      });
+    } else if (isPlainObject(route)) {
+      var _ref2 = route,
+        urlPath = _ref2.path,
+        other = _objectWithoutProperties(_ref2, _excluded2);
+      routes = [_objectSpread(_objectSpread(_objectSpread({}, original), other), {}, {
+        urlPath: urlPath
+      })];
+    } else {
+      routes = [_objectSpread(_objectSpread({}, original), {}, {
+        urlPath: route
+      })];
+    }
+  } else {
+    routes = [original];
+  }
+  return routes;
+};
+
+/**
+ * Collect routes from entrypoints.
+ * @param entrypoints - Bundle entrypoints.
+ * @param config - Normalized user config.
+ * @returns entrypoint Routes
+ */
+var collectHtmlRoutes = function collectHtmlRoutes(entrypoints, appContext, config) {
+  var _config$output = config.output,
+    htmlPath = _config$output.htmlPath,
+    disableHtmlFolder = _config$output.disableHtmlFolder,
+    enableModernMode = _config$output.enableModernMode,
+    _config$server = config.server,
+    baseUrl = _config$server.baseUrl,
+    routes = _config$server.routes,
+    ssr = _config$server.ssr,
+    ssrByEntries = _config$server.ssrByEntries;
+  var packageName = appContext.packageName;
+  var htmlRoutes = entrypoints.reduce(function (previous, _ref3) {
+    var entryName = _ref3.entryName;
+    var entryOptions = getEntryOptions(entryName, ssr, ssrByEntries, packageName);
+    var isSSR = Boolean(entryOptions);
+    var _ref4 = (routes === null || routes === void 0 ? void 0 : routes[entryName]) || {},
+      resHeaders = _ref4.resHeaders;
+    var route = {
+      urlPath: "/".concat(entryName === MAIN_ENTRY_NAME ? '' : entryName),
+      entryName: entryName,
+      entryPath: removeLeadingSlash(path.posix.normalize("".concat(htmlPath, "/").concat(entryName).concat(disableHtmlFolder ? '.html' : '/index.html'))),
+      isSPA: true,
+      isSSR: isSSR,
+      responseHeaders: resHeaders,
+      enableModernMode: Boolean(enableModernMode),
+      bundle: isSSR ? "".concat(SERVER_BUNDLE_DIRECTORY, "/").concat(entryName, ".js") : undefined
+    };
+    if (routes !== null && routes !== void 0 && routes.hasOwnProperty(entryName)) {
+      var routeOptions = isPlainObject(routes[entryName]) ? routes[entryName] : {
+        route: routes[entryName]
+      };
+      route = applyRouteOptions(route, routeOptions);
+    }
+    return Array.isArray(route) ? [].concat(_toConsumableArray(previous), _toConsumableArray(route)) : [].concat(_toConsumableArray(previous), [route]);
+  }, []);
+  htmlRoutes = applyBaseUrl(baseUrl, htmlRoutes);
+  return htmlRoutes;
+};
+
+/**
+ * Collect static public file routes from config/public folder.
+ * @param appContext - App context info.
+ * @param config - normalized user config.
+ * @returns Static public file routes.
+ */
+var collectStaticRoutes = function collectStaticRoutes(appContext, config) {
+  var appDirectory = appContext.appDirectory;
+  var configDir = config.source.configDir,
+    _config$server$public = config.server.publicRoutes,
+    publicRoutes = _config$server$public === void 0 ? {} : _config$server$public;
+  var publicFolder = path.resolve(appDirectory, configDir, 'public');
+  return fs.existsSync(publicFolder) ? walkDirectory(publicFolder).map(function (filePath) {
+    var urlPath = "".concat(urlJoin(toPosix(filePath).slice(toPosix(publicFolder).length)));
+    return {
+      urlPath: publicRoutes[removeLeadingSlash(urlPath)] || urlPath,
+      isSPA: true,
+      isSSR: false,
+      entryPath: toPosix(path.relative(path.resolve(appDirectory, configDir), filePath))
+    };
+  }) : [];
+};
+export var getServerRoutes = function getServerRoutes(entrypoints, _ref5) {
+  var appContext = _ref5.appContext,
+    config = _ref5.config;
+  return [].concat(_toConsumableArray(collectHtmlRoutes(entrypoints, appContext, config)), _toConsumableArray(collectStaticRoutes(appContext, config)));
+};
+var toPosix = function toPosix(pathStr) {
+  return pathStr.split(path.sep).join(path.posix.sep);
+};

package/dist/js/treeshaking/analyze/index.js

@@ -0,0 +1,334 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import * as path from 'path';
+import { createAsyncWaterfall } from '@modern-js/plugin';
+import { createDebugger, fs, isApiOnly } from '@modern-js/utils';
+import { cloneDeep } from '@modern-js/utils/lodash';
+import { createBuilderForEdenX } from "../builder";
+import { printInstructions } from "../utils/printInstructions";
+import { generateRoutes } from "../utils/routes";
+import { emitResolvedConfig } from "../utils/config";
+import { getCommand } from "../utils/commands";
+import { isRouteComponentFile } from "./utils";
+var debug = createDebugger('plugin-analyze');
+export var modifyEntryImports = createAsyncWaterfall();
+export var modifyEntryExport = createAsyncWaterfall();
+export var addRuntimeExports = createAsyncWaterfall();
+export var modifyEntryRuntimePlugins = createAsyncWaterfall();
+export var modifyEntryRenderFunction = createAsyncWaterfall();
+export var modifyAsyncEntry = createAsyncWaterfall();
+export var modifyFileSystemRoutes = createAsyncWaterfall();
+export var modifyServerRoutes = createAsyncWaterfall();
+export var htmlPartials = createAsyncWaterfall();
+export var beforeGenerateRoutes = createAsyncWaterfall();
+export var addDefineTypes = createAsyncWaterfall();
+export default (function () {
+  return {
+    name: '@modern-js/plugin-analyze',
+    registerHook: {
+      modifyAsyncEntry: modifyAsyncEntry,
+      modifyEntryImports: modifyEntryImports,
+      modifyEntryExport: modifyEntryExport,
+      modifyEntryRuntimePlugins: modifyEntryRuntimePlugins,
+      modifyEntryRenderFunction: modifyEntryRenderFunction,
+      modifyFileSystemRoutes: modifyFileSystemRoutes,
+      modifyServerRoutes: modifyServerRoutes,
+      htmlPartials: htmlPartials,
+      addRuntimeExports: addRuntimeExports,
+      beforeGenerateRoutes: beforeGenerateRoutes,
+      addDefineTypes: addDefineTypes
+    },
+    setup: function setup(api) {
+      var pagesDir = [];
+      var originEntrypoints = [];
+      return {
+        prepare: function prepare() {
+          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+            var _resolvedConfig$sourc;
+            var appContext, resolvedConfig, hookRunners, apiOnly, _yield$hookRunners$mo, _routes, _yield$Promise$all, _yield$Promise$all2, getBundleEntry, getServerRoutes, generateCode, getHtmlTemplate, entrypoints, defaultChecked, initialRoutes, _yield$hookRunners$mo2, routes, nestedRouteEntries, htmlTemplates, command, buildCommands, normalizedConfig, builder;
+            return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+              while (1) {
+                switch (_context6.prev = _context6.next) {
+                  case 0:
+                    appContext = api.useAppContext();
+                    resolvedConfig = api.useResolvedConfigContext();
+                    hookRunners = api.useHookRunners();
+                    try {
+                      fs.emptydirSync(appContext.internalDirectory);
+                    } catch (_unused) {
+                      // FIXME:
+                    }
+                    _context6.next = 6;
+                    return isApiOnly(appContext.appDirectory, resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig$sourc = resolvedConfig.source) === null || _resolvedConfig$sourc === void 0 ? void 0 : _resolvedConfig$sourc.entriesDir);
+                  case 6:
+                    apiOnly = _context6.sent;
+                    _context6.next = 9;
+                    return hookRunners.addRuntimeExports();
+                  case 9:
+                    if (!apiOnly) {
+                      _context6.next = 18;
+                      break;
+                    }
+                    _context6.next = 12;
+                    return hookRunners.modifyServerRoutes({
+                      routes: []
+                    });
+                  case 12:
+                    _yield$hookRunners$mo = _context6.sent;
+                    _routes = _yield$hookRunners$mo.routes;
+                    debug("server routes: %o", _routes);
+                    appContext = _objectSpread(_objectSpread({}, appContext), {}, {
+                      apiOnly: apiOnly,
+                      serverRoutes: _routes
+                    });
+                    api.setAppContext(appContext);
+                    return _context6.abrupt("return");
+                  case 18:
+                    _context6.next = 20;
+                    return Promise.all([import("./getBundleEntry"), import("./getServerRoutes"), import("./generateCode"), import("./getHtmlTemplate")]);
+                  case 20:
+                    _yield$Promise$all = _context6.sent;
+                    _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 4);
+                    getBundleEntry = _yield$Promise$all2[0].getBundleEntry;
+                    getServerRoutes = _yield$Promise$all2[1].getServerRoutes;
+                    generateCode = _yield$Promise$all2[2].generateCode;
+                    getHtmlTemplate = _yield$Promise$all2[3].getHtmlTemplate;
+                    entrypoints = getBundleEntry(appContext, resolvedConfig);
+                    defaultChecked = entrypoints.map(function (point) {
+                      return point.entryName;
+                    });
+                    debug("entrypoints: %o", entrypoints);
+                    initialRoutes = getServerRoutes(entrypoints, {
+                      appContext: appContext,
+                      config: resolvedConfig
+                    });
+                    _context6.next = 32;
+                    return hookRunners.modifyServerRoutes({
+                      routes: initialRoutes
+                    });
+                  case 32:
+                    _yield$hookRunners$mo2 = _context6.sent;
+                    routes = _yield$hookRunners$mo2.routes;
+                    debug("server routes: %o", routes);
+                    appContext = _objectSpread(_objectSpread({}, appContext), {}, {
+                      entrypoints: entrypoints,
+                      serverRoutes: routes
+                    });
+                    api.setAppContext(appContext);
+                    nestedRouteEntries = entrypoints.map(function (point) {
+                      return point.nestedRoutesEntry;
+                    }).filter(Boolean);
+                    pagesDir = entrypoints.map(function (point) {
+                      return point.entry;
+                    }).filter(Boolean).concat(nestedRouteEntries);
+                    originEntrypoints = cloneDeep(entrypoints);
+                    _context6.next = 42;
+                    return generateCode(appContext, resolvedConfig, entrypoints, api);
+                  case 42:
+                    _context6.next = 44;
+                    return getHtmlTemplate(entrypoints, api, {
+                      appContext: appContext,
+                      config: resolvedConfig
+                    });
+                  case 44:
+                    htmlTemplates = _context6.sent;
+                    debug("html templates: %o", htmlTemplates);
+                    _context6.next = 48;
+                    return hookRunners.addDefineTypes();
+                  case 48:
+                    debug("add Define Types");
+                    appContext = _objectSpread(_objectSpread({}, appContext), {}, {
+                      entrypoints: entrypoints,
+                      checkedEntries: defaultChecked,
+                      apiOnly: apiOnly,
+                      serverRoutes: routes,
+                      htmlTemplates: htmlTemplates
+                    });
+                    api.setAppContext(appContext);
+                    command = getCommand();
+                    buildCommands = ['dev', 'build', 'inspect', 'deploy'];
+                    if (!buildCommands.includes(command)) {
+                      _context6.next = 60;
+                      break;
+                    }
+                    normalizedConfig = api.useResolvedConfigContext();
+                    _context6.next = 57;
+                    return createBuilderForEdenX({
+                      normalizedConfig: normalizedConfig,
+                      appContext: appContext,
+                      compatPluginConfig: {
+                        onBeforeBuild: function onBeforeBuild(_ref) {
+                          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+                            var bundlerConfigs, hookRunners;
+                            return _regeneratorRuntime().wrap(function _callee$(_context) {
+                              while (1) {
+                                switch (_context.prev = _context.next) {
+                                  case 0:
+                                    bundlerConfigs = _ref.bundlerConfigs;
+                                    hookRunners = api.useHookRunners();
+                                    _context.next = 4;
+                                    return generateRoutes(appContext);
+                                  case 4:
+                                    _context.next = 6;
+                                    return hookRunners.beforeBuild({
+                                      bundlerConfigs: bundlerConfigs
+                                    });
+                                  case 6:
+                                  case "end":
+                                    return _context.stop();
+                                }
+                              }
+                            }, _callee);
+                          }))();
+                        },
+                        onAfterBuild: function onAfterBuild(_ref2) {
+                          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+                            var stats, hookRunners;
+                            return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                              while (1) {
+                                switch (_context2.prev = _context2.next) {
+                                  case 0:
+                                    stats = _ref2.stats;
+                                    hookRunners = api.useHookRunners();
+                                    _context2.next = 4;
+                                    return hookRunners.afterBuild({
+                                      stats: stats
+                                    });
+                                  case 4:
+                                    _context2.next = 6;
+                                    return emitResolvedConfig(appContext.appDirectory, normalizedConfig);
+                                  case 6:
+                                  case "end":
+                                    return _context2.stop();
+                                }
+                              }
+                            }, _callee2);
+                          }))();
+                        },
+                        onDevCompileDone: function onDevCompileDone(_ref3) {
+                          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+                            var isFirstCompile, hookRunners;
+                            return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                              while (1) {
+                                switch (_context3.prev = _context3.next) {
+                                  case 0:
+                                    isFirstCompile = _ref3.isFirstCompile;
+                                    hookRunners = api.useHookRunners();
+                                    if (process.stdout.isTTY || isFirstCompile) {
+                                      hookRunners.afterDev();
+                                      if (isFirstCompile) {
+                                        printInstructions(hookRunners, appContext, normalizedConfig);
+                                      }
+                                    }
+                                  case 3:
+                                  case "end":
+                                    return _context3.stop();
+                                }
+                              }
+                            }, _callee3);
+                          }))();
+                        },
+                        onBeforeCreateCompiler: function onBeforeCreateCompiler(_ref4) {
+                          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+                            var bundlerConfigs, hookRunners;
+                            return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+                              while (1) {
+                                switch (_context4.prev = _context4.next) {
+                                  case 0:
+                                    bundlerConfigs = _ref4.bundlerConfigs;
+                                    hookRunners = api.useHookRunners(); // run modernjs framework `beforeCreateCompiler` hook
+                                    _context4.next = 4;
+                                    return hookRunners.beforeCreateCompiler({
+                                      bundlerConfigs: bundlerConfigs
+                                    });
+                                  case 4:
+                                  case "end":
+                                    return _context4.stop();
+                                }
+                              }
+                            }, _callee4);
+                          }))();
+                        },
+                        onAfterCreateCompiler: function onAfterCreateCompiler(_ref5) {
+                          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+                            var compiler, hookRunners;
+                            return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+                              while (1) {
+                                switch (_context5.prev = _context5.next) {
+                                  case 0:
+                                    compiler = _ref5.compiler;
+                                    hookRunners = api.useHookRunners(); // run modernjs framework afterCreateCompiler hooks
+                                    _context5.next = 4;
+                                    return hookRunners.afterCreateCompiler({
+                                      compiler: compiler
+                                    });
+                                  case 4:
+                                  case "end":
+                                    return _context5.stop();
+                                }
+                              }
+                            }, _callee5);
+                          }))();
+                        }
+                      }
+                    });
+                  case 57:
+                    builder = _context6.sent;
+                    appContext = _objectSpread(_objectSpread({}, appContext), {}, {
+                      builder: builder
+                    });
+                    api.setAppContext(appContext);
+                  case 60:
+                  case "end":
+                    return _context6.stop();
+                }
+              }
+            }, _callee6);
+          }))();
+        },
+        watchFiles: function watchFiles() {
+          return pagesDir;
+        },
+        fileChange: function fileChange(e) {
+          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
+            var appContext, appDirectory, filename, eventType, isPageFile, absoluteFilePath, isRouteComponent, resolvedConfig, _yield$import, generateCode, entrypoints;
+            return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+              while (1) {
+                switch (_context7.prev = _context7.next) {
+                  case 0:
+                    appContext = api.useAppContext();
+                    appDirectory = appContext.appDirectory;
+                    filename = e.filename, eventType = e.eventType;
+                    isPageFile = function isPageFile(name) {
+                      return pagesDir.some(function (pageDir) {
+                        return name.includes(pageDir);
+                      });
+                    };
+                    absoluteFilePath = path.resolve(appDirectory, filename);
+                    isRouteComponent = isPageFile(absoluteFilePath) && isRouteComponentFile(absoluteFilePath);
+                    if (!(isRouteComponent && (eventType === 'add' || eventType === 'unlink'))) {
+                      _context7.next = 14;
+                      break;
+                    }
+                    resolvedConfig = api.useResolvedConfigContext();
+                    _context7.next = 10;
+                    return import("./generateCode");
+                  case 10:
+                    _yield$import = _context7.sent;
+                    generateCode = _yield$import.generateCode;
+                    entrypoints = cloneDeep(originEntrypoints);
+                    generateCode(appContext, resolvedConfig, entrypoints, api);
+                  case 14:
+                  case "end":
+                    return _context7.stop();
+                }
+              }
+            }, _callee7);
+          }))();
+        }
+      };
+    }
+  };
+});

package/dist/js/treeshaking/analyze/isDefaultExportFunction.js

@@ -0,0 +1,28 @@
+import fs from 'fs';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+var isFunction = function isFunction(node) {
+  return t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node);
+};
+export var isDefaultExportFunction = function isDefaultExportFunction(file) {
+  if (!file || !fs.existsSync(file)) {
+    return false;
+  }
+  var ast = parse(fs.readFileSync(file, 'utf8'), {
+    sourceType: 'unambiguous',
+    plugins: ['jsx', 'typescript', 'classProperties', 'dynamicImport', 'exportDefaultFrom', 'exportNamespaceFrom', 'decorators-legacy', 'functionBind', 'classPrivateMethods', ['pipelineOperator', {
+      proposal: 'minimal'
+    }], 'optionalChaining', 'optionalCatchBinding', 'objectRestSpread', 'numericSeparator']
+  });
+  var isExportFunction = false;
+  traverse(ast, {
+    ExportDefaultDeclaration: function ExportDefaultDeclaration(path) {
+      var declaration = path.node.declaration;
+      if (isFunction(declaration)) {
+        isExportFunction = true;
+      }
+    }
+  });
+  return isExportFunction;
+};

package/dist/js/treeshaking/analyze/makeLegalIdentifier.js

@@ -0,0 +1,16 @@
+/**
+ * modified from https://github.com/rollup/plugins/blob/master/packages/pluginutils
+ * license at https://github.com/rollup/plugins/blob/master/LICENSE
+ */
+var reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+var builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+var forbidList = new Set("".concat(reservedWords, " ").concat(builtins).split(' '));
+export function makeLegalIdentifier(str) {
+  var identifier = str.replace(/-(\w)/g, function (_, letter) {
+    return letter.toUpperCase();
+  }).replace(/[^$_a-zA-Z0-9]/g, '_');
+  if (/\d/.test(identifier[0]) || forbidList.has(identifier)) {
+    return "_".concat(identifier);
+  }
+  return identifier || '_';
+}