@modern-js/utils 2.69.5 → 3.0.0-alpha.0

package/dist/esm/cli/alias.mjs

@@ -0,0 +1,31 @@
+import fs from "fs";
+import path from "path";
+import { applyOptionsChain } from "./applyOptionsChain";
+import { readTsConfigByFile } from "./get";
+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/cli/applyOptionsChain.mjs

@@ -0,0 +1,16 @@
+import { isFunction, isPlainObject } from "./is";
+import { logger } from "./logger";
+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/cli/babel.mjs

@@ -0,0 +1,76 @@
+import { isAbsolute, sep } from "path";
+import { applyOptionsChain } from "./applyOptionsChain";
+import { ensureArray } from "./ensure";
+import { normalizeToPosixPath } from "./path";
+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/cli/commands.mjs

@@ -0,0 +1,23 @@
+import { logger } from "./logger";
+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/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 };

package/dist/esm/cli/config.mjs

@@ -0,0 +1,5 @@
+const isOverriddenConfigKey = (key)=>[
+        'removeConsole',
+        'baseUrl'
+    ].includes(key);
+export { isOverriddenConfigKey };

package/dist/esm/cli/constants.mjs

@@ -0,0 +1,29 @@
+import { 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";
+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 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 { API_DIR, CONFIG_CACHE_DIR, CONFIG_FILE_EXTENSIONS, DEFAULT_API_PREFIX, DEFAULT_DEV_HOST, DEFAULT_ENTRY_NAME, DEFAULT_RUNTIME_CONFIG, ENTRY_NAME_PATTERN, INTERNAL_RUNTIME_PLUGINS, JS_EXTENSIONS, LOADABLE_STATS_FILE, LOADER_ROUTES_DIR, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, OUTPUT_CONFIG_FILE, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, SERVER_DIR, SERVER_PLUGIN_BFF, SERVER_PLUGIN_POLYFILL, SERVER_RENDER_FUNCTION_NAME, SERVER_WORKER_BUNDLE_DIRECTORY, SHARED_DIR };

package/dist/esm/cli/ensure.mjs

@@ -0,0 +1,9 @@
+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/cli/fs.mjs

@@ -0,0 +1,9 @@
+import { fs } from "../compiled";
+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/cli/get/config.mjs

@@ -0,0 +1,14 @@
+import { isPlainObject } from "../is";
+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/cli/get/data.mjs

@@ -0,0 +1,57 @@
+import os from "os";
+import path from "path";
+import { browserslist, fs, json5 } from "../../compiled";
+import { isDepExists } from "../is";
+import { canUsePnpm, canUseYarn } from "../package";
+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';
+    }
+};
+const defaults = [
+    'chrome >= 87',
+    'edge >= 88',
+    'firefox >= 78',
+    'safari >= 14'
+];
+const getBrowserslist = (appDirectory)=>browserslist.loadConfig({
+        path: appDirectory
+    }) || defaults;
+function getInternalPlugins(appDirectory, internalPlugins = {}) {
+    return [
+        ...Object.keys(internalPlugins).filter((name)=>{
+            const config = internalPlugins[name];
+            if ('string' != typeof config && true === config.forced) return true;
+            return isDepExists(appDirectory, name);
+        }).map((name)=>{
+            const config = internalPlugins[name];
+            if ('string' != typeof config) return config.path;
+            return config;
+        })
+    ];
+}
+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 { defaults, getBrowserslist, getCoreJsVersion, getInternalPlugins, getPackageManager, readTsConfig, readTsConfigByFile };

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

@@ -0,0 +1,18 @@
+import path from "path";
+import { CONFIG_FILE_EXTENSIONS } from "../constants";
+import { findExists } from "../fs";
+export * from "./data";
+export * from "./config";
+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.js → esm/cli/index.mjs}

@@ -18,6 +18,5 @@ export * from "./require";
 export * from "./runtimeExports";
 export * from "./watch";
 export * from "./config";
-export * from "./action";
 export * from "./version";
 export * from "./route";

package/dist/esm/cli/is/config.mjs

