@stacksjs/bun-router 0.0.2 → 0.0.3

package/dist/utils/index.d.ts

@@ -1 +0,0 @@
-export * from './query-preservation';

package/dist/utils/query-preservation.d.ts

@@ -1,31 +0,0 @@
-/**
- * Generate the client-side script for query preservation
- * This script intercepts link clicks and preserves specified query params
- */
-export declare function generateQueryPreservationScript(config: QueryPreservationConfig): string;
-/**
- * Inject the query preservation script into HTML content
- * Inserts before </head> or </body> if </head> not found
- */
-export declare function injectQueryPreservationScript(html: string, config: QueryPreservationConfig): string;
-/**
- * Build a URL with preserved query parameters
- * Server-side utility for generating links
- */
-export declare function buildUrlWithPreservedParams(path: string, currentUrl: string | URL, config: QueryPreservationConfig, additionalParams?: Record<string, string>): string;
-/**
- * Default configuration
- */
-export declare const defaultQueryPreservationConfig: QueryPreservationConfig;
-/**
- * Query Parameter Preservation
- *
- * Automatically preserves specified query parameters across navigation.
- * This is useful for maintaining state like siteId, theme, locale, etc.
- */
-export declare interface QueryPreservationConfig {
-  enabled?: boolean
-  preserve?: string[]
-  exclude?: string[]
-  routes?: string[]
-}

package/dist/utils.d.ts

@@ -1,69 +0,0 @@
-import type { ActionHandler, ActionHandlerClass, RouteHandler } from './types';
-/**
- * Normalizes a path by ensuring it starts with a forward slash and has no trailing slash
- * @param path The path to normalize
- */
-export declare function normalizePath(path: string): string;
-/**
- * Converts a string path to an action path for dynamic imports
- * @param path The path to convert (e.g., 'Actions/Home/IndexAction')
- */
-export declare function toActionPath(path: string): string;
-/**
- * Checks if a handler is a class constructor implementing ActionHandlerClass
- * @param handler The handler to check
- */
-export declare function isActionClass(handler: ActionHandler): handler is new () => ActionHandlerClass;
-/**
- * Checks if a handler is a route handler function
- * @param handler The handler to check
- */
-export declare function isRouteHandler(handler: ActionHandler): handler is RouteHandler;
-/**
- * Extracts named parameters from a path pattern
- * @param pattern The path pattern (e.g., '/users/{id}/posts/{postId}')
- */
-export declare function extractParamNames(pattern: string): string[];
-/**
- * Creates a regex pattern from a path pattern
- * @param pattern The path pattern
- */
-export declare function createPathRegex(pattern: string): RegExp;
-/**
- * Matches a path against a pattern and extracts parameters
- * @param pattern The path pattern (e.g., '/users/{id}')
- * @param path The actual path (e.g., '/users/123')
- * @param params Output parameter object that will contain extracted parameters
- * @param constraints Optional constraints for route parameters
- * @returns Boolean indicating whether the path matches the pattern
- */
-export declare function matchPath(pattern: string, path: string, params: Record<string, string>, constraints?: Record<string, string>): boolean;
-/**
- * Joins path segments ensuring proper formatting
- * @param segments Path segments to join
- */
-export declare function joinPaths(...segments: string[]): string;
-/**
- * Validates a route path format
- * @param path The path to validate
- */
-export declare function validatePath(path: string): boolean;
-/**
- * Check if a file exists at the given path
- * @param path The file path to check
- */
-export declare function fileExists(path: string): Promise<boolean>;
-/**
- * Resolve a view name to an actual file path
- * @param viewName The view name (without extension)
- * @param viewsPath The base path for views
- * @param extensions File extensions to try
- */
-export declare function resolveViewPath(viewName: string, viewsPath: string, extensions: string[]): Promise<string | null>;
-/**
- * Basic HTML template processing - replaces {{ varName }} with the corresponding value
- * @param template The HTML template string
- * @param data The data to inject into the template
- */
-export declare function processHtmlTemplate(template: string, data: Record<string, any>): string;
-export * from './utils/query-preservation';

package/dist/validation/validator.d.ts

