@stacksjs/bun-router 0.0.2 → 0.0.4

package/dist/container/decorators.d.ts

@@ -1,114 +0,0 @@
-import { Container } from './container';
-import type { ResolutionContext } from './container';
-/**
- * Injectable decorator - marks a class as injectable
- */
-export declare function Injectable(metadata?: InjectableMetadata): ClassDecorator;
-/**
- * Inject decorator - specifies dependency injection for constructor parameters
- */
-export declare function Inject(token: string | symbol | Function, options?: {
-  optional?: boolean
-  tags?: string[]
-  when?: (context: ResolutionContext) => boolean
-}): ParameterDecorator;
-/**
- * Optional decorator - marks a dependency as optional
- */
-export declare function Optional(): ParameterDecorator;
-/**
- * Tagged decorator - injects services with specific tags
- */
-export declare function Tagged(tag: string): ParameterDecorator;
-/**
- * Controller decorator - marks a class as a controller
- */
-export declare function Controller(prefix?: string, options?: {
-  middleware?: Function[]
-  tags?: string[]
-}): ClassDecorator;
-/**
- * HTTP method decorators
- */
-export declare function Get(path?: string, options?: { middleware?: Function[], tags?: string[] }): MethodDecorator;
-export declare function Post(path?: string, options?: { middleware?: Function[], tags?: string[] }): MethodDecorator;
-export declare function Put(path?: string, options?: { middleware?: Function[], tags?: string[] }): MethodDecorator;
-export declare function Delete(path?: string, options?: { middleware?: Function[], tags?: string[] }): MethodDecorator;
-export declare function Patch(path?: string, options?: { middleware?: Function[], tags?: string[] }): MethodDecorator;
-export declare function Options(path?: string, options?: { middleware?: Function[], tags?: string[] }): MethodDecorator;
-export declare function Head(path?: string, options?: { middleware?: Function[], tags?: string[] }): MethodDecorator;
-/**
- * UseMiddleware decorator - applies middleware to a class or method
- */
-export declare function UseMiddleware(...middleware: Function[]): ClassDecorator & MethodDecorator;
-/**
- * Parameter decorators for route handlers
- */
-export declare function Param(key?: string): ParameterDecorator;
-export declare function Query(key?: string): ParameterDecorator;
-export declare function Body(): ParameterDecorator;
-export declare function Header(key?: string): ParameterDecorator;
-export declare function Cookie(key?: string): ParameterDecorator;
-export declare function InjectParam(token: string | symbol | Function): ParameterDecorator;
-// Metadata keys with explicit types
-export declare const INJECTABLE_METADATA_KEY: unique symbol;
-export declare const INJECT_METADATA_KEY: unique symbol;
-export declare const OPTIONAL_METADATA_KEY: unique symbol;
-export declare const TAGGED_METADATA_KEY: unique symbol;
-export declare const CONTROLLER_METADATA_KEY: unique symbol;
-export declare const ROUTE_METADATA_KEY: unique symbol;
-export declare const MIDDLEWARE_METADATA_KEY: unique symbol;
-export declare const PARAM_METADATA_KEY: unique symbol;
-// Export a default instance
-export declare const decoratorContainer: DecoratorContainer;
-// Decorator metadata interfaces
-export declare interface InjectableMetadata {
-  token?: string | symbol
-  scope?: 'singleton' | 'transient' | 'scoped' | 'request'
-  tags?: string[]
-}
-export declare interface InjectMetadata {
-  token: string | symbol | Function
-  optional?: boolean
-  tags?: string[]
-  when?: (context: ResolutionContext) => boolean
-}
-export declare interface ControllerMetadata {
-  prefix?: string
-  middleware?: Function[]
-  tags?: string[]
-}
-export declare interface RouteMetadata {
-  method: string
-  path: string
-  middleware?: Function[]
-  tags?: string[]
-}
-export declare interface ParamMetadata {
-  type: 'param' | 'query' | 'body' | 'header' | 'cookie'
-  key?: string
-  token?: string | symbol | Function
-  optional?: boolean
-  transform?: (value: any) => any
-  validate?: (value: any) => boolean
-}
-/**
- * Metadata reader utility class
- */
-export declare class MetadataReader {
-  static getInjectableMetadata(target: Function): InjectableMetadata | undefined;
-  static getInjectMetadata(target: Function): InjectMetadata[];
-  static getOptionalMetadata(target: Function): boolean[];
-  static getTaggedMetadata(target: Function): string[];
-  static getControllerMetadata(target: Function): ControllerMetadata | undefined;
-  static getAllRoutes(target: Function): any[];
-  static getMiddlewareMetadata(target: Function, propertyKey?: string | symbol): Function[];
-  static getParamMetadata(target: Function, propertyKey: string | symbol): ParamMetadata[];
-}
-/**
- * Modern Decorator Container
- */
-export declare class DecoratorContainer extends Container {
-  registerController(controllerClass: Function): void;
-  resolve<T>(token: string | symbol | Function, context?: ResolutionContext): T;
-}

