@esportsplus/routing 0.0.5 → 0.0.7

package/build/group.js

@@ -2,7 +2,7 @@ export default () => {
     return {
         middleware: [],
         name: '',
-        pattern: '',
+        path: '',
         subdomain: ''
     };
 };

package/build/index.d.ts

@@ -8,9 +8,8 @@ declare const _default: {
         data: Record<string, any>;
         href: string;
         hostname: string;
-        uri: string;
         origin: string;
-        pathname: string;
+        path: string;
         port: string;
         protocol: string;
         query: {
@@ -24,9 +23,8 @@ declare const _default: {
                 data: Record<string, any>;
                 href: string;
                 hostname: string;
-                uri: string;
                 origin: string;
-                pathname: string;
+                path: string;
                 port: string;
                 protocol: string;
                 query: {
@@ -34,13 +32,12 @@ declare const _default: {
                 };
                 subdomain: string;
             }) => any;
-            match: (routes: import("./routes").Routes) => (request: {
+            match: ({ routes, subdomains }: import("./types").Routes) => (request: {
                 data: Record<string, any>;
                 href: string;
                 hostname: string;
-                uri: string;
                 origin: string;
-                pathname: string;
+                path: string;
                 port: string;
                 protocol: string;
                 query: {
@@ -53,9 +50,8 @@ declare const _default: {
             data: Record<string, any>;
             href: string;
             hostname: string;
-            uri: string;
             origin: string;
-            pathname: string;
+            path: string;
             port: string;
             protocol: string;
             query: {
@@ -65,15 +61,23 @@ declare const _default: {
         }) => Promise<unknown>;
     };
     redirect: (key: string, _?: Record<string, any>) => void;
-    routes: import("./routes").Routes;
+    routes: {
+        add: ({ name, path, responder }: {
+            name: string;
+            path?: string | undefined;
+            responder: import("./types").Responder;
+        }) => import("./types").Route;
+        group: (group: any, fn: (routes: import("./types").Routes) => void) => void;
+        routes: Record<string, import("./types").Route>;
+        subdomains: Record<string, Record<string, string>>;
+    };
     url: {
         parse: (url?: string) => {
             data: Record<string, any>;
             href: string;
             hostname: string;
-            uri: string;
             origin: string;
-            pathname: string;
+            path: string;
             port: string;
             protocol: string;
             query: {
@@ -85,3 +89,4 @@ declare const _default: {
 };
 export default _default;
 export { listener, middleware, redirect, routes, url };
+export * from './types';

package/build/index.js

@@ -5,3 +5,4 @@ import routes from './routes';
 import url from './url';
 export default { listener, middleware, redirect, routes, url };
 export { listener, middleware, redirect, routes, url };
+export * from './types';

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

@@ -3,9 +3,8 @@ declare const _default: {
         data: Record<string, any>;
         href: string;
         hostname: string;
-        uri: string;
         origin: string;
-        pathname: string;
+        path: string;
         port: string;
         protocol: string;
         query: {
@@ -13,13 +12,12 @@ declare const _default: {
         };
         subdomain: string;
     }) => any;
-    match: (routes: import("../../routes").Routes) => (request: {
+    match: ({ routes, subdomains }: import("../../types").Routes) => (request: {
         data: Record<string, any>;
         href: string;
         hostname: string;
-        uri: string;
         origin: string;
-        pathname: string;
+        path: string;
         port: string;
         protocol: string;
         query: {

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

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

package/build/middleware/common/match.js

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

package/build/middleware/index.d.ts

@@ -6,9 +6,8 @@ declare const _default: {
             data: Record<string, any>;
             href: string;
             hostname: string;
-            uri: string;
             origin: string;
-            pathname: string;
+            path: string;
             port: string;
             protocol: string;
             query: {
@@ -16,13 +15,12 @@ declare const _default: {
             };
             subdomain: string;
         }) => any;
-        match: (routes: import("../routes").Routes) => (request: {
+        match: ({ routes, subdomains }: import("../types").Routes) => (request: {
             data: Record<string, any>;
             href: string;
             hostname: string;
-            uri: string;
             origin: string;
-            pathname: string;
+            path: string;
             port: string;
             protocol: string;
             query: {
@@ -35,9 +33,8 @@ declare const _default: {
         data: Record<string, any>;
         href: string;
         hostname: string;
-        uri: string;
         origin: string;
-        pathname: string;
+        path: string;
         port: string;
         protocol: string;
         query: {

package/build/redirect.js

@@ -1,10 +1,10 @@
-import routes from './routes';
+import { routes } from './routes';
 export default (key, _ = {}) => {
     if (key.startsWith('http://') || key.startsWith('https://')) {
         window.location.replace(key);
     }
-    if (!routes.static[key]) {
+    if (!routes[key]) {
         throw new Error(`Route '${key}' does not exist`);
     }
-    window.location.hash = `#${routes.static[key].pattern}`;
+    window.location.hash = `#${routes[key].path || ''}`;
 };

package/build/routes.d.ts

@@ -1,13 +1,20 @@
-import { Group, Responder, Route } from './types';
-declare class Routes {
-    dynamic: Record<Route['name'], Route>;
-    fallback?: string;
-    groups: Group[];
-    static: Record<Route['name'], Route>;
-    subdomains: Record<Route['subdomain'], Record<Route['pattern'], Route['name']>>;
-    add(name: string, pattern: string, responder: Responder): Route;
-    group(group: any, routes: (routes: Routes) => void): void;
-}
-declare const _default: Routes;
+import { Responder, Routes, Route } from './types';
+declare let routes: Record<Route['name'], Route>, subdomains: Record<NonNullable<Route['subdomain']>, Record<NonNullable<Route['path']>, Route['name']>>;
+declare const add: ({ name, path, responder }: {
+    name: string;
+    path?: string | undefined;
+    responder: Responder;
+}) => Route;
+declare const group: (group: any, fn: (routes: Routes) => void) => void;
+declare const _default: {
+    add: ({ name, path, responder }: {
+        name: string;
+        path?: string | undefined;
+        responder: Responder;
+    }) => Route;
+    group: (group: any, fn: (routes: Routes) => void) => void;
+    routes: Record<string, Route>;
+    subdomains: Record<string, Record<string, string>>;
+};
 export default _default;
-export { Routes };
+export { add, group, routes, subdomains };

package/build/routes.js

@@ -1,46 +1,45 @@
-class Routes {
-    dynamic = {};
-    fallback;
-    groups = [];
-    static = {};
-    subdomains = {};
-    add(name, pattern, responder) {
-        let route = {
-            middleware: [],
-            name: '',
-            pattern: '',
-            responder,
-            subdomain: ''
-        };
-        for (let i = 0, n = this.groups.length; i < n; i++) {
-            let group = this.groups[i];
-            route.name += group.name;
-            route.pattern += group.pattern;
+let groups = [], routes = {}, subdomains = {};
+const add = ({ name, path, responder }) => {
+    let http = path !== undefined, route = {
+        middleware: [],
+        name: '',
+        responder
+    };
+    if (http) {
+        route.path = '';
+        route.subdomain = '';
+    }
+    for (let i = 0, n = groups.length; i < n; i++) {
+        let group = groups[i];
+        if (group.middleware.length) {
+            route.middleware.push(...group.middleware);
+        }
+        route.name += group.name;
+        if (http) {
+            route.path += group.path;
             route.subdomain = group.subdomain + route.subdomain;
-            if (group.middleware.length) {
-                route.middleware.push(...group.middleware);
-            }
         }
-        route.name += name;
-        route.pattern += pattern;
-        if (route.pattern[0] !== '/') {
-            route.pattern = `/${route.pattern}`;
+    }
+    routes[route.name += name] = route;
+    if (http) {
+        route.path = `${route.path}${path}`;
+        if (route.path[0] !== '/') {
+            route.path = `/${route.path}`;
         }
-        if (route.subdomain === 'www') {
+        if (!route.subdomain || route.subdomain === 'www') {
             route.subdomain = '';
         }
-        if (!this.subdomains[route.subdomain]) {
-            this.subdomains[route.subdomain] = {};
+        if (!subdomains[route.subdomain]) {
+            subdomains[route.subdomain] = {};
         }
-        this.static[route.name] = route;
-        this.subdomains[route.subdomain][route.pattern] = route.name;
-        return route;
-    }
-    group(group, routes) {
-        this.groups.push(group);
-        routes(this);
-        this.groups.pop();
+        subdomains[route.subdomain][route.path] = route.name;
     }
-}
-export default new Routes();
-export { Routes };
+    return route;
+};
+const group = (group, fn) => {
+    groups.push(group);
+    fn({ add, group, routes, subdomains });
+    groups.pop();
+};
+export default { add, group, routes, subdomains };
+export { add, group, routes, subdomains };

package/build/types.d.ts

@@ -1,20 +1,26 @@
-import { Routes } from './routes';
 import { parse } from './url';
+import routes from './routes';
 type Group = {
     middleware: Middleware[];
     name: string;
-    pattern: string;
+    path: 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 Routes = {
+    add: typeof routes.add;
+    group: typeof routes.group;
+    routes: typeof routes.routes;
+    subdomains: typeof routes.subdomains;
+};
 type Route = {
     middleware: Middleware[];
     name: string;
-    pattern: string;
+    path?: string;
     responder: Responder;
-    subdomain: string;
+    subdomain?: string;
 };
 export { Group, Middleware, Next, Request, Responder, Route, Routes };

package/build/types.js

@@ -1,2 +1 @@
-import { Routes } from './routes';
-export { Routes };
+export {};

package/build/url.d.ts

@@ -2,9 +2,8 @@ declare const parse: (url?: string) => {
     data: Record<string, any>;
     href: string;
     hostname: string;
-    uri: string;
     origin: string;
-    pathname: string;
+    path: string;
     port: string;
     protocol: string;
     query: {
@@ -17,9 +16,8 @@ declare const _default: {
         data: Record<string, any>;
         href: string;
         hostname: string;
-        uri: string;
         origin: string;
-        pathname: string;
+        path: string;
         port: string;
         protocol: string;
         query: {

package/build/url.js

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

package/package.json

@@ -2,8 +2,8 @@
     "author": "ICJR",
     "description": "Routing",
     "devDependencies": {
-        "tsc-alias": "^1.8.1",
-        "typescript": "^4.9.3"
+        "tsc-alias": "^1.8.2",
+        "typescript": "^4.9.4"
     },
     "main": "./build/index.js",
     "name": "@esportsplus/routing",
@@ -15,12 +15,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "typesVersions": {
-        "*": {
-            "types": [
-                "build/types"
-            ]
-        }
-    },
-    "version": "0.0.5"
+    "version": "0.0.7"
 }

package/src/group.ts

@@ -5,7 +5,7 @@ export default (): Group => {
     return {
         middleware: [],
         name: '',
-        pattern: '',
+        path: '',
         subdomain: ''
     };
 };

package/src/index.ts

@@ -7,3 +7,4 @@ import url from './url';
 
 export default { listener, middleware, redirect, routes, url };
 export { listener, middleware, redirect, routes, url };
+export * from './types';

package/src/middleware/common/match.ts

@@ -1,11 +1,10 @@
-import { Routes } from '~/routes';
-import { Next, Request } from '~/types';
+import { Next, Request, Routes } from '~/types';
 
 
-export default (routes: Routes) => {
+export default ({ routes, subdomains }: Routes) => {
     return (request: Request, next: Next) => {
-        let name = (routes.subdomains[request.subdomain] || {})[request.uri],
-            route = routes.static[name];
+        let name = (subdomains[request.subdomain] || {})[request.path],
+            route = routes[name];
 
         // Dynamic routing
         if (!route) {
@@ -14,9 +13,8 @@ export default (routes: Routes) => {
             // - Bind variables to request
         }
 
-        // Fallback route
         if (!route && routes.fallback) {
-            route = routes.static[routes.fallback];
+            route = routes.fallback;
         }
 
         request.data.route = route;

package/src/redirect.ts

@@ -1,4 +1,4 @@
-import routes from './routes';
+import { routes } from './routes';
 
 
 export default (key: string, _: Record<string, any> = {}) => {
@@ -8,9 +8,9 @@ export default (key: string, _: Record<string, any> = {}) => {
     }
 
     // Internal route based redirect
-    if (!routes.static[key]) {
+    if (!routes[key]) {
         throw new Error(`Route '${key}' does not exist`);
     }
 
-    window.location.hash = `#${routes.static[key].pattern}`;
+    window.location.hash = `#${routes[key].path || ''}`;
 };

package/src/routes.ts

@@ -1,63 +1,68 @@
-import { Group, Responder, Route } from './types';
+import { Group, Responder, Routes, Route } from './types';
 
 
-class Routes {
-    dynamic: Record<Route['name'], Route> = {};
-    fallback?: string;
-    groups: Group[] = [];
-    static: Record<Route['name'], Route> = {};
-    subdomains: Record<Route['subdomain'], Record<Route['pattern'], Route['name']>> = {};
+let groups: Group[] = [],
+    routes: Record<Route['name'], Route> = {},
+    subdomains: Record<NonNullable<Route['subdomain']>, Record<NonNullable<Route['path']>, Route['name']>> = {};
 
 
-    add(name: string, pattern: string, responder: Responder) {
-        let route: Route = {
-                middleware: [],
-                name: '',
-                pattern: '',
-                responder,
-                subdomain: ''
-            };
+const add = ({ name, path, responder }: { name: string, path?: string, responder: Responder }) => {
+    let http = path !== undefined,
+        route: Route = {
+            middleware: [],
+            name: '',
+            responder
+        };
 
-        for (let i = 0, n = this.groups.length; i < n; i++) {
-            let group = this.groups[i];
+    if (http) {
+        route.path = '';
+        route.subdomain = '';
+    }
 
-            route.name += group.name;
-            route.pattern += group.pattern;
-            route.subdomain = group.subdomain + route.subdomain;
+    for (let i = 0, n = groups.length; i < n; i++) {
+        let group = groups[i];
 
-            if (group.middleware.length) {
-                route.middleware.push(...group.middleware);
-            }
+        if (group.middleware.length) {
+            route.middleware.push(...group.middleware);
         }
 
-        route.name += name;
-        route.pattern += pattern;
+        route.name += group.name;
 
-        if (route.pattern[0] !== '/') {
-            route.pattern = `/${route.pattern}`;
+        if (http) {
+            route.path += group.path;
+            route.subdomain = group.subdomain + route.subdomain;
         }
+    }
 
-        if (route.subdomain === 'www') {
-            route.subdomain = '';
+    routes[ route.name += name ] = route;
+
+    if (http) {
+        route.path = `${route.path}${path}`;
+
+        if (route.path[0] !== '/') {
+            route.path = `/${route.path}`;
         }
 
-        if (!this.subdomains[route.subdomain]) {
-            this.subdomains[route.subdomain] = {};
+        if (!route.subdomain || route.subdomain === 'www') {
+            route.subdomain = '';
         }
 
-        this.static[route.name] = route;
-        this.subdomains[route.subdomain][route.pattern] = route.name;
+        if (!subdomains[route.subdomain]) {
+            subdomains[route.subdomain] = {};
+        }
 
-        return route;
+        subdomains[route.subdomain][route.path] = route.name;
     }
 
-    group(group: any, routes: (routes: Routes) => void) {
-        this.groups.push(group);
-        routes(this);
-        this.groups.pop();
-    }
-}
+    return route;
+};
+
+const group = (group: any, fn: (routes: Routes) => void) => {
+    groups.push(group);
+    fn({ add, group, routes, subdomains });
+    groups.pop();
+};
 
 
-export default new Routes();
-export { Routes };
+export default { add, group, routes, subdomains };
+export { add, group, routes, subdomains };

package/src/types.ts

@@ -1,11 +1,11 @@
-import { Routes } from './routes';
 import { parse } from './url';
+import routes from './routes';
 
 
 type Group = {
     middleware: Middleware[];
     name: string;
-    pattern: string;
+    path: string;
     subdomain: string;
 };
 
@@ -17,12 +17,19 @@ type Request = ReturnType<typeof parse>;
 
 type Responder = (request: Request) => Promise<unknown> | unknown;
 
+type Routes = {
+    add: typeof routes.add;
+    group: typeof routes.group;
+    routes: typeof routes.routes;
+    subdomains: typeof routes.subdomains;
+};
+
 type Route = {
     middleware: Middleware[];
     name: string;
-    pattern: string;
+    path?: string;
     responder: Responder;
-    subdomain: string;
+    subdomain?: string;
 };
 
 

package/src/url.ts

@@ -1,5 +1,5 @@
-const parse = (url: string = window.location.href) => {
-    let { hash, host, hostname, href, origin, pathname, port, protocol } = new URL( url ),
+const parse = (url: string = window?.location?.href || '') => {
+    let { hash, host, hostname, href, origin, port, protocol } = new URL( url ),
         parts = host.split('.'),
         path = hash?.replace('#/', '/')?.split('?') || ['/', ''],
         subdomain = '';
@@ -16,9 +16,8 @@ const parse = (url: string = window.location.href) => {
         data: {} as Record<string, any>,
         href: href,
         hostname: hostname,
-        uri: path[0],
         origin: origin,
-        pathname: pathname,
+        path: path[0],
         port: port,
         protocol: protocol,
         query: Object.fromEntries( (new URLSearchParams(path[1])).entries() ),