@modern-js/app-tools 1.21.5 → 2.0.0-beta.1

package/dist/js/treeshaking/analyze/getBundleEntry.js

@@ -0,0 +1,69 @@
+import path from 'path';
+import { ensureAbsolutePath, fs, findExists, MAIN_ENTRY_NAME } from '@modern-js/utils';
+import { getFileSystemEntry } from "./getFileSystemEntry";
+import { JS_EXTENSIONS } from "./constants";
+var ensureExtensions = function ensureExtensions(file) {
+  if (!path.extname(file)) {
+    return findExists(JS_EXTENSIONS.map(function (ext) {
+      return "".concat(file).concat(ext);
+    })) || file;
+  }
+  return file;
+};
+var ifAlreadyExists = function ifAlreadyExists(entrypoints, checked) {
+  return entrypoints.some(function (entrypoint) {
+    if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
+      // reset entryName
+      checked.entryName = entrypoint.entryName;
+      return true;
+    }
+    // filesystem routes entrypoint conflict with normal entrypoint.
+    if (entrypoint.entry.startsWith(checked.entry) || checked.entry.startsWith(entrypoint.entry)) {
+      throw new Error("Entry configuration conflicts\n Your configuration: ".concat(checked.entry, ".\n Default entrypoint: ").concat(entrypoint.entry, "\n Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules."));
+    }
+    return false;
+  });
+};
+export var getBundleEntry = function getBundleEntry(appContext, config) {
+  var appDirectory = appContext.appDirectory,
+    packageName = appContext.packageName;
+  var _config$source = config.source,
+    disableDefaultEntries = _config$source.disableDefaultEntries,
+    entries = _config$source.entries,
+    entriesDir = _config$source.entriesDir;
+  var defaults = disableDefaultEntries ? [] : getFileSystemEntry(appContext, config);
+
+  // merge entrypoints from user config with directory convention.
+  if (entries) {
+    Object.keys(entries).forEach(function (name) {
+      var value = entries[name];
+      var entrypoint = typeof value === 'string' ? {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value),
+        isAutoMount: true,
+        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, value)).isDirectory() ? {} : undefined
+      } : {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value.entry),
+        isAutoMount: !value.disableMount,
+        fileSystemRoutes: value.enableFileSystemRoutes ? {} : undefined
+      };
+      if (!ifAlreadyExists(defaults, entrypoint)) {
+        defaults.push(entrypoint);
+      }
+    });
+  }
+  if (!disableDefaultEntries) {
+    // find main entry point which server route is '/'.
+    var entriesDirAbs = ensureAbsolutePath(appDirectory, entriesDir);
+    var found = defaults.find(function (_ref) {
+      var entryName = _ref.entryName,
+        entry = _ref.entry,
+        _ref$nestedRoutesEntr = _ref.nestedRoutesEntry,
+        nestedRoutesEntry = _ref$nestedRoutesEntr === void 0 ? '' : _ref$nestedRoutesEntr;
+      return entryName === packageName || path.dirname(entry) === entriesDirAbs || path.dirname(nestedRoutesEntry) === entriesDirAbs;
+    });
+    found && (found.entryName = MAIN_ENTRY_NAME);
+  }
+  return defaults;
+};

package/dist/js/treeshaking/analyze/getClientRoutes/getRoutes.js

