style: format with prettier v3

src/adapters/node.ts

@@ -14,39 +14,39 @@ export type {
 } from "node:http";
 export type NodeListener = (
   req: NodeIncomingMessage,
-  res: NodeServerResponse
+  res: NodeServerResponse,
 ) => void;
 export type NodePromisifiedHandler = (
   req: NodeIncomingMessage,
-  res: NodeServerResponse
+  res: NodeServerResponse,
 ) => Promise<any>;
 export type NodeMiddleware = (
   req: NodeIncomingMessage,
   res: NodeServerResponse,
-  next: (err?: Error) => any
+  next: (err?: Error) => any,
 ) => any;
 
 export const defineNodeListener = (handler: NodeListener) => handler;
 
 export const defineNodeMiddleware = (middleware: NodeMiddleware) => middleware;
 
 export function fromNodeMiddleware(
-  handler: NodeListener | NodeMiddleware
+  handler: NodeListener | NodeMiddleware,
 ): EventHandler {
   if (isEventHandler(handler)) {
     return handler;
   }
   if (typeof handler !== "function") {
     throw new (TypeError as any)(
       "Invalid handler. It should be a function:",
-      handler
+      handler,
     );
   }
   return eventHandler((event) => {
     return callNodeListener(
       handler,
       event.node.req as NodeIncomingMessage,
-      event.node.res
+      event.node.res,
     ) as EventHandlerResponse;
   });
 }
