@esportsplus/routing 0.0.1

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+end_of_line = lf

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/build/group.d.ts

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

package/build/group.js

@@ -0,0 +1,8 @@
+export default () => {
+    return {
+        middleware: [],
+        name: '',
+        pattern: '',
+        subdomain: ''
+    };
+};

package/build/index.d.ts

@@ -0,0 +1,85 @@
+import middleware from './middleware';
+import redirect from './redirect';
+import listener from './listener';
+import request from './request';
+import routes from './routes';
+declare const _default: {
+    listener: (d: Record<string, any>, f: (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;
+    }) => void;
+    middleware: {
+        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("./request/types").Next) => 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>;
+        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;
+        };
+    };
+    routes: import("./routes").Routes;
+};
+export default _default;
+export { listener, middleware, redirect, request, routes };

package/build/index.js

@@ -0,0 +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 };

package/build/listener.d.ts

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

package/build/listener.js

@@ -0,0 +1,13 @@
+let data, factory, registered = false;
+function update() {
+    data.request = factory();
+}
+export default (d, f) => {
+    data = d;
+    factory = f;
+    if (!registered) {
+        registered = true;
+        update();
+        window.addEventListener('popstate', update);
+    }
+};

package/build/middleware/dispatch.d.ts

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

package/build/middleware/dispatch.js

@@ -0,0 +1,11 @@
+import { middleware } from '../request';
+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 middleware(...route.middleware, (request => route.responder(request)))(request);
+};

package/build/middleware/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("../request/types").Next) => unknown;
+};
+export default _default;

package/build/middleware/index.js

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

package/build/middleware/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/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/redirect.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (key: string, _?: Record<string, any>) => void;
+export default _default;

package/build/redirect.js

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

package/build/request/index.d.ts

