@modern-js/core 0.0.0-windows-20211056953 → 0.0.1-20221226

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runBin_1 = require("./runBin");
+(0, runBin_1.run)();

package/dist/config/createDefaultConfig.d.ts

@@ -0,0 +1,2 @@
+import { UserConfig } from '../types';
+export declare function createDefaultConfig(): UserConfig;

package/dist/config/createDefaultConfig.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultConfig = void 0;
+function createDefaultConfig() {
+    return {
+        autoLoadPlugins: false,
+    };
+}
+exports.createDefaultConfig = createDefaultConfig;

package/dist/config/createLoadedConfig.d.ts

@@ -0,0 +1,6 @@
+import { LoadedConfig, UserConfig, ConfigParams } from '../types';
+/**
+ * Assign the pkg config into the user config.
+ */
+export declare const assignPkgConfig: (userConfig?: UserConfig, pkgConfig?: ConfigParams) => UserConfig;
+export declare function createLoadedConfig(appDirectory: string, filePath?: string, packageJsonConfig?: string): Promise<LoadedConfig<{}>>;

package/dist/config/createLoadedConfig.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLoadedConfig = exports.assignPkgConfig = void 0;
+const lodash_1 = require("@modern-js/utils/lodash");
+const utils_1 = require("@modern-js/utils");
+const load_configs_1 = require("../load-configs");
+/**
+ * Assign the pkg config into the user config.
+ */
+const assignPkgConfig = (userConfig = {}, pkgConfig = {}) => (0, lodash_1.mergeWith)({}, userConfig, pkgConfig, (objValue, srcValue) => {
+    // mergeWith can not merge object with symbol, but plugins object contains symbol,
+    // so we need to handle it manually.
+    if (objValue === undefined && (0, utils_1.isPlainObject)(srcValue)) {
+        return { ...srcValue };
+    }
+    // return undefined to use the default behavior of mergeWith
+    return undefined;
+});
+exports.assignPkgConfig = assignPkgConfig;
+async function createLoadedConfig(appDirectory, filePath, packageJsonConfig) {
+    const loaded = await (0, load_configs_1.loadConfig)(appDirectory, filePath, packageJsonConfig);
+    const config = !loaded
+        ? {}
+        : await (typeof loaded.config === 'function'
+            ? loaded.config(0)
+            : loaded.config);
+    return {
+        config: (0, exports.assignPkgConfig)(config, loaded === null || loaded === void 0 ? void 0 : loaded.pkgConfig),
+        filePath: loaded.path,
+        dependencies: loaded.dependencies || [],
+        pkgConfig: loaded.pkgConfig || {},
+        jsConfig: config || {},
+    };
+}
+exports.createLoadedConfig = createLoadedConfig;

package/dist/config/createResolvedConfig.d.ts

@@ -0,0 +1,3 @@
+import type { ErrorObject } from '@modern-js/utils/ajv';
+import type { UserConfig, NormalizedConfig, LoadedConfig, PluginValidateSchema } from '../types';
+export declare const createResolveConfig: (loaded: LoadedConfig<{}>, configs: UserConfig[], schemas: PluginValidateSchema[], onSchemaError?: (error: ErrorObject) => void | Promise<void>) => Promise<NormalizedConfig>;

