@modern-js/app-tools 2.0.0-beta.3 → 2.0.0-beta.6

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

@@ -1,318 +1,588 @@
-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 { createDebugger, fs, isApiOnly } from '@modern-js/utils';
-import { cloneDeep } from '@modern-js/utils/lodash';
-import { createBuilderForEdenX } from "../builder";
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+import * as path from "path";
+import { createDebugger, fs, isApiOnly } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import { createBuilderForModern } from "../builder";
 import { printInstructions } from "../utils/printInstructions";
 import { generateRoutes } from "../utils/routes";
 import { emitResolvedConfig } from "../utils/config";
 import { getCommand } from "../utils/commands";
 import { initialNormalizedConfig } from "../config";
-import { isRouteComponentFile } from "./utils";
-var debug = createDebugger('plugin-analyze');
-export default (function () {
-  return {
-    name: '@modern-js/plugin-analyze',
-    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$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;
+import { isNestedRouteComponent, isPageComponentFile } from "./utils";
+import { loaderBuilder, serverLoaderBuilder } from "./Builder";
+var debug = createDebugger("plugin-analyze");
+var analyze_default = function() {
+    return {
+        name: "@modern-js/plugin-analyze",
+        setup: function(api) {
+            var pagesDir = [];
+            var nestedRouteEntries = [];
+            var originEntrypoints = [];
+            return {
+                prepare: function prepare() {
+                    return _asyncToGenerator(function() {
+                        var ref, appContext, resolvedConfig, hookRunners, apiOnly, ref1, routes2, ref2, getBundleEntry, getServerRoutes, generateCode, getHtmlTemplate, entrypoints, defaultChecked, initialRoutes, routes, htmlTemplates, command, buildCommands, normalizedConfig, builder;
+                        return __generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    appContext = api.useAppContext();
+                                    resolvedConfig = api.useResolvedConfigContext();
                                     hookRunners = api.useHookRunners();
-                                    _context.next = 4;
-                                    return generateRoutes(appContext);
-                                  case 4:
-                                    _context.next = 6;
-                                    return hookRunners.beforeBuild({
-                                      bundlerConfigs: bundlerConfigs
+                                    try {
+                                        fs.emptydirSync(appContext.internalDirectory);
+                                    } catch (e) {}
+                                    return [
+                                        4,
+                                        isApiOnly(appContext.appDirectory, (ref = resolvedConfig.source) === null || ref === void 0 ? void 0 : ref.entriesDir)
+                                    ];
+                                case 1:
+                                    apiOnly = _state.sent();
+                                    return [
+                                        4,
+                                        hookRunners.addRuntimeExports()
+                                    ];
+                                case 2:
+                                    _state.sent();
+                                    if (!apiOnly) return [
+                                        3,
+                                        4
+                                    ];
+                                    return [
+                                        4,
+                                        hookRunners.modifyServerRoutes({
+                                            routes: []
+                                        })
+                                    ];
+                                case 3:
+                                    ref1 = _state.sent(), routes2 = ref1.routes;
+                                    debug("server routes: %o", routes2);
+                                    appContext = _objectSpreadProps(_objectSpread({}, appContext), {
+                                        apiOnly: apiOnly,
+                                        serverRoutes: routes2
                                     });
-                                  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
+                                    api.setAppContext(appContext);
+                                    return [
+                                        2
+                                    ];
+                                case 4:
+                                    return [
+                                        4,
+                                        Promise.all([
+                                            import("./getBundleEntry"),
+                                            import("./getServerRoutes"),
+                                            import("./generateCode"),
+                                            import("./getHtmlTemplate")
+                                        ])
+                                    ];
+                                case 5:
+                                    ref2 = _slicedToArray.apply(void 0, [
+                                        _state.sent(),
+                                        4
+                                    ]), getBundleEntry = ref2[0].getBundleEntry, getServerRoutes = ref2[1].getServerRoutes, generateCode = ref2[2].generateCode, getHtmlTemplate = ref2[3].getHtmlTemplate;
+                                    entrypoints = getBundleEntry(appContext, resolvedConfig);
+                                    defaultChecked = entrypoints.map(function(point) {
+                                        return point.entryName;
                                     });
-                                  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
+                                    debug("entrypoints: %o", entrypoints);
+                                    initialRoutes = getServerRoutes(entrypoints, {
+                                        appContext: appContext,
+                                        config: resolvedConfig
                                     });
-                                  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
+                                    return [
+                                        4,
+                                        hookRunners.modifyServerRoutes({
+                                            routes: initialRoutes
+                                        })
+                                    ];
+                                case 6:
+                                    routes = _state.sent().routes;
+                                    debug("server routes: %o", routes);
+                                    appContext = _objectSpreadProps(_objectSpread({}, appContext), {
+                                        entrypoints: entrypoints,
+                                        serverRoutes: routes
                                     });
-                                  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;
-        },
-        resolvedConfig: function resolvedConfig(_ref6) {
-          var resolved = _ref6.resolved;
-          var appContext = api.useAppContext();
-          var config = initialNormalizedConfig(resolved, appContext);
-          return {
-            resolved: config
-          };
-        },
-        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);
-                      });
+                                    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);
+                                    return [
+                                        4,
+                                        generateCode(appContext, resolvedConfig, entrypoints, api)
+                                    ];
+                                case 7:
+                                    _state.sent();
+                                    return [
+                                        4,
+                                        getHtmlTemplate(entrypoints, api, {
+                                            appContext: appContext,
+                                            config: resolvedConfig
+                                        })
+                                    ];
+                                case 8:
+                                    htmlTemplates = _state.sent();
+                                    debug("html templates: %o", htmlTemplates);
+                                    return [
+                                        4,
+                                        hookRunners.addDefineTypes()
+                                    ];
+                                case 9:
+                                    _state.sent();
+                                    debug("add Define Types");
+                                    appContext = _objectSpreadProps(_objectSpread({}, appContext), {
+                                        entrypoints: entrypoints,
+                                        checkedEntries: defaultChecked,
+                                        apiOnly: apiOnly,
+                                        serverRoutes: routes,
+                                        htmlTemplates: htmlTemplates
+                                    });
+                                    api.setAppContext(appContext);
+                                    command = getCommand();
+                                    buildCommands = [
+                                        "dev",
+                                        "start",
+                                        "build",
+                                        "inspect",
+                                        "deploy"
+                                    ];
+                                    if (!buildCommands.includes(command)) return [
+                                        3,
+                                        11
+                                    ];
+                                    normalizedConfig = api.useResolvedConfigContext();
+                                    return [
+                                        4,
+                                        createBuilderForModern({
+                                            normalizedConfig: normalizedConfig,
+                                            appContext: appContext,
+                                            compatPluginConfig: {
+                                                onBeforeBuild: function onBeforeBuild(param) {
+                                                    var bundlerConfigs = param.bundlerConfigs;
+                                                    return _asyncToGenerator(function() {
+                                                        var hookRunners2;
+                                                        return __generator(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    hookRunners2 = api.useHookRunners();
+                                                                    return [
+                                                                        4,
+                                                                        generateRoutes(appContext)
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        4,
+                                                                        hookRunners2.beforeBuild({
+                                                                            bundlerConfigs: bundlerConfigs
+                                                                        })
+                                                                    ];
+                                                                case 2:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                },
+                                                onAfterBuild: function onAfterBuild(param) {
+                                                    var stats = param.stats;
+                                                    return _asyncToGenerator(function() {
+                                                        var hookRunners2;
+                                                        return __generator(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    hookRunners2 = api.useHookRunners();
+                                                                    return [
+                                                                        4,
+                                                                        hookRunners2.afterBuild({
+                                                                            stats: stats
+                                                                        })
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        4,
+                                                                        emitResolvedConfig(appContext.appDirectory, normalizedConfig)
+                                                                    ];
+                                                                case 2:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                },
+                                                onDevCompileDone: function onDevCompileDone(param) {
+                                                    var isFirstCompile = param.isFirstCompile;
+                                                    return _asyncToGenerator(function() {
+                                                        var hookRunners2;
+                                                        return __generator(this, function(_state) {
+                                                            hookRunners2 = api.useHookRunners();
+                                                            if (process.stdout.isTTY || isFirstCompile) {
+                                                                hookRunners2.afterDev();
+                                                                if (isFirstCompile) {
+                                                                    printInstructions(hookRunners2, appContext, normalizedConfig);
+                                                                }
+                                                            }
+                                                            return [
+                                                                2
+                                                            ];
+                                                        });
+                                                    })();
+                                                },
+                                                onBeforeCreateCompiler: function onBeforeCreateCompiler(param) {
+                                                    var bundlerConfigs = param.bundlerConfigs;
+                                                    return _asyncToGenerator(function() {
+                                                        var hookRunners2;
+                                                        return __generator(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    hookRunners2 = api.useHookRunners();
+                                                                    return [
+                                                                        4,
+                                                                        hookRunners2.beforeCreateCompiler({
+                                                                            bundlerConfigs: bundlerConfigs
+                                                                        })
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                },
+                                                onAfterCreateCompiler: function onAfterCreateCompiler(param) {
+                                                    var compiler = param.compiler;
+                                                    return _asyncToGenerator(function() {
+                                                        var hookRunners2;
+                                                        return __generator(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    hookRunners2 = api.useHookRunners();
+                                                                    return [
+                                                                        4,
+                                                                        hookRunners2.afterCreateCompiler({
+                                                                            compiler: compiler
+                                                                        })
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                }
+                                            }
+                                        })
+                                    ];
+                                case 10:
+                                    builder = _state.sent();
+                                    builder.addPlugins(resolvedConfig.builderPlugins);
+                                    appContext = _objectSpreadProps(_objectSpread({}, appContext), {
+                                        builder: builder
+                                    });
+                                    api.setAppContext(appContext);
+                                    _state.label = 11;
+                                case 11:
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    })();
+                },
+                watchFiles: function watchFiles() {
+                    return pagesDir;
+                },
+                resolvedConfig: function resolvedConfig(param) {
+                    var resolved = param.resolved;
+                    var appContext = api.useAppContext();
+                    var config = initialNormalizedConfig(resolved, appContext);
+                    return {
+                        resolved: config
                     };
-                    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();
+                },
+                beforeRestart: function beforeRestart() {
+                    return _asyncToGenerator(function() {
+                        return __generator(this, function(_state) {
+                            serverLoaderBuilder.stop();
+                            loaderBuilder.stop();
+                            return [
+                                2
+                            ];
+                        });
+                    })();
+                },
+                fileChange: function fileChange(e) {
+                    return _asyncToGenerator(function() {
+                        var appContext, appDirectory, filename, eventType, isPageFile, absoluteFilePath, isRouteComponent, resolvedConfig, generateCode, entrypoints;
+                        return __generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    appContext = api.useAppContext();
+                                    appDirectory = appContext.appDirectory;
+                                    filename = e.filename, eventType = e.eventType;
+                                    isPageFile = function(name) {
+                                        return pagesDir.some(function(pageDir) {
+                                            return name.includes(pageDir);
+                                        });
+                                    };
+                                    absoluteFilePath = path.resolve(appDirectory, filename);
+                                    isRouteComponent = isPageFile(absoluteFilePath) && isPageComponentFile(absoluteFilePath);
+                                    if (!(isRouteComponent && (eventType === "add" || eventType === "unlink") || isNestedRouteComponent(nestedRouteEntries, absoluteFilePath) && eventType === "change")) return [
+                                        3,
+                                        2
+                                    ];
+                                    resolvedConfig = api.useResolvedConfigContext();
+                                    return [
+                                        4,
+                                        import("./generateCode")
+                                    ];
+                                case 1:
+                                    generateCode = _state.sent().generateCode;
+                                    entrypoints = cloneDeep(originEntrypoints);
+                                    generateCode(appContext, resolvedConfig, entrypoints, api);
+                                    _state.label = 2;
+                                case 2:
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    })();
                 }
-              }
-            }, _callee7);
-          }))();
+            };
         }
-      };
-    }
-  };
-});
+    };
+};
+export { analyze_default as default };