@orpc/server 0.0.0-next.c099c92 → 0.0.0-next.c0afbea

package/dist/chunk-KK4SDLC7.js

@@ -1,320 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/lazy.ts
-var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
-function lazy(loader) {
-  return {
-    [LAZY_LOADER_SYMBOL]: loader
-  };
-}
-function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_LOADER_SYMBOL in item && typeof item[LAZY_LOADER_SYMBOL] === "function";
-}
-function unlazy(lazied) {
-  return isLazy(lazied) ? lazied[LAZY_LOADER_SYMBOL]() : Promise.resolve({ default: lazied });
-}
-
-// src/procedure.ts
-import { isContractProcedure } from "@orpc/contract";
-var Procedure = class {
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-};
-function isProcedure(item) {
-  if (item instanceof Procedure) {
-    return true;
-  }
-  return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
-}
-
-// src/lazy-utils.ts
-function flatLazy(lazied) {
-  const flattenLoader = async () => {
-    let current = await unlazy(lazied);
-    while (true) {
-      if (!isLazy(current.default)) {
-        break;
-      }
-      current = await unlazy(current.default);
-    }
-    return current;
-  };
-  return lazy(flattenLoader);
-}
-function createLazyProcedureFormAnyLazy(lazied) {
-  const lazyProcedure = lazy(async () => {
-    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
-    if (!isProcedure(maybeProcedure)) {
-      throw new Error(`
-            Expected a lazy<procedure> but got lazy<unknown>.
-            This should be caught by TypeScript compilation.
-            Please report this issue if this makes you feel uncomfortable.
-        `);
-    }
-    return { default: maybeProcedure };
-  });
-  return lazyProcedure;
-}
-
-// src/middleware.ts
-function middlewareOutputFn(output) {
-  return { output, context: {} };
-}
-
-// src/procedure-client.ts
-import { createORPCErrorConstructorMap, ORPCError, validateORPCError, ValidationError } from "@orpc/contract";
-import { executeWithHooks, toError, value } from "@orpc/shared";
-function createProcedureClient(lazyableProcedure, ...[options]) {
-  return async (...[input, callerOptions]) => {
-    const path = options?.path ?? [];
-    const { default: procedure } = await unlazy(lazyableProcedure);
-    const context = await value(options?.context ?? {}, callerOptions?.context);
-    const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
-    const executeOptions = {
-      input,
-      context,
-      errors,
-      path,
-      procedure,
-      signal: callerOptions?.signal
-    };
-    try {
-      const output = await executeWithHooks({
-        hooks: options,
-        input,
-        context,
-        meta: executeOptions,
-        execute: () => executeProcedureInternal(procedure, executeOptions)
-      });
-      return output;
-    } catch (e) {
-      if (!(e instanceof ORPCError)) {
-        throw toError(e);
-      }
-      const validated = await validateORPCError(procedure["~orpc"].errorMap, e);
-      throw validated;
-    }
-  };
-}
-async function validateInput(procedure, input) {
-  const schema = procedure["~orpc"].inputSchema;
-  if (!schema) {
-    return input;
-  }
-  const result = await schema["~standard"].validate(input);
-  if (result.issues) {
-    throw new ORPCError("BAD_REQUEST", {
-      message: "Input validation failed",
-      data: {
-        issues: result.issues
-      },
-      cause: new ValidationError({ message: "Input validation failed", issues: result.issues })
-    });
-  }
-  return result.value;
-}
-async function validateOutput(procedure, output) {
-  const schema = procedure["~orpc"].outputSchema;
-  if (!schema) {
-    return output;
-  }
-  const result = await schema["~standard"].validate(output);
-  if (result.issues) {
-    throw new ORPCError("INTERNAL_SERVER_ERROR", {
-      message: "Output validation failed",
-      cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
-    });
-  }
-  return result.value;
-}
-async function executeProcedureInternal(procedure, options) {
-  const middlewares = procedure["~orpc"].middlewares;
-  const inputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].inputValidationIndex), middlewares.length);
-  const outputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].outputValidationIndex), middlewares.length);
-  let currentIndex = 0;
-  let currentContext = options.context;
-  let currentInput = options.input;
-  const next = async (...[nextOptions]) => {
-    const index = currentIndex;
-    currentIndex += 1;
-    currentContext = { ...currentContext, ...nextOptions?.context };
-    if (index === inputValidationIndex) {
-      currentInput = await validateInput(procedure, currentInput);
-    }
-    const mid = middlewares[index];
-    const result = mid ? await mid({ ...options, context: currentContext, next }, currentInput, middlewareOutputFn) : { output: await procedure["~orpc"].handler({ ...options, context: currentContext, input: currentInput }), context: currentContext };
-    if (index === outputValidationIndex) {
-      const validatedOutput = await validateOutput(procedure, result.output);
-      return {
-        ...result,
-        output: validatedOutput
-      };
-    }
-    return result;
-  };
-  return (await next({})).output;
-}
-
-// src/hidden.ts
-var ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
-function setRouterContract(obj, contract) {
-  return new Proxy(obj, {
-    get(target, key) {
-      if (key === ROUTER_CONTRACT_SYMBOL) {
-        return contract;
-      }
-      return Reflect.get(target, key);
-    }
-  });
-}
-function getRouterContract(obj) {
-  return obj[ROUTER_CONTRACT_SYMBOL];
-}
-var LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
-function deepSetLazyRouterPrefix(router, prefix) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key !== LAZY_ROUTER_PREFIX_SYMBOL) {
-        const val = Reflect.get(target, key);
-        if (isLazy(val)) {
-          return deepSetLazyRouterPrefix(val, prefix);
-        }
-        return val;
-      }
-      return prefix;
-    }
-  });
-}
-function getLazyRouterPrefix(obj) {
-  return obj[LAZY_ROUTER_PREFIX_SYMBOL];
-}
-
-// src/router.ts
-import { adaptRoute, mergeErrorMap, mergePrefix } from "@orpc/contract";
-
-// src/middleware-utils.ts
-function dedupeMiddlewares(compare, middlewares) {
-  let min = 0;
-  for (let i = 0; i < middlewares.length; i++) {
-    const index = compare.indexOf(middlewares[i], min);
-    if (index === -1) {
-      return middlewares.slice(i);
-    }
-    min = index + 1;
-  }
-  return [];
-}
-function mergeMiddlewares(first, second) {
-  return [...first, ...dedupeMiddlewares(first, second)];
-}
-function addMiddleware(middlewares, addition) {
-  return [...middlewares, addition];
-}
-
-// src/router.ts
-function adaptRouter(router, options) {
-  if (isLazy(router)) {
-    const adapted2 = lazy(async () => {
-      const unlaziedRouter = (await unlazy(router)).default;
-      const adapted3 = adaptRouter(unlaziedRouter, options);
-      return { default: adapted3 };
-    });
-    const accessible = createAccessibleLazyRouter(adapted2);
-    const currentPrefix = getLazyRouterPrefix(router);
-    const prefix = currentPrefix ? mergePrefix(options.prefix, currentPrefix) : options.prefix;
-    if (prefix) {
-      return deepSetLazyRouterPrefix(accessible, prefix);
-    }
-    return accessible;
-  }
-  if (isProcedure(router)) {
-    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares);
-    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
-    const adapted2 = new Procedure({
-      ...router["~orpc"],
-      route: adaptRoute(router["~orpc"].route, options),
-      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
-      middlewares: newMiddlewares,
-      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
-      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
-    });
-    return adapted2;
-  }
-  const adapted = {};
-  for (const key in router) {
-    adapted[key] = adaptRouter(router[key], options);
-  }
-  return adapted;
-}
-function getRouterChild(router, ...path) {
-  let current = router;
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i];
-    if (!current) {
-      return void 0;
-    }
-    if (isProcedure(current)) {
-      return void 0;
-    }
-    if (!isLazy(current)) {
-      current = current[segment];
-      continue;
-    }
-    const lazied = current;
-    const rest = path.slice(i);
-    const newLazy = lazy(async () => {
-      const unwrapped = await unlazy(lazied);
-      if (!unwrapped.default) {
-        return unwrapped;
-      }
-      const next = getRouterChild(unwrapped.default, ...rest);
-      return { default: next };
-    });
-    return flatLazy(newLazy);
-  }
-  return current;
-}
-
-// src/router-accessible-lazy.ts
-function createAccessibleLazyRouter(lazied) {
-  const flattenLazy = flatLazy(lazied);
-  const recursive = new Proxy(flattenLazy, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      const next = getRouterChild(flattenLazy, key);
-      return createAccessibleLazyRouter(next);
-    }
-  });
-  return recursive;
-}
-
-export {
-  __export,
-  LAZY_LOADER_SYMBOL,
-  lazy,
-  isLazy,
-  unlazy,
-  Procedure,
-  isProcedure,
-  flatLazy,
-  createLazyProcedureFormAnyLazy,
-  addMiddleware,
-  middlewareOutputFn,
-  createProcedureClient,
-  setRouterContract,
-  getRouterContract,
-  deepSetLazyRouterPrefix,
-  getLazyRouterPrefix,
-  createAccessibleLazyRouter,
-  adaptRouter,
-  getRouterChild
-};
-//# sourceMappingURL=chunk-KK4SDLC7.js.map

