@modern-js/core 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/loadPlugins.js

@@ -4,11 +4,18 @@ exports.loadPlugins = exports.isOldPluginConfig = void 0;
 const utils_1 = require("@modern-js/utils");
 const manager_1 = require("./manager");
 const debug = (0, utils_1.createDebugger)('load-plugins');
-const resolveCliPlugin = (p, userConfig, appDirectory, transformPlugin) => {
+const resolveCliPlugin = async (p, userConfig, appDirectory, transformPlugin) => {
     const pkg = typeof p === 'string' ? p : p[0];
     const pluginOptions = typeof p === 'string' ? undefined : p[1];
     const path = (0, utils_1.tryResolve)(pkg, appDirectory);
-    let module = (0, utils_1.compatRequire)(path);
+    let module;
+    try {
+        module = (0, utils_1.compatRequire)(path);
+    }
+    catch (e) {
+        // load esm module
+        ({ default: module } = await (0, utils_1.dynamicImport)(path));
+    }
     if (transformPlugin) {
         module = transformPlugin(module, userConfig, pluginOptions);
     }
@@ -31,18 +38,18 @@ exports.isOldPluginConfig = isOldPluginConfig;
  * @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 loadPlugins = async (appDirectory, userConfig, options = {}) => {
     const pluginConfig = userConfig.plugins;
     const plugins = [
         ...(0, utils_1.getInternalPlugins)(appDirectory, options.internalPlugins),
         ...((0, exports.isOldPluginConfig)(pluginConfig) ? pluginConfig : []),
     ];
-    const loadedPlugins = plugins.map(plugin => {
+    const loadedPlugins = await Promise.all(plugins.map(plugin => {
         const loadedPlugin = resolveCliPlugin(plugin, userConfig, appDirectory, options.transformPlugin);
         // server plugins don't support to accept params
         debug(`resolve plugin %s: %s`, plugin, loadedPlugin);
         return loadedPlugin;
-    });
+    }));
     if (!(0, exports.isOldPluginConfig)(pluginConfig)) {
         if (pluginConfig === null || pluginConfig === void 0 ? void 0 : pluginConfig.length) {
             loadedPlugins.push(...pluginConfig.map(item => (0, manager_1.createPlugin)(item.setup, item)));

package/dist/manager.d.ts

@@ -1,71 +1,87 @@
-import { ToThreads, ToRunners, AsyncSetup, PluginOptions, AsyncWorkflow, AsyncWaterfall, ParallelWorkflow } from '@modern-js/plugin';
-import type { Hooks } from './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;
+import { BasePluginAPI } from './types';
+export declare const manager: import("@modern-js/plugin").AsyncManager<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
     }>;
-    validateSchema: ParallelWorkflow<void>;
-    prepare: AsyncWorkflow<void, void>;
-    commands: AsyncWorkflow<{
-        program: Command;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
     }, void>;
-    watchFiles: ParallelWorkflow<void>;
-    fileChange: AsyncWorkflow<{
-        filename: string;
-        eventType: 'add' | 'change' | 'unlink';
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}, BasePluginAPI<{}, {}, {}, {}>>;
+export declare const createPlugin: (setup?: import("@modern-js/plugin").AsyncSetup<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
     }, void>;
-    beforeExit: AsyncWorkflow<void, void>;
-    beforeRestart: AsyncWorkflow<void, void>;
-}>;
-declare const baseHooks: {
-    config: ParallelWorkflow<void, UserConfig>;
-    resolvedConfig: AsyncWaterfall<{
-        resolved: NormalizedConfig;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}, BasePluginAPI<{}, {}, {}, {}>> | undefined, options?: import("@modern-js/plugin").PluginOptions<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
     }>;
-    validateSchema: ParallelWorkflow<void, unknown>;
-    prepare: AsyncWorkflow<void, void>;
-    commands: AsyncWorkflow<{
-        program: Command;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
     }, void>;
-    watchFiles: ParallelWorkflow<void, unknown>;
-    fileChange: AsyncWorkflow<{
-        filename: string;
-        eventType: 'add' | 'change' | 'unlink';
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}, import("@modern-js/plugin").AsyncSetup<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
+    }, void>;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}, BasePluginAPI<{}, {}, {}, {}>>, Record<string, unknown>, any, any> | undefined) => import("@modern-js/plugin").AsyncPlugin<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
+    }, void>;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}, BasePluginAPI<{}, {}, {}, {}>>, registerHook: (newHooks: Partial<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
+    }, void>;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}>) => void, mountHook: () => import("@modern-js/plugin").ToRunners<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
     }, 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/cli").IAppContext) => void;