@@ -0,0 +1,184 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import path from 'path';
+import { fs } from '@modern-js/utils';
+import { makeLegalIdentifier } from "../makeLegalIdentifier";
+import { FILE_SYSTEM_ROUTES_COMPONENTS_DIR, FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP, FILE_SYSTEM_ROUTES_INDEX, FILE_SYSTEM_ROUTES_LAYOUT } from "../constants";
+import { replaceWithAlias } from "../utils";
+import { debug, findLayout, shouldSkip, getRouteWeight } from "./utils";
+var compName = function compName(srcDirectory, filePath) {
+  var legalCompName = makeLegalIdentifier(path.relative(srcDirectory, filePath));
+  return "Comp_".concat(legalCompName);
+};
+var layoutNameAbbr = function layoutNameAbbr(filePath) {
+  var prefix = 'L_';
+  var dirName = path.dirname(filePath).split('/').pop() || '';
+  return "".concat(prefix).concat(makeLegalIdentifier(dirName));
+};
+var parents = [];
+
+/* eslint-disable no-param-reassign */
+var recursiveReadDir = function recursiveReadDir(_ref) {
+  var dir = _ref.dir,
+    routes = _ref.routes,
+    _ref$basePath = _ref.basePath,
+    basePath = _ref$basePath === void 0 ? '/' : _ref$basePath,
+    srcDirectory = _ref.srcDirectory,
+    srcAlias = _ref.srcAlias;
+  var hasDynamicRoute = false;
+  var resetParent = false;
+  var parent = parents[parents.length - 1];
+  var layout = findLayout(dir);
+  if (layout) {
+    if (basePath === '/') {
+      throw new Error("should use _app instead of _layout in ".concat(dir));
+    } else {
+      var alias = replaceWithAlias(srcDirectory, layout, srcAlias);
+      var componentName = compName(srcDirectory, layout);
+      var route = {
+        path: "".concat(basePath.substring(0, basePath.length - 1)),
+        children: [],
+        _component: alias,
+        component: componentName,
+        parent: parent,
+        type: 'page'
+      };
+      parent = route;
+      resetParent = true;
+      routes.push(route);
+      parents.push(route);
+      routes = route.children;
+    }
+  }
+  var _iterator = _createForOfIteratorHelper(fs.readdirSync(dir)),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var relative = _step.value;
+      var filePath = path.join(dir, relative);
+      if (!shouldSkip(filePath)) {
+        var filename = path.basename(filePath, path.extname(filePath));
+        var _alias = replaceWithAlias(srcDirectory, filePath, srcAlias);
+        var _componentName = compName(srcDirectory, filePath);
+        var dynamicRouteMatched = FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP.exec(filename);
+        if (dynamicRouteMatched) {
+          if (hasDynamicRoute) {
+            throw new Error("Can't set two dynamic route in one directory: ".concat(dir));
+          } else {
+            hasDynamicRoute = true;
+          }
+        }
+        var _route = {
+          path: "".concat(basePath).concat(dynamicRouteMatched ? ":".concat(dynamicRouteMatched[1]).concat(dynamicRouteMatched[2]) : filename),
+          _component: _alias,
+          component: _componentName,
+          parent: parent,
+          type: 'page'
+        };
+        if (fs.statSync(filePath).isDirectory()) {
+          recursiveReadDir({
+            dir: filePath,
+            routes: routes,
+            basePath: "".concat(_route.path, "/"),
+            srcDirectory: srcDirectory,
+            srcAlias: srcAlias
+          });
+          continue;
+        }
+        if (filename === FILE_SYSTEM_ROUTES_LAYOUT) {
+          continue;
+        }
+        if (filename === FILE_SYSTEM_ROUTES_INDEX) {
+          _route.path = basePath === '/' ? basePath : "".concat(basePath.substring(0, basePath.length - 1));
+        }
+        if (filename === '404' && basePath === '/') {
+          _route.path = '*';
+        }
+        routes.push(_route);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (resetParent) {
+    parents.pop();
+  }
+};
+/* eslint-enable  no-param-reassign */
+
+var normalizeNestedRoutes = function normalizeNestedRoutes(nested, internalComponentsDir, internalDirectory, internalDirAlias) {
+  var flat = function flat(routes) {
+    return routes.reduce(function (memo, route) {
+      return memo.concat(Array.isArray(route.children) ? flat(route.children) : [route]);
+    }, []);
+  };
+  var generate = function generate(route) {
+    var codes = [];
+    var lastComponent = route.component;
+    var imports = ["import React from 'react';", "import ".concat(lastComponent, " from '").concat(route._component, "'")];
+
+    // eslint-disable-next-line no-param-reassign, no-cond-assign
+    while (route = route.parent) {
+      var layoutComponent = route.component;
+      var layoutComponentAbbr = layoutNameAbbr(route._component);
+      imports.push("import ".concat(layoutComponent, " from '").concat(route._component, "';"));
+      var currentComponent = "".concat(layoutComponentAbbr, "_").concat(lastComponent);
+      codes.push("const ".concat(currentComponent, " = props => <").concat(layoutComponent, " Component={").concat(lastComponent, "} {...props} />;"));
+      lastComponent = currentComponent;
+    }
+    var file = path.resolve(internalComponentsDir, "".concat(lastComponent, ".jsx"));
+    fs.outputFileSync(file, "".concat(imports.join('\n'), "\n").concat(codes.join('\n'), "\nexport default ").concat(lastComponent));
+    return {
+      component: lastComponent,
+      _component: replaceWithAlias(internalDirectory, file, internalDirAlias)
+    };
+  };
+  var normalized = flat(nested).map(function (route) {
+    return route.parent ? _objectSpread(_objectSpread(_objectSpread({}, route), generate(route)), {}, {
+      parent: undefined
+    }) : _objectSpread(_objectSpread({}, route), {}, {
+      parent: undefined
+    });
+  });
+  return normalized;
+};
+export var getClientRoutes = function getClientRoutes(_ref2) {
+  var entrypoint = _ref2.entrypoint,
+    srcDirectory = _ref2.srcDirectory,
+    srcAlias = _ref2.srcAlias,
+    internalDirectory = _ref2.internalDirectory,
+    internalDirAlias = _ref2.internalDirAlias;
+  var entry = entrypoint.entry,
+    entryName = entrypoint.entryName;
+  if (!fs.existsSync(entry)) {
+    throw new Error("generate file system routes error, ".concat(entry, " directory not found."));
+  }
+  if (!(fs.existsSync(entry) && fs.statSync(entry).isDirectory())) {
+    throw new Error("generate file system routes error, ".concat(entry, " should be directory."));
+  }
+  var routes = [];
+  recursiveReadDir({
+    dir: entry,
+    routes: routes,
+    basePath: '/',
+    srcDirectory: srcDirectory,
+    srcAlias: srcAlias
+  });
+  var internalComponentsDir = path.resolve(internalDirectory, "".concat(entryName, "/").concat(FILE_SYSTEM_ROUTES_COMPONENTS_DIR));
+  fs.emptyDirSync(internalComponentsDir);
+  routes = normalizeNestedRoutes(routes, internalComponentsDir, internalDirectory, internalDirAlias);
+  parents.length = 0;
+
+  // FIXME: support more situations
+  routes.sort(function (a, b) {
+    var delta = getRouteWeight(a.path) - getRouteWeight(b.path);
+    if (delta === 0) {
+      return a.path.length - b.path.length;
+    }
+    return delta;
+  });
+  debug("fileSystem routes: %o", routes);
+  return routes;
+};

package/dist/js/treeshaking/analyze/getClientRoutes/getRoutesLegacy.js

@@ -0,0 +1,185 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import path from 'path';
+import { fs } from '@modern-js/utils';
+import { makeLegalIdentifier } from "../makeLegalIdentifier";
+import { FILE_SYSTEM_ROUTES_COMPONENTS_DIR, FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP, FILE_SYSTEM_ROUTES_INDEX, FILE_SYSTEM_ROUTES_LAYOUT } from "../constants";
+import { replaceWithAlias } from "../utils";
+import { debug, findLayout, shouldSkip, getRouteWeight } from "./utils";
+var compName = function compName(srcDirectory, filePath) {
+  var legalCompName = makeLegalIdentifier(path.relative(srcDirectory, filePath));
+  return "Comp_".concat(legalCompName);
+};
+var layoutNameAbbr = function layoutNameAbbr(filePath) {
+  var prefix = 'L_';
+  var dirName = path.dirname(filePath).split('/').pop() || '';
+  return "".concat(prefix).concat(makeLegalIdentifier(dirName));
+};
+var parents = [];
+
+/* eslint-disable no-param-reassign */
+var recursiveReadDirLegacy = function recursiveReadDirLegacy(_ref) {
+  var dir = _ref.dir,
+    routes = _ref.routes,
+    _ref$basePath = _ref.basePath,
+    basePath = _ref$basePath === void 0 ? '/' : _ref$basePath,
+    srcDirectory = _ref.srcDirectory,
+    srcAlias = _ref.srcAlias;
+  var hasDynamicRoute = false;
+  var resetParent = false;
+  var parent = parents[parents.length - 1];
+  var layout = findLayout(dir);
+  if (layout) {
+    if (basePath === '/') {
+      throw new Error("should use _app instead of _layout in ".concat(dir));
+    } else {
+      var alias = replaceWithAlias(srcDirectory, layout, srcAlias);
+      var componentName = compName(srcDirectory, layout);
+      var route = {
+        path: "".concat(basePath.substring(0, basePath.length - 1)),
+        exact: false,
+        routes: [],
+        _component: alias,
+        component: componentName,
+        parent: parent
+      };
+      parent = route;
+      resetParent = true;
+      routes.push(route);
+      parents.push(route);
+      routes = route.routes;
+    }
+  }
+  var _iterator = _createForOfIteratorHelper(fs.readdirSync(dir)),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var relative = _step.value;
+      var filePath = path.join(dir, relative);
+      if (!shouldSkip(filePath)) {
+        var filename = path.basename(filePath, path.extname(filePath));
+        var _alias = replaceWithAlias(srcDirectory, filePath, srcAlias);
+        var _componentName = compName(srcDirectory, filePath);
+        var dynamicRouteMatched = FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP.exec(filename);
+        if (dynamicRouteMatched) {
+          if (hasDynamicRoute) {
+            throw new Error("Can't set two dynamic route in one directory: ".concat(dir));
+          } else {
+            hasDynamicRoute = true;
+          }
+        }
+        var _route = {
+          path: "".concat(basePath).concat(dynamicRouteMatched ? ":".concat(dynamicRouteMatched[1]).concat(dynamicRouteMatched[2]) : filename),
+          _component: _alias,
+          component: _componentName,
+          exact: true,
+          parent: parent
+        };
+        if (fs.statSync(filePath).isDirectory()) {
+          recursiveReadDirLegacy({
+            dir: filePath,
+            routes: routes,
+            basePath: "".concat(_route.path, "/"),
+            srcDirectory: srcDirectory,
+            srcAlias: srcAlias
+          });
+          continue;
+        }
+        if (filename === FILE_SYSTEM_ROUTES_LAYOUT) {
+          continue;
+        }
+        if (filename === FILE_SYSTEM_ROUTES_INDEX) {
+          _route.path = basePath === '/' ? basePath : "".concat(basePath.substring(0, basePath.length - 1));
+        }
+        if (filename === '404' && basePath === '/') {
+          _route.path = '*';
+          _route.exact = false;
+        }
+        routes.push(_route);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (resetParent) {
+    parents.pop();
+  }
+};
+/* eslint-enable  no-param-reassign */
+
+var normalizeNestedRoutes = function normalizeNestedRoutes(nested, internalComponentsDir, internalDirectory, internalDirAlias) {
+  var flat = function flat(routes) {
+    return routes.reduce(function (memo, route) {
+      return memo.concat(Array.isArray(route.routes) ? flat(route.routes) : [route]);
+    }, []);
+  };
+  var generate = function generate(route) {
+    var codes = [];
+    var lastComponent = route.component;
+    var imports = ["import React from 'react';", "import ".concat(lastComponent, " from '").concat(route._component, "'")];
+
+    // eslint-disable-next-line no-param-reassign, no-cond-assign
+    while (route = route.parent) {
+      var layoutComponent = route.component;
+      var layoutComponentAbbr = layoutNameAbbr(route._component);
+      imports.push("import ".concat(layoutComponent, " from '").concat(route._component, "';"));
+      var currentComponent = "".concat(layoutComponentAbbr, "_").concat(lastComponent);
+      codes.push("const ".concat(currentComponent, " = props => <").concat(layoutComponent, " Component={").concat(lastComponent, "} {...props} />;"));
+      lastComponent = currentComponent;
+    }
+    var file = path.resolve(internalComponentsDir, "".concat(lastComponent, ".jsx"));
+    fs.outputFileSync(file, "".concat(imports.join('\n'), "\n").concat(codes.join('\n'), "\nexport default ").concat(lastComponent));
+    return {
+      component: lastComponent,
+      _component: replaceWithAlias(internalDirectory, file, internalDirAlias)
+    };
+  };
+  var normalized = flat(nested).map(function (route) {
+    return route.parent ? _objectSpread(_objectSpread(_objectSpread({}, route), generate(route)), {}, {
+      parent: undefined
+    }) : _objectSpread(_objectSpread({}, route), {}, {
+      parent: undefined
+    });
+  });
+  return normalized;
+};
+export var getClientRoutes = function getClientRoutes(_ref2) {
+  var entrypoint = _ref2.entrypoint,
+    srcDirectory = _ref2.srcDirectory,
+    srcAlias = _ref2.srcAlias,
+    internalDirectory = _ref2.internalDirectory,
+    internalDirAlias = _ref2.internalDirAlias;
+  var entry = entrypoint.entry,
+    entryName = entrypoint.entryName;
+  if (!fs.existsSync(entry)) {
+    throw new Error("generate file system routes error, ".concat(entry, " directory not found."));
+  }
+  if (!(fs.existsSync(entry) && fs.statSync(entry).isDirectory())) {
+    throw new Error("generate file system routes error, ".concat(entry, " should be directory."));
+  }
+  var routes = [];
+  recursiveReadDirLegacy({
+    dir: entry,
+    routes: routes,
+    basePath: '/',
+    srcDirectory: srcDirectory,
+    srcAlias: srcAlias
+  });
+  var internalComponentsDir = path.resolve(internalDirectory, "".concat(entryName, "/").concat(FILE_SYSTEM_ROUTES_COMPONENTS_DIR));
+  fs.emptyDirSync(internalComponentsDir);
+  routes = normalizeNestedRoutes(routes, internalComponentsDir, internalDirectory, internalDirAlias);
+  parents.length = 0;
+
+  // FIXME: support more situations
+  routes.sort(function (a, b) {
+    var delta = getRouteWeight(a.path) - getRouteWeight(b.path);
+    if (delta === 0) {
+      return a.path.length - b.path.length;
+    }
+    return delta;
+  });
+  debug("fileSystem routes: %o", routes);
+  return routes;
+};

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

@@ -0,0 +1,2 @@
+export { getClientRoutes } from "./getRoutes";
+export { getClientRoutes as getClientRoutesLegacy } from "./getRoutesLegacy";

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

@@ -0,0 +1,24 @@
+import path from 'path';
+import { createDebugger, findExists, fs } from '@modern-js/utils';
+import { JS_EXTENSIONS, FILE_SYSTEM_ROUTES_LAYOUT, FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT, FILE_SYSTEM_ROUTES_IGNORED_REGEX } from "../constants";
+var debug = createDebugger('get-client-routes');
+export { debug };
+export var findLayout = function findLayout(dir) {
+  return findExists(JS_EXTENSIONS.map(function (ext) {
+    return path.resolve(dir, "".concat(FILE_SYSTEM_ROUTES_LAYOUT).concat(ext));
+  }));
+};
+export var getRouteWeight = function getRouteWeight(route) {
+  return route === '*' ? 999 : route.split(':').length - 1;
+};
+export var shouldSkip = function shouldSkip(file) {
+  // should not skip directory.
+  if (fs.statSync(file).isDirectory()) {
+    return false;
+  }
+  var ext = path.extname(file);
+  if (FILE_SYSTEM_ROUTES_IGNORED_REGEX.test(file) || !JS_EXTENSIONS.includes(ext) || FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT === path.basename(file, ext)) {
+    return true;
+  }
+  return false;
+};

package/dist/js/treeshaking/analyze/getFileSystemEntry.js

@@ -0,0 +1,96 @@
+import fs from 'fs';
+import path from 'path';
+import { findExists, ensureAbsolutePath } from '@modern-js/utils';
+import { isDefaultExportFunction } from "./isDefaultExportFunction";
+import { JS_EXTENSIONS, INDEX_FILE_NAME, APP_FILE_NAME, PAGES_DIR_NAME, FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT, NESTED_ROUTES_DIR } from "./constants";
+var hasIndex = function hasIndex(dir) {
+  return findExists(JS_EXTENSIONS.map(function (ext) {
+    return path.resolve(dir, "".concat(INDEX_FILE_NAME).concat(ext));
+  }));
+};
+var hasApp = function hasApp(dir) {
+  return findExists(JS_EXTENSIONS.map(function (ext) {
+    return path.resolve(dir, "".concat(APP_FILE_NAME).concat(ext));
+  }));
+};
+var hasPages = function hasPages(dir) {
+  return fs.existsSync(path.join(dir, PAGES_DIR_NAME));
+};
+var hasNestedRoutes = function hasNestedRoutes(dir) {
+  return fs.existsSync(path.join(dir, NESTED_ROUTES_DIR));
+};
+var isBundleEntry = function isBundleEntry(dir) {
+  return hasApp(dir) || hasPages(dir) || hasIndex(dir) || hasNestedRoutes(dir);
+};
+var scanDir = function scanDir(dirs) {
+  return dirs.map(function (dir) {
+    var indexFile = hasIndex(dir);
+    var customBootstrap = isDefaultExportFunction(indexFile) ? indexFile : false;
+    var entryName = path.basename(dir);
+    if (indexFile && !customBootstrap) {
+      return {
+        entryName: entryName,
+        entry: indexFile,
+        absoluteEntryDir: path.resolve(dir),
+        isAutoMount: false
+      };
+    }
+    var isHasApp = hasApp(dir);
+    if (isHasApp) {
+      return {
+        entryName: entryName,
+        entry: path.join(dir, APP_FILE_NAME),
+        isAutoMount: true,
+        absoluteEntryDir: path.resolve(dir),
+        customBootstrap: customBootstrap
+      };
+    }
+    var isHasNestedRoutes = hasNestedRoutes(dir);
+    var isHasPages = hasPages(dir);
+    if (isHasNestedRoutes || isHasPages) {
+      var entrypoint = {
+        entryName: entryName,
+        entry: '',
+        fileSystemRoutes: {
+          globalApp: findExists(JS_EXTENSIONS.map(function (ext) {
+            return path.resolve(dir, "./".concat(PAGES_DIR_NAME, "/").concat(FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT).concat(ext));
+          }))
+        },
+        isAutoMount: true,
+        absoluteEntryDir: path.resolve(dir),
+        customBootstrap: customBootstrap
+      };
+      if (isHasPages) {
+        entrypoint.entry = path.join(dir, PAGES_DIR_NAME);
+      }
+      if (isHasNestedRoutes) {
+        entrypoint.nestedRoutesEntry = path.join(dir, NESTED_ROUTES_DIR);
+      }
+      return entrypoint;
+    }
+    return {
+      entryName: entryName,
+      entry: indexFile,
+      absoluteEntryDir: path.resolve(dir),
+      isAutoMount: false
+    };
+  });
+};
+export var getFileSystemEntry = function getFileSystemEntry(appContext, config) {
+  var appDirectory = appContext.appDirectory;
+  var entriesDir = config.source.entriesDir;
+  var src = ensureAbsolutePath(appDirectory, entriesDir);
+  if (fs.existsSync(src)) {
+    if (fs.statSync(src).isDirectory()) {
+      return scanDir(isBundleEntry(src) ? [src] : fs.readdirSync(src).map(function (file) {
+        return path.join(src, file);
+      }).filter(function (file) {
+        return fs.statSync(file).isDirectory() && isBundleEntry(file);
+      }));
+    } else {
+      throw Error("source.entriesDir accept a directory.");
+    }
+  } else {
+    throw Error("src dir ".concat(entriesDir, " not found."));
+  }
+};