refactor: deprecate define* from wrapper functions

src/app.ts

@@ -1,6 +1,6 @@
 import type http from 'http'
 import { withoutTrailingSlash } from 'ufo'
-import { defineLazyEventHandler, toEventHandler, createEvent, isEventHandler, defineEventHandler } from './event'
+import { lazyEventHandler, toEventHandler, createEvent, isEventHandler, eventHandler } from './event'
 import { createError, sendError, isError } from './error'
 import { send, sendStream, isStream, MIMES } from './utils'
 import type { Handler, LazyHandler, Middleware } from './types'
@@ -103,7 +103,7 @@ export function use (
 
 export function createAppEventHandler (stack: Stack, options: AppOptions) {
   const spacing = options.debug ? 2 : undefined
-  return defineEventHandler(async (event) => {
+  return eventHandler(async (event) => {
     event.req.originalUrl = event.req.originalUrl || event.req.url || '/'
     const reqUrl = event.req.url || '/'
     for (const layer of stack) {
@@ -152,7 +152,7 @@ function normalizeLayer (input: InputLayer) {
   }
 
   if (input.lazy) {
-    handler = defineLazyEventHandler(handler as LazyEventHandler)
+    handler = lazyEventHandler(handler as LazyEventHandler)
   } else if (!isEventHandler(handler)) {
     handler = toEventHandler(handler)
   }

src/event.ts

@@ -24,13 +24,15 @@ export interface EventHandler {
   (event: CompatibilityEvent): H3Response| Promise<H3Response>
 }
 
-export function defineEventHandler (handler: EventHandler) {
+export function eventHandler (handler: EventHandler) {
   handler.__is_handler__ = true
   return handler
 }
+/** @deprecated Use eventHandler() */
+export const defineEventHandler = eventHandler
 
 export type LazyEventHandler = () => EventHandler | Promise<EventHandler>
-export function defineLazyEventHandler (factory: LazyEventHandler): EventHandler {
+export function lazyEventHandler (factory: LazyEventHandler): EventHandler {
   let _promise: Promise<EventHandler>
   let _resolved: EventHandler
   const resolveHandler = () => {
@@ -47,13 +49,15 @@ export function defineLazyEventHandler (factory: LazyEventHandler): EventHandler
     }
     return _promise
   }
-  return defineEventHandler((event) => {
+  return eventHandler((event) => {
     if (_resolved) {
       return _resolved(event)
     }
     return resolveHandler().then(handler => handler(event))
   })
 }
+/** @deprecated use lazyEventHandler() */
+export const defineLazyEventHandler = lazyEventHandler
 
 export function isEventHandler (input: any): input is EventHandler {
   return '__is_handler__' in input
@@ -68,7 +72,7 @@ export function toEventHandler (handler: CompatibilityEventHandler): EventHandle
   if (typeof handler !== 'function') {
     throw new TypeError('Invalid handler. It should be a function:', handler)
   }
-  return defineEventHandler((event) => {
+  return eventHandler((event) => {
     return callHandler(handler, event.req as IncomingMessage, event.res) as Promise<H3Response>
   })
 }

src/router.ts

@@ -1,7 +1,7 @@
 import { createRouter as _createRouter } from 'radix3'
 import type { HTTPMethod } from './types'
 import { createError } from './error'
-import { defineEventHandler, EventHandler, toEventHandler } from './event'
+import { eventHandler, EventHandler, toEventHandler } from './event'
 import type { CompatibilityEventHandler } from './event'
 
 export type RouterMethod = Lowercase<HTTPMethod>
@@ -42,7 +42,7 @@ export function createRouter (): Router {
   }
 
   // Main handle
-  router.handler = defineEventHandler((event) => {
+  router.handler = eventHandler((event) => {
     // Match route
 
     // Remove query parameters for matching