@esportsplus/routing 0.0.1 → 0.0.3

package/build/index.d.ts

@@ -1,8 +1,8 @@
 import middleware from './middleware';
 import redirect from './redirect';
 import listener from './listener';
-import request from './request';
 import routes from './routes';
+import url from './url';
 declare const _default: {
     listener: (d: Record<string, any>, f: (url?: string) => {
         data: Record<string, any>;
@@ -19,7 +19,7 @@ declare const _default: {
         subdomain: string;
     }) => void;
     middleware: {
-        dispatch: (request: {
+        factory: (...middleware: import("./types").Middleware[]) => (request: {
             data: Record<string, any>;
             href: string;
             hostname: string;
@@ -32,38 +32,11 @@ declare const _default: {
                 [k: string]: string;
             };
             subdomain: string;
-        }) => any;
-        match: (routes: import("./routes").Routes) => (request: {
-            data: Record<string, any>;
-            href: string;
-            hostname: string;
-            uri: string;
-            origin: string;
-            pathname: string;
-            port: string;
-            protocol: string;
-            query: {
-                [k: string]: string;
-            };
-            subdomain: string;
-        }, next: import("./request/types").Next) => unknown;
+        }) => Promise<unknown>;
     };
     redirect: (key: string, _?: Record<string, any>) => void;
-    request: {
-        middleware: (...middleware: import("./request/types").Middleware[]) => (request: {
-            data: Record<string, any>;
-            href: string;
-            hostname: string;
-            uri: string;
-            origin: string;
-            pathname: string;
-            port: string;
-            protocol: string;
-            query: {
-                [k: string]: string;
-            };
-            subdomain: string;
-        }) => Promise<unknown>;
+    routes: import("./routes").Routes;
+    url: {
         parse: (url?: string) => {
             data: Record<string, any>;
             href: string;
@@ -79,7 +52,6 @@ declare const _default: {
             subdomain: string;
         };
     };
-    routes: import("./routes").Routes;
 };
 export default _default;
-export { listener, middleware, redirect, request, routes };
+export { listener, middleware, redirect, routes, url };

package/build/index.js

@@ -1,7 +1,7 @@
 import middleware from './middleware';
 import redirect from './redirect';
 import listener from './listener';
-import request from './request';
 import routes from './routes';
-export default { listener, middleware, redirect, request, routes };
-export { listener, middleware, redirect, request, routes };
+import url from './url';
+export default { listener, middleware, redirect, routes, url };
+export { listener, middleware, redirect, routes, url };

package/build/listener.d.ts

@@ -1,4 +1,4 @@
-import { parse } from './request';
+import { parse } from './url';
 declare let data: Record<string, any>, factory: typeof parse;
 declare const _default: (d: typeof data, f: typeof factory) => void;
 export default _default;

package/build/middleware/common/dispatch.d.ts

@@ -0,0 +1,3 @@
+import { Request } from '../../types';
+declare const _default: (request: Request) => any;
+export default _default;

package/build/middleware/common/dispatch.js

@@ -0,0 +1,11 @@
+import { factory } from '../../middleware';
+export default (request) => {
+    let route = request.data.route;
+    if (!route) {
+        throw new Error(`Route dispatching failed, route was not defined!`);
+    }
+    if (!route.middleware.length) {
+        return route.responder(request);
+    }
+    return factory(...route.middleware, (request => route.responder(request)))(request);
+};

package/build/middleware/common/index.d.ts

@@ -0,0 +1,31 @@
+declare const _default: {
+    dispatch: (request: {
+        data: Record<string, any>;
+        href: string;
+        hostname: string;
+        uri: string;
+        origin: string;
+        pathname: string;
+        port: string;
+        protocol: string;
+        query: {
+            [k: string]: string;
+        };
+        subdomain: string;
+    }) => any;
+    match: (routes: import("../../routes").Routes) => (request: {
+        data: Record<string, any>;
+        href: string;
+        hostname: string;
+        uri: string;
+        origin: string;
+        pathname: string;
+        port: string;
+        protocol: string;
+        query: {
+            [k: string]: string;
+        };
+        subdomain: string;
+    }, next: import("../../types").Next) => unknown;
+};
+export default _default;

package/build/middleware/common/index.js

@@ -0,0 +1,3 @@
+import dispatch from './dispatch';
+import match from './match';
+export default { dispatch, match };

package/build/middleware/common/match.d.ts

@@ -0,0 +1,4 @@
+import { Routes } from '../../routes';
+import { Next, Request } from '../../types';
+declare const _default: (routes: Routes) => (request: Request, next: Next) => unknown;
+export default _default;

package/build/middleware/common/match.js

@@ -0,0 +1,12 @@
+export default (routes) => {
+    return (request, next) => {
+        let name = (routes.subdomains[request.subdomain] || {})[request.uri], route = routes.static[name];
+        if (!route) {
+        }
+        if (!route && routes.fallback) {
+            route = routes.static[routes.fallback];
+        }
+        request.data.route = route;
+        return next(request);
+    };
+};

package/build/middleware/factory.d.ts

@@ -0,0 +1,3 @@
+import { Middleware, Request } from '../types';
+declare const _default: (...middleware: Middleware[]) => (request: Request) => Promise<unknown>;
+export default _default;

package/build/middleware/factory.js

@@ -0,0 +1,12 @@
+export default (...middleware) => {
+    let i = -1, n = middleware.length, next = (request) => middleware[++i](request, (i < n ? next : () => {
+        throw new Error('Request middleware did not return a responder');
+    }));
+    return async (request) => {
+        if (!middleware.length) {
+            throw new Error('Request middleware has not been defined');
+        }
+        i = -1;
+        return await next(request);
+    };
+};

package/build/middleware/index.d.ts

@@ -1,5 +1,6 @@
+import factory from './factory';
 declare const _default: {
-    dispatch: (request: {
+    factory: (...middleware: import("../types").Middleware[]) => (request: {
         data: Record<string, any>;
         href: string;
         hostname: string;
@@ -12,20 +13,7 @@ declare const _default: {
             [k: string]: string;
         };
         subdomain: string;
-    }) => any;
-    match: (routes: import("../routes").Routes) => (request: {
-        data: Record<string, any>;
-        href: string;
-        hostname: string;
-        uri: string;
-        origin: string;
-        pathname: string;
-        port: string;
-        protocol: string;
-        query: {
-            [k: string]: string;
-        };
-        subdomain: string;
-    }, next: import("../request/types").Next) => unknown;
+    }) => Promise<unknown>;
 };
 export default _default;
+export { factory };

package/build/middleware/index.js

@@ -1,3 +1,3 @@
-import dispatch from './dispatch';
-import match from './match';
-export default { dispatch, match };
+import factory from './factory';
+export default { factory };
+export { factory };

package/build/types.d.ts

@@ -1,11 +1,15 @@
-import { Middleware, Next, Request, Responder } from "./request/types";
 import { Routes } from './routes';
+import { parse } from './url';
 type Group = {
     middleware: Middleware[];
     name: string;
     pattern: string;
     subdomain: string;
 };
+type Middleware = (request: Request, next: Next) => unknown;
+type Next = (request: Request) => unknown;
+type Request = ReturnType<typeof parse>;
+type Responder = (request: Request) => Promise<unknown> | unknown;
 type Route = {
     middleware: Middleware[];
     name: string;

package/build/url.d.ts

@@ -0,0 +1,32 @@
+declare const parse: (url?: string) => {
+    data: Record<string, any>;
+    href: string;
+    hostname: string;
+    uri: string;
+    origin: string;
+    pathname: string;
+    port: string;
+    protocol: string;
+    query: {
+        [k: string]: string;
+    };
+    subdomain: string;
+};
+declare const _default: {
+    parse: (url?: string) => {
+        data: Record<string, any>;
+        href: string;
+        hostname: string;
+        uri: string;
+        origin: string;
+        pathname: string;
+        port: string;
+        protocol: string;
+        query: {
+            [k: string]: string;
+        };
+        subdomain: string;
+    };
+};
+export default _default;
+export { parse };

package/build/url.js

@@ -0,0 +1,23 @@
+const parse = (url = window.location.href) => {
+    let data = new URL(url), parts = data.host.split('.'), subdomain = '';
+    if (parts.length > 2) {
+        subdomain = parts[0];
+        if (['127', 'www'].includes(subdomain)) {
+            subdomain = '';
+        }
+    }
+    return {
+        data: {},
+        href: data.href,
+        hostname: data.hostname,
+        uri: data.hash.replace('#/', '/') || '/',
+        origin: data.origin,
+        pathname: data.pathname,
+        port: data.port,
+        protocol: data.protocol,
+        query: Object.fromEntries(data.searchParams.entries()),
+        subdomain
+    };
+};
+export default { parse };
+export { parse };

package/package.json

@@ -22,5 +22,5 @@
             ]
         }
     },
-    "version": "0.0.1"
+    "version": "0.0.3"
 }

