@orpc/client 0.42.0 → 0.44.0

package/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 />
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
 </div>
 
 <h1></h1>

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

@@ -0,0 +1,103 @@
+import { Value } from '@orpc/shared';
+import { ToFetchBodyOptions } from '@orpc/standard-server-fetch';
+import { C as ClientContext, a as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from '../../shared/client.D_CzLDyB.mjs';
+import { RPCSerializer } from '../standard/index.mjs';
+
+interface FetchWithContext<TClientContext extends ClientContext> {
+    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
+}
+
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+declare class InvalidEventSourceRetryResponse extends Error {
+}
+interface RPCLinkOptions<TClientContext extends ClientContext> extends ToFetchBodyOptions {
+    /**
+     * 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
+    ]>;
+}
+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;
+    private readonly toFetchBodyOptions;
+    constructor(options: RPCLinkOptions<TClientContext>);
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
+    private performCall;
+    private encodeRequest;
+}
+
+export { type FetchWithContext, InvalidEventSourceRetryResponse, RPCLink, type RPCLinkOptions };

package/dist/{src/adapters/fetch/rpc-link.d.ts → adapters/fetch/index.d.ts}

@@ -1,12 +1,16 @@
-import type { Value } from '@orpc/shared';
-import type { ClientContext, ClientLink, ClientOptionsOut } from '../../types';
-import type { FetchWithContext } from './types';
-import { type EventIteratorReconnectOptions } from '../../event-iterator';
-import { RPCSerializer } from '../../rpc';
+import { Value } from '@orpc/shared';
+import { ToFetchBodyOptions } from '@orpc/standard-server-fetch';
+import { C as ClientContext, a as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from '../../shared/client.D_CzLDyB.js';
+import { RPCSerializer } from '../standard/index.js';
+
+interface FetchWithContext<TClientContext extends ClientContext> {
+    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
+}
+
 type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-export declare class InvalidEventSourceRetryResponse extends Error {
+declare class InvalidEventSourceRetryResponse extends Error {
 }
-export interface RPCLinkOptions<TClientContext extends ClientContext> {
+interface RPCLinkOptions<TClientContext extends ClientContext> extends ToFetchBodyOptions {
     /**
      * Base url for all requests.
      */
@@ -78,7 +82,7 @@ export interface RPCLinkOptions<TClientContext extends ClientContext> {
         input: unknown
     ]>;
 }
-export declare class RPCLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+declare class RPCLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
     private readonly fetch;
     private readonly rpcSerializer;
     private readonly maxUrlLength;
@@ -89,10 +93,11 @@ export declare class RPCLink<TClientContext extends ClientContext> implements Cl
     private readonly eventSourceMaxNumberOfRetries;
     private readonly eventSourceRetryDelay;
     private readonly eventSourceRetry;
+    private readonly toFetchBodyOptions;
     constructor(options: RPCLinkOptions<TClientContext>);
     call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
     private performCall;
     private encodeRequest;
 }
-export {};
-//# sourceMappingURL=rpc-link.d.ts.map
+
+export { type FetchWithContext, InvalidEventSourceRetryResponse, RPCLink, type RPCLinkOptions };

package/dist/{fetch.js → adapters/fetch/index.mjs}

@@ -1,18 +1,12 @@
-import {
-  RPCSerializer
-} from "./chunk-4FUUNP74.js";
-import {
-  ORPCError,
-  createAutoRetryEventIterator
-} from "./chunk-OGAGXWCU.js";
+import { isAsyncIteratorObject, value, trim, stringifyJSON } from '@orpc/shared';
+import { toFetchBody, toStandardBody } from '@orpc/standard-server-fetch';
+import { c as createAutoRetryEventIterator, O as ORPCError } from '../../shared/client.Ly4zGQrc.mjs';
+import { a as RPCSerializer } from '../../shared/client.DHJ8vRIG.mjs';
+import '@orpc/standard-server';
 
