@orpc/client 0.0.0-next.c29cb6d → 0.0.0-next.c40b544

package/README.md

@@ -0,0 +1,96 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/client">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fclient?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards
+
+---
+
+## Highlights
+
+- **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
+- **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
+- **📝 Contract-First Development**: Optionally define your API contract before implementation.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte, Angular), Pinia Colada, and more.
+- **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
+- **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
+- **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
+- **⏱️ Lazy Router**: Enhance cold start times with our lazy routing feature.
+- **📡 SSE & Streaming**: Enjoy full type-safe support for SSE and streaming.
+- **🌍 Multi-Runtime Support**: Fast and lightweight on Cloudflare, Deno, Bun, Node.js, and beyond.
+- **🔌 Extendability**: Easily extend functionality with plugins, middleware, and interceptors.
+- **🛡️ Reliability**: Well-tested, TypeScript-based, production-ready, and MIT licensed.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
+- [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with [NestJS](https://nestjs.com/).
+- [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
+- [@orpc/tanstack-query](https://www.npmjs.com/package/@orpc/tanstack-query): [TanStack Query](https://tanstack.com/query/latest) integration.
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/hey-api](https://www.npmjs.com/package/@orpc/hey-api): [Hey API](https://heyapi.dev/) integration.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+- [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
+- [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).
+
+## `@orpc/client`
+
+Consume your API on the client with type-safety. Read the [documentation](https://orpc.unnoq.com/docs/client/client-side) for more information.
+
+```ts
+import { createORPCClient } from '@orpc/client'
+import { RPCLink } from '@orpc/client/fetch'
+import { ContractRouterClient } from '@orpc/contract'
+import { RouterClient } from '@orpc/server'
+
+const link = new RPCLink({
+  url: 'http://localhost:3000/rpc',
+  headers: () => ({
+    authorization: 'Bearer token',
+  }),
+  // fetch: <-- provide fetch polyfill fetch if needed
+})
+
+// Create a client for your router
+const client: RouterClient<typeof router> = createORPCClient(link)
+// Or, create a client using a contract
+const client: ContractRouterClient<typeof contract> = createORPCClient(link)
+```
+
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg'/>
+  </a>
+</p>
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/adapters/fetch/index.d.mts

@@ -0,0 +1,33 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
+import { a as ClientContext, b as ClientOptions } from '../../shared/client.4TS_0JaO.mjs';
+import { f as StandardLinkClient } from '../../shared/client.BMoG_EdN.mjs';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.BdD8cpjs.mjs';
+import '@orpc/shared';
+
+interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
+    fetch?: (request: Request, init: {
+        redirect?: Request['redirect'];
+    }, options: ClientOptions<T>, path: readonly string[], input: unknown) => Promise<Response>;
+}
+declare class LinkFetchClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly fetch;
+    private readonly toFetchRequestOptions;
+    constructor(options: LinkFetchClientOptions<T>);
+    call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface RPCLinkOptions<T extends ClientContext> extends StandardRPCLinkOptions<T>, LinkFetchClientOptions<T> {
+}
+/**
+ * The RPC Link communicates with the server using the RPC protocol.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/advanced/rpc-protocol RPC Protocol Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
+}
+
+export { LinkFetchClient, RPCLink };
+export type { LinkFetchClientOptions, RPCLinkOptions };

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

@@ -0,0 +1,33 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
+import { a as ClientContext, b as ClientOptions } from '../../shared/client.4TS_0JaO.js';
+import { f as StandardLinkClient } from '../../shared/client.C0KbSWlC.js';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.7UM0t5o-.js';
+import '@orpc/shared';
+
+interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
+    fetch?: (request: Request, init: {
+        redirect?: Request['redirect'];
+    }, options: ClientOptions<T>, path: readonly string[], input: unknown) => Promise<Response>;
+}
+declare class LinkFetchClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly fetch;
+    private readonly toFetchRequestOptions;
+    constructor(options: LinkFetchClientOptions<T>);
+    call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface RPCLinkOptions<T extends ClientContext> extends StandardRPCLinkOptions<T>, LinkFetchClientOptions<T> {
+}
+/**
+ * The RPC Link communicates with the server using the RPC protocol.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/advanced/rpc-protocol RPC Protocol Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
+}
+
+export { LinkFetchClient, RPCLink };
+export type { LinkFetchClientOptions, RPCLinkOptions };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,29 @@
+import { toFetchRequest, toStandardLazyResponse } from '@orpc/standard-server-fetch';
+import '@orpc/shared';
+import { c as StandardRPCLink } from '../../shared/client.CQCGVpTM.mjs';
+import '@orpc/standard-server';
+import '../../shared/client.BX0_8bnM.mjs';
+
+class LinkFetchClient {
+  fetch;
+  toFetchRequestOptions;
+  constructor(options) {
+    this.fetch = options?.fetch ?? globalThis.fetch.bind(globalThis);
+    this.toFetchRequestOptions = options;
+  }
+  async call(request, options, path, input) {
+    const fetchRequest = toFetchRequest(request, this.toFetchRequestOptions);
+    const fetchResponse = await this.fetch(fetchRequest, { redirect: "manual" }, options, path, input);
+    const lazyResponse = toStandardLazyResponse(fetchResponse);
+    return lazyResponse;
+  }
+}
+
+class RPCLink extends StandardRPCLink {
+  constructor(options) {
+    const linkClient = new LinkFetchClient(options);
+    super(linkClient, options);
+  }
+}
+
+export { LinkFetchClient, RPCLink };

package/dist/adapters/message-port/index.d.mts

@@ -0,0 +1,59 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, b as ClientOptions } from '../../shared/client.4TS_0JaO.mjs';
+import { f as StandardLinkClient } from '../../shared/client.BMoG_EdN.mjs';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.BdD8cpjs.mjs';
+import '@orpc/shared';
+
+/**
+ * The message port used by electron in main process
+ */
+interface MessagePortMainLike {
+    on: <T extends string>(event: T, callback: (event?: {
+        data: any;
+    }) => void) => void;
+    postMessage: (data: any) => void;
+}
+/**
+ * The message port used by browser extension
+ */
+interface BrowserPortLike {
+    onMessage: {
+        addListener: (callback: (data: any) => void) => void;
+    };
+    onDisconnect: {
+        addListener: (callback: () => void) => void;
+    };
+    postMessage: (data: any) => void;
+}
+type SupportedMessagePort = Pick<MessagePort, 'addEventListener' | 'postMessage'> | MessagePortMainLike | BrowserPortLike;
+/**
+ *  Message port can support [The structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm)
+ */
+type SupportedMessagePortData = string | ArrayBufferLike;
+declare function postMessagePortMessage(port: SupportedMessagePort, data: SupportedMessagePortData): void;
+declare function onMessagePortMessage(port: SupportedMessagePort, callback: (data: SupportedMessagePortData) => void): void;
+declare function onMessagePortClose(port: SupportedMessagePort, callback: () => void): void;
+
+interface experimental_LinkMessagePortClientOptions {
+    port: SupportedMessagePort;
+}
+declare class experimental_LinkMessagePortClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: experimental_LinkMessagePortClientOptions);
+    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'headers' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, experimental_LinkMessagePortClientOptions {
+}
+/**
+ * The RPC Link for common message port implementations.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/message-port Message Port Adapter Docs}
+ */
+declare class experimental_RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: experimental_RPCLinkOptions<T>);
+}
+
+export { experimental_LinkMessagePortClient, experimental_RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
+export type { BrowserPortLike, MessagePortMainLike, SupportedMessagePort, SupportedMessagePortData, experimental_LinkMessagePortClientOptions, experimental_RPCLinkOptions };

package/dist/adapters/message-port/index.d.ts

@@ -0,0 +1,59 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, b as ClientOptions } from '../../shared/client.4TS_0JaO.js';
+import { f as StandardLinkClient } from '../../shared/client.C0KbSWlC.js';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.7UM0t5o-.js';
+import '@orpc/shared';
+
+/**
+ * The message port used by electron in main process
+ */
+interface MessagePortMainLike {
+    on: <T extends string>(event: T, callback: (event?: {
+        data: any;
+    }) => void) => void;
+    postMessage: (data: any) => void;
+}
+/**
+ * The message port used by browser extension
+ */
+interface BrowserPortLike {
+    onMessage: {
+        addListener: (callback: (data: any) => void) => void;
+    };
+    onDisconnect: {
+        addListener: (callback: () => void) => void;
+    };
+    postMessage: (data: any) => void;
+}
+type SupportedMessagePort = Pick<MessagePort, 'addEventListener' | 'postMessage'> | MessagePortMainLike | BrowserPortLike;
+/**
+ *  Message port can support [The structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm)
+ */
+type SupportedMessagePortData = string | ArrayBufferLike;
+declare function postMessagePortMessage(port: SupportedMessagePort, data: SupportedMessagePortData): void;
+declare function onMessagePortMessage(port: SupportedMessagePort, callback: (data: SupportedMessagePortData) => void): void;
+declare function onMessagePortClose(port: SupportedMessagePort, callback: () => void): void;
+
+interface experimental_LinkMessagePortClientOptions {
+    port: SupportedMessagePort;
+}
+declare class experimental_LinkMessagePortClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: experimental_LinkMessagePortClientOptions);
+    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'headers' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, experimental_LinkMessagePortClientOptions {
+}
+/**
+ * The RPC Link for common message port implementations.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/message-port Message Port Adapter Docs}
+ */
+declare class experimental_RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: experimental_RPCLinkOptions<T>);
+}
+
+export { experimental_LinkMessagePortClient, experimental_RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
+export type { BrowserPortLike, MessagePortMainLike, SupportedMessagePort, SupportedMessagePortData, experimental_LinkMessagePortClientOptions, experimental_RPCLinkOptions };

package/dist/adapters/message-port/index.mjs

@@ -0,0 +1,71 @@
+import { ClientPeer } from '@orpc/standard-server-peer';
+import '@orpc/shared';
+import { c as StandardRPCLink } from '../../shared/client.CQCGVpTM.mjs';
+import '@orpc/standard-server';
+import '../../shared/client.BX0_8bnM.mjs';
+
+function postMessagePortMessage(port, data) {
+  port.postMessage(data);
+}
+function onMessagePortMessage(port, callback) {
+  if ("addEventListener" in port) {
+    port.addEventListener("message", (event) => {
+      callback(event.data);
+    });
+  } else if ("on" in port) {
+    port.on("message", (event) => {
+      callback(event?.data);
+    });
+  } else if ("onMessage" in port) {
+    port.onMessage.addListener((data) => {
+      callback(data);
+    });
+  } else {
+    throw new Error("Cannot find a addEventListener/on/onMessage method on the port");
+  }
+}
+function onMessagePortClose(port, callback) {
+  if ("addEventListener" in port) {
+    port.addEventListener("close", async () => {
+      callback();
+    });
+  } else if ("on" in port) {
+    port.on("close", async () => {
+      callback();
+    });
+  } else if ("onDisconnect" in port) {
+    port.onDisconnect.addListener(() => {
+      callback();
+    });
+  } else {
+    throw new Error("Cannot find a addEventListener/on/onDisconnect method on the port");
+  }
+}
+
+class experimental_LinkMessagePortClient {
+  peer;
+  constructor(options) {
+    this.peer = new ClientPeer((message) => {
+      return postMessagePortMessage(options.port, message);
+    });
+    onMessagePortMessage(options.port, async (message) => {
+      await this.peer.message(message);
+    });
+    onMessagePortClose(options.port, () => {
+      this.peer.close();
+    });
+  }
+  async call(request, _options, _path, _input) {
+    const response = await this.peer.request(request);
+    return { ...response, body: () => Promise.resolve(response.body) };
+  }
+}
+
+class experimental_RPCLink extends StandardRPCLink {
+  constructor(options) {
+    const linkClient = new experimental_LinkMessagePortClient(options);
+    super(linkClient, { ...options, url: "orpc:/" });
+  }
+}
+
+export { experimental_LinkMessagePortClient, experimental_RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };

package/dist/adapters/standard/index.d.mts

@@ -0,0 +1,10 @@
+export { C as CompositeStandardLinkPlugin, d as StandardLink, f as StandardLinkClient, S as StandardLinkClientInterceptorOptions, e as StandardLinkCodec, c as StandardLinkInterceptorOptions, b as StandardLinkOptions, a as StandardLinkPlugin } from '../../shared/client.BMoG_EdN.mjs';
+export { S as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, c as StandardRPCCustomJsonSerializer, b as StandardRPCJsonSerialized, a as StandardRPCJsonSerializedMetaItem, e as StandardRPCJsonSerializer, d as StandardRPCJsonSerializerOptions, g as StandardRPCLink, i as StandardRPCLinkCodec, h as StandardRPCLinkCodecOptions, f as StandardRPCLinkOptions, j as StandardRPCSerializer } from '../../shared/client.BdD8cpjs.mjs';
+import { H as HTTPPath } from '../../shared/client.4TS_0JaO.mjs';
+import '@orpc/shared';
+import '@orpc/standard-server';
+
+declare function toHttpPath(path: readonly string[]): HTTPPath;
+declare function getMalformedResponseErrorCode(status: number): string;
+
+export { getMalformedResponseErrorCode, toHttpPath };

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

@@ -0,0 +1,10 @@
+export { C as CompositeStandardLinkPlugin, d as StandardLink, f as StandardLinkClient, S as StandardLinkClientInterceptorOptions, e as StandardLinkCodec, c as StandardLinkInterceptorOptions, b as StandardLinkOptions, a as StandardLinkPlugin } from '../../shared/client.C0KbSWlC.js';
+export { S as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, c as StandardRPCCustomJsonSerializer, b as StandardRPCJsonSerialized, a as StandardRPCJsonSerializedMetaItem, e as StandardRPCJsonSerializer, d as StandardRPCJsonSerializerOptions, g as StandardRPCLink, i as StandardRPCLinkCodec, h as StandardRPCLinkCodecOptions, f as StandardRPCLinkOptions, j as StandardRPCSerializer } from '../../shared/client.7UM0t5o-.js';
+import { H as HTTPPath } from '../../shared/client.4TS_0JaO.js';
+import '@orpc/shared';
+import '@orpc/standard-server';
+
+declare function toHttpPath(path: readonly string[]): HTTPPath;
+declare function getMalformedResponseErrorCode(status: number): string;
+
+export { getMalformedResponseErrorCode, toHttpPath };

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,4 @@
+export { C as CompositeStandardLinkPlugin, a as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, S as StandardLink, b as StandardRPCJsonSerializer, c as StandardRPCLink, d as StandardRPCLinkCodec, e as StandardRPCSerializer, g as getMalformedResponseErrorCode, t as toHttpPath } from '../../shared/client.CQCGVpTM.mjs';
+import '@orpc/shared';
+import '@orpc/standard-server';
+import '../../shared/client.BX0_8bnM.mjs';

package/dist/adapters/websocket/index.d.mts

@@ -0,0 +1,29 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, b as ClientOptions } from '../../shared/client.4TS_0JaO.mjs';
+import { f as StandardLinkClient } from '../../shared/client.BMoG_EdN.mjs';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.BdD8cpjs.mjs';
+import '@orpc/shared';
+
+interface experimental_LinkWebsocketClientOptions {
+    websocket: Pick<WebSocket, 'addEventListener' | 'send' | 'readyState'>;
+}
+declare class experimental_LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: experimental_LinkWebsocketClientOptions);
+    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'headers' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, experimental_LinkWebsocketClientOptions {
+}
+/**
+ * The RPC Link communicates with the server using the RPC protocol over WebSocket.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket WebSocket Adapter Docs}
+ */
+declare class experimental_RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: experimental_RPCLinkOptions<T>);
+}
+
+export { experimental_LinkWebsocketClient, experimental_RPCLink };
+export type { experimental_LinkWebsocketClientOptions, experimental_RPCLinkOptions };