package/dist/chunk-WUOGVGWG.js

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-WUOGVGWG.js.map

package/dist/fetch.js

@@ -1,15 +0,0 @@
-import "./chunk-WUOGVGWG.js";
-import {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports
-} from "./chunk-ESTRJAOX.js";
-import "./chunk-KK4SDLC7.js";
-export {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports as SuperJSON
-};
-//# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -1,30 +0,0 @@
-import "./chunk-WUOGVGWG.js";
-import {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports
-} from "./chunk-ESTRJAOX.js";
-import "./chunk-KK4SDLC7.js";
-
-// src/adapters/hono/middleware.ts
-import { value } from "@orpc/shared";
-function createMiddleware(handler, ...[options]) {
-  return async (c, next) => {
-    const context = await value(options?.context ?? {}, c);
-    const { matched, response } = await handler.handle(c.req.raw, { ...options, context });
-    if (matched) {
-      c.res = response;
-      return;
-    }
-    await next();
-  };
-}
-export {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports as SuperJSON,
-  createMiddleware
-};
-//# sourceMappingURL=hono.js.map

package/dist/node.js

@@ -1,87 +0,0 @@
-import {
-  RPCHandler
-} from "./chunk-ESTRJAOX.js";
-import "./chunk-KK4SDLC7.js";
-
-// src/adapters/node/request-listener.ts
-function createRequest(req, res) {
-  const controller = new AbortController();
-  res.on("close", () => {
-    controller.abort();
-  });
-  const method = req.method ?? "GET";
-  const headers = createHeaders(req);
-  const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
-  const host = headers.get("Host") ?? "localhost";
-  const url = new URL(req.originalUrl ?? req.url ?? "/", `${protocol}//${host}`);
-  const init = { method, headers, signal: controller.signal };
-  if (method !== "GET" && method !== "HEAD") {
-    init.body = new ReadableStream({
-      start(controller2) {
-        req.on("data", (chunk) => {
-          controller2.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
-        });
-        req.on("end", () => {
-          controller2.close();
-        });
-      }
-    });
-    init.duplex = "half";
-  }
-  return new Request(url, init);
-}
-function createHeaders(req) {
-  const headers = new Headers();
-  const rawHeaders = req.rawHeaders;
-  for (let i = 0; i < rawHeaders.length; i += 2) {
-    headers.append(rawHeaders[i], rawHeaders[i + 1]);
-  }
-  return headers;
-}
-async function sendResponse(res, response) {
-  const headers = {};
-  for (const [key, value] of response.headers) {
-    if (key in headers) {
-      if (Array.isArray(headers[key])) {
-        headers[key].push(value);
-      } else {
-        headers[key] = [headers[key], value];
-      }
-    } else {
-      headers[key] = value;
-    }
-  }
-  res.writeHead(response.status, headers);
-  if (response.body != null && res.req.method !== "HEAD") {
-    for await (const chunk of response.body) {
-      res.write(chunk);
-    }
-  }
-  res.end();
-}
-
-// src/adapters/node/orpc-handler.ts
-var RPCHandler2 = class {
-  orpcFetchHandler;
-  constructor(router, options) {
-    this.orpcFetchHandler = new RPCHandler(router, options);
-  }
-  async handle(req, res, ...rest) {
-    const request = createRequest(req, res);
-    const result = await this.orpcFetchHandler.handle(request, ...rest);
-    if (result.matched === false) {
-      return { matched: false };
-    }
-    const context = rest[0]?.context ?? {};
-    await rest[0]?.beforeSend?.(result.response, context);
-    await sendResponse(res, result.response);
-    return { matched: true };
-  }
-};
-export {
-  RPCHandler2 as RPCHandler,
-  createHeaders,
-  createRequest,
-  sendResponse
-};
-//# sourceMappingURL=node.js.map

