@orpc/client 0.0.0-next.3f40711 → 0.0.0-next.3f73bd3

package/dist/shared/client.WCinBImJ.d.ts

@@ -0,0 +1,91 @@
+import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.BOYsZIRq.js';
+import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.CXXEPIbK.js';
+import { Segment, Value, Promisable } from '@orpc/shared';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+
+declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
+    readonly BIGINT: 0;
+    readonly DATE: 1;
+    readonly NAN: 2;
+    readonly UNDEFINED: 3;
+    readonly URL: 4;
+    readonly REGEXP: 5;
+    readonly SET: 6;
+    readonly MAP: 7;
+};
+type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
+type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
+interface StandardRPCCustomJsonSerializer {
+    type: number;
+    condition(data: unknown): boolean;
+    serialize(data: any): unknown;
+    deserialize(serialized: any): unknown;
+}
+interface StandardRPCJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
+}
+declare class StandardRPCJsonSerializer {
+    private readonly customSerializers;
+    constructor(options?: StandardRPCJsonSerializerOptions);
+    serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
+}
+
+declare class StandardRPCSerializer {
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer: StandardRPCJsonSerializer);
+    serialize(data: unknown): object;
+    deserialize(data: unknown): unknown;
+}
+
+interface StandardRPCLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<Promisable<string | URL>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<Promisable<number>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    method?: Value<Promisable<Exclude<HTTPMethod, 'HEAD'>>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The method to use when the payload cannot safely pass to the server with method return from method function.
+     * GET is not allowed, it's very dangerous.
+     *
+     * @default 'POST'
+     */
+    fallbackMethod?: Exclude<HTTPMethod, 'HEAD' | 'GET'>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<Promisable<StandardHeaders>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+}
+declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    private readonly serializer;
+    private readonly baseUrl;
+    private readonly maxUrlLength;
+    private readonly fallbackMethod;
+    private readonly expectedMethod;
+    private readonly headers;
+    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse): Promise<unknown>;
+}
+
+interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
+}
+declare class StandardRPCLink<T extends ClientContext> extends StandardLink<T> {
+    constructor(linkClient: StandardLinkClient<T>, options: StandardRPCLinkOptions<T>);
+}
+
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, StandardRPCJsonSerializer as e, StandardRPCLink as g, StandardRPCLinkCodec as i, StandardRPCSerializer as j };
+export type { StandardRPCJsonSerializedMetaItem as a, StandardRPCJsonSerialized as b, StandardRPCCustomJsonSerializer as c, StandardRPCJsonSerializerOptions as d, StandardRPCLinkOptions as f, StandardRPCLinkCodecOptions as h };

package/dist/shared/client.aTp4sII-.d.mts