@@ -0,0 +1,34 @@
+import { MAIN_ENTRY_NAME } from "../constants";
+import { isEmpty } from "./type";
+const isSSR = (config)=>{
+    const { server } = config;
+    if (server?.ssr) return true;
+    if (server?.ssrByEntries && !isEmpty(server.ssrByEntries)) {
+        for (const name of Object.keys(server.ssrByEntries))if (server.ssrByEntries[name]) return true;
+    }
+    return false;
+};
+const isUseSSRBundle = (config)=>{
+    const { output } = config;
+    if (output?.ssg || output?.ssgByEntries && Object.keys(output?.ssgByEntries).length > 0) return true;
+    return isSSR(config);
+};
+const isUseRsc = (config)=>config?.server?.rsc;
+const isServiceWorker = (config)=>{
+    const { output, deploy } = config;
+    if (deploy?.worker?.ssr && (output?.ssg || isSSR(config))) return true;
+    return false;
+};
+const isSSGEntry = (config, entryName, entrypoints)=>{
+    const { output, source } = config;
+    const single = isSingleEntry(entrypoints, source?.mainEntryName);
+    if (single) {
+        const byEntries = output?.ssgByEntries;
+        return Boolean(output?.ssg) || byEntries && !isEmpty(byEntries);
+    }
+    const byEntries = output?.ssgByEntries;
+    if (!byEntries || isEmpty(byEntries)) return false;
+    return Boolean(byEntries[entryName]);
+};
+const isSingleEntry = (entrypoints, mainEntryName = MAIN_ENTRY_NAME)=>1 === entrypoints.length && entrypoints[0].entryName === mainEntryName;
+export { isSSGEntry, isSSR, isServiceWorker, isSingleEntry, isUseRsc, isUseSSRBundle };

package/dist/esm/cli/is/env.mjs

@@ -0,0 +1,6 @@
+const getNodeEnv = ()=>process.env.NODE_ENV || 'development';
+const isDev = ()=>'development' === getNodeEnv();
+const isProd = ()=>'production' === getNodeEnv();
+const isTest = ()=>'test' === getNodeEnv();
+const isBrowser = ()=>"u" > typeof window;
+export { getNodeEnv, isBrowser, isDev, isProd, isTest };

package/dist/esm/cli/is/project.mjs

@@ -0,0 +1,104 @@
+import path from "path";
+import { fs, minimist, semver } from "../../compiled";
+import { getArgv } from "../commands";
+import { createDebugger } from "../common";
+import { ensureArray } from "../ensure";
+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/pkg-up/index.js");
+var index_js_default = /*#__PURE__*/ __webpack_require__.n(index_js_namespaceObject);
+const debug = createDebugger('judge-depExists');
+const isDepExists = (appDirectory, name)=>{
+    const pkgPath = path.resolve(appDirectory, './package.json');
+    if (!fs.existsSync(pkgPath)) {
+        debug("can't find package.json under: %s", appDirectory);
+        return false;
+    }
+    const json = require(pkgPath);
+    const { dependencies = {}, devDependencies = {} } = json;
+    return dependencies.hasOwnProperty(name) || devDependencies.hasOwnProperty(name);
+};
+const isPackageInstalled = (name, resolvePaths)=>{
+    try {
+        require.resolve(name, {
+            paths: ensureArray(resolvePaths)
+        });
+        return true;
+    } catch (err) {
+        return false;
+    }
+};
+const isApiOnly = async (appDirectory, entryDir, apiDir)=>{
+    const existApi = await fs.pathExists(apiDir ?? path.join(appDirectory, 'api'));
+    const existSrc = await fs.pathExists(path.join(appDirectory, entryDir ?? 'src'));
+    const options = minimist(getArgv());
+    if (options['api-only']) return true;
+    return existApi && !existSrc;
+};
+const isWebOnly = async ()=>{
+    const options = minimist(getArgv());
+    return Boolean(options['web-only']);
+};
+const isVersionBeyond17 = (version)=>semver.gte(semver.minVersion(version), '17.0.0');
+const getReactVersion = (cwd)=>{
+    const pkgPath = index_js_default().sync({
+        cwd
+    });
+    if (!pkgPath) return false;
+    const pkgInfo = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const deps = {
+        ...pkgInfo.devDependencies,
+        ...pkgInfo.dependencies
+    };
+    if ('string' != typeof deps.react) return false;
+    try {
+        const reactPath = require.resolve('react/package.json', {
+            paths: [
+                cwd
+            ]
+        });
+        const reactVersion = JSON.parse(fs.readFileSync(reactPath, 'utf8')).version;
+        return reactVersion;
+    } catch (error) {
+        console.error('Failed to resolve React version:', error);
+        return false;
+    }
+};
+const isBeyondReact17 = (cwd)=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return isVersionBeyond17(reactVersion);
+};
+const isSupportAutomaticJsx = (cwd)=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return semver.satisfies(semver.minVersion(reactVersion), '>=16.14.0');
+};
+const isReact18 = (cwd = process.cwd())=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return semver.gte(semver.minVersion(reactVersion), '18.0.0');
+};
+const isTypescript = (root)=>fs.existsSync(path.resolve(root, './tsconfig.json'));
+export { getReactVersion, isApiOnly, isBeyondReact17, isDepExists, isPackageInstalled, isReact18, isSupportAutomaticJsx, isTypescript, isVersionBeyond17, isWebOnly };

