moost 0.4.6 → 0.4.8

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
+var mate$1 = require('@prostojs/mate');
 var eventCore = require('@wooksjs/event-core');
 var infact$1 = require('@prostojs/infact');
-var mate$1 = require('@prostojs/mate');
 var logger = require('@prostojs/logger');
 var hookable = require('hookable');
 
@@ -82,17 +82,19 @@ function getNewMoostInfact() {
     });
 }
 
-function setControllerContext(controller, method) {
+function setControllerContext(controller, method, route) {
     const { store } = eventCore.useAsyncEventContext();
     const { set } = store('controller');
     set('instance', controller);
     set('method', method);
+    set('route', route);
 }
 function useControllerContext() {
     const { store } = eventCore.useAsyncEventContext();
     const { get } = store('controller');
     const getController = () => get('instance');
     const getMethod = () => get('method');
+    const getRoute = () => get('route');
     const getControllerMeta = () => getMoostMate().read(getController());
     const getMethodMeta = (name) => getMoostMate().read(getController(), name || getMethod());
     function instantiate(c) {
@@ -100,6 +102,7 @@ function useControllerContext() {
     }
     return {
         instantiate,
+        getRoute,
         getController,
         getMethod,
         getControllerMeta,
@@ -119,6 +122,7 @@ function registerEventScope(scopeId) {
     };
 }
 function defineMoostEventHandler(options) {
+    const ci = eventCore.getContextInjector();
     return async () => {
         const scopeId = eventCore.useEventId().getId();
         const logger = eventCore.useEventLogger(options.loggerTitle);
@@ -137,12 +141,12 @@ function defineMoostEventHandler(options) {
         }
         const instance = await options.getControllerInstance();
         if (instance) {
-            setControllerContext(instance, options.controllerMethod || '');
+            setControllerContext(instance, options.controllerMethod || '', options.targetPath);
         }
         const interceptorHandler = await options.getIterceptorHandler();
         if (interceptorHandler) {
             try {
-                response = await interceptorHandler.init();
+                response = await ci.with('Inteceptors:init', () => interceptorHandler.init());
                 if (response !== undefined) {
                     return await endWithResponse();
                 }
@@ -156,7 +160,7 @@ function defineMoostEventHandler(options) {
         let args = [];
         if (options.resolveArgs) {
             try {
-                args = await options.resolveArgs();
+                args = await ci.with('Arguments:resolve', () => options.resolveArgs());
             }
             catch (error) {
                 options.logErrors && logger.error(error);
@@ -165,7 +169,7 @@ function defineMoostEventHandler(options) {
             }
         }
         if (interceptorHandler) {
-            response = await interceptorHandler.fireBefore(response);
+            response = await ci.with('Inteceptors:before', () => interceptorHandler.fireBefore(response));
             if (response !== undefined) {
                 return endWithResponse();
             }
@@ -181,7 +185,10 @@ function defineMoostEventHandler(options) {
             }
         };
         try {
-            response = callControllerMethod();
+            response = await ci.with('Handler', {
+                'moost.handler': options.controllerMethod || '',
+                'moost.controller': mate$1.getConstructor(instance).name,
+            }, () => callControllerMethod());
         }
         catch (error) {
             options.logErrors && logger.error(error);
@@ -191,7 +198,7 @@ function defineMoostEventHandler(options) {
         async function endWithResponse(raise = false) {
             if (interceptorHandler) {
                 try {
-                    response = await interceptorHandler.fireAfter(response);
+                    response = await ci.with('Inteceptors:after', () => interceptorHandler.fireAfter(response));
                 }
                 catch (error) {
                     options.logErrors && logger.error(error);
@@ -285,28 +292,48 @@ class InterceptorHandler {
         this.onError = [];
         this.responseOverwritten = false;
     }
+    get count() {
+        return this.handlers.length;
+    }
+    get countBefore() {
+        return this.before.length;
+    }
+    get countAfter() {
+        return this.after.length;
+    }
+    get countOnError() {
+        return this.onError.length;
+    }
     replyFn(reply) {
         this.response = reply;
         this.responseOverwritten = true;
     }
     async init() {
+        const ci = eventCore.getContextInjector();
         for (const handler of this.handlers) {
-            const response = await handler(fn => {
-                this.before.push(fn);
+            const response = await ci.with(`Inteceptor:${handler.name}`, {
+                'moost.interceptor.stage': 'init',
+                'moost.interceptor.priority': handler.priority || '',
+            }, () => handler(fn => {
+                this.before.push({ handler, fn });
             }, fn => {
-                this.after.unshift(fn);
+                this.after.unshift({ handler, fn });
             }, fn => {
-                this.onError.unshift(fn);
-            });
+                this.onError.unshift({ handler, fn });
+            }));
             if (response !== undefined) {
                 return response;
             }
         }
     }
     async fireBefore(response) {
+        const ci = eventCore.getContextInjector();
         this.response = response;
-        for (const handler of this.before) {
-            await handler(this.replyFn.bind(this));
+        for (const { handler, fn } of this.before) {
+            await ci.with(`Inteceptor:${handler.name}`, {
+                'moost.interceptor.stage': 'before',
+                'moost.interceptor.priority': handler.priority || '',
+            }, () => fn(this.replyFn.bind(this)));
             if (this.responseOverwritten) {
                 break;
             }
@@ -314,15 +341,22 @@ class InterceptorHandler {
         return this.response;
     }
     async fireAfter(response) {
+        const ci = eventCore.getContextInjector();
         this.response = response;
         if (response instanceof Error) {
-            for (const handler of this.onError) {
-                await handler(response, this.replyFn.bind(this));
+            for (const { handler, fn } of this.onError) {
+                await ci.with(`Inteceptor:${handler.name}`, {
+                    'moost.interceptor.stage': 'after',
+                    'moost.interceptor.priority': handler.priority || '',
+                }, () => fn(response, this.replyFn.bind(this)));
             }
         }
         else {
-            for (const handler of this.after) {
-                await handler(response, this.replyFn.bind(this));
+            for (const { handler, fn } of this.after) {
+                await ci.with(`Inteceptor:${handler.name}`, {
+                    'moost.interceptor.stage': 'onError',
+                    'moost.interceptor.priority': handler.priority || '',
+                }, () => fn(response, this.replyFn.bind(this)));
             }
         }
         return this.response;
@@ -707,7 +741,7 @@ class Moost extends hookable.Hookable {
                 event: { type: 'init' },
                 options: {},
             })(async () => {
-                setControllerContext(this, 'bindController');
+                setControllerContext(this, 'bindController', '');
                 instance = (await infact.get(controller, infactOpts));
             });
         }
@@ -819,13 +853,29 @@ class Moost extends hookable.Hookable {
     }
 }
 
+Object.defineProperty(exports, "getConstructor", {
+  enumerable: true,
+  get: function () { return mate$1.getConstructor; }
+});
+Object.defineProperty(exports, "isConstructor", {
+  enumerable: true,
+  get: function () { return mate$1.isConstructor; }
+});
+Object.defineProperty(exports, "ContextInjector", {
+  enumerable: true,
+  get: function () { return eventCore.ContextInjector; }
+});
 Object.defineProperty(exports, "EventLogger", {
   enumerable: true,
   get: function () { return eventCore.EventLogger; }
 });
-Object.defineProperty(exports, "eventContextHooks", {
+Object.defineProperty(exports, "getContextInjector", {
   enumerable: true,
-  get: function () { return eventCore.eventContextHooks; }
+  get: function () { return eventCore.getContextInjector; }
+});
+Object.defineProperty(exports, "replaceContextInjector", {
+  enumerable: true,
+  get: function () { return eventCore.replaceContextInjector; }
 });
 Object.defineProperty(exports, "useAsyncEventContext", {
   enumerable: true,
@@ -843,14 +893,6 @@ Object.defineProperty(exports, "createReplaceRegistry", {
   enumerable: true,
   get: function () { return infact$1.createReplaceRegistry; }
 });
-Object.defineProperty(exports, "getConstructor", {
-  enumerable: true,
-  get: function () { return mate$1.getConstructor; }
-});
-Object.defineProperty(exports, "isConstructor", {
-  enumerable: true,
-  get: function () { return mate$1.isConstructor; }
-});
 exports.Circular = Circular;
 exports.Const = Const;
 exports.ConstFactory = ConstFactory;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { useEventLogger } from '@wooksjs/event-core';
-export { EventLogger, THook, eventContextHooks, useAsyncEventContext, useEventLogger } from '@wooksjs/event-core';
+export { ContextInjector, EventLogger, THook, getContextInjector, replaceContextInjector, useAsyncEventContext, useEventLogger } from '@wooksjs/event-core';
 import { TProvideRegistry, Infact, TReplaceRegistry, TProvideFn } from '@prostojs/infact';
 export { TProvideRegistry, createProvideRegistry, createReplaceRegistry } from '@prostojs/infact';
 import { TConsoleBase } from '@prostojs/logger';
@@ -321,11 +321,24 @@ declare function InjectEventLogger(topic?: string): ParameterDecorator & Propert
 declare class InterceptorHandler {
     protected handlers: TInterceptorFn[];
     constructor(handlers: TInterceptorFn[]);
-    protected before: TInterceptorBefore[];
-    protected after: TInterceptorAfter[];
-    protected onError: TInterceptorOnError[];
+    protected before: Array<{
+        handler: TInterceptorFn;
+        fn: TInterceptorBefore;
+    }>;
+    protected after: Array<{
+        handler: TInterceptorFn;
+        fn: TInterceptorAfter;
+    }>;
+    protected onError: Array<{
+        handler: TInterceptorFn;
+        fn: TInterceptorOnError;
+    }>;
     response?: unknown;
     responseOverwritten: boolean;
+    get count(): number;
+    get countBefore(): number;
+    get countAfter(): number;
+    get countOnError(): number;
     replyFn(reply: unknown): void;
     init(): Promise<{} | null | undefined>;
     fireBefore(response: unknown): Promise<unknown>;
@@ -355,6 +368,7 @@ interface TMoostEventHandlerOptions<T> {
         init?: (opts: TMoostEventHandlerHookOptions<T>) => unknown;
         end?: (opts: TMoostEventHandlerHookOptions<T>) => unknown;
     };
+    targetPath: string;
 }
 declare function registerEventScope(scopeId: string): () => void;
 declare function defineMoostEventHandler<T>(options: TMoostEventHandlerOptions<T>): () => Promise<unknown>;
@@ -379,6 +393,7 @@ interface THandlerOverview {
         args: string[];
     }>;
 }
+type TContextInjectorHook = 'Event:start' | 'Inteceptors:init' | 'Arguments:resolve' | 'Inteceptors:before' | 'Handler' | 'Inteceptors:after';
 
 interface TMoostOptions {
     /**
@@ -518,27 +533,32 @@ interface TMoostAdapter<H> {
     getProvideRegistry?: () => TProvideRegistry;
 }
 
-declare function setControllerContext<T>(controller: T, method: keyof T): void;
+declare function setControllerContext<T>(controller: T, method: keyof T, route: string): void;
 declare function useControllerContext<T extends object>(): {
-    instantiate: <T_1>(c: TClassConstructor<T_1>) => Promise<T_1>;
+    instantiate: <TT>(c: TClassConstructor<TT>) => Promise<TT>;
+    getRoute: () => string | undefined;
     getController: () => T;
     getMethod: () => string | undefined;
-    getControllerMeta: () => (TMoostMetadata<TEmpty> & TEmpty & {
-        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
+    getControllerMeta: <TT extends object>() => (TMoostMetadata<TEmpty> & TT & {
+        params: (TT & _prostojs_mate.TMateParamMeta)[];
     }) | undefined;
-    getMethodMeta: (name?: string) => (TMoostMetadata<TEmpty> & TEmpty & {
-        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
+    getMethodMeta: <TT_1 extends object>(name?: string) => (TMoostMetadata<TEmpty> & TT_1 & {
+        params: (TT_1 & _prostojs_mate.TMateParamMeta)[];
     } & {
-        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
-    } & _prostojs_mate.TMateClassMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty> & _prostojs_mate.TMatePropMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty>) | undefined;
+        params: (TT_1 & _prostojs_mate.TMateParamMeta)[];
+    } & _prostojs_mate.TMateClassMeta<(TMoostMetadata<TEmpty> & TT_1 & {
+        params: (TT_1 & _prostojs_mate.TMateParamMeta)[];
+    })["params"][0]> & _prostojs_mate.TMatePropMeta<(TMoostMetadata<TEmpty> & TT_1 & {
+        params: (TT_1 & _prostojs_mate.TMateParamMeta)[];
+    })["params"][0]>) | undefined;
     getPropertiesList: () => (string | symbol)[];
     getScope: () => true | TInjectableScope;
-    getParamsMeta: () => (_prostojs_mate.TMateParamMeta & TMoostParamsMetadata)[] & (TEmpty & _prostojs_mate.TMateParamMeta)[] & (_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty)[];
-    getPropMeta: (name: string) => (TMoostMetadata<TEmpty> & TEmpty & {
-        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
+    getParamsMeta: () => (_prostojs_mate.TMateParamMeta & TMoostParamsMetadata)[] & (object & _prostojs_mate.TMateParamMeta)[] & (_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & object)[];
+    getPropMeta: (name: string) => (TMoostMetadata<TEmpty> & object & {
+        params: (object & _prostojs_mate.TMateParamMeta)[];
     } & {
-        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
-    } & _prostojs_mate.TMateClassMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty> & _prostojs_mate.TMatePropMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty>) | undefined;
+        params: (object & _prostojs_mate.TMateParamMeta)[];
+    } & _prostojs_mate.TMateClassMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & object> & _prostojs_mate.TMatePropMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & object>) | undefined;
 };
 
 /**
@@ -585,4 +605,4 @@ type TInterceptorClass = TClassFunction<TInterceptorFn>;
  */
 declare function definePipeFn<T extends TObject = TEmpty>(fn: TPipeFn<T>, priority?: TPipePriority): TPipeFn<T>;
 
-export { Circular, Const, ConstFactory, Controller, Description, Id, ImportController, Inherit, Inject, InjectEventLogger, Injectable, Intercept, InterceptorHandler, Label, Moost, Optional, Param, Params, Pipe, Provide, Replace, Required, Resolve, type TCallableClassFunction, type TClassConstructor, type TClassFunction, type TControllerOverview, type TInjectableScope, type TInterceptorAfter, type TInterceptorBefore, type TInterceptorClass, type TInterceptorData, type TInterceptorFn, type TInterceptorOnError, TInterceptorPriority, type TMoostAdapter, type TMoostAdapterOptions, type TMoostEventHandlerHookOptions, type TMoostEventHandlerOptions, type TMoostHandler, type TMoostMetadata, type TMoostOptions, type TMoostParamsMetadata, type TPipeData, type TPipeFn, type TPipeMetas, TPipePriority, Value, defineInterceptorFn, defineMoostEventHandler, definePipeFn, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, registerEventScope, resolvePipe, setControllerContext, useControllerContext };
+export { Circular, Const, ConstFactory, Controller, Description, Id, ImportController, Inherit, Inject, InjectEventLogger, Injectable, Intercept, InterceptorHandler, Label, Moost, Optional, Param, Params, Pipe, Provide, Replace, Required, Resolve, type TCallableClassFunction, type TClassConstructor, type TClassFunction, type TContextInjectorHook, type TControllerOverview, type TInjectableScope, type TInterceptorAfter, type TInterceptorBefore, type TInterceptorClass, type TInterceptorData, type TInterceptorFn, type TInterceptorOnError, TInterceptorPriority, type TMoostAdapter, type TMoostAdapterOptions, type TMoostEventHandlerHookOptions, type TMoostEventHandlerOptions, type TMoostHandler, type TMoostMetadata, type TMoostOptions, type TMoostParamsMetadata, type TPipeData, type TPipeFn, type TPipeMetas, TPipePriority, Value, defineInterceptorFn, defineMoostEventHandler, definePipeFn, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, registerEventScope, resolvePipe, setControllerContext, useControllerContext };

package/dist/index.mjs

@@ -1,9 +1,9 @@
-import { useEventId, useAsyncEventContext, useEventLogger, useRouteParams, createAsyncEventContext } from '@wooksjs/event-core';
-export { EventLogger, eventContextHooks, useAsyncEventContext, useEventLogger } from '@wooksjs/event-core';
-import { Infact, createProvideRegistry, createReplaceRegistry } from '@prostojs/infact';
-export { createProvideRegistry, createReplaceRegistry } from '@prostojs/infact';
 import { Mate, getConstructor, isConstructor } from '@prostojs/mate';
 export { getConstructor, isConstructor } from '@prostojs/mate';
+import { useEventId, useAsyncEventContext, getContextInjector, useEventLogger, useRouteParams, createAsyncEventContext } from '@wooksjs/event-core';
+export { ContextInjector, EventLogger, getContextInjector, replaceContextInjector, useAsyncEventContext, useEventLogger } from '@wooksjs/event-core';
+import { Infact, createProvideRegistry, createReplaceRegistry } from '@prostojs/infact';
+export { createProvideRegistry, createReplaceRegistry } from '@prostojs/infact';
 import { ProstoLogger, createConsoleTransort, coloredConsole } from '@prostojs/logger';
 import { Hookable } from 'hookable';
 
@@ -83,17 +83,19 @@ function getNewMoostInfact() {
     });
 }
 
-function setControllerContext(controller, method) {
+function setControllerContext(controller, method, route) {
     const { store } = useAsyncEventContext();
     const { set } = store('controller');
     set('instance', controller);
     set('method', method);
+    set('route', route);
 }
 function useControllerContext() {
     const { store } = useAsyncEventContext();
     const { get } = store('controller');
     const getController = () => get('instance');
     const getMethod = () => get('method');
+    const getRoute = () => get('route');
     const getControllerMeta = () => getMoostMate().read(getController());
     const getMethodMeta = (name) => getMoostMate().read(getController(), name || getMethod());
     function instantiate(c) {
@@ -101,6 +103,7 @@ function useControllerContext() {
     }
     return {
         instantiate,
+        getRoute,
         getController,
         getMethod,
         getControllerMeta,
@@ -120,6 +123,7 @@ function registerEventScope(scopeId) {
     };
 }
 function defineMoostEventHandler(options) {
+    const ci = getContextInjector();
     return async () => {
         const scopeId = useEventId().getId();
         const logger = useEventLogger(options.loggerTitle);
@@ -138,12 +142,12 @@ function defineMoostEventHandler(options) {
         }
         const instance = await options.getControllerInstance();
         if (instance) {
-            setControllerContext(instance, options.controllerMethod || '');
+            setControllerContext(instance, options.controllerMethod || '', options.targetPath);
         }
         const interceptorHandler = await options.getIterceptorHandler();
         if (interceptorHandler) {
             try {
-                response = await interceptorHandler.init();
+                response = await ci.with('Inteceptors:init', () => interceptorHandler.init());
                 if (response !== undefined) {
                     return await endWithResponse();
                 }
@@ -157,7 +161,7 @@ function defineMoostEventHandler(options) {
         let args = [];
         if (options.resolveArgs) {
             try {
-                args = await options.resolveArgs();
+                args = await ci.with('Arguments:resolve', () => options.resolveArgs());
             }
             catch (error) {
                 options.logErrors && logger.error(error);
@@ -166,7 +170,7 @@ function defineMoostEventHandler(options) {
             }
         }
         if (interceptorHandler) {
-            response = await interceptorHandler.fireBefore(response);
+            response = await ci.with('Inteceptors:before', () => interceptorHandler.fireBefore(response));
             if (response !== undefined) {
                 return endWithResponse();
             }
@@ -182,7 +186,10 @@ function defineMoostEventHandler(options) {
             }
         };
         try {
-            response = callControllerMethod();
+            response = await ci.with('Handler', {
+                'moost.handler': options.controllerMethod || '',
+                'moost.controller': getConstructor(instance).name,
+            }, () => callControllerMethod());
         }
         catch (error) {
             options.logErrors && logger.error(error);
@@ -192,7 +199,7 @@ function defineMoostEventHandler(options) {
         async function endWithResponse(raise = false) {
             if (interceptorHandler) {
                 try {
-                    response = await interceptorHandler.fireAfter(response);
+                    response = await ci.with('Inteceptors:after', () => interceptorHandler.fireAfter(response));
                 }
                 catch (error) {
                     options.logErrors && logger.error(error);
@@ -286,28 +293,48 @@ class InterceptorHandler {
         this.onError = [];
         this.responseOverwritten = false;
     }
+    get count() {
+        return this.handlers.length;
+    }
+    get countBefore() {
+        return this.before.length;
+    }
+    get countAfter() {
+        return this.after.length;
+    }
+    get countOnError() {
+        return this.onError.length;
+    }
     replyFn(reply) {
         this.response = reply;
         this.responseOverwritten = true;
     }
     async init() {
+        const ci = getContextInjector();
         for (const handler of this.handlers) {
-            const response = await handler(fn => {
-                this.before.push(fn);
+            const response = await ci.with(`Inteceptor:${handler.name}`, {
+                'moost.interceptor.stage': 'init',
+                'moost.interceptor.priority': handler.priority || '',
+            }, () => handler(fn => {
+                this.before.push({ handler, fn });
             }, fn => {
-                this.after.unshift(fn);
+                this.after.unshift({ handler, fn });
             }, fn => {
-                this.onError.unshift(fn);
-            });
+                this.onError.unshift({ handler, fn });
+            }));
             if (response !== undefined) {
                 return response;
             }
         }
     }
     async fireBefore(response) {
+        const ci = getContextInjector();
         this.response = response;
-        for (const handler of this.before) {
-            await handler(this.replyFn.bind(this));
+        for (const { handler, fn } of this.before) {
+            await ci.with(`Inteceptor:${handler.name}`, {
+                'moost.interceptor.stage': 'before',
+                'moost.interceptor.priority': handler.priority || '',
+            }, () => fn(this.replyFn.bind(this)));
             if (this.responseOverwritten) {
                 break;
             }
@@ -315,15 +342,22 @@ class InterceptorHandler {
         return this.response;
     }
     async fireAfter(response) {
+        const ci = getContextInjector();
         this.response = response;
         if (response instanceof Error) {
-            for (const handler of this.onError) {
-                await handler(response, this.replyFn.bind(this));
+            for (const { handler, fn } of this.onError) {
+                await ci.with(`Inteceptor:${handler.name}`, {
+                    'moost.interceptor.stage': 'after',
+                    'moost.interceptor.priority': handler.priority || '',
+                }, () => fn(response, this.replyFn.bind(this)));
             }
         }
         else {
-            for (const handler of this.after) {
-                await handler(response, this.replyFn.bind(this));
+            for (const { handler, fn } of this.after) {
+                await ci.with(`Inteceptor:${handler.name}`, {
+                    'moost.interceptor.stage': 'onError',
+                    'moost.interceptor.priority': handler.priority || '',
+                }, () => fn(response, this.replyFn.bind(this)));
             }
         }
         return this.response;
@@ -708,7 +742,7 @@ class Moost extends Hookable {
                 event: { type: 'init' },
                 options: {},
             })(async () => {
-                setControllerContext(this, 'bindController');
+                setControllerContext(this, 'bindController', '');
                 instance = (await infact.get(controller, infactOpts));
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moost",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "moost",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -34,9 +34,9 @@
     "@prostojs/infact": "^0.2.3",
     "@prostojs/mate": "^0.3.2",
     "@prostojs/logger": "^0.4.0",
-    "@wooksjs/event-core": "^0.5.5",
+    "@wooksjs/event-core": "^0.5.9",
     "hookable": "^5.5.3",
-    "wooks": "^0.5.5"
+    "wooks": "^0.5.9"
   },
   "author": "Artem Maltsev",
   "license": "MIT",