@orpc/client 1.14.11 → 1.14.12

package/dist/plugins/index.d.ts

@@ -1,253 +1,168 @@
 import { Value, Promisable } from '@orpc/shared';
-import { StandardUrl, StandardHeaders, StandardRequest, StandardLazyResponse } from '@standardserver/core';
-import { C as ClientContext } from '../shared/client.BBZBQID8.js';
-import { c as StandardLinkPlugin, d as StandardLinkTransportInterceptorOptions, b as StandardLinkOptions, e as StandardLinkInterceptorOptions } from '../shared/client.BMKYqpdy.js';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { BatchResponseMode } from '@orpc/standard-server/batch';
+import { b as ClientContext } from '../shared/client.i2uoJbEp.js';
+import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.2jUAqzYU.js';
 
-type BatchLinkPluginMode = 'streaming' | 'buffered';
 interface BatchLinkPluginGroup<T extends ClientContext> {
-    /**
-     * Determines whether a request should be included in this batch group.
-     * Requests will be evaluated against each group's condition in order,
-     * and included in the first group whose condition returns true.
-     * If no group's condition returns true, the request will not be batched.
-     */
-    condition: Value<boolean, [options: StandardLinkTransportInterceptorOptions<T>]>;
-    /**
-     * The client context applied to requests in this batch group for the remainder of the link chain.
-     */
-    context: Value<T, [items: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
-    /**
-     * The path segments applied to requests in this batch group for the remainder of the link chain.
-     *
-     * @default []
-     */
-    path?: Value<string[], [items: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
-}
-declare class BatchLinkPluginError extends TypeError {
+    condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
+    context: T;
+    path?: readonly string[];
+    input?: unknown;
 }
 interface BatchLinkPluginOptions<T extends ClientContext> {
-    groups: [BatchLinkPluginGroup<T>, ...BatchLinkPluginGroup<T>[]];
-    /**
-     * Filters requests to batch.
-     *
-     * @default () => true
-     */
-    filter?: Value<boolean, [options: StandardLinkTransportInterceptorOptions<T>]>;
+    groups: readonly [BatchLinkPluginGroup<T>, ...BatchLinkPluginGroup<T>[]];
     /**
      * The maximum number of requests in the batch.
      *
      * @default 10
      */
-    maxSize?: Value<Promisable<number>, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
+    maxSize?: Value<Promisable<number>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
     /**
      * The batch response mode.
      *
      * @default 'streaming'
      */
-    mode?: Value<BatchLinkPluginMode, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
+    mode?: Value<BatchResponseMode, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
     /**
-     * URL for the batch request.
+     * Defines the URL to use for the batch request.
      *
-     * @default URL of the first subrequest in the batch + '/__batch__'
+     * @default the URL of the first request in the batch + '/__batch__'
      */
-    url?: Value<Promisable<StandardUrl>, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
+    url?: Value<Promisable<string | URL>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
     /**
-     * The maximum length of the URL that runtime supports,
-     * if exceeded, the batch will be split into smaller batches and sent sequentially.
-     *
-     * This only applies to GET batch requests where the batch data is sent via URL query parameter.
+     * The maximum length of the URL.
      *
      * @default 2083
      */
-    maxUrlLength?: Value<Promisable<number>, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
+    maxUrlLength?: Value<Promisable<number>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
     /**
-     * Headers used for the batch request.
+     * Defines the HTTP headers to use for the batch request.
      *
-     * @default Common headers among all subrequests in the batch.
+     * @default The same headers of all requests in the batch
      */
-    headers?: Value<Promisable<StandardHeaders>, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
+    headers?: Value<Promisable<StandardHeaders>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
     /**
-     * Map each subrequest in the batch before it is sent.
+     * Map the batch request items before sending them.
      *
-     * @default Removes headers that are duplicated with the batch headers
+     * @default Removes headers that are duplicated in the batch headers.
      */
-    mapSubrequest?: (subOptions: StandardLinkTransportInterceptorOptions<T>, partialBatchRequest: Pick<StandardRequest, 'url' | 'headers'>) => StandardRequest;
+    mapRequestItem?: (options: StandardLinkClientInterceptorOptions<T> & {
+        batchUrl: URL;
+        batchHeaders: StandardHeaders;
+    }) => StandardRequest;
     /**
-     * Maps each subresponse before returning the final response.
+     * Exclude a request from the batch.
      *
-     * @default Low-priority merges headers from the batch response into each subresponse.
+     * @default () => false
      */
-    mapSubresponse?: (subResponse: StandardLazyResponse, batchResponse: StandardLazyResponse, subOptions: StandardLinkTransportInterceptorOptions<T>) => StandardLazyResponse;
+    exclude?: (options: StandardLinkClientInterceptorOptions<T>) => boolean;
 }
+/**
+ * The Batch Requests Plugin allows you to combine multiple requests and responses into a single batch,
+ * reducing the overhead of sending each one separately.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/batch-requests Batch Requests Plugin Docs}
+ */
 declare class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
-    name: string;
+    #private;
     private readonly groups;
-    private readonly filter;
     private readonly maxSize;
-    private readonly mode;
     private readonly batchUrl;
     private readonly maxUrlLength;
     private readonly batchHeaders;
-    private readonly mapSubrequest;
-    private readonly mapSubresponse;
-    private readonly queue;
+    private readonly mapRequestItem;
+    private readonly exclude;
+    private readonly mode;
+    private pending;
+    order: number;
     constructor(options: NoInfer<BatchLinkPluginOptions<T>>);
-    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
-    private processPendingBatches;
-    private executeBatch;
+    init(options: StandardLinkOptions<T>): void;
 }
 
-interface DedupeLinkPluginGroup<T extends ClientContext> {
-    condition: Value<boolean, [options: StandardLinkTransportInterceptorOptions<T>]>;
+interface DedupeRequestsPluginGroup<T extends ClientContext> {
+    condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
     /**
      * The context used for the rest of the request lifecycle.
      */
-    context: Value<T, [
-        items: [
-            StandardLinkTransportInterceptorOptions<T>,
-            StandardLinkTransportInterceptorOptions<T>,
-            ...StandardLinkTransportInterceptorOptions<T>[]
-        ]
-    ]>;
+    context: T;
 }
-interface DedupeLinkPluginOptions<T extends ClientContext> {
+interface DedupeRequestsPluginOptions<T extends ClientContext> {
     /**
      * To enable deduplication, a request must match at least one defined group.
      * Requests that fall into the same group are considered for deduplication together.
      */
-    groups: [DedupeLinkPluginGroup<T>, ...DedupeLinkPluginGroup<T>[]];
+    groups: readonly [DedupeRequestsPluginGroup<T>, ...DedupeRequestsPluginGroup<T>[]];
     /**
-     * Filters requests to dedupe.
+     * Filters requests to dedupe
      *
-     * @default ({ request }) => request.method === 'GET'
-     */
-    filter?: Value<boolean, [options: StandardLinkTransportInterceptorOptions<T>]>;
-}
-declare class DedupeLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
-    name: string;
-    before: string[];
-    private readonly groups;
-    private readonly filter;
-    private readonly queue;
-    constructor(options: NoInfer<DedupeLinkPluginOptions<T>>);
-    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
-    private enqueue;
-    private processPendingRequests;
-    private execute;
-}
-
-interface RequestCompressionLinkPluginOptions<_T extends ClientContext> {
-    /**
-     * The compression scheme to use for request compression.
-     *
-     * @default 'gzip'
-     */
-    encoding?: 'gzip' | 'deflate' | 'deflate-raw';
-    /**
-     * The minimum request size in bytes required to trigger compression.
-     * Requests smaller than this threshold will not be compressed to avoid overhead.
-     * If the request size cannot be determined, compression will still be applied.
-     *
-     * @default 1024 (1KB)
-     */
-    threshold?: number;
-}
-declare class RequestCompressionLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
-    name: string;
-    /**
-     * Compression should be done after batching, to compress the final request
+     * @default (({ request }) => request.method === 'GET')
      */
-    after: string[];
-    private readonly encoding;
-    private readonly threshold;
-    constructor(options?: RequestCompressionLinkPluginOptions<T>);
-    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
-}
-
-interface ResponseCompressionLinkPluginOptions<_T extends ClientContext> {
-    /**
-     * Compression schemes to advertise via Accept-Encoding, in preference order.
-     * Only schemes that can be decompressed by this plugin should be listed.
-     *
-     * @default ['gzip', 'deflate']
-     */
-    encodings?: readonly ('gzip' | 'deflate' | 'deflate-raw')[];
+    filter?: (options: StandardLinkClientInterceptorOptions<T>) => boolean;
 }
 /**
- * Advertises Accept-Encoding on requests and decompresses response bodies
- * based on the Content-Encoding header. Works at the standard link level,
- * so it supports all adapters.
+ * Prevents duplicate requests by deduplicating similar ones to reduce server load.
  *
- * @see {@link https://orpc.dev/docs/plugins/response-compression Response Compression Plugin Docs}
+ * @see {@link https://orpc.dev/docs/plugins/dedupe-requests Dedupe Requests Plugin}
  */
-declare class ResponseCompressionLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
-    name: string;
-    /**
-     * Decompression should wrap the final batch response instead of sub-responses.
-     */
-    after: string[];
-    private readonly encodings;
-    constructor(options?: ResponseCompressionLinkPluginOptions<T>);
-    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+declare class DedupeRequestsPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    #private;
+    order: number;
+    constructor(options: NoInfer<DedupeRequestsPluginOptions<T>>);
+    init(options: StandardLinkOptions<T>): void;
 }
 
