@visulima/connect 4.0.0-alpha.6 → 4.0.0-alpha.8

package/CHANGELOG.md

@@ -1,3 +1,28 @@
+## @visulima/connect [4.0.0-alpha.8](https://github.com/visulima/visulima/compare/@visulima/connect@4.0.0-alpha.7...@visulima/connect@4.0.0-alpha.8) (2026-04-08)
+
+### Bug Fixes
+
+* **connect:** properly fix eslint errors in code ([5266ef1](https://github.com/visulima/visulima/commit/5266ef1ee416732409b8bff352247fc972929634))
+* **connect:** remove remaining eslint suppressions with proper code fixes ([bc69936](https://github.com/visulima/visulima/commit/bc69936bd0508def799d95a1772a5792fb57949c))
+* **connect:** resolve eslint errors ([49abc96](https://github.com/visulima/visulima/commit/49abc96b7cccbedb47507adda539cdf715dfc7a9))
+
+### Miscellaneous Chores
+
+* **api:** remove empty dependency objects from package.json ([f6bfc85](https://github.com/visulima/visulima/commit/f6bfc85c48c973ff8ea0a7db5951794ae0ea3efb))
+* **connect:** add tsconfig.eslint.json for type-aware linting ([d8e6ae1](https://github.com/visulima/visulima/commit/d8e6ae1cfe5ce82d228054feb35b7fa4a4503211))
+* **connect:** apply prettier formatting ([8ecf930](https://github.com/visulima/visulima/commit/8ecf93071cb0087a8c49520cc594a753dba5e39d))
+* **connect:** migrate .prettierrc.cjs to prettier.config.js ([949d441](https://github.com/visulima/visulima/commit/949d44166d9ce6f66044d87eb0bdd0a8b85c03ed))
+
+## @visulima/connect [4.0.0-alpha.7](https://github.com/visulima/visulima/compare/@visulima/connect@4.0.0-alpha.6...@visulima/connect@4.0.0-alpha.7) (2026-03-26)
+
+### Features
+
+* **web:** auto-generate packages page from workspace metadata ([623e520](https://github.com/visulima/visulima/commit/623e5207693a7fe720f5f2f179593a3654c880e3))
+
+### Miscellaneous Chores
+
+* update homepage URLs to visulima.com/packages/ format ([be42968](https://github.com/visulima/visulima/commit/be42968129df85fb074224435e33135ff44cab91))
+
 ## @visulima/connect [4.0.0-alpha.6](https://github.com/visulima/visulima/compare/@visulima/connect@4.0.0-alpha.5...@visulima/connect@4.0.0-alpha.6) (2026-03-26)
 
 ### Bug Fixes

package/dist/adapter/express.d.cts

@@ -1,7 +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;
+type NextFunction = (error?: Error) => 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

@@ -1,7 +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;
+type NextFunction = (error?: Error) => 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

@@ -1,7 +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;
+type NextFunction = (error?: Error) => 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

@@ -1,8 +1,4 @@
-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>;
+import * as z from "zod";
+import type { FunctionLike, Nextable, NextHandler } from "../types.d.d.cts";
+declare const withZod: (schema: z.ZodObject<any>, handler: Nextable<FunctionLike>) => (request: unknown, response: unknown, next: NextHandler) => Promise<unknown>;
 export = withZod;

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

@@ -1,8 +1,4 @@
-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>;
+import * as z from "zod";
+import type { FunctionLike, Nextable, NextHandler } from "../types.d.d.mts";
+declare const withZod: (schema: z.ZodObject<any>, handler: Nextable<FunctionLike>) => (request: unknown, response: unknown, next: NextHandler) => Promise<unknown>;
 export default withZod;

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

@@ -1,8 +1,4 @@
-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>;
+import * as z from "zod";
+import type { FunctionLike, Nextable, NextHandler } from "../types.d.d.ts";
+declare const withZod: (schema: z.ZodObject<any>, handler: Nextable<FunctionLike>) => (request: unknown, response: unknown, next: NextHandler) => Promise<unknown>;
 export = withZod;

package/dist/edge.d.cts

@@ -1,11 +1,12 @@
-import type { ZodObject } from "zod";
+import type * as z 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>> {
+export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | undefined>;
+export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+    private static prepareRequest;
     all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
     connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
     delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
@@ -21,10 +22,9 @@ export declare class EdgeRouter<R extends Request = Request, Context = unknown,
     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>;
+    handler(): (request: R, context_: Context) => Promise<RResponse | undefined>;
     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

@@ -1,11 +1,12 @@
-import type { ZodObject } from "zod";
+import type * as z 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>> {
+export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | undefined>;
+export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+    private static prepareRequest;
     all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
     connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
     delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
@@ -21,10 +22,9 @@ export declare class EdgeRouter<R extends Request = Request, Context = unknown,
     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>;
+    handler(): (request: R, context_: Context) => Promise<RResponse | undefined>;
     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

@@ -1,11 +1,12 @@
-import type { ZodObject } from "zod";
+import type * as z 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>> {
+export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | undefined>;
+export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+    private static prepareRequest;
     all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
     connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
     delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
@@ -21,10 +22,9 @@ export declare class EdgeRouter<R extends Request = Request, Context = unknown,
     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>;
+    handler(): (request: R, context_: Context) => Promise<RResponse | undefined>;
     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

@@ -2,12 +2,12 @@
 
 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');
+const expressWrapper = require('./packem_shared/expressWrapper-oEj2tv9s.cjs');
+const withZod = require('./packem_shared/withZod-hpoT0ByV.cjs');
+const EdgeRouter = require('./packem_shared/EdgeRouter-Dx7Q5duD.cjs');
+const createRouter = require('./packem_shared/createRouter-D-kQjdxT.cjs');
+const Router = require('./packem_shared/Router-DMp6zIkp.cjs');
+const sendJson = require('./packem_shared/sendJson-DjC80Qht.cjs');
 
 
 

package/dist/index.mjs

@@ -1,6 +1,6 @@
-export { default as expressWrapper } from './packem_shared/expressWrapper-spfs58is.mjs';
-export { default as withZod } from './packem_shared/withZod-HYgoC7AX.mjs';
-export { EdgeRouter, createEdgeRouter } from './packem_shared/EdgeRouter-CdtQHTwm.mjs';
-export { NodeRouter, createRouter as createNodeRouter, createRouter } from './packem_shared/createRouter-_G1XhaP4.mjs';
-export { Router } from './packem_shared/Router-ChnTdYfl.mjs';
-export { default as sendJson } from './packem_shared/sendJson-DwLYLDbt.mjs';
+export { default as expressWrapper } from './packem_shared/expressWrapper-CeTFmeNH.mjs';
+export { default as withZod } from './packem_shared/withZod-DMHxmHJB.mjs';
+export { EdgeRouter, createEdgeRouter } from './packem_shared/EdgeRouter-x-Px7BEe.mjs';
+export { NodeRouter, createRouter as createNodeRouter, createRouter } from './packem_shared/createRouter-BRGcdDwj.mjs';
+export { Router } from './packem_shared/Router-CT_g_29S.mjs';
+export { default as sendJson } from './packem_shared/sendJson-Cd6CsJC_.mjs';

package/dist/node.d.cts

@@ -1,10 +1,11 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ZodObject } from "zod";
+import type * as z 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: (url: string) => string;
 export type RequestHandler<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends ZodObject<any> = ZodObject<never>> {
+export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+    private static prepareRequest;
     all: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
     connect: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
     delete: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
@@ -24,10 +25,5 @@ export declare class NodeRouter<Request extends IncomingMessage = IncomingMessag
     run(request: Request, response: Response): Promise<unknown>;
     use(base: Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
     private add;
-    private prepareRequest;
 }
-export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
+export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;

package/dist/node.d.mts

@@ -1,10 +1,11 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ZodObject } from "zod";
+import type * as z 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: (url: string) => string;
 export type RequestHandler<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends ZodObject<any> = ZodObject<never>> {
+export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+    private static prepareRequest;
     all: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
     connect: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
     delete: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
@@ -24,10 +25,5 @@ export declare class NodeRouter<Request extends IncomingMessage = IncomingMessag
     run(request: Request, response: Response): Promise<unknown>;
     use(base: Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
     private add;
-    private prepareRequest;
 }
-export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
+export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;

package/dist/node.d.ts

@@ -1,10 +1,11 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ZodObject } from "zod";
+import type * as z 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: (url: string) => string;
 export type RequestHandler<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends ZodObject<any> = ZodObject<never>> {
+export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+    private static prepareRequest;
     all: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
     connect: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
     delete: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
@@ -24,10 +25,5 @@ export declare class NodeRouter<Request extends IncomingMessage = IncomingMessag
     run(request: Request, response: Response): Promise<unknown>;
     use(base: Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
     private add;
-    private prepareRequest;
 }
-export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
+export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;

package/dist/packem_shared/{EdgeRouter-B-e2l9un.cjs → EdgeRouter-Dx7Q5duD.cjs}

@@ -2,19 +2,23 @@
 
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
-const withZod = require('./withZod-ULTsdyM5.cjs');
-const Router = require('./Router-Eg_OPxIL.cjs');
+const withZod = require('./withZod-hpoT0ByV.cjs');
+const Router = require('./Router-DMp6zIkp.cjs');
 
-const onNoMatch = async (request) => new Response(request.method === "HEAD" ? null : `Route ${request.method} ${request.url} not found`, { status: 404 });
-const onError = async (error) => {
-  console.error(error);
+const onNoMatch = (request) => new Response(request.method === "HEAD" ? void 0 : `Route ${request.method} ${request.url} not found`, { status: 404 });
+const onError = (error) => {
+  globalThis.console.error(error);
   return new Response("Internal Server Error", { status: 500 });
 };
-const getPathname = (request) => (
-  // eslint-disable-next-line compat/compat
-  (request.nextUrl ?? new URL(request.url)).pathname
-);
+const getPathname = (request) => (request.nextUrl ?? new URL(request.url)).pathname;
 class EdgeRouter {
+  static prepareRequest(request, findResult) {
+    request.params = {
+      ...findResult.params,
+      ...request.params
+      // original params will take precedence
+    };
+  }
   all = this.add.bind(this, "");
   connect = this.add.bind(this, "CONNECT");
   delete = this.add.bind(this, "DELETE");
@@ -40,8 +44,10 @@ class EdgeRouter {
   handler() {
     const { routes } = this.router;
     return async (request, context_) => {
-      const result = this.router.find(request.method, getPathname(request));
-      this.prepareRequest(request, result);
+      const pathname = getPathname(request);
+      const method = request.method;
+      const result = this.router.find(method, pathname);
+      EdgeRouter.prepareRequest(request, result);
       try {
         return await (result.fns.length === 0 || result.middleOnly ? this.onNoMatch(request, context_, routes) : Router.Router.exec(result.fns, request, context_));
       } catch (error) {
@@ -50,44 +56,45 @@ class EdgeRouter {
     };
   }
   async run(request, context_) {
-    const result = this.router.find(request.method, getPathname(request));
+    const pathname = getPathname(request);
+    const method = request.method;
+    const result = this.router.find(method, pathname);
     if (result.fns.length === 0) {
-      return;
+      return void 0;
     }
-    this.prepareRequest(request, result);
-    return await Router.Router.exec(result.fns, request, context_);
+    EdgeRouter.prepareRequest(request, result);
+    return Router.Router.exec(result.fns, request, context_);
   }
   use(base, ...fns) {
+    let resolvedBase;
     if (typeof base === "function" || base instanceof EdgeRouter) {
       fns.unshift(base);
-      base = "/";
+      resolvedBase = "/";
+    } else {
+      resolvedBase = base;
     }
-    this.router.use(base, ...fns.map((function_) => function_ instanceof EdgeRouter ? function_.router : function_));
+    this.router.use(resolvedBase, ...fns.map((function_) => {
+      if (function_ instanceof EdgeRouter) {
+        return function_.router;
+      }
+      return function_;
+    }));
     return this;
   }
   add(method, routeOrFunction, zodOrRouteOrFunction, ...fns) {
+    let resolvedFns;
     if (typeof routeOrFunction === "string" && typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
     } else if (typeof zodOrRouteOrFunction === "object") {
-      if (typeof routeOrFunction === "function") {
-        fns = [withZod(zodOrRouteOrFunction, routeOrFunction)];
-      } else {
-        fns = fns.map((function_) => withZod(zodOrRouteOrFunction, function_));
-      }
+      resolvedFns = typeof routeOrFunction === "function" ? [withZod(zodOrRouteOrFunction, routeOrFunction)] : fns.map((function_) => withZod(zodOrRouteOrFunction, function_));
     } else if (typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
+    } else {
+      resolvedFns = fns;
     }
-    this.router.add(method, routeOrFunction, ...fns);
+    this.router.add(method, routeOrFunction, ...resolvedFns);
     return this;
   }
-  // eslint-disable-next-line class-methods-use-this
-  prepareRequest(request, findResult) {
-    request.params = {
-      ...findResult.params,
-      ...request.params
-      // original params will take precedence
-    };
-  }
 }
 const createEdgeRouter = (options = {}) => new EdgeRouter(options);
 

package/dist/packem_shared/{EdgeRouter-CdtQHTwm.mjs → EdgeRouter-x-Px7BEe.mjs}

@@ -1,16 +1,20 @@
-import withZod from './withZod-HYgoC7AX.mjs';
-import { Router } from './Router-ChnTdYfl.mjs';
+import withZod from './withZod-DMHxmHJB.mjs';
+import { Router } from './Router-CT_g_29S.mjs';
 
-const onNoMatch = async (request) => new Response(request.method === "HEAD" ? null : `Route ${request.method} ${request.url} not found`, { status: 404 });
-const onError = async (error) => {
-  console.error(error);
+const onNoMatch = (request) => new Response(request.method === "HEAD" ? void 0 : `Route ${request.method} ${request.url} not found`, { status: 404 });
+const onError = (error) => {
+  globalThis.console.error(error);
   return new Response("Internal Server Error", { status: 500 });
 };
-const getPathname = (request) => (
-  // eslint-disable-next-line compat/compat
-  (request.nextUrl ?? new URL(request.url)).pathname
-);
+const getPathname = (request) => (request.nextUrl ?? new URL(request.url)).pathname;
 class EdgeRouter {
+  static prepareRequest(request, findResult) {
+    request.params = {
+      ...findResult.params,
+      ...request.params
+      // original params will take precedence
+    };
+  }
   all = this.add.bind(this, "");
   connect = this.add.bind(this, "CONNECT");
   delete = this.add.bind(this, "DELETE");
@@ -36,8 +40,10 @@ class EdgeRouter {
   handler() {
     const { routes } = this.router;
     return async (request, context_) => {
-      const result = this.router.find(request.method, getPathname(request));
-      this.prepareRequest(request, result);
+      const pathname = getPathname(request);
+      const method = request.method;
+      const result = this.router.find(method, pathname);
+      EdgeRouter.prepareRequest(request, result);
       try {
         return await (result.fns.length === 0 || result.middleOnly ? this.onNoMatch(request, context_, routes) : Router.exec(result.fns, request, context_));
       } catch (error) {
@@ -46,44 +52,45 @@ class EdgeRouter {
     };
   }
   async run(request, context_) {
-    const result = this.router.find(request.method, getPathname(request));
+    const pathname = getPathname(request);
+    const method = request.method;
+    const result = this.router.find(method, pathname);
     if (result.fns.length === 0) {
-      return;
+      return void 0;
     }
-    this.prepareRequest(request, result);
-    return await Router.exec(result.fns, request, context_);
+    EdgeRouter.prepareRequest(request, result);
+    return Router.exec(result.fns, request, context_);
   }
   use(base, ...fns) {
+    let resolvedBase;
     if (typeof base === "function" || base instanceof EdgeRouter) {
       fns.unshift(base);
-      base = "/";
+      resolvedBase = "/";
+    } else {
+      resolvedBase = base;
     }
-    this.router.use(base, ...fns.map((function_) => function_ instanceof EdgeRouter ? function_.router : function_));
+    this.router.use(resolvedBase, ...fns.map((function_) => {
+      if (function_ instanceof EdgeRouter) {
+        return function_.router;
+      }
+      return function_;
+    }));
     return this;
   }
   add(method, routeOrFunction, zodOrRouteOrFunction, ...fns) {
+    let resolvedFns;
     if (typeof routeOrFunction === "string" && typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
     } else if (typeof zodOrRouteOrFunction === "object") {
-      if (typeof routeOrFunction === "function") {
-        fns = [withZod(zodOrRouteOrFunction, routeOrFunction)];
-      } else {
-        fns = fns.map((function_) => withZod(zodOrRouteOrFunction, function_));
-      }
+      resolvedFns = typeof routeOrFunction === "function" ? [withZod(zodOrRouteOrFunction, routeOrFunction)] : fns.map((function_) => withZod(zodOrRouteOrFunction, function_));
     } else if (typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
+    } else {
+      resolvedFns = fns;
     }
-    this.router.add(method, routeOrFunction, ...fns);
+    this.router.add(method, routeOrFunction, ...resolvedFns);
     return this;
   }
-  // eslint-disable-next-line class-methods-use-this
-  prepareRequest(request, findResult) {
-    request.params = {
-      ...findResult.params,
-      ...request.params
-      // original params will take precedence
-    };
-  }
 }
 const createEdgeRouter = (options = {}) => new EdgeRouter(options);