keq 2.0.8 → 2.1.0

package/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+  "[markdown]": {
+    "editor.formatOnSave": false
+  }
+}

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.1.0](https://github.com/keq-request/keq/compare/v2.0.8...v2.1.0) (2024-01-05)
+
+
+### Features
+
+* add .route to Router ([dc27057](https://github.com/keq-request/keq/commit/dc27057b3c85ab8a52fe51892f4aa5792f53898d))
+* flow control function for sending multiple requests ([5d24adf](https://github.com/keq-request/keq/commit/5d24adffaf26181ebd296b97ea3062514354f7e0))
+
 ## [2.0.8](https://github.com/keq-request/keq/compare/v2.0.7...v2.0.8) (2024-01-02)
 
 

package/README.md

@@ -113,10 +113,12 @@ You may also pass an object or `Headers` to set several fields in a single call:
 ```javascript
 import { request } from "keq";
 
-await request.get("/search").set({
-  "X-Origin-Host": "https://example.com",
-  Accept: "application/json",
-});
+await request
+  .get("/search")
+  .set({
+    "X-Origin-Host": "https://example.com",
+    Accept: "application/json",
+  });
 ```
 
 ### Request query
@@ -153,7 +155,9 @@ The follwing will produce the path `/search/keq`.
 ```javascript
 import { request } from "keq";
 
-await request.get("/search/:searchKey").params("searchKey", "keq");
+await request
+  .get("/search/:searchKey")
+  .params("searchKey", "keq");
 ```
 
 Or as a single object:
@@ -161,7 +165,9 @@ Or as a single object:
 ```javascript
 import { request } from "keq";
 
-await request.get("/search/:searchKey").params({ searchKey: "keq" });
+await request
+  .get("/search/:searchKey")
+  .params({ searchKey: "keq" });
 ```
 
 ### JSON Request
@@ -251,7 +257,9 @@ or simply the extension name such as "xml", "json", "png", etc:
 ```javascript
 import { request } from "keq";
 
-await request.post("/user").type("json");
+await request
+  .post("/user")
+  .type("json");
 ```
 
 | **Shorthand**                                 | **Mime Type**                                                                                 |
@@ -276,14 +284,16 @@ No retry by default, invoke `.retry(retryTimes[, retryDelay[, retryOn]])` to set
 ```javascript
 import { request } from "keq";
 
-await request.get("http://test.com").retry(2, 1000, (attempt, err, ctx) => {
-  if (err) {
-    console.log("an error throw");
-    return true;
-  }
-
-  return false;
-});
+await request
+  .get("http://test.com")
+  .retry(2, 1000, (attempt, err, ctx) => {
+    if (err) {
+      console.log("an error throw");
+      return true;
+    }
+
+    return false;
+  });
 ```
 
 ### Set Request Redirect mode
@@ -293,7 +303,9 @@ Follow redirect by default, invoke `.redirect(mode)` to set the redirect mode. A
 ```javascript
 import { request } from "keq";
 
-await request.get("http://test.com").redirect("manual");
+await request
+  .get("http://test.com")
+  .redirect("manual");
 ```
 
 ### Set Request Credentials And Mode
@@ -303,7 +315,10 @@ These two parameters are used to control cross-domain requests.
 ```javascript
 import { request } from "keq";
 
-await request.get("http://test.com").mode("cors").credentials("include");
+await request
+  .get("http://test.com")
+  .mode("cors")
+  .credentials("include");
 ```
 
 ### Keq Internal Options
@@ -328,10 +343,12 @@ Or as a single object:
 ```javascript
 import { request } from "keq";
 
-await request.get("http://test.com").options({
-  resolveWithFullResponse: true,
-  middlewareOption: "value",
-});
+await request
+  .get("http://test.com")
+  .options({
+    resolveWithFullResponse: true,
+    middlewareOption: "value",
+  });
 ```
 
 | **Option**                | **Description**                                                                                         |
@@ -341,6 +358,53 @@ await request.get("http://test.com").options({
 
 <!-- ###### The options with **DEPRECATED** will be removed in next major version -->
 
+### Flow Control
+
+Controlling the behavior of sending requests multiple times.
+
+#### Abort
+
+If the previous request was not completed, abort the last request.
+
+```javascript
+import { request } from "keq";
+
+request
+  .get("http://test.com/cat")
+  // second args is the abort signal
+  // this will abort the request with same signal
+  // a unique signal will be generated, if not signal set.
+  .followControl("abort", 'animal');
+  .end()
+
+request
+  .get("http://test.com/dog")
+  // abort http://test.com/cat
+  .followControl("abort", 'animal')
+  .end()
+```
+
+#### Serial
+
+The next request will not start until the previous request is completed.
+
+```javascript
+import { request } from "keq";
+
+request
+  .get("http://test.com/cat")
+  // a unique signal will be generated, if signal is not set.
+  .followControl("serial", 'animal');
+  .end()
+
+// This request will be send after https://test.com/cat is complete
+request
+  .get("http://test.com/dog")
+  .followControl("serial", 'animal')
+  .end()
+```
+​
+
 ### Middleware
 
 You can extend `Keq` by write/import middleware.
@@ -389,6 +453,10 @@ request
    * used with keq-cli
    */
   .module('yourServiceName',middleware)
+  /**
+   * this middleware run when pathname start with '/api'
+   */
+  .route((ctx) => ctx.pathname.startsWith('/api'), middleware)
 
 await request
   .get("http://test.com")
@@ -450,6 +518,7 @@ This is the utils used to route middleware.
 | `.pathname(matcher: string \| Regexp[, ...middlewares])` |
 | `.host(host: string[, ...middlewares])`                  |
 | `.module(moduleName: string[, ...middlewares])`          |
+| `.route(...middlewares)`                                 |
 
 ### Create Request
 

package/dist/esm/src/core.d.ts

@@ -9,10 +9,11 @@ import { KeqRequestInit } from './types/keq-request-init';
 export declare class Core<T> {
     private requestPromise?;
     protected requestContext: KeqRequestContext;
+    protected __global__: Record<string, any>;
     protected __prepend_middlewares__: KeqMiddleware[];
     protected __append_middlewares__: KeqMiddleware[];
     protected __options__: KeqOptions;
-    constructor(url: (URL | globalThis.URL), init: KeqRequestInit);
+    constructor(url: (URL | globalThis.URL), init: KeqRequestInit, global?: Record<string, any>);
     prependMiddlewares(...middlewares: KeqMiddleware[]): this;
     appendMiddlewares(...middlewares: KeqMiddleware[]): this;
     private run;

package/dist/esm/src/core.js

@@ -2,7 +2,7 @@ import { URL } from 'whatwg-url';
 import { Exception } from "./exception/exception";
 import { clone } from "./util/clone";
 import { OUTPUT_PROPERTY } from './constant';
-import { composeMiddleware } from './middleware';
+import { composeMiddleware } from './util/compose-middleware';
 import { shadowClone } from './util/shadow-clone';
 /**
  * @description Keq 核心 API，发送请求必要的原子化的API
@@ -10,10 +10,12 @@ import { shadowClone } from './util/shadow-clone';
 export class Core {
     requestPromise;
     requestContext;
+    __global__;
     __prepend_middlewares__ = [];
     __append_middlewares__ = [];
     __options__ = { resolveWithFullResponse: false };
-    constructor(url, init) {
+    constructor(url, init, global = {}) {
+        this.__global__ = global;
         this.requestContext = {
             method: 'get',
             headers: new Headers(),
@@ -42,11 +44,21 @@ export class Core {
             headers,
             routeParams: shadowClone(this.requestContext.routeParams),
             body: clone(this.requestContext.body),
+            cache: this.requestContext.cache,
+            credentials: this.requestContext.credentials,
+            integrity: this.requestContext.integrity,
+            keepalive: this.requestContext.keepalive,
+            mode: this.requestContext.mode,
+            redirect: this.requestContext.redirect,
+            referrer: this.requestContext.referrer,
+            referrerPolicy: this.requestContext.referrerPolicy,
+            signal: this.requestContext.signal,
         };
         const options = shadowClone(this.__options__);
         const ctx = {
             request: requestContext,
             options,
+            global: this.__global__,
             get output() {
                 throw new Exception('output property is write-only');
             },

package/dist/esm/src/create-request.js

@@ -1,62 +1,41 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 import { URL } from 'whatwg-url';
-import { KeqHostRouter } from "./router/keq-host-router";
-import { KeqLocationRouter } from "./router/keq-location-router";
-import { KeqMethodRouter } from "./router/keq-method-router";
-import { KeqModuleRouter } from "./router/keq-module-router";
-import { KeqPathnameRouter } from "./router/keq-pathname-router";
 import { isBrowser } from './is/is-browser';
 import { Keq } from './keq';
+import { abortFlowControlMiddleware } from './middlewares/abort-flow-control-middleware.js';
 import { fetchArgumentsMiddleware } from './middlewares/fetch-arguments-middleware';
 import { fetchMiddleware } from './middlewares/fetch-middleware';
 import { proxyResponseMiddleware } from './middlewares/proxy-response-middleware';
 import { retryMiddleware } from './middlewares/retry-middleware';
+import { serialFlowControlMiddleware } from './middlewares/serial-flow-control-middleware.js';
+import { KeqRouter } from './router/keq-router.js';
 export function createRequest(options) {
     let baseOrigin = options?.baseOrigin;
     if (isBrowser() && !baseOrigin)
         baseOrigin = location.origin;
     const appendMiddlewares = options?.initMiddlewares ? [...options.initMiddlewares] : [
+        serialFlowControlMiddleware(),
+        abortFlowControlMiddleware(),
         proxyResponseMiddleware(),
         fetchArgumentsMiddleware(),
         retryMiddleware(),
         fetchMiddleware(),
     ];
     const prependMiddlewares = [];
+    /**
+     * share data between requests, used to implement flowControl
+     * @description 跨请求共享数据，用于实现 flowControl的功能
+     */
+    const global = {};
     const formatUrl = (url) => {
         if (typeof url === 'string') {
             return new URL(url, baseOrigin);
         }
         return new URL(url.href);
     };
-    const routerMap = {
-        host: (host, ...middlewares) => {
-            const route = new KeqHostRouter(host, middlewares);
-            prependMiddlewares.push(route.routes());
-            return routerMap;
-        },
-        method: (method, ...middlewares) => {
-            const route = new KeqMethodRouter(method, middlewares);
-            prependMiddlewares.push(route.routes());
-            return routerMap;
-        },
-        pathname: (pathname, ...middlewares) => {
-            const route = new KeqPathnameRouter(pathname, middlewares);
-            prependMiddlewares.push(route.routes());
-            return routerMap;
-        },
-        location: (...middlewares) => {
-            const route = new KeqLocationRouter(middlewares);
-            prependMiddlewares.push(route.routes());
-            return routerMap;
-        },
-        module: (moduleName, ...middlewares) => {
-            const route = new KeqModuleRouter(moduleName, middlewares);
-            prependMiddlewares.push(route.routes());
-            return routerMap;
-        },
-    };
+    const router = new KeqRouter(prependMiddlewares);
     const request = function (url, init) {
-        const keq = new Keq(formatUrl(url), init);
+        const keq = new Keq(formatUrl(url), { ...init }, global);
         keq.appendMiddlewares(...appendMiddlewares);
         keq.prependMiddlewares(...prependMiddlewares);
         return keq;
@@ -65,41 +44,41 @@ export function createRequest(options) {
         baseOrigin = origin;
     };
     request.useRouter = function useRouter() {
-        return routerMap;
+        return router;
     };
     request.get = function (url) {
-        const keq = new Keq(formatUrl(url), { method: 'get' });
+        const keq = new Keq(formatUrl(url), { method: 'get' }, global);
         keq.appendMiddlewares(...appendMiddlewares);
         keq.prependMiddlewares(...prependMiddlewares);
         return keq;
     };
     request.put = function (url) {
-        const keq = new Keq(formatUrl(url), { method: 'put' });
+        const keq = new Keq(formatUrl(url), { method: 'put' }, global);
         keq.appendMiddlewares(...appendMiddlewares);
         keq.prependMiddlewares(...prependMiddlewares);
         return keq;
     };
     request.delete = function (url) {
-        const keq = new Keq(formatUrl(url), { method: 'delete' });
+        const keq = new Keq(formatUrl(url), { method: 'delete' }, global);
         keq.appendMiddlewares(...appendMiddlewares);
         keq.prependMiddlewares(...prependMiddlewares);
         return keq;
     };
     request.del = request.delete;
     request.post = function (url) {
-        const keq = new Keq(formatUrl(url), { method: 'post' });
+        const keq = new Keq(formatUrl(url), { method: 'post' }, global);
         keq.appendMiddlewares(...appendMiddlewares);
         keq.prependMiddlewares(...prependMiddlewares);
         return keq;
     };
     request.head = function (url) {
-        const keq = new Keq(formatUrl(url), { method: 'head' });
+        const keq = new Keq(formatUrl(url), { method: 'head' }, global);
         keq.appendMiddlewares(...appendMiddlewares);
         keq.prependMiddlewares(...prependMiddlewares);
         return keq;
     };
     request.patch = function (url) {
-        const keq = new Keq(formatUrl(url), { method: 'patch' });
+        const keq = new Keq(formatUrl(url), { method: 'patch' }, global);
         keq.appendMiddlewares(...appendMiddlewares);
         keq.prependMiddlewares(...prependMiddlewares);
         return keq;

package/dist/esm/src/index.d.ts

@@ -1,13 +1,21 @@
-export { createRequest } from './create-request';
-export { Keq } from './keq';
-export { composeMiddleware } from './middleware';
-export { request } from './request';
-export { KeqContext } from './types/keq-context';
-export { KeqMiddleware } from './types/keq-middleware';
-export { KeqNext } from './types/keq-next';
-export { KeqOptions } from './types/keq-options';
-export { KeqRequest } from './types/keq-request';
-export { KeqRequestBody } from './types/keq-request-body';
-export { KeqRequestInit } from './types/keq-request-init';
-export { KeqRetryDelay } from './types/keq-retry-delay';
-export { KeqRetryOn } from './types/keq-retry-on';
+export { createRequest } from './create-request.js';
+export { Keq } from './keq.js';
+export { request } from './request.js';
+export { composeMiddleware } from './util/compose-middleware.js';
+export { composeRoute } from './util/compose-route.js';
+export { KeqContext } from './types/keq-context.js';
+export { KeqMiddleware } from './types/keq-middleware.js';
+export { KeqNext } from './types/keq-next.js';
+export { KeqOptions } from './types/keq-options.js';
+export { KeqRequestBody } from './types/keq-request-body.js';
+export { KeqRequestInit } from './types/keq-request-init.js';
+export { KeqRequest } from './types/keq-request.js';
+export { KeqRetryDelay } from './types/keq-retry-delay.js';
+export { KeqRetryOn } from './types/keq-retry-on.js';
+export { KeqRoute } from './types/keq-route.js';
+export { keqHostRoute } from './router/keq-host-route.js';
+export { keqLocationRoute } from './router/keq-location-route.js';
+export { keqMethodRoute } from './router/keq-method-route.js';
+export { keqModuleRoute } from './router/keq-module-route.js';
+export { keqPathnameRoute } from './router/keq-pathname-route.js';
+export { KeqRouter } from './router/keq-router.js';

package/dist/esm/src/index.js

@@ -1,4 +1,11 @@
-export { createRequest } from './create-request';
-export { Keq } from './keq';
-export { composeMiddleware } from './middleware';
-export { request } from './request';
+export { createRequest } from './create-request.js';
+export { Keq } from './keq.js';
+export { request } from './request.js';
+export { composeMiddleware } from './util/compose-middleware.js';
+export { composeRoute } from './util/compose-route.js';
+export { keqHostRoute } from './router/keq-host-route.js';
+export { keqLocationRoute } from './router/keq-location-route.js';
+export { keqMethodRoute } from './router/keq-method-route.js';
+export { keqModuleRoute } from './router/keq-module-route.js';
+export { keqPathnameRoute } from './router/keq-pathname-route.js';
+export { KeqRouter } from './router/keq-router.js';

package/dist/esm/src/keq.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { Core } from './core';
+import { KeqFlowControlMode, KeqFlowControlSignal } from './types/keq-flow-control.js';
 import { KeqMiddleware } from './types/keq-middleware';
 import { KeqBuildInOptions, KeqOptions, KeqOptionsWithFullResponse, KeqOptionsWithoutFullResponse } from './types/keq-options';
 import { KeqRequestBody } from './types/keq-request-body';
@@ -11,11 +12,11 @@ import { ShorthandContentType } from './types/shorthand-content-type';
  */
 export declare class Keq<T> extends Core<T> {
     use(...middlewares: KeqMiddleware[]): this;
-    option(key: 'resolveWithFullResponse', value?: true): Core<Response>;
+    option(key: 'resolveWithFullResponse', value?: true): Keq<Response>;
     option<K extends keyof KeqBuildInOptions>(key: K, value?: KeqBuildInOptions[K]): this;
     option(key: string, value?: any): this;
     options(opts: KeqOptionsWithoutFullResponse): this;
-    options(opts: KeqOptionsWithFullResponse): Core<Response>;
+    options(opts: KeqOptionsWithFullResponse): Keq<Response>;
     options(opts: KeqOptions): this;
     /**
      * Set request header
@@ -67,4 +68,5 @@ export declare class Keq<T> extends Core<T> {
     redirect(mod: RequestRedirect): this;
     credentials(mod: RequestCredentials): this;
     mode(mod: RequestMode): this;
+    flowControl(mode: KeqFlowControlMode, signal?: KeqFlowControlSignal): this;
 }

package/dist/esm/src/keq.js

@@ -9,6 +9,7 @@ import { isUrlSearchParams } from './is/is-url-search-params';
 import { assignKeqRequestBody } from './util/assign-keq-request-body';
 import { base64Encode } from './util/base64';
 import { fixContentType } from './util/fix-content-type';
+import { getUniqueCodeIdentifier } from './util/get-unique-code-identifier.js';
 /**
  * @description Keq 扩展 API，人性化的常用的API
  */
@@ -176,4 +177,16 @@ export class Keq extends Core {
         this.requestContext.mode = mod;
         return this;
     }
+    flowControl(mode, signal) {
+        const sig = signal ? signal : getUniqueCodeIdentifier(1);
+        if (!sig) {
+            throw new Exception('please set signal to .flowControl()');
+        }
+        const flowControl = {
+            mode,
+            signal: sig,
+        };
+        this.option('flowControl', flowControl);
+        return this;
+    }
 }

package/dist/esm/src/middlewares/abort-flow-control-middleware.d.ts

@@ -0,0 +1,2 @@
+import { KeqMiddleware } from "../types/keq-middleware.js";
+export declare function abortFlowControlMiddleware(): KeqMiddleware;

package/dist/esm/src/middlewares/abort-flow-control-middleware.js

@@ -0,0 +1,26 @@
+export function abortFlowControlMiddleware() {
+    return async (ctx, next) => {
+        if (!ctx.options.flowControl || ctx.options.flowControl.mode !== 'abort') {
+            await next();
+            return;
+        }
+        if (ctx.request.signal) {
+            console.warn('[keq] request signal had be set manual, abort follow control will not take effect');
+            await next();
+            return;
+        }
+        const { signal } = ctx.options.flowControl;
+        const key = typeof signal === 'string' ? signal : signal(ctx);
+        if (!ctx.global.abortFlowControl)
+            ctx.global.abortFlowControl = {};
+        if (ctx.global.abortFlowControl[key]) {
+            const abortController = ctx.global.abortFlowControl[key];
+            abortController.abort('abort flow control');
+        }
+        const abortController = new AbortController();
+        ctx.global.abortFlowControl[key] = abortController;
+        ctx.request.signal = abortController.signal;
+        await next();
+        ctx.global.abortFlowControl[key] = undefined;
+    };
+}

package/dist/esm/src/middlewares/fetch-arguments-middleware.js

@@ -75,6 +75,15 @@ export function fetchArgumentsMiddleware() {
             method: request.method.toUpperCase(),
             headers: request.headers,
             body: compileBody(ctx),
+            cache: request.cache,
+            credentials: request.credentials,
+            integrity: request.integrity,
+            keepalive: request.keepalive,
+            mode: request.mode,
+            redirect: request.redirect,
+            referrer: request.referrer,
+            referrerPolicy: request.referrerPolicy,
+            signal: request.signal,
         };
         ctx.fetchArguments = [url, requestInit];
         await next();

package/dist/esm/src/middlewares/serial-flow-control-middleware.d.ts

@@ -0,0 +1,2 @@
+import { KeqMiddleware } from "../types/keq-middleware.js";
+export declare function serialFlowControlMiddleware(): KeqMiddleware;

package/dist/esm/src/middlewares/serial-flow-control-middleware.js

@@ -0,0 +1,20 @@
+import * as fastq from 'fastq';
+export function serialFlowControlMiddleware() {
+    return async (ctx, next) => {
+        if (!ctx.options.flowControl || ctx.options.flowControl.mode !== 'serial') {
+            await next();
+            return;
+        }
+        const { signal } = ctx.options.flowControl;
+        const key = typeof signal === 'string' ? signal : signal(ctx);
+        if (!ctx.global.serialFlowControl)
+            ctx.global.serialFlowControl = {};
+        if (!ctx.global.serialFlowControl[key]) {
+            ctx.global.serialFlowControl[key] = fastq.promise(async (next) => {
+                await next();
+            }, 1);
+        }
+        const queue = ctx.global.serialFlowControl[key];
+        await queue.push(next);
+    };
+}

package/dist/esm/src/router/keq-host-route.d.ts

@@ -0,0 +1,2 @@
+import { KeqRoute } from "../types/keq-route.js";
+export declare function keqHostRoute(host: string): KeqRoute;

package/dist/esm/src/router/keq-host-route.js

@@ -0,0 +1,3 @@
+export function keqHostRoute(host) {
+    return (ctx) => ctx.request.url.host === host;
+}

package/dist/esm/src/router/keq-location-route.d.ts

@@ -0,0 +1,2 @@
+import { KeqRoute } from "../types/keq-route.js";
+export declare function keqLocationRoute(): KeqRoute;

package/dist/esm/src/router/keq-location-route.js

@@ -0,0 +1,4 @@
+import { isBrowser } from "../is/is-browser.js";
+export function keqLocationRoute() {
+    return (ctx) => isBrowser() && ctx.request.url.host === window.location.host;
+}

package/dist/esm/src/router/keq-method-route.d.ts

@@ -0,0 +1,2 @@
+import { KeqRoute } from "../types/keq-route.js";
+export declare function keqMethodRoute(method: any): KeqRoute;

package/dist/esm/src/router/keq-method-route.js

@@ -0,0 +1,3 @@
+export function keqMethodRoute(method) {
+    return (ctx) => ctx.request.method.toLowerCase() === method.toLowerCase();
+}

package/dist/esm/src/router/keq-module-route.d.ts

@@ -0,0 +1,2 @@
+import { KeqRoute } from "../types/keq-route.js";
+export declare function keqModuleRoute(moduleName: string): KeqRoute;

package/dist/esm/src/router/keq-module-route.js

@@ -0,0 +1,7 @@
+import { Exception } from "../exception/exception.js";
+export function keqModuleRoute(moduleName) {
+    if (!moduleName) {
+        throw new Exception('Module name should not be empty');
+    }
+    return (ctx) => ctx.options.module?.name === moduleName;
+}

package/dist/esm/src/router/keq-pathname-route.d.ts

@@ -0,0 +1,2 @@
+import { KeqRoute } from "../types/keq-route.js";
+export declare function keqPathnameRoute(pathname: string): KeqRoute;

package/dist/esm/src/router/keq-pathname-route.js

@@ -0,0 +1,4 @@
+import { minimatch } from 'minimatch';
+export function keqPathnameRoute(pathname) {
+    return (ctx) => minimatch(ctx.request.url.pathname, pathname);
+}

package/dist/esm/src/router/keq-router.d.ts

@@ -1,7 +1,12 @@
 import { KeqMiddleware } from "../types/keq-middleware";
-export declare abstract class KeqRouter {
-    protected middlewares: KeqMiddleware[];
-    constructor(middlewares: KeqMiddleware[]);
-    use(middleware: KeqMiddleware, ...middlewares: KeqMiddleware[]): this;
-    abstract routes(): KeqMiddleware;
+import { KeqRoute } from "../types/keq-route.js";
+export declare class KeqRouter {
+    private readonly prependMiddlewares;
+    constructor(prependMiddlewares?: KeqMiddleware[]);
+    route(route: KeqRoute, ...middlewares: KeqMiddleware[]): this;
+    host(host: string, ...middlewares: KeqMiddleware[]): this;
+    method(method: string, ...middlewares: KeqMiddleware[]): this;
+    pathname(pathname: string, ...middlewares: KeqMiddleware[]): this;
+    location(...middlewares: KeqMiddleware[]): this;
+    module(moduleName: string, ...middlewares: KeqMiddleware[]): this;
 }