@shuvi/hook 0.0.1-rc.34 → 1.0.0-rc.0

package/esm/hookGroup.d.ts

@@ -0,0 +1,56 @@
+import { SyncHook, SyncBailHook, SyncWaterfallHook, AsyncParallelHook, AsyncSeriesWaterfallHook, SyncHookHandler, SyncBailHookHandler, SyncWaterfallHookHandler, AsyncParallelHookHandler, AsyncSeriesWaterfallHookHandler } from './hooks';
+export declare type PatchPluginParameter<T, C> = RemoveManagerVoidParameter<AddContextParameter<T, C>>;
+export declare type AddContextParameter<T, C> = T extends (initalValue: infer I, extraArg: infer E) => infer R ? (initalValue: I, extraArg: E, context: C) => R : T;
+export declare type AnyHook = SyncHook<any, any, any> | SyncBailHook<any, any, any> | SyncWaterfallHook<any, any> | AsyncParallelHook<any, any, any> | AsyncSeriesWaterfallHook<any, any>;
+export interface HookMap {
+    [x: string]: AnyHook;
+}
+export declare type Setup<EHM> = (utils: {
+    addHooks: (hook: Partial<EHM>) => void;
+}) => void;
+export declare type CreatePlugin<HM extends HookMap, C, EHM extends HookMap> = (pluginHandlers: IPluginHandlers<HM & EHM, C> & {
+    setup?: Setup<EHM>;
+}, options?: PluginOptions) => IPluginInstance<HM & EHM, C>;
+export declare type HookManager<HM extends HookMap, C, EHM extends HookMap> = {
+    createPlugin: (pluginHandlers: IPluginHandlers<HM & EHM, C> & {
+        setup?: Setup<EHM>;
+    }, options?: PluginOptions) => IPluginInstance<HM & EHM, C>;
+    usePlugin: (...plugins: IPluginInstance<HM & EHM, C>[]) => void;
+    runner: RunnerType<HM, EHM>;
+    setContext: (context: C) => void;
+    clear: () => void;
+    addHooks: (hook: Partial<EHM>) => void;
+    hooks: HM | (HM & EHM);
+    getPlugins: () => IPluginInstance<HM & EHM, C>[];
+};
+export declare type RunnerType<HM, EHM> = {
+    [K in keyof (HM & EHM)]: HookRunnerType<(HM & EHM)[K]>;
+} & {
+    setup: Setup<EHM>;
+};
+export declare type HookRunnerType<H> = H extends SyncHook<infer T, infer E, infer R> ? SyncHook<T, E, R>['run'] : H extends SyncBailHook<infer T, infer E, infer R> ? SyncBailHook<T, E, R>['run'] : H extends SyncWaterfallHook<infer T, infer E> ? SyncWaterfallHook<T, E>['run'] : H extends AsyncParallelHook<infer T, infer E, infer R> ? AsyncParallelHook<T, E, R>['run'] : H extends AsyncSeriesWaterfallHook<infer T, infer E> ? AsyncSeriesWaterfallHook<T, E>['run'] : never;
+export declare type IPluginInstance<HM, C> = {
+    handlers: IPluginHandlers<HM, C>;
+    SYNC_PLUGIN_SYMBOL: 'SYNC_PLUGIN_SYMBOL';
+} & PluginOptions;
+export declare type IPluginHandlers<HM, C> = Partial<IPluginHandlersFullMap<HM, C>>;
+export declare type IPluginHandlersFullMap<HM, C> = {
+    [K in keyof HM]: HM[K] extends SyncHook<infer T, infer E, infer R> ? PatchPluginParameter<SyncHookHandler<T, E, R>, C> : HM[K] extends SyncBailHook<infer T, infer E, infer R> ? PatchPluginParameter<SyncBailHookHandler<T, E, R>, C> : HM[K] extends SyncWaterfallHook<infer T, infer E> ? PatchPluginParameter<SyncWaterfallHookHandler<T, E>, C> : HM[K] extends AsyncParallelHook<infer T, infer E, infer R> ? PatchPluginParameter<AsyncParallelHookHandler<T, E, R>, C> : HM[K] extends AsyncSeriesWaterfallHook<infer T, infer E> ? PatchPluginParameter<AsyncSeriesWaterfallHookHandler<T, E>, C> : never;
+};
+export declare type PluginOptions = {
+    name?: string;
+    pre?: string[];
+    post?: string[];
+    rivals?: string[];
+    required?: string[];
+    order?: number;
+    [x: string]: any;
+};
+export declare const DEFAULT_OPTIONS: Required<PluginOptions>;
+export declare const SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
+export declare const isPluginInstance: (plugin: any) => any;
+export declare type ArrayElements<T extends {}> = {
+    [K in keyof T]: T[K][];
+};
+export declare const createHookManager: <HM extends HookMap, C = void, EHM extends HookMap = {}>(hookMap: HM, hasContext?: boolean) => HookManager<HM, C, EHM>;
+export declare type RemoveManagerVoidParameter<T> = T extends (initalValue: infer I, extraArg: infer E, context: infer C) => infer R ? null extends I ? null extends E ? null extends C ? (initialValue: I, extraArg: E, context: C) => R : void extends C ? (initialValue: I, extraArg: E) => R : (initialValue: I, extraArg: E, context: C) => R : void extends E ? null extends C ? (initialValue: I, context: C) => R : void extends C ? (initialValue: I) => R : (initialValue: I, context: C) => R : null extends C ? (initialValue: I, extraArg: E, context: C) => R : void extends C ? (initialValue: I, extraArg: E) => R : (initialValue: I, extraArg: E, context: C) => R : void extends I ? null extends E ? null extends C ? (extraArg: E, context: C) => R : void extends C ? (extraArg: E) => R : (extraArg: E, context: C) => R : void extends E ? null extends C ? (context: C) => R : void extends C ? () => R : (context: C) => R : null extends C ? (extraArg: E, context: C) => R : void extends C ? (extraArg: E) => R : (extraArg: E, context: C) => R : null extends E ? null extends C ? (initialValue: I, extraArg: E, context: C) => R : void extends C ? (initialValue: I, extraArg: E) => R : (initialValue: I, extraArg: E, context: C) => R : void extends E ? null extends C ? (initialValue: I, context: C) => R : void extends C ? (initialValue: I) => R : (initialValue: I, context: C) => R : null extends C ? (initialValue: I, extraArg: E, context: C) => R : void extends C ? (initialValue: I, extraArg: E) => R : (initialValue: I, extraArg: E, context: C) => R : T;

