@esportsplus/routing 0.0.49 → 0.1.1

package/src/router2/index.ts

@@ -1,330 +0,0 @@
-import { METHOD_NAME_ALL, PATH_ERROR } from './constants';
-import { Trie } from './trie';
-import { HandlerMap, HandlerMetadata, Matcher, Method, ParameterMap, ParameterMetadata, Path, Result, StaticMap } from './types';
-
-
-const NULL_MATCHER = [/^$/, [], Object.create(null)] as Matcher<any>;
-
-
-let empty: any[] = [],
-    wildcardCache: Record<Path, RegExp> = Object.create(null);
-
-
-function buildMatcherFromPreprocessedRoutes<T>(routes: [Path, HandlerMap<T>[]][]): Matcher<T> {
-    if (routes.length === 0) {
-        return NULL_MATCHER;
-    }
-
-    let handlerMetadata: HandlerMetadata<T>[] = [],
-        routesWithStaticPathFlag = routes
-            .map(
-                (route) => [!/\*|\/:/.test(route[0]), ...route] as [boolean, Path, HandlerMap<T>[]]
-            )
-            .sort(([isStaticA, pathA], [isStaticB, pathB]) =>
-                isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
-            ),
-        staticMap: StaticMap<T> = 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: 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: ParameterMap = 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: HandlerMetadata<T>[] = [];
-
-    for (let i = 0, n = handlerReplacementMap.length; i < n; i++) {
-        handlerMap[i] = handlerMetadata[handlerReplacementMap[i]];
-    }
-
-    return [regexp, handlerMap, staticMap] as Matcher<T>;
-}
-
-function buildWildcardRegExp(path: Path): RegExp {
-    return (wildcardCache[path] ??= new RegExp(
-        path === '*'
-            ? ''
-            : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, char) =>
-                char ? `\\${char}` : '(?:|/.*)'
-            )}$`
-    ))
-}
-
-function clearWildcardCache() {
-    wildcardCache = Object.create(null);
-}
-
-function findMiddleware<T>(middleware: Record<string, T[]> | undefined, path: Path): T[] | undefined {
-    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;
-}
-
-// If path is `/api/animals/:type?` [`/api/animals`, `/api/animals/:type`] else null
-function findOptionalParameters(path: Path): string[] | null {
-    if (!path.match(/\:.+\?$/)) {
-        return null
-    }
-
-    let base = '',
-        results: string[] = [],
-        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<T> {
-    middleware?: Record<Method, Record<Path, HandlerMap<T>[]>>
-    routes?: Record<Method, Record<Path, HandlerMap<T>[]>>
-
-
-    constructor() {
-        this.middleware = {
-            [METHOD_NAME_ALL]: Object.create(null)
-        };
-        this.routes = {
-            [METHOD_NAME_ALL]: Object.create(null)
-        };
-    }
-
-
-    private buildAllMatchers(): Record<Method, Matcher<T> | null> {
-        let matchers: Record<Method, Matcher<T> | null> = 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;
-    }
-
-    private buildMatcher(method: Method): Matcher<T> | null {
-        let isAll = method === METHOD_NAME_ALL,
-            properties = [this.middleware, this.routes],
-            property,
-            routes: [Path, HandlerMap<T>[]][] = [];
-
-        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 as typeof routes));
-            }
-            else if (method !== METHOD_NAME_ALL) {
-                routes.push(
-                    ...(Object.keys(property[METHOD_NAME_ALL]).map((path) => [path, property![METHOD_NAME_ALL][path]]) as typeof routes)
-                );
-            }
-        }
-
-        return isAll === true ? buildMatcherFromPreprocessedRoutes(routes) : null;
-    }
-
-    add(method: Method, path: Path, handler: T) {
-        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: Method, path: Path): Result<T> {
-        clearWildcardCache();
-
-        let matchers = this.buildAllMatchers();
-
-        this.match = (method, path) => {
-            let matcher = (matchers[method] || matchers[METHOD_NAME_ALL]) as Matcher<T>,
-                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/src/router2/node.ts

@@ -1,184 +0,0 @@
-import { PATH_ERROR } from './constants';
-import type { Trie } from './trie';
-import { ParameterMetadata, Path } from './types';
-
-
-const LABEL_REGEXP = '[^/]+';
-
-const REGEXP_CHARACTERS = new Set('.\\+*[^]$()');
-
-const WILDCARD_ONLY_REGEXP = '.*';
-
-const WILDCARD_TAIL_REGEXP = '(?:|/.*)';
-
-
-// '*' matches to all the trailing paths
-const MATCH_WILDCARD_ONLY = ['', '', WILDCARD_ONLY_REGEXP];
-
-const MATCH_LABEL = ['', '', LABEL_REGEXP];
-
-// '/path/to/*' is /\/path\/to(?:|/.*)$
-const MATCH_WILDCARD_TAIL = ['', '', WILDCARD_TAIL_REGEXP];
-
-
-/**
- * Sort order:
- * 1. literal
- * 2. special pattern (e.g. :label{[0-9]+})
- * 3. common label pattern (e.g. :label)
- * 4. wildcard
- */
-function sort(a: Path, b: Path): number {
-    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: Record<Path, Node> = Object.create(null);
-    index?: number;
-    slot?: number;
-
-
-    buildRegexString(): Path {
-        let children = this.children,
-            path,
-            paths: Path[] = 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: readonly Path[],
-        index: number,
-        parameters: ParameterMetadata,
-        context: Trie['context'],
-        validatePathOnly: boolean
-    ): void {
-        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]) {
-                // (a|b) => (?:a|b)
-                path = path.replace(/^\((?!\?:)(?=[^)]+\)$)/, '(?:');
-
-                // prefix(?:a|b) is allowed, but prefix(a|b) is not
-                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 as number]);
-            }
-        }
-        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/src/router2/trie.ts

@@ -1,88 +0,0 @@
-import { Node } from './node'
-import { Indexes, ParameterMetadata, Path } from './types';
-
-
-const NEVER_MATCH = [/^$/, [], []] as [RegExp, Indexes, Indexes];
-
-
-class Trie {
-    context = { slot: 0 };
-    root = new Node();
-
-
-    build(): [RegExp, Indexes, Indexes] {
-        let regex = this.root.buildRegexString();
-
-        if (regex === '') {
-            return NEVER_MATCH;
-        }
-
-        let handlers: Indexes = [],
-            i = 0,
-            parameters: Indexes = [];
-
-        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: Path, index: number, pathErrorCheckOnly: boolean): ParameterMetadata {
-        let groups: [string, string][] = [],
-            parameters: ParameterMetadata = [];
-
-        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;
-            }
-        }
-
-        /**
-         *  - pattern (:label, :label{0-9]+}, ...)
-         *  - /* wildcard
-         *  - character
-         */
-        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/src/router2/types.ts

@@ -1,59 +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;
-
-/**
- * The result can be in one of two formats:
- * 1. An array of handlers with their corresponding parameter index maps, followed by a parameter stash.
- * 2. An array of handlers with their corresponding parameter maps.
- *
- * Example:
- *
- * [[handler, paramIndexMap][], paramArray]
- * ```typescript
- * [
- *   [
- *     [middlewareA, {}],                     // '*'
- *     [funcA,       {'id': 0}],              // '/user/:id/*'
- *     [funcB,       {'id': 0, 'action': 1}], // '/user/:id/:action'
- *   ],
- *   ['123', 'abc']
- * ]
- * ```
- *
- * [[handler, params][]]
- * ```typescript
- * [
- *   [
- *     [middlewareA, {}],                             // '*'
- *     [funcA,       {'id': '123'}],                  // '/user/:id/*'
- *     [funcB,       {'id': '123', 'action': 'abc'}], // '/user/:id/:action'
- *   ]
- * ]
- * ```
- */
-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
-};