@hazeljs/event-emitter 0.2.0-alpha.1

package/dist/event-emitter.module.test.js

@@ -0,0 +1,280 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@hazeljs/core");
+const event_emitter_module_1 = require("./event-emitter.module");
+const event_emitter_service_1 = require("./event-emitter.service");
+const on_event_decorator_1 = require("./on-event.decorator");
+describe('EventEmitterModule', () => {
+    let container;
+    const originalGetInstance = core_1.Container.getInstance;
+    beforeEach(() => {
+        container = core_1.Container.createTestInstance();
+        core_1.Container.getInstance = jest.fn(() => container);
+    });
+    afterEach(() => {
+        core_1.Container.getInstance = originalGetInstance;
+    });
+    describe('forRoot', () => {
+        it('should return module config with providers and exports', () => {
+            const config = event_emitter_module_1.EventEmitterModule.forRoot();
+            expect(config.module).toBe(event_emitter_module_1.EventEmitterModule);
+            expect(config.providers).toHaveLength(1);
+            expect(config.providers[0].provide).toBe(event_emitter_service_1.EventEmitterService);
+            expect(config.providers[0].useFactory).toBeDefined();
+            expect(config.exports).toContain(event_emitter_service_1.EventEmitterService);
+            expect(config.global).toBe(true);
+        });
+        it('should use isGlobal option', () => {
+            const config = event_emitter_module_1.EventEmitterModule.forRoot({ isGlobal: false });
+            expect(config.global).toBe(false);
+        });
+        it('should default isGlobal to true when not provided', () => {
+            const config = event_emitter_module_1.EventEmitterModule.forRoot({});
+            expect(config.global).toBe(true);
+        });
+        it('should pass options to EventEmitterService factory', () => {
+            const config = event_emitter_module_1.EventEmitterModule.forRoot({
+                wildcard: true,
+                delimiter: ':',
+            });
+            const factory = config.providers[0].useFactory;
+            const service = factory();
+            expect(service).toBeInstanceOf(event_emitter_service_1.EventEmitterService);
+        });
+    });
+    describe('registerListenersFromProvider', () => {
+        it('should register event listeners from provider with @OnEvent', () => {
+            const mockEmit = jest.fn();
+            const mockOn = jest.fn();
+            const eventEmitter = {
+                on: mockOn,
+                emit: mockEmit,
+            };
+            container.register(event_emitter_service_1.EventEmitterService, eventEmitter);
+            class TestHandler {
+                handleOrderCreated(payload) {
+                    return payload;
+                }
+            }
+            __decorate([
+                (0, on_event_decorator_1.OnEvent)('order.created'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", void 0)
+            ], TestHandler.prototype, "handleOrderCreated", null);
+            const handler = new TestHandler();
+            event_emitter_module_1.EventEmitterModule.registerListenersFromProvider(handler);
+            expect(mockOn).toHaveBeenCalledWith('order.created', expect.any(Function), expect.objectContaining({ suppressErrors: true }));
+        });
+        it('should handle async listeners', () => {
+            const mockOn = jest.fn();
+            const eventEmitter = {
+                on: mockOn,
+            };
+            container.register(event_emitter_service_1.EventEmitterService, eventEmitter);
+            class TestHandler {
+                async handleAsync(_payload) { }
+            }
+            __decorate([
+                (0, on_event_decorator_1.OnEvent)('async.event', { async: true }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", Promise)
+            ], TestHandler.prototype, "handleAsync", null);
+            const handler = new TestHandler();
+            event_emitter_module_1.EventEmitterModule.registerListenersFromProvider(handler);
+            expect(mockOn).toHaveBeenCalledWith('async.event', expect.any(Function), expect.objectContaining({ async: true }));
+        });
+        it('should call listener when event is emitted', () => {
+            const eventEmitter = new event_emitter_service_1.EventEmitterService();
+            container.register(event_emitter_service_1.EventEmitterService, eventEmitter);
+            const handlerFn = jest.fn();
+            class TestHandler {
+                handleTest(payload) {
+                    handlerFn(payload);
+                }
+            }
+            __decorate([
+                (0, on_event_decorator_1.OnEvent)('test.event'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", void 0)
+            ], TestHandler.prototype, "handleTest", null);
+            const handler = new TestHandler();
+            event_emitter_module_1.EventEmitterModule.registerListenersFromProvider(handler);
+            eventEmitter.emit('test.event', { data: 'test' });
+            expect(handlerFn).toHaveBeenCalledWith({ data: 'test' });
+        });
+        it('should suppress errors when suppressErrors is true', () => {
+            const eventEmitter = new event_emitter_service_1.EventEmitterService();
+            container.register(event_emitter_service_1.EventEmitterService, eventEmitter);
+            class TestHandler {
+                handleTest() {
+                    throw new Error('Handler error');
+                }
+            }
+            __decorate([
+                (0, on_event_decorator_1.OnEvent)('test.event'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestHandler.prototype, "handleTest", null);
+            const handler = new TestHandler();
+            expect(() => {
+                event_emitter_module_1.EventEmitterModule.registerListenersFromProvider(handler);
+                eventEmitter.emit('test.event');
+            }).not.toThrow();
+        });
+        it('should rethrow errors when suppressErrors is false', () => {
+            const eventEmitter = new event_emitter_service_1.EventEmitterService();
+            container.register(event_emitter_service_1.EventEmitterService, eventEmitter);
+            class TestHandler {
+                handleTest() {
+                    throw new Error('Handler error');
+                }
+            }
+            __decorate([
+                (0, on_event_decorator_1.OnEvent)('test.event', { suppressErrors: false }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestHandler.prototype, "handleTest", null);
+            const handler = new TestHandler();
+            event_emitter_module_1.EventEmitterModule.registerListenersFromProvider(handler);
+            expect(() => eventEmitter.emit('test.event')).toThrow('Handler error');
+        });
+        it('should skip when method is not a function', () => {
+            const mockOn = jest.fn();
+            const eventEmitter = { on: mockOn };
+            container.register(event_emitter_service_1.EventEmitterService, eventEmitter);
+            class TestHandler {
+                handleTest(_payload) {
+                    return _payload;
+                }
+            }
+            __decorate([
+                (0, on_event_decorator_1.OnEvent)('test.event'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", void 0)
+            ], TestHandler.prototype, "handleTest", null);
+            const handler = new TestHandler();
+            // Overwrite method with non-function to simulate missing/invalid method
+            handler.handleTest = 'not a function';
+            event_emitter_module_1.EventEmitterModule.registerListenersFromProvider(handler);
+            expect(mockOn).not.toHaveBeenCalled();
+        });
+        it('should handle provider with no @OnEvent decorators', () => {
+            const mockOn = jest.fn();
+            const eventEmitter = { on: mockOn };
+            container.register(event_emitter_service_1.EventEmitterService, eventEmitter);
+            class PlainHandler {
+            }
+            event_emitter_module_1.EventEmitterModule.registerListenersFromProvider(new PlainHandler());
+            expect(mockOn).not.toHaveBeenCalled();
+        });
+        it('should handle EventEmitterService not in container', () => {
+            const emptyContainer = core_1.Container.createTestInstance();
+            // Register EventEmitterService as undefined to simulate "not found"
+            emptyContainer.register(event_emitter_service_1.EventEmitterService, undefined);
+            core_1.Container.getInstance = jest.fn(() => emptyContainer);
+            class TestHandler {
+                handle() { }
+            }
+            __decorate([
+                (0, on_event_decorator_1.OnEvent)('test'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestHandler.prototype, "handle", null);
+            expect(() => {
+                event_emitter_module_1.EventEmitterModule.registerListenersFromProvider(new TestHandler());
+            }).not.toThrow();
+        });
+        it('should handle errors during registration gracefully', () => {
+            core_1.Container.getInstance = jest.fn(() => {
+                throw new Error('Container error');
+            });
+            class TestHandler {
+                handle() { }
+            }
+            __decorate([
+                (0, on_event_decorator_1.OnEvent)('test'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestHandler.prototype, "handle", null);
+            expect(() => {
+                event_emitter_module_1.EventEmitterModule.registerListenersFromProvider(new TestHandler());
+            }).not.toThrow();
+        });
+    });
+    describe('registerListenersFromProviders', () => {
+        it('should register listeners from multiple provider classes', () => {
+            const eventEmitter = new event_emitter_service_1.EventEmitterService();
+            container.register(event_emitter_service_1.EventEmitterService, eventEmitter);
+            const handler1Fn = jest.fn();
+            const handler2Fn = jest.fn();
+            class Handler1 {
+                handle() {
+                    handler1Fn();
+                }
+            }
+            __decorate([
+                (0, on_event_decorator_1.OnEvent)('event.1'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Handler1.prototype, "handle", null);
+            class Handler2 {
+                handle() {
+                    handler2Fn();
+                }
+            }
+            __decorate([
+                (0, on_event_decorator_1.OnEvent)('event.2'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Handler2.prototype, "handle", null);
+            container.register(Handler1, new Handler1());
+            container.register(Handler2, new Handler2());
+            event_emitter_module_1.EventEmitterModule.registerListenersFromProviders([Handler1, Handler2]);
+            eventEmitter.emit('event.1');
+            eventEmitter.emit('event.2');
+            expect(handler1Fn).toHaveBeenCalled();
+            expect(handler2Fn).toHaveBeenCalled();
+        });
+        it('should skip provider when resolve returns undefined', () => {
+            const eventEmitter = new event_emitter_service_1.EventEmitterService();
+            container.register(event_emitter_service_1.EventEmitterService, eventEmitter);
+            class Handler1 {
+                handle() { }
+            }
+            __decorate([
+                (0, on_event_decorator_1.OnEvent)('event.1'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Handler1.prototype, "handle", null);
+            const originalResolve = container.resolve.bind(container);
+            jest.spyOn(container, 'resolve').mockImplementation((token) => {
+                if (token === Handler1)
+                    return undefined;
+                return originalResolve(token);
+            });
+            expect(() => {
+                event_emitter_module_1.EventEmitterModule.registerListenersFromProviders([Handler1]);
+            }).not.toThrow();
+        });
+    });
+});

package/dist/event-emitter.service.d.ts

@@ -0,0 +1,33 @@
+import EventEmitter2 from 'eventemitter2';
+import type { EventEmitterModuleOptions } from './event-emitter.types';
+/**
+ * Event emitter service - wraps EventEmitter2 for DI injection
+ * Use this service to emit events throughout your application
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class OrderService {
+ *   constructor(private eventEmitter: EventEmitterService) {}
+ *
+ *   createOrder(order: Order) {
+ *     // ... create order
+ *     this.eventEmitter.emit('order.created', new OrderCreatedEvent(order));
+ *   }
+ * }
+ * ```
+ */
+export declare class EventEmitterService extends EventEmitter2 {
+    constructor(options?: EventEmitterModuleOptions);
+    /**
+     * Emit an event
+     * @param event - Event name
+     * @param values - Payload values (spread as arguments to listeners)
+     */
+    emit(event: string | symbol, ...values: unknown[]): boolean;
+    /**
+     * Emit an event asynchronously (listeners receive a promise)
+     */
+    emitAsync(event: string | symbol, ...values: unknown[]): Promise<unknown[]>;
+}
+//# sourceMappingURL=event-emitter.service.d.ts.map

package/dist/event-emitter.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter.service.d.ts","sourceRoot":"","sources":["../src/event-emitter.service.ts"],"names":[],"mappings":"AACA,OAAO,aAAa,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAEvE;;;;;;;;;;;;;;;;GAgBG;AACH,qBACa,mBAAoB,SAAQ,aAAa;gBACxC,OAAO,CAAC,EAAE,yBAAyB;IAI/C;;;;OAIG;IACM,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO;IAIpE;;OAEG;IACM,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;CAGrF"}

package/dist/event-emitter.service.js

@@ -0,0 +1,58 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitterService = void 0;
+const core_1 = require("@hazeljs/core");
+const eventemitter2_1 = __importDefault(require("eventemitter2"));
+/**
+ * Event emitter service - wraps EventEmitter2 for DI injection
+ * Use this service to emit events throughout your application
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class OrderService {
+ *   constructor(private eventEmitter: EventEmitterService) {}
+ *
+ *   createOrder(order: Order) {
+ *     // ... create order
+ *     this.eventEmitter.emit('order.created', new OrderCreatedEvent(order));
+ *   }
+ * }
+ * ```
+ */
+let EventEmitterService = class EventEmitterService extends eventemitter2_1.default {
+    constructor(options) {
+        super(options ?? {});
+    }
+    /**
+     * Emit an event
+     * @param event - Event name
+     * @param values - Payload values (spread as arguments to listeners)
+     */
+    emit(event, ...values) {
+        return super.emit(event, ...values);
+    }
+    /**
+     * Emit an event asynchronously (listeners receive a promise)
+     */
+    emitAsync(event, ...values) {
+        return super.emitAsync(event, ...values);
+    }
+};
+exports.EventEmitterService = EventEmitterService;
+exports.EventEmitterService = EventEmitterService = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [Object])
+], EventEmitterService);

package/dist/event-emitter.service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=event-emitter.service.test.d.ts.map

package/dist/event-emitter.service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter.service.test.d.ts","sourceRoot":"","sources":["../src/event-emitter.service.test.ts"],"names":[],"mappings":""}

package/dist/event-emitter.service.test.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_emitter_service_1 = require("./event-emitter.service");
+describe('EventEmitterService', () => {
+    describe('constructor', () => {
+        it('should create instance with default options when no options provided', () => {
+            const service = new event_emitter_service_1.EventEmitterService();
+            expect(service).toBeInstanceOf(event_emitter_service_1.EventEmitterService);
+        });
+        it('should create instance with custom options', () => {
+            const service = new event_emitter_service_1.EventEmitterService({
+                wildcard: true,
+                delimiter: ':',
+                maxListeners: 20,
+            });
+            expect(service).toBeInstanceOf(event_emitter_service_1.EventEmitterService);
+        });
+    });
+    describe('emit', () => {
+        it('should emit event and invoke listeners', () => {
+            const service = new event_emitter_service_1.EventEmitterService();
+            const listener = jest.fn();
+            service.on('test.event', listener);
+            const result = service.emit('test.event', { data: 'payload' });
+            expect(result).toBe(true);
+            expect(listener).toHaveBeenCalledTimes(1);
+            expect(listener).toHaveBeenCalledWith({ data: 'payload' });
+        });
+        it('should emit event with multiple arguments', () => {
+            const service = new event_emitter_service_1.EventEmitterService();
+            const listener = jest.fn();
+            service.on('multi', listener);
+            service.emit('multi', 'arg1', 'arg2', 123);
+            expect(listener).toHaveBeenCalledWith('arg1', 'arg2', 123);
+        });
+        it('should return false when no listeners', () => {
+            const service = new event_emitter_service_1.EventEmitterService();
+            const result = service.emit('nonexistent.event');
+            expect(result).toBe(false);
+        });
+    });
+    describe('emitAsync', () => {
+        it('should emit event asynchronously and return promise', async () => {
+            const service = new event_emitter_service_1.EventEmitterService();
+            const listener = jest.fn().mockResolvedValue(undefined);
+            service.on('async.event', listener);
+            const promise = service.emitAsync('async.event', { id: 1 });
+            expect(promise).toBeInstanceOf(Promise);
+            const results = await promise;
+            expect(listener).toHaveBeenCalledWith({ id: 1 });
+            expect(results).toEqual([undefined]);
+        });
+        it('should handle async listeners that return values', async () => {
+            const service = new event_emitter_service_1.EventEmitterService();
+            const listener = jest.fn().mockResolvedValue('result');
+            service.on('async.event', listener);
+            const results = await service.emitAsync('async.event');
+            expect(results).toEqual(['result']);
+        });
+    });
+});

package/dist/event-emitter.types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Event emitter configuration options (passed to eventemitter2)
+ */
+export interface EventEmitterModuleOptions {
+    /**
+     * Use wildcards for event names (e.g. 'order.*')
+     * @default false
+     */
+    wildcard?: boolean;
+    /**
+     * Delimiter used to segment namespaces
+     * @default '.'
+     */
+    delimiter?: string;
+    /**
+     * Emit newListener event when adding listeners
+     * @default false
+     */
+    newListener?: boolean;
+    /**
+     * Emit removeListener event when removing listeners
+     * @default false
+     */
+    removeListener?: boolean;
+    /**
+     * Maximum number of listeners per event
+     * @default 10
+     */
+    maxListeners?: number;
+    /**
+     * Show event name in memory leak message
+     * @default false
+     */
+    verboseMemoryLeak?: boolean;
+    /**
+     * Disable throwing uncaughtException if error event has no listeners
+     * @default false
+     */
+    ignoreErrors?: boolean;
+}
+/**
+ * Options for @OnEvent decorator
+ */
+export interface OnEventOptions {
+    /**
+     * If true, listener runs asynchronously
+     * @default false
+     */
+    async?: boolean;
+    /**
+     * If true, prepends listener instead of appending
+     * @default false
+     */
+    prependListener?: boolean;
+    /**
+     * If true, errors in the handler are suppressed (not rethrown)
+     * @default true
+     */
+    suppressErrors?: boolean;
+}
+//# sourceMappingURL=event-emitter.types.d.ts.map

package/dist/event-emitter.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter.types.d.ts","sourceRoot":"","sources":["../src/event-emitter.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B"}

package/dist/event-emitter.types.js

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

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @hazeljs/event-emitter - Event emitter module for HazelJS
+ *
+ * Event-driven architecture with decorators, similar to @nestjs/event-emitter.
+ * Built on eventemitter2 - supports wildcards, namespaces, and async listeners.
+ */
+export { EventEmitterModule, type EventEmitterModuleConfig } from './event-emitter.module';
+export { EventEmitterService } from './event-emitter.service';
+export { OnEvent, getOnEventMetadata } from './on-event.decorator';
+export type { OnEventMetadata } from './on-event.decorator';
+export type { EventEmitterModuleOptions, OnEventOptions } from './event-emitter.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,kBAAkB,EAAE,KAAK,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAC3F,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACnE,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,YAAY,EAAE,yBAAyB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @hazeljs/event-emitter - Event emitter module for HazelJS
+ *
+ * Event-driven architecture with decorators, similar to @nestjs/event-emitter.
+ * Built on eventemitter2 - supports wildcards, namespaces, and async listeners.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOnEventMetadata = exports.OnEvent = exports.EventEmitterService = exports.EventEmitterModule = void 0;
+var event_emitter_module_1 = require("./event-emitter.module");
+Object.defineProperty(exports, "EventEmitterModule", { enumerable: true, get: function () { return event_emitter_module_1.EventEmitterModule; } });
+var event_emitter_service_1 = require("./event-emitter.service");
+Object.defineProperty(exports, "EventEmitterService", { enumerable: true, get: function () { return event_emitter_service_1.EventEmitterService; } });
+var on_event_decorator_1 = require("./on-event.decorator");
+Object.defineProperty(exports, "OnEvent", { enumerable: true, get: function () { return on_event_decorator_1.OnEvent; } });
+Object.defineProperty(exports, "getOnEventMetadata", { enumerable: true, get: function () { return on_event_decorator_1.getOnEventMetadata; } });

package/dist/on-event.decorator.d.ts

@@ -0,0 +1,36 @@
+import 'reflect-metadata';
+import { OnEventOptions } from './event-emitter.types';
+/**
+ * Metadata key for event listeners
+ */
+export declare const ON_EVENT_METADATA_KEY: unique symbol;
+export interface OnEventMetadata {
+    event: string | symbol | string[];
+    methodName: string;
+    options?: OnEventOptions;
+}
+/**
+ * Decorator to mark a method as an event listener
+ * @param event - Event name(s) to listen for. With wildcards enabled, supports patterns like 'order.*'
+ * @param options - Listener options
+ *
+ * @example
+ * ```typescript
+ * @OnEvent('order.created')
+ * handleOrderCreated(payload: OrderCreatedEvent) {
+ *   // handle event
+ * }
+ *
+ * // With wildcards (when EventEmitterModule.forRoot({ wildcard: true }))
+ * @OnEvent('order.*')
+ * handleOrderEvents(payload: OrderCreatedEvent | OrderUpdatedEvent) {
+ *   // handle any order event
+ * }
+ * ```
+ */
+export declare function OnEvent(event: string | symbol | string[], options?: OnEventOptions): MethodDecorator;
+/**
+ * Get @OnEvent metadata from a class
+ */
+export declare function getOnEventMetadata(target: object): OnEventMetadata[];
+//# sourceMappingURL=on-event.decorator.d.ts.map

package/dist/on-event.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-event.decorator.d.ts","sourceRoot":"","sources":["../src/on-event.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,qBAAqB,eAAmC,CAAC;AAEtE,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,cAAc,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,EACjC,OAAO,CAAC,EAAE,cAAc,GACvB,eAAe,CAgBjB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,EAAE,CAEpE"}

package/dist/on-event.decorator.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ON_EVENT_METADATA_KEY = void 0;
+exports.OnEvent = OnEvent;
+exports.getOnEventMetadata = getOnEventMetadata;
+require("reflect-metadata");
+/**
+ * Metadata key for event listeners
+ */
+exports.ON_EVENT_METADATA_KEY = Symbol('event-emitter:on-event');
+/**
+ * Decorator to mark a method as an event listener
+ * @param event - Event name(s) to listen for. With wildcards enabled, supports patterns like 'order.*'
+ * @param options - Listener options
+ *
+ * @example
+ * ```typescript
+ * @OnEvent('order.created')
+ * handleOrderCreated(payload: OrderCreatedEvent) {
+ *   // handle event
+ * }
+ *
+ * // With wildcards (when EventEmitterModule.forRoot({ wildcard: true }))
+ * @OnEvent('order.*')
+ * handleOrderEvents(payload: OrderCreatedEvent | OrderUpdatedEvent) {
+ *   // handle any order event
+ * }
+ * ```
+ */
+function OnEvent(event, options) {
+    return (target, propertyKey, _descriptor) => {
+        const existing = Reflect.getMetadata(exports.ON_EVENT_METADATA_KEY, target.constructor) || [];
+        existing.push({
+            event,
+            methodName: propertyKey.toString(),
+            options: {
+                suppressErrors: true,
+                ...options,
+            },
+        });
+        Reflect.defineMetadata(exports.ON_EVENT_METADATA_KEY, existing, target.constructor);
+    };
+}
+/**
+ * Get @OnEvent metadata from a class
+ */
+function getOnEventMetadata(target) {
+    return Reflect.getMetadata(exports.ON_EVENT_METADATA_KEY, target.constructor) || [];
+}

package/dist/on-event.decorator.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=on-event.decorator.test.d.ts.map

package/dist/on-event.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-event.decorator.test.d.ts","sourceRoot":"","sources":["../src/on-event.decorator.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}