@velajs/vela 0.2.1 → 0.3.0

package/README.md

@@ -1,13 +1,15 @@
 # @velajs/vela
 
+[![npm version](https://img.shields.io/npm/v/@velajs/vela)](https://www.npmjs.com/package/@velajs/vela)
+[![CI](https://github.com/velajs/vela/actions/workflows/ci.yml/badge.svg)](https://github.com/velajs/vela/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/npm/l/@velajs/vela)](https://github.com/velajs/vela/blob/main/LICENSE)
+
 NestJS-compatible framework for edge runtimes, powered by [Hono](https://hono.dev).
 
 ## Install
 
 ```bash
-npm install @velajs/vela
-# or
-bun add @velajs/vela
+pnpm add @velajs/vela
 ```
 
 ## Quick Start
@@ -74,7 +76,7 @@ No Node.js-specific APIs (`node:fs`, `Buffer`, `process`) are used.
 ## CRUD Module (Optional)
 
 ```bash
-bun add @velajs/crud hono-crud @hono/zod-openapi zod
+pnpm add @velajs/crud hono-crud @hono/zod-openapi zod
 ```
 
 See [`@velajs/crud`](https://github.com/velajs/crud) for documentation.

package/dist/application.d.ts

@@ -1,6 +1,7 @@
 import type { Hono } from 'hono';
 import type { Container } from './container/container';
 import type { Token } from './container/types';
+import type { CorsOptions } from './cors/cors.types';
 import type { RouteManager } from './http/route.manager';
 import type { FilterType, GuardType, InterceptorType, MiddlewareType, PipeType } from './registry/types';
 export declare class VelaApplication {
@@ -36,6 +37,7 @@ export declare class VelaApplication {
     useGlobalGuards(...guards: GuardType[]): this;
     useGlobalInterceptors(...interceptors: InterceptorType[]): this;
     useGlobalFilters(...filters: FilterType[]): this;
+    enableCors(options?: CorsOptions): this;
     get<T>(token: Token<T>): T;
     getHonoApp(): Hono;
     callOnModuleInit(): Promise<void>;

package/dist/application.js

@@ -1,3 +1,4 @@
+import { cors } from "hono/cors";
 import { hasBeforeApplicationShutdown, hasOnApplicationBootstrap, hasOnApplicationShutdown, hasOnModuleDestroy, hasOnModuleInit } from "./lifecycle/index.js";
 export class VelaApplication {
     container;
@@ -68,6 +69,21 @@ export class VelaApplication {
         this.routeManager.useGlobalFilters(...filters);
         return this;
     }
+    enableCors(options = {}) {
+        const corsMiddleware = cors({
+            origin: options.origin ?? '*',
+            allowMethods: options.allowMethods,
+            allowHeaders: options.allowHeaders,
+            exposeHeaders: options.exposeHeaders,
+            credentials: options.credentials,
+            maxAge: options.maxAge
+        });
+        const mw = {
+            use: (c, next)=>corsMiddleware(c, next)
+        };
+        this.routeManager.useGlobalMiddleware(mw);
+        return this;
+    }
     get(token) {
         return this.container.resolve(token);
     }

package/dist/cache/cache.decorators.d.ts

@@ -0,0 +1,2 @@
+export declare const CacheKey: (key: string) => (target: Function | object, propertyKey?: string | symbol) => void;
+export declare const CacheTTL: (seconds: number) => (target: Function | object, propertyKey?: string | symbol) => void;

package/dist/cache/cache.decorators.js

@@ -0,0 +1,4 @@
+import { SetMetadata } from "../pipeline/reflector.js";
+import { CACHE_KEY_METADATA, CACHE_TTL_METADATA } from "./cache.tokens.js";
+export const CacheKey = (key)=>SetMetadata(CACHE_KEY_METADATA, key);
+export const CacheTTL = (seconds)=>SetMetadata(CACHE_TTL_METADATA, seconds);

package/dist/cache/cache.interceptor.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutionContext, CallHandler, NestInterceptor } from '../pipeline/types';
+import type { CacheModuleOptions, CacheStore } from './cache.types';
+export declare class CacheInterceptor implements NestInterceptor {
+    private cacheStore;
+    private options;
+    private reflector;
+    constructor(cacheStore: CacheStore, options: CacheModuleOptions);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<unknown>;
+}

package/dist/cache/cache.interceptor.js

@@ -0,0 +1,60 @@
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Injectable, Inject } from "../container/decorators.js";
+import { Reflector } from "../pipeline/reflector.js";
+import { CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA } from "./cache.tokens.js";
+export class CacheInterceptor {
+    cacheStore;
+    options;
+    reflector = new Reflector();
+    constructor(cacheStore, options){
+        this.cacheStore = cacheStore;
+        this.options = options;
+    }
+    async intercept(context, next) {
+        const request = context.getRequest();
+        // Only cache GET requests
+        if (request.method !== 'GET') {
+            return next.handle();
+        }
+        // Determine cache key
+        const customKey = this.reflector.getAllAndOverride(CACHE_KEY_METADATA, context);
+        const url = new URL(request.url);
+        const cacheKey = customKey ?? `cache:GET:${url.pathname}`;
+        // Check cache
+        const cached = this.cacheStore.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+        // Execute handler
+        const result = await next.handle();
+        // Determine TTL
+        const customTtl = this.reflector.getAllAndOverride(CACHE_TTL_METADATA, context);
+        const ttl = customTtl ?? this.options.ttl ?? 5;
+        // Store in cache
+        this.cacheStore.set(cacheKey, result, ttl);
+        return result;
+    }
+}
+CacheInterceptor = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(CACHE_MANAGER)),
+    _ts_param(1, Inject(CACHE_MODULE_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof CacheStore === "undefined" ? Object : CacheStore,
+        typeof CacheModuleOptions === "undefined" ? Object : CacheModuleOptions
+    ])
+], CacheInterceptor);

package/dist/cache/cache.module.d.ts

@@ -0,0 +1,5 @@
+import type { DynamicModule } from '../module/types';
+import type { CacheModuleOptions } from './cache.types';
+export declare class CacheModule {
+    static forRoot(options?: CacheModuleOptions): DynamicModule;
+}

package/dist/cache/cache.module.js

@@ -0,0 +1,50 @@
+import { METADATA_KEYS } from "../constants.js";
+import { defineMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { APP_INTERCEPTOR } from "../pipeline/tokens.js";
+import { CacheInterceptor } from "./cache.interceptor.js";
+import { CacheService } from "./cache.service.js";
+import { MemoryCacheStore } from "./cache.store.js";
+import { CACHE_MANAGER, CACHE_MODULE_OPTIONS } from "./cache.tokens.js";
+export class CacheModule {
+    static forRoot(options = {}) {
+        const { ttl = 5, max = 100, isGlobal = false } = options;
+        const store = new MemoryCacheStore(ttl, max);
+        const moduleClass = class CacheDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'CacheModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            exports: [
+                CACHE_MANAGER,
+                CACHE_MODULE_OPTIONS,
+                CacheService,
+                CacheInterceptor
+            ]
+        });
+        const providers = [
+            {
+                token: CACHE_MANAGER,
+                useValue: store
+            },
+            {
+                token: CACHE_MODULE_OPTIONS,
+                useValue: options
+            },
+            CacheService,
+            CacheInterceptor
+        ];
+        if (isGlobal) {
+            providers.push({
+                token: APP_INTERCEPTOR,
+                useExisting: CacheInterceptor
+            });
+        }
+        return {
+            module: moduleClass,
+            providers
+        };
+    }
+}

package/dist/cache/cache.service.d.ts

@@ -0,0 +1,9 @@
+import type { CacheStore } from './cache.types';
+export declare class CacheService {
+    private store;
+    constructor(store: CacheStore);
+    get<T = unknown>(key: string): T | undefined;
+    set<T = unknown>(key: string, value: T, ttl?: number): void;
+    del(key: string): void;
+    clear(): void;
+}

package/dist/cache/cache.service.js

@@ -0,0 +1,42 @@
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Injectable, Inject } from "../container/decorators.js";
+import { CACHE_MANAGER } from "./cache.tokens.js";
+export class CacheService {
+    store;
+    constructor(store){
+        this.store = store;
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    set(key, value, ttl) {
+        this.store.set(key, value, ttl);
+    }
+    del(key) {
+        this.store.del(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+}
+CacheService = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(CACHE_MANAGER)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof CacheStore === "undefined" ? Object : CacheStore
+    ])
+], CacheService);

