@tanstack/start-server-core 1.121.20 → 1.121.21

package/dist/esm/createStartHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStartHandler.js","sources":["../../src/createStartHandler.ts"],"sourcesContent":["import { createMemoryHistory } from '@tanstack/history'\nimport {\n  flattenMiddlewares,\n  json,\n  mergeHeaders,\n} from '@tanstack/start-client-core'\nimport {\n  getMatchedRoutes,\n  isRedirect,\n  isResolvedRedirect,\n  joinPaths,\n  processRouteTree,\n  trimPath,\n} from '@tanstack/router-core'\nimport { getResponseHeaders, requestHandler } from './h3'\nimport { attachRouterServerSsrUtils, dehydrateRouter } from './ssr-server'\nimport { getStartManifest } from './router-manifest'\nimport { handleServerAction } from './server-functions-handler'\nimport { VIRTUAL_MODULES } from './virtual-modules'\nimport { loadVirtualModule } from './loadVirtualModule'\nimport type {\n  AnyServerRoute,\n  AnyServerRouteWithTypes,\n  ServerRouteMethodHandlerFn,\n} from './serverRoute'\nimport type { RequestHandler } from './h3'\nimport type {\n  AnyRoute,\n  AnyRouter,\n  Manifest,\n  ProcessRouteTreeResult,\n} from '@tanstack/router-core'\nimport type { HandlerCallback } from './handlerCallback'\n\ntype TODO = any\n\nexport type CustomizeStartHandler<TRouter extends AnyRouter> = (\n  cb: HandlerCallback<TRouter>,\n) => RequestHandler\n\nfunction getStartResponseHeaders(opts: { router: AnyRouter }) {\n  const headers = mergeHeaders(\n    getResponseHeaders(),\n    {\n      'Content-Type': 'text/html; charset=UTF-8',\n    },\n    ...opts.router.state.matches.map((match) => {\n      return match.headers\n    }),\n  )\n  return headers\n}\n\nexport function createStartHandler<TRouter extends AnyRouter>({\n  createRouter,\n}: {\n  createRouter: () => TRouter\n}): CustomizeStartHandler<TRouter> {\n  let routeTreeModule: {\n    serverRouteTree: AnyServerRoute | undefined\n    routeTree: AnyRoute | undefined\n  } | null = null\n  let startRoutesManifest: Manifest | null = null\n  let processedServerRouteTree:\n    | ProcessRouteTreeResult<AnyServerRouteWithTypes>\n    | undefined = undefined\n\n  return (cb) => {\n    const originalFetch = globalThis.fetch\n\n    const startRequestResolver: RequestHandler = async ({ request }) => {\n      // Patching fetch function to use our request resolver\n      // if the input starts with `/` which is a common pattern for\n      // client-side routing.\n      // When we encounter similar requests, we can assume that the\n      // user wants to use the same origin as the current request.\n      globalThis.fetch = async function (input, init) {\n        function resolve(url: URL, requestOptions: RequestInit | undefined) {\n          const fetchRequest = new Request(url, requestOptions)\n          return startRequestResolver({ request: fetchRequest })\n        }\n\n        function getOrigin() {\n          return (\n            request.headers.get('Origin') ||\n            request.headers.get('Referer') ||\n            'http://localhost'\n          )\n        }\n\n        if (typeof input === 'string' && input.startsWith('/')) {\n          // e.g: fetch('/api/data')\n          const url = new URL(input, getOrigin())\n          return resolve(url, init)\n        } else if (\n          typeof input === 'object' &&\n          'url' in input &&\n          typeof input.url === 'string' &&\n          input.url.startsWith('/')\n        ) {\n          // e.g: fetch(new Request('/api/data'))\n          const url = new URL(input.url, getOrigin())\n          return resolve(url, init)\n        }\n\n        // If not, it should just use the original fetch\n        return originalFetch(input, init)\n      }\n\n      const url = new URL(request.url)\n      const href = url.href.replace(url.origin, '')\n\n      const APP_BASE = process.env.TSS_APP_BASE || '/'\n\n      // TODO how does this work with base path? does the router need to be configured the same as APP_BASE?\n      const router = createRouter()\n      // Create a history for the client-side router\n      const history = createMemoryHistory({\n        initialEntries: [href],\n      })\n\n      // Update the client-side router with the history\n      router.update({\n        history,\n      })\n\n      const response = await (async () => {\n        try {\n          if (!process.env.TSS_SERVER_FN_BASE) {\n            throw new Error(\n              'tanstack/start-server-core: TSS_SERVER_FN_BASE must be defined in your environment for createStartHandler()',\n            )\n          }\n\n          // First, let's attempt to handle server functions\n          // Add trailing slash to sanitise user defined TSS_SERVER_FN_BASE\n          const serverFnBase = joinPaths([\n            APP_BASE,\n            trimPath(process.env.TSS_SERVER_FN_BASE),\n            '/',\n          ])\n          if (href.startsWith(serverFnBase)) {\n            return await handleServerAction({ request })\n          }\n\n          if (routeTreeModule === null) {\n            try {\n              routeTreeModule = await loadVirtualModule(\n                VIRTUAL_MODULES.routeTree,\n              )\n              if (routeTreeModule.serverRouteTree) {\n                processedServerRouteTree =\n                  processRouteTree<AnyServerRouteWithTypes>({\n                    routeTree: routeTreeModule.serverRouteTree,\n                    initRoute: (route, i) => {\n                      route.init({\n                        originalIndex: i,\n                      })\n                    },\n                  })\n              }\n            } catch (e) {\n              console.log(e)\n            }\n          }\n\n          async function executeRouter() {\n            const requestAcceptHeader = request.headers.get('Accept') || '*/*'\n            const splitRequestAcceptHeader = requestAcceptHeader.split(',')\n\n            const supportedMimeTypes = ['*/*', 'text/html']\n            const isRouterAcceptSupported = supportedMimeTypes.some(\n              (mimeType) =>\n                splitRequestAcceptHeader.some((acceptedMimeType) =>\n                  acceptedMimeType.trim().startsWith(mimeType),\n                ),\n            )\n\n            if (!isRouterAcceptSupported) {\n              return json(\n                {\n                  error: 'Only HTML requests are supported here',\n                },\n                {\n                  status: 500,\n                },\n              )\n            }\n\n            // if the startRoutesManifest is not loaded yet, load it once\n            if (startRoutesManifest === null) {\n              startRoutesManifest = await getStartManifest({\n                basePath: APP_BASE,\n              })\n            }\n\n            // Attach the server-side SSR utils to the client-side router\n            attachRouterServerSsrUtils(router, startRoutesManifest)\n\n            await router.load()\n\n            // If there was a redirect, skip rendering the page at all\n            if (router.state.redirect) {\n              return router.state.redirect\n            }\n\n            dehydrateRouter(router)\n\n            const responseHeaders = getStartResponseHeaders({ router })\n            const response = await cb({\n              request,\n              router,\n              responseHeaders,\n            })\n\n            return response\n          }\n\n          // If we have a server route tree, then we try matching to see if we have a\n          // server route that matches the request.\n          if (processedServerRouteTree) {\n            const [_matchedRoutes, response] = await handleServerRoutes({\n              processedServerRouteTree,\n              router,\n              request,\n              basePath: APP_BASE,\n              executeRouter,\n            })\n\n            if (response) return response\n          }\n\n          // Server Routes did not produce a response, so fallback to normal SSR matching using the router\n          const routerResponse = await executeRouter()\n          return routerResponse\n        } catch (err) {\n          if (err instanceof Response) {\n            return err\n          }\n\n          throw err\n        }\n      })()\n\n      if (isRedirect(response)) {\n        if (isResolvedRedirect(response)) {\n          if (request.headers.get('x-tsr-redirect') === 'manual') {\n            return json(\n              {\n                ...response.options,\n                isSerializedRedirect: true,\n              },\n              {\n                headers: response.headers,\n              },\n            )\n          }\n          return response\n        }\n        if (\n          response.options.to &&\n          typeof response.options.to === 'string' &&\n          !response.options.to.startsWith('/')\n        ) {\n          throw new Error(\n            `Server side redirects must use absolute paths via the 'href' or 'to' options. Received: ${JSON.stringify(response.options)}`,\n          )\n        }\n\n        if (\n          ['params', 'search', 'hash'].some(\n            (d) => typeof (response.options as any)[d] === 'function',\n          )\n        ) {\n          throw new Error(\n            `Server side redirects must use static search, params, and hash values and do not support functional values. Received functional values for: ${Object.keys(\n              response.options,\n            )\n              .filter((d) => typeof (response.options as any)[d] === 'function')\n              .map((d) => `\"${d}\"`)\n              .join(', ')}`,\n          )\n        }\n\n        const redirect = router.resolveRedirect(response)\n\n        if (request.headers.get('x-tsr-redirect') === 'manual') {\n          return json(\n            {\n              ...response.options,\n              isSerializedRedirect: true,\n            },\n            {\n              headers: response.headers,\n            },\n          )\n        }\n\n        return redirect\n      }\n\n      return response\n    }\n\n    return requestHandler(startRequestResolver)\n  }\n}\n\nasync function handleServerRoutes(opts: {\n  router: AnyRouter\n  processedServerRouteTree: ProcessRouteTreeResult<AnyServerRouteWithTypes>\n  request: Request\n  basePath: string\n  executeRouter: () => Promise<Response>\n}) {\n  const url = new URL(opts.request.url)\n  const pathname = url.pathname\n\n  const serverTreeResult = getMatchedRoutes<AnyServerRouteWithTypes>({\n    pathname,\n    basepath: opts.basePath,\n    caseSensitive: true,\n    routesByPath: opts.processedServerRouteTree.routesByPath,\n    routesById: opts.processedServerRouteTree.routesById,\n    flatRoutes: opts.processedServerRouteTree.flatRoutes,\n  })\n\n  const routeTreeResult = opts.router.getMatchedRoutes(pathname, undefined)\n\n  let response: Response | undefined\n  let matchedRoutes: Array<AnyServerRouteWithTypes> = []\n  matchedRoutes = serverTreeResult.matchedRoutes\n  // check if the app route tree found a match that is deeper than the server route tree\n  if (routeTreeResult.foundRoute) {\n    if (\n      serverTreeResult.matchedRoutes.length <\n      routeTreeResult.matchedRoutes.length\n    ) {\n      const closestCommon = [...routeTreeResult.matchedRoutes]\n        .reverse()\n        .find((r) => {\n          return opts.processedServerRouteTree.routesById[r.id] !== undefined\n        })\n      if (closestCommon) {\n        // walk up the tree and collect all parents\n        let routeId = closestCommon.id\n        matchedRoutes = []\n        do {\n          const route = opts.processedServerRouteTree.routesById[routeId]\n          if (!route) {\n            break\n          }\n          matchedRoutes.push(route)\n          routeId = route.parentRoute?.id\n        } while (routeId)\n\n        matchedRoutes.reverse()\n      }\n    }\n  }\n\n  if (matchedRoutes.length) {\n    // We've found a server route that (partially) matches the request, so we can call it.\n    // TODO: Error handling? What happens when its `throw redirect()` vs `throw new Error()`?\n\n    const middlewares = flattenMiddlewares(\n      matchedRoutes.flatMap((r) => r.options.middleware).filter(Boolean),\n    ).map((d) => d.options.server)\n\n    if (serverTreeResult.foundRoute?.options.methods) {\n      const method = Object.keys(\n        serverTreeResult.foundRoute.options.methods,\n      ).find(\n        (method) => method.toLowerCase() === opts.request.method.toLowerCase(),\n      )\n\n      if (method) {\n        const handler = serverTreeResult.foundRoute.options.methods[method]\n\n        if (handler) {\n          middlewares.push(handlerToMiddleware(handler) as TODO)\n        }\n      }\n    }\n\n    // eventually, execute the router\n    middlewares.push(handlerToMiddleware(opts.executeRouter))\n\n    // TODO: This is starting to feel too much like a server function\n    // Do generalize the existing middleware execution? Or do we need to\n    // build a new middleware execution system for server routes?\n    const ctx = await executeMiddleware(middlewares, {\n      request: opts.request,\n      context: {},\n      params: serverTreeResult.routeParams,\n      pathname,\n    })\n\n    response = ctx.response\n  }\n\n  // We return the matched routes too so if\n  // the app router happens to match the same path,\n  // it can use any request middleware from server routes\n  return [matchedRoutes, response] as const\n}\n\nfunction handlerToMiddleware(\n  handler: ServerRouteMethodHandlerFn<\n    AnyServerRouteWithTypes,\n    any,\n    any,\n    any,\n    any\n  >,\n) {\n  return async ({ next: _next, ...rest }: TODO) => {\n    const response = await handler(rest)\n    if (response) {\n      return { response }\n    }\n    return _next(rest)\n  }\n}\n\nfunction executeMiddleware(middlewares: TODO, ctx: TODO) {\n  let index = -1\n\n  const next = async (ctx: TODO) => {\n    index++\n    const middleware = middlewares[index]\n    if (!middleware) return ctx\n\n    const result = await middleware({\n      ...ctx,\n      // Allow the middleware to call the next middleware in the chain\n      next: async (nextCtx: TODO) => {\n        // Allow the caller to extend the context for the next middleware\n        const nextResult = await next({ ...ctx, ...nextCtx })\n\n        // Merge the result into the context\\\n        return Object.assign(ctx, handleCtxResult(nextResult))\n      },\n      // Allow the middleware result to extend the return context\n    }).catch((err: TODO) => {\n      if (isSpecialResponse(err)) {\n        return {\n          response: err,\n        }\n      }\n\n      throw err\n    })\n\n    // Merge the middleware result into the context, just in case it\n    // returns a partial context\n    return Object.assign(ctx, handleCtxResult(result))\n  }\n\n  return handleCtxResult(next(ctx))\n}\n\nfunction handleCtxResult(result: TODO) {\n  if (isSpecialResponse(result)) {\n    return {\n      response: result,\n    }\n  }\n\n  return result\n}\n\nfunction isSpecialResponse(err: TODO) {\n  return isResponse(err) || isRedirect(err)\n}\n\nfunction isResponse(response: Response): response is Response {\n  return response instanceof Response\n}\n"],"names":["url","response","method","ctx"],"mappings":"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"}

package/dist/esm/h3.d.ts

@@ -0,0 +1,109 @@
+import { H3Event, appendCorsHeaders as _appendCorsHeaders, appendCorsPreflightHeaders as _appendCorsPreflightHeaders, appendHeader as _appendHeader, appendResponseHeader as _appendResponseHeader, appendResponseHeaders as _appendResponseHeaders, assertMethod as _assertMethod, clearResponseHeaders as _clearResponseHeaders, clearSession as _clearSession, defaultContentType as _defaultContentType, deleteCookie as _deleteCookie, fetchWithEvent as _fetchWithEvent, getCookie as _getCookie, getProxyRequestHeaders as _getProxyRequestHeaders, getQuery as _getQuery, getRequestFingerprint as _getRequestFingerprint, getRequestHeader as _getRequestHeader, getRequestHeaders as _getRequestHeaders, getRequestHost as _getRequestHost, getRequestIP as _getRequestIP, getRequestProtocol as _getRequestProtocol, getRequestURL as _getRequestURL, getRequestWebStream as _getRequestWebStream, getResponseHeader as _getResponseHeader, getResponseHeaders as _getResponseHeaders, getResponseStatus as _getResponseStatus, getResponseStatusText as _getResponseStatusText, getRouterParam as _getRouterParam, getRouterParams as _getRouterParams, getSession as _getSession, getValidatedQuery as _getValidatedQuery, getValidatedRouterParams as _getValidatedRouterParams, handleCacheHeaders as _handleCacheHeaders, handleCors as _handleCors, isMethod as _isMethod, isPreflightRequest as _isPreflightRequest, parseCookies as _parseCookies, proxyRequest as _proxyRequest, readBody as _readBody, readFormData as _readFormData, readMultipartFormData as _readMultipartFormData, readRawBody as _readRawBody, readValidatedBody as _readValidatedBody, removeResponseHeader as _removeResponseHeader, sealSession as _sealSession, send as _send, sendError as _sendError, sendNoContent as _sendNoContent, sendProxy as _sendProxy, sendRedirect as _sendRedirect, sendStream as _sendStream, sendWebResponse as _sendWebResponse, setCookie as _setCookie, setHeader as _setHeader, setResponseHeader as _setResponseHeader, setResponseHeaders as _setResponseHeaders, setResponseStatus as _setResponseStatus, toWebRequest as _toWebRequest, unsealSession as _unsealSession, updateSession as _updateSession, useSession as _useSession, writeEarlyHints as _writeEarlyHints, Encoding, EventHandler, HTTPHeaderName, InferEventInput, _RequestMiddleware, _ResponseMiddleware } from 'h3';
+declare function _setContext(event: H3Event, key: string, value: any): void;
+declare function _getContext(event: H3Event, key: string): any;
+export declare function defineMiddleware(options: {
+    onRequest?: _RequestMiddleware | Array<_RequestMiddleware>;
+    onBeforeResponse?: _ResponseMiddleware | Array<_ResponseMiddleware>;
+}): {
+    onRequest?: _RequestMiddleware | Array<_RequestMiddleware>;
+    onBeforeResponse?: _ResponseMiddleware | Array<_ResponseMiddleware>;
+};
+export { H3Error, H3Event, MIMES, callNodeListener, createApp, createAppEventHandler, createEvent, createRouter, defineLazyEventHandler, defineNodeListener, defineNodeMiddleware, defineRequestMiddleware, defineResponseMiddleware, dynamicEventHandler, defineWebSocket, splitCookiesString, fromNodeMiddleware, fromPlainHandler, fromWebHandler, isError, isEventHandler, isWebResponse, lazyEventHandler, promisifyNodeListener, serveStatic, toEventHandler, toNodeListener, toPlainHandler, toWebHandler, toWebRequest, isCorsOriginAllowed, isStream, createError, sanitizeStatusCode, sanitizeStatusMessage, useBase, type AddRouteShortcuts, type App, type AppOptions, type AppUse, type CacheConditions, type CreateRouterOptions, type Duplex, type DynamicEventHandler, type Encoding, type EventHandler, type EventHandlerObject, type EventHandlerRequest, type EventHandlerResponse, type H3CorsOptions, type H3EventContext, type HTTPHeaderName, type HTTPMethod, type InferEventInput, type InputLayer, type InputStack, type Layer, type LazyEventHandler, type Matcher, type MultiPartData, type NodeEventContext, type NodeListener, type NodeMiddleware, type NodePromisifiedHandler, type PlainHandler, type PlainRequest, type PlainResponse, type ProxyOptions, type RequestFingerprintOptions, type RequestHeaders, type RouteNode, type Router, type RouterMethod, type RouterUse, type ServeStaticOptions, type Session, type SessionConfig, type SessionData, type Stack, type StaticAssetMeta, type ValidateFunction, type ValidateResult, type WebEventContext, type WebHandler, type _RequestMiddleware, type _ResponseMiddleware, } from 'h3';
+export declare function defineEventHandler(handler: EventHandler): EventHandler<import('h3').EventHandlerRequest, Promise<any>>;
+export declare function eventHandler(handler: EventHandler): EventHandler<import('h3').EventHandlerRequest, Promise<any>>;
+export declare function runWithEvent<T>(event: H3Event, fn: () => T | Promise<T>): Promise<T>;
+export declare function getEvent(): H3Event<import('h3').EventHandlerRequest>;
+export declare const HTTPEventSymbol: unique symbol;
+export declare function isEvent(obj: any): obj is H3Event | {
+    [HTTPEventSymbol]: H3Event;
+};
+type Tail<T> = T extends [any, ...infer U] ? U : never;
+type PrependOverload<TOriginal extends (...args: Array<any>) => any, TOverload extends (...args: Array<any>) => any> = TOverload & TOriginal;
+type WrapFunction<TFn extends (...args: Array<any>) => any> = PrependOverload<TFn, (...args: Parameters<TFn> extends [H3Event, ...infer TArgs] ? TArgs : Parameters<TFn>) => ReturnType<TFn>>;
+type WrappedReadRawBody = <TEncoding extends Encoding = 'utf8'>(...args: Tail<Parameters<typeof _readRawBody<TEncoding>>>) => ReturnType<typeof _readRawBody<TEncoding>>;
+export declare const readRawBody: PrependOverload<typeof _readRawBody, WrappedReadRawBody>;
+type WrappedReadBody = <T, TEventInput = InferEventInput<'body', H3Event, T>>(...args: Tail<Parameters<typeof _readBody<T, H3Event, TEventInput>>>) => ReturnType<typeof _readBody<T, H3Event, TEventInput>>;
+export declare const readBody: PrependOverload<typeof _readBody, WrappedReadBody>;
+type WrappedGetQuery = <T, TEventInput = Exclude<InferEventInput<'query', H3Event, T>, undefined>>(...args: Tail<Parameters<typeof _getQuery<T, H3Event, TEventInput>>>) => ReturnType<typeof _getQuery<T, H3Event, TEventInput>>;
+export declare const getQuery: PrependOverload<typeof _getQuery, WrappedGetQuery>;
+export declare const isMethod: WrapFunction<typeof _isMethod>;
+export declare const isPreflightRequest: WrapFunction<typeof _isPreflightRequest>;
+type WrappedGetValidatedQuery = <T, TEventInput = InferEventInput<'query', H3Event, T>>(...args: Tail<Parameters<typeof _getValidatedQuery<T, H3Event, TEventInput>>>) => ReturnType<typeof _getValidatedQuery<T, H3Event, TEventInput>>;
+export declare const getValidatedQuery: PrependOverload<typeof _getValidatedQuery, WrappedGetValidatedQuery>;
+export declare const getRouterParams: WrapFunction<typeof _getRouterParams>;
+export declare const getRouterParam: WrapFunction<typeof _getRouterParam>;
+type WrappedGetValidatedRouterParams = <T, TEventInput = InferEventInput<'routerParams', H3Event, T>>(...args: Tail<Parameters<typeof _getValidatedRouterParams<T, H3Event, TEventInput>>>) => ReturnType<typeof _getValidatedRouterParams<T, H3Event, TEventInput>>;
+export declare const getValidatedRouterParams: PrependOverload<typeof _getValidatedRouterParams, WrappedGetValidatedRouterParams>;
+export declare const assertMethod: WrapFunction<typeof _assertMethod>;
+export declare const getRequestHeaders: WrapFunction<typeof _getRequestHeaders>;
+export declare const getRequestHeader: WrapFunction<typeof _getRequestHeader>;
+export declare const getRequestURL: WrapFunction<typeof _getRequestURL>;
+export declare const getRequestHost: WrapFunction<typeof _getRequestHost>;
+export declare const getRequestProtocol: WrapFunction<typeof _getRequestProtocol>;
+export declare const getRequestIP: WrapFunction<typeof _getRequestIP>;
+export declare const send: WrapFunction<typeof _send>;
+export declare const sendNoContent: WrapFunction<typeof _sendNoContent>;
+export declare const setResponseStatus: WrapFunction<typeof _setResponseStatus>;
+export declare const getResponseStatus: WrapFunction<typeof _getResponseStatus>;
+export declare const getResponseStatusText: WrapFunction<typeof _getResponseStatusText>;
+export declare const getResponseHeaders: WrapFunction<typeof _getResponseHeaders>;
+export declare const getResponseHeader: WrapFunction<typeof _getResponseHeader>;
+export declare const setResponseHeaders: WrapFunction<typeof _setResponseHeaders>;
+type WrappedSetResponseHeader = <T extends HTTPHeaderName>(...args: Tail<Parameters<typeof _setResponseHeader<T>>>) => ReturnType<typeof _setResponseHeader<T>>;
+export declare const setResponseHeader: PrependOverload<typeof _setResponseHeader, WrappedSetResponseHeader>;
+export declare const appendResponseHeaders: WrapFunction<typeof _appendResponseHeaders>;
+type WrappedAppendResponseHeader = <T extends HTTPHeaderName>(...args: Tail<Parameters<typeof _appendResponseHeader<T>>>) => ReturnType<typeof _appendResponseHeader<T>>;
+export declare const appendResponseHeader: PrependOverload<typeof _appendResponseHeader, WrappedAppendResponseHeader>;
+export declare const defaultContentType: WrapFunction<typeof _defaultContentType>;
+export declare const sendRedirect: WrapFunction<typeof _sendRedirect>;
+export declare const sendStream: WrapFunction<typeof _sendStream>;
+export declare const writeEarlyHints: WrapFunction<typeof _writeEarlyHints>;
+export declare const sendError: WrapFunction<typeof _sendError>;
+export declare const sendProxy: WrapFunction<typeof _sendProxy>;
+export declare const proxyRequest: WrapFunction<typeof _proxyRequest>;
+type WrappedFetchWithEvent = <T = unknown, TResponse = any, TFetch extends (req: RequestInfo | URL, opts?: any) => any = typeof fetch>(...args: Tail<Parameters<typeof _fetchWithEvent<T, TResponse, TFetch>>>) => ReturnType<typeof _fetchWithEvent<T, TResponse, TFetch>>;
+export declare const fetchWithEvent: PrependOverload<typeof _fetchWithEvent, WrappedFetchWithEvent>;
+export declare const getProxyRequestHeaders: WrapFunction<typeof _getProxyRequestHeaders>;
+export declare const parseCookies: WrapFunction<typeof _parseCookies>;
+export declare const getCookie: WrapFunction<typeof _getCookie>;
+export declare const setCookie: WrapFunction<typeof _setCookie>;
+export declare const deleteCookie: WrapFunction<typeof _deleteCookie>;
+type SessionDataT = Record<string, any>;
+type WrappedUseSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof _useSession<T>>>) => ReturnType<typeof _useSession<T>>;
+export declare const useSession: PrependOverload<typeof _useSession, WrappedUseSession>;
+type WrappedGetSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof _getSession<T>>>) => ReturnType<typeof _getSession<T>>;
+export declare const getSession: PrependOverload<typeof _getSession, WrappedGetSession>;
+type WrappedUpdateSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof _updateSession<T>>>) => ReturnType<typeof _updateSession<T>>;
+export declare const updateSession: PrependOverload<typeof _updateSession, WrappedUpdateSession>;
+type WrappedSealSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof _sealSession<T>>>) => ReturnType<typeof _sealSession<T>>;
+export declare const sealSession: PrependOverload<typeof _sealSession, WrappedSealSession>;
+export declare const unsealSession: WrapFunction<typeof _unsealSession>;
+export declare const clearSession: WrapFunction<typeof _clearSession>;
+export declare const handleCacheHeaders: WrapFunction<typeof _handleCacheHeaders>;
+export declare const handleCors: WrapFunction<typeof _handleCors>;
+export declare const appendCorsHeaders: WrapFunction<typeof _appendCorsHeaders>;
+export declare const appendCorsPreflightHeaders: WrapFunction<typeof _appendCorsPreflightHeaders>;
+export declare const sendWebResponse: WrapFunction<typeof _sendWebResponse>;
+type WrappedAppendHeader = <T extends HTTPHeaderName>(...args: Tail<Parameters<typeof _appendHeader<T>>>) => ReturnType<typeof _appendHeader<T>>;
+export declare const appendHeader: PrependOverload<typeof _appendHeader, WrappedAppendHeader>;
+export declare const appendHeaders: WrapFunction<typeof _appendResponseHeaders>;
+type WrappedSetHeader = <T extends HTTPHeaderName>(...args: Tail<Parameters<typeof _setHeader<T>>>) => ReturnType<typeof _setHeader<T>>;
+export declare const setHeader: PrependOverload<typeof _setHeader, WrappedSetHeader>;
+export declare const setHeaders: WrapFunction<typeof _setResponseHeaders>;
+export declare const getHeader: WrapFunction<typeof _getRequestHeader>;
+export declare const getHeaders: WrapFunction<typeof _getRequestHeaders>;
+export declare const getRequestFingerprint: WrapFunction<typeof _getRequestFingerprint>;
+export declare const getRequestWebStream: WrapFunction<typeof _getRequestWebStream>;
+export declare const readFormData: WrapFunction<typeof _readFormData>;
+export declare const readMultipartFormData: WrapFunction<typeof _readMultipartFormData>;
+type WrappedReadValidatedBody = <T, TEventInput = InferEventInput<'body', H3Event, T>>(...args: Tail<Parameters<typeof _readValidatedBody<T, H3Event, TEventInput>>>) => ReturnType<typeof _readValidatedBody<T, H3Event, TEventInput>>;
+export declare const readValidatedBody: PrependOverload<typeof _readValidatedBody, WrappedReadValidatedBody>;
+export declare const removeResponseHeader: WrapFunction<typeof _removeResponseHeader>;
+export declare const getContext: WrapFunction<typeof _getContext>;
+export declare const setContext: WrapFunction<typeof _setContext>;
+export declare const clearResponseHeaders: WrapFunction<typeof _clearResponseHeaders>;
+export declare const getWebRequest: WrapFunction<typeof _toWebRequest>;
+export type RequestHandler = (ctx: {
+    request: Request;
+}) => Promise<Response> | Response;
+export declare function requestHandler(handler: RequestHandler): RequestHandler;

