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

package/dist/js/treeshaking/analyze/nestedRoutes.js

@@ -1,17 +1,44 @@
-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 _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import * as path from 'path';
-import { fs, getRouteId } from '@modern-js/utils';
+import { fs, getRouteId, normalizeToPosixPath } from '@modern-js/utils';
 import { JS_EXTENSIONS } from "./constants";
-import { replaceWithAlias } from "./utils";
+import { hasLoader, replaceWithAlias } from "./utils";
 var LAYOUT_FILE = 'layout';
 var PAGE_FILE = 'page';
 var LOADING_FILE = 'loading';
 var ERROR_FILE = 'error';
 var LOADER_FILE = 'loader';
 var conventionNames = [LAYOUT_FILE, PAGE_FILE, LOADING_FILE, ERROR_FILE, LOADER_FILE];
+var getLoaderPath = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(filename) {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return hasLoader(filename);
+          case 2:
+            if (!_context.sent) {
+              _context.next = 4;
+              break;
+            }
+            return _context.abrupt("return", normalizeToPosixPath(filename));
+          case 4:
+            return _context.abrupt("return", undefined);
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return function getLoaderPath(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
 var replaceDynamicPath = function replaceDynamicPath(routePath) {
   return routePath.replace(/\[(.*?)\]/g, ':$1');
 };
@@ -29,30 +56,30 @@ var createRoute = function createRoute(routeInfo, rootDir, filename, entryName)
   });
 };
 export var walk = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(dirname, rootDir, alias, entryName) {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(dirname, rootDir, alias, entryName) {
     var isDirectory, relativeDir, pathSegments, lastSegment, isRoot, isPathlessLayout, isWithoutLayoutPath, routePath, route, items, _iterator, _step, item, itemPath, extname, itemWithoutExt, _isDirectory, childRoute, _route$children, _route$children2, _childRoute, finalRoute;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
       while (1) {
-        switch (_context.prev = _context.next) {
+        switch (_context2.prev = _context2.next) {
           case 0:
-            _context.next = 2;
+            _context2.next = 2;
             return fs.pathExists(dirname);
           case 2:
-            if (_context.sent) {
-              _context.next = 4;
+            if (_context2.sent) {
+              _context2.next = 4;
               break;
             }
-            return _context.abrupt("return", null);
+            return _context2.abrupt("return", null);
           case 4:
-            _context.next = 6;
+            _context2.next = 6;
             return fs.stat(dirname);
           case 6:
-            isDirectory = _context.sent.isDirectory();
+            isDirectory = _context2.sent.isDirectory();
             if (isDirectory) {
-              _context.next = 9;
+              _context2.next = 9;
               break;
             }
-            return _context.abrupt("return", null);
+            return _context2.abrupt("return", null);
           case 9:
             relativeDir = path.relative(rootDir, dirname);
             pathSegments = relativeDir.split(path.sep);
@@ -67,79 +94,95 @@ export var walk = /*#__PURE__*/function () {
             routePath = replaceDynamicPath(routePath);
             route = {
               path: routePath,
-              children: []
+              children: [],
+              isRoot: isRoot
             };
-            _context.next = 21;
+            _context2.next = 21;
             return fs.readdir(dirname);
           case 21:
-            items = _context.sent;
+            items = _context2.sent;
             _iterator = _createForOfIteratorHelper(items);
-            _context.prev = 23;
+            _context2.prev = 23;
             _iterator.s();
           case 25:
             if ((_step = _iterator.n()).done) {
-              _context.next = 47;
+              _context2.next = 55;
               break;
             }
             item = _step.value;
             itemPath = path.join(dirname, item);
             extname = path.extname(item);
             itemWithoutExt = item.slice(0, -extname.length);
-            _context.next = 32;
+            _context2.next = 32;
             return fs.stat(itemPath);
           case 32:
-            _isDirectory = _context.sent.isDirectory();
+            _isDirectory = _context2.sent.isDirectory();
             if (!_isDirectory) {
-              _context.next = 38;
+              _context2.next = 38;
               break;
             }
-            _context.next = 36;
+            _context2.next = 36;
             return walk(itemPath, rootDir, alias, entryName);
           case 36:
-            childRoute = _context.sent;
+            childRoute = _context2.sent;
             if (childRoute) {
               (_route$children = route.children) === null || _route$children === void 0 ? void 0 : _route$children.push(childRoute);
             }
           case 38:
             if (!(extname && (!JS_EXTENSIONS.includes(extname) || !conventionNames.includes(itemWithoutExt)))) {
-              _context.next = 40;
+              _context2.next = 40;
               break;
             }
-            return _context.abrupt("continue", 45);
+            return _context2.abrupt("continue", 53);
           case 40:
-            if (itemWithoutExt === LAYOUT_FILE) {
-              route._component = replaceWithAlias(alias.basename, itemPath, alias.name);
-            }
-            if (itemWithoutExt === PAGE_FILE) {
-              _childRoute = createIndexRoute({
-                _component: replaceWithAlias(alias.basename, itemPath, alias.name)
-              }, rootDir, itemPath, entryName);
-              (_route$children2 = route.children) === null || _route$children2 === void 0 ? void 0 : _route$children2.push(_childRoute);
+            if (!(itemWithoutExt === LAYOUT_FILE)) {
+              _context2.next = 45;
+              break;
             }
-            if (itemWithoutExt === LOADER_FILE) {
-              route.loader = replaceWithAlias(alias.basename, itemPath, alias.name);
+            route._component = replaceWithAlias(alias.basename, itemPath, alias.name);
+            _context2.next = 44;
+            return getLoaderPath(itemPath);
+          case 44:
+            route.loader = _context2.sent;
+          case 45:
+            if (!(itemWithoutExt === PAGE_FILE)) {
+              _context2.next = 51;
+              break;
             }
+            _childRoute = createIndexRoute({
+              _component: replaceWithAlias(alias.basename, itemPath, alias.name)
+            }, rootDir, itemPath, entryName);
+            _context2.next = 49;
+            return getLoaderPath(itemPath);
+          case 49:
+            _childRoute.loader = _context2.sent;
+            (_route$children2 = route.children) === null || _route$children2 === void 0 ? void 0 : _route$children2.push(_childRoute);
+          case 51:
+            // if (itemWithoutExt === LOADER_FILE) {
+            //   route.loader = replaceWithAlias(alias.basename, itemPath, alias.name);
+            // }
+
             if (itemWithoutExt === LOADING_FILE) {
               route.loading = replaceWithAlias(alias.basename, itemPath, alias.name);
             }
             if (itemWithoutExt === ERROR_FILE) {
               route.error = replaceWithAlias(alias.basename, itemPath, alias.name);
             }
-          case 45:
-            _context.next = 25;
+          case 53:
+            _context2.next = 25;
             break;
-          case 47:
-            _context.next = 52;
+          case 55:
+            _context2.next = 60;
             break;
-          case 49:
-            _context.prev = 49;
-            _context.t0 = _context["catch"](23);
-            _iterator.e(_context.t0);
-          case 52:
-            _context.prev = 52;
+          case 57:
+            _context2.prev = 57;
+            _context2.t0 = _context2["catch"](23);
+            _iterator.e(_context2.t0);
+          case 60:
+            _context2.prev = 60;
             _iterator.f();
-            return _context.finish(52);
-          case 55:
+            return _context2.finish(60);
+          case 63:
             finalRoute = createRoute(route, rootDir, path.join(dirname, "".concat(LAYOUT_FILE, ".ts")), entryName);
             /**
              * when the url is /, the __auth/layout.tsx component should not be rendered
@@ -151,15 +194,15 @@ export var walk = /*#__PURE__*/function () {
             if (isPathlessLayout) {
               delete finalRoute.path;
             }
-            return _context.abrupt("return", finalRoute);
-          case 58:
+            return _context2.abrupt("return", finalRoute);
+          case 66:
           case "end":
-            return _context.stop();
+            return _context2.stop();
         }
       }
-    }, _callee, null, [[23, 49, 52, 55]]);
+    }, _callee2, null, [[23, 57, 60, 63]]);
   }));
-  return function walk(_x, _x2, _x3, _x4) {
-    return _ref.apply(this, arguments);
+  return function walk(_x2, _x3, _x4, _x5) {
+    return _ref2.apply(this, arguments);
   };
 }();

package/dist/js/treeshaking/analyze/templates.js

@@ -1,5 +1,10 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import path from 'path';
+import { fs } from '@modern-js/utils';
+import { TEMP_LOADERS_DIR } from "./constants";
 export var index = function index(_ref) {
   var mountId = _ref.mountId,
     imports = _ref.imports,
@@ -23,10 +28,10 @@ export var html = function html(partials) {
 };
 export var routesForServer = function routesForServer(_ref4) {
   var routes = _ref4.routes,
-    alias = _ref4.alias;
-  var name = alias.name,
-    basename = alias.basename;
+    internalDirectory = _ref4.internalDirectory,
+    entryName = _ref4.entryName;
   var loaders = [];
+  var loaderIndexFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, 'index.js');
   var traverseRouteTree = function traverseRouteTree(route) {
     var children;
     if ('children' in route && route.children) {
@@ -65,106 +70,175 @@ export var routesForServer = function routesForServer(_ref4) {
     _iterator.f();
   }
   routesCode += "\n];";
-  var importLoadersCode = loaders.map(function (loader, index) {
-    var realLoaderPath = loader.replace(name, basename);
-    return "import loader_".concat(index, " from '").concat(realLoaderPath, "';\n");
-  }).join('');
+  var importLoadersCode = '';
+  if (loaders.length > 0) {
+    importLoadersCode = "\n    import { ".concat(loaders.map(function (loader, index) {
+      return "loader_".concat(index);
+    }), " } from \"").concat(loaderIndexFile, "\"");
+  }
   return "\n    ".concat(importLoadersCode, "\n    ").concat(routesCode, "\n  ");
 };
-export var fileSystemRoutes = function fileSystemRoutes(_ref5) {
-  var routes = _ref5.routes,
-    ssrMode = _ref5.ssrMode,
-    nestedRoutesEntry = _ref5.nestedRoutesEntry,
-    entryName = _ref5.entryName;
-  // The legacy mode and pages dir routes should use loadable
-  // nested routes + renderTostring should use loadable.lazy
-  // nested routes + renderToStream should use react.lazy
-  var importLazyCode = "\n    import { lazy } from \"react\";\n    import loadable, { lazy as loadableLazy } from \"@modern-js/runtime/loadable\"\n  ";
-  var dataLoaderPath = '';
-  if (ssrMode) {
-    dataLoaderPath = require.resolve("@modern-js/plugin-data-loader/loader");
-    if (nestedRoutesEntry) {
-      dataLoaderPath = "".concat(dataLoaderPath, "?routesDir=").concat(nestedRoutesEntry, "&entryName=").concat(entryName, "!");
-    }
-  }
-  var loadings = [];
-  var errors = [];
-  var loaders = [];
-  var traverseRouteTree = function traverseRouteTree(route) {
-    var children;
-    if ('children' in route && route.children) {
-      var _route$children2;
-      children = route === null || route === void 0 ? void 0 : (_route$children2 = route.children) === null || _route$children2 === void 0 ? void 0 : _route$children2.map(traverseRouteTree);
-    }
-    var loading;
-    var error;
-    var loader;
-    var component = '';
-    if (route.type === 'nested') {
-      if (route.loading) {
-        loadings.push(route.loading);
-        loading = "loading_".concat(loadings.length - 1);
-      }
-      if (route.error) {
-        errors.push(route.error);
-        error = "error_".concat(errors.length - 1);
-      }
-      if (route.loader) {
-        loaders.push(route.loader);
-        loader = "loader_".concat(loaders.length - 1);
-      }
-      if (route._component) {
-        if (ssrMode === 'stream') {
-          component = "lazy(() => import(/* webpackChunkName: \"".concat(route.id, "\" */  /* webpackMode: \"lazy-once\" */ '").concat(route._component, "'))");
-        } else {
-          component = "loadable(() => import(/* webpackChunkName: \"".concat(route.id, "\" */  /* webpackMode: \"lazy-once\" */ '").concat(route._component, "'))");
+export var fileSystemRoutes = /*#__PURE__*/function () {
+  var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref5) {
+    var routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, loadings, errors, loaders, loadersMap, loadersIndexFile, loadersMapFile, importLazyCode, rootLayoutCode, dataLoaderPath, componentLoaderPath, traverseRouteTree, routeComponentsCode, _iterator2, _step2, route, newRoute, component, finalRoute, importLoadingCode, importErrorComponentsCode, importLoadersCode, loaderEntryCode, loaderEntryFile;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            routes = _ref5.routes, ssrMode = _ref5.ssrMode, nestedRoutesEntry = _ref5.nestedRoutesEntry, entryName = _ref5.entryName, internalDirectory = _ref5.internalDirectory;
+            loadings = [];
+            errors = [];
+            loaders = [];
+            loadersMap = {};
+            loadersIndexFile = path.join('@_modern_js_internal', entryName, TEMP_LOADERS_DIR, 'index.js');
+            loadersMapFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, 'map.json');
+            importLazyCode = "\n    import { lazy } from \"react\";\n    import loadable, { lazy as loadableLazy } from \"@modern-js/runtime/loadable\"\n  ";
+            rootLayoutCode = "";
+            dataLoaderPath = '';
+            componentLoaderPath = '';
+            if (ssrMode) {
+              dataLoaderPath = require.resolve("@modern-js/plugin-data-loader/loader");
+              if (nestedRoutesEntry) {
+                dataLoaderPath = "".concat(dataLoaderPath, "?routesDir=").concat(nestedRoutesEntry, "&mapFile=").concat(loadersMapFile, "!");
+              }
+              componentLoaderPath = "".concat(path.join(__dirname, '../builder/loaders/routerLoader'), "!");
+            }
+            traverseRouteTree = function traverseRouteTree(route) {
+              var children;
+              if ('children' in route && route.children) {
+                var _route$children2;
+                children = route === null || route === void 0 ? void 0 : (_route$children2 = route.children) === null || _route$children2 === void 0 ? void 0 : _route$children2.map(traverseRouteTree);
+              }
+              var loading;
+              var error;
+              var loader;
+              var component = '';
+              if (route.type === 'nested') {
+                if (route.loading) {
+                  loadings.push(route.loading);
+                  loading = "loading_".concat(loadings.length - 1);
+                }
+                if (route.error) {
+                  errors.push(route.error);
+                  error = "error_".concat(errors.length - 1);
+                }
+                if (route.loader) {
+                  loaders.push(route.loader);
+                  var loaderId = loaders.length - 1;
+                  loader = "loader_".concat(loaderId);
+                  loadersMap[loader] = route.id;
+                }
+                if (route._component) {
+                  if (route.isRoot) {
+                    rootLayoutCode = "import RootLayout from '".concat(route._component, "'");
+                    component = "RootLayout";
+                  } else if (ssrMode === 'string') {
+                    component = "loadable(() => import(/* webpackChunkName: \"".concat(route.id, "\" */  '").concat(componentLoaderPath).concat(route._component, "'))");
+                  } else {
+                    // csr and streaming
+                    component = "lazy(() => import(/* webpackChunkName: \"".concat(route.id, "\" */  '").concat(componentLoaderPath).concat(route._component, "'))");
+                  }
+                }
+              } else if (route._component) {
+                component = "loadable(() => import('".concat(route._component, "'))");
+              }
+              var finalRoute = _objectSpread(_objectSpread({}, route), {}, {
+                loading: loading,
+                loader: loader,
+                error: error,
+                children: children
+              });
+              if (route._component) {
+                finalRoute.component = component;
+              }
+              return finalRoute;
+            };
+            routeComponentsCode = "\n    export const routes = [\n  ";
+            _iterator2 = _createForOfIteratorHelper(routes);
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                route = _step2.value;
+                if ('type' in route) {
+                  newRoute = traverseRouteTree(route);
+                  routeComponentsCode += "".concat(JSON.stringify(newRoute, null, 2).replace(/"(loadable.*\))"/g, '$1').replace(/"(loadableLazy.*\))"/g, '$1').replace(/"(lazy.*\))"/g, '$1').replace(/"(loading_[^"])"/g, '$1').replace(/"(loader_[^"])"/g, '$1').replace(/"(RootLayout)"/g, '$1').replace(/"(error_[^"])"/g, '$1').replace(/\\"/g, '"'), ",");
+                } else {
+                  component = "loadable(() => import('".concat(route._component, "'))");
+                  finalRoute = _objectSpread(_objectSpread({}, route), {}, {
+                    component: component
+                  });
+                  routeComponentsCode += "".concat(JSON.stringify(finalRoute, null, 2).replace(/"(loadable[^"]*)"/g, '$1').replace(/"(lazy[^"]*)"/g, '$1'), ",");
+                }
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            routeComponentsCode += "\n];";
+            importLoadingCode = loadings.map(function (loading, index) {
+              return "import loading_".concat(index, " from '").concat(loading, "';\n");
+            }).join('');
+            importErrorComponentsCode = errors.map(function (error, index) {
+              return "import error_".concat(index, " from '").concat(error, "';\n");
+            }).join('');
+            importLoadersCode = '';
+            if (!(loaders.length > 0)) {
+              _context2.next = 32;
+              break;
+            }
+            importLoadersCode = "\n    import { ".concat(loaders.map(function (loader, index) {
+              return "loader_".concat(index);
+            }), " } from \"").concat(dataLoaderPath).concat(loadersIndexFile, "\"\n  ");
+            loaderEntryCode = loaders.map(function (loader, index) {
+              return "export * from './loader_".concat(index, ".js';");
+            }).join('\n');
+            loaderEntryFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, 'entry.js');
+            _context2.next = 26;
+            return fs.ensureFile(loaderEntryFile);
+          case 26:
+            _context2.next = 28;
+            return fs.writeFile(loaderEntryFile, loaderEntryCode);
+          case 28:
+            _context2.next = 30;
+            return fs.writeJSON(loadersMapFile, loadersMap);
+          case 30:
+            _context2.next = 32;
+            return Promise.all(loaders.map( /*#__PURE__*/function () {
+              var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(loader, index) {
+                var name, filename, code;
+                return _regeneratorRuntime().wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        name = "loader_".concat(index);
+                        filename = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, "".concat(name, ".js"));
+                        code = "\n          export { loader as ".concat(name, " } from '").concat(loader, "'\n        ");
+                        _context.next = 5;
+                        return fs.ensureFile(filename);
+                      case 5:
+                        _context.next = 7;
+                        return fs.writeFile(filename, code);
+                      case 7:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+              return function (_x2, _x3) {
+                return _ref7.apply(this, arguments);
+              };
+            }()));
+          case 32:
+            return _context2.abrupt("return", "\n    ".concat(importLazyCode, "\n    ").concat(rootLayoutCode, "\n    ").concat(importLoadingCode, "\n    ").concat(importErrorComponentsCode, "\n    ").concat(importLoadersCode, "\n    ").concat(routeComponentsCode, "\n  "));
+          case 33:
+          case "end":
+            return _context2.stop();
         }
       }
-    } else if (route._component) {
-      component = "loadable(() => import('".concat(route._component, "'))");
-    }
-    var finalRoute = _objectSpread(_objectSpread({}, route), {}, {
-      loading: loading,
-      loader: loader,
-      error: error,
-      children: children
-    });
-    if (route._component) {
-      finalRoute.component = component;
-    }
-    return finalRoute;
+    }, _callee2);
+  }));
+  return function fileSystemRoutes(_x) {
+    return _ref6.apply(this, arguments);
   };
