@esportsplus/routing 0.0.12 → 0.0.14

package/build/constants.d.ts

@@ -0,0 +1,4 @@
+declare const PLACEHOLDER = 0;
+declare const STATIC = 1;
+declare const WILDCARD = 2;
+export { PLACEHOLDER, STATIC, WILDCARD };

package/build/constants.js

@@ -0,0 +1,4 @@
+const PLACEHOLDER = 0;
+const STATIC = 1;
+const WILDCARD = 2;
+export { PLACEHOLDER, STATIC, WILDCARD };

package/build/index.d.ts

@@ -1,6 +1,6 @@
-import hash from './hash';
 import middleware from './middleware';
 import router from './router';
 import slugify from './slugify';
-export { hash, middleware, router, slugify };
+import spa from './spa';
+export { middleware, router, slugify, spa };
 export * from './types';

package/build/index.js

@@ -1,6 +1,6 @@
-import hash from './hash';
 import middleware from './middleware';
 import router from './router';
 import slugify from './slugify';
-export { hash, middleware, router, slugify };
+import spa from './spa';
+export { middleware, router, slugify, spa };
 export * from './types';

package/build/middleware/dispatch.d.ts

@@ -1,5 +1,5 @@
-import { Router } from '../types';
-declare const _default: (request: {
+import { Middleware, Request, Router } from '../types';
+declare const _default: <R>(request: {
     data: ReturnType<Router['match']>;
-}) => unknown;
+}) => Middleware<Request, R>;
 export default _default;

package/build/middleware/index.d.ts

@@ -2,16 +2,16 @@ import factory from '@esportsplus/middleware';
 import dispatch from './dispatch';
 import match from './match';
 declare const _default: {
-    dispatch: (request: {
+    dispatch: <R>(request: {
         data: {
             parameters?: Record<PropertyKey, unknown> | undefined;
             route?: import("../router/route").Route | undefined;
         };
-    }) => unknown;
-    factory: <I, R>(...middleware: import("@esportsplus/middleware/build/types").Middleware<I, R>[]) => import("@esportsplus/middleware/build/types").Next<I, R>;
-    match: (router: import("../router").Router, { spa }?: {
+    }) => import("@esportsplus/middleware/build/types").Middleware<import("../types").Request, 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;
-    }) => (request: import("../types").Request, next: import("@esportsplus/middleware/build/types").Next<import("../types").Request, unknown>) => unknown;
+    }) => import("@esportsplus/middleware/build/types").Middleware<import("../types").Request, R_2>;
 };
 export default _default;
 export { dispatch, factory, match };

package/build/middleware/match.d.ts

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

package/build/router/index.d.ts

@@ -16,7 +16,7 @@ declare class Router {
         routes: (fn: (router: Router) => void) => void;
     };
     match(method: string, path: string, subdomain?: string | null): ReturnType<Node['find']>;
-    on(methods: string[], options: Options): void;
+    on(methods: string[], options: Options): this;
     post(options: Options): this;
     put(options: Options): this;
     uri(name: string, values?: unknown[]): string;

package/build/router/index.js

@@ -1,4 +1,4 @@
-import { STATIC } from "../symbols";
+import { STATIC } from "../constants";
 import { Node } from './node';
 import { normalize, radixkey } from './path';
 import { Route } from './route';
