@esportsplus/routing 0.6.0

package/build/client/router/index.js

@@ -0,0 +1,172 @@
+import { ON_DELETE, ON_GET, ON_POST, ON_PUT, PACKAGE_NAME } from '../constants.js';
+import { Node } from './node.js';
+import pipeline from '@esportsplus/pipeline';
+function key(method, subdomain) {
+    return (method + (subdomain ? ' ' + subdomain : '')).toUpperCase();
+}
+function normalize(path) {
+    if (path) {
+        if (path[0] !== '/') {
+            path = '/' + path;
+        }
+        if (path.length > 1 && path[path.length - 1] === '/') {
+            path = path.slice(0, -1);
+        }
+    }
+    return path || '/';
+}
+function set(route, options) {
+    let pipeline = route.pipeline;
+    for (let key in options) {
+        let value = options[key];
+        if (key === 'middleware') {
+            for (let i = 0, n = value.length; i < n; i++) {
+                pipeline.add(value[i]);
+            }
+        }
+        else if (key === 'responder') {
+            pipeline.add(value);
+        }
+        else {
+            route[key] = (route[key] || '') + value;
+        }
+    }
+}
+class Router {
+    bucket = {};
+    groups = [];
+    routes = {};
+    subdomains = null;
+    add(method, path, route) {
+        let bucket = this.bucket[key(method, route.subdomain)] ??= {
+            root: new Node(),
+            static: {}
+        };
+        if (path.indexOf(':') === -1) {
+            if (path in bucket.static) {
+                throw new Error(`${PACKAGE_NAME}: static path '${path}' is already in use`);
+            }
+            bucket.static[path] = route;
+        }
+        else {
+            bucket.root.add(path, route);
+        }
+        return this;
+    }
+    create(options) {
+        let groups = this.groups, route = {
+            name: null,
+            path: null,
+            pipeline: pipeline(),
+            subdomain: null
+        };
+        for (let i = 0, n = groups.length; i < n; i++) {
+            set(route, groups[i]);
+        }
+        set(route, options);
+        if (route.path) {
+            route.path = normalize(route.path);
+        }
+        if (route.subdomain === 'www') {
+            route.subdomain = '';
+        }
+        return route;
+    }
+    delete(options) {
+        this.on(ON_DELETE, options);
+        return this;
+    }
+    get(options) {
+        this.on(ON_GET, options);
+        return this;
+    }
+    group(options) {
+        return {
+            routes: (fn) => {
+                this.groups.push(options);
+                fn(this);
+                this.groups.pop();
+                return this;
+            }
+        };
+    }
+    match(method, path, subdomain) {
+        let bucket = this.bucket[key(method, subdomain)];
+        if (!bucket) {
+            return {};
+        }
+        path = normalize(path);
+        if (path in bucket.static) {
+            return { route: bucket.static[path] };
+        }
+        return bucket.root.find(path);
+    }
+    on(methods, options) {
+        let route = this.create(options);
+        let name = route.name, path = route.path, subdomain = route.subdomain;
+        if (name) {
+            if (this.routes[name]) {
+                throw new Error(`${PACKAGE_NAME}: '${name}' is already in use`);
+            }
+            this.routes[name] = route;
+        }
+        if (path) {
+            for (let i = 0, n = methods.length; i < n; i++) {
+                let method = methods[i];
+                if (path.indexOf('?:') !== -1) {
+                    let segments = path.split('?:'), url = segments[0];
+                    this.add(method, url, route);
+                    for (let i = 1; i < segments.length; i++) {
+                        url += '/:' + segments[i];
+                        this.add(method, url, route);
+                    }
+                }
+                else {
+                    this.add(method, path, route);
+                }
+            }
+        }
+        if (subdomain) {
+            (this.subdomains ??= []).push(subdomain.toLowerCase());
+        }
+        return this;
+    }
+    post(options) {
+        this.on(ON_POST, options);
+        return this;
+    }
+    put(options) {
+        this.on(ON_PUT, options);
+        return this;
+    }
+    uri(name, values = []) {
+        let path = this.routes[name]?.path;
+        if (!path) {
+            throw new Error(`${PACKAGE_NAME}: route name '${name}' does not exist or it does not provide a path`);
+        }
+        let resolved = [], segments = path.split('/'), v = 0;
+        for (let i = 0, n = segments.length; i < n; i++) {
+            let segment = segments[i], symbol = segment[0];
+            if (symbol === ':') {
+                resolved.push(values[v++]);
+            }
+            else if (symbol === '?') {
+                if (values[v] === undefined) {
+                    break;
+                }
+                resolved.push(values[v++]);
+            }
+            else if (symbol === '*') {
+                for (let n = values.length; v < n; v++) {
+                    resolved.push(values[v]);
+                }
+                break;
+            }
+            else {
+                resolved.push(segment);
+            }
+        }
+        return resolved.join('/');
+    }
+}
+export { Router };

