@shuvi/hook 0.0.1-pre.1

package/README.md

@@ -0,0 +1 @@
+# @shuvi/hook

package/esm/AsyncParallelHook.d.ts

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

package/esm/AsyncParallelHook.js

@@ -0,0 +1,13 @@
+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

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

package/esm/AsyncSeriesBailHook.js

@@ -0,0 +1,22 @@
+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

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

package/esm/AsyncSeriesHook.js

@@ -0,0 +1,16 @@
+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

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

package/esm/AsyncSeriesWaterfallHook.js

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,9 @@
+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;
+}

package/esm/Hookable.js

@@ -0,0 +1,87 @@
+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());
+    });
+};
+import { executeAsyncParallelHook } from './AsyncParallelHook';
+import { executeAsyncSeriesHook } from './AsyncSeriesHook';
+import { executeAsyncSeriesBailHook } from './AsyncSeriesBailHook';
+import { executeAsyncSeriesWaterfallHook } from './AsyncSeriesWaterfallHook';
+import { insertHook, getHooksFunctions, removeHook } from './utils';
+function callSerailWithInitialValue(hooks, args, initialValue) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fns = getHooksFunctions(hooks);
+        return executeAsyncSeriesWaterfallHook(fns, initialValue, ...args);
+    });
+}
+function callSerail(hooks, args, bail) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const thookFn = bail ? executeAsyncSeriesBailHook : executeAsyncSeriesHook;
+        const fns = getHooksFunctions(hooks);
+        return thookFn(fns, ...args);
+    });
+}
+function callParallel(hooks, args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fns = getHooksFunctions(hooks);
+        return (yield executeAsyncParallelHook(fns, ...args));
+    });
+}
+export class Hookable {
+    constructor() {
+        this._hooks = new Map();
+    }
+    tap(name, hook) {
+        let hooks = this._hooks.get(name);
+        if (!hooks) {
+            hooks = [];
+            this._hooks.set(name, hooks);
+        }
+        insertHook(hooks, hook);
+        return () => {
+            removeHook(hooks, hook);
+        };
+    }
+    // implement
+    callHook(options, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultOpts = {
+                bail: false,
+                parallel: false,
+                initialValue: undefined
+            };
+            let opts;
+            if (typeof options === 'object') {
+                opts = Object.assign(Object.assign({}, defaultOpts), options);
+            }
+            else {
+                opts = Object.assign(Object.assign({}, defaultOpts), { name: options });
+            }
+            const hasInitialValue = typeof opts.initialValue !== 'undefined';
+            const hooks = this._hooks.get(opts.name);
+            if (!hooks || hooks.length <= 0) {
+                // @ts-ignore no return value
+                return hasInitialValue ? opts.initialValue : [];
+            }
+            if (opts.parallel) {
+                return yield callParallel(hooks, args);
+            }
+            else if (hasInitialValue) {
+                return yield callSerailWithInitialValue(hooks, args, opts.initialValue);
+            }
+            else {
+                return yield callSerail(hooks, args, opts.bail);
+            }
+        });
+    }
+    on(event, listener) {
+        return this.tap(event, { name: 'listener', fn: listener });
+    }
+    emitEvent(name, ...args) {
+        this.callHook({ name, parallel: true }, ...args);
+    }
+}

package/esm/index.d.ts

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

package/esm/index.js

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

package/esm/types.d.ts

