@modern-js/core 1.7.1-beta.peer.1 → 1.9.0

package/dist/index.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAppContext = exports.initAppDir = exports.cli = exports.mergeOptions = exports.useResolvedConfigContext = exports.useConfigContext = exports.useAppContext = exports.ResolvedConfigContext = exports.ConfigContext = exports.AppContext = exports.registerHook = exports.createPlugin = exports.usePlugins = exports.mountHook = exports.manager = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@modern-js/utils");
+const node_1 = require("@modern-js/plugin/node");
+const commander_1 = require("./utils/commander");
+const config_1 = require("./config");
+const loadPlugins_1 = require("./loadPlugins");
+const context_1 = require("./context");
+Object.defineProperty(exports, "initAppContext", { enumerable: true, get: function () { return context_1.initAppContext; } });
+const initWatcher_1 = require("./initWatcher");
+const loadEnv_1 = require("./loadEnv");
+const manager_1 = require("./manager");
+__exportStar(require("./config"), exports);
+__exportStar(require("@modern-js/plugin"), exports);
+__exportStar(require("@modern-js/plugin/node"), exports);
+// TODO: remove export after refactor all plugins
+var manager_2 = require("./manager");
+Object.defineProperty(exports, "manager", { enumerable: true, get: function () { return manager_2.manager; } });
+Object.defineProperty(exports, "mountHook", { enumerable: true, get: function () { return manager_2.mountHook; } });
+Object.defineProperty(exports, "usePlugins", { enumerable: true, get: function () { return manager_2.usePlugins; } });
+Object.defineProperty(exports, "createPlugin", { enumerable: true, get: function () { return manager_2.createPlugin; } });
+Object.defineProperty(exports, "registerHook", { enumerable: true, get: function () { return manager_2.registerHook; } });
+// TODO: remove export after refactor all plugins
+var pluginAPI_1 = require("./pluginAPI");
+Object.defineProperty(exports, "AppContext", { enumerable: true, get: function () { return pluginAPI_1.AppContext; } });
+Object.defineProperty(exports, "ConfigContext", { enumerable: true, get: function () { return pluginAPI_1.ConfigContext; } });
+Object.defineProperty(exports, "ResolvedConfigContext", { enumerable: true, get: function () { return pluginAPI_1.ResolvedConfigContext; } });
+Object.defineProperty(exports, "useAppContext", { enumerable: true, get: function () { return pluginAPI_1.useAppContext; } });
+Object.defineProperty(exports, "useConfigContext", { enumerable: true, get: function () { return pluginAPI_1.useConfigContext; } });
+Object.defineProperty(exports, "useResolvedConfigContext", { enumerable: true, get: function () { return pluginAPI_1.useResolvedConfigContext; } });
+utils_1.program
+    .name('modern')
+    .usage('<command> [options]')
+    .version(process.env.MODERN_JS_VERSION || '0.1.0');
+const initAppDir = (cwd) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!cwd) {
+        // eslint-disable-next-line no-param-reassign
+        cwd = process.cwd();
+    }
+    const pkg = yield (0, utils_1.pkgUp)({ cwd });
+    if (!pkg) {
+        throw new Error(`no package.json found in current work dir: ${cwd}`);
+    }
+    return path_1.default.dirname(pkg);
+});
+exports.initAppDir = initAppDir;
+const mergeOptions = (options) => {
+    const defaultOptions = {
+        serverConfigFile: utils_1.DEFAULT_SERVER_CONFIG,
+    };
+    return Object.assign(Object.assign({}, defaultOptions), options);
+};
+exports.mergeOptions = mergeOptions;
+const createCli = () => {
+    let hooksRunner;
+    let isRestart = false;
+    let restartWithExistingPort = 0;
+    let restartOptions;
+    const init = (argv = [], options) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        (0, node_1.enable)();
+        manager_1.manager.clear();
+        const mergedOptions = (0, exports.mergeOptions)(options);
+        restartOptions = mergedOptions;
+        const appDirectory = yield initAppDir();
+        (0, commander_1.initCommandsMap)();
+        const metaName = (_b = (_a = mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.options) === null || _a === void 0 ? void 0 : _a.metaName) !== null && _b !== void 0 ? _b : 'MODERN';
+        (0, loadEnv_1.loadEnv)(appDirectory, process.env[`${metaName.toUpperCase()}_ENV`]);
+        const loaded = yield (0, config_1.loadUserConfig)(appDirectory, mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.configFile, mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.packageJsonConfig);
+        const plugins = (0, loadPlugins_1.loadPlugins)(appDirectory, loaded.config, {
+            internalPlugins: mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.plugins,
+            transformPlugin: mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.transformPlugin,
+        });
+        plugins.forEach(plugin => plugin.cli && manager_1.manager.usePlugin(plugin.cli));
+        const appContext = (0, context_1.initAppContext)({
+            appDirectory,
+            plugins,
+            configFile: loaded.filePath,
+            options: mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.options,
+            serverConfigFile: mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.serverConfigFile,
+        });
+        // 将 server.config 加入到 loaded.dependencies，以便对文件监听做热更新
+        (0, config_1.addServerConfigToDeps)(loaded.dependencies, appDirectory, mergedOptions.serverConfigFile);
+        manager_1.manager.run(() => {
+            context_1.ConfigContext.set(loaded.config);
+            context_1.AppContext.set(appContext);
+        });
+        hooksRunner = yield manager_1.manager.init();
+        ['SIGINT', 'SIGTERM', 'unhandledRejection', 'uncaughtException'].forEach(event => {
+            process.on(event, (err) => __awaiter(void 0, void 0, void 0, function* () {
+                yield hooksRunner.beforeExit();
+                if (err instanceof Error) {
+                    utils_1.logger.error(err.stack);
+                }
+                process.nextTick(() => {
+                    // eslint-disable-next-line no-process-exit
+                    process.exit(1);
+                });
+            }));
+        });
+        const extraConfigs = yield hooksRunner.config();
+        const extraSchemas = yield hooksRunner.validateSchema();
+        const config = yield (0, config_1.resolveConfig)(loaded, extraConfigs, extraSchemas, restartWithExistingPort, argv, options === null || options === void 0 ? void 0 : options.onSchemaError);
+        const { resolved } = yield hooksRunner.resolvedConfig({
+            resolved: config,
+        });
+        // update context value
+        manager_1.manager.run(() => {
+            context_1.ConfigContext.set(loaded.config);
+            context_1.ResolvedConfigContext.set(resolved);
+            context_1.AppContext.set(Object.assign(Object.assign({}, appContext), { port: resolved.server.port, distDirectory: (0, utils_1.ensureAbsolutePath)(appDirectory, resolved.output.path) }));
+        });
+        yield hooksRunner.prepare();
+        return { loadedConfig: loaded, appContext, resolved };
+    });
+    function run(argv, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { loadedConfig, appContext, resolved } = yield init(argv, options);
+            yield hooksRunner.commands({ program: utils_1.program });
+            (0, initWatcher_1.initWatcher)(loadedConfig, appContext.appDirectory, resolved.source.configDir, hooksRunner, argv);
+            manager_1.manager.run(() => utils_1.program.parse(process.argv));
+        });
+    }
+    function restart() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            isRestart = true;
+            restartWithExistingPort = isRestart ? (_b = (_a = context_1.AppContext.use().value) === null || _a === void 0 ? void 0 : _a.port) !== null && _b !== void 0 ? _b : 0 : 0;
+            utils_1.logger.info('Restart...\n');
+            let hasGetError = false;
+            const runner = manager_1.manager.useRunner();
+            yield runner.beforeRestart();
+            try {
+                yield init(process.argv.slice(2), restartOptions);
+            }
+            catch (err) {
+                console.error(err);
+                hasGetError = true;
+            }
+            finally {
+                if (!hasGetError) {
+                    manager_1.manager.run(() => utils_1.program.parse(process.argv));
+                }
+            }
+        });
+    }
+    return {
+        init,
+        run,
+        restart,
+    };
+};
+exports.cli = createCli();

