@eggjs/router 3.0.6 → 4.0.0-beta.17

package/dist/esm/index.d.ts

@@ -1,7 +0,0 @@
-import { Router } from './Router.js';
-export type * from './types.js';
-export * from './Layer.js';
-export * from './Router.js';
-export * from './EggRouter.js';
-export declare const KoaRouter: typeof Router;
-export default Router;

package/dist/esm/index.js

@@ -1,7 +0,0 @@
-import { Router } from './Router.js';
-export * from './Layer.js';
-export * from './Router.js';
-export * from './EggRouter.js';
-export const KoaRouter = Router;
-export default Router;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUdyQyxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDO0FBRS9CLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxNQUFNLENBQUM7QUFDaEMsZUFBZSxNQUFNLENBQUMifQ==

package/dist/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/dist/esm/types.d.ts

@@ -1,18 +0,0 @@
-export type Next = () => Promise<void>;
-export type MiddlewareFunc = (ctx: any, next: Next) => Promise<void> | void;
-export type MiddlewareFuncWithParamProperty = MiddlewareFunc & {
-    param?: string;
-};
-export type ParamMiddlewareFunc = (param: string, ctx: any, next: Next) => Promise<void> | void;
-export type MiddlewareFuncWithRouter<T> = MiddlewareFunc & {
-    router: T;
-};
-export interface ResourcesController {
-    index?: MiddlewareFunc;
-    new?: MiddlewareFunc;
-    create?: MiddlewareFunc;
-    show?: MiddlewareFunc;
-    edit?: MiddlewareFunc;
-    update?: MiddlewareFunc;
-    destroy?: MiddlewareFunc;
-}

package/dist/esm/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/package.json

@@ -1,4 +0,0 @@
-{
-  "name": "@eggjs/router",
-  "version": "3.0.6"
-}

package/src/EggRouter.ts

