@bleedingdev/modern-js-utils 3.2.0-ultramodern.0

package/dist/esm/cli/require.mjs

@@ -0,0 +1,79 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
+import { moduleResolve } from "import-meta-resolve";
+import { findExists } from "./fs.mjs";
+async function importPath(path) {
+    const modulePath = isAbsolute(path) ? pathToFileURL(path).href : path;
+    if ('development' !== process.env.NODE_ENV) return await import(modulePath);
+    {
+        const timestamp = Date.now();
+        return await import(`${modulePath}?t=${timestamp}`);
+    }
+}
+async function compatibleRequireESM(path, interop = true) {
+    if (path.endsWith('.json')) return JSON.parse(await readFile(path, 'utf8'));
+    const requiredModule = await importPath(path);
+    return interop ? requiredModule.default : requiredModule;
+}
+async function compatibleRequire(path, interop = true) {
+    return await compatibleRequireESM(path, interop);
+}
+async function loadFromProject(moduleName, appDir) {
+    let requiredModule;
+    const paths = [
+        appDir,
+        process.cwd()
+    ];
+    try {
+        const modulePath = tryResolve(moduleName, ...paths);
+        {
+            const moduleUrl = pathToFileURL(modulePath).href;
+            requiredModule = await import(moduleUrl);
+        }
+        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)=>{};
+const tryResolveESM = (name, ...resolvePath)=>{
+    const conditions = new Set([
+        'node',
+        'import',
+        'module',
+        'default'
+    ]);
+    for (const p of resolvePath)try {
+        return moduleResolve(name, pathToFileURL(`${p}/`), conditions, false).pathname.replace(/^\/(\w):/, '$1:');
+    } catch (err) {}
+    const err = new Error(`Can not find module ${name}.`);
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+};
+const tryResolve = (name, ...resolvePath)=>{
+    let filePath = '';
+    try {
+        filePath = tryResolveESM(name, ...resolvePath);
+    } catch (err) {
+        if ('MODULE_NOT_FOUND' === err.code) throw new Error(`Can not find module ${name}.`);
+        throw err;
+    }
+    return filePath;
+};
+export { cleanRequireCache, compatibleRequire, dynamicImport, loadFromProject, requireExistModule, tryResolve };

package/dist/esm/cli/route.mjs

@@ -0,0 +1,36 @@
+import { lodash } from "../compiled.mjs";
+const { cloneDeep: 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/runtimeExports.mjs

@@ -0,0 +1,42 @@
+import path from "path";
+import { fs } from "../compiled.mjs";
+import { normalizeOutputPath } from "./path.mjs";
+const memo = (fn)=>{
+    const cache = new Map();
+    return (...params)=>{
+        const stringifiedParams = JSON.stringify(params);
+        const cachedResult = cache.get(stringifiedParams);
+        if (cachedResult) return cachedResult;
+        const res = fn(...params);
+        cache.set(stringifiedParams, res);
+        return res;
+    };
+};
+const ensureRuntimeExportsFile = (filepath)=>{
+    fs.ensureDirSync(path.dirname(filepath));
+    if (!fs.existsSync(filepath)) fs.writeFileSync(filepath, 'export {};\n');
+};
+const formatRuntimeExports = (exportsList)=>{
+    if (0 === exportsList.length) return 'export {};\n';
+    return `${exportsList.join('\n')}\n`;
+};
+const flushRuntimeExports = (filepath, exportsSet)=>{
+    fs.writeFileSync(filepath, formatRuntimeExports(Array.from(exportsSet)));
+};
+const createRuntimeExportsUtils = memo((internalDirectory, filename)=>{
+    const filepath = path.resolve(internalDirectory, `${filename}.ts`);
+    const exportsSet = new Set();
+    ensureRuntimeExportsFile(filepath);
+    return {
+        addExport (exportStatement) {
+            const normalized = exportStatement?.trim();
+            if (!normalized) return;
+            exportsSet.add(normalized);
+            flushRuntimeExports(filepath, exportsSet);
+        },
+        getPath () {
+            return normalizeOutputPath(filepath);
+        }
+    };
+});
+export { createRuntimeExportsUtils };

package/dist/esm/cli/tsconfig.mjs

@@ -0,0 +1,7 @@
+import path from "path";
+import { TS_CONFIG_FILENAME } from "./constants.mjs";
+const resolveServerTsconfig = (appDirectory, configuredPath)=>{
+    if (configuredPath) return path.isAbsolute(configuredPath) ? configuredPath : path.resolve(appDirectory, configuredPath);
+    return path.resolve(appDirectory, TS_CONFIG_FILENAME);
+};
+export { resolveServerTsconfig };

package/dist/esm/cli/version.mjs

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

package/dist/esm/cli/watch.mjs

@@ -0,0 +1,40 @@
+import path from "path";
+import { chokidar } from "../compiled.mjs";
+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,45 @@
+import { createRequire } from "node:module";
+import { Import } from "./import.mjs";
+import { __webpack_require__ } from "./rslib-runtime.mjs";
+import chokidar from "../compiled/chokidar/index.js";
+import signale from "../compiled/signale/index.js";
+const { Signale: Signale } = signale;
+const getNodeRequire = ()=>{
+    try {
+        return /*#__PURE__*/ createRequire(import.meta.url);
+    } catch  {
+        if ('object' == typeof __webpack_require__.g && 'function' == typeof __webpack_require__.g.require) return __webpack_require__.g.require;
+        if ('object' == typeof globalThis && 'function' == typeof globalThis.require) return globalThis.require;
+        throw new Error('Unable to resolve require function for lazy compiled imports');
+    }
+};
+const mime = Import.lazy('../compiled/mime-types', getNodeRequire);
+const compiled_chokidar = chokidar;
+const inquirer = Import.lazy('../compiled/inquirer', getNodeRequire);
+export { default as address } from "../compiled/address/index.js";
+export { default as browserslist } from "../compiled/browserslist/index.js";
+export { default as chalk } from "../compiled/chalk/index.js";
+export { Command, program } from "../compiled/commander/index.mjs";
+export { default as debug } from "../compiled/debug/index.js";
+export { default as dotenv } from "../compiled/dotenv/index.js";
+export { default as dotenvExpand } from "../compiled/dotenv-expand/index.js";
+export { default as execa } from "../compiled/execa/index.js";
+export { default as fastGlob } from "../compiled/fast-glob/index.js";
+export { default as filesize } from "../compiled/filesize/index.js";
+export { default as fs } from "../compiled/fs-extra/index.js";
+export { default as glob } from "../compiled/glob/index.js";
+export { default as globby } from "../compiled/globby/index.js";
+export { default as gzipSize } from "../compiled/gzip-size/index.js";
+export { default as yaml } from "../compiled/js-yaml/index.mjs";
+export { default as json5 } from "../compiled/json5/index.js";
+export { default as lodash } from "../compiled/lodash/index.js";
+export { default as minimist } from "../compiled/minimist/index.js";
+export { nanoid } from "../compiled/nanoid/index.mjs";
+export { default as ora } from "../compiled/ora/index.js";
+export { default as pkgUp } from "../compiled/pkg-up/index.js";
+export { default as semver } from "../compiled/semver/index.js";
+export { default as slash } from "../compiled/slash/index.js";
+export { default as stripAnsi } from "../compiled/strip-ansi/index.js";
+export { default as upath } from "../compiled/upath/index.js";
+export { default as urlJoin } from "../compiled/url-join/index.js";
+export { Signale, compiled_chokidar as chokidar, inquirer, mime, signale };

package/dist/esm/import.mjs

@@ -0,0 +1,9 @@
+import import_lazy from "../compiled/import-lazy/index.js";
+const lazy = (moduleName, getRequireFn)=>{
+    const importLazyLocal = import_lazy(getRequireFn());
+    return importLazyLocal(moduleName);
+};
+const Import = {
+    lazy: lazy
+};
+export { Import, lazy as lazyImport };

package/dist/esm/index.mjs

@@ -0,0 +1,3 @@
+export * from "./cli/index.mjs";
+export * from "./compiled.mjs";
+export * from "./import.mjs";

package/dist/esm/rslib-runtime.mjs

@@ -0,0 +1,12 @@
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.g = (()=>{
+        if ('object' == typeof globalThis) return globalThis;
+        try {
+            return this || new Function('return this')();
+        } catch (e) {
+            if ('object' == typeof window) return window;
+        }
+    })();
+})();
+export { __webpack_require__ };