package/dist/{types/initWatcher.d.ts → initWatcher.d.ts}

@@ -1,3 +1,3 @@
 import { LoadedConfig } from './config';
 import { HooksRunner } from './manager';
-export declare const initWatcher: (loaded: LoadedConfig, appDirectory: string, configDir: string | undefined, hooksRunner: HooksRunner, argv: string[]) => Promise<import("@modern-js/utils").FSWatcher | undefined>;
+export declare const initWatcher: (loaded: LoadedConfig, appDirectory: string, configDir: string | undefined, hooksRunner: HooksRunner, argv: string[]) => Promise<import("@modern-js/utils").FSWatcher | undefined>;

package/dist/initWatcher.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initWatcher = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@modern-js/utils");
+const debug = (0, utils_1.createDebugger)('watch-files');
+const md5 = (data) => crypto_1.default.createHash('md5').update(data).digest('hex');
+const hashMap = new Map();
+const initWatcher = (loaded, appDirectory, configDir, hooksRunner, argv) => __awaiter(void 0, void 0, void 0, function* () {
+    // only add fs watcher on dev mode.
+    if (((0, utils_1.isDev)() || (0, utils_1.isTest)()) && argv[0] === 'dev') {
+        const extraFiles = yield hooksRunner.watchFiles();
+        const configPath = path_1.default.join(appDirectory, configDir);
+        const watched = [
+            `${configPath}/html`,
+            ...extraFiles,
+            loaded === null || loaded === void 0 ? void 0 : loaded.filePath,
+            ...loaded.dependencies,
+        ].filter(Boolean);
+        debug(`watched: %o`, watched);
+        const watcher = utils_1.chokidar.watch(watched, {
+            cwd: appDirectory,
+            ignoreInitial: true,
+            ignorePermissionErrors: true,
+            ignored: [
+                /node_modules/,
+                '**/__test__/**',
+                '**/*.test.(js|jsx|ts|tsx)',
+                '**/*.spec.(js|jsx|ts|tsx)',
+                '**/*.stories.(js|jsx|ts|tsx)',
+            ],
+        });
+        watcher.on('change', changed => {
+            const lastHash = hashMap.get(changed);
+            const currentHash = md5(fs_1.default.readFileSync(path_1.default.join(appDirectory, changed), 'utf8'));
+            if (currentHash !== lastHash) {
+                debug(`file change: %s`, changed);
+                hashMap.set(changed, currentHash);
+                hooksRunner.fileChange({ filename: changed, eventType: 'change' });
+            }
+        });
+        watcher.on('add', name => {
+            debug(`add file: %s`, name);
+            const currentHash = md5(fs_1.default.readFileSync(path_1.default.join(appDirectory, name), 'utf8'));
+            hashMap.set(name, currentHash);
+            hooksRunner.fileChange({ filename: name, eventType: 'add' });
+        });
+        watcher.on('unlink', name => {
+            debug(`remove file: %s`, name);
+            if (hashMap.has(name)) {
+                hashMap.delete(name);
+            }
+            hooksRunner.fileChange({ filename: name, eventType: 'unlink' });
+        });
+        watcher.on('error', err => {
+            throw err;
+        });
+        return watcher;
+    }
+});
+exports.initWatcher = initWatcher;

