@tdb/util/lib/helpers/url/Route.d.ts

Shared helpers and utilities.

import { IRoute, IRouteMeta, RouteOptions, RouteParams, RouteQuery } from './types';
export * from './types';
export declare type CreateRoute = <P extends RouteParams, Q extends RouteQuery = {}>(path: string, args?: RouteOptions) => Route<P, Q>;
export declare class Route<P extends RouteParams = {}, Q extends RouteQuery = {}> implements IRoute {
    static create: CreateRoute;
    static get: CreateRoute;
    static put: CreateRoute;
    static post: CreateRoute;
    static delete: CreateRoute;
    static patch: CreateRoute;
    readonly path: IRoute['path'];
    private readonly _options;
    private readonly _tokens;
    private readonly _regex;
    private readonly _toPath;
    private constructor();
    toString(): string;
    readonly schema: IRoute['schema'];
    readonly method: IRoute['method'];
    readonly title: IRoute['title'];
    readonly description: IRoute['description'];
    readonly docs: IRoute['docs'];
    readonly meta: IRouteMeta;
    readonly tokens: IRoute['tokens'];
    isMatch(url?: string): boolean;
    params(url?: string): P;
    static params<P extends RouteParams = {}>(route: Route, url?: string): P;
    query(url?: string): Q;
    static query<Q extends RouteQuery = {}>(url?: string): Q;
    url(url?: string, options?: {
        origin?: string;
    }): RouteUrl;
    toUrl(args: {
        params?: P;
        query?: Q;
        origin?: string;
    }): RouteUrl<{}, {}>;
    static toQueryString(query?: RouteQuery): string;
    clone(options?: {
        path?: string;
    } & RouteOptions): Route<RouteParams, {}>;
    toObject(): IRoute;
    static walk(tree: object | undefined, fn: (route: Route, args: {
        stop: () => void;
    }) => void): void;
    static find(tree: object | undefined, match: (route: Route) => boolean): Route<{}, {}> | undefined;
    static map<T>(tree: object | undefined, fn: (route: Route, index: number) => T): T[];
    static toString(path: string, options?: {
        origin?: string;
    }): string;
}
export declare class RouteUrl<P extends RouteParams = {}, Q extends RouteQuery = {}> {
    readonly path: string;
    readonly route: Route;
    readonly params: P;
    readonly query: Q;
    readonly origin: string | undefined;
    constructor(args: {
        url: string;
        route: Route<P, Q>;
        origin?: string;
    });
    readonly s: string;
    toString(options?: {
        origin?: string;
    }): string;
    hasFlag(key?: string | string[]): boolean;
}