@hazeljs/event-emitter 0.2.0-alpha.1

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

@@ -0,0 +1,54 @@
+{
+  "name": "@hazeljs/event-emitter",
+  "version": "0.2.0-alpha.1",
+  "description": "Event emitter module for HazelJS framework - event-driven architecture with decorators",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --coverage --passWithNoTests",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "eventemitter2": "^6.4.9"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.50",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "@hazeljs/core": ">=0.2.0-beta.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/event-emitter"
+  },
+  "keywords": [
+    "hazeljs",
+    "events",
+    "event-emitter",
+    "event-driven",
+    "decorators"
+  ],
+  "author": "Muhammad Arslan <muhammad.arslan@hazeljs.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com",
+  "gitHead": "cbc5ee2c12ced28fd0576faf13c5f078c1e8421e"
+}