@esportsplus/routing 0.0.16 → 0.0.17

package/build/middleware/dispatch.d.ts

@@ -1,3 +1,3 @@
-import { Middleware, Request } from '../types';
-declare const _default: <R>(request: Request) => Middleware<Request, R>;
+import { Request, Responder } from '../types';
+declare const _default: <R>(request: Request<R>) => R | Promise<R>;
 export default _default;

package/build/middleware/index.d.ts

@@ -2,11 +2,9 @@ import factory from '@esportsplus/middleware';
 import dispatch from './dispatch';
 import match from './match';
 declare const _default: {
-    dispatch: <R>(request: import("../types").Request) => import("@esportsplus/middleware/build/types").Middleware<import("../types").Request, R>;
+    dispatch: <R>(request: import("../types").Request<R>) => R | Promise<R>;
     factory: <I, R_1>(...middleware: import("@esportsplus/middleware/build/types").Middleware<I, R_1>[]) => import("@esportsplus/middleware/build/types").Next<I, R_1>;
-    match: <R_2>(router: import("../router").Router, { spa }?: {
-        spa?: boolean | undefined;
-    }) => import("@esportsplus/middleware/build/types").Middleware<import("../types").Request, R_2>;
+    match: <R_2>(router: import("../router").Router<R_2>, subdomain?: string | undefined) => import("../types").Middleware<R_2>;
 };
 export default _default;
 export { dispatch, factory, match };

package/build/middleware/match.d.ts

@@ -1,5 +1,3 @@
-import { Middleware, Request, Router } from '../types';
-declare const _default: <R>(router: Router, { spa }?: {
-    spa?: boolean | undefined;
-}) => Middleware<Request, R>;
+import { Middleware, Router } from '../types';
+declare const _default: <R>(router: Router<R>, subdomain?: string) => Middleware<R>;
 export default _default;

package/build/middleware/match.js