@@ -0,0 +1,91 @@
+import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.BOYsZIRq.mjs';
+import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.C4VxIexA.mjs';
+import { Segment, Value, Promisable } from '@orpc/shared';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+
+declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
+    readonly BIGINT: 0;
+    readonly DATE: 1;
+    readonly NAN: 2;
+    readonly UNDEFINED: 3;
+    readonly URL: 4;
+    readonly REGEXP: 5;
+    readonly SET: 6;
+    readonly MAP: 7;
+};
+type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
+type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
+interface StandardRPCCustomJsonSerializer {
+    type: number;
+    condition(data: unknown): boolean;
+    serialize(data: any): unknown;
+    deserialize(serialized: any): unknown;
+}
+interface StandardRPCJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
+}
+declare class StandardRPCJsonSerializer {
+    private readonly customSerializers;
+    constructor(options?: StandardRPCJsonSerializerOptions);
+    serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
+}
+
+declare class StandardRPCSerializer {
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer: StandardRPCJsonSerializer);
+    serialize(data: unknown): object;
+    deserialize(data: unknown): unknown;
+}
+
+interface StandardRPCLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<Promisable<string | URL>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<Promisable<number>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    method?: Value<Promisable<Exclude<HTTPMethod, 'HEAD'>>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The method to use when the payload cannot safely pass to the server with method return from method function.
+     * GET is not allowed, it's very dangerous.
+     *
+     * @default 'POST'
+     */
+    fallbackMethod?: Exclude<HTTPMethod, 'HEAD' | 'GET'>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<Promisable<StandardHeaders>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+}
+declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    private readonly serializer;
+    private readonly baseUrl;
+    private readonly maxUrlLength;
+    private readonly fallbackMethod;
+    private readonly expectedMethod;
+    private readonly headers;
+    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse): Promise<unknown>;
+}
+
+interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
+}
+declare class StandardRPCLink<T extends ClientContext> extends StandardLink<T> {
+    constructor(linkClient: StandardLinkClient<T>, options: StandardRPCLinkOptions<T>);
+}
+
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, StandardRPCJsonSerializer as e, StandardRPCLink as g, StandardRPCLinkCodec as i, StandardRPCSerializer as j };
+export type { StandardRPCJsonSerializedMetaItem as a, StandardRPCJsonSerialized as b, StandardRPCCustomJsonSerializer as c, StandardRPCJsonSerializerOptions as d, StandardRPCLinkOptions as f, StandardRPCLinkCodecOptions as h };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.3f40711",
+  "version": "0.0.0-next.3f73bd3",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,37 +15,50 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
+    },
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
+    },
+    "./websocket": {
+      "types": "./dist/adapters/websocket/index.d.mts",
+      "import": "./dist/adapters/websocket/index.mjs",
+      "default": "./dist/adapters/websocket/index.mjs"
     },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+    "./message-port": {
+      "types": "./dist/adapters/message-port/index.d.mts",
+      "import": "./dist/adapters/message-port/index.mjs",
+      "default": "./dist/adapters/message-port/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
-    "@orpc/server-standard": "^0.4.0",
-    "@orpc/server-standard-fetch": "^0.4.0",
-    "@orpc/contract": "0.0.0-next.3f40711",
-    "@orpc/shared": "0.0.0-next.3f40711",
-    "@orpc/server": "0.0.0-next.3f40711"
+    "@orpc/shared": "0.0.0-next.3f73bd3",
+    "@orpc/standard-server-fetch": "0.0.0-next.3f73bd3",
+    "@orpc/standard-server-peer": "0.0.0-next.3f73bd3",
+    "@orpc/standard-server": "0.0.0-next.3f73bd3"
   },
   "devDependencies": {
-    "zod": "^3.24.1",
-    "@orpc/openapi": "0.0.0-next.3f40711"
+    "zod": "^4.0.5"
   },
   "scripts": {
-    "build": "tsup --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-HYT35LXG.js

@@ -1,105 +0,0 @@
-// src/event-iterator-state.ts
-var iteratorStates = /* @__PURE__ */ new WeakMap();
-function registerEventIteratorState(iterator, state) {
-  iteratorStates.set(iterator, state);
-}
-function updateEventIteratorStatus(state, status) {
-  if (state.status !== status) {
-    state.status = status;
-    state.listeners.forEach((cb) => cb(status));
-  }
-}
-function onEventIteratorStatusChange(iterator, callback, notifyImmediately = true) {
-  const state = iteratorStates.get(iterator);
-  if (!state) {
-    throw new Error("Iterator is not registered.");
-  }
-  if (notifyImmediately) {
-    callback(state.status);
-  }
-  state.listeners.push(callback);
-  return () => {
-    const index = state.listeners.indexOf(callback);
-    if (index !== -1) {
-      state.listeners.splice(index, 1);
-    }
-  };
-}
-
-// src/event-iterator.ts
-import { getEventMeta } from "@orpc/server-standard";
-import { retry } from "@orpc/shared";
-var MAX_ALLOWED_RETRY_TIMES = 99;
-function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
-  const state = {
-    status: "connected",
-    listeners: []
-  };
-  const iterator = async function* () {
-    let current = initial;
-    let lastEventId = initialLastEventId;
-    let lastRetry;
-    let retryTimes = 0;
-    try {
-      while (true) {
-        try {
-          updateEventIteratorStatus(state, "connected");
-          const { done, value } = await current.next();
-          const meta = getEventMeta(value);
-          lastEventId = meta?.id ?? lastEventId;
-          lastRetry = meta?.retry ?? lastRetry;
-          retryTimes = 0;
-          if (done) {
-            return value;
-          }
-          yield value;
-        } catch (e) {
-          updateEventIteratorStatus(state, "reconnecting");
-          const meta = getEventMeta(e);
-          lastEventId = meta?.id ?? lastEventId;
-          lastRetry = meta?.retry ?? lastRetry;
-          let currentError = e;
-          current = await retry({ times: MAX_ALLOWED_RETRY_TIMES }, async (exit) => {
-            retryTimes += 1;
-            if (retryTimes > MAX_ALLOWED_RETRY_TIMES) {
-              throw exit(new Error(
-                `Exceeded maximum retry attempts (${MAX_ALLOWED_RETRY_TIMES}) for event source. Possible infinite retry loop detected. Please review the retry logic.`,
-                { cause: currentError }
-              ));
-            }
-            const reconnected = await (async () => {
-              try {
-                return await reconnect({
-                  lastRetry,
-                  lastEventId,
-                  retryTimes,
-                  error: currentError
-                });
-              } catch (e2) {
-                currentError = e2;
-                throw e2;
-              }
-            })();
-            if (!reconnected) {
-              throw exit(currentError);
-            }
-            return reconnected;
-          });
-        }
-      }
-    } finally {
-      updateEventIteratorStatus(state, "closed");
-      await current.return?.();
-    }
-  }();
-  registerEventIteratorState(iterator, state);
-  return iterator;
-}
-
-export {
-  registerEventIteratorState,
-  updateEventIteratorStatus,
-  onEventIteratorStatusChange,
-  createAutoRetryEventIterator
-};
-//# sourceMappingURL=chunk-HYT35LXG.js.map