package/dist/container/service-provider.d.ts

@@ -1,221 +0,0 @@
-import type { BindingBuilder, Container, ResolutionContext } from './container';
-// Service provider interfaces
-export declare interface ServiceProvider {
-  register: (container: Container) => void | Promise<void>
-  boot?: (container: Container) => void | Promise<void>
-  shutdown?: (container: Container) => void | Promise<void>
-  name: string
-  version?: string
-  dependencies?: readonly string[]
-  environment?: string[]
-  priority?: number
-}
-export declare interface DeferredServiceProvider extends ServiceProvider {
-  provides: () => (string | symbol | Function)[]
-  isDeferred: () => boolean
-}
-export declare interface ConditionalServiceProvider extends ServiceProvider {
-  shouldLoad: (container: Container) => boolean | Promise<boolean>
-}
-// Service provider manager
-export declare interface ServiceProviderManager {
-  register: (provider: ServiceProvider) => this
-  boot: () => Promise<void>
-  shutdown: () => Promise<void>
-  getProvider: (name: string) => ServiceProvider | undefined
-  getProviders: () => ServiceProvider[]
-}
-/**
- * Base service provider implementation
- */
-export declare abstract class BaseServiceProvider implements ServiceProvider {
-  abstract readonly name: string;
-  readonly version?: string;
-  readonly dependencies?: readonly string[];
-  readonly environment?: string[];
-  readonly priority: number;
-  abstract register(container: Container): void | Promise<void>;
-  boot(_container: Container): void | Promise<void>;
-  shutdown(_container: Container): void | Promise<void>;
-  protected singleton<T>(container: Container, token: string | symbol | Function, implementation: new (...args: any[]) => T): void;
-  protected transient<T>(container: Container, token: string | symbol | Function, implementation: new (...args: any[]) => T): void;
-  protected value<T>(container: Container, token: string | symbol | Function, value: T): void;
-  protected factory<T>(container: Container, token: string | symbol | Function, factory: (...args: any[]) => T): void;
-  protected when(container: Container, condition: (context: ResolutionContext) => boolean): { bind: <T>(token: string | symbol | Function) => BindingBuilder<T> };
-  protected forEnvironment(container: Container, environments: string[]): { bind: <T>(token: string | symbol | Function) => BindingBuilder<T> };
-}
-/**
- * Deferred service provider base class
- */
-export declare abstract class BaseDeferredServiceProvider extends BaseServiceProvider implements DeferredServiceProvider {
-  abstract provides(): (string | symbol | Function)[];
-  isDeferred(): boolean;
-}
-/**
- * Service provider manager implementation
- */
-export declare class DefaultServiceProviderManager implements ServiceProviderManager {
-  private providers: any;
-  private deferredProviders: any;
-  private loadedProviders: any;
-  private bootedProviders: any;
-  private container: Container;
-  constructor(container: Container);
-  register(provider: ServiceProvider): this;
-  boot(): Promise<void>;
-  shutdown(): Promise<void>;
-  getProvider(name: string): ServiceProvider | undefined;
-  getProviders(): ServiceProvider[];
-  loadDeferredProvider(token: string | symbol | Function): Promise<void>;
-  private doRegister(provider: ServiceProvider): void;
-  private loadProvider(provider: ServiceProvider): Promise<void>;
-  private bootProvider(provider: ServiceProvider): Promise<void>;
-  private validateDependencies(providers: ServiceProvider[]): void;
-  private isDeferredProvider(provider: ServiceProvider): provider is DeferredServiceProvider;
-  private isConditionalProvider(provider: ServiceProvider): provider is ConditionalServiceProvider;
-}
-/**
- * Common service providers
- */
-/**
- * Configuration service provider
- */
-export declare class ConfigServiceProvider extends BaseServiceProvider {
-  readonly name: any;
-  readonly priority: any;
-  register(container: Container): void;
-}
-/**
- * Logging service provider
- */
-export declare class LoggingServiceProvider extends BaseServiceProvider {
-  readonly name: any;
-  readonly priority: any;
-  register(container: Container): void;
-}
-/**
- * Database service provider
- */
-export declare class DatabaseServiceProvider extends BaseServiceProvider {
-  readonly name: any;
-  readonly dependencies: any;
-  register(container: Container): void;
-  boot(container: Container): Promise<void>;
-  shutdown(container: Container): Promise<void>;
-}
-/**
- * Cache service provider
- */
-export declare class CacheServiceProvider extends BaseServiceProvider {
-  readonly name: any;
-  readonly dependencies: any;
-  register(container: Container): void;
-}
-/**
- * Authentication service provider
- */
-export declare class AuthServiceProvider extends BaseServiceProvider {
-  readonly name: any;
-  readonly dependencies: any;
-  register(container: Container): void;
-}
-/**
- * Validation service provider
- */
-export declare class ValidationServiceProvider extends BaseServiceProvider {
-  readonly name: any;
-  register(container: Container): void;
-}
-/**
- * Event service provider (deferred)
- */
-export declare class EventServiceProvider extends BaseDeferredServiceProvider {
-  readonly name: any;
-  provides(): (string | symbol | Function)[];
-  register(container: Container): void;
-}
-// Mock service classes for demonstration
-declare class ConfigService {
-  get(key: string, defaultValue?: any): any;
-}
-declare class Logger {
-  private config: any;
-  constructor(config: any);
-  log(message: string): void;
-}
-declare class ConsoleLogger extends Logger {
-  constructor();
-}
-declare class FileLogger extends Logger {
-  private filePath: string;
-  constructor(filePath: string);
-}
-declare class DatabaseConnection {
-  connect(): Promise<void>;
-  disconnect(): Promise<void>;
-}
-declare class UserRepository {
-  private db: DatabaseConnection;
-  constructor(db: DatabaseConnection);
-}
-declare class PostRepository {
-  private db: DatabaseConnection;
-  constructor(db: DatabaseConnection);
-}
-declare class CacheManager {
-  private store: any;
-  constructor(store: any);
-}
-declare class MemoryCache {
-  private cache: any;
-}
-declare class RedisCache {
-  private config: any;
-  constructor(config: any);
-}
-declare class AuthService {
-  private jwt: JwtService;
-  private userRepo: UserRepository;
-  constructor(jwt: JwtService, userRepo: UserRepository);
-}
-declare class JwtService {
-  private config: ConfigService;
-  constructor(config: ConfigService);
-}
-declare class AuthGuard {
-  private auth: AuthService;
-  constructor(auth: AuthService);
-}
-declare class Validator {
-  validate(_data: any, _rules: any): boolean;
-}
-declare class ValidationPipe {
-  private validator: Validator;
-  constructor(validator: Validator);
-}
-declare class EventBus {
-  emit(_event: string, _data: any): void;
-}
-declare class EventDispatcher {
-  private bus: EventBus;
-  constructor(bus: EventBus);
-}
-export {
-  AuthGuard,
-  AuthService,
-  CacheManager,
-  ConfigService,
-  ConsoleLogger,
-  DatabaseConnection,
-  EventBus,
-  EventDispatcher,
-  FileLogger,
-  JwtService,
-  Logger,
-  MemoryCache,
-  PostRepository,
-  RedisCache,
-  UserRepository,
-  ValidationPipe,
-  Validator,
-};