@@ -1,169 +0,0 @@
-/**
- * Validation middleware factory
- */
-export declare function createValidationMiddleware(rules: ValidationRules, config?: ValidatorConfig): void;
-/**
- * Factory function to create validation rule builder
- */
-export declare function rule(): ValidationRuleBuilder;
-/**
- * Built-in validation rules
- */
-export declare const BuiltInRules: {
-  required: { name: 'required'; validate: (value) => unknown; message: 'The :field field is required.' };
-  string: {
-  name: 'string';
-  validate: unknown;
-  message: 'The :field field must be a string.'
-};
-  number: {
-  name: 'number';
-  validate: unknown
-};
-  integer: {
-  name: 'integer';
-  validate: unknown
-};
-  boolean: {
-  name: 'boolean';
-  validate: unknown;
-  message: 'The :field field must be true or false.'
-};
-  email: { name: 'email'; validate: (value) => unknown };
-  url: { name: 'url'; validate: (value) => unknown };
-  min: { name: 'min'; validate: (value, parameters) => unknown };
-  max: { name: 'max'; validate: (value, parameters) => unknown };
-  between: { name: 'between'; validate: (value, parameters) => unknown };
-  in: { name: 'in'; validate: (value, parameters) => unknown; message: (field, parameters) => unknown };
-  notIn: { name: 'not_in'; validate: (value, parameters) => unknown; message: (field, parameters) => unknown };
-  regex: { name: 'regex'; validate: (value, parameters) => unknown };
-  alpha: {
-  name: 'alpha';
-  validate: unknown
-};
-  alphaNum: {
-  name: 'alpha_num';
-  validate: unknown
-};
-  alphaDash: {
-  name: 'alpha_dash';
-  validate: unknown
-};
-  date: { name: 'date'; validate: (value) => unknown };
-  dateAfter: { name: 'after'; validate: (value, parameters) => unknown };
-  dateBefore: { name: 'before'; validate: (value, parameters) => unknown };
-  confirmed: { name: 'confirmed'; validate: (value, parameters, field, data) => unknown };
-  same: { name: 'same'; validate: (value, parameters, field, data) => unknown };
-  different: { name: 'different'; validate: (value, parameters, field, data) => unknown; message: (field, parameters) => unknown };
-  json: { name: 'json'; validate: (value) => unknown; message: 'The :field field must be valid JSON.' };
-  uuid: { name: 'uuid'; validate: (value) => unknown };
-  array: {
-  name: 'array';
-  validate: unknown
-};
-  object: {
-  name: 'object';
-  validate: unknown
-}
-};
-/**
- * Database validation rules (require external implementation)
- */
-export declare const DatabaseRules: {
-  unique: { name: 'unique'; validate: (_value, _parameters) => unknown; message: 'The :field field must be unique.' };
-  exists: { name: 'exists'; validate: (_value, _parameters) => unknown; message: 'The selected :field is invalid.' }
-};
-/**
- * Global validator instance
- */
-export declare const globalValidator: Validator;
-/**
- * Validation helper functions
- */
-export declare const ValidationHelpers: {
-  /**
-   * Create validation rules object
-   */
-  rules(rules: Record<string, string | ValidationRuleBuilder>): unknown;
-  /**
-   * Validate single value
-   */
-  async validateValue(value: any, rules: string, field = 'value'): unknown;
-  /**
-   * Check if value passes validation
-   */
-  async passes(value: any, rules: string): unknown;
-  /**
-   * Check if value fails validation
-   */
-  async fails(value: any, rules: string): unknown
-};
-export declare interface ValidationRule {
-  name: string
-  validate: (value: any, parameters: string[], field: string, data: Record<string, any>) => Promise<boolean> | boolean
-  message: string | ((field: string, parameters: string[]) => string)
-}
-export declare interface ValidationRules {
-
-}
-export declare interface ValidationErrors {
-
-}
-export declare interface ValidatorConfig {
-  stopOnFirstFailure?: boolean
-  customMessages?: Record<string, string>
-  customAttributes?: Record<string, string>
-  bail?: boolean
-}
-/**
- * Main validator class
- */
-export declare class Validator {
-  private rules: Record<string, ValidationRule>;
-  private config: ValidatorConfig;
-  constructor(config?: ValidatorConfig);
-  registerRule(rule: ValidationRule): void;
-  registerRules(rules: Record<string, ValidationRule>): void;
-  private parseRuleString(ruleString: string): Array<{ name: string, parameters: string[] }>;
-  validate(data: Record<string, any>, rules: ValidationRules): Promise<ValidationErrors>;
-  validateOrFail(data: Record<string, any>, rules: ValidationRules): Promise<void>;
-  private getNestedValue(obj: Record<string, any>, path: string): any;
-  private formatErrorMessage(rule: ValidationRule, field: string, parameters: string[]): string;
-  private replacePlaceholders(message: string, field: string, parameters: string[]): string;
-}
-/**
- * Validation rule builder for fluent API
- */
-export declare class ValidationRuleBuilder {
-  private rules: string[];
-  required(): this;
-  string(): this;
-  number(): this;
-  integer(): this;
-  boolean(): this;
-  email(): this;
-  url(): this;
-  min(value: number): this;
-  max(value: number): this;
-  between(min: number, max: number): this;
-  in(values: string[]): this;
-  notIn(values: string[]): this;
-  regex(pattern: string): this;
-  alpha(): this;
-  alphaNum(): this;
-  alphaDash(): this;
-  date(): this;
-  after(date: string): this;
-  before(date: string): this;
-  confirmed(field?: string): this;
-  same(field: string): this;
-  different(field: string): this;
-  json(): this;
-  uuid(): this;
-  array(): this;
-  object(): this;
-  unique(table: string, column?: string): this;
-  exists(table: string, column?: string): this;
-  custom(ruleName: string, parameters: string[]): this;
-  build(): string;
-}