package/dist/fetch.js

@@ -1,126 +0,0 @@
-import {
-  createAutoRetryEventIterator
-} from "./chunk-HYT35LXG.js";
-
-// src/adapters/fetch/orpc-link.ts
-import { ORPCError } from "@orpc/contract";
-import { isAsyncIteratorObject } from "@orpc/server-standard";
-import { toFetchBody, toStandardBody } from "@orpc/server-standard-fetch";
-import { RPCSerializer } from "@orpc/server/standard";
-import { trim, value } from "@orpc/shared";
-var InvalidEventSourceRetryResponse = class extends Error {
-};
-var RPCLink = class {
-  fetch;
-  rpcSerializer;
-  maxUrlLength;
-  fallbackMethod;
-  method;
-  headers;
-  url;
-  eventSourceMaxNumberOfRetries;
-  eventSourceRetryDelay;
-  eventSourceRetry;
-  constructor(options) {
-    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-    this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer();
-    this.maxUrlLength = options.maxUrlLength ?? 2083;
-    this.fallbackMethod = options.fallbackMethod ?? "POST";
-    this.url = options.url;
-    this.eventSourceMaxNumberOfRetries = options.eventSourceMaxNumberOfRetries ?? 5;
-    this.method = options.method ?? this.fallbackMethod;
-    this.headers = options.headers ?? {};
-    this.eventSourceRetry = options.eventSourceRetry ?? true;
-    this.eventSourceRetryDelay = options.eventSourceRetryDelay ?? (({ retryTimes, lastRetry }) => lastRetry ?? 1e3 * 2 ** retryTimes);
-  }
-  async call(path, input, options) {
-    const output = await this.performCall(path, input, options);
-    if (!isAsyncIteratorObject(output)) {
-      return output;
-    }
-    return createAutoRetryEventIterator(output, async (reconnectOptions) => {
-      if (options.signal?.aborted || reconnectOptions.retryTimes > this.eventSourceMaxNumberOfRetries) {
-        return null;
-      }
-      if (!await value(this.eventSourceRetry, reconnectOptions, options, path, input)) {
-        return null;
-      }
-      const delay = await value(this.eventSourceRetryDelay, reconnectOptions, options, path, input);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      const updatedOptions = { ...options, lastEventId: reconnectOptions.lastEventId };
-      const maybeIterator = await this.performCall(path, input, updatedOptions);
-      if (!isAsyncIteratorObject(maybeIterator)) {
-        throw new InvalidEventSourceRetryResponse("Invalid EventSource retry response");
-      }
-      return maybeIterator;
-    }, void 0);
-  }
-  async performCall(path, input, options) {
-    const encoded = await this.encodeRequest(path, input, options);
-    const fetchBody = toFetchBody(encoded.body, encoded.headers);
-    if (options.lastEventId !== void 0) {
-      encoded.headers.set("last-event-id", options.lastEventId);
-    }
-    const response = await this.fetch(encoded.url, {
-      method: encoded.method,
-      headers: encoded.headers,
-      body: fetchBody,
-      signal: options.signal
-    }, options, path, input);
-    const body = await toStandardBody(response);
-    const deserialized = (() => {
-      try {
-        return this.rpcSerializer.deserialize(body);
-      } catch (error) {
-        if (response.ok) {
-          throw new ORPCError("INTERNAL_SERVER_ERROR", {
-            message: "Invalid RPC response",
-            cause: error
-          });
-        }
-        throw new ORPCError(response.status.toString(), {
-          message: response.statusText
-        });
-      }
-    })();
-    if (!response.ok) {
-      if (ORPCError.isValidJSON(deserialized)) {
-        throw ORPCError.fromJSON(deserialized);
-      }
-      throw new ORPCError("INTERNAL_SERVER_ERROR", {
-        message: "Invalid RPC error response",
-        cause: deserialized
-      });
-    }
-    return deserialized;
-  }
-  async encodeRequest(path, input, options) {
-    const expectedMethod = await value(this.method, options, path, input);
-    const headers = new Headers(await value(this.headers, options, path, input));
-    const url = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
-    const serialized = this.rpcSerializer.serialize(input);
-    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
-      const getUrl = new URL(url);
-      getUrl.searchParams.append("data", JSON.stringify(serialized));
-      if (getUrl.toString().length <= this.maxUrlLength) {
-        return {
-          body: void 0,
-          method: expectedMethod,
-          headers,
-          url: getUrl
-        };
-      }
-    }
-    return {
-      url,
-      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
-      headers,
-      body: serialized
-    };
-  }
-};
-export {
-  InvalidEventSourceRetryResponse,
-  RPCLink
-};
-//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,58 +0,0 @@
-import {
-  createAutoRetryEventIterator,
-  onEventIteratorStatusChange,
-  registerEventIteratorState,
-  updateEventIteratorStatus
-} from "./chunk-HYT35LXG.js";
-
-// src/client.ts
-function createORPCClient(link, options) {
-  const path = options?.path ?? [];
-  const procedureClient = async (...[input, options2]) => {
-    const optionsOut = {
-      ...options2,
-      context: options2?.context ?? {}
-      // options.context can be undefined when all field is optional
-    };
-    return await link.call(path, input, optionsOut);
-  };
-  const recursive = new Proxy(procedureClient, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      return createORPCClient(link, {
-        ...options,
-        path: [...path, key]
-      });
-    }
-  });
-  return recursive;
-}
-
-// src/dynamic-link.ts
-var DynamicLink = class {
-  constructor(linkResolver) {
-    this.linkResolver = linkResolver;
-  }
-  async call(path, input, options) {
-    const resolvedLink = await this.linkResolver(options, path, input);
-    const output = await resolvedLink.call(path, input, options);
-    return output;
-  }
-};
-
-// src/index.ts
-import { isDefinedError, ORPCError, safe } from "@orpc/contract";
-export {
-  DynamicLink,
-  ORPCError,
-  createAutoRetryEventIterator,
-  createORPCClient,
-  isDefinedError,
-  onEventIteratorStatusChange,
-  registerEventIteratorState,
-  safe,
-  updateEventIteratorStatus
-};
-//# sourceMappingURL=index.js.map

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

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

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