package/build/client/router/node.d.ts

@@ -0,0 +1,18 @@
+import { Route } from './index.js';
+declare class Node<T> {
+    parent: Node<T> | null;
+    path: string | null;
+    route: Route<T> | null;
+    static: Map<string | number, Node<T>> | null;
+    type: number | null;
+    name: string | null;
+    parameter: Node<T> | null;
+    wildcard: Node<T> | null;
+    constructor(parent?: Node<T>['parent']);
+    add(path: string, route: Route<T>): Node<T>;
+    find(path: string): {
+        parameters?: Readonly<Record<PropertyKey, unknown>>;
+        route?: Readonly<Route<T>>;
+    };
+}
+export { Node };

package/build/client/router/node.js

@@ -0,0 +1,80 @@
+import { PARAMETER, STATIC, WILDCARD } from '../constants.js';
+class Node {
+    parent = null;
+    path = null;
+    route = null;
+    static = null;
+    type = null;
+    name = null;
+    parameter = null;
+    wildcard = 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 segment = segments[i], symbol = segment[0];
+            if (symbol === ':') {
+                if (!node.parameter) {
+                    node.parameter = new Node(node);
+                    node.parameter.name = (segment.slice(1) || unnamed++).toString();
+                }
+                node = node.parameter;
+                type = PARAMETER;
+            }
+            else if (symbol === '*') {
+                if (!node.wildcard) {
+                    node.wildcard = new Node(node);
+                    node.wildcard.name = (segment.slice(2) || unnamed++).toString();
+                }
+                node = node.wildcard;
+                type = WILDCARD;
+            }
+            else {
+                let next = node.static?.get(segment);
+                if (!next) {
+                    next = new Node(node);
+                    (node.static ??= new Map()).set(segment, next);
+                }
+                node = next;
+            }
+        }
+        node.path = path;
+        node.route = route;
+        node.type = type;
+        return node;
+    }
+    find(path) {
+        let node = this, parameters, segments = path.split('/'), wildcard;
+        for (let i = 0, n = segments.length; i < n; i++) {
+            let segment = segments[i];
+            if (node.wildcard) {
+                wildcard = {
+                    node: node.wildcard,
+                    start: i
+                };
+            }
+            let next = node.static?.get(segment);
+            if (next) {
+                node = next;
+                continue;
+            }
+            if (!node.parameter) {
+                node = undefined;
+                break;
+            }
+            node = node.parameter;
+            (parameters ??= {})[node.name] = segment;
+        }
+        if ((node === undefined || node.route === null) && wildcard) {
+            node = wildcard.node;
+            (parameters ??= {})[node.name] = segments.slice(wildcard.start).join('/');
+        }
+        return {
+            parameters,
+            route: node?.route || undefined
+        };
+    }
+}
+export { Node };

package/build/client/types.d.ts

@@ -0,0 +1,54 @@
+import { NeverAsync } from '@esportsplus/utilities';
+import { Router } from './router/index.js';
+import pipeline from '@esportsplus/pipeline';
+type AccumulateRoutes<T extends readonly RouteFactory<any>[]> = T extends readonly [infer F extends RouteFactory<any>, ...infer Rest extends readonly RouteFactory<any>[]] ? ExtractRoutes<F> & AccumulateRoutes<Rest> : {};
+type ExtractOptionalParams<Path extends string> = Path extends `/${infer Segment}/${infer Rest}` ? (Segment extends `?:${infer Param}` ? Param : never) | ExtractOptionalParams<`/${Rest}`> : Path extends `/${infer Segment}` ? (Segment extends `?:${infer Param}` ? Param : never) : never;
+type ExtractParamsTuple<Path extends string> = Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? [Param, ...ExtractParamsTuple<`/${Rest}`>] : Path extends `${infer _Start}:${infer Param}` ? [Param] : [];
+type ExtractRequiredParams<Path extends string> = Path extends `/${infer Segment}/${infer Rest}` ? (Segment extends `:${infer Param}` ? Param : never) | ExtractRequiredParams<`/${Rest}`> : Path extends `/${infer Segment}` ? (Segment extends `:${infer Param}` ? Param : never) : never;
+type ExtractRoutes<F> = F extends (r: Router<any, any>) => Router<any, infer Routes extends RouteRegistry> ? Routes : never;
+type InferOutput<F> = F extends RouteFactory<infer T> ? T : never;
+type LabeledParamsTuple<Params extends string[]> = Params extends [infer _First extends string, ...infer Rest extends string[]] ? [_First: string | number, ...LabeledParamsTuple<Rest>] : [];
+type Middleware<T> = NeverAsync<(input: Request<T>, next: Next<T>) => T>;
+type Name = string;
+type Next<T> = NeverAsync<(input: Request<T>) => T>;
+type Options<T> = {
+    middleware?: Middleware<T>[];
+    name?: string;
+    path?: string;
+    subdomain?: string;
+};
+type PathParamsObject<Path extends string> = {
+    [K in ExtractRequiredParams<Path>]: string | number;
+} & {
+    [K in ExtractOptionalParams<Path>]?: string | number;
+};
+type PathParamsTuple<Path extends string> = LabeledParamsTuple<ExtractParamsTuple<Path>>;
+type Request<T> = {
+    data: Record<PropertyKey, unknown> & ReturnType<Router<T>['match']>;
+    hostname: string;
+    href: string;
+    method: string;
+    origin: string;
+    path: string;
+    port: string;
+    protocol: string;
+    query: Record<string, unknown>;
+    subdomain?: string;
+};
+type Route<T> = {
+    name: Name | null;
+    path: string | null;
+    pipeline: ReturnType<typeof pipeline<Request<T>, T>>;
+    subdomain: string | null;
+};
+type RouteFactory<T> = (router: Router<T, any>) => Router<T, RouteRegistry>;
+type RouteOptions<T> = Options<T> & {
+    responder: Next<T>;
+};
+type RoutePath<Routes, K extends keyof Routes> = Routes[K] extends {
+    path: infer P extends string;
+} ? P : string;
+type RouteRegistry = Record<string, {
+    path: string;
+}>;
+export type { AccumulateRoutes, ExtractOptionalParams, ExtractRequiredParams, InferOutput, Middleware, Name, Next, Options, PathParamsObject, PathParamsTuple, Request, Router, Route, RouteFactory, RouteOptions, RoutePath, RouteRegistry };