package/dist/src/adapters/fetch/index.d.ts

@@ -1,6 +0,0 @@
-export * from './orpc-handler';
-export * from './orpc-payload-codec';
-export * from './orpc-procedure-matcher';
-export * as SuperJSON from './super-json';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/fetch/orpc-handler.d.ts

@@ -1,20 +0,0 @@
-import type { Hooks } from '@orpc/shared';
-import type { Context } from '../../context';
-import type { Router } from '../../router';
-import type { FetchHandler, FetchHandleRest, FetchHandleResult } from './types';
-import { type PublicORPCPayloadCodec } from './orpc-payload-codec';
-import { type PublicORPCProcedureMatcher } from './orpc-procedure-matcher';
-export type RPCHandlerOptions<T extends Context> = Hooks<Request, FetchHandleResult, T, {
-    signal?: AbortSignal;
-}> & {
-    procedureMatcher?: PublicORPCProcedureMatcher;
-    payloadCodec?: PublicORPCPayloadCodec;
-};
-export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
-    private readonly options?;
-    private readonly procedureMatcher;
-    private readonly payloadCodec;
-    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>> | undefined);
-    handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult>;
-}
-//# sourceMappingURL=orpc-handler.d.ts.map

package/dist/src/adapters/fetch/orpc-payload-codec.d.ts

