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

package/dist/server.d.ts

@@ -1,74 +0,0 @@
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack-dev-server
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
- */
-import type { DevServerClient, DevServerHeaders, DevServerHost, DevServerProxyConfigArray, DevServerStatic } from '@rspack/core';
-import type { NextHandleFunction } from 'connect-next';
-import type { BasicApplication, BasicServer, ClientConnection, Compiler, ConnectHistoryApiFallbackOptions, DevMiddlewareContext, DevMiddlewareOptions, DevServer, EXPECTED_ANY, FSWatcher, HTTPServer, LiteralUnion, Middleware, MultiCompiler, MultiStats, Open, Port, Request, Response, ServerConfiguration, ServerType, Socket, Stats, StatsOptions, WatchFiles, WatchOptions, WebSocketServerConfiguration, WebSocketServerImplementation } from './types.js';
-import type { ConnectApplication } from './types.js';
-export interface Configuration<A extends BasicApplication = ConnectApplication, S extends BasicServer = HTTPServer> {
-    ipc?: boolean | string;
-    host?: DevServerHost;
-    port?: Port;
-    hot?: boolean | 'only';
-    liveReload?: boolean;
-    devMiddleware?: DevMiddlewareOptions<Request, Response>;
-    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, res: Response, context: DevMiddlewareContext<Request, Response> | undefined) => DevServerHeaders);
-    onListening?: (devServer: Server<A, S>) => void;
-    setupMiddlewares?: (middlewares: Middleware[], devServer: Server<A, S>) => Middleware[];
-}
-declare class Server<A extends BasicApplication = ConnectApplication, S extends BasicServer = HTTPServer> {
-    #private;
-    compiler: Compiler | MultiCompiler;
-    logger: ReturnType<Compiler['getInfrastructureLogger']>;
-    options: Configuration<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: import('@rspack/dev-middleware').API<Request, Response> | undefined;
-    server: S | undefined;
-    app: A | undefined;
-    stats: Stats | MultiStats | undefined;
-    constructor(options: DevServer, 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?: WatchOptions): Promise<void>;
-    invalidate(callback?: import('@rspack/dev-middleware').Callback): void;
-    start(): Promise<void>;
-    startCallback(callback?: (err?: Error) => void): void;
-    stop(): Promise<void>;
-    stopCallback(callback?: (err?: Error) => void): void;
-}
-export { Server };

package/dist/servers/BaseServer.d.ts

@@ -1,17 +0,0 @@
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack-dev-server
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
- */
-import type { Server } from '../server.js';
-import type { ClientConnection } from '../types.js';
-declare class BaseServer {
-    server: Server;
-    clients: ClientConnection[];
-    constructor(server: Server);
-}
-export default BaseServer;

package/dist/servers/WebsocketServer.d.ts

@@ -1,17 +0,0 @@
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack-dev-server
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
- */
-import * as Ws from 'ws';
-import type { Server } from '../server.js';
-import BaseServer from './BaseServer.js';
-export declare class WebsocketServer extends BaseServer {
-    static heartbeatInterval: number;
-    implementation: Ws.WebSocketServer;
-    constructor(server: Server);
-}

package/dist/types.d.ts

@@ -1,73 +0,0 @@
-import type { Server as HTTPServer, IncomingMessage, ServerResponse } from 'node:http';
-import type { ServerOptions } from 'node:https';
-import type { DevServer, DevServerMiddlewareHandler, DevServerOpenOptions, DevServerStaticItem } from '@rspack/core';
-import type { FSWatcher, ChokidarOptions as WatchOptions } from 'chokidar';
-import type { Server as ConnectApplication, IncomingMessage as ConnectIncomingMessage, ErrorHandleFunction, HandleFunction, NextHandleFunction } from 'connect-next';
-export type { FSWatcher, WatchOptions, BasicServer, HTTPServer, ServerOptions, IncomingMessage, ConnectApplication, };
-export type { Socket } from 'node:net';
-export type { AddressInfo } from 'node:net';
-export type { NetworkInterfaceInfo } from 'node:os';
-export type { Compiler, DevServer, MultiCompiler, MultiStats, Stats, StatsCompilation, StatsOptions, } from '@rspack/core';
-export type EXPECTED_ANY = any;
-type BasicServer = import('node:net').Server | import('node:tls').Server;
-/** https://github.com/microsoft/TypeScript/issues/29729 */
-export type LiteralUnion<T extends U, U> = T | (U & Record<never, never>);
-export type ConnectHistoryApiFallbackOptions = Exclude<NonNullable<DevServer['historyApiFallback']>, boolean>;
-export type Request<T extends BasicApplication = ConnectApplication> = T extends ConnectApplication ? ConnectIncomingMessage : IncomingMessage;
-export type Response = ServerResponse;
-export type DevMiddlewareOptions<T extends Request, U extends Response> = import('@rspack/dev-middleware').Options<T, U>;
-export type DevMiddlewareContext<T extends Request, U extends Response> = import('@rspack/dev-middleware').Context<T, U>;
-export type Port = number | LiteralUnion<'auto', string>;
-export interface WatchFiles {
-    paths: string | string[];
-    options?: WatchOptions & {
-        aggregateTimeout?: number;
-        poll?: number | boolean;
-    };
-}
-export interface NormalizedStatic {
-    directory: string;
-    publicPath: string[];
-    staticOptions: DevServerStaticItem['staticOptions'];
-    watch: false | WatchOptions;
-}
-export type ServerType<A extends BasicApplication, S extends BasicServer> = LiteralUnion<'http' | 'https' | 'http2', string> | ((serverOptions: ServerOptions, application: A) => S);
-export interface ServerConfiguration<A extends BasicApplication = ConnectApplication, S extends BasicServer = HTTPServer> {
-    type?: ServerType<A, S>;
-    options?: ServerOptions;
-}
-export interface WebSocketServerConfiguration {
-    type?: LiteralUnion<'ws', string> | (() => WebSocketServerConfiguration);
-    options?: Record<string, EXPECTED_ANY>;
-}
-export type ClientConnection = import('ws').WebSocket & {
-    isAlive?: boolean;
-};
-export type WebSocketServer = import('ws').WebSocketServer;
-export interface WebSocketServerImplementation {
-    implementation: WebSocketServer;
-    clients: ClientConnection[];
-}
-export type Open = DevServerOpenOptions & {
-    target?: string | string[];
-};
-export interface NormalizedOpen {
-    target: string;
-    options: DevServerOpenOptions;
-}
-export interface MiddlewareObject {
-    name?: string;
-    path?: string;
-    middleware: DevServerMiddlewareHandler | ErrorHandleFunction;
-}
-export type Middleware = MiddlewareObject | DevServerMiddlewareHandler | ErrorHandleFunction;
-export type OverlayMessageOptions = boolean | ((error: Error) => void);
-type UseFn = {
-    (fn: NextHandleFunction): BasicApplication;
-    (fn: HandleFunction): BasicApplication;
-    (route: string, fn: NextHandleFunction): BasicApplication;
-    (route: string, fn: HandleFunction): BasicApplication;
-};
-export type BasicApplication = {
-    use: UseFn;
-};