@stacksjs/bun-router 0.0.4 → 0.0.6

package/dist/cli/colors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Simple color utility for CLI output without external dependencies
+ */
+export declare const chalk: {
+    red: (text: string) => string;
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    blue: (text: string) => string;
+    cyan: (text: string) => string;
+    white: (text: string) => string;
+    gray: (text: string) => string;
+    bold: (text: string) => string;
+    dim: (text: string) => string;
+    hex: (_color: string) => (text: string) => string;
+};

package/dist/cli/index.d.ts

@@ -0,0 +1,10 @@
+import { CLI } from '@stacksjs/clapp';
+/**
+ * Create and configure the CLI
+ */
+export declare function createCLI(): CLI;
+export * from './middleware';
+export * from './openapi';
+export * from './router';
+export * from './routes';
+export * from './utils';

package/dist/cli/middleware.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Options for the middleware:types command
+ */
+export interface GenerateMiddlewareTypesOptions {
+    output?: string;
+    watch?: boolean;
+}
+/**
+ * Options for the middleware:map command
+ */
+export interface MapMiddlewareOptions {
+    output?: string;
+    dir?: string;
+    watch?: boolean;
+}
+/**
+ * Generate TypeScript types for middleware configurations
+ */
+export declare function generateMiddlewareTypes(outputPath: string): Promise<void>;
+/**
+ * Generate middleware type mappings for user project
+ */
+export declare function generateMiddlewareMap(directoryPath: string, outputPath: string): Promise<void>;
+/**
+ * Watch for changes in the directory and regenerate middleware map
+ */
+export declare function watchDirectoryForMiddleware(directoryPath: string, outputPath: string): Promise<void>;
+/**
+ * Watch for changes in the middleware directory and regenerate types
+ */
+export declare function watchMiddlewareDirectory(outputPath: string): Promise<void>;

package/dist/cli/openapi.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Options for the openapi command
+ */
+export interface OpenAPIOptions {
+    output?: string;
+    title?: string;
+    version?: string;
+    description?: string;
+    basePath?: string;
+    servers?: string;
+    tags?: boolean;
+    security?: boolean;
+}
+/**
+ * Generate OpenAPI specification for API routes
+ */
+export declare function generateOpenAPISpec(options: OpenAPIOptions): Promise<void>;

package/dist/cli/router.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Options for the router:types command
+ */
+export interface GenerateRouterTypesOptions {
+    output?: string;
+    watch?: boolean;
+}
+/**
+ * Generate TypeScript types for router extensions
+ */
+export declare function generateRouterTypes(outputPath: string): Promise<void>;
+/**
+ * Watch for changes in router files and regenerate types
+ */
+export declare function watchRouterFiles(outputPath: string): Promise<void>;

package/dist/cli/routes.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Options for the route:list command
+ */
+export interface RouteListOptions {
+    verbose?: boolean;
+    extraVerbose?: boolean;
+    path?: string;
+    exceptVendor?: boolean;
+    onlyVendor?: boolean;
+}
+/**
+ * Options for the route:types command
+ */
+export interface GenerateRouteTypesOptions {
+    output?: string;
+    watch?: boolean;
+}
+/**
+ * Display all registered routes in a formatted table
+ */
+export declare function displayRoutes(options: RouteListOptions): Promise<void>;
+/**
+ * Generate TypeScript types for route names
+ */
+export declare function generateRouteTypes(outputPath: string): Promise<void>;
+/**
+ * Watch for changes in the routes directory and regenerate types
+ */
+export declare function watchRoutesDirectory(outputPath: string): Promise<void>;

