@rspack-debug/browser 2.0.0-canary-20260116 → 2.0.0-rc.0

package/dist/config/devServer.d.ts

@@ -7,32 +7,26 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack-dev-server/blob/master/LICENSE
  */
-import type * as http from 'node:http';
-import type * as net from 'node:net';
-import type * as stream from 'node:stream';
-import type * as url from 'node:url';
-import type { Compiler, LiteralUnion, MultiCompiler, MultiStats, Stats, Watching } from '..';
+import type { ReadStream } from 'node:fs';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { ServerOptions } from 'node:https';
+import type { Server as ConnectApplication, NextFunction } from 'connect-next';
+import type { Filter as ProxyFilter, Options as ProxyOptions } from 'http-proxy-middleware';
+import type { Options as OpenOptions } from 'open';
+import type { Compiler, Configuration, LiteralUnion, MultiCompiler, MultiStats, Stats, Watching } from '..';
 type Logger = ReturnType<Compiler['getInfrastructureLogger']>;
 type MultiWatching = MultiCompiler['watch'];
-type BasicServer = import('net').Server | import('tls').Server;
-type ReadStream = import('fs').ReadStream;
-type IncomingMessage = import('http').IncomingMessage;
-type ServerResponse = import('http').ServerResponse;
-type ServerOptions = import('https').ServerOptions & {
-    spdy?: {
-        plain?: boolean | undefined;
-        ssl?: boolean | undefined;
-        'x-forwarded-for'?: string | undefined;
-        protocol?: string | undefined;
-        protocols?: string[] | undefined;
-    };
+export type DevServerHost = LiteralUnion<'local-ip' | 'local-ipv4' | 'local-ipv6', string>;
+type BasicServer = import('node:net').Server | import('node:tls').Server;
+export type DevServerOpenOptions = OpenOptions & {
+    target?: string | string[];
 };
 type ResponseData = {
     data: Buffer | ReadStream;
     byteLength: number;
 };
-type ModifyResponseData<RequestInternal extends IncomingMessage = IncomingMessage, ResponseInternal extends ServerResponse = ServerResponse> = (req: RequestInternal, res: ResponseInternal, data: Buffer | ReadStream, byteLength: number) => ResponseData;
-type Headers = {
+type ModifyResponseData<Req extends IncomingMessage = IncomingMessage, Res extends ServerResponse = ServerResponse> = (req: Req, res: Res, data: Buffer | ReadStream, byteLength: number) => ResponseData;
+export type DevServerHeaders = {
     key: string;
     value: string;
 }[] | Record<string, string | string[]>;
@@ -40,7 +34,6 @@ type OutputFileSystem = import('..').OutputFileSystem & {
     statSync: import('fs').StatSyncFn;
     readFileSync: typeof import('fs').readFileSync;
 };
-type RspackConfiguration = import('..').Configuration;
 type Port = number | LiteralUnion<'auto', string>;
 type HistoryContext = {
     readonly match: RegExpMatchArray;
@@ -53,88 +46,75 @@ type Rewrite = {
     readonly to: string | RegExp | RewriteTo;
 };
 type HistoryApiFallbackOptions = {
-    readonly disableDotRule?: true | undefined;
-    readonly htmlAcceptHeaders?: readonly string[] | undefined;
-    readonly index?: string | undefined;
-    readonly logger?: typeof console.log | undefined;
-    readonly rewrites?: readonly Rewrite[] | undefined;
-    readonly verbose?: boolean | undefined;
-};
-type DevMiddlewareOptions<RequestInternal extends IncomingMessage = IncomingMessage, ResponseInternal extends ServerResponse = ServerResponse> = {
+    readonly disableDotRule?: true;
+    readonly htmlAcceptHeaders?: readonly string[];
+    readonly index?: string;
+    readonly logger?: typeof console.log;
+    readonly rewrites?: readonly Rewrite[];
+    readonly verbose?: boolean;
+};
+type DevMiddlewareOptions<Req extends IncomingMessage = IncomingMessage, Res extends ServerResponse = ServerResponse> = {
     mimeTypes?: {
         [key: string]: string;
-    } | undefined;
-    mimeTypeDefault?: string | undefined;
-    writeToDisk?: boolean | ((targetPath: string) => boolean) | undefined;
-    methods?: string[] | undefined;
+    };
+    mimeTypeDefault?: string;
+    writeToDisk?: boolean | ((targetPath: string) => boolean);
+    methods?: string[];
     headers?: any;
-    publicPath?: NonNullable<RspackConfiguration['output']>['publicPath'];
-    stats?: RspackConfiguration['stats'];
-    serverSideRender?: boolean | undefined;
-    outputFileSystem?: OutputFileSystem | undefined;
-    index?: string | boolean | undefined;
-    modifyResponseData?: ModifyResponseData<RequestInternal, ResponseInternal> | undefined;
-    etag?: 'strong' | 'weak' | undefined;
-    lastModified?: boolean | undefined;
+    publicPath?: NonNullable<Configuration['output']>['publicPath'];
+    stats?: Configuration['stats'];
+    serverSideRender?: boolean;
+    outputFileSystem?: OutputFileSystem;
+    index?: string | boolean;
+    modifyResponseData?: ModifyResponseData<Req, Res>;
+    etag?: 'strong' | 'weak';
+    lastModified?: boolean;
     cacheControl?: string | number | boolean | {
         maxAge?: number;
         immutable?: boolean;
-    } | undefined;
-    cacheImmutable?: boolean | undefined;
+    };
+    cacheImmutable?: boolean;
 };
 type BasicApplication = any;
-type BonjourServer = Record<string, any>;
 type ChokidarWatchOptions = {
     [key: string]: any;
 };
-type ServeIndexOptions = {
-    [key: string]: any;
-};
 type ServeStaticOptions = {
     [key: string]: any;
 };
-type HttpProxyMiddlewareOptionsFilter = any;
-type Request = IncomingMessage;
-type Response = ServerResponse;
 type WatchFiles = {
     paths: string | string[];
-    options?: (ChokidarWatchOptions & {
+    options?: ChokidarWatchOptions & {
         aggregateTimeout?: number;
-        ignored?: ChokidarWatchOptions['ignored'];
         poll?: number | boolean;
-    }) | undefined;
+    };
 };
-type Static = {
-    directory?: string | undefined;
-    publicPath?: string | string[] | undefined;
-    serveIndex?: boolean | ServeIndexOptions | undefined;
-    staticOptions?: ServeStaticOptions | undefined;
-    watch?: boolean | (ChokidarWatchOptions & {
-        aggregateTimeout?: number;
-        ignored?: ChokidarWatchOptions['ignored'];
-        poll?: number | boolean;
-    }) | undefined;
+export type DevServerStaticItem = {
+    directory?: string;
+    publicPath?: string | string[];
+    staticOptions?: ServeStaticOptions;
+    watch?: boolean | NonNullable<WatchFiles['options']>;
 };
-type ServerType<A extends BasicApplication = BasicApplication, S extends BasicServer = import('http').Server<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>> = LiteralUnion<'http' | 'https' | 'spdy' | 'http2', string> | ((arg0: ServerOptions, arg1: A) => S);
-type ServerConfiguration<A extends BasicApplication = BasicApplication, S extends BasicServer = import('http').Server<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>> = {
-    type?: ServerType<A, S> | undefined;
-    options?: ServerOptions | undefined;
+export type DevServerStatic = string | boolean | DevServerStaticItem | (string | DevServerStaticItem)[];
+type ServerType<A extends BasicApplication, S extends BasicServer> = LiteralUnion<'http' | 'https' | 'http2', string> | ((arg0: ServerOptions, arg1: A) => S);
+type ServerConfiguration<A extends BasicApplication, S extends BasicServer> = {
+    type?: ServerType<A, S>;
+    options?: ServerOptions;
 };
 type WebSocketServerConfiguration = {
-    type?: string | Function | undefined;
-    options?: Record<string, any> | undefined;
-};
-type NextFunction = (err?: any) => void;
-type ProxyConfigArrayItem = {
-    path?: HttpProxyMiddlewareOptionsFilter;
-    context?: HttpProxyMiddlewareOptionsFilter;
-} & {
-    bypass?: ByPass;
-} & HttpProxyMiddlewareOptions;
-type ByPass = (req: Request, res: Response, proxyConfig: ProxyConfigArrayItem) => any;
-type ProxyConfigArray = (ProxyConfigArrayItem | ((req?: Request, res?: Response, next?: NextFunction) => ProxyConfigArrayItem))[];
+    type?: string | Function;
+    options?: Record<string, any>;
+};
+export type DevServerProxyConfigArrayItem = {
+    /**
+     * Alias for `pathFilter` in `http-proxy-middleware` options.
+     * When both `context` and `pathFilter` are provided, `pathFilter` takes precedence.
+     */
+    context?: ProxyFilter;
+} & ProxyOptions;
+export type DevServerProxyConfigArray = (DevServerProxyConfigArrayItem | ((req?: IncomingMessage, res?: ServerResponse, next?: NextFunction) => DevServerProxyConfigArrayItem))[];
 type Callback = (stats?: Stats | MultiStats) => any;
-type DevMiddlewareContext<_RequestInternal extends IncomingMessage = IncomingMessage, _ResponseInternal extends ServerResponse = ServerResponse> = {
+type DevMiddlewareContext = {
     state: boolean;
     stats: Stats | MultiStats | undefined;
     callbacks: Callback[];
@@ -144,171 +124,56 @@ type DevMiddlewareContext<_RequestInternal extends IncomingMessage = IncomingMes
     logger: Logger;
     outputFileSystem: OutputFileSystem;
 };
-type Server = any;
-export type MiddlewareHandler<RequestInternal extends Request = Request, ResponseInternal extends Response = Response> = (req: RequestInternal, res: ResponseInternal, next: NextFunction) => void | Promise<void>;
-type MiddlewareObject<RequestInternal extends Request = Request, ResponseInternal extends Response = Response> = {
+export type DevServerMiddlewareHandler<Req extends IncomingMessage = IncomingMessage, Res extends ServerResponse = ServerResponse> = (req: Req, res: Res, next: NextFunction) => void | Promise<void>;
+export type DevServerMiddlewareErrorHandler<Req extends IncomingMessage = IncomingMessage, Res extends ServerResponse = ServerResponse> = (error: any, req: Req, res: Res, next: NextFunction) => void | Promise<void>;
+export type DevServerMiddlewareObject<Req extends IncomingMessage = IncomingMessage, Res extends ServerResponse = ServerResponse> = {
     name?: string;
     path?: string;
-    middleware: MiddlewareHandler<RequestInternal, ResponseInternal>;
-};
-export type Middleware<RequestInternal extends Request = Request, ResponseInternal extends Response = Response> = MiddlewareObject<RequestInternal, ResponseInternal> | MiddlewareHandler<RequestInternal, ResponseInternal>;
-type OpenApp = {
-    name?: string | undefined;
-    arguments?: string[] | undefined;
-};
-type Open = {
-    app?: string | string[] | OpenApp | undefined;
-    target?: string | string[] | undefined;
+    middleware: DevServerMiddlewareHandler<Req, Res> | DevServerMiddlewareErrorHandler<Req, Res>;
 };
+export type DevServerMiddleware = DevServerMiddlewareObject | DevServerMiddlewareHandler | DevServerMiddlewareErrorHandler;
 type OverlayMessageOptions = boolean | ((error: Error) => void);
-type WebSocketURL = {
-    hostname?: string | undefined;
-    password?: string | undefined;
-    pathname?: string | undefined;
-    port?: string | number | undefined;
-    protocol?: string | undefined;
-    username?: string | undefined;
-};
-type ClientConfiguration = {
-    logging?: 'none' | 'error' | 'warn' | 'info' | 'log' | 'verbose' | undefined;
+export type DevServerWebSocketURL = {
+    hostname?: string;
+    password?: string;
+    pathname?: string;
+    port?: string | number;
+    protocol?: string;
+    username?: string;
+};
+export type DevServerClient = {
+    logging?: 'none' | 'error' | 'warn' | 'info' | 'log' | 'verbose';
     overlay?: boolean | {
         warnings?: OverlayMessageOptions;
         errors?: OverlayMessageOptions;
         runtimeErrors?: OverlayMessageOptions;
-    } | undefined;
-    progress?: boolean | undefined;
-    reconnect?: number | boolean | undefined;
-    webSocketTransport?: string | undefined;
-    webSocketURL?: string | WebSocketURL | undefined;
-};
-export type DevServerOptions<A extends BasicApplication = BasicApplication, S extends BasicServer = import('http').Server<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>> = {
-    ipc?: string | boolean | undefined;
-    host?: string | undefined;
-    port?: Port | undefined;
-    hot?: boolean | 'only' | undefined;
-    liveReload?: boolean | undefined;
-    devMiddleware?: DevMiddlewareOptions | undefined;
-    compress?: boolean | undefined;
-    allowedHosts?: string | string[] | undefined;
-    historyApiFallback?: boolean | HistoryApiFallbackOptions | undefined;
-    bonjour?: boolean | BonjourServer | undefined;
-    watchFiles?: string | string[] | WatchFiles | (string | WatchFiles)[] | undefined;
-    static?: string | boolean | Static | (string | Static)[] | undefined;
-    server?: ServerType<A, S> | ServerConfiguration<A, S> | undefined;
-    app?: (() => Promise<A>) | undefined;
-    webSocketServer?: string | boolean | WebSocketServerConfiguration | undefined;
-    proxy?: ProxyConfigArray | undefined;
-    open?: string | boolean | Open | (string | Open)[] | undefined;
-    setupExitSignals?: boolean | undefined;
-    client?: boolean | ClientConfiguration | undefined;
-    headers?: Headers | ((req: Request, res: Response, context: DevMiddlewareContext | undefined) => Headers) | undefined;
-    onListening?: ((devServer: Server) => void) | undefined;
-    setupMiddlewares?: ((middlewares: Middleware[], devServer: Server) => Middleware[]) | undefined;
+    };
+    progress?: boolean;
+    reconnect?: number | boolean;
+    webSocketTransport?: LiteralUnion<'ws', string>;
+    webSocketURL?: string | DevServerWebSocketURL;
+};
+export type DevServerOptions<A extends BasicApplication = ConnectApplication, S extends BasicServer = BasicServer> = {
+    ipc?: string | boolean;
+    host?: DevServerHost;
+    port?: Port;
+    hot?: boolean | 'only';
+    liveReload?: boolean;
+    devMiddleware?: DevMiddlewareOptions;
+    compress?: boolean;
+    allowedHosts?: LiteralUnion<'auto' | 'all', string> | string[];
+    historyApiFallback?: boolean | HistoryApiFallbackOptions;
+    watchFiles?: string | string[] | WatchFiles | (string | WatchFiles)[];
+    static?: DevServerStatic;
+    server?: ServerType<A, S> | ServerConfiguration<A, S>;
+    app?: () => Promise<A>;
+    webSocketServer?: boolean | LiteralUnion<'ws', string> | WebSocketServerConfiguration;
+    proxy?: DevServerProxyConfigArray;
+    open?: string | boolean | DevServerOpenOptions | (string | DevServerOpenOptions)[];
+    setupExitSignals?: boolean;
+    client?: boolean | DevServerClient;
+    headers?: DevServerHeaders | ((req: IncomingMessage, res: ServerResponse, context: DevMiddlewareContext | undefined) => DevServerHeaders);
+    onListening?: (devServer: any) => void;
+    setupMiddlewares?: (middlewares: DevServerMiddleware[], devServer: any) => DevServerMiddleware[];
 };
-interface HttpProxyMiddlewareOptions extends HttpProxyServerOptions {
-    pathRewrite?: {
-        [regexp: string]: string;
-    } | ((path: string, req: Request) => string) | ((path: string, req: Request) => Promise<string>);
-    router?: {
-        [hostOrPath: string]: HttpProxyServerOptions['target'];
-    } | ((req: Request) => HttpProxyServerOptions['target']) | ((req: Request) => Promise<HttpProxyServerOptions['target']>);
-    logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent';
-    logProvider?: LogProviderCallback;
-    onError?: OnErrorCallback;
-    onProxyRes?: OnProxyResCallback;
-    onProxyReq?: OnProxyReqCallback;
-    onProxyReqWs?: OnProxyReqWsCallback;
-    onOpen?: OnOpenCallback;
-    onClose?: OnCloseCallback;
-}
-interface LogProvider {
-    log: Logger;
-    debug?: Logger;
-    info?: Logger;
-    warn?: Logger;
-    error?: Logger;
-}
-type LogProviderCallback = (provider: LogProvider) => LogProvider;
-type OnErrorCallback = (err: Error, req: Request, res: Response, target?: string | Partial<url.Url>) => void;
-type OnProxyResCallback = (proxyRes: http.IncomingMessage, req: Request, res: Response) => void;
-type OnProxyReqCallback = (proxyReq: http.ClientRequest, req: Request, res: Response, options: HttpProxyServerOptions) => void;
-type OnProxyReqWsCallback = (proxyReq: http.ClientRequest, req: Request, socket: net.Socket, options: HttpProxyServerOptions, head: any) => void;
-type OnCloseCallback = (proxyRes: Response, proxySocket: net.Socket, proxyHead: any) => void;
-type OnOpenCallback = (proxySocket: net.Socket) => void;
-interface HttpProxyServerOptions {
-    /** URL string to be parsed with the url module. */
-    target?: HttpProxyTarget | undefined;
-    /** URL string to be parsed with the url module. */
-    forward?: HttpProxyTargetUrl | undefined;
-    /** Object to be passed to http(s).request. */
-    agent?: any;
-    /** Object to be passed to https.createServer(). */
-    ssl?: any;
-    /** If you want to proxy websockets. */
-    ws?: boolean | undefined;
-    /** Adds x- forward headers. */
-    xfwd?: boolean | undefined;
-    /** Verify SSL certificate. */
-    secure?: boolean | undefined;
-    /** Explicitly specify if we are proxying to another proxy. */
-    toProxy?: boolean | undefined;
-    /** Specify whether you want to prepend the target's path to the proxy path. */
-    prependPath?: boolean | undefined;
-    /** Specify whether you want to ignore the proxy path of the incoming request. */
-    ignorePath?: boolean | undefined;
-    /** Local interface string to bind for outgoing connections. */
-    localAddress?: string | undefined;
-    /** Changes the origin of the host header to the target URL. */
-    changeOrigin?: boolean | undefined;
-    /** specify whether you want to keep letter case of response header key */
-    preserveHeaderKeyCase?: boolean | undefined;
-    /** Basic authentication i.e. 'user:password' to compute an Authorization header. */
-    auth?: string | undefined;
-    /** Rewrites the location hostname on (301 / 302 / 307 / 308) redirects, Default: null. */
-    hostRewrite?: string | undefined;
-    /** Rewrites the location host/ port on (301 / 302 / 307 / 308) redirects based on requested host/ port.Default: false. */
-    autoRewrite?: boolean | undefined;
-    /** Rewrites the location protocol on (301 / 302 / 307 / 308) redirects to 'http' or 'https'.Default: null. */
-    protocolRewrite?: string | undefined;
-    /** rewrites domain of set-cookie headers. */
-    cookieDomainRewrite?: false | string | {
-        [oldDomain: string]: string;
-    } | undefined;
-    /** rewrites path of set-cookie headers. Default: false */
-    cookiePathRewrite?: false | string | {
-        [oldPath: string]: string;
-    } | undefined;
-    /** object with extra headers to be added to target requests. */
-    headers?: {
-        [header: string]: string;
-    } | undefined;
-    /** Timeout (in milliseconds) when proxy receives no response from target. Default: 120000 (2 minutes) */
-    proxyTimeout?: number | undefined;
-    /** Timeout (in milliseconds) for incoming requests */
-    timeout?: number | undefined;
-    /** Specify whether you want to follow redirects. Default: false */
-    followRedirects?: boolean | undefined;
-    /** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
-    selfHandleResponse?: boolean | undefined;
-    /** Buffer */
-    buffer?: stream.Stream | undefined;
-    /** Explicitly set the method type of the ProxyReq */
-    method?: string | undefined;
-}
-interface HttpProxyTargetDetailed {
-    host: string;
-    port: number;
-    protocol?: string | undefined;
-    hostname?: string | undefined;
-    socketPath?: string | undefined;
-    key?: string | undefined;
-    passphrase?: string | undefined;
-    pfx?: Buffer | string | undefined;
-    cert?: string | undefined;
-    ca?: string | undefined;
-    ciphers?: string | undefined;
-    secureProtocol?: string | undefined;
-}
-type HttpProxyTarget = HttpProxyTargetUrl | HttpProxyTargetDetailed;
-type HttpProxyTargetUrl = string | Partial<url.Url>;
 export {};

package/dist/config/normalization.d.ts

@@ -76,7 +76,6 @@ export interface ModuleOptionsNormalized {
     parser: ParserOptionsByModuleType;
     generator: GeneratorOptionsByModuleType;
     noParse?: NoParseOption;
-    unsafeCache?: boolean | RegExp;
 }
 export type CacheNormalized = boolean | {
     type: 'memory';
@@ -93,12 +92,11 @@ export type CacheNormalized = boolean | {
         type: 'filesystem';
         directory: string;
     };
+    portable?: boolean;
 };
 export interface ExperimentsNormalized {
     asyncWebAssembly?: boolean;
-    outputModule?: boolean;
     css?: boolean;
-    incremental?: false | Incremental;
     futureDefaults?: boolean;
     buildHttp?: HttpUriPluginOptions;
     useInputFileSystem?: false | RegExp[];
@@ -136,6 +134,7 @@ export interface RspackOptionsNormalized {
     plugins: Plugins;
     experiments: ExperimentsNormalized;
     lazyCompilation?: false | LazyCompilationOptions;
+    incremental?: false | Incremental;
     watch?: Watch;
     watchOptions: WatchOptions;
     devServer?: DevServer;

package/dist/config/target.d.ts

@@ -1,3 +1,12 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/config/target.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
 /**
  * @param context the context directory
  * @returns default target
@@ -73,21 +82,15 @@ export type EcmaTargetProperties = {
     /**  async functions and await are available */
     asyncFunction: boolean | null;
 };
+export type ExtractedTargetProperties = {
+    esVersion?: number | null;
+    targets?: Record<string, string> | null;
+};
 type Never<T> = {
     [P in keyof T]?: never;
 };
 type Mix<A, B> = (A & Never<B>) | (Never<A> & B) | (A & B);
-export type TargetProperties = Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>;
-/**
- * @param target the target
- * @param context the context directory
- * @returns target properties
- */
+export type TargetProperties = Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>> & ExtractedTargetProperties;
 export declare const getTargetProperties: (target: string, context: string) => TargetProperties;
-/**
- * @param targets the targets
- * @param context the context directory
- * @returns target properties
- */
 export declare const getTargetsProperties: (targets: string[], context: string) => TargetProperties;
 export {};