@@ -0,0 +1,44 @@
+export declare type NoInitValue = '$$no-initial-value';
+export interface ICallHookOpts<Name extends string = string, InitV = unknown> {
+    name: Name;
+    bail?: boolean;
+    parallel?: boolean;
+    initialValue?: InitV;
+}
+export interface IHookOpts<InitValue = NoInitValue, Args extends any[] = any[]> {
+    name: string;
+    fn: (InitValue extends NoInitValue ? (...args: Args) => void | Promise<void> : (init: InitValue, ...args: Args) => InitValue | Promise<InitValue>) & {
+        hookName?: string;
+    };
+    before?: string;
+    stage?: number;
+}
+export interface IHookConfig {
+    name: string;
+    args: any[];
+    initialValue: any;
+}
+export interface IHookable {
+    tap<Config extends IHookConfig>(hook: Config['name'], opts: IHookOpts<Config['initialValue'], Config['args']>): void;
+    callHook<Config extends IHookConfig>(name: Config['name'], ...args: Config['args']): Promise<unknown[]>;
+    callHook<Config extends IHookConfig>(options: ICallHookOpts<Config['name'], Config['initialValue']>, ...args: Config['args']): Promise<Config['initialValue']>;
+    on<Config extends IHookConfig>(event: Config['name'], listener: (...args: Config['args']) => void): void;
+    emitEvent<Config extends IHookConfig>(name: Config['name'], ...args: Config['args']): void;
+}
+declare type IDefaultHookConfig = {
+    args: [];
+    initialValue: NoInitValue;
+};
+export declare type defineHook<Name extends string, Config extends Partial<IHookConfig> = {}> = {
+    name: Name;
+} & {
+    [K in keyof Config]: Config[K];
+} & {
+    [K in Exclude<keyof IDefaultHookConfig, keyof Config>]: IDefaultHookConfig[K];
+};
+export declare type defineEvent<Name extends string, Args = []> = {
+    name: Name;
+    args: Args;
+    initialValue: NoInitValue;
+};
+export {};

package/esm/utils.d.ts

@@ -0,0 +1,6 @@
+import { IHookOpts } from './types';
+export declare const getHooksFunctions: (hooks: IHookOpts<"$$no-initial-value", any[]>[]) => (((...args: any[]) => void | Promise<void>) & {
+    hookName?: string | undefined;
+})[];
+export declare const insertHook: (hooks: IHookOpts<"$$no-initial-value", any[]>[], hook: IHookOpts<"$$no-initial-value", any[]>) => IHookOpts<"$$no-initial-value", any[]>[];
+export declare const removeHook: (hooks: IHookOpts<"$$no-initial-value", any[]>[], hookToRemove: IHookOpts<"$$no-initial-value", any[]>) => void;

package/esm/utils.js

@@ -0,0 +1,45 @@
+export const getHooksFunctions = (hooks) => {
+    return hooks.map(({ fn, name }) => {
+        fn.hookName = name;
+        return fn;
+    });
+};
+// mutable sort
+export const insertHook = (hooks, hook) => {
+    let before;
+    if (typeof hook.before === 'string') {
+        before = new Set([hook.before]);
+    }
+    let stage = 0;
+    if (typeof hook.stage === 'number') {
+        stage = hook.stage;
+    }
+    const originalHooksLength = hooks.length;
+    if (hooks.length > 1) {
+        for (let i = 1; i < originalHooksLength; i++) {
+            const tap = hooks[i];
+            const tapStage = tap.stage || 0;
+            if (before) {
+                if (before.has(tap.name)) {
+                    hooks.splice(i, 0, hook);
+                    break;
+                }
+            }
+            if (tapStage > stage) {
+                hooks.splice(i, 0, hook);
+                break;
+            }
+        }
+    }
+    if (hooks.length === originalHooksLength) {
+        hooks.push(hook);
+    }
+    return hooks;
+};
+// mutable way
+export const removeHook = (hooks, hookToRemove) => {
+    const indexToRemove = hooks.findIndex(hook => hook === hookToRemove);
+    if (indexToRemove >= 0) {
+        hooks.splice(indexToRemove, 1);
+    }
+};

package/lib/AsyncParallelHook.d.ts

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

package/lib/AsyncParallelHook.js

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

package/lib/AsyncSeriesBailHook.d.ts

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

package/lib/AsyncSeriesBailHook.js

@@ -0,0 +1,24 @@
+"use strict";
+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.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/lib/AsyncSeriesHook.d.ts

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

package/lib/AsyncSeriesHook.js

@@ -0,0 +1,18 @@
+"use strict";
+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.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/lib/AsyncSeriesWaterfallHook.d.ts

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