package/dist/esm/cli/is/type.mjs

@@ -0,0 +1,26 @@
+function isString(str) {
+    return 'string' == typeof str;
+}
+function isUndefined(obj) {
+    return void 0 === obj;
+}
+function isArray(obj) {
+    return Array.isArray(obj);
+}
+function isFunction(func) {
+    return 'function' == typeof func;
+}
+function isObject(obj) {
+    return null !== obj && 'object' == typeof obj;
+}
+function isPlainObject(obj) {
+    return isObject(obj) && '[object Object]' === Object.prototype.toString.call(obj);
+}
+function isPromise(obj) {
+    return Boolean(obj) && ('object' == typeof obj || 'function' == typeof obj) && 'function' == typeof obj.then;
+}
+function isRegExp(obj) {
+    return '[object RegExp]' === Object.prototype.toString.call(obj);
+}
+const isEmpty = (o)=>0 === Object.entries(o).length && o.constructor === Object;
+export { isArray, isEmpty, isFunction, isObject, isPlainObject, isPromise, isRegExp, isString, isUndefined };

package/dist/esm/cli/logger.mjs

@@ -0,0 +1,2 @@
+import { createLogger, logger } from "rslog";
+export { createLogger, logger };

package/dist/esm/cli/monorepo.mjs

@@ -0,0 +1,50 @@
+import fs from "fs";
+import path from "path";
+import { glob, yaml } from "../compiled";
+const PACKAGE_MAX_DEPTH = 5;
+const WORKSPACE_FILES = {
+    YARN: 'package.json',
+    PNPM: 'pnpm-workspace.yaml',
+    LERNA: 'lerna.json'
+};
+const isLerna = (root)=>fs.existsSync(path.join(root, WORKSPACE_FILES.LERNA));
+const isYarnWorkspaces = (root)=>{
+    const pkg = path.join(root, WORKSPACE_FILES.YARN);
+    if (!fs.existsSync(pkg)) return false;
+    const json = JSON.parse(fs.readFileSync(pkg, 'utf8'));
+    return Boolean(json.workspaces?.packages);
+};
+const isPnpmWorkspaces = (root)=>fs.existsSync(path.join(root, WORKSPACE_FILES.PNPM));
+const isMonorepo = (root)=>isLerna(root) || isYarnWorkspaces(root) || isPnpmWorkspaces(root);
+const findMonorepoRoot = (appDirectory, maxDepth = PACKAGE_MAX_DEPTH)=>{
+    let inMonorepo = false;
+    let monorepoRoot = appDirectory;
+    for(let depth = 0; depth < maxDepth; depth++){
+        if (isMonorepo(appDirectory)) {
+            inMonorepo = true;
+            break;
+        }
+        monorepoRoot = path.dirname(appDirectory);
+    }
+    return inMonorepo ? monorepoRoot : void 0;
+};
+const getMonorepoPackages = (root)=>{
+    let packages = [];
+    if (isYarnWorkspaces(root)) {
+        const json = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+        ({ packages } = json.workspaces);
+    } else if (isLerna(root)) {
+        const json = JSON.parse(fs.readFileSync(path.resolve(root, 'lerna.json'), 'utf8'));
+        ({ packages } = json);
+    } else ({ packages } = yaml.load(fs.readFileSync(path.join(root, WORKSPACE_FILES.PNPM), 'utf8')));
+    if (packages) return packages.map((name)=>glob.sync(path.join(root, `${name}/`), {
+            ignore: [
+                '**/node_modules/**'
+            ]
+        })).reduce((acc, val)=>acc.concat(val), []).filter((filepath)=>fs.existsSync(path.resolve(filepath, 'package.json'))).map((filepath)=>({
+            path: filepath,
+            name: JSON.parse(fs.readFileSync(path.resolve(filepath, 'package.json'), 'utf8')).name
+        }));
+    return [];
+};
+export { findMonorepoRoot, getMonorepoPackages, isLerna, isMonorepo, isPnpmWorkspaces, isYarnWorkspaces };

