@rsbuild/core 2.0.0 → 2.0.2

package/compiled/http-proxy-middleware/index.d.ts

@@ -10,7 +10,6 @@ import { HttpBindings } from '@hono/node-server';
 // @ts-ignore
 import { MiddlewareHandler } from 'hono';
 
-//#region src/types.d.ts
 interface ProxyTargetDetailed {
   host?: string;
   port?: number | string;
@@ -88,15 +87,11 @@ interface ProxyServerOptions {
   /** Buffer */
   buffer?: stream.Stream;
 }
-//#endregion
-//#region src/middleware/_utils.d.ts
 type ResOfType<T extends "web" | "ws"> = T extends "ws" ? T extends "web" ? ServerResponse | Http2ServerResponse | Socket : Socket : T extends "web" ? ServerResponse | Http2ServerResponse : never;
 type ProxyMiddleware<T extends ServerResponse | Http2ServerResponse | Socket> = (req: IncomingMessage | Http2ServerRequest, res: T, opts: ProxyServerOptions & {
   target: URL | ProxyTargetDetailed;
   forward: URL;
 }, server: ProxyServer<IncomingMessage | Http2ServerRequest, ServerResponse | Http2ServerResponse>, head?: Buffer, callback?: (err: any, req: IncomingMessage | Http2ServerRequest, socket: T, url?: any) => void) => void | true;
-//#endregion
-//#region src/server.d.ts
 interface ProxyServerEventMap<Req extends http__default.IncomingMessage | http2.Http2ServerRequest = http__default.IncomingMessage, Res extends http__default.ServerResponse | http2.Http2ServerResponse = http__default.ServerResponse> {
   error: [err: Error, req?: Req, res?: Res | net__default.Socket, target?: URL | ProxyTarget];
   start: [req: Req, res: Res, target: URL | ProxyTarget];
@@ -126,8 +121,9 @@ declare class ProxyServer<Req extends http__default.IncomingMessage | http2.Http
    * A function that wraps the object in a webserver, for your convenience
    * @param port - Port to listen on
    * @param hostname - The hostname to listen on
+   * @param listeningListener - A callback function that is called when the server starts listening
    */
-  listen(port: number, hostname?: string): this;
+  listen(port: number, hostname?: string, listeningListener?: () => void): this;
   /**
    * A function that closes the inner webserver and stops listening on given port
    */
@@ -146,7 +142,7 @@ declare class ProxyServer<Req extends http__default.IncomingMessage | http2.Http
 type NextFunction<T = (err?: any) => void> = T;
 interface RequestHandler<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse, TNext = NextFunction> {
     (req: TReq, res: TRes, next?: TNext): Promise<void>;
-    upgrade: (req: http.IncomingMessage, socket: net.Socket, head: Buffer) => void;
+    upgrade: (req: TReq, socket: net.Socket, head: Buffer) => void;
 }
 type Filter<TReq extends http.IncomingMessage = http.IncomingMessage> = string | string[] | ((pathname: string, req: TReq) => boolean);
 interface Plugin<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> {
@@ -164,6 +160,9 @@ interface OnProxyEvent<TReq extends http.IncomingMessage = http.IncomingMessage,
     econnreset?: (err: Error, req: TReq, res: TRes, target: string | Partial<URL>) => void;
 }
 type Logger = Pick<Console, 'info' | 'warn' | 'error'>;
+type PathRewriteConfig<TReq extends http.IncomingMessage = http.IncomingMessage> = {
+    [regexp: string]: string;
+} | ((path: string, req: TReq) => string | undefined) | ((path: string, req: TReq) => Promise<string>);
 interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> extends ProxyServerOptions {
     /**
      * Narrow down requests to proxy or not.
@@ -185,9 +184,7 @@ interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes
      * ```
      * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/pathRewrite.md
      */
-    pathRewrite?: {
-        [regexp: string]: string;
-    } | ((path: string, req: TReq) => string | undefined) | ((path: string, req: TReq) => Promise<string>);
+    pathRewrite?: PathRewriteConfig<TReq>;
     /**
      * Access the internal http-proxy server instance to customize behavior
      *
@@ -242,9 +239,7 @@ interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes
      * ```
      * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/router.md
      */
-    router?: {
-        [hostOrPath: string]: ProxyServerOptions['target'];
-    } | ((req: TReq) => ProxyServerOptions['target']) | ((req: TReq) => Promise<ProxyServerOptions['target']>);
+    router?: Record<string, ProxyServerOptions['target']> | ((req: TReq) => ProxyServerOptions['target']) | ((req: TReq) => Promise<ProxyServerOptions['target']>);
     /**
      * Log information from http-proxy-middleware
      * @example
@@ -259,6 +254,82 @@ interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes
     logger?: Logger;
 }
 
+/**
+ * Create proxy middleware for Express-like servers. ([list of servers with examples](https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/servers.md))
+ *
+ * @example Basic proxy to a single target.
+ * ```ts
+ * import { createProxyMiddleware } from 'http-proxy-middleware';
+ *
+ * const proxy = createProxyMiddleware({
+ *   target: 'http://www.example.org',
+ *   changeOrigin: true,
+ * });
+ * ```
+ *
+ * @example Proxy only matching paths and rewrite the forwarded path.
+ * ```ts
+ * import { createProxyMiddleware } from 'http-proxy-middleware';
+ *
+ * const proxy = createProxyMiddleware({
+ *   target: 'http://localhost:3000',
+ *   pathFilter: '/api',
+ *   pathRewrite: {
+ *     '^/api/': '/',
+ *   },
+ * });
+ * ```
+ *
+ * @example Native path rewrite by mounting at a route (alternative to `pathRewrite`).
+ * ```ts
+ * import express from 'express';
+ * import { createProxyMiddleware } from 'http-proxy-middleware';
+ *
+ * const app = express();
+ * app.use(
+ *   '/users',
+ *   createProxyMiddleware({
+ *     target: 'http://jsonplaceholder.typicode.com/users',
+ *     changeOrigin: true,
+ *   }),
+ * );
+ * ```
+ *
+ * @example Use framework-specific request/response types (Express).
+ * ```ts
+ * import type { Request, Response } from 'express';
+ * import { createProxyMiddleware } from 'http-proxy-middleware';
+ *
+ * const proxy = createProxyMiddleware<Request, Response>({
+ *   target: 'http://www.example.org/api',
+ *   changeOrigin: true,
+ * });
+ * ```
+ *
+ * @example Intercept and modify a proxied response body.
+ * ```ts
+ * import { createProxyMiddleware, responseInterceptor } from 'http-proxy-middleware';
+ *
+ * const proxy = createProxyMiddleware({
+ *   target: 'http://www.example.org',
+ *   selfHandleResponse: true,
+ *   on: {
+ *     proxyRes: responseInterceptor(async (responseBuffer) => {
+ *       const response = responseBuffer.toString('utf8');
+ *       return response.replace('Hello', 'Goodbye');
+ *     }),
+ *   },
+ * });
+ * ```
+ *
+ * @see https://github.com/chimurai/http-proxy-middleware/
+ * @see https://github.com/chimurai/http-proxy-middleware/#basic-usage
+ * @see https://github.com/chimurai/http-proxy-middleware/#intercept-and-manipulate-responses
+ * @see https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/servers.md
+ * @see https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/pathFilter.md
+ * @see https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/pathRewrite.md
+ * @see https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/response-interceptor.md
+ */
 declare function createProxyMiddleware<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse, TNext = NextFunction>(options: Options<TReq, TRes>): RequestHandler<TReq, TRes, TNext>;
 
 /**

package/compiled/http-proxy-middleware/package.json

@@ -1 +1 @@
-{"name":"http-proxy-middleware","author":"Steven Chim","version":"4.0.0-beta.3","license":"MIT","types":"index.d.ts","type":"module"}
+{"name":"http-proxy-middleware","author":"Steven Chim","version":"4.0.0-beta.5","license":"MIT","types":"index.d.ts","type":"module"}