@orpc/server 0.0.0-next.d74cac4 → 0.0.0-next.d760838

package/dist/chunk-XXBE6CYD.js

@@ -1,379 +0,0 @@
-// 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 { intercept, toError, value } from "@orpc/shared";
-function createProcedureClient(lazyableProcedure, ...[options]) {
-  return async (...[input, callerOptions]) => {
-    const path = options?.path ?? [];
-    const { default: procedure } = await unlazy(lazyableProcedure);
-    const clientContext = callerOptions?.context ?? {};
-    const context = await value(options?.context ?? {}, clientContext);
-    const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
-    try {
-      return await intercept(
-        options?.interceptors ?? [],
-        {
-          context,
-          input,
-          // input only optional when it undefinable so we can safely cast it
-          errors,
-          path,
-          procedure,
-          signal: callerOptions?.signal,
-          lastEventId: callerOptions?.lastEventId
-        },
-        (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
-      );
-    } 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;
-}
-
-// src/utils.ts
-import { isContractProcedure as isContractProcedure2 } from "@orpc/contract";
-function eachContractProcedure(options, callback, laziedOptions = []) {
-  const hiddenContract = getRouterContract(options.router);
-  if (hiddenContract) {
-    return eachContractProcedure(
-      {
-        router: hiddenContract,
-        path: options.path
-      },
-      callback,
-      laziedOptions
-    );
-  }
-  if (isLazy(options.router)) {
-    laziedOptions.push({
-      lazied: options.router,
-      path: options.path
-    });
-  } else if (isContractProcedure2(options.router)) {
-    callback({
-      contract: options.router,
-      path: options.path
-    });
-  } else {
-    for (const key in options.router) {
-      eachContractProcedure(
-        {
-          router: options.router[key],
-          path: [...options.path, key]
-        },
-        callback,
-        laziedOptions
-      );
-    }
-  }
-  return laziedOptions;
-}
-async function eachAllContractProcedure(options, callback) {
-  const pending = [options];
-  for (const item of pending) {
-    const lazies = eachContractProcedure(item, callback);
-    for (const lazy2 of lazies) {
-      const { default: router } = await unlazy(lazy2.lazied);
-      pending.push({
-        path: lazy2.path,
-        router
-      });
-    }
-  }
-}
-function convertPathToHttpPath(path) {
-  return `/${path.map(encodeURIComponent).join("/")}`;
-}
-function createContractedProcedure(contract, procedure) {
-  return new Procedure({
-    ...procedure["~orpc"],
-    errorMap: contract["~orpc"].errorMap,
-    route: contract["~orpc"].route,
-    meta: contract["~orpc"].meta
-  });
-}
-
-export {
-  LAZY_LOADER_SYMBOL,
-  lazy,
-  isLazy,
-  unlazy,
-  Procedure,
-  isProcedure,
-  flatLazy,
-  createLazyProcedureFormAnyLazy,
-  addMiddleware,
-  middlewareOutputFn,
-  createProcedureClient,
-  setRouterContract,
-  getRouterContract,
-  deepSetLazyRouterPrefix,
-  getLazyRouterPrefix,
-  createAccessibleLazyRouter,
-  adaptRouter,
-  getRouterChild,
-  eachContractProcedure,
-  eachAllContractProcedure,
-  convertPathToHttpPath,
-  createContractedProcedure
-};
-//# sourceMappingURL=chunk-XXBE6CYD.js.map

package/dist/fetch.js

@@ -1,10 +0,0 @@
-import {
-  RPCHandler
-} from "./chunk-L4ESXQX7.js";
-import "./chunk-NXEANHUK.js";
-import "./chunk-XXBE6CYD.js";
-import "./chunk-XI6WGCB3.js";
-export {
-  RPCHandler
-};
-//# sourceMappingURL=fetch.js.map

package/dist/node.js

@@ -1,31 +0,0 @@
-import {
-  RPCCodec,
-  RPCMatcher,
-  StandardHandler
-} from "./chunk-NXEANHUK.js";
-import "./chunk-XXBE6CYD.js";
-import "./chunk-XI6WGCB3.js";
-
-// src/adapters/node/rpc-handler.ts
-import { sendStandardResponse, toStandardRequest } from "@orpc/server-standard-node";
-var RPCHandler = class {
-  standardHandler;
-  constructor(router, options) {
-    const codec = options?.codec ?? new RPCCodec();
-    const matcher = options?.matcher ?? new RPCMatcher();
-    this.standardHandler = new StandardHandler(router, matcher, codec, options);
-  }
-  async handle(req, res, ...rest) {
-    const standardRequest = toStandardRequest(req, res);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
-    if (!result.matched) {
-      return { matched: false };
-    }
-    await sendStandardResponse(res, result.response);
-    return { matched: true };
-  }
-};
-export {
-  RPCHandler
-};
-//# sourceMappingURL=node.js.map

package/dist/plugins.js

@@ -1,11 +0,0 @@
-import {
-  CORSPlugin,
-  CompositePlugin,
-  ResponseHeadersPlugin
-} from "./chunk-XI6WGCB3.js";
-export {
-  CORSPlugin,
-  CompositePlugin,
-  ResponseHeadersPlugin
-};
-//# sourceMappingURL=plugins.js.map

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

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

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

@@ -1,11 +0,0 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { Context } from '../../context';
-import type { Router } from '../../router';
-import type { RPCHandlerOptions, StandardHandleOptions } from '../standard';
-import type { FetchHandler, FetchHandleResult } from './types';
-export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
-    private readonly standardHandler;
-    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
-    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<FetchHandleResult>;
-}
-//# sourceMappingURL=rpc-handler.d.ts.map

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

@@ -1,14 +0,0 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { Context } from '../../context';
-import type { StandardHandleOptions } from '../standard';
-export type FetchHandleResult = {
-    matched: true;
-    response: Response;
-} | {
-    matched: false;
-    response: undefined;
-};
-export interface FetchHandler<T extends Context> {
-    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<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 { MaybeOptionalOptions, Value } from '@orpc/shared';
-import type { Context as HonoContext, MiddlewareHandler } from 'hono';
-import type { Context } from '../../context';
-import type { FetchHandler } from '../fetch';
-import type { StandardHandleOptions } from '../standard';
-export type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<T, [HonoContext]>;
-} : {
-    context: Value<T, [HonoContext]>;
-});
-export declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<CreateMiddlewareOptions<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 { MaybeOptionalOptions, Value } from '@orpc/shared';
-import type { NextRequest } from 'next/server';
-import type { Context } from '../../context';
-import type { FetchHandler } from '../fetch';
-import type { StandardHandleOptions } from '../standard';
-export type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<T, [NextRequest]>;
-} : {
-    context: Value<T, [NextRequest]>;
-});
-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]: MaybeOptionalOptions<ServeOptions<T>>): ServeResult;
-//# sourceMappingURL=serve.d.ts.map

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

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

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

