@hono-di/core 0.0.6

package/dist/interfaces-4oTuNIHA.d.ts

@@ -0,0 +1,139 @@
+import { HonoRequest, Context, Next, MiddlewareHandler, Hono } from 'hono';
+import { Observable } from 'rxjs';
+
+declare enum Scope {
+    DEFAULT = 0,
+    TRANSIENT = 1,
+    REQUEST = 2
+}
+
+declare enum RequestMethod {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    DELETE = "delete",
+    PATCH = "patch",
+    ALL = "all",
+    OPTIONS = "options",
+    HEAD = "head"
+}
+interface ModuleOptions {
+    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    controllers?: Type<any>[];
+    providers?: Provider[];
+    exports?: Array<DynamicModule | Promise<DynamicModule> | string | symbol | Provider | ForwardReference | Function>;
+}
+interface Type<T = any> extends Function {
+    new (...args: any[]): T;
+}
+interface ArgumentsHost {
+    getArgs<T extends Array<any> = any[]>(): T;
+    getType<TContext extends string = 'http'>(): TContext;
+    switchToHttp(): HttpArgumentsHost;
+}
+interface HttpArgumentsHost {
+    getRequest<T extends string = any>(): HonoRequest<T, any>;
+    getResponse<T = any>(): Context;
+    getNext<T = any>(): Next;
+    getContext(): Context;
+}
+interface ExecutionContext extends ArgumentsHost {
+    getClass<T = any>(): Type<T>;
+    getHandler(): Function;
+}
+interface ExceptionFilter<T = any> {
+    catch(exception: T, host: ArgumentsHost): void;
+}
+interface ArgumentMetadata {
+    type: 'body' | 'query' | 'param' | 'custom';
+    metatype?: Type<any>;
+    data?: string;
+}
+interface PipeTransform<T = any, R = any> {
+    transform(value: T, metadata: ArgumentMetadata): R;
+}
+interface CanActivate {
+    canActivate(context: ExecutionContext): boolean | Promise<boolean>;
+}
+interface CallHandler<T = any> {
+    handle(): Observable<T>;
+}
+interface Interceptor<T = any, R = any> {
+    intercept(context: ExecutionContext, next: CallHandler<T>): Observable<R> | Promise<Observable<R>>;
+}
+interface OnModuleInit {
+    onModuleInit(): any;
+}
+interface OnApplicationBootstrap {
+    onApplicationBootstrap(): any;
+}
+interface OnModuleDestroy {
+    onModuleDestroy(): any;
+}
+interface BeforeApplicationShutdown {
+    beforeApplicationShutdown(signal?: string): any;
+}
+interface OnApplicationShutdown {
+    onApplicationShutdown(signal?: string): any;
+}
+type InjectionToken<T = any> = string | symbol | Type<T> | Function | ForwardReference;
+type Provider<T = any> = Type<any> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider<T>;
+interface ClassProvider<T = any> {
+    provide: InjectionToken;
+    useClass: Type<T>;
+    scope?: Scope;
+}
+interface ValueProvider<T = any> {
+    provide: InjectionToken;
+    useValue: T;
+}
+interface FactoryProvider<T = any> {
+    provide: InjectionToken;
+    useFactory: (...args: any[]) => T | Promise<T>;
+    inject?: InjectionToken[];
+    scope?: Scope;
+}
+interface ExistingProvider<T = any> {
+    provide: InjectionToken;
+    useExisting: InjectionToken;
+}
+interface DynamicModule extends ModuleOptions {
+    module: Type<any>;
+    global?: boolean;
+}
+interface ForwardReference {
+    forwardRef: () => Type<any>;
+}
+interface HonoDiMiddleware {
+    use: MiddlewareHandler;
+}
+interface MiddlewareConsumer {
+    apply(...middleware: (Type<any> | MiddlewareHandler)[]): MiddlewareConfigProxy;
+}
+interface MiddlewareConfigProxy {
+    exclude(...routes: (string | RouteInfo)[]): MiddlewareConfigProxy;
+    forRoutes(...routes: (string | Type<any> | RouteInfo)[]): MiddlewareConsumer;
+}
+interface RouteInfo {
+    path: string;
+    method: RequestMethod;
+}
+interface HonoDiModule {
+    configure(consumer: MiddlewareConsumer): void;
+}
+interface IApplication {
+    useGlobalFilters(...filters: ExceptionFilter[]): this;
+    useGlobalPipes(...pipes: PipeTransform[]): this;
+    useGlobalInterceptors(...interceptors: Interceptor[]): this;
+    useGlobalGuards(...guards: CanActivate[]): this;
+    setGlobalPrefix(prefix: string): this;
+    init(): Promise<this>;
+    listen(port: number | string, callback?: () => void): Promise<any>;
+    getHttpAdapter(): Hono;
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, options?: {
+        strict?: boolean;
+    }): TResult;
+    close(): Promise<void>;
+}
+
+export { type ArgumentsHost as A, type BeforeApplicationShutdown as B, type CanActivate as C, type DynamicModule as D, type ExceptionFilter as E, type FactoryProvider as F, type HttpArgumentsHost as H, type InjectionToken as I, type ModuleOptions as M, type OnModuleInit as O, type PipeTransform as P, RequestMethod as R, Scope as S, type Type as T, type ValueProvider as V, type Interceptor as a, type ExecutionContext as b, type ArgumentMetadata as c, type CallHandler as d, type OnApplicationBootstrap as e, type OnModuleDestroy as f, type OnApplicationShutdown as g, type Provider as h, type ClassProvider as i, type ExistingProvider as j, type ForwardReference as k, type HonoDiMiddleware as l, type MiddlewareConsumer as m, type MiddlewareConfigProxy as n, type RouteInfo as o, type HonoDiModule as p, type IApplication as q };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@hono-di/core",
+  "version": "0.0.6",
+  "description": "NestJS-style Dependency Injection for Hono",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./decorators": {
+      "types": "./dist/decorators.d.ts",
+      "import": "./dist/decorators.js",
+      "require": "./dist/decorators.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "reflect-metadata": "^0.2.2"
+  },
+  "peerDependencies": {
+    "hono": "^4",
+    "rxjs": "^7.8.2"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.4.0"
+  }
+}