-    useAppContext: () => import("@modern-js/types/cli").IAppContext;
-    useConfigContext: () => UserConfig;
-    useResolvedConfigContext: () => NormalizedConfig;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
 }>;
-/** Plugin options of a cli plugin. */
-export declare type CliPlugin<ExtendHooks = {}> = PluginOptions<CliHooks, AsyncSetup<CliHooks & ExtendHooks, typeof pluginAPI>, ExtendHooks>;
-export declare const createPlugin: (setup?: AsyncSetup<CliHooks, {
-    setAppContext: (value: import("@modern-js/types/cli").IAppContext) => void;
-    useAppContext: () => import("@modern-js/types/cli").IAppContext;
-    useConfigContext: () => UserConfig;
-    useResolvedConfigContext: () => NormalizedConfig;
-}> | undefined, options?: PluginOptions<CliHooks, AsyncSetup<CliHooks, {
-    setAppContext: (value: import("@modern-js/types/cli").IAppContext) => void;
-    useAppContext: () => import("@modern-js/types/cli").IAppContext;
-    useConfigContext: () => UserConfig;
-    useResolvedConfigContext: () => NormalizedConfig;
-}>, Record<string, unknown>> | undefined) => import("@modern-js/plugin").AsyncPlugin<CliHooks, {
-    setAppContext: (value: import("@modern-js/types/cli").IAppContext) => void;
-    useAppContext: () => import("@modern-js/types/cli").IAppContext;
-    useConfigContext: () => UserConfig;
-    useResolvedConfigContext: () => NormalizedConfig;
-}>, registerHook: (newHooks: Partial<CliHooks>) => void, mountHook: () => ToRunners<CliHooks>;
-export {};

package/dist/manager.js

@@ -2,17 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mountHook = exports.registerHook = exports.createPlugin = exports.manager = void 0;
 const plugin_1 = require("@modern-js/plugin");
-const pluginAPI_1 = require("./pluginAPI");
+const context_1 = require("./context");
+// eslint-disable-next-line @typescript-eslint/ban-types
 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)(),
+    addRuntimeExports: (0, plugin_1.createAsyncWaterfall)(),
 };
-exports.manager = (0, plugin_1.createAsyncManager)(baseHooks, pluginAPI_1.pluginAPI);
+// eslint-disable-next-line @typescript-eslint/ban-types
+const pluginAPI = {
+    setAppContext: context_1.setAppContext,
+    useAppContext: context_1.useAppContext,
+    useConfigContext: context_1.useConfigContext,
+    useResolvedConfigContext: context_1.useResolvedConfigContext,
+};
+exports.manager = (0, plugin_1.createAsyncManager)(baseHooks, pluginAPI);
 exports.createPlugin = exports.manager.createPlugin, exports.registerHook = exports.manager.registerHook, exports.mountHook = exports.manager.useRunner;

package/dist/schema/patchSchema.d.ts

@@ -0,0 +1,19 @@
+import { PluginValidateSchema } from '../types';
+export declare const patchSchema: (pluginSchemas: Array<PluginValidateSchema | PluginValidateSchema[]>) => {
+    type: string;
+    properties: {
+        testing: {
+            type: string;
+            additionalProperties: boolean;
+            properties: {
+                transformer: {
+                    type: string;
+                    enum: string[];
+                };
+                jest: {
+                    typeof: string[];
+                };
+            };
+        };
+    };
+};

package/dist/{config/schema/index.js → schema/patchSchema.js}

@@ -1,45 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseSchema = exports.patchSchema = void 0;
+exports.patchSchema = void 0;
 const utils_1 = require("@modern-js/utils");
 const lodash_1 = require("@modern-js/utils/lodash");
-const source_1 = require("./source");
-const output_1 = require("./output");
-const server_1 = require("./server");
-const deploy_1 = require("./deploy");
-const tools_1 = require("./tools");
+const testing_1 = require("./testing");
 const debug = (0, utils_1.createDebugger)('validate-schema');
