@esportsplus/routing 0.0.8 → 0.0.10

package/build/hash.d.ts

@@ -0,0 +1,70 @@
+import { Router } from './types';
+declare let cache: {
+    factory: typeof request;
+    state: Record<PropertyKey, unknown>;
+}[];
+declare const back: () => void;
+declare const forward: () => void;
+declare const listener: {
+    register: (factory: (typeof cache)[0]['factory'], state: (typeof cache)[0]['state']) => () => void;
+    remove: (state: (typeof cache)[0]['state']) => void;
+};
+declare const factory: {
+    redirect: (router: Router) => (path: string, { state, values }: {
+        state?: Record<PropertyKey, unknown> | undefined;
+        values?: unknown[] | undefined;
+    }) => void;
+    uri: (router: Router) => (path: string, values?: unknown[]) => string;
+};
+declare const request: (url?: string) => {
+    href: string;
+    hostname: string;
+    method: string;
+    origin: string;
+    path: string;
+    port: string;
+    protocol: string;
+    query: {
+        [k: string]: string;
+    };
+};
+declare const _default: {
+    back: () => void;
+    factory: {
+        redirect: (router: Router) => (path: string, { state, values }: {
+            state?: Record<PropertyKey, unknown> | undefined;
+            values?: unknown[] | undefined;
+        }) => void;
+        uri: (router: Router) => (path: string, values?: unknown[]) => string;
+    };
+    forward: () => void;
+    listener: {
+        register: (factory: (url?: string) => {
+            href: string;
+            hostname: string;
+            method: string;
+            origin: string;
+            path: string;
+            port: string;
+            protocol: string;
+            query: {
+                [k: string]: string;
+            };
+        }, state: Record<PropertyKey, unknown>) => () => void;
+        remove: (state: Record<PropertyKey, unknown>) => void;
+    };
+    request: (url?: string) => {
+        href: string;
+        hostname: string;
+        method: string;
+        origin: string;
+        path: string;
+        port: string;
+        protocol: string;
+        query: {
+            [k: string]: string;
+        };
+    };
+};
+export default _default;
+export { back, factory, forward, listener, request };

package/build/hash.js

@@ -0,0 +1,75 @@
+let cache = [], 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];
+        }
+    }
+}
+const back = () => window.history.back();
+const forward = () => window.history.forward();
+const listener = {
+    register: (factory, state) => {
+        cache.push({ factory, state });
+        if (!registered) {
+            registered = true;
+            update();
+            window.addEventListener('popstate', update);
+        }
+        return () => {
+            listener.remove(state);
+        };
+    },
+    remove: (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) => {
+        return (path, { state, values }) => {
+            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) => {
+        return (path, values = []) => {
+            let uri = router.uri(path, values || []);
+            if (uri[0] === '/') {
+                uri = '#' + uri;
+            }
+            return uri;
+        };
+    }
+};
+const request = (url = 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/build/index.d.ts

@@ -1,92 +1,6 @@
-import middleware from './middleware';
-import redirect from './redirect';
-import listener from './listener';
-import routes from './routes';
-import url from './url';
-declare const _default: {
-    listener: (d: Record<string, any>, f: (url?: string) => {
-        data: Record<string, any>;
-        href: string;
-        hostname: string;
-        origin: string;
-        path: string;
-        port: string;
-        protocol: string;
-        query: {
-            [k: string]: string;
-        };
-        subdomain: string;
-    }) => void;
-    middleware: {
-        common: {
-            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;
-        };
-        factory: (...m: import("./types").Middleware[]) => (request: {
-            data: Record<string, any>;
-            href: string;
-            hostname: string;
-            origin: string;
-            path: string;
-            port: string;
-            protocol: string;
-            query: {
-                [k: string]: string;
-            };
-            subdomain: string;
-        }) => Promise<unknown>;
-    };
-    redirect: (key: string, _?: Record<string, any>) => void;
-    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;
-            origin: string;
-            path: string;
-            port: string;
-            protocol: string;
-            query: {
-                [k: string]: string;
-            };
-            subdomain: string;
-        };
-    };
-};
-export default _default;
-export { listener, middleware, redirect, routes, url };
-export * from './types';
+import hash from './hash';
+import middleware from './middleware';
+import router from './router';
+import slugify from './slugify';
+export { hash, middleware, router, slugify };
+export * from './types';

