@modern-js/utils 2.69.7 → 3.0.0-alpha.1

package/dist/esm/cli/port.mjs

@@ -0,0 +1,35 @@
+import net from "net";
+import { chalk } from "../compiled";
+import { logger } from "./logger";
+const getPort = async (expectPort, { tryLimits = 20, strictPort = false, slient = false } = {})=>{
+    let port = expectPort;
+    if ('string' == typeof port) port = parseInt(port, 10);
+    if (strictPort) tryLimits = 1;
+    const original = port;
+    let found = false;
+    let attempts = 0;
+    while(!found && attempts <= tryLimits)try {
+        await new Promise((resolve, reject)=>{
+            const server = net.createServer();
+            server.unref();
+            server.on('error', reject);
+            server.listen({
+                port,
+                host: '0.0.0.0'
+            }, ()=>{
+                found = true;
+                server.close(resolve);
+            });
+        });
+    } catch (e) {
+        if ('EADDRINUSE' !== e.code) throw e;
+        port++;
+        attempts++;
+    }
+    if (port !== original) {
+        if (strictPort) throw new Error(`Port "${original}" is occupied, please choose another one.`);
+        else if (!slient) logger.info(`Port ${original} is in use. ${chalk.yellow(`using port ${port}.`)}`);
+    }
+    return port;
+};
+export { getPort };

package/dist/esm/cli/prettyInstructions.mjs

@@ -0,0 +1,68 @@
+import { isIPv6 } from "net";
+import os from "os";
+import { chalk } from "../compiled";
+import { DEFAULT_DEV_HOST } from "./constants";
+import { isDev, isSingleEntry } from "./is";
+const normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1');
+const getIpv4Interfaces = ()=>{
+    const interfaces = os.networkInterfaces();
+    const ipv4Interfaces = [];
+    Object.keys(interfaces).forEach((key)=>{
+        interfaces[key].forEach((detail)=>{
+            const familyV4Value = 'string' == typeof detail.family ? 'IPv4' : 4;
+            if (detail.family === familyV4Value) ipv4Interfaces.push(detail);
+        });
+    });
+    return ipv4Interfaces;
+};
+const getHostInUrl = (host)=>{
+    if (isIPv6(host)) return '::' === host ? '[::1]' : `[${host}]`;
+    return host;
+};
+const getAddressUrls = (protocol = 'http', port, host)=>{
+    const LOCAL_LABEL = 'Local:  ';
+    const NETWORK_LABEL = 'Network:  ';
+    const isLocalhost = (url)=>url?.includes('localhost');
+    if (host && host !== DEFAULT_DEV_HOST) return [
+        {
+            label: isLocalhost(host) ? LOCAL_LABEL : NETWORK_LABEL,
+            url: `${protocol}://${getHostInUrl(host)}:${port}`
+        }
+    ];
+    const ipv4Interfaces = getIpv4Interfaces();
+    return ipv4Interfaces.reduce((memo, detail)=>{
+        if (isLocalhost(detail.address) || detail.internal) memo.push({
+            label: LOCAL_LABEL,
+            url: `${protocol}://localhost:${port}`
+        });
+        else memo.push({
+            label: NETWORK_LABEL,
+            url: `${protocol}://${detail.address}:${port}`
+        });
+        return memo;
+    }, []);
+};
+const prettyInstructions = (appContext, config)=>{
+    const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
+    const isHttps = isDev() && (config?.dev?.https || config?.tools?.devServer?.https);
+    const urls = getAddressUrls(isHttps ? 'https' : 'http', port, config.dev?.host);
+    const routes = apiOnly ? serverRoutes : serverRoutes.filter((route)=>route.entryName);
+    let message = '\n';
+    if (isSingleEntry(entrypoints, config.source?.mainEntryName) || apiOnly) message += urls.map(({ label, url })=>`  ${chalk.bold(`> ${label.padEnd(10)}`)}${chalk.cyanBright(normalizeUrl(`${url}/${routes[0].urlPath}`))}\n`).join('');
+    else {
+        const maxNameLength = Math.max(...routes.map((r)=>r.entryName.length));
+        urls.forEach(({ label, url })=>{
+            message += `  ${chalk.bold(`> ${label}`)}${0 === routes.length ? chalk.cyanBright(url) : ''}\n`;
+            routes.forEach(({ entryName, urlPath, isSSR })=>{
+                if (!checkedEntries.includes(entryName)) return;
+                message += `    ${chalk.yellowBright(isSSR ? 'λ' : '○')}  ${chalk.yellowBright(entryName.padEnd(maxNameLength + 8))}${chalk.cyanBright(normalizeUrl(`${url}/${urlPath}`))}\n`;
+            });
+        });
+        message += '\n';
+        message += chalk.cyanBright('  λ (Server) server-side renders at runtime\n');
+        message += chalk.cyanBright('  ○ (Static) client-side renders as static HTML\n');
+    }
+    if (config.dev?.cliShortcuts) message += `  ${chalk.dim('> press')} ${chalk.bold('h + enter')} ${chalk.dim('to show shortcuts')}\n`;
+    return message;
+};
+export { getAddressUrls, prettyInstructions };