-const plugins = {
-    type: 'array',
-    additionalProperties: false,
-};
-const dev = {
-    type: 'object',
-    properties: {
-        assetPrefix: { type: ['boolean', 'string'] },
-        https: {
-            type: 'boolean',
-        },
-    },
-    additionalProperties: false,
-};
 const patchSchema = (pluginSchemas) => {
     const finalSchema = (0, lodash_1.cloneDeep)({
         type: 'object',
-        additionalProperties: false,
         properties: {
-            source: source_1.source,
-            output: output_1.output,
-            server: server_1.server,
-            deploy: deploy_1.deploy,
-            plugins,
-            dev,
-            tools: tools_1.tools,
+            testing: testing_1.testing,
         },
     });
     const findTargetNode = (props) => {
         let node = finalSchema.properties;
         for (const prop of props) {
+            if (!node[prop]) {
+                node[prop] = {
+                    type: 'object',
+                };
+            }
             node = node[prop];
             if (!node || !(0, utils_1.isObject)(node)) {
                 throw new Error(`add schema ${props.join('.')} error`);
@@ -75,20 +55,3 @@ const patchSchema = (pluginSchemas) => {
     return finalSchema;
 };
 exports.patchSchema = patchSchema;
-const traverseSchema = (schema) => {
-    const keys = [];
-    const traverse = ({ properties }, old = []) => {
-        for (const key of Object.keys(properties)) {
-            const current = [...old, key];
-            if (properties[key].type === 'object' && properties[key].properties) {
-                traverse(properties[key], current);
-            }
-            else {
-                keys.push(current.join('.'));
-            }
-        }
-    };
-    traverse(schema);
-    return keys;
-};
-exports.traverseSchema = traverseSchema;

package/dist/schema/source.d.ts

@@ -0,0 +1,9 @@
+export declare const source: {
+    type: string;
+    additionalProperties: boolean;
+    properties: {
+        designSystem: {
+            type: string;
+        };
+    };
+};

package/dist/schema/source.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.source = void 0;
+exports.source = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        designSystem: { type: 'object' },
+    },
+};

package/dist/schema/testing.d.ts

@@ -0,0 +1,13 @@
+export declare const testing: {
+    type: string;
+    additionalProperties: boolean;
+    properties: {
+        transformer: {
+            type: string;
+            enum: string[];
+        };
+        jest: {
+            typeof: string[];
+        };
+    };
+};

package/dist/schema/testing.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testing = void 0;
+exports.testing = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        transformer: { type: 'string', enum: ['babel-jest', 'ts-jest'] },
+        jest: { typeof: ['object', 'function'] },
+    },
+};

package/dist/schema/traverseSchema.d.ts

@@ -0,0 +1,2 @@
+import { patchSchema } from './patchSchema';
+export declare const traverseSchema: (schema: ReturnType<typeof patchSchema>) => string[];

package/dist/schema/traverseSchema.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseSchema = void 0;
+const traverseSchema = (schema) => {
+    const keys = [];
+    const traverse = ({ properties }, old = []) => {
+        for (const key of Object.keys(properties)) {
+            const current = [...old, key];
+            if (properties[key].type === 'object' && properties[key].properties) {
+                traverse(properties[key], current);
+            }
+            else {
+                keys.push(current.join('.'));
+            }
+        }
+    };
+    traverse(schema);
+    return keys;
+};
+exports.traverseSchema = traverseSchema;

package/dist/types/config/index.d.ts

@@ -0,0 +1,41 @@
+import { PluginConfig } from '../plugin';
+import type { BaseTestingNormalizedConfig, BaseTestingUserConfig } from './testing';
+export type { Jest as JestConfig, BaseTestingUserConfig as TestConfig, } from './testing';
+declare type DropUndefined<T> = T extends undefined ? never : T;
+export declare type UserConfig<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+} = {}, ExtendHooks extends Record<string, any> = {}, ExtendUserConfig extends {
+    source?: Record<string, any>;
+    tools?: Record<string, any>;
+    testing?: Record<string, any>;
+    [property: string]: any;
+} = {}, ExtendNormalizedConfig extends Record<string, any> = {}> = {
+    testing?: BaseTestingUserConfig<DropUndefined<Extends['userConfig']>['testing']>;
+    plugins?: PluginConfig<Extends>;
+} & Omit<Extends['userConfig'], 'plugins' | 'testing'>;
+export declare type NormalizedConfig<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+} = {}, ExtendHooks extends Record<string, any> = {}, ExtendUserConfig extends Record<string, any> = {}, ExtendNormalizedConfig extends {
+    source?: Record<string, any>;
+    tools?: Record<string, any>;
+    testing?: Record<string, any>;
+    [property: string]: any;
+} = {}> = {
+    plugins: PluginConfig<Extends>;
+    testing: BaseTestingNormalizedConfig<DropUndefined<Extends['normalizedConfig']>['testing']>;
+} & Omit<Extends['normalizedConfig'], 'plugins' | 'testing'>;
+export declare type LoadedConfig<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+} = {}, ExtendHooks extends {} = {}, ExtendUserConfig extends Record<string, any> = {}> = {
+    config: UserConfig<Extends>;
+    filePath: string | false;
+    dependencies: string[];
+    pkgConfig: UserConfig<Extends>;
+    jsConfig: UserConfig<Extends>;
+};
+export declare type ConfigParams = UserConfig | Promise<UserConfig> | ((env: any) => UserConfig | Promise<UserConfig>);