@@ -1,21 +1,21 @@
-export default (router, { spa } = {}) => {
-    let subdomain = null;
+export default (router, subdomain) => {
     return (request, next) => {
-        if ((typeof request.subdomain !== 'string' && !spa) || subdomain === null) {
+        let match = subdomain || request.subdomain;
+        if (match === undefined) {
             if (router.subdomains) {
                 for (let i = 0, n = router.subdomains.length; i < n; i++) {
                     if (!request.hostname.startsWith(router.subdomains[i])) {
                         continue;
                     }
-                    subdomain = router.subdomains[i];
+                    match = router.subdomains[i];
                     break;
                 }
             }
-            if (subdomain === null) {
-                subdomain = '';
+            if (match === undefined) {
+                match = '';
             }
         }
-        let { parameters, route } = router.match(request.method, request.path, request.subdomain || subdomain);
+        let { parameters, route } = router.match(request.method, request.path, match);
         request.data.parameters = parameters;
         request.data.route = route;
         return next(request);

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

package/build/router/index.js

@@ -1,8 +1,19 @@
 import { STATIC } from '../constants';
 import { Node } from './node';
-import { normalize, radixkey } from './path';
 import { Route } from './route';
 let { isArray } = Array;
+function normalize(path) {
+    if (path[0] !== '/') {
+        path = '/' + path;
+    }
+    if (path[path.length - 1] === '/') {
+        path = path.slice(0, -1);
+    }
+    return path || '/';
+}
+function radixkey(method, path, subdomain) {
+    return ((subdomain ? subdomain + ' ' : '') + method).toUpperCase() + ' ' + normalize(path);
+}
 function set(route, key, value) {
     if (!value) {
         return;
@@ -78,9 +89,11 @@ class Router {
         };
     }
     match(method, path, subdomain) {
-        let key = radixkey(path, { method, subdomain });
+        let key = radixkey(method, path, subdomain);
         if (key in this.static) {
-            return { route: this.static[key] };
+            return {
+                route: this.static[key]
+            };
         }
         return this.root.find(key);
     }
@@ -94,10 +107,7 @@ class Router {
         }
         if (route.path) {
             for (let i = 0, n = methods.length; i < n; i++) {
-                let key = radixkey(route.path, {
-                    method: methods[i],
-                    subdomain: route.subdomain
-                });
+                let key = radixkey(methods[i], route.path, route.subdomain);
                 if (key.indexOf('?:') !== -1) {
                     let segments = key.split('?:'), url = '';
                     for (let i = 0, n = segments.length; i < n; i++) {

package/build/router/node.d.ts

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

package/build/router/node.js

@@ -20,12 +20,12 @@ class Node {
                 }
                 node.children.set(segment, (child = new Node(node)));
                 if (symbol === ':') {
-                    child.property = segment.slice(1) || `${unnamed++}`;
+                    child.property = (segment.slice(1) || unnamed++).toString();
                     node.children.set(PLACEHOLDER, child);
                     type = null;
                 }
                 else if (symbol === '*') {
-                    child.property = segment.slice(2) || `${unnamed++}`;
+                    child.property = (segment.slice(2) || unnamed++).toString();
                     node.children.set(WILDCARD, child);
                     type = null;
                 }
@@ -79,15 +79,15 @@ class Node {
                 return;
             }
         }
-        if (!node?.children?.size) {
-            let parent = node.parent;
-            if (parent && parent.children) {
-                parent.children.delete(segments[segments.length - 1]);
-                parent.children.delete(WILDCARD);
-                parent.children.delete(PLACEHOLDER);
-            }
+        if (node.children?.size) {
+            return;
+        }
+        let parent = node.parent;
+        if (parent && parent.children) {
+            parent.children.delete(segments[segments.length - 1]);
+            parent.children.delete(WILDCARD);
+            parent.children.delete(PLACEHOLDER);
         }
-        return node;
     }
 }
 export { Node };

package/build/router/route.d.ts

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

package/build/router/route.js

@@ -11,7 +11,7 @@ class Route {
     }
     get dispatcher() {
         if (this.dispatch === null) {
-            if (!this.stack?.length) {
+            if (this.stack === null) {
                 this.dispatch = (request) => this.responder(request);
             }
             else {

package/build/spa.d.ts

@@ -1,16 +1,14 @@
-import { Router } from './types';
-type Cache<T = Record<string, unknown>> = {
-    factory: () => T;
-    state: T;
-};
-declare const _default: (router: Router, fn?: Cache['factory']) => {
-    back: () => void;
-    forward: () => void;
+import { Request, Router } from './types';
+declare function back(): void;
+declare function forward(): void;
+declare const _default: <R>(router: Router<R>) => {
+    back: typeof back;
+    forward: typeof forward;
     redirect: (path: string, { state, values }: {
         state?: Record<PropertyKey, unknown> | undefined;
         values?: unknown[] | undefined;
     }) => void;
-    request: Record<string, unknown>;
+    request: Request<unknown>;
     uri: (path: string, values?: unknown[]) => string;
 };
 export default _default;

package/build/spa.js

@@ -1,6 +1,18 @@
-let cache = [];
-function request(url = window?.location?.href || '') {
-    let { hash, hostname, href, origin, port, protocol } = new URL(url), path = hash?.replace('#/', '/')?.split('?') || ['/', ''];
+let state = request();
+function back() {
+    window.history.back();
+}
+function forward() {
+    window.history.forward();
+}
+function normalize(uri) {
+    if (uri[0] === '/') {
+        return '#' + uri;
+    }
+    return uri;
+}
+function request() {
+    let { hash, hostname, href, origin, port, protocol } = new URL(window?.location?.href || ''), path = hash?.replace('#/', '/')?.split('?') || ['/', ''];
     return {
         data: {},
         href,
@@ -14,43 +26,25 @@ function request(url = window?.location?.href || '') {
     };
 }
 function update() {
-    for (let i = 0, n = cache.length; i < n; i++) {
-        let { factory, state } = cache[i], values = factory();
-        for (let key in values) {
-            state[key] = values[key];
-        }
+    let values = request();
+    for (let key in values) {
+        state[key] = values[key];
     }
 }
-const back = () => window.history.back();
-const forward = () => window.history.forward();
-export default (router, fn = request) => {
-    let state = {};
-    cache.push({
-        factory: fn,
-        state
-    });
-    update();
+export default (router) => {
     window.addEventListener('popstate', update);
     return {
         back,
         forward,
         redirect: (path, { state, values }) => {
-            if (path.startsWith('http://') || path.startsWith('https://')) {
+            if (path.startsWith('https://') || path.startsWith('http://')) {
                 return window.location.replace(path);
             }
-            let uri = router.uri(path, values || []);
-            if (uri[0] === '/') {
-                uri = '#' + uri;
-            }
-            window.history.pushState(state || {}, '', uri);
+            window.history.pushState((state || {}), '', normalize(router.uri(path, values || [])));
         },
         request: state,
         uri: (path, values = []) => {
-            let uri = router.uri(path, values || []);
-            if (uri[0] === '/') {
-                uri = '#' + uri;
-            }
-            return uri;
+            return normalize(router.uri(path, values || []));
         }
     };
 };

package/build/types.d.ts

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

package/package.json

@@ -16,5 +16,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.16"
+    "version": "0.0.17"
 }

package/src/middleware/dispatch.ts

@@ -1,12 +1,12 @@
-import { Middleware, Request } from '~/types';
+import { Request, Responder } from '~/types';
 
 
-export default <R>(request: Request) => {
+export default <R>(request: Request<R>): ReturnType<Responder<R>> => {
     let { route } = request.data;
 
     if (!route) {
         throw new Error(`Routing: route dispatching failed, route is undefined!`);
     }
 
-    return route.dispatcher(request) as Middleware<Request, R>;
+    return route.dispatcher(request);
 };

package/src/middleware/match.ts

@@ -1,28 +1,28 @@
-import { Middleware, Request, Router } from '~/types';
+import { Middleware, Router } from '~/types';
 
 
-export default <R>(router: Router, { spa }: { spa?: boolean } = {}): Middleware<Request, R> => {
-    let subdomain: string | null = null;
-
+export default <R>(router: Router<R>, subdomain?: string): Middleware<R> => {
     return (request, next) => {
-        if ((typeof request.subdomain !== 'string' && !spa) || subdomain === null) {
+        let match = subdomain || request.subdomain;
+
+        if (match === undefined) {
             if (router.subdomains) {
                 for (let i = 0, n = router.subdomains.length; i < n; i++) {
                     if (!request.hostname.startsWith(router.subdomains[i])) {
                         continue;
                     }
 
-                    subdomain = router.subdomains[i];
+                    match = router.subdomains[i];
                     break;
                 }
             }
 
-            if (subdomain === null) {
-                subdomain = '';
+            if (match === undefined) {
+                match = '';
             }
         }
 
-        let { parameters, route } = router.match(request.method, request.path, request.subdomain || subdomain);
+        let { parameters, route } = router.match(request.method, request.path, match);
 
         request.data.parameters = parameters;
         request.data.route = route;

package/src/router/index.ts

@@ -1,14 +1,29 @@
 import { STATIC } from '~/constants';
 import { Options } from '~/types';
 import { Node } from './node';
-import { normalize, radixkey } from './path';
 import { Route } from './route';
 
 
 let { isArray } = Array;
 
 
-function set(route: Route, key: keyof Route, value?: unknown) {
+function normalize(path: string) {
+    if (path[0] !== '/') {
+        path = '/' + path;
+    }
+
+    if (path[path.length - 1] === '/') {
+        path = path.slice(0, -1);
+    }
+
+    return path || '/';
+}
+
+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) {
     if (!value) {
         return;
     }
@@ -29,11 +44,11 @@ function set(route: Route, key: keyof Route, value?: unknown) {
 }
 
 
-class Router {
-    groups: Omit<Options, 'responder'>[] = [];
-    root: Node;
-    routes: Record<string, Route> = {};
-    static: Record<string, Route> = {};
+class Router<R> {
+    groups: Omit<Options<R>, 'responder'>[] = [];
+    root: Node<R>;
+    routes: Record<string, Route<R>> = {};
+    static: Record<string, Route<R>> = {};
     subdomains: string[] | null = null;
 
 
@@ -42,7 +57,7 @@ class Router {
     }
 
 
-    private add(radixkey: string, route: Route) {
+    private add(radixkey: string, route: Route<R>) {
         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`);
@@ -54,7 +69,7 @@ class Router {
         return this;
     }
 
-    private route({ middleware, name, path, responder, subdomain }: Options) {
+    private route({ middleware, name, path, responder, subdomain }: Options<R>) {
         let route = new Route(responder);
 
         for (let i = 0, n = this.groups.length; i < n; i++) {
@@ -83,19 +98,19 @@ class Router {
     }
 
 
-    delete(options: Options) {
+    delete(options: Options<R>) {
         this.on(['DELETE'], options);
         return this;
     }
 
-    get(options: Options) {
+    get(options: Options<R>) {
         this.on(['GET'], options);
         return this;
     }
 
-    group(options: Router['groups'][0]) {
+    group(options: Router<R>['groups'][0]) {
         return {
-            routes: (fn: (router: Router) => void) => {
+            routes: (fn: (router: Router<R>) => void) => {
                 this.groups.push(options);
                 fn(this);
                 this.groups.pop();
@@ -103,17 +118,19 @@ class Router {
         }
     }
 
-    match(method: string, path: string, subdomain?: string | null): ReturnType<Node['find']> {
-        let key = radixkey(path, { method, subdomain });
+    match(method: string, path: string, subdomain?: string | null): ReturnType<Node<R>['find']> {
+        let key = radixkey(method, path, subdomain);
 
         if (key in this.static) {
-            return { route: this.static[key] };
+            return {
+                route: this.static[key]
+            };
         }
 
         return this.root.find(key);
     }
 
-    on(methods: string[], options: Options) {
+    on(methods: string[], options: Options<R>) {
         let route = this.route(options);
 
         if (route.name) {
@@ -126,10 +143,7 @@ class Router {
 
         if (route.path) {
             for (let i = 0, n = methods.length; i < n; i++) {
-                let key = radixkey(route.path, {
-                        method: methods[i],
-                        subdomain: route.subdomain
-                    });
+                let key = radixkey(methods[i], route.path, route.subdomain);
 
                 if (key.indexOf('?:') !== -1) {
                     let segments = key.split('?:'),
@@ -157,12 +171,12 @@ class Router {
         return this;
     }
 
-    post(options: Options) {
+    post(options: Options<R>) {
         this.on(['POST'], options);
         return this;
     }
 
-    put(options: Options) {
+    put(options: Options<R>) {
         this.on(['PUT'], options);
         return this;
     }
@@ -205,5 +219,5 @@ class Router {
 }
 
 
-export default () => new Router();
+export default <R>() => new Router<R>();
 export { Router, Route };

package/src/router/node.ts

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

package/src/router/route.ts

@@ -1,25 +1,25 @@
-import { Middleware, Responder } from '~/types';
+import { Middleware, Next, Responder } from '~/types';
 import { factory } from '~/middleware';
 
 
-class Route {
-    dispatch: ReturnType<typeof factory> | null = null;
+class Route<R> {
+    dispatch: Next<R> | null = null;
     name: string | null = null;
     path: string | null = null;
-    responder: Responder;
-    stack: Middleware<unknown, unknown>[] | null = null;
+    responder: Responder<R>;
+    stack: Middleware<R>[] | null = null;
     subdomain: string | null = null;
 
 
-    constructor(responder: Responder) {
+    constructor(responder: Responder<R>) {
         this.responder = responder;
     }
 
 
     get dispatcher() {
         if (this.dispatch === null) {
-            if (!this.stack?.length) {
-                this.dispatch = <T>(request: T) => this.responder(request);
+            if (this.stack === null) {
+                this.dispatch = (request) => this.responder(request);
             }
             else {
                 this.dispatch = factory(...this.stack, (request => this.responder(request)));

package/src/spa.ts

@@ -1,17 +1,27 @@
 import { Request, Router } from './types';
 
 
-type Cache<T = Record<string, unknown>> = {
-    factory: () => T;
-    state: T;
-};
+let state = request();
 
 
-let cache: Cache[] = [];
+function back() {
+    window.history.back();
+}
+
+function forward() {
+    window.history.forward();
+}
+
+function normalize(uri: string) {
+    if (uri[0] === '/') {
+        return '#' + uri;
+    }
 
+    return uri;
+}
 
-function request(url: string = window?.location?.href || ''): Request {
-    let { hash, hostname, href, origin, port, protocol } = new URL( url ),
+function request<R>(): Request<R> {
+    let { hash, hostname, href, origin, port, protocol } = new URL( window?.location?.href || '' ),
         path = hash?.replace('#/', '/')?.split('?') || ['/', ''];
 
     return {
@@ -28,59 +38,31 @@ function request(url: string = window?.location?.href || ''): Request {
 }
 
 function update() {
-    for (let i = 0, n = cache.length; i < n; i++) {
-        let { factory, state } = cache[i],
-            values = factory();
+    let values = request();
 
-        for (let key in values) {
-            state[key] = values[key];
-        }
+    for (let key in values) {
+        // @ts-ignore
+        state[key] = values[key];
     }
 }
 
 
-const back = () => window.history.back();
-
-const forward = () => window.history.forward();
-
-
-export default (router: Router, fn: Cache['factory'] = request) => {
-    let state = {} as ReturnType< typeof fn >;
-
-    cache.push({
-        factory: fn,
-        state
-    });
-
-    update();
-
+export default <R>(router: Router<R>) => {
     window.addEventListener('popstate', update);
 
     return {
         back,
         forward,
         redirect: (path: string, { state, values }: { state?: Record<PropertyKey, unknown>; values?: unknown[] }) => {
-            if (path.startsWith('http://') || path.startsWith('https://')) {
+            if (path.startsWith('https://') || path.startsWith('http://')) {
                 return window.location.replace(path);
             }
 
-            let uri = router.uri(path, values || []);
-
-            if (uri[0] === '/') {
-                uri = '#' + uri;
-            }
-
-            window.history.pushState(state || {}, '', uri);
+            window.history.pushState( (state || {}), '', normalize(router.uri(path, values || [])) );
         },
         request: state,
         uri: (path: string, values: unknown[] = []) => {
-            let uri = router.uri(path, values || []);
-
-            if (uri[0] === '/') {
-                uri = '#' + uri;
-            }
-
-            return uri;
+            return normalize( router.uri(path, values || []) );
         }
     };
 };

package/src/types.ts

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

package/src/router/path.ts

@@ -1,28 +0,0 @@
-const normalize = (path: string) => {
-    if (path[0] !== '/') {
-        path = '/' + path;
-    }
-
-    if (path.endsWith('/')) {
-        path = path.slice(0, -1);
-    }
-
-    return path || '/';
-};
-
-const radixkey = (path: string, { method, subdomain }: { method?: string | null; subdomain?: string | null; } = {}) => {
-    let prefix = '';
-
-    if (subdomain) {
-        prefix = subdomain + ' ';
-    }
-
-    if (method) {
-        prefix += method + ' ';
-    }
-
-    return prefix.toUpperCase() + normalize(path);
-};
-
-
-export { normalize, radixkey };