@rspack/dev-middleware 0.2.12 → 2.0.0-beta.0

package/dist/index.js.LICENSE.txt

@@ -0,0 +1,19 @@
+/*!
+ * ee-first
+ * Copyright(c) 2014 Jonathan Ong
+ * MIT Licensed
+ */
+
+/*!
+ * on-finished
+ * Copyright(c) 2013 Jonathan Ong
+ * Copyright(c) 2014 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */

package/dist/rslib-runtime.js

@@ -0,0 +1,29 @@
+var __webpack_modules__ = {};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+export { __webpack_require__ };

package/package.json

@@ -1,27 +1,78 @@
 {
   "name": "@rspack/dev-middleware",
-  "version": "0.2.12",
+  "version": "2.0.0-beta.0",
+  "description": "A development middleware for Rspack",
+  "keywords": [
+    "rspack",
+    "middleware",
+    "development"
+  ],
+  "homepage": "https://github.com/rstackjs/rspack-dev-middleware",
+  "bugs": "https://github.com/rstackjs/rspack-dev-middleware/issues",
+  "repository": "rstackjs/rspack-dev-middleware",
   "license": "MIT",
-  "description": "Development middleware for rspack",
-  "main": "index.cjs",
-  "types": "dist/index.d.ts",
+  "author": "Tobias Koppers @sokra",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
   "files": [
-    "index.cjs",
-    "dist"
+    "dist",
+    "types"
   ],
-  "homepage": "https://rspack.dev",
-  "bugs": "https://github.com/web-infra-dev/rspack/issues",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/web-infra-dev/rspack",
-    "directory": "packages/rspack-dev-middleware"
+  "scripts": {
+    "build": "rslib --syntax es2023 && pnpm run build:types",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir types && prettier \"types/**/*.ts\" --write",
+    "lint": "npm-run-all -l -p \"lint:**\"",
+    "lint:prettier": "prettier --cache --list-different .",
+    "lint:spelling": "cspell --cache --no-must-find-files --quiet \"**/*.*\"",
+    "lint:types": "tsc --pretty --noEmit",
+    "prepare": "pnpm run build",
+    "test": "rstest",
+    "test:watch": "rstest -w",
+    "bump": "npx bumpp"
   },
-  "dependencies": {
-    "webpack-dev-middleware": "6.0.2",
-    "@rspack/core": "0.2.12"
+  "devDependencies": {
+    "@fastify/express": "^4.0.2",
+    "@hapi/hapi": "^21.3.7",
+    "@hono/node-server": "^1.12.0",
+    "@rslib/core": "^0.20.0",
+    "@rspack/core": "2.0.0-beta.5",
+    "@rstest/core": "0.9.2",
+    "@types/connect": "^3.4.35",
+    "@types/express": "^5.0.2",
+    "@types/node": "^22.3.0",
+    "@types/on-finished": "^2.3.4",
+    "@types/range-parser": "^1.2.7",
+    "connect": "^3.7.0",
+    "cspell": "^9.6.2",
+    "deepmerge": "^4.2.2",
+    "execa": "^5.1.1",
+    "express": "^5.1.0",
+    "fastify": "^5.2.1",
+    "file-loader": "^6.2.0",
+    "finalhandler": "^2.1.0",
+    "hono": "^4.4.13",
+    "koa": "^3.0.0",
+    "memfs": "^4.43.1",
+    "mrmime": "^2.0.1",
+    "npm-run-all": "^4.1.5",
+    "on-finished": "^2.4.1",
+    "prettier": "^3.6.0",
+    "range-parser": "^1.2.1",
+    "router": "^2.2.0",
+    "supertest": "^7.0.0",
+    "typescript": "^5.3.3"
   },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc -w"
+  "peerDependencies": {
+    "@rspack/core": "^2.0.0-0"
+  },
+  "peerDependenciesMeta": {
+    "@rspack/core": {
+      "optional": true
+    }
+  },
+  "packageManager": "pnpm@10.21.0",
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
   }
-}
+}

package/types/index.d.ts

