@esportsplus/routing 0.0.49 → 0.1.1

package/src/types.ts

@@ -1,16 +1,18 @@
 import { NeverAsync } from '@esportsplus/typescript';
-import { Route, Router } from './router';
+import { Router } from './router';
+import pipeline from '@esportsplus/pipeline';
 
 
 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;
-    responder: Next<T>;
     subdomain?: string;
 };
 
@@ -27,5 +29,16 @@ type Request<T> = {
     subdomain?: string;
 };
 
+type Route<T> = {
+    name: Name | null;
+    path: string | null;
+    pipeline: ReturnType<typeof pipeline<Request<T>, T>>,
+    subdomain: string | null;
+};
+
+type RouteOptions<T> = Options<T> & {
+    responder: Next<T>;
+};
+
 
-export { Middleware, Next, Options, Request, Route, Router };
+export { Middleware, Name, Next, Options, Request, Route, RouteOptions, Router };

package/build/router/route.d.ts

@@ -1,11 +0,0 @@
-import { Middleware, Next, Request } from '../types';
-declare class Route<T> {
-    middleware: Middleware<T>[] | null;
-    name: string | null;
-    path: string | null;
-    responder: Next<T>;
-    subdomain: string | null;
-    constructor(responder: Next<T>);
-    dispatch(request: Request<T>): T;
-}
-export { Route };

package/build/router/route.js

@@ -1,18 +0,0 @@
-import pipeline from '@esportsplus/pipeline';
-class Route {
-    middleware = null;
-    name = null;
-    path = null;
-    responder;
-    subdomain = null;
-    constructor(responder) {
-        this.responder = responder;
-    }
-    dispatch(request) {
-        if (this.middleware === null) {
-            return this.responder(request);
-        }
-        return pipeline(...this.middleware, (request) => this.responder(request))(request);
-    }
-}
-export { Route };

package/build/router2/constants.d.ts

@@ -1,3 +0,0 @@
-declare const METHOD_NAME_ALL = "ALL";
-declare const PATH_ERROR: unique symbol;
-export { METHOD_NAME_ALL, PATH_ERROR };

package/build/router2/constants.js

@@ -1,3 +0,0 @@
-const METHOD_NAME_ALL = 'ALL';
-const PATH_ERROR = Symbol();
-export { METHOD_NAME_ALL, PATH_ERROR };

package/build/router2/index.d.ts

@@ -1,11 +0,0 @@
-import { HandlerMap, Method, Path, Result } from './types';
-declare class Router<T> {
-    middleware?: Record<Method, Record<Path, HandlerMap<T>[]>>;
-    routes?: Record<Method, Record<Path, HandlerMap<T>[]>>;
-    constructor();
-    private buildAllMatchers;
-    private buildMatcher;
-    add(method: Method, path: Path, handler: T): void;
-    match(method: Method, path: Path): Result<T>;
-}
-export { Router };

package/build/router2/index.js