package/build/client/types.js

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

package/build/constants.d.ts

@@ -0,0 +1,2 @@
+declare const PACKAGE_NAME = "@esportsplus/routing";
+export { PACKAGE_NAME };

package/build/constants.js

@@ -0,0 +1,2 @@
+const PACKAGE_NAME = '@esportsplus/routing';
+export { PACKAGE_NAME };

package/build/index.d.ts

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

package/build/index.js

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

package/package.json

@@ -0,0 +1,38 @@
+{
+  "author": "ICJR",
+  "dependencies": {
+    "@esportsplus/pipeline": "^1.2.2",
+    "@esportsplus/reactivity": "file:/../reactivity",
+    "@esportsplus/typescript": "file:/../typescript",
+    "@esportsplus/utilities": "^0.27.2"
+  },
+  "exports": {
+    "./client": {
+      "types": "./build/client/index.d.ts",
+      "default": "./build/client/index.js"
+    },
+    "./server": {
+      "types": "./build/server/index.d.ts",
+      "default": "./build/server/index.js"
+    },
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    }
+  },
+  "main": "./build/index.js",
+  "name": "@esportsplus/routing",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/esportsplus/routing"
+  },
+  "type": "module",
+  "types": "./build/index.d.ts",
+  "version": "0.6.0",
+  "scripts": {
+    "build": "tsc",
+    "build:test": "vite build --config test/vite.config.ts",
+    "-": "-"
+  }
+}

package/src/client/constants.ts

@@ -0,0 +1,22 @@
+const ON_DELETE = ['DELETE'];
+
+const ON_GET = ['GET'];
+
+const ON_POST = ['POST'];
+
+const ON_PUT = ['PUT'];
+
+const PARAMETER = 0;
+
+const STATIC = 1;
+
+const WILDCARD = 2;
+
+
+export {
+    ON_DELETE, ON_GET, ON_POST, ON_PUT,
+    PARAMETER,
+    STATIC,
+    WILDCARD
+};
+export { PACKAGE_NAME } from '~/constants';

package/src/client/index.ts