@@ -31,13 +31,13 @@ class Router {
         this.root = new Node();
     }
     add(radixkey, route) {
-        let node = this.root.add(radixkey, route);
-        if (node.type === STATIC) {
+        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`);
             }
             this.static[radixkey] = route;
         }
+        return this;
     }
     route({ middleware, name, path, responder, subdomain }) {
         let route = new Route(responder);
@@ -79,10 +79,8 @@ class Router {
     }
     match(method, path, subdomain) {
         let key = radixkey(path, { method, subdomain });
-        if (this.static[key]) {
-            return {
-                route: this.static[key]
-            };
+        if (key in this.static) {
+            return { route: this.static[key] };
         }
         return this.root.find(key);
     }
@@ -119,6 +117,7 @@ class Router {
                 this.subdomains.push(route.subdomain);
             }
         }
+        return this;
     }
     post(options) {
         this.on(['POST'], options);
@@ -129,7 +128,7 @@ class Router {
         return this;
     }
     uri(name, values = []) {
-        let path = this.routes?.[name]?.path;
+        let path = this.routes[name]?.path;
         if (!path) {
             throw new Error(`Routing: route name '${name}' does not exist or it does not provide a path`);
         }

package/build/router/node.js

@@ -1,4 +1,4 @@
-import { PLACEHOLDER, STATIC, WILDCARD } from "../symbols";
+import { PLACEHOLDER, STATIC, WILDCARD } from "../constants";
 class Node {
     children = null;
     parent = null;

package/build/spa.d.ts

@@ -0,0 +1,16 @@
+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;
+    redirect: (path: string, { state, values }: {
+        state?: Record<PropertyKey, unknown> | undefined;
+        values?: unknown[] | undefined;
+    }) => void;
+    request: Record<string, unknown>;
+    uri: (path: string, values?: unknown[]) => string;
+};
+export default _default;

package/build/spa.js

@@ -0,0 +1,56 @@
+let cache = [];
+function request(url = window?.location?.href || '') {
+    let { hash, hostname, href, origin, port, protocol } = new URL(url), path = hash?.replace('#/', '/')?.split('?') || ['/', ''];
+    return {
+        data: {},
+        href,
+        hostname,
+        method: 'GET',
+        origin,
+        path: path[0],
+        port,
+        protocol,
+        query: Object.fromEntries((new URLSearchParams(path[1])).entries())
+    };
+}
+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];
+        }
+    }
+}
+const back = () => window.history.back();
+const forward = () => window.history.forward();
+export default (router, fn = request) => {
+    let state = {};
+    cache.push({
+        factory: fn,
+        state
+    });
+    update();
+    window.addEventListener('popstate', update);
+    return {
+        back,
+        forward,
+        redirect: (path, { state, values }) => {
+            if (path.startsWith('http://') || path.startsWith('https://')) {
+                return window.location.replace(path);
+            }
+            let uri = router.uri(path, values || []);
+            if (uri[0] === '/') {
+                uri = '#' + uri;
+            }
+            window.history.pushState(state || {}, '', uri);
+        },
+        request: state,
+        uri: (path, values = []) => {
+            let uri = router.uri(path, values || []);
+            if (uri[0] === '/') {
+                uri = '#' + uri;
+            }
+            return uri;
+        }
+    };
+};

package/build/types.d.ts

@@ -8,11 +8,16 @@ type Options = {
     subdomain?: string;
 };
 type Request = {
-    data: ReturnType<Router['match']>;
+    data: ReturnType<Router['match']> & Record<PropertyKey, unknown>;
+    href: string;
     hostname: string;
     method: string;
+    origin: string;
     path: string;
+    port: string;
+    protocol: string;
+    query: Record<string, unknown>;
     subdomain?: string;
 };
-type Responder = <T>(request: T) => Promise<unknown> | unknown;
+type Responder = <T, U>(request: T) => Promise<U> | U;
 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.12"
+    "version": "0.0.14"
 }

package/src/index.ts

@@ -1,8 +1,8 @@
-import hash from './hash';
 import middleware from './middleware';
 import router from './router';
 import slugify from './slugify';
+import spa from './spa';
 
 
-export { hash, middleware, router, slugify };
+export { middleware, router, slugify, spa };
 export * from './types';

package/src/middleware/dispatch.ts

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

package/src/middleware/match.ts

@@ -1,10 +1,10 @@
-import { Next, Request, Router } from '~/types';
+import { Middleware, Request, Router } from '~/types';
 
 
-export default (router: Router, { spa }: { spa?: boolean } = {}) => {
+export default <R>(router: Router, { spa }: { spa?: boolean } = {}): Middleware<Request, R> => {
     let subdomain: string | null = null;
 
-    return (request: Request, next: Next<Request, unknown>) => {
+    return (request, next) => {
         if ((typeof request.subdomain !== 'string' && !spa) || subdomain === null) {
             if (router.subdomains) {
                 for (let i = 0, n = router.subdomains.length; i < n; i++) {

package/src/router/index.ts

@@ -1,4 +1,4 @@
-import { STATIC } from "~/symbols";
+import { STATIC } from "~/constants";
 import { Options } from '~/types';
 import { Node } from './node';
 import { normalize, radixkey } from './path';
@@ -8,13 +8,13 @@ import { Route } from './route';
 let { isArray } = Array;
 
 
-function set(route: Route, key: keyof Route, value?: any) {
+function set(route: Route, key: keyof Route, value?: unknown) {
     if (!value) {
         return;
     }
 
     if (!route[key]) {
-        (route[key] as any) = value;
+        (route[key] as unknown) = value;
     }
     else if (typeof value === 'string') {
         if (typeof route[key] === 'string') {
@@ -23,7 +23,7 @@ function set(route: Route, key: keyof Route, value?: any) {
     }
     else if (isArray(value)) {
         if (isArray(route[key])) {
-            (route[key] as any[]).push( ...value );
+            (route[key] as unknown[]).push( ...value );
         }
     }
 }
@@ -43,15 +43,15 @@ class Router {
 
 
     private add(radixkey: string, route: Route) {
-        let node = this.root.add(radixkey, route);
-
-        if (node.type === STATIC) {
+        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`);
             }
 
             this.static[radixkey] = route;
         }