package/lib/AsyncSeriesWaterfallHook.js

@@ -0,0 +1,26 @@
+"use strict";
+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.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/lib/Hookable.d.ts

@@ -0,0 +1,9 @@
+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;
+}

package/lib/Hookable.js

@@ -0,0 +1,90 @@
+"use strict";
+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 });
+const AsyncParallelHook_1 = require("./AsyncParallelHook");
+const AsyncSeriesHook_1 = require("./AsyncSeriesHook");
+const AsyncSeriesBailHook_1 = require("./AsyncSeriesBailHook");
+const AsyncSeriesWaterfallHook_1 = require("./AsyncSeriesWaterfallHook");
+const utils_1 = require("./utils");
+function callSerailWithInitialValue(hooks, args, initialValue) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fns = utils_1.getHooksFunctions(hooks);
+        return AsyncSeriesWaterfallHook_1.executeAsyncSeriesWaterfallHook(fns, initialValue, ...args);
+    });
+}
+function callSerail(hooks, args, bail) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const thookFn = bail ? AsyncSeriesBailHook_1.executeAsyncSeriesBailHook : AsyncSeriesHook_1.executeAsyncSeriesHook;
+        const fns = utils_1.getHooksFunctions(hooks);
+        return thookFn(fns, ...args);
+    });
+}
+function callParallel(hooks, args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fns = utils_1.getHooksFunctions(hooks);
+        return (yield AsyncParallelHook_1.executeAsyncParallelHook(fns, ...args));
+    });
+}
+class Hookable {
+    constructor() {
+        this._hooks = new Map();
+    }
+    tap(name, hook) {
+        let hooks = this._hooks.get(name);
+        if (!hooks) {
+            hooks = [];
+            this._hooks.set(name, hooks);
+        }
+        utils_1.insertHook(hooks, hook);
+        return () => {
+            utils_1.removeHook(hooks, hook);
+        };
+    }
+    // implement
+    callHook(options, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultOpts = {
+                bail: false,
+                parallel: false,
+                initialValue: undefined
+            };
+            let opts;
+            if (typeof options === 'object') {
+                opts = Object.assign(Object.assign({}, defaultOpts), options);
+            }
+            else {
+                opts = Object.assign(Object.assign({}, defaultOpts), { name: options });
+            }
+            const hasInitialValue = typeof opts.initialValue !== 'undefined';
+            const hooks = this._hooks.get(opts.name);
+            if (!hooks || hooks.length <= 0) {
+                // @ts-ignore no return value
+                return hasInitialValue ? opts.initialValue : [];
+            }
+            if (opts.parallel) {
+                return yield callParallel(hooks, args);
+            }
+            else if (hasInitialValue) {
+                return yield callSerailWithInitialValue(hooks, args, opts.initialValue);
+            }
+            else {
+                return yield callSerail(hooks, args, opts.bail);
+            }
+        });
+    }
+    on(event, listener) {
+        return this.tap(event, { name: 'listener', fn: listener });
+    }
+    emitEvent(name, ...args) {
+        this.callHook({ name, parallel: true }, ...args);
+    }
+}
+exports.Hookable = Hookable;

package/lib/index.d.ts

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

package/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Hookable_1 = require("./Hookable");
+exports.Hookable = Hookable_1.Hookable;

package/lib/types.d.ts