package/dist/development/hot-reload.d.ts

@@ -1,129 +0,0 @@
-/**
- * Hot reload middleware for preserving server state
- */
-export declare function createHotReloadMiddleware(hotReload: HotReloadManager): void;
-/**
- * Initialize global hot reload
- */
-export declare function initializeHotReload(config?: HotReloadConfig): HotReloadManager;
-/**
- * Get global hot reload instance
- */
-export declare function getHotReload(): HotReloadManager | null;
-/**
- * Hot reload utilities
- */
-export declare const HotReloadUtils: {
-  /**
-   * Check if running in hot reload mode
-   */
-  isHotReloadEnabled: () => any;
-  /**
-   * Get current reload count
-   */
-  getReloadCount: () => any;
-  /**
-   * Create hot-reloadable module cache
-   */
-  createModuleCache: <T>() => unknown;
-  /**
-   * Create hot-reloadable configuration
-   */
-  createHotConfig: <T>(initialConfig: T, configPath?: string) => { get: ()
-};
-/**
- * Hot reload helpers for common patterns
- */
-export declare const HotReloadHelpers: {
-  /**
-   * Create hot-reloadable route handlers
-   */
-  createHotHandler: (handlerPath: string) => unknown;
-  /**
-   * Create hot-reloadable middleware
-   */
-  createHotMiddleware: (middlewarePath: string) => unknown;
-  /**
-   * Create development server with hot reload
-   */
-  createDevelopmentServer: (config: { port?: number hostname?: string hotReload?: HotReloadConfig onReload?: () => void } = {}) => unknown
-};
-/**
- * Hot reload decorators for classes and methods
- */
-export declare const HotReloadDecorators: {
-  /**
-   * Class decorator for hot-reloadable classes
-   */
-  hotReloadable: () => unknown;
-  /**
-   * Method decorator for hot-reloadable methods
-   */
-  hotMethod: (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any
-};
-/**
- * Hot reload factory functions
- */
-export declare const HotReloadFactory: {
-  /**
-   * Create development hot reload
-   */
-  createDevelopment: () => any;
-  /**
-   * Create production hot reload (disabled)
-   */
-  createProduction: () => any;
-  /**
-   * Create testing hot reload
-   */
-  createTesting: () => any
-};
-export declare interface HotReloadConfig {
-  enabled?: boolean
-  watchPaths?: string[]
-  ignorePaths?: string[]
-  extensions?: string[]
-  debounceMs?: number
-  preserveState?: boolean
-  onReload?: (changedFiles: string[]) => void
-  onError?: (error: Error) => void
-  verbose?: boolean
-}
-export declare interface HotReloadState {
-  reloadCount: number
-  lastReload: number
-  changedFiles: string[]
-  preservedState: Record<string, any>
-  watchers: Map<string, any>
-}
-/**
- * Hot reload manager for development
- */
-export declare class HotReloadManager {
-  private config: Required<HotReloadConfig>;
-  private state: HotReloadState;
-  private debounceTimer?: Timer;
-  private isReloading: any;
-  constructor(config?: HotReloadConfig);
-  private initializeState(): void;
-  private setupWatchers(): void;
-  private handleFileChange(eventType: string, filePath: string): void;
-  private shouldIgnoreFile(filePath: string): boolean;
-  private shouldWatchFile(filePath: string): boolean;
-  private triggerReload(): void;
-  preserveState<T>(key: string, value: T): void;
-  restoreState<T>(key: string, defaultValue?: T): T | undefined;
-  clearState(key?: string): void;
-  getStats(): {
-    reloadCount: number
-    lastReload: number
-    uptime: number
-    watchedPaths: string[]
-    preservedKeys: string[]
-  };
-  stop(): void;
-}
-declare namespace global {
-  var __HOT_RELOAD_STATE__: HotReloadState | undefined;
-  var __HOT_RELOAD_PRESERVE__: Record<string, any>;
-}

package/dist/development/index.d.ts

@@ -1,144 +0,0 @@
-import { PerformanceProfiler, PerformanceProfilingHelpers } from './performance-profiler';
-import { RouteDebugger, RouteDebugHelpers } from './route-debugger';
-import { RouteInspectionHelpers, RouteInspector } from './route-inspector';
-import { TypeScriptHelpers, TypeScriptUtilities } from './typescript-utilities';
-import type { EnhancedRequest } from '../types';
-export type {
-  ProfileConfig as ProfilerConfig,
-  PerformanceMetrics as ProfilerMetrics,
-  RouteProfile as ProfilerRouteProfile,
-} from './performance-profiler';
-export type {
-  RouteDebugConfig,
-  RouteDebugInfo,
-} from './route-debugger';
-export type {
-  RouteAnalysis as InspectorRouteAnalysis,
-  RouteMetadata as InspectorRouteMetadata,
-  RouteGroup,
-} from './route-inspector';
-export type {
-  TypeScriptConfig as TSConfig,
-  RouteTypeInfo as TSRouteTypeInfo,
-  TypeDefinition as TSTypeDefinition,
-  ValidationSchema as TSValidationSchema,
-} from './typescript-utilities';
-/**
- * Development presets for common configurations
- */
-export declare const DevelopmentPresets: {
-  /**
-   * Full development mode with all features enabled
-   */
-  development: () => any;
-  /**
-   * Production debugging with minimal overhead
-   */
-  production: () => any;
-  /**
-   * Performance testing configuration
-   */
-  performance: () => any;
-  /**
-   * TypeScript development configuration
-   */
-  typescript: () => any
-};
-export declare interface DevelopmentConfig {
-  debug?: {
-    enabled?: boolean
-    logLevel?: 'debug' | 'info' | 'warn' | 'error'
-    includeHeaders?: boolean
-    includeBody?: boolean
-    colorOutput?: boolean
-  }
-  profiling?: {
-    enabled?: boolean
-    sampleRate?: number
-    includeMemory?: boolean
-    includeCpu?: boolean
-  }
-  inspection?: {
-    enabled?: boolean
-    trackStats?: boolean
-    generateReports?: boolean
-  }
-  typescript?: {
-    generateTypes?: boolean
-    validateTypes?: boolean
-    generateSchemas?: boolean
-  }
-}
-/**
- * Development tools manager
- */
-export declare class DevelopmentTools {
-  private debugger: RouteDebugger;
-  private inspector: RouteInspector;
-  private profiler: PerformanceProfiler;
-  private tsUtils: TypeScriptUtilities;
-  private config: DevelopmentConfig;
-  constructor(config?: DevelopmentConfig);
-  createMiddleware(): Array<(req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>>;
-  registerRoute(method: string, pattern: string, handler: (...args: any[]) => any, middleware?: ((...args: any[]) => any)[], options?: any): string;
-  debug(): {
-    listRoutes: typeof RouteInspectionHelpers.listRoutes
-    analyzeRoutes: typeof RouteInspectionHelpers.analyzeRoutes
-    exportRoutes: typeof RouteInspectionHelpers.exportRoutes
-    getDebugSession: (requestId: string) => import('./route-debugger').RouteDebugInfo | undefined
-    clearSessions: () => void
-  };
-  routes(): {
-    list: (filter?: any) => import('./route-inspector').RouteMetadata[]
-    analyze: () => import('./route-inspector').RouteAnalysis
-    export: (format?: 'json' | 'csv' | 'markdown' | 'openapi') => string
-    groups: () => import('./route-inspector').RouteGroup[]
-    find: (method: string, path: string) => import('./route-inspector').RouteMetadata[]
-  };
-  profile(): {
-    getMetrics: () => import('./performance-profiler').PerformanceMetrics
-    getProfiles: (filter?: any) => import('./performance-profiler').RouteProfile[]
-    generateReport: () => string
-    clear: () => void
-  };
-  typescript(): {
-    generateTypes: () => string
-    generateSchemas: () => Record<string, import('./typescript-utilities').ValidationSchema>
-    generateOpenAPI: () => any
-    generateRouteBuilder: () => string
-    validateRequest: (req: EnhancedRequest, routeKey: string) => { valid: boolean, errors: string[], warnings: string[] }
-  };
-  generateReport(): string;
-  clear(): void;
-  private createInspectionMiddleware(): void;
-}
-/**
- * Router extension for development tools
- */
-export declare class DevelopmentRouter {
-  private devTools: DevelopmentTools;
-  private routes: any;
-  constructor(config?: DevelopmentConfig);
-  debug(): {
-    get: (pattern: string, handler: (...args: any[]) => any) => any
-    post: (pattern: string, handler: (...args: any[]) => any) => any
-    put: (pattern: string, handler: (...args: any[]) => any) => any
-    patch: (pattern: string, handler: (...args: any[]) => any) => any
-    delete: (pattern: string, handler: (...args: any[]) => any) => any
-  };
-  profile(): {
-    group: (callback: () => void) => void
-  };
-  getRoutes(): import('./route-inspector').RouteMetadata[];
-  private registerRoute(method: string, pattern: string, handler: (...args: any[]) => any, options?: any): void;
-}
-export {
-  PerformanceProfiler,
-  PerformanceProfilingHelpers,
-  RouteDebugger,
-  RouteDebugHelpers,
-  RouteInspectionHelpers,
-  RouteInspector,
-  TypeScriptHelpers,
-  TypeScriptUtilities,
-};