-// src/adapters/fetch/rpc-link.ts
-import { isAsyncIteratorObject } from "@orpc/server-standard";
-import { toFetchBody, toStandardBody } from "@orpc/server-standard-fetch";
-import { trim, value } from "@orpc/shared";
-var InvalidEventSourceRetryResponse = class extends Error {
-};
-var RPCLink = class {
+class InvalidEventSourceRetryResponse extends Error {
+}
+class RPCLink {
   fetch;
   rpcSerializer;
   maxUrlLength;
@@ -23,6 +17,7 @@ var RPCLink = class {
   eventSourceMaxNumberOfRetries;
   eventSourceRetryDelay;
   eventSourceRetry;
+  toFetchBodyOptions;
   constructor(options) {
     this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
     this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer();
@@ -34,6 +29,7 @@ var RPCLink = class {
     this.headers = options.headers ?? {};
     this.eventSourceRetry = options.eventSourceRetry ?? true;
     this.eventSourceRetryDelay = options.eventSourceRetryDelay ?? (({ retryTimes, lastRetry }) => lastRetry ?? 1e3 * 2 ** retryTimes);
+    this.toFetchBodyOptions = options;
   }
   async call(path, input, options) {
     const output = await this.performCall(path, input, options);
@@ -59,7 +55,7 @@ var RPCLink = class {
   }
   async performCall(path, input, options) {
     const encoded = await this.encodeRequest(path, input, options);
-    const fetchBody = toFetchBody(encoded.body, encoded.headers);
+    const fetchBody = toFetchBody(encoded.body, encoded.headers, this.toFetchBodyOptions);
     if (options.lastEventId !== void 0) {
       encoded.headers.set("last-event-id", options.lastEventId);
     }
@@ -103,7 +99,7 @@ var RPCLink = class {
     const serialized = this.rpcSerializer.serialize(input);
     if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !isAsyncIteratorObject(serialized)) {
       const getUrl = new URL(url);
-      getUrl.searchParams.append("data", JSON.stringify(serialized) ?? "");
+      getUrl.searchParams.append("data", stringifyJSON(serialized) ?? "");
       if (getUrl.toString().length <= this.maxUrlLength) {
         return {
           body: void 0,
@@ -120,9 +116,6 @@ var RPCLink = class {
       body: serialized
     };
   }
-};
-export {
-  InvalidEventSourceRetryResponse,
-  RPCLink
-};
-//# sourceMappingURL=fetch.js.map
+}
+
+export { InvalidEventSourceRetryResponse, RPCLink };

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

@@ -0,0 +1,22 @@
+import { Segment } from '@orpc/shared';
+
+type RPCJsonSerializedMeta = [
+    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7,
+    Segment[]
+][];
+type RPCJsonSerialized = [json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], blobs: Blob[]];
+declare class RPCJsonSerializer {
+    serialize(data: unknown, segments?: Segment[], meta?: RPCJsonSerializedMeta, maps?: Segment[][], blobs?: Blob[]): RPCJsonSerialized;
+    deserialize(json: unknown, meta: RPCJsonSerializedMeta): unknown;
+    deserialize(json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], getBlob: (index: number) => Blob): unknown;
+}
+
+declare class RPCSerializer {
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer?: RPCJsonSerializer);
+    serialize(data: unknown): unknown;
+    deserialize(data: unknown): unknown;
+}
+
+export { type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer };

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

@@ -0,0 +1,22 @@
+import { Segment } from '@orpc/shared';
+
+type RPCJsonSerializedMeta = [
+    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7,
+    Segment[]
+][];
+type RPCJsonSerialized = [json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], blobs: Blob[]];
+declare class RPCJsonSerializer {
+    serialize(data: unknown, segments?: Segment[], meta?: RPCJsonSerializedMeta, maps?: Segment[][], blobs?: Blob[]): RPCJsonSerialized;
+    deserialize(json: unknown, meta: RPCJsonSerializedMeta): unknown;
+    deserialize(json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], getBlob: (index: number) => Blob): unknown;
+}
+
+declare class RPCSerializer {
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer?: RPCJsonSerializer);
+    serialize(data: unknown): unknown;
+    deserialize(data: unknown): unknown;
+}
+
+export { type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer };

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,4 @@
+export { R as RPCJsonSerializer, a as RPCSerializer } from '../../shared/client.DHJ8vRIG.mjs';
+import '@orpc/shared';
+import '@orpc/standard-server';
+import '../../shared/client.Ly4zGQrc.mjs';

package/dist/index.d.mts

