webpack-dev-server

  • Version 5.1.0
  • Published
  • 541 kB
  • 28 dependencies
  • MIT license

Install

npm i webpack-dev-server
yarn add webpack-dev-server
pnpm add webpack-dev-server

Overview

Serves a webpack app. Updates the browser on changes.

Index

Functions

function useFn

useFn: {
(fn: NextHandleFunction): BasicApplication;
(fn: HandleFunction): BasicApplication;
(route: string, fn: NextHandleFunction): BasicApplication;
};
  • Parameter fn

    Returns

    {BasicApplication}

  • Parameter fn

    Returns

    {BasicApplication}

  • Parameter route

    Parameter fn

    Returns

    {BasicApplication}

Classes

class DEFAULT_STATS

class DEFAULT_STATS {}

    class Server

    class Server<
    A extends BasicApplication = import('express').Application,
    S extends BasicServer = import('http').Server<
    typeof import('http').IncomingMessage,
    typeof import('http').ServerResponse
    >
    > {}
    • {BasicApplication} [A=ExpressApplication] {BasicServer} [S=HTTPServer]

    constructor

    constructor(options: Configuration<A, S>, compiler: any);
    • Parameter options

      Parameter compiler

    property app

    app: BasicApplication;
    • {A | undefined}

    property compiler

    compiler: any;

      property isTlsServer

      isTlsServer: boolean;

        property logger

        logger: any;
        • {ReturnType<Compiler["getInfrastructureLogger"]>}

        property middleware

        middleware: any;
        • {import("webpack-dev-middleware").API<Request, Response>}

        property options

        options: Configuration<A, S>;

          property schema

          static readonly schema: {
          title: string;
          type: string;
          definitions: {
          App: { instanceof: string; description: string; link: string };
          AllowedHosts: {
          anyOf: (
          | {
          type: string;
          minItems: number;
          items: { $ref: string };
          enum?: undefined;
          $ref?: undefined;
          }
          | {
          enum: string[];
          type?: undefined;
          minItems?: undefined;
          items?: undefined;
          $ref?: undefined;
          }
          | {
          $ref: string;
          type?: undefined;
          minItems?: undefined;
          items?: undefined;
          enum?: undefined;
          }
          )[];
          description: string;
          link: string;
          };
          AllowedHostsItem: { type: string; minLength: number };
          Bonjour: {
          anyOf: (
          | {
          type: string;
          cli: { negatedDescription: string };
          description?: undefined;
          link?: undefined;
          }
          | {
          type: string;
          description: string;
          link: string;
          cli?: undefined;
          }
          )[];
          description: string;
          link: string;
          };
          Client: {
          description: string;
          link: string;
          anyOf: (
          | {
          enum: boolean[];
          cli: { negatedDescription: string };
          type?: undefined;
          additionalProperties?: undefined;
          properties?: undefined;
          }
          | {
          type: string;
          additionalProperties: boolean;
          properties: {
          logging: { $ref: string };
          overlay: { $ref: string };
          progress: { $ref: string };
          reconnect: { $ref: string };
          webSocketTransport: { $ref: string };
          webSocketURL: { $ref: string };
          };
          enum?: undefined;
          cli?: undefined;
          }
          )[];
          };
          ClientLogging: { enum: string[]; description: string; link: string };
          ClientOverlay: {
          anyOf: (
          | {
          description: string;
          link: string;
          type: string;
          cli: { negatedDescription: string };
          additionalProperties?: undefined;
          properties?: undefined;
          }
          | {
          type: string;
          additionalProperties: boolean;
          properties: {
          errors: {
          anyOf: (
          | {
          description: string;
          type: string;
          cli: { negatedDescription: string };
          instanceof?: undefined;
          }
          | {
          instanceof: string;
          description: string;
          type?: undefined;
          cli?: undefined;
          }
          )[];
          };
          warnings: {
          anyOf: (
          | {
          description: string;
          type: string;
          cli: { negatedDescription: string };
          instanceof?: undefined;
          }
          | {
          instanceof: string;
          description: string;
          type?: undefined;
          cli?: undefined;
          }
          )[];
          };
          runtimeErrors: {
          anyOf: (
          | {
          description: string;
          type: string;
          cli: { negatedDescription: string };
          instanceof?: undefined;
          }
          | {
          instanceof: string;
          description: string;
          type?: undefined;
          cli?: undefined;
          }
          )[];
          };
          trustedTypesPolicyName: {
          description: string;
          type: string;
          };
          };
          description?: undefined;
          link?: undefined;
          cli?: undefined;
          }
          )[];
          };
          ClientProgress: {
          description: string;
          link: string;
          type: string[];
          enum: (string | boolean)[];
          cli: { negatedDescription: string };
          };
          ClientReconnect: {
          description: string;
          link: string;
          anyOf: (
          | {
          type: string;
          cli: { negatedDescription: string };
          minimum?: undefined;
          }
          | { type: string; minimum: number; cli?: undefined }
          )[];
          };
          ClientWebSocketTransport: {
          anyOf: { $ref: string }[];
          description: string;
          link: string;
          };
          ClientWebSocketTransportEnum: { enum: string[] };
          ClientWebSocketTransportString: { type: string; minLength: number };
          ClientWebSocketURL: {
          description: string;
          link: string;
          anyOf: (
          | {
          type: string;
          minLength: number;
          additionalProperties?: undefined;
          properties?: undefined;
          }
          | {
          type: string;
          additionalProperties: boolean;
          properties: {
          hostname: {
          description: string;
          type: string;
          minLength: number;
          };
          pathname: { description: string; type: string };
          password: { description: string; type: string };
          port: {
          description: string;
          anyOf: (
          | { type: string; minLength?: undefined }
          | { type: string; minLength: number }
          )[];
          };
          protocol: {
          description: string;
          anyOf: (
          | {
          enum: string[];
          type?: undefined;
          minLength?: undefined;
          }
          | {
          type: string;
          minLength: number;
          enum?: undefined;
          }
          )[];
          };
          username: { description: string; type: string };
          };
          minLength?: undefined;
          }
          )[];
          };
          Compress: {
          type: string;
          description: string;
          link: string;
          cli: { negatedDescription: string };
          };
          DevMiddleware: {
          description: string;
          link: string;
          type: string;
          additionalProperties: boolean;
          };
          HeaderObject: {
          type: string;
          additionalProperties: boolean;
          properties: {
          key: { description: string; type: string };
          value: { description: string; type: string };
          };
          cli: { exclude: boolean };
          };
          Headers: {
          anyOf: (
          | {
          type: string;
          items: { $ref: string };
          minItems: number;
          instanceof?: undefined;
          }
          | {
          type: string;
          items?: undefined;
          minItems?: undefined;
          instanceof?: undefined;
          }
          | {
          instanceof: string;
          type?: undefined;
          items?: undefined;
          minItems?: undefined;
          }
          )[];
          description: string;
          link: string;
          };
          HistoryApiFallback: {
          anyOf: (
          | {
          type: string;
          cli: { negatedDescription: string };
          description?: undefined;
          link?: undefined;
          }
          | {
          type: string;
          description: string;
          link: string;
          cli?: undefined;
          }
          )[];
          description: string;
          link: string;
          };
          Host: {
          description: string;
          link: string;
          anyOf: (
          | { enum: string[]; type?: undefined; minLength?: undefined }
          | { type: string; minLength: number; enum?: undefined }
          )[];
          };
          Hot: {
          anyOf: (
          | {
          type: string;
          cli: { negatedDescription: string };
          enum?: undefined;
          }
          | { enum: string[]; type?: undefined; cli?: undefined }
          )[];
          description: string;
          link: string;
          };
          IPC: {
          anyOf: (
          | { type: string; minLength: number; enum?: undefined }
          | { type: string; enum: boolean[]; minLength?: undefined }
          )[];
          description: string;
          link: string;
          };
          LiveReload: {
          type: string;
          description: string;
          cli: { negatedDescription: string };
          link: string;
          };
          OnListening: { instanceof: string; description: string; link: string };
          Open: {
          anyOf: (
          | {
          type: string;
          items: { anyOf: { $ref: string }[] };
          $ref?: undefined;
          }
          | { $ref: string; type?: undefined; items?: undefined }
          )[];
          description: string;
          link: string;
          };
          OpenBoolean: { type: string; cli: { negatedDescription: string } };
          OpenObject: {
          type: string;
          additionalProperties: boolean;
          properties: {
          target: {
          anyOf: (
          | { type: string; items: { type: string } }
          | { type: string; items?: undefined }
          )[];
          description: string;
          };
          app: {
          anyOf: (
          | {
          type: string;
          additionalProperties: boolean;
          properties: {
          name: {
          anyOf: (
          | {
          type: string;
          items: {
          type: string;
          minLength: number;
          };
          minItems: number;
          minLength?: undefined;
          }
          | {
          type: string;
          minLength: number;
          items?: undefined;
          minItems?: undefined;
          }
          )[];
          };
          arguments: {
          items: { type: string; minLength: number };
          };
          };
          minLength?: undefined;
          description?: undefined;
          cli?: undefined;
          }
          | {
          type: string;
          minLength: number;
          description: string;
          cli: { exclude: boolean };
          additionalProperties?: undefined;
          properties?: undefined;
          }
          )[];
          description: string;
          };
          };
          };
          OpenString: { type: string; minLength: number };
          Port: {
          anyOf: (
          | {
          type: string;
          minimum: number;
          maximum: number;
          minLength?: undefined;
          enum?: undefined;
          }
          | {
          type: string;
          minLength: number;
          minimum?: undefined;
          maximum?: undefined;
          enum?: undefined;
          }
          | {
          enum: string[];
          type?: undefined;
          minimum?: undefined;
          maximum?: undefined;
          minLength?: undefined;
          }
          )[];
          description: string;
          link: string;
          };
          Proxy: {
          type: string;
          items: {
          anyOf: (
          | { type: string; instanceof?: undefined }
          | { instanceof: string; type?: undefined }
          )[];
          };
          description: string;
          link: string;
          };
          Server: { anyOf: { $ref: string }[]; link: string; description: string };
          ServerType: { enum: string[] };
          ServerFn: { instanceof: string };
          ServerEnum: { enum: string[]; cli: { exclude: boolean } };
          ServerString: {
          type: string;
          minLength: number;
          cli: { exclude: boolean };
          };
          ServerObject: {
          type: string;
          properties: {
          type: { anyOf: { $ref: string }[] };
          options: { $ref: string };
          };
          additionalProperties: boolean;
          };
          ServerOptions: {
          type: string;
          additionalProperties: boolean;
          properties: {
          passphrase: { type: string; description: string };
          requestCert: {
          type: string;
          description: string;
          cli: { negatedDescription: string };
          };
          ca: {
          anyOf: (
          | {
          type: string;
          items: {
          anyOf: (
          | { type: string; instanceof?: undefined }
          | { instanceof: string; type?: undefined }
          )[];
          };
          instanceof?: undefined;
          }
          | {
          type: string;
          items?: undefined;
          instanceof?: undefined;
          }
          | {
          instanceof: string;
          type?: undefined;
          items?: undefined;
          }
          )[];
          description: string;
          };
          cert: {
          anyOf: (
          | {
          type: string;
          items: {
          anyOf: (
          | { type: string; instanceof?: undefined }
          | { instanceof: string; type?: undefined }
          )[];
          };
          instanceof?: undefined;
          }
          | {
          type: string;
          items?: undefined;
          instanceof?: undefined;
          }
          | {
          instanceof: string;
          type?: undefined;
          items?: undefined;
          }
          )[];
          description: string;
          };
          crl: {
          anyOf: (
          | {
          type: string;
          items: {
          anyOf: (
          | { type: string; instanceof?: undefined }
          | { instanceof: string; type?: undefined }
          )[];
          };
          instanceof?: undefined;
          }
          | {
          type: string;
          items?: undefined;
          instanceof?: undefined;
          }
          | {
          instanceof: string;
          type?: undefined;
          items?: undefined;
          }
          )[];
          description: string;
          };
          key: {
          anyOf: (
          | {
          type: string;
          items: {
          anyOf: (
          | {
          type: string;
          instanceof?: undefined;
          additionalProperties?: undefined;
          }
          | {
          instanceof: string;
          type?: undefined;
          additionalProperties?: undefined;
          }
          | {
          type: string;
          additionalProperties: boolean;
          instanceof?: undefined;
          }
          )[];
          };
          instanceof?: undefined;
          }
          | {
          type: string;
          items?: undefined;
          instanceof?: undefined;
          }
          | {
          instanceof: string;
          type?: undefined;
          items?: undefined;
          }
          )[];
          description: string;
          };
          pfx: {
          anyOf: (
          | {
          type: string;
          items: {
          anyOf: (
          | {
          type: string;
          instanceof?: undefined;
          additionalProperties?: undefined;
          }
          | {
          instanceof: string;
          type?: undefined;
          additionalProperties?: undefined;
          }
          | {
          type: string;
          additionalProperties: boolean;
          instanceof?: undefined;
          }
          )[];
          };
          instanceof?: undefined;
          }
          | {
          type: string;
          items?: undefined;
          instanceof?: undefined;
          }
          | {
          instanceof: string;
          type?: undefined;
          items?: undefined;
          }
          )[];
          description: string;
          };
          };
          };
          SetupExitSignals: {
          type: string;
          description: string;
          link: string;
          cli: { exclude: boolean };
          };
          SetupMiddlewares: {
          instanceof: string;
          description: string;
          link: string;
          };
          Static: {
          anyOf: (
          | {
          type: string;
          items: { anyOf: { $ref: string }[] };
          cli?: undefined;
          $ref?: undefined;
          }
          | {
          type: string;
          cli: { negatedDescription: string };
          items?: undefined;
          $ref?: undefined;
          }
          | {
          $ref: string;
          type?: undefined;
          items?: undefined;
          cli?: undefined;
          }
          )[];
          description: string;
          link: string;
          };
          StaticObject: {
          type: string;
          additionalProperties: boolean;
          properties: {
          directory: {
          type: string;
          minLength: number;
          description: string;
          link: string;
          };
          staticOptions: {
          type: string;
          link: string;
          additionalProperties: boolean;
          };
          publicPath: {
          anyOf: (
          | {
          type: string;
          items: { type: string };
          minItems: number;
          }
          | {
          type: string;
          items?: undefined;
          minItems?: undefined;
          }
          )[];
          description: string;
          link: string;
          };
          serveIndex: {
          anyOf: (
          | {
          type: string;
          cli: { negatedDescription: string };
          additionalProperties?: undefined;
          }
          | {
          type: string;
          additionalProperties: boolean;
          cli?: undefined;
          }
          )[];
          description: string;
          link: string;
          };
          watch: {
          anyOf: (
          | {
          type: string;
          cli: { negatedDescription: string };
          description?: undefined;
          link?: undefined;
          }
          | {
          type: string;
          description: string;
          link: string;
          cli?: undefined;
          }
          )[];
          description: string;
          link: string;
          };
          };
          };
          StaticString: { type: string; minLength: number };
          WatchFiles: {
          anyOf: (
          | {
          type: string;
          items: { anyOf: { $ref: string }[] };
          $ref?: undefined;
          }
          | { $ref: string; type?: undefined; items?: undefined }
          )[];
          description: string;
          link: string;
          };
          WatchFilesObject: {
          cli: { exclude: boolean };
          type: string;
          properties: {
          paths: {
          anyOf: (
          | {
          type: string;
          items: { type: string; minLength: number };
          minLength?: undefined;
          }
          | { type: string; minLength: number; items?: undefined }
          )[];
          description: string;
          };
          options: {
          type: string;
          description: string;
          link: string;
          additionalProperties: boolean;
          };
          };
          additionalProperties: boolean;
          };
          WatchFilesString: { type: string; minLength: number };
          WebSocketServer: {
          anyOf: { $ref: string }[];
          description: string;
          link: string;
          };
          WebSocketServerType: { enum: string[] };
          WebSocketServerEnum: {
          anyOf: (
          | {
          enum: boolean[];
          cli: { negatedDescription: string; exclude?: undefined };
          }
          | {
          enum: string[];
          cli: { exclude: boolean; negatedDescription?: undefined };
          }
          )[];
          };
          WebSocketServerFunction: { instanceof: string };
          WebSocketServerObject: {
          type: string;
          properties: {
          type: { anyOf: { $ref: string }[] };
          options: {
          type: string;
          additionalProperties: boolean;
          cli: { exclude: boolean };
          };
          };
          additionalProperties: boolean;
          };
          WebSocketServerString: {
          type: string;
          minLength: number;
          cli: { exclude: boolean };
          };
          };
          additionalProperties: boolean;
          properties: {
          allowedHosts: { $ref: string };
          bonjour: { $ref: string };
          client: { $ref: string };
          compress: { $ref: string };
          devMiddleware: { $ref: string };
          headers: { $ref: string };
          historyApiFallback: { $ref: string };
          host: { $ref: string };
          hot: { $ref: string };
          ipc: { $ref: string };
          liveReload: { $ref: string };
          onListening: { $ref: string };
          open: { $ref: string };
          port: { $ref: string };
          proxy: { $ref: string };
          server: { $ref: string };
          app: { $ref: string };
          setupExitSignals: { $ref: string };
          setupMiddlewares: { $ref: string };
          static: { $ref: string };
          watchFiles: { $ref: string };
          webSocketServer: { $ref: string };
          };
          };

            property server

            server: {};
            • {S | undefined}

            property sockets

            sockets: any[];
            • {Socket[]}

            property staticWatchers

            staticWatchers: any[];
            • {FSWatcher[]}

            property webSocketServer

            webSocketServer: WebSocketServerImplementation;
            • {WebSocketServerImplementation | undefined | null}

            method findCacheDir

            static findCacheDir: () => string;
            • Returns

              {string}

            method findIp

            static findIp: (
            gatewayOrFamily: string,
            isInternal?: boolean | undefined
            ) => string | undefined;
            • Parameter gatewayOrFamily

              or family

              Parameter isInternal

              ip should be internal

              Returns

              {string | undefined}

            method getFreePort

            static getFreePort: (port: Port, host: string) => Promise<number | string>;
            • Parameter port

              Parameter host

              Returns

              {Promise<number | string>}

            method getHostname

            static getHostname: (hostname: Host) => Promise<string>;
            • Parameter hostname

              Returns

              {Promise}

            method internalIP

            static internalIP: (family: 'v4' | 'v6') => Promise<string | undefined>;
            • Parameter family

              Returns

              {Promise<string | undefined>}

            method internalIPSync

            static internalIPSync: (family: 'v4' | 'v6') => string | undefined;
            • Parameter family

              Returns

              {string | undefined}

            method invalidate

            invalidate: (
            callback?: import('webpack-dev-middleware').Callback | undefined
            ) => void;
            • Parameter callback

            method isAbsoluteURL

            static isAbsoluteURL: (URL: string) => boolean;
            • Parameter URL

              Returns

              {boolean}

            method sendMessage

            sendMessage: (
            clients: ClientConnection[],
            type: string,
            data?: any,
            params?: any
            ) => void;
            • Parameter clients

              Parameter type

              Parameter data

              Parameter params

            method start

            start: () => Promise<void>;
            • Returns

              {Promise}

            method startCallback

            startCallback: (callback?: (err?: Error) => void) => void;
            • Parameter callback

            method stop

            stop: () => Promise<void>;
            • Returns

              {Promise}

            method stopCallback

            stopCallback: (callback?: (err?: Error) => void) => void;
            • Parameter callback

            method watchFiles

            watchFiles: (
            watchPath: string | string[],
            watchOptions?: import('chokidar').WatchOptions | undefined
            ) => void;
            • Parameter watchPath

              Parameter watchOptions

            Type Aliases

            type BasicApplication

            type BasicApplication = {
            use: typeof useFn;
            };

              type BasicServer

              type BasicServer = import('net').Server | import('tls').Server;

                type Bonjour

                type Bonjour = import('bonjour-service').Bonjour;

                  type BonjourOptions

                  type BonjourOptions = import('bonjour-service').Service;

                    type ByPass

                    type ByPass = (
                    req: Request,
                    res: Response,
                    proxyConfig: ProxyConfigArrayItem
                    ) => any;

                      type ClientConfiguration

                      type ClientConfiguration = {
                      logging?: 'none' | 'error' | 'warn' | 'info' | 'log' | 'verbose' | undefined;
                      overlay?:
                      | boolean
                      | {
                      warnings?: OverlayMessageOptions;
                      errors?: OverlayMessageOptions;
                      runtimeErrors?: OverlayMessageOptions;
                      }
                      | undefined;
                      progress?: boolean | undefined;
                      reconnect?: number | boolean | undefined;
                      webSocketTransport?: string | undefined;
                      webSocketURL?: string | WebSocketURL | undefined;
                      };

                        type ClientConnection

                        type ClientConnection = (
                        | import('ws').WebSocket
                        | (import('sockjs').Connection & {
                        send: import('ws').WebSocket['send'];
                        terminate: import('ws').WebSocket['terminate'];
                        ping: import('ws').WebSocket['ping'];
                        })
                        ) & {
                        isAlive?: boolean;
                        };

                          type Compiler

                          type Compiler = import('webpack').Compiler;

                            type Configuration

                            type Configuration<
                            A extends BasicApplication = import('express').Application,
                            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<
                            import('express').Request<
                            import('express-serve-static-core').ParamsDictionary,
                            any,
                            any,
                            qs.ParsedQs,
                            Record<string, any>
                            >,
                            import('express').Response<any, Record<string, any>>
                            >
                            | undefined;
                            compress?: boolean | undefined;
                            allowedHosts?: string | string[] | undefined;
                            historyApiFallback?:
                            | boolean
                            | import('connect-history-api-fallback').Options
                            | undefined;
                            bonjour?:
                            | boolean
                            | Record<string, never>
                            | import('bonjour-service').Service
                            | 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<Request, Response> | undefined
                            ) => Headers)
                            | undefined;
                            onListening?: ((devServer: Server<A, S>) => void) | undefined;
                            setupMiddlewares?:
                            | ((middlewares: Middleware[], devServer: Server<A, S>) => Middleware[])
                            | undefined;
                            };

                              type ConnectHistoryApiFallbackOptions

                              type ConnectHistoryApiFallbackOptions =
                              import('connect-history-api-fallback').Options;

                                type DevMiddlewareContext

                                type DevMiddlewareContext<
                                T extends Request,
                                U extends Response
                                > = import('webpack-dev-middleware').Context<T, U>;

                                  type DevMiddlewareOptions

                                  type DevMiddlewareOptions<
                                  T extends Request,
                                  U extends Response
                                  > = import('webpack-dev-middleware').Options<T, U>;

                                    type ErrorHandleFunction

                                    type ErrorHandleFunction = (
                                    err: any,
                                    req: IncomingMessage,
                                    res: ServerResponse,
                                    next: NextFunction
                                    ) => void;

                                      type ExpressApplication

                                      type ExpressApplication = import('express').Application;

                                        type ExpressErrorRequestHandler

                                        type ExpressErrorRequestHandler = import('express').ErrorRequestHandler;

                                          type ExpressRequest

                                          type ExpressRequest = import('express').Request;

                                            type ExpressRequestHandler

                                            type ExpressRequestHandler = import('express').RequestHandler;

                                              type ExpressResponse

                                              type ExpressResponse = import('express').Response;

                                                type FSWatcher

                                                type FSWatcher = import('chokidar').FSWatcher;

                                                  type HandleFunction

                                                  type HandleFunction =
                                                  | SimpleHandleFunction
                                                  | NextHandleFunction
                                                  | ErrorHandleFunction;

                                                    type Headers

                                                    type Headers =
                                                    | Array<{
                                                    key: string;
                                                    value: string;
                                                    }>
                                                    | Record<string, string | string[]>;

                                                      type Host

                                                      type Host = 'local-ip' | 'local-ipv4' | 'local-ipv6' | string;

                                                        type HttpProxyMiddlewareOptions

                                                        type HttpProxyMiddlewareOptions = import('http-proxy-middleware').Options;

                                                          type HttpProxyMiddlewareOptionsFilter

                                                          type HttpProxyMiddlewareOptionsFilter = import('http-proxy-middleware').Filter;

                                                            type HTTPServer

                                                            type HTTPServer = import('http').Server;

                                                              type IncomingMessage

                                                              type IncomingMessage = import('http').IncomingMessage;

                                                                type IPv4

                                                                type IPv4 = import('ipaddr.js').IPv4;

                                                                  type IPv6

                                                                  type IPv6 = import('ipaddr.js').IPv6;

                                                                    type Middleware

                                                                    type Middleware = MiddlewareObject | MiddlewareHandler;

                                                                      type MiddlewareHandler

                                                                      type MiddlewareHandler<T extends BasicApplication = import('express').Application> =
                                                                      T extends ExpressApplication
                                                                      ? ExpressRequestHandler | ExpressErrorRequestHandler
                                                                      : HandleFunction;

                                                                        type MiddlewareObject

                                                                        type MiddlewareObject = {
                                                                        name?: string;
                                                                        path?: string;
                                                                        middleware: MiddlewareHandler;
                                                                        };

                                                                          type MultiCompiler

                                                                          type MultiCompiler = import('webpack').MultiCompiler;

                                                                            type MultiStats

                                                                            type MultiStats = import('webpack').MultiStats;

                                                                              type NetworkInterfaceInfo

                                                                              type NetworkInterfaceInfo = import('os').NetworkInterfaceInfo;

                                                                                type NextFunction

                                                                                type NextFunction = (err?: any) => void;

                                                                                  type NextHandleFunction

                                                                                  type NextHandleFunction = (
                                                                                  req: IncomingMessage,
                                                                                  res: ServerResponse,
                                                                                  next: NextFunction
                                                                                  ) => void;

                                                                                    type NormalizedOpen

                                                                                    type NormalizedOpen = {
                                                                                    target: string;
                                                                                    options: import('open').Options;
                                                                                    };

                                                                                      type NormalizedStatic

                                                                                      type NormalizedStatic = {
                                                                                      directory: string;
                                                                                      publicPath: string[];
                                                                                      serveIndex: false | ServeIndexOptions;
                                                                                      staticOptions: ServeStaticOptions;
                                                                                      watch: false | WatchOptions;
                                                                                      };

                                                                                        type Open

                                                                                        type Open = {
                                                                                        app?: string | string[] | OpenApp | undefined;
                                                                                        target?: string | string[] | undefined;
                                                                                        };

                                                                                          type OpenApp

                                                                                          type OpenApp = {
                                                                                          name?: string | undefined;
                                                                                          arguments?: string[] | undefined;
                                                                                          };

                                                                                            type OpenOptions

                                                                                            type OpenOptions = import('open').Options;

                                                                                              type OverlayMessageOptions

                                                                                              type OverlayMessageOptions = boolean | ((error: Error) => void);

                                                                                                type Port

                                                                                                type Port = number | string | 'auto';

                                                                                                  type ProxyConfigArray

                                                                                                  type ProxyConfigArray = (
                                                                                                  | ProxyConfigArrayItem
                                                                                                  | ((
                                                                                                  req?: Request | undefined,
                                                                                                  res?: Response | undefined,
                                                                                                  next?: NextFunction | undefined
                                                                                                  ) => ProxyConfigArrayItem)
                                                                                                  )[];

                                                                                                    type ProxyConfigArrayItem

                                                                                                    type ProxyConfigArrayItem = {
                                                                                                    path?: HttpProxyMiddlewareOptionsFilter | undefined;
                                                                                                    context?: HttpProxyMiddlewareOptionsFilter | undefined;
                                                                                                    } & {
                                                                                                    bypass?: ByPass;
                                                                                                    } & HttpProxyMiddlewareOptions;

                                                                                                      type Request

                                                                                                      type Request<T extends BasicApplication = import('express').Application> =
                                                                                                      T extends ExpressApplication ? ExpressRequest : IncomingMessage;

                                                                                                        type RequestHandler

                                                                                                        type RequestHandler = import('http-proxy-middleware').RequestHandler;

                                                                                                          type Response

                                                                                                          type Response<T extends BasicApplication = import('express').Application> =
                                                                                                          T extends ExpressApplication ? ExpressResponse : ServerResponse;

                                                                                                            type Schema

                                                                                                            type Schema = import('schema-utils/declarations/validate').Schema;

                                                                                                              type ServeIndexOptions

                                                                                                              type ServeIndexOptions = import('serve-index').Options;

                                                                                                                type ServerConfiguration

                                                                                                                type ServerConfiguration<
                                                                                                                A extends BasicApplication = import('express').Application,
                                                                                                                S extends BasicServer = import('http').Server<
                                                                                                                typeof import('http').IncomingMessage,
                                                                                                                typeof import('http').ServerResponse
                                                                                                                >
                                                                                                                > = {
                                                                                                                type?: ServerType<A, S> | undefined;
                                                                                                                options?: ServerOptions | undefined;
                                                                                                                };

                                                                                                                  type ServerOptions

                                                                                                                  type ServerOptions = import('https').ServerOptions & {
                                                                                                                  spdy?: {
                                                                                                                  plain?: boolean | undefined;
                                                                                                                  ssl?: boolean | undefined;
                                                                                                                  'x-forwarded-for'?: string | undefined;
                                                                                                                  protocol?: string | undefined;
                                                                                                                  protocols?: string[] | undefined;
                                                                                                                  };
                                                                                                                  };

                                                                                                                    type ServerResponse

                                                                                                                    type ServerResponse = import('http').ServerResponse;

                                                                                                                      type ServerType

                                                                                                                      type ServerType<
                                                                                                                      A extends BasicApplication = import('express').Application,
                                                                                                                      S extends BasicServer = import('http').Server<
                                                                                                                      typeof import('http').IncomingMessage,
                                                                                                                      typeof import('http').ServerResponse
                                                                                                                      >
                                                                                                                      > =
                                                                                                                      | 'http'
                                                                                                                      | 'https'
                                                                                                                      | 'spdy'
                                                                                                                      | 'http2'
                                                                                                                      | string
                                                                                                                      | ((arg0: ServerOptions, arg1: A) => S);

                                                                                                                        type ServeStaticOptions

                                                                                                                        type ServeStaticOptions = import('serve-static').ServeStaticOptions;

                                                                                                                          type SimpleHandleFunction

                                                                                                                          type SimpleHandleFunction = (req: IncomingMessage, res: ServerResponse) => void;

                                                                                                                            type Socket

                                                                                                                            type Socket = import('net').Socket;

                                                                                                                              type Static

                                                                                                                              type Static = {
                                                                                                                              directory?: string | undefined;
                                                                                                                              publicPath?: string | string[] | undefined;
                                                                                                                              serveIndex?: boolean | import('serve-index').Options | undefined;
                                                                                                                              staticOptions?:
                                                                                                                              | import('serve-static').ServeStaticOptions<
                                                                                                                              import('http').ServerResponse<import('http').IncomingMessage>
                                                                                                                              >
                                                                                                                              | undefined;
                                                                                                                              watch?:
                                                                                                                              | boolean
                                                                                                                              | (import('chokidar').WatchOptions & {
                                                                                                                              aggregateTimeout?: number;
                                                                                                                              ignored?: WatchOptions['ignored'];
                                                                                                                              poll?: number | boolean;
                                                                                                                              })
                                                                                                                              | undefined;
                                                                                                                              };

                                                                                                                                type Stats

                                                                                                                                type Stats = import('webpack').Stats;

                                                                                                                                  type StatsCompilation

                                                                                                                                  type StatsCompilation = import('webpack').StatsCompilation;

                                                                                                                                    type StatsOptions

                                                                                                                                    type StatsOptions = import('webpack').StatsOptions;

                                                                                                                                      type WatchFiles

                                                                                                                                      type WatchFiles = {
                                                                                                                                      paths: string | string[];
                                                                                                                                      options?:
                                                                                                                                      | (import('chokidar').WatchOptions & {
                                                                                                                                      aggregateTimeout?: number;
                                                                                                                                      ignored?: WatchOptions['ignored'];
                                                                                                                                      poll?: number | boolean;
                                                                                                                                      })
                                                                                                                                      | undefined;
                                                                                                                                      };

                                                                                                                                        type WatchOptions

                                                                                                                                        type WatchOptions = import('chokidar').WatchOptions;

                                                                                                                                          type WebpackConfiguration

                                                                                                                                          type WebpackConfiguration = import('webpack').Configuration;

                                                                                                                                            type WebSocketServer

                                                                                                                                            type WebSocketServer =
                                                                                                                                            | import('ws').WebSocketServer
                                                                                                                                            | (import('sockjs').Server & {
                                                                                                                                            close: import('ws').WebSocketServer['close'];
                                                                                                                                            });

                                                                                                                                              type WebSocketServerConfiguration

                                                                                                                                              type WebSocketServerConfiguration = {
                                                                                                                                              type?: string | Function | undefined;
                                                                                                                                              options?: Record<string, any> | undefined;
                                                                                                                                              };

                                                                                                                                                type WebSocketServerImplementation

                                                                                                                                                type WebSocketServerImplementation = {
                                                                                                                                                implementation: WebSocketServer;
                                                                                                                                                clients: ClientConnection[];
                                                                                                                                                };

                                                                                                                                                  type WebSocketURL

                                                                                                                                                  type WebSocketURL = {
                                                                                                                                                  hostname?: string | undefined;
                                                                                                                                                  password?: string | undefined;
                                                                                                                                                  pathname?: string | undefined;
                                                                                                                                                  port?: string | number | undefined;
                                                                                                                                                  protocol?: string | undefined;
                                                                                                                                                  username?: string | undefined;
                                                                                                                                                  };

                                                                                                                                                    Package Files (1)

                                                                                                                                                    Dependencies (28)

                                                                                                                                                    Dev Dependencies (57)

                                                                                                                                                    Peer Dependencies (1)

                                                                                                                                                    Badge

                                                                                                                                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/webpack-dev-server.

                                                                                                                                                    • Markdown
                                                                                                                                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/webpack-dev-server)
                                                                                                                                                    • HTML
                                                                                                                                                      <a href="https://www.jsdocs.io/package/webpack-dev-server"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>