@eggjs/router 4.0.0-beta.19 → 4.0.0-beta.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/dist/EggRouter.d.ts +98 -102
  2. package/dist/EggRouter.js +228 -198
  3. package/dist/Layer.d.ts +111 -115
  4. package/dist/Layer.js +238 -201
  5. package/dist/Router.d.ts +489 -491
  6. package/dist/Router.js +775 -675
  7. package/dist/index.d.ts +7 -9
  8. package/dist/index.js +6 -9
  9. package/dist/types.d.ts +15 -18
  10. package/dist/types.js +2 -1
  11. package/package.json +5 -5
package/dist/Router.js CHANGED
@@ -1,676 +1,776 @@
1
+ /**
2
+ * RESTful resource routing middleware for eggjs.
3
+ */
4
+ import { debuglog } from 'node:util';
5
+ import assert from 'node:assert';
6
+ import compose from 'koa-compose';
7
+ import HttpError from 'http-errors';
8
+ import methods from 'methods';
1
9
  import { Layer } from "./Layer.js";
2
- import assert from "node:assert";
3
- import methods from "methods";
4
- import { debuglog } from "node:util";
5
- import compose from "koa-compose";
6
- import HttpError from "http-errors";
7
-
8
- //#region src/Router.ts
9
- const debug = debuglog("egg/router:Router");
10
- var Router = class {
11
- opts;
12
- methods;
13
- /** Layer stack */
14
- stack = [];
15
- params = {};
16
- /**
17
- * Create a new router.
18
- *
19
- * @example
20
- *
21
- * Basic usage:
22
- *
23
- * ```javascript
24
- * var Koa = require('koa');
25
- * var Router = require('koa-router');
26
- *
27
- * var app = new Koa();
28
- * var router = new Router();
29
- *
30
- * router.get('/', (ctx, next) => {
31
- * // ctx.router available
32
- * });
33
- *
34
- * app
35
- * .use(router.routes())
36
- * .use(router.allowedMethods());
37
- * ```
38
- *
39
- * @alias module:koa-router
40
- * @param {Object=} opts optional
41
- * @param {String=} opts.prefix prefix router paths
42
- * @class
43
- */
44
- constructor(opts) {
45
- this.opts = opts ?? {};
46
- this.methods = this.opts.methods ?? [
47
- "HEAD",
48
- "OPTIONS",
49
- "GET",
50
- "PUT",
51
- "PATCH",
52
- "POST",
53
- "DELETE"
54
- ];
55
- }
56
- use(pathOrMiddleware, ...middlewares) {
57
- if (Array.isArray(pathOrMiddleware) && typeof pathOrMiddleware[0] === "string") {
58
- for (const path$1 of pathOrMiddleware) this.use(path$1, ...middlewares);
59
- return this;
60
- }
61
- let path = "";
62
- let hasPath = false;
63
- if (typeof pathOrMiddleware === "string") {
64
- path = pathOrMiddleware;
65
- hasPath = true;
66
- } else if (typeof pathOrMiddleware === "function") middlewares = [pathOrMiddleware, ...middlewares];
67
- for (const m of middlewares) if (m.router) {
68
- for (const nestedLayer of m.router.stack) {
69
- if (path) nestedLayer.setPrefix(path);
70
- if (this.opts.prefix) nestedLayer.setPrefix(this.opts.prefix);
71
- this.stack.push(nestedLayer);
72
- }
73
- if (this.params) for (const key in this.params) m.router.param(key, this.params[key]);
74
- } else this.register(path || "(.*)", [], m, {
75
- end: false,
76
- ignoreCaptures: !hasPath
77
- });
78
- return this;
79
- }
80
- /**
81
- * Set the path prefix for a Router instance that was already initialized.
82
- *
83
- * @example
84
- *
85
- * ```javascript
86
- * router.prefix('/things/:thing_id')
87
- * ```
88
- *
89
- * @param {String} prefix prefix string
90
- * @return {Router} router instance
91
- */
92
- prefix(prefix) {
93
- prefix = prefix.replace(/\/$/, "");
94
- this.opts.prefix = prefix;
95
- for (const layer of this.stack) layer.setPrefix(prefix);
96
- return this;
97
- }
98
- /**
99
- * Returns router middleware which dispatches a route matching the request.
100
- *
101
- * @return {Function} middleware function
102
- */
103
- routes() {
104
- const dispatch = (ctx, next) => {
105
- const routerPath = this.opts.routerPath || ctx.routerPath || ctx.path;
106
- const matched = this.match(routerPath, ctx.method);
107
- debug("dispatch: %s %s, routerPath: %s, matched: %s", ctx.method, ctx.path, routerPath, matched.route);
108
- if (ctx.matched) ctx.matched.push(...matched.path);
109
- else ctx.matched = matched.path;
110
- ctx.router = this;
111
- if (!matched.route) return next();
112
- const layerChain = matched.pathAndMethod.reduce((memo, layer) => {
113
- memo.push((ctx$1, next$1) => {
114
- ctx$1.captures = layer.captures(routerPath);
115
- ctx$1.params = layer.params(routerPath, ctx$1.captures, ctx$1.params);
116
- ctx$1._matchedRouteName = ctx$1.routerName = layer.name;
117
- if (!layer.name) ctx$1._matchedRouteName = void 0;
118
- ctx$1._matchedRoute = ctx$1.routerPath = layer.path;
119
- return next$1();
120
- });
121
- return memo.concat(layer.stack);
122
- }, []);
123
- return compose(layerChain)(ctx, next);
124
- };
125
- dispatch.router = this;
126
- return dispatch;
127
- }
128
- /**
129
- * @alias to routes()
130
- */
131
- middleware() {
132
- return this.routes();
133
- }
134
- /**
135
- * Returns separate middleware for responding to `OPTIONS` requests with
136
- * an `Allow` header containing the allowed methods, as well as responding
137
- * with `405 Method Not Allowed` and `501 Not Implemented` as appropriate.
138
- *
139
- * @example
140
- *
141
- * ```javascript
142
- * var Koa = require('koa');
143
- * var Router = require('koa-router');
144
- *
145
- * var app = new Koa();
146
- * var router = new Router();
147
- *
148
- * app.use(router.routes());
149
- * app.use(router.allowedMethods());
150
- * ```
151
- *
152
- * **Example with [Boom](https://github.com/hapijs/boom)**
153
- *
154
- * ```javascript
155
- * var Koa = require('koa');
156
- * var Router = require('koa-router');
157
- * var Boom = require('boom');
158
- *
159
- * var app = new Koa();
160
- * var router = new Router();
161
- *
162
- * app.use(router.routes());
163
- * app.use(router.allowedMethods({
164
- * throw: true,
165
- * notImplemented: () => new Boom.notImplemented(),
166
- * methodNotAllowed: () => new Boom.methodNotAllowed()
167
- * }));
168
- * ```
169
- *
170
- * @param {Object=} options optional params
171
- * @param {Boolean=} options.throw throw error instead of setting status and header
172
- * @param {Function=} options.notImplemented throw the returned value in place of the default NotImplemented error
173
- * @param {Function=} options.methodNotAllowed throw the returned value in place of the default MethodNotAllowed error
174
- * @return {Function} middleware function
175
- */
176
- allowedMethods(options) {
177
- const implemented = this.methods;
178
- return async function allowedMethods(ctx, next) {
179
- await next();
180
- if (ctx.status && ctx.status !== 404) return;
181
- const allowed = {};
182
- ctx.matched.forEach((route) => {
183
- route.methods.forEach((method) => {
184
- allowed[method] = method;
185
- });
186
- });
187
- const allowedMethods$1 = Object.keys(allowed);
188
- if (!implemented.includes(ctx.method)) if (options?.throw) {
189
- let notImplementedThrowable;
190
- if (typeof options?.notImplemented === "function") notImplementedThrowable = options.notImplemented();
191
- else notImplementedThrowable = new HttpError.NotImplemented();
192
- throw notImplementedThrowable;
193
- } else {
194
- ctx.status = 501;
195
- ctx.set("Allow", allowedMethods$1.join(", "));
196
- }
197
- else if (allowedMethods$1.length > 0) {
198
- if (ctx.method === "OPTIONS") {
199
- ctx.status = 200;
200
- ctx.body = "";
201
- ctx.set("Allow", allowedMethods$1.join(", "));
202
- } else if (!allowed[ctx.method]) if (options?.throw) {
203
- let notAllowedThrowable;
204
- if (typeof options?.methodNotAllowed === "function") notAllowedThrowable = options.methodNotAllowed();
205
- else notAllowedThrowable = new HttpError.MethodNotAllowed();
206
- throw notAllowedThrowable;
207
- } else {
208
- ctx.status = 405;
209
- ctx.set("Allow", allowedMethods$1.join(", "));
210
- }
211
- }
212
- };
213
- }
214
- /**
215
- * Redirect `source` to `destination` URL with optional 30x status `code`.
216
- *
217
- * Both `source` and `destination` can be route names.
218
- *
219
- * ```javascript
220
- * router.redirect('/login', 'sign-in');
221
- * ```
222
- *
223
- * This is equivalent to:
224
- *
225
- * ```javascript
226
- * router.all('/login', ctx => {
227
- * ctx.redirect('/sign-in');
228
- * ctx.status = 301;
229
- * });
230
- * ```
231
- *
232
- * @param {String} source URL or route name.
233
- * @param {String} destination URL or route name.
234
- * @param {Number=} status HTTP status code (default: 301).
235
- * @return {Router} router instance
236
- */
237
- redirect(source, destination, status = 301) {
238
- if (source[0] !== "/") {
239
- const routeUrl = this.url(source);
240
- if (routeUrl instanceof Error) throw routeUrl;
241
- source = routeUrl;
242
- }
243
- if (destination[0] !== "/") {
244
- const routeUrl = this.url(destination);
245
- if (routeUrl instanceof Error) throw routeUrl;
246
- destination = routeUrl;
247
- }
248
- return this.all(source, (ctx) => {
249
- ctx.redirect(destination);
250
- ctx.status = status;
251
- });
252
- }
253
- /**
254
- * Create and register a route.
255
- *
256
- * @param {String|RegExp|(String|RegExp)[]} path Path string.
257
- * @param {String[]} methods Array of HTTP verbs.
258
- * @param {Function|Function[]} middleware Multiple middleware also accepted.
259
- * @param {Object} [opts] optional params
260
- * @private
261
- */
262
- register(path, methods$1, middleware, opts) {
263
- if (Array.isArray(path)) {
264
- const routes = [];
265
- for (const p of path) {
266
- const route = this.#register(p, methods$1, middleware, opts);
267
- routes.push(route);
268
- }
269
- return routes;
270
- }
271
- return this.#register(path, methods$1, middleware, opts);
272
- }
273
- #register(path, methods$1, middleware, opts) {
274
- opts = opts ?? {};
275
- const route = new Layer(path, methods$1, middleware, {
276
- end: opts.end === false ? opts.end : true,
277
- name: opts.name,
278
- sensitive: opts.sensitive ?? this.opts.sensitive ?? false,
279
- strict: opts.strict ?? this.opts.strict ?? false,
280
- prefix: opts.prefix ?? this.opts.prefix ?? "",
281
- ignoreCaptures: opts.ignoreCaptures
282
- });
283
- if (this.opts.prefix) route.setPrefix(this.opts.prefix);
284
- for (const param in this.params) route.param(param, this.params[param]);
285
- this.stack.push(route);
286
- return route;
287
- }
288
- /**
289
- * Lookup route with given `name`.
290
- *
291
- * @param {String} name route name
292
- * @return {Layer|false} layer instance of false
293
- */
294
- route(name) {
295
- for (const route of this.stack) if (route.name === name) return route;
296
- return false;
297
- }
298
- /**
299
- * Generate URL for route. Takes a route name and map of named `params`.
300
- *
301
- * @example
302
- *
303
- * ```javascript
304
- * router.get('user', '/users/:id', (ctx, next) => {
305
- * // ...
306
- * });
307
- *
308
- * router.url('user', 3);
309
- * // => "/users/3"
310
- *
311
- * router.url('user', { id: 3 });
312
- * // => "/users/3"
313
- *
314
- * router.use((ctx, next) => {
315
- * // redirect to named route
316
- * ctx.redirect(ctx.router.url('sign-in'));
317
- * })
318
- *
319
- * router.url('user', { id: 3 }, { query: { limit: 1 } });
320
- * // => "/users/3?limit=1"
321
- *
322
- * router.url('user', { id: 3 }, { query: "limit=1" });
323
- * // => "/users/3?limit=1"
324
- * ```
325
- */
326
- url(name, params, ...paramsOrOptions) {
327
- const route = this.route(name);
328
- if (route) return route.url(params, ...paramsOrOptions);
329
- return /* @__PURE__ */ new Error(`No route found for name: ${name}`);
330
- }
331
- /**
332
- * Generate URL from url pattern and given `params`.
333
- *
334
- * @example
335
- *
336
- * ```javascript
337
- * var url = Router.url('/users/:id', { id: 1 });
338
- * // => "/users/1"
339
- * ```
340
- *
341
- * @param {String} path url pattern
342
- * @param {Object} params url parameters
343
- * @return {String} url string
344
- */
345
- static url(path, params, ...paramsOrOptions) {
346
- return Layer.prototype.url.call({ path }, params, ...paramsOrOptions);
347
- }
348
- /**
349
- * Match given `path` and return corresponding routes.
350
- *
351
- * @param {String} path path string
352
- * @param {String} method method name
353
- * @return {Object.<path, pathAndMethod>} returns layers that matched path and
354
- * path and method.
355
- * @private
356
- */
357
- match(path, method) {
358
- const matched = {
359
- path: [],
360
- pathAndMethod: [],
361
- route: false
362
- };
363
- for (const layer of this.stack) {
364
- debug("test %s %s", layer.path, layer.regexp);
365
- if (layer.match(path)) {
366
- matched.path.push(layer);
367
- if (layer.methods.length === 0 || layer.methods.includes(method)) {
368
- matched.pathAndMethod.push(layer);
369
- if (layer.methods.length > 0) matched.route = true;
370
- }
371
- }
372
- }
373
- return matched;
374
- }
375
- /**
376
- * Run middleware for named route parameters. Useful for auto-loading or
377
- * validation.
378
- *
379
- * @example
380
- *
381
- * ```javascript
382
- * router
383
- * .param('user', (id, ctx, next) => {
384
- * ctx.user = users[id];
385
- * if (!ctx.user) return ctx.status = 404;
386
- * return next();
387
- * })
388
- * .get('/users/:user', ctx => {
389
- * ctx.body = ctx.user;
390
- * })
391
- * .get('/users/:user/friends', ctx => {
392
- * return ctx.user.getFriends().then(function(friends) {
393
- * ctx.body = friends;
394
- * });
395
- * })
396
- * // /users/3 => {"id": 3, "name": "Alex"}
397
- * // /users/3/friends => [{"id": 4, "name": "TJ"}]
398
- * ```
399
- *
400
- * @param {String} param param
401
- * @param {Function} middleware route middleware
402
- * @return {Router} instance
403
- */
404
- param(param, middleware) {
405
- this.params[param] = middleware;
406
- for (const route of this.stack) route.param(param, middleware);
407
- return this;
408
- }
409
- _formatRouteParams(nameOrPath, pathOrMiddleware, middlewares) {
410
- const options = {};
411
- let path;
412
- if (typeof nameOrPath === "string" && nameOrPath.startsWith("/")) {
413
- path = nameOrPath;
414
- middlewares = [pathOrMiddleware, ...middlewares];
415
- if (typeof pathOrMiddleware === "string") options.name = pathOrMiddleware;
416
- } else if (nameOrPath instanceof RegExp) {
417
- path = nameOrPath;
418
- middlewares = [pathOrMiddleware, ...middlewares];
419
- if (typeof pathOrMiddleware === "string") options.name = pathOrMiddleware;
420
- } else if (Array.isArray(nameOrPath)) {
421
- path = nameOrPath;
422
- middlewares = [pathOrMiddleware, ...middlewares];
423
- if (typeof pathOrMiddleware === "string") options.name = pathOrMiddleware;
424
- } else if (typeof pathOrMiddleware === "string" || pathOrMiddleware instanceof RegExp) {
425
- path = pathOrMiddleware;
426
- assert(typeof nameOrPath === "string", "route name should be string");
427
- options.name = nameOrPath;
428
- } else if (Array.isArray(pathOrMiddleware)) {
429
- path = pathOrMiddleware;
430
- assert(typeof nameOrPath === "string", "route name should be string");
431
- options.name = nameOrPath;
432
- } else {
433
- path = nameOrPath;
434
- middlewares = [pathOrMiddleware, ...middlewares];
435
- }
436
- return {
437
- path,
438
- middlewares,
439
- options
440
- };
441
- }
442
- /**
443
- * Create `router.verb()` methods, where *verb* is one of the HTTP verbs such
444
- * as `router.get()` or `router.post()`.
445
- *
446
- * Match URL patterns to callback functions or controller actions using `router.verb()`,
447
- * where **verb** is one of the HTTP verbs such as `router.get()` or `router.post()`.
448
- *
449
- * Additionally, `router.all()` can be used to match against all methods.
450
- *
451
- * ```javascript
452
- * router
453
- * .get('/', (ctx, next) => {
454
- * ctx.body = 'Hello World!';
455
- * })
456
- * .post('/users', (ctx, next) => {
457
- * // ...
458
- * })
459
- * .put('/users/:id', (ctx, next) => {
460
- * // ...
461
- * })
462
- * .del('/users/:id', (ctx, next) => {
463
- * // ...
464
- * })
465
- * .all('/users/:id', (ctx, next) => {
466
- * // ...
467
- * });
468
- * ```
469
- *
470
- * When a route is matched, its path is available at `ctx._matchedRoute` and if named,
471
- * the name is available at `ctx._matchedRouteName`
472
- *
473
- * Route paths will be translated to regular expressions using
474
- * [path-to-regexp](https://github.com/pillarjs/path-to-regexp).
475
- *
476
- * Query strings will not be considered when matching requests.
477
- *
478
- * #### Named routes
479
- *
480
- * Routes can optionally have names. This allows generation of URLs and easy
481
- * renaming of URLs during development.
482
- *
483
- * ```javascript
484
- * router.get('user', '/users/:id', (ctx, next) => {
485
- * // ...
486
- * });
487
- *
488
- * router.url('user', 3);
489
- * // => "/users/3"
490
- * ```
491
- *
492
- * #### Multiple middleware
493
- *
494
- * Multiple middleware may be given:
495
- *
496
- * ```javascript
497
- * router.get(
498
- * '/users/:id',
499
- * (ctx, next) => {
500
- * return User.findOne(ctx.params.id).then(function(user) {
501
- * ctx.user = user;
502
- * next();
503
- * });
504
- * },
505
- * ctx => {
506
- * console.log(ctx.user);
507
- * // => { id: 17, name: "Alex" }
508
- * }
509
- * );
510
- * ```
511
- *
512
- * ### Nested routers
513
- *
514
- * Nesting routers is supported:
515
- *
516
- * ```javascript
517
- * var forums = new Router();
518
- * var posts = new Router();
519
- *
520
- * posts.get('/', (ctx, next) => {...});
521
- * posts.get('/:pid', (ctx, next) => {...});
522
- * forums.use('/forums/:fid/posts', posts.routes(), posts.allowedMethods());
523
- *
524
- * // responds to "/forums/123/posts" and "/forums/123/posts/123"
525
- * app.use(forums.routes());
526
- * ```
527
- *
528
- * #### Router prefixes
529
- *
530
- * Route paths can be prefixed at the router level:
531
- *
532
- * ```javascript
533
- * var router = new Router({
534
- * prefix: '/users'
535
- * });
536
- *
537
- * router.get('/', ...); // responds to "/users"
538
- * router.get('/:id', ...); // responds to "/users/:id"
539
- * ```
540
- *
541
- * #### URL parameters
542
- *
543
- * Named route parameters are captured and added to `ctx.params`.
544
- *
545
- * ```javascript
546
- * router.get('/:category/:title', (ctx, next) => {
547
- * console.log(ctx.params);
548
- * // => { category: 'programming', title: 'how-to-node' }
549
- * });
550
- * ```
551
- *
552
- * The [path-to-regexp](https://github.com/pillarjs/path-to-regexp) module is
553
- * used to convert paths to regular expressions.
554
- *
555
- */
556
- verb(method, nameOrPath, pathOrMiddleware, ...middleware) {
557
- const { options, path, middlewares } = this._formatRouteParams(nameOrPath, pathOrMiddleware, middleware);
558
- if (typeof method === "string") method = [method];
559
- this.register(path, method, middlewares, options);
560
- return this;
561
- }
562
- all(nameOrPath, pathOrMiddleware, ...middlewares) {
563
- return this.verb(methods, nameOrPath, pathOrMiddleware, ...middlewares);
564
- }
565
- acl(nameOrPath, pathOrMiddleware, ...middlewares) {
566
- return this.verb("acl", nameOrPath, pathOrMiddleware, ...middlewares);
567
- }
568
- bind(nameOrPath, pathOrMiddleware, ...middlewares) {
569
- return this.verb("bind", nameOrPath, pathOrMiddleware, ...middlewares);
570
- }
571
- checkout(nameOrPath, pathOrMiddleware, ...middlewares) {
572
- return this.verb("checkout", nameOrPath, pathOrMiddleware, ...middlewares);
573
- }
574
- connect(nameOrPath, pathOrMiddleware, ...middlewares) {
575
- return this.verb("connect", nameOrPath, pathOrMiddleware, ...middlewares);
576
- }
577
- copy(nameOrPath, pathOrMiddleware, ...middlewares) {
578
- return this.verb("copy", nameOrPath, pathOrMiddleware, ...middlewares);
579
- }
580
- delete(nameOrPath, pathOrMiddleware, ...middlewares) {
581
- return this.verb("delete", nameOrPath, pathOrMiddleware, ...middlewares);
582
- }
583
- del(nameOrPath, pathOrMiddleware, ...middlewares) {
584
- return this.verb("delete", nameOrPath, pathOrMiddleware, ...middlewares);
585
- }
586
- get(nameOrPath, pathOrMiddleware, ...middlewares) {
587
- return this.verb("get", nameOrPath, pathOrMiddleware, ...middlewares);
588
- }
589
- query(nameOrPath, pathOrMiddleware, ...middlewares) {
590
- return this.verb("query", nameOrPath, pathOrMiddleware, ...middlewares);
591
- }
592
- head(nameOrPath, pathOrMiddleware, ...middlewares) {
593
- return this.verb("head", nameOrPath, pathOrMiddleware, ...middlewares);
594
- }
595
- link(nameOrPath, pathOrMiddleware, ...middlewares) {
596
- return this.verb("link", nameOrPath, pathOrMiddleware, ...middlewares);
597
- }
598
- lock(nameOrPath, pathOrMiddleware, ...middlewares) {
599
- return this.verb("lock", nameOrPath, pathOrMiddleware, ...middlewares);
600
- }
601
- ["m-search"](nameOrPath, pathOrMiddleware, ...middlewares) {
602
- return this.verb("m-search", nameOrPath, pathOrMiddleware, ...middlewares);
603
- }
604
- merge(nameOrPath, pathOrMiddleware, ...middlewares) {
605
- return this.verb("merge", nameOrPath, pathOrMiddleware, ...middlewares);
606
- }
607
- mkactivity(nameOrPath, pathOrMiddleware, ...middlewares) {
608
- return this.verb("mkactivity", nameOrPath, pathOrMiddleware, ...middlewares);
609
- }
610
- mkcalendar(nameOrPath, pathOrMiddleware, ...middlewares) {
611
- return this.verb("mkcalendar", nameOrPath, pathOrMiddleware, ...middlewares);
612
- }
613
- mkcol(nameOrPath, pathOrMiddleware, ...middlewares) {
614
- return this.verb("mkcol", nameOrPath, pathOrMiddleware, ...middlewares);
615
- }
616
- move(nameOrPath, pathOrMiddleware, ...middlewares) {
617
- return this.verb("move", nameOrPath, pathOrMiddleware, ...middlewares);
618
- }
619
- notify(nameOrPath, pathOrMiddleware, ...middlewares) {
620
- return this.verb("notify", nameOrPath, pathOrMiddleware, ...middlewares);
621
- }
622
- options(nameOrPath, pathOrMiddleware, ...middlewares) {
623
- return this.verb("options", nameOrPath, pathOrMiddleware, ...middlewares);
624
- }
625
- patch(nameOrPath, pathOrMiddleware, ...middlewares) {
626
- return this.verb("patch", nameOrPath, pathOrMiddleware, ...middlewares);
627
- }
628
- post(nameOrPath, pathOrMiddleware, ...middlewares) {
629
- return this.verb("post", nameOrPath, pathOrMiddleware, ...middlewares);
630
- }
631
- propfind(nameOrPath, pathOrMiddleware, ...middlewares) {
632
- return this.verb("propfind", nameOrPath, pathOrMiddleware, ...middlewares);
633
- }
634
- proppatch(nameOrPath, pathOrMiddleware, ...middlewares) {
635
- return this.verb("proppatch", nameOrPath, pathOrMiddleware, ...middlewares);
636
- }
637
- purge(nameOrPath, pathOrMiddleware, ...middlewares) {
638
- return this.verb("purge", nameOrPath, pathOrMiddleware, ...middlewares);
639
- }
640
- put(nameOrPath, pathOrMiddleware, ...middlewares) {
641
- return this.verb("put", nameOrPath, pathOrMiddleware, ...middlewares);
642
- }
643
- rebind(nameOrPath, pathOrMiddleware, ...middlewares) {
644
- return this.verb("rebind", nameOrPath, pathOrMiddleware, ...middlewares);
645
- }
646
- report(nameOrPath, pathOrMiddleware, ...middlewares) {
647
- return this.verb("report", nameOrPath, pathOrMiddleware, ...middlewares);
648
- }
649
- search(nameOrPath, pathOrMiddleware, ...middlewares) {
650
- return this.verb("search", nameOrPath, pathOrMiddleware, ...middlewares);
651
- }
652
- source(nameOrPath, pathOrMiddleware, ...middlewares) {
653
- return this.verb("source", nameOrPath, pathOrMiddleware, ...middlewares);
654
- }
655
- subscribe(nameOrPath, pathOrMiddleware, ...middlewares) {
656
- return this.verb("subscribe", nameOrPath, pathOrMiddleware, ...middlewares);
657
- }
658
- trace(nameOrPath, pathOrMiddleware, ...middlewares) {
659
- return this.verb("trace", nameOrPath, pathOrMiddleware, ...middlewares);
660
- }
661
- unbind(nameOrPath, pathOrMiddleware, ...middlewares) {
662
- return this.verb("unbind", nameOrPath, pathOrMiddleware, ...middlewares);
663
- }
664
- unlink(nameOrPath, pathOrMiddleware, ...middlewares) {
665
- return this.verb("unlink", nameOrPath, pathOrMiddleware, ...middlewares);
666
- }
667
- unlock(nameOrPath, pathOrMiddleware, ...middlewares) {
668
- return this.verb("unlock", nameOrPath, pathOrMiddleware, ...middlewares);
669
- }
670
- unsubscribe(nameOrPath, pathOrMiddleware, ...middlewares) {
671
- return this.verb("unsubscribe", nameOrPath, pathOrMiddleware, ...middlewares);
672
- }
673
- };
674
-
675
- //#endregion
676
- export { Router };
10
+ import {} from "./types.js";
11
+ const debug = debuglog('egg/router:Router');
12
+ export class Router {
13
+ opts;
14
+ methods;
15
+ /** Layer stack */
16
+ stack = [];
17
+ params = {};
18
+ /**
19
+ * Create a new router.
20
+ *
21
+ * @example
22
+ *
23
+ * Basic usage:
24
+ *
25
+ * ```javascript
26
+ * var Koa = require('koa');
27
+ * var Router = require('koa-router');
28
+ *
29
+ * var app = new Koa();
30
+ * var router = new Router();
31
+ *
32
+ * router.get('/', (ctx, next) => {
33
+ * // ctx.router available
34
+ * });
35
+ *
36
+ * app
37
+ * .use(router.routes())
38
+ * .use(router.allowedMethods());
39
+ * ```
40
+ *
41
+ * @alias module:koa-router
42
+ * @param {Object=} opts optional
43
+ * @param {String=} opts.prefix prefix router paths
44
+ * @class
45
+ */
46
+ constructor(opts) {
47
+ this.opts = opts ?? {};
48
+ this.methods = this.opts.methods ?? ['HEAD', 'OPTIONS', 'GET', 'PUT', 'PATCH', 'POST', 'DELETE'];
49
+ }
50
+ use(pathOrMiddleware, ...middlewares) {
51
+ // support array of paths
52
+ // use(paths, ...middlewares)
53
+ if (Array.isArray(pathOrMiddleware) && typeof pathOrMiddleware[0] === 'string') {
54
+ for (const path of pathOrMiddleware) {
55
+ this.use(path, ...middlewares);
56
+ }
57
+ return this;
58
+ }
59
+ let path = '';
60
+ let hasPath = false;
61
+ if (typeof pathOrMiddleware === 'string') {
62
+ // use(path, ...middlewares)
63
+ path = pathOrMiddleware;
64
+ hasPath = true;
65
+ }
66
+ else if (typeof pathOrMiddleware === 'function') {
67
+ // use(...middlewares)
68
+ middlewares = [pathOrMiddleware, ...middlewares];
69
+ }
70
+ for (const m of middlewares) {
71
+ if (m.router) {
72
+ for (const nestedLayer of m.router.stack) {
73
+ if (path) {
74
+ nestedLayer.setPrefix(path);
75
+ }
76
+ if (this.opts.prefix) {
77
+ nestedLayer.setPrefix(this.opts.prefix);
78
+ }
79
+ this.stack.push(nestedLayer);
80
+ }
81
+ if (this.params) {
82
+ for (const key in this.params) {
83
+ m.router.param(key, this.params[key]);
84
+ }
85
+ }
86
+ }
87
+ else {
88
+ this.register(path || '(.*)', [], m, { end: false, ignoreCaptures: !hasPath });
89
+ }
90
+ }
91
+ return this;
92
+ }
93
+ /**
94
+ * Set the path prefix for a Router instance that was already initialized.
95
+ *
96
+ * @example
97
+ *
98
+ * ```javascript
99
+ * router.prefix('/things/:thing_id')
100
+ * ```
101
+ *
102
+ * @param {String} prefix prefix string
103
+ * @return {Router} router instance
104
+ */
105
+ prefix(prefix) {
106
+ prefix = prefix.replace(/\/$/, '');
107
+ this.opts.prefix = prefix;
108
+ for (const layer of this.stack) {
109
+ layer.setPrefix(prefix);
110
+ }
111
+ return this;
112
+ }
113
+ /**
114
+ * Returns router middleware which dispatches a route matching the request.
115
+ *
116
+ * @return {Function} middleware function
117
+ */
118
+ routes() {
119
+ const dispatch = (ctx, next) => {
120
+ const routerPath = this.opts.routerPath || ctx.routerPath || ctx.path;
121
+ const matched = this.match(routerPath, ctx.method);
122
+ debug('dispatch: %s %s, routerPath: %s, matched: %s', ctx.method, ctx.path, routerPath, matched.route);
123
+ if (ctx.matched) {
124
+ ctx.matched.push(...matched.path);
125
+ }
126
+ else {
127
+ ctx.matched = matched.path;
128
+ }
129
+ ctx.router = this;
130
+ if (!matched.route) {
131
+ return next();
132
+ }
133
+ const matchedLayers = matched.pathAndMethod;
134
+ const layerChain = matchedLayers.reduce((memo, layer) => {
135
+ memo.push((ctx, next) => {
136
+ // ctx.captures = layer.captures(routerPath, ctx.captures);
137
+ ctx.captures = layer.captures(routerPath);
138
+ ctx.params = layer.params(routerPath, ctx.captures, ctx.params);
139
+ // ctx._matchedRouteName & ctx._matchedRoute for compatibility
140
+ ctx._matchedRouteName = ctx.routerName = layer.name;
141
+ if (!layer.name) {
142
+ ctx._matchedRouteName = undefined;
143
+ }
144
+ ctx._matchedRoute = ctx.routerPath = layer.path;
145
+ return next();
146
+ });
147
+ return memo.concat(layer.stack);
148
+ }, []);
149
+ return compose(layerChain)(ctx, next);
150
+ };
151
+ dispatch.router = this;
152
+ return dispatch;
153
+ }
154
+ /**
155
+ * @alias to routes()
156
+ */
157
+ middleware() {
158
+ return this.routes();
159
+ }
160
+ /**
161
+ * Returns separate middleware for responding to `OPTIONS` requests with
162
+ * an `Allow` header containing the allowed methods, as well as responding
163
+ * with `405 Method Not Allowed` and `501 Not Implemented` as appropriate.
164
+ *
165
+ * @example
166
+ *
167
+ * ```javascript
168
+ * var Koa = require('koa');
169
+ * var Router = require('koa-router');
170
+ *
171
+ * var app = new Koa();
172
+ * var router = new Router();
173
+ *
174
+ * app.use(router.routes());
175
+ * app.use(router.allowedMethods());
176
+ * ```
177
+ *
178
+ * **Example with [Boom](https://github.com/hapijs/boom)**
179
+ *
180
+ * ```javascript
181
+ * var Koa = require('koa');
182
+ * var Router = require('koa-router');
183
+ * var Boom = require('boom');
184
+ *
185
+ * var app = new Koa();
186
+ * var router = new Router();
187
+ *
188
+ * app.use(router.routes());
189
+ * app.use(router.allowedMethods({
190
+ * throw: true,
191
+ * notImplemented: () => new Boom.notImplemented(),
192
+ * methodNotAllowed: () => new Boom.methodNotAllowed()
193
+ * }));
194
+ * ```
195
+ *
196
+ * @param {Object=} options optional params
197
+ * @param {Boolean=} options.throw throw error instead of setting status and header
198
+ * @param {Function=} options.notImplemented throw the returned value in place of the default NotImplemented error
199
+ * @param {Function=} options.methodNotAllowed throw the returned value in place of the default MethodNotAllowed error
200
+ * @return {Function} middleware function
201
+ */
202
+ allowedMethods(options) {
203
+ const implemented = this.methods;
204
+ return async function allowedMethods(ctx, next) {
205
+ await next();
206
+ if (ctx.status && ctx.status !== 404)
207
+ return;
208
+ const allowed = {};
209
+ ctx.matched.forEach((route) => {
210
+ route.methods.forEach(method => {
211
+ allowed[method] = method;
212
+ });
213
+ });
214
+ const allowedMethods = Object.keys(allowed);
215
+ if (!implemented.includes(ctx.method)) {
216
+ if (options?.throw) {
217
+ let notImplementedThrowable;
218
+ if (typeof options?.notImplemented === 'function') {
219
+ notImplementedThrowable = options.notImplemented(); // set whatever the user returns from their function
220
+ }
221
+ else {
222
+ notImplementedThrowable = new HttpError.NotImplemented();
223
+ }
224
+ throw notImplementedThrowable;
225
+ }
226
+ else {
227
+ ctx.status = 501;
228
+ ctx.set('Allow', allowedMethods.join(', '));
229
+ }
230
+ }
231
+ else if (allowedMethods.length > 0) {
232
+ if (ctx.method === 'OPTIONS') {
233
+ ctx.status = 200;
234
+ ctx.body = '';
235
+ ctx.set('Allow', allowedMethods.join(', '));
236
+ }
237
+ else if (!allowed[ctx.method]) {
238
+ if (options?.throw) {
239
+ let notAllowedThrowable;
240
+ if (typeof options?.methodNotAllowed === 'function') {
241
+ notAllowedThrowable = options.methodNotAllowed(); // set whatever the user returns from their function
242
+ }
243
+ else {
244
+ notAllowedThrowable = new HttpError.MethodNotAllowed();
245
+ }
246
+ throw notAllowedThrowable;
247
+ }
248
+ else {
249
+ ctx.status = 405;
250
+ ctx.set('Allow', allowedMethods.join(', '));
251
+ }
252
+ }
253
+ }
254
+ };
255
+ }
256
+ /**
257
+ * Redirect `source` to `destination` URL with optional 30x status `code`.
258
+ *
259
+ * Both `source` and `destination` can be route names.
260
+ *
261
+ * ```javascript
262
+ * router.redirect('/login', 'sign-in');
263
+ * ```
264
+ *
265
+ * This is equivalent to:
266
+ *
267
+ * ```javascript
268
+ * router.all('/login', ctx => {
269
+ * ctx.redirect('/sign-in');
270
+ * ctx.status = 301;
271
+ * });
272
+ * ```
273
+ *
274
+ * @param {String} source URL or route name.
275
+ * @param {String} destination URL or route name.
276
+ * @param {Number=} status HTTP status code (default: 301).
277
+ * @return {Router} router instance
278
+ */
279
+ redirect(source, destination, status = 301) {
280
+ // lookup source route by name
281
+ if (source[0] !== '/') {
282
+ const routeUrl = this.url(source);
283
+ if (routeUrl instanceof Error) {
284
+ throw routeUrl;
285
+ }
286
+ source = routeUrl;
287
+ }
288
+ // lookup destination route by name
289
+ if (destination[0] !== '/') {
290
+ const routeUrl = this.url(destination);
291
+ if (routeUrl instanceof Error) {
292
+ throw routeUrl;
293
+ }
294
+ destination = routeUrl;
295
+ }
296
+ return this.all(source, ctx => {
297
+ ctx.redirect(destination);
298
+ ctx.status = status;
299
+ });
300
+ }
301
+ /**
302
+ * Create and register a route.
303
+ *
304
+ * @param {String|RegExp|(String|RegExp)[]} path Path string.
305
+ * @param {String[]} methods Array of HTTP verbs.
306
+ * @param {Function|Function[]} middleware Multiple middleware also accepted.
307
+ * @param {Object} [opts] optional params
308
+ * @private
309
+ */
310
+ register(path, methods, middleware, opts) {
311
+ // support array of paths
312
+ if (Array.isArray(path)) {
313
+ const routes = [];
314
+ for (const p of path) {
315
+ const route = this.#register(p, methods, middleware, opts);
316
+ routes.push(route);
317
+ }
318
+ return routes;
319
+ }
320
+ // create route
321
+ const route = this.#register(path, methods, middleware, opts);
322
+ return route;
323
+ }
324
+ #register(path, methods, middleware, opts) {
325
+ opts = opts ?? {};
326
+ // create route
327
+ const route = new Layer(path, methods, middleware, {
328
+ end: opts.end === false ? opts.end : true,
329
+ name: opts.name,
330
+ sensitive: opts.sensitive ?? this.opts.sensitive ?? false,
331
+ strict: opts.strict ?? this.opts.strict ?? false,
332
+ prefix: opts.prefix ?? this.opts.prefix ?? '',
333
+ ignoreCaptures: opts.ignoreCaptures,
334
+ });
335
+ // FIXME: why???
336
+ if (this.opts.prefix) {
337
+ route.setPrefix(this.opts.prefix);
338
+ }
339
+ // add parameter middleware to the new route layer
340
+ for (const param in this.params) {
341
+ route.param(param, this.params[param]);
342
+ }
343
+ this.stack.push(route);
344
+ return route;
345
+ }
346
+ /**
347
+ * Lookup route with given `name`.
348
+ *
349
+ * @param {String} name route name
350
+ * @return {Layer|false} layer instance of false
351
+ */
352
+ route(name) {
353
+ for (const route of this.stack) {
354
+ if (route.name === name) {
355
+ return route;
356
+ }
357
+ }
358
+ return false;
359
+ }
360
+ /**
361
+ * Generate URL for route. Takes a route name and map of named `params`.
362
+ *
363
+ * @example
364
+ *
365
+ * ```javascript
366
+ * router.get('user', '/users/:id', (ctx, next) => {
367
+ * // ...
368
+ * });
369
+ *
370
+ * router.url('user', 3);
371
+ * // => "/users/3"
372
+ *
373
+ * router.url('user', { id: 3 });
374
+ * // => "/users/3"
375
+ *
376
+ * router.use((ctx, next) => {
377
+ * // redirect to named route
378
+ * ctx.redirect(ctx.router.url('sign-in'));
379
+ * })
380
+ *
381
+ * router.url('user', { id: 3 }, { query: { limit: 1 } });
382
+ * // => "/users/3?limit=1"
383
+ *
384
+ * router.url('user', { id: 3 }, { query: "limit=1" });
385
+ * // => "/users/3?limit=1"
386
+ * ```
387
+ */
388
+ url(name, params, ...paramsOrOptions) {
389
+ const route = this.route(name);
390
+ if (route) {
391
+ return route.url(params, ...paramsOrOptions);
392
+ }
393
+ return new Error(`No route found for name: ${name}`);
394
+ }
395
+ /**
396
+ * Generate URL from url pattern and given `params`.
397
+ *
398
+ * @example
399
+ *
400
+ * ```javascript
401
+ * var url = Router.url('/users/:id', { id: 1 });
402
+ * // => "/users/1"
403
+ * ```
404
+ *
405
+ * @param {String} path url pattern
406
+ * @param {Object} params url parameters
407
+ * @return {String} url string
408
+ */
409
+ static url(path, params, ...paramsOrOptions) {
410
+ return Layer.prototype.url.call({ path }, params, ...paramsOrOptions);
411
+ }
412
+ /**
413
+ * Match given `path` and return corresponding routes.
414
+ *
415
+ * @param {String} path path string
416
+ * @param {String} method method name
417
+ * @return {Object.<path, pathAndMethod>} returns layers that matched path and
418
+ * path and method.
419
+ * @private
420
+ */
421
+ match(path, method) {
422
+ const matched = {
423
+ // matched path
424
+ path: [],
425
+ // matched path and method(including none method)
426
+ pathAndMethod: [],
427
+ // method matched or not
428
+ route: false,
429
+ };
430
+ for (const layer of this.stack) {
431
+ debug('test %s %s', layer.path, layer.regexp);
432
+ if (layer.match(path)) {
433
+ matched.path.push(layer);
434
+ if (layer.methods.length === 0 || layer.methods.includes(method)) {
435
+ matched.pathAndMethod.push(layer);
436
+ if (layer.methods.length > 0) {
437
+ matched.route = true;
438
+ }
439
+ }
440
+ // if (layer.methods.length === 0) {
441
+ // matched.pathAndMethod.push(layer);
442
+ // } else if (layer.methods.includes(method)) {
443
+ // matched.pathAndMethod.push(layer);
444
+ // matched.route = true;
445
+ // }
446
+ }
447
+ }
448
+ return matched;
449
+ }
450
+ /**
451
+ * Run middleware for named route parameters. Useful for auto-loading or
452
+ * validation.
453
+ *
454
+ * @example
455
+ *
456
+ * ```javascript
457
+ * router
458
+ * .param('user', (id, ctx, next) => {
459
+ * ctx.user = users[id];
460
+ * if (!ctx.user) return ctx.status = 404;
461
+ * return next();
462
+ * })
463
+ * .get('/users/:user', ctx => {
464
+ * ctx.body = ctx.user;
465
+ * })
466
+ * .get('/users/:user/friends', ctx => {
467
+ * return ctx.user.getFriends().then(function(friends) {
468
+ * ctx.body = friends;
469
+ * });
470
+ * })
471
+ * // /users/3 => {"id": 3, "name": "Alex"}
472
+ * // /users/3/friends => [{"id": 4, "name": "TJ"}]
473
+ * ```
474
+ *
475
+ * @param {String} param param
476
+ * @param {Function} middleware route middleware
477
+ * @return {Router} instance
478
+ */
479
+ param(param, middleware) {
480
+ this.params[param] = middleware;
481
+ for (const route of this.stack) {
482
+ route.param(param, middleware);
483
+ }
484
+ return this;
485
+ }
486
+ _formatRouteParams(nameOrPath, pathOrMiddleware, middlewares) {
487
+ const options = {};
488
+ let path;
489
+ if (typeof nameOrPath === 'string' && nameOrPath.startsWith('/')) {
490
+ // verb(method, path, ...middlewares)
491
+ path = nameOrPath;
492
+ middlewares = [pathOrMiddleware, ...middlewares];
493
+ if (typeof pathOrMiddleware === 'string') {
494
+ // verb(method, path, controllerString)
495
+ // set controller name to router name
496
+ options.name = pathOrMiddleware;
497
+ }
498
+ }
499
+ else if (nameOrPath instanceof RegExp) {
500
+ // verb(method, pathRegex, ...middlewares)
501
+ path = nameOrPath;
502
+ middlewares = [pathOrMiddleware, ...middlewares];
503
+ if (typeof pathOrMiddleware === 'string') {
504
+ // verb(method, pathRegex, controllerString)
505
+ // set controller name to router name
506
+ options.name = pathOrMiddleware;
507
+ }
508
+ }
509
+ else if (Array.isArray(nameOrPath)) {
510
+ // verb(method, paths, ...middlewares)
511
+ path = nameOrPath;
512
+ middlewares = [pathOrMiddleware, ...middlewares];
513
+ if (typeof pathOrMiddleware === 'string') {
514
+ // verb(method, pathRegex, controllerString)
515
+ // set controller name to router name
516
+ options.name = pathOrMiddleware;
517
+ }
518
+ }
519
+ else if (typeof pathOrMiddleware === 'string' || pathOrMiddleware instanceof RegExp) {
520
+ // verb(method, name, path, ...middlewares)
521
+ path = pathOrMiddleware;
522
+ assert(typeof nameOrPath === 'string', 'route name should be string');
523
+ options.name = nameOrPath;
524
+ }
525
+ else if (Array.isArray(pathOrMiddleware)) {
526
+ // verb(method, name, paths, ...middlewares)
527
+ path = pathOrMiddleware;
528
+ assert(typeof nameOrPath === 'string', 'route name should be string');
529
+ options.name = nameOrPath;
530
+ }
531
+ else {
532
+ // verb(method, path, ...middlewares)
533
+ path = nameOrPath;
534
+ middlewares = [pathOrMiddleware, ...middlewares];
535
+ }
536
+ return {
537
+ path,
538
+ middlewares,
539
+ options,
540
+ };
541
+ }
542
+ /**
543
+ * Create `router.verb()` methods, where *verb* is one of the HTTP verbs such
544
+ * as `router.get()` or `router.post()`.
545
+ *
546
+ * Match URL patterns to callback functions or controller actions using `router.verb()`,
547
+ * where **verb** is one of the HTTP verbs such as `router.get()` or `router.post()`.
548
+ *
549
+ * Additionally, `router.all()` can be used to match against all methods.
550
+ *
551
+ * ```javascript
552
+ * router
553
+ * .get('/', (ctx, next) => {
554
+ * ctx.body = 'Hello World!';
555
+ * })
556
+ * .post('/users', (ctx, next) => {
557
+ * // ...
558
+ * })
559
+ * .put('/users/:id', (ctx, next) => {
560
+ * // ...
561
+ * })
562
+ * .del('/users/:id', (ctx, next) => {
563
+ * // ...
564
+ * })
565
+ * .all('/users/:id', (ctx, next) => {
566
+ * // ...
567
+ * });
568
+ * ```
569
+ *
570
+ * When a route is matched, its path is available at `ctx._matchedRoute` and if named,
571
+ * the name is available at `ctx._matchedRouteName`
572
+ *
573
+ * Route paths will be translated to regular expressions using
574
+ * [path-to-regexp](https://github.com/pillarjs/path-to-regexp).
575
+ *
576
+ * Query strings will not be considered when matching requests.
577
+ *
578
+ * #### Named routes
579
+ *
580
+ * Routes can optionally have names. This allows generation of URLs and easy
581
+ * renaming of URLs during development.
582
+ *
583
+ * ```javascript
584
+ * router.get('user', '/users/:id', (ctx, next) => {
585
+ * // ...
586
+ * });
587
+ *
588
+ * router.url('user', 3);
589
+ * // => "/users/3"
590
+ * ```
591
+ *
592
+ * #### Multiple middleware
593
+ *
594
+ * Multiple middleware may be given:
595
+ *
596
+ * ```javascript
597
+ * router.get(
598
+ * '/users/:id',
599
+ * (ctx, next) => {
600
+ * return User.findOne(ctx.params.id).then(function(user) {
601
+ * ctx.user = user;
602
+ * next();
603
+ * });
604
+ * },
605
+ * ctx => {
606
+ * console.log(ctx.user);
607
+ * // => { id: 17, name: "Alex" }
608
+ * }
609
+ * );
610
+ * ```
611
+ *
612
+ * ### Nested routers
613
+ *
614
+ * Nesting routers is supported:
615
+ *
616
+ * ```javascript
617
+ * var forums = new Router();
618
+ * var posts = new Router();
619
+ *
620
+ * posts.get('/', (ctx, next) => {...});
621
+ * posts.get('/:pid', (ctx, next) => {...});
622
+ * forums.use('/forums/:fid/posts', posts.routes(), posts.allowedMethods());
623
+ *
624
+ * // responds to "/forums/123/posts" and "/forums/123/posts/123"
625
+ * app.use(forums.routes());
626
+ * ```
627
+ *
628
+ * #### Router prefixes
629
+ *
630
+ * Route paths can be prefixed at the router level:
631
+ *
632
+ * ```javascript
633
+ * var router = new Router({
634
+ * prefix: '/users'
635
+ * });
636
+ *
637
+ * router.get('/', ...); // responds to "/users"
638
+ * router.get('/:id', ...); // responds to "/users/:id"
639
+ * ```
640
+ *
641
+ * #### URL parameters
642
+ *
643
+ * Named route parameters are captured and added to `ctx.params`.
644
+ *
645
+ * ```javascript
646
+ * router.get('/:category/:title', (ctx, next) => {
647
+ * console.log(ctx.params);
648
+ * // => { category: 'programming', title: 'how-to-node' }
649
+ * });
650
+ * ```
651
+ *
652
+ * The [path-to-regexp](https://github.com/pillarjs/path-to-regexp) module is
653
+ * used to convert paths to regular expressions.
654
+ *
655
+ */
656
+ verb(method, nameOrPath, pathOrMiddleware, ...middleware) {
657
+ const { options, path, middlewares } = this._formatRouteParams(nameOrPath, pathOrMiddleware, middleware);
658
+ if (typeof method === 'string') {
659
+ method = [method];
660
+ }
661
+ this.register(path, method, middlewares, options);
662
+ return this;
663
+ }
664
+ all(nameOrPath, pathOrMiddleware, ...middlewares) {
665
+ return this.verb(methods, nameOrPath, pathOrMiddleware, ...middlewares);
666
+ }
667
+ acl(nameOrPath, pathOrMiddleware, ...middlewares) {
668
+ return this.verb('acl', nameOrPath, pathOrMiddleware, ...middlewares);
669
+ }
670
+ bind(nameOrPath, pathOrMiddleware, ...middlewares) {
671
+ return this.verb('bind', nameOrPath, pathOrMiddleware, ...middlewares);
672
+ }
673
+ checkout(nameOrPath, pathOrMiddleware, ...middlewares) {
674
+ return this.verb('checkout', nameOrPath, pathOrMiddleware, ...middlewares);
675
+ }
676
+ connect(nameOrPath, pathOrMiddleware, ...middlewares) {
677
+ return this.verb('connect', nameOrPath, pathOrMiddleware, ...middlewares);
678
+ }
679
+ copy(nameOrPath, pathOrMiddleware, ...middlewares) {
680
+ return this.verb('copy', nameOrPath, pathOrMiddleware, ...middlewares);
681
+ }
682
+ delete(nameOrPath, pathOrMiddleware, ...middlewares) {
683
+ return this.verb('delete', nameOrPath, pathOrMiddleware, ...middlewares);
684
+ }
685
+ del(nameOrPath, pathOrMiddleware, ...middlewares) {
686
+ return this.verb('delete', nameOrPath, pathOrMiddleware, ...middlewares);
687
+ }
688
+ get(nameOrPath, pathOrMiddleware, ...middlewares) {
689
+ return this.verb('get', nameOrPath, pathOrMiddleware, ...middlewares);
690
+ }
691
+ query(nameOrPath, pathOrMiddleware, ...middlewares) {
692
+ return this.verb('query', nameOrPath, pathOrMiddleware, ...middlewares);
693
+ }
694
+ head(nameOrPath, pathOrMiddleware, ...middlewares) {
695
+ return this.verb('head', nameOrPath, pathOrMiddleware, ...middlewares);
696
+ }
697
+ link(nameOrPath, pathOrMiddleware, ...middlewares) {
698
+ return this.verb('link', nameOrPath, pathOrMiddleware, ...middlewares);
699
+ }
700
+ lock(nameOrPath, pathOrMiddleware, ...middlewares) {
701
+ return this.verb('lock', nameOrPath, pathOrMiddleware, ...middlewares);
702
+ }
703
+ ['m-search'](nameOrPath, pathOrMiddleware, ...middlewares) {
704
+ return this.verb('m-search', nameOrPath, pathOrMiddleware, ...middlewares);
705
+ }
706
+ merge(nameOrPath, pathOrMiddleware, ...middlewares) {
707
+ return this.verb('merge', nameOrPath, pathOrMiddleware, ...middlewares);
708
+ }
709
+ mkactivity(nameOrPath, pathOrMiddleware, ...middlewares) {
710
+ return this.verb('mkactivity', nameOrPath, pathOrMiddleware, ...middlewares);
711
+ }
712
+ mkcalendar(nameOrPath, pathOrMiddleware, ...middlewares) {
713
+ return this.verb('mkcalendar', nameOrPath, pathOrMiddleware, ...middlewares);
714
+ }
715
+ mkcol(nameOrPath, pathOrMiddleware, ...middlewares) {
716
+ return this.verb('mkcol', nameOrPath, pathOrMiddleware, ...middlewares);
717
+ }
718
+ move(nameOrPath, pathOrMiddleware, ...middlewares) {
719
+ return this.verb('move', nameOrPath, pathOrMiddleware, ...middlewares);
720
+ }
721
+ notify(nameOrPath, pathOrMiddleware, ...middlewares) {
722
+ return this.verb('notify', nameOrPath, pathOrMiddleware, ...middlewares);
723
+ }
724
+ options(nameOrPath, pathOrMiddleware, ...middlewares) {
725
+ return this.verb('options', nameOrPath, pathOrMiddleware, ...middlewares);
726
+ }
727
+ patch(nameOrPath, pathOrMiddleware, ...middlewares) {
728
+ return this.verb('patch', nameOrPath, pathOrMiddleware, ...middlewares);
729
+ }
730
+ post(nameOrPath, pathOrMiddleware, ...middlewares) {
731
+ return this.verb('post', nameOrPath, pathOrMiddleware, ...middlewares);
732
+ }
733
+ propfind(nameOrPath, pathOrMiddleware, ...middlewares) {
734
+ return this.verb('propfind', nameOrPath, pathOrMiddleware, ...middlewares);
735
+ }
736
+ proppatch(nameOrPath, pathOrMiddleware, ...middlewares) {
737
+ return this.verb('proppatch', nameOrPath, pathOrMiddleware, ...middlewares);
738
+ }
739
+ purge(nameOrPath, pathOrMiddleware, ...middlewares) {
740
+ return this.verb('purge', nameOrPath, pathOrMiddleware, ...middlewares);
741
+ }
742
+ put(nameOrPath, pathOrMiddleware, ...middlewares) {
743
+ return this.verb('put', nameOrPath, pathOrMiddleware, ...middlewares);
744
+ }
745
+ rebind(nameOrPath, pathOrMiddleware, ...middlewares) {
746
+ return this.verb('rebind', nameOrPath, pathOrMiddleware, ...middlewares);
747
+ }
748
+ report(nameOrPath, pathOrMiddleware, ...middlewares) {
749
+ return this.verb('report', nameOrPath, pathOrMiddleware, ...middlewares);
750
+ }
751
+ search(nameOrPath, pathOrMiddleware, ...middlewares) {
752
+ return this.verb('search', nameOrPath, pathOrMiddleware, ...middlewares);
753
+ }
754
+ source(nameOrPath, pathOrMiddleware, ...middlewares) {
755
+ return this.verb('source', nameOrPath, pathOrMiddleware, ...middlewares);
756
+ }
757
+ subscribe(nameOrPath, pathOrMiddleware, ...middlewares) {
758
+ return this.verb('subscribe', nameOrPath, pathOrMiddleware, ...middlewares);
759
+ }
760
+ trace(nameOrPath, pathOrMiddleware, ...middlewares) {
761
+ return this.verb('trace', nameOrPath, pathOrMiddleware, ...middlewares);
762
+ }
763
+ unbind(nameOrPath, pathOrMiddleware, ...middlewares) {
764
+ return this.verb('unbind', nameOrPath, pathOrMiddleware, ...middlewares);
765
+ }
766
+ unlink(nameOrPath, pathOrMiddleware, ...middlewares) {
767
+ return this.verb('unlink', nameOrPath, pathOrMiddleware, ...middlewares);
768
+ }
769
+ unlock(nameOrPath, pathOrMiddleware, ...middlewares) {
770
+ return this.verb('unlock', nameOrPath, pathOrMiddleware, ...middlewares);
771
+ }
772
+ unsubscribe(nameOrPath, pathOrMiddleware, ...middlewares) {
773
+ return this.verb('unsubscribe', nameOrPath, pathOrMiddleware, ...middlewares);
774
+ }
775
+ }
776
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Router.js","sourceRoot":"","sources":["../src/Router.ts"],"names":[],"mappings":"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"}