package/dist/esm/cli/require.mjs

@@ -0,0 +1,79 @@
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
+import { findExists } from "./fs";
+async function compatibleRequire(path, interop = true) {
+    if (path.endsWith('.json')) return require(path);
+    let requiredModule;
+    try {
+        requiredModule = require(path);
+    } catch (err) {
+        if ('ERR_REQUIRE_ESM' === err.code) {
+            const modulePath = isAbsolute(path) ? pathToFileURL(path).href : path;
+            if ('development' === process.env.NODE_ENV) {
+                const timestamp = Date.now();
+                requiredModule = await import(`${modulePath}?t=${timestamp}`);
+            } else requiredModule = await import(modulePath);
+            return interop ? requiredModule.default : requiredModule;
+        }
+        throw err;
+    }
+    return interop && requiredModule?.__esModule ? requiredModule.default : requiredModule;
+}
+async function loadFromProject(moduleName, appDir) {
+    let requiredModule;
+    const paths = [
+        appDir,
+        process.cwd()
+    ];
+    try {
+        {
+            const modulePath = require.resolve(moduleName, {
+                paths
+            });
+            requiredModule = require(modulePath);
+        }
+        return requiredModule.default || requiredModule;
+    } catch (error) {
+        if ('MODULE_NOT_FOUND' === error.code) throw new Error(`Cannot find module ${moduleName}.`);
+        throw error;
+    }
+}
+const dynamicImport = new Function('modulePath', 'return import(modulePath)');
+const requireExistModule = async (filename, opt)=>{
+    const final = {
+        extensions: [
+            '.ts',
+            '.js'
+        ],
+        interop: true,
+        ...opt
+    };
+    const exist = findExists(final.extensions.map((ext)=>`${filename}${ext}`));
+    if (!exist) return null;
+    return compatibleRequire(exist, final.interop);
+};
+const cleanRequireCache = (filelist)=>{
+    filelist.forEach((filepath)=>{
+        if (require.cache) delete require.cache[filepath];
+    });
+};
+function deleteRequireCache(path) {
+    if (require.cache[path]) delete require.cache[path];
+    if (module.children) module.children = module.children.filter((item)=>item.filename !== path);
+}
+const tryResolve = (name, resolvePath)=>{
+    let filePath = '';
+    try {
+        filePath = require.resolve(name, {
+            paths: [
+                resolvePath
+            ]
+        });
+        delete require.cache[filePath];
+    } catch (err) {
+        if ('MODULE_NOT_FOUND' === err.code) throw new Error(`Can not find module ${name}.`);
+        throw err;
+    }
+    return filePath;
+};
+export { cleanRequireCache, compatibleRequire, deleteRequireCache, dynamicImport, loadFromProject, requireExistModule, tryResolve };

package/dist/esm/cli/route.mjs

