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

package/dist/js/modern/analyze/index.js

@@ -1,60 +1,35 @@
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 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; }
-
 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 { initialNormalizedConfig } from "../config";
 import { isRouteComponentFile } from "./utils";
 const debug = createDebugger('plugin-analyze');
-export const modifyEntryImports = createAsyncWaterfall();
-export const modifyEntryExport = createAsyncWaterfall();
-export const addRuntimeExports = createAsyncWaterfall();
-export const modifyEntryRuntimePlugins = createAsyncWaterfall();
-export const modifyEntryRenderFunction = createAsyncWaterfall();
-export const modifyAsyncEntry = createAsyncWaterfall();
-export const modifyFileSystemRoutes = createAsyncWaterfall();
-export const modifyServerRoutes = createAsyncWaterfall();
-export const htmlPartials = createAsyncWaterfall();
-export const beforeGenerateRoutes = createAsyncWaterfall();
-export const addDefineTypes = createAsyncWaterfall();
 export default (() => ({
   name: '@modern-js/plugin-analyze',
-  registerHook: {
-    modifyAsyncEntry,
-    modifyEntryImports,
-    modifyEntryExport,
-    modifyEntryRuntimePlugins,
-    modifyEntryRenderFunction,
-    modifyFileSystemRoutes,
-    modifyServerRoutes,
-    htmlPartials,
-    addRuntimeExports,
-    beforeGenerateRoutes,
-    addDefineTypes
-  },
   setup: api => {
     let pagesDir = [];
     let originEntrypoints = [];
     return {
       async prepare() {
         var _resolvedConfig$sourc;
-
-        const appContext = api.useAppContext();
+        let appContext = api.useAppContext();
         const resolvedConfig = api.useResolvedConfigContext();
         const hookRunners = api.useHookRunners();
-
         try {
           fs.emptydirSync(appContext.internalDirectory);
-        } catch (_unused) {// FIXME:
+        } catch (_unused) {
+          // FIXME:
         }
-
-        const apiOnly = await isApiOnly(appContext.appDirectory, resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig$sourc = resolvedConfig.source) === null || _resolvedConfig$sourc === void 0 ? void 0 : _resolvedConfig$sourc.entriesDir);
+        const apiOnly = await isApiOnly(appContext.appDirectory, (_resolvedConfig$sourc = resolvedConfig.source) === null || _resolvedConfig$sourc === void 0 ? void 0 : _resolvedConfig$sourc.entriesDir);
         await hookRunners.addRuntimeExports();
-
         if (apiOnly) {
           const {
             routes
@@ -62,13 +37,13 @@ export default (() => ({
             routes: []
           });
           debug(`server routes: %o`, routes);
-          api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+          appContext = _objectSpread(_objectSpread({}, appContext), {}, {
             apiOnly,
             serverRoutes: routes
-          }));
+          });
+          api.setAppContext(appContext);
           return;
         }
-
         const [{
           getBundleEntry
         }, {
@@ -91,10 +66,11 @@ export default (() => ({
           routes: initialRoutes
         });
         debug(`server routes: %o`, routes);
-        api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+        appContext = _objectSpread(_objectSpread({}, appContext), {}, {
           entrypoints,
           serverRoutes: routes
-        }));
+        });
+        api.setAppContext(appContext);
         const nestedRouteEntries = entrypoints.map(point => point.nestedRoutesEntry).filter(Boolean);
         pagesDir = entrypoints.map(point => point.entry).filter(Boolean).concat(nestedRouteEntries);
         originEntrypoints = cloneDeep(entrypoints);
@@ -106,19 +82,89 @@ export default (() => ({
         debug(`html templates: %o`, htmlTemplates);
         await hookRunners.addDefineTypes();
         debug(`add Define Types`);
-        api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+        appContext = _objectSpread(_objectSpread({}, appContext), {}, {
           entrypoints,
           checkedEntries: defaultChecked,
           apiOnly,
           serverRoutes: routes,
           htmlTemplates
-        }));
+        });
+        api.setAppContext(appContext);
+        const command = getCommand();
+        const buildCommands = ['dev', 'build', 'inspect', 'deploy'];
+        if (buildCommands.includes(command)) {
+          const normalizedConfig = api.useResolvedConfigContext();
+          const builder = await createBuilderForEdenX({
+            normalizedConfig: normalizedConfig,
+            appContext,
+            compatPluginConfig: {
+              async onBeforeBuild({
+                bundlerConfigs
+              }) {
+                const hookRunners = api.useHookRunners();
+                await generateRoutes(appContext);
+                await hookRunners.beforeBuild({
+                  bundlerConfigs
+                });
+              },
+              async onAfterBuild({
+                stats
+              }) {
+                const hookRunners = api.useHookRunners();
+                await hookRunners.afterBuild({
+                  stats
+                });
+                await emitResolvedConfig(appContext.appDirectory, normalizedConfig);
+              },
+              async onDevCompileDone({
+                isFirstCompile
+              }) {
+                const hookRunners = api.useHookRunners();
+                if (process.stdout.isTTY || isFirstCompile) {
+                  hookRunners.afterDev();
+                  if (isFirstCompile) {
+                    printInstructions(hookRunners, appContext, normalizedConfig);
+                  }
+                }
+              },
+              async onBeforeCreateCompiler({
+                bundlerConfigs
+              }) {
+                const hookRunners = api.useHookRunners();
+                // run modernjs framework `beforeCreateCompiler` hook
+                await hookRunners.beforeCreateCompiler({
+                  bundlerConfigs
+                });
+              },
+              async onAfterCreateCompiler({
+                compiler
+              }) {
+                const hookRunners = api.useHookRunners();
+                // run modernjs framework afterCreateCompiler hooks
+                await hookRunners.afterCreateCompiler({
+                  compiler
+                });
+              }
+            }
+          });
+          appContext = _objectSpread(_objectSpread({}, appContext), {}, {
+            builder
+          });
+          api.setAppContext(appContext);
+        }
       },
-
       watchFiles() {
         return pagesDir;
       },
-
+      resolvedConfig({
+        resolved
+      }) {
+        const appContext = api.useAppContext();
+        const config = initialNormalizedConfig(resolved, appContext);
+        return {
+          resolved: config
+        };
+      },
       async fileChange(e) {
         const appContext = api.useAppContext();
         const {
@@ -128,12 +174,9 @@ export default (() => ({
           filename,
           eventType
         } = e;
-
         const isPageFile = name => pagesDir.some(pageDir => name.includes(pageDir));
-
         const absoluteFilePath = path.resolve(appDirectory, filename);
         const isRouteComponent = isPageFile(absoluteFilePath) && isRouteComponentFile(absoluteFilePath);
-
         if (isRouteComponent && (eventType === 'add' || eventType === 'unlink')) {
           const resolvedConfig = api.useResolvedConfigContext();
           const {
@@ -143,7 +186,6 @@ export default (() => ({
           generateCode(appContext, resolvedConfig, entrypoints, api);
         }
       }
-
     };
   }
 }));

package/dist/js/modern/analyze/isDefaultExportFunction.js

@@ -2,14 +2,11 @@ import fs from 'fs';
 import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
 import * as t from '@babel/types';
-
 const isFunction = node => t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node);
-
 export const isDefaultExportFunction = file => {
   if (!file || !fs.existsSync(file)) {
     return false;
   }
-
   const ast = parse(fs.readFileSync(file, 'utf8'), {
     sourceType: 'unambiguous',
     plugins: ['jsx', 'typescript', 'classProperties', 'dynamicImport', 'exportDefaultFrom', 'exportNamespaceFrom', 'decorators-legacy', 'functionBind', 'classPrivateMethods', ['pipelineOperator', {
@@ -22,7 +19,6 @@ export const isDefaultExportFunction = file => {
       const {
         declaration
       } = path.node;
-
       if (isFunction(declaration)) {
         isExportFunction = true;
       }

package/dist/js/modern/analyze/makeLegalIdentifier.js

@@ -7,10 +7,8 @@ const builtins = 'arguments Infinity NaN undefined null true false eval uneval i
 const forbidList = new Set(`${reservedWords} ${builtins}`.split(' '));
 export function makeLegalIdentifier(str) {
   const identifier = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');
-
   if (/\d/.test(identifier[0]) || forbidList.has(identifier)) {
     return `_${identifier}`;
   }
-
   return identifier || '_';
 }

package/dist/js/modern/analyze/nestedRoutes.js

@@ -1,9 +1,6 @@
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 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; }
-
 import * as path from 'path';
 import { fs, getRouteId } from '@modern-js/utils';
 import { JS_EXTENSIONS } from "./constants";
@@ -14,37 +11,30 @@ const LOADING_FILE = 'loading';
 const ERROR_FILE = 'error';
 const LOADER_FILE = 'loader';
 const conventionNames = [LAYOUT_FILE, PAGE_FILE, LOADING_FILE, ERROR_FILE, LOADER_FILE];
-
 const replaceDynamicPath = routePath => {
   return routePath.replace(/\[(.*?)\]/g, ':$1');
 };
-
-const createIndexRoute = (routeInfo, rootDir, filename) => {
+const createIndexRoute = (routeInfo, rootDir, filename, entryName) => {
   return createRoute(_objectSpread(_objectSpread({}, routeInfo), {}, {
     index: true,
     children: undefined
-  }), rootDir, filename);
+  }), rootDir, filename, entryName);
 };
-
-const createRoute = (routeInfo, rootDir, filename) => {
-  const id = getRouteId(filename, rootDir);
+const createRoute = (routeInfo, rootDir, filename, entryName) => {
+  const id = getRouteId(filename, rootDir, entryName);
   return _objectSpread(_objectSpread({}, routeInfo), {}, {
     id,
     type: 'nested'
   });
 };
-
-export const walk = async (dirname, rootDir, alias) => {
+export const walk = async (dirname, rootDir, alias, entryName) => {
   if (!(await fs.pathExists(dirname))) {
     return null;
   }
-
   const isDirectory = (await fs.stat(dirname)).isDirectory();
-
   if (!isDirectory) {
     return null;
   }
-
   const relativeDir = path.relative(rootDir, dirname);
   const pathSegments = relativeDir.split(path.sep);
   const lastSegment = pathSegments[pathSegments.length - 1];
@@ -52,65 +42,52 @@ export const walk = async (dirname, rootDir, alias) => {
   const isPathlessLayout = lastSegment.startsWith('__');
   const isWithoutLayoutPath = lastSegment.includes('.');
   let routePath = isRoot || isPathlessLayout ? '/' : `${lastSegment}`;
-
   if (isWithoutLayoutPath) {
     routePath = lastSegment.split('.').join('/');
   }
-
   routePath = replaceDynamicPath(routePath);
   const route = {
     path: routePath,
     children: []
   };
   const items = await fs.readdir(dirname);
-
   for (const item of items) {
     const itemPath = path.join(dirname, item);
     const extname = path.extname(item);
     const itemWithoutExt = item.slice(0, -extname.length);
     const isDirectory = (await fs.stat(itemPath)).isDirectory();
-
     if (isDirectory) {
-      const childRoute = await walk(itemPath, rootDir, alias);
-
+      const childRoute = await walk(itemPath, rootDir, alias, entryName);
       if (childRoute) {
         var _route$children;
-
         (_route$children = route.children) === null || _route$children === void 0 ? void 0 : _route$children.push(childRoute);
       }
     }
-
     if (extname && (!JS_EXTENSIONS.includes(extname) || !conventionNames.includes(itemWithoutExt))) {
       continue;
     }
-
     if (itemWithoutExt === LAYOUT_FILE) {
       route._component = replaceWithAlias(alias.basename, itemPath, alias.name);
     }
-
     if (itemWithoutExt === PAGE_FILE) {
       var _route$children2;
-
       const childRoute = createIndexRoute({
         _component: replaceWithAlias(alias.basename, itemPath, alias.name)
-      }, rootDir, itemPath);
+      }, rootDir, itemPath, entryName);
       (_route$children2 = route.children) === null || _route$children2 === void 0 ? void 0 : _route$children2.push(childRoute);
     }
-
     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);
     }
   }
+  const finalRoute = createRoute(route, rootDir, path.join(dirname, `${LAYOUT_FILE}.ts`), entryName);
 
-  const finalRoute = createRoute(route, rootDir, path.join(dirname, `${LAYOUT_FILE}.ts`));
   /**
    * when the url is /, the __auth/layout.tsx component should not be rendered
    * - routes
@@ -118,10 +95,8 @@ export const walk = async (dirname, rootDir, alias) => {
    *    - layout.tsx
    *  - layout.tsx
    */
-
   if (isPathlessLayout) {
     delete finalRoute.path;
   }
-
   return finalRoute;
 };

package/dist/js/modern/analyze/templates.js

@@ -1,9 +1,6 @@
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 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; }
-
 export const index = ({
   mountId,
   imports,
@@ -88,37 +85,28 @@ export const routesForServer = ({
     basename
   } = alias;
   const loaders = [];
-
   const traverseRouteTree = route => {
     let children;
-
     if ('children' in route && route.children) {
       var _route$children;
-
       children = route === null || route === void 0 ? void 0 : (_route$children = route.children) === null || _route$children === void 0 ? void 0 : _route$children.map(traverseRouteTree);
     }
-
     let loader;
-
     if (route.type === 'nested') {
       if (route.loader) {
         loaders.push(route.loader);
         loader = `loader_${loaders.length - 1}`;
       }
     }
-
     const finalRoute = _objectSpread(_objectSpread({}, route), {}, {
       loader,
       children
     });
-
     return finalRoute;
   };
-
   let routesCode = `
   export const routes = [
   `;
-
   for (const route of routes) {
     if ('type' in route) {
       const newRoute = traverseRouteTree(route);
@@ -127,7 +115,6 @@ export const routesForServer = ({
       routesCode += `${JSON.stringify(route, null, 2)}`;
     }
   }
-
   routesCode += `\n];`;
   const importLoadersCode = loaders.map((loader, index) => {
     const realLoaderPath = loader.replace(name, basename);
@@ -141,87 +128,85 @@ export const routesForServer = ({
 export const fileSystemRoutes = ({
   routes,
   ssrMode,
-  nestedRoutesEntry
+  nestedRoutesEntry,
+  entryName
 }) => {
-  const importLazyCode = ssrMode === 'stream' ? 'import { lazy } from "react";' : `import loadable from '@modern-js/runtime/loadable'`;
+  // The legacy mode and pages dir routes should use loadable
+  // nested routes + renderTostring should use loadable.lazy
+  // nested routes + renderToStream should use react.lazy
+  const importLazyCode = `
+    import { lazy } from "react";
+    import loadable, { lazy as loadableLazy } from "@modern-js/runtime/loadable"
+  `;
   let dataLoaderPath = '';
-
   if (ssrMode) {
     dataLoaderPath = require.resolve(`@modern-js/plugin-data-loader/loader`);
-
     if (nestedRoutesEntry) {
-      dataLoaderPath = `${dataLoaderPath}?routesDir=${nestedRoutesEntry}!`;
+      dataLoaderPath = `${dataLoaderPath}?routesDir=${nestedRoutesEntry}&entryName=${entryName}!`;
     }
   }
-
   const loadings = [];
   const errors = [];
   const loaders = [];
-
   const traverseRouteTree = route => {
     let 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);
     }
-
     let loading;
     let error;
     let loader;
-
+    let component = '';
     if (route.type === 'nested') {
       if (route.loading) {
         loadings.push(route.loading);
         loading = `loading_${loadings.length - 1}`;
       }
-
       if (route.error) {
         errors.push(route.error);
         error = `error_${errors.length - 1}`;
       }
-
       if (route.loader) {
         loaders.push(route.loader);
         loader = `loader_${loaders.length - 1}`;
       }
+      if (route._component) {
+        if (ssrMode === 'stream') {
+          component = `lazy(() => import(/* webpackChunkName: "${route.id}" */  /* webpackMode: "lazy-once" */ '${route._component}'))`;
+        } else {
+          component = `loadable(() => import(/* webpackChunkName: "${route.id}" */  /* webpackMode: "lazy-once" */ '${route._component}'))`;
+        }
+      }
+    } else if (route._component) {
+      component = `loadable(() => import('${route._component}'))`;
     }
-
     const finalRoute = _objectSpread(_objectSpread({}, route), {}, {
       loading,
       loader,
       error,
       children
     });
-
     if (route._component) {
-      const component = ssrMode === 'stream' ? `lazy(() => import('${route._component}'))` : `loadable(() => import('${route._component}'))`;
       finalRoute.component = component;
     }
-
     return finalRoute;
   };
-
   let routeComponentsCode = `
     export const routes = [
   `;
-
   for (const route of routes) {
     if ('type' in route) {
       const newRoute = traverseRouteTree(route);
-      routeComponentsCode += `${JSON.stringify(newRoute, null, 2).replace(/"(loadable[^"]*)"/g, '$1').replace(/"(lazy[^"]*)"/g, '$1').replace(/"(loading_[^"])"/g, '$1').replace(/"(loader_[^"])"/g, '$1').replace(/"(error_[^"])"/g, '$1')},`;
+      routeComponentsCode += `${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 {
-      const component = ssrMode === 'stream' ? `lazy(() => import('${route._component}'))` : `loadable(() => import('${route._component}'))`;
-
+      const component = `loadable(() => import('${route._component}'))`;
       const finalRoute = _objectSpread(_objectSpread({}, route), {}, {
         component
       });
-
       routeComponentsCode += `${JSON.stringify(finalRoute, null, 2).replace(/"(loadable[^"]*)"/g, '$1').replace(/"(lazy[^"]*)"/g, '$1')},`;
     }
   }
-
   routeComponentsCode += `\n];`;
   const importLoadingCode = loadings.map((loading, index) => {
     return `import loading_${index} from '${loading}';\n`;

package/dist/js/modern/analyze/utils.js

@@ -4,7 +4,6 @@ import { isReact18, normalizeToPosixPath } from '@modern-js/utils';
 import { FILE_SYSTEM_ROUTES_FILE_NAME } from "./constants";
 export const walkDirectory = dir => fs.readdirSync(dir).reduce((previous, filename) => {
   const filePath = path.join(dir, filename);
-
   if (fs.statSync(filePath).isDirectory()) {
     return [...previous, ...walkDirectory(filePath)];
   } else {
@@ -47,7 +46,6 @@ export const getDefaultImports = ({
     }],
     value: normalizeToPosixPath(customBootstrap.replace(srcDirectory, internalSrcAlias))
   }].filter(Boolean);
-
   if (fileSystemRoutes) {
     const route = {
       specifiers: [{
@@ -55,7 +53,6 @@ export const getDefaultImports = ({
       }],
       value: normalizeToPosixPath(`${internalDirAlias}/${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`)
     };
-
     if (fileSystemRoutes.globalApp) {
       imports.push({
         specifiers: [{
@@ -66,7 +63,6 @@ export const getDefaultImports = ({
     } else {
       route.initialize = 'const App = false;';
     }
-
     imports.push(route);
   } else {
     imports.push({
@@ -76,18 +72,15 @@ export const getDefaultImports = ({
       value: normalizeToPosixPath(entry.replace(srcDirectory, internalSrcAlias))
     });
   }
-
   return imports;
 };
 export const isRouteComponentFile = filePath => {
   if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
     return false;
   }
-
   if (['.js', '.jsx', '.ts', '.tsx'].includes(path.extname(filePath))) {
     return true;
   }
-
   return false;
 };
 export const replaceWithAlias = (base, filePath, alias) => normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));