package/dist/{types/loadEnv.d.ts → loadEnv.d.ts}

@@ -1 +1 @@
-export declare const loadEnv: (appDirectory: string, mode?: string) => void;
+export declare const loadEnv: (appDirectory: string, mode?: string) => void;

package/dist/loadEnv.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEnv = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@modern-js/utils");
+const loadEnv = (appDirectory, mode = process.env.NODE_ENV) => {
+    // Don't change the order of the filenames， since they are ordered by the priority.
+    // Files on the left have more priority than files on the right.
+    [`.env.${mode}.local`, '.env.local', `.env.${mode}`, '.env']
+        .map(name => path_1.default.resolve(appDirectory, name))
+        .filter(filePath => fs_1.default.existsSync(filePath) && !fs_1.default.statSync(filePath).isDirectory())
+        .forEach(filePath => {
+        const envConfig = utils_1.dotenv.config({ path: filePath });
+        (0, utils_1.dotenvExpand)(envConfig);
+    });
+};
+exports.loadEnv = loadEnv;

package/dist/{types/loadPlugins.d.ts → loadPlugins.d.ts}

@@ -3,30 +3,28 @@ import type { UserConfig } from './config';
 import { CliPlugin } from './manager';
 declare type PluginItem = string | [string, any];
 export declare type LoadedPlugin = {
-  cli?: CliPlugin;
-  server?: string;
-  serverPkg?: string;
+    cli?: CliPlugin;
+    server?: string;
+    serverPkg?: string;
 };
 export declare type TransformPlugin = (plugin: PluginConfig, resolvedConfig: UserConfig, pluginOptions?: any) => PluginConfig;
 /**
  * @deprecated
  * Using NewPluginConfig insteand.
  */