@@ -0,0 +1,36 @@
+import { lodash } from "../compiled";
+const { cloneDeep } = lodash;
+function filterRoutesForServer(routes) {
+    const clonedRoutes = cloneDeep(routes);
+    const newRoutes = clonedRoutes.map((route)=>{
+        if ('nested' !== route.type) return route;
+        if (route.children && route.children.length > 0) route.children = filterRoutesForServer(route.children);
+        if (route.inValidSSRRoute) return null;
+        return route;
+    }).filter((route)=>null !== route);
+    return newRoutes;
+}
+function filterRoutesLoader(routes) {
+    const clonedRoutes = cloneDeep(routes);
+    const newRoutes = clonedRoutes.map((route)=>{
+        if ('nested' !== route.type) return route;
+        if (route.children && route.children.length > 0) route.children = filterRoutesLoader(route.children);
+        if (route.inValidSSRRoute) {
+            delete route.loader;
+            delete route.data;
+            delete route.action;
+        }
+        return route;
+    }).filter((route)=>null !== route);
+    return newRoutes;
+}
+function markRoutes(routes, routeIds) {
+    return routes.map((route)=>{
+        if ('nested' !== route.type) return route;
+        if (route.children && route.children.length > 0) route.children = markRoutes(route.children, routeIds);
+        if (route.children && route.children.length > 0) route.inValidSSRRoute = route.children.every((child)=>child.inValidSSRRoute ?? false);
+        else if (route.id) route.inValidSSRRoute = !routeIds.includes(route.id);
+        return route;
+    });
+}
+export { filterRoutesForServer, filterRoutesLoader, markRoutes };

package/dist/esm/cli/version.mjs

@@ -0,0 +1,21 @@
+function isVersionAtLeast1819() {
+    const nodeVersion = process.versions.node;
+    const versionArr = nodeVersion.split('.').map(Number);
+    return versionArr[0] > 18 || 18 === versionArr[0] && versionArr[1] >= 19;
+}
+function isVersionAtLeast18() {
+    const nodeVersion = process.versions.node;
+    const versionArr = nodeVersion.split('.').map(Number);
+    return versionArr[0] >= 18;
+}
+function isVersionAtLeast22() {
+    const nodeVersion = process.versions.node;
+    const versionArr = nodeVersion.split('.').map(Number);
+    return versionArr[0] >= 22;
+}
+function isVersionAtLeast20() {
+    const nodeVersion = process.versions.node;
+    const versionArr = nodeVersion.split('.').map(Number);
+    return versionArr[0] >= 20;
+}
+export { isVersionAtLeast18, isVersionAtLeast1819, isVersionAtLeast20, isVersionAtLeast22 };

package/dist/esm/cli/watch.mjs

@@ -0,0 +1,40 @@
+import path from "path";
+import { chokidar } from "../compiled";
+const WatchChangeType = {
+    ADD: 'add',
+    UNLINK: 'unlink',
+    CHANGE: 'change'
+};
+const watch = (watchDir, runTask, ignored = [])=>{
+    let ready = false;
+    const watcher = chokidar.watch(watchDir, {
+        ignored
+    });
+    watcher.on('ready', ()=>ready = true);
+    watcher.on('change', async (filePath)=>{
+        const changedFilePath = path.resolve(filePath);
+        await runTask({
+            changedFilePath,
+            changeType: WatchChangeType.CHANGE
+        });
+    });
+    watcher.on('add', async (filePath)=>{
+        const changedFilePath = path.resolve(filePath);
+        if (ready) await runTask({
+            changedFilePath,
+            changeType: WatchChangeType.ADD
+        });
+    });
+    watcher.on('unlink', async (filePath)=>{
+        const changedFilePath = path.resolve(filePath);
+        await runTask({
+            changedFilePath,
+            changeType: WatchChangeType.UNLINK
+        });
+    });
+    watcher.on('error', (err)=>{
+        throw err;
+    });
+    return watcher;
+};
+export { WatchChangeType, watch };

package/dist/esm/compiled.mjs