@@ -0,0 +1,44 @@
+export declare type NoInitValue = '$$no-initial-value';
+export interface ICallHookOpts<Name extends string = string, InitV = unknown> {
+    name: Name;
+    bail?: boolean;
+    parallel?: boolean;
+    initialValue?: InitV;
+}
+export interface IHookOpts<InitValue = NoInitValue, Args extends any[] = any[]> {
+    name: string;
+    fn: (InitValue extends NoInitValue ? (...args: Args) => void | Promise<void> : (init: InitValue, ...args: Args) => InitValue | Promise<InitValue>) & {
+        hookName?: string;
+    };
+    before?: string;
+    stage?: number;
+}
+export interface IHookConfig {
+    name: string;
+    args: any[];
+    initialValue: any;
+}
+export interface IHookable {
+    tap<Config extends IHookConfig>(hook: Config['name'], opts: IHookOpts<Config['initialValue'], Config['args']>): void;
+    callHook<Config extends IHookConfig>(name: Config['name'], ...args: Config['args']): Promise<unknown[]>;
+    callHook<Config extends IHookConfig>(options: ICallHookOpts<Config['name'], Config['initialValue']>, ...args: Config['args']): Promise<Config['initialValue']>;
+    on<Config extends IHookConfig>(event: Config['name'], listener: (...args: Config['args']) => void): void;
+    emitEvent<Config extends IHookConfig>(name: Config['name'], ...args: Config['args']): void;
+}
+declare type IDefaultHookConfig = {
+    args: [];
+    initialValue: NoInitValue;
+};
+export declare type defineHook<Name extends string, Config extends Partial<IHookConfig> = {}> = {
+    name: Name;
+} & {
+    [K in keyof Config]: Config[K];
+} & {
+    [K in Exclude<keyof IDefaultHookConfig, keyof Config>]: IDefaultHookConfig[K];
+};
+export declare type defineEvent<Name extends string, Args = []> = {
+    name: Name;
+    args: Args;
+    initialValue: NoInitValue;
+};
+export {};

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils.d.ts

@@ -0,0 +1,6 @@
+import { IHookOpts } from './types';
+export declare const getHooksFunctions: (hooks: IHookOpts<"$$no-initial-value", any[]>[]) => (((...args: any[]) => void | Promise<void>) & {
+    hookName?: string | undefined;
+})[];
+export declare const insertHook: (hooks: IHookOpts<"$$no-initial-value", any[]>[], hook: IHookOpts<"$$no-initial-value", any[]>) => IHookOpts<"$$no-initial-value", any[]>[];
+export declare const removeHook: (hooks: IHookOpts<"$$no-initial-value", any[]>[], hookToRemove: IHookOpts<"$$no-initial-value", any[]>) => void;

package/lib/utils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHooksFunctions = (hooks) => {
+    return hooks.map(({ fn, name }) => {
+        fn.hookName = name;
+        return fn;
+    });
+};
+// mutable sort
+exports.insertHook = (hooks, hook) => {
+    let before;
+    if (typeof hook.before === 'string') {
+        before = new Set([hook.before]);
+    }
+    let stage = 0;
+    if (typeof hook.stage === 'number') {
+        stage = hook.stage;
+    }
+    const originalHooksLength = hooks.length;
+    if (hooks.length > 1) {
+        for (let i = 1; i < originalHooksLength; i++) {
+            const tap = hooks[i];
+            const tapStage = tap.stage || 0;
+            if (before) {
+                if (before.has(tap.name)) {
+                    hooks.splice(i, 0, hook);
+                    break;
+                }
+            }
+            if (tapStage > stage) {
+                hooks.splice(i, 0, hook);
+                break;
+            }
+        }
+    }
+    if (hooks.length === originalHooksLength) {
+        hooks.push(hook);
+    }
+    return hooks;
+};
+// mutable way
+exports.removeHook = (hooks, hookToRemove) => {
+    const indexToRemove = hooks.findIndex(hook => hook === hookToRemove);
+    if (indexToRemove >= 0) {
+        hooks.splice(indexToRemove, 1);
+    }
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@shuvi/hook",
+  "version": "0.0.1-pre.1",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "module": "esm/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "esm",
+    "lib"
+  ],
+  "engines": {
+    "node": ">= 12.0.0"
+  },
+  "scripts": {
+    "dev": "run-p watch:*",
+    "watch:esm": "tsc -p tsconfig.build.esm.json -w",
+    "watch:cjs": "tsc -p tsconfig.build.cjs.json -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": "0bc0bc76e72ca5a339341e8b71d6bb6bb41409e8"
+}