@@ -1,11 +0,0 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { Context } from '../../context';
-import type { Router } from '../../router';
-import type { RPCHandlerOptions, StandardHandleOptions } from '../standard';
-import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from './types';
-export declare class RPCHandler<T extends Context> implements NodeHttpHandler<T> {
-    private readonly standardHandler;
-    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
-    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
-}
-//# sourceMappingURL=rpc-handler.d.ts.map

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

@@ -1,22 +0,0 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
-import type { Context } from '../../context';
-import type { StandardHandleOptions } from '../standard';
-export type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
-    /**
-     * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
-     * This is useful for `express.js` middleware.
-     */
-    originalUrl?: string;
-};
-export type NodeHttpResponse = ServerResponse | Http2ServerResponse;
-export type NodeHttpHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-export interface NodeHttpHandler<T extends Context> {
-    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/standard/handler.d.ts

@@ -1,51 +0,0 @@
-import type { ErrorMap, HTTPPath, Meta, Schema } from '@orpc/contract';
-import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
-import type { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import type { Context } from '../../context';
-import type { Plugin } from '../../plugins';
-import type { CreateProcedureClientOptions } from '../../procedure-client';
-import type { Router } from '../../router';
-import type { StandardCodec, StandardMatcher } from './types';
-export type StandardHandleOptions<T extends Context> = {
-    prefix?: HTTPPath;
-} & (Record<never, never> extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-export type WellStandardHandleOptions<T extends Context> = StandardHandleOptions<T> & {
-    context: T;
-};
-export type StandardHandleResult = {
-    matched: true;
-    response: StandardResponse;
-} | {
-    matched: false;
-    response: undefined;
-};
-export type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
-    request: StandardRequest;
-};
-export type WellCreateProcedureClientOptions<TContext extends Context> = CreateProcedureClientOptions<TContext, Schema, Schema, unknown, ErrorMap, Meta, Record<never, never>> & {
-    context: TContext;
-};
-export interface StandardHandlerOptions<TContext extends Context> {
-    plugins?: Plugin<TContext>[];
-    /**
-     * Interceptors at the request level, helpful when you want catch errors
-     */
-    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
-    /**
-     * Interceptors at the root level, helpful when you want override the response
-     */
-    interceptorsRoot?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
-}
-export declare class StandardHandler<T extends Context> {
-    private readonly matcher;
-    private readonly codec;
-    private readonly options;
-    private readonly plugin;
-    constructor(router: Router<T, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<T>>);
-    handle(request: StandardRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
-}
-//# sourceMappingURL=handler.d.ts.map

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

@@ -1,7 +0,0 @@
-export * from './handler';
-export * from './rpc-codec';
-export * from './rpc-handler';
-export * from './rpc-matcher';
-export * from './rpc-serializer';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/standard/rpc-codec.d.ts

@@ -1,16 +0,0 @@
-import type { ORPCError } from '@orpc/contract';
-import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
-import type { AnyProcedure } from '../../procedure';
-import type { StandardCodec, StandardParams } from './types';
-import { RPCSerializer } from './rpc-serializer';
-export interface StandardCodecOptions {
-    serializer?: RPCSerializer;
-}
-export declare class RPCCodec implements StandardCodec {
-    private readonly serializer;
-    constructor(options?: StandardCodecOptions);
-    decode(request: StandardRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
-    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
-    encodeError(error: ORPCError<any, any>): StandardResponse;
-}
-//# sourceMappingURL=rpc-codec.d.ts.map

package/dist/src/adapters/standard/rpc-handler.d.ts

@@ -1,8 +0,0 @@
-import type { Context } from '../../context';
-import type { StandardHandlerOptions } from './handler';
-import type { StandardCodec, StandardMatcher } from './types';
-export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T> {
-    matcher?: StandardMatcher;
-    codec?: StandardCodec;
-}
-//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/standard/rpc-matcher.d.ts

@@ -1,10 +0,0 @@
-import type { HTTPPath } from '@orpc/contract';
-import type { StandardMatcher, StandardMatchResult } from './types';
-import { type AnyRouter } from '../../router';
-export declare class RPCMatcher implements StandardMatcher {
-    private readonly tree;
-    private pendingRouters;
-    init(router: AnyRouter, path?: string[]): void;
-    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
-}
-//# sourceMappingURL=rpc-matcher.d.ts.map

package/dist/src/adapters/standard/rpc-serializer.d.ts

@@ -1,22 +0,0 @@
-import type { Segment } from '@orpc/shared';
-export type RPCSerializedJsonMeta = ['bigint' | 'date' | 'nan' | 'undefined' | 'set' | 'map' | 'regexp' | 'url', Segment[]][];
-export type RPCSerialized = {
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-} | FormData | AsyncIteratorObject<{
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-}, {
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-}, void>;
-export type RPCSerializedFormDataMaps = Segment[][];
-export declare class RPCSerializer {
-    serialize(data: unknown): RPCSerialized;
-    deserialize(serialized: RPCSerialized): unknown;
-}
-export declare function serializeRPCJson(value: unknown, segments?: Segment[], meta?: RPCSerializedJsonMeta): {
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-};
-//# sourceMappingURL=rpc-serializer.d.ts.map