package/dist/config/createResolvedConfig.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResolveConfig = void 0;
+const utils_1 = require("@modern-js/utils");
+const constants_1 = require("@modern-js/utils/constants");
+const patchSchema_1 = require("../schema/patchSchema");
+const repeatKeyWarning_1 = require("../utils/repeatKeyWarning");
+const mergeConfig_1 = require("../utils/mergeConfig");
+const createDefaultConfig_1 = require("./createDefaultConfig");
+const debug = (0, utils_1.createDebugger)('resolve-config');
+const showAdditionalPropertiesError = async (error) => {
+    if (error.keyword === 'additionalProperties' &&
+        error.params.additionalProperty) {
+        const target = [
+            error.instancePath.slice(1),
+            error.params.additionalProperty,
+        ]
+            .filter(Boolean)
+            .join('.');
+        const name = Object.keys(constants_1.PLUGIN_SCHEMAS).find(key => constants_1.PLUGIN_SCHEMAS[key].some((schemaItem) => schemaItem.target === target));
+        if (name) {
+            const packageManager = await (0, utils_1.getPackageManager)();
+            utils_1.logger.warn(`The configuration of ${utils_1.chalk.bold(target)} is provided by plugin ${utils_1.chalk.bold(name)}. Please use ${utils_1.chalk.bold(`${packageManager} run new`)} to enable the corresponding capability.\n`);
+        }
+    }
+};
+const createResolveConfig = async (
+// eslint-disable-next-line @typescript-eslint/ban-types
+loaded, configs, schemas, onSchemaError = showAdditionalPropertiesError) => {
+    var _a;
+    const { default: Ajv } = await Promise.resolve().then(() => __importStar(require('@modern-js/utils/ajv')));
+    const { default: ajvKeywords } = await Promise.resolve().then(() => __importStar(require('@modern-js/utils/ajv-keywords')));
+    const { default: betterAjvErrors } = await Promise.resolve().then(() => __importStar(require('@modern-js/utils/better-ajv-errors')));
+    const { config: userConfig, jsConfig, pkgConfig } = loaded;
+    const ajv = new Ajv({ $data: true, strict: false });
+    ajvKeywords(ajv);
+    const validateSchema = (0, patchSchema_1.patchSchema)(schemas);
+    const validate = ajv.compile(validateSchema);
+    (0, repeatKeyWarning_1.repeatKeyWarning)(validateSchema, jsConfig, pkgConfig);
+    // validate user config.
+    const valid = validate(userConfig);
+    const formatValidateError = (config) => {
+        var _a;
+        return betterAjvErrors(validateSchema, config, (_a = validate.errors) === null || _a === void 0 ? void 0 : _a.map(e => ({
+            ...e,
+            dataPath: e.instancePath,
+        })), {
+            indent: 2,
+        });
+    };
+    if (!valid && ((_a = validate.errors) === null || _a === void 0 ? void 0 : _a.length)) {
+        await onSchemaError(validate === null || validate === void 0 ? void 0 : validate.errors[0]);
+        const errors = formatValidateError(userConfig);
+        utils_1.logger.log(errors);
+        throw new Error(`Validate configuration error`);
+    }
+    // validate config from plugins.
+    for (const config of configs) {
+        if (!validate(config)) {
+            const errors = formatValidateError(config);
+            utils_1.logger.error(errors);
+            throw new Error(`Validate configuration error.`);
+        }
+    }
+    const resolved = (0, mergeConfig_1.mergeConfig)([(0, createDefaultConfig_1.createDefaultConfig)(), ...configs, userConfig]);
+    debug('resolved %o', resolved);
+    return resolved;
+};
+exports.createResolveConfig = createResolveConfig;

package/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from './createLoadedConfig';
+export * from './createResolvedConfig';
+export * from './createDefaultConfig';

package/dist/config/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./createLoadedConfig"), exports);
+__exportStar(require("./createResolvedConfig"), exports);
+__exportStar(require("./createDefaultConfig"), exports);

package/dist/context.d.ts

@@ -0,0 +1,35 @@
+import type { CliPlugin, UserConfig, IAppContext, InternalPlugins, NormalizedConfig, ToolsType } from './types';
+export declare const AppContext: import("@modern-js/plugin").Context<IAppContext>;
+export declare const ConfigContext: import("@modern-js/plugin").Context<UserConfig<any, {}, {}, {}>>;
+export declare const ResolvedConfigContext: import("@modern-js/plugin").Context<NormalizedConfig<any, {}, {}, {}>>;
+/**
+ * Set app context.
+ * @param value new app context. It will override previous app context.
+ */
+export declare const setAppContext: (value: IAppContext) => void;
+/**
+ * Get app context, including directories, plugins and some static infos.
+ */
+export declare const useAppContext: () => IAppContext;
+/**
+ * Get original content of user config.
+ */
+export declare const useConfigContext: <Extends extends Record<string, any>>() => UserConfig<Extends>;
+/**
+ * Get normalized content of user config.
+ */
+export declare const useResolvedConfigContext: <Extends extends Record<string, any>>() => NormalizedConfig<Extends>;
+export declare const initAppContext: ({ appDirectory, plugins, configFile, options, serverConfigFile, serverInternalPlugins, toolsType, }: {
+    appDirectory: string;
+    plugins: CliPlugin[];
+    configFile: string | false;
+    options?: {
+        metaName?: string | undefined;
+        srcDir?: string | undefined;
+        distDir?: string | undefined;
+        sharedDir?: string | undefined;
+    } | undefined;
+    serverConfigFile: string;
+    serverInternalPlugins: InternalPlugins;
+    toolsType?: ToolsType | undefined;
+}) => IAppContext;

