@rspack/dev-server 2.0.0-rc.0 → 2.0.0-rc.2

package/dist/index.d.ts

@@ -1,2 +1,587 @@
-export { Server as RspackDevServer } from './server.js';
-export type { DevServer as Configuration } from '@rspack/core';
+import { API } from '@rspack/dev-middleware';
+import { Callback } from '@rspack/dev-middleware';
+import { Compiler } from '@rspack/core';
+import { DevServer as Configuration } from '@rspack/core';
+import { Context } from '@rspack/dev-middleware';
+import type { DevServerClient } from '@rspack/core';
+import type { DevServerHeaders } from '@rspack/core';
+import type { DevServerHost } from '@rspack/core';
+import type { DevServerMiddlewareHandler } from '@rspack/core';
+import type { DevServerOpenOptions } from '@rspack/core';
+import type { DevServerProxyConfigArray } from '@rspack/core';
+import type { DevServerStatic } from '@rspack/core';
+import type { Dirent } from 'node:fs';
+import { EventEmitter } from 'node:events';
+import * as http from 'node:http';
+import type { IncomingMessage as IncomingMessage_2 } from 'node:http';
+import type { ListenOptions } from 'node:net';
+import { MultiCompiler } from '@rspack/core';
+import { MultiStats } from '@rspack/core';
+import { Options } from '@rspack/dev-middleware';
+import { Readable } from 'node:stream';
+import { Server as Server_2 } from 'node:net';
+import { Server as Server_3 } from 'node:tls';
+import type { Server as Server_4 } from 'node:http';
+import type { ServerOptions } from 'node:https';
+import type { ServerResponse } from 'node:http';
+import { Socket } from 'node:net';
+import { Stats } from 'node:fs';
+import { Stats as Stats_2 } from '@rspack/core';
+import { StatsOptions } from '@rspack/core';
+import type { WatchEventType } from 'node:fs';
+import { WebSocket as WebSocket_2 } from 'ws';
+import { WebSocketServer as WebSocketServer_2 } from 'ws';
+
+declare type AWF = {
+    stabilityThreshold: number;
+    pollInterval: number;
+};
+
+declare type BasicApplication = {
+    use: UseFn;
+};
+
+declare type BasicOpts = {
+    persistent: boolean;
+    ignoreInitial: boolean;
+    followSymlinks: boolean;
+    cwd?: string;
+    usePolling: boolean;
+    interval: number;
+    binaryInterval: number;
+    alwaysStat?: boolean;
+    depth?: number;
+    ignorePermissionErrors: boolean;
+    atomic: boolean | number;
+};
+
+declare type BasicServer = Server_2 | Server_3;
+
+declare type ChokidarOptions = Partial<BasicOpts & {
+    ignored: Matcher | Matcher[];
+    awaitWriteFinish: boolean | Partial<AWF>;
+}>;
+
+declare type ClientConnection = WebSocket_2 & {
+    isAlive?: boolean;
+};
+
+export { Configuration }
+
+declare interface Configuration_2<A extends BasicApplication = Server, S extends BasicServer = Server_4> {
+    ipc?: boolean | string;
+    host?: DevServerHost;
+    port?: Port;
+    hot?: boolean | 'only';
+    liveReload?: boolean;
+    devMiddleware?: DevMiddlewareOptions<Request_2, Response_2>;
+    compress?: boolean;
+    allowedHosts?: LiteralUnion<'auto' | 'all', string> | string[];
+    historyApiFallback?: boolean | ConnectHistoryApiFallbackOptions;
+    watchFiles?: string | string[] | WatchFiles | Array<string | WatchFiles>;
+    static?: DevServerStatic;
+    server?: ServerType<A, S> | ServerConfiguration<A, S>;
+    app?: () => Promise<A>;
+    webSocketServer?: boolean | LiteralUnion<'ws', string> | WebSocketServerConfiguration;
+    proxy?: DevServerProxyConfigArray;
+    open?: boolean | string | Open | Array<string | Open>;
+    setupExitSignals?: boolean;
+    client?: boolean | DevServerClient;
+    headers?: DevServerHeaders | ((req: Request_2, res: Response_2, context: DevMiddlewareContext<Request_2, Response_2> | undefined) => DevServerHeaders);
+    onListening?: (devServer: RspackDevServer<A, S>) => void;
+    setupMiddlewares?: (middlewares: Middleware[], devServer: RspackDevServer<A, S>) => Middleware[];
+}
+
+declare type ConnectHistoryApiFallbackOptions = Exclude<NonNullable<Configuration['historyApiFallback']>, boolean>;
+
+declare type DevMiddlewareContext<T extends Request_2, U extends Response_2> = Context<T, U>;
+
+declare type DevMiddlewareOptions<T extends Request_2, U extends Response_2> = Options<T, U>;
+
+/** Directory entry. Contains path, depth count, and files. */
+declare interface DirEntry {
+    files: PathOrDirent[];
+    depth: number;
+    path: Path_2;
+}
+
+/**
+ * Directory entry.
+ */
+declare class DirEntry_2 {
+    path: Path;
+    _removeWatcher: (dir: string, base: string) => void;
+    items: Set<Path>;
+    constructor(dir: Path, removeWatcher: (dir: string, base: string) => void);
+    add(item: string): void;
+    remove(item: string): Promise<void>;
+    has(item: string): boolean | undefined;
+    getChildren(): string[];
+    dispose(): void;
+}
+
+declare type EmitArgs = [path: Path, stats?: Stats];
+
+declare type EmitArgsWithName = [event: EventName, ...EmitArgs];
+
+/** Emitted entry. Contains relative & absolute path, basename, and either stats or dirent. */
+declare interface EntryInfo {
+    path: string;
+    fullPath: string;
+    stats?: Stats;
+    dirent?: Dirent;
+    basename: string;
+}
+
+declare type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes];
+
+declare const EntryTypes: {
+    readonly FILE_TYPE: "files";
+    readonly DIR_TYPE: "directories";
+    readonly FILE_DIR_TYPE: "files_directories";
+    readonly EVERYTHING_TYPE: "all";
+};
+
+declare type ErrorHandleFunction = (err: any, req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
+
+declare type EventName = (typeof EVENTS)[keyof typeof EVENTS];
+
+declare const EVENTS: {
+    readonly ALL: "all";
+    readonly READY: "ready";
+    readonly ADD: "add";
+    readonly CHANGE: "change";
+    readonly ADD_DIR: "addDir";
+    readonly UNLINK: "unlink";
+    readonly UNLINK_DIR: "unlinkDir";
+    readonly RAW: "raw";
+    readonly ERROR: "error";
+};
+
+declare type EXPECTED_ANY = any;
+
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
+    closed: boolean;
+    options: FSWInstanceOptions;
+    _closers: Map<string, Array<any>>;
+    _ignoredPaths: Set<Matcher>;
+    _throttled: Map<ThrottleType, Map<any, any>>;
+    _streams: Set<ReaddirpStream>;
+    _symlinkPaths: Map<Path, string | boolean>;
+    _watched: Map<string, DirEntry_2>;
+    _pendingWrites: Map<string, any>;
+    _pendingUnlinks: Map<string, EmitArgsWithName>;
+    _readyCount: number;
+    _emitReady: () => void;
+    _closePromise?: Promise<void>;
+    _userIgnored?: MatchFunction;
+    _readyEmitted: boolean;
+    _emitRaw: WatchHandlers['rawEmitter'];
+    _boundRemove: (dir: string, item: string) => void;
+    _nodeFsHandler: NodeFsHandler;
+    constructor(_opts?: ChokidarOptions);
+    _addIgnoredPath(matcher: Matcher): void;
+    _removeIgnoredPath(matcher: Matcher): void;
+    /**
+     * Adds paths to be watched on an existing FSWatcher instance.
+     * @param paths_ file or file list. Other arguments are unused
+     */
+    add(paths_: Path | Path[], _origAdd?: string, _internal?: boolean): FSWatcher;
+    /**
+     * Close watchers or start ignoring events from specified paths.
+     */
+    unwatch(paths_: Path | Path[]): FSWatcher;
+    /**
+     * Close watchers and remove all listeners from watched paths.
+     */
+    close(): Promise<void>;
+    /**
+     * Expose list of watched paths
+     * @returns for chaining
+     */
+    getWatched(): Record<string, string[]>;
+    emitWithAll(event: EventName, args: EmitArgs): void;
+    /**
+     * Normalize and emit events.
+     * Calling _emit DOES NOT MEAN emit() would be called!
+     * @param event Type of event
+     * @param path File or directory path
+     * @param stats arguments to be passed with event
+     * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _emit(event: EventName, path: Path, stats?: Stats): Promise<this | undefined>;
+    /**
+     * Common handler for errors
+     * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _handleError(error: Error): Error | boolean;
+    /**
+     * Helper utility for throttling
+     * @param actionType type being throttled
+     * @param path being acted upon
+     * @param timeout duration of time to suppress duplicate actions
+     * @returns tracking object or false if action should be suppressed
+     */
+    _throttle(actionType: ThrottleType, path: Path, timeout: number): Throttler | false;
+    _incrReadyCount(): number;
+    /**
+     * Awaits write operation to finish.
+     * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+     * @param path being acted upon
+     * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+     * @param event
+     * @param awfEmit Callback to be called when ready for event to be emitted.
+     */
+    _awaitWriteFinish(path: Path, threshold: number, event: EventName, awfEmit: (err?: Error, stat?: Stats) => void): void;
+    /**
+     * Determines whether user has asked to ignore this path.
+     */
+    _isIgnored(path: Path, stats?: Stats): boolean;
+    _isntIgnored(path: Path, stat?: Stats): boolean;
+    /**
+     * Provides a set of common helpers and properties relating to symlink handling.
+     * @param path file or directory pattern being watched
+     */
+    _getWatchHelpers(path: Path): WatchHelper;
+    /**
+     * Provides directory tracking objects
+     * @param directory path of the directory
+     */
+    _getWatchedDir(directory: string): DirEntry_2;
+    /**
+     * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+     */
+    _hasReadPermissions(stats: Stats): boolean;
+    /**
+     * Handles emitting unlink events for
+     * files and directories, and via recursion, for
+     * files and directories within directories that are unlinked
+     * @param directory within which the following item is located
+     * @param item      base path of item/directory
+     */
+    _remove(directory: string, item: string, isDirectory?: boolean): void;
+    /**
+     * Closes all watchers for a path
+     */
+    _closePath(path: Path): void;
+    /**
+     * Closes only file-specific watchers
+     */
+    _closeFile(path: Path): void;
+    _addPathCloser(path: Path, closer: () => void): void;
+    _readdirp(root: Path, opts?: Partial<ReaddirpOptions>): ReaddirpStream | undefined;
+}
+
+declare interface FSWatcherEventMap {
+    [EVENTS.READY]: [];
+    [EVENTS.RAW]: Parameters<WatchHandlers['rawEmitter']>;
+    [EVENTS.ERROR]: Parameters<WatchHandlers['errHandler']>;
+    [EVENTS.ALL]: [event: EventName, ...EmitArgs];
+    [EVENTS.ADD]: EmitArgs;
+    [EVENTS.CHANGE]: EmitArgs;
+    [EVENTS.ADD_DIR]: EmitArgs;
+    [EVENTS.UNLINK]: EmitArgs;
+    [EVENTS.UNLINK_DIR]: EmitArgs;
+}
+
+declare type FSWInstanceOptions = BasicOpts & {
+    ignored: Matcher[];
+    awaitWriteFinish: false | AWF;
+};
+
+declare type HandleFunction = SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction;
+
+/**
+ * Public and internal Connect types.
+ */
+declare interface IncomingMessage extends http.IncomingMessage {
+    originalUrl?: http.IncomingMessage['url'] | undefined;
+}
+
+/** https://github.com/microsoft/TypeScript/issues/29729 */
+declare type LiteralUnion<T extends U, U> = T | (U & Record<never, never>);
+
+declare type Matcher = string | RegExp | MatchFunction | MatcherObject;
+
+declare interface MatcherObject {
+    path: string;
+    recursive?: boolean;
+}
+
+declare type MatchFunction = (val: string, stats?: Stats) => boolean;
+
+declare type Middleware = MiddlewareObject | DevServerMiddlewareHandler | ErrorHandleFunction;
+
+declare interface MiddlewareObject {
+    name?: string;
+    path?: string;
+    middleware: DevServerMiddlewareHandler | ErrorHandleFunction;
+}
+
+declare type NextFunction = (err?: any) => void;
+
+declare type NextHandleFunction = (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
+
+/**
+ * @mixin
+ */
+declare class NodeFsHandler {
+    fsw: FSWatcher;
+    _boundHandleError: (error: unknown) => void;
+    constructor(fsW: FSWatcher);
+    /**
+     * Watch file for changes with fs_watchFile or fs_watch.
+     * @param path to file or dir
+     * @param listener on fs change
+     * @returns closer for the watcher instance
+     */
+    _watchWithNodeFs(path: string, listener: (path: string, newStats?: any) => void | Promise<void>): (() => void) | undefined;
+    /**
+     * Watch a file and emit add event if warranted.
+     * @returns closer for the watcher instance
+     */
+    _handleFile(file: Path, stats: Stats, initialAdd: boolean): (() => void) | undefined;
+    /**
+     * Handle symlinks encountered while reading a dir.
+     * @param entry returned by readdirp
+     * @param directory path of dir being read
+     * @param path of this item
+     * @param item basename of this item
+     * @returns true if no more processing is needed for this entry.
+     */
+    _handleSymlink(entry: EntryInfo, directory: string, path: Path, item: string): Promise<boolean | undefined>;
+    _handleRead(directory: string, initialAdd: boolean, wh: WatchHelper, target: Path | undefined, dir: Path, depth: number, throttler: Throttler): Promise<unknown> | undefined;
+    /**
+     * Read directory to add / remove files from `@watched` list and re-read it on change.
+     * @param dir fs path
+     * @param stats
+     * @param initialAdd
+     * @param depth relative to user-supplied path
+     * @param target child path targeted for watch
+     * @param wh Common watch helpers for this path
+     * @param realpath
+     * @returns closer for the watcher instance.
+     */
+    _handleDir(dir: string, stats: Stats, initialAdd: boolean, depth: number, target: string | undefined, wh: WatchHelper, realpath: string): Promise<(() => void) | undefined>;
+    /**
+     * Handle added file, directory, or glob pattern.
+     * Delegates call to _handleFile / _handleDir after checks.
+     * @param path to file or ir
+     * @param initialAdd was the file added at watch instantiation?
+     * @param priorWh depth relative to user-supplied path
+     * @param depth Child path actually targeted for watch
+     * @param target Child path actually targeted for watch
+     */
+    _addToNodeFs(path: string, initialAdd: boolean, priorWh: WatchHelper | undefined, depth: number, target?: string): Promise<string | false | undefined>;
+}
+
+declare type Open = DevServerOpenOptions & {
+    target?: string | string[];
+};
+
+declare type Path = string;
+
+/** Path in file system. */
+declare type Path_2 = string;
+
+/** Path or dir entries (files) */
+declare type PathOrDirent = Dirent | Path_2;
+
+declare type Port = number | LiteralUnion<'auto', string>;
+
+declare type Predicate = string[] | string | Tester;
+
+/**
+ * Options for readdirp.
+ * * type: files, directories, or both
+ * * lstat: whether to use symlink-friendly stat
+ * * depth: max depth
+ * * alwaysStat: whether to use stat (more resources) or dirent
+ * * highWaterMark: streaming param, specifies max amount of resources per entry
+ */
+declare type ReaddirpOptions = {
+    root: string;
+    fileFilter?: Predicate;
+    directoryFilter?: Predicate;
+    type?: EntryType;
+    lstat?: boolean;
+    depth?: number;
+    alwaysStat?: boolean;
+    highWaterMark?: number;
+};
+
+/** Readable readdir stream, emitting new files as they're being listed. */
+declare class ReaddirpStream extends Readable {
+    parents: any[];
+    reading: boolean;
+    parent?: DirEntry;
+    _stat: Function;
+    _maxDepth: number;
+    _wantsDir: boolean;
+    _wantsFile: boolean;
+    _wantsEverything: boolean;
+    _root: Path_2;
+    _isDirent: boolean;
+    _statsProp: 'dirent' | 'stats';
+    _rdOptions: {
+        encoding: 'utf8';
+        withFileTypes: boolean;
+    };
+    _fileFilter: Tester;
+    _directoryFilter: Tester;
+    constructor(options?: Partial<ReaddirpOptions>);
+    _read(batch: number): Promise<void>;
+    _exploreDir(path: Path_2, depth: number): Promise<{
+        files: string[] | undefined;
+        depth: number;
+        path: string;
+    }>;
+    _formatEntry(dirent: PathOrDirent, path: Path_2): Promise<EntryInfo | undefined>;
+    _onError(err: Error): void;
+    _getEntryType(entry: EntryInfo): Promise<void | '' | 'file' | 'directory'>;
+    _includeAsFile(entry: EntryInfo): boolean | undefined;
+}
+
+declare type Request_2<T extends BasicApplication = Server> = T extends Server ? IncomingMessage : IncomingMessage_2;
+
+declare type Response_2 = ServerResponse;
+
+export declare class RspackDevServer<A extends BasicApplication = Server, S extends BasicServer = Server_4> {
+    #private;
+    compiler: Compiler | MultiCompiler;
+    logger: ReturnType<Compiler['getInfrastructureLogger']>;
+    options: Configuration_2<A, S>;
+    staticWatchers: FSWatcher[];
+    listeners: {
+        name: string | symbol;
+        listener: (...args: EXPECTED_ANY[]) => void;
+    }[];
+    webSocketProxies: NextHandleFunction[];
+    sockets: Socket[];
+    currentHash: string | undefined;
+    isTlsServer: boolean;
+    webSocketServer: WebSocketServerImplementation | null | undefined;
+    middleware: API<Request_2, Response_2> | undefined;
+    server: S | undefined;
+    app: A | undefined;
+    stats: Stats_2 | MultiStats | undefined;
+    constructor(options: Configuration, compiler: Compiler | MultiCompiler);
+    static get DEFAULT_STATS(): StatsOptions;
+    static isAbsoluteURL(URL: string): boolean;
+    static findIp(gatewayOrFamily: string, isInternal: boolean): string | undefined;
+    static getHostname(hostname: DevServerHost): Promise<string>;
+    static getFreePort(port: string, host: string): Promise<string | number>;
+    static findCacheDir(): string;
+    getClientEntry(): string;
+    getClientHotEntry(): string | undefined;
+    isValidHost(headers: Record<string, string | undefined>, headerToCheck: string, validateHost?: boolean): boolean;
+    sendMessage(clients: ClientConnection[], type: string, data?: EXPECTED_ANY, params?: EXPECTED_ANY): void;
+    watchFiles(watchPath: string | string[], watchOptions?: ChokidarOptions): Promise<void>;
+    invalidate(callback?: Callback): void;
+    start(): Promise<void>;
+    startCallback(callback?: (err?: Error) => void): void;
+    stop(): Promise<void>;
+    stopCallback(callback?: (err?: Error) => void): void;
+}
+
+declare interface Server extends EventEmitter {
+    (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;
+    route: string;
+    stack: ServerStackItem[];
+    handle(req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;
+    use(fn: NextHandleFunction): Server;
+    use(fn: HandleFunction): Server;
+    use(fn: http.Server): Server;
+    use(route: string, fn: NextHandleFunction): Server;
+    use(route: string, fn: HandleFunction): Server;
+    use(route: string, fn: http.Server): Server;
+    listen(port: number, hostname?: string, backlog?: number, callback?: Function): http.Server;
+    listen(port: number, hostname?: string, callback?: Function): http.Server;
+    listen(path: string, callback?: Function): http.Server;
+    listen(options: ListenOptions, callback?: Function): http.Server;
+    listen(handle: unknown, listeningListener?: Function): http.Server;
+}
+
+declare interface ServerConfiguration<A extends BasicApplication = Server, S extends BasicServer = Server_4> {
+    type?: ServerType<A, S>;
+    options?: ServerOptions;
+}
+
+declare type ServerHandle = HandleFunction | http.Server;
+
+declare interface ServerStackItem {
+    route: string;
+    handle: ServerHandle;
+}
+
+declare type ServerType<A extends BasicApplication, S extends BasicServer> = LiteralUnion<'http' | 'https' | 'http2', string> | ((serverOptions: ServerOptions, application: A) => S);
+
+declare type SimpleHandleFunction = (req: IncomingMessage, res: http.ServerResponse) => void;
+
+/** Filterer for files */
+declare type Tester = (entryInfo: EntryInfo) => boolean;
+
+declare type Throttler = {
+    timeoutObject: NodeJS.Timeout;
+    clear: () => void;
+    count: number;
+};
+
+declare type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change';
+
+declare type UseFn = {
+    (fn: NextHandleFunction): BasicApplication;
+    (fn: HandleFunction): BasicApplication;
+    (route: string, fn: NextHandleFunction): BasicApplication;
+    (route: string, fn: HandleFunction): BasicApplication;
+};
+
+declare interface WatchFiles {
+    paths: string | string[];
+    options?: ChokidarOptions & {
+        aggregateTimeout?: number;
+        poll?: number | boolean;
+    };
+}
+
+declare interface WatchHandlers {
+    listener: (path: string) => void;
+    errHandler: (err: unknown) => void;
+    rawEmitter: (ev: WatchEventType, path: string, opts: unknown) => void;
+}
+
+declare class WatchHelper {
+    fsw: FSWatcher;
+    path: string;
+    watchPath: string;
+    fullWatchPath: string;
+    dirParts: string[][];
+    followSymlinks: boolean;
+    statMethod: 'stat' | 'lstat';
+    constructor(path: string, follow: boolean, fsw: FSWatcher);
+    entryPath(entry: EntryInfo): Path;
+    filterPath(entry: EntryInfo): boolean;
+    filterDir(entry: EntryInfo): boolean;
+}
+
+declare type WebSocketServer = WebSocketServer_2;
+
+declare interface WebSocketServerConfiguration {
+    type?: LiteralUnion<'ws', string> | (() => WebSocketServerConfiguration);
+    options?: Record<string, EXPECTED_ANY>;
+}
+
+declare interface WebSocketServerImplementation {
+    implementation: WebSocketServer;
+    clients: ClientConnection[];
+}
+
+export { }

package/dist/index.js

@@ -1 +1 @@
-export { RspackDevServer } from "./831.js";
+export { RspackDevServer } from "./108.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/dev-server",
-  "version": "2.0.0-rc.0",
+  "version": "2.0.0-rc.2",
   "description": "Development server for rspack",
   "homepage": "https://rspack.rs",
   "bugs": "https://github.com/rstackjs/rspack-dev-server/issues",
@@ -29,8 +29,9 @@
     "lint": "rslint",
     "lint:write": "rslint --fix",
     "prettier:ci": "prettier --check .",
-    "test": "pnpm run test:install && pnpm run build && rstest",
-    "test:install": "cross-env ./node_modules/.bin/puppeteer browsers install chrome"
+    "test": "pnpm run test:install && pnpm run test:type && rstest",
+    "test:install": "cross-env ./node_modules/.bin/puppeteer browsers install chrome",
+    "test:type": "pnpm run build && pnpm --dir tests run type-check"
   },
   "simple-git-hooks": {
     "pre-commit": "npx nano-staged"
@@ -45,32 +46,31 @@
     ]
   },
   "dependencies": {
-    "@rspack/dev-middleware": "^2.0.0",
-    "@types/ws": "^8.18.1",
-    "chokidar": "^5.0.0",
-    "connect-history-api-fallback": "^2.0.0",
-    "connect-next": "^4.0.0",
-    "http-proxy-middleware": "^3.0.5",
-    "ws": "^8.20.0"
+    "@rspack/dev-middleware": "^2.0.0"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.12",
+    "@microsoft/api-extractor": "^7.58.0",
     "@rslib/core": "^0.20.2",
-    "@rslint/core": "^0.3.3",
+    "@rslint/core": "^0.3.4",
     "@rspack/core": "2.0.0-rc.0",
     "@rspack/plugin-react-refresh": "1.6.1",
     "@rstest/core": "^0.9.5",
+    "@types/connect-history-api-fallback": "^1.5.4",
     "@types/mime-types": "3.0.1",
     "@types/node": "^24.12.0",
     "@types/serve-static": "^2.2.0",
     "@types/trusted-types": "^2.0.7",
     "@types/ws": "8.18.1",
+    "chokidar": "^5.0.0",
+    "connect-history-api-fallback": "^2.0.0",
+    "connect-next": "^4.0.1",
     "cross-env": "^10.1.0",
-    "css-loader": "^7.1.4",
     "express": "^5.2.1",
     "hono": "^4.12.9",
     "http-compression": "^1.1.2",
     "http-proxy": "^1.18.1",
+    "http-proxy-middleware": "^3.0.5",
     "ipaddr.js": "^2.3.0",
     "launch-editor": "^2.13.2",
     "nano-staged": "^0.9.0",
@@ -83,8 +83,8 @@
     "selfsigned": "^5.5.0",
     "serve-static": "^2.2.1",
     "simple-git-hooks": "^2.13.1",
-    "style-loader": "^4.0.0",
-    "typescript": "^6.0.2"
+    "typescript": "^6.0.2",
+    "ws": "^8.20.0"
   },
   "peerDependencies": {
     "@rspack/core": "^2.0.0-0",

package/dist/config.d.ts

@@ -1,22 +0,0 @@
-import type { DevServerClient, DevServerOpenOptions } from '@rspack/core';
-import type { ConnectHistoryApiFallbackOptions, DevServer, NormalizedStatic, ServerConfiguration, WatchFiles, WebSocketServerConfiguration } from './types.js';
-export interface ResolvedDevServer extends DevServer {
-    port: number | string;
-    static: false | Array<NormalizedStatic>;
-    devMiddleware: DevServer['devMiddleware'];
-    hot: boolean | 'only';
-    host?: string;
-    open: DevServerOpenOptions[];
-    magicHtml: boolean;
-    liveReload: boolean;
-    webSocketServer: false | WebSocketServerConfiguration;
-    proxy: Required<DevServer['proxy']>;
-    client: DevServerClient;
-    allowedHosts: 'auto' | string[] | 'all';
-    compress: boolean;
-    historyApiFallback: false | ConnectHistoryApiFallbackOptions;
-    server: ServerConfiguration;
-    ipc: string | undefined;
-    setupExitSignals: boolean;
-    watchFiles: WatchFiles[];
-}