package/build/index.js

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

package/build/middleware/dispatch.d.ts

@@ -0,0 +1,5 @@
+import { Router } from '../types';
+declare const _default: (request: {
+    data: ReturnType<Router['match']>;
+}) => unknown;
+export default _default;

package/build/middleware/dispatch.js

@@ -0,0 +1,7 @@
+export default (request) => {
+    let { route } = request.data;
+    if (!route) {
+        throw new Error(`Routing: route dispatching failed, route is undefined!`);
+    }
+    return route.dispatcher(request);
+};

package/build/middleware/factory.d.ts

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

package/build/middleware/factory.js

@@ -1,13 +1,13 @@
-function error() {
-    throw new Error('Request middleware did not return a responder');
-}
-export default (...m) => {
-    let middleware = [];
-    for (let i = 0, n = m.length; i < n; i++) {
-        middleware[i] = (request) => m[i](request, middleware[i + 1] || error);
-    }
-    if (!middleware.length) {
-        throw new Error('Request middleware has not been defined');
-    }
-    return async (request) => await middleware[0](request);
-};
+function error() {
+    throw new Error('Routing: request middleware did not return a responder');
+}
+export default (...middleware) => {
+    let stack = [];
+    for (let i = 0, n = middleware.length; i < n; i++) {
+        stack[i] = (request) => middleware[i](request, stack[i + 1] || error);
+    }
+    if (!stack.length) {
+        throw new Error('Routing: request middleware has not been defined');
+    }
+    return (request) => stack[0](request);
+};

package/build/middleware/index.d.ts

@@ -1,47 +1,24 @@
-import common from './common';
-import factory from './factory';
-declare const _default: {
-    common: {
-        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;
-    };
-    factory: (...m: import("../types").Middleware[]) => (request: {
-        data: Record<string, any>;
-        href: string;
-        hostname: string;
-        origin: string;
-        path: string;
-        port: string;
-        protocol: string;
-        query: {
-            [k: string]: string;
-        };
-        subdomain: string;
-    }) => Promise<unknown>;
-};
-export default _default;
-export { common, factory };
+import dispatch from './dispatch';
+import factory from './factory';
+import match from './match';
+declare const _default: {
+    dispatch: (request: {
+        data: {
+            parameters?: Record<PropertyKey, unknown> | undefined;
+            route?: import("../router").Route | undefined;
+        };
+    }) => unknown;
+    factory: (...middleware: import("../types").Middleware[]) => <T>(request: T) => unknown;
+    match: (router: import("../router").Router, spa?: boolean) => (request: {
+        data: {
+            parameters?: Record<PropertyKey, unknown> | undefined;
+            route?: import("../router").Route | undefined;
+        };
+        hostname: string;
+        method: string;
+        path: string;
+        subdomain?: string | undefined;
+    }, next: import("../types").Next) => unknown;
+};
+export default _default;
+export { dispatch, factory, match };

package/build/middleware/index.js

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

package/build/middleware/match.d.ts

@@ -0,0 +1,10 @@
+import { Next, Router } from '../types';
+type Request = {
+    data: ReturnType<Router['match']>;
+    hostname: string;
+    method: string;
+    path: string;
+    subdomain?: string;
+};
+declare const _default: (router: Router, spa?: boolean) => (request: Request, next: Next) => unknown;
+export default _default;

package/build/middleware/match.js

