@modern-js/app-tools 2.58.3 → 2.59.0

package/dist/esm-node/config/legacy/index.js

@@ -0,0 +1,43 @@
+import { createHtmlConfig } from "./createHtmlConfig";
+import { createOutputConfig } from "./createOutputConfig";
+import { createSourceConfig } from "./createSourceConfig";
+import { createToolsConfig } from "./createToolsConfig";
+function transformNormalizedConfig(config) {
+  const html = createHtmlConfig(config);
+  const output = createOutputConfig(config);
+  const source = createSourceConfig(config);
+  const tools = createToolsConfig(config);
+  const { bff, dev, deploy, runtime, runtimeByEntries, server, cliOptions, plugins, testing, autoLoadPlugins } = config;
+  return {
+    source,
+    html,
+    output,
+    tools,
+    bff,
+    dev,
+    deploy,
+    runtime,
+    runtimeByEntries,
+    server,
+    cliOptions,
+    testing,
+    devtools: {},
+    builderPlugins: [],
+    plugins,
+    security: {},
+    _raw: {},
+    experiments: {},
+    environments: {},
+    autoLoadPlugins,
+    performance: {
+      removeMomentLocale: true
+    }
+  };
+}
+function checkIsLegacyConfig(config) {
+  return Boolean(config.legacy);
+}
+export {
+  checkIsLegacyConfig,
+  transformNormalizedConfig
+};

package/dist/esm-node/defineConfig.js

@@ -0,0 +1,13 @@
+const defineConfig = (config) => config;
+const defineLegacyConfig = (config) => {
+  var _config_autoLoadPlugins;
+  return {
+    ...config,
+    legacy: true,
+    autoLoadPlugins: (_config_autoLoadPlugins = config.autoLoadPlugins) !== null && _config_autoLoadPlugins !== void 0 ? _config_autoLoadPlugins : true
+  };
+};
+export {
+  defineConfig,
+  defineLegacyConfig
+};

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

@@ -0,0 +1,20 @@
+import { pathToFileURL } from 'url';
+import { createMatchPath } from './utils.mjs';
+
+let matchPath;
+export 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);
+}
+
+export { load } from 'esbuild-register/loader';

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

@@ -0,0 +1,66 @@
+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;
+  }
+};
+
+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 esbuildRegister = await import('esbuild-register/dist/node');
+    esbuildRegister.register({
+      tsconfigRaw: hasTsconfig ? tsConfig : undefined,
+      hookIgnoreNodeModules: true,
+      hookMatcher: fileName => !fileName.startsWith(distDir),
+    });
+    register('./esbuild-loader.mjs', import.meta.url, {
+      data: {
+        appDir,
+        distDir,
+        alias,
+        tsconfigPath,
+      },
+    });
+  }
+};

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

@@ -0,0 +1,21 @@
+import { pathToFileURL } from 'url';
+import { resolve as tsNodeResolve } from 'ts-node/esm';
+import { createMatchPath } from './utils.mjs';
+
+let matchPath;
+export 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);
+}
+
+export { transformSource, load } from 'ts-node/esm';

package/dist/esm-node/esm/utils.mjs

@@ -0,0 +1,43 @@
+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);
+}

package/dist/esm-node/exports/server.js

@@ -0,0 +1,4 @@
+import { defineServerConfig } from "../utils/config";
+export {
+  defineServerConfig as defineConfig
+};

package/dist/esm-node/hooks.js