package/dist/esm/h3.js

@@ -0,0 +1,248 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { defineEventHandler as defineEventHandler$1, eventHandler as eventHandler$1, H3Event, readBody as readBody$1, getQuery as getQuery$1, isMethod as isMethod$1, isPreflightRequest as isPreflightRequest$1, getValidatedQuery as getValidatedQuery$1, getRouterParams as getRouterParams$1, getRouterParam as getRouterParam$1, getValidatedRouterParams as getValidatedRouterParams$1, assertMethod as assertMethod$1, getRequestHeaders as getRequestHeaders$1, getRequestHeader as getRequestHeader$1, getRequestURL as getRequestURL$1, getRequestHost as getRequestHost$1, getRequestProtocol as getRequestProtocol$1, getRequestIP as getRequestIP$1, send as send$1, sendNoContent as sendNoContent$1, setResponseStatus as setResponseStatus$1, getResponseStatus as getResponseStatus$1, getResponseStatusText as getResponseStatusText$1, getResponseHeaders as getResponseHeaders$1, getResponseHeader as getResponseHeader$1, setResponseHeaders as setResponseHeaders$1, setResponseHeader as setResponseHeader$1, appendResponseHeaders as appendResponseHeaders$1, appendResponseHeader as appendResponseHeader$1, defaultContentType as defaultContentType$1, sendRedirect as sendRedirect$1, sendStream as sendStream$1, writeEarlyHints as writeEarlyHints$1, sendError as sendError$1, sendProxy as sendProxy$1, proxyRequest as proxyRequest$1, fetchWithEvent as fetchWithEvent$1, getProxyRequestHeaders as getProxyRequestHeaders$1, parseCookies as parseCookies$1, getCookie as getCookie$1, setCookie as setCookie$1, deleteCookie as deleteCookie$1, useSession as useSession$1, getSession as getSession$1, updateSession as updateSession$1, sealSession as sealSession$1, unsealSession as unsealSession$1, clearSession as clearSession$1, handleCacheHeaders as handleCacheHeaders$1, handleCors as handleCors$1, appendCorsHeaders as appendCorsHeaders$1, appendCorsPreflightHeaders as appendCorsPreflightHeaders$1, sendWebResponse as sendWebResponse$1, appendHeader as appendHeader$1, appendHeaders as appendHeaders$1, setHeader as setHeader$1, setHeaders as setHeaders$1, getHeader as getHeader$1, getHeaders as getHeaders$1, getRequestFingerprint as getRequestFingerprint$1, getRequestWebStream as getRequestWebStream$1, readFormData as readFormData$1, readMultipartFormData as readMultipartFormData$1, readValidatedBody as readValidatedBody$1, removeResponseHeader as removeResponseHeader$1, clearResponseHeaders as clearResponseHeaders$1, toWebRequest, readRawBody as readRawBody$1 } from "h3";
+import { H3Error, H3Event as H3Event2, MIMES, callNodeListener, createApp, createAppEventHandler, createError, createEvent, createRouter, defineLazyEventHandler, defineNodeListener, defineNodeMiddleware, defineRequestMiddleware, defineResponseMiddleware, defineWebSocket, dynamicEventHandler, fromNodeMiddleware, fromPlainHandler, fromWebHandler, isCorsOriginAllowed, isError, isEventHandler, isStream, isWebResponse, lazyEventHandler, promisifyNodeListener, sanitizeStatusCode, sanitizeStatusMessage, serveStatic, splitCookiesString, toEventHandler, toNodeListener, toPlainHandler, toWebHandler, toWebRequest as toWebRequest2, useBase } from "h3";
+const eventStorage = new AsyncLocalStorage();
+function _setContext(event, key, value) {
+  event.context[key] = value;
+}
+function _getContext(event, key) {
+  return event.context[key];
+}
+function defineMiddleware(options) {
+  return options;
+}
+function defineEventHandler(handler) {
+  return defineEventHandler$1((event) => {
+    return runWithEvent(event, () => handler(event));
+  });
+}
+function eventHandler(handler) {
+  return eventHandler$1((event) => {
+    return runWithEvent(event, () => handler(event));
+  });
+}
+async function runWithEvent(event, fn) {
+  return eventStorage.run(event, fn);
+}
+function getEvent() {
+  const event = eventStorage.getStore();
+  if (!event) {
+    throw new Error(
+      `No HTTPEvent found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`
+    );
+  }
+  return event;
+}
+const HTTPEventSymbol = Symbol("$HTTPEvent");
+function isEvent(obj) {
+  return typeof obj === "object" && (obj instanceof H3Event || (obj == null ? void 0 : obj[HTTPEventSymbol]) instanceof H3Event || (obj == null ? void 0 : obj.__is_event__) === true);
+}
+function createWrapperFunction(h3Function) {
+  return function(...args) {
+    const event = args[0];
+    if (!isEvent(event)) {
+      args.unshift(getEvent());
+    } else {
+      args[0] = event instanceof H3Event || event.__is_event__ ? event : event[HTTPEventSymbol];
+    }
+    return h3Function(...args);
+  };
+}
+const readRawBody = createWrapperFunction(readRawBody$1);
+const readBody = createWrapperFunction(readBody$1);
+const getQuery = createWrapperFunction(getQuery$1);
+const isMethod = createWrapperFunction(isMethod$1);
+const isPreflightRequest = createWrapperFunction(isPreflightRequest$1);
+const getValidatedQuery = createWrapperFunction(getValidatedQuery$1);
+const getRouterParams = createWrapperFunction(getRouterParams$1);
+const getRouterParam = createWrapperFunction(getRouterParam$1);
+const getValidatedRouterParams = createWrapperFunction(getValidatedRouterParams$1);
+const assertMethod = createWrapperFunction(assertMethod$1);
+const getRequestHeaders = createWrapperFunction(getRequestHeaders$1);
+const getRequestHeader = createWrapperFunction(getRequestHeader$1);
+const getRequestURL = createWrapperFunction(getRequestURL$1);
+const getRequestHost = createWrapperFunction(getRequestHost$1);
+const getRequestProtocol = createWrapperFunction(getRequestProtocol$1);
+const getRequestIP = createWrapperFunction(getRequestIP$1);
+const send = createWrapperFunction(send$1);
+const sendNoContent = createWrapperFunction(sendNoContent$1);
+const setResponseStatus = createWrapperFunction(setResponseStatus$1);
+const getResponseStatus = createWrapperFunction(getResponseStatus$1);
+const getResponseStatusText = createWrapperFunction(
+  getResponseStatusText$1
+);
+const getResponseHeaders = createWrapperFunction(getResponseHeaders$1);
+const getResponseHeader = createWrapperFunction(getResponseHeader$1);
+const setResponseHeaders = createWrapperFunction(setResponseHeaders$1);
+const setResponseHeader = createWrapperFunction(setResponseHeader$1);
+const appendResponseHeaders = createWrapperFunction(
+  appendResponseHeaders$1
+);
+const appendResponseHeader = createWrapperFunction(appendResponseHeader$1);
+const defaultContentType = createWrapperFunction(defaultContentType$1);
+const sendRedirect = createWrapperFunction(sendRedirect$1);
+const sendStream = createWrapperFunction(sendStream$1);
+const writeEarlyHints = createWrapperFunction(writeEarlyHints$1);
+const sendError = createWrapperFunction(sendError$1);
+const sendProxy = createWrapperFunction(sendProxy$1);
+const proxyRequest = createWrapperFunction(proxyRequest$1);
+const fetchWithEvent = createWrapperFunction(fetchWithEvent$1);
+const getProxyRequestHeaders = createWrapperFunction(
+  getProxyRequestHeaders$1
+);
+const parseCookies = createWrapperFunction(parseCookies$1);
+const getCookie = createWrapperFunction(getCookie$1);
+const setCookie = createWrapperFunction(setCookie$1);
+const deleteCookie = createWrapperFunction(deleteCookie$1);
+const useSession = createWrapperFunction(useSession$1);
+const getSession = createWrapperFunction(getSession$1);
+const updateSession = createWrapperFunction(updateSession$1);
+const sealSession = createWrapperFunction(
+  sealSession$1
+);
+const unsealSession = createWrapperFunction(unsealSession$1);
+const clearSession = createWrapperFunction(clearSession$1);
+const handleCacheHeaders = createWrapperFunction(handleCacheHeaders$1);
+const handleCors = createWrapperFunction(handleCors$1);
+const appendCorsHeaders = createWrapperFunction(appendCorsHeaders$1);
+const appendCorsPreflightHeaders = createWrapperFunction(
+  appendCorsPreflightHeaders$1
+);
+const sendWebResponse = createWrapperFunction(sendWebResponse$1);
+const appendHeader = createWrapperFunction(appendHeader$1);
+const appendHeaders = createWrapperFunction(appendHeaders$1);
+const setHeader = createWrapperFunction(setHeader$1);
+const setHeaders = createWrapperFunction(setHeaders$1);
+const getHeader = createWrapperFunction(getHeader$1);
+const getHeaders = createWrapperFunction(getHeaders$1);
+const getRequestFingerprint = createWrapperFunction(
+  getRequestFingerprint$1
+);
+const getRequestWebStream = createWrapperFunction(getRequestWebStream$1);
+const readFormData = createWrapperFunction(readFormData$1);
+const readMultipartFormData = createWrapperFunction(
+  readMultipartFormData$1
+);
+const readValidatedBody = createWrapperFunction(readValidatedBody$1);
+const removeResponseHeader = createWrapperFunction(removeResponseHeader$1);
+const getContext = createWrapperFunction(_getContext);
+const setContext = createWrapperFunction(_setContext);
+const clearResponseHeaders = createWrapperFunction(clearResponseHeaders$1);
+const getWebRequest = createWrapperFunction(toWebRequest);
+function requestHandler(handler) {
+  return handler;
+}
+export {
+  H3Error,
+  H3Event2 as H3Event,
+  HTTPEventSymbol,
+  MIMES,
+  appendCorsHeaders,
+  appendCorsPreflightHeaders,
+  appendHeader,
+  appendHeaders,
+  appendResponseHeader,
+  appendResponseHeaders,
+  assertMethod,
+  callNodeListener,
+  clearResponseHeaders,
+  clearSession,
+  createApp,
+  createAppEventHandler,
+  createError,
+  createEvent,
+  createRouter,
+  defaultContentType,
+  defineEventHandler,
+  defineLazyEventHandler,
+  defineMiddleware,
+  defineNodeListener,
+  defineNodeMiddleware,
+  defineRequestMiddleware,
+  defineResponseMiddleware,
+  defineWebSocket,
+  deleteCookie,
+  dynamicEventHandler,
+  eventHandler,
+  fetchWithEvent,
+  fromNodeMiddleware,
+  fromPlainHandler,
+  fromWebHandler,
+  getContext,
+  getCookie,
+  getEvent,
+  getHeader,
+  getHeaders,
+  getProxyRequestHeaders,
+  getQuery,
+  getRequestFingerprint,
+  getRequestHeader,
+  getRequestHeaders,
+  getRequestHost,
+  getRequestIP,
+  getRequestProtocol,
+  getRequestURL,
+  getRequestWebStream,
+  getResponseHeader,
+  getResponseHeaders,
+  getResponseStatus,
+  getResponseStatusText,
+  getRouterParam,
+  getRouterParams,
+  getSession,
+  getValidatedQuery,
+  getValidatedRouterParams,
+  getWebRequest,
+  handleCacheHeaders,
+  handleCors,
+  isCorsOriginAllowed,
+  isError,
+  isEvent,
+  isEventHandler,
+  isMethod,
+  isPreflightRequest,
+  isStream,
+  isWebResponse,
+  lazyEventHandler,
+  parseCookies,
+  promisifyNodeListener,
+  proxyRequest,
+  readBody,
+  readFormData,
+  readMultipartFormData,
+  readRawBody,
+  readValidatedBody,
+  removeResponseHeader,
+  requestHandler,
+  runWithEvent,
+  sanitizeStatusCode,
+  sanitizeStatusMessage,
+  sealSession,
+  send,
+  sendError,
+  sendNoContent,
+  sendProxy,
+  sendRedirect,
+  sendStream,
+  sendWebResponse,
+  serveStatic,
+  setContext,
+  setCookie,
+  setHeader,
+  setHeaders,
+  setResponseHeader,
+  setResponseHeaders,
+  setResponseStatus,
+  splitCookiesString,
+  toEventHandler,
+  toNodeListener,
+  toPlainHandler,
+  toWebHandler,
+  toWebRequest2 as toWebRequest,
+  unsealSession,
+  updateSession,
+  useBase,
+  useSession,
+  writeEarlyHints
+};
+//# sourceMappingURL=h3.js.map