@@ -0,0 +1,115 @@
+import { createRequire } from "node:module";
+import { Import } from "./import";
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+const index_js_namespaceObject = __rspack_createRequire_require("../compiled/fs-extra/index.js");
+var index_js_default = /*#__PURE__*/ __webpack_require__.n(index_js_namespaceObject);
+const ora_index_js_namespaceObject = __rspack_createRequire_require("../compiled/ora/index.js");
+var ora_index_js_default = /*#__PURE__*/ __webpack_require__.n(ora_index_js_namespaceObject);
+const glob_index_js_namespaceObject = __rspack_createRequire_require("../compiled/glob/index.js");
+var glob_index_js_default = /*#__PURE__*/ __webpack_require__.n(glob_index_js_namespaceObject);
+const js_yaml_index_js_namespaceObject = __rspack_createRequire_require("../compiled/js-yaml/index.js");
+var js_yaml_index_js_default = /*#__PURE__*/ __webpack_require__.n(js_yaml_index_js_namespaceObject);
+const chalk_index_js_namespaceObject = __rspack_createRequire_require("../compiled/chalk/index.js");
+var chalk_index_js_default = /*#__PURE__*/ __webpack_require__.n(chalk_index_js_namespaceObject);
+const debug_index_js_namespaceObject = __rspack_createRequire_require("../compiled/debug/index.js");
+var debug_index_js_default = /*#__PURE__*/ __webpack_require__.n(debug_index_js_namespaceObject);
+const slash_index_js_namespaceObject = __rspack_createRequire_require("../compiled/slash/index.js");
+var slash_index_js_default = /*#__PURE__*/ __webpack_require__.n(slash_index_js_namespaceObject);
+const execa_index_js_namespaceObject = __rspack_createRequire_require("../compiled/execa/index.js");
+var execa_index_js_default = /*#__PURE__*/ __webpack_require__.n(execa_index_js_namespaceObject);
+const json5_index_js_namespaceObject = __rspack_createRequire_require("../compiled/json5/index.js");
+var json5_index_js_default = /*#__PURE__*/ __webpack_require__.n(json5_index_js_namespaceObject);
+const upath_index_js_namespaceObject = __rspack_createRequire_require("../compiled/upath/index.js");
+var upath_index_js_default = /*#__PURE__*/ __webpack_require__.n(upath_index_js_namespaceObject);
+const pkg_up_index_js_namespaceObject = __rspack_createRequire_require("../compiled/pkg-up/index.js");
+var pkg_up_index_js_default = /*#__PURE__*/ __webpack_require__.n(pkg_up_index_js_namespaceObject);
+const nanoid_index_js_namespaceObject = __rspack_createRequire_require("../compiled/nanoid/index.js");
+const semver_index_js_namespaceObject = __rspack_createRequire_require("../compiled/semver/index.js");
+var semver_index_js_default = /*#__PURE__*/ __webpack_require__.n(semver_index_js_namespaceObject);
+const dotenv_index_js_namespaceObject = __rspack_createRequire_require("../compiled/dotenv/index.js");
+var dotenv_index_js_default = /*#__PURE__*/ __webpack_require__.n(dotenv_index_js_namespaceObject);
+const lodash_index_js_namespaceObject = __rspack_createRequire_require("../compiled/lodash/index.js");
+var lodash_index_js_default = /*#__PURE__*/ __webpack_require__.n(lodash_index_js_namespaceObject);
+const globby_index_js_namespaceObject = __rspack_createRequire_require("../compiled/globby/index.js");
+var globby_index_js_default = /*#__PURE__*/ __webpack_require__.n(globby_index_js_namespaceObject);
+const address_index_js_namespaceObject = __rspack_createRequire_require("../compiled/address/index.js");
+var address_index_js_default = /*#__PURE__*/ __webpack_require__.n(address_index_js_namespaceObject);
+const signale_index_js_namespaceObject = __rspack_createRequire_require("../compiled/signale/index.js");
+var signale_index_js_default = /*#__PURE__*/ __webpack_require__.n(signale_index_js_namespaceObject);
+const url_join_index_js_namespaceObject = __rspack_createRequire_require("../compiled/url-join/index.js");
+var url_join_index_js_default = /*#__PURE__*/ __webpack_require__.n(url_join_index_js_namespaceObject);
+const minimist_index_js_namespaceObject = __rspack_createRequire_require("../compiled/minimist/index.js");
+var minimist_index_js_default = /*#__PURE__*/ __webpack_require__.n(minimist_index_js_namespaceObject);
+const fast_glob_index_js_namespaceObject = __rspack_createRequire_require("../compiled/fast-glob/index.js");
+var fast_glob_index_js_default = /*#__PURE__*/ __webpack_require__.n(fast_glob_index_js_namespaceObject);
+const filesize_index_js_namespaceObject = __rspack_createRequire_require("../compiled/filesize/index.js");
+var filesize_index_js_default = /*#__PURE__*/ __webpack_require__.n(filesize_index_js_namespaceObject);
+const gzip_size_index_js_namespaceObject = __rspack_createRequire_require("../compiled/gzip-size/index.js");
+var gzip_size_index_js_default = /*#__PURE__*/ __webpack_require__.n(gzip_size_index_js_namespaceObject);
+const strip_ansi_index_js_namespaceObject = __rspack_createRequire_require("../compiled/strip-ansi/index.js");
+var strip_ansi_index_js_default = /*#__PURE__*/ __webpack_require__.n(strip_ansi_index_js_namespaceObject);
+const dotenv_expand_index_js_namespaceObject = __rspack_createRequire_require("../compiled/dotenv-expand/index.js");
+var dotenv_expand_index_js_default = /*#__PURE__*/ __webpack_require__.n(dotenv_expand_index_js_namespaceObject);
+const browserslist_index_js_namespaceObject = __rspack_createRequire_require("../compiled/browserslist/index.js");
+var browserslist_index_js_default = /*#__PURE__*/ __webpack_require__.n(browserslist_index_js_namespaceObject);
+const commander_index_js_namespaceObject = __rspack_createRequire_require("../compiled/commander/index.js");
+const nodeRequire = (()=>{
+    const gRequire = globalThis.require;
+    if ('function' == typeof gRequire) return gRequire;
+    return createRequire(import.meta.url);
+})();
+const mime = Import.lazy('../compiled/mime-types', nodeRequire);
+const chokidar = Import.lazy('../compiled/chokidar', nodeRequire);
+const inquirer = Import.lazy('../compiled/inquirer', nodeRequire);
+var __webpack_exports__Command = commander_index_js_namespaceObject.Command;
+var __webpack_exports__Signale = signale_index_js_namespaceObject.Signale;
+var __webpack_exports__address = address_index_js_default();
+var __webpack_exports__browserslist = browserslist_index_js_default();
+var __webpack_exports__chalk = chalk_index_js_default();
+var __webpack_exports__debug = debug_index_js_default();
+var __webpack_exports__dotenv = dotenv_index_js_default();
+var __webpack_exports__dotenvExpand = dotenv_expand_index_js_default();
+var __webpack_exports__execa = execa_index_js_default();
+var __webpack_exports__fastGlob = fast_glob_index_js_default();
+var __webpack_exports__filesize = filesize_index_js_default();
+var __webpack_exports__fs = index_js_default();
+var __webpack_exports__glob = glob_index_js_default();
+var __webpack_exports__globby = globby_index_js_default();
+var __webpack_exports__gzipSize = gzip_size_index_js_default();
+var __webpack_exports__json5 = json5_index_js_default();
+var __webpack_exports__lodash = lodash_index_js_default();
+var __webpack_exports__minimist = minimist_index_js_default();
+var __webpack_exports__nanoid = nanoid_index_js_namespaceObject.nanoid;
+var __webpack_exports__ora = ora_index_js_default();
+var __webpack_exports__pkgUp = pkg_up_index_js_default();
+var __webpack_exports__program = commander_index_js_namespaceObject.program;
+var __webpack_exports__semver = semver_index_js_default();
+var __webpack_exports__signale = signale_index_js_default();
+var __webpack_exports__slash = slash_index_js_default();
+var __webpack_exports__stripAnsi = strip_ansi_index_js_default();
+var __webpack_exports__upath = upath_index_js_default();
+var __webpack_exports__urlJoin = url_join_index_js_default();
+var __webpack_exports__yaml = js_yaml_index_js_default();
+export { chokidar, inquirer, mime, __webpack_exports__Command as Command, __webpack_exports__Signale as Signale, __webpack_exports__address as address, __webpack_exports__browserslist as browserslist, __webpack_exports__chalk as chalk, __webpack_exports__debug as debug, __webpack_exports__dotenv as dotenv, __webpack_exports__dotenvExpand as dotenvExpand, __webpack_exports__execa as execa, __webpack_exports__fastGlob as fastGlob, __webpack_exports__filesize as filesize, __webpack_exports__fs as fs, __webpack_exports__glob as glob, __webpack_exports__globby as globby, __webpack_exports__gzipSize as gzipSize, __webpack_exports__json5 as json5, __webpack_exports__lodash as lodash, __webpack_exports__minimist as minimist, __webpack_exports__nanoid as nanoid, __webpack_exports__ora as ora, __webpack_exports__pkgUp as pkgUp, __webpack_exports__program as program, __webpack_exports__semver as semver, __webpack_exports__signale as signale, __webpack_exports__slash as slash, __webpack_exports__stripAnsi as stripAnsi, __webpack_exports__upath as upath, __webpack_exports__urlJoin as urlJoin, __webpack_exports__yaml as yaml };