package/dist/esm/universal/constants.mjs

@@ -0,0 +1,14 @@
+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';
+const SSR_HYDRATION_ID_PREFIX = 'modern-js-';
+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, SSR_HYDRATION_ID_PREFIX };

package/dist/esm/universal/index.mjs

@@ -0,0 +1 @@
+export { cutNameByHyphen } from "./path.mjs";

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,32 @@
+import "node:module";
+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,17 @@
+import "node:module";
+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/commands.mjs

@@ -0,0 +1,24 @@
+import "node:module";
+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,10 @@
+import "node:module";
+import debug from "../../compiled/debug/index.js";
+const createDebugger = (scope)=>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 };

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

@@ -0,0 +1,6 @@
+import "node:module";
+const isOverriddenConfigKey = (key)=>[
+        'removeConsole',
+        'baseUrl'
+    ].includes(key);
+export { isOverriddenConfigKey };

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

@@ -0,0 +1,31 @@
+import "node:module";
+const JS_EXTENSIONS = [
+    '.js',
+    '.ts',
+    '.jsx',
+    '.tsx'
+];
+const SERVER_WORKER_BUNDLE_DIRECTORY = 'worker';
+const ENTRY_NAME_PATTERN = '^[a-zA-Z0-9_-]+$';
+const LOADABLE_STATS_FILE = 'loadable-stats.json';
+const API_DIR = 'api';
+const DEFAULT_API_PREFIX = '/api';
+const SERVER_DIR = 'server';
+const SHARED_DIR = 'shared';
+const TS_CONFIG_FILENAME = 'tsconfig.json';
+const CONFIG_CACHE_DIR = './node_modules/.cache/bundle-require';
+const CONFIG_FILE_EXTENSIONS = [
+    '.js',
+    '.ts',
+    '.mjs'
+];
+const OUTPUT_CONFIG_FILE = 'modern.config.json';
+const DEFAULT_RUNTIME_CONFIG = 'modern.runtime';
+const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
+const LOADER_ROUTES_DIR = "loader-routes";
+const DEFAULT_DEV_HOST = '0.0.0.0';
+const INTERNAL_RUNTIME_PLUGINS = {
+    '@modern-js/runtime': '@modern-js/runtime/cli'
+};
+export { DEFAULT_ENTRY_NAME, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, SERVER_PLUGIN_BFF, SERVER_PLUGIN_POLYFILL, SERVER_RENDER_FUNCTION_NAME } from "../universal/constants.mjs";
+export { API_DIR, CONFIG_CACHE_DIR, CONFIG_FILE_EXTENSIONS, DEFAULT_API_PREFIX, DEFAULT_DEV_HOST, DEFAULT_RUNTIME_CONFIG, ENTRY_NAME_PATTERN, INTERNAL_RUNTIME_PLUGINS, JS_EXTENSIONS, LOADABLE_STATS_FILE, LOADER_ROUTES_DIR, OUTPUT_CONFIG_FILE, ROUTE_MANIFEST_FILE, SERVER_DIR, SERVER_WORKER_BUNDLE_DIRECTORY, SHARED_DIR, TS_CONFIG_FILENAME };

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

