@esportsplus/routing 0.0.32 → 0.0.34

package/build/browser.d.ts

@@ -1,17 +1,15 @@
-import { Middleware, Next, Request, Router } from './types';
+import { Scheduler } from '@esportsplus/reactivity';
+import { Middleware, Next, NeverAsync, Request, Route, Router } from './types';
 declare function back(): void;
 declare function forward(): void;
 declare const _default: <T>(instance?: Router<T> | undefined) => {
     back: typeof back;
     forward: typeof forward;
-    match: {
-        (subdomain?: string): {
-            parameters?: Record<PropertyKey, unknown> | undefined;
-            route?: import("./router/route").Route<T> | undefined;
-        };
-        middleware(subdomain?: string): (request: Request<T>, next: Next<T>) => import("@esportsplus/template/build/types").Template;
+    middleware: {
+        (...middleware: Middleware<T>[]): () => NeverAsync<T>;
+        dispatch(request: Request<T>): NeverAsync<T>;
+        match(fallback: Route<T>, scheduler: Scheduler, subdomain?: string | undefined): (request: Request<T>, next: Next<T>) => import("@esportsplus/template/build/types").Template;
     };
-    middleware: (...middleware: Middleware<T>[]) => () => T;
     redirect: (path: string, values?: unknown[]) => void;
     router: Router<T>;
     uri: (path: string, values?: unknown[]) => string;

package/build/browser.js

@@ -23,69 +23,83 @@ function href() {
         query: path[1] ? Object.fromEntries((new URLSearchParams(path[1])).entries()) : {},
     };
 }
-function normalize(uri) {
-    if (uri[0] === '/') {
-        return '#' + uri;
-    }
-    return uri;
-}
-function onpopstate() {
-    let values = href();
-    for (let i = 0, n = cache.length; i < n; i++) {
-        let state = cache[i];
-        for (let key in values) {
-            state[key] = values[key];
+function match(request, router, subdomain) {
+    if (router.subdomains !== null) {
+        for (let i = 0, n = router.subdomains.length; i < n; i++) {
+            if (!request.hostname.startsWith(router.subdomains[i])) {
+                continue;
+            }
+            subdomain = router.subdomains[i];
+            break;
         }
     }
+    return router.match(request.method, request.path, subdomain || '');
 }
-export default (instance) => {
-    let request = reactive(href()), router = instance || factory();
-    if (cache.push(request) === 1) {
-        window.addEventListener('hashchange', onpopstate);
+function middleware(request, router) {
+    function host(...middleware) {
+        let instance = pipeline(...middleware);
+        return () => instance(request);
     }
-    function match(subdomain) {
-        if (router.subdomains !== null) {
-            for (let i = 0, n = router.subdomains.length; i < n; i++) {
-                if (!request.hostname.startsWith(router.subdomains[i])) {
-                    continue;
-                }
-                subdomain = router.subdomains[i];
-                break;
-            }
+    ;
+    host.dispatch = (request) => {
+        let { route } = request.data;
+        if (route === undefined) {
+            throw new Error(`Middleware: route is undefined!`);
         }
-        return router.match(request.method, request.path, subdomain || '');
-    }
-    match.middleware = (subdomain) => {
+        return route.dispatch(request);
+    };
+    host.match = (fallback, scheduler, subdomain) => {
         let state = reactive({
             parameters: undefined,
             route: undefined
         });
+        if (fallback === undefined) {
+            throw new Error('Middleware: fallback route does not exist');
+        }
         effect(() => {
-            let { parameters, route } = match(subdomain);
+            let { parameters, route } = match(request, router, subdomain);
             state.parameters = parameters;
-            state.route = route;
+            state.route = route || fallback;
         });
         return (request, next) => {
             return html `${() => {
                 if (state.route === undefined) {
-                    throw new Error(`Routing: route is undefined!`);
+                    throw new Error('Routing: route is undefined');
                 }
                 return root(() => {
                     request.data.parameters = state.parameters;
                     request.data.route = state.route;
                     return next(request);
-                });
+                }, { scheduler });
             }}`;
         };
     };
+    return host;
+}
+function normalize(uri) {
+    if (uri[0] === '/') {
+        return '#' + uri;
+    }
+    return uri;
+}
+function onpopstate() {
+    let values = href();
+    for (let i = 0, n = cache.length; i < n; i++) {
+        let state = cache[i];
+        for (let key in values) {
+            state[key] = values[key];
+        }
+    }
+}
+export default (instance) => {
+    let request = reactive(href()), router = instance || factory();
+    if (cache.push(request) === 1) {
+        window.addEventListener('hashchange', onpopstate);
+    }
     return {
         back,
         forward,
-        match,
-        middleware: (...middleware) => {
-            let instance = pipeline(...middleware);
-            return () => instance(request);
-        },
+        middleware: middleware(request, router),
         redirect: (path, values = []) => {
             if (path.indexOf('://') !== -1) {
                 return window.location.replace(path);

package/build/router/route.d.ts

@@ -1,4 +1,4 @@
-import { Middleware, Next, Request } from '../types';
+import { Middleware, Next, NeverAsync, Request } from '../types';
 declare class Route<T> {
     middleware: Middleware<T>[] | null;
     name: string | null;
@@ -6,6 +6,6 @@ declare class Route<T> {
     responder: Next<T>;
     subdomain: string | null;
     constructor(responder: Next<T>);
-    dispatch(request: Request<T>): T;
+    dispatch(request: Request<T>): NeverAsync<T>;
 }
 export { Route };

package/build/types.d.ts

@@ -1,7 +1,8 @@
+import { NeverAsync } from '@esportsplus/typescript';
 import { Next as N, Stage } from '@esportsplus/pipeline';
 import { Route, Router } from './router';
-type Middleware<T> = Stage<Request<T>, T>;
-type Next<T> = N<Request<T>, T>;
+type Middleware<T> = Stage<Request<T>, NeverAsync<T>>;
+type Next<T> = N<Request<T>, NeverAsync<T>>;
 type Options<T> = {
     middleware?: Middleware<T>[];
     name?: string;
@@ -21,4 +22,4 @@ type Request<T> = {
     query: Record<string, unknown>;
     subdomain?: string;
 };
-export { Middleware, Next, Options, Request, Route, Router };
+export { Middleware, Next, NeverAsync, Options, Request, Route, Router };

package/package.json

@@ -2,11 +2,11 @@
     "author": "ICJR",
     "dependencies": {
         "@esportsplus/pipeline": "^0.0.5",
-        "@esportsplus/reactivity": "^0.1.3",
+        "@esportsplus/reactivity": "^0.1.7",
         "@esportsplus/template": "^0.1.5"
     },
     "devDependencies": {
-        "@esportsplus/typescript": "^0.0.3"
+        "@esportsplus/typescript": "^0.0.7"
     },
     "main": "./build/index.js",
     "name": "@esportsplus/routing",
@@ -18,5 +18,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.32"
+    "version": "0.0.34"
 }

package/src/browser.ts

@@ -1,6 +1,6 @@
-import { effect, reactive, root } from '@esportsplus/reactivity';
+import { effect, reactive, root, Scheduler } from '@esportsplus/reactivity';
 import { html } from '@esportsplus/template';
-import { Middleware, Next, Request, Router } from './types';
+import { Middleware, Next, NeverAsync, Request, Route, Router } from './types';
 import pipeline from '@esportsplus/pipeline';
 import factory from './router';
 
@@ -33,68 +33,59 @@ function href<T>(): Request<T> {
     };
 }
 
-function normalize(uri: string) {
-    if (uri[0] === '/') {
-        return '#' + uri;
-    }
-
-    return uri;
-}
-
-function onpopstate() {
-    let values = href();
-
-    for (let i = 0, n = cache.length; i < n; i++) {
-        let state = cache[i];
+function match<T>(request: Request<T>, router: Router<T>, subdomain?: string) {
+    if (router.subdomains !== null) {
+        for (let i = 0, n = router.subdomains.length; i < n; i++) {
+            if (!request.hostname.startsWith(router.subdomains[i])) {
+                continue;
+            }
 
-        for (let key in values) {
-            // @ts-ignore
-            state[key] = values[key];
+            subdomain = router.subdomains[i];
+            break;
         }
     }
-}
 
+    return router.match(request.method, request.path, subdomain || '');
+}
 
-export default <T>(instance?: Router<T>) => {
-    let request = reactive( href<T>() ),
-        router = instance || factory<T>();
+function middleware<T>(request: Request<T>, router: Router<T>) {
+    function host(...middleware: Middleware<T>[]) {
+        let instance = pipeline(...middleware);
 
-    if (cache.push(request) === 1) {
-        window.addEventListener('hashchange', onpopstate);
-    }
+        return () => instance(request);
+    };
 
-    function match(subdomain?: string) {
-        if (router.subdomains !== null) {
-            for (let i = 0, n = router.subdomains.length; i < n; i++) {
-                if (!request.hostname.startsWith(router.subdomains[i])) {
-                    continue;
-                }
+    host.dispatch = (request: Request<T>): NeverAsync<T> => {
+        let { route } = request.data;
 
-                subdomain = router.subdomains[i];
-                break;
-            }
+        if (route === undefined) {
+            throw new Error(`Middleware: route is undefined!`);
         }
 
-        return router.match(request.method, request.path, subdomain || '');
-    }
+        return route.dispatch(request);
+    };
 
-    match.middleware = (subdomain?: string) => {
+    host.match = (fallback: Route<T>, scheduler: Scheduler, subdomain?: string) => {
         let state = reactive<ReturnType<typeof router.match>>({
                 parameters: undefined,
                 route: undefined
             });
 
+        if (fallback === undefined) {
+            throw new Error('Middleware: fallback route does not exist');
+        }
+
         effect(() => {
-            let { parameters, route } = match(subdomain);
+            let { parameters, route } = match(request, router, subdomain);
 
             state.parameters = parameters;
-            state.route = route;
+            state.route = route || fallback;
         });
 
         return (request: Request<T>, next: Next<T>) => {
             return html`${() => {
                 if (state.route === undefined) {
-                    throw new Error(`Routing: route is undefined!`);
+                    throw new Error('Routing: route is undefined');
                 }
 
                 return root(() => {
@@ -102,20 +93,48 @@ export default <T>(instance?: Router<T>) => {
                     request.data.route = state.route;
 
                     return next(request);
-                });
+                }, { scheduler });
             }}`;
         };
     };
 
+    return host;
+}
+
+function normalize(uri: string) {
+    if (uri[0] === '/') {
+        return '#' + uri;
+    }
+
+    return uri;
+}
+
+function onpopstate() {
+    let values = href();
+
+    for (let i = 0, n = cache.length; i < n; i++) {
+        let state = cache[i];
+
+        for (let key in values) {
+            // @ts-ignore
+            state[key] = values[key];
+        }
+    }
+}
+
+
+export default <T>(instance?: Router<T>) => {
+    let request = reactive( href<T>() ),
+        router = instance || factory<T>();
+
+    if (cache.push(request) === 1) {
+        window.addEventListener('hashchange', onpopstate);
+    }
+
     return {
         back,
         forward,
-        match,
-        middleware: (...middleware: Middleware<T>[]) => {
-            let instance = pipeline(...middleware);
-
-            return () => instance(request);
-        },
+        middleware: middleware(request, router),
         redirect: (path: string, values: unknown[] = []) => {
             if (path.indexOf('://') !== -1) {
                 return window.location.replace(path);

package/src/router/route.ts

@@ -1,4 +1,4 @@
-import { Middleware, Next, Request } from '~/types';
+import { Middleware, Next, NeverAsync, Request } from '~/types';
 import pipeline from '@esportsplus/pipeline';
 
 
@@ -15,7 +15,7 @@ class Route<T> {
     }
 
 
-    dispatch(request: Request<T>) {
+    dispatch(request: Request<T>): NeverAsync<T> {
         if (this.middleware === null) {
             return this.responder(request);
         }

package/src/types.ts

@@ -1,10 +1,11 @@
+import { NeverAsync } from '@esportsplus/typescript';
 import { Next as N, Stage } from '@esportsplus/pipeline';
 import { Route, Router } from './router';
 
 
-type Middleware<T> = Stage<Request<T>, T>;
+type Middleware<T> = Stage<Request<T>, NeverAsync<T>>;
 
-type Next<T> = N<Request<T>, T>;
+type Next<T> = N<Request<T>, NeverAsync<T>>;
 
 type Options<T> = {
     middleware?: Middleware<T>[];
@@ -28,4 +29,4 @@ type Request<T> = {
 };
 
 
-export { Middleware, Next, Options, Request, Route, Router };
+export { Middleware, Next, NeverAsync, Options, Request, Route, Router };