package/dist/esm/h3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"h3.js","sources":["../../src/h3.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport {\n  H3Event,\n  appendCorsHeaders as _appendCorsHeaders,\n  appendCorsPreflightHeaders as _appendCorsPreflightHeaders,\n  appendHeader as _appendHeader,\n  appendHeaders as _appendHeaders,\n  appendResponseHeader as _appendResponseHeader,\n  appendResponseHeaders as _appendResponseHeaders,\n  assertMethod as _assertMethod,\n  clearResponseHeaders as _clearResponseHeaders,\n  clearSession as _clearSession,\n  defaultContentType as _defaultContentType,\n  defineEventHandler as _defineEventHandler,\n  deleteCookie as _deleteCookie,\n  eventHandler as _eventHandler,\n  fetchWithEvent as _fetchWithEvent,\n  getCookie as _getCookie,\n  getHeader as _getHeader,\n  getHeaders as _getHeaders,\n  getProxyRequestHeaders as _getProxyRequestHeaders,\n  getQuery as _getQuery,\n  getRequestFingerprint as _getRequestFingerprint,\n  getRequestHeader as _getRequestHeader,\n  getRequestHeaders as _getRequestHeaders,\n  getRequestHost as _getRequestHost,\n  getRequestIP as _getRequestIP,\n  getRequestProtocol as _getRequestProtocol,\n  getRequestURL as _getRequestURL,\n  getRequestWebStream as _getRequestWebStream,\n  getResponseHeader as _getResponseHeader,\n  getResponseHeaders as _getResponseHeaders,\n  getResponseStatus as _getResponseStatus,\n  getResponseStatusText as _getResponseStatusText,\n  getRouterParam as _getRouterParam,\n  getRouterParams as _getRouterParams,\n  getSession as _getSession,\n  getValidatedQuery as _getValidatedQuery,\n  getValidatedRouterParams as _getValidatedRouterParams,\n  handleCacheHeaders as _handleCacheHeaders,\n  handleCors as _handleCors,\n  isMethod as _isMethod,\n  isPreflightRequest as _isPreflightRequest,\n  parseCookies as _parseCookies,\n  proxyRequest as _proxyRequest,\n  readBody as _readBody,\n  readFormData as _readFormData,\n  readMultipartFormData as _readMultipartFormData,\n  readRawBody as _readRawBody,\n  readValidatedBody as _readValidatedBody,\n  removeResponseHeader as _removeResponseHeader,\n  sealSession as _sealSession,\n  send as _send,\n  sendError as _sendError,\n  sendNoContent as _sendNoContent,\n  sendProxy as _sendProxy,\n  sendRedirect as _sendRedirect,\n  sendStream as _sendStream,\n  sendWebResponse as _sendWebResponse,\n  setCookie as _setCookie,\n  setHeader as _setHeader,\n  setHeaders as _setHeaders,\n  setResponseHeader as _setResponseHeader,\n  setResponseHeaders as _setResponseHeaders,\n  setResponseStatus as _setResponseStatus,\n  toWebRequest as _toWebRequest,\n  unsealSession as _unsealSession,\n  updateSession as _updateSession,\n  useSession as _useSession,\n  writeEarlyHints as _writeEarlyHints,\n} from 'h3'\n\nimport type {\n  Encoding,\n  EventHandler,\n  HTTPHeaderName,\n  InferEventInput,\n  _RequestMiddleware,\n  _ResponseMiddleware,\n} from 'h3'\n\nconst eventStorage = new AsyncLocalStorage()\n\nfunction _setContext(event: H3Event, key: string, value: any) {\n  event.context[key] = value\n}\n\nfunction _getContext(event: H3Event, key: string) {\n  return event.context[key]\n}\n\nexport function defineMiddleware(options: {\n  onRequest?: _RequestMiddleware | Array<_RequestMiddleware>\n  onBeforeResponse?: _ResponseMiddleware | Array<_ResponseMiddleware>\n}) {\n  return options\n}\n\n// function toWebRequestH3(event: H3Event) {\n//   /**\n//    * @type {ReadableStream | undefined}\n//    */\n//   let readableStream: ReadableStream | undefined\n\n//   const url = _getRequestURL(event)\n//   const base = {\n//     // @ts-ignore Undici option\n//     duplex: 'half',\n//     method: event.method,\n//     headers: event.headers,\n//   }\n\n//   if ((event.node.req as any).body instanceof ArrayBuffer) {\n//     return new Request(url, {\n//       ...base,\n//       body: (event.node.req as any).body,\n//     })\n//   }\n\n//   return new Request(url, {\n//     ...base,\n//     get body() {\n//       if (readableStream) {\n//         return readableStream\n//       }\n//       readableStream = _getRequestWebStream(event)\n//       return readableStream\n//     },\n//   })\n// }\n\nexport {\n  H3Error,\n  H3Event,\n  MIMES,\n  callNodeListener,\n  createApp,\n  createAppEventHandler,\n  createEvent,\n  createRouter,\n  defineLazyEventHandler,\n  defineNodeListener,\n  defineNodeMiddleware,\n  defineRequestMiddleware,\n  defineResponseMiddleware,\n  dynamicEventHandler,\n  defineWebSocket,\n  splitCookiesString,\n  fromNodeMiddleware,\n  fromPlainHandler,\n  fromWebHandler,\n  isError,\n  isEventHandler,\n  isWebResponse,\n  lazyEventHandler,\n  promisifyNodeListener,\n  serveStatic,\n  toEventHandler,\n  toNodeListener,\n  toPlainHandler,\n  toWebHandler,\n  toWebRequest,\n  isCorsOriginAllowed,\n  isStream,\n  createError,\n  sanitizeStatusCode,\n  sanitizeStatusMessage,\n  useBase,\n  type AddRouteShortcuts,\n  type App,\n  type AppOptions,\n  type AppUse,\n  type CacheConditions,\n  type CreateRouterOptions,\n  type Duplex,\n  type DynamicEventHandler,\n  type Encoding,\n  type EventHandler,\n  type EventHandlerObject,\n  type EventHandlerRequest,\n  type EventHandlerResponse,\n  type H3CorsOptions,\n  type H3EventContext,\n  type HTTPHeaderName,\n  type HTTPMethod,\n  type InferEventInput,\n  type InputLayer,\n  type InputStack,\n  type Layer,\n  type LazyEventHandler,\n  type Matcher,\n  type MultiPartData,\n  type NodeEventContext,\n  type NodeListener,\n  type NodeMiddleware,\n  type NodePromisifiedHandler,\n  type PlainHandler,\n  type PlainRequest,\n  type PlainResponse,\n  type ProxyOptions,\n  type RequestFingerprintOptions,\n  type RequestHeaders,\n  type RouteNode,\n  type Router,\n  type RouterMethod,\n  type RouterUse,\n  type ServeStaticOptions,\n  type Session,\n  type SessionConfig,\n  type SessionData,\n  type Stack,\n  type StaticAssetMeta,\n  type ValidateFunction,\n  type ValidateResult,\n  type WebEventContext,\n  type WebHandler,\n  type _RequestMiddleware,\n  type _ResponseMiddleware,\n} from 'h3'\n\nexport function defineEventHandler(handler: EventHandler) {\n  return _defineEventHandler((event) => {\n    return runWithEvent(event, () => handler(event))\n  })\n}\n\nexport function eventHandler(handler: EventHandler) {\n  return _eventHandler((event) => {\n    return runWithEvent(event, () => handler(event))\n  })\n}\n\nexport async function runWithEvent<T>(\n  event: H3Event,\n  fn: () => T | Promise<T>,\n): Promise<T> {\n  return eventStorage.run(event, fn)\n}\n\nexport function getEvent() {\n  const event = eventStorage.getStore() as H3Event | undefined\n  if (!event) {\n    throw new Error(\n      `No HTTPEvent found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`,\n    )\n  }\n  return event\n}\n\nexport const HTTPEventSymbol = Symbol('$HTTPEvent')\n\nexport function isEvent(\n  obj: any,\n): obj is H3Event | { [HTTPEventSymbol]: H3Event } {\n  return (\n    typeof obj === 'object' &&\n    (obj instanceof H3Event ||\n      obj?.[HTTPEventSymbol] instanceof H3Event ||\n      obj?.__is_event__ === true)\n  )\n  // Implement logic to check if obj is an H3Event\n}\n\ntype Tail<T> = T extends [any, ...infer U] ? U : never\n\ntype PrependOverload<\n  TOriginal extends (...args: Array<any>) => any,\n  TOverload extends (...args: Array<any>) => any,\n> = TOverload & TOriginal\n\n// add an overload to the function without the event argument\ntype WrapFunction<TFn extends (...args: Array<any>) => any> = PrependOverload<\n  TFn,\n  (\n    ...args: Parameters<TFn> extends [H3Event, ...infer TArgs]\n      ? TArgs\n      : Parameters<TFn>\n  ) => ReturnType<TFn>\n>\n\nfunction createWrapperFunction<TFn extends (...args: Array<any>) => any>(\n  h3Function: TFn,\n): WrapFunction<TFn> {\n  return function (...args: Array<any>) {\n    const event = args[0]\n    if (!isEvent(event)) {\n      args.unshift(getEvent())\n    } else {\n      args[0] =\n        event instanceof H3Event || (event as any).__is_event__\n          ? event\n          : event[HTTPEventSymbol]\n    }\n\n    return (h3Function as any)(...args)\n  } as any\n}\n\n// Creating wrappers for each utility and exporting them with their original names\ntype WrappedReadRawBody = <TEncoding extends Encoding = 'utf8'>(\n  ...args: Tail<Parameters<typeof _readRawBody<TEncoding>>>\n) => ReturnType<typeof _readRawBody<TEncoding>>\nexport const readRawBody: PrependOverload<\n  typeof _readRawBody,\n  WrappedReadRawBody\n> = createWrapperFunction(_readRawBody)\ntype WrappedReadBody = <T, TEventInput = InferEventInput<'body', H3Event, T>>(\n  ...args: Tail<Parameters<typeof _readBody<T, H3Event, TEventInput>>>\n) => ReturnType<typeof _readBody<T, H3Event, TEventInput>>\nexport const readBody: PrependOverload<typeof _readBody, WrappedReadBody> =\n  createWrapperFunction(_readBody)\ntype WrappedGetQuery = <\n  T,\n  TEventInput = Exclude<InferEventInput<'query', H3Event, T>, undefined>,\n>(\n  ...args: Tail<Parameters<typeof _getQuery<T, H3Event, TEventInput>>>\n) => ReturnType<typeof _getQuery<T, H3Event, TEventInput>>\nexport const getQuery: PrependOverload<typeof _getQuery, WrappedGetQuery> =\n  createWrapperFunction(_getQuery)\nexport const isMethod = createWrapperFunction(_isMethod)\nexport const isPreflightRequest = createWrapperFunction(_isPreflightRequest)\ntype WrappedGetValidatedQuery = <\n  T,\n  TEventInput = InferEventInput<'query', H3Event, T>,\n>(\n  ...args: Tail<Parameters<typeof _getValidatedQuery<T, H3Event, TEventInput>>>\n) => ReturnType<typeof _getValidatedQuery<T, H3Event, TEventInput>>\nexport const getValidatedQuery: PrependOverload<\n  typeof _getValidatedQuery,\n  WrappedGetValidatedQuery\n> = createWrapperFunction(_getValidatedQuery)\nexport const getRouterParams = createWrapperFunction(_getRouterParams)\nexport const getRouterParam = createWrapperFunction(_getRouterParam)\ntype WrappedGetValidatedRouterParams = <\n  T,\n  TEventInput = InferEventInput<'routerParams', H3Event, T>,\n>(\n  ...args: Tail<\n    Parameters<typeof _getValidatedRouterParams<T, H3Event, TEventInput>>\n  >\n) => ReturnType<typeof _getValidatedRouterParams<T, H3Event, TEventInput>>\nexport const getValidatedRouterParams: PrependOverload<\n  typeof _getValidatedRouterParams,\n  WrappedGetValidatedRouterParams\n> = createWrapperFunction(_getValidatedRouterParams)\nexport const assertMethod = createWrapperFunction(_assertMethod)\nexport const getRequestHeaders = createWrapperFunction(_getRequestHeaders)\nexport const getRequestHeader = createWrapperFunction(_getRequestHeader)\nexport const getRequestURL = createWrapperFunction(_getRequestURL)\nexport const getRequestHost = createWrapperFunction(_getRequestHost)\nexport const getRequestProtocol = createWrapperFunction(_getRequestProtocol)\nexport const getRequestIP = createWrapperFunction(_getRequestIP)\nexport const send = createWrapperFunction(_send)\nexport const sendNoContent = createWrapperFunction(_sendNoContent)\nexport const setResponseStatus = createWrapperFunction(_setResponseStatus)\nexport const getResponseStatus = createWrapperFunction(_getResponseStatus)\nexport const getResponseStatusText = createWrapperFunction(\n  _getResponseStatusText,\n)\nexport const getResponseHeaders = createWrapperFunction(_getResponseHeaders)\nexport const getResponseHeader = createWrapperFunction(_getResponseHeader)\nexport const setResponseHeaders = createWrapperFunction(_setResponseHeaders)\ntype WrappedSetResponseHeader = <T extends HTTPHeaderName>(\n  ...args: Tail<Parameters<typeof _setResponseHeader<T>>>\n) => ReturnType<typeof _setResponseHeader<T>>\nexport const setResponseHeader: PrependOverload<\n  typeof _setResponseHeader,\n  WrappedSetResponseHeader\n> = createWrapperFunction(_setResponseHeader)\nexport const appendResponseHeaders = createWrapperFunction(\n  _appendResponseHeaders,\n)\ntype WrappedAppendResponseHeader = <T extends HTTPHeaderName>(\n  ...args: Tail<Parameters<typeof _appendResponseHeader<T>>>\n) => ReturnType<typeof _appendResponseHeader<T>>\nexport const appendResponseHeader: PrependOverload<\n  typeof _appendResponseHeader,\n  WrappedAppendResponseHeader\n> = createWrapperFunction(_appendResponseHeader)\nexport const defaultContentType = createWrapperFunction(_defaultContentType)\nexport const sendRedirect = createWrapperFunction(_sendRedirect)\nexport const sendStream = createWrapperFunction(_sendStream)\nexport const writeEarlyHints = createWrapperFunction(_writeEarlyHints)\nexport const sendError = createWrapperFunction(_sendError)\nexport const sendProxy = createWrapperFunction(_sendProxy)\nexport const proxyRequest = createWrapperFunction(_proxyRequest)\ntype WrappedFetchWithEvent = <\n  T = unknown,\n  TResponse = any,\n  TFetch extends (req: RequestInfo | URL, opts?: any) => any = typeof fetch,\n>(\n  ...args: Tail<Parameters<typeof _fetchWithEvent<T, TResponse, TFetch>>>\n) => ReturnType<typeof _fetchWithEvent<T, TResponse, TFetch>>\nexport const fetchWithEvent: PrependOverload<\n  typeof _fetchWithEvent,\n  WrappedFetchWithEvent\n> = createWrapperFunction(_fetchWithEvent)\nexport const getProxyRequestHeaders = createWrapperFunction(\n  _getProxyRequestHeaders,\n)\n\nexport const parseCookies = createWrapperFunction(_parseCookies)\nexport const getCookie = createWrapperFunction(_getCookie)\nexport const setCookie = createWrapperFunction(_setCookie)\nexport const deleteCookie = createWrapperFunction(_deleteCookie)\n// not exported :(\ntype SessionDataT = Record<string, any>\ntype WrappedUseSession = <T extends SessionDataT>(\n  ...args: Tail<Parameters<typeof _useSession<T>>>\n) => ReturnType<typeof _useSession<T>>\n// we need to `as` these because the WrapFunction doesn't work for them\n// because they also accept CompatEvent instead of H3Event\nexport const useSession = createWrapperFunction(_useSession) as PrependOverload<\n  typeof _useSession,\n  WrappedUseSession\n>\ntype WrappedGetSession = <T extends SessionDataT>(\n  ...args: Tail<Parameters<typeof _getSession<T>>>\n) => ReturnType<typeof _getSession<T>>\nexport const getSession = createWrapperFunction(_getSession) as PrependOverload<\n  typeof _getSession,\n  WrappedGetSession\n>\ntype WrappedUpdateSession = <T extends SessionDataT>(\n  ...args: Tail<Parameters<typeof _updateSession<T>>>\n) => ReturnType<typeof _updateSession<T>>\nexport const updateSession: PrependOverload<\n  typeof _updateSession,\n  WrappedUpdateSession\n> = createWrapperFunction(_updateSession)\ntype WrappedSealSession = <T extends SessionDataT>(\n  ...args: Tail<Parameters<typeof _sealSession<T>>>\n) => ReturnType<typeof _sealSession<T>>\nexport const sealSession = createWrapperFunction(\n  _sealSession,\n) as PrependOverload<typeof _sealSession, WrappedSealSession>\nexport const unsealSession = createWrapperFunction(_unsealSession)\nexport const clearSession = createWrapperFunction(_clearSession)\nexport const handleCacheHeaders = createWrapperFunction(_handleCacheHeaders)\nexport const handleCors = createWrapperFunction(_handleCors)\nexport const appendCorsHeaders = createWrapperFunction(_appendCorsHeaders)\nexport const appendCorsPreflightHeaders = createWrapperFunction(\n  _appendCorsPreflightHeaders,\n)\nexport const sendWebResponse = createWrapperFunction(_sendWebResponse)\ntype WrappedAppendHeader = <T extends HTTPHeaderName>(\n  ...args: Tail<Parameters<typeof _appendHeader<T>>>\n) => ReturnType<typeof _appendHeader<T>>\nexport const appendHeader: PrependOverload<\n  typeof _appendHeader,\n  WrappedAppendHeader\n> = createWrapperFunction(_appendHeader)\nexport const appendHeaders = createWrapperFunction(_appendHeaders)\ntype WrappedSetHeader = <T extends HTTPHeaderName>(\n  ...args: Tail<Parameters<typeof _setHeader<T>>>\n) => ReturnType<typeof _setHeader<T>>\nexport const setHeader: PrependOverload<typeof _setHeader, WrappedSetHeader> =\n  createWrapperFunction(_setHeader)\nexport const setHeaders = createWrapperFunction(_setHeaders)\nexport const getHeader = createWrapperFunction(_getHeader)\nexport const getHeaders = createWrapperFunction(_getHeaders)\nexport const getRequestFingerprint = createWrapperFunction(\n  _getRequestFingerprint,\n)\nexport const getRequestWebStream = createWrapperFunction(_getRequestWebStream)\nexport const readFormData = createWrapperFunction(_readFormData)\nexport const readMultipartFormData = createWrapperFunction(\n  _readMultipartFormData,\n)\ntype WrappedReadValidatedBody = <\n  T,\n  TEventInput = InferEventInput<'body', H3Event, T>,\n>(\n  ...args: Tail<Parameters<typeof _readValidatedBody<T, H3Event, TEventInput>>>\n) => ReturnType<typeof _readValidatedBody<T, H3Event, TEventInput>>\nexport const readValidatedBody: PrependOverload<\n  typeof _readValidatedBody,\n  WrappedReadValidatedBody\n> = createWrapperFunction(_readValidatedBody)\nexport const removeResponseHeader = createWrapperFunction(_removeResponseHeader)\nexport const getContext = createWrapperFunction(_getContext)\nexport const setContext = createWrapperFunction(_setContext)\nexport const clearResponseHeaders = createWrapperFunction(_clearResponseHeaders)\nexport const getWebRequest = createWrapperFunction(_toWebRequest)\n\nexport type RequestHandler = (ctx: {\n  request: Request\n}) => Promise<Response> | Response\n\nexport function requestHandler(handler: RequestHandler) {\n  return handler\n}\n"],"names":["_defineEventHandler","_eventHandler","_readRawBody","_readBody","_getQuery","_isMethod","_isPreflightRequest","_getValidatedQuery","_getRouterParams","_getRouterParam","_getValidatedRouterParams","_assertMethod","_getRequestHeaders","_getRequestHeader","_getRequestURL","_getRequestHost","_getRequestProtocol","_getRequestIP","_send","_sendNoContent","_setResponseStatus","_getResponseStatus","_getResponseStatusText","_getResponseHeaders","_getResponseHeader","_setResponseHeaders","_setResponseHeader","_appendResponseHeaders","_appendResponseHeader","_defaultContentType","_sendRedirect","_sendStream","_writeEarlyHints","_sendError","_sendProxy","_proxyRequest","_fetchWithEvent","_getProxyRequestHeaders","_parseCookies","_getCookie","_setCookie","_deleteCookie","_useSession","_getSession","_updateSession","_sealSession","_unsealSession","_clearSession","_handleCacheHeaders","_handleCors","_appendCorsHeaders","_appendCorsPreflightHeaders","_sendWebResponse","_appendHeader","_appendHeaders","_setHeader","_setHeaders","_getHeader","_getHeaders","_getRequestFingerprint","_getRequestWebStream","_readFormData","_readMultipartFormData","_readValidatedBody","_removeResponseHeader","_clearResponseHeaders","_toWebRequest"],"mappings":"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"}