@@ -0,0 +1,10 @@
+import "node:module";
+import path from "path";
+const ensureAbsolutePath = (base, filePath)=>path.isAbsolute(filePath) ? filePath : path.resolve(base, filePath);
+const ensureArray = (params)=>{
+    if (Array.isArray(params)) return params;
+    return [
+        params
+    ];
+};
+export { ensureAbsolutePath, ensureArray };

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

@@ -0,0 +1,10 @@
+import "node:module";
+import { fs } from "../compiled.mjs";
+const findExists = (files)=>{
+    for (const file of files)if (fs.existsSync(file) && fs.statSync(file).isFile()) return file;
+    return false;
+};
+const emptyDir = async (dir)=>{
+    if (await fs.pathExists(dir)) await fs.emptyDir(dir);
+};
+export { emptyDir, findExists };

package/dist/esm-node/cli/get/config.mjs

@@ -0,0 +1,15 @@
+import "node:module";
+import { isPlainObject } from "../is/index.mjs";
+const getEntryOptions = (name, isMainEntry, baseOptions, optionsByEntries, packageName)=>{
+    if (!optionsByEntries) return baseOptions;
+    {
+        let optionsByEntry = getOptionsByEntryName(name, optionsByEntries);
+        if (void 0 === optionsByEntry && isMainEntry && packageName) optionsByEntry = getOptionsByEntryName(packageName, optionsByEntries);
+        return void 0 !== optionsByEntry ? isPlainObject(optionsByEntry) && isPlainObject(baseOptions) ? {
+            ...baseOptions,
+            ...optionsByEntry
+        } : optionsByEntry : baseOptions;
+    }
+};
+const getOptionsByEntryName = (name, optionsByEntries)=>optionsByEntries.hasOwnProperty(name) ? optionsByEntries[name] : void 0;
+export { getEntryOptions };