package/dist/adapters/websocket/index.d.ts

@@ -0,0 +1,29 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, b as ClientOptions } from '../../shared/client.4TS_0JaO.js';
+import { f as StandardLinkClient } from '../../shared/client.C0KbSWlC.js';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.7UM0t5o-.js';
+import '@orpc/shared';
+
+interface experimental_LinkWebsocketClientOptions {
+    websocket: Pick<WebSocket, 'addEventListener' | 'send' | 'readyState'>;
+}
+declare class experimental_LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: experimental_LinkWebsocketClientOptions);
+    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'headers' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, experimental_LinkWebsocketClientOptions {
+}
+/**
+ * The RPC Link communicates with the server using the RPC protocol over WebSocket.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket WebSocket Adapter Docs}
+ */
+declare class experimental_RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: experimental_RPCLinkOptions<T>);
+}
+
+export { experimental_LinkWebsocketClient, experimental_RPCLink };
+export type { experimental_LinkWebsocketClientOptions, experimental_RPCLinkOptions };

package/dist/adapters/websocket/index.mjs

@@ -0,0 +1,44 @@
+import { ClientPeer } from '@orpc/standard-server-peer';
+import '@orpc/shared';
+import { c as StandardRPCLink } from '../../shared/client.CQCGVpTM.mjs';
+import '@orpc/standard-server';
+import '../../shared/client.BX0_8bnM.mjs';
+
+class experimental_LinkWebsocketClient {
+  peer;
+  constructor(options) {
+    const untilOpen = new Promise((resolve) => {
+      if (options.websocket.readyState === 0) {
+        options.websocket.addEventListener("open", () => {
+          resolve();
+        }, { once: true });
+      } else {
+        resolve();
+      }
+    });
+    this.peer = new ClientPeer(async (message) => {
+      await untilOpen;
+      return options.websocket.send(message);
+    });
+    options.websocket.addEventListener("message", async (event) => {
+      const message = event.data instanceof Blob ? await event.data.arrayBuffer() : event.data;
+      this.peer.message(message);
+    });
+    options.websocket.addEventListener("close", () => {
+      this.peer.close();
+    });
+  }
+  async call(request, _options, _path, _input) {
+    const response = await this.peer.request(request);
+    return { ...response, body: () => Promise.resolve(response.body) };
+  }
+}
+
+class experimental_RPCLink extends StandardRPCLink {
+  constructor(options) {
+    const linkClient = new experimental_LinkWebsocketClient(options);
+    super(linkClient, { ...options, url: "orpc:/" });
+  }
+}
+
+export { experimental_LinkWebsocketClient, experimental_RPCLink };