-
 declare type OldPluginConfig = Array<PluginItem | {
-  cli?: PluginItem;
-  server?: PluginItem;
+    cli?: PluginItem;
+    server?: PluginItem;
 }>;
 declare type NewPluginConfig = CliPlugin[] | {
-  cli?: CliPlugin[];
-  /** Custom server plugin is not supported yet. */
-
-  server?: never;
+    cli?: CliPlugin[];
+    /** Custom server plugin is not supported yet. */
+    server?: never;
 };
 export declare type PluginConfig = OldPluginConfig | NewPluginConfig;
 export declare function getAppPlugins(appDirectory: string, oldPluginConfig: OldPluginConfig, internalPlugins?: typeof INTERNAL_PLUGINS): (PluginItem | {
-  cli?: PluginItem | undefined;
-  server?: PluginItem | undefined;
+    cli?: PluginItem | undefined;
+    server?: PluginItem | undefined;
 })[];
 /**
  * Load internal plugins which in @modern-js scope and user's custom plugins.
@@ -36,9 +34,8 @@ export declare function getAppPlugins(appDirectory: string, oldPluginConfig: Old
  * @param options.transformPlugin - transform plugin before using it. Used for compatible with legacy jupiter plugins.
  * @returns Plugin Objects has been required.
  */
-
 export declare const loadPlugins: (appDirectory: string, userConfig: UserConfig, options?: {
-  internalPlugins?: typeof INTERNAL_PLUGINS;
-  transformPlugin?: TransformPlugin;
+    internalPlugins?: typeof INTERNAL_PLUGINS;
+    transformPlugin?: TransformPlugin;
 }) => LoadedPlugin[];
-export {};
+export {};