package/dist/esm-node/cli/get/data.mjs

@@ -0,0 +1,50 @@
+import "node:module";
+import os from "os";
+import path from "path";
+import { fs, json5 } from "../../compiled.mjs";
+import { isDepExists } from "../is/index.mjs";
+import { canUsePnpm, canUseYarn } from "../package.mjs";
+const MAX_TIMES = 5;
+async function getPackageManager(cwd = process.cwd()) {
+    let appDirectory = cwd;
+    let times = 0;
+    while(os.homedir() !== appDirectory && times < MAX_TIMES){
+        times++;
+        if (fs.existsSync(path.resolve(appDirectory, 'pnpm-lock.yaml'))) return 'pnpm';
+        if (fs.existsSync(path.resolve(appDirectory, 'yarn.lock'))) return 'yarn';
+        if (fs.existsSync(path.resolve(appDirectory, 'package-lock.json'))) return 'npm';
+        appDirectory = path.join(appDirectory, '..');
+    }
+    if (await canUsePnpm()) return 'pnpm';
+    if (await canUseYarn()) return 'yarn';
+    return 'npm';
+}
+const getCoreJsVersion = (corejsPkgPath)=>{
+    try {
+        const { version } = fs.readJSONSync(corejsPkgPath);
+        const [major, minor] = version.split('.');
+        return `${major}.${minor}`;
+    } catch (err) {
+        return '3';
+    }
+};
+function getInternalPlugins(appDirectory, internalPlugins = {}) {
+    return [
+        ...Object.keys(internalPlugins).filter((name)=>{
+            const config = internalPlugins[name];
+            if (config && 'string' != typeof config && true === config.forced) return true;
+            return isDepExists(appDirectory, name);
+        }).map((name)=>{
+            const config = internalPlugins[name];
+            if (config && 'string' != typeof config) return config.path;
+            if ('string' == typeof config) return config;
+            return name;
+        })
+    ];
+}
+const readTsConfig = (root)=>readTsConfigByFile(path.resolve(root, './tsconfig.json'));
+const readTsConfigByFile = (filename)=>{
+    const content = fs.readFileSync(path.resolve(filename), 'utf-8');
+    return json5.parse(content);
+};
+export { getCoreJsVersion, getInternalPlugins, getPackageManager, readTsConfig, readTsConfigByFile };

package/dist/esm-node/cli/get/index.mjs

@@ -0,0 +1,19 @@
+import "node:module";
+import path from "path";
+import { CONFIG_FILE_EXTENSIONS } from "../constants.mjs";
+import { findExists } from "../fs.mjs";
+export * from "./config.mjs";
+export * from "./data.mjs";
+const getServerConfig = async (appDirectory, configFile)=>{
+    const configFilePath = findExists(CONFIG_FILE_EXTENSIONS.map((extension)=>path.resolve(appDirectory, `${configFile}${extension}`)));
+    return configFilePath;
+};
+const getMeta = (metaName = 'modern-js')=>{
+    const meta = metaName.toLowerCase().split('-')[0];
+    return meta;
+};
+const getTargetDir = (from, baseDir, targetBaseDir)=>{
+    const relativePath = path.relative(baseDir, from);
+    return path.resolve(targetBaseDir, relativePath);
+};
+export { getMeta, getServerConfig, getTargetDir };

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

@@ -0,0 +1,24 @@
+import "node:module";
+export * from "./alias.mjs";
+export * from "./applyOptionsChain.mjs";
+export * from "./commands.mjs";
+export * from "./common.mjs";
+export * from "./config.mjs";
+export * from "./constants.mjs";
+export * from "./ensure.mjs";
+export * from "./fs.mjs";
+export * from "./get/index.mjs";
+export * from "./is/index.mjs";
+export * from "./logger.mjs";
+export * from "./modulePath.mjs";
+export * from "./monorepo.mjs";
+export * from "./package.mjs";
+export * from "./path.mjs";
+export * from "./port.mjs";
+export * from "./prettyInstructions.mjs";
+export * from "./require.mjs";
+export * from "./route.mjs";
+export * from "./runtimeExports.mjs";
+export * from "./tsconfig.mjs";
+export * from "./version.mjs";
+export * from "./watch.mjs";