@hazeljs/event-emitter 0.2.0-beta.53 → 0.2.0-beta.55

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

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

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

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

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.js

@@ -53,6 +53,6 @@ let EventEmitterService = class EventEmitterService extends eventemitter2_1.defa
 };
 exports.EventEmitterService = EventEmitterService;
 exports.EventEmitterService = EventEmitterService = __decorate([
-    (0, core_1.Injectable)(),
+    (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/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"}

package/dist/on-event.decorator.test.js

@@ -0,0 +1,136 @@
+"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 });
+require("reflect-metadata");
+const on_event_decorator_1 = require("./on-event.decorator");
+describe('OnEvent decorator', () => {
+    it('should define ON_EVENT_METADATA_KEY', () => {
+        expect(typeof on_event_decorator_1.ON_EVENT_METADATA_KEY).toBe('symbol');
+    });
+    it('should add metadata for single event', () => {
+        class TestHandler {
+            handleOrderCreated(_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 metadata = (0, on_event_decorator_1.getOnEventMetadata)(new TestHandler());
+        expect(metadata).toHaveLength(1);
+        expect(metadata[0].event).toBe('order.created');
+        expect(metadata[0].methodName).toBe('handleOrderCreated');
+        expect(metadata[0].options).toEqual({ suppressErrors: true });
+    });
+    it('should add metadata for multiple events on same class', () => {
+        class TestHandler {
+            handleCreated(_payload) { }
+            handleUpdated(_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, "handleCreated", null);
+        __decorate([
+            (0, on_event_decorator_1.OnEvent)('order.updated'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestHandler.prototype, "handleUpdated", null);
+        const metadata = (0, on_event_decorator_1.getOnEventMetadata)(new TestHandler());
+        expect(metadata).toHaveLength(2);
+        expect(metadata[0].event).toBe('order.created');
+        expect(metadata[0].methodName).toBe('handleCreated');
+        expect(metadata[1].event).toBe('order.updated');
+        expect(metadata[1].methodName).toBe('handleUpdated');
+    });
+    it('should merge custom options with defaults', () => {
+        class TestHandler {
+            handleEvent(_payload) { }
+        }
+        __decorate([
+            (0, on_event_decorator_1.OnEvent)('test.event', { async: true, suppressErrors: false }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestHandler.prototype, "handleEvent", null);
+        const metadata = (0, on_event_decorator_1.getOnEventMetadata)(new TestHandler());
+        expect(metadata[0].options).toEqual({
+            async: true,
+            suppressErrors: false,
+        });
+    });
+    it('should support array of events', () => {
+        class TestHandler {
+            handleMultiple(_payload) { }
+        }
+        __decorate([
+            (0, on_event_decorator_1.OnEvent)(['event.a', 'event.b']),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestHandler.prototype, "handleMultiple", null);
+        const metadata = (0, on_event_decorator_1.getOnEventMetadata)(new TestHandler());
+        expect(metadata[0].event).toEqual(['event.a', 'event.b']);
+    });
+    it('should support symbol as event', () => {
+        const sym = Symbol('custom-event');
+        class TestHandler {
+            handleSymbol(_payload) { }
+        }
+        __decorate([
+            (0, on_event_decorator_1.OnEvent)(sym),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestHandler.prototype, "handleSymbol", null);
+        const metadata = (0, on_event_decorator_1.getOnEventMetadata)(new TestHandler());
+        expect(metadata[0].event).toBe(sym);
+    });
+    it('should default suppressErrors to true when not provided', () => {
+        class TestHandler {
+            handleEvent(_payload) { }
+        }
+        __decorate([
+            (0, on_event_decorator_1.OnEvent)('test.event', { async: true }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], TestHandler.prototype, "handleEvent", null);
+        const metadata = (0, on_event_decorator_1.getOnEventMetadata)(new TestHandler());
+        expect(metadata[0].options?.suppressErrors).toBe(true);
+    });
+});
+describe('getOnEventMetadata', () => {
+    it('should return empty array for class without @OnEvent decorators', () => {
+        class PlainClass {
+        }
+        const metadata = (0, on_event_decorator_1.getOnEventMetadata)(new PlainClass());
+        expect(metadata).toEqual([]);
+    });
+    it('should return metadata from class constructor', () => {
+        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);
+        const instance = new TestHandler();
+        const metadata = (0, on_event_decorator_1.getOnEventMetadata)(instance);
+        expect(metadata).toHaveLength(1);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/event-emitter",
-  "version": "0.2.0-beta.53",
+  "version": "0.2.0-beta.55",
   "description": "Event emitter module for HazelJS framework - event-driven architecture with decorators",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,5 +50,5 @@
     "url": "https://github.com/hazeljs/hazel-js/issues"
   },
   "homepage": "https://hazeljs.com",
-  "gitHead": "84311f65083627fa53bf2a22f96cd212c196873c"
+  "gitHead": "f2e54f346eea552595a44607999454a9e388cb9e"
 }