@@ -0,0 +1,195 @@
+import { effect, reactive, root } from '@esportsplus/reactivity';
+import { AccumulateRoutes, ExtractOptionalParams, ExtractRequiredParams, InferOutput, Middleware, Next, PathParamsObject, Request, Route, RouteFactory, RoutePath } from './types';
+import { Router } from './router';
+import pipeline from '@esportsplus/pipeline';
+import { PACKAGE_NAME } from './constants';
+
+
+let cache: Request<any>[] = [],
+    location = window.location;
+
+
+function back() {
+    window.history.back();
+}
+
+function forward() {
+    window.history.forward();
+}
+
+function href<T>() {
+    let hash = location.hash || '#/',
+        path = hash ? hash.slice(1).split('?') : ['/', ''],
+        request = {
+            hostname: location.hostname,
+            href: location.href,
+            method: 'GET',
+            origin: location.origin,
+            path: path[0],
+            port: location.port,
+            protocol: location.protocol,
+            query: {} as Record<PropertyKey, unknown>
+        };
+
+    if (path[1]) {
+        let params = new URLSearchParams(path[1]),
+            query = request.query;
+
+        for (let [key, value] of params.entries()) {
+            query[key] = value;
+        }
+    }
+
+    return request as Request<T>;
+}
+
+function match<T>(request: Request<T>, router: Router<T>, subdomain?: string) {
+    if (router.subdomains !== null) {
+        let hostname = request.hostname,
+            subdomains = router.subdomains;
+
+        for (let i = 0, n = subdomains.length; i < n; i++) {
+            if (!hostname.startsWith(subdomains[i])) {
+                continue;
+            }
+
+            subdomain = subdomains[i];
+            break;
+        }
+    }
+
+    return router.match(request.method, request.path, subdomain || '');
+}
+
+function middleware<T>(request: Request<T>, router: Router<T>) {
+    let middleware = pipeline<Request<T>, T>();
+
+    function host(...stages: Middleware<T>[]) {
+        for (let i = 0, n = stages.length; i < n; i++) {
+            middleware.add( stages[i] );
+        }
+
+        return middleware.dispatch(request) as T;
+    };
+
+    host.dispatch = (request: Request<T>) => {
+        let { route } = request.data;
+
+        if (route === undefined) {
+            throw new Error(`${PACKAGE_NAME}: route is undefined!`);
+        }
+
+        return route.pipeline.dispatch(request);
+    };
+
+    host.match = (fallback: Route<T>) => {
+        let state = reactive<ReturnType<typeof router.match>>({
+                parameters: undefined,
+                route: undefined
+            });
+
+        if (fallback === undefined) {
+            throw new Error(`${PACKAGE_NAME}: fallback route does not exist`);
+        }
+
+        effect(() => {
+            let { parameters, route } = match(request, router);
+
+            state.parameters = parameters;
+            state.route = route || fallback;
+        });
+
+        return (request: Request<T>, next: Next<T>) => {
+            if (state.route === undefined) {
+                throw new Error(`${PACKAGE_NAME}: route is undefined`);
+            }
+
+            return root(() => {
+                request.data = {
+                    parameters: state.parameters,
+                    route: state.route
+                };
+
+                return next(request);
+            });
+        };
+    };
+
+    return host;
+}
+
+function normalize(uri: string) {
+    if (uri[0] === '/') {
+        return '#' + uri;
+    }
+
+    return uri;
+}
+
+function onpopstate() {
+    let values = href();
+
+    for (let i = 0, n = cache.length; i < n; i++) {
+        let state = cache[i];
+
+        for (let key in values) {
+            // @ts-ignore
+            state[key] = values[key];
+        }
+    }
+}
+
+
+const router = <const Factories extends readonly RouteFactory<any>[]>(...factories: Factories) => {
+    type Routes = AccumulateRoutes<Factories>;
+    type T = InferOutput<Factories[number]>;
+
+    let instance = factories.reduce(
+            (r, factory) => factory(r),
+            new Router<T, {}>() as Router<T, any>
+        ) as Router<T, Routes>,
+        request = reactive<Request<T>>(Object.assign(href<T>(), { data: {} } as any));
+
+    if (cache.push(request) === 1) {
+        window.addEventListener('hashchange', onpopstate);
+    }
+
+    return {
+        back,
+        forward,
+        middleware: middleware(request, instance as Router<T>),
+        redirect: <RouteName extends keyof Routes>(
+            name: RouteName,
+            ...values: ExtractRequiredParams<RoutePath<Routes, RouteName>> extends never
+                ? ExtractOptionalParams<RoutePath<Routes, RouteName>> extends never
+                    ? []
+                    : [params?: PathParamsObject<RoutePath<Routes, RouteName>>]
+                : [params: PathParamsObject<RoutePath<Routes, RouteName>>]
+        ) => {
+            if ((name as string).indexOf('://') !== -1) {
+                return window.location.replace(name as any);
+            }
+
+            window.location.hash = normalize(instance.uri(name as any, values as any));
+        },
+        routes: instance.routes,
+        uri: <RouteName extends keyof Routes>(
+            name: RouteName,
+            ...values: ExtractRequiredParams<RoutePath<Routes, RouteName>> extends never
+                ? ExtractOptionalParams<RoutePath<Routes, RouteName>> extends never
+                    ? []
+                    : [params?: PathParamsObject<RoutePath<Routes, RouteName>>]
+                : [params: PathParamsObject<RoutePath<Routes, RouteName>>]
+        ) => {
+            return normalize(instance.uri(name as any, values as any));
+        }
+    };
+};
+
+
+export { router };
+export type {
+    Middleware,
+    Next,
+    Request, Route, RouteFactory
+} from './types';