webpack-dev-middleware

hapiWrapper: <HapiServer, HapiOptionsInternal extends HapiOptions>(
    usePlugin?: boolean | undefined
) => HapiPlugin<HapiServer, HapiOptionsInternal>;

honoWrapper: <
    RequestInternal extends any = any,
    ResponseInternal extends unknown = any
>(
    compiler: Compiler | MultiCompiler,
    options?: Options<RequestInternal, ResponseInternal> | undefined,
    usePlugin?: boolean | undefined
) => (ctx: EXPECTED_ANY, next: EXPECTED_FUNCTION) => Promise<void> | void;

koaWrapper: <
    RequestInternal extends any = any,
    ResponseInternal extends unknown = any
>(
    compiler: Compiler | MultiCompiler,
    options?: Options<RequestInternal, ResponseInternal> | undefined,
    usePlugin?: boolean | undefined
) => (ctx: EXPECTED_ANY, next: EXPECTED_FUNCTION) => Promise<void> | void;

wdm: typeof wdm;

type AdditionalMethods<
    RequestInternal extends IncomingMessage,
    ResponseInternal extends ServerResponse
> = {
    /**
     * get filename from url
     */
    getFilenameFromUrl: GetFilenameFromUrl;
    /**
     * wait until valid
     */
    waitUntilValid: WaitUntilValid;
    /**
     * invalidate
     */
    invalidate: Invalidate;
    /**
     * close
     */
    close: Close;
    /**
     * context
     */
    context: Context<RequestInternal, ResponseInternal>;
};

type API<
    RequestInternal extends IncomingMessage = import('node:http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = Middleware<RequestInternal, ResponseInternal> &
    AdditionalMethods<RequestInternal, ResponseInternal>;

type Callback = (stats?: (Stats | MultiStats) | undefined) => any;

type Close = (callback: (err: Error | null | undefined) => void) => any;

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

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

type Context<
    RequestInternal extends IncomingMessage = import('node:http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = {
    /**
     * state
     */
    state: boolean;
    /**
     * stats
     */
    stats: Stats | MultiStats | undefined;
    /**
     * callbacks
     */
    callbacks: Callback[];
    /**
     * options
     */
    options: Options<RequestInternal, ResponseInternal>;
    /**
     * compiler
     */
    compiler: Compiler | MultiCompiler;
    /**
     * watching
     */
    watching: Watching | MultiWatching;
    /**
     * logger
     */
    logger: Logger;
    /**
     * output file system
     */
    outputFileSystem: OutputFileSystem;
    /**
     * hot module replacement instance
     */
    hot?: HotInstance | undefined;
};

type EXPECTED_ANY = any;

type EXPECTED_FUNCTION = Function;

type ExtendedServerResponse = {
    /**
     * locals
     */
    locals?:
        | {
              webpack?: {
                  devMiddleware?: Context<IncomingMessage, ServerResponse>;
              };
          }
        | undefined;
};

type FilenameWithExtra = import('./middleware').FilenameWithExtra;

type FilledContext<
    RequestInternal extends IncomingMessage = import('node:http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = WithoutUndefined<Context<RequestInternal, ResponseInternal>, 'watching'>;

type GetFilenameFromUrl = (url: string) => Promise<FilenameWithExtra | undefined>;

type HapiOptions = Options & {
    compiler: Compiler | MultiCompiler;
};

type HapiPlugin<S, O> = HapiPluginBase<S, O> & {
    pkg: {
        name: string;
    };
    multiple: boolean;
};

type HapiPluginBase<S, O> = {
    /**
     * register
     */
    register: (server: S, options: O) => void | Promise<void>;
};

type Headers<
    RequestInternal extends IncomingMessage = import('node:http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> =
    | NormalizedHeaders
    | ((
          req: RequestInternal,
          res: ResponseInternal,
          context: Context<RequestInternal, ResponseInternal>
      ) => void | undefined | NormalizedHeaders)
    | undefined;

type HotInstance = import('./hot').HotInstance;

type HotOptions = import('./hot').HotOptions;

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

type Invalidate = (callback: Callback) => any;

type Logger = ReturnType<Compiler['getInfrastructureLogger']>;

type Middleware<
    RequestInternal extends IncomingMessage = import('node:http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = (
    req: RequestInternal,
    res: ResponseInternal,
    next: NextFunction
) => Promise<void>;

type ModifyResponseData<
    RequestInternal extends IncomingMessage = import('node:http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = (
    req: RequestInternal,
    res: ResponseInternal,
    data: Buffer | ReadStream,
    byteLength: number
) => ResponseData;

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

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

type MultiStatsOptions = {
    children: Configuration['stats'][];
};

type MultiWatching = ReturnType<MultiCompiler['watch']>;

type NextFunction = (err?: EXPECTED_ANY | undefined) => void;

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

type Options<
    RequestInternal extends IncomingMessage = import('node:http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = {
    /**
     * mime types
     */
    mimeTypes?:
        | {
              [key: string]: string;
          }
        | undefined;
    /**
     * mime type default
     */
    mimeTypeDefault?: (string | undefined) | undefined;
    /**
     * write to disk
     */
    writeToDisk?: (boolean | ((targetPath: string) => boolean)) | undefined;
    /**
     * methods
     */
    methods?: string[] | undefined;
    /**
     * headers
     */
    headers?: Headers<RequestInternal, ResponseInternal> | undefined;
    /**
     * public path
     */
    publicPath?: NonNullable<Configuration['output']>['publicPath'] | undefined;
    /**
     * stats
     */
    stats?: Configuration['stats'] | undefined;
    /**
     * is server side render
     */
    serverSideRender?: boolean | undefined;
    /**
     * output file system
     */
    outputFileSystem?: OutputFileSystem | undefined;
    /**
     * index
     */
    index?: (boolean | string) | undefined;
    /**
     * modify response data
     */
    modifyResponseData?:
        | ModifyResponseData<RequestInternal, ResponseInternal>
        | undefined;
    /**
     * options to generate etag header
     */
    etag?: ('weak' | 'strong') | undefined;
    /**
     * options to generate last modified header
     */
    lastModified?: boolean | undefined;
    /**
     * options to generate cache headers
     */
    cacheControl?:
        | (
              | boolean
              | number
              | string
              | {
                    maxAge?: number;
                    immutable?: boolean;
                }
          )
        | undefined;
    /**
     * is cache immutable
     */
    cacheImmutable?: boolean | undefined;
    /**
     * forward error to next middleware
     */
    forwardError?: boolean | undefined;
    /**
     * enable hot module replacement
     */
    hot?: (boolean | HotOptions) | undefined;
};

type OutputFileSystem = import('webpack').OutputFileSystem & {
    createReadStream?: typeof fs.createReadStream;
    statSync: typeof fs.statSync;
    readFileSync: typeof fs.readFileSync;
};

type ReadStream = import('fs').ReadStream;

type ResponseData = {
    /**
     * data
     */
    data: Buffer | ReadStream;
    /**
     * byte length
     */
    byteLength: number;
};

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

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

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

type StatsObjectOptions = Exclude<
    Configuration['stats'],
    boolean | string | undefined
>;

type StatsOptions = Configuration['stats'];

type WaitUntilValid = (callback: Callback) => any;

type Watching = Compiler['watching'];

type WatchOptions = NonNullable<Configuration['watchOptions']>;

type WithOptional<T, K extends keyof T> = Omit<T, K> & Partial<T>;

type WithoutUndefined<T, K extends keyof T> = T & {
    [P in K]: NonNullable<T[P]>;
};