-interface RetryLinkPluginAttemptOptions<T extends RetryLinkPluginContext> extends StandardLinkInterceptorOptions<T> {
-    /**
-     * Latest retry delay advertised by the server via event metadata.
-     */
+interface ClientRetryPluginAttemptOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
     lastEventRetry: number | undefined;
-    /**
-     * Current retry attempt number, starting at 1.
-     */
-    attempt: number;
-    /**
-     * Error that triggered this retry attempt.
-     */
+    attemptIndex: number;
     error: unknown;
 }
-interface RetryLinkPluginContext {
+interface ClientRetryPluginContext {
     /**
-     * Maximum retry attempts before throwing.
-     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g. for AsyncIteratorObject).
+     * Maximum retry attempts before throwing
+     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g., when handling Server-Sent Events).
      *
      * @default 0
      */
-    retry?: Value<Promisable<number>, [Omit<StandardLinkInterceptorOptions<RetryLinkPluginContext>, 'next'>]>;
+    retry?: Value<Promisable<number>, [StandardLinkInterceptorOptions<ClientRetryPluginContext>]>;
     /**
      * Delay (in ms) before retrying.
      *
-     * @info Why 2000ms? The EventSource spec suggests a default retry delay of 2 seconds if it doesn't specify
      * @default (o) => o.lastEventRetry ?? 2000
      */
-    retryDelay?: Value<Promisable<number>, [RetryLinkPluginAttemptOptions<RetryLinkPluginContext>]>;
+    retryDelay?: Value<Promisable<number>, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
     /**
-     * Determine whether to retry.
+     * Determine should retry or not.
      *
      * @default true
      */
-    shouldRetry?: Value<Promisable<boolean>, [RetryLinkPluginAttemptOptions<RetryLinkPluginContext>]>;
+    shouldRetry?: Value<Promisable<boolean>, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
     /**
-     * Hook called before each retry. Can return a cleanup callback.
+     * The hook called when retrying, and return the unsubscribe function.
      */
-    onRetry?: (options: RetryLinkPluginAttemptOptions<RetryLinkPluginContext>) => void | ((isSuccess: boolean) => void);
+    onRetry?: (options: ClientRetryPluginAttemptOptions<ClientRetryPluginContext>) => void | ((isSuccess: boolean) => void);
 }
-interface RetryLinkPluginOptions<_T extends RetryLinkPluginContext> {
-    /**
-     * Default retry options. Can be overridden by individual calls via the context.
-     */
-    default?: RetryLinkPluginContext | undefined;
+declare class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
 }
-declare class RetryLinkPlugin<T extends RetryLinkPluginContext & ClientContext> implements StandardLinkPlugin<T> {
+interface ClientRetryPluginOptions {
+    default?: ClientRetryPluginContext;
+}
+/**
+ * The Client Retry Plugin enables retrying client calls when errors occur.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/client-retry Client Retry Plugin Docs}
+ */
+declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements StandardLinkPlugin<T> {
     private readonly defaultRetry;
     private readonly defaultRetryDelay;
     private readonly defaultShouldRetry;
     private readonly defaultOnRetry;
-    name: string;
-    constructor(options?: RetryLinkPluginOptions<T>);
-    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+    order: number;
+    constructor(options?: ClientRetryPluginOptions);
+    init(options: StandardLinkOptions<T>): void;
 }
 
-interface RetryAfterLinkPluginOptions<T extends ClientContext> {
+interface RetryAfterPluginOptions<T extends ClientContext> {
     /**
      * Override condition to determine whether to retry or not.
      *
@@ -255,7 +170,7 @@ interface RetryAfterLinkPluginOptions<T extends ClientContext> {
      */
     condition?: Value<boolean, [
         response: StandardLazyResponse,
-        options: StandardLinkTransportInterceptorOptions<T>
+        options: StandardLinkClientInterceptorOptions<T>
     ]>;
     /**
      * Maximum attempts before giving up retries.
@@ -264,7 +179,7 @@ interface RetryAfterLinkPluginOptions<T extends ClientContext> {
      */
     maxAttempts?: Value<number, [
         response: StandardLazyResponse,
-        options: StandardLinkTransportInterceptorOptions<T>
+        options: StandardLinkClientInterceptorOptions<T>
     ]>;
     /**
      * Maximum timeout in milliseconds to wait before giving up retries.
@@ -273,46 +188,62 @@ interface RetryAfterLinkPluginOptions<T extends ClientContext> {
      */
     timeout?: Value<number, [
         response: StandardLazyResponse,
-        options: StandardLinkTransportInterceptorOptions<T>
+        options: StandardLinkClientInterceptorOptions<T>
     ]>;
 }
 /**
- * The Retry After Link Plugin automatically retries requests based on server `retry-after` header.
+ * The Retry After Plugin automatically retries requests based on server `Retry-After` headers.
  * This is particularly useful for handling rate limiting and temporary server unavailability.
  *
  * @see {@link https://orpc.dev/docs/plugins/retry-after Retry After Plugin Docs}
  */
-declare class RetryAfterLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+declare class RetryAfterPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
     private readonly condition;
     private readonly maxAttempts;
     private readonly timeout;
-    name: string;
-    constructor(options?: RetryAfterLinkPluginOptions<T>);
-    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+    order: number;
+    constructor(options?: RetryAfterPluginOptions<T>);
+    init(options: StandardLinkOptions<T>): void;
+    private parseRetryAfterHeader;
+    private delayExecution;
 }
 
-interface TimeoutLinkPluginOptions<T extends ClientContext> {
+interface SimpleCsrfProtectionLinkPluginOptions<T extends ClientContext> {
     /**
-     * Timeout in milliseconds before the request is aborted.
-     * Use `null` or `undefined` to disable the timeout.
+     * The name of the header to check.
+     *
+     * @default 'x-csrf-token'
      */
-    timeout: Value<number | null | undefined, [options: StandardLinkInterceptorOptions<T>]>;
+    headerName?: Value<Promisable<string>, [options: StandardLinkClientInterceptorOptions<T>]>;
+    /**
+     * The value of the header to check.
+     *
+     * @default 'orpc'
+     *
+     */
+    headerValue?: Value<Promisable<string>, [options: StandardLinkClientInterceptorOptions<T>]>;
+    /**
+     * Exclude a procedure from the plugin.
+     *
+     * @default false
+     */
+    exclude?: Value<Promisable<boolean>, [options: StandardLinkClientInterceptorOptions<T>]>;
 }
 /**
- * The Timeout Link Plugin aborts requests that exceed a configured timeout with an `AbortError`.
+ * This plugin adds basic Cross-Site Request Forgery (CSRF) protection to your oRPC application.
+ * It helps ensure that requests to your procedures originate from JavaScript code,
+ * not from other sources like standard HTML forms or direct browser navigation.
  *
- * @see {@link https://orpc.dev/docs/plugins/timeout Timeout Plugin Docs}
+ * @see {@link https://orpc.dev/docs/plugins/simple-csrf-protection Simple CSRF Protection Plugin Docs}
  */
-declare class TimeoutLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
-    private readonly timeout;
-    name: string;
-    /**
-     * Should abort if the total retry time exceeds the configured timeout
-     */
-    after: string[];
-    constructor(options: NoInfer<TimeoutLinkPluginOptions<T>>);
-    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+declare class SimpleCsrfProtectionLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly headerName;
+    private readonly headerValue;
+    private readonly exclude;
+    constructor(options?: SimpleCsrfProtectionLinkPluginOptions<T>);
+    order: number;
+    init(options: StandardLinkOptions<T>): void;
 }
 
-export { BatchLinkPlugin, BatchLinkPluginError, DedupeLinkPlugin, RequestCompressionLinkPlugin, ResponseCompressionLinkPlugin, RetryAfterLinkPlugin, RetryLinkPlugin, TimeoutLinkPlugin };
-export type { BatchLinkPluginGroup, BatchLinkPluginMode, BatchLinkPluginOptions, DedupeLinkPluginGroup, DedupeLinkPluginOptions, RequestCompressionLinkPluginOptions, ResponseCompressionLinkPluginOptions, RetryAfterLinkPluginOptions, RetryLinkPluginAttemptOptions, RetryLinkPluginContext, RetryLinkPluginOptions, TimeoutLinkPluginOptions };
+export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, DedupeRequestsPlugin, RetryAfterPlugin, SimpleCsrfProtectionLinkPlugin };
+export type { BatchLinkPluginGroup, BatchLinkPluginOptions, ClientRetryPluginAttemptOptions, ClientRetryPluginContext, ClientRetryPluginOptions, DedupeRequestsPluginGroup, DedupeRequestsPluginOptions, RetryAfterPluginOptions, SimpleCsrfProtectionLinkPluginOptions };