@esportsplus/routing 0.0.9 → 0.0.10

package/src/router/node.ts

@@ -0,0 +1,141 @@
+import { PLACEHOLDER, STATIC, WILDCARD } from "~/symbols";
+import { Route } from './index';
+
+
+class Node {
+    children: Map<string | number, Node> | null = null;
+    parent: Node | null = null;
+    path: string | null = null;
+    property: string | null = null;
+    route: Route | null = null;
+    type: number | null = null;
+
+
+    constructor(parent: Node['parent'] = null) {
+        this.parent = parent;
+    }
+
+
+    add(path: string, route: Route) {
+        let node: Node | undefined = this,
+            segments = path.split('/'),
+            type: Node['type'] = STATIC,
+            unnamed = 0;
+
+        for (let i = 0, n = segments.length; i < n; i++) {
+            let child: Node | undefined = node.children?.get(segments[i]);
+
+            if (!child) {
+                let segment = segments[i],
+                    symbol = segment[0];
+
+                if (!node.children) {
+                    node.children = new Map();
+                }
+
+                node.children.set(segment, (child = new Node(node)));
+
+                // Named property
+                if (symbol === ':') {
+                    child.property = segment.slice(1) || `${unnamed++}`;
+                    node.children.set(PLACEHOLDER, child);
+                    type = null;
+                }
+                // "*:" Wildcard property
+                else if (symbol === '*') {
+                    child.property = segment.slice(2) || `${unnamed++}`;
+                    node.children.set(WILDCARD, child);
+                    type = null;
+                }
+            }
+
+            node = child;
+        }
+
+        node.path = path;
+        node.route = route;
+        node.type = type;
+
+        return node;
+    }
+
+    find(path: string): {
+        parameters?: Record<PropertyKey, unknown>;
+        route?: Route;
+    } {
+        let node: Node | undefined = this,
+            parameters: Record<PropertyKey, unknown> = {},
+            segments = path.split('/'),
+            wildcard: { node: Node, value: string } | null = null;
+
+        for (let i = 0, n = segments.length; i < n; i++) {
+            let segment = segments[i],
+                wc = node.children?.get(WILDCARD);
+
+            if (wc) {
+                wildcard = {
+                    node: wc,
+                    value: segments.slice(i).join('/')
+                };
+            }
+
+            // Exact matches take precedence over placeholders
+            let next: Node | undefined = node.children?.get(segment);
+
+            if (next) {
+                node = next;
+            }
+            else {
+                node = node.children?.get(PLACEHOLDER);
+
+                if (!node) {
+                    break;
+                }
+
+                parameters[ node.property! ] = segment;
+            }
+        }
+
+        if ((!node || !node.route) && wildcard) {
+            node = wildcard.node;
+            parameters[ node.property! ] = wildcard.value;
+        }
+
+        if (!node) {
+            return {};
+        }
+
+        return {
+            parameters,
+            route: node.route!
+        };
+    }
+
+    remove(path: string) {
+        let node: Node | undefined = this,
+            segments = path.split('/');
+
+        for (let i = 0, n = segments.length; i < n; i++) {
+            node = node.children?.get( segments[i] );
+
+            if (!node) {
+                return;
+            }
+        }
+
+        if (!node?.children?.size) {
+            let parent = node.parent;
+
+            if (parent && parent.children) {
+                parent.children.delete( segments[segments.length - 1] );
+                parent.children.delete(WILDCARD);
+                parent.children.delete(PLACEHOLDER);
+            }
+        }
+
+        return node;
+    }
+}
+
+
+export { Node };

package/src/router/path.ts

@@ -0,0 +1,29 @@
+const normalize = (path: string) => {
+    if (path[0] !== '/') {
+        path = `/${path}`;
+    }
+
+    if (path.endsWith('/')) {
+        path = path.slice(0, -1);
+    }
+
+    return path || '/';
+};
+
+const radixkey = (path: string, { method, subdomain }: { method?: string | null; subdomain?: string | null; } = {}) => {
+    let prefix = '';
+
+    if (subdomain) {
+        prefix = subdomain + ' ';
+    }
+
+    if (method) {
+        prefix += method + ' ';
+    }
+
+    return prefix.toUpperCase() + normalize(path);
+};
+
+
+export default { normalize, radixkey };
+export { normalize, radixkey };

package/src/slugify.ts

@@ -0,0 +1,4 @@
+// https://twitter.com/Swizec/status/1589416111971635201
+export default (value: string) => {
+    return value.replace(/\W+/g, '-').replace(/[-]+$/, '').toLowerCase();
+};

package/src/symbols.ts

@@ -0,0 +1,8 @@
+const PLACEHOLDER = 0;
+
+const STATIC = 1;
+
+const WILDCARD = 2;
+
+
+export { PLACEHOLDER, STATIC, WILDCARD };

package/src/types.ts

@@ -1,36 +1,19 @@
-import { parse } from './url';
-import routes from './routes';
+import { Route, Router } from './router';
 
 
-type Group = {
-    middleware: Middleware[];
-    name: string;
-    path: string;
-    subdomain: string;
-};
-
-type Middleware = (request: Request, next: Next) => unknown;
-
-type Next = (request: Request) => unknown;
-
-type Request = ReturnType<typeof parse>;
+type Middleware = <T>(request: T, next: Next) => unknown;
 