package/dist/cache/cache.store.d.ts

@@ -0,0 +1,12 @@
+import type { CacheStore } from './cache.types';
+export declare class MemoryCacheStore implements CacheStore {
+    private store;
+    private defaultTtl;
+    private max;
+    constructor(ttl?: number, max?: number);
+    get<T = unknown>(key: string): T | undefined;
+    set<T = unknown>(key: string, value: T, ttl?: number): void;
+    del(key: string): void;
+    clear(): void;
+    private evict;
+}

package/dist/cache/cache.store.js

@@ -0,0 +1,51 @@
+export class MemoryCacheStore {
+    store = new Map();
+    defaultTtl;
+    max;
+    constructor(ttl = 5, max = 100){
+        this.defaultTtl = ttl;
+        this.max = max;
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry) return undefined;
+        if (Date.now() > entry.expiresAt) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value, ttl) {
+        // Evict if at capacity
+        if (!this.store.has(key) && this.store.size >= this.max) {
+            this.evict();
+        }
+        const effectiveTtl = ttl ?? this.defaultTtl;
+        this.store.set(key, {
+            value,
+            expiresAt: Date.now() + effectiveTtl * 1000
+        });
+    }
+    del(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+    evict() {
+        // First remove expired entries
+        const now = Date.now();
+        for (const [key, entry] of this.store){
+            if (now > entry.expiresAt) {
+                this.store.delete(key);
+            }
+        }
+        // If still at capacity, remove oldest (first inserted)
+        if (this.store.size >= this.max) {
+            const firstKey = this.store.keys().next().value;
+            if (firstKey !== undefined) {
+                this.store.delete(firstKey);
+            }
+        }
+    }
+}

