weifuwu 0.30.1 → 0.31.0

package/dist/core/router.d.ts

@@ -1,30 +1,17 @@
-import type { WebSocket, Context, Handler, Middleware, ErrorHandler } from '../types.ts';
-import { type IncomingMessage } from 'node:http';
-import type { Duplex } from 'node:stream';
+import type { Context, Handler, Middleware, ErrorHandler } from '../types.ts';
 import { type Hub } from '../hub.ts';
+import { type WebSocketHandler, type WsUpgradeHandler } from './ws.ts';
 declare module '../types.ts' {
     interface Context {
         ws: {
-            /** Per-connection state object */
             state: Record<string, unknown>;
-            /** Send JSON to this connection */
             json(data: unknown): void;
-            /** Join a room */
             join(room: string): void;
-            /** Leave a room */
             leave(room: string): void;
-            /** Broadcast to a room */
             sendRoom(room: string, data: unknown): void;
         };
     }
 }
-export type WebSocketHandler = {
-    open?: (ws: WebSocket, ctx: Context) => void | Promise<void>;
-    message?: (ws: WebSocket, ctx: Context, data: string | Buffer) => void | Promise<void>;
-    close?: (ws: WebSocket, ctx: Context) => void | Promise<void>;
-    error?: (ws: WebSocket, ctx: Context, error: Error) => void | Promise<void>;
-};
-type WsUpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
 export declare class Router<T extends Context = Context> {
     private root;
     private wsRoot;
@@ -33,63 +20,39 @@ export declare class Router<T extends Context = Context> {
     private _hasWildcard;
     private _hub?;
     private _wss?;
-    /** Track which ctx fields have been injected so far (for dependency checking). */
     private _ctxFields;
     private get wss();
     private get hub();
-    /** Inject a custom hub (e.g. with Redis for cross-process broadcast). */
     wsHub(hub: Hub): this;
-    /** Global middleware — accumulates types into Router<T>. */
-    use<Out extends Context>(mw: Middleware<Context, Out>): Router<T & Out>;
-    /**
-     * Mount a sub-router at the given path prefix.
-     * All routes from the sub-router are registered with the prefix.
-     *
-     * ```ts
-     * const admin = new Router()
-     * admin.get('/dashboard', handler)
-     * app.mount('/admin', admin)  // → GET /admin/dashboard
-     * ```
-     */
+    use(mw: Middleware<Context, Context>): Router<T>;
     mount(path: string, router: Router<Context>): Router<T>;
-    /**
-     * Check a middleware's dependency metadata and emit warnings if
-     * required fields haven't been injected yet.
-     * Attach __meta to a middleware function:
-     *
-     * ```ts
-     * mw.__meta = { injects: ['sql'], depends: ['session'] }
-     * ```
-     */
-    private _checkMiddlewareMeta;
-    get(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    post(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    put(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    delete(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    patch(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    head(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    options(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    all(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
     onError(handler: ErrorHandler<T>): Router<T>;
-    private _route;
-    /** Internal route registration — no type constraints (used by _mountRouter). */
-    private _routeImpl;
-    ws(path: string, ...args: [...Middleware<T, T>[], WebSocketHandler]): Router<T>;
+    get(path: string, ...rest: [...Middleware[], Handler | Router<Context>]): Router<T>;
+    post(path: string, ...rest: [...Middleware[], Handler | Router<Context>]): Router<T>;
+    put(path: string, ...rest: [...Middleware[], Handler | Router<Context>]): Router<T>;
+    delete(path: string, ...rest: [...Middleware[], Handler | Router<Context>]): Router<T>;
+    patch(path: string, ...rest: [...Middleware[], Handler | Router<Context>]): Router<T>;
+    head(path: string, ...rest: [...Middleware[], Handler | Router<Context>]): Router<T>;
+    options(path: string, ...rest: [...Middleware[], Handler | Router<Context>]): Router<T>;
+    all(path: string, ...rest: [...Middleware[], Handler | Router<Context>]): Router<T>;
+    ws(path: string, ...args: [...Middleware[], WebSocketHandler]): Router<T>;
     handler(): Handler<T>;
-    /** Returns a human-readable list of all registered routes. Useful for debugging. */
-    routes(): string[];
-    private _collectRoutes;
-    private _collectWsRoutes;
     websocketHandler(): WsUpgradeHandler;
+    routes(): string[];
+    private _route;
+    private _routeImpl;
     private _mountRouter;
     private _collect;
     private _collectWs;
     private splitPath;
+    private _collectRoutes;
+    private _collectWsRoutes;
     private matchTrie;
+    private _wildcardMatch;
+    private _resolveMatch;
     private matchWsTrie;
-    private handleError;
-    private _notFoundResponse;
     private handle;
+    private handleError;
     private runChain;
+    private _checkMiddlewareMeta;
 }
-export {};

package/dist/core/serve.d.ts

@@ -29,8 +29,4 @@ export declare function createRequest(req: IncomingMessage, body: Buffer): [Requ
 export declare function sendResponse(res: ServerResponse, response: Response, opts?: {
     traceId?: string | null;
 }): Promise<void>;
-export declare function createTestServer(router: Router, options?: ServeOptions): Promise<{
-    server: Server;
-    url: string;
-}>;
 export declare function serve(router: Router, options?: ServeOptions): Server;

package/dist/core/ws.d.ts

@@ -0,0 +1,28 @@
+/**
+ * WebSocket upgrade + connection lifecycle.
+ *
+ * Handles the HTTP-to-WS upgrade and per-connection state.
+ * Used internally by Router — not exported to end users.
+ */
+import { WebSocketServer } from 'ws';
+import type { WebSocket, Context, Handler, Middleware } from '../types.ts';
+import type { IncomingMessage } from 'node:http';
+import type { Duplex } from 'node:stream';
+import { type Hub } from '../hub.ts';
+/** WebSocket lifecycle handler. */
+export type WebSocketHandler = {
+    open?: (ws: WebSocket, ctx: Context) => void | Promise<void>;
+    message?: (ws: WebSocket, ctx: Context, data: string | Buffer) => void | Promise<void>;
+    close?: (ws: WebSocket, ctx: Context) => void | Promise<void>;
+    error?: (ws: WebSocket, ctx: Context, error: Error) => void | Promise<void>;
+};
+export type WsUpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
+export declare function nodeReqHeadersToRecord(headers: IncomingMessage['headers']): Record<string, string>;
+export declare function upgradeSocket(wss: WebSocketServer, req: IncomingMessage, socket: Duplex, head: Buffer, handler: WebSocketHandler, ctx: Context, hub: Hub): void;
+type WsMatch = {
+    handler: WebSocketHandler;
+    middlewares: Middleware[];
+    params: Record<string, string>;
+};
+export declare function createWsUpgradeHandler(wss: WebSocketServer, hub: Hub, matchWsFn: (segments: string[]) => WsMatch | null, globalMws: Middleware[], runChainFn: (mws: Middleware[], h: Handler, req: Request, ctx: Context) => Promise<Response>): WsUpgradeHandler;
+export {};

package/dist/index.d.ts

@@ -2,21 +2,16 @@ export type { Context, Handler, Middleware, ErrorHandler, WsContext, WebSocket }
 export { HttpError } from './types.ts';
 export { currentTraceId, currentTrace, runWithTrace, traceElapsed, trace } from './core/trace.ts';
 export type { TraceContext, TraceInjected, TraceOptions } from './core/trace.ts';
-export { loadEnv, isDev, isProd, isBundled, getPublicEnv, env } from './core/env.ts';
-export { serve, createTestServer, DEFAULT_MAX_BODY } from './core/serve.ts';
+export { serve, DEFAULT_MAX_BODY } from './core/serve.ts';
 export type { ServeOptions, Server } from './core/serve.ts';
 export { Router } from './core/router.ts';
-export type { WebSocketHandler } from './core/router.ts';
+export type { WebSocketHandler } from './core/ws.ts';
 export { logger } from './core/logger.ts';
 export type { LoggerOptions } from './core/logger.ts';
 export { cors } from './middleware/cors.ts';
 export type { CORSOptions } from './middleware/cors.ts';
 export { serveStatic } from './middleware/static.ts';
 export type { ServeStaticOptions } from './middleware/static.ts';
-export { validate } from './middleware/validate.ts';
-export type { ValidationSchemas, ValidateModule } from './middleware/validate.ts';
-export { getCookies, setCookie, deleteCookie } from './core/cookie.ts';
-export type { CookieOptions } from './core/cookie.ts';
 export { upload } from './middleware/upload.ts';
 export type { UploadOptions, UploadedFile, UploadModule } from './middleware/upload.ts';
 export { rateLimit } from './middleware/rate-limit.ts';
@@ -25,12 +20,6 @@ export { compress } from './middleware/compress.ts';
 export type { CompressOptions } from './middleware/compress.ts';
 export { helmet } from './middleware/helmet.ts';
 export type { HelmetOptions } from './middleware/helmet.ts';
-export { requestId } from './middleware/request-id.ts';
-export type { RequestIdOptions, RequestIdModule } from './middleware/request-id.ts';
-export { createSSEStream, formatSSE, formatSSEData } from './core/sse.ts';
-export type { SSEEvent } from './core/sse.ts';
-export { testApp, TestApp, TestRequest, createTestDb, withTestDb } from './test/test-utils.ts';
-export type { TestResponse, TestDb } from './test/test-utils.ts';
 export { graphql } from './graphql.ts';
 export type { GraphQLOptions, GraphQLHandler } from './graphql.ts';
 export { postgres, MIGRATIONS_TABLE } from './postgres/index.ts';
@@ -41,14 +30,10 @@ export { createHub } from './hub.ts';
 export type { Hub, HubOptions } from './hub.ts';
 export { queue } from './queue/index.ts';
 export type { QueueOptions, QueueJob, Queue, QueueInjected } from './queue/types.ts';
-export { health } from './middleware/health.ts';
-export type { HealthOptions } from './middleware/health.ts';
-export { html, raw } from './core/html.ts';
-export { theme } from './middleware/theme.ts';
-export type { ThemeOptions, ThemeInjected, ThemeModule } from './middleware/theme.ts';
-export { i18n } from './middleware/i18n.ts';
-export type { I18nOptions, I18nInjected, I18nModule } from './middleware/i18n.ts';
-export { flash } from './middleware/flash.ts';
-export type { FlashOptions, FlashInjected, FlashModule } from './middleware/flash.ts';
-export { csrf } from './middleware/csrf.ts';
-export type { CsrfOptions, CsrfInjected, CsrfModule } from './middleware/csrf.ts';
+export { react } from './react/index.ts';
+export type { ReactOptions, RenderOptions, ReactInjected } from './react/types.ts';
+export { useServerData, ServerDataContext } from './react/index.ts';
+export { Link, useParams, useNavigate, useRevalidate, Form, useNavigation } from './react/index.ts';
+export type { LinkProps, FormProps, NavigationState } from './react/index.ts';
+export { ErrorBoundary } from './react/index.ts';
+export type { ErrorBoundaryProps } from './react/index.ts';