@@ -1,226 +0,0 @@
-import { METHOD_NAME_ALL, PATH_ERROR } from './constants';
-import { Trie } from './trie';
-const NULL_MATCHER = [/^$/, [], Object.create(null)];
-let empty = [], wildcardCache = Object.create(null);
-function buildMatcherFromPreprocessedRoutes(routes) {
-    if (routes.length === 0) {
-        return NULL_MATCHER;
-    }
-    let handlerMetadata = [], routesWithStaticPathFlag = routes
-        .map((route) => [!/\*|\/:/.test(route[0]), ...route])
-        .sort(([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length), staticMap = Object.create(null), trie = new Trie();
-    for (let i = 0, j = -1, n = routesWithStaticPathFlag.length; i < n; i++) {
-        let [validatePathOnly, path, handlers] = routesWithStaticPathFlag[i];
-        if (validatePathOnly) {
-            staticMap[path] = [handlers.map(([h]) => [h, Object.create(null)]), empty];
-        }
-        else {
-            j++;
-        }
-        let parameterMetadata;
-        try {
-            parameterMetadata = trie.insert(path, j, validatePathOnly);
-        }
-        catch (e) {
-            throw e === PATH_ERROR ? new Error(`Routing: '${path}' is not supported`) : e;
-        }
-        if (validatePathOnly) {
-            continue;
-        }
-        handlerMetadata[j] = handlers.map(([h, i]) => {
-            let paramIndexMap = Object.create(null);
-            i -= 1;
-            for (; i >= 0; i--) {
-                let [key, value] = parameterMetadata[i];
-                paramIndexMap[key] = value;
-            }
-            return [h, paramIndexMap];
-        });
-    }
-    let [regexp, handlerReplacementMap, parameterReplacementMap] = trie.build();
-    for (let i = 0, n = handlerMetadata.length; i < n; i++) {
-        let metadata = handlerMetadata[i];
-        for (let j = 0, n = metadata.length; j < n; j++) {
-            let map = metadata[j]?.[1];
-            if (!map) {
-                continue;
-            }
-            for (let key in map) {
-                map[key] = parameterReplacementMap[map[key]];
-            }
-        }
-    }
-    let handlerMap = [];
-    for (let i = 0, n = handlerReplacementMap.length; i < n; i++) {
-        handlerMap[i] = handlerMetadata[handlerReplacementMap[i]];
-    }
-    return [regexp, handlerMap, staticMap];
-}
-function buildWildcardRegExp(path) {
-    return (wildcardCache[path] ??= new RegExp(path === '*'
-        ? ''
-        : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, char) => char ? `\\${char}` : '(?:|/.*)')}$`));
-}
-function clearWildcardCache() {
-    wildcardCache = Object.create(null);
-}
-function findMiddleware(middleware, path) {
-    if (!middleware) {
-        return undefined;
-    }
-    let keys = Object.keys(middleware).sort((a, b) => b.length - a.length);
-    for (let i = 0, n = keys.length; i < n; i++) {
-        if (buildWildcardRegExp(keys[i]).test(path)) {
-            return [...middleware[keys[i]]];
-        }
-    }
-    return undefined;
-}
-function findOptionalParameters(path) {
-    if (!path.match(/\:.+\?$/)) {
-        return null;
-    }
-    let base = '', results = [], segments = path.split('/');
-    for (let i = 0, n = segments.length; i < n; i++) {
-        let segment = segments[i];
-        if (segment !== '' && !/\:/.test(segment)) {
-            base += '/' + segment;
-        }
-        else if (/\:/.test(segment)) {
-            if (/\?/.test(segment)) {
-                if (results.length === 0 && base === '') {
-                    results.push('/');
-                }
-                else {
-                    results.push(base);
-                }
-                base += '/' + segment.replace('?', '');
-                results.push(base);
-            }
-            else {
-                base += '/' + segment;
-            }
-        }
-    }
-    return results.filter((v, i, a) => a.indexOf(v) === i);
-}
-class Router {
-    middleware;
-    routes;
-    constructor() {
-        this.middleware = {
-            [METHOD_NAME_ALL]: Object.create(null)
-        };
-        this.routes = {
-            [METHOD_NAME_ALL]: Object.create(null)
-        };
-    }
-    buildAllMatchers() {
-        let matchers = Object.create(null);
-        for (let method in this.middleware) {
-            matchers[method] ||= this.buildMatcher(method);
-        }
-        for (let method in this.routes) {
-            matchers[method] ||= this.buildMatcher(method);
-        }
-        this.middleware = this.routes = undefined;
-        return matchers;
-    }
-    buildMatcher(method) {
-        let isAll = method === METHOD_NAME_ALL, properties = [this.middleware, this.routes], property, routes = [];
-        while (property = properties.pop()) {
-            let values = property[method]
-                ? Object.keys(property[method]).map((path) => [path, property[method][path]])
-                : [];
-            if (values.length !== 0) {
-                isAll ||= true;
-                routes.push(...values);
-            }
-            else if (method !== METHOD_NAME_ALL) {
-                routes.push(...Object.keys(property[METHOD_NAME_ALL]).map((path) => [path, property[METHOD_NAME_ALL][path]]));
-            }
-        }
-        return isAll === true ? buildMatcherFromPreprocessedRoutes(routes) : null;
-    }
-    add(method, path, handler) {
-        let { middleware, routes } = this;
-        if (!middleware || !routes) {
-            throw new Error('Routing: Cannot add route after matcher has been built.');
-        }
-        if (!middleware[method]) {
-            let properties = [middleware, routes], property;
-            while (property = properties.pop()) {
-                let copy = property[METHOD_NAME_ALL], into = property[method];
-                property[method] = Object.create(null);
-                for (let path in copy) {
-                    into[path] = [...copy[path]];
-                }
-            }
-        }
-        if (path === '/*') {
-            path = '*';
-        }
-        let parameters = (path.match(/\/:/g) || []).length;
-        if (/\*$/.test(path)) {
-            let regex = buildWildcardRegExp(path);
-            if (method === METHOD_NAME_ALL) {
-                for (let m in middleware) {
-                    middleware[m][path] ||=
-                        findMiddleware(middleware[m], path) ||
-                            findMiddleware(middleware[METHOD_NAME_ALL], path) ||
-                            [];
-                }
-            }
-            else {
-                middleware[method][path] ||=
-                    findMiddleware(middleware[method], path) ||
-                        findMiddleware(middleware[METHOD_NAME_ALL], path) ||
-                        [];
-            }
-            let properties = [middleware, routes], property;
-            while (property = properties.pop()) {
-                for (let m in property) {
-                    if (method === METHOD_NAME_ALL || method === m) {
-                        let routes = property[m];
-                        for (let path in routes) {
-                            regex.test(path) && routes[path].push([handler, parameters]);
-                        }
-                    }
-                }
-            }
-            return;
-        }
-        let paths = findOptionalParameters(path) || [path];
-        for (let i = 0, n = paths.length; i < n; i++) {
-            let path = paths[i];
-            for (let m in routes) {
-                if (method === METHOD_NAME_ALL || method === m) {
-                    let r = routes[m];
-                    r[path] ||= [
-                        ...(findMiddleware(middleware[m], path) ||
-                            findMiddleware(middleware[METHOD_NAME_ALL], path) ||
-                            []),
-                    ];
-                    r[path].push([handler, parameters - n + i + 1]);
-                }
-            }
-        }
-    }
-    match(method, path) {
-        clearWildcardCache();
-        let matchers = this.buildAllMatchers();
-        this.match = (method, path) => {
-            let matcher = (matchers[method] || matchers[METHOD_NAME_ALL]), staticMatch = matcher[2][path];
-            if (staticMatch) {
-                return staticMatch;
-            }
-            let match = path.match(matcher[0]);
-            if (!match) {
-                return [[], empty];
-            }
-            return [matcher[1][match.indexOf('', 1)], match];
-        };
-        return this.match(method, path);
-    }
-}
-export { Router };

package/build/router2/node.d.ts

@@ -1,10 +0,0 @@
-import type { Trie } from './trie';
-import { ParameterMetadata, Path } from './types';
-declare class Node {
-    children: Record<Path, Node>;
-    index?: number;
-    slot?: number;
-    buildRegexString(): Path;
-    insert(tokens: readonly Path[], index: number, parameters: ParameterMetadata, context: Trie['context'], validatePathOnly: boolean): void;
-}
-export { Node };

package/build/router2/node.js

@@ -1,117 +0,0 @@
-import { PATH_ERROR } from './constants';
-const LABEL_REGEXP = '[^/]+';
-const REGEXP_CHARACTERS = new Set('.\\+*[^]$()');
-const WILDCARD_ONLY_REGEXP = '.*';
-const WILDCARD_TAIL_REGEXP = '(?:|/.*)';
-const MATCH_WILDCARD_ONLY = ['', '', WILDCARD_ONLY_REGEXP];
-const MATCH_LABEL = ['', '', LABEL_REGEXP];
-const MATCH_WILDCARD_TAIL = ['', '', WILDCARD_TAIL_REGEXP];
-function sort(a, b) {
-    if (a.length === 1) {
-        return b.length === 1 ? (a < b ? -1 : 1) : -1;
-    }
-    else if (b.length === 1) {
-        return 1;
-    }
-    if (a === WILDCARD_ONLY_REGEXP || a === WILDCARD_TAIL_REGEXP) {
-        return 1;
-    }
-    else if (b === WILDCARD_ONLY_REGEXP || b === WILDCARD_TAIL_REGEXP) {
-        return -1;
-    }
-    if (a === LABEL_REGEXP) {
-        return 1;
-    }
-    else if (b === LABEL_REGEXP) {
-        return -1;
-    }
-    return a.length === b.length ? (a < b ? -1 : 1) : b.length - a.length;
-}
-class Node {
-    children = Object.create(null);
-    index;
-    slot;
-    buildRegexString() {
-        let children = this.children, path, paths = Object.keys(children).sort(sort);
-        for (let i = 0, n = paths.length; i < n; i++) {
-            let child = children[path = paths[i]];
-            paths[i] = (typeof child.slot === 'number'
-                ? `(${path})@${child.slot}`
-                : REGEXP_CHARACTERS.has(path)
-                    ? `\\${path}`
-                    : path) + child.buildRegexString();
-        }
-        if (typeof this.index === 'number') {
-            paths.unshift(`#${this.index}`);
-        }
-        if (paths.length === 0) {
-            return '';
-        }
-        else if (paths.length === 1) {
-            return paths[0];
-        }
-        return '(?:' + paths.join('|') + ')';
-    }
-    insert(tokens, index, parameters, context, validatePathOnly) {
-        if (tokens.length === 0) {
-            if (this.index !== undefined) {
-                throw PATH_ERROR;
-            }
-            else if (validatePathOnly) {
-                return;
-            }
-            this.index = index;
-            return;
-        }
-        let [token, ...remainingTokens] = tokens, node, pattern = token === '*'
-            ? remainingTokens.length === 0
-                ? MATCH_WILDCARD_ONLY
-                : MATCH_LABEL
-            : token === '/*'
-                ? MATCH_WILDCARD_TAIL
-                : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-        if (pattern) {
-            let name = pattern[1], path = pattern[2] || LABEL_REGEXP;
-            if (name && pattern[2]) {
-                path = path.replace(/^\((?!\?:)(?=[^)]+\)$)/, '(?:');
-                if (/\((?!\?:)/.test(path)) {
-                    throw PATH_ERROR;
-                }
-            }
-            node = this.children[path];
-            if (!node) {
-                for (let key in this.children) {
-                    if (key !== WILDCARD_ONLY_REGEXP && key !== WILDCARD_TAIL_REGEXP) {
-                        throw PATH_ERROR;
-                    }
-                }
-                if (validatePathOnly) {
-                    return;
-                }
-                node = this.children[path] = new Node();
-                if (name !== '') {
-                    node.slot = context.slot++;
-                }
-            }
-            if (name !== '' && validatePathOnly === false) {
-                parameters.push([name, node.slot]);
-            }
-        }
-        else {
-            node = this.children[token];
-            if (!node) {
-                for (let key in this.children) {
-                    if (key.length > 1 && key !== WILDCARD_ONLY_REGEXP && key !== WILDCARD_TAIL_REGEXP) {
-                        throw PATH_ERROR;
-                    }
-                }
-                if (validatePathOnly) {
-                    return;
-                }
-                node = this.children[token] = new Node();
-            }
-        }
-        node.insert(remainingTokens, index, parameters, context, validatePathOnly);
-    }
-}
-export { Node };