@@ -0,0 +1,153 @@
+import { N as NestedClient, b as ClientLink, I as InferClientContext, C as ClientContext, a as ClientOptionsOut, c as ClientPromiseResult } from './shared/client.D_CzLDyB.mjs';
+export { g as Client, e as ClientOptions, f as ClientRest, E as EventIteratorReconnectOptions, d as createAutoRetryEventIterator, m as mapEventIterator } from './shared/client.D_CzLDyB.mjs';
+import { Promisable, MaybeOptionalOptions } from '@orpc/shared';
+export { ErrorEvent } from '@orpc/standard-server';
+
+interface createORPCClientOptions {
+    /**
+     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
+     */
+    path?: string[];
+}
+declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
+
+/**
+ * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
+ * based on the request path, input, and context.
+ */
+declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly linkResolver;
+    constructor(linkResolver: (options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
+}
+
+declare const COMMON_ORPC_ERROR_DEFS: {
+    readonly BAD_REQUEST: {
+        readonly status: 400;
+        readonly message: "Bad Request";
+    };
+    readonly UNAUTHORIZED: {
+        readonly status: 401;
+        readonly message: "Unauthorized";
+    };
+    readonly FORBIDDEN: {
+        readonly status: 403;
+        readonly message: "Forbidden";
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly message: "Not Found";
+    };
+    readonly METHOD_NOT_SUPPORTED: {
+        readonly status: 405;
+        readonly message: "Method Not Supported";
+    };
+    readonly NOT_ACCEPTABLE: {
+        readonly status: 406;
+        readonly message: "Not Acceptable";
+    };
+    readonly TIMEOUT: {
+        readonly status: 408;
+        readonly message: "Request Timeout";
+    };
+    readonly CONFLICT: {
+        readonly status: 409;
+        readonly message: "Conflict";
+    };
+    readonly PRECONDITION_FAILED: {
+        readonly status: 412;
+        readonly message: "Precondition Failed";
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly status: 413;
+        readonly message: "Payload Too Large";
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly status: 415;
+        readonly message: "Unsupported Media Type";
+    };
+    readonly UNPROCESSABLE_CONTENT: {
+        readonly status: 422;
+        readonly message: "Unprocessable Content";
+    };
+    readonly TOO_MANY_REQUESTS: {
+        readonly status: 429;
+        readonly message: "Too Many Requests";
+    };
+    readonly CLIENT_CLOSED_REQUEST: {
+        readonly status: 499;
+        readonly message: "Client Closed Request";
+    };
+    readonly INTERNAL_SERVER_ERROR: {
+        readonly status: 500;
+        readonly message: "Internal Server Error";
+    };
+    readonly NOT_IMPLEMENTED: {
+        readonly status: 501;
+        readonly message: "Not Implemented";
+    };
+    readonly BAD_GATEWAY: {
+        readonly status: 502;
+        readonly message: "Bad Gateway";
+    };
+    readonly SERVICE_UNAVAILABLE: {
+        readonly status: 503;
+        readonly message: "Service Unavailable";
+    };
+    readonly GATEWAY_TIMEOUT: {
+        readonly status: 504;
+        readonly message: "Gateway Timeout";
+    };
+};
+type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
+type ORPCErrorCode = CommonORPCErrorCode | (string & {});
+declare function fallbackORPCErrorStatus(code: ORPCErrorCode, status: number | undefined): number;
+declare function fallbackORPCErrorMessage(code: ORPCErrorCode, message: string | undefined): string;
+type ORPCErrorOptions<TData> = ErrorOptions & {
+    defined?: boolean;
+    status?: number;
+    message?: string;
+} & (undefined extends TData ? {
+    data?: TData;
+} : {
+    data: TData;
+});
+declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
+    readonly defined: boolean;
+    readonly code: TCode;
+    readonly status: number;
+    readonly data: TData;
+    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    toJSON(): ORPCErrorJSON<TCode, TData>;
+    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
+    static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
+}
+type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
+declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
+declare function toORPCError(error: unknown): ORPCError<any, any>;
+
+type ConnectionStatus = 'reconnecting' | 'connected' | 'closed';
+interface EventIteratorState {
+    status: ConnectionStatus;
+    listeners: Array<(newStatus: ConnectionStatus) => void>;
+}
+declare function registerEventIteratorState(iterator: AsyncIteratorObject<unknown, unknown, void>, state: EventIteratorState): void;
+declare function updateEventIteratorStatus(state: EventIteratorState, status: ConnectionStatus): void;
+declare function onEventIteratorStatusChange(iterator: AsyncIteratorObject<unknown, unknown, void>, callback: (status: ConnectionStatus) => void, notifyImmediately?: boolean): () => void;
+
+type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, isDefined: false] & {
+    error: null;
+    data: TOutput;
+    isDefined: false;
+} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false] & {
+    error: Exclude<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: false;
+} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true] & {
+    error: Extract<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: true;
+};
+declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+
+export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptionsOut, ClientPromiseResult, type CommonORPCErrorCode, type ConnectionStatus, DynamicLink, type EventIteratorState, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, onEventIteratorStatusChange, registerEventIteratorState, safe, toORPCError, updateEventIteratorStatus };