package/dist/cache/cache.tokens.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken } from '../container/types';
+import type { CacheStore, CacheModuleOptions } from './cache.types';
+export declare const CACHE_MANAGER: InjectionToken<CacheStore>;
+export declare const CACHE_MODULE_OPTIONS: InjectionToken<CacheModuleOptions>;
+export declare const CACHE_KEY_METADATA = "vela:cache-key";
+export declare const CACHE_TTL_METADATA = "vela:cache-ttl";

package/dist/cache/cache.tokens.js

@@ -0,0 +1,5 @@
+import { InjectionToken } from "../container/types.js";
+export const CACHE_MANAGER = new InjectionToken('CACHE_MANAGER');
+export const CACHE_MODULE_OPTIONS = new InjectionToken('CACHE_MODULE_OPTIONS');
+export const CACHE_KEY_METADATA = 'vela:cache-key';
+export const CACHE_TTL_METADATA = 'vela:cache-ttl';

package/dist/cache/cache.types.d.ts

@@ -0,0 +1,15 @@
+export interface CacheModuleOptions {
+    ttl?: number;
+    max?: number;
+    isGlobal?: boolean;
+}
+export interface CacheStore {
+    get<T = unknown>(key: string): T | undefined;
+    set<T = unknown>(key: string, value: T, ttl?: number): void;
+    del(key: string): void;
+    clear(): void;
+}
+export interface CacheEntry<T = unknown> {
+    value: T;
+    expiresAt: number;
+}

package/dist/cache/cache.types.js

@@ -0,0 +1 @@
+export { };

package/dist/cache/index.d.ts

@@ -0,0 +1,7 @@
+export { CacheModule } from './cache.module';
+export { CacheService } from './cache.service';
+export { CacheInterceptor } from './cache.interceptor';
+export { MemoryCacheStore } from './cache.store';
+export { CacheKey, CacheTTL } from './cache.decorators';
+export { CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA } from './cache.tokens';
+export type { CacheModuleOptions, CacheStore, CacheEntry } from './cache.types';

package/dist/cache/index.js

