@modern-js/plugin 1.2.1 → 1.3.2

package/tests/async.test.ts

@@ -7,6 +7,7 @@ import {
   createContext,
   createContainer,
 } from 'farrow-pipeline';
+import type { PluginOptions, AsyncSetup } from '../src';
 import { createManager, createAsyncManager, useRunner } from '../src/manager';
 import { createWaterfall, createAsyncWaterfall } from '../src/waterfall';
 import {
@@ -14,7 +15,7 @@ import {
   createAsyncWorkflow,
   createParallelWorkflow,
 } from '../src/workflow';
-import { main } from './fixtures/async/core';
+import { main, TestAsyncHooks, TestAsyncPlugin } from './fixtures/async/core';
 import foo from './fixtures/async/base/foo';
 import bar, { getBar } from './fixtures/async/base/bar';
 import dFoo from './fixtures/async/dynamic/foo';
@@ -40,7 +41,7 @@ describe('async manager', () => {
     expect(getBar()).toBe(3);
   });
 
-  it('should support async initializer', async () => {
+  it('should support async setup function', async () => {
     const manager = createAsyncManager();
 
     const countContext = createContext(0);
@@ -397,6 +398,22 @@ describe('async manager', () => {
     expect(count).toBe(2);
   });
 
+  it('should support manager clone and override pluginAPI', done => {
+    const myAPI = { hello: () => 1 };
+    const manager = createAsyncManager({}, myAPI);
+    const plugin = {
+      setup(api: typeof myAPI) {
+        expect(api.hello()).toEqual(2);
+        done();
+      },
+    };
+    const clonedManager = manager.clone({
+      hello: () => 2,
+    });
+
+    clonedManager.usePlugin(plugin).init();
+  });
+
   it('isPlugin if exclusive plugins of manager', () => {
     const manager0 = createManager();
     const manager1 = createAsyncManager();
@@ -410,21 +427,6 @@ describe('async manager', () => {
     expect(manager1.isPlugin('' as any)).toBeFalsy();
   });
 
-  it('usePlugin should only add exclusive plugins of manager', async () => {
-    const manager0 = createManager();
-    const manager1 = createAsyncManager();
-
-    let count = 0;
-    const plugin = manager0.createPlugin(() => {
-      count += 1;
-    });
-
-    manager1.usePlugin(plugin as any);
-    await manager1.init();
-
-    expect(count).toBe(0);
-  });
-
   it('should support clear plugins', async () => {
     const manager = createAsyncManager();
 
@@ -501,11 +503,11 @@ describe('async manager', () => {
 
     runner.pipeline({});
     await runner.asyncPipeline({});
-    runner.waterfall({});
-    await runner.asyncWaterfall({});
-    runner.workflow({});
-    await runner.asyncWorkflow({});
-    await runner.parallelWorkflow({});
+    runner.waterfall();
+    await runner.asyncWaterfall();
+    runner.workflow();
+    await runner.asyncWorkflow();
+    await runner.parallelWorkflow();
 
     expect(list).toStrictEqual([
       'pipeline',
@@ -591,4 +593,146 @@ describe('async manager', () => {
       );
     });
   });
+
+  describe('setup api', () => {
+    it('should allow to access api.useHookRunners by default', done => {
+      const manager = createAsyncManager<TestAsyncHooks>();
+      const plugin: TestAsyncPlugin = {
+        name: 'plugin',
+        setup: api => {
+          expect(api.useHookRunners).toBeTruthy();
+          done();
+        },
+      };
+      manager.usePlugin(plugin);
+      manager.init();
+    });
+
+    it('should allow to register extra api', done => {
+      type API = { foo: () => void };
+
+      const manager = createAsyncManager<TestAsyncHooks, API>(
+        {},
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        { foo: () => {} },
+      );
+
+      const plugin: PluginOptions<
+        TestAsyncHooks,
+        AsyncSetup<TestAsyncHooks, API>
+      > = {
+        name: 'plugin',
+        setup: api => {
+          expect(api.foo).toBeTruthy();
+          done();
+        },
+      };
+
+      manager.usePlugin(plugin);
+      manager.init();
+    });
+  });
+
+  describe('usePlugins option', () => {
+    it('should allow to use single plugin', async () => {
+      const manager = createAsyncManager<TestAsyncHooks>();
+
+      const list: number[] = [];
+      const plugin0: TestAsyncPlugin = {
+        name: 'plugin0',
+        setup: () => {
+          list.push(0);
+        },
+      };
+
+      const plugin1: TestAsyncPlugin = {
+        name: 'plugin1',
+        usePlugins: [plugin0],
+        setup: () => {
+          list.push(1);
+        },
+      };
+
+      manager.usePlugin(plugin1);
+
+      await manager.init();
+
+      expect(list).toStrictEqual([0, 1]);
+    });
+
+    it('should allow to use multiple plugins', async () => {
+      const manager = createAsyncManager<TestAsyncHooks>();
+
+      const list: number[] = [];
+      const plugin0: TestAsyncPlugin = {
+        name: 'plugin0',
+        setup: () => {
+          list.push(0);
+        },
+      };
+
+      const plugin1 = {
+        name: 'plugin1',
+        usePlugins: [plugin0],
+        setup: () => {
+          list.push(1);
+        },
+      };
+
+      const plugin2 = {
+        name: 'plugin2',
+        usePlugins: [plugin1],
+        setup: () => {
+          list.push(2);
+        },
+      };
+
+      manager.usePlugin(plugin2);
+
+      await manager.init();
+
+      expect(list).toStrictEqual([0, 1, 2]);
+    });
+
+    it('should allow to use plugin without setup function', async () => {
+      const manager = createAsyncManager<TestAsyncHooks>();
+
+      const list: number[] = [];
+      const plugin0: TestAsyncPlugin = {
+        name: 'plugin0',
+        setup: () => {
+          list.push(0);
+        },
+      };
+
+      const plugin1 = {
+        name: 'plugin1',
+        usePlugins: [plugin0],
+      };
+
+      manager.usePlugin(plugin1);
+
+      await manager.init();
+
+      expect(list).toStrictEqual([0]);
+    });
+
+    it('should allow to use function plugin', async () => {
+      const manager = createAsyncManager<TestAsyncHooks>();
+
+      const list: number[] = [];
+      const plugin0: TestAsyncPlugin = {
+        name: 'plugin0',
+        setup: () => {
+          list.push(0);
+        },
+      };
+
+      manager.usePlugin(() => plugin0);
+
+      await manager.init();
+
+      expect(list).toStrictEqual([0]);
+    });
+  });
 });

package/tests/fixtures/async/core/index.ts

@@ -3,6 +3,8 @@ import {
   createWaterfall,
   createWorkflow,
   createContext,
+  PluginOptions,
+  AsyncSetup,
 } from '../../../../src';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -99,9 +101,15 @@ const lifecircle = {
   preBuild,
   postBuild,
 };
-export const main = createAsyncManager<ExternalProgress, typeof lifecircle>(
-  lifecircle,
-);
+
+export type TestAsyncHooks = ExternalProgress & typeof lifecircle;
+
+export const main = createAsyncManager<TestAsyncHooks>(lifecircle);
+
+export type TestAsyncPlugin = PluginOptions<
+  TestAsyncHooks,
+  AsyncSetup<TestAsyncHooks>
+>;
 
 export const { createPlugin } = main;
 
@@ -111,7 +119,7 @@ export const { usePlugin } = main;
 
 export const initPlugins = main.init;
 
-export const registeManager = main.registe;
+export const { registerHook } = main;
 
 export const { useRunner } = main;
 

package/tests/fixtures/async/dynamic/foo.ts

@@ -1,5 +1,5 @@
 import { createAsyncWaterfall } from '../../../../src';
-import { createPlugin, registeManager, useRunner } from '../core';
+import { createPlugin, registerHook, useRunner } from '../core';
 
 // declare new lifecircle type
 declare module '../core' {
@@ -13,7 +13,7 @@ const fooWaterfall = createAsyncWaterfall();
 
 const foo = createPlugin(() => {
   // registe new lifecircle
-  registeManager({ fooWaterfall });
+  registerHook({ fooWaterfall });
 
   return {
     preDev: () => {

package/tests/fixtures/sync/core/index.ts

@@ -1,8 +1,10 @@
 import {
+  Setup,
   createManager,
   createWaterfall,
   createWorkflow,
   createContext,
+  PluginOptions,
 } from '../../../../src';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -99,9 +101,12 @@ const lifecircle = {
   preBuild,
   postBuild,
 };
-export const main = createManager<ExternalProgress, typeof lifecircle>(
-  lifecircle,
-);
+
+export type TestHooks = ExternalProgress & typeof lifecircle;
+
+export const main = createManager<TestHooks>(lifecircle);
+
+export type TestPlugin = PluginOptions<TestHooks, Setup<TestHooks>>;
 
 export const { createPlugin } = main;
 
@@ -111,7 +116,7 @@ export const { usePlugin } = main;
 
 export const initPlugins = main.init;
 
-export const registeManager = main.registe;
+export const { registerHook } = main;
 
 export const { useRunner } = main;
 

package/tests/fixtures/sync/dynamic/foo.ts

@@ -1,5 +1,5 @@
 import { createAsyncWaterfall } from '../../../../src';
-import { createPlugin, registeManager, useRunner } from '../core';
+import { createPlugin, registerHook, useRunner } from '../core';
 
 // declare new lifecircle type
 declare module '../core' {
@@ -13,7 +13,7 @@ const fooWaterfall = createAsyncWaterfall();
 
 const foo = createPlugin(() => {
   // registe new lifecircle
-  registeManager({ fooWaterfall });
+  registerHook({ fooWaterfall });
 
   return {
     preDev: () => {

package/tests/sync.test.ts

@@ -6,6 +6,7 @@ import {
   createContext,
   createContainer,
 } from 'farrow-pipeline';
+import type { PluginOptions, Setup } from '../src';
 import { createManager, createAsyncManager, useRunner } from '../src/manager';
 import { createWaterfall, createAsyncWaterfall } from '../src/waterfall';
 import {
@@ -13,7 +14,7 @@ import {
   createAsyncWorkflow,
   createParallelWorkflow,
 } from '../src/workflow';
-import { main } from './fixtures/sync/core';
+import { main, TestHooks, TestPlugin } from './fixtures/sync/core';
 import foo from './fixtures/sync/base/foo';
 import bar, { getBar } from './fixtures/sync/base/bar';
 import dFoo from './fixtures/sync/dynamic/foo';
@@ -391,6 +392,22 @@ describe('sync manager', () => {
     expect(count).toBe(1);
   });
 
+  it('should support manager clone and override pluginAPI', done => {
+    const myAPI = { hello: () => 1 };
+    const manager = createManager({}, myAPI);
+    const plugin = {
+      setup(api: typeof myAPI) {
+        expect(api.hello()).toEqual(2);
+        done();
+      },
+    };
+    const clonedManager = manager.clone({
+      hello: () => 2,
+    });
+
+    clonedManager.usePlugin(plugin).init();
+  });
+
   it('isPlugin: exclusive plugins of manager', () => {
     const manager0 = createAsyncManager();
     const manager1 = createManager();
@@ -404,21 +421,6 @@ describe('sync manager', () => {
     expect(manager1.isPlugin('' as any)).toBeFalsy();
   });
 
-  it('usePlugin: exclusive plugins of manager', () => {
-    const manager0 = createAsyncManager();
-    const manager1 = createManager();
-
-    let count = 0;
-    const plugin = manager0.createPlugin(() => {
-      count += 1;
-    });
-
-    manager1.usePlugin(plugin as any);
-    manager1.init();
-
-    expect(count).toBe(0);
-  });
-
   it('should support clear plugins', () => {
     setNumber(0);
 
@@ -497,11 +499,11 @@ describe('sync manager', () => {
 
     runner.pipeline({});
     await runner.asyncPipeline({});
-    runner.waterfall({});
-    await runner.asyncWaterfall({});
-    runner.workflow({});
-    await runner.asyncWorkflow({});
-    await runner.parallelWorkflow({});
+    runner.waterfall();
+    await runner.asyncWaterfall();
+    runner.workflow();
+    await runner.asyncWorkflow();
+    await runner.parallelWorkflow();
 
     expect(list).toStrictEqual([
       'pipeline',
@@ -561,4 +563,139 @@ describe('sync manager', () => {
       );
     });
   });
+
+  describe('setup api', () => {
+    it('should allow to access api.useHookRunners by default', done => {
+      const manager = createManager<TestHooks>();
+      const plugin: TestPlugin = {
+        name: 'plugin',
+        setup: api => {
+          expect(api.useHookRunners).toBeTruthy();
+          done();
+        },
+      };
+      manager.usePlugin(plugin);
+      manager.init();
+    });
+
+    it('should allow to register extra api', done => {
+      type API = { foo: () => void };
+
+      const manager = createAsyncManager<TestHooks, API>(
+        {},
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        { foo: () => {} },
+      );
+
+      const plugin: PluginOptions<TestHooks, Setup<TestHooks, API>> = {
+        name: 'plugin',
+        setup: api => {
+          expect(api.foo).toBeTruthy();
+          done();
+        },
+      };
+
+      manager.usePlugin(plugin);
+      manager.init();
+    });
+  });
+
+  describe('usePlugins option', () => {
+    it('should allow to use single plugin', async () => {
+      const manager = createManager<TestHooks>();
+
+      const list: number[] = [];
+      const plugin0: TestPlugin = {
+        name: 'plugin0',
+        setup: () => {
+          list.push(0);
+        },
+      };
+
+      const plugin1: TestPlugin = {
+        name: 'plugin1',
+        usePlugins: [plugin0],
+        setup: () => {
+          list.push(1);
+        },
+      };
+
+      manager.usePlugin(plugin1);
+      manager.init();
+
+      expect(list).toStrictEqual([0, 1]);
+    });
+
+    it('should allow to use multiple plugins', async () => {
+      const manager = createManager<TestHooks>();
+
+      const list: number[] = [];
+      const plugin0: TestPlugin = {
+        name: 'plugin0',
+        setup: () => {
+          list.push(0);
+        },
+      };
+
+      const plugin1: TestPlugin = {
+        name: 'plugin1',
+        usePlugins: [plugin0],
+        setup: () => {
+          list.push(1);
+        },
+      };
+
+      const plugin2: TestPlugin = {
+        name: 'plugin2',
+        usePlugins: [plugin1],
+        setup: () => {
+          list.push(2);
+        },
+      };
+
+      manager.usePlugin(plugin2);
+      manager.init();
+
+      expect(list).toStrictEqual([0, 1, 2]);
+    });
+
+    it('should allow to use plugin without setup function', async () => {
+      const manager = createManager<TestHooks>();
+
+      const list: number[] = [];
+      const plugin0: TestPlugin = {
+        name: 'plugin0',
+        setup: () => {
+          list.push(0);
+        },
+      };
+
+      const plugin1: TestPlugin = {
+        name: 'plugin1',
+        usePlugins: [plugin0],
+      };
+
+      manager.usePlugin(plugin1);
+      manager.init();
+
+      expect(list).toStrictEqual([0]);
+    });
+
+    it('should allow to use function plugin', async () => {
+      const manager = createManager<TestHooks>();
+
+      const list: number[] = [];
+      const plugin0: TestPlugin = {
+        name: 'plugin0',
+        setup: () => {
+          list.push(0);
+        },
+      };
+
+      manager.usePlugin(() => plugin0);
+      manager.init();
+
+      expect(list).toStrictEqual([0]);
+    });
+  });
 });