package/esm/hookGroup.js

@@ -0,0 +1,243 @@
+import { createSyncHook, createSyncBailHook, createSyncWaterfallHook, createAsyncParallelHook, createAsyncSeriesWaterfallHook } from './hooks';
+export const DEFAULT_OPTIONS = {
+    name: 'untitled',
+    pre: [],
+    post: [],
+    rivals: [],
+    required: [],
+    order: 0
+};
+export const SYNC_PLUGIN_SYMBOL = 'SYNC_PLUGIN_SYMBOL';
+export const isPluginInstance = (plugin) => plugin &&
+    plugin.hasOwnProperty(SYNC_PLUGIN_SYMBOL) &&
+    plugin.SYNC_PLUGIN_SYMBOL === SYNC_PLUGIN_SYMBOL;
+const sortPlugins = (input) => {
+    let plugins = input.slice();
+    plugins.sort((a, b) => a.order - b.order);
+    for (let i = 0; i < plugins.length; i++) {
+        let plugin = plugins[i];
+        if (plugin.pre) {
+            for (const pre of plugin.pre) {
+                for (let j = i + 1; j < plugins.length; j++) {
+                    if (plugins[j].name === pre) {
+                        plugins = [
+                            ...plugins.slice(0, i),
+                            plugins[j],
+                            ...plugins.slice(i, j),
+                            ...plugins.slice(j + 1, plugins.length)
+                        ];
+                    }
+                }
+            }
+        }
+        if (plugin.post) {
+            for (const post of plugin.post) {
+                for (let j = 0; j < i; j++) {
+                    if (plugins[j].name === post) {
+                        plugins = [
+                            ...plugins.slice(0, j),
+                            ...plugins.slice(j + 1, i + 1),
+                            plugins[j],
+                            ...plugins.slice(i + 1, plugins.length)
+                        ];
+                    }
+                }
+            }
+        }
+    }
+    return plugins;
+};
+const checkPlugins = (plugins) => {
+    for (const origin of plugins) {
+        if (origin.rivals) {
+            for (const rival of origin.rivals) {
+                for (const plugin of plugins) {
+                    if (rival === plugin.name) {
+                        throw new Error(`${origin.name} has rival ${plugin.name}`);
+                    }
+                }
+            }
+        }
+        if (origin.required) {
+            for (const required of origin.required) {
+                if (!plugins.some(plugin => plugin.name === required)) {
+                    throw new Error(`The plugin: ${required} is required when plugin: ${origin.name} is exist.`);
+                }
+            }
+        }
+    }
+};
+function uuid() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        var r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+const copyHookMap = (hookMap) => {
+    const newHookMap = {};
+    for (const hookName in hookMap) {
+        const hook = hookMap[hookName];
+        switch (hook === null || hook === void 0 ? void 0 : hook.type) {
+            case 'SyncHook':
+                newHookMap[hookName] = createSyncHook();
+                break;
+            case 'SyncBailHook':
+                newHookMap[hookName] = createSyncBailHook();
+                break;
+            case 'SyncWaterfallHook':
+                newHookMap[hookName] = createSyncWaterfallHook();
+                break;
+            case 'AsyncParallelHook':
+                newHookMap[hookName] = createAsyncParallelHook();
+                break;
+            case 'AsyncSeriesWaterfallHook':
+                newHookMap[hookName] = createAsyncSeriesWaterfallHook();
+                break;
+            default:
+        }
+    }
+    return newHookMap;
+};
+export const createHookManager = (hookMap, hasContext = true) => {
+    const setupHook = createSyncHook();
+    const _hookMap = Object.assign(Object.assign({}, copyHookMap(hookMap)), { setup: setupHook });
+    let _plugins = [];
+    let _hookHandlers = {};
+    let _internalRunners = {};
+    let _context;
+    let _initiated = false;
+    const init = () => {
+        load();
+        const setupRunner = getRunner('setup');
+        setupRunner({ addHooks });
+    };
+    const createPlugin = (pluginHandlers, options = {}) => {
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, DEFAULT_OPTIONS), { name: `plugin-id-${uuid()}` }), options), { handlers: pluginHandlers, SYNC_PLUGIN_SYMBOL });
+    };
+    const usePlugin = (...plugins) => {
+        if (_initiated) {
+            return;
+        }
+        _plugins.push(...plugins);
+    };
+    const load = () => {
+        let plugins = _plugins;
+        plugins = sortPlugins(plugins);
+        checkPlugins(plugins);
+        plugins.forEach(plugin => {
+            const handlers = plugin.handlers;
+            let hookName;
+            for (hookName in handlers) {
+                if (!_hookHandlers[hookName]) {
+                    _hookHandlers[hookName] = [];
+                }
+                _hookHandlers[hookName].push(handlers[hookName]);
+            }
+        });
+    };
+    const setContext = (context) => {
+        _context = context;
+    };
+    const hooks = _hookMap;
+    const clear = () => {
+        Object.values(_hookMap).forEach(cur => {
+            cur.clear();
+        });
+        _plugins = [];
+        _hookHandlers = {};
+        _internalRunners = {};
+        _initiated = false;
+    };
+    const addHooks = (extraHookMap) => {
+        const extraHookMapNew = copyHookMap(extraHookMap);
+        for (const hookName in extraHookMapNew) {
+            // connot override existed hooks
+            if (!_hookMap[hookName]) {
+                //@ts-ignore
+                _hookMap[hookName] = extraHookMapNew[hookName];
+                if (_internalRunners[hookName]) {
+                    delete _internalRunners[hookName];
+                }
+            }
+            else {
+                console.log('has been added', hookName);
+            }
+        }
+    };
+    const getRunner = (hookName) => {
+        if (_internalRunners[hookName]) {
+            return _internalRunners[hookName];
+        }
+        const currentRunner = getSingerRunner(hookName);
+        _internalRunners[hookName] = currentRunner;
+        return currentRunner;
+    };
+    const getSingerRunner = (hookName) => {
+        let used = false;
+        const hook = _hookMap[hookName];
+        const handlers = _hookHandlers[hookName] || [];
+        if (!hook)
+            return () => { };
+        const isSetupHook = hookName === 'setup';
+        if (isSetupHook) {
+            return (util) => {
+                let setupDone = false;
+                if (!used) {
+                    hook.use(...handlers);
+                    // every time setup hook runs, set setupDone to true at the end
+                    // to make sure util methods cannot be used outside of the hook
+                    hook.use(() => {
+                        setupDone = true;
+                    });
+                    used = true;
+                }
+                const getDisposableFunctionProxy = (func) => new Proxy(func, {
+                    apply(target, thisArg, argArray) {
+                        if (setupDone) {
+                            return;
+                        }
+                        return target.apply(thisArg, argArray);
+                    }
+                });
+                const wrappedUtil = Object.assign({}, util);
+                for (let key in wrappedUtil) {
+                    if (typeof wrappedUtil[key] === 'function') {
+                        wrappedUtil[key] = getDisposableFunctionProxy(wrappedUtil[key]);
+                    }
+                }
+                // @ts-ignore
+                return hook.run(wrappedUtil);
+            };
+        }
+        return (...args) => {
+            if (!used) {
+                hook.use(...handlers);
+                used = true;
+            }
+            if (hasContext && !_context) {
+                throw new Error(`Context not set. Hook ${String(hookName)} running failed.`);
+            }
+            // @ts-ignore
+            return hook.run(...args, _context);
+        };
+    };
+    const runnerProxy = new Proxy({}, {
+        get(_, prop) {
+            if (!_initiated) {
+                init();
+                _initiated = true;
+            }
+            return getRunner(prop);
+        }
+    });
+    return {
+        createPlugin,
+        usePlugin,
+        runner: runnerProxy,
+        clear,
+        addHooks,
+        hooks,
+        setContext,
+        getPlugins: () => _plugins
+    };
+};

