refactor: rename HookName to HookType to improve semantic

README.md

@@ -72,7 +72,7 @@ server.listen(3000, 'localhost');             // прослушивание за
 - `cookie: ParsedCookie` объект ключ-значение разобранного заголовка `cookie`
 - `method: string` метод запроса в верхнем регистре, например `GET`, `POST` и т.д.
 - `path: string` путь включающий строку запроса, например `/myPath?foo=bar`
-- `pathname: string` путь запроса, например `/myMath`
+- `pathname: string` путь запроса, например `/myPath`
 - `body: unknown` тело запроса
 
 Пример доступа к контексту из обработчика маршрута.
@@ -132,9 +132,9 @@ router.defineRoute({     // регистрация маршрута
 router.defineRoute({
   // ...
   handler(ctx) {
-    res.statusCode = 404;
-    res.setHeader('content-type', 'text/plain; charset=utf-8');
-    res.end('404 Not Found', 'utf-8');
+    ctx.res.statusCode = 404;
+    ctx.res.setHeader('content-type', 'text/plain; charset=utf-8');
+    ctx.res.end('404 Not Found', 'utf-8');
   },
 });
 ```
@@ -217,7 +217,7 @@ router.defineRoute({
 - `postHandler` выполняется после вызова обработчика каждого маршрута
 
 Добавить глобальные хуки можно методом `addHook` экземпляра роутера,
-где первым параметром передается название хука, а вторым его функция.
+где первым параметром передается тип хука, а вторым его функция.
 
 ```js
 router.addHook('preHandler', (ctx) => {

dist/cjs/index.cjs

@@ -38,8 +38,8 @@ __export(index_exports, {
   EXPOSED_ERROR_PROPERTIES: () => EXPOSED_ERROR_PROPERTIES,
   ErrorSender: () => ErrorSender,
   HookInvoker: () => HookInvoker,
-  HookName: () => HookName,
   HookRegistry: () => HookRegistry,
+  HookType: () => HookType,
   HttpMethod: () => HttpMethod,
   METHODS_WITH_BODY: () => METHODS_WITH_BODY,
   QueryParser: () => QueryParser,
@@ -661,7 +661,7 @@ __name(_DebuggableService, "DebuggableService");
 var DebuggableService = _DebuggableService;
 
 // src/hooks/hook-registry.js
-var HookName = {
+var HookType = {
   PRE_HANDLER: "preHandler",
   POST_HANDLER: "postHandler"
 };
@@ -676,59 +676,59 @@ var _HookRegistry = class _HookRegistry extends DebuggableService {
   /**
    * Add hook.
    *
-   * @param {string} name
+   * @param {string} type
    * @param {Function} hook
    * @returns {this}
    */
-  addHook(name, hook) {
-    if (!name || typeof name !== "string")
-      throw new import_js_format12.Errorf("The hook name is required, but %v given.", name);
-    if (!Object.values(HookName).includes(name))
-      throw new import_js_format12.Errorf("The hook name %v is not supported.", name);
+  addHook(type, hook) {
+    if (!type || typeof type !== "string")
+      throw new import_js_format12.Errorf("The hook type is required, but %v given.", type);
+    if (!Object.values(HookType).includes(type))
+      throw new import_js_format12.Errorf("The hook type %v is not supported.", type);
     if (!hook || typeof hook !== "function")
       throw new import_js_format12.Errorf(
         "The hook %v should be a Function, but %v given.",
-        name,
+        type,
         hook
       );
-    const hooks = this._hooks.get(name) || [];
+    const hooks = this._hooks.get(type) || [];
     hooks.push(hook);
-    this._hooks.set(name, hooks);
+    this._hooks.set(type, hooks);
     return this;
   }
   /**
    * Has hook.
    *
-   * @param {string} name
+   * @param {string} type
    * @param {Function} hook
    * @returns {boolean}
    */
-  hasHook(name, hook) {
-    if (!name || typeof name !== "string")
-      throw new import_js_format12.Errorf("The hook name is required, but %v given.", name);
-    if (!Object.values(HookName).includes(name))
-      throw new import_js_format12.Errorf("The hook name %v is not supported.", name);
+  hasHook(type, hook) {
+    if (!type || typeof type !== "string")
+      throw new import_js_format12.Errorf("The hook type is required, but %v given.", type);
+    if (!Object.values(HookType).includes(type))
+      throw new import_js_format12.Errorf("The hook type %v is not supported.", type);
     if (!hook || typeof hook !== "function")
       throw new import_js_format12.Errorf(
         "The hook %v should be a Function, but %v given.",
-        name,
+        type,
         hook
       );
-    const hooks = this._hooks.get(name) || [];
+    const hooks = this._hooks.get(type) || [];
     return hooks.indexOf(hook) > -1;
   }
   /**
    * Get hooks.
    *
-   * @param {string} name
+   * @param {string} type
    * @returns {Function[]}
    */
-  getHooks(name) {
-    if (!name || typeof name !== "string")
-      throw new import_js_format12.Errorf("The hook name is required, but %v given.", name);
-    if (!Object.values(HookName).includes(name))
-      throw new import_js_format12.Errorf("The hook name %v is not supported.", name);
-    return this._hooks.get(name) || [];
+  getHooks(type) {
+    if (!type || typeof type !== "string")
+      throw new import_js_format12.Errorf("The hook type is required, but %v given.", type);
+    if (!Object.values(HookType).includes(type))
+      throw new import_js_format12.Errorf("The hook type %v is not supported.", type);
+    return this._hooks.get(type) || [];
   }
 };
 __name(_HookRegistry, "HookRegistry");
@@ -740,24 +740,24 @@ var _HookInvoker = class _HookInvoker extends DebuggableService {
    * Invoke and continue until value received.
    *
    * @param {Route} route
-   * @param {string} hookName
+   * @param {string} hookType
    * @param {import('http').ServerResponse} response
    * @param {*[]} args
    * @returns {Promise<*>|*}
    */
-  invokeAndContinueUntilValueReceived(route, hookName, response, ...args) {
+  invokeAndContinueUntilValueReceived(route, hookType, response, ...args) {
     if (!route || !(route instanceof Route))
       throw new import_js_format13.Errorf(
         'The parameter "route" of the HookInvoker.invokeAndContinueUntilValueReceived should be a Route instance, but %v given.',
         route
       );
-    if (!hookName || typeof hookName !== "string")
+    if (!hookType || typeof hookType !== "string")
       throw new import_js_format13.Errorf(
-        'The parameter "hookName" of the HookInvoker.invokeAndContinueUntilValueReceived should be a non-empty String, but %v given.',
-        hookName
+        'The parameter "hookType" of the HookInvoker.invokeAndContinueUntilValueReceived should be a non-empty String, but %v given.',
+        hookType
       );
-    if (!Object.values(HookName).includes(hookName))
-      throw new import_js_format13.Errorf("The hook name %v is not supported.", hookName);
+    if (!Object.values(HookType).includes(hookType))
+      throw new import_js_format13.Errorf("The hook type %v is not supported.", hookType);
     if (!response || typeof response !== "object" || Array.isArray(response) || typeof response.headersSent !== "boolean") {
       throw new import_js_format13.Errorf(
         'The parameter "response" of the HookInvoker.invokeAndContinueUntilValueReceived should be a ServerResponse instance, but %v given.',
@@ -765,8 +765,8 @@ var _HookInvoker = class _HookInvoker extends DebuggableService {
       );
     }
     const hooks = [
-      ...this.getService(HookRegistry).getHooks(hookName),
-      ...route.hookRegistry.getHooks(hookName)
+      ...this.getService(HookRegistry).getHooks(hookType),
+      ...route.hookRegistry.getHooks(hookType)
     ];
     let result = void 0;
     for (const hook of hooks) {
@@ -897,13 +897,13 @@ var _Route = class _Route {
     if (routeDef.preHandler != null) {
       const preHandlerHooks = Array.isArray(routeDef.preHandler) ? routeDef.preHandler : [routeDef.preHandler];
       preHandlerHooks.forEach((hook) => {
-        this._hookRegistry.addHook(HookName.PRE_HANDLER, hook);
+        this._hookRegistry.addHook(HookType.PRE_HANDLER, hook);
       });
     }
     if (routeDef.postHandler != null) {
       const postHandlerHooks = Array.isArray(routeDef.postHandler) ? routeDef.postHandler : [routeDef.postHandler];
       postHandlerHooks.forEach((hook) => {
-        this._hookRegistry.addHook(HookName.POST_HANDLER, hook);
+        this._hookRegistry.addHook(HookType.POST_HANDLER, hook);
       });
     }
   }
@@ -1619,7 +1619,7 @@ var _TrieRouter = class _TrieRouter extends DebuggableService {
       try {
         data = hookInvoker.invokeAndContinueUntilValueReceived(
           route,
-          HookName.PRE_HANDLER,
+          HookType.PRE_HANDLER,
           res,
           context
         );
@@ -1629,7 +1629,7 @@ var _TrieRouter = class _TrieRouter extends DebuggableService {
           if (isPromise(data)) data = await data;
           let postHandlerData = hookInvoker.invokeAndContinueUntilValueReceived(
             route,
-            HookName.POST_HANDLER,
+            HookType.POST_HANDLER,
             res,
             context,
             data
@@ -1654,30 +1654,30 @@ var _TrieRouter = class _TrieRouter extends DebuggableService {
    * Example:
    * ```
    * import {TrieRouter} from '@e22m4u/js-trie-router';
-   * import {HookName} from '@e22m4u/js-trie-router';
+   * import {HookType} from '@e22m4u/js-trie-router';
    *
    * // Router instance.
    * const router = new TrieRouter();
    *
    * // Adds the "preHandler" hook for each route.
    * router.addHook(
-   *   HookName.PRE_HANDLER,
+   *   HookType.PRE_HANDLER,
    *   ctx => { ... },
    * );
    *
    * // Adds the "postHandler" hook for each route.
    * router.addHook(
-   *   HookName.POST_HANDLER,
+   *   HookType.POST_HANDLER,
    *   ctx => { ... },
    * );
    * ```
    *
-   * @param {string} name
+   * @param {string} type
    * @param {Function} hook
    * @returns {this}
    */
-  addHook(name, hook) {
-    this.getService(HookRegistry).addHook(name, hook);
+  addHook(type, hook) {
+    this.getService(HookRegistry).addHook(type, hook);
     return this;
   }
 };
@@ -1692,8 +1692,8 @@ var TrieRouter = _TrieRouter;
   EXPOSED_ERROR_PROPERTIES,
   ErrorSender,
   HookInvoker,
-  HookName,
   HookRegistry,
+  HookType,
   HttpMethod,
   METHODS_WITH_BODY,
   QueryParser,

src/hooks/hook-invoker.d.ts

@@ -1,7 +1,7 @@
 import {Route} from '../route.js';
 import {ServerResponse} from 'http';
 import {ValueOrPromise} from '../types.js';
-import {HookName} from './hook-registry.js';
+import {HookType} from './hook-registry.js';
 import {DebuggableService} from '../debuggable-service.js';
 
 /**
@@ -12,13 +12,13 @@ export declare class HookInvoker extends DebuggableService {
    * Invoke and continue until value received.
    *
    * @param route
-   * @param hookName
+   * @param hookType
    * @param response
    * @param args
    */
   invokeAndContinueUntilValueReceived(
     route: Route,
-    hookName: HookName,
+    hookType: HookType,
     response: ServerResponse,
     ...args: unknown[]
   ): ValueOrPromise<unknown>;

src/hooks/hook-invoker.js

@@ -1,7 +1,7 @@
 import {Route} from '../route.js';
 import {Errorf} from '@e22m4u/js-format';
 import {isPromise} from '../utils/index.js';
-import {HookName} from './hook-registry.js';
+import {HookType} from './hook-registry.js';
 import {HookRegistry} from './hook-registry.js';
 import {isResponseSent} from '../utils/index.js';
 import {DebuggableService} from '../debuggable-service.js';
@@ -14,12 +14,12 @@ export class HookInvoker extends DebuggableService {
    * Invoke and continue until value received.
    *
    * @param {Route} route
-   * @param {string} hookName
+   * @param {string} hookType
    * @param {import('http').ServerResponse} response
    * @param {*[]} args
    * @returns {Promise<*>|*}
    */
-  invokeAndContinueUntilValueReceived(route, hookName, response, ...args) {
+  invokeAndContinueUntilValueReceived(route, hookType, response, ...args) {
     if (!route || !(route instanceof Route))
       throw new Errorf(
         'The parameter "route" of ' +
@@ -27,15 +27,15 @@ export class HookInvoker extends DebuggableService {
           'should be a Route instance, but %v given.',
         route,
       );
-    if (!hookName || typeof hookName !== 'string')
+    if (!hookType || typeof hookType !== 'string')
       throw new Errorf(
-        'The parameter "hookName" of ' +
+        'The parameter "hookType" of ' +
           'the HookInvoker.invokeAndContinueUntilValueReceived ' +
           'should be a non-empty String, but %v given.',
-        hookName,
+        hookType,
       );
-    if (!Object.values(HookName).includes(hookName))
-      throw new Errorf('The hook name %v is not supported.', hookName);
+    if (!Object.values(HookType).includes(hookType))
+      throw new Errorf('The hook type %v is not supported.', hookType);
     if (
       !response ||
       typeof response !== 'object' ||
@@ -53,8 +53,8 @@ export class HookInvoker extends DebuggableService {
     // после глобальных, то объединяем
     // их в данной последовательности
     const hooks = [
-      ...this.getService(HookRegistry).getHooks(hookName),
-      ...route.hookRegistry.getHooks(hookName),
+      ...this.getService(HookRegistry).getHooks(hookType),
+      ...route.hookRegistry.getHooks(hookType),
     ];
     // последовательный вызов хуков будет прерван,
     // если один из них вернет значение (или Promise)

src/hooks/hook-invoker.spec.js

@@ -2,7 +2,7 @@ import {expect} from '../chai.js';
 import {Route} from '../route.js';
 import {HttpMethod} from '../route.js';
 import {format} from '@e22m4u/js-format';
-import {HookName} from './hook-registry.js';
+import {HookType} from './hook-registry.js';
 import {HookInvoker} from './hook-invoker.js';
 import {HookRegistry} from './hook-registry.js';
 import {createResponseMock} from '../utils/index.js';
@@ -13,7 +13,7 @@ describe('HookInvoker', function () {
       const s = new HookInvoker();
       const res = createResponseMock();
       const throwable = v => () =>
-        s.invokeAndContinueUntilValueReceived(v, HookName.PRE_HANDLER, res);
+        s.invokeAndContinueUntilValueReceived(v, HookType.PRE_HANDLER, res);
       const error = v =>
         format(
           'The parameter "route" of ' +
@@ -40,7 +40,7 @@ describe('HookInvoker', function () {
       )();
     });
 
-    it('requires the parameter "hookName" to be a non-empty String', function () {
+    it('requires the parameter "hookType" to be a non-empty String', function () {
       const s = new HookInvoker();
       const route = new Route({
         method: HttpMethod.GET,
@@ -52,7 +52,7 @@ describe('HookInvoker', function () {
         s.invokeAndContinueUntilValueReceived(route, v, res);
       const error = v =>
         format(
-          'The parameter "hookName" of ' +
+          'The parameter "hookType" of ' +
             'the HookInvoker.invokeAndContinueUntilValueReceived ' +
             'should be a non-empty String, but %s given.',
           v,
@@ -66,10 +66,10 @@ describe('HookInvoker', function () {
       expect(throwable({})).to.throw(error('Object'));
       expect(throwable([])).to.throw(error('Array'));
       expect(throwable(undefined)).to.throw(error('undefined'));
-      throwable(HookName.PRE_HANDLER)();
+      throwable(HookType.PRE_HANDLER)();
     });
 
-    it('requires the parameter "hookName" to be a supported hook', function () {
+    it('requires the parameter "hookType" to be a supported hook', function () {
       const s = new HookInvoker();
       const route = new Route({
         method: HttpMethod.GET,
@@ -77,12 +77,12 @@ describe('HookInvoker', function () {
         handler: () => undefined,
       });
       const res = createResponseMock();
-      Object.values(HookName).forEach(name =>
-        s.invokeAndContinueUntilValueReceived(route, name, res),
+      Object.values(HookType).forEach(type =>
+        s.invokeAndContinueUntilValueReceived(route, type, res),
       );
       const throwable = () =>
         s.invokeAndContinueUntilValueReceived(route, 'unknown', res);
-      expect(throwable).to.throw('The hook name "unknown" is not supported.');
+      expect(throwable).to.throw('The hook type "unknown" is not supported.');
     });
 
     it('requires the parameter "response" to be an instance of ServerResponse', function () {
@@ -93,7 +93,7 @@ describe('HookInvoker', function () {
         handler: () => undefined,
       });
       const throwable = v => () =>
-        s.invokeAndContinueUntilValueReceived(route, HookName.PRE_HANDLER, v);
+        s.invokeAndContinueUntilValueReceived(route, HookType.PRE_HANDLER, v);
       const error = v =>
         format(
           'The parameter "response" of ' +
@@ -117,10 +117,10 @@ describe('HookInvoker', function () {
     it('invokes global hooks in priority', function () {
       const s = new HookInvoker();
       const order = [];
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook1');
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook2');
       });
       const route = new Route({
@@ -138,7 +138,7 @@ describe('HookInvoker', function () {
       });
       s.invokeAndContinueUntilValueReceived(
         route,
-        HookName.PRE_HANDLER,
+        HookType.PRE_HANDLER,
         createResponseMock(),
       );
       expect(order).to.be.eql([
@@ -153,14 +153,14 @@ describe('HookInvoker', function () {
       const s = new HookInvoker();
       const order = [];
       const ret = 'OK';
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook1');
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook2');
         return ret;
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook3');
       });
       const route = new Route({
@@ -178,7 +178,7 @@ describe('HookInvoker', function () {
       });
       const result = s.invokeAndContinueUntilValueReceived(
         route,
-        HookName.PRE_HANDLER,
+        HookType.PRE_HANDLER,
         createResponseMock(),
       );
       expect(result).to.be.eq(ret);
@@ -189,10 +189,10 @@ describe('HookInvoker', function () {
       const s = new HookInvoker();
       const order = [];
       const ret = 'OK';
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook1');
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook2');
       });
       const route = new Route({
@@ -214,7 +214,7 @@ describe('HookInvoker', function () {
       });
       const result = s.invokeAndContinueUntilValueReceived(
         route,
-        HookName.PRE_HANDLER,
+        HookType.PRE_HANDLER,
         createResponseMock(),
       );
       expect(result).to.be.eq(ret);
@@ -230,14 +230,14 @@ describe('HookInvoker', function () {
       const s = new HookInvoker();
       const order = [];
       const res = createResponseMock();
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook1');
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook2');
         res._headersSent = true;
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook3');
       });
       const route = new Route({
@@ -255,7 +255,7 @@ describe('HookInvoker', function () {
       });
       const result = s.invokeAndContinueUntilValueReceived(
         route,
-        HookName.PRE_HANDLER,
+        HookType.PRE_HANDLER,
         res,
       );
       expect(result).to.be.eq(res);
@@ -266,10 +266,10 @@ describe('HookInvoker', function () {
       const s = new HookInvoker();
       const order = [];
       const res = createResponseMock();
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook1');
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook2');
       });
       const route = new Route({
@@ -291,7 +291,7 @@ describe('HookInvoker', function () {
       });
       const result = s.invokeAndContinueUntilValueReceived(
         route,
-        HookName.PRE_HANDLER,
+        HookType.PRE_HANDLER,
         res,
       );
       expect(result).to.be.eq(res);
@@ -306,13 +306,13 @@ describe('HookInvoker', function () {
     it('returns a Promise if any global hook is asynchronous', async function () {
       const s = new HookInvoker();
       const order = [];
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook1');
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, async () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, async () => {
         order.push('globalHook2');
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook3');
       });
       const route = new Route({
@@ -330,7 +330,7 @@ describe('HookInvoker', function () {
       });
       const promise = s.invokeAndContinueUntilValueReceived(
         route,
-        HookName.PRE_HANDLER,
+        HookType.PRE_HANDLER,
         createResponseMock(),
       );
       expect(promise).to.be.instanceof(Promise);
@@ -347,10 +347,10 @@ describe('HookInvoker', function () {
     it('returns a Promise if entire global hooks are asynchronous', async function () {
       const s = new HookInvoker();
       const order = [];
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, async () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, async () => {
         order.push('globalHook1');
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, async () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, async () => {
         order.push('globalHook2');
       });
       const route = new Route({
@@ -368,7 +368,7 @@ describe('HookInvoker', function () {
       });
       const promise = s.invokeAndContinueUntilValueReceived(
         route,
-        HookName.PRE_HANDLER,
+        HookType.PRE_HANDLER,
         createResponseMock(),
       );
       expect(promise).to.be.instanceof(Promise);
@@ -384,10 +384,10 @@ describe('HookInvoker', function () {
     it('returns a Promise if any route hook is asynchronous', async function () {
       const s = new HookInvoker();
       const order = [];
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook1');
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook2');
       });
       const route = new Route({
@@ -408,7 +408,7 @@ describe('HookInvoker', function () {
       });
       const promise = s.invokeAndContinueUntilValueReceived(
         route,
-        HookName.PRE_HANDLER,
+        HookType.PRE_HANDLER,
         createResponseMock(),
       );
       expect(promise).to.be.instanceof(Promise);
@@ -425,10 +425,10 @@ describe('HookInvoker', function () {
     it('returns a Promise if entire route hooks are asynchronous', async function () {
       const s = new HookInvoker();
       const order = [];
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook1');
       });
-      s.getService(HookRegistry).addHook(HookName.PRE_HANDLER, () => {
+      s.getService(HookRegistry).addHook(HookType.PRE_HANDLER, () => {
         order.push('globalHook2');
       });
       const route = new Route({
@@ -446,7 +446,7 @@ describe('HookInvoker', function () {
       });
       const promise = s.invokeAndContinueUntilValueReceived(
         route,
-        HookName.PRE_HANDLER,
+        HookType.PRE_HANDLER,
         createResponseMock(),
       );
       expect(promise).to.be.instanceof(Promise);

src/hooks/hook-registry.d.ts

@@ -4,10 +4,15 @@ import {DebuggableService} from '../debuggable-service.js';
 /**
  * Hook type.
  */
-export enum HookName {
-  PRE_HANDLER = 'preHandler',
-  POST_HANDLER = 'postHandler',
-}
+export declare const HookType: {
+  PRE_HANDLER: 'preHandler';
+  POST_HANDLER: 'postHandler';
+};
+
+/**
+ * Type of HookType.
+ */
+export type HookType = (typeof HookType)[keyof typeof HookType];
 
 /**
  * Router hook.
@@ -21,23 +26,23 @@ export declare class HookRegistry extends DebuggableService {
   /**
    * Add hook.
    *
-   * @param name
+   * @param type
    * @param hook
    */
-  addHook(name: HookName, hook: RouterHook): this;
+  addHook(type: HookType, hook: RouterHook): this;
 
   /**
    * Has hook.
    *
-   * @param name
+   * @param type
    * @param hook
    */
-  hasHook(name: HookName, hook: RouterHook): this;
+  hasHook(type: HookType, hook: RouterHook): this;
 
   /**
    * Get hooks.
    *
-   * @param name
+   * @param type
    */
-  getHooks(name: HookName): RouterHook[];
+  getHooks(type: HookType): RouterHook[];
 }

src/hooks/hook-registry.js

@@ -2,14 +2,14 @@ import {Errorf} from '@e22m4u/js-format';
 import {DebuggableService} from '../debuggable-service.js';
 
 /**
- * Router hook.
+ * Hook type.
  *
  * @type {{
  *   PRE_HANDLER: 'preHandler',
  *   POST_HANDLER: 'postHandler',
  * }}
  */
-export const HookName = {
+export const HookType = {
   PRE_HANDLER: 'preHandler',
   POST_HANDLER: 'postHandler',
 };
@@ -29,60 +29,60 @@ export class HookRegistry extends DebuggableService {
   /**
    * Add hook.
    *
-   * @param {string} name
+   * @param {string} type
    * @param {Function} hook
    * @returns {this}
    */
-  addHook(name, hook) {
-    if (!name || typeof name !== 'string')
-      throw new Errorf('The hook name is required, but %v given.', name);
-    if (!Object.values(HookName).includes(name))
-      throw new Errorf('The hook name %v is not supported.', name);
+  addHook(type, hook) {
+    if (!type || typeof type !== 'string')
+      throw new Errorf('The hook type is required, but %v given.', type);
+    if (!Object.values(HookType).includes(type))
+      throw new Errorf('The hook type %v is not supported.', type);
     if (!hook || typeof hook !== 'function')
       throw new Errorf(
         'The hook %v should be a Function, but %v given.',
-        name,
+        type,
         hook,
       );
-    const hooks = this._hooks.get(name) || [];
+    const hooks = this._hooks.get(type) || [];
     hooks.push(hook);
-    this._hooks.set(name, hooks);
+    this._hooks.set(type, hooks);
     return this;
   }
 
   /**
    * Has hook.
    *
-   * @param {string} name
+   * @param {string} type
    * @param {Function} hook
    * @returns {boolean}
    */
-  hasHook(name, hook) {
-    if (!name || typeof name !== 'string')
-      throw new Errorf('The hook name is required, but %v given.', name);
-    if (!Object.values(HookName).includes(name))
-      throw new Errorf('The hook name %v is not supported.', name);
+  hasHook(type, hook) {
+    if (!type || typeof type !== 'string')
+      throw new Errorf('The hook type is required, but %v given.', type);
+    if (!Object.values(HookType).includes(type))
+      throw new Errorf('The hook type %v is not supported.', type);
     if (!hook || typeof hook !== 'function')
       throw new Errorf(
         'The hook %v should be a Function, but %v given.',
-        name,
+        type,
         hook,
       );
-    const hooks = this._hooks.get(name) || [];
+    const hooks = this._hooks.get(type) || [];
     return hooks.indexOf(hook) > -1;
   }
 
   /**
    * Get hooks.
    *
-   * @param {string} name
+   * @param {string} type
    * @returns {Function[]}
    */
-  getHooks(name) {
-    if (!name || typeof name !== 'string')
-      throw new Errorf('The hook name is required, but %v given.', name);
-    if (!Object.values(HookName).includes(name))
-      throw new Errorf('The hook name %v is not supported.', name);
-    return this._hooks.get(name) || [];
+  getHooks(type) {
+    if (!type || typeof type !== 'string')
+      throw new Errorf('The hook type is required, but %v given.', type);
+    if (!Object.values(HookType).includes(type))
+      throw new Errorf('The hook type %v is not supported.', type);
+    return this._hooks.get(type) || [];
   }
 }

src/hooks/hook-registry.spec.js

@@ -1,14 +1,14 @@
 import {expect} from '../chai.js';
 import {format} from '@e22m4u/js-format';
-import {HookName} from './hook-registry.js';
+import {HookType} from './hook-registry.js';
 import {HookRegistry} from './hook-registry.js';
 
 describe('HookRegistry', function () {
   describe('addHook', function () {
-    it('requires the parameter "name" to be a non-empty String', function () {
+    it('requires the parameter "type" to be a non-empty String', function () {
       const s = new HookRegistry();
       const throwable = v => () => s.addHook(v, () => undefined);
-      const error = v => format('The hook name is required, but %s given.', v);
+      const error = v => format('The hook type is required, but %s given.', v);
       expect(throwable('')).to.throw(error('""'));
       expect(throwable(10)).to.throw(error('10'));
       expect(throwable(0)).to.throw(error('0'));
@@ -19,12 +19,12 @@ describe('HookRegistry', function () {
       expect(throwable([])).to.throw(error('Array'));
       expect(throwable(undefined)).to.throw(error('undefined'));
       expect(throwable(() => undefined)).to.throw(error('Function'));
-      throwable(HookName.PRE_HANDLER)();
+      throwable(HookType.PRE_HANDLER)();
     });
 
     it('requires the parameter "hook" to be a Function', function () {
       const s = new HookRegistry();
-      const throwable = v => () => s.addHook(HookName.PRE_HANDLER, v);
+      const throwable = v => () => s.addHook(HookType.PRE_HANDLER, v);
       const error = v =>
         format('The hook "preHandler" should be a Function, but %s given.', v);
       expect(throwable('str')).to.throw(error('"str"'));
@@ -40,36 +40,36 @@ describe('HookRegistry', function () {
       throwable(() => undefined)();
     });
 
-    it('requires the parameter "name" to be a supported hook', function () {
+    it('requires the parameter "type" to be a supported hook', function () {
       const s = new HookRegistry();
       const hook = () => undefined;
-      Object.values(HookName).forEach(name => s.addHook(name, hook));
+      Object.values(HookType).forEach(type => s.addHook(type, hook));
       const throwable = () => s.addHook('unknown', hook);
-      expect(throwable).to.throw('The hook name "unknown" is not supported.');
+      expect(throwable).to.throw('The hook type "unknown" is not supported.');
     });
 
-    it('sets the given function to the map array by the hook name', function () {
+    it('sets the given function to the map array by the hook type', function () {
       const s = new HookRegistry();
-      const name = HookName.PRE_HANDLER;
+      const type = HookType.PRE_HANDLER;
       const hook = () => undefined;
-      s.addHook(name, hook);
-      expect(s._hooks.get(name)).to.include(hook);
+      s.addHook(type, hook);
+      expect(s._hooks.get(type)).to.include(hook);
     });
 
     it('returns this', function () {
       const s = new HookRegistry();
       const hook = () => undefined;
-      const name = HookName.PRE_HANDLER;
-      const res = s.addHook(name, hook);
+      const type = HookType.PRE_HANDLER;
+      const res = s.addHook(type, hook);
       expect(res).to.be.eq(s);
     });
   });
 
   describe('hasHook', function () {
-    it('requires the parameter "name" to be a non-empty String', function () {
+    it('requires the parameter "type" to be a non-empty String', function () {
       const s = new HookRegistry();
       const throwable = v => () => s.hasHook(v, () => undefined);
-      const error = v => format('The hook name is required, but %s given.', v);
+      const error = v => format('The hook type is required, but %s given.', v);
       expect(throwable('')).to.throw(error('""'));
       expect(throwable(10)).to.throw(error('10'));
       expect(throwable(0)).to.throw(error('0'));
@@ -80,12 +80,12 @@ describe('HookRegistry', function () {
       expect(throwable([])).to.throw(error('Array'));
       expect(throwable(undefined)).to.throw(error('undefined'));
       expect(throwable(() => undefined)).to.throw(error('Function'));
-      throwable(HookName.PRE_HANDLER)();
+      throwable(HookType.PRE_HANDLER)();
     });
 
     it('requires the parameter "hook" to be a Function', function () {
       const s = new HookRegistry();
-      const throwable = v => () => s.hasHook(HookName.PRE_HANDLER, v);
+      const throwable = v => () => s.hasHook(HookType.PRE_HANDLER, v);
       const error = v =>
         format('The hook "preHandler" should be a Function, but %s given.', v);
       expect(throwable('str')).to.throw(error('"str"'));
@@ -101,29 +101,29 @@ describe('HookRegistry', function () {
       throwable(() => undefined)();
     });
 
-    it('requires the parameter "name" to be a supported hook', function () {
+    it('requires the parameter "type" to be a supported hook', function () {
       const s = new HookRegistry();
       const hook = () => undefined;
-      Object.values(HookName).forEach(name => s.hasHook(name, hook));
+      Object.values(HookType).forEach(type => s.hasHook(type, hook));
       const throwable = () => s.hasHook('unknown', hook);
-      expect(throwable).to.throw('The hook name "unknown" is not supported.');
+      expect(throwable).to.throw('The hook type "unknown" is not supported.');
     });
 
     it('returns true if the given hook is set or false', function () {
       const s = new HookRegistry();
-      const name = HookName.PRE_HANDLER;
+      const type = HookType.PRE_HANDLER;
       const hook = () => undefined;
-      expect(s.hasHook(name, hook)).to.be.false;
-      s.addHook(name, hook);
-      expect(s.hasHook(name, hook)).to.be.true;
+      expect(s.hasHook(type, hook)).to.be.false;
+      s.addHook(type, hook);
+      expect(s.hasHook(type, hook)).to.be.true;
     });
   });
 
   describe('getHooks', function () {
-    it('requires the parameter "name" to be a non-empty String', function () {
+    it('requires the parameter "type" to be a non-empty String', function () {
       const s = new HookRegistry();
       const throwable = v => () => s.getHooks(v);
-      const error = v => format('The hook name is required, but %s given.', v);
+      const error = v => format('The hook type is required, but %s given.', v);
       expect(throwable('')).to.throw(error('""'));
       expect(throwable(10)).to.throw(error('10'));
       expect(throwable(0)).to.throw(error('0'));
@@ -134,31 +134,31 @@ describe('HookRegistry', function () {
       expect(throwable([])).to.throw(error('Array'));
       expect(throwable(undefined)).to.throw(error('undefined'));
       expect(throwable(() => undefined)).to.throw(error('Function'));
-      throwable(HookName.PRE_HANDLER)();
+      throwable(HookType.PRE_HANDLER)();
     });
 
-    it('requires the parameter "name" to be a supported hook', function () {
+    it('requires the parameter "type" to be a supported hook', function () {
       const s = new HookRegistry();
-      Object.values(HookName).forEach(name => s.getHooks(name));
+      Object.values(HookType).forEach(type => s.getHooks(type));
       const throwable = () => s.getHooks('unknown');
-      expect(throwable).to.throw('The hook name "unknown" is not supported.');
+      expect(throwable).to.throw('The hook type "unknown" is not supported.');
     });
 
     it('returns existing hooks', function () {
       const s = new HookRegistry();
       const hook = () => undefined;
-      const name = HookName.PRE_HANDLER;
-      const res1 = s.getHooks(name);
+      const type = HookType.PRE_HANDLER;
+      const res1 = s.getHooks(type);
       expect(res1).to.be.eql([]);
-      s.addHook(name, hook);
-      const res2 = s.getHooks(name);
+      s.addHook(type, hook);
+      const res2 = s.getHooks(type);
       expect(res2).to.have.length(1);
       expect(res2[0]).to.be.eq(hook);
     });
 
     it('returns an empty array if no hook exists', function () {
       const s = new HookRegistry();
-      const res = s.getHooks(HookName.PRE_HANDLER);
+      const res = s.getHooks(HookType.PRE_HANDLER);
       expect(res).to.be.eql([]);
     });
   });

src/route.js

@@ -1,5 +1,5 @@
 import {Errorf} from '@e22m4u/js-format';
-import {HookName} from './hooks/index.js';
+import {HookType} from './hooks/index.js';
 import {HookRegistry} from './hooks/index.js';
 import {createDebugger} from './utils/index.js';
 import {getRequestPathname} from './utils/index.js';
@@ -153,7 +153,7 @@ export class Route {
         ? routeDef.preHandler
         : [routeDef.preHandler];
       preHandlerHooks.forEach(hook => {
-        this._hookRegistry.addHook(HookName.PRE_HANDLER, hook);
+        this._hookRegistry.addHook(HookType.PRE_HANDLER, hook);
       });
     }
     if (routeDef.postHandler != null) {
@@ -161,7 +161,7 @@ export class Route {
         ? routeDef.postHandler
         : [routeDef.postHandler];
       postHandlerHooks.forEach(hook => {
-        this._hookRegistry.addHook(HookName.POST_HANDLER, hook);
+        this._hookRegistry.addHook(HookType.POST_HANDLER, hook);
       });
     }
   }

src/route.spec.js

@@ -2,7 +2,7 @@ import {Route} from './route.js';
 import {expect} from './chai.js';
 import {HttpMethod} from './route.js';
 import {format} from '@e22m4u/js-format';
-import {HookName} from './hooks/index.js';
+import {HookType} from './hooks/index.js';
 import {createRequestMock} from './utils/index.js';
 import {createResponseMock} from './utils/index.js';
 import {RequestContext} from './request-context.js';
@@ -232,7 +232,7 @@ describe('Route', function () {
         preHandler: value,
         handler: () => undefined,
       });
-      expect(route.hookRegistry.hasHook(HookName.PRE_HANDLER, value)).to.be
+      expect(route.hookRegistry.hasHook(HookType.PRE_HANDLER, value)).to.be
         .true;
     });
 
@@ -244,9 +244,9 @@ describe('Route', function () {
         preHandler: value,
         handler: () => undefined,
       });
-      expect(route.hookRegistry.hasHook(HookName.PRE_HANDLER, value[0])).to.be
+      expect(route.hookRegistry.hasHook(HookType.PRE_HANDLER, value[0])).to.be
         .true;
-      expect(route.hookRegistry.hasHook(HookName.PRE_HANDLER, value[1])).to.be
+      expect(route.hookRegistry.hasHook(HookType.PRE_HANDLER, value[1])).to.be
         .true;
     });
 
@@ -258,7 +258,7 @@ describe('Route', function () {
         handler: () => undefined,
         postHandler: value,
       });
-      expect(route.hookRegistry.hasHook(HookName.POST_HANDLER, value)).to.be
+      expect(route.hookRegistry.hasHook(HookType.POST_HANDLER, value)).to.be
         .true;
     });
 
@@ -270,9 +270,9 @@ describe('Route', function () {
         handler: () => undefined,
         postHandler: value,
       });
-      expect(route.hookRegistry.hasHook(HookName.POST_HANDLER, value[0])).to.be
+      expect(route.hookRegistry.hasHook(HookType.POST_HANDLER, value[0])).to.be
         .true;
-      expect(route.hookRegistry.hasHook(HookName.POST_HANDLER, value[1])).to.be
+      expect(route.hookRegistry.hasHook(HookType.POST_HANDLER, value[1])).to.be
         .true;
     });
   });

src/trie-router.d.ts

@@ -1,6 +1,6 @@
 import {Route} from './route.js';
 import {RequestListener} from 'http';
-import {HookName} from './hooks/index.js';
+import {HookType} from './hooks/index.js';
 import {RouteDefinition} from './route.js';
 import {RouterHook} from './hooks/index.js';
 import {DebuggableService} from './debuggable-service.js';
@@ -59,8 +59,8 @@ export declare class TrieRouter extends DebuggableService {
   /**
    * Add hook.
    *
-   * @param name
+   * @param type
    * @param hook
    */
-  addHook(name: HookName, hook: RouterHook): this;
+  addHook(type: HookType, hook: RouterHook): this;
 }

src/trie-router.js

@@ -1,4 +1,4 @@
-import {HookName} from './hooks/index.js';
+import {HookType} from './hooks/index.js';
 import {isPromise} from './utils/index.js';
 import {HookInvoker} from './hooks/index.js';
 import {DataSender} from './senders/index.js';
@@ -121,7 +121,7 @@ export class TrieRouter extends DebuggableService {
         // то такое значение используется в качестве ответа
         data = hookInvoker.invokeAndContinueUntilValueReceived(
           route,
-          HookName.PRE_HANDLER,
+          HookType.PRE_HANDLER,
           res,
           context,
         );
@@ -137,7 +137,7 @@ export class TrieRouter extends DebuggableService {
           // в качестве ответа
           let postHandlerData = hookInvoker.invokeAndContinueUntilValueReceived(
             route,
-            HookName.POST_HANDLER,
+            HookType.POST_HANDLER,
             res,
             context,
             data,
@@ -163,30 +163,30 @@ export class TrieRouter extends DebuggableService {
    * Example:
    * ```
    * import {TrieRouter} from '@e22m4u/js-trie-router';
-   * import {HookName} from '@e22m4u/js-trie-router';
+   * import {HookType} from '@e22m4u/js-trie-router';
    *
    * // Router instance.
    * const router = new TrieRouter();
    *
    * // Adds the "preHandler" hook for each route.
    * router.addHook(
-   *   HookName.PRE_HANDLER,
+   *   HookType.PRE_HANDLER,
    *   ctx => { ... },
    * );
    *
    * // Adds the "postHandler" hook for each route.
    * router.addHook(
-   *   HookName.POST_HANDLER,
+   *   HookType.POST_HANDLER,
    *   ctx => { ... },
    * );
    * ```
    *
-   * @param {string} name
+   * @param {string} type
    * @param {Function} hook
    * @returns {this}
    */
-  addHook(name, hook) {
-    this.getService(HookRegistry).addHook(name, hook);
+  addHook(type, hook) {
+    this.getService(HookRegistry).addHook(type, hook);
     return this;
   }
 }

src/trie-router.spec.js

@@ -1,7 +1,7 @@
 import {Route} from './route.js';
 import {expect} from './chai.js';
 import {HttpMethod} from './route.js';
-import {HookName} from './hooks/index.js';
+import {HookType} from './hooks/index.js';
 import {TrieRouter} from './trie-router.js';
 import {HookRegistry} from './hooks/index.js';
 import {DataSender} from './senders/index.js';
@@ -478,12 +478,12 @@ describe('TrieRouter', function () {
     it('adds the given hook to the HookRegistry and returns itself', function () {
       const router = new TrieRouter();
       const reg = router.getService(HookRegistry);
-      const name = HookName.PRE_HANDLER;
+      const type = HookType.PRE_HANDLER;
       const hook = () => undefined;
-      expect(reg.hasHook(name, hook)).to.be.false;
-      const res = router.addHook(name, hook);
+      expect(reg.hasHook(type, hook)).to.be.false;
+      const res = router.addHook(type, hook);
       expect(res).to.be.eq(router);
-      expect(reg.hasHook(name, hook)).to.be.true;
+      expect(reg.hasHook(type, hook)).to.be.true;
     });
   });
 });