@@ -78,7 +78,7 @@ export function toNodeListener(app: App): NodeListener {
 }
 
 export function promisifyNodeListener(
-  handler: NodeListener | NodeMiddleware
+  handler: NodeListener | NodeMiddleware,
 ): NodePromisifiedHandler {
   return function (req: NodeIncomingMessage, res: NodeServerResponse) {
     return callNodeListener(handler, req, res);
@@ -88,7 +88,7 @@ export function promisifyNodeListener(
 export function callNodeListener(
   handler: NodeMiddleware,
   req: NodeIncomingMessage,
-  res: NodeServerResponse
+  res: NodeServerResponse,
 ) {
   const isMiddleware = handler.length > 2;
   return new Promise((resolve, reject) => {

src/adapters/plain.ts

@@ -97,7 +97,7 @@ export async function _handlePlainRequest(app: App, request: PlainRequest) {
 }
 
 function _normalizeUnenvHeaders(
-  input: Record<string, undefined | string | number | string[]>
+  input: Record<string, undefined | string | number | string[]>,
 ) {
   const headers: [string, string][] = [];
   const cookies: string[] = [];
@@ -107,7 +107,7 @@ function _normalizeUnenvHeaders(
 
     if (key === "set-cookie") {
       cookies.push(
-        ...splitCookiesString(input["set-cookie"] as string | string[])
+        ...splitCookiesString(input["set-cookie"] as string | string[]),
       );
       continue;
     }

src/adapters/web.ts

@@ -3,7 +3,7 @@ import { _handlePlainRequest } from "./plain";
 
 export type WebHandler = (
   request: Request,
-  context?: Record<string, unknown>
+  context?: Record<string, unknown>,
 ) => Promise<Response>;
 
 /** @experimental */
@@ -20,7 +20,7 @@ export function toWebHandler(app: App) {
 async function _handleWebRequest(
   app: App,
   request: Request,
-  context?: Record<string, unknown>
+  context?: Record<string, unknown>,
 ) {
   const url = new URL(request.url);
   const res = await _handlePlainRequest(app, {

src/app.ts

@@ -40,7 +40,7 @@ export interface AppUse {
   (
     route: string | string[],
     handler: EventHandler | EventHandler[],
-    options?: Partial<InputLayer>
+    options?: Partial<InputLayer>,
   ): App;
   (handler: EventHandler | EventHandler[], options?: Partial<InputLayer>): App;
   (options: InputLayer): App;
@@ -52,11 +52,11 @@ export interface AppOptions {
   onRequest?: (event: H3Event) => void | Promise<void>;
   onBeforeResponse?: (
     event: H3Event,
-    response: { body?: unknown }
+    response: { body?: unknown },
   ) => void | Promise<void>;
   onAfterResponse?: (
     event: H3Event,
-    response?: { body?: unknown }
+    response?: { body?: unknown },
   ) => void | Promise<void>;
 }
 
@@ -84,7 +84,7 @@ export function use(
   app: App,
   arg1: string | EventHandler | InputLayer | InputLayer[],
   arg2?: Partial<InputLayer> | EventHandler | EventHandler[],
-  arg3?: Partial<InputLayer>
+  arg3?: Partial<InputLayer>,
 ) {
   if (Array.isArray(arg1)) {
     for (const i of arg1) {
@@ -96,11 +96,11 @@ export function use(
     }
   } else if (typeof arg1 === "string") {
     app.stack.push(
-      normalizeLayer({ ...arg3, route: arg1, handler: arg2 as EventHandler })
+      normalizeLayer({ ...arg3, route: arg1, handler: arg2 as EventHandler }),
     );
   } else if (typeof arg1 === "function") {
     app.stack.push(
-      normalizeLayer({ ...arg2, route: "/", handler: arg1 as EventHandler })
+      normalizeLayer({ ...arg2, route: "/", handler: arg1 as EventHandler }),
     );
   } else {
     app.stack.push(normalizeLayer({ ...arg1 }));

src/error.ts

@@ -64,7 +64,7 @@ export class H3Error extends Error {
  * @return {H3Error} - An instance of H3Error.
  */
 export function createError(
-  input: string | (Partial<H3Error> & { status?: number; statusText?: string })
+  input: string | (Partial<H3Error> & { status?: number; statusText?: string }),
 ): H3Error {
   if (typeof input === "string") {
     return new H3Error(input);
@@ -112,7 +112,7 @@ export function createError(
     const sanitizedMessage = sanitizeStatusMessage(err.statusMessage);
     if (sanitizedMessage !== originalMessage) {
       console.warn(
-        "[h3] Please prefer using `message` for longer error messages instead of `statusMessage`. In the future, `statusMessage` will be sanitized by default."
+        "[h3] Please prefer using `message` for longer error messages instead of `statusMessage`. In the future, `statusMessage` will be sanitized by default.",
       );
     }
   }
@@ -140,7 +140,7 @@ export function createError(
 export function sendError(
   event: H3Event,
   error: Error | H3Error,
-  debug?: boolean
+  debug?: boolean,
 ) {
   if (event.handled) {
     return;

src/event/event.ts

@@ -18,7 +18,7 @@ export interface NodeEventContext {
 
 export class H3Event<
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  _RequestT extends EventHandlerRequest = EventHandlerRequest
+  _RequestT extends EventHandlerRequest = EventHandlerRequest,
 > implements Pick<FetchEvent, "respondWith">
 {
   "__is_event__" = true;
@@ -131,7 +131,7 @@ export class H3Event<
 
   respondWith(response: Response | PromiseLike<Response>): Promise<void> {
     return Promise.resolve(response).then((_response) =>
-      sendWebResponse(this, _response)
+      sendWebResponse(this, _response),
     );
   }
 }
@@ -142,7 +142,7 @@ export function isEvent(input: any): input is H3Event {
 
 export function createEvent(
   req: NodeIncomingMessage,
-  res: NodeServerResponse
+  res: NodeServerResponse,
 ): H3Event {
   return new H3Event(req, res);
 }

src/event/polyfills/headers.ts

@@ -10,13 +10,13 @@ export class H3Headers implements Headers {
       this._headers = {};
     } else if (Array.isArray(init)) {
       this._headers = Object.fromEntries(
-        init.map(([key, value]) => [key.toLowerCase(), value])
+        init.map(([key, value]) => [key.toLowerCase(), value]),
       );
     } else if (init && "append" in init) {
       this._headers = Object.fromEntries((init as any).entries());
     } else {
       this._headers = Object.fromEntries(
-        Object.entries(init).map(([key, value]) => [key.toLowerCase(), value])
+        Object.entries(init).map(([key, value]) => [key.toLowerCase(), value]),
       );
     }
   }
@@ -59,7 +59,7 @@ export class H3Headers implements Headers {
   }
 
   forEach(
-    callbackfn: (value: string, key: string, parent: Headers) => void
+    callbackfn: (value: string, key: string, parent: Headers) => void,
   ): void {
     for (const [key, value] of Object.entries(this._headers)) {
       callbackfn(value, key, this);

src/event/polyfills/response.ts

@@ -21,7 +21,7 @@ export class H3Response implements Response {
 
   constructor(
     body: BodyInit | EventHandlerResponse | null = null,
-    init: ResponseInit = {}
+    init: ResponseInit = {},
   ) {
     this.headers = new H3Headers(init.headers);
     this.status = init.status ?? 200;

src/event/utils.ts

@@ -7,25 +7,25 @@ import type {
 
 export function defineEventHandler<
   Request extends EventHandlerRequest = EventHandlerRequest,
-  Response = any
+  Response = any,
 >(handler: EventHandler<Request, Response>): EventHandler<Request, Response>;
 // TODO: remove when appropriate
 // This signature provides backwards compatibility with previous signature where first generic was return type
 export function defineEventHandler<
   Request = EventHandlerRequest,
-  Response = EventHandlerResponse
+  Response = EventHandlerResponse,
 >(
   handler: EventHandler<
     Request extends EventHandlerRequest ? Request : any,
     Request extends EventHandlerRequest ? Response : Request
-  >
+  >,
 ): EventHandler<
   Request extends EventHandlerRequest ? Request : any,
   Request extends EventHandlerRequest ? Response : Request
 >;
 export function defineEventHandler<
   Request extends EventHandlerRequest = EventHandlerRequest,
-  Response = EventHandlerResponse
+  Response = EventHandlerResponse,
 >(handler: EventHandler<Request, Response>): EventHandler<Request, Response> {
   handler.__is_handler__ = true;
   return handler;
@@ -39,14 +39,14 @@ export function isEventHandler(input: any): input is EventHandler {
 export function toEventHandler(
   input: any,
   _?: any,
-  _route?: string
+  _route?: string,
 ): EventHandler {
   if (!isEventHandler(input)) {
     // eslint-disable-next-line no-console
     console.warn(
       "[h3] Implicit event handler conversion is deprecated. Use `eventHandler()` or `fromNodeMiddleware()` to define event handlers.",
       _route && _route !== "/" ? "\n" + `     Route: ${_route}` : "",
-      "\n" + `     Handler: ${input}`
+      "\n" + `     Handler: ${input}`,
     );
   }
   return input;
@@ -57,7 +57,7 @@ export interface DynamicEventHandler extends EventHandler {
 }
 
 export function dynamicEventHandler(
-  initial?: EventHandler
+  initial?: EventHandler,
 ): DynamicEventHandler {
   let current: EventHandler | undefined = initial;
   const wrapper = eventHandler((event) => {
@@ -72,7 +72,7 @@ export function dynamicEventHandler(
 }
 
 export function defineLazyEventHandler<T extends LazyEventHandler>(
-  factory: T
+  factory: T,
 ): Awaited<ReturnType<T>> {
   let _promise: Promise<EventHandler>;
   let _resolved: EventHandler;
@@ -86,7 +86,7 @@ export function defineLazyEventHandler<T extends LazyEventHandler>(
         if (typeof handler !== "function") {
           throw new (TypeError as any)(
             "Invalid lazy handler result. It should be a function:",
-            handler
+            handler,
           );
         }
         _resolved = toEventHandler(r.default || r);

src/router.ts

@@ -24,7 +24,7 @@ const RouterMethods: RouterMethod[] = [
 export type RouterUse = (
   path: string,
   handler: EventHandler,
-  method?: RouterMethod | RouterMethod[]
+  method?: RouterMethod | RouterMethod[],
 ) => Router;
 export type AddRouteShortcuts = Record<RouterMethod, RouterUse>;
 
@@ -56,7 +56,7 @@ export function createRouter(opts: CreateRouterOptions = {}): Router {
   const addRoute = (
     path: string,
     handler: EventHandler,
-    method: RouterMethod | RouterMethod[] | "all"
+    method: RouterMethod | RouterMethod[] | "all",
   ) => {
     let route = routes[path];
     if (!route) {

src/types.ts

@@ -51,12 +51,12 @@ export interface EventHandlerRequest {
 export type InferEventInput<
   Key extends keyof EventHandlerRequest,
   Event extends H3Event,
-  T
+  T,
 > = void extends T ? (Event extends H3Event<infer E> ? E[Key] : never) : T;
 
 export interface EventHandler<
   Request extends EventHandlerRequest = EventHandlerRequest,
-  Response extends EventHandlerResponse = EventHandlerResponse
+  Response extends EventHandlerResponse = EventHandlerResponse,
 > {
   __is_handler__?: true;
   (event: H3Event<Request>): Response;

src/utils/body.ts

@@ -28,7 +28,7 @@ const PayloadMethods: HTTPMethod[] = ["PATCH", "POST", "PUT", "DELETE"];
  */
 export function readRawBody<E extends Encoding = "utf8">(
   event: H3Event,
-  encoding = "utf8" as E
+  encoding = "utf8" as E,
 ): E extends false ? Promise<Buffer | undefined> : Promise<string | undefined> {
   // Ensure using correct HTTP method before attempt to read payload
   assertMethod(event, PayloadMethods);
@@ -69,7 +69,7 @@ export function readRawBody<E extends Encoding = "utf8">(
         .on("end", () => {
           resolve(Buffer.concat(bodyData));
         });
-    }
+    },
   ));
 
   const result = encoding
@@ -95,7 +95,7 @@ export function readRawBody<E extends Encoding = "utf8">(
 export async function readBody<
   T,
   Event extends H3Event = H3Event,
-  _T = InferEventInput<"body", Event, T>
+  _T = InferEventInput<"body", Event, T>,
 >(event: Event, options: { strict?: boolean } = {}): Promise<_T> {
   const request = event.node.req as InternalRequest<T>;
   if (ParsedBodySymbol in request) {
@@ -125,7 +125,7 @@ export async function readBody<
 export async function readValidatedBody<
   T,
   Event extends H3Event = H3Event,
-  _T = InferEventInput<"body", Event, T>
+  _T = InferEventInput<"body", Event, T>,
 >(event: Event, validate: ValidateFunction<_T>): Promise<_T> {
   const _body = await readBody(event, { strict: true });
   return validateData(_body, validate);

src/utils/cache.ts

@@ -14,7 +14,7 @@ export interface CacheConditions {
  */
 export function handleCacheHeaders(
   event: H3Event,
-  opts: CacheConditions
+  opts: CacheConditions,
 ): boolean {
   const cacheControls = ["public", ...(opts.cacheControls || [])];
   let cacheMatched = false;