package/esm/hooks.d.ts

@@ -0,0 +1,57 @@
+export declare type HookRunnerFromHandler<T> = T extends (...args: infer A) => infer R ? void extends R ? (...args: A) => void : (...args: A) => R[] : T;
+export declare type RemoveVoidParameter<T> = T extends (initalValue: infer I, extraArg: infer E) => infer R ? null extends I ? null extends E ? (initialValue: I, extraArg: E) => R : void extends E ? (initialValue: I) => R : (initialValue: I, extraArg: E) => R : void extends I ? null extends E ? (extraArg: E) => R : void extends E ? () => R : (extraArg: E) => R : null extends E ? (initialValue: I, extraArg: E) => R : void extends E ? (initialValue: I) => R : (initialValue: I, extraArg: E) => R : T;
+export declare type RemoveVoidParameterBackup<T> = T extends (initalValue: infer I, extraArg: infer E) => infer R ? I extends void ? I extends void ? E extends void ? E extends void ? () => R : (extraArg: E) => R : (extraArg: E) => R : E extends void ? E extends void ? () => R : (initalValue: I, extraArg: E) => R : (initalValue: I, extraArg: E) => R : E extends void ? E extends void ? (initalValue: I) => R : (initalValue: I, extradddArg: E) => R : (initalValue: I, extraArg: E) => R : T;
+export declare type Remove3VoidParameter<T> = T extends (initalValue: infer I, extraArg: infer E, context: infer C) => infer R ? I extends void ? I extends void ? E extends void ? E extends void ? C extends void ? C extends void ? 'C无' : 'C为any' : 'C有' : (extraArg: E) => R : (extraArg: E) => R : E extends void ? E extends void ? () => R : (initalValue: I, extraArg: E) => R : (initalValue: I, extraArg: E) => R : 'I有' : T;
+export declare type SyncHookHandler<I, E, R> = (initalValue: I, extraArg: E) => R;
+export declare type SyncBailHookHandler<I, E, R> = (initalValue: I, extraArg: E) => R | undefined | void;
+export declare type SyncWaterfallHookHandler<I, E> = (initalValue: I, extraArgs: E) => I;
+export declare type AsyncSeriesWaterfallHookHandler<I, E> = (initalValue: I, extraArg: E) => Promise<I> | I;
+export declare type AsyncParallelHookHandler<I, E, R> = (initalValue: I, extraArgs: E) => Promise<R> | R;
+/** Normal hook. */
+export declare type SyncHook<I = void, E = void, R = void> = {
+    use: (...handlers: RemoveVoidParameter<SyncHookHandler<I, E, R>>[]) => void;
+    run: RemoveVoidParameter<(initalValue: I, extraArg: E) => R[]>;
+    clear: () => void;
+    type: string;
+};
+/** Has return value with `any` type */
+export declare type SyncBailHook<I = void, E = void, R = I> = {
+    use: (...handlers: RemoveVoidParameter<SyncBailHookHandler<I, E, R>>[]) => void;
+    run: RemoveVoidParameter<SyncBailHookHandler<I, E, R>>;
+    clear: () => void;
+    type: string;
+};
+/** Has return value with given type */
+export declare type SyncWaterfallHook<I, E = void> = {
+    use: (...handlers: RemoveVoidParameter<SyncWaterfallHookHandler<I, E>>[]) => void;
+    run: RemoveVoidParameter<SyncWaterfallHookHandler<I, E>>;
+    clear: () => void;
+    type: string;
+};
+/** Normal async hook. No return value
+ *
+ * RemoveVoidParameter<(
+    null extends R ?
+    (R extends void ? ((initalValue: I, extraArg: E) => Promise<R[]>) :
+      ((initalValue: I, extraArg: E) => Promise<R[]>)) :
+    ((initalValue: I, extraArg: E) => Promise<R[]>)
+  )>
+ */
+export declare type AsyncParallelHook<I = void, E = void, R = void> = {
+    use: (...handlers: RemoveVoidParameter<AsyncParallelHookHandler<I, E, R>>[]) => void;
+    run: RemoveVoidParameter<(initalValue: I, extraArg: E) => Promise<R[]>>;
+    clear: () => void;
+    type: string;
+};
+/** Has return value with given type */
+export declare type AsyncSeriesWaterfallHook<I = void, E = void> = {
+    use: (...handlers: RemoveVoidParameter<AsyncSeriesWaterfallHookHandler<I, E>>[]) => void;
+    run: RemoveVoidParameter<(initalValue: I, extraArgs: E) => Promise<I>>;
+    clear: () => void;
+    type: string;
+};
+export declare const createSyncHook: <I = void, E = void, R = void>() => SyncHook<I, E, R>;
+export declare const createSyncBailHook: <I = void, E = void, R = I>() => SyncBailHook<I, E, R>;
+export declare const createSyncWaterfallHook: <I = void, E = void>() => SyncWaterfallHook<I, E>;
+export declare const createAsyncParallelHook: <I = void, E = void, R = void>() => AsyncParallelHook<I, E, R>;
+export declare const createAsyncSeriesWaterfallHook: <I = void, E = void>() => AsyncSeriesWaterfallHook<I, E>;