package/dist/types/config/testing.d.ts

@@ -0,0 +1,15 @@
+import type { JestConfigTypes, Merge } from '@modern-js/types';
+export declare type Jest = JestConfigTypes.InitialOptions;
+export declare type BaseTestingUserConfig<ExtendTestingUserConfig = {}> = Merge<{
+    /**
+     * Decide which transformer will be used to compile file
+     * Default: babel-jest
+     */
+    transformer?: 'babel-jest' | 'ts-jest';
+    /**
+     * Original jest config
+     * Doc: https://jestjs.io/docs/configuration
+     */
+    jest?: Jest | ((jestConfig: Jest) => Jest);
+}, ExtendTestingUserConfig>;
+export declare type BaseTestingNormalizedConfig<ExtendTestingNormailzedConfig = {}> = BaseTestingUserConfig<ExtendTestingNormailzedConfig>;

package/dist/types/context.d.ts

@@ -0,0 +1,26 @@
+import { Entrypoint, InternalPlugins, ServerRoute, HtmlTemplates } from '@modern-js/types';
+import { BuilderInstance } from '@modern-js/builder-shared';
+export interface IAppContext {
+    metaName: string;
+    appDirectory: string;
+    configFile: string | false;
+    serverConfigFile: string;
+    serverInternalPlugins: InternalPlugins;
+    ip?: string;
+    port?: number;
+    distDirectory: string;
+    packageName: string;
+    srcDirectory: string;
+    sharedDirectory: string;
+    nodeModulesDirectory: string;
+    internalDirectory: string;
+    plugins: any[];
+    entrypoints: Entrypoint[];
+    checkedEntries: string[];
+    serverRoutes: ServerRoute[];
+    htmlTemplates: HtmlTemplates;
+    apiOnly: boolean;
+    internalDirAlias: string;
+    internalSrcAlias: string;
+    builder?: BuilderInstance;
+}

package/dist/types/hooks.d.ts

@@ -0,0 +1,26 @@
+import { ParallelWorkflow, AsyncWaterfall, AsyncWorkflow, ToRunners, ToThreads } from '@modern-js/plugin';
+import type { Command } from '@modern-js/utils';
+import type { UserConfig, NormalizedConfig } from './config';
+export declare type BaseHooks<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+}, ExtendHooks extends {} = {}, ExtendUserConfig extends Record<string, any> = {}, ExtendNormalizedConfig extends Record<string, any> = {}> = {
+    config: ParallelWorkflow<void, UserConfig<Extends>>;
+    resolvedConfig: AsyncWaterfall<{
+        resolved: NormalizedConfig<Extends>;
+    }>;
+    validateSchema: ParallelWorkflow<void>;
+    prepare: AsyncWorkflow<void, void>;
+    commands: AsyncWorkflow<{
+        program: Command;
+    }, void>;
+    beforeExit: AsyncWorkflow<void, void>;
+    addRuntimeExports: AsyncWaterfall<void>;
+};
+export declare type CliHooksRunner<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+} = {}, ExtendHooks extends {} = {}, ExtendUserConfig extends Record<string, any> = {}, ExtendNormalizedConfig extends Record<string, any> = {}> = ToRunners<BaseHooks<Extends> & Extends['hooks']>;
+export declare type CliHookCallbacks = ToThreads<BaseHooks<{}>>;

package/dist/types/index.d.ts

@@ -1 +1,10 @@
-export * from './cli';
+import type { JSONSchemaType } from '@modern-js/utils/ajv/json-schema';
+export * from './plugin';
+export * from './config';
+export * from './pluginAPI';
+export * from './hooks';
+export * from './context';
+export interface PluginValidateSchema {
+    target: string;
+    schema: JSONSchemaType<any>;
+}

package/dist/types/index.js

