@visulima/connect 3.0.24 → 3.0.26

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+## @visulima/connect [3.0.26](https://github.com/visulima/visulima/compare/@visulima/connect@3.0.25...@visulima/connect@3.0.26) (2025-11-12)
+
+### Bug Fixes
+
+* update package configurations and TypeScript definitions ([b59aa59](https://github.com/visulima/visulima/commit/b59aa59dac1508216b944f4b917fb4a7ab1f70a4))
+
+### Miscellaneous Chores
+
+* Add jsr file to all packages for release ([#565](https://github.com/visulima/visulima/issues/565)) ([ec91652](https://github.com/visulima/visulima/commit/ec91652b4e4112adf14ba152c1239a7703ba425a))
+* update license files and clean up TypeScript definitions ([fe668cc](https://github.com/visulima/visulima/commit/fe668cc26de23591d4df54a0954455ebbe31b22d))
+
+## @visulima/connect [3.0.25](https://github.com/visulima/visulima/compare/@visulima/connect@3.0.24...@visulima/connect@3.0.25) (2025-11-07)
+
+### Bug Fixes
+
+* update TypeScript configurations and improve linting across multiple packages ([6f25ec7](https://github.com/visulima/visulima/commit/6f25ec7841da7246f8f9166efc5292a7089d37ee))
+
+### Miscellaneous Chores
+
+* update npm and pnpm configurations for monorepo optimization ([#564](https://github.com/visulima/visulima/issues/564)) ([5512b42](https://github.com/visulima/visulima/commit/5512b42f672c216b6a3c9e39035199a4ebd9a4b8))
+
 ## @visulima/connect [3.0.24](https://github.com/visulima/visulima/compare/@visulima/connect@3.0.23...@visulima/connect@3.0.24) (2025-11-05)
 
 ### Bug Fixes

package/dist/adapter/express.d.cts

@@ -0,0 +1,7 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RequestHandler } from "../node.d.cts";
+import type { Nextable } from "../types.d.d.cts";
+type NextFunction = (error?: any) => void;
+declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler<Request, Response>>;
+export type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
+export = expressWrapper;

package/dist/adapter/express.d.mts

@@ -0,0 +1,7 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RequestHandler } from "../node.d.mts";
+import type { Nextable } from "../types.d.d.mts";
+type NextFunction = (error?: any) => void;
+declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler<Request, Response>>;
+export type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
+export default expressWrapper;

package/dist/adapter/express.d.ts

@@ -0,0 +1,7 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RequestHandler } from "../node.d.ts";
+import type { Nextable } from "../types.d.d.ts";
+type NextFunction = (error?: any) => void;
+declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler<Request, Response>>;
+export type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
+export = expressWrapper;

package/dist/adapter/with-zod.d.cts

@@ -0,0 +1,8 @@
+import type { ZodObject } from "zod";
+import type { Nextable, NextHandler } from "../types.d.d.cts";
+declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
+    body?: ZodObject<any>;
+    headers?: ZodObject<any>;
+    query?: ZodObject<any>;
+}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
+export = withZod;

package/dist/adapter/with-zod.d.mts

@@ -0,0 +1,8 @@
+import type { ZodObject } from "zod";
+import type { Nextable, NextHandler } from "../types.d.d.mts";
+declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
+    body?: ZodObject<any>;
+    headers?: ZodObject<any>;
+    query?: ZodObject<any>;
+}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
+export default withZod;

package/dist/adapter/with-zod.d.ts

@@ -0,0 +1,8 @@
+import type { ZodObject } from "zod";
+import type { Nextable, NextHandler } from "../types.d.d.ts";
+declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
+    body?: ZodObject<any>;
+    headers?: ZodObject<any>;
+    query?: ZodObject<any>;
+}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
+export = withZod;

package/dist/edge.d.cts

@@ -0,0 +1,30 @@
+import type { ZodObject } from "zod";
+import type { Route } from "./router.d.cts";
+import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.cts";
+export declare const getPathname: (request: Request & {
+    nextUrl?: URL;
+}) => string;
+export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
+export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
+    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    private readonly onError;
+    private readonly onNoMatch;
+    private router;
+    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
+    clone(): EdgeRouter<R, Context, RResponse, Schema>;
+    handler(): (request: R, context_: Context) => Promise<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
+    run(request: R, context_: Context): Promise<unknown>;
+    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
+    private add;
+    private prepareRequest;
+}
+export declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;

package/dist/edge.d.mts

@@ -0,0 +1,30 @@
+import type { ZodObject } from "zod";
+import type { Route } from "./router.d.mts";
+import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.mts";
+export declare const getPathname: (request: Request & {
+    nextUrl?: URL;
+}) => string;
+export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
+export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
+    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    private readonly onError;
+    private readonly onNoMatch;
+    private router;
+    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
+    clone(): EdgeRouter<R, Context, RResponse, Schema>;
+    handler(): (request: R, context_: Context) => Promise<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
+    run(request: R, context_: Context): Promise<unknown>;
+    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
+    private add;
+    private prepareRequest;
+}
+export declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;

package/dist/edge.d.ts

@@ -0,0 +1,30 @@
+import type { ZodObject } from "zod";
+import type { Route } from "./router.d.ts";
+import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.ts";
+export declare const getPathname: (request: Request & {
+    nextUrl?: URL;
+}) => string;
+export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
+export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
+    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+    private readonly onError;
+    private readonly onNoMatch;
+    private router;
+    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
+    clone(): EdgeRouter<R, Context, RResponse, Schema>;
+    handler(): (request: R, context_: Context) => Promise<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
+    run(request: R, context_: Context): Promise<unknown>;
+    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
+    private add;
+    private prepareRequest;
+}
+export declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;

package/dist/index.cjs

@@ -1 +1,22 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const t=require("./packem_shared/expressWrapper-CnZ-5oTw.cjs"),o=require("./packem_shared/withZod-CvygheEk.cjs"),r=require("./packem_shared/EdgeRouter-KIBlNPX3.cjs"),e=require("./packem_shared/createRouter-CcKo5sWT.cjs"),u=require("./packem_shared/Router-fcD22mVn.cjs"),d=require("./packem_shared/sendJson-l4jM19lK.cjs");exports.expressWrapper=t;exports.withZod=o;exports.EdgeRouter=r.EdgeRouter;exports.createEdgeRouter=r.createEdgeRouter;exports.NodeRouter=e.NodeRouter;exports.createNodeRouter=e.createRouter;exports.createRouter=e.createRouter;exports.Router=u.Router;exports.sendJson=d;
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const expressWrapper = require('./packem_shared/expressWrapper-CTExfWvM.cjs');
+const withZod = require('./packem_shared/withZod-ULTsdyM5.cjs');
+const EdgeRouter = require('./packem_shared/EdgeRouter-B-e2l9un.cjs');
+const createRouter = require('./packem_shared/createRouter-C8hDVJcV.cjs');
+const Router = require('./packem_shared/Router-Eg_OPxIL.cjs');
+const sendJson = require('./packem_shared/sendJson-pJY2tT2n.cjs');
+
+
+
+exports.expressWrapper = expressWrapper;
+exports.withZod = withZod;
+exports.EdgeRouter = EdgeRouter.EdgeRouter;
+exports.createEdgeRouter = EdgeRouter.createEdgeRouter;
+exports.NodeRouter = createRouter.NodeRouter;
+exports.createNodeRouter = createRouter.createRouter;
+exports.createRouter = createRouter.createRouter;
+exports.Router = Router.Router;
+exports.sendJson = sendJson;

package/dist/index.d.cts

@@ -1,128 +1,12 @@
-import { IncomingMessage, ServerResponse } from 'node:http';
-import { AnyZodObject, ZodObject } from 'zod';
-
-type HttpMethod = "CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE";
-
-type FunctionLike = (...arguments_: any[]) => any;
-
-type RouteMatch = RegExp | string;
-
-type ValueOrPromise<T> = Promise<T> | T;
-
-type NextHandler = () => ValueOrPromise<any>;
-
-type Nextable<H extends FunctionLike> = (...arguments_: [...Parameters<H>, NextHandler]) => ValueOrPromise<any>;
-
-interface FindResult<H extends FunctionLike> {
-    fns: Nextable<H>[];
-    middleOnly: boolean;
-    params: Record<string, string>;
-}
-
-type RoutesExtendedRequestHandler<Request extends object, Context, RResponse, Routes> = (
-    request: Request,
-    response: Context,
-    routes: Routes,
-    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-) => ValueOrPromise<RResponse | void>;
-
-interface HandlerOptions<Handler extends FunctionLike> {
-    onError?: (error: unknown, ...arguments_: Parameters<Handler>) => ReturnType<Handler>;
-    onNoMatch?: Handler;
-}
-
-type RouteShortcutMethod<This, Schema extends AnyZodObject, H extends FunctionLike> = (
-    route: Nextable<H> | RouteMatch,
-    zodSchemaOrRouteOrFns?: Nextable<H> | RouteMatch | Schema | string,
-    ...fns: Nextable<H>[]
-) => This;
-
-type Route<H> = {
-    fns: (H | Router<H extends FunctionLike ? H : never>)[];
-    isMiddleware: boolean;
-    method: HttpMethod | "";
-} & ({
-    keys: string[] | false;
-    pattern: RegExp;
-} | {
-    matchAll: true;
-});
-declare class Router<H extends FunctionLike> {
-    base: string;
-    routes: Route<Nextable<H>>[];
-    static exec<FL extends FunctionLike>(fns: (Nextable<FL> | undefined)[], ...arguments_: Parameters<FL>): Promise<any>;
-    constructor(base?: string, routes?: Route<Nextable<H>>[]);
-    add(method: HttpMethod | "", route: Nextable<H> | RouteMatch, ...fns: Nextable<H>[]): this;
-    clone(base?: string): Router<H>;
-    find(method: HttpMethod, pathname: string): FindResult<H>;
-    use(base: Nextable<H> | RouteMatch | Router<H>, ...fns: (Nextable<H> | Router<H>)[]): this;
-}
-
-type RequestHandler$1<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends AnyZodObject = ZodObject<never>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
-    clone(): NodeRouter<Request, Response, Schema>;
-    handler(): (request: Request, response: Response) => Promise<void>;
-    run(request: Request, response: Response): Promise<unknown>;
-    use(base: Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
-    private add;
-    private prepareRequest;
-}
-declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends AnyZodObject = ZodObject<{
-    body?: AnyZodObject;
-    headers?: AnyZodObject;
-    query?: AnyZodObject;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
-
-type NextFunction = (error?: any) => void;
-declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler$1<Request, Response>>;
-type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
-
-declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
-    body?: AnyZodObject;
-    headers?: AnyZodObject;
-    query?: AnyZodObject;
-}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
-
-type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
-declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends AnyZodObject = ZodObject<any>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
-    clone(): EdgeRouter<R, Context, RResponse, Schema>;
-    handler(): (request: R, context_: Context) => Promise<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
-    run(request: R, context_: Context): Promise<unknown>;
-    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
-    private add;
-    private prepareRequest;
-}
-declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;
-
-declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
-
-export { EdgeRouter, NodeRouter, Router, createEdgeRouter, createRouter as createNodeRouter, createRouter, expressWrapper, sendJson, withZod };
-export type { RequestHandler as EdgeRequestHandler, ExpressRequestHandler, FindResult, FunctionLike, HandlerOptions, HttpMethod, NextHandler, Nextable, RequestHandler$1 as NodeRequestHandler, Route, RouteShortcutMethod, ValueOrPromise };
+export type { ExpressRequestHandler } from "./adapter/express.d.cts";
+export { default as expressWrapper } from "./adapter/express.d.cts";
+export { default as withZod } from "./adapter/with-zod.d.cts";
+export type { RequestHandler as EdgeRequestHandler } from "./edge.d.cts";
+export { createEdgeRouter, EdgeRouter } from "./edge.d.cts";
+export type { RequestHandler as NodeRequestHandler } from "./node.d.cts";
+export { createRouter } from "./node.d.cts";
+export { createRouter as createNodeRouter, NodeRouter } from "./node.d.cts";
+export type { Route } from "./router.d.cts";
+export { Router } from "./router.d.cts";
+export type { FindResult, FunctionLike, HandlerOptions, HttpMethod, Nextable, NextHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.cts";
+export { default as sendJson } from "./utils/send-json.d.cts";

package/dist/index.d.mts

@@ -1,128 +1,12 @@
-import { IncomingMessage, ServerResponse } from 'node:http';
-import { AnyZodObject, ZodObject } from 'zod';
-
-type HttpMethod = "CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE";
-
-type FunctionLike = (...arguments_: any[]) => any;
-
-type RouteMatch = RegExp | string;
-
-type ValueOrPromise<T> = Promise<T> | T;
-
-type NextHandler = () => ValueOrPromise<any>;
-
-type Nextable<H extends FunctionLike> = (...arguments_: [...Parameters<H>, NextHandler]) => ValueOrPromise<any>;
-
-interface FindResult<H extends FunctionLike> {
-    fns: Nextable<H>[];
-    middleOnly: boolean;
-    params: Record<string, string>;
-}
-
-type RoutesExtendedRequestHandler<Request extends object, Context, RResponse, Routes> = (
-    request: Request,
-    response: Context,
-    routes: Routes,
-    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-) => ValueOrPromise<RResponse | void>;
-
-interface HandlerOptions<Handler extends FunctionLike> {
-    onError?: (error: unknown, ...arguments_: Parameters<Handler>) => ReturnType<Handler>;
-    onNoMatch?: Handler;
-}
-
-type RouteShortcutMethod<This, Schema extends AnyZodObject, H extends FunctionLike> = (
-    route: Nextable<H> | RouteMatch,
-    zodSchemaOrRouteOrFns?: Nextable<H> | RouteMatch | Schema | string,
-    ...fns: Nextable<H>[]
-) => This;
-
-type Route<H> = {
-    fns: (H | Router<H extends FunctionLike ? H : never>)[];
-    isMiddleware: boolean;
-    method: HttpMethod | "";
-} & ({
-    keys: string[] | false;
-    pattern: RegExp;
-} | {
-    matchAll: true;
-});
-declare class Router<H extends FunctionLike> {
-    base: string;
-    routes: Route<Nextable<H>>[];
-    static exec<FL extends FunctionLike>(fns: (Nextable<FL> | undefined)[], ...arguments_: Parameters<FL>): Promise<any>;
-    constructor(base?: string, routes?: Route<Nextable<H>>[]);
-    add(method: HttpMethod | "", route: Nextable<H> | RouteMatch, ...fns: Nextable<H>[]): this;
-    clone(base?: string): Router<H>;
-    find(method: HttpMethod, pathname: string): FindResult<H>;
-    use(base: Nextable<H> | RouteMatch | Router<H>, ...fns: (Nextable<H> | Router<H>)[]): this;
-}
-
-type RequestHandler$1<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends AnyZodObject = ZodObject<never>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
-    clone(): NodeRouter<Request, Response, Schema>;
-    handler(): (request: Request, response: Response) => Promise<void>;
-    run(request: Request, response: Response): Promise<unknown>;
-    use(base: Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
-    private add;
-    private prepareRequest;
-}
-declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends AnyZodObject = ZodObject<{
-    body?: AnyZodObject;
-    headers?: AnyZodObject;
-    query?: AnyZodObject;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
-
-type NextFunction = (error?: any) => void;
-declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler$1<Request, Response>>;
-type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
-
-declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
-    body?: AnyZodObject;
-    headers?: AnyZodObject;
-    query?: AnyZodObject;
-}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
-
-type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
-declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends AnyZodObject = ZodObject<any>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
-    clone(): EdgeRouter<R, Context, RResponse, Schema>;
-    handler(): (request: R, context_: Context) => Promise<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
-    run(request: R, context_: Context): Promise<unknown>;
-    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
-    private add;
-    private prepareRequest;
-}
-declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;
-
-declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
-
-export { EdgeRouter, NodeRouter, Router, createEdgeRouter, createRouter as createNodeRouter, createRouter, expressWrapper, sendJson, withZod };
-export type { RequestHandler as EdgeRequestHandler, ExpressRequestHandler, FindResult, FunctionLike, HandlerOptions, HttpMethod, NextHandler, Nextable, RequestHandler$1 as NodeRequestHandler, Route, RouteShortcutMethod, ValueOrPromise };
+export type { ExpressRequestHandler } from "./adapter/express.d.mts";
+export { default as expressWrapper } from "./adapter/express.d.mts";
+export { default as withZod } from "./adapter/with-zod.d.mts";
+export type { RequestHandler as EdgeRequestHandler } from "./edge.d.mts";
+export { createEdgeRouter, EdgeRouter } from "./edge.d.mts";
+export type { RequestHandler as NodeRequestHandler } from "./node.d.mts";
+export { createRouter } from "./node.d.mts";
+export { createRouter as createNodeRouter, NodeRouter } from "./node.d.mts";
+export type { Route } from "./router.d.mts";
+export { Router } from "./router.d.mts";
+export type { FindResult, FunctionLike, HandlerOptions, HttpMethod, Nextable, NextHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.mts";
+export { default as sendJson } from "./utils/send-json.d.mts";

package/dist/index.d.ts

@@ -1,128 +1,12 @@
-import { IncomingMessage, ServerResponse } from 'node:http';
-import { AnyZodObject, ZodObject } from 'zod';
-
-type HttpMethod = "CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE";
-
-type FunctionLike = (...arguments_: any[]) => any;
-
-type RouteMatch = RegExp | string;
-
-type ValueOrPromise<T> = Promise<T> | T;
-
-type NextHandler = () => ValueOrPromise<any>;
-
-type Nextable<H extends FunctionLike> = (...arguments_: [...Parameters<H>, NextHandler]) => ValueOrPromise<any>;
-
-interface FindResult<H extends FunctionLike> {
-    fns: Nextable<H>[];
-    middleOnly: boolean;
-    params: Record<string, string>;
-}
-
-type RoutesExtendedRequestHandler<Request extends object, Context, RResponse, Routes> = (
-    request: Request,
-    response: Context,
-    routes: Routes,
-    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-) => ValueOrPromise<RResponse | void>;
-
-interface HandlerOptions<Handler extends FunctionLike> {
-    onError?: (error: unknown, ...arguments_: Parameters<Handler>) => ReturnType<Handler>;
-    onNoMatch?: Handler;
-}
-
-type RouteShortcutMethod<This, Schema extends AnyZodObject, H extends FunctionLike> = (
-    route: Nextable<H> | RouteMatch,
-    zodSchemaOrRouteOrFns?: Nextable<H> | RouteMatch | Schema | string,
-    ...fns: Nextable<H>[]
-) => This;
-
-type Route<H> = {
-    fns: (H | Router<H extends FunctionLike ? H : never>)[];
-    isMiddleware: boolean;
-    method: HttpMethod | "";
-} & ({
-    keys: string[] | false;
-    pattern: RegExp;
-} | {
-    matchAll: true;
-});
-declare class Router<H extends FunctionLike> {
-    base: string;
-    routes: Route<Nextable<H>>[];
-    static exec<FL extends FunctionLike>(fns: (Nextable<FL> | undefined)[], ...arguments_: Parameters<FL>): Promise<any>;
-    constructor(base?: string, routes?: Route<Nextable<H>>[]);
-    add(method: HttpMethod | "", route: Nextable<H> | RouteMatch, ...fns: Nextable<H>[]): this;
-    clone(base?: string): Router<H>;
-    find(method: HttpMethod, pathname: string): FindResult<H>;
-    use(base: Nextable<H> | RouteMatch | Router<H>, ...fns: (Nextable<H> | Router<H>)[]): this;
-}
-
-type RequestHandler$1<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends AnyZodObject = ZodObject<never>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
-    clone(): NodeRouter<Request, Response, Schema>;
-    handler(): (request: Request, response: Response) => Promise<void>;
-    run(request: Request, response: Response): Promise<unknown>;
-    use(base: Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
-    private add;
-    private prepareRequest;
-}
-declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends AnyZodObject = ZodObject<{
-    body?: AnyZodObject;
-    headers?: AnyZodObject;
-    query?: AnyZodObject;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
-
-type NextFunction = (error?: any) => void;
-declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler$1<Request, Response>>;
-type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
-
-declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
-    body?: AnyZodObject;
-    headers?: AnyZodObject;
-    query?: AnyZodObject;
-}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
-
-type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
-declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends AnyZodObject = ZodObject<any>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
-    clone(): EdgeRouter<R, Context, RResponse, Schema>;
-    handler(): (request: R, context_: Context) => Promise<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
-    run(request: R, context_: Context): Promise<unknown>;
-    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
-    private add;
-    private prepareRequest;
-}
-declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;
-
-declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
-
-export { EdgeRouter, NodeRouter, Router, createEdgeRouter, createRouter as createNodeRouter, createRouter, expressWrapper, sendJson, withZod };
-export type { RequestHandler as EdgeRequestHandler, ExpressRequestHandler, FindResult, FunctionLike, HandlerOptions, HttpMethod, NextHandler, Nextable, RequestHandler$1 as NodeRequestHandler, Route, RouteShortcutMethod, ValueOrPromise };
+export type { ExpressRequestHandler } from "./adapter/express.d.ts";
+export { default as expressWrapper } from "./adapter/express.d.ts";
+export { default as withZod } from "./adapter/with-zod.d.ts";
+export type { RequestHandler as EdgeRequestHandler } from "./edge.d.ts";
+export { createEdgeRouter, EdgeRouter } from "./edge.d.ts";
+export type { RequestHandler as NodeRequestHandler } from "./node.d.ts";
+export { createRouter } from "./node.d.ts";
+export { createRouter as createNodeRouter, NodeRouter } from "./node.d.ts";
+export type { Route } from "./router.d.ts";
+export { Router } from "./router.d.ts";
+export type { FindResult, FunctionLike, HandlerOptions, HttpMethod, Nextable, NextHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.ts";
+export { default as sendJson } from "./utils/send-json.d.ts";