@modern-js/app-tools 2.31.2 → 2.31.3-alpha.0

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

@@ -0,0 +1,233 @@
+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;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+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(srcDirectory, filePath) {
+    var legalCompName = makeLegalIdentifier(path.relative(srcDirectory, filePath));
+    return "Comp_".concat(legalCompName);
+};
+var layoutNameAbbr = function(filePath) {
+    var prefix = "L_";
+    var dirName = path.dirname(filePath).split("/").pop() || "";
+    return "".concat(prefix).concat(makeLegalIdentifier(dirName));
+};
+var parents = [];
+var recursiveReadDir = function(param) {
+    var dir = param.dir, routes = param.routes, _basePath = param.basePath, basePath = _basePath === void 0 ? "/" : _basePath, srcDirectory = param.srcDirectory, srcAlias = param.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 _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = fs.readdirSync(dir)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var relative = _step.value;
+            var filePath = path.join(dir, relative);
+            if (!shouldSkip(filePath)) {
+                var filename = path.basename(filePath, path.extname(filePath));
+                var alias1 = replaceWithAlias(srcDirectory, filePath, srcAlias);
+                var componentName1 = 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 route1 = {
+                    path: "".concat(basePath).concat(dynamicRouteMatched ? ":".concat(dynamicRouteMatched[1]).concat(dynamicRouteMatched[2]) : filename),
+                    _component: alias1,
+                    component: componentName1,
+                    parent: parent,
+                    type: "page"
+                };
+                if (fs.statSync(filePath).isDirectory()) {
+                    recursiveReadDir({
+                        dir: filePath,
+                        routes: routes,
+                        basePath: "".concat(route1.path, "/"),
+                        srcDirectory: srcDirectory,
+                        srcAlias: srcAlias
+                    });
+                    continue;
+                }
+                if (filename === FILE_SYSTEM_ROUTES_LAYOUT) {
+                    continue;
+                }
+                if (filename === FILE_SYSTEM_ROUTES_INDEX) {
+                    route1.path = basePath === "/" ? basePath : "".concat(basePath.substring(0, basePath.length - 1));
+                }
+                if (filename === "404" && basePath === "/") {
+                    route1.path = "*";
+                }
+                routes.push(route1);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (resetParent) {
+        parents.pop();
+    }
+};
+var normalizeNestedRoutes = function(nested, internalComponentsDir, internalDirectory, internalDirAlias) {
+    var flat = function(routes) {
+        return routes.reduce(function(memo, route) {
+            return memo.concat(Array.isArray(route.children) ? flat(route.children) : [
+                route
+            ]);
+        }, []);
+    };
+    var generate = function(route) {
+        var codes = [];
+        var lastComponent = route.component;
+        var imports = [
+            "import React from 'react';",
+            "import ".concat(lastComponent, " from '").concat(route._component, "'")
+        ];
+        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 ? _objectSpreadProps(_objectSpread({}, route, generate(route)), {
+            parent: void 0
+        }) : _objectSpreadProps(_objectSpread({}, route), {
+            parent: void 0
+        });
+    });
+    return normalized;
+};
+var getClientRoutes = function(param) {
+    var entrypoint = param.entrypoint, srcDirectory = param.srcDirectory, srcAlias = param.srcAlias, internalDirectory = param.internalDirectory, internalDirAlias = param.internalDirAlias;
+    var entryName = entrypoint.entryName, pageRoutesEntry = entrypoint.pageRoutesEntry;
+    if (!pageRoutesEntry) {
+        return [];
+    }
+    if (!fs.existsSync(pageRoutesEntry)) {
+        throw new Error("generate file system routes error, ".concat(pageRoutesEntry, " directory not found."));
+    }
+    if (!(fs.existsSync(pageRoutesEntry) && fs.statSync(pageRoutesEntry).isDirectory())) {
+        throw new Error("generate file system routes error, ".concat(pageRoutesEntry, " should be directory."));
+    }
+    var routes = [];
+    recursiveReadDir({
+        dir: pageRoutesEntry,
+        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;
+    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;
+};
+export { getClientRoutes };

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

@@ -0,0 +1,231 @@
+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;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+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(srcDirectory, filePath) {
+    var legalCompName = makeLegalIdentifier(path.relative(srcDirectory, filePath));
+    return "Comp_".concat(legalCompName);
+};
+var layoutNameAbbr = function(filePath) {
+    var prefix = "L_";
+    var dirName = path.dirname(filePath).split("/").pop() || "";
+    return "".concat(prefix).concat(makeLegalIdentifier(dirName));
+};
+var parents = [];
+var recursiveReadDirLegacy = function(param) {
+    var dir = param.dir, routes = param.routes, _basePath = param.basePath, basePath = _basePath === void 0 ? "/" : _basePath, srcDirectory = param.srcDirectory, srcAlias = param.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 _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = fs.readdirSync(dir)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var relative = _step.value;
+            var filePath = path.join(dir, relative);
+            if (!shouldSkip(filePath)) {
+                var filename = path.basename(filePath, path.extname(filePath));
+                var alias1 = replaceWithAlias(srcDirectory, filePath, srcAlias);
+                var componentName1 = 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 route1 = {
+                    path: "".concat(basePath).concat(dynamicRouteMatched ? ":".concat(dynamicRouteMatched[1]).concat(dynamicRouteMatched[2]) : filename),
+                    _component: alias1,
+                    component: componentName1,
+                    exact: true,
+                    parent: parent
+                };
+                if (fs.statSync(filePath).isDirectory()) {
+                    recursiveReadDirLegacy({
+                        dir: filePath,
+                        routes: routes,
+                        basePath: "".concat(route1.path, "/"),
+                        srcDirectory: srcDirectory,
+                        srcAlias: srcAlias
+                    });
+                    continue;
+                }
+                if (filename === FILE_SYSTEM_ROUTES_LAYOUT) {
+                    continue;
+                }
+                if (filename === FILE_SYSTEM_ROUTES_INDEX) {
+                    route1.path = basePath === "/" ? basePath : "".concat(basePath.substring(0, basePath.length - 1));
+                }
+                if (filename === "404" && basePath === "/") {
+                    route1.path = "*";
+                    route1.exact = false;
+                }
+                routes.push(route1);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (resetParent) {
+        parents.pop();
+    }
+};
+var normalizeNestedRoutes = function(nested, internalComponentsDir, internalDirectory, internalDirAlias) {
+    var flat = function(routes) {
+        return routes.reduce(function(memo, route) {
+            return memo.concat(Array.isArray(route.routes) ? flat(route.routes) : [
+                route
+            ]);
+        }, []);
+    };
+    var generate = function(route) {
+        var codes = [];
+        var lastComponent = route.component;
+        var imports = [
+            "import React from 'react';",
+            "import ".concat(lastComponent, " from '").concat(route._component, "'")
+        ];
+        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 ? _objectSpreadProps(_objectSpread({}, route, generate(route)), {
+            parent: void 0
+        }) : _objectSpreadProps(_objectSpread({}, route), {
+            parent: void 0
+        });
+    });
+    return normalized;
+};
+var getClientRoutes = function(param) {
+    var entrypoint = param.entrypoint, srcDirectory = param.srcDirectory, srcAlias = param.srcAlias, internalDirectory = param.internalDirectory, internalDirAlias = param.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;
+    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;
+};
+export { getClientRoutes };

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

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

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

@@ -0,0 +1,23 @@
+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");
+var findLayout = function(dir) {
+    return findExists(JS_EXTENSIONS.map(function(ext) {
+        return path.resolve(dir, "".concat(FILE_SYSTEM_ROUTES_LAYOUT).concat(ext));
+    }));
+};
+var getRouteWeight = function(route) {
+    return route === "*" ? 999 : route.split(":").length - 1;
+};
+var shouldSkip = function(file) {
+    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;
+};
+export { debug, findLayout, getRouteWeight, shouldSkip };

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

@@ -0,0 +1,107 @@
+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(dir) {
+    return findExists(JS_EXTENSIONS.map(function(ext) {
+        return path.resolve(dir, "".concat(INDEX_FILE_NAME).concat(ext));
+    }));
+};
+var hasApp = function(dir) {
+    return findExists(JS_EXTENSIONS.map(function(ext) {
+        return path.resolve(dir, "".concat(APP_FILE_NAME).concat(ext));
+    }));
+};
+var hasPages = function(dir) {
+    return fs.existsSync(path.join(dir, PAGES_DIR_NAME));
+};
+var hasNestedRoutes = function(dir) {
+    return fs.existsSync(path.join(dir, NESTED_ROUTES_DIR));
+};
+var isBundleEntry = function(dir) {
+    return hasApp(dir) || hasPages(dir) || hasIndex(dir) || hasNestedRoutes(dir);
+};
+var scanDir = function(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);
+                entrypoint.pageRoutesEntry = entrypoint.entry;
+            }
+            if (isHasNestedRoutes) {
+                entrypoint.entry = path.join(dir, NESTED_ROUTES_DIR);
+                entrypoint.nestedRoutesEntry = entrypoint.entry;
+            }
+            return entrypoint;
+        }
+        return {
+            entryName: entryName,
+            entry: indexFile,
+            absoluteEntryDir: path.resolve(dir),
+            isAutoMount: false
+        };
+    });
+};
+var getFileSystemEntry = function(appContext, config) {
+    var appDirectory = appContext.appDirectory;
+    var _source = config.source, entriesDir = _source.entriesDir, disableEntryDirs = _source.disableEntryDirs;
+    var disabledDirs = [];
+    if (disableEntryDirs && Array.isArray(disableEntryDirs)) {
+        disabledDirs = disableEntryDirs === null || disableEntryDirs === void 0 ? void 0 : disableEntryDirs.map(function(dir) {
+            return ensureAbsolutePath(appDirectory, dir);
+        });
+    }
+    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) && !disabledDirs.includes(file);
+            }));
+        } else {
+            throw Error("source.entriesDir accept a directory.");
+        }
+    } else {
+        throw Error("src dir ".concat(entriesDir, " not found."));
+    }
+};
+export { getFileSystemEntry };