package/src/index.ts

@@ -1,9 +1,9 @@
 import middleware from './middleware';
 import redirect from './redirect';
 import listener from './listener';
-import request from './request';
 import routes from './routes';
+import url from './url';
 
 
-export default { listener, middleware, redirect, request, routes };
-export { listener, middleware, redirect, request, routes };
+export default { listener, middleware, redirect, routes, url };
+export { listener, middleware, redirect, routes, url };

package/src/listener.ts

@@ -1,4 +1,4 @@
-import { parse } from './request';
+import { parse } from './url';
 
 
 let data: Record<string, any>,

package/src/middleware/{dispatch.ts → common/dispatch.ts}

@@ -1,4 +1,4 @@
-import { middleware } from '~/request';
+import { factory } from '~/middleware';
 import { Request } from '~/types';
 
 
@@ -13,5 +13,5 @@ export default (request: Request) => {
         return route.responder(request);
     }
 
-    return middleware(...route.middleware, (request => route.responder(request)))(request);
+    return factory(...route.middleware, (request => route.responder(request)))(request);
 };

package/src/middleware/common/index.ts

@@ -0,0 +1,5 @@
+import dispatch from './dispatch';
+import match from './match';
+
+
+export default { dispatch, match };

package/src/{request/middleware.ts → middleware/factory.ts}

