routup 1.0.3 → 3.0.0-alpha.1

package/dist/layer/constants.d.ts

@@ -0,0 +1 @@
+export declare const LayerSymbol: unique symbol;

package/dist/layer/module.d.ts

@@ -1,14 +1,17 @@
-import type { DispatcherMeta, Request, Response } from '../type';
+import type { Dispatcher, DispatcherEvent, DispatcherMeta } from '../dispatcher';
+import type { Handler } from '../handler';
 import { PathMatcher } from '../path';
-import type { LayerOptions } from './type';
-export declare class Layer {
+import type { Response } from '../response';
+export declare class Layer implements Dispatcher {
     readonly '@instanceof': symbol;
-    protected fn: CallableFunction;
-    protected pathMatcher: PathMatcher;
-    constructor(options: LayerOptions, fn: CallableFunction);
-    isError(): boolean;
-    dispatch(req: Request, res: Response, meta: DispatcherMeta, next: CallableFunction): void;
-    dispatch(req: Request, res: Response, meta: DispatcherMeta, next: CallableFunction, err: Error): void;
+    protected handler: Handler;
+    protected pathMatcher: PathMatcher | undefined;
+    constructor(handler: Handler);
+    get type(): "error" | "core";
+    get path(): import("../path").Path | undefined;
+    get method(): string | undefined;
+    dispatch(event: DispatcherEvent, meta: DispatcherMeta): Promise<boolean>;
+    protected sendOutput(res: Response, input: unknown): Promise<any>;
     matchPath(path: string): boolean;
-    exec(path: string): import("../path").PathMatcherExecResult | undefined;
+    matchMethod(method: string): boolean;
 }

package/dist/layer/type.d.ts

@@ -1,6 +1,8 @@
-import type { PathMatcherOptions } from '../path';
-import type { Path } from '../type';
+import type { MethodName } from '../constants';
+import type { HandlerFn } from '../handler';
+import type { Path } from '../path';
 export type LayerOptions = {
-    path: Path;
-    pathMatcher: PathMatcherOptions;
+    handler: HandlerFn;
+    method?: `${MethodName}`;
+    path?: Path;
 };

package/dist/path/index.d.ts

@@ -1,2 +1,3 @@
 export * from './matcher';
 export * from './type';
+export * from './utils';

package/dist/path/matcher.d.ts

@@ -1,11 +1,10 @@
 import type { Key } from 'path-to-regexp';
-import type { Path } from '../type';
-import type { PathMatcherExecResult, PathMatcherOptions } from './type';
+import type { Path, PathMatcherExecResult, PathMatcherOptions } from './type';
 export declare class PathMatcher {
-    path: Path;
-    regexp: RegExp;
-    regexpKeys: Key[];
-    regexpOptions: PathMatcherOptions;
+    protected path: Path;
+    protected regexp: RegExp;
+    protected regexpKeys: Key[];
+    protected regexpOptions: PathMatcherOptions;
     constructor(path: Path, options?: PathMatcherOptions);
     test(path: string): boolean;
     exec(path: string): PathMatcherExecResult | undefined;

package/dist/path/type.d.ts

@@ -4,3 +4,4 @@ export type PathMatcherExecResult = {
     path: string;
     params: Record<string, any>;
 };
+export type Path = string | RegExp;

package/dist/path/utils.d.ts

@@ -0,0 +1,2 @@
+import type { Path } from './type';
+export declare function isPath(input: unknown): input is Path;

package/dist/plugin/index.d.ts

@@ -0,0 +1,2 @@
+export * from './is';
+export * from './types';

package/dist/plugin/is.d.ts

@@ -0,0 +1,2 @@
+import type { PluginInstallContext } from './types';
+export declare function isPluginInstallContext(input: unknown): input is PluginInstallContext;

package/dist/plugin/types.d.ts

@@ -0,0 +1,32 @@
+import type { Path } from '../path';
+import type { Router } from '../router';
+export type PluginOptions = Record<string | symbol, any>;
+export type PluginInstallFn<Options extends PluginOptions = PluginOptions> = (router: Router, options: Options) => any;
+export type Plugin<Options extends PluginOptions = PluginOptions> = {
+    /**
+     * The name of the plugin.
+     */
+    name: string;
+    /**
+     *  The supported routup (semver) version.
+     */
+    version?: string;
+    /**
+     * The installation function called on registration.
+     */
+    install: PluginInstallFn<Options>;
+};
+export type PluginInstallContext<Options = any> = {
+    /**
+     * The name property overwrites the name defined by the plugin.
+     */
+    name?: string;
+    /**
+     * By specifying a path, the plugin will be installed as a child router.
+     */
+    path?: Path;
+    /**
+     * Pass options to the plugin installation routine.
+     */
+    options: Options;
+};

package/dist/{helpers/request → request/helpers}/body.d.ts

@@ -1,4 +1,4 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function useRequestBody(req: Request): Record<string, any>;
 export declare function useRequestBody(req: Request, key: string): any | undefined;
 export declare function hasRequestBody(req: Request): boolean;

package/dist/{helpers/request → request/helpers}/cache.d.ts

@@ -1,2 +1,2 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function isRequestCacheable(req: Request, modifiedTime: string | Date): boolean;

package/dist/{helpers/request → request/helpers}/cookie.d.ts

@@ -1,4 +1,4 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function useRequestCookies(req: Request): Record<string, string>;
 export declare function hasRequestCookies(req: Request): boolean;
 export declare function useRequestCookie(req: Request, name: string): string | undefined;

package/dist/{helpers/request → request/helpers}/env.d.ts

@@ -1,4 +1,4 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function setRequestEnv(req: Request, key: string, value: unknown): void;
 export declare function setRequestEnv(req: Request, record: Record<string, any>, append?: boolean): void;
 export declare function useRequestEnv(req: Request): Record<string, any>;

package/dist/{helpers/request → request/helpers}/header-accept-charset.d.ts

@@ -1,3 +1,3 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function getRequestAcceptableCharsets(req: Request): string[];
 export declare function getRequestAcceptableCharset(req: Request, input: string | string[]): string | undefined;

package/dist/{helpers/request → request/helpers}/header-accept-language.d.ts

@@ -1,3 +1,3 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function getRequestAcceptableLanguages(req: Request): string[];
 export declare function getRequestAcceptableLanguage(req: Request, input?: string | string[]): string | undefined;

package/dist/{helpers/request → request/helpers}/header-accept.d.ts

@@ -1,3 +1,3 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function getRequestAcceptableContentTypes(req: Request): string[];
 export declare function getRequestAcceptableContentType(req: Request, input?: string | string[]): string | undefined;

package/dist/{helpers/request → request/helpers}/header-content-type.d.ts

@@ -1,2 +1,2 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function matchRequestContentType(req: Request, contentType: string): boolean;

package/dist/{helpers/request → request/helpers}/header.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
 import type { IncomingHttpHeaders } from 'node:http';
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function getRequestHeader<K extends keyof IncomingHttpHeaders>(req: Request, name: K): IncomingHttpHeaders[K];
 export declare function setRequestHeader<K extends keyof IncomingHttpHeaders>(req: Request, name: K, value: IncomingHttpHeaders[K]): void;

package/dist/{helpers/request → request/helpers}/hostname.d.ts

@@ -1,5 +1,5 @@
-import type { Request } from '../../type';
 import type { TrustProxyInput } from '../../utils';
+import type { Request } from '../types';
 type RequestHostNameOptions = {
     trustProxy?: TrustProxyInput;
 };

package/dist/{helpers/request → request/helpers}/index.d.ts

@@ -16,3 +16,4 @@ export * from './params';
 export * from './path';
 export * from './protocol';
 export * from './query';
+export * from './router';

package/dist/{helpers/request → request/helpers}/ip.d.ts

@@ -1,5 +1,5 @@
-import type { Request } from '../../type';
 import type { TrustProxyInput } from '../../utils';
+import type { Request } from '../types';
 type RequestIpOptions = {
     trustProxy?: TrustProxyInput;
 };

package/dist/{helpers/request → request/helpers}/mount-path.d.ts

@@ -1,3 +1,3 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function useRequestMountPath(req: Request): string;
 export declare function setRequestMountPath(req: Request, basePath: string): void;

package/dist/{helpers/request → request/helpers}/negotiator.d.ts

@@ -1,3 +1,3 @@
 import Negotiator from 'negotiator';
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function useRequestNegotiator(req: Request): Negotiator;

package/dist/{helpers/request → request/helpers}/params.d.ts

@@ -1,4 +1,4 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function useRequestParams(req: Request): Record<string, any>;
 export declare function useRequestParam(req: Request, key: string): any;
 export declare function setRequestParams(req: Request, data: Record<string, any>): void;

package/dist/{helpers/request → request/helpers}/path.d.ts

@@ -1,2 +1,2 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function useRequestPath(req: Request): string;

package/dist/{helpers/request → request/helpers}/protocol.d.ts

@@ -1,5 +1,5 @@
-import type { Request } from '../../type';
 import type { TrustProxyInput } from '../../utils';
+import type { Request } from '../types';
 type RequestProtocolOptions = {
     trustProxy?: TrustProxyInput;
     default?: string;

package/dist/{helpers/request → request/helpers}/query.d.ts

@@ -1,4 +1,4 @@
-import type { Request } from '../../type';
+import type { Request } from '../types';
 export declare function useRequestQuery(req: Request): Record<string, any>;
 export declare function useRequestQuery(req: Request, key: string): any;
 export declare function hasRequestQuery(req: Request): boolean;

package/dist/request/helpers/router.d.ts

@@ -0,0 +1,3 @@
+import type { Request } from '../types';
+export declare function setRequestRouterPath(req: Request, path: number[]): void;
+export declare function useRequestRouterPath(req: Request): number[] | undefined;

package/dist/request/index.d.ts

@@ -0,0 +1,3 @@
+export * from './helpers';
+export * from './module';
+export * from './types';

package/dist/request/module.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { IncomingMessage } from 'node:http';
+import type { RequestCreateContext } from './types';
+export declare function createRequest(context: RequestCreateContext): IncomingMessage;

package/dist/request/types.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import type { IncomingMessage } from 'node:http';
+import type { NodeReadableStream, WebReadableStream } from '../types';
+export type RequestBody = null | Iterable<any> | AsyncIterable<any> | NodeReadableStream | WebReadableStream;
+export type RequestHeaders = Record<string, string | string[]>;
+export type RequestCreateContext = {
+    body?: RequestBody;
+    headers?: RequestHeaders;
+    method?: string;
+    url?: string;
+};
+export interface Request extends IncomingMessage {
+}

package/dist/{helpers/response → response/helpers}/cache.d.ts

@@ -1,4 +1,4 @@
-import type { Response } from '../../type';
+import type { Response } from '../types';
 export type ResponseCacheHeadersOptions = {
     maxAge?: number;
     modifiedTime?: string | Date;

package/dist/response/helpers/gone.d.ts

@@ -0,0 +1,2 @@
+import type { Response } from '../types';
+export declare function isResponseGone(res: Response): any;

package/dist/{helpers/response → response/helpers}/header-attachment.d.ts

@@ -1,2 +1,2 @@
-import type { Response } from '../../type';
+import type { Response } from '../types';
 export declare function setResponseHeaderAttachment(res: Response, filename?: string): void;

package/dist/{helpers/response → response/helpers}/header-content-type.d.ts

@@ -1,2 +1,2 @@
-import type { Response } from '../../type';
+import type { Response } from '../types';
 export declare function setResponseHeaderContentType(res: Response, input: string, ifNotExists?: boolean): void;

package/dist/{helpers/response → response/helpers}/header.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
 import type { OutgoingHttpHeader } from 'node:http';
-import type { Response } from '../../type';
+import type { Response } from '../types';
 export declare function appendResponseHeader(res: Response, name: string, value: OutgoingHttpHeader): void;
 export declare function appendResponseHeaderDirective(res: Response, name: string, value: OutgoingHttpHeader): void;

package/dist/{helpers/response → response/helpers}/index.d.ts

@@ -1,4 +1,5 @@
 export * from './cache';
+export * from './gone';
 export * from './header';
 export * from './header-attachment';
 export * from './header-content-type';
@@ -9,4 +10,6 @@ export * from './send-file';
 export * from './send-format';
 export * from './send-redirect';
 export * from './send-stream';
+export * from './send-web-response';
+export * from './send-web-blob';
 export * from './utils';

package/dist/{helpers/response → response/helpers}/send-accepted.d.ts

@@ -1,2 +1,2 @@
-import type { Response } from '../../type';
-export declare function sendAccepted(res: Response, chunk?: any): void;
+import type { Response } from '../types';
+export declare function sendAccepted(res: Response, chunk?: any): Promise<void>;

package/dist/{helpers/response → response/helpers}/send-created.d.ts

@@ -1,2 +1,2 @@
-import type { Response } from '../../type';
-export declare function sendCreated(res: Response, chunk?: any): void;
+import type { Response } from '../types';
+export declare function sendCreated(res: Response, chunk?: any): Promise<void>;

package/dist/response/helpers/send-file.d.ts

@@ -0,0 +1,17 @@
+import type { Response } from '../types';
+export type SendFileContentOptions = {
+    end?: number;
+    start?: number;
+};
+export type SendFileStats = {
+    size?: number;
+    mtime?: Date | number | string;
+    name?: string;
+};
+export type SendFileOptions = {
+    stats: () => Promise<SendFileStats> | SendFileStats;
+    content: (options: SendFileContentOptions) => Promise<unknown> | unknown;
+    attachment?: boolean;
+    name?: string;
+};
+export declare function sendFile(res: Response, options: SendFileOptions, next?: (err?: Error) => Promise<unknown> | unknown): Promise<unknown>;

package/dist/{helpers/response → response/helpers}/send-format.d.ts

@@ -1,4 +1,4 @@
-import type { Response } from '../../type';
+import type { Response } from '../types';
 type ResponseFormats = {
     default: () => void;
     [key: string]: () => void;

package/dist/response/helpers/send-redirect.d.ts

@@ -0,0 +1,2 @@
+import type { Response } from '../types';
+export declare function sendRedirect(res: Response, location: string, statusCode?: number): Promise<void>;

package/dist/response/helpers/send-stream.d.ts

@@ -0,0 +1,3 @@
+import type { NodeReadableStream, WebReadableStream } from '../../types';
+import type { Response } from '../types';
+export declare function sendStream(res: Response, stream: NodeReadableStream | WebReadableStream, next?: (err?: Error) => Promise<unknown> | unknown): Promise<unknown>;

package/dist/response/helpers/send-web-blob.d.ts

@@ -0,0 +1,3 @@
+import type { WebBlob } from '../../types';
+import type { Response } from '../types';
+export declare function sendWebBlob(res: Response, blob: WebBlob): Promise<unknown>;

package/dist/response/helpers/send-web-response.d.ts

@@ -0,0 +1,3 @@
+import type { WebResponse } from '../../types';
+import type { Response } from '../types';
+export declare function sendWebResponse(res: Response, webResponse: WebResponse): Promise<unknown>;

package/dist/response/helpers/send.d.ts

@@ -0,0 +1,2 @@
+import type { Response } from '../types';
+export declare function send(res: Response, chunk?: any): Promise<void>;

package/dist/response/helpers/utils.d.ts

@@ -0,0 +1,2 @@
+import type { Response } from '../types';
+export declare function setResponseContentTypeByFileName(res: Response, fileName: string): void;

package/dist/response/index.d.ts

@@ -0,0 +1,3 @@
+export * from './helpers';
+export * from './module';
+export * from './types';

package/dist/response/module.d.ts

@@ -0,0 +1,3 @@
+import type { Request } from '../request';
+import type { Response } from './types';
+export declare function createResponse(request: Request): Response;

package/dist/response/types.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { ServerResponse } from 'node:http';
+export interface Response extends ServerResponse {
+}

package/dist/router/constants.d.ts

@@ -0,0 +1 @@
+export declare const RouterSymbol: unique symbol;

package/dist/router/index.d.ts

@@ -1,2 +1,2 @@
 export * from './module';
-export * from './type';
+export { isRouterInstance } from './utils';

package/dist/router/module.d.ts

@@ -1,70 +1,54 @@
-/// <reference types="node" />
-import type { RequestListener } from 'node:http';
-import type { DispatcherMeta, ErrorHandler, Handler, Next, Path, Request, Response } from '../type';
-import type { PathMatcherOptions } from '../path';
-import { PathMatcher } from '../path';
+import type { Dispatcher, DispatcherEvent, DispatcherMeta } from '../dispatcher';
+import type { Handler } from '../handler';
 import { Layer } from '../layer';
-import { Route } from '../route';
-import type { RouterOptions } from './type';
-export declare function isRouterInstance(input: unknown): input is Router;
-export declare class Router {
+import type { Path } from '../path';
+import { PathMatcher } from '../path';
+import type { RouterOptionsInput } from '../router-options';
+import type { Plugin, PluginInstallContext, PluginOptions } from '../plugin';
+export declare class Router implements Dispatcher {
     readonly '@instanceof': symbol;
     /**
-     * Array of mounted layers, routes & routers.
-     *
-     * @protected
-     */
-    protected stack: (Router | Route | Layer)[];
-    /**
-     * Mount path of instance
-     *
-     * @protected
-     */
-    protected path: Path | undefined;
-    /**
-     * Path matcher for the current mount path.
-     *
-     * @protected
+     * An identifier for the router instance.
      */
-    protected pathMatcher: PathMatcher | undefined;
+    readonly id: number;
     /**
-     * Path matcher options.
-     *
-     * @protected
+     * A label for the router instance.
      */
-    protected pathMatcherOptions: PathMatcherOptions;
+    readonly name?: string;
     /**
-     * Is this the root instance?
+     * Array of mounted layers, routes & routers.
      *
      * @protected
      */
-    protected isRoot: boolean | undefined;
+    protected stack: (Router | Layer)[];
     /**
-     * Timeout before the router decides to abort the request.
+     * Path matcher for the current mount path.
      *
      * @protected
      */
-    protected timeout: number | undefined;
-    constructor(ctx?: RouterOptions);
-    setPathMatcherOptions(input: PathMatcherOptions): void;
-    setPath(value: Path): void;
-    createListener(): RequestListener;
-    listen(port: number): import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    protected pathMatcher: PathMatcher | undefined;
+    constructor(options?: RouterOptionsInput);
+    setPath(value?: Path): void;
     matchPath(path: string): boolean;
-    dispatch(req: Request, res: Response, meta?: DispatcherMeta, done?: Next): void;
-    dispatchAsync(req: Request, res: Response): Promise<void>;
-    route(path: Path): Route;
-    delete(path: Path, ...handlers: Handler[]): this;
-    get(path: Path, ...handlers: Handler[]): this;
-    post(path: Path, ...handlers: Handler[]): this;
-    put(path: Path, ...handlers: Handler[]): this;
-    patch(path: Path, ...handlers: Handler[]): this;
-    head(path: Path, ...handlers: Handler[]): this;
-    options(path: Path, ...handlers: Handler[]): this;
+    dispatch(event: DispatcherEvent, meta: DispatcherMeta): Promise<boolean>;
+    delete(handler: Handler): this;
+    delete(path: Path, handler: Handler): this;
+    get(handler: Handler): this;
+    get(path: Path, handler: Handler): this;
+    post(handler: Handler): this;
+    post(path: Path, handler: Handler): this;
+    put(handler: Handler): this;
+    put(path: Path, handler: Handler): this;
+    patch(handler: Handler): this;
+    patch(path: Path, handler: Handler): this;
+    head(handler: Handler): this;
+    head(path: Path, handler: Handler): this;
+    options(handler: Handler): this;
+    options(path: Path, handler: Handler): this;
     use(router: Router): this;
     use(handler: Handler): this;
-    use(handler: ErrorHandler): this;
     use(path: Path, router: Router): this;
     use(path: Path, handler: Handler): this;
-    use(path: Path, handler: ErrorHandler): this;
+    install<Options extends PluginOptions = PluginOptions>(plugin: Plugin<Options>, context: PluginInstallContext<Options> | Options): this;
+    uninstall(name: string): void;
 }

package/dist/router/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Router } from './module';
+export declare function generateRouterID(): number;
+export declare function isRouterInstance(input: unknown): input is Router;

package/dist/router-options/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './type';

package/dist/router-options/module.d.ts

@@ -0,0 +1,4 @@
+import type { RouterOptions } from './type';
+export declare function setRouterOptions(id: number, input: Partial<RouterOptions>): void;
+export declare function unsetRouterOptions(id: number): void;
+export declare function findRouterOption<K extends keyof RouterOptions>(key: K, path?: number[]): RouterOptions[K];

package/dist/router-options/transform.d.ts

@@ -0,0 +1,2 @@
+import type { RouterOptions, RouterOptionsInput } from './type';
+export declare function transformRouterOptions(input: RouterOptionsInput): Partial<RouterOptions>;

package/dist/router-options/type.d.ts

@@ -0,0 +1,41 @@
+import type { Path } from '../path';
+import type { EtagFn, EtagInput, TrustProxyFn, TrustProxyInput } from '../utils';
+export type RouterOptions = {
+    /**
+     * The path the router is mounted on.
+     *
+     * @type string
+     * @default '/'
+     */
+    path?: Path;
+    /**
+     * Name of the router.
+     */
+    name?: string;
+    /**
+     * default: 2
+     */
+    subdomainOffset: number;
+    /**
+     * default: 0
+     */
+    proxyIpMax: number;
+    /**
+     * default: () => true
+     */
+    etag: EtagFn;
+    /**
+     * default: () => false
+     */
+    trustProxy: TrustProxyFn;
+};
+export type RouterOptionsInput = Omit<Partial<RouterOptions>, 'etag' | 'trustProxy'> & {
+    /**
+     * default: true
+     */
+    etag?: EtagInput;
+    /**
+     * default: false
+     */
+    trustProxy?: TrustProxyInput;
+};

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Readable as NodeReadable } from 'node:stream';
+import type { Readable } from 'readable-stream';
+import type { ReadableStream } from 'stream/web';
+export type NodeReadableStream = NodeReadable | Readable;
+export type WebReadableStream = globalThis.ReadableStream | ReadableStream;
+export type WebResponse = globalThis.Response;
+export type WebRequest = globalThis.Request;
+export type WebBlob = globalThis.Blob;

package/dist/utils/cookie.d.ts

@@ -0,0 +1 @@
+export declare function splitCookiesString(input?: string | string[]): string[];

package/dist/utils/etag/module.d.ts

@@ -1,12 +1,13 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { Stats } from 'node:fs';
+import { Buffer } from 'buffer';
+import { type Stats } from 'node:fs';
 import type { EtagOptions } from './type';
 /**
  * Generate an ETag.
  */
-export declare function generateETag(input: string | Buffer | Stats): string;
+export declare function generateETag(input: string | Buffer | Stats): Promise<string>;
 /**
  * Create a simple ETag.
  */
-export declare function createEtag(input: string | Buffer | Stats, options?: EtagOptions): string;
+export declare function createEtag(input: string | Buffer | Stats, options?: EtagOptions): Promise<string>;