package/dist/websocket/clustering.d.ts

@@ -1,114 +0,0 @@
-import type { ServerWebSocket } from 'bun';
-import type { Buffer } from 'node:buffer';
-/**
- * WebSocket cluster helpers
- */
-export declare const WebSocketClusterHelpers: {
-  /**
-   * Create room-based chat system
-   */
-  createChatSystem: (cluster: WebSocketCluster) => any;
-  /**
-   * Create real-time notifications system
-   */
-  createNotificationSystem: (cluster: WebSocketCluster) => any;
-  /**
-   * Create presence system
-   */
-  createPresenceSystem: (cluster: WebSocketCluster) => any
-};
-export declare interface WebSocketClusterConfig {
-  workers?: number
-  maxConnections?: number
-  heartbeatInterval?: number
-  compression?: boolean
-  backpressureLimit?: number
-  closeOnBackpressureLimit?: boolean
-  idleTimeout?: number
-  maxPayloadLength?: number
-}
-export declare interface ClusterMessage {
-  type: 'broadcast' | 'direct' | 'join' | 'leave' | 'heartbeat' | 'stats'
-  workerId?: string
-  targetId?: string
-  roomId?: string
-  data?: any
-  timestamp: number
-}
-export declare interface WebSocketConnection {
-  id: string
-  workerId: string
-  socket: ServerWebSocket<any>
-  rooms: Set<string>
-  metadata: Record<string, any>
-  lastHeartbeat: number
-  connected: boolean
-}
-export declare interface WebSocketRoom {
-  id: string
-  connections: Set<string>
-  metadata: Record<string, any>
-  created: number
-}
-export declare interface ClusterStats {
-  totalConnections: number
-  totalRooms: number
-  workerStats: Record<string, {
-    connections: number
-    rooms: number
-    memoryUsage: number
-    uptime: number
-  }>
-  messagesSent: number
-  messagesReceived: number
-  bytesTransferred: number
-}
-/**
- * WebSocket cluster manager for distributing connections across workers
- */
-export declare class WebSocketCluster {
-  private config: Required<WebSocketClusterConfig>;
-  private workers: any;
-  private connections: any;
-  private rooms: any;
-  private messageHandlers: any;
-  private stats: ClusterStats;
-  private heartbeatTimer?: Timer;
-  private isMainWorker: boolean;
-  private workerId: string;
-  constructor(config?: WebSocketClusterConfig);
-  createServer(options?: {
-    port?: number
-    hostname?: string
-    onConnection?: (ws: ServerWebSocket<any>, request: Request) => void
-    onMessage?: (ws: ServerWebSocket<any>, message: string | Buffer) => void
-    onClose?: (ws: ServerWebSocket<any>, code?: number, reason?: string) => void
-    onError?: (ws: ServerWebSocket<any>, error: Error) => void
-  }): any;
-  joinRoom(connectionId: string, roomId: string, metadata?: Record<string, any>): boolean;
-  leaveRoom(connectionId: string, roomId: string): boolean;
-  broadcastToRoom(roomId: string, message: string | Buffer, excludeConnectionId?: string): number;
-  sendToConnection(connectionId: string, message: string | Buffer): boolean;
-  getStats(): ClusterStats;
-  getRoomConnections(roomId: string): string[];
-  getConnectionRooms(connectionId: string): string[];
-  closeConnection(connectionId: string, code?: number, reason?: string): boolean;
-  shutdown(): void;
-  private generateConnectionId(): string;
-  private generateWorkerId(): string;
-  private initializeStats(): ClusterStats;
-  private setupWorkerCommunication(): void;
-  private handleWorkerMessage(message: ClusterMessage): void;
-  private handleClusterMessage(connection: WebSocketConnection, message: ClusterMessage): void;
-  private broadcastToWorkers(message: ClusterMessage): void;
-  private startHeartbeat(): void;
-  private updateWorkerStats(): void;
-}
-/**
- * WebSocket cluster factory
- */
-export declare class WebSocketClusterFactory {
-  static create(config?: WebSocketClusterConfig): WebSocketCluster;
-  static createHighPerformance(): WebSocketCluster;
-  static createDevelopment(): WebSocketCluster;
-}