@@ -1,16 +0,0 @@
-import { type HTTPMethod } from '@orpc/contract';
-export declare class ORPCPayloadCodec {
-    /**
-     * If method is GET, the payload will be encoded as query string.
-     * If method is GET and payload contain file, the method will be fallback to fallbackMethod. (fallbackMethod = GET will force to use GET method)
-     */
-    encode(payload: unknown, method?: HTTPMethod, fallbackMethod?: HTTPMethod): {
-        query?: URLSearchParams;
-        body?: FormData | string;
-        headers?: Headers;
-        method: HTTPMethod;
-    };
-    decode(re: Request | Response): Promise<unknown>;
-}
-export type PublicORPCPayloadCodec = Pick<ORPCPayloadCodec, keyof ORPCPayloadCodec>;
-//# sourceMappingURL=orpc-payload-codec.d.ts.map

package/dist/src/adapters/fetch/orpc-procedure-matcher.d.ts

@@ -1,12 +0,0 @@
-import type { AnyProcedure } from '../../procedure';
-import type { AnyRouter } from '../../router';
-export declare class ORPCProcedureMatcher {
-    private readonly router;
-    constructor(router: AnyRouter);
-    match(pathname: string): Promise<{
-        path: string[];
-        procedure: AnyProcedure;
-    } | undefined>;
-}
-export type PublicORPCProcedureMatcher = Pick<ORPCProcedureMatcher, keyof ORPCProcedureMatcher>;
-//# sourceMappingURL=orpc-procedure-matcher.d.ts.map

package/dist/src/adapters/fetch/super-json.d.ts

@@ -1,12 +0,0 @@
-import type { Segment } from '@orpc/shared';
-export type JSONExtraType = 'bigint' | 'date' | 'nan' | 'undefined' | 'set' | 'map' | 'regexp' | 'url';
-export type JSONMeta = [JSONExtraType, Segment[]][];
-export declare function serialize(value: unknown, segments?: Segment[], meta?: JSONMeta): {
-    data: unknown;
-    meta: JSONMeta;
-};
-export declare function deserialize({ data, meta, }: {
-    data: unknown;
-    meta: JSONMeta;
-}): unknown;
-//# sourceMappingURL=super-json.d.ts.map

package/dist/src/adapters/fetch/types.d.ts

@@ -1,21 +0,0 @@
-import type { HTTPPath } from '@orpc/contract';
-import type { Context } from '../../context';
-export type FetchHandleOptions<T extends Context> = {
-    prefix?: HTTPPath;
-} & (Record<never, never> extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-export type FetchHandleRest<T extends Context> = [options: FetchHandleOptions<T>] | (Record<never, never> extends T ? [] : never);
-export type FetchHandleResult = {
-    matched: true;
-    response: Response;
-} | {
-    matched: false;
-    response: undefined;
-};
-export interface FetchHandler<T extends Context> {
-    handle(request: Request, ...rest: FetchHandleRest<T>): Promise<FetchHandleResult>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/hono/index.d.ts

@@ -1,3 +0,0 @@
-export * from '../fetch';
-export * from './middleware';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/hono/middleware.d.ts

@@ -1,12 +0,0 @@
-import type { Context as HonoContext, MiddlewareHandler } from 'hono';
-import type { Context } from '../../context';
-import type { FetchHandleOptions, FetchHandler } from '../fetch';
-import { type Value } from '@orpc/shared';
-export type CreateMiddlewareOptions<T extends Context> = Omit<FetchHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<T, [HonoContext]>;
-} : {
-    context: Value<T, [HonoContext]>;
-});
-export type CreateMiddlewareRest<T extends Context> = [options: CreateMiddlewareOptions<T>] | (Record<never, never> extends T ? [] : never);
-export declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: CreateMiddlewareRest<T>): MiddlewareHandler;
-//# sourceMappingURL=middleware.d.ts.map

