@eggjs/router 2.0.1 → 3.0.1

package/dist/commonjs/EggRouter.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EggRouter = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const utility_1 = require("utility");
+const inflection_1 = __importDefault(require("inflection"));
+const methods_1 = __importDefault(require("methods"));
+const Router_js_1 = require("./Router.js");
+const REST_MAP = {
+    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',
+    },
+};
+/**
+ * FIXME: move these patch into @eggjs/router
+ */
+class EggRouter extends Router_js_1.Router {
+    app;
+    /**
+     * @class
+     * @param {Object} opts - Router options.
+     * @param {Application} app - Application object.
+     */
+    constructor(opts, app) {
+        super(opts);
+        this.app = app;
+    }
+    verb(method, nameOrPath, pathOrMiddleware, ...middleware) {
+        const { path, middlewares, options } = this._formatRouteParams(nameOrPath, pathOrMiddleware, middleware);
+        if (typeof method === 'string') {
+            method = [method];
+        }
+        this.register(path, method, middlewares, options);
+        return this;
+    }
+    head(nameOrPath, pathOrMiddleware, ...middlewares) {
+        return this.verb('head', nameOrPath, pathOrMiddleware, ...middlewares);
+    }
+    options(nameOrPath, pathOrMiddleware, ...middlewares) {
+        return this.verb('options', nameOrPath, pathOrMiddleware, ...middlewares);
+    }
+    get(nameOrPath, pathOrMiddleware, ...middlewares) {
+        return this.verb('get', nameOrPath, pathOrMiddleware, ...middlewares);
+    }
+    put(nameOrPath, pathOrMiddleware, ...middlewares) {
+        return this.verb('put', nameOrPath, pathOrMiddleware, ...middlewares);
+    }
+    patch(nameOrPath, pathOrMiddleware, ...middlewares) {
+        return this.verb('patch', nameOrPath, pathOrMiddleware, ...middlewares);
+    }
+    post(nameOrPath, pathOrMiddleware, ...middlewares) {
+        return this.verb('post', nameOrPath, pathOrMiddleware, ...middlewares);
+    }
+    delete(nameOrPath, pathOrMiddleware, ...middlewares) {
+        return this.verb('delete', nameOrPath, pathOrMiddleware, ...middlewares);
+    }
+    all(nameOrPath, pathOrMiddleware, ...middlewares) {
+        return this.verb(methods_1.default, nameOrPath, pathOrMiddleware, ...middlewares);
+    }
+    register(path, methods, middleware, opts) {
+        // patch register to support generator function middleware and string controller
+        middleware = Array.isArray(middleware) ? middleware : [middleware];
+        const middlewares = convertMiddlewares(middleware, this.app);
+        return super.register(path, methods, middlewares, opts);
+    }
+    resources(nameOrPath, pathOrMiddleware, ...middleware) {
+        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];
+            if (!action)
+                continue;
+            const opts = REST_MAP[key];
+            let routeName;
+            if (opts.member) {
+                routeName = inflection_1.default.singularize(options.name ?? '');
+            }
+            else {
+                routeName = inflection_1.default.pluralize(options.name ?? '');
+            }
+            if (opts.namePrefix) {
+                routeName = opts.namePrefix + routeName;
+            }
+            const prefix = path.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, params) {
+        const route = this.route(name);
+        if (!route)
+            return '';
+        const args = params;
+        let url = route.path;
+        (0, node_assert_1.default)(!(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 = [];
+            url = url.replace(/:([a-zA-Z_]\w*)/g, ($0, key) => {
+                if (key in args) {
+                    const values = args[key];
+                    replacedParams.push(key);
+                    return (0, utility_1.encodeURIComponent)(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 = (0, utility_1.encodeURIComponent)(key);
+                if (Array.isArray(values)) {
+                    for (const val of values) {
+                        queries.push(`${encodedKey}=${(0, utility_1.encodeURIComponent)(String(val))}`);
+                    }
+                }
+                else {
+                    queries.push(`${encodedKey}=${(0, utility_1.encodeURIComponent)(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, params) {
+        return this.url(name, params);
+    }
+}
+exports.EggRouter = EggRouter;
+/**
+ * resolve controller from string to function
+ * @param {String|Function} controller input controller
+ * @param {Application} app egg application instance
+ */
+function resolveController(controller, app) {
+    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;
+    }
+    // ensure controller is exists
+    if (!controller)
+        throw new Error('controller not exists');
+    return controller;
+}
+/**
+ * 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. make middleware support generator function
+ *
+ * @param  {Array} middlewares middlewares and controller(last middleware)
+ * @param  {Application} app  egg application instance
+ */
+function convertMiddlewares(middlewares, app) {
+    // ensure controller is resolved
+    const controller = resolveController(middlewares.pop(), app);
+    return [...middlewares, controller];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EggRouter.js","sourceRoot":"","sources":["../../src/EggRouter.ts"],"names":[],"mappings":";;;;;;AAAA,8DAAiC;AACjC,qCAAuE;AACvE,4DAAoC;AACpC,sDAA8B;AAC9B,2CAAmF;AAUnF,MAAM,QAAQ,GAAmC;IAC/C,KAAK,EAAE;QACL,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,KAAK;KACd;IACD,GAAG,EAAE;QACH,UAAU,EAAE,MAAM;QAClB,MAAM,EAAE,IAAI;QACZ,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,KAAK;KACd;IACD,MAAM,EAAE;QACN,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,MAAM;KACf;IACD,IAAI,EAAE;QACJ,MAAM,EAAE,IAAI;QACZ,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,KAAK;KACd;IACD,IAAI,EAAE;QACJ,MAAM,EAAE,IAAI;QACZ,UAAU,EAAE,OAAO;QACnB,MAAM,EAAE,UAAU;QAClB,MAAM,EAAE,KAAK;KACd;IACD,MAAM,EAAE;QACN,MAAM,EAAE,IAAI;QACZ,UAAU,EAAE,EAAE;QACd,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,CAAE,OAAO,EAAE,KAAK,CAAE;KAC3B;IACD,OAAO,EAAE;QACP,MAAM,EAAE,IAAI;QACZ,UAAU,EAAE,UAAU;QACtB,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,QAAQ;KACjB;CACF,CAAC;AAMF;;GAEG;AACH,MAAa,SAAU,SAAQ,kBAAM;IAC1B,GAAG,CAAc;IAE1B;;;;OAIG;IACH,YAAY,IAAmB,EAAE,GAAgB;QAC/C,KAAK,CAAC,IAAI,CAAC,CAAC;QACZ,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED,IAAI,CAAC,MAAqC,EACxC,UAAiD,EACjD,gBAAwE,EACxE,GAAG,UAAuC;QAC1C,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,gBAAgB,EAAE,UAAU,CAAC,CAAC;QACzG,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC/B,MAAM,GAAG,CAAE,MAAM,CAAE,CAAC;QACtB,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;QAClD,OAAO,IAAI,CAAC;IACd,CAAC;IAKD,IAAI,CAAC,UAAiD,EACpD,gBAAwE,EACxE,GAAG,WAAwC;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,WAAW,CAAC,CAAC;IACzE,CAAC;IAGD,OAAO,CAAC,UAAiD,EACvD,gBAAwE,EACxE,GAAG,WAAwC;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,WAAW,CAAC,CAAC;IAC5E,CAAC;IAGD,GAAG,CAAC,UAAiD,EACnD,gBAAwE,EACxE,GAAG,WAAwC;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,WAAW,CAAC,CAAC;IACxE,CAAC;IAGD,GAAG,CAAC,UAAiD,EACnD,gBAAwE,EACxE,GAAG,WAAwC;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,WAAW,CAAC,CAAC;IACxE,CAAC;IAGD,KAAK,CAAC,UAAiD,EACrD,gBAAwE,EACxE,GAAG,WAAwC;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,WAAW,CAAC,CAAC;IAC1E,CAAC;IAGD,IAAI,CAAC,UAAiD,EACpD,gBAAwE,EACxE,GAAG,WAAwC;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,WAAW,CAAC,CAAC;IACzE,CAAC;IAGD,MAAM,CAAC,UAAiD,EACtD,gBAAwE,EACxE,GAAG,WAAwC;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,WAAW,CAAC,CAAC;IAC3E,CAAC;IAGD,GAAG,CAAC,UAAiD,EACnD,gBAAwE,EACxE,GAAG,WAAwC;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,iBAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,WAAW,CAAC,CAAC;IAC1E,CAAC;IAED,QAAQ,CAAC,IAA2C,EAClD,OAAiB,EACjB,UAAuF,EACvF,IAAsB;QACtB,gFAAgF;QAChF,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAE,UAAU,CAAE,CAAC;QACrE,MAAM,WAAW,GAAG,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7D,OAAO,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;IAC1D,CAAC;IAkDD,SAAS,CAAC,UAA2B,EAAE,gBAAwE,EAC7G,GAAG,UAA6D;QAChE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,gBAAgB,EAAE,UAAU,CAAC,CAAC;QACzG,qCAAqC;QACrC,MAAM,UAAU,GAAG,iBAAiB,CAAC,WAAW,CAAC,GAAG,EAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QACnE,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;YAC3B,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAmB,CAAC;YACjD,IAAI,CAAC,MAAM;gBAAE,SAAS;YAEtB,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;YAC3B,IAAI,SAAS,CAAC;YACd,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;gBAChB,SAAS,GAAG,oBAAU,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;YACzD,CAAC;iBAAM,CAAC;gBACN,SAAS,GAAG,oBAAU,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;YACvD,CAAC;YACD,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;gBACpB,SAAS,GAAG,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;YAC1C,CAAC;YACD,MAAM,MAAM,GAAI,IAAe,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACnD,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;YAClE,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,IAAI,CAAC,MAAM,CAAE,CAAC;YAC1E,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;QAClF,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,IAAY,EAAE,MAA8D;QAC9E,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,KAAK;YAAE,OAAO,EAAE,CAAC;QAEtB,MAAM,IAAI,GAAG,MAAM,CAAC;QACpB,IAAI,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC;QAErB,IAAA,qBAAM,EAAC,CAAC,CAAC,GAAG,YAAY,MAAM,CAAC,EAAE,gCAAgC,GAAG,iBAAiB,IAAI,GAAG,CAAC,CAAC;QAE9F,MAAM,OAAO,GAAG,EAAE,CAAC;QACnB,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAC9C,MAAM,cAAc,GAAa,EAAE,CAAC;YACpC,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,kBAAkB,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE;gBAChD,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;oBAChB,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;oBACzB,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACzB,OAAO,IAAA,4BAAsB,EAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC5F,CAAC;gBACD,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC,CAAC;YAEH,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;gBACvB,IAAI,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;oBACjC,SAAS;gBACX,CAAC;gBACD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;gBACzB,MAAM,UAAU,GAAG,IAAA,4BAAsB,EAAC,GAAG,CAAC,CAAC;gBAC/C,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;oBAC1B,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;wBACzB,OAAO,CAAC,IAAI,CAAC,GAAG,UAAU,IAAI,IAAA,4BAAsB,EAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;oBACvE,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,IAAI,CAAC,GAAG,UAAU,IAAI,IAAA,4BAAsB,EAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;gBAC1E,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvB,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACnC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBACvB,GAAG,GAAG,GAAG,GAAG,IAAI,QAAQ,EAAE,CAAC;YAC7B,CAAC;iBAAM,CAAC;gBACN,GAAG,GAAG,GAAG,GAAG,IAAI,QAAQ,EAAE,CAAC;YAC7B,CAAC;QACH,CAAC;QAED,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,IAAY,EAAE,MAA8D;QAClF,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAChC,CAAC;CACF;AA5OD,8BA4OC;AAED;;;;GAIG;AACH,SAAS,iBAAiB,CAAC,UAAyD,EAAE,GAAgB;IACpG,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;QACnC,yCAAyC;QACzC,MAAM,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC;QACzB,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACpB,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;YACf,IAAI,CAAC,GAAG;gBAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,UAAU,aAAa,CAAC,CAAC;QACvE,CAAC,CAAC,CAAC;QACH,UAAU,GAAG,GAAU,CAAC;IAC1B,CAAC;IACD,8BAA8B;IAC9B,IAAI,CAAC,UAAU;QAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;IAC1D,OAAO,UAAiB,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,kBAAkB,CAAC,WAA8D,EAAE,GAAgB;IAC1G,gCAAgC;IAChC,MAAM,UAAU,GAAG,iBAAiB,CAAC,WAAW,CAAC,GAAG,EAAG,EAAE,GAAG,CAAC,CAAC;IAC9D,OAAO,CAAE,GAAG,WAA+B,EAAE,UAAU,CAAE,CAAC;AAC5D,CAAC"}

package/dist/commonjs/Layer.d.ts

@@ -0,0 +1,114 @@
+import { type Key } from 'path-to-regexp';
+import type { MiddlewareFunc, MiddlewareFuncWithParamProperty, ParamMiddlewareFunc } from './types.js';
+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 declare 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);
+    /**
+     * Returns whether request `path` matches route.
+     *
+     * @param {String} path path string
+     * @return {Boolean} matched or not
+     * @private
+     */
+    match(path: string): boolean;
+    /**
+     * 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>;
+    /**
+     * Returns array of regexp url path captures.
+     *
+     * @param {String} path path string
+     * @return {Array.<String>} captures strings
+     * @private
+     */
+    captures(path: string): Array<string>;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Prefix route path.
+     *
+     * @param {String} prefix prefix string
+     * @return {Layer} layer instance
+     * @private
+     */
+    setPrefix(prefix: string): Layer;
+}

package/dist/commonjs/Layer.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Layer = void 0;
+const node_util_1 = require("node:util");
+const path_to_regexp_1 = __importDefault(require("path-to-regexp"));
+const urijs_1 = __importDefault(require("urijs"));
+const utility_1 = require("utility");
+const is_type_of_1 = require("is-type-of");
+const debug = (0, node_util_1.debuglog)('egg-router:layer');
+class Layer {
+    opts;
+    name;
+    methods = [];
+    stack;
+    path;
+    regexp;
+    paramNames = [];
+    /**
+     * 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, methods, middlewares, opts) {
+        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 ((0, is_type_of_1.isGeneratorFunction)(fn)) {
+                throw new TypeError(methods.toString() + ' `' + (this.opts.name || path) + '`: Please use async function instead of generator function');
+            }
+        });
+        this.path = path;
+        this.regexp = (0, path_to_regexp_1.default)(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) {
+        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, captures, existingParams) {
+        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 ? (0, utility_1.decodeURIComponent)(c) : c;
+            }
+        }
+        return params;
+    }
+    /**
+     * Returns array of regexp url path captures.
+     *
+     * @param {String} path path string
+     * @return {Array.<String>} captures strings
+     * @private
+     */
+    captures(path) {
+        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, ...paramsOrOptions) {
+        let args = params;
+        const url = this.path.replace(/\(\.\*\)/g, '');
+        const toPath = path_to_regexp_1.default.compile(url);
+        let options;
+        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 = path_to_regexp_1.default.parse(url);
+        let replace = {};
+        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;
+        }
+        else {
+            // route.url(options);
+            options = params;
+        }
+        const replaced = toPath(replace);
+        if (options?.query) {
+            const urlObject = new urijs_1.default(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, fn) {
+        const stack = this.stack;
+        const params = this.paramNames;
+        const middleware = function (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) {
+        if (this.path) {
+            this.path = prefix + this.path;
+            this.paramNames = [];
+            this.regexp = (0, path_to_regexp_1.default)(this.path, this.paramNames, this.opts);
+        }
+        return this;
+    }
+}
+exports.Layer = Layer;
+//# sourceMappingURL=data:application/json;base64,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