package/dist/esm/handlerCallback.d.ts

@@ -0,0 +1,9 @@
+import { AnyRouter } from '@tanstack/router-core';
+export interface HandlerCallback<TRouter extends AnyRouter> {
+    (ctx: {
+        request: Request;
+        router: TRouter;
+        responseHeaders: Headers;
+    }): Response | Promise<Response>;
+}
+export declare function defineHandlerCallback<TRouter extends AnyRouter>(handler: HandlerCallback<TRouter>): HandlerCallback<TRouter>;

package/dist/esm/handlerCallback.js

@@ -0,0 +1,7 @@
+function defineHandlerCallback(handler) {
+  return handler;
+}
+export {
+  defineHandlerCallback
+};
+//# sourceMappingURL=handlerCallback.js.map

package/dist/esm/handlerCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlerCallback.js","sources":["../../src/handlerCallback.ts"],"sourcesContent":["import type { AnyRouter } from '@tanstack/router-core'\n\nexport interface HandlerCallback<TRouter extends AnyRouter> {\n  (ctx: {\n    request: Request\n    router: TRouter\n    responseHeaders: Headers\n  }): Response | Promise<Response>\n}\n\nexport function defineHandlerCallback<TRouter extends AnyRouter>(\n  handler: HandlerCallback<TRouter>,\n): HandlerCallback<TRouter> {\n  return handler\n}\n"],"names":[],"mappings":"AAUO,SAAS,sBACd,SAC0B;AACnB,SAAA;AACT;"}

