@esportsplus/routing 0.0.8 → 0.0.10

package/build/router/node.js

@@ -0,0 +1,93 @@
+import { PLACEHOLDER, STATIC, WILDCARD } from "../symbols";
+class Node {
+    children = null;
+    parent = null;
+    path = null;
+    property = null;
+    route = null;
+    type = null;
+    constructor(parent = null) {
+        this.parent = parent;
+    }
+    add(path, route) {
+        let node = this, segments = path.split('/'), type = STATIC, unnamed = 0;
+        for (let i = 0, n = segments.length; i < n; i++) {
+            let child = 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)));
+                if (symbol === ':') {
+                    child.property = segment.slice(1) || `${unnamed++}`;
+                    node.children.set(PLACEHOLDER, child);
+                    type = null;
+                }
+                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) {
+        let node = this, parameters = {}, segments = path.split('/'), wildcard = 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('/')
+                };
+            }
+            let next = 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) {
+        let node = 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/build/router/path.d.ts

@@ -0,0 +1,14 @@
+declare const normalize: (path: string) => string;
+declare const radixkey: (path: string, { method, subdomain }?: {
+    method?: string | null | undefined;
+    subdomain?: string | null | undefined;
+}) => string;
+declare const _default: {
+    normalize: (path: string) => string;
+    radixkey: (path: string, { method, subdomain }?: {
+        method?: string | null | undefined;
+        subdomain?: string | null | undefined;
+    }) => string;
+};
+export default _default;
+export { normalize, radixkey };

package/build/router/path.js

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

package/build/slugify.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (value: string) => string;
+export default _default;

package/build/slugify.js

@@ -0,0 +1,3 @@
+export default (value) => {
+    return value.replace(/\W+/g, '-').replace(/[-]+$/, '').toLowerCase();
+};

package/build/symbols.d.ts

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

package/build/symbols.js

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

package/build/types.d.ts

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

package/build/types.js

@@ -1 +1,2 @@
-export {};
+import { Route, Router } from './router';
+export { Route, Router };

package/package.json

@@ -2,8 +2,7 @@
     "author": "ICJR",
     "description": "Routing",
     "devDependencies": {
-        "tsc-alias": "^1.8.2",
-        "typescript": "^4.9.4"
+        "@esportsplus/rspack": "^0.0.15"
     },
     "main": "./build/index.js",
     "name": "@esportsplus/routing",
@@ -15,5 +14,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.8"
+    "version": "0.0.10"
 }

package/readme.md

@@ -0,0 +1 @@
+https://github.com/unjs/radix3

package/src/hash.ts

@@ -0,0 +1,106 @@
+import { Router } from './types';
+
+
+let cache: {
+        factory: typeof request;
+        state: Record<PropertyKey, unknown>;
+    }[] = [],
+    registered = false;
+
+
+function update() {
+    for (let i = 0, n = cache.length; i < n; i++) {
+        let { factory, state } = cache[i],
+            values = factory();
+
+        for (let key in values) {
+            state[key] = values[key as keyof typeof values];
+        }
+    }
+}
+
+
+const back = () => window.history.back();
+
+const forward = () => window.history.forward();
+
+const listener = {
+    register: (factory: typeof cache[0]['factory'], state: typeof cache[0]['state']) => {
+        cache.push({ factory, state });
+
+        if (!registered) {
+            registered = true;
+            update();
+
+            window.addEventListener('popstate', update);
+        }
+
+        return () => {
+            listener.remove(state);
+        };
+    },
+    remove: (state: typeof cache[0]['state']) => {
+        for (let i = 0, n = cache.length; i < n; i++) {
+            if (cache[i].state !== state) {
+                continue;
+            }
+
+            cache[i] = cache[n - 1];
+            cache.pop();
+
+            if (cache.length === 0) {
+                window.removeEventListener('popstate', update);
+            }
+            return;
+        }
+    }
+};
+
+const factory = {
+    redirect: (router: Router) => {
+        return (path: string, { state, values }: { state?: Record<PropertyKey, unknown>; values?: unknown[] }) => {
+            if (path.startsWith('http://') || path.startsWith('https://')) {
+                return window.location.replace(path);
+            }
+
+            let uri = router.uri(path, values || []);
+
+            if (uri[0] === '/') {
+                uri = '#' + uri;
+            }
+
+            window.history.pushState(state || {}, '', uri);
+        };
+    },
+    uri: (router: Router) => {
+        return (path: string, values: unknown[] = []) => {
+            let uri = router.uri(path, values || []);
+
+            if (uri[0] === '/') {
+                uri = '#' + uri;
+            }
+
+            return uri;
+        };
+    }
+};
+
+const request = (url: string = window?.location?.href || '') => {
+    let { hash, hostname, href, origin, port, protocol } = new URL( url ),
+        path = hash?.replace('#/', '/')?.split('?') || ['/', ''];
+
+    return {
+        href,
+        hostname,
+        method: 'GET',
+        origin,
+        path: path[0],
+        port,
+        protocol,
+        query: Object.fromEntries( (new URLSearchParams(path[1])).entries() )
+    };
+};
+
+
+export default { back, factory, forward, listener, request };
+export { back, factory, forward, listener, request };

