@esportsplus/routing 0.0.29 → 0.0.31

package/build/browser.d.ts

@@ -4,14 +4,27 @@ 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;
+    match: {
+        (subdomain?: string): {
+            parameters?: Record<PropertyKey, unknown> | undefined;
+            route?: import("./router/route").Route<T> | undefined;
+        };
+        reactive(subdomain?: string): {
+            parameters?: {
+                [x: string]: unknown;
+                [x: number]: unknown;
+                [x: symbol]: unknown;
+            } | undefined;
+            route?: import("./router/route").Route<T> | undefined;
+            dispose: () => void;
+            reset: () => void;
+            nodes: {
+                parameters?: import("@esportsplus/reactivity/build/signal").default<undefined> | import("@esportsplus/reactivity/build/signal").default<Record<PropertyKey, unknown>> | undefined;
+                route?: import("@esportsplus/reactivity/build/signal").default<undefined> | import("@esportsplus/reactivity/build/signal").default<import("./router/route").Route<T>> | undefined;
+            };
+        };
     };
-    middleware: (...middleware: Middleware<T>[]) => ({ parameters, route }: {
-        parameters?: Record<PropertyKey, unknown> | undefined;
-        route?: import("./router/route").Route<T> | undefined;
-    }) => T;
+    middleware: (...middleware: Middleware<T>[]) => () => T;
     redirect: (path: string, values?: unknown[]) => void;
     router: Router<T>;
     uri: (path: string, values?: unknown[]) => string;

package/build/browser.js

@@ -1,13 +1,27 @@
-import { reactive } from '@esportsplus/reactivity';
+import { effect, reactive } from '@esportsplus/reactivity';
 import pipeline from '@esportsplus/pipeline';
 import factory from './router';
-let cache = [], registered = false;
+let cache = [];
 function back() {
     window.history.back();
 }
 function forward() {
     window.history.forward();
 }