@@ -0,0 +1,6 @@
+export { CacheModule } from "./cache.module.js";
+export { CacheService } from "./cache.service.js";
+export { CacheInterceptor } from "./cache.interceptor.js";
+export { MemoryCacheStore } from "./cache.store.js";
+export { CacheKey, CacheTTL } from "./cache.decorators.js";
+export { CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA } from "./cache.tokens.js";

package/dist/config/config.module.d.ts

@@ -0,0 +1,5 @@
+import type { DynamicModule } from '../module/types';
+import type { ConfigModuleOptions } from './config.types';
+export declare class ConfigModule {
+    static forRoot<T extends Record<string, unknown>>(options: ConfigModuleOptions<T>): DynamicModule;
+}

package/dist/config/config.module.js

@@ -0,0 +1,32 @@
+import { METADATA_KEYS } from "../constants.js";
+import { defineMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { ConfigService } from "./config.service.js";
+import { CONFIG_OPTIONS } from "./config.tokens.js";
+export class ConfigModule {
+    static forRoot(options) {
+        const config = options.validate ? options.validate(options.config) : options.config;
+        const moduleClass = class ConfigDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'ConfigModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            exports: [
+                ConfigService,
+                CONFIG_OPTIONS
+            ]
+        });
+        return {
+            module: moduleClass,
+            providers: [
+                {
+                    token: CONFIG_OPTIONS,
+                    useValue: config
+                },
+                ConfigService
+            ]
+        };
+    }
+}

package/dist/config/config.service.d.ts

@@ -0,0 +1,7 @@
+export declare class ConfigService<T extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly config;
+    constructor(config: T);
+    get<V>(key: string): V | undefined;
+    get<V>(key: string, defaultValue: V): V;
+    getAll(): T;
+}

package/dist/config/config.service.js

@@ -0,0 +1,45 @@
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Injectable } from "../container/decorators.js";
+import { Inject } from "../container/decorators.js";
+import { CONFIG_OPTIONS } from "./config.tokens.js";
+export class ConfigService {
+    config;
+    constructor(config){
+        this.config = config;
+    }
+    get(key, defaultValue) {
+        const parts = key.split('.');
+        let current = this.config;
+        for (const part of parts){
+            if (current === null || current === undefined || typeof current !== 'object') {
+                return defaultValue;
+            }
+            current = current[part];
+        }
+        return current ?? defaultValue;
+    }
+    getAll() {
+        return this.config;
+    }
+}
+ConfigService = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(CONFIG_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof T === "undefined" ? Object : T
+    ])
+], ConfigService);

package/dist/config/config.tokens.d.ts

@@ -0,0 +1,2 @@
+import { InjectionToken } from '../container/types';
+export declare const CONFIG_OPTIONS: InjectionToken<Record<string, unknown>>;

package/dist/config/config.tokens.js

@@ -0,0 +1,2 @@
+import { InjectionToken } from "../container/types.js";
+export const CONFIG_OPTIONS = new InjectionToken('CONFIG_OPTIONS');

package/dist/config/config.types.d.ts

@@ -0,0 +1,4 @@
+export interface ConfigModuleOptions<T extends Record<string, unknown> = Record<string, unknown>> {
+    config: T;
+    validate?: (config: T) => T;
+}

package/dist/config/config.types.js

@@ -0,0 +1 @@
+export { };

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+export { ConfigModule } from './config.module';
+export { ConfigService } from './config.service';
+export { CONFIG_OPTIONS } from './config.tokens';
+export type { ConfigModuleOptions } from './config.types';

package/dist/config/index.js

@@ -0,0 +1,3 @@
+export { ConfigModule } from "./config.module.js";
+export { ConfigService } from "./config.service.js";
+export { CONFIG_OPTIONS } from "./config.tokens.js";

package/dist/cors/cors.module.d.ts

@@ -0,0 +1,5 @@
+import type { DynamicModule } from '../module/types';
+import type { CorsOptions } from './cors.types';
+export declare class CorsModule {
+    static forRoot(options?: CorsOptions): DynamicModule;
+}

package/dist/cors/cors.module.js