package/dist/esm/index.d.ts

@@ -0,0 +1,12 @@
+export { transformReadableStreamWithRouter, transformPipeableStreamWithRouter, } from './transformStreamWithRouter.js';
+export { createStartHandler } from './createStartHandler.js';
+export type { CustomizeStartHandler } from './createStartHandler.js';
+export { createRequestHandler } from './createRequestHandler.js';
+export { defineHandlerCallback } from './handlerCallback.js';
+export type { HandlerCallback } from './handlerCallback.js';
+export { attachRouterServerSsrUtils, dehydrateRouter } from './ssr-server.js';
+export { handleServerAction } from './server-functions-handler.js';
+export * from './h3.js';
+export { createServerRoute, createServerFileRoute, createServerRootRoute, } from './serverRoute.js';
+export type { CreateServerFileRoute, ServerFileRoutesByPath, ServerRouteOptions, ServerRouteManifest, ServerRouteAddFileChildrenFn, ServerRouteMethodBuilderOptions, AnyServerRouteWithTypes, ServerRouteWithTypes, ServerRouteTypes, ResolveAllServerContext, AnyServerRoute, ServerRoute, ServerRouteMiddleware, ServerRouteAfterMiddleware, ServerRouteMethods, ServerRouteMethodsOptions, ServerRouteMethodsRecord, ServerRouteMethodRecordValue, ServerRouteVerb, ServerRouteMethodHandlerFn, ServerRouteMethodHandlerCtx, MergeMethodMiddlewares, AssignAllMethodContext, AnyRouteMethodsBuilder, ServerRouteMethodBuilder, ServerRouteMethodBuilderWithTypes, ServerRouteMethodBuilderTypes, ServerRouteMethodBuilderMiddleware, ServerRouteMethodBuilderAfterMiddleware, ServerRouteMethodBuilderHandler, ServerRouteMethodBuilderAfterHandler, ServerRouteMethod, ServerRouteAfterMethods, } from './serverRoute.js';
+export * from './virtual-modules.js';