package/dist/esm/cli/package.mjs

@@ -0,0 +1,51 @@
+import { execa } from "../compiled";
+async function getPnpmVersion() {
+    const { stdout } = await execa('pnpm', [
+        '--version'
+    ]);
+    return stdout;
+}
+async function canUseNpm() {
+    try {
+        await execa('npm', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+async function canUseYarn() {
+    try {
+        await execa('yarn', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+async function canUsePnpm() {
+    try {
+        await execa('pnpm', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function removeModuleSyncFromExports(exports) {
+    if ('object' != typeof exports || null === exports) return exports;
+    if (Array.isArray(exports)) return exports.map(removeModuleSyncFromExports);
+    const result = {};
+    for (const [key, value] of Object.entries(exports))if ('module-sync' !== key) result[key] = removeModuleSyncFromExports(value);
+    return result;
+}
+export { canUseNpm, canUsePnpm, canUseYarn, getPnpmVersion, removeModuleSyncFromExports };

package/dist/esm/cli/path.mjs

@@ -0,0 +1,35 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { nanoid, upath } from "../compiled";
+const isPathString = (test)=>path.posix.basename(test) !== test || path.win32.basename(test) !== test;
+const isRelativePath = (test)=>/^\.\.?($|[\\/])/.test(test);
+const normalizeOutputPath = (s)=>s.replace(/\\/g, '\\\\');
+const normalizeToPosixPath = (p)=>upath.normalizeSafe(path.normalize(p || '')).replace(/^([a-zA-Z]+):/, (_, m)=>`/${m.toLowerCase()}`);
+const getTemplatePath = (prefix)=>{
+    const tmpRoot = fs.realpathSync(os.tmpdir());
+    const parts = [
+        tmpRoot
+    ];
+    prefix && parts.push(prefix);
+    parts.push(nanoid());
+    return path.resolve(...parts);
+};
+function getRealTemporaryDirectory() {
+    let ret = null;
+    try {
+        ret = os.tmpdir();
+        ret = fs.realpathSync(ret);
+    } catch  {}
+    return ret;
+}
+function splitPathString(str) {
+    return str.split(/[\\/]/);
+}
+const removeLeadingSlash = (s)=>s.replace(/^\/+/, '');
+const removeTailSlash = (s)=>s.replace(/\/+$/, '');
+const removeSlash = (s)=>removeLeadingSlash(removeTailSlash(s));
+function formatImportPath(str) {
+    return str.replace(/\\/g, '/');
+}
+export { formatImportPath, getRealTemporaryDirectory, getTemplatePath, isPathString, isRelativePath, normalizeOutputPath, normalizeToPosixPath, removeLeadingSlash, removeSlash, removeTailSlash, splitPathString };