@@ -0,0 +1,487 @@
+/** @typedef {import("@rspack/core").Compiler} Compiler */
+/** @typedef {import("@rspack/core").MultiCompiler} MultiCompiler */
+/** @typedef {import("@rspack/core").Configuration} Configuration */
+/** @typedef {import("@rspack/core").Stats} Stats */
+/** @typedef {import("@rspack/core").MultiStats} MultiStats */
+/** @typedef {import("fs").ReadStream} ReadStream */
+/**
+ * @typedef {object} ExtendedServerResponse
+ * @property {{ rspack?: { devMiddleware?: Context<IncomingMessage, ServerResponse> }, webpack?: { devMiddleware?: Context<IncomingMessage, ServerResponse> } }=} locals locals
+ */
+/** @typedef {import("http").IncomingMessage} IncomingMessage */
+/** @typedef {import("http").ServerResponse & ExtendedServerResponse} ServerResponse */
+/** @typedef {any} EXPECTED_ANY */
+/** @typedef {Function} EXPECTED_FUNCTION */
+/**
+ * @callback NextFunction
+ * @param {EXPECTED_ANY=} err error
+ * @returns {void}
+ */
+/**
+ * @typedef {NonNullable<Configuration["watchOptions"]>} WatchOptions
+ */
+/**
+ * @typedef {boolean | Configuration["devServer"] | undefined} DevServerOption
+ */
+/**
+ * @typedef {Compiler["watching"]} Watching
+ */
+/**
+ * @typedef {ReturnType<MultiCompiler["watch"]>} MultiWatching
+ */
+/**
+ * @typedef {import("@rspack/core").OutputFileSystem & { createReadStream?: import("fs").createReadStream, statSync: import("fs").statSync, readFileSync: import("fs").readFileSync }} OutputFileSystem
+ */
+/** @typedef {ReturnType<Compiler["getInfrastructureLogger"]>} Logger */
+/** @typedef {{ close(callback: (err?: Error | null | undefined) => void): void }} ClosableWatching */
+/**
+ * @callback Callback
+ * @param {(Stats | MultiStats)=} stats
+ */
+/**
+ * @typedef {object} ResponseData
+ * @property {Buffer | ReadStream} data data
+ * @property {number} byteLength byte length
+ */
+/**
+ * @template {IncomingMessage} [RequestInternal=IncomingMessage]
+ * @template {ServerResponse} [ResponseInternal=ServerResponse]
+ * @callback ModifyResponseData
+ * @param {RequestInternal} req req
+ * @param {ResponseInternal} res res
+ * @param {Buffer | ReadStream} data data
+ * @param {number} byteLength byte length
+ * @returns {ResponseData}
+ */
+/**
+ * @template {IncomingMessage} [RequestInternal=IncomingMessage]
+ * @template {ServerResponse} [ResponseInternal=ServerResponse]
+ * @typedef {object} Context
+ * @property {boolean} state state
+ * @property {Stats | MultiStats | undefined} stats stats
+ * @property {Callback[]} callbacks callbacks
+ * @property {Options<RequestInternal, ResponseInternal>} options options
+ * @property {Compiler | MultiCompiler} compiler compiler
+ * @property {Watching | MultiWatching | undefined} watching watching
+ * @property {Logger} logger logger
+ * @property {OutputFileSystem} outputFileSystem output file system
+ */
+/**
+ * @template {IncomingMessage} [RequestInternal=IncomingMessage]
+ * @template {ServerResponse} [ResponseInternal=ServerResponse]
+ * @typedef {WithoutUndefined<Context<RequestInternal, ResponseInternal>, "watching">} FilledContext
+ */
+/** @typedef {Record<string, string | number> | { key: string, value: number | string }[]} NormalizedHeaders */
+/**
+ * @template {IncomingMessage} [RequestInternal=IncomingMessage]
+ * @template {ServerResponse} [ResponseInternal=ServerResponse]
+ * @typedef {NormalizedHeaders | ((req: RequestInternal, res: ResponseInternal, context: Context<RequestInternal, ResponseInternal>) => void | undefined | NormalizedHeaders) | undefined} Headers
+ */
+/**
+ * @template {IncomingMessage} [RequestInternal = IncomingMessage]
+ * @template {ServerResponse} [ResponseInternal = ServerResponse]
+ * @typedef {object} Options
+ * @property {{ [key: string]: string }=} mimeTypes mime types
+ * @property {(string | undefined)=} mimeTypeDefault mime type default
+ * @property {(boolean | ((targetPath: string) => boolean))=} writeToDisk write to disk
+ * @property {string[]=} methods methods
+ * @property {Headers<RequestInternal, ResponseInternal>=} headers headers
+ * @property {NonNullable<Configuration["output"]>["publicPath"]=} publicPath public path
+ * @property {Configuration["stats"]=} stats stats
+ * @property {boolean=} serverSideRender is server side render
+ * @property {OutputFileSystem=} outputFileSystem output file system
+ * @property {(boolean | string)=} index index
+ * @property {ModifyResponseData<RequestInternal, ResponseInternal>=} modifyResponseData modify response data
+ * @property {"weak" | "strong"=} etag options to generate etag header
+ * @property {boolean=} lastModified options to generate last modified header
+ * @property {(boolean | number | string | { maxAge?: number, immutable?: boolean })=} cacheControl options to generate cache headers
+ * @property {boolean=} cacheImmutable is cache immutable
+ */
+/**
+ * @template {IncomingMessage} [RequestInternal=IncomingMessage]
+ * @template {ServerResponse} [ResponseInternal=ServerResponse]
+ * @callback Middleware
+ * @param {RequestInternal} req
+ * @param {ResponseInternal} res
+ * @param {NextFunction} next
+ * @returns {Promise<void>}
+ */
+/** @typedef {import("./utils/getFilenameFromUrl").Extra} Extra */
+/**
+ * @callback GetFilenameFromUrl
+ * @param {string} url
+ * @param {Extra=} extra
+ * @returns {string | undefined}
+ */
+/**
+ * @callback WaitUntilValid
+ * @param {Callback} callback
+ */
+/**
+ * @callback Invalidate
+ * @param {Callback} callback
+ */
+/**
+ * @callback Close
+ * @param {(err: Error | null | undefined) => void} callback
+ */
+/**
+ * @template {IncomingMessage} RequestInternal
+ * @template {ServerResponse} ResponseInternal
+ * @typedef {object} AdditionalMethods
+ * @property {GetFilenameFromUrl} getFilenameFromUrl get filename from url
+ * @property {WaitUntilValid} waitUntilValid wait until valid
+ * @property {Invalidate} invalidate invalidate
+ * @property {Close} close close
+ * @property {Context<RequestInternal, ResponseInternal>} context context
+ */
+/**
+ * @template {IncomingMessage} [RequestInternal=IncomingMessage]
+ * @template {ServerResponse} [ResponseInternal=ServerResponse]
+ * @typedef {Middleware<RequestInternal, ResponseInternal> & AdditionalMethods<RequestInternal, ResponseInternal>} API
+ */
+/**
+ * @template T
+ * @template {keyof T} K
+ * @typedef {Omit<T, K> & Partial<T>} WithOptional
+ */
+/**
+ * @template T
+ * @template {keyof T} K
+ * @typedef {T & { [P in K]: NonNullable<T[P]> }} WithoutUndefined
+ */
+/**
+ * @template {IncomingMessage} [RequestInternal=IncomingMessage]
+ * @template {ServerResponse} [ResponseInternal=ServerResponse]
+ * @param {Compiler | MultiCompiler} compiler compiler
+ * @param {Options<RequestInternal, ResponseInternal>=} options options
+ * @returns {API<RequestInternal, ResponseInternal>} rspack dev middleware
+ */
+export function devMiddleware<
+  RequestInternal extends IncomingMessage = import("http").IncomingMessage,
+  ResponseInternal extends ServerResponse = ServerResponse,
+>(
+  compiler: Compiler | MultiCompiler,
+  options?: Options<RequestInternal, ResponseInternal> | undefined,
+): API<RequestInternal, ResponseInternal>;
+export namespace devMiddleware {
+  export { hapiWrapper };
+  export { koaWrapper };
+  export { honoWrapper };
+}
+export type Compiler = import("@rspack/core").Compiler;
+export type MultiCompiler = import("@rspack/core").MultiCompiler;
+export type Configuration = import("@rspack/core").Configuration;
+export type Stats = import("@rspack/core").Stats;
+export type MultiStats = import("@rspack/core").MultiStats;
+export type ReadStream = import("fs").ReadStream;
+export type ExtendedServerResponse = {
+  /**
+   * locals
+   */
+  locals?:
+    | {
+        rspack?: {
+          devMiddleware?: Context<IncomingMessage, ServerResponse>;
+        };
+        webpack?: {
+          devMiddleware?: Context<IncomingMessage, ServerResponse>;
+        };
+      }
+    | undefined;
+};
+export type IncomingMessage = import("http").IncomingMessage;
+export type ServerResponse = import("http").ServerResponse &
+  ExtendedServerResponse;
+export type EXPECTED_ANY = any;
+export type EXPECTED_FUNCTION = Function;
+export type NextFunction = (err?: EXPECTED_ANY | undefined) => void;
+export type WatchOptions = NonNullable<Configuration["watchOptions"]>;
+export type DevServerOption = boolean | Configuration["devServer"] | undefined;
+export type Watching = Compiler["watching"];
+export type MultiWatching = ReturnType<MultiCompiler["watch"]>;
+export type OutputFileSystem = import("@rspack/core").OutputFileSystem & {
+  createReadStream?: typeof import("fs").createReadStream;
+  statSync: import("fs").StatSyncFn;
+  readFileSync: typeof import("fs").readFileSync;
+};
+export type Logger = ReturnType<Compiler["getInfrastructureLogger"]>;
+export type ClosableWatching = {
+  close(callback: (err?: Error | null | undefined) => void): void;
+};
+export type Callback = (stats?: (Stats | MultiStats) | undefined) => any;
+export type ResponseData = {
+  /**
+   * data
+   */
+  data: Buffer | ReadStream;
+  /**
+   * byte length
+   */
+  byteLength: number;
+};
+export type ModifyResponseData<
+  RequestInternal extends IncomingMessage = import("http").IncomingMessage,
+  ResponseInternal extends ServerResponse = ServerResponse,
+> = (
+  req: RequestInternal,
+  res: ResponseInternal,
+  data: Buffer | ReadStream,
+  byteLength: number,
+) => ResponseData;
+export type Context<
+  RequestInternal extends IncomingMessage = import("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 | undefined;
+  /**
+   * logger
+   */
+  logger: Logger;
+  /**
+   * output file system
+   */
+  outputFileSystem: OutputFileSystem;
+};
+export type FilledContext<
+  RequestInternal extends IncomingMessage = import("http").IncomingMessage,
+  ResponseInternal extends ServerResponse = ServerResponse,
+> = WithoutUndefined<Context<RequestInternal, ResponseInternal>, "watching">;
+export type NormalizedHeaders =
+  | Record<string, string | number>
+  | {
+      key: string;
+      value: number | string;
+    }[];
+export type Headers<
+  RequestInternal extends IncomingMessage = import("http").IncomingMessage,
+  ResponseInternal extends ServerResponse = ServerResponse,
+> =
+  | NormalizedHeaders
+  | ((
+      req: RequestInternal,
+      res: ResponseInternal,
+      context: Context<RequestInternal, ResponseInternal>,
+    ) => void | undefined | NormalizedHeaders)
+  | undefined;
+export type Options<
+  RequestInternal extends IncomingMessage = import("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;
+};
+export type Middleware<
+  RequestInternal extends IncomingMessage = import("http").IncomingMessage,
+  ResponseInternal extends ServerResponse = ServerResponse,
+> = (
+  req: RequestInternal,
+  res: ResponseInternal,
+  next: NextFunction,
+) => Promise<void>;
+export type Extra = import("./utils/getFilenameFromUrl").Extra;
+export type GetFilenameFromUrl = (
+  url: string,
+  extra?: Extra | undefined,
+) => string | undefined;
+export type WaitUntilValid = (callback: Callback) => any;
+export type Invalidate = (callback: Callback) => any;
+export type Close = (callback: (err: Error | null | undefined) => void) => any;
+export 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>;
+};
+export type API<
+  RequestInternal extends IncomingMessage = import("http").IncomingMessage,
+  ResponseInternal extends ServerResponse = ServerResponse,
+> = Middleware<RequestInternal, ResponseInternal> &
+  AdditionalMethods<RequestInternal, ResponseInternal>;
+export type WithOptional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
+export type WithoutUndefined<T, K extends keyof T> = T & {
+  [P in K]: NonNullable<T[P]>;
+};
+export type HapiPluginBase<S, O> = {
+  /**
+   * register
+   */
+  register: (server: S, options: O) => void | Promise<void>;
+};
+export type HapiPlugin<S, O> = HapiPluginBase<S, O> & {
+  pkg: {
+    name: string;
+  };
+  multiple: boolean;
+};
+export type HapiOptions = Options & {
+  compiler: Compiler | MultiCompiler;
+};
+/**
+ * @template S
+ * @template O
+ * @typedef {object} HapiPluginBase
+ * @property {(server: S, options: O) => void | Promise<void>} register register
+ */
+/**
+ * @template S
+ * @template O
+ * @typedef {HapiPluginBase<S, O> & { pkg: { name: string }, multiple: boolean }} HapiPlugin
+ */
+/**
+ * @typedef {Options & { compiler: Compiler | MultiCompiler }} HapiOptions
+ */
+/**
+ * @template HapiServer
+ * @template {HapiOptions} HapiOptionsInternal
+ * @returns {HapiPlugin<HapiServer, HapiOptionsInternal>} hapi wrapper
+ */
+declare function hapiWrapper<
+  HapiServer,
+  HapiOptionsInternal extends HapiOptions,
+>(): HapiPlugin<HapiServer, HapiOptionsInternal>;
+/**
+ * @template {IncomingMessage} [RequestInternal=IncomingMessage]
+ * @template {ServerResponse} [ResponseInternal=ServerResponse]
+ * @param {Compiler | MultiCompiler} compiler compiler
+ * @param {Options<RequestInternal, ResponseInternal>=} options options
+ * @returns {(ctx: EXPECTED_ANY, next: EXPECTED_FUNCTION) => Promise<void> | void} kow wrapper
+ */
+declare function koaWrapper<
+  RequestInternal extends IncomingMessage = import("http").IncomingMessage,
+  ResponseInternal extends ServerResponse = ServerResponse,
+>(
+  compiler: Compiler | MultiCompiler,
+  options?: Options<RequestInternal, ResponseInternal> | undefined,
+): (ctx: EXPECTED_ANY, next: EXPECTED_FUNCTION) => Promise<void> | void;
+/**
+ * @template {IncomingMessage} [RequestInternal=IncomingMessage]
+ * @template {ServerResponse} [ResponseInternal=ServerResponse]
+ * @param {Compiler | MultiCompiler} compiler compiler
+ * @param {Options<RequestInternal, ResponseInternal>=} options options
+ * @returns {(ctx: EXPECTED_ANY, next: EXPECTED_FUNCTION) => Promise<void> | void} hono wrapper
+ */
+declare function honoWrapper<
+  RequestInternal extends IncomingMessage = import("http").IncomingMessage,
+  ResponseInternal extends ServerResponse = ServerResponse,
+>(
+  compiler: Compiler | MultiCompiler,
+  options?: Options<RequestInternal, ResponseInternal> | undefined,
+): (ctx: EXPECTED_ANY, next: EXPECTED_FUNCTION) => Promise<void> | void;
+export {};

