webpack-dev-server

webpack-dev-server

Version 5.0.4
Published 1 month ago
530 kB
30 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

Classes

class DEFAULT_STATS

class DEFAULT_STATS {}

class Server

class Server {}

constructor

constructor(options: any, compiler: any);

Parameter options
Parameter compiler

property app

app: any;

{import("express").Application | undefined}

property compiler

compiler: any;

property logger

logger: any;

{ReturnType<Compiler["getInfrastructureLogger"]>}

property middleware

middleware: any;

property options

options: Configuration;

property schema

static readonly schema: {
    title: string;
    type: string;
    definitions: {
        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;
            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[] };
        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 };
        setupExitSignals: { $ref: string };
        setupMiddlewares: { $ref: string };
        static: { $ref: string };
        watchFiles: { $ref: string };
        webSocketServer: { $ref: string };
    };
};

property server

server: any;

{import("http").Server | undefined | null}

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: (gateway: string) => string | undefined;

Parameter gateway
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 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 | undefined;
              errors?: OverlayMessageOptions | undefined;
              runtimeErrors?: OverlayMessageOptions | undefined;
          }
        | 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 = {
    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;
    https?: boolean | ServerOptions | undefined;
    http2?: boolean | undefined;
    server?: string | ServerConfiguration | 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>
          ) => Headers)
        | undefined;
    onListening?: ((devServer: Server) => void) | undefined;
    setupMiddlewares?:
        | ((middlewares: Middleware[], devServer: Server) => Middleware[])
        | undefined;
};

type ConnectHistoryApiFallbackOptions

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

type DevMiddlewareContext

type DevMiddlewareContext<
    T extends import('express').Request<
        import('express-serve-static-core').ParamsDictionary,
        any,
        any,
        qs.ParsedQs,
        Record<string, any>
    >,
    U extends import('express').Response<any, Record<string, any>>
> = import('webpack-dev-middleware').Context<T, U>;

type DevMiddlewareOptions

type DevMiddlewareOptions<
    T extends import('express').Request<
        import('express-serve-static-core').ParamsDictionary,
        any,
        any,
        qs.ParsedQs,
        Record<string, any>
    >,
    U extends import('express').Response<any, Record<string, any>>
> = import('webpack-dev-middleware').Options<T, U>;

type ExpressErrorRequestHandler

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

type ExpressRequestHandler

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

type FSWatcher

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

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 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 =
    | {
          name?: string;
          path?: string;
          middleware: ExpressRequestHandler | ExpressErrorRequestHandler;
      }
    | ExpressRequestHandler
    | ExpressErrorRequestHandler;

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 = import('express').NextFunction;

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 = import('express').Request;

type RequestHandler

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

type Response

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

type Schema

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

type ServeIndexOptions

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

type ServerConfiguration

type ServerConfiguration = {
    type?: string | 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 ServeStaticOptions

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

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 | undefined;
              ignored?: WatchOptions['ignored'];
              poll?: number | boolean | undefined;
          })
        | 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 | undefined;
              ignored?: WatchOptions['ignored'];
              poll?: number | boolean | undefined;
          })
        | 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)

types/lib/Server.d.ts

Peer Dependencies (1)

webpack

Badge

To add a badge like this oneto 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>

Updated 1 month ago.
Package analyzed in 4773 ms.
Missing or incorrect documentation? Open an issue for this package.

webpack-dev-server

Install

Overview

Index

Classes

Type Aliases

Classes

class DEFAULT_STATS

class Server

constructor

Parameter options

Parameter compiler

property app

property compiler

property logger

property middleware

property options

property schema

property server

property sockets

property staticWatchers

property webSocketServer

method findCacheDir

Returns

method findIp

Parameter gateway

Returns

method getFreePort

Parameter port

Parameter host

Returns

method getHostname

Parameter hostname

Returns

method internalIP

Parameter family

Returns

method internalIPSync

Parameter family

Returns

method invalidate

Parameter callback

method isAbsoluteURL

Parameter URL

Returns

method sendMessage

Parameter clients

Parameter type

Parameter data

Parameter params

method start

Returns

method startCallback

Parameter callback

method stop

Returns

method stopCallback

Parameter callback

method watchFiles

Parameter watchPath

Parameter watchOptions

Type Aliases

type Bonjour

type BonjourOptions

type ByPass

type ClientConfiguration

type ClientConnection

type Compiler

type Configuration

type ConnectHistoryApiFallbackOptions

type DevMiddlewareContext

type DevMiddlewareOptions

type ExpressErrorRequestHandler

type ExpressRequestHandler

type FSWatcher

type Headers

type Host

type HttpProxyMiddlewareOptions

type HttpProxyMiddlewareOptionsFilter

type IncomingMessage