-  var routeComponentsCode = "\n    export const routes = [\n  ";
-  var _iterator2 = _createForOfIteratorHelper(routes),
-    _step2;
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var route = _step2.value;
-      if ('type' in route) {
-        var newRoute = traverseRouteTree(route);
-        routeComponentsCode += "".concat(JSON.stringify(newRoute, null, 2).replace(/"(loadable.*\))"/g, '$1').replace(/"(loadableLazy.*\))"/g, '$1').replace(/"(lazy.*\))"/g, '$1').replace(/"(loading_[^"])"/g, '$1').replace(/"(loader_[^"])"/g, '$1').replace(/"(error_[^"])"/g, '$1').replace(/\\"/g, '"'), ",");
-      } else {
-        var component = "loadable(() => import('".concat(route._component, "'))");
-        var finalRoute = _objectSpread(_objectSpread({}, route), {}, {
-          component: component
-        });
-        routeComponentsCode += "".concat(JSON.stringify(finalRoute, null, 2).replace(/"(loadable[^"]*)"/g, '$1').replace(/"(lazy[^"]*)"/g, '$1'), ",");
-      }
-    }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
-  }
-  routeComponentsCode += "\n];";
-  var importLoadingCode = loadings.map(function (loading, index) {
-    return "import loading_".concat(index, " from '").concat(loading, "';\n");
-  }).join('');
-  var importErrorComponentsCode = errors.map(function (error, index) {
-    return "import error_".concat(index, " from '").concat(error, "';\n");
-  }).join('');
-  var importLoaderComponentsCode = loaders.map(function (loader, index) {
-    return "import loader_".concat(index, " from '").concat(dataLoaderPath).concat(loader, "';\n");
-  }).join('');
-  return "\n    ".concat(importLazyCode, "\n    ").concat(importLoadingCode, "\n    ").concat(importErrorComponentsCode, "\n    ").concat(importLoaderComponentsCode, "\n    ").concat(routeComponentsCode, "\n  ");
-};
+}();