package/types/middleware.d.ts

@@ -0,0 +1,43 @@
+export default wrapper;
+/**
+ * send error options
+ */
+export type SendErrorOptions<
+  Request extends IncomingMessage,
+  Response extends ServerResponse,
+> = {
+  /**
+   * headers
+   */
+  headers?: Record<string, number | string | string[] | undefined> | undefined;
+  /**
+   * modify response data callback
+   */
+  modifyResponseData?:
+    | import("./index").ModifyResponseData<Request, Response>
+    | undefined;
+};
+export type NextFunction = import("./index.js").NextFunction;
+export type IncomingMessage = import("./index.js").IncomingMessage;
+export type ServerResponse = import("./index.js").ServerResponse;
+export type NormalizedHeaders = import("./index.js").NormalizedHeaders;
+export type ReadStream = import("fs").ReadStream;
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @typedef {object} SendErrorOptions send error options
+ * @property {Record<string, number | string | string[] | undefined>=} headers headers
+ * @property {import("./index").ModifyResponseData<Request, Response>=} modifyResponseData modify response data callback
+ */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("./index.js").FilledContext<Request, Response>} context context
+ * @returns {import("./index.js").Middleware<Request, Response>} wrapper
+ */
+declare function wrapper<
+  Request extends IncomingMessage,
+  Response extends ServerResponse,
+>(
+  context: import("./index.js").FilledContext<Request, Response>,
+): import("./index.js").Middleware<Request, Response>;