-type Responder = (request: Request) => Promise<unknown> | unknown;
+type Next = <T>(request: T) => 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;
+type Options = {
+    middleware?: Middleware[];
+    name?: string;
     path?: string;
     responder: Responder;
     subdomain?: string;
 };
 
+type Responder = <T>(request: T) => Promise<unknown> | unknown;
+
 
-export { Group, Middleware, Next, Request, Responder, Route, Routes };
+export { Middleware, Next, Options, Responder, Route, Router };

package/tsconfig.json

@@ -1,24 +1,10 @@
 {
     "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"
+        "baseUrl": ".",
+        "declarationDir": "build",
+        "outDir": "build",
     },
     "exclude": ["node_modules"],
+    "extends": "@esportsplus/rspack/tsconfig.base.json",
     "include": ["src"]
-}
+}

package/build/group.d.ts

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

package/build/group.js

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

package/build/listener.d.ts

@@ -1,4 +0,0 @@
-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/listener.js

@@ -1,13 +0,0 @@
-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/common/dispatch.d.ts

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

package/build/middleware/common/dispatch.js

@@ -1,11 +0,0 @@
-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

@@ -1,29 +0,0 @@
-declare const _default: {
-    dispatch: (request: {
-        data: Record<string, any>;
-        href: string;
-        hostname: string;
-        origin: string;
-        path: string;
-        port: string;
-        protocol: string;
-        query: {
-            [k: string]: string;
-        };
-        subdomain: string;
-    }) => any;
-    match: ({ routes, subdomains }: import("../../types").Routes) => (request: {
-        data: Record<string, any>;
-        href: string;
-        hostname: string;
-        origin: string;
-        path: 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

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

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

@@ -1,3 +0,0 @@
-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,12 +0,0 @@
-export default ({ routes, subdomains }) => {
-    return (request, next) => {
-        let name = (subdomains[request.subdomain] || {})[request.path], route = routes[name];
-        if (!route) {
-        }
-        if (!route && routes.fallback) {
-            route = routes.fallback;
-        }
-        request.data.route = route;
-        return next(request);
-    };
-};

package/build/redirect.d.ts

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

package/build/redirect.js

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

package/build/routes.d.ts

@@ -1,20 +0,0 @@
-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 { add, group, routes, subdomains };

package/build/routes.js

@@ -1,45 +0,0 @@
-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;
-        }
-    }
-    routes[route.name += name] = route;
-    if (http) {
-        route.path = `${route.path}${path}`;
-        if (route.path[0] !== '/') {
-            route.path = `/${route.path}`;
-        }
-        if (!route.subdomain || route.subdomain === 'www') {
-            route.subdomain = '';
-        }
-        if (!subdomains[route.subdomain]) {
-            subdomains[route.subdomain] = {};
-        }
-        subdomains[route.subdomain][route.path] = route.name;
-    }
-    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/url.d.ts

@@ -1,30 +0,0 @@
-declare const parse: (url?: string) => {
-    data: Record<string, any>;
-    href: string;
-    hostname: string;
-    origin: string;
-    path: 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;
-        origin: string;
-        path: string;
-        port: string;
-        protocol: string;
-        query: {
-            [k: string]: string;
-        };
-        subdomain: string;
-    };
-};
-export default _default;
-export { parse };

package/build/url.js

@@ -1,22 +0,0 @@
-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)) {
-            subdomain = '';
-        }
-    }
-    return {
-        data: {},
-        href: href,
-        hostname: hostname,
-        origin: origin,
-        path: path[0],
-        port: port,
-        protocol: protocol,
-        query: Object.fromEntries((new URLSearchParams(path[1])).entries()),
-        subdomain
-    };
-};
-export default { parse };
-export { parse };

package/src/group.ts

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

package/src/listener.ts

@@ -1,24 +0,0 @@
-import { parse } from './url';
-
-
-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/common/dispatch.ts

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

package/src/middleware/common/index.ts

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

package/src/middleware/common/match.ts

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

package/src/redirect.ts

@@ -1,16 +0,0 @@
-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[key]) {
-        throw new Error(`Route '${key}' does not exist`);
-    }
-
-    window.location.hash = `#${routes[key].path || ''}`;
-};

package/src/routes.ts

@@ -1,68 +0,0 @@
-import { Group, Responder, Routes, Route } from './types';
-
-
-let groups: Group[] = [],
-    routes: Record<Route['name'], Route> = {},
-    subdomains: Record<NonNullable<Route['subdomain']>, Record<NonNullable<Route['path']>, Route['name']>> = {};
-
-
-const add = ({ name, path, responder }: { name: string, path?: string, responder: Responder }) => {
-    let http = path !== undefined,
-        route: 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;
-        }
-    }
-
-    routes[ route.name += name ] = route;
-
-    if (http) {
-        route.path = `${route.path}${path}`;
-
-        if (route.path[0] !== '/') {
-            route.path = `/${route.path}`;
-        }
-
-        if (!route.subdomain || route.subdomain === 'www') {
-            route.subdomain = '';
-        }
-
-        if (!subdomains[route.subdomain]) {
-            subdomains[route.subdomain] = {};
-        }
-
-        subdomains[route.subdomain][route.path] = route.name;
-    }
-
-    return route;
-};
-
-const group = (group: any, fn: (routes: Routes) => void) => {
-    groups.push(group);
-    fn({ add, group, routes, subdomains });
-    groups.pop();
-};
-
-
-export default { add, group, routes, subdomains };
-export { add, group, routes, subdomains };