@@ -0,0 +1,34 @@
+import middleware from './middleware';
+import parse from './parse';
+declare const _default: {
+    middleware: (...middleware: import("./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>;
+    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 { middleware, parse };

package/build/request/index.js

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

package/build/request/middleware.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/request/middleware.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/request/parse.d.ts

@@ -0,0 +1,15 @@
+declare const _default: (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;

package/build/request/parse.js

@@ -0,0 +1,18 @@
+export default (url = window.location.href) => {
+    let data = new URL(url), subdomain = data.host.split('.')[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
+    };
+};

package/build/request/types.d.ts

@@ -0,0 +1,6 @@
+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 };

package/build/request/types.js

@@ -0,0 +1 @@
+export {};

package/build/routes.d.ts

@@ -0,0 +1,13 @@
+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;
+export default _default;
+export { Routes };

package/build/routes.js

@@ -0,0 +1,46 @@
+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;
+            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}`;
+        }
+        if (route.subdomain === 'www') {
+            route.subdomain = '';
+        }
+        if (!this.subdomains[route.subdomain]) {
+            this.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();
+    }
+}
+export default new Routes();
+export { Routes };

package/build/types.d.ts

@@ -0,0 +1,16 @@
+import { Middleware, Next, Request, Responder } from "./request/types";
+import { Routes } from './routes';
+type Group = {
+    middleware: Middleware[];
+    name: string;
+    pattern: string;
+    subdomain: string;
+};
+type Route = {
+    middleware: Middleware[];
+    name: string;
+    pattern: string;
+    responder: Responder;
+    subdomain: string;
+};
+export { Group, Middleware, Next, Request, Responder, Route, Routes };

package/build/types.js

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

package/package.json

@@ -0,0 +1,26 @@
+{
+    "author": "ICJR",
+    "description": "Routing",
+    "devDependencies": {
+        "tsc-alias": "^1.8.1",
+        "typescript": "^4.9.3"
+    },
+    "main": "./build/index.js",
+    "name": "@esportsplus/routing",
+    "private": false,
+    "scripts": {
+        "build": "tsc && tsc-alias",
+        "-": "-",
+        "prepare": "npm run build",
+        "prepublishOnly": "npm run build"
+    },
+    "types": "./build/index.d.ts",
+    "typesVersions": {
+        "*": {
+            "types": [
+                "build/types"
+            ]
+        }
+    },
+    "version": "0.0.1"
+}

package/src/group.ts

@@ -0,0 +1,11 @@
+import { Group } from "./types";
+
+
+export default (): Group => {
+    return {
+        middleware: [],
+        name: '',
+        pattern: '',
+        subdomain: ''
+    };
+};

package/src/index.ts

@@ -0,0 +1,9 @@
+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 };

package/src/listener.ts

@@ -0,0 +1,24 @@
+import { parse } from './request';
+
+
+let data: Record<string, any>,
+    factory: typeof parse,
+    registered: boolean = false;
+
+
+function update() {
+    data.request = factory();
+}
+
+
+export default (d: typeof data, f: typeof factory) => {
+    data = d;
+    factory = f;
+
+    if (!registered) {
+        registered = true;
+        update();
+
+        window.addEventListener('popstate', update);
+    }
+};

package/src/middleware/dispatch.ts

@@ -0,0 +1,17 @@
+import { middleware } from '~/request';
+import { Request } from '~/types';
+
+
+export default (request: 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 middleware(...route.middleware, (request => route.responder(request)))(request);
+};

package/src/middleware/index.ts

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

package/src/middleware/match.ts

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

package/src/redirect.ts

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

package/src/request/index.ts

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

package/src/request/middleware.ts

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

package/src/request/parse.ts

@@ -0,0 +1,21 @@
+export default (url: string = window.location.href) => {
+    let data = new URL( url ),
+        subdomain = data.host.split('.')[0] || '';
+
+    if (['127', 'www'].includes(`${subdomain}`)) {
+        subdomain = '';
+    }
+
+    return {
+        data: {} as Record<string, any>,
+        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
+    };
+};

package/src/request/types.ts

@@ -0,0 +1,13 @@
+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 };

package/src/routes.ts

@@ -0,0 +1,63 @@
+import { Group, Responder, 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']>> = {};
+
+
+    add(name: string, pattern: string, responder: Responder) {
+        let route: 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;
+            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}`;
+        }
+
+        if (route.subdomain === 'www') {
+            route.subdomain = '';
+        }
+
+        if (!this.subdomains[route.subdomain]) {
+            this.subdomains[route.subdomain] = {};
+        }
+
+        this.static[route.name] = route;
+        this.subdomains[route.subdomain][route.pattern] = route.name;
+
+        return route;
+    }
+
+    group(group: any, routes: (routes: Routes) => void) {
+        this.groups.push(group);
+        routes(this);
+        this.groups.pop();
+    }
+}
+
+
+export default new Routes();
+export { Routes };

package/src/types.ts

@@ -0,0 +1,21 @@
+import { Middleware, Next, Request, Responder } from "./request/types";
+import { Routes } from './routes';
+
+
+type Group = {
+    middleware: Middleware[];
+    name: string;
+    pattern: string;
+    subdomain: string;
+};
+
+type Route = {
+    middleware: Middleware[];
+    name: string;
+    pattern: string;
+    responder: Responder;
+    subdomain: string;
+};
+
+
+export { Group, Middleware, Next, Request, Responder, Route, Routes };

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "allowJs": true,
+        "alwaysStrict": true,
+        "baseUrl": "src",
+        "declaration": true,
+        "declarationDir": "./build",
+        "lib": ["dom", "dom.iterable", "esnext"],
+        "module": "esnext",
+        "moduleResolution": "nodenext",
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "outDir": "./build",
+        "paths": {
+            "~/*": ["*"]
+        },
+        "removeComments": true,
+        "resolveJsonModule": true,
+        "strict": true,
+        "target": "esnext"
+    },
+    "exclude": ["node_modules"],
+    "include": ["src"]
+}