@modern-js/core 1.4.4 → 1.5.0

package/dist/js/node/loadPlugins.js

@@ -8,6 +8,8 @@ exports.loadPlugins = void 0;
 
 var _utils = require("@modern-js/utils");
 
+var _manager = require("./manager");
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
@@ -60,15 +62,13 @@ function getAppPlugins(appDirectory, pluginConfig, internalPlugins) {
  * @param appDirectory - Application root directory.
  * @param userConfig - Resolved user config.
  * @param options.internalPlugins - Internal plugins.
- * @param options.transformPlugin - transform plugin before using it.
  * @returns Plugin Objects has been required.
  */
 
 
 const loadPlugins = (appDirectory, userConfig, options = {}) => {
   const {
-    internalPlugins,
-    transformPlugin
+    internalPlugins
   } = options;
 
   const resolvePlugin = p => {
@@ -77,10 +77,9 @@ const loadPlugins = (appDirectory, userConfig, options = {}) => {
     let module = (0, _utils.compatRequire)(path);
     const pluginOptions = Array.isArray(p) ? p[1] : undefined;
 
-    if (transformPlugin) {
-      module = transformPlugin(module, userConfig, pluginOptions);
-    } else {
-      module = typeof module === 'function' ? module(pluginOptions) : module;
+    if (typeof module === 'function') {
+      const plugin = module(pluginOptions);
+      module = (0, _manager.createPlugin)(plugin.setup, plugin);
     }
 
     return {
@@ -92,7 +91,7 @@ const loadPlugins = (appDirectory, userConfig, options = {}) => {
 
   const plugins = getAppPlugins(appDirectory, userConfig.plugins || [], internalPlugins);
   return plugins.map(plugin => {
-    const _plugin = typeof plugin === 'string' ? {
+    const _plugin = typeof plugin === 'string' || Array.isArray(plugin) ? {
       cli: plugin
     } : plugin;
 
@@ -116,10 +115,7 @@ const loadPlugins = (appDirectory, userConfig, options = {}) => {
 
 
     if (server && typeof server === 'string') {
-      const path = tryResolve(server, appDirectory);
-      loadedPlugin.server = {
-        pluginPath: path
-      };
+      loadedPlugin.server = server;
       loadedPlugin.serverPkg = server;
     }
 

package/dist/js/node/manager.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePlugins = exports.registerHook = exports.mountHook = exports.manager = exports.createPlugin = void 0;
+
+var _plugin = require("@modern-js/plugin");
+
+var _utils = require("@modern-js/utils");
+
+var _pluginAPI = require("./pluginAPI");
+
+const baseHooks = {
+  config: (0, _plugin.createParallelWorkflow)(),
+  resolvedConfig: (0, _plugin.createAsyncWaterfall)(),
+  validateSchema: (0, _plugin.createParallelWorkflow)(),
+  prepare: (0, _plugin.createAsyncWorkflow)(),
+  commands: (0, _plugin.createAsyncWorkflow)(),
+  watchFiles: (0, _plugin.createParallelWorkflow)(),
+  fileChange: (0, _plugin.createAsyncWorkflow)(),
+  beforeExit: (0, _plugin.createAsyncWorkflow)(),
+  beforeRestart: (0, _plugin.createAsyncWorkflow)()
+};
+/** All hooks of cli plugin. */
+
+const manager = (0, _plugin.createAsyncManager)(baseHooks, _pluginAPI.pluginAPI);
+/** Plugin options of a cli plugin. */
+
+exports.manager = manager;
+const {
+  createPlugin,
+  registerHook,
+  useRunner: mountHook
+} = manager;
+exports.mountHook = mountHook;
+exports.registerHook = registerHook;
+exports.createPlugin = createPlugin;
+
+const usePlugins = plugins => plugins.forEach(pluginPath => {
+  const module = (0, _utils.compatRequire)(require.resolve(pluginPath));
+  manager.usePlugin(module);
+});
+
+exports.usePlugins = usePlugins;

package/dist/js/node/pluginAPI.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AppContext", {
+  enumerable: true,
+  get: function () {
+    return _context.AppContext;
+  }
+});
+Object.defineProperty(exports, "ConfigContext", {
+  enumerable: true,
+  get: function () {
+    return _context.ConfigContext;
+  }
+});
+Object.defineProperty(exports, "ResolvedConfigContext", {
+  enumerable: true,
+  get: function () {
+    return _context.ResolvedConfigContext;
+  }
+});
+exports.pluginAPI = void 0;
+Object.defineProperty(exports, "useAppContext", {
+  enumerable: true,
+  get: function () {
+    return _context.useAppContext;
+  }
+});
+Object.defineProperty(exports, "useConfigContext", {
+  enumerable: true,
+  get: function () {
+    return _context.useConfigContext;
+  }
+});
+Object.defineProperty(exports, "useResolvedConfigContext", {
+  enumerable: true,
+  get: function () {
+    return _context.useResolvedConfigContext;
+  }
+});
+
+var _context = require("./context");
+
+const pluginAPI = {
+  setAppContext: _context.setAppContext,
+  useAppContext: _context.useAppContext,
+  useConfigContext: _context.useConfigContext,
+  useResolvedConfigContext: _context.useResolvedConfigContext
+};
+/** all apis for cli plugin */
+
+exports.pluginAPI = pluginAPI;

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

@@ -65,7 +65,7 @@ interface OutputConfig {
   enableTsLoader?: boolean;
 }
 interface ServerConfig {
-  routes?: Record<string, string | {
+  routes?: Record<string, string | string[] | {
     route: string | string[];
     disableSpa?: boolean;
   }>;
@@ -76,8 +76,8 @@ interface ServerConfig {
   ssrByEntries?: Record<string, boolean | Record<string, unknown>>;
   baseUrl?: string | Array<string>;
   port?: number;
-  logger?: Record<string, any>;
-  metrics?: Record<string, any>;
+  logger?: boolean | Record<string, any>;
+  metrics?: boolean | Record<string, any>;
   enableMicroFrontendDebug?: boolean;
 }
 interface DevConfig {

package/dist/types/config/schema/deploy.d.ts

@@ -1,9 +1,6 @@
 export declare const deploy: {
   type: string;
   properties: {
-    microFrontend: {
-      type: string[];
-    };
     domain: {
       type: string[];
     };

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

@@ -380,10 +380,10 @@ export declare const patchSchema: (pluginSchemas: Array<PluginValidateSchema | P
           instanceof: string;
         };
         logger: {
-          type: string;
+          type: string[];
         };
         metrics: {
-          type: string;
+          type: string[];
         };
         proxy: {
           type: string;
@@ -396,9 +396,6 @@ export declare const patchSchema: (pluginSchemas: Array<PluginValidateSchema | P
     deploy: {
       type: string;
       properties: {
-        microFrontend: {
-          type: string[];
-        };
         domain: {
           type: string[];
         };

package/dist/types/config/schema/server.d.ts

@@ -167,10 +167,10 @@ export declare const server: {
       instanceof: string;
     };
     logger: {
-      type: string;
+      type: string[];
     };
     metrics: {
-      type: string;
+      type: string[];
     };
     proxy: {
       type: string;

package/dist/types/context.d.ts

@@ -6,8 +6,26 @@ export type { IAppContext };
 export declare const AppContext: import("@modern-js/plugin").Context<IAppContext>;
 export declare const ConfigContext: import("@modern-js/plugin").Context<UserConfig>;
 export declare const ResolvedConfigContext: import("@modern-js/plugin").Context<NormalizedConfig>;
+/**
+ * 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: () => UserConfig;
+/**
+ * Get normalized content of user config.
+ */
+
 export declare const useResolvedConfigContext: () => NormalizedConfig;
 export declare const initAppContext: (appDirectory: string, plugins: Array<LoadedPlugin>, configFile: string | false, options?: {
   metaName?: string | undefined;

package/dist/types/index.d.ts

@@ -1,111 +1,22 @@
 import { INTERNAL_PLUGINS } from '@modern-js/utils';
-import { ParallelWorkflow, AsyncWorkflow, Progresses2Runners, AsyncWaterfall } from '@modern-js/plugin';
 import type { Hooks } from '@modern-js/types';
 import { ErrorObject } from 'ajv';
-import { Command } from './utils/commander';
-import { TransformPlugin } from './loadPlugins';
-import { AppContext, ConfigContext, IAppContext, initAppContext, ResolvedConfigContext, useAppContext, useConfigContext, useResolvedConfigContext } from './context';
-import { NormalizedConfig } from './config/mergeConfig';
+import { IAppContext, initAppContext } from './context';
+import type { NormalizedConfig } from './config/mergeConfig';
 export type { Hooks };
 export * from './config';
 export * from '@modern-js/plugin';
 export * from '@modern-js/plugin/node';
-export declare type HooksRunner = Progresses2Runners<{
-  config: ParallelWorkflow<void>;
-  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>;
-}>;
-export declare const manager: import("@modern-js/plugin").AsyncManager<Hooks, {
-  config: ParallelWorkflow<void, unknown>;
-  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>;
-}>;
-export declare const createPlugin: (initializer: import("@modern-js/plugin").AsyncInitializer<Partial<import("@modern-js/plugin").Progresses2Threads<{
-  config: ParallelWorkflow<void, unknown>;
-  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>;
-} & import("@modern-js/plugin").ClearDraftProgress<Hooks>>>>, options?: import("@modern-js/plugin").PluginOptions | undefined) => import("@modern-js/plugin").AsyncPlugin<Partial<import("@modern-js/plugin").Progresses2Threads<{
-  config: ParallelWorkflow<void, unknown>;
-  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>;
-} & import("@modern-js/plugin").ClearDraftProgress<Hooks>>>>, registerHook: (newShape: Partial<Hooks>) => void, mountHook: () => Progresses2Runners<{
-  config: ParallelWorkflow<void, unknown>;
-  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>;
-} & import("@modern-js/plugin").ClearDraftProgress<Hooks>>;
-export declare const usePlugins: (plugins: string[]) => void;
-export { AppContext, ResolvedConfigContext, useAppContext, useConfigContext, useResolvedConfigContext, ConfigContext };
+export { manager, mountHook, usePlugins, createPlugin, registerHook } from './manager';
+export type { CliHooks, CliPlugin, CliHookCallbacks } from './manager';
+export { AppContext, ConfigContext, ResolvedConfigContext, useAppContext, useConfigContext, useResolvedConfigContext } from './pluginAPI';
+export type { PluginAPI } from './pluginAPI';
 export type { NormalizedConfig, IAppContext };
 declare const initAppDir: (cwd?: string | undefined) => Promise<string>;
 export interface CoreOptions {
   configFile?: string;
   packageJsonConfig?: string;
   plugins?: typeof INTERNAL_PLUGINS;
-  transformPlugin?: TransformPlugin;
   onSchemaError?: (error: ErrorObject) => void;
   options?: {
     metaName?: string;

package/dist/types/initWatcher.d.ts

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

package/dist/types/loadPlugins.d.ts

@@ -10,21 +10,18 @@ export declare type LoadedPlugin = {
 export declare type PluginConfigItem = {
   cli?: Plugin;
   server?: Plugin;
-} | string;
+} | Plugin;
 export declare type PluginConfig = Array<PluginConfigItem>;
-export declare type TransformPlugin = (plugin: PluginConfig, resolvedConfig: UserConfig, pluginOptions?: any) => PluginConfig;
 export declare function getAppPlugins(appDirectory: string, pluginConfig: PluginConfig, internalPlugins?: typeof INTERNAL_PLUGINS): PluginConfigItem[];
 /**
  * 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.
  * @returns Plugin Objects has been required.
  */
 
 export declare const loadPlugins: (appDirectory: string, userConfig: UserConfig, options?: {
   internalPlugins?: typeof INTERNAL_PLUGINS;
-  transformPlugin?: TransformPlugin;
 }) => LoadedPlugin[];
 export {};

package/dist/types/manager.d.ts

@@ -0,0 +1,74 @@
+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 { pluginAPI } from './pluginAPI';
+export declare type HooksRunner = ToRunners<{
+  config: ParallelWorkflow<void>;
+  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, unknown>;
+  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: () => import("./config").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: () => import("./config").UserConfig;
+  useResolvedConfigContext: () => NormalizedConfig;
+}> | undefined, options?: PluginOptions<CliHooks, AsyncSetup<CliHooks, {
+  setAppContext: (value: import("@modern-js/types").IAppContext) => void;
+  useAppContext: () => import("@modern-js/types").IAppContext;
+  useConfigContext: () => import("./config").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: () => import("./config").UserConfig;
+  useResolvedConfigContext: () => NormalizedConfig;
+}>, registerHook: (newHooks: Partial<CliHooks>) => void, mountHook: () => ToRunners<CliHooks>;
+export declare const usePlugins: (plugins: string[]) => void;
+export {};

package/dist/types/pluginAPI.d.ts

@@ -0,0 +1,13 @@
+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;
+};
+/** all apis for cli plugin */
+
+export declare type PluginAPI = typeof pluginAPI & CommonAPI<CliHooks>;
+export { AppContext, ConfigContext, ResolvedConfigContext, useAppContext, useConfigContext, useResolvedConfigContext };

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.4.4",
+  "version": "1.5.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -43,8 +43,8 @@
     "@babel/code-frame": "^7.14.5",
     "@babel/runtime": "^7",
     "@modern-js/load-config": "^1.2.2",
-    "@modern-js/plugin": "^1.2.1",
-    "@modern-js/utils": "^1.3.3",
+    "@modern-js/plugin": "^1.3.0",
+    "@modern-js/utils": "^1.3.5",
     "address": "^1.1.2",
     "ajv": "^8.6.2",
     "ajv-keywords": "^5.0.0",
@@ -61,7 +61,7 @@
   "devDependencies": {
     "btsm": "2.2.2",
     "@types/babel__code-frame": "^7.0.3",
-    "@modern-js/types": "^1.3.4",
+    "@modern-js/types": "^1.3.5",
     "@types/jest": "^26",
     "@types/lodash.clonedeep": "^4.5.6",
     "@types/lodash.mergewith": "^4.6.6",

package/tests/loadPlugin.test.ts

@@ -38,9 +38,7 @@ describe('load plugins', () => {
         cliPkg: path.join(fixture, './test-plugin-a.js'),
       },
       {
-        server: {
-          pluginPath: path.join(fixture, './test-plugin-b.js'),
-        },
+        server: './test-plugin-b',
         serverPkg: './test-plugin-b',
       },
     ]);
@@ -53,18 +51,11 @@ describe('load plugins', () => {
     );
 
     const plugins = loadPlugins(fixture, {
-      plugins: [{ cli: ['./test-plugin-c', 'c'] }],
+      plugins: [{ cli: ['./test-plugin-c', 'c'] }, ['./test-plugin-c', 'c2']],
     });
 
-    expect(plugins).toEqual([
-      {
-        cli: {
-          name: 'c',
-          pluginPath: path.join(fixture, './test-plugin-c.js'),
-        },
-        cliPkg: './test-plugin-c',
-      },
-    ]);
+    expect(plugins[0].cli.name).toEqual('c');
+    expect(plugins[1].cli.name).toEqual('c2');
   });
 
   test('should load user string plugin successfully', () => {
@@ -88,26 +79,6 @@ describe('load plugins', () => {
     ]);
   });
 
-  test('should call transformPlugin', () => {
-    const fixture = path.resolve(
-      __dirname,
-      './fixtures/load-plugin/user-plugins',
-    );
-
-    const options = {
-      transformPlugin: jest.fn(),
-    };
-    options.transformPlugin.mockImplementation((plugins, _) => plugins);
-
-    loadPlugins(
-      fixture,
-      { plugins: [{ cli: path.join(fixture, './test-plugin-a.js') }] },
-      options,
-    );
-
-    expect(options.transformPlugin).toHaveBeenCalled();
-  });
-
   test(`should throw error when plugin not found `, () => {
     const fixture = path.resolve(__dirname, './fixtures/load-plugin/not-found');
 

package/tests/mergeConfig.test.ts

@@ -19,7 +19,7 @@ describe('load plugins', () => {
     });
   });
 
-  test(`should set value when property value is undefined `, () => {
+  test(`should set value when property value is not undefined `, () => {
     expect(
       mergeConfig([
         { source: { entries: { app: './App.tsx' } } },
@@ -37,6 +37,22 @@ describe('load plugins', () => {
     });
   });
 
+  test(`should ignore undefined property`, () => {
+    const config = mergeConfig([
+      { source: { entries: { app: './App.tsx' } } },
+      { source: { entries: undefined } },
+      { tools: { webpack: () => ({}) } },
+      { tools: { webpack: undefined } },
+    ]);
+    expect(config.source).toEqual({
+      entries: {
+        app: './App.tsx',
+      },
+    });
+    expect(Array.isArray(config.tools.webpack)).toBe(true);
+    expect(config.tools.webpack?.length).toBe(1);
+  });
+
   test(`should merge array value`, () => {
     expect(
       mergeConfig([
@@ -67,12 +83,15 @@ describe('load plugins', () => {
       { source: { alias: { a: 'b' } } },
       { source: { alias: () => ({ c: 'd' }) } },
       { tools: { webpack: () => ({}) } },
+      { tools: { webpack: { name: 'test' } } },
+      { tools: { webpack: () => ({}) } },
     ]);
     expect(Array.isArray(config.source.alias)).toBe(true);
     expect(config?.source?.alias?.length).toBe(2);
     expect(typeof (config.source.alias as Array<any>)[1]).toBe('function');
-
     expect(Array.isArray(config.tools.webpack)).toBe(true);
-    expect(config.tools.webpack?.length).toBe(1);
+    expect(config.tools.webpack?.length).toBe(3);
+    expect(typeof (config.tools.webpack as Array<any>)[0]).toBe('function');
+    expect(typeof (config.tools.webpack as Array<any>)[2]).toBe('function');
   });
 });

package/tests/pluginAPI.test.ts

@@ -0,0 +1,19 @@
+import { CliPlugin, manager } from '../src';
+
+describe('pluginAPI', () => {
+  it('api.setAppContext', done => {
+    const plugin = (): CliPlugin => ({
+      setup(api) {
+        api.setAppContext({
+          ...api.useAppContext(),
+          packageName: 'foo',
+        });
+
+        expect(api.useAppContext().packageName).toEqual('foo');
+        done();
+      },
+    });
+
+    manager.clone().usePlugin(plugin).init();
+  });
+});

package/tests/schema.test.ts

@@ -8,16 +8,14 @@ describe('patch schemas', () => {
         schema: { type: 'string' },
       },
       {
-        target: 'deploy.microFrontend.foo',
+        target: 'deploy.foo',
         schema: { type: 'number' },
       },
     ]);
 
     expect(schema.properties).toHaveProperty('foo');
 
-    expect(
-      schema.properties.deploy.properties.microFrontend.properties,
-    ).toHaveProperty('foo');
+    expect(schema.properties.deploy.properties).toHaveProperty('foo');
   });
 
   test('should throw error when node is undefined', () => {