@@ -1,97 +0,0 @@
-import type { ClientContext, HTTPMethod } from '@orpc/contract';
-import type { Value } from '@orpc/shared';
-import type { ClientLink, ClientOptionsOut } from '../../types';
-import type { FetchWithContext } from './types';
-import { RPCSerializer } from '@orpc/server/standard';
-import { type EventIteratorReconnectOptions } from '../../event-iterator';
-export declare class InvalidEventSourceRetryResponse extends Error {
-}
-export interface RPCLinkOptions<TClientContext extends ClientContext> {
-    /**
-     * Base url for all requests.
-     */
-    url: string;
-    /**
-     * The maximum length of the URL.
-     *
-     * @default 2083
-     */
-    maxUrlLength?: number;
-    /**
-     * The method used to make the request.
-     *
-     * @default 'POST'
-     */
-    method?: Value<HTTPMethod, [
-        options: ClientOptionsOut<TClientContext>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * The method to use when the payload cannot safely pass to the server with method return from method function.
-     * GET is not allowed, it's very dangerous.
-     *
-     * @default 'POST'
-     */
-    fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
-    /**
-     * Inject headers to the request.
-     */
-    headers?: Value<[string, string][] | Record<string, string> | Headers, [
-        options: ClientOptionsOut<TClientContext>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * Custom fetch implementation.
-     *
-     * @default globalThis.fetch.bind(globalThis)
-     */
-    fetch?: FetchWithContext<TClientContext>;
-    rpcSerializer?: RPCSerializer;
-    /**
-     * Maximum number of retry attempts for EventSource errors before throwing.
-     *
-     * @default 5
-     */
-    eventSourceMaxNumberOfRetries?: number;
-    /**
-     * Delay (in ms) before retrying an EventSource call.
-     *
-     * @default ({retryTimes, lastRetry}) => lastRetry ?? (1000 * 2 ** retryTimes)
-     */
-    eventSourceRetryDelay?: Value<number, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<TClientContext>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * Function to determine if an error is retryable.
-     *
-     * @default true
-     */
-    eventSourceRetry?: Value<boolean, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<TClientContext>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-}
-export declare class RPCLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
-    private readonly fetch;
-    private readonly rpcSerializer;
-    private readonly maxUrlLength;
-    private readonly fallbackMethod;
-    private readonly method;
-    private readonly headers;
-    private readonly url;
-    private readonly eventSourceMaxNumberOfRetries;
-    private readonly eventSourceRetryDelay;
-    private readonly eventSourceRetry;
-    constructor(options: RPCLinkOptions<TClientContext>);
-    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
-    private performCall;
-    private encodeRequest;
-}
-//# sourceMappingURL=orpc-link.d.ts.map

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

@@ -1,6 +0,0 @@
-import type { ClientContext } from '@orpc/contract';
-import type { ClientOptionsOut } from '../../types';
-export interface FetchWithContext<TClientContext extends ClientContext> {
-    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/client.d.ts

@@ -1,11 +0,0 @@
-import type { AnyContractRouter, ClientContext, ContractRouterClient } from '@orpc/contract';
-import type { AnyRouter, RouterClient } from '@orpc/server';
-import type { ClientLink } from './types';
-export interface createORPCClientOptions {
-    /**
-     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
-     */
-    path?: string[];
-}
-export declare function createORPCClient<TRouter extends AnyRouter | AnyContractRouter, TClientContext extends ClientContext = Record<never, never>>(link: ClientLink<TClientContext>, options?: createORPCClientOptions): TRouter extends AnyRouter ? RouterClient<TRouter, TClientContext> : TRouter extends AnyContractRouter ? ContractRouterClient<TRouter, TClientContext> : never;
-//# sourceMappingURL=client.d.ts.map