package/dist/loadPlugins.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPlugins = exports.getAppPlugins = void 0;
+const utils_1 = require("@modern-js/utils");
+const manager_1 = require("./manager");
+const debug = (0, utils_1.createDebugger)('load-plugins');
+/**
+ * Try to resolve plugin entry file path.
+ * @param name - Plugin name.
+ * @param appDirectory - Application root directory.
+ * @returns Resolved file path.
+ */
+const tryResolve = (name, appDirectory) => {
+    let filePath = '';
+    try {
+        filePath = require.resolve(name, { paths: [appDirectory] });
+        delete require.cache[filePath];
+    }
+    catch (err) {
+        if (err.code === 'MODULE_NOT_FOUND') {
+            throw new Error(`Can not find plugin ${name}.`);
+        }
+        throw err;
+    }
+    return filePath;
+};
+function getAppPlugins(appDirectory, oldPluginConfig, internalPlugins) {
+    const allPlugins = internalPlugins || utils_1.INTERNAL_PLUGINS;
+    const appPlugins = [
+        ...Object.keys(allPlugins)
+            .filter(name => {
+            const config = allPlugins[name];
+            if (config.forced === true) {
+                // 参考 packages/cli/core/src/cli.ts 文件
+                return true;
+            }
+            return (0, utils_1.isDepExists)(appDirectory, name);
+        })
+            .map(name => allPlugins[name]),
+        ...oldPluginConfig,
+    ];
+    return appPlugins;
+}
+exports.getAppPlugins = getAppPlugins;
+const resolveCliPlugin = (p, userConfig, appDirectory, transformPlugin) => {
+    const pkg = typeof p === 'string' ? p : p[0];
+    const pluginOptions = typeof p === 'string' ? undefined : p[1];
+    const path = tryResolve(pkg, appDirectory);
+    let module = (0, utils_1.compatRequire)(path);
+    if (transformPlugin) {
+        module = transformPlugin(module, userConfig, pluginOptions);
+    }
+    if (typeof module === 'function') {
+        const result = module(pluginOptions);
+        return (0, manager_1.createPlugin)(result.setup, result);
+    }
+    return module;
+};
+const isOldPluginConfig = (config) => Array.isArray(config) &&
+    config.some(item => {
+        if (typeof item === 'string' || Array.isArray(item)) {
+            return true;
+        }
+        return 'cli' in item || 'server' in item;
+    });
+/**
+ * Load internal plugins which in @modern-js scope and user's custom plugins.
+ * @param appDirectory - Application root directory.
+ * @param userConfig - Resolved user config.
+ * @param options.internalPlugins - Internal plugins.
+ * @param options.transformPlugin - transform plugin before using it. Used for compatible with legacy jupiter plugins.
+ * @returns Plugin Objects has been required.
+ */
+const loadPlugins = (appDirectory, userConfig, options = {}) => {
+    const pluginConfig = userConfig.plugins;
+    const plugins = getAppPlugins(appDirectory, isOldPluginConfig(pluginConfig) ? pluginConfig : [], options.internalPlugins);
+    const loadedPlugins = plugins.map(plugin => {
+        const _plugin = typeof plugin === 'string' || Array.isArray(plugin)
+            ? { cli: plugin }
+            : plugin;
+        const { cli, server } = _plugin;
+        const loadedPlugin = {};
+        if (cli) {
+            loadedPlugin.cli = resolveCliPlugin(cli, userConfig, appDirectory, options.transformPlugin);
+        }
+        // server plugins don't support to accept params
+        if (server && typeof server === 'string') {
+            loadedPlugin.server = server;
+            loadedPlugin.serverPkg = server;
+        }
+        debug(`resolve plugin %s: %s`, plugin, {
+            cli: loadedPlugin.cli,
+            server: loadedPlugin.server,
+        });
+        return loadedPlugin;
+    });
+    if (!isOldPluginConfig(pluginConfig)) {
+        const cliPlugins = Array.isArray(pluginConfig)
+            ? pluginConfig
+            : pluginConfig === null || pluginConfig === void 0 ? void 0 : pluginConfig.cli;
+        if (cliPlugins === null || cliPlugins === void 0 ? void 0 : cliPlugins.length) {
+            loadedPlugins.push(...cliPlugins.map(item => ({
+                cli: (0, manager_1.createPlugin)(item.setup, item),
+            })));
+        }
+    }
+    return loadedPlugins;
+};
+exports.loadPlugins = loadPlugins;

package/dist/manager.d.ts

