@modern-js/app-tools 2.69.5 → 3.0.0-alpha.0

package/dist/esm/esm/esbuild-loader.mjs

@@ -1,33 +1,22 @@
-import { pathToFileURL } from 'url';
-import { load as esbuildLoad } from 'esbuild-register/loader';
-import { createMatchPath } from './utils.mjs';
-
+import { pathToFileURL } from "url";
+import { load } from "esbuild-register/loader";
+import { createMatchPath } from "./utils.mjs";
 let matchPath;
-export async function initialize({ appDir, alias, tsconfigPath }) {
-  matchPath = createMatchPath({
-    alias,
-    appDir,
-    tsconfigPath,
-  });
+async function initialize({ appDir, alias, tsconfigPath }) {
+    matchPath = createMatchPath({
+        alias,
+        appDir,
+        tsconfigPath
+    });
 }
-
-export function resolve(specifier, context, defaultResolve) {
-  const match = matchPath(specifier);
-  return match
-    ? defaultResolve(pathToFileURL(match).href, context)
-    : defaultResolve(specifier, context);
+function resolve(specifier, context, defaultResolve) {
+    const match = matchPath(specifier);
+    return match ? defaultResolve(pathToFileURL(match).href, context) : defaultResolve(specifier, context);
 }
-
-export function load(url, context, defaultLoad) {
-  const filePath = new URL(url).pathname;
-
-  if (url.startsWith('node:')) {
-    return defaultLoad(url, context);
-  }
-
-  if (filePath.includes('node_modules')) {
-    return defaultLoad(url, context);
-  }
-
-  return esbuildLoad(url, context, defaultLoad);
+function esbuild_loader_load(url, context, defaultLoad) {
+    const filePath = new URL(url).pathname;
+    if (url.startsWith('node:')) return defaultLoad(url, context);
+    if (filePath.includes('node_modules')) return defaultLoad(url, context);
+    return load(url, context, defaultLoad);
 }
+export { initialize, esbuild_loader_load as load, resolve };

package/dist/esm/esm/register-esm.mjs

@@ -1,60 +1,48 @@
-import assert from 'node:assert';
-import path from 'node:path';
-import { fs, isVersionAtLeast1819, readTsConfigByFile } from '@modern-js/utils';
-
-const checkDep = async dep => {
-  try {
-    await import(dep);
-    return true;
-  } catch (error) {
-    return false;
-  }
+import node_assert from "node:assert";
+import { fs, isVersionAtLeast1819, readTsConfigByFile } from "@modern-js/utils";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+const checkDep = async (dep)=>{
+    try {
+        await import(dep);
+        return true;
+    } catch (error) {
+        return false;
+    }
 };
-
-export const registerEsm = async ({ appDir, distDir, alias }) => {
-  const nodeVersion = process.versions.node;
-  const versionArr = nodeVersion.split('.').map(Number);
-
-  assert(
-    isVersionAtLeast1819(nodeVersion),
-    `The node version of the esm project must be greater than 18.19.0, current version is ${nodeVersion}`,
-  );
-  const hasTsNode = await checkDep('ts-node');
-  const TS_CONFIG_FILENAME = `tsconfig.json`;
-  const tsconfigPath = path.resolve(appDir, TS_CONFIG_FILENAME);
-  const hasTsconfig = await fs.pathExists(tsconfigPath);
-  const { register } = await import('node:module');
-  if (hasTsNode && hasTsconfig) {
-    // These can be overridden by ts-node options in tsconfig.json
-    process.env.TS_NODE_TRANSPILE_ONLY = true;
-    process.env.TS_NODE_PROJECT = tsconfigPath;
-    process.env.TS_NODE_SCOPE = true;
-    process.env.TS_NODE_FILES = true;
-    process.env.TS_NODE_IGNORE = `(?:^|/)node_modules/,(?:^|/)${path.relative(
-      appDir,
-      distDir,
-    )}/`;
-    register('./ts-node-loader.mjs', import.meta.url, {
-      data: {
-        appDir,
-        distDir,
-        alias,
-        tsconfigPath,
-      },
-    });
-  } else {
-    process.env.MODERN_NODE_LOADER = 'esbuild';
-    let tsConfig = {};
-    if (hasTsconfig) {
-      tsConfig = readTsConfigByFile(tsconfigPath);
+const registerEsm = async ({ appDir, distDir, alias })=>{
+    const nodeVersion = process.versions.node;
+    nodeVersion.split('.').map(Number);
+    node_assert(isVersionAtLeast1819(nodeVersion), `The node version of the esm project must be greater than 18.19.0, current version is ${nodeVersion}`);
+    const hasTsNode = await checkDep('ts-node');
+    const TS_CONFIG_FILENAME = "tsconfig.json";
+    const tsconfigPath = __rspack_external_node_path_c5b9b54f["default"].resolve(appDir, TS_CONFIG_FILENAME);
+    const hasTsconfig = await fs.pathExists(tsconfigPath);
+    const { register } = await import("node:module");
+    if (hasTsNode && hasTsconfig) {
+        process.env.TS_NODE_TRANSPILE_ONLY = true;
+        process.env.TS_NODE_PROJECT = tsconfigPath;
+        process.env.TS_NODE_SCOPE = true;
+        process.env.TS_NODE_FILES = true;
+        process.env.TS_NODE_IGNORE = `(?:^|/)node_modules/,(?:^|/)${__rspack_external_node_path_c5b9b54f["default"].relative(appDir, distDir)}/`;
+        register('./ts-node-loader.mjs', import.meta.url, {
+            data: {
+                appDir,
+                distDir,
+                alias,
+                tsconfigPath
+            }
+        });
+    } else {
+        process.env.MODERN_NODE_LOADER = 'esbuild';
+        if (hasTsconfig) readTsConfigByFile(tsconfigPath);
+        register('./esbuild-loader.mjs', import.meta.url, {
+            data: {
+                appDir,
+                distDir,
+                alias,
+                tsconfigPath
+            }
+        });
     }
-    register('./esbuild-loader.mjs', import.meta.url, {
-      data: {
-        appDir,
-        distDir,
-        alias,
-        tsconfigPath,
-      },
-    });
-  }
 };
+export { registerEsm };

package/dist/esm/esm/ts-node-loader.mjs

@@ -1,34 +1,22 @@
-import { pathToFileURL } from 'url';
-import { resolve as tsNodeResolve } from 'ts-node/esm';
-import { load as tsNodeLoad } from 'ts-node/esm';
-import { createMatchPath } from './utils.mjs';
-
+import { pathToFileURL } from "url";
+import { load, resolve } from "ts-node/esm";
+import { createMatchPath } from "./utils.mjs";
 let matchPath;
-export async function initialize({ appDir, alias, tsconfigPath }) {
-  matchPath = createMatchPath({
-    alias,
-    appDir,
-    tsconfigPath,
-  });
+async function initialize({ appDir, alias, tsconfigPath }) {
+    matchPath = createMatchPath({
+        alias,
+        appDir,
+        tsconfigPath
+    });
 }
-
-export function resolve(specifier, context, defaultResolve) {
-  const match = matchPath(specifier);
-  return match
-    ? tsNodeResolve(pathToFileURL(match).href, context, defaultResolve)
-    : tsNodeResolve(specifier, context, defaultResolve);
+function ts_node_loader_resolve(specifier, context, defaultResolve) {
+    const match = matchPath(specifier);
+    return match ? resolve(pathToFileURL(match).href, context, defaultResolve) : resolve(specifier, context, defaultResolve);
 }
-
-export function load(url, context, defaultLoad) {
-  const filePath = new URL(url).pathname;
-
-  if (url.startsWith('node:')) {
-    return defaultLoad(url, context);
-  }
-
-  if (filePath.includes('node_modules')) {
-    return defaultLoad(url, context);
-  }
-
-  return tsNodeLoad(url, context, defaultLoad);
+function ts_node_loader_load(url, context, defaultLoad) {
+    const filePath = new URL(url).pathname;
+    if (url.startsWith('node:')) return defaultLoad(url, context);
+    if (filePath.includes('node_modules')) return defaultLoad(url, context);
+    return load(url, context, defaultLoad);
 }
+export { initialize, ts_node_loader_load as load, ts_node_loader_resolve as resolve };

package/dist/esm/esm/utils.mjs

@@ -1,43 +1,32 @@
-import { createRequire } from 'module';
-import path from 'path';
-import { getAliasConfig } from '@modern-js/utils';
-import tsConfigPaths from '@modern-js/utils/tsconfig-paths';
-
-const require = createRequire(import.meta.url);
-export function createMatchPath({ alias, appDir, tsconfigPath }) {
-  const aliasConfig = getAliasConfig(alias, {
-    appDirectory: appDir,
-    tsconfigPath,
-  });
-
-  const { paths = {}, absoluteBaseUrl = './' } = aliasConfig;
-
-  const tsPaths = Object.keys(paths).reduce((o, key) => {
-    let tsPath = paths[key];
-    // Do some special handling for Modern.js's internal alias, we can drop it in the next version
-    if (
-      typeof tsPath === 'string' &&
-      key.startsWith('@') &&
-      tsPath.startsWith('@')
-    ) {
-      try {
-        tsPath = require.resolve(tsPath, {
-          paths: [appDir],
-        });
-      } catch {}
-    }
-
-    if (typeof tsPath === 'string' && path.isAbsolute(tsPath)) {
-      tsPath = path.relative(absoluteBaseUrl, tsPath);
-    }
-    if (typeof tsPath === 'string') {
-      tsPath = [tsPath];
-    }
-    return {
-      ...o,
-      [`${key}`]: tsPath,
-    };
-  }, {});
-
-  return tsConfigPaths.createMatchPath(absoluteBaseUrl, tsPaths);
+import { createRequire } from "module";
+import path from "path";
+import { getAliasConfig } from "@modern-js/utils";
+import tsconfig_paths from "@modern-js/utils/tsconfig-paths";
+const utils_require = createRequire(import.meta.url);
+function createMatchPath({ alias, appDir, tsconfigPath }) {
+    const aliasConfig = getAliasConfig(alias, {
+        appDirectory: appDir,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasConfig;
+    const tsPaths = Object.keys(paths).reduce((o, key)=>{
+        let tsPath = paths[key];
+        if ('string' == typeof tsPath && key.startsWith('@') && tsPath.startsWith('@')) try {
+            tsPath = utils_require.resolve(tsPath, {
+                paths: [
+                    appDir
+                ]
+            });
+        } catch  {}
+        if ('string' == typeof tsPath && path.isAbsolute(tsPath)) tsPath = path.relative(absoluteBaseUrl, tsPath);
+        if ('string' == typeof tsPath) tsPath = [
+            tsPath
+        ];
+        return {
+            ...o,
+            [`${key}`]: tsPath
+        };
+    }, {});
+    return tsconfig_paths.createMatchPath(absoluteBaseUrl, tsPaths);
 }
+export { createMatchPath };

package/dist/esm/index.mjs

@@ -0,0 +1,121 @@
+import path from "path";
+import { castArray } from "@modern-js/builder";
+import { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
+import { createAsyncHook } from "@modern-js/plugin";
+import { cleanRequireCache, deprecatedCommands, emptyDir, getArgv, getCommand } from "@modern-js/utils";
+import { buildCommand, deployCommand, devCommand, inspectCommand, serverCommand } from "./commands";
+import { compatPlugin } from "./compat";
+import { DEFAULT_RUNTIME_CONFIG_FILE } from "./constants";
+import { i18n } from "./locale";
+import analyze from "./plugins/analyze";
+import deploy from "./plugins/deploy";
+import initialize from "./plugins/initialize";
+import serverBuild from "./plugins/serverBuild";
+import serverRuntime from "./plugins/serverRuntime";
+import { generateWatchFiles } from "./utils/generateWatchFiles";
+import { initAppContext } from "./utils/initAppContext";
+import { restart } from "./utils/restart";
+import { defineConfig } from "./defineConfig";
+import { dev } from "./commands/dev";
+import { serve } from "./commands/serve";
+import { mergeConfig } from "@modern-js/plugin/cli";
+export * from "./defineConfig";
+export * from "./types";
+const appTools = ()=>({
+        name: '@modern-js/app-tools',
+        usePlugins: [
+            serverRuntime(),
+            compatPlugin(),
+            initialize(),
+            analyze(),
+            serverBuild(),
+            deploy()
+        ],
+        post: [
+            '@modern-js/plugin-initialize',
+            '@modern-js/plugin-analyze',
+            '@modern-js/plugin-ssr',
+            '@modern-js/plugin-document',
+            '@modern-js/plugin-router',
+            '@modern-js/plugin-polyfill'
+        ],
+        registryHooks: {
+            onAfterPrepare: createAsyncHook(),
+            deploy: createAsyncHook(),
+            checkEntryPoint: createAsyncHook(),
+            modifyEntrypoints: createAsyncHook(),
+            modifyFileSystemRoutes: createAsyncHook(),
+            generateEntryCode: createAsyncHook(),
+            onBeforeGenerateRoutes: createAsyncHook(),
+            onBeforePrintInstructions: createAsyncHook()
+        },
+        setup: (api)=>{
+            const context = api.getAppContext();
+            const userConfig = api.getConfig();
+            const locale = getLocaleLanguage();
+            i18n.changeLanguage({
+                locale
+            });
+            api.updateAppContext(initAppContext({
+                metaName: context.metaName,
+                appDirectory: context.appDirectory,
+                runtimeConfigFile: DEFAULT_RUNTIME_CONFIG_FILE,
+                tempDir: userConfig.output?.tempDir
+            }));
+            api.addCommand(async ({ program })=>{
+                await devCommand(program, api);
+                await buildCommand(program, api);
+                serverCommand(program, api);
+                deployCommand(program, api);
+                inspectCommand(program, api);
+                deprecatedCommands(program);
+            });
+            api.onPrepare(async ()=>{
+                const command = getCommand();
+                if ('deploy' === command) {
+                    const isSkipBuild = [
+                        '-s',
+                        '--skip-build'
+                    ].some((tag)=>getArgv().includes(tag));
+                    if (isSkipBuild) return;
+                }
+                if ('dev' === command || 'start' === command || 'build' === command || 'deploy' === command) {
+                    const resolvedConfig = api.getNormalizedConfig();
+                    if (resolvedConfig.output.cleanDistPath) {
+                        const appContext = api.getAppContext();
+                        await emptyDir(appContext.distDirectory);
+                    }
+                }
+            });
+            api.addWatchFiles(async ()=>{
+                const appContext = api.getAppContext();
+                const config = api.getNormalizedConfig();
+                const files = await generateWatchFiles(appContext, config.source.configDir);
+                const watchFiles = castArray(config.dev.watchFiles);
+                watchFiles.forEach(({ type, paths })=>{
+                    if ('reload-server' === type) files.push(...Array.isArray(paths) ? paths : [
+                        paths
+                    ]);
+                });
+                return files;
+            });
+            api.onFileChanged(async (e)=>{
+                const { filename, eventType, isPrivate } = e;
+                const { appDirectory, apiDirectory } = api.getAppContext();
+                const relativeApiPath = path.relative(appDirectory, apiDirectory);
+                const isApiProject = filename.startsWith(`${relativeApiPath}/`);
+                if (!isPrivate && ('change' === eventType || 'unlink' === eventType) && !isApiProject) {
+                    const { closeServer } = await import("./utils/createServer.js");
+                    await closeServer();
+                    await restart(api.getHooks(), filename);
+                }
+            });
+            api.onBeforeRestart(()=>{
+                cleanRequireCache([
+                    require.resolve('./plugins/analyze')
+                ]);
+            });
+        }
+    });
+const src = appTools;
+export { appTools, src as default, defineConfig, dev, generateWatchFiles, initAppContext, mergeConfig, serve };

package/dist/esm/locale/en.mjs

@@ -0,0 +1,42 @@
+const EN_LOCALE = {
+    command: {
+        shared: {
+            analyze: 'analyze bundle size',
+            config: 'specify the configuration file, which can be a relative or absolute path',
+            skipBuild: 'skip the build phase',
+            noNeedInstall: 'not run install command'
+        },
+        dev: {
+            describe: 'starting the dev server',
+            entry: 'compiler by entry',
+            apiOnly: 'start api server only',
+            webOnly: 'start web server only',
+            selectEntry: 'Please select the entry that needs to be built',
+            requireEntry: 'You must choose at least one entry'
+        },
+        build: {
+            describe: 'build the app for production',
+            watch: 'turn on watch mode, watch for changes and rebuild'
+        },
+        serve: {
+            describe: 'preview the production build locally'
+        },
+        deploy: {
+            describe: 'deploy the application'
+        },
+        new: {
+            describe: 'enable optional features or add a new entry',
+            debug: 'using debug mode to log something',
+            config: 'set default generator config(json string)',
+            distTag: "use specified tag version for it's generator",
+            registry: 'set npm registry url to run npm command',
+            lang: 'set new command language(en or zh)'
+        },
+        inspect: {
+            env: 'specify env mode',
+            output: 'specify inspect content output path',
+            verbose: 'show full function definitions in output'
+        }
+    }
+};
+export { EN_LOCALE };

package/dist/esm/locale/index.mjs

@@ -0,0 +1,9 @@
+import { I18n } from "@modern-js/i18n-utils";
+import { EN_LOCALE } from "./en";
+import { ZH_LOCALE } from "./zh";
+const i18n = new I18n();
+const localeKeys = i18n.init('en', {
+    zh: ZH_LOCALE,
+    en: EN_LOCALE
+});
+export { i18n, localeKeys };

package/dist/esm/locale/zh.mjs

@@ -0,0 +1,42 @@
+const ZH_LOCALE = {
+    command: {
+        shared: {
+            analyze: '分析构建产物体积，查看各个模块打包后的大小',
+            config: '指定配置文件路径，可以为相对路径或绝对路径',
+            skipBuild: '跳过构建阶段',
+            noNeedInstall: '无需安装依赖'
+        },
+        dev: {
+            describe: '启动开发服务器',
+            entry: '指定入口，编译特定的页面',
+            apiOnly: '仅启动 API 接口服务',
+            webOnly: '仅启动 Web 服务',
+            selectEntry: '请选择需要构建的入口',
+            requireEntry: '请至少选择一个入口'
+        },
+        build: {
+            describe: '构建生产环境产物',
+            watch: '开启 watch 模式, 监听文件变更并重新构建'
+        },
+        serve: {
+            describe: '启动生产环境服务'
+        },
+        deploy: {
+            describe: '部署应用'
+        },
+        new: {
+            describe: 'Web App 项目中执行生成器',
+            debug: '开启 Debug 模式，打印调试日志信息',
+            config: '生成器运行默认配置(JSON 字符串)',
+            distTag: '生成器使用特殊的 npm Tag 版本',
+            registry: '生成器运行过程中定制 npm Registry',
+            lang: '设置 new 命令执行语言(zh 或者 en)'
+        },
+        inspect: {
+            env: '查看指定环境下的配置',
+            output: '指定在 dist 目录下输出的路径',
+            verbose: '在结果中展示函数的完整内容'
+        }
+    }
+};
+export { ZH_LOCALE };

package/dist/esm/plugins/analyze/constants.mjs

@@ -0,0 +1,8 @@
+const ENTRY_FILE_NAME = 'entry';
+const HTML_PARTIALS_FOLDER = 'html';
+const HTML_PARTIALS_EXTENSIONS = [
+    '.htm',
+    '.html',
+    '.ejs'
+];
+export { ENTRY_FILE_NAME, HTML_PARTIALS_EXTENSIONS, HTML_PARTIALS_FOLDER };

package/dist/esm/plugins/analyze/getBundleEntry.mjs

@@ -0,0 +1,53 @@
+import path from "path";
+import { JS_EXTENSIONS, MAIN_ENTRY_NAME, ensureAbsolutePath, findExists, fs } from "@modern-js/utils";
+import { getFileSystemEntry, hasEntry, hasServerEntry } from "./getFileSystemEntry";
+import { isSubDirOrEqual } from "./utils";
+const ensureExtensions = (file)=>{
+    if (!path.extname(file)) return findExists(JS_EXTENSIONS.map((ext)=>`${file}${ext}`)) || file;
+    return file;
+};
+const isDirectory = (file)=>!path.extname(file);
+const ifAlreadyExists = (entrypoints, checked)=>entrypoints.some((entrypoint)=>{
+        if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
+            checked.entryName = entrypoint.entryName;
+            return true;
+        }
+        if (isSubDirOrEqual(entrypoint.entry, checked.entry) || isSubDirOrEqual(checked.entry, entrypoint.entry)) throw new Error(`Entry configuration conflicts\n Your configuration: ${checked.entry}.\n Default entrypoint: ${entrypoint.entry}\n Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules.`);
+        return false;
+    });
+const getBundleEntry = async (hooks, appContext, config)=>{
+    const { appDirectory, packageName } = appContext;
+    const { disableDefaultEntries, entries, entriesDir, mainEntryName } = config.source;
+    const defaults = disableDefaultEntries ? [] : await getFileSystemEntry(hooks, appContext, config);
+    if (entries) Object.keys(entries).forEach((name)=>{
+        const value = entries[name];
+        const entryName = 'string' == typeof value ? value : value.entry;
+        const entryFile = ensureAbsolutePath(appDirectory, entryName);
+        const entryDir = path.dirname(entryFile);
+        const customEntryFile = hasEntry(entryDir);
+        const serverEntryFile = hasServerEntry(entryDir);
+        const isAutoMount = 'string' == typeof value ? true : !value.disableMount;
+        const entrypoint = {
+            entryName: name,
+            isMainEntry: false,
+            entry: 'string' == typeof value ? entryFile : value.customEntry ? customEntryFile || entryFile : entryFile,
+            absoluteEntryDir: isDirectory(entryFile) ? entryFile : path.dirname(entryFile),
+            isAutoMount,
+            fileSystemRoutes: fs.statSync(entryFile).isDirectory() ? {} : void 0,
+            isCustomSourceEntry: true,
+            customEntry: 'string' == typeof value ? false : value.customEntry,
+            customServerEntry: 'string' == typeof value ? false : value.customEntry ? serverEntryFile : false
+        };
+        if (!ifAlreadyExists(defaults, entrypoint)) defaults.push(entrypoint);
+    });
+    if (!disableDefaultEntries) {
+        const entriesDirAbs = ensureAbsolutePath(appDirectory, entriesDir || '');
+        const found = defaults.find(({ entryName, entry, nestedRoutesEntry = '' })=>entryName === packageName || path.dirname(entry) === entriesDirAbs || path.dirname(nestedRoutesEntry) === entriesDirAbs);
+        if (found) {
+            found.entryName = mainEntryName || MAIN_ENTRY_NAME;
+            found.isMainEntry = true;
+        }
+    }
+    return defaults;
+};
+export { getBundleEntry };

package/dist/esm/plugins/analyze/getFileSystemEntry.mjs

@@ -0,0 +1,66 @@
+import fs from "fs";
+import path from "path";
+import { JS_EXTENSIONS, ensureAbsolutePath, findExists } from "@modern-js/utils";
+import { ENTRY_FILE_NAME } from "./constants";
+const hasEntry = (dir)=>findExists(JS_EXTENSIONS.map((ext)=>path.resolve(dir, `${ENTRY_FILE_NAME}${ext}`)));
+const hasServerEntry = (dir)=>findExists(JS_EXTENSIONS.map((ext)=>path.resolve(dir, `${ENTRY_FILE_NAME}.server${ext}`)));
+const isBundleEntry = async (hooks, dir)=>{
+    const { entry } = await hooks.checkEntryPoint.call({
+        path: dir,
+        entry: false
+    });
+    if (entry) return entry;
+    const customEntry = hasEntry(dir);
+    if (customEntry) return customEntry;
+    return false;
+};
+const scanDir = async (hooks, dirs)=>{
+    const entries = await Promise.all(dirs.map(async (dir)=>{
+        const entryName = path.basename(dir);
+        const customEntryFile = hasEntry(dir);
+        const customServerEntry = hasServerEntry(dir);
+        const entryFile = (await hooks.checkEntryPoint.call({
+            path: dir,
+            entry: false
+        })).entry;
+        if (entryFile) return {
+            entryName,
+            isMainEntry: false,
+            entry: customEntryFile || entryFile,
+            customServerEntry,
+            absoluteEntryDir: path.resolve(dir),
+            isAutoMount: true,
+            customEntry: Boolean(customEntryFile)
+        };
+        if (customEntryFile) return {
+            entryName,
+            isMainEntry: false,
+            entry: customEntryFile,
+            customServerEntry,
+            absoluteEntryDir: path.resolve(dir),
+            isAutoMount: false,
+            customEntry: Boolean(customEntryFile)
+        };
+        return false;
+    })).then((entries)=>entries.filter(Boolean));
+    if (0 === entries.length) throw Error('There is no valid entry point in the current project!');
+    return entries;
+};
+const getFileSystemEntry = async (hooks, appContext, config)=>{
+    const { appDirectory } = appContext;
+    const { source: { entriesDir } } = config;
+    const src = ensureAbsolutePath(appDirectory, entriesDir || '');
+    if (fs.existsSync(src)) if (fs.statSync(src).isDirectory()) {
+        if (await isBundleEntry(hooks, src)) return scanDir(hooks, [
+            src
+        ]);
+        const dirs = [];
+        await Promise.all(fs.readdirSync(src).map(async (filename)=>{
+            const file = path.join(src, filename);
+            if (fs.statSync(file).isDirectory() && await isBundleEntry(hooks, file)) dirs.push(file);
+        }));
+        return scanDir(hooks, dirs);
+    } else throw Error("source.entriesDir accept a directory.");
+    throw Error(`src dir ${entriesDir} not found.`);
+};
+export { getFileSystemEntry, hasEntry, hasServerEntry };