package/dist/index.d.ts

@@ -0,0 +1,153 @@
+import { N as NestedClient, b as ClientLink, I as InferClientContext, C as ClientContext, a as ClientOptionsOut, c as ClientPromiseResult } from './shared/client.D_CzLDyB.js';
+export { g as Client, e as ClientOptions, f as ClientRest, E as EventIteratorReconnectOptions, d as createAutoRetryEventIterator, m as mapEventIterator } from './shared/client.D_CzLDyB.js';
+import { Promisable, MaybeOptionalOptions } from '@orpc/shared';
+export { ErrorEvent } from '@orpc/standard-server';
+
+interface createORPCClientOptions {
+    /**
+     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
+     */
+    path?: string[];
+}
+declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
+
+/**
+ * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
+ * based on the request path, input, and context.
+ */
+declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly linkResolver;
+    constructor(linkResolver: (options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
+}
+
+declare const COMMON_ORPC_ERROR_DEFS: {
+    readonly BAD_REQUEST: {
+        readonly status: 400;
+        readonly message: "Bad Request";
+    };
+    readonly UNAUTHORIZED: {
+        readonly status: 401;
+        readonly message: "Unauthorized";
+    };
+    readonly FORBIDDEN: {
+        readonly status: 403;
+        readonly message: "Forbidden";
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly message: "Not Found";
+    };
+    readonly METHOD_NOT_SUPPORTED: {
+        readonly status: 405;
+        readonly message: "Method Not Supported";
+    };
+    readonly NOT_ACCEPTABLE: {
+        readonly status: 406;
+        readonly message: "Not Acceptable";
+    };
+    readonly TIMEOUT: {
+        readonly status: 408;
+        readonly message: "Request Timeout";
+    };
+    readonly CONFLICT: {
+        readonly status: 409;
+        readonly message: "Conflict";
+    };
+    readonly PRECONDITION_FAILED: {
+        readonly status: 412;
+        readonly message: "Precondition Failed";
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly status: 413;
+        readonly message: "Payload Too Large";
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly status: 415;
+        readonly message: "Unsupported Media Type";
+    };
+    readonly UNPROCESSABLE_CONTENT: {
+        readonly status: 422;
+        readonly message: "Unprocessable Content";
+    };
+    readonly TOO_MANY_REQUESTS: {
+        readonly status: 429;
+        readonly message: "Too Many Requests";
+    };
+    readonly CLIENT_CLOSED_REQUEST: {
+        readonly status: 499;
+        readonly message: "Client Closed Request";
+    };
+    readonly INTERNAL_SERVER_ERROR: {
+        readonly status: 500;
+        readonly message: "Internal Server Error";
+    };
+    readonly NOT_IMPLEMENTED: {
+        readonly status: 501;
+        readonly message: "Not Implemented";
+    };
+    readonly BAD_GATEWAY: {
+        readonly status: 502;
+        readonly message: "Bad Gateway";
+    };
+    readonly SERVICE_UNAVAILABLE: {
+        readonly status: 503;
+        readonly message: "Service Unavailable";
+    };
+    readonly GATEWAY_TIMEOUT: {
+        readonly status: 504;
+        readonly message: "Gateway Timeout";
+    };
+};
+type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
+type ORPCErrorCode = CommonORPCErrorCode | (string & {});
+declare function fallbackORPCErrorStatus(code: ORPCErrorCode, status: number | undefined): number;
+declare function fallbackORPCErrorMessage(code: ORPCErrorCode, message: string | undefined): string;
+type ORPCErrorOptions<TData> = ErrorOptions & {
+    defined?: boolean;
+    status?: number;
+    message?: string;
+} & (undefined extends TData ? {
+    data?: TData;
+} : {
+    data: TData;
+});
+declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
+    readonly defined: boolean;
+    readonly code: TCode;
+    readonly status: number;
+    readonly data: TData;
+    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    toJSON(): ORPCErrorJSON<TCode, TData>;
+    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
+    static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
+}
+type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
+declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
+declare function toORPCError(error: unknown): ORPCError<any, any>;
+
+type ConnectionStatus = 'reconnecting' | 'connected' | 'closed';
+interface EventIteratorState {
+    status: ConnectionStatus;
+    listeners: Array<(newStatus: ConnectionStatus) => void>;
+}
+declare function registerEventIteratorState(iterator: AsyncIteratorObject<unknown, unknown, void>, state: EventIteratorState): void;
+declare function updateEventIteratorStatus(state: EventIteratorState, status: ConnectionStatus): void;
+declare function onEventIteratorStatusChange(iterator: AsyncIteratorObject<unknown, unknown, void>, callback: (status: ConnectionStatus) => void, notifyImmediately?: boolean): () => void;
+
+type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, isDefined: false] & {
+    error: null;
+    data: TOutput;
+    isDefined: false;
+} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false] & {
+    error: Exclude<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: false;
+} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true] & {
+    error: Extract<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: true;
+};
+declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+
+export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptionsOut, ClientPromiseResult, type CommonORPCErrorCode, type ConnectionStatus, DynamicLink, type EventIteratorState, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, onEventIteratorStatusChange, registerEventIteratorState, safe, toORPCError, updateEventIteratorStatus };