package/build/router2/trie.d.ts

@@ -1,11 +0,0 @@
-import { Node } from './node';
-import { Indexes, ParameterMetadata, Path } from './types';
-declare class Trie {
-    context: {
-        slot: number;
-    };
-    root: Node;
-    build(): [RegExp, Indexes, Indexes];
-    insert(path: Path, index: number, pathErrorCheckOnly: boolean): ParameterMetadata;
-}
-export { Trie };

package/build/router2/trie.js

@@ -1,53 +0,0 @@
-import { Node } from './node';
-const NEVER_MATCH = [/^$/, [], []];
-class Trie {
-    context = { slot: 0 };
-    root = new Node();
-    build() {
-        let regex = this.root.buildRegexString();
-        if (regex === '') {
-            return NEVER_MATCH;
-        }
-        let handlers = [], i = 0, parameters = [];
-        regex = regex.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handler, parameter) => {
-            if (typeof handler !== 'undefined') {
-                handlers[++i] = Number(handler);
-                return '$()';
-            }
-            else if (typeof parameter !== 'undefined') {
-                parameters[Number(parameter)] = ++i;
-            }
-            return '';
-        });
-        return [new RegExp(`^${regex}`), handlers, parameters];
-    }
-    insert(path, index, pathErrorCheckOnly) {
-        let groups = [], parameters = [];
-        for (let i = 0;;) {
-            let replaced = false;
-            path = path.replace(/\{[^}]+\}/g, (m) => {
-                let mark = `@\\${i}`;
-                groups[i++] = [mark, m];
-                replaced = true;
-                return mark;
-            });
-            if (!replaced) {
-                break;
-            }
-        }
-        let tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
-        for (let i = groups.length - 1; i >= 0; i--) {
-            let [mark, replacement] = groups[i], token;
-            for (let j = tokens.length - 1; j >= 0; j--) {
-                token = tokens[j];
-                if (token.indexOf(mark) !== -1) {
-                    token = token.replace(mark, replacement);
-                    break;
-                }
-            }
-        }
-        this.root.insert(tokens, index, parameters, this.context, pathErrorCheckOnly);
-        return parameters;
-    }
-}
-export { Trie };