package/src/index.ts

@@ -1,10 +1,8 @@
+import hash from './hash';
 import middleware from './middleware';
-import redirect from './redirect';
-import listener from './listener';
-import routes from './routes';
-import url from './url';
+import router from './router';
+import slugify from './slugify';
 
 
-export default { listener, middleware, redirect, routes, url };
-export { listener, middleware, redirect, routes, url };
+export { hash, middleware, router, slugify };
 export * from './types';

package/src/middleware/dispatch.ts

@@ -0,0 +1,12 @@
+import { Router } from '~/types';
+
+
+export default (request: { data: ReturnType<Router['match']> }) => {
+    let { route } = request.data;
+
+    if (!route) {
+        throw new Error(`Routing: route dispatching failed, route is undefined!`);
+    }
+
+    return route.dispatcher(request);
+};

package/src/middleware/factory.ts

@@ -1,21 +1,22 @@
-import { Middleware, Next, Request } from '~/types';
+import { Middleware, Next } from '~/types';
 
 
 function error() {
-    throw new Error('Request middleware did not return a responder');
+    throw new Error('Routing: request middleware did not return a responder');
 }
 
 
-export default (...m: Middleware[]) => {
-    let middleware: Next[] = [];
+// TODO: Use '@esportsplus/middleware'
+export default (...middleware: Middleware[]) => {
+    let stack: Next[] = [];
 
-    for (let i = 0, n = m.length; i < n; i++) {
-        middleware[i] = (request: Request) => m[i](request, middleware[i + 1] || error);
+    for (let i = 0, n = middleware.length; i < n; i++) {
+        stack[i] = <T>(request: T) => middleware[i](request, stack[i + 1] || error);
     }
 
-    if (!middleware.length) {
-        throw new Error('Request middleware has not been defined');
+    if (!stack.length) {
+        throw new Error('Routing: request middleware has not been defined');
     }
 
-    return async (request: Request) => await middleware[0](request);
+    return <T>(request: T) => stack[0](request);
 };

package/src/middleware/index.ts

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

package/src/middleware/match.ts

@@ -0,0 +1,41 @@
+import { Next, Router } from '~/types';
+
+
+type Request = {
+    data: ReturnType<Router['match']>;
+    hostname: string;
+    method: string;
+    path: string;
+    subdomain?: string;
+};
+
+
+export default (router: Router, spa = false) => {
+    let subdomain: string | null = null;
+
+    return (request: Request, next: Next) => {
+        if ((typeof request.subdomain !== 'string' && !spa) || subdomain === null) {
+            if (router.subdomains) {
+                for (let i = 0, n = router.subdomains.length; i < n; i++) {
+                    if (!request.hostname.startsWith(router.subdomains[i])) {
+                        continue;
+                    }
+
+                    subdomain = router.subdomains[i];
+                    break;
+                }
+            }
+
+            if (subdomain === null) {
+                subdomain = '';
+            }
+        }
+
+        let { parameters, route } = router.match(request.method, request.path, request.subdomain || subdomain);
+
+        request.data.parameters = parameters;
+        request.data.route = route;
+
+        return next(request);
+    };
+};

package/src/router/index.ts

@@ -0,0 +1,237 @@
+import { STATIC } from "~/symbols";
+import { Middleware, Responder, Options } from '~/types';
+import { Node } from './node';
+import { normalize, radixkey } from './path';
+import factory from '~/middleware/factory';
+
+
+let { isArray } = Array;
+
+
+function set(route: Route, key: keyof Route, value?: any) {
+    if (!value) {
+        return;
+    }
+
+    if (!route[key]) {
+        (route[key] as any) = value;
+    }
+    else if (typeof value === 'string') {
+        if (typeof route[key] === 'string') {
+            (route[key] as string) += value;
+        }
+    }
+    else if (isArray(value)) {
+        if (isArray(route[key])) {
+            (route[key] as any[]).push( ...value );
+        }
+    }
+}
+
+
+class Route {
+    dispatch: ReturnType<typeof factory> | null = null;
+    name: string | null = null;
+    path: string | null = null;
+    responder: Responder;
+    stack: Middleware[] | null = null;
+    subdomain: string | null = null;
+
+
+    constructor(responder: Responder) {
+        this.responder = responder;
+    }
+
+
+    get dispatcher() {
+        if (this.dispatch === null) {
+            if (!this.stack?.length) {
+                this.dispatch = <T>(request: T) => this.responder(request);
+            }
+            else {
+                this.dispatch = factory(...this.stack, (request => this.responder(request)));
+            }
+        }
+
+        return this.dispatch;
+    }
+}
+
+class Router {
+    groups: Omit<Options, 'responder'>[] = [];
+    root: Node;
+    routes: Record<string, Route> = {};
+    static: Record<string, Route> = {};
+    subdomains: string[] | null = null;
+
+
+    constructor() {
+        this.root = new Node();
+    }
+
+
+    private add(radixkey: string, route: Route) {
+        let node = this.root.add(radixkey, route);
+
+        if (node.type === STATIC) {
+            if (this.static[radixkey]) {
+                throw new Error(`Routing: static path '${radixkey}' is already in use`);
+            }
+
+            this.static[radixkey] = route;
+        }
+    }
+
+    private route({ middleware, name, path, responder, subdomain }: Options) {
+        let route = new Route(responder);
+
+        for (let i = 0, n = this.groups.length; i < n; i++) {
+            let { middleware, name, path, subdomain } = this.groups[i];
+
+            set(route, 'name', name);
+            set(route, 'path', path);
+            set(route, 'stack', middleware);
+            set(route, 'subdomain', subdomain);
+        }
+
+        set(route, 'name', name);
+        set(route, 'path', path);
+        set(route, 'stack', middleware);
+        set(route, 'subdomain', subdomain);
+
+        if (route.path) {
+            route.path = normalize(route.path);
+        }
+
+        if (route.subdomain === 'www') {
+            route.subdomain = '';
+        }
+
+        return route;
+    }
+
+
+    delete(options: Options) {
+        this.on(['DELETE'], options);
+        return this;
+    }
+
+    get(options: Options) {
+        this.on(['GET'], options);
+        return this;
+    }
+
+    group(options: Router['groups'][0]) {
+        return {
+            routes: (fn: (router: Router) => void) => {
+                this.groups.push(options);
+                fn(this);
+                this.groups.pop();
+            }
+        }
+    }
+
+    match(method: string, path: string, subdomain?: string | null): ReturnType<Node['find']> {
+        let key = radixkey(path, { method, subdomain });
+
+        if (this.static[key]) {
+            return {
+                route: this.static[key]
+            };
+        }
+
+        return this.root.find(key);
+    }
+
+    on(methods: string[], options: Options) {
+        let route = this.route(options);
+
+        if (route.name) {
+            if (this.routes[route.name]) {
+                throw new Error(`Routing: '${route.name}' is already in use`);
+            }
+
+            this.routes[route.name] = route;
+        }
+
+        if (route.path) {
+            for (let i = 0, n = methods.length; i < n; i++) {
+                let key = radixkey(route.path, {
+                        method: methods[i],
+                        subdomain: route.subdomain
+                    });
+
+                if (key.indexOf('?:') !== -1) {
+                    let segments = key.split('?:'),
+                        url = '';
+
+                    for (let i = 0, n = segments.length; i < n; i++) {
+                        this.add((url += (i > 0 ? '/:' : '/') + segments[i]), route);
+                    }
+                }
+                else {
+                    this.add(key, route);
+                }
+            }
+        }
+
+        if (route.subdomain) {
+            if (!this.subdomains) {
+                this.subdomains = [route.subdomain];
+            }
+            else {
+                this.subdomains.push(route.subdomain);
+            }
+        }
+    }
+
+    post(options: Options) {
+        this.on(['POST'], options);
+        return this;
+    }
+
+    put(options: Options) {
+        this.on(['PUT'], options);
+        return this;
+    }
+
+    uri(name: string, values: unknown[] = []) {
+        let path = this.routes?.[name]?.path;
+
+        if (!path) {
+            throw new Error(`Routing: route name '${name}' does not exist or it does not provide a path`);
+        }
+
+        let resolved = [] as typeof values,
+            segments = path.split('/');
+
+        for (let i = 0, n = segments.length; i < n; i++) {
+            let segment = segments[i],
+                symbol = segment[0];
+
+            if (symbol === ':') {
+                resolved.push(values[i]);
+            }
+            else if (symbol === '?') {
+                if (values[i] === undefined) {
+                    break;
+                }
+
+                resolved.push(values[i]);
+            }
+            else if (symbol === '*') {
+                resolved.push( ...values.slice(i) );
+                break;
+            }
+            else {
+                resolved.push(segment);
+            }
+        }
+
+        return resolved.join('/');
+    }
+}
+
+
+export default (...args: ConstructorParameters<typeof Router>) => new Router(...args);
+export { Router, Route };