package/dist/{index.js → index.mjs}

@@ -1,18 +1,8 @@
-import {
-  COMMON_ORPC_ERROR_DEFS,
-  ORPCError,
-  createAutoRetryEventIterator,
-  fallbackORPCErrorMessage,
-  fallbackORPCErrorStatus,
-  isDefinedError,
-  mapEventIterator,
-  onEventIteratorStatusChange,
-  registerEventIteratorState,
-  toORPCError,
-  updateEventIteratorStatus
-} from "./chunk-OGAGXWCU.js";
+import { i as isDefinedError } from './shared/client.Ly4zGQrc.mjs';
+export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, c as createAutoRetryEventIterator, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, m as mapEventIterator, o as onEventIteratorStatusChange, r as registerEventIteratorState, t as toORPCError, u as updateEventIteratorStatus } from './shared/client.Ly4zGQrc.mjs';
+export { ErrorEvent } from '@orpc/standard-server';
+import '@orpc/shared';
 
-// src/client.ts
 function createORPCClient(link, options) {
   const path = options?.path ?? [];
   const procedureClient = async (...[input, options2]) => {
@@ -37,8 +27,7 @@ function createORPCClient(link, options) {
   return recursive;
 }
 
-// src/dynamic-link.ts
-var DynamicLink = class {
+class DynamicLink {
   constructor(linkResolver) {
     this.linkResolver = linkResolver;
   }
@@ -47,35 +36,28 @@ var DynamicLink = class {
     const output = await resolvedLink.call(path, input, options);
     return output;
   }
-};
+}
 
-// src/utils.ts
 async function safe(promise) {
   try {
     const output = await promise;
-    return [output, void 0, false];
+    return Object.assign(
+      [null, output, false],
+      { error: null, data: output, isDefined: false }
+    );
   } catch (e) {
     const error = e;
     if (isDefinedError(error)) {
-      return [void 0, error, true];
+      return Object.assign(
+        [error, void 0, true],
+        { error, data: void 0, isDefined: true }
+      );
     }
-    return [void 0, error, false];
+    return Object.assign(
+      [error, void 0, false],
+      { error, data: void 0, isDefined: false }
+    );
   }
 }
-export {
-  COMMON_ORPC_ERROR_DEFS,
-  DynamicLink,
-  ORPCError,
-  createAutoRetryEventIterator,
-  createORPCClient,
-  fallbackORPCErrorMessage,
-  fallbackORPCErrorStatus,
-  isDefinedError,
-  mapEventIterator,
-  onEventIteratorStatusChange,
-  registerEventIteratorState,
-  safe,
-  toORPCError,
-  updateEventIteratorStatus
-};
-//# sourceMappingURL=index.js.map
+
+export { DynamicLink, createORPCClient, isDefinedError, safe };