package/dist/src/adapters/next/index.d.ts

@@ -1,3 +0,0 @@
-export * from '../fetch';
-export * from './serve';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/next/serve.d.ts

@@ -1,19 +0,0 @@
-import type { NextRequest } from 'next/server';
-import type { Context } from '../../context';
-import type { FetchHandleOptions, FetchHandler } from '../fetch';
-import { type Value } from '@orpc/shared';
-export type ServeOptions<T extends Context> = Omit<FetchHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<T, [NextRequest]>;
-} : {
-    context: Value<T, [NextRequest]>;
-});
-export type ServeRest<T extends Context> = [options: ServeOptions<T>] | (Record<never, never> extends T ? [] : never);
-export interface ServeResult {
-    GET(req: NextRequest): Promise<Response>;
-    POST(req: NextRequest): Promise<Response>;
-    PUT(req: NextRequest): Promise<Response>;
-    PATCH(req: NextRequest): Promise<Response>;
-    DELETE(req: NextRequest): Promise<Response>;
-}
-export declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: ServeRest<T>): ServeResult;
-//# sourceMappingURL=serve.d.ts.map

package/dist/src/adapters/node/index.d.ts

@@ -1,5 +0,0 @@
-export * from './orpc-handler';
-export * from './orpc-handler';
-export * from './request-listener';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/orpc-handler.d.ts

@@ -1,12 +0,0 @@
-import type { ServerResponse } from 'node:http';
-import type { Context } from '../../context';
-import type { Router } from '../../router';
-import type { RPCHandlerOptions } from '../fetch/orpc-handler';
-import type { RequestHandler, RequestHandleRest, RequestHandleResult } from './types';
-import { type ExpressableIncomingMessage } from './request-listener';
-export declare class RPCHandler<T extends Context> implements RequestHandler<T> {
-    private readonly orpcFetchHandler;
-    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
-    handle(req: ExpressableIncomingMessage, res: ServerResponse, ...rest: RequestHandleRest<T>): Promise<RequestHandleResult>;
-}
-//# sourceMappingURL=orpc-handler.d.ts.map

package/dist/src/adapters/node/request-listener.d.ts

@@ -1,28 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-export interface ExpressableIncomingMessage extends IncomingMessage {
-    originalUrl?: string;
-}
-/**
- * Creates a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) object from a Node.js
- * [`IncomingMessage`](https://nodejs.org/api/http.html#class-httpincomingmessage) and
- * [`http.ServerResponse`](https://nodejs.org/api/http.html#class-httpserverresponse) pair.
- *
- */
-export declare function createRequest(req: ExpressableIncomingMessage, res: ServerResponse): Request;
-/**
- * Creates a [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers) object from the headers
- * in a Node.js [`IncomingMessage`](https://nodejs.org/api/http.html#class-httpincomingmessage).
- *
- * @param req The incoming request object.
- * @returns A headers object.
- */
-export declare function createHeaders(req: IncomingMessage): Headers;
-/**
- * Sends a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) to the client using the
- * Node.js [`http.ServerResponse`](https://nodejs.org/api/http.html#class-httpserverresponse) object.
- *
- * @param res The server response object.
- * @param response The response to send.
- */
-export declare function sendResponse(res: ServerResponse, response: Response): Promise<void>;
-//# sourceMappingURL=request-listener.d.ts.map

package/dist/src/adapters/node/types.d.ts

@@ -1,22 +0,0 @@
-import type { HTTPPath } from '@orpc/contract';
-import type { Promisable } from '@orpc/shared';
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Context } from '../../context';
-export type RequestHandleOptions<T extends Context> = {
-    prefix?: HTTPPath;
-    beforeSend?(response: Response, context: T): Promisable<void>;
-} & (Record<never, never> extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-export type RequestHandleRest<T extends Context> = [options: RequestHandleOptions<T>] | (Record<never, never> extends T ? [] : never);
-export type RequestHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-export interface RequestHandler<T extends Context> {
-    handle(req: IncomingMessage, res: ServerResponse, ...rest: RequestHandleRest<T>): Promise<RequestHandleResult>;
-}
-//# sourceMappingURL=types.d.ts.map