package/dist/cli/utils.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Formats console output with consistent styling
+ */
+export declare const format: {
+    success: (message: string) => string;
+    info: (message: string) => string;
+    warning: (message: string) => string;
+    error: (message: string) => string;
+    dim: (message: string) => string;
+    bold: (message: string) => string;
+};
+/**
+ * Logger for CLI commands with consistent styling
+ */
+export declare const logger: {
+    success: (message: string) => void;
+    info: (message: string) => void;
+    warning: (message: string) => void;
+    error: (message: string) => void;
+    debug: (message: string) => void;
+};
+/**
+ * Load router instance from the application
+ */
+export declare function loadRouter(): Promise<any>;
+/**
+ * Setup a debounced file watcher
+ */
+export declare function setupDebouncedWatcher(_callback: () => Promise<void>, _debounceTime?: number): {
+    timeoutId: NodeJS.Timeout | null;
+};
+/**
+ * Utility to get method color for console output
+ */
+export declare function getMethodColor(method: string): string;
+/**
+ * Pad a string to a specified length
+ */
+export declare function padString(str: string, length: number): string;
+/**
+ * Check router health and configuration
+ */
+export declare function checkRouterHealth(options: {
+    verbose?: boolean;
+}): Promise<void>;
+/**
+ * Test routes by making HTTP requests
+ */
+export declare function testRoutes(options: {
+    baseUrl?: string;
+    filter?: string;
+    method?: string;
+    timeout?: number;
+}): Promise<void>;
+/**
+ * Debug route matching for a specific path
+ */
+export declare function debugRoute(path: string, options: {
+    method?: string;
+    verbose?: boolean;
+}): Promise<void>;
+/**
+ * Clear route caches
+ */
+export declare function clearCaches(options: {
+    stats?: boolean;
+}): Promise<void>;
+/**
+ * Validate route definitions and configuration
+ */
+export declare function validateRoutes(options: {
+    strict?: boolean;
+    fix?: boolean;
+}): Promise<void>;

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   middleware
-} from "./chunk-cjdekj87.js";
+} from "./chunk-jhsk5c5b.js";
 
 // src/cli/index.ts
 import process13 from "process";
@@ -1879,7 +1879,7 @@ var prefix = getPrefix();
 var color18 = __toESM(require_picocolors(), 1);
 var import_picocolors19 = __toESM(require_picocolors(), 1);
 // package.json
-var version = "0.0.4";
+var version = "0.0.6";
 
 // src/cli/middleware.ts
 import fs from "fs/promises";

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+import type { RouterConfig } from './types';
+/**
+ * Default configuration for the router
+ */
+export declare const defaultConfig: RouterConfig;
+export declare function getConfig(): Promise<RouterConfig>;
+export declare const config: RouterConfig;

package/dist/container/container.d.ts