+
+        return this;
     }
 
     private route({ middleware, name, path, responder, subdomain }: Options) {
@@ -106,10 +106,8 @@ class Router {
     match(method: string, path: string, subdomain?: string | null): ReturnType<Node['find']> {
         let key = radixkey(path, { method, subdomain });
 
-        if (this.static[key]) {
-            return {
-                route: this.static[key]
-            };
+        if (key in this.static) {
+            return { route: this.static[key] };
         }
 
         return this.root.find(key);
@@ -155,6 +153,8 @@ class Router {
                 this.subdomains.push(route.subdomain);
             }
         }
+
+        return this;
     }
 
     post(options: Options) {
@@ -168,7 +168,7 @@ class Router {
     }
 
     uri(name: string, values: unknown[] = []) {
-        let path = this.routes?.[name]?.path;
+        let path = this.routes[name]?.path;
 
         if (!path) {
             throw new Error(`Routing: route name '${name}' does not exist or it does not provide a path`);

package/src/router/node.ts

@@ -1,4 +1,4 @@
-import { PLACEHOLDER, STATIC, WILDCARD } from "~/symbols";
+import { PLACEHOLDER, STATIC, WILDCARD } from "~/constants";
 import { Route } from './index';
 
 

package/src/spa.ts

@@ -0,0 +1,86 @@
+import { Request, Router } from './types';
+
+
+type Cache<T = Record<string, unknown>> = {
+    factory: () => T;
+    state: T;
+};
+
+
+let cache: Cache[] = [];
+
+
+function request(url: string = window?.location?.href || ''): Request {
+    let { hash, hostname, href, origin, port, protocol } = new URL( url ),
+        path = hash?.replace('#/', '/')?.split('?') || ['/', ''];
+
+    return {
+        data: {},
+        href,
+        hostname,
+        method: 'GET',
+        origin,
+        path: path[0],
+        port,
+        protocol,
+        query: Object.fromEntries( (new URLSearchParams(path[1])).entries() )
+    };
+}
+
+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];
+        }
+    }
+}
+
+
+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();
+
+    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://')) {
+                return window.location.replace(path);
+            }
+
+            let uri = router.uri(path, values || []);
+
+            if (uri[0] === '/') {
+                uri = '#' + uri;
+            }
+
+            window.history.pushState(state || {}, '', uri);
+        },
+        request: state,
+        uri: (path: string, values: unknown[] = []) => {
+            let uri = router.uri(path, values || []);
+
+            if (uri[0] === '/') {
+                uri = '#' + uri;
+            }
+
+            return uri;
+        }
+    };
+};

package/src/types.ts

@@ -11,14 +11,19 @@ type Options = {
 };
 
 type Request = {
-    data: ReturnType<Router['match']>;
+    data: ReturnType<Router['match']> & Record<PropertyKey, unknown>;
+    href: string;
     hostname: string;
     method: string;
+    origin: string;
     path: string;
+    port: string;
+    protocol: string;
+    query: Record<string, unknown>;
     subdomain?: string;
 };
 
-type Responder = <T>(request: T) => Promise<unknown> | unknown;
+type Responder = <T, U>(request: T) => Promise<U> | U;
 
 
 export { Middleware, Next, Options, Request, Responder, Route, Router };

package/src/hash.ts

@@ -1,106 +0,0 @@
-import { Router } from './types';
-
-
-let cache: {
-        factory: typeof request;
-        state: Record<PropertyKey, unknown>;
-    }[] = [],
-    registered = false;
-
-
-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 as keyof typeof values];
-        }
-    }
-}
-
-
-const back = () => window.history.back();
-
-const forward = () => window.history.forward();
-
-const listener = {
-    register: (factory: typeof cache[0]['factory'], state: typeof cache[0]['state']) => {
-        cache.push({ factory, state });
-
-        if (!registered) {
-            registered = true;
-            update();
-
-            window.addEventListener('popstate', update);
-        }
-
-        return () => {
-            listener.remove(state);
-        };
-    },
-    remove: (state: typeof cache[0]['state']) => {
-        for (let i = 0, n = cache.length; i < n; i++) {
-            if (cache[i].state !== state) {
-                continue;
-            }
-
-            cache[i] = cache[n - 1];
-            cache.pop();
-
-            if (cache.length === 0) {
-                window.removeEventListener('popstate', update);
-            }
-            return;
-        }
-    }
-};
-
-const factory = {
-    redirect: (router: Router) => {
-        return (path: string, { state, values }: { state?: Record<PropertyKey, unknown>; values?: unknown[] }) => {
-            if (path.startsWith('http://') || path.startsWith('https://')) {
-                return window.location.replace(path);
-            }
-
-            let uri = router.uri(path, values || []);
-
-            if (uri[0] === '/') {
-                uri = '#' + uri;
-            }
-
-            window.history.pushState(state || {}, '', uri);
-        };
-    },
-    uri: (router: Router) => {
-        return (path: string, values: unknown[] = []) => {
-            let uri = router.uri(path, values || []);
-
-            if (uri[0] === '/') {
-                uri = '#' + uri;
-            }
-
-            return uri;
-        };
-    }
-};
-
-const request = (url: string = window?.location?.href || '') => {
-    let { hash, hostname, href, origin, port, protocol } = new URL( url ),
-        path = hash?.replace('#/', '/')?.split('?') || ['/', ''];
-
-    return {
-        href,
-        hostname,
-        method: 'GET',
-        origin,
-        path: path[0],
-        port,
-        protocol,
-        query: Object.fromEntries( (new URLSearchParams(path[1])).entries() )
-    };
-};
-
-
-export default { back, factory, forward, listener, request };
-export { back, factory, forward, listener, request };