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

package/lib/hookGroup.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHookManager = exports.isPluginInstance = exports.SYNC_PLUGIN_SYMBOL = exports.DEFAULT_OPTIONS = void 0;
+const hooks_1 = require("./hooks");
+exports.DEFAULT_OPTIONS = {
+    name: 'untitled',
+    pre: [],
+    post: [],
+    rivals: [],
+    required: [],
+    order: 0
+};
+exports.SYNC_PLUGIN_SYMBOL = 'SYNC_PLUGIN_SYMBOL';
+const isPluginInstance = (plugin) => plugin &&
+    plugin.hasOwnProperty(exports.SYNC_PLUGIN_SYMBOL) &&
+    plugin.SYNC_PLUGIN_SYMBOL === exports.SYNC_PLUGIN_SYMBOL;
+exports.isPluginInstance = isPluginInstance;
+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] = (0, hooks_1.createSyncHook)();
+                break;
+            case 'SyncBailHook':
+                newHookMap[hookName] = (0, hooks_1.createSyncBailHook)();
+                break;
+            case 'SyncWaterfallHook':
+                newHookMap[hookName] = (0, hooks_1.createSyncWaterfallHook)();
+                break;
+            case 'AsyncParallelHook':
+                newHookMap[hookName] = (0, hooks_1.createAsyncParallelHook)();
+                break;
+            case 'AsyncSeriesWaterfallHook':
+                newHookMap[hookName] = (0, hooks_1.createAsyncSeriesWaterfallHook)();
+                break;
+            default:
+        }
+    }
+    return newHookMap;
+};
+const createHookManager = (hookMap, hasContext = true) => {
+    const setupHook = (0, hooks_1.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({}, exports.DEFAULT_OPTIONS), { name: `plugin-id-${uuid()}` }), options), { handlers: pluginHandlers, SYNC_PLUGIN_SYMBOL: exports.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
+    };
+};
+exports.createHookManager = createHookManager;

package/lib/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/lib/hooks.js

@@ -0,0 +1,131 @@
+"use strict";
+// 钩子参数来源（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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAsyncSeriesWaterfallHook = exports.createAsyncParallelHook = exports.createSyncWaterfallHook = exports.createSyncBailHook = exports.createSyncHook = void 0;
+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'
+    };
+};
+exports.createSyncHook = createSyncHook;
+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'
+    };
+};
+exports.createSyncBailHook = createSyncBailHook;
+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'
+    };
+};
+exports.createSyncWaterfallHook = createSyncWaterfallHook;
+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'
+    };
+};
+exports.createAsyncParallelHook = createAsyncParallelHook;
+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'
+    };
+};
+exports.createAsyncSeriesWaterfallHook = createAsyncSeriesWaterfallHook;

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const Hookable_1 = require("./Hookable");
-exports.Hookable = Hookable_1.Hookable;
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./hookGroup"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shuvi/hook",
-  "version": "0.0.1-rc.34",
+  "version": "1.0.0-rc.0",
   "license": "MIT",
   "main": "lib/index.js",
   "module": "esm/index.js",
@@ -12,15 +12,14 @@
   "engines": {
     "node": ">= 12.0.0"
   },
+  "author": "Zheng Yu Tay",
   "scripts": {
     "dev": "run-p watch:*",
-    "watch:esm": "tsc -p tsconfig.build.esm.json -w",
-    "watch:cjs": "tsc -p tsconfig.build.cjs.json -w",
+    "watch:esm": "tsc -p tsconfig.build.json -m esnext --outDir esm -w",
+    "watch:cjs": "tsc -p tsconfig.build.json -m commonjs --outDir lib -w",
     "prebuild": "rimraf lib esm",
     "build": "run-p build:*",
-    "build:esm": "tsc -p tsconfig.build.esm.json",
-    "build:cjs": "tsc -p tsconfig.build.cjs.json"
-  },
-  "author": "Zheng Yu Tay",
-  "gitHead": "10ebaa2a20fd06bc7f34be0feeddef9a26f9dddd"
-}
+    "build:esm": "tsc -p tsconfig.build.json -m esnext --outDir esm",
+    "build:cjs": "tsc -p tsconfig.build.json -m commonjs --outDir lib"
+  }
+}