package/dist/esm/import.mjs

@@ -0,0 +1,25 @@
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+var __webpack_modules__ = {
+    "../compiled/import-lazy" (module) {
+        module.exports = __rspack_createRequire_require("../compiled/import-lazy/index.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const lazy = (moduleName, requireFn)=>{
+    const importLazyLocal = __webpack_require__("../compiled/import-lazy")(requireFn);
+    return importLazyLocal(moduleName);
+};
+const Import = {
+    lazy
+};
+export { Import, lazy as lazyImport };

package/dist/esm/universal/constants.mjs

@@ -0,0 +1,13 @@
+const ROUTE_MANIFEST = "_MODERNJS_ROUTE_MANIFEST";
+const ROUTE_MODULES = "_routeModules";
+const HTML_CHUNKSMAP_SEPARATOR = '<!--<?- chunksMap.js ?>-->';
+const LOADER_REPORTER_NAME = "server-loader";
+const ROUTE_SPEC_FILE = 'route.json';
+const NESTED_ROUTE_SPEC_FILE = 'nestedRoutes.json';
+const MAIN_ENTRY_NAME = 'main';
+const DEFAULT_ENTRY_NAME = 'index';
+const SERVER_BUNDLE_DIRECTORY = 'bundles';
+const SERVER_RENDER_FUNCTION_NAME = 'serverRender';
+const SERVER_PLUGIN_BFF = '@modern-js/plugin-bff';
+const SERVER_PLUGIN_POLYFILL = '@modern-js/plugin-polyfill';
+export { DEFAULT_ENTRY_NAME, HTML_CHUNKSMAP_SEPARATOR, LOADER_REPORTER_NAME, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST, ROUTE_MODULES, ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, SERVER_PLUGIN_BFF, SERVER_PLUGIN_POLYFILL, SERVER_RENDER_FUNCTION_NAME };

package/dist/{esm-node/universal/index.js → esm/universal/index.mjs}

@@ -1,4 +1,2 @@
 import { cutNameByHyphen } from "./path";
-export {
-  cutNameByHyphen
-};
+export { cutNameByHyphen };

package/dist/esm/universal/path.mjs

@@ -0,0 +1,2 @@
+const cutNameByHyphen = (s)=>s.split(/[-_]/)[0];
+export { cutNameByHyphen };

package/dist/esm/universal/pluginDagSort.mjs

@@ -0,0 +1,41 @@
+const pluginDagSort = (plugins, key = 'name', preKey = 'pre', postKey = 'post')=>{
+    let allLines = [];
+    function getPluginByAny(q) {
+        const target = plugins.find((item)=>'string' == typeof q ? item[key] === q : item[key] === q[key]);
+        if (!target) throw new Error(`plugin ${q} not existed`);
+        return target;
+    }
+    plugins.forEach((item)=>{
+        item[preKey]?.forEach((p)=>{
+            if (plugins.find((ap)=>ap.name === p)) allLines.push([
+                getPluginByAny(p)[key],
+                getPluginByAny(item)[key]
+            ]);
+        });
+        item[postKey]?.forEach((pt)=>{
+            if (plugins.find((ap)=>ap.name === pt)) allLines.push([
+                getPluginByAny(item)[key],
+                getPluginByAny(pt)[key]
+            ]);
+        });
+    });
+    let zeroEndPoints = plugins.filter((item)=>!allLines.find((l)=>l[1] === item[key]));
+    const sortedPoint = [];
+    while(zeroEndPoints.length){
+        const zep = zeroEndPoints.shift();
+        sortedPoint.push(getPluginByAny(zep));
+        allLines = allLines.filter((l)=>l[0] !== getPluginByAny(zep)[key]);
+        const restPoints = plugins.filter((item)=>!sortedPoint.find((sp)=>sp[key] === item[key]));
+        zeroEndPoints = restPoints.filter((item)=>!allLines.find((l)=>l[1] === item[key]));
+    }
+    if (allLines.length) {
+        const restInRingPoints = {};
+        allLines.forEach((l)=>{
+            restInRingPoints[l[0]] = true;
+            restInRingPoints[l[1]] = true;
+        });
+        throw new Error(`plugins dependencies has loop: ${Object.keys(restInRingPoints).join(',')}`);
+    }
+    return sortedPoint;
+};
+export { pluginDagSort };

package/dist/esm-node/cli/alias.mjs

@@ -0,0 +1,31 @@
+import fs from "fs";
+import path from "path";
+import { applyOptionsChain } from "./applyOptionsChain.mjs";
+import { readTsConfigByFile } from "./get/index.mjs";
+const mergeAlias = (alias)=>applyOptionsChain({}, alias);
+const getAliasConfig = (aliasOption, option)=>{
+    const isTsProject = fs.existsSync(option.tsconfigPath);
+    const alias = mergeAlias(aliasOption);
+    if (!isTsProject) return {
+        absoluteBaseUrl: option.appDirectory,
+        paths: alias,
+        isTsPath: false,
+        isTsProject
+    };
+    const tsconfig = readTsConfigByFile(option.tsconfigPath);
+    const baseUrl = tsconfig?.compilerOptions?.baseUrl;
+    return {
+        absoluteBaseUrl: baseUrl ? path.join(option.appDirectory, baseUrl) : option.appDirectory,
+        paths: {
+            ...alias,
+            ...tsconfig?.compilerOptions?.paths
+        },
+        isTsPath: true,
+        isTsProject
+    };
+};
+const getUserAlias = (alias = {})=>Object.keys(alias).reduce((o, k)=>{
+        if (Array.isArray(alias[k])) o[k] = alias[k];
+        return o;
+    }, {});
+export { getAliasConfig, getUserAlias, mergeAlias };

package/dist/esm-node/cli/applyOptionsChain.mjs

@@ -0,0 +1,16 @@
+import { isFunction, isPlainObject } from "./is/index.mjs";
+import { logger } from "./logger.mjs";
+function applyOptionsChain(defaults, options, utils, mergeFn = Object.assign) {
+    if (!options) return defaults;
+    if (isPlainObject(options)) return mergeFn(defaults, options);
+    if (isFunction(options)) {
+        const ret = options(defaults, utils);
+        if (ret) {
+            if (!isPlainObject(ret)) logger.warn(`${options.name}: Function should mutate the config and return nothing, Or return a cloned or merged version of config object.`);
+            return ret;
+        }
+    } else if (Array.isArray(options)) return options.reduce((memo, cur)=>applyOptionsChain(memo, cur, utils, mergeFn), defaults);
+    else throw new Error(`applyOptionsChain error:\ndefault options is: ${JSON.stringify(defaults)}`);
+    return defaults;
+}
+export { applyOptionsChain };

package/dist/esm-node/cli/babel.mjs

@@ -0,0 +1,76 @@
+import { isAbsolute, sep } from "path";
+import { applyOptionsChain } from "./applyOptionsChain.mjs";
+import { ensureArray } from "./ensure.mjs";
+import { normalizeToPosixPath } from "./path.mjs";
+const formatPath = (originPath)=>{
+    if (isAbsolute(originPath)) return originPath.split(sep).join('/');
+    return originPath;
+};
+const getPluginItemName = (item)=>{
+    if ('string' == typeof item) return formatPath(item);
+    if (Array.isArray(item) && 'string' == typeof item[0]) return formatPath(item[0]);
+    return null;
+};
+const addPlugins = (plugins, config)=>{
+    if (config.plugins) config.plugins.push(...plugins);
+    else config.plugins = plugins;
+};
+const addPresets = (presets, config)=>{
+    if (config.presets) config.presets.push(...presets);
+    else config.presets = presets;
+};
+const removePlugins = (plugins, config)=>{
+    if (!config.plugins) return;
+    const removeList = ensureArray(plugins);
+    config.plugins = config.plugins.filter((item)=>{
+        const name = getPluginItemName(item);
+        if (name) return !removeList.find((removeItem)=>name.includes(removeItem));
+        return true;
+    });
+};
+const removePresets = (presets, config)=>{
+    if (!config.presets) return;
+    const removeList = ensureArray(presets);
+    config.presets = config.presets.filter((item)=>{
+        const name = getPluginItemName(item);
+        if (name) return !removeList.find((removeItem)=>name.includes(removeItem));
+        return true;
+    });
+};
+const modifyPresetOptions = (presetName, options, presets = [])=>{
+    presets.forEach((preset, index)=>{
+        if (Array.isArray(preset)) {
+            if ('string' == typeof preset[0] && normalizeToPosixPath(preset[0]).includes(presetName)) preset[1] = {
+                ...preset[1] || {},
+                ...options
+            };
+        } else if ('string' == typeof preset && normalizeToPosixPath(preset).includes(presetName)) presets[index] = [
+            preset,
+            options
+        ];
+    });
+};
+const getBabelUtils = (config)=>{
+    const noop = ()=>{};
+    return {
+        addPlugins: (plugins)=>addPlugins(plugins, config),
+        addPresets: (presets)=>addPresets(presets, config),
+        removePlugins: (plugins)=>removePlugins(plugins, config),
+        removePresets: (presets)=>removePresets(presets, config),
+        addIncludes: noop,
+        addExcludes: noop,
+        modifyPresetEnvOptions: (options)=>modifyPresetOptions('@babel/preset-env', options, config.presets || []),
+        modifyPresetReactOptions: (options)=>modifyPresetOptions('@babel/preset-react', options, config.presets || [])
+    };
+};
+const applyUserBabelConfig = (defaultOptions, userBabelConfig, extraBabelUtils)=>{
+    if (userBabelConfig) {
+        const babelUtils = {
+            ...getBabelUtils(defaultOptions),
+            ...extraBabelUtils
+        };
+        return applyOptionsChain(defaultOptions, userBabelConfig || {}, babelUtils);
+    }
+    return defaultOptions;
+};
+export { applyUserBabelConfig, getBabelUtils };

package/dist/esm-node/cli/commands.mjs

@@ -0,0 +1,23 @@
+import { logger } from "./logger.mjs";
+const getFullArgv = ()=>process.env.MODERN_ARGV?.split(' ') || process.argv;
+const getArgv = ()=>getFullArgv().slice(2);
+const getCommand = ()=>{
+    const args = getArgv();
+    const command = args[0];
+    return command;
+};
+const isDevCommand = ()=>{
+    const command = getCommand();
+    return 'dev' === command || 'start' === command;
+};
+const deprecatedCommands = (program)=>{
+    const lintCommand = program.commandsMap?.get('lint');
+    if (!lintCommand) program.command('lint [...files]').allowUnknownOption().description('Deprecated').action(()=>{
+        logger.warn('The "modern lint" command is deprecated, please use "eslint" or "biome" instead.');
+    });
+    const preCommitCommand = program.commandsMap?.get('pre-commit');
+    if (!preCommitCommand) program.command('pre-commit').description('Deprecated').action(()=>{
+        logger.warn('The "modern pre-commit" command is deprecated, please use "lint-staged" instead.');
+    });
+};
+export { deprecatedCommands, getArgv, getCommand, getFullArgv, isDevCommand };

package/dist/esm-node/cli/common.mjs

@@ -0,0 +1,11 @@
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+const index_js_namespaceObject = __rspack_createRequire_require("../../compiled/debug/index.js");
+const createDebugger = (scope)=>(0, index_js_namespaceObject.debug)(`modern-js:${scope}`);
+const clearConsole = ()=>{
+    if (process.stdout.isTTY && !process.env.DEBUG) process.stdout.write('\x1B[H\x1B[2J');
+};
+const wait = (time = 0)=>new Promise((resolve)=>{
+        setTimeout(resolve, time);
+    });
+export { clearConsole, createDebugger, wait };