+function href() {
+    let { hash, hostname, href, origin, port, protocol } = new URL(window.location?.href || ''), path = hash ? hash.slice(1).split('?') : ['/', ''];
+    return {
+        data: {},
+        href,
+        hostname,
+        method: 'GET',
+        origin,
+        path: path[0],
+        port,
+        protocol,
+        query: path[1] ? Object.fromEntries((new URLSearchParams(path[1])).entries()) : {},
+    };
+}
 function normalize(uri) {
     if (uri[0] === '/') {
         return '#' + uri;
@@ -15,7 +29,7 @@ function normalize(uri) {
     return uri;
 }
 function onpopstate() {
-    let values = request();
+    let values = href();
     for (let i = 0, n = cache.length; i < n; i++) {
         let state = cache[i];
         for (let key in values) {
@@ -23,55 +37,42 @@ function onpopstate() {
         }
     }
 }
-function request() {
-    let { hash, hostname, href, origin, port, protocol } = new URL(window.location?.href || ''), path = hash ? hash.slice(1).split('?') : ['/', ''];
-    return {
-        data: {},
-        href,
-        hostname,
-        method: 'GET',
-        origin,
-        path: path[0],
-        port,
-        protocol,
-        query: path[1] ? Object.fromEntries((new URLSearchParams(path[1])).entries()) : {},
-    };
-}
 export default (instance) => {
-    let router = instance || factory(), state = reactive(request());
-    cache.push(state);
-    if (!registered) {
-        registered = true;
+    let request = reactive(href()), router = instance || factory();
+    if (cache.push(request) === 1) {
         window.addEventListener('hashchange', onpopstate);
     }
+    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;
+            }
+        }
+        return router.match(request.method, request.path, subdomain || '');
+    }
+    match.reactive = (subdomain) => {
+        let state = reactive({
+            parameters: undefined,
+            route: undefined
+        });
+        effect(() => {
+            let { parameters, route } = match(subdomain);
+            state.parameters = parameters;
+            state.route = route;
+        });
+        return state;
+    };
     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 = '';
-                }
-            }
-            return router.match(state.method, state.path, match);
-        },
+        match,
         middleware: (...middleware) => {
             let instance = pipeline(...middleware);
-            return ({ parameters, route }) => {
-                state.data.parameters = parameters;
-                state.data.route = route;
-                return instance(state);
-            };
+            return () => instance(request);
         },
         redirect: (path, values = []) => {
             if (path.indexOf('://') !== -1) {

package/build/router/route.d.ts

@@ -6,6 +6,6 @@ declare class Route<T> {
     responder: Next<T>;
     subdomain: string | null;
     constructor(responder: Next<T>);
-    get dispatch(): (request: Request<T>) => T;
+    dispatch(request: Request<T>): T;
 }
 export { Route };

package/build/router/route.js

@@ -8,11 +8,11 @@ class Route {
     constructor(responder) {
         this.responder = responder;
     }
-    get dispatch() {
+    dispatch(request) {
         if (this.middleware === null) {
-            return (request) => this.responder(request);
+            return this.responder(request);
         }
-        return pipeline(...this.middleware, (request) => this.responder(request));
+        return pipeline(...this.middleware, (request) => this.responder(request))(request);
     }
 }
 export { Route };

package/package.json

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

package/src/browser.ts

@@ -1,11 +1,10 @@
-import { reactive } from '@esportsplus/reactivity';
+import { effect, reactive } from '@esportsplus/reactivity';
 import { Middleware, Request, Router } from './types';
 import pipeline from '@esportsplus/pipeline';
 import factory from './router';
 
 
-let cache: Request<any>[] = [],
-    registered = false;
+let cache: Request<any>[] = [];
 
 
 function back() {
@@ -16,6 +15,23 @@ function forward() {
     window.history.forward();
 }
 
+function href<T>(): Request<T> {
+    let { hash, hostname, href, origin, port, protocol } = new URL( window.location?.href || '' ),
+        path = hash ? hash.slice(1).split('?') : ['/', ''];
+
+    return {
+        data: {},
+        href,
+        hostname,
+        method: 'GET',
+        origin,
+        path: path[0],
+        port,
+        protocol,
+        query: path[1] ? Object.fromEntries( (new URLSearchParams(path[1])).entries() ) : {},
+    };
+}
+
 function normalize(uri: string) {
     if (uri[0] === '/') {
         return '#' + uri;
@@ -25,7 +41,7 @@ function normalize(uri: string) {
 }
 
 function onpopstate() {
-    let values = request();
+    let values = href();
 
     for (let i = 0, n = cache.length; i < n; i++) {
         let state = cache[i];
@@ -37,69 +53,54 @@ function onpopstate() {
     }
 }
 
-function request<T>(): Request<T> {
-    let { hash, hostname, href, origin, port, protocol } = new URL( window.location?.href || '' ),
-        path = hash ? hash.slice(1).split('?') : ['/', ''];
-
-    return {
-        data: {},
-        href,
-        hostname,
-        method: 'GET',
-        origin,
-        path: path[0],
-        port,
-        protocol,
-        query: path[1] ? Object.fromEntries( (new URLSearchParams(path[1])).entries() ) : {},
-    };
-}
-
 
 export default <T>(instance?: Router<T>) => {
-    let router = instance || factory<T>(),
-        state = reactive( request<T>() );
+    let request = reactive( href<T>() ),
+        router = instance || factory<T>();
 
-    cache.push(state);
-
-    if (!registered) {
-        registered = true;
+    if (cache.push(request) === 1) {
         window.addEventListener('hashchange', onpopstate);
     }
 
-    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;
-                    }
+    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;
                 }
 
-                if (match === undefined) {
-                    match = '';
-                }
+                subdomain = router.subdomains[i];
+                break;
             }
+        }
 
-            return router.match(state.method, state.path, match);
-        },
+        return router.match(request.method, request.path, subdomain || '');
+    }
+
+    match.reactive = (subdomain?: string) => {
+        let state = reactive<ReturnType<typeof router.match>>({
+                parameters: undefined,
+                route: undefined
+            });
+
+        effect(() => {
+            let { parameters, route } = match(subdomain);
+
+            state.parameters = parameters;
+            state.route = route;
+        });
+
+        return state;
+    };
+
+    return {
+        back,
+        forward,
+        match,
         middleware: (...middleware: Middleware<T>[]) => {
             let instance = pipeline(...middleware);
 
-            return ({ parameters, route }: ReturnType<typeof router.match>) => {
-                state.data.parameters = parameters;
-                state.data.route = route;
-
-                return instance(state);
-            };
+            return () => instance(request);
         },
         redirect: (path: string, values: unknown[] = []) => {
             if (path.indexOf('://') !== -1) {

package/src/router/route.ts

@@ -15,12 +15,12 @@ class Route<T> {
     }
 
 
-    get dispatch() {
+    dispatch(request: Request<T>) {
         if (this.middleware === null) {
-            return (request: Request<T>) => this.responder(request);
+            return this.responder(request);
         }
 
-        return pipeline(...this.middleware, (request) => this.responder(request));
+        return pipeline(...this.middleware, (request) => this.responder(request))(request);
     }
 }