package/esm/hooks.js

@@ -0,0 +1,123 @@
+// 钩子参数来源（void，固定值，前一个钩子的返回值） 钩子同步异步 钩子调用顺序（） 钩子返回值
+// 普通型钩子handler均无返回值（如果有，则是一个数组，但是似乎没啥用，如果对返回值有要求，那么应该用waterfall钩子）
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export const createSyncHook = () => {
+    let _handlers = [];
+    const use = (...handlers) => {
+        _handlers.push(...handlers);
+    };
+    const run = (...args) => {
+        // @ts-ignore
+        return _handlers.map(handler => handler(...args));
+    };
+    const clear = () => {
+        _handlers = [];
+    };
+    return {
+        use,
+        run,
+        clear,
+        type: 'SyncHook'
+    };
+};
+export const createSyncBailHook = () => {
+    let _handlers = [];
+    const use = (...handlers) => {
+        _handlers.push(...handlers);
+    };
+    const run = (...args) => {
+        for (let i = 0; i < _handlers.length; i++) {
+            const handler = _handlers[i];
+            // @ts-ignore
+            const result = handler(...args);
+            if (result)
+                return result;
+        }
+        return undefined;
+    };
+    const clear = () => {
+        _handlers = [];
+    };
+    return {
+        use,
+        run,
+        clear,
+        type: 'SyncBailHook'
+    };
+};
+export const createSyncWaterfallHook = () => {
+    let _handlers = [];
+    const use = (...handlers) => {
+        _handlers.push(...handlers);
+    };
+    const run = (...args) => {
+        let [currentParam, ...otherArgs] = args;
+        for (let i = 0; i < _handlers.length; i++) {
+            const handler = _handlers[i];
+            // @ts-ignore
+            currentParam = handler(currentParam, ...otherArgs);
+        }
+        return currentParam;
+    };
+    const clear = () => {
+        _handlers = [];
+    };
+    return {
+        use,
+        run,
+        clear,
+        type: 'SyncWaterfallHook'
+    };
+};
+export const createAsyncParallelHook = () => {
+    let _handlers = [];
+    const use = (...handlers) => {
+        _handlers.push(...handlers);
+    };
+    const run = (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        return yield Promise.all(_handlers.map(
+        // @ts-ignore
+        handler => handler(...args)));
+    });
+    const clear = () => {
+        _handlers = [];
+    };
+    return {
+        use,
+        run,
+        clear,
+        type: 'AsyncParallelHook'
+    };
+};
+export const createAsyncSeriesWaterfallHook = () => {
+    let _handlers = [];
+    const use = (...handlers) => {
+        _handlers.push(...handlers);
+    };
+    const run = (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        let [currentParam, ...otherArgs] = args;
+        for (let i = 0; i < _handlers.length; i++) {
+            const handler = _handlers[i];
+            // @ts-ignore
+            currentParam = yield handler(currentParam, ...otherArgs);
+        }
+        return currentParam;
+    });
+    const clear = () => {
+        _handlers = [];
+    };
+    return {
+        use,
+        run,
+        clear,
+        type: 'AsyncSeriesWaterfallHook'
+    };
+};