@@ -0,0 +1,45 @@
+import { cors } from "hono/cors";
+import { METADATA_KEYS } from "../constants.js";
+import { defineMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { APP_MIDDLEWARE } from "../pipeline/tokens.js";
+import { CORS_OPTIONS } from "./cors.tokens.js";
+export class CorsModule {
+    static forRoot(options = {}) {
+        const corsMiddleware = cors({
+            origin: options.origin ?? '*',
+            allowMethods: options.allowMethods,
+            allowHeaders: options.allowHeaders,
+            exposeHeaders: options.exposeHeaders,
+            credentials: options.credentials,
+            maxAge: options.maxAge
+        });
+        const middleware = {
+            use: (c, next)=>corsMiddleware(c, next)
+        };
+        const moduleClass = class CorsDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'CorsModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            exports: [
+                CORS_OPTIONS
+            ]
+        });
+        return {
+            module: moduleClass,
+            providers: [
+                {
+                    token: CORS_OPTIONS,
+                    useValue: options
+                },
+                {
+                    token: APP_MIDDLEWARE,
+                    useValue: middleware
+                }
+            ]
+        };
+    }
+}

package/dist/cors/cors.tokens.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '../container/types';
+import type { CorsOptions } from './cors.types';
+export declare const CORS_OPTIONS: InjectionToken<CorsOptions>;

package/dist/cors/cors.tokens.js

@@ -0,0 +1,2 @@
+import { InjectionToken } from "../container/types.js";
+export const CORS_OPTIONS = new InjectionToken('CORS_OPTIONS');

package/dist/cors/cors.types.d.ts

@@ -0,0 +1,8 @@
+export interface CorsOptions {
+    origin?: string | string[] | ((origin: string) => string | undefined | null);
+    allowMethods?: string[];
+    allowHeaders?: string[];
+    exposeHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}

package/dist/cors/cors.types.js

@@ -0,0 +1 @@
+export { };

package/dist/cors/index.d.ts

@@ -0,0 +1,3 @@
+export { CorsModule } from './cors.module';
+export { CORS_OPTIONS } from './cors.tokens';
+export type { CorsOptions } from './cors.types';

package/dist/cors/index.js

@@ -0,0 +1,2 @@
+export { CorsModule } from "./cors.module.js";
+export { CORS_OPTIONS } from "./cors.tokens.js";

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

@@ -0,0 +1 @@
+export declare function OnEvent(event: string): MethodDecorator;

package/dist/event-emitter/event-emitter.decorators.js

@@ -0,0 +1,11 @@
+import { ON_EVENT_METADATA } from "./event-emitter.tokens.js";
+export function OnEvent(event) {
+    return (target, propertyKey)=>{
+        const existing = Reflect.getMetadata(ON_EVENT_METADATA, target.constructor) ?? [];
+        existing.push({
+            event,
+            methodName: String(propertyKey)
+        });
+        Reflect.defineMetadata(ON_EVENT_METADATA, existing, target.constructor);
+    };
+}

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

@@ -0,0 +1,2 @@
+export declare class EventEmitterModule {
+}

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

@@ -0,0 +1,22 @@
+function _ts_decorate(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;
+}
+import { Module } from "../module/index.js";
+import { EventEmitter } from "./event-emitter.service.js";
+import { EventEmitterSubscriber } from "./event-emitter.subscriber.js";
+export class EventEmitterModule {
+}
+EventEmitterModule = _ts_decorate([
+    Module({
+        providers: [
+            EventEmitter,
+            EventEmitterSubscriber
+        ],
+        exports: [
+            EventEmitter
+        ]
+    })
+], EventEmitterModule);

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

@@ -0,0 +1,13 @@
+import type { EventHandler } from './event-emitter.types';
+export declare class EventEmitter {
+    private listeners;
+    private onceListeners;
+    on(event: string, handler: EventHandler): this;
+    once(event: string, handler: EventHandler): this;
+    off(event: string, handler: EventHandler): this;
+    emit(event: string, ...args: unknown[]): Promise<void>;
+    removeAllListeners(event?: string): this;
+    listenerCount(event: string): number;
+    private getMatchingHandlers;
+    private matchPattern;
+}