package/dist/context.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAppContext = exports.useResolvedConfigContext = exports.useConfigContext = exports.useAppContext = exports.setAppContext = exports.ResolvedConfigContext = exports.ConfigContext = exports.AppContext = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@modern-js/utils");
+const plugin_1 = require("@modern-js/plugin");
+exports.AppContext = (0, plugin_1.createContext)({});
+exports.ConfigContext = (0, plugin_1.createContext)({});
+exports.ResolvedConfigContext = (0, plugin_1.createContext)({});
+/**
+ * Set app context.
+ * @param value new app context. It will override previous app context.
+ */
+const setAppContext = (value) => exports.AppContext.set(value);
+exports.setAppContext = setAppContext;
+/**
+ * Get app context, including directories, plugins and some static infos.
+ */
+const useAppContext = () => exports.AppContext.use().value;
+exports.useAppContext = useAppContext;
+/**
+ * Get original content of user config.
+ */
+const useConfigContext = () => exports.ConfigContext.use().value;
+exports.useConfigContext = useConfigContext;
+/**
+ * Get normalized content of user config.
+ */
+const useResolvedConfigContext = () => exports.ResolvedConfigContext.use().value;
+exports.useResolvedConfigContext = useResolvedConfigContext;
+const initAppContext = ({ appDirectory, plugins, configFile, options, serverConfigFile, serverInternalPlugins, toolsType, }) => {
+    const { metaName = 'modern-js', srcDir = 'src', distDir = '', sharedDir = 'shared', } = options || {};
+    return {
+        metaName,
+        appDirectory,
+        configFile,
+        serverConfigFile,
+        serverInternalPlugins,
+        ip: utils_1.address.ip(),
+        port: 0,
+        packageName: require(path_1.default.resolve(appDirectory, './package.json')).name,
+        srcDirectory: path_1.default.resolve(appDirectory, srcDir),
+        distDirectory: distDir,
+        sharedDirectory: path_1.default.resolve(appDirectory, sharedDir),
+        nodeModulesDirectory: path_1.default.resolve(appDirectory, './node_modules'),
+        internalDirectory: path_1.default.resolve(appDirectory, `./node_modules/.${metaName}`),
+        plugins,
+        htmlTemplates: {},
+        serverRoutes: [],
+        entrypoints: [],
+        checkedEntries: [],
+        apiOnly: false,
+        internalDirAlias: `@_${metaName.replace(/-/g, '_')}_internal`,
+        internalSrcAlias: `@_${metaName.replace(/-/g, '_')}_src`,
+        toolsType,
+    };
+};
+exports.initAppContext = initAppContext;

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+import type { ErrorObject } from '@modern-js/utils/ajv';
+import { InternalPlugins } from '@modern-js/types';
+import { TransformPlugin } from './loadPlugins';
+import { initAppContext } from './context';
+import type { ToolsType } from './types';
+export * from './types';
+export * from '@modern-js/plugin';
+export { manager, mountHook, createPlugin, registerHook } from './manager';
+export { AppContext, ConfigContext, ResolvedConfigContext, useAppContext, useConfigContext, useResolvedConfigContext, } from './context';
+declare const initAppDir: (cwd?: string) => Promise<string>;
+export interface CoreOptions {
+    cwd?: string;
+    version?: string;
+    configFile?: string;
+    serverConfigFile?: string;
+    packageJsonConfig?: string;
+    internalPlugins?: {
+        cli?: InternalPlugins;
+        server?: InternalPlugins;
+        autoLoad?: InternalPlugins;
+    };
+    transformPlugin?: TransformPlugin;
+    onSchemaError?: (error: ErrorObject) => void;
+    options?: {
+        metaName?: string;
+        srcDir?: string;
+        distDir?: string;
+        sharedDir?: string;
+    };
+    toolsType?: ToolsType;
+    /** force the modern-js core auto register plugin exist in the package.json  */
+    forceAutoLoadPlugins?: boolean;
+}
+export declare const mergeOptions: (options?: CoreOptions) => {
+    cwd?: string | undefined;
+    version?: string | undefined;
+    configFile?: string | undefined;
+    serverConfigFile: string;
+    packageJsonConfig?: string | undefined;
+    internalPlugins?: {
+        cli?: InternalPlugins | undefined;
+        server?: InternalPlugins | undefined;
+        autoLoad?: InternalPlugins | undefined;
+    } | undefined;
+    transformPlugin?: TransformPlugin | undefined;
+    onSchemaError?: ((error: ErrorObject) => void) | undefined;
+    options?: {
+        metaName?: string | undefined;
+        srcDir?: string | undefined;
+        distDir?: string | undefined;
+        sharedDir?: string | undefined;
+    } | undefined;
+    toolsType?: ToolsType | undefined;
+    forceAutoLoadPlugins?: boolean | undefined;
+};
+export declare const cli: {
+    init: (options?: CoreOptions) => Promise<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+        appContext: import("./types").IAppContext;
+    }>;
+    run: (options?: CoreOptions) => Promise<void>;
+    test: (argv: string[], options?: {
+        coreOptions?: CoreOptions;
+        disableWatcher?: boolean;
+    }) => Promise<void>;
+    getPrevInitOptions: () => CoreOptions | undefined;
+};
+export { initAppDir, initAppContext };
+declare module '@modern-js/utils/compiled/commander' {
+    interface Command {
+        commandsMap: Map<string, Command>;
+    }
+}