@@ -0,0 +1,273 @@
+/**
+ * IoC Container for Dependency Resolution
+ *
+ * Comprehensive dependency injection container with automatic resolution,
+ * lifecycle management, and contextual binding support
+ */
+declare global {
+    namespace Reflect {
+        function getMetadata(_metadataKey: any, _target: any, _propertyKey?: string | symbol): any;
+        function defineMetadata(_metadataKey: any, _metadataValue: any, _target: any, _propertyKey?: string | symbol): void;
+    }
+}
+export type BindingScope = 'singleton' | 'transient' | 'scoped' | 'request';
+export type Token = string | symbol | ((...args: any[]) => any) | (new (...args: any[]) => any) | Function;
+export interface BindingMetadata {
+    scope: BindingScope;
+    tags?: string[];
+    when?: (context: ResolutionContext) => boolean;
+    factory?: (..._args: any[]) => any;
+    dependencies?: Token[];
+    lazy?: boolean;
+    decorators?: ((..._args: any[]) => any)[];
+}
+export interface Binding<T = any> {
+    token: Token;
+    implementation?: new (...args: any[]) => T;
+    instance?: T;
+    factory?: (...args: any[]) => T;
+    value?: T;
+    metadata: BindingMetadata;
+}
+export interface ResolutionContext {
+    container: Container;
+    token: Token;
+    parent?: ResolutionContext;
+    environment?: string;
+    requestId?: string;
+    depth: number;
+    resolving: Set<Token>;
+}
+export interface ContainerOptions {
+    autoRegister?: boolean;
+    strictMode?: boolean;
+    maxDepth?: number;
+    enableDecorators?: boolean;
+    enableInterception?: boolean;
+    defaultScope?: BindingScope;
+}
+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 interface InjectableMetadata {
+    token?: string | symbol;
+    scope?: BindingScope;
+    tags?: string[];
+}
+export interface InjectMetadata {
+    token: Token;
+    optional?: boolean;
+    tags?: string[];
+    when?: (context: ResolutionContext) => boolean;
+}
+/**
+ * Main IoC Container implementation
+ */
+export declare class Container {
+    private bindings;
+    private instances;
+    private scopedInstances;
+    private interceptors;
+    private parent?;
+    private children;
+    private options;
+    constructor(options?: ContainerOptions);
+    /**
+     * Bind a token to an implementation
+     */
+    bind<T>(token: Token): BindingBuilder<T>;
+    /**
+     * Register a binding
+     */
+    register<T>(binding: Binding<T>): this;
+    /**
+     * Bind a singleton
+     */
+    singleton<T>(token: Token, implementation: new (...args: any[]) => T): Container;
+    /**
+     * Bind a transient
+     */
+    transient<T>(token: Token, implementation: new (...args: any[]) => T): Container;
+    /**
+     * Bind a value
+     */
+    value<T>(token: Token, value: T): Container;
+    /**
+     * Bind a factory
+     */
+    factory<T>(token: Token, factory: (...args: any[]) => T): Container;
+    /**
+     * Resolve a dependency
+     */
+    resolve<T>(token: Token, context?: Partial<ResolutionContext>): T;
+    /**
+     * Resolve all instances of a token (useful for arrays of services)
+     */
+    resolveAll<T>(token: Token): T[];
+    /**
+     * Resolve with tags
+     */
+    resolveTagged<T>(tag: string): T[];
+    /**
+     * Get all bindings with a specific tag
+     */
+    getTaggedBindings<T>(tag: string): Binding<T>[];
+    /**
+     * Add interceptor for a service
+     */
+    addInterceptor<T>(token: Token, interceptor: (service: T) => T): void;
+    /**
+     * Register controller (basic implementation for compatibility)
+     */
+    registerController(controller: new (...args: any[]) => any): void;
+    /**
+     * Get controller instance
+     */
+    getController<T>(controller: new (...args: any[]) => T): T;
+    /**
+     * Check if a token is bound
+     */
+    isBound(token: Token): boolean;
+    /**
+     * Unbind a token
+     */
+    unbind(token: Token): this;
+    /**
+     * Create a child container
+     */
+    createChild(options?: ContainerOptions): Container;
+    /**
+     * Create a scoped container
+     */
+    createScope(scopeId: string): Container;
+    /**
+     * Get all bindings
+     */
+    getBindings(): Map<Token, Binding>;
+    /**
+     * Clear all bindings and instances
+     */
+    clear(): this;
+    /**
+     * Add interceptor
+     */
+    intercept<T>(token: string | symbol | ((..._args: any[]) => any), interceptor: (instance: T, context: ResolutionContext) => T): this;
+    /**
+     * Internal resolution logic
+     */
+    private resolveInternal;
+    /**
+     * Create instance from binding
+     */
+    protected createInstance<T>(binding: Binding<T>, context: ResolutionContext): T;
+    /**
+     * Create new instance from binding
+     */
+    private createNewInstance;
+    /**
+     * Create instance from constructor
+     */
+    private createInstanceFromConstructor;
+    /**
+     * Get constructor dependencies using reflection
+     */
+    private getConstructorDependencies;
+    /**
+     * Parse constructor dependencies from function string
+     */
+    private parseConstructorDependencies;
+    /**
+     * Resolve array of dependencies
+     */
+    private resolveDependencies;
+    /**
+     * Auto-register and resolve
+     */
+    private autoRegisterAndResolve;
+    /**
+     * Apply decorators to instance
+     */
+    private applyDecorators;
+    /**
+     * Check if binding has tag
+     */
+    private hasTag;
+    /**
+     * Convert token to string for error messages
+     */
+    private tokenToString;
+    /**
+     * Generate unique request ID
+     */
+    private generateRequestId;
+}
+/**
+ * Fluent binding builder
+ */
+export declare class BindingBuilder<T> {
+    private container;
+    private binding;
+    constructor(container: Container, token: Token);
+    /**
+     * Bind to implementation
+     */
+    to(implementation: new (...args: any[]) => T): this;
+    /**
+     * Bind to value
+     */
+    toValue(value: T): this;
+    /**
+     * Bind to factory
+     */
+    toFactory(factory: (...args: any[]) => T): this;
+    /**
+     * Bind to existing instance
+     */
+    toInstance(instance: T): this;
+    /**
+     * Set singleton scope
+     */
+    inSingletonScope(): this;
+    /**
+     * Set transient scope
+     */
+    inTransientScope(): this;
+    /**
+     * Set scoped scope
+     */
+    inScopedScope(): this;
+    /**
+     * Set request scope
+     */
+    inRequestScope(): this;
+    /**
+     * Add tags
+     */
+    withTags(...tags: string[]): this;
+    /**
+     * Add contextual condition
+     */
+    when(condition: (context: ResolutionContext) => boolean): this;
+    /**
+     * Set as lazy
+     */
+    lazy(): this;
+    /**
+     * Build and register binding
+     */
+    build(): Container;
+}
+/**
+ * Get or create global container
+ */
+export declare function getContainer(): Container;
+/**
+ * Set global container
+ */
+export declare function setContainer(container: Container): void;
+/**
+ * Create new container
+ */
+export declare function createContainer(options?: ContainerOptions): Container;
+export { Container as DIContainer };