@@ -1,4 +1,4 @@
-import { Middleware, Request } from './types';
+import { Middleware, Request } from '~/types';
 
 
 export default (...middleware: Middleware[]) => {

package/src/middleware/index.ts

@@ -1,5 +1,5 @@
-import dispatch from './dispatch';
-import match from './match';
-
-
-export default { dispatch, match };
+import factory from './factory';
+
+
+export default { factory };
+export { factory };

package/src/types.ts

@@ -1,5 +1,5 @@
-import { Middleware, Next, Request, Responder } from "./request/types";
 import { Routes } from './routes';
+import { parse } from './url';
 
 
 type Group = {
@@ -9,6 +9,14 @@ type Group = {
     subdomain: string;
 };
 
+type Middleware = (request: Request, next: Next) => unknown;
+
+type Next = (request: Request) => unknown;
+
+type Request = ReturnType<typeof parse>;
+
+type Responder = (request: Request) => Promise<unknown> | unknown;
+
 type Route = {
     middleware: Middleware[];
     name: string;

package/src/{request/parse.ts → url.ts}

@@ -1,9 +1,14 @@
-export default (url: string = window.location.href) => {
+const parse = (url: string = window.location.href) => {
     let data = new URL( url ),
-        subdomain = data.host.split('.')[0] || '';
-
-    if (['127', 'www'].includes(`${subdomain}`)) {
+        parts = data.host.split('.'),
         subdomain = '';
+
+    if (parts.length > 2) {
+        subdomain = parts[0];
+
+        if (['127', 'www'].includes(subdomain)) {
+            subdomain = '';
+        }
     }
 
     return {
@@ -19,3 +24,7 @@ export default (url: string = window.location.href) => {
         subdomain
     };
 };
+
+
+export default { parse };
+export { parse };

package/src/request/index.ts

@@ -1,6 +0,0 @@
-import middleware from './middleware';
-import parse from './parse';
-
-
-export default { middleware, parse };
-export { middleware, parse };

package/src/request/types.ts

@@ -1,13 +0,0 @@
-import parse from './parse';
-
-
-type Middleware = (request: Request, next: Next) => unknown;
-
-type Next = (request: Request) => unknown;
-
-type Request = ReturnType<typeof parse>;
-
-type Responder = (request: Request) => Promise<unknown> | unknown;
-
-
-export { Middleware, Next, Request, Responder };