@@ -1,351 +0,0 @@
-import assert from 'node:assert';
-import { encodeURIComponent as safeEncodeURIComponent } from 'utility';
-import inflection from 'inflection';
-import methods from 'methods';
-import { isGeneratorFunction } from 'is-type-of';
-import { RegisterOptions, Router, RouterMethod, RouterOptions } from './Router.js';
-import { MiddlewareFunc, Next, ResourcesController } from './types.js';
-
-interface RestfulOptions {
-  suffix?: string;
-  namePrefix?: string;
-  method: string | string[];
-  member?: true;
-}
-
-const REST_MAP: Record<string, RestfulOptions> = {
-  index: {
-    suffix: '',
-    method: 'GET',
-  },
-  new: {
-    namePrefix: 'new_',
-    member: true,
-    suffix: 'new',
-    method: 'GET',
-  },
-  create: {
-    suffix: '',
-    method: 'POST',
-  },
-  show: {
-    member: true,
-    suffix: ':id',
-    method: 'GET',
-  },
-  edit: {
-    member: true,
-    namePrefix: 'edit_',
-    suffix: ':id/edit',
-    method: 'GET',
-  },
-  update: {
-    member: true,
-    namePrefix: '',
-    suffix: ':id',
-    method: [ 'PATCH', 'PUT' ],
-  },
-  destroy: {
-    member: true,
-    namePrefix: 'destroy_',
-    suffix: ':id',
-    method: 'DELETE',
-  },
-};
-
-interface Application {
-  controller: Record<string, any>;
-}
-
-/**
- * FIXME: move these patch into @eggjs/router
- */
-export class EggRouter extends Router {
-  readonly app: Application;
-
-  /**
-   * @class
-   * @param {Object} opts - Router options.
-   * @param {Application} app - Application object.
-   */
-  constructor(opts: RouterOptions, app: Application) {
-    super(opts);
-    this.app = app;
-  }
-
-  verb(method: RouterMethod | RouterMethod[],
-    nameOrPath: string | RegExp | (string | RegExp)[],
-    pathOrMiddleware: string | RegExp | (string | RegExp)[] | MiddlewareFunc,
-    ...middleware: (MiddlewareFunc | string)[]) {
-    const { path, middlewares, options } = this._formatRouteParams(nameOrPath, pathOrMiddleware, middleware);
-    if (typeof method === 'string') {
-      method = [ method ];
-    }
-    this.register(path, method, middlewares, options);
-    return this;
-  }
-
-  // const METHODS = [ 'head', 'options', 'get', 'put', 'patch', 'post', 'delete', 'all' ];
-  head(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  head(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  head(nameOrPath: string | RegExp | (string | RegExp)[],
-    pathOrMiddleware: string | RegExp | (string | RegExp)[] | MiddlewareFunc,
-    ...middlewares: (MiddlewareFunc | string)[]): Router {
-    return this.verb('head', nameOrPath, pathOrMiddleware, ...middlewares);
-  }
-  options(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  options(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  options(nameOrPath: string | RegExp | (string | RegExp)[],
-    pathOrMiddleware: string | RegExp | (string | RegExp)[] | MiddlewareFunc,
-    ...middlewares: (MiddlewareFunc | string)[]): Router {
-    return this.verb('options', nameOrPath, pathOrMiddleware, ...middlewares);
-  }
-  get(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  get(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  get(nameOrPath: string | RegExp | (string | RegExp)[],
-    pathOrMiddleware: string | RegExp | (string | RegExp)[] | MiddlewareFunc,
-    ...middlewares: (MiddlewareFunc | string)[]): Router {
-    return this.verb('get', nameOrPath, pathOrMiddleware, ...middlewares);
-  }
-  put(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  put(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  put(nameOrPath: string | RegExp | (string | RegExp)[],
-    pathOrMiddleware: string | RegExp | (string | RegExp)[] | MiddlewareFunc,
-    ...middlewares: (MiddlewareFunc | string)[]): Router {
-    return this.verb('put', nameOrPath, pathOrMiddleware, ...middlewares);
-  }
-  patch(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  patch(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  patch(nameOrPath: string | RegExp | (string | RegExp)[],
-    pathOrMiddleware: string | RegExp | (string | RegExp)[] | MiddlewareFunc,
-    ...middlewares: (MiddlewareFunc | string)[]): Router {
-    return this.verb('patch', nameOrPath, pathOrMiddleware, ...middlewares);
-  }
-  post(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  post(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  post(nameOrPath: string | RegExp | (string | RegExp)[],
-    pathOrMiddleware: string | RegExp | (string | RegExp)[] | MiddlewareFunc,
-    ...middlewares: (MiddlewareFunc | string)[]): Router {
-    return this.verb('post', nameOrPath, pathOrMiddleware, ...middlewares);
-  }
-  delete(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  delete(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  delete(nameOrPath: string | RegExp | (string | RegExp)[],
-    pathOrMiddleware: string | RegExp | (string | RegExp)[] | MiddlewareFunc,
-    ...middlewares: (MiddlewareFunc | string)[]): Router {
-    return this.verb('delete', nameOrPath, pathOrMiddleware, ...middlewares);
-  }
-  all(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  all(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): Router;
-  all(nameOrPath: string | RegExp | (string | RegExp)[],
-    pathOrMiddleware: string | RegExp | (string | RegExp)[] | MiddlewareFunc,
-    ...middlewares: (MiddlewareFunc | string)[]): Router {
-    return this.verb(methods, nameOrPath, pathOrMiddleware, ...middlewares);
-  }
-
-  register(path: string | RegExp | (string | RegExp)[],
-    methods: string[],
-    middleware: MiddlewareFunc | string | (MiddlewareFunc | string | ResourcesController)[],
-    opts?: RegisterOptions) {
-    // patch register to support bind ctx function middleware and string controller
-    middleware = Array.isArray(middleware) ? middleware : [ middleware ];
-    for (const mw of middleware) {
-      if (isGeneratorFunction(mw)) {
-        throw new TypeError(
-          methods.toString() + ' `' + path + '`: Please use async function instead of generator function',
-        );
-      }
-    }
-    const middlewares = convertMiddlewares(middleware, this.app);
-    return super.register(path, methods, middlewares, opts);
-  }
-
-  /**
-   * restful router api
-   * @param {String} name - Router name
-   * @param {String} prefix - url prefix
-   * @param {Function} middleware - middleware or controller
-   * @example
-   * ```js
-   * app.resources('/posts', 'posts')
-   * app.resources('posts', '/posts', 'posts')
-   * app.resources('posts', '/posts', app.role.can('user'), app.controller.posts)
-   * app.resources('posts', '/posts', middleware1, middleware2, app.controller.posts)
-   * ```
-   *
-   * Examples:
-   *
-   * ```js
-   * app.resources('/posts', 'posts')
-   * ```
-   *
-   * yield router mapping
-   *
-   * Method | Path            | Route Name     | Controller.Action
-   * -------|-----------------|----------------|-----------------------------
-   * GET    | /posts          | posts          | app.controller.posts.index
-   * GET    | /posts/new      | new_post       | app.controller.posts.new
-   * GET    | /posts/:id      | post           | app.controller.posts.show
-   * GET    | /posts/:id/edit | edit_post      | app.controller.posts.edit
-   * POST   | /posts          | posts          | app.controller.posts.create
-   * PATCH  | /posts/:id      | post           | app.controller.posts.update
-   * DELETE | /posts/:id      | post           | app.controller.posts.destroy
-   *
-   * app.router.url can generate url based on arguments
-   * ```js
-   * app.router.url('posts')
-   * => /posts
-   * app.router.url('post', { id: 1 })
-   * => /posts/1
-   * app.router.url('new_post')
-   * => /posts/new
-   * app.router.url('edit_post', { id: 1 })
-   * => /posts/1/edit
-   * ```
-   * @return {Router} return route object.
-   * @since 1.0.0
-   */
-  resources(prefix: string, controller: string | ResourcesController): Router;
-  resources(prefix: string, middleware: MiddlewareFunc, controller: string | ResourcesController): Router;
-  resources(name: string, prefix: string, controller: string | ResourcesController): Router;
-  resources(name: string, prefix: string, middleware: MiddlewareFunc, controller: string | ResourcesController): Router;
-  resources(nameOrPath: string | RegExp, ...middleware: (MiddlewareFunc | string | ResourcesController)[]): Router;
-  resources(nameOrPath: string | RegExp, pathOrMiddleware: string | RegExp | MiddlewareFunc | ResourcesController,
-    ...middleware: (MiddlewareFunc | string | ResourcesController)[]): Router {
-    const { path, middlewares, options } = this._formatRouteParams(nameOrPath, pathOrMiddleware, middleware);
-    // last argument is Controller object
-    const controller = resolveController(middlewares.pop()!, this.app);
-    for (const key in REST_MAP) {
-      const action = controller[key] as MiddlewareFunc;
-      if (!action) continue;
-
-      const opts = REST_MAP[key];
-      let routeName;
-      if (opts.member) {
-        routeName = inflection.singularize(options.name ?? '');
-      } else {
-        routeName = inflection.pluralize(options.name ?? '');
-      }
-      if (opts.namePrefix) {
-        routeName = opts.namePrefix + routeName;
-      }
-      const prefix = (path as string).replace(/\/$/, '');
-      const urlPath = opts.suffix ? `${prefix}/${opts.suffix}` : prefix;
-      const method = Array.isArray(opts.method) ? opts.method : [ opts.method ];
-      this.register(urlPath, method, middlewares.concat(action), { name: routeName });
-    }
-    return this;
-  }
-
-  /**
-   * @param {String} name - Router name
-   * @param {Object} params - more parameters
-   * @example
-   * ```js
-   * router.url('edit_post', { id: 1, name: 'foo', page: 2 })
-   * => /posts/1/edit?name=foo&page=2
-   * router.url('posts', { name: 'foo&1', page: 2 })
-   * => /posts?name=foo%261&page=2
-   * ```
-   * @return {String} url by path name and query params.
-   * @since 1.0.0
-   */
-  url(name: string, params?: Record<string, string | number | (string | number)[]>): string {
-    const route = this.route(name);
-    if (!route) return '';
-
-    const args = params;
-    let url = route.path;
-
-    assert(!(url instanceof RegExp), `Can't get the url for regExp ${url} for by name '${name}'`);
-
-    const queries = [];
-    if (typeof args === 'object' && args !== null) {
-      const replacedParams: string[] = [];
-      url = url.replace(/:([a-zA-Z_]\w*)/g, ($0, key) => {
-        if (key in args) {
-          const values = args[key];
-          replacedParams.push(key);
-          return safeEncodeURIComponent(Array.isArray(values) ? String(values[0]) : String(values));
-        }
-        return $0;
-      });
-
-      for (const key in args) {
-        if (replacedParams.includes(key)) {
-          continue;
-        }
-        const values = args[key];
-        const encodedKey = safeEncodeURIComponent(key);
-        if (Array.isArray(values)) {
-          for (const val of values) {
-            queries.push(`${encodedKey}=${safeEncodeURIComponent(String(val))}`);
-          }
-        } else {
-          queries.push(`${encodedKey}=${safeEncodeURIComponent(String(values))}`);
-        }
-      }
-    }
-
-    if (queries.length > 0) {
-      const queryStr = queries.join('&');
-      if (!url.includes('?')) {
-        url = `${url}?${queryStr}`;
-      } else {
-        url = `${url}&${queryStr}`;
-      }
-    }
-
-    return url;
-  }
-
-  /**
-   * @alias to url()
-   */
-  pathFor(name: string, params?: Record<string, string | number | (string | number)[]>) {
-    return this.url(name, params);
-  }
-}
-
-/**
- * resolve controller from string to function
- * @param {String|Function} controller input controller
- * @param {Application} app egg application instance
- */
-function resolveController(controller: string | MiddlewareFunc | ResourcesController, app: Application) {
-  if (typeof controller === 'string') {
-    // resolveController('foo.bar.Home', app)
-    const actions = controller.split('.');
-    let obj = app.controller;
-    actions.forEach(key => {
-      obj = obj[key];
-      if (!obj) throw new Error(`app.controller.${controller} not exists`);
-    });
-    controller = obj as any;
-  }
-  // ensure controller is exists
-  if (!controller) throw new Error('controller not exists');
-  return controller as any;
-}
-
-/**
- * 1. ensure controller(last argument) support string
- * - [url, controller]: app.get('/home', 'home');
- * - [name, url, controller(string)]: app.get('posts', '/posts', 'posts.list');
- * - [name, url, controller]: app.get('posts', '/posts', app.controller.posts.list);
- * - [name, url(regexp), controller]: app.get('regRouter', /\/home\/index/, 'home.index');
- * - [name, url, middleware, [...], controller]: `app.get(/user/:id', hasLogin, canGetUser, 'user.show');`
- *
- * 2. bind ctx to controller `this`
- *
- * @param  {Array} middlewares middlewares and controller(last middleware)
- * @param  {Application} app  egg application instance
- */
-function convertMiddlewares(middlewares: (MiddlewareFunc | string | ResourcesController)[], app: Application) {
-  // ensure controller is resolved
-  const controller = resolveController(middlewares.pop()!, app);
-  function wrappedController(ctx: any, next: Next) {
-    return controller.apply(ctx, [ ctx, next ]);
-  }
-  return [ ...middlewares as MiddlewareFunc[], wrappedController ];
-}

package/src/Layer.ts

@@ -1,274 +0,0 @@
-import { debuglog } from 'node:util';
-import pathToRegExp, { type Key } from 'path-to-regexp';
-import URI from 'urijs';
-import { decodeURIComponent as safeDecodeURIComponent } from 'utility';
-import { isGeneratorFunction } from 'is-type-of';
-import type {
-  MiddlewareFunc,
-  MiddlewareFuncWithParamProperty,
-  ParamMiddlewareFunc,
-} from './types.js';
-
-const debug = debuglog('@eggjs/router:Layer');
-
-export interface LayerOptions {
-  prefix?: string;
-  /** route name */
-  name?: string;
-  /** case sensitive (default: false) */
-  sensitive?: boolean;
-  /** require the trailing slash (default: false) */
-  strict?: boolean;
-  ignoreCaptures?: boolean;
-  end?: boolean;
-}
-
-export interface LayerURLOptions {
-  query?: string | object;
-}
-
-export class Layer {
-  readonly opts: LayerOptions;
-  readonly name?: string;
-  readonly methods: string[] = [];
-  readonly stack: MiddlewareFuncWithParamProperty[];
-  path: string | RegExp;
-  regexp: RegExp;
-  paramNames: Key[] = [];
-
-  /**
-   * Initialize a new routing Layer with given `method`, `path`, and `middleware`.
-   *
-   * @param {String|RegExp} path Path string or regular expression.
-   * @param {Array} methods Array of HTTP verbs.
-   * @param {Array|Function} middlewares Layer callback/middleware or series of.
-   * @param {Object=} opts optional params
-   * @param {String=} opts.name route name
-   * @param {String=} opts.sensitive case sensitive (default: false)
-   * @param {String=} opts.strict require the trailing slash (default: false)
-   * @private
-   */
-  constructor(path: string | RegExp, methods: string[], middlewares: MiddlewareFunc | MiddlewareFunc[],
-    opts?: LayerOptions | string) {
-    if (typeof opts === 'string') {
-      // new Layer(path, methods, middlewares, name);
-      opts = { name: opts };
-    }
-    this.opts = opts ?? {};
-    this.opts.prefix = this.opts.prefix ?? '';
-    this.name = this.opts.name;
-    this.stack = Array.isArray(middlewares) ? middlewares : [ middlewares ];
-
-    for (const method of methods) {
-      const l = this.methods.push(method.toUpperCase());
-      if (this.methods[l - 1] === 'GET') {
-        this.methods.unshift('HEAD');
-      }
-    }
-
-    // ensure middleware is a function
-    this.stack.forEach(fn => {
-      const type = typeof fn;
-      if (type !== 'function') {
-        throw new TypeError(
-          methods.toString() + ' `' + (this.opts.name || path) + '`: `middleware` '
-          + 'must be a function, not `' + type + '`',
-        );
-      }
-      if (isGeneratorFunction(fn)) {
-        throw new TypeError(
-          methods.toString() + ' `' + (this.opts.name || path) + '`: Please use async function instead of generator function',
-        );
-      }
-    });
-
-    this.path = path;
-    this.regexp = pathToRegExp(path, this.paramNames, this.opts);
-
-    debug('defined route %s %s', this.methods, this.opts.prefix + this.path);
-  }
-
-  /**
-   * Returns whether request `path` matches route.
-   *
-   * @param {String} path path string
-   * @return {Boolean} matched or not
-   * @private
-   */
-  match(path: string): boolean {
-    return this.regexp.test(path);
-  }
-
-  /**
-   * Returns map of URL parameters for given `path` and `paramNames`.
-   *
-   * @param {String} _path path string
-   * @param {Array.<String>} captures captures strings
-   * @param {Object=} [existingParams] existing params
-   * @return {Object} params object
-   * @private
-   */
-  params(_path: string, captures: Array<string>, existingParams?: Record<string, string>): Record<string, string> {
-    const params = existingParams ?? {};
-
-    for (let len = captures.length, i = 0; i < len; i++) {
-      const paramName = this.paramNames[i];
-      if (paramName) {
-        const c = captures[i];
-        params[paramName.name] = c ? safeDecodeURIComponent(c) : c;
-      }
-    }
-    return params;
-  }
-
-  /**
-   * Returns array of regexp url path captures.
-   *
-   * @param {String} path path string
-   * @return {Array.<String>} captures strings
-   * @private
-   */
-  captures(path: string): Array<string> {
-    if (this.opts.ignoreCaptures) return [];
-    const m = path.match(this.regexp);
-    return m ? m.slice(1) : [];
-  }
-
-  /**
-   * Generate URL for route using given `params`.
-   *
-   * @example
-   *
-   * ```javascript
-   * var route = new Layer(['GET'], '/users/:id', fn);
-   *
-   * route.url(123); // => "/users/123"
-   * route.url('123'); // => "/users/123"
-   * route.url({ id: 123 }); // => "/users/123"
-   * ```
-   *
-   * @param {Object} params url parameters
-   * @param {Object} paramsOrOptions optional parameters
-   * @return {String} url string
-   * @private
-   */
-  url(params?: string | number | object, ...paramsOrOptions: (string | number | object | LayerURLOptions)[]): string {
-    let args: Array<string | number | object> | object = params as object;
-    const url = (this.path as string).replace(/\(\.\*\)/g, '');
-    const toPath = pathToRegExp.compile(url);
-    let options: LayerURLOptions | undefined;
-
-    if (params !== undefined && typeof params !== 'object') {
-      args = [ params, ...paramsOrOptions ];
-      // route.url(stringOrNumber, params1, ..., options);
-      if (Array.isArray(args)) {
-        const lastIndex = args.length - 1;
-        if (typeof args[lastIndex] === 'object') {
-          options = args[lastIndex];
-          args = args.slice(0, lastIndex);
-        }
-      }
-    } else if (typeof params === 'object') {
-      if (typeof paramsOrOptions[0] === 'object' && 'query' in paramsOrOptions[0]) {
-        // route.url(param, options);
-        options = paramsOrOptions[0];
-      }
-    }
-
-    const tokens = pathToRegExp.parse(url);
-    let replace: Record<string, any> = {};
-
-    if (Array.isArray(args)) {
-      for (let len = tokens.length, i = 0, j = 0; i < len; i++) {
-        const token = tokens[i];
-        if (typeof token === 'object' && token.name) {
-          replace[token.name] = args[j++];
-        }
-      }
-    } else if (tokens.some(token => typeof token === 'object' && token.name)) {
-      // route.url(params);
-      replace = params as object;
-    } else {
-      // route.url(options);
-      options = params as LayerURLOptions;
-    }
-
-    const replaced = toPath(replace);
-
-    if (options?.query) {
-      const urlObject = new URI(replaced);
-      urlObject.search(options.query);
-      return urlObject.toString();
-    }
-
-    return replaced;
-  }
-
-  /**
-   * Run validations on route named parameters.
-   *
-   * @example
-   *
-   * ```javascript
-   * router
-   *   .param('user', function (id, ctx, next) {
-   *     ctx.user = users[id];
-   *     if (!user) return ctx.status = 404;
-   *     next();
-   *   })
-   *   .get('/users/:user', function (ctx, next) {
-   *     ctx.body = ctx.user;
-   *   });
-   * ```
-   *
-   * @param {String} param param string
-   * @param {Function} fn middleware function
-   * @return {Layer} layer instance
-   * @private
-   */
-  param(param: string, fn: ParamMiddlewareFunc): Layer {
-    const stack = this.stack;
-    const params = this.paramNames;
-    const middleware: MiddlewareFuncWithParamProperty = function(this: any, ctx, next) {
-      return fn.call(this, ctx.params[param], ctx, next);
-    };
-    middleware.param = param;
-
-    const names = params.map(p => {
-      return p.name;
-    });
-
-    const x = names.indexOf(param);
-    if (x > -1) {
-      // iterate through the stack, to figure out where to place the handler fn
-      stack.some(function(fn, i) {
-        // param handlers are always first, so when we find an fn w/o a param property, stop here
-        // if the param handler at this part of the stack comes after the one we are adding, stop here
-        if (!fn.param || names.indexOf(fn.param) > x) {
-          // inject this param handler right before the current item
-          stack.splice(i, 0, middleware);
-          return true; // then break the loop
-        }
-        return false;
-      });
-    }
-
-    return this;
-  }
-
-  /**
-   * Prefix route path.
-   *
-   * @param {String} prefix prefix string
-   * @return {Layer} layer instance
-   * @private
-   */
-  setPrefix(prefix: string): Layer {
-    if (this.path) {
-      this.path = prefix + this.path;
-      this.paramNames = [];
-      this.regexp = pathToRegExp(this.path, this.paramNames, this.opts);
-    }
-    return this;
-  }
-}