@@ -14,4 +14,8 @@ 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("./cli"), exports);
+__exportStar(require("./plugin"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./pluginAPI"), exports);
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./context"), exports);

package/dist/types/plugin.d.ts

@@ -0,0 +1,26 @@
+import { AsyncSetup, PluginOptions } from '@modern-js/plugin';
+import { BaseHooks } from './hooks';
+import { BasePluginAPI } from './pluginAPI';
+export type { InternalPlugins } from '@modern-js/types';
+/** Plugin options of a cli plugin. */
+export declare type CliPlugin<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+} = {}, ExtendHooks extends Record<string, any> = {}, ExtendUserConfig extends Record<string, any> = {}, ExtendNormalizedConfig extends Record<string, any> = {}> = PluginOptions<BaseHooks<Extends>, AsyncSetup<BaseHooks<Extends> & Extends['hooks'], BasePluginAPI<Extends>>, Extends['hooks'], BaseHooks<Extends> | BaseHooks<{}>, AsyncSetup<BaseHooks<Extends> & Extends['hooks'], BasePluginAPI<Extends>> | AsyncSetup<BaseHooks<{}>, BasePluginAPI<{}>>>;
+export declare type PluginItem = string | [string, any];
+/**
+ * @deprecated
+ * Using NewPluginConfig instead.
+ */
+export declare type OldPluginConfig = Array<PluginItem>;
+export declare type NewPluginConfig<PluginTypes extends {
+    hooks?: Record<string, any>;
+    userConfig?: Record<string, any>;
+    normalizedConfig?: Record<string, any>;
+}> = CliPlugin<PluginTypes>[];
+export declare type PluginConfig<PluginTypes extends {
+    hooks?: Record<string, any>;
+    userConfig?: Record<string, any>;
+    normalizedConfig?: Record<string, any>;
+} = {}> = OldPluginConfig | NewPluginConfig<PluginTypes>;

package/dist/types/pluginAPI.d.ts

@@ -0,0 +1,18 @@
+import { CommonAPI } from '@modern-js/plugin';
+import type { setAppContext, useAppContext, useResolvedConfigContext, useConfigContext } from '../context';
+import { BaseHooks } from './hooks';
+export declare type BasePluginAPI<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+}, ExtendHooks extends {} = {}, ExtendUserConfig extends Record<string, any> = {}, ExtendNormalizedConfig extends Record<string, any> = {}> = {
+    setAppContext: typeof setAppContext;
+    useAppContext: typeof useAppContext;
+    useConfigContext: typeof useConfigContext<Extends>;
+    useResolvedConfigContext: typeof useResolvedConfigContext<Extends>;
+};
+/** all apis for cli plugin */
+export declare type PluginAPI<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+} = {}, ExtendHooks extends {} = {}, ExtendUserConfig extends Record<string, any> = {}> = BasePluginAPI<Extends> & CommonAPI<BaseHooks<Extends> & Extends['hooks']>;

package/dist/utils/mergeConfig.d.ts

@@ -0,0 +1,2 @@
+import { UserConfig, NormalizedConfig } from '../types';
+export declare const mergeConfig: <ExtendConfig extends Record<string, any>>(configs: (UserConfig<ExtendConfig, {}, {}, {}> | NormalizedConfig<ExtendConfig, {}, {}, {}>)[]) => NormalizedConfig<ExtendConfig, {}, {}, {}>;

package/dist/{config → utils}/mergeConfig.js

@@ -2,13 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeConfig = void 0;
 const lodash_1 = require("@modern-js/utils/lodash");
-const utils_1 = require("@modern-js/utils");
-/**
- * merge configuration from  modern.config.js and plugins.
- *
- * @param configs - Configuration from modern.config.ts or plugin's config hook.
- * @returns - normalized user config.
- */
 const mergeConfig = (configs) => (0, lodash_1.mergeWith)({}, ...configs, (target, source, key) => {
     // Do not use the following merge logic for source.designSystem and tools.tailwind(css)
     if (key === 'designSystem' ||
@@ -25,7 +18,7 @@ const mergeConfig = (configs) => (0, lodash_1.mergeWith)({}, ...configs, (target
             return source !== undefined ? [...target, source] : target;
         }
     }
-    else if ((0, utils_1.isFunction)(target) || (0, utils_1.isFunction)(source)) {
+    else if ((0, lodash_1.isFunction)(target) || (0, lodash_1.isFunction)(source)) {
         if (source === undefined) {
             return target;
         }

package/dist/utils/repeatKeyWarning.d.ts

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