package/build/router2/types.d.ts

@@ -1,11 +0,0 @@
-type HandlerMap<T> = [T, number];
-type HandlerMetadata<T> = [T, ParameterMap][];
-type Indexes = number[];
-type Matcher<T> = [RegExp, HandlerMetadata<T>[], StaticMap<T>];
-type Method = string;
-type ParameterMap = Record<string, number>;
-type ParameterMetadata = [string, number][];
-type Path = string;
-type Result<T> = [[T, ParameterMap][], string[]] | [[T, Record<string, string>][]];
-type StaticMap<T> = Record<Path, Result<T>>;
-export { HandlerMap, HandlerMetadata, Indexes, Matcher, Method, ParameterMap, ParameterMetadata, Path, Result, StaticMap };

package/build/router2/types.js

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

package/src/router/route.ts

@@ -1,28 +0,0 @@
-import { Middleware, Next, Request } from '~/types';
-import pipeline from '@esportsplus/pipeline';
-
-
-class Route<T> {
-    middleware: Middleware<T>[] | null = null;
-    name: string | null = null;
-    path: string | null = null;
-    responder: Next<T>;
-    subdomain: string | null = null;
-
-
-    constructor(responder: Next<T>) {
-        this.responder = responder;
-    }
-
-
-    dispatch(request: Request<T>) {
-        if (this.middleware === null) {
-            return this.responder(request);
-        }
-
-        return pipeline(...this.middleware, (request) => this.responder(request))(request);
-    }
-}
-
-
-export { Route };

package/src/router2/constants.ts

@@ -1,6 +0,0 @@
-const METHOD_NAME_ALL = 'ALL';
-
-const PATH_ERROR = Symbol();
-
-
-export { METHOD_NAME_ALL, PATH_ERROR };