@esportsplus/routing 0.0.25 → 0.0.27

package/build/browser.d.ts

@@ -4,46 +4,44 @@ declare function forward(): void;
 declare const _default: <T>(instance?: Router<T> | undefined) => {
     back: typeof back;
     forward: typeof forward;
-    middleware: (...middleware: Middleware<T>[]) => {
-        pipeline: () => T;
-        request: {
-            data: {
-                [x: string]: unknown;
-                [x: number]: unknown;
-                [x: symbol]: unknown;
+    match: (subdomain?: string) => {
+        data: {
+            [x: string]: unknown;
+            [x: number]: unknown;
+            [x: symbol]: unknown;
+            parameters?: Record<PropertyKey, unknown> | undefined;
+            route?: import("./router/route").Route<T> | undefined;
+        };
+        href: string;
+        hostname: string;
+        method: string;
+        origin: string;
+        path: string;
+        port: string;
+        protocol: string;
+        query: {
+            [x: string]: unknown;
+        };
+        subdomain?: string | undefined;
+        dispose: () => void;
+        reset: () => void;
+        nodes: {
+            data: import("@esportsplus/reactivity/build/signal").default<Record<PropertyKey, unknown> & {
                 parameters?: Record<PropertyKey, unknown> | undefined;
                 route?: import("./router/route").Route<T> | undefined;
-            };
-            href: string;
-            hostname: string;
-            method: string;
-            origin: string;
-            path: string;
-            port: string;
-            protocol: string;
-            query: {
-                [x: string]: unknown;
-            };
-            subdomain?: string | undefined;
-            dispose: () => void;
-            reset: () => void;
-            nodes: {
-                data: import("@esportsplus/reactivity/build/signal").default<Record<PropertyKey, unknown> & {
-                    parameters?: Record<PropertyKey, unknown> | undefined;
-                    route?: import("./router/route").Route<T> | undefined;
-                }>;
-                href: import("@esportsplus/reactivity/build/signal").default<string>;
-                hostname: import("@esportsplus/reactivity/build/signal").default<string>;
-                method: import("@esportsplus/reactivity/build/signal").default<string>;
-                origin: import("@esportsplus/reactivity/build/signal").default<string>;
-                path: import("@esportsplus/reactivity/build/signal").default<string>;
-                port: import("@esportsplus/reactivity/build/signal").default<string>;
-                protocol: import("@esportsplus/reactivity/build/signal").default<string>;
-                query: import("@esportsplus/reactivity/build/signal").default<Record<string, unknown>>;
-                subdomain?: import("@esportsplus/reactivity/build/signal").default<string> | import("@esportsplus/reactivity/build/signal").default<undefined> | undefined;
-            };
+            }>;
+            href: import("@esportsplus/reactivity/build/signal").default<string>;
+            hostname: import("@esportsplus/reactivity/build/signal").default<string>;
+            method: import("@esportsplus/reactivity/build/signal").default<string>;
+            origin: import("@esportsplus/reactivity/build/signal").default<string>;
+            path: import("@esportsplus/reactivity/build/signal").default<string>;
+            port: import("@esportsplus/reactivity/build/signal").default<string>;
+            protocol: import("@esportsplus/reactivity/build/signal").default<string>;
+            query: import("@esportsplus/reactivity/build/signal").default<Record<string, unknown>>;
+            subdomain?: import("@esportsplus/reactivity/build/signal").default<string> | import("@esportsplus/reactivity/build/signal").default<undefined> | undefined;
         };
     };
+    middleware: (...middleware: Middleware<T>[]) => () => T | Promise<T>;
     redirect: (path: string, values?: unknown[]) => void;
     router: Router<T>;
     uri: (path: string, values?: unknown[]) => string;

package/build/browser.js

@@ -47,12 +47,30 @@ export default (instance) => {
     return {
         back,
         forward,
+        match: (subdomain) => {
+            let match = subdomain || state.subdomain;
+            if (match === undefined) {
+                if (router.subdomains) {
+                    for (let i = 0, n = router.subdomains.length; i < n; i++) {
+                        if (!state.hostname.startsWith(router.subdomains[i])) {
+                            continue;
+                        }
+                        match = router.subdomains[i];
+                        break;
+                    }
+                }
+                if (match === undefined) {
+                    match = '';
+                }
+            }
+            let { parameters, route } = router.match(state.method, state.path, match);
+            state.data.parameters = parameters;
+            state.data.route = route;
+            return state;
+        },
         middleware: (...middleware) => {
             let instance = pipeline(...middleware);
-            return {
-                pipeline: () => instance(state),
-                request: state
-            };
+            return () => instance(state);
         },
         redirect: (path, values = []) => {
             if (path.startsWith('https://') || path.startsWith('http://')) {

package/build/router/index.js

@@ -55,13 +55,13 @@ class Router {
         for (let i = 0, n = this.groups.length; i < n; i++) {
             let { middleware, name, path, subdomain } = this.groups[i];
             set(route, 'name', name);
+            set(route, 'middleware', middleware);
             set(route, 'path', path);
-            set(route, 'stack', middleware);
             set(route, 'subdomain', subdomain);
         }
         set(route, 'name', name);
+        set(route, 'middleware', middleware);
         set(route, 'path', path);
-        set(route, 'stack', middleware);
         set(route, 'subdomain', subdomain);
         if (route.path) {
             route.path = normalize(route.path);
@@ -72,12 +72,10 @@ class Router {
         return route;
     }
     delete(options) {
-        this.on(['DELETE'], options);
-        return this;
+        return this.on(['DELETE'], options);
     }
     get(options) {
-        this.on(['GET'], options);
-        return this;
+        return this.on(['GET'], options);
     }
     group(options) {
         return {
@@ -130,12 +128,10 @@ class Router {
         return this;
     }
     post(options) {
-        this.on(['POST'], options);
-        return this;
+        return this.on(['POST'], options);
     }
     put(options) {
-        this.on(['PUT'], options);
-        return this;
+        return this.on(['PUT'], options);
     }
     uri(name, values = []) {
         let path = this.routes[name]?.path;

package/build/router/route.d.ts

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

package/build/router/route.js

@@ -1,24 +1,18 @@
 import pipeline from '@esportsplus/pipeline';
 class Route {
-    dispatch = null;
+    middleware = null;
     name = null;
     path = null;
     responder;
-    stack = null;
     subdomain = null;
     constructor(responder) {
         this.responder = responder;
     }
-    get dispatcher() {
-        if (this.dispatch === null) {
-            if (this.stack === null) {
-                this.dispatch = (request) => this.responder(request);
-            }
-            else {
-                this.dispatch = pipeline(...this.stack, (request => this.responder(request)));
-            }
+    get dispatch() {
+        if (this.middleware === null) {
+            return (request) => this.responder(request);
         }
-        return this.dispatch;
+        return pipeline(...this.middleware, (request) => this.responder(request));
     }
 }
 export { Route };

package/build/types.d.ts

@@ -22,5 +22,5 @@ type Request<T> = {
     subdomain?: string;
 };
 type Responder<T> = (request: Request<T>) => Response<T>;
-type Response<T> = T;
-export { Middleware, Next, Options, Request, Responder, Response, Route, Router };
+type Response<T> = Promise<T> | T;
+export { Middleware, Next, Options, Request, Responder, Route, Router };

package/package.json

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

package/src/browser.ts

@@ -1,5 +1,5 @@
 import { reactive } from '@esportsplus/reactivity';
-import { Middleware, Request, Response, Router } from './types';
+import { Middleware, Request, Router } from './types';
 import pipeline from '@esportsplus/pipeline';
 import factory from './router';
 
@@ -69,13 +69,37 @@ export default <T>(instance?: Router<T>) => {
     return {
         back,
         forward,
+        match: (subdomain?: string) => {
+            let match = subdomain || state.subdomain;
+
+            if (match === undefined) {
+                if (router.subdomains) {
+                    for (let i = 0, n = router.subdomains.length; i < n; i++) {
+                        if (!state.hostname.startsWith(router.subdomains[i])) {
+                            continue;
+                        }
+
+                        match = router.subdomains[i];
+                        break;
+                    }
+                }
+
+                if (match === undefined) {
+                    match = '';
+                }
+            }
+
+            let { parameters, route } = router.match(state.method, state.path, match);
+
+            state.data.parameters = parameters;
+            state.data.route = route;
+
+            return state;
+        },
         middleware: (...middleware: Middleware<T>[]) => {
-            let instance = pipeline<Request<T>, Response<T>>(...middleware);
+            let instance = pipeline(...middleware);
 
-            return {
-                pipeline: () => instance(state),
-                request: state
-            };
+            return () => instance(state);
         },
         redirect: (path: string, values: unknown[] = []) => {
             if (path.startsWith('https://') || path.startsWith('http://')) {

package/src/router/index.ts

@@ -76,14 +76,14 @@ class Router<T> {
             let { middleware, name, path, subdomain } = this.groups[i];
 
             set(route, 'name', name);
+            set(route, 'middleware', middleware);
             set(route, 'path', path);
-            set(route, 'stack', middleware);
             set(route, 'subdomain', subdomain);
         }
 
         set(route, 'name', name);
+        set(route, 'middleware', middleware);
         set(route, 'path', path);
-        set(route, 'stack', middleware);
         set(route, 'subdomain', subdomain);
 
         if (route.path) {
@@ -99,13 +99,11 @@ class Router<T> {
 
 
     delete(options: Options<T>) {
-        this.on(['DELETE'], options);
-        return this;
+        return this.on(['DELETE'], options);
     }
 
     get(options: Options<T>) {
-        this.on(['GET'], options);
-        return this;
+        return this.on(['GET'], options);
     }
 
     group(options: Router<T>['groups'][0]) {
@@ -172,13 +170,11 @@ class Router<T> {
     }
 
     post(options: Options<T>) {
-        this.on(['POST'], options);
-        return this;
+        return this.on(['POST'], options);
     }
 
     put(options: Options<T>) {
-        this.on(['PUT'], options);
-        return this;
+        return this.on(['PUT'], options);
     }
 
     uri(name: string, values: unknown[] = []) {

package/src/router/route.ts

@@ -1,13 +1,12 @@
-import { Middleware, Next, Responder } from '~/types';
+import { Middleware, Request, Responder } from '~/types';
 import pipeline from '@esportsplus/pipeline';
 
 
 class Route<T> {
-    dispatch: Next<T> | null = null;
+    middleware: Middleware<T>[] | null = null;
     name: string | null = null;
     path: string | null = null;
     responder: Responder<T>;
-    stack: Middleware<T>[] | null = null;
     subdomain: string | null = null;
 
 
@@ -16,17 +15,12 @@ class Route<T> {
     }
 
 
-    get dispatcher() {
-        if (this.dispatch === null) {
-            if (this.stack === null) {
-                this.dispatch = (request) => this.responder(request);
-            }
-            else {
-                this.dispatch = pipeline(...this.stack, (request => this.responder(request)));
-            }
+    get dispatch() {
+        if (this.middleware === null) {
+            return (request: Request<T>) => this.responder(request);
         }
 
-        return this.dispatch;
+        return pipeline(...this.middleware, (request: Request<T>) => this.responder(request));
     }
 }
 

package/src/types.ts

@@ -29,7 +29,7 @@ type Request<T> = {
 
 type Responder<T> = (request: Request<T>) => Response<T>;
 
-type Response<T> = T;
+type Response<T> = Promise<T> | T;
 
 
-export { Middleware, Next, Options, Request, Responder, Response, Route, Router };
+export { Middleware, Next, Options, Request, Responder, Route, Router };