package/dist/index.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 __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.mountHook = exports.manager = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@modern-js/utils");
+const commander_1 = require("./utils/commander");
+const loadPlugins_1 = require("./loadPlugins");
+const context_1 = require("./context");
+Object.defineProperty(exports, "initAppContext", { enumerable: true, get: function () { return context_1.initAppContext; } });
+const loadEnv_1 = require("./loadEnv");
+const manager_1 = require("./manager");
+const config_1 = require("./config");
+__exportStar(require("./types"), exports);
+__exportStar(require("@modern-js/plugin"), 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, "createPlugin", { enumerable: true, get: function () { return manager_2.createPlugin; } });
+Object.defineProperty(exports, "registerHook", { enumerable: true, get: function () { return manager_2.registerHook; } });
+var context_2 = require("./context");
+Object.defineProperty(exports, "AppContext", { enumerable: true, get: function () { return context_2.AppContext; } });
+Object.defineProperty(exports, "ConfigContext", { enumerable: true, get: function () { return context_2.ConfigContext; } });
+Object.defineProperty(exports, "ResolvedConfigContext", { enumerable: true, get: function () { return context_2.ResolvedConfigContext; } });
+Object.defineProperty(exports, "useAppContext", { enumerable: true, get: function () { return context_2.useAppContext; } });
+Object.defineProperty(exports, "useConfigContext", { enumerable: true, get: function () { return context_2.useConfigContext; } });
+Object.defineProperty(exports, "useResolvedConfigContext", { enumerable: true, get: function () { return context_2.useResolvedConfigContext; } });
+const initAppDir = async (cwd) => {
+    if (!cwd) {
+        // eslint-disable-next-line no-param-reassign
+        cwd = process.cwd();
+    }
+    const pkg = await (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 {
+        ...defaultOptions,
+        ...options,
+    };
+};
+exports.mergeOptions = mergeOptions;
+const setProgramVersion = (version = 'unknown') => {
+    utils_1.program.name('modern').usage('<command> [options]').version(version);
+};
+const createCli = () => {
+    let hooksRunner;
+    let initOptions;
+    const init = async (options) => {
+        var _a, _b, _c, _d, _e;
+        manager_1.manager.clear();
+        const mergedOptions = (0, exports.mergeOptions)(options);
+        initOptions = mergedOptions;
+        const appDirectory = await initAppDir(options === null || options === void 0 ? void 0 : options.cwd);
+        (0, commander_1.initCommandsMap)();
+        setProgramVersion(options === null || options === void 0 ? void 0 : options.version);
+        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 = await (0, config_1.createLoadedConfig)(appDirectory, mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.configFile, mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.packageJsonConfig);
+        const plugins = await (0, loadPlugins_1.loadPlugins)(appDirectory, loaded.config, {
+            internalPlugins: (_c = mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.internalPlugins) === null || _c === void 0 ? void 0 : _c.cli,
+            transformPlugin: mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.transformPlugin,
+            autoLoad: (_d = mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.internalPlugins) === null || _d === void 0 ? void 0 : _d.autoLoad,
+            forceAutoLoadPlugins: mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.forceAutoLoadPlugins,
+        });
+        plugins.forEach(plugin => plugin && manager_1.manager.usePlugin(plugin));
+        const appContext = (0, context_1.initAppContext)({
+            toolsType: mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.toolsType,
+            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,
+            serverInternalPlugins: ((_e = mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.internalPlugins) === null || _e === void 0 ? void 0 : _e.server) || utils_1.INTERNAL_SERVER_PLUGINS,
+        });
+        context_1.ConfigContext.set(loaded.config);
+        context_1.AppContext.set(appContext);
+        hooksRunner = await manager_1.manager.init();
+        ['SIGINT', 'SIGTERM', 'unhandledRejection', 'uncaughtException'].forEach(event => {
+            process.on(event, async (err) => {
+                await 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 = await hooksRunner.config();
+        const extraSchemas = await hooksRunner.validateSchema();
+        const normalizedConfig = await (0, config_1.createResolveConfig)(loaded, extraConfigs, extraSchemas, options === null || options === void 0 ? void 0 : options.onSchemaError);
+        const { resolved } = await hooksRunner.resolvedConfig({
+            resolved: normalizedConfig,
+        });
+        // update context value
+        context_1.ConfigContext.set(loaded.config);
+        context_1.ResolvedConfigContext.set(resolved);
+        await hooksRunner.addRuntimeExports();
+        await hooksRunner.prepare();
+        return {
+            resolved,
+            appContext: (0, context_1.useAppContext)(),
+        };
+    };
+    async function run(options) {
+        await init(options);
+        await hooksRunner.commands({ program: utils_1.program });
+        utils_1.program.parse(process.argv);
+    }
+    async function test(argv, options) {
+        const newProgram = new utils_1.Command();
+        const { coreOptions } = options !== null && options !== void 0 ? options : {};
+        await init(coreOptions);
+        await hooksRunner.commands({ program: newProgram });
+        await newProgram.parseAsync(argv);
+    }
+    return {
+        init,
+        run,
+        test,
+        getPrevInitOptions: () => initOptions,
+    };
+};
+exports.cli = createCli();

package/dist/load-configs/index.d.ts

@@ -0,0 +1,34 @@
+import path from 'path';
+export declare const CONFIG_FILE_NAME = "modern.config";
+export declare const PACKAGE_JSON_CONFIG_NAME = "modernConfig";
+/**
+ * Get user config from package.json.
+ * @param appDirectory - App root directory.
+ * @returns modernConfig or undefined
+ */
+export declare const getPackageConfig: <T>(appDirectory: string, packageJsonConfig?: string) => T | undefined;
+/**
+ * Get the file dependencies by module.children, ignore file path in node_modules and this monorepo packages default.
+ * @param filePath - Absolute file path.
+ * @returns File dependencies array.
+ */
+export declare const getDependencies: (filePath: string) => string[];
+/**
+ *
+ * @param targetDir target dir
+ * @param overtime Unit of second
+ */
+export declare const clearFilesOverTime: (targetDir: string, overtime: number) => Promise<void>;
+export declare const getConfigFilePath: (appDirectory: string, filePath?: string) => string | false;
+/**
+ * Parse and load user config file, support extensions like .ts, mjs, js, ejs.
+ * @param appDirectory - App root directory, from which start search user config file.
+ * @param filePath - Specific absolute config file path.
+ * @returns Object contain config file path, user config object and dependency files used by config file.
+ */
+export declare const loadConfig: <T>(appDirectory: string, filePath?: string, packageJsonConfig?: string) => Promise<{
+    path: string | false;
+    config?: T | undefined;
+    dependencies?: string[] | undefined;
+    pkgConfig?: T | undefined;
+}>;