package/dist/js/treeshaking/analyze/utils.js

@@ -1,8 +1,13 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import fs from 'fs';
 import path from 'path';
-import { isReact18, normalizeToPosixPath } from '@modern-js/utils';
-import { FILE_SYSTEM_ROUTES_FILE_NAME } from "./constants";
+import { isReact18, normalizeToPosixPath, fs as fse } from '@modern-js/utils';
+import { transform } from 'esbuild';
+import { parse } from 'es-module-lexer';
+import { FILE_SYSTEM_ROUTES_FILE_NAME, LOADER_EXPORT_NAME } from "./constants";
 export var walkDirectory = function walkDirectory(dir) {
   return fs.readdirSync(dir).reduce(function (previous, filename) {
     var filePath = path.join(dir, filename);
@@ -51,7 +56,7 @@ export var getDefaultImports = function getDefaultImports(_ref) {
       specifiers: [{
         imported: 'routes'
       }],
-      value: normalizeToPosixPath("".concat(internalDirAlias, "/").concat(entryName, "/").concat(FILE_SYSTEM_ROUTES_FILE_NAME))
+      value: normalizeToPosixPath("".concat(internalDirAlias, "/").concat(entryName, "/").concat(FILE_SYSTEM_ROUTES_FILE_NAME.replace('.js', '')))
     };
     if (fileSystemRoutes.globalApp) {
       imports.push({
@@ -85,4 +90,75 @@ export var isRouteComponentFile = function isRouteComponentFile(filePath) {
 };
 export var replaceWithAlias = function replaceWithAlias(base, filePath, alias) {
   return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
-};
+};
+export var parseModule = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref2) {
+    var source, filename, content, result;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            source = _ref2.source, filename = _ref2.filename;
+            content = source;
+            if (!(filename.endsWith('.tsx') || filename.endsWith('.jsx'))) {
+              _context.next = 7;
+              break;
+            }
+            _context.next = 5;
+            return transform(content, {
+              loader: path.extname(filename).slice(1),
+              format: 'esm'
+            });
+          case 5:
+            result = _context.sent;
+            content = result.code;
+          case 7:
+            _context.next = 9;
+            return parse(content);
+          case 9:
+            return _context.abrupt("return", _context.sent);
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return function parseModule(_x) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+export var hasLoader = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(filename) {
+    var source, _yield$parseModule, _yield$parseModule2, moduleExports;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return fse.readFile(filename);
+          case 2:
+            source = _context2.sent;
+            _context2.next = 5;
+            return parseModule({
+              source: source.toString(),
+              filename: filename
+            });
+          case 5:
+            _yield$parseModule = _context2.sent;
+            _yield$parseModule2 = _slicedToArray(_yield$parseModule, 2);
+            moduleExports = _yield$parseModule2[1];
+            return _context2.abrupt("return", moduleExports.some(function (e) {
+              return e.n === LOADER_EXPORT_NAME;
+            }));
+          case 9:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return function hasLoader(_x2) {
+    return _ref4.apply(this, arguments);
+  };
+}();