@@ -0,0 +1,34 @@
+import { createAsyncWaterfall, createAsyncWorkflow, createParallelWorkflow } from "@modern-js/plugin";
+const hooks = {
+  _internalRuntimePlugins: createAsyncWaterfall(),
+  modifyFileSystemRoutes: createAsyncWaterfall(),
+  modifyServerRoutes: createAsyncWaterfall(),
+  /** add entry point info to entrypoints array */
+  modifyEntrypoints: createAsyncWaterfall(),
+  /** add entry type */
+  checkEntryPoint: createAsyncWaterfall(),
+  generateEntryCode: createAsyncWorkflow(),
+  htmlPartials: createAsyncWaterfall(),
+  beforeGenerateRoutes: createAsyncWaterfall(),
+  addDefineTypes: createAsyncWaterfall(),
+  collectServerPlugins: createAsyncWaterfall(),
+  _internalServerPlugins: createAsyncWaterfall(),
+  beforeDev: createAsyncWorkflow(),
+  afterDev: createAsyncWorkflow(),
+  beforeCreateCompiler: createAsyncWorkflow(),
+  afterCreateCompiler: createAsyncWorkflow(),
+  beforePrintInstructions: createAsyncWaterfall(),
+  beforeBuild: createAsyncWorkflow(),
+  afterBuild: createAsyncWorkflow(),
+  beforeDeploy: createAsyncWorkflow(),
+  deploy: createAsyncWorkflow(),
+  afterDeploy: createAsyncWorkflow(),
+  beforeRestart: createAsyncWorkflow(),
+  registerDev: createParallelWorkflow(),
+  beforeDevTask: createParallelWorkflow(),
+  registerBuildPlatform: createParallelWorkflow(),
+  beforeBuildPlatform: createParallelWorkflow()
+};
+export {
+  hooks
+};

package/dist/esm-node/index.js

@@ -0,0 +1,131 @@
+import path from "path";
+import { getLocaleLanguage } from "@modern-js/plugin-i18n/language-detector";
+import { lintPlugin } from "@modern-js/plugin-lint";
+import { cleanRequireCache, emptyDir, getArgv, getCommand } from "@modern-js/utils";
+import { hooks } from "./hooks";
+import { i18n } from "./locale";
+import analyzePlugin from "./plugins/analyze";
+import deployPlugin from "./plugins/deploy";
+import initializePlugin from "./plugins/initialize";
+import serverBuildPlugin from "./plugins/serverBuild";
+import { buildCommand, deployCommand, devCommand, inspectCommand, newCommand, serverCommand, upgradeCommand } from "./commands";
+import { generateWatchFiles } from "./utils/generateWatchFiles";
+import { restart } from "./utils/restart";
+import { dev } from "./commands/dev";
+import { mergeConfig } from "@modern-js/core";
+export * from "./defineConfig";
+export * from "./types";
+const appTools = (options = {
+  // default webpack to be compatible with original projects
+  bundler: "webpack"
+}) => ({
+  name: "@modern-js/app-tools",
+  post: [
+    "@modern-js/plugin-initialize",
+    "@modern-js/plugin-analyze",
+    "@modern-js/plugin-ssr",
+    "@modern-js/plugin-document",
+    "@modern-js/plugin-state",
+    "@modern-js/plugin-router",
+    "@modern-js/plugin-router-v5",
+    "@modern-js/plugin-polyfill"
+  ],
+  registerHook: hooks,
+  usePlugins: [
+    initializePlugin({
+      bundler: (options === null || options === void 0 ? void 0 : options.bundler) && [
+        "rspack",
+        "experimental-rspack"
+      ].includes(options.bundler) ? "rspack" : "webpack"
+    }),
+    analyzePlugin({
+      bundler: (options === null || options === void 0 ? void 0 : options.bundler) && [
+        "rspack",
+        "experimental-rspack"
+      ].includes(options.bundler) ? "rspack" : "webpack"
+    }),
+    serverBuildPlugin(),
+    lintPlugin(),
+    deployPlugin()
+  ],
+  setup: (api) => {
+    const appContext = api.useAppContext();
+    api.setAppContext({
+      ...appContext,
+      toolsType: "app-tools"
+    });
+    const locale = getLocaleLanguage();
+    i18n.changeLanguage({
+      locale
+    });
+    return {
+      async beforeConfig() {
+        var _userConfig_output;
+        const userConfig = api.useConfigContext();
+        const appContext2 = api.useAppContext();
+        if ((_userConfig_output = userConfig.output) === null || _userConfig_output === void 0 ? void 0 : _userConfig_output.tempDir) {
+          api.setAppContext({
+            ...appContext2,
+            internalDirectory: path.resolve(appContext2.appDirectory, userConfig.output.tempDir)
+          });
+        }
+      },
+      async commands({ program }) {
+        await devCommand(program, api);
+        await buildCommand(program, api);
+        serverCommand(program, api);
+        deployCommand(program, api);
+        newCommand(program, locale);
+        inspectCommand(program, api);
+        upgradeCommand(program);
+      },
+      async prepare() {
+        const command = getCommand();
+        if (command === "deploy") {
+          const isSkipBuild = [
+            "-s",
+            "--skip-build"
+          ].some((tag) => {
+            return getArgv().includes(tag);
+          });
+          if (isSkipBuild) {
+            return;
+          }
+        }
+        if (command === "dev" || command === "start" || command === "build" || command === "deploy") {
+          const resolvedConfig = api.useResolvedConfigContext();
+          if (resolvedConfig.output.cleanDistPath) {
+            const appContext2 = api.useAppContext();
+            await emptyDir(appContext2.distDirectory);
+          }
+        }
+      },
+      async watchFiles() {
+        const appContext2 = api.useAppContext();
+        const config = api.useResolvedConfigContext();
+        return await generateWatchFiles(appContext2, config.source.configDir);
+      },
+      // 这里会被 core/initWatcher 监听的文件变动触发，如果是 src 目录下的文件变动，则不做 restart
+      async fileChange(e) {
+        const { filename, eventType, isPrivate } = e;
+        if (!isPrivate && (eventType === "change" || eventType === "unlink")) {
+          const { closeServer } = await import("./utils/createServer.js");
+          await closeServer();
+          await restart(api.useHookRunners(), filename);
+        }
+      },
+      async beforeRestart() {
+        cleanRequireCache([
+          require.resolve("./plugins/analyze")
+        ]);
+      }
+    };
+  }
+});
+var src_default = appTools;
+export {
+  appTools,
+  src_default as default,
+  dev,
+  mergeConfig
+};