package/esm/index.d.ts

@@ -1,3 +1,2 @@
-import { Hookable } from './Hookable';
-export { Hookable };
-export * from './types';
+export * from './hooks';
+export * from './hookGroup';

package/esm/index.js

@@ -1,2 +1,2 @@
-import { Hookable } from './Hookable';
-export { Hookable };
+export * from './hooks';
+export * from './hookGroup';

package/lib/hookGroup.d.ts

@@ -0,0 +1,56 @@
+import { SyncHook, SyncBailHook, SyncWaterfallHook, AsyncParallelHook, AsyncSeriesWaterfallHook, SyncHookHandler, SyncBailHookHandler, SyncWaterfallHookHandler, AsyncParallelHookHandler, AsyncSeriesWaterfallHookHandler } from './hooks';
+export declare type PatchPluginParameter<T, C> = RemoveManagerVoidParameter<AddContextParameter<T, C>>;
+export declare type AddContextParameter<T, C> = T extends (initalValue: infer I, extraArg: infer E) => infer R ? (initalValue: I, extraArg: E, context: C) => R : T;
+export declare type AnyHook = SyncHook<any, any, any> | SyncBailHook<any, any, any> | SyncWaterfallHook<any, any> | AsyncParallelHook<any, any, any> | AsyncSeriesWaterfallHook<any, any>;
+export interface HookMap {
+    [x: string]: AnyHook;
+}
+export declare type Setup<EHM> = (utils: {
+    addHooks: (hook: Partial<EHM>) => void;
+}) => void;
+export declare type CreatePlugin<HM extends HookMap, C, EHM extends HookMap> = (pluginHandlers: IPluginHandlers<HM & EHM, C> & {
+    setup?: Setup<EHM>;
+}, options?: PluginOptions) => IPluginInstance<HM & EHM, C>;
+export declare type HookManager<HM extends HookMap, C, EHM extends HookMap> = {
+    createPlugin: (pluginHandlers: IPluginHandlers<HM & EHM, C> & {
+        setup?: Setup<EHM>;
+    }, options?: PluginOptions) => IPluginInstance<HM & EHM, C>;
+    usePlugin: (...plugins: IPluginInstance<HM & EHM, C>[]) => void;
+    runner: RunnerType<HM, EHM>;
+    setContext: (context: C) => void;
+    clear: () => void;
+    addHooks: (hook: Partial<EHM>) => void;
+    hooks: HM | (HM & EHM);
+    getPlugins: () => IPluginInstance<HM & EHM, C>[];
+};
+export declare type RunnerType<HM, EHM> = {
+    [K in keyof (HM & EHM)]: HookRunnerType<(HM & EHM)[K]>;
+} & {
+    setup: Setup<EHM>;
+};
+export declare type HookRunnerType<H> = H extends SyncHook<infer T, infer E, infer R> ? SyncHook<T, E, R>['run'] : H extends SyncBailHook<infer T, infer E, infer R> ? SyncBailHook<T, E, R>['run'] : H extends SyncWaterfallHook<infer T, infer E> ? SyncWaterfallHook<T, E>['run'] : H extends AsyncParallelHook<infer T, infer E, infer R> ? AsyncParallelHook<T, E, R>['run'] : H extends AsyncSeriesWaterfallHook<infer T, infer E> ? AsyncSeriesWaterfallHook<T, E>['run'] : never;
+export declare type IPluginInstance<HM, C> = {
+    handlers: IPluginHandlers<HM, C>;
+    SYNC_PLUGIN_SYMBOL: 'SYNC_PLUGIN_SYMBOL';
+} & PluginOptions;
+export declare type IPluginHandlers<HM, C> = Partial<IPluginHandlersFullMap<HM, C>>;
+export declare type IPluginHandlersFullMap<HM, C> = {
+    [K in keyof HM]: HM[K] extends SyncHook<infer T, infer E, infer R> ? PatchPluginParameter<SyncHookHandler<T, E, R>, C> : HM[K] extends SyncBailHook<infer T, infer E, infer R> ? PatchPluginParameter<SyncBailHookHandler<T, E, R>, C> : HM[K] extends SyncWaterfallHook<infer T, infer E> ? PatchPluginParameter<SyncWaterfallHookHandler<T, E>, C> : HM[K] extends AsyncParallelHook<infer T, infer E, infer R> ? PatchPluginParameter<AsyncParallelHookHandler<T, E, R>, C> : HM[K] extends AsyncSeriesWaterfallHook<infer T, infer E> ? PatchPluginParameter<AsyncSeriesWaterfallHookHandler<T, E>, C> : never;
+};
+export declare type PluginOptions = {
+    name?: string;
+    pre?: string[];
+    post?: string[];
+    rivals?: string[];
+    required?: string[];
+    order?: number;
+    [x: string]: any;
+};
+export declare const DEFAULT_OPTIONS: Required<PluginOptions>;
+export declare const SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
+export declare const isPluginInstance: (plugin: any) => any;
+export declare type ArrayElements<T extends {}> = {
+    [K in keyof T]: T[K][];
+};
+export declare const createHookManager: <HM extends HookMap, C = void, EHM extends HookMap = {}>(hookMap: HM, hasContext?: boolean) => HookManager<HM, C, EHM>;
+export declare type RemoveManagerVoidParameter<T> = T extends (initalValue: infer I, extraArg: infer E, context: infer C) => infer R ? null extends I ? null extends E ? null extends C ? (initialValue: I, extraArg: E, context: C) => R : void extends C ? (initialValue: I, extraArg: E) => R : (initialValue: I, extraArg: E, context: C) => R : void extends E ? null extends C ? (initialValue: I, context: C) => R : void extends C ? (initialValue: I) => R : (initialValue: I, context: C) => R : null extends C ? (initialValue: I, extraArg: E, context: C) => R : void extends C ? (initialValue: I, extraArg: E) => R : (initialValue: I, extraArg: E, context: C) => R : void extends I ? null extends E ? null extends C ? (extraArg: E, context: C) => R : void extends C ? (extraArg: E) => R : (extraArg: E, context: C) => R : void extends E ? null extends C ? (context: C) => R : void extends C ? () => R : (context: C) => R : null extends C ? (extraArg: E, context: C) => R : void extends C ? (extraArg: E) => R : (extraArg: E, context: C) => R : null extends E ? null extends C ? (initialValue: I, extraArg: E, context: C) => R : void extends C ? (initialValue: I, extraArg: E) => R : (initialValue: I, extraArg: E, context: C) => R : void extends E ? null extends C ? (initialValue: I, context: C) => R : void extends C ? (initialValue: I) => R : (initialValue: I, context: C) => R : null extends C ? (initialValue: I, extraArg: E, context: C) => R : void extends C ? (initialValue: I, extraArg: E) => R : (initialValue: I, extraArg: E, context: C) => R : T;