package/esm/AsyncParallelHook.d.ts

@@ -1,3 +0,0 @@
-export declare const executeAsyncParallelHook: (tapFns: (((...args: any[]) => void | Promise<void>) & {
-    hookName?: string | undefined;
-})[], ...args: any[]) => Promise<void[]>;

package/esm/AsyncParallelHook.js

@@ -1,13 +0,0 @@
-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 executeAsyncParallelHook = (tapFns, ...args) => __awaiter(void 0, void 0, void 0, function* () {
-    const results = yield Promise.all(tapFns.map(fn => fn(...args)));
-    return results;
-});

package/esm/AsyncSeriesBailHook.d.ts

@@ -1,3 +0,0 @@
-export declare const executeAsyncSeriesBailHook: (tapFns: (((...args: any[]) => void | Promise<void>) & {
-    hookName?: string | undefined;
-})[], ...args: any[]) => Promise<unknown>;

package/esm/AsyncSeriesBailHook.js

@@ -1,22 +0,0 @@
-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 executeAsyncSeriesBailHook = (tapFns, ...args) => __awaiter(void 0, void 0, void 0, function* () {
-    let result = [];
-    for (let i = 0; i < tapFns.length; i++) {
-        result = tapFns[i](...args);
-        if (Promise.resolve(result) === result) {
-            result = yield result;
-        }
-        if (result) {
-            break;
-        }
-    }
-    return result;
-});

package/esm/AsyncSeriesHook.d.ts

@@ -1,3 +0,0 @@
-export declare const executeAsyncSeriesHook: (tapFns: (((...args: any[]) => void | Promise<void>) & {
-    hookName?: string | undefined;
-})[], ...args: any[]) => Promise<unknown[]>;

package/esm/AsyncSeriesHook.js

@@ -1,16 +0,0 @@
-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 executeAsyncSeriesHook = (tapFns, ...args) => __awaiter(void 0, void 0, void 0, function* () {
-    let results = [];
-    for (let i = 0; i < tapFns.length; i++) {
-        results.push(yield tapFns[i](...args));
-    }
-    return results;
-});

package/esm/AsyncSeriesWaterfallHook.d.ts

@@ -1,3 +0,0 @@
-export declare const executeAsyncSeriesWaterfallHook: (tapFns: (((...args: any[]) => void | Promise<void>) & {
-    hookName?: string | undefined;
-})[], ...args: any[]) => Promise<any>;

package/esm/AsyncSeriesWaterfallHook.js

@@ -1,24 +0,0 @@
-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 executeAsyncSeriesWaterfallHook = (tapFns, ...args) => __awaiter(void 0, void 0, void 0, function* () {
-    for (let i = 0; i < tapFns.length; i++) {
-        let fn = tapFns[i];
-        let promiseResult = yield fn(...args);
-        if (typeof args[0] !== 'undefined') {
-            if (typeof promiseResult !== 'undefined') {
-                args[0] = promiseResult;
-            }
-            else {
-                console.warn(`Expected return value from hook "${fn.hookName}" but is undefined`);
-            }
-        }
-    }
-    return args[0];
-});

package/esm/Hookable.d.ts

@@ -1,9 +0,0 @@
-import { IHookOpts, ICallHookOpts, IHookable, IHookConfig } from './types';
-export declare class Hookable implements IHookable {
-    private _hooks;
-    tap<Config extends IHookConfig = IHookConfig>(name: Config['name'], hook: IHookOpts<Config['initialValue'], Config['args']>): () => void;
-    callHook<Config extends IHookConfig = IHookConfig>(name: Config['name'], ...args: Config['args']): Promise<unknown[]>;
-    callHook<Config extends IHookConfig = IHookConfig>(options: ICallHookOpts<Config['name'], Config['initialValue']>, ...args: Config['args']): Promise<Config['initialValue']>;
-    on<Config extends IHookConfig = IHookConfig>(event: Config['name'], listener: (...args: Config['args']) => void): () => void;
-    emitEvent<Config extends IHookConfig = IHookConfig>(name: Config['name'], ...args: Config['args']): void;
-}