package/dist/esm-node/locale/en.js

@@ -0,0 +1,43 @@
+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"
+    },
+    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-node/locale/index.js

@@ -0,0 +1,12 @@
+import { I18n } from "@modern-js/plugin-i18n";
+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-node/locale/zh.js

@@ -0,0 +1,43 @@
+const ZH_LOCALE = {
+  command: {
+    shared: {
+      analyze: "分析构建产物体积，查看各个模块打包后的大小",
+      config: "指定配置文件路径，可以为相对路径或绝对路径",
+      skipBuild: "跳过构建阶段",
+      noNeedInstall: "无需安装依赖"
+    },
+    dev: {
+      describe: "启动开发服务器",
+      entry: "指定入口，编译特定的页面",
+      apiOnly: "仅启动 API 接口服务",
+      webOnly: "仅启动 Web 服务",
+      selectEntry: "请选择需要构建的入口",
+      requireEntry: "请至少选择一个入口"
+    },
+    build: {
+      describe: "构建生产环境产物"
+    },
+    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-node/plugins/analyze/constants.js

@@ -0,0 +1,14 @@
+const INDEX_FILE_NAME = "index";
+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,
+  INDEX_FILE_NAME
+};

package/dist/esm-node/plugins/analyze/getBundleEntry.js

@@ -0,0 +1,61 @@
+import path from "path";
+import { fs, JS_EXTENSIONS, MAIN_ENTRY_NAME, ensureAbsolutePath, findExists } from "@modern-js/utils";
+import { getFileSystemEntry } 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
+ Your configuration: ${checked.entry}.
+ Default entrypoint: ${entrypoint.entry}
+ Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules.`);
+  }
+  return false;
+});
+const getBundleEntry = async (hookRunners, appContext, config) => {
+  const { appDirectory, packageName } = appContext;
+  const { disableDefaultEntries, entries, entriesDir, mainEntryName } = config.source;
+  const defaults = disableDefaultEntries ? [] : await getFileSystemEntry(hookRunners, appContext, config);
+  if (entries) {
+    Object.keys(entries).forEach((name) => {
+      const value = entries[name];
+      const entryName = typeof value === "string" ? value : value.entry;
+      const isAutoMount = typeof value === "string" ? true : !value.disableMount;
+      const entrypoint = {
+        entryName: name,
+        isMainEntry: false,
+        entry: ensureAbsolutePath(appDirectory, entryName),
+        absoluteEntryDir: isDirectory(ensureAbsolutePath(appDirectory, entryName)) ? ensureAbsolutePath(appDirectory, entryName) : path.dirname(ensureAbsolutePath(appDirectory, entryName)),
+        isAutoMount,
+        customBootstrap: typeof value === "string" ? false : value.customBootstrap && ensureAbsolutePath(appDirectory, value.customBootstrap),
+        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, entryName)).isDirectory() ? {} : void 0,
+        isCustomSourceEntry: true
+      };
+      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-node/plugins/analyze/getFileSystemEntry.js

@@ -0,0 +1,106 @@
+import fs from "fs";
+import path from "path";
+import { JS_EXTENSIONS, ensureAbsolutePath, findExists } from "@modern-js/utils";
+import { ENTRY_FILE_NAME, INDEX_FILE_NAME } from "./constants";
+import { isDefaultExportFunction } from "./isDefaultExportFunction";
+const hasIndex = (dir) => findExists(JS_EXTENSIONS.map((ext) => path.resolve(dir, `${INDEX_FILE_NAME}${ext}`)));
+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 (hookRunners, dir, enableCustomEntry) => {
+  const { entry } = await hookRunners.checkEntryPoint({
+    path: dir,
+    entry: false
+  });
+  if (entry) {
+    return entry;
+  }
+  const customEntry = hasEntry(dir);
+  if (enableCustomEntry && customEntry) {
+    return customEntry;
+  }
+  return hasIndex(dir);
+};
+const scanDir = async (hookRunners, dirs, enableCustomEntry) => {
+  const entries = await Promise.all(dirs.map(async (dir) => {
+    const indexFile = hasIndex(dir);
+    const customBootstrap = isDefaultExportFunction(indexFile) ? indexFile : false;
+    const entryName = path.basename(dir);
+    const customEntryFile = hasEntry(dir);
+    const customServerEntry = hasServerEntry(dir);
+    if (indexFile && !customBootstrap) {
+      return {
+        entryName,
+        isMainEntry: false,
+        entry: indexFile,
+        absoluteEntryDir: path.resolve(dir),
+        isAutoMount: false,
+        customBootstrap
+      };
+    }
+    const entryFile = (await hookRunners.checkEntryPoint({
+      path: dir,
+      entry: false
+    })).entry;
+    if (entryFile) {
+      return {
+        entryName,
+        isMainEntry: false,
+        entry: enableCustomEntry ? customEntryFile || entryFile : entryFile,
+        customServerEntry,
+        absoluteEntryDir: path.resolve(dir),
+        isAutoMount: true,
+        customBootstrap,
+        customEntry: enableCustomEntry ? Boolean(customEntryFile) : false
+      };
+    }
+    if (enableCustomEntry && customEntryFile) {
+      return {
+        entryName,
+        isMainEntry: false,
+        entry: customEntryFile,
+        customServerEntry,
+        absoluteEntryDir: path.resolve(dir),
+        isAutoMount: false,
+        customEntry: Boolean(customEntryFile)
+      };
+    }
+    return false;
+  })).then((entries2) => entries2.filter(Boolean));
+  if (entries.length === 0) {
+    throw Error("There is no valid entry point in the current project!");
+  }
+  return entries;
+};
+const getFileSystemEntry = async (hookRunners, appContext, config) => {
+  const { appDirectory } = appContext;
+  const { source: { entriesDir, disableEntryDirs, enableCustomEntry } } = config;
+  let disabledDirs = [];
+  if (disableEntryDirs && Array.isArray(disableEntryDirs)) {
+    disabledDirs = disableEntryDirs === null || disableEntryDirs === void 0 ? void 0 : disableEntryDirs.map((dir) => ensureAbsolutePath(appDirectory, dir));
+  }
+  const src = ensureAbsolutePath(appDirectory, entriesDir || "");
+  if (fs.existsSync(src)) {
+    if (fs.statSync(src).isDirectory()) {
+      if (await isBundleEntry(hookRunners, src, enableCustomEntry)) {
+        return scanDir(hookRunners, [
+          src
+        ], enableCustomEntry);
+      }
+      const dirs = [];
+      await Promise.all(fs.readdirSync(src).map(async (filename) => {
+        const file = path.join(src, filename);
+        if (fs.statSync(file).isDirectory() && await isBundleEntry(hookRunners, file, enableCustomEntry) && !disabledDirs.includes(file)) {
+          dirs.push(file);
+        }
+      }));
+      return scanDir(hookRunners, dirs, enableCustomEntry);
+    } else {
+      throw Error(`source.entriesDir accept a directory.`);
+    }
+  } else {
+    throw Error(`src dir ${entriesDir} not found.`);
+  }
+};
+export {
+  getFileSystemEntry
+};