@@ -0,0 +1,72 @@
+import { ToThreads, ToRunners, AsyncSetup, PluginOptions, AsyncWorkflow, AsyncWaterfall, ParallelWorkflow } from '@modern-js/plugin';
+import type { Hooks } from '@modern-js/types';
+import type { Command } from './utils/commander';
+import type { NormalizedConfig } from './config/mergeConfig';
+import type { UserConfig } from './config';
+import { pluginAPI } from './pluginAPI';
+export declare type HooksRunner = ToRunners<{
+    config: ParallelWorkflow<void, UserConfig>;
+    resolvedConfig: AsyncWaterfall<{
+        resolved: NormalizedConfig;
+    }>;
+    validateSchema: ParallelWorkflow<void>;
+    prepare: AsyncWorkflow<void, void>;
+    commands: AsyncWorkflow<{
+        program: Command;
+    }, void>;
+    watchFiles: ParallelWorkflow<void>;
+    fileChange: AsyncWorkflow<{
+        filename: string;
+        eventType: 'add' | 'change' | 'unlink';
+    }, void>;
+    beforeExit: AsyncWorkflow<void, void>;
+    beforeRestart: AsyncWorkflow<void, void>;
+}>;
+declare const baseHooks: {
+    config: ParallelWorkflow<void, UserConfig>;
+    resolvedConfig: AsyncWaterfall<{
+        resolved: NormalizedConfig;
+    }>;
+    validateSchema: ParallelWorkflow<void, unknown>;
+    prepare: AsyncWorkflow<void, void>;
+    commands: AsyncWorkflow<{
+        program: Command;
+    }, void>;
+    watchFiles: ParallelWorkflow<void, unknown>;
+    fileChange: AsyncWorkflow<{
+        filename: string;
+        eventType: 'add' | 'change' | 'unlink';
+    }, void>;
+    beforeExit: AsyncWorkflow<void, void>;
+    beforeRestart: AsyncWorkflow<void, void>;
+};
+/** All hooks of cli plugin. */
+export declare type CliHooks = typeof baseHooks & Hooks;
+/** All hook callbacks of cli plugin. */
+export declare type CliHookCallbacks = ToThreads<CliHooks>;
+export declare const manager: import("@modern-js/plugin").AsyncManager<CliHooks, {
+    setAppContext: (value: import("@modern-js/types").IAppContext) => void;
+    useAppContext: () => import("@modern-js/types").IAppContext;
+    useConfigContext: () => UserConfig;
+    useResolvedConfigContext: () => NormalizedConfig;
+}>;
+/** Plugin options of a cli plugin. */
+export declare type CliPlugin = PluginOptions<CliHooks, AsyncSetup<CliHooks, typeof pluginAPI>>;
+export declare const createPlugin: (setup?: AsyncSetup<CliHooks, {
+    setAppContext: (value: import("@modern-js/types").IAppContext) => void;
+    useAppContext: () => import("@modern-js/types").IAppContext;
+    useConfigContext: () => UserConfig;
+    useResolvedConfigContext: () => NormalizedConfig;
+}> | undefined, options?: PluginOptions<CliHooks, AsyncSetup<CliHooks, {
+    setAppContext: (value: import("@modern-js/types").IAppContext) => void;
+    useAppContext: () => import("@modern-js/types").IAppContext;
+    useConfigContext: () => UserConfig;
+    useResolvedConfigContext: () => NormalizedConfig;
+}>> | undefined) => import("@modern-js/plugin").AsyncPlugin<CliHooks, {
+    setAppContext: (value: import("@modern-js/types").IAppContext) => void;
+    useAppContext: () => import("@modern-js/types").IAppContext;
+    useConfigContext: () => UserConfig;
+    useResolvedConfigContext: () => NormalizedConfig;
+}>, registerHook: (newHooks: Partial<CliHooks>) => void, mountHook: () => ToRunners<CliHooks>;
+export declare const usePlugins: (plugins: string[]) => void;
+export {};

package/dist/manager.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePlugins = exports.mountHook = exports.registerHook = exports.createPlugin = exports.manager = void 0;
+const plugin_1 = require("@modern-js/plugin");
+const utils_1 = require("@modern-js/utils");
+const pluginAPI_1 = require("./pluginAPI");
+const baseHooks = {
+    config: (0, plugin_1.createParallelWorkflow)(),
+    resolvedConfig: (0, plugin_1.createAsyncWaterfall)(),
+    validateSchema: (0, plugin_1.createParallelWorkflow)(),
+    prepare: (0, plugin_1.createAsyncWorkflow)(),
+    commands: (0, plugin_1.createAsyncWorkflow)(),
+    watchFiles: (0, plugin_1.createParallelWorkflow)(),
+    fileChange: (0, plugin_1.createAsyncWorkflow)(),
+    beforeExit: (0, plugin_1.createAsyncWorkflow)(),
+    beforeRestart: (0, plugin_1.createAsyncWorkflow)(),
+};
+exports.manager = (0, plugin_1.createAsyncManager)(baseHooks, pluginAPI_1.pluginAPI);
+exports.createPlugin = exports.manager.createPlugin, exports.registerHook = exports.manager.registerHook, exports.mountHook = exports.manager.useRunner;
+const usePlugins = (plugins) => plugins.forEach(pluginPath => {
+    const module = (0, utils_1.compatRequire)(require.resolve(pluginPath));
+    exports.manager.usePlugin(module);
+});
+exports.usePlugins = usePlugins;

package/dist/{types/pluginAPI.d.ts → pluginAPI.d.ts}

@@ -2,12 +2,11 @@ import type { CommonAPI } from '@modern-js/plugin';
 import type { CliHooks } from './manager';
 import { AppContext, ConfigContext, useAppContext, useConfigContext, ResolvedConfigContext, useResolvedConfigContext } from './context';
 export declare const pluginAPI: {
-  setAppContext: (value: import("@modern-js/types/cli").IAppContext) => void;
-  useAppContext: () => import("@modern-js/types/cli").IAppContext;
-  useConfigContext: () => import("./config").UserConfig;
-  useResolvedConfigContext: () => import(".").NormalizedConfig;
+    setAppContext: (value: import("@modern-js/types/cli").IAppContext) => void;
+    useAppContext: () => import("@modern-js/types/cli").IAppContext;
+    useConfigContext: () => import("./config").UserConfig;
+    useResolvedConfigContext: () => import(".").NormalizedConfig;
 };
 /** all apis for cli plugin */
