@esportsplus/routing 0.0.23 → 0.0.24

package/build/browser.d.ts

@@ -1,15 +1,15 @@
 import { Middleware, Response, Router } from './types';
 declare function back(): void;
 declare function forward(): void;
-declare const _default: <R>(instance?: Router<R> | undefined) => {
+declare const _default: <T>(instance?: Router<T> | undefined) => {
     back: typeof back;
     forward: typeof forward;
-    middleware: (...middleware: Middleware<R>[]) => () => Response<R>;
+    middleware: (...middleware: Middleware<T>[]) => () => Response<T>;
     redirect: (path: string, { state, values }: {
         state?: Record<PropertyKey, unknown> | undefined;
         values?: unknown[] | undefined;
     }) => void;
-    router: Router<R>;
+    router: Router<T>;
     uri: (path: string, values?: unknown[]) => string;
 };
 export default _default;

package/build/router/index.d.ts

@@ -1,26 +1,26 @@
 import { Options } from '../types';
 import { Node } from './node';
 import { Route } from './route';
-declare class Router<R> {
-    groups: Omit<Options<R>, 'responder'>[];
-    root: Node<R>;
-    routes: Record<string, Route<R>>;
-    static: Record<string, Route<R>>;
+declare class Router<T> {
+    groups: Omit<Options<T>, 'responder'>[];
+    root: Node<T>;
+    routes: Record<string, Route<T>>;
+    static: Record<string, Route<T>>;
     subdomains: string[] | null;
     constructor();
     private add;
     private route;
-    delete(options: Options<R>): this;
-    get(options: Options<R>): this;
-    group(options: Router<R>['groups'][0]): {
-        routes: (fn: (router: Router<R>) => void) => void;
+    delete(options: Options<T>): this;
+    get(options: Options<T>): this;
+    group(options: Router<T>['groups'][0]): {
+        routes: (fn: (router: Router<T>) => void) => void;
     };
-    match(method: string, path: string, subdomain?: string | null): ReturnType<Node<R>['find']>;
-    on(methods: string[], options: Options<R>): this;
-    post(options: Options<R>): this;
-    put(options: Options<R>): this;
+    match(method: string, path: string, subdomain?: string | null): ReturnType<Node<T>['find']>;
+    on(methods: string[], options: Options<T>): this;
+    post(options: Options<T>): this;
+    put(options: Options<T>): this;
     uri(name: string, values?: unknown[]): string;
 }
-declare const _default: <R>() => Router<R>;
+declare const _default: <T>() => Router<T>;
 export default _default;
 export { Router, Route };

package/build/router/node.d.ts

@@ -1,16 +1,16 @@
 import { Route } from './index';
-declare class Node<R> {
-    children: Map<string | number, Node<R>> | null;
-    parent: Node<R> | null;
+declare class Node<T> {
+    children: Map<string | number, Node<T>> | null;
+    parent: Node<T> | null;
     path: string | null;
     property: string | null;
-    route: Route<R> | null;
+    route: Route<T> | null;
     type: number | null;
-    constructor(parent?: Node<R>['parent']);
-    add(path: string, route: Route<R>): Node<R>;
+    constructor(parent?: Node<T>['parent']);
+    add(path: string, route: Route<T>): Node<T>;
     find(path: string): {
         parameters?: Record<PropertyKey, unknown>;
-        route?: Route<R>;
+        route?: Route<T>;
     };
     remove(path: string): void;
 }

package/build/router/route.d.ts

@@ -1,12 +1,12 @@
 import { Middleware, Next, Responder } from '../types';
-declare class Route<R> {
-    dispatch: Next<R> | null;
+declare class Route<T> {
+    dispatch: Next<T> | null;
     name: string | null;
     path: string | null;
-    responder: Responder<R>;
-    stack: Middleware<R>[] | null;
+    responder: Responder<T>;
+    stack: Middleware<T>[] | null;
     subdomain: string | null;
-    constructor(responder: Responder<R>);
-    get dispatcher(): Next<R>;
+    constructor(responder: Responder<T>);
+    get dispatcher(): Next<T>;
 }
 export { Route };

package/build/types.d.ts

@@ -1,16 +1,16 @@
 import { Next as N, Stage } from '@esportsplus/pipeline';
 import { Route, Router } from './router';
-type Middleware<R> = Stage<Request, Response<R>>;
-type Next<R> = N<Request, Response<R>>;
-type Options<R> = {
-    middleware?: Middleware<R>[];
+type Middleware<T> = Stage<Request<T>, Response<T>>;
+type Next<T> = N<Request<T>, Response<T>>;
+type Options<T> = {
+    middleware?: Middleware<T>[];
     name?: string;
     path?: string;
-    responder: Responder<R>;
+    responder: Responder<T>;
     subdomain?: string;
 };
-type Request = {
-    data: Record<PropertyKey, unknown>;
+type Request<T> = {
+    data: Record<PropertyKey, unknown> & ReturnType<Router<T>['match']>;
     href: string;
     hostname: string;
     method: string;
@@ -21,6 +21,6 @@ type Request = {
     query: Record<string, unknown>;
     subdomain?: string;
 };
-type Responder<R> = (request: Request) => Response<R>;
-type Response<R> = Promise<R> | R;
+type Responder<T> = (request: Request<T>) => Response<T>;
+type Response<T> = Promise<T> | T;
 export { Middleware, Next, Options, Request, Responder, Response, Route, Router };

package/package.json

@@ -17,5 +17,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.23"
+    "version": "0.0.24"
 }

package/src/browser.ts

@@ -4,7 +4,7 @@ import pipeline from '@esportsplus/pipeline';
 import factory from './router';
 
 
-let cache: Request[] = [],
+let cache: Request<any>[] = [],
     registered = false;
 
 
@@ -37,7 +37,7 @@ function onpopstate() {
     }
 }
 
-function request(): Request {
+function request<T>(): Request<T> {
     let { hash, hostname, href, origin, port, protocol } = new URL( window.location?.href || '' ),
         path = hash ? hash.slice(1).split('?') : ['/', ''];
 
@@ -55,9 +55,9 @@ function request(): Request {
 }
 
 
-export default <R>(instance?: Router<R>) => {
-    let router = instance || factory<R>(),
-        state = reactive( request() );
+export default <T>(instance?: Router<T>) => {
+    let router = instance || factory<T>(),
+        state = reactive( request<T>() );
 
     cache.push(state);
 
@@ -69,8 +69,8 @@ export default <R>(instance?: Router<R>) => {
     return {
         back,
         forward,
-        middleware: (...middleware: Middleware<R>[]) => {
-            let instance = pipeline<Request, Response<R>>(...middleware);
+        middleware: (...middleware: Middleware<T>[]) => {
+            let instance = pipeline<Request<T>, Response<T>>(...middleware);
 
             return () => instance(state);
         },

package/src/router/index.ts

@@ -23,7 +23,7 @@ function radixkey(method: string, path: string, subdomain?: string | null) {
     return ((subdomain ? subdomain + ' ' : '') + method).toUpperCase() + ' ' + normalize(path);
 }
 
-function set<R>(route: Route<R>, key: keyof Route<R>, value?: unknown) {
+function set<T>(route: Route<T>, key: keyof Route<T>, value?: unknown) {
     if (!value) {
         return;
     }
@@ -44,11 +44,11 @@ function set<R>(route: Route<R>, key: keyof Route<R>, value?: unknown) {
 }
 
 
-class Router<R> {
-    groups: Omit<Options<R>, 'responder'>[] = [];
-    root: Node<R>;
-    routes: Record<string, Route<R>> = {};
-    static: Record<string, Route<R>> = {};
+class Router<T> {
+    groups: Omit<Options<T>, 'responder'>[] = [];
+    root: Node<T>;
+    routes: Record<string, Route<T>> = {};
+    static: Record<string, Route<T>> = {};
     subdomains: string[] | null = null;
 
 
@@ -57,7 +57,7 @@ class Router<R> {
     }
 
 
-    private add(radixkey: string, route: Route<R>) {
+    private add(radixkey: string, route: Route<T>) {
         if (radixkey.indexOf(':') === -1 || this.root.add(radixkey, route).type === STATIC) {
             if (this.static[radixkey]) {
                 throw new Error(`Routing: static path '${radixkey}' is already in use`);
@@ -69,7 +69,7 @@ class Router<R> {
         return this;
     }
 
-    private route({ middleware, name, path, responder, subdomain }: Options<R>) {
+    private route({ middleware, name, path, responder, subdomain }: Options<T>) {
         let route = new Route(responder);
 
         for (let i = 0, n = this.groups.length; i < n; i++) {
@@ -98,19 +98,19 @@ class Router<R> {
     }
 
 
-    delete(options: Options<R>) {
+    delete(options: Options<T>) {
         this.on(['DELETE'], options);
         return this;
     }
 
-    get(options: Options<R>) {
+    get(options: Options<T>) {
         this.on(['GET'], options);
         return this;
     }
 
-    group(options: Router<R>['groups'][0]) {
+    group(options: Router<T>['groups'][0]) {
         return {
-            routes: (fn: (router: Router<R>) => void) => {
+            routes: (fn: (router: Router<T>) => void) => {
                 this.groups.push(options);
                 fn(this);
                 this.groups.pop();
@@ -118,7 +118,7 @@ class Router<R> {
         }
     }
 
-    match(method: string, path: string, subdomain?: string | null): ReturnType<Node<R>['find']> {
+    match(method: string, path: string, subdomain?: string | null): ReturnType<Node<T>['find']> {
         let key = radixkey(method, path, subdomain);
 
         if (key in this.static) {
@@ -130,7 +130,7 @@ class Router<R> {
         return this.root.find(key);
     }
 
-    on(methods: string[], options: Options<R>) {
+    on(methods: string[], options: Options<T>) {
         let route = this.route(options);
 
         if (route.name) {
@@ -171,12 +171,12 @@ class Router<R> {
         return this;
     }
 
-    post(options: Options<R>) {
+    post(options: Options<T>) {
         this.on(['POST'], options);
         return this;
     }
 
-    put(options: Options<R>) {
+    put(options: Options<T>) {
         this.on(['PUT'], options);
         return this;
     }
@@ -219,5 +219,5 @@ class Router<R> {
 }
 
 
-export default <R>() => new Router<R>();
+export default <T>() => new Router<T>();
 export { Router, Route };

package/src/router/node.ts

@@ -2,28 +2,28 @@ import { PLACEHOLDER, STATIC, WILDCARD } from '~/constants';
 import { Route } from './index';
 
 
-class Node<R> {
-    children: Map<string | number, Node<R>> | null = null;
-    parent: Node<R> | null = null;
+class Node<T> {
+    children: Map<string | number, Node<T>> | null = null;
+    parent: Node<T> | null = null;
     path: string | null = null;
     property: string | null = null;
-    route: Route<R> | null = null;
+    route: Route<T> | null = null;
     type: number | null = null;
 
 
-    constructor(parent: Node<R>['parent'] = null) {
+    constructor(parent: Node<T>['parent'] = null) {
         this.parent = parent;
     }
 
 
-    add(path: string, route: Route<R>) {
-        let node: Node<R> | undefined = this,
+    add(path: string, route: Route<T>) {
+        let node: Node<T> | undefined = this,
             segments = path.split('/'),
-            type: Node<R>['type'] = STATIC,
+            type: Node<T>['type'] = STATIC,
             unnamed = 0;
 
         for (let i = 0, n = segments.length; i < n; i++) {
-            let child: Node<R> | undefined = node.children?.get(segments[i]);
+            let child: Node<T> | undefined = node.children?.get(segments[i]);
 
             if (!child) {
                 let segment = segments[i],
@@ -33,7 +33,7 @@ class Node<R> {
                     node.children = new Map();
                 }
 
-                node.children.set(segment, (child = new Node<R>(node)));
+                node.children.set(segment, (child = new Node<T>(node)));
 
                 // Named property
                 if (symbol === ':') {
@@ -61,12 +61,12 @@ class Node<R> {
 
     find(path: string): {
         parameters?: Record<PropertyKey, unknown>;
-        route?: Route<R>;
+        route?: Route<T>;
     } {
-        let node: Node<R> | undefined = this,
+        let node: Node<T> | undefined = this,
             parameters: Record<PropertyKey, unknown> = {},
             segments = path.split('/'),
-            wildcard: { node: Node<R>, value: string } | null = null;
+            wildcard: { node: Node<T>, value: string } | null = null;
 
         for (let i = 0, n = segments.length; i < n; i++) {
             let segment = segments[i],
@@ -80,7 +80,7 @@ class Node<R> {
             }
 
             // Exact matches take precedence over placeholders
-            let next: Node<R> | undefined = node.children?.get(segment);
+            let next: Node<T> | undefined = node.children?.get(segment);
 
             if (next) {
                 node = next;
@@ -112,7 +112,7 @@ class Node<R> {
     }
 
     remove(path: string) {
-        let node: Node<R> | undefined = this,
+        let node: Node<T> | undefined = this,
             segments = path.split('/');
 
         for (let i = 0, n = segments.length; i < n; i++) {

package/src/router/route.ts

@@ -2,16 +2,16 @@ import { Middleware, Next, Responder } from '~/types';
 import pipeline from '@esportsplus/pipeline';
 
 
-class Route<R> {
-    dispatch: Next<R> | null = null;
+class Route<T> {
+    dispatch: Next<T> | null = null;
     name: string | null = null;
     path: string | null = null;
-    responder: Responder<R>;
-    stack: Middleware<R>[] | null = null;
+    responder: Responder<T>;
+    stack: Middleware<T>[] | null = null;
     subdomain: string | null = null;
 
 
-    constructor(responder: Responder<R>) {
+    constructor(responder: Responder<T>) {
         this.responder = responder;
     }
 

package/src/types.ts

@@ -2,20 +2,20 @@ import { Next as N, Stage } from '@esportsplus/pipeline';
 import { Route, Router } from './router';
 
 
-type Middleware<R> = Stage<Request, Response<R>>;
+type Middleware<T> = Stage<Request<T>, Response<T>>;
 
-type Next<R> = N<Request, Response<R>>;
+type Next<T> = N<Request<T>, Response<T>>;
 
-type Options<R> = {
-    middleware?: Middleware<R>[];
+type Options<T> = {
+    middleware?: Middleware<T>[];
     name?: string;
     path?: string;
-    responder: Responder<R>;
+    responder: Responder<T>;
     subdomain?: string;
 };
 
-type Request = {
-    data: Record<PropertyKey, unknown>;
+type Request<T> = {
+    data: Record<PropertyKey, unknown> & ReturnType<Router<T>['match']>;
     href: string;
     hostname: string;
     method: string;
@@ -27,9 +27,9 @@ type Request = {
     subdomain?: string;
 };
 
-type Responder<R> = (request: Request) => Response<R>;
+type Responder<T> = (request: Request<T>) => Response<T>;
 
-type Response<R> = Promise<R> | R;
+type Response<T> = Promise<T> | T;
 
 
 export { Middleware, Next, Options, Request, Responder, Response, Route, Router };