@@ -0,0 +1,23 @@
+export default (router, spa = false) => {
+    let subdomain = null;
+    return (request, 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/build/router/index.d.ts

@@ -0,0 +1,36 @@
+import { Middleware, Responder, Options } from '../types';
+import { Node } from './node';
+import factory from '../middleware/factory';
+declare class Route {
+    dispatch: ReturnType<typeof factory> | null;
+    name: string | null;
+    path: string | null;
+    responder: Responder;
+    stack: Middleware[] | null;
+    subdomain: string | null;
+    constructor(responder: Responder);
+    get dispatcher(): <T>(request: T) => unknown;
+}
+declare class Router {
+    groups: Omit<Options, 'responder'>[];
+    root: Node;
+    routes: Record<string, Route>;
+    static: Record<string, Route>;
+    subdomains: string[] | null;
+    constructor();
+    private add;
+    private route;
+    delete(options: Options): this;
+    get(options: Options): this;
+    group(options: Router['groups'][0]): {
+        routes: (fn: (router: Router) => void) => void;
+    };
+    match(method: string, path: string, subdomain?: string | null): ReturnType<Node['find']>;
+    on(methods: string[], options: Options): void;
+    post(options: Options): this;
+    put(options: Options): this;
+    uri(name: string, values?: unknown[]): string;
+}
+declare const _default: () => Router;
+export default _default;
+export { Router, Route };

package/build/router/index.js

@@ -0,0 +1,182 @@
+import { STATIC } from "../symbols";
+import { Node } from './node';
+import { normalize, radixkey } from './path';
+import factory from '../middleware/factory';
+let { isArray } = Array;
+function set(route, key, value) {
+    if (!value) {
+        return;
+    }
+    if (!route[key]) {
+        route[key] = value;
+    }
+    else if (typeof value === 'string') {
+        if (typeof route[key] === 'string') {
+            route[key] += value;
+        }
+    }
+    else if (isArray(value)) {
+        if (isArray(route[key])) {
+            route[key].push(...value);
+        }
+    }
+}
+class Route {
+    dispatch = null;
+    name = null;
+    path = null;
+    responder;
+    stack = null;
+    subdomain = null;
+    constructor(responder) {
+        this.responder = responder;
+    }
+    get dispatcher() {
+        if (this.dispatch === null) {
+            if (!this.stack?.length) {
+                this.dispatch = (request) => this.responder(request);
+            }
+            else {
+                this.dispatch = factory(...this.stack, (request => this.responder(request)));
+            }
+        }
+        return this.dispatch;
+    }
+}
+class Router {
+    groups = [];
+    root;
+    routes = {};
+    static = {};
+    subdomains = null;
+    constructor() {
+        this.root = new Node();
+    }
+    add(radixkey, 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;
+        }
+    }
+    route({ middleware, name, path, responder, subdomain }) {
+        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) {
+        this.on(['DELETE'], options);
+        return this;
+    }
+    get(options) {
+        this.on(['GET'], options);
+        return this;
+    }
+    group(options) {
+        return {
+            routes: (fn) => {
+                this.groups.push(options);
+                fn(this);
+                this.groups.pop();
+            }
+        };
+    }
+    match(method, path, subdomain) {
+        let key = radixkey(path, { method, subdomain });
+        if (this.static[key]) {
+            return {
+                route: this.static[key]
+            };
+        }
+        return this.root.find(key);
+    }
+    on(methods, 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) {
+        this.on(['POST'], options);
+        return this;
+    }
+    put(options) {
+        this.on(['PUT'], options);
+        return this;
+    }
+    uri(name, values = []) {
+        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 = [], 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) => new Router(...args);
+export { Router, Route };

package/build/router/node.d.ts

@@ -0,0 +1,17 @@
+import { Route } from './index';
+declare class Node {
+    children: Map<string | number, Node> | null;
+    parent: Node | null;
+    path: string | null;
+    property: string | null;
+    route: Route | null;
+    type: number | null;
+    constructor(parent?: Node['parent']);
+    add(path: string, route: Route): Node;
+    find(path: string): {
+        parameters?: Record<PropertyKey, unknown>;
+        route?: Route;
+    };
+    remove(path: string): Node | undefined;
+}
+export { Node };