-
 export declare type PluginAPI = typeof pluginAPI & CommonAPI<CliHooks>;
-export { AppContext, ConfigContext, ResolvedConfigContext, useAppContext, useConfigContext, useResolvedConfigContext };
+export { AppContext, ConfigContext, ResolvedConfigContext, useAppContext, useConfigContext, useResolvedConfigContext, };

package/dist/pluginAPI.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useResolvedConfigContext = exports.useConfigContext = exports.useAppContext = exports.ResolvedConfigContext = exports.ConfigContext = exports.AppContext = exports.pluginAPI = void 0;
+const context_1 = require("./context");
+Object.defineProperty(exports, "AppContext", { enumerable: true, get: function () { return context_1.AppContext; } });
+Object.defineProperty(exports, "ConfigContext", { enumerable: true, get: function () { return context_1.ConfigContext; } });
+Object.defineProperty(exports, "useAppContext", { enumerable: true, get: function () { return context_1.useAppContext; } });
+Object.defineProperty(exports, "useConfigContext", { enumerable: true, get: function () { return context_1.useConfigContext; } });
+Object.defineProperty(exports, "ResolvedConfigContext", { enumerable: true, get: function () { return context_1.ResolvedConfigContext; } });
+Object.defineProperty(exports, "useResolvedConfigContext", { enumerable: true, get: function () { return context_1.useResolvedConfigContext; } });
+exports.pluginAPI = {
+    setAppContext: context_1.setAppContext,
+    useAppContext: context_1.useAppContext,
+    useConfigContext: context_1.useConfigContext,
+    useResolvedConfigContext: context_1.useResolvedConfigContext,
+};

package/dist/{types/utils → utils}/commander.d.ts

@@ -1,4 +1,4 @@
 import { program, Command } from '@modern-js/utils';
 export declare function initCommandsMap(): void;
 export type { Command };
-export { program };
+export { program };

package/dist/utils/commander.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.program = exports.initCommandsMap = void 0;
+const utils_1 = require("@modern-js/utils");
+Object.defineProperty(exports, "program", { enumerable: true, get: function () { return utils_1.program; } });
+function initCommandsMap() {
+    if (!utils_1.program.hasOwnProperty('commandsMap')) {
+        Object.defineProperty(utils_1.program, 'commandsMap', {
+            get() {
+                const map = new Map();
+                for (const command of utils_1.program.commands) {
+                    map.set(command._name, command);
+                }
+                return map;
+            },
+            configurable: false,
+        });
+    }
+}
+exports.initCommandsMap = initCommandsMap;

package/dist/{types/utils → utils}/repeatKeyWarning.d.ts

@@ -1,3 +1,3 @@
 import { UserConfig } from '../config';
 export declare const deepGet: (obj: any, key: string) => any;
-export declare const repeatKeyWarning: (schema: any, jsConfig: UserConfig, pkgConfig: UserConfig) => void;
+export declare const repeatKeyWarning: (schema: any, jsConfig: UserConfig, pkgConfig: UserConfig) => void;

package/dist/utils/repeatKeyWarning.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repeatKeyWarning = exports.deepGet = void 0;
+const schema_1 = require("../config/schema");
+const deepGet = (obj, key) => {
+    for (const p of key.split('.')) {
+        // eslint-disable-next-line no-param-reassign
+        obj = obj ? obj[p] : undefined;
+    }
+    return obj;
+};
+exports.deepGet = deepGet;
+const repeatKeyWarning = (schema, jsConfig, pkgConfig) => {
+    const keys = (0, schema_1.traverseSchema)(schema);
+    for (const key of keys) {
+        if ((0, exports.deepGet)(jsConfig, key) !== undefined &&
+            (0, exports.deepGet)(pkgConfig, key) !== undefined) {
+            throw new Error(`The same configuration ${key} exists in modern.config.js and package.json.\n Please remove it from package.json.`);
+        }
+    }
+};
+exports.repeatKeyWarning = repeatKeyWarning;