@atproto/xrpc 0.4.3 → 0.6.0-rc.0

package/dist/types.d.ts

@@ -1,17 +1,15 @@
 import { z } from 'zod';
 import { ValidationError } from '@atproto/lexicon';
 export type QueryParams = Record<string, any>;
-export type Headers = Record<string, string>;
+export type HeadersMap = Record<string, string>;
+/** @deprecated not to be confused with the WHATWG Headers constructor */
+export type Headers = HeadersMap;
+export type Gettable<T> = T | (() => T);
 export interface CallOptions {
     encoding?: string;
-    headers?: Headers;
+    signal?: AbortSignal;
+    headers?: HeadersMap;
 }
-export interface FetchHandlerResponse {
-    status: number;
-    headers: Headers;
-    body: ArrayBuffer | undefined;
-}
-export type FetchHandler = (httpUri: string, httpMethod: string, httpHeaders: Headers, httpReqBody: any) => Promise<FetchHandlerResponse>;
 export declare const errorResponseBody: z.ZodObject<{
     error: z.ZodOptional<z.ZodString>;
     message: z.ZodOptional<z.ZodString>;
@@ -39,7 +37,9 @@ export declare enum ResponseType {
     NotEnoughResources = 503,
     UpstreamTimeout = 504
 }
+export declare function httpResponseCodeToEnum(status: number): ResponseType;
 export declare const ResponseTypeNames: {
+    1: string;
     2: string;
     200: string;
     400: string;
@@ -54,7 +54,9 @@ export declare const ResponseTypeNames: {
     503: string;
     504: string;
 };
+export declare function httpResponseCodeToName(status: number): string;
 export declare const ResponseTypeStrings: {
+    1: string;
     2: string;
     200: string;
     400: string;
@@ -69,6 +71,7 @@ export declare const ResponseTypeStrings: {
     503: string;
     504: string;
 };
+export declare function httpResponseCodeToString(status: number): string;
 export declare class XRPCResponse {
     data: any;
     headers: Headers;
@@ -76,11 +79,12 @@ export declare class XRPCResponse {
     constructor(data: any, headers: Headers);
 }
 export declare class XRPCError extends Error {
-    status: ResponseType;
-    error?: string | undefined;
+    error: string;
+    headers?: HeadersMap | undefined;
     success: boolean;
-    headers?: Headers;
-    constructor(status: ResponseType, error?: string | undefined, message?: string, headers?: Headers);
+    status: ResponseType;
+    constructor(statusCode: number, error?: string, message?: string, headers?: HeadersMap | undefined, options?: ErrorOptions);
+    static from(cause: unknown, fallbackStatus?: ResponseType): XRPCError;
 }
 export declare class XRPCInvalidResponseError extends XRPCError {
     lexiconNsid: string;
@@ -88,3 +92,4 @@ export declare class XRPCInvalidResponseError extends XRPCError {
     responseBody: unknown;
     constructor(lexiconNsid: string, validationError: ValidationError, responseBody: unknown);
 }
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAElD,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAC7C,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE/C,yEAAyE;AACzE,MAAM,MAAM,OAAO,GAAG,UAAU,CAAA;AAEhC,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;AAEvC,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,OAAO,CAAC,EAAE,UAAU,CAAA;CACrB;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;EAG5B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEjE,oBAAY,YAAY;IACtB,OAAO,IAAI;IACX,eAAe,IAAI;IACnB,OAAO,MAAM;IACb,cAAc,MAAM;IACpB,YAAY,MAAM;IAClB,SAAS,MAAM;IACf,gBAAgB,MAAM;IACtB,eAAe,MAAM;IACrB,iBAAiB,MAAM;IACvB,mBAAmB,MAAM;IACzB,oBAAoB,MAAM;IAC1B,eAAe,MAAM;IACrB,kBAAkB,MAAM;IACxB,eAAe,MAAM;CACtB;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAcnE;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;CAe7B,CAAA;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;CAe/B,CAAA;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,qBAAa,YAAY;IAId,IAAI,EAAE,GAAG;IACT,OAAO,EAAE,OAAO;IAJzB,OAAO,UAAO;gBAGL,IAAI,EAAE,GAAG,EACT,OAAO,EAAE,OAAO;CAE1B;AAED,qBAAa,SAAU,SAAQ,KAAK;IAOzB,KAAK,EAAE,MAAM;IAEb,OAAO,CAAC;IARjB,OAAO,UAAQ;IAER,MAAM,EAAE,YAAY,CAAA;gBAGzB,UAAU,EAAE,MAAM,EACX,KAAK,GAAE,MAA2C,EACzD,OAAO,CAAC,EAAE,MAAM,EACT,OAAO,CAAC,wBAAS,EACxB,OAAO,CAAC,EAAE,YAAY;IAaxB,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,CAAC,EAAE,YAAY,GAAG,SAAS;CAsBtE;AAED,qBAAa,wBAAyB,SAAQ,SAAS;IAE5C,WAAW,EAAE,MAAM;IACnB,eAAe,EAAE,eAAe;IAChC,YAAY,EAAE,OAAO;gBAFrB,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,eAAe,EAChC,YAAY,EAAE,OAAO;CAU/B"}

package/dist/types.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XRPCInvalidResponseError = exports.XRPCError = exports.XRPCResponse = exports.httpResponseCodeToString = exports.ResponseTypeStrings = exports.httpResponseCodeToName = exports.ResponseTypeNames = exports.httpResponseCodeToEnum = exports.ResponseType = exports.errorResponseBody = void 0;
+const zod_1 = require("zod");
+exports.errorResponseBody = zod_1.z.object({
+    error: zod_1.z.string().optional(),
+    message: zod_1.z.string().optional(),
+});
+var ResponseType;
+(function (ResponseType) {
+    ResponseType[ResponseType["Unknown"] = 1] = "Unknown";
+    ResponseType[ResponseType["InvalidResponse"] = 2] = "InvalidResponse";
+    ResponseType[ResponseType["Success"] = 200] = "Success";
+    ResponseType[ResponseType["InvalidRequest"] = 400] = "InvalidRequest";
+    ResponseType[ResponseType["AuthRequired"] = 401] = "AuthRequired";
+    ResponseType[ResponseType["Forbidden"] = 403] = "Forbidden";
+    ResponseType[ResponseType["XRPCNotSupported"] = 404] = "XRPCNotSupported";
+    ResponseType[ResponseType["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+    ResponseType[ResponseType["RateLimitExceeded"] = 429] = "RateLimitExceeded";
+    ResponseType[ResponseType["InternalServerError"] = 500] = "InternalServerError";
+    ResponseType[ResponseType["MethodNotImplemented"] = 501] = "MethodNotImplemented";
+    ResponseType[ResponseType["UpstreamFailure"] = 502] = "UpstreamFailure";
+    ResponseType[ResponseType["NotEnoughResources"] = 503] = "NotEnoughResources";
+    ResponseType[ResponseType["UpstreamTimeout"] = 504] = "UpstreamTimeout";
+})(ResponseType || (exports.ResponseType = ResponseType = {}));
+function httpResponseCodeToEnum(status) {
+    if (status in ResponseType) {
+        return status;
+    }
+    else if (status >= 100 && status < 200) {
+        return ResponseType.XRPCNotSupported;
+    }
+    else if (status >= 200 && status < 300) {
+        return ResponseType.Success;
+    }
+    else if (status >= 300 && status < 400) {
+        return ResponseType.XRPCNotSupported;
+    }
+    else if (status >= 400 && status < 500) {
+        return ResponseType.InvalidRequest;
+    }
+    else {
+        return ResponseType.InternalServerError;
+    }
+}
+exports.httpResponseCodeToEnum = httpResponseCodeToEnum;
+exports.ResponseTypeNames = {
+    [ResponseType.Unknown]: 'Unknown',
+    [ResponseType.InvalidResponse]: 'InvalidResponse',
+    [ResponseType.Success]: 'Success',
+    [ResponseType.InvalidRequest]: 'InvalidRequest',
+    [ResponseType.AuthRequired]: 'AuthenticationRequired',
+    [ResponseType.Forbidden]: 'Forbidden',
+    [ResponseType.XRPCNotSupported]: 'XRPCNotSupported',
+    [ResponseType.PayloadTooLarge]: 'PayloadTooLarge',
+    [ResponseType.RateLimitExceeded]: 'RateLimitExceeded',
+    [ResponseType.InternalServerError]: 'InternalServerError',
+    [ResponseType.MethodNotImplemented]: 'MethodNotImplemented',
+    [ResponseType.UpstreamFailure]: 'UpstreamFailure',
+    [ResponseType.NotEnoughResources]: 'NotEnoughResources',
+    [ResponseType.UpstreamTimeout]: 'UpstreamTimeout',
+};
+function httpResponseCodeToName(status) {
+    return exports.ResponseTypeNames[httpResponseCodeToEnum(status)];
+}
+exports.httpResponseCodeToName = httpResponseCodeToName;
+exports.ResponseTypeStrings = {
+    [ResponseType.Unknown]: 'Unknown',
+    [ResponseType.InvalidResponse]: 'Invalid Response',
+    [ResponseType.Success]: 'Success',
+    [ResponseType.InvalidRequest]: 'Invalid Request',
+    [ResponseType.AuthRequired]: 'Authentication Required',
+    [ResponseType.Forbidden]: 'Forbidden',
+    [ResponseType.XRPCNotSupported]: 'XRPC Not Supported',
+    [ResponseType.PayloadTooLarge]: 'Payload Too Large',
+    [ResponseType.RateLimitExceeded]: 'Rate Limit Exceeded',
+    [ResponseType.InternalServerError]: 'Internal Server Error',
+    [ResponseType.MethodNotImplemented]: 'Method Not Implemented',
+    [ResponseType.UpstreamFailure]: 'Upstream Failure',
+    [ResponseType.NotEnoughResources]: 'Not Enough Resources',
+    [ResponseType.UpstreamTimeout]: 'Upstream Timeout',
+};
+function httpResponseCodeToString(status) {
+    return exports.ResponseTypeStrings[httpResponseCodeToEnum(status)];
+}
+exports.httpResponseCodeToString = httpResponseCodeToString;
+class XRPCResponse {
+    constructor(data, headers) {
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: data
+        });
+        Object.defineProperty(this, "headers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: headers
+        });
+        Object.defineProperty(this, "success", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+    }
+}
+exports.XRPCResponse = XRPCResponse;
+class XRPCError extends Error {
+    constructor(statusCode, error = httpResponseCodeToName(statusCode), message, headers, options) {
+        super(message || error || httpResponseCodeToString(statusCode), options);
+        Object.defineProperty(this, "error", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: error
+        });
+        Object.defineProperty(this, "headers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: headers
+        });
+        Object.defineProperty(this, "success", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.status = httpResponseCodeToEnum(statusCode);
+        // Pre 2022 runtimes won't handle the "options" constructor argument
+        const cause = options?.cause;
+        if (this.cause === undefined && cause !== undefined) {
+            this.cause = cause;
+        }
+    }
+    static from(cause, fallbackStatus) {
+        if (cause instanceof XRPCError) {
+            return cause;
+        }
+        // Extract status code from "http-errors" like errors
+        const statusCode = cause instanceof Error
+            ? ('statusCode' in cause ? cause.statusCode : undefined) ??
+                ('status' in cause ? cause.status : undefined)
+            : undefined;
+        const status = typeof statusCode === 'number'
+            ? httpResponseCodeToEnum(statusCode)
+            : fallbackStatus ?? ResponseType.Unknown;
+        const error = exports.ResponseTypeNames[status];
+        const message = cause instanceof Error ? cause.message : String(cause);
+        return new XRPCError(status, error, message, undefined, { cause });
+    }
+}
+exports.XRPCError = XRPCError;
+class XRPCInvalidResponseError extends XRPCError {
+    constructor(lexiconNsid, validationError, responseBody) {
+        super(ResponseType.InvalidResponse, exports.ResponseTypeStrings[ResponseType.InvalidResponse], `The server gave an invalid response and may be out of date.`, undefined, { cause: validationError });
+        Object.defineProperty(this, "lexiconNsid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: lexiconNsid
+        });
+        Object.defineProperty(this, "validationError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: validationError
+        });
+        Object.defineProperty(this, "responseBody", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: responseBody
+        });
+    }
+}
+exports.XRPCInvalidResponseError = XRPCInvalidResponseError;
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/util.d.ts

@@ -1,10 +1,14 @@
 import { LexXrpcProcedure, LexXrpcQuery } from '@atproto/lexicon';
-import { CallOptions, Headers, QueryParams, ResponseType } from './types';
+import { CallOptions, ErrorResponseBody, Gettable, QueryParams } from './types';
+export declare function isErrorResponseBody(v: unknown): v is ErrorResponseBody;
 export declare function getMethodSchemaHTTPMethod(schema: LexXrpcProcedure | LexXrpcQuery): "post" | "get";
 export declare function constructMethodCallUri(nsid: string, schema: LexXrpcProcedure | LexXrpcQuery, serviceUri: URL, params?: QueryParams): string;
+export declare function constructMethodCallUrl(nsid: string, schema: LexXrpcProcedure | LexXrpcQuery, params?: QueryParams): string;
 export declare function encodeQueryParam(type: 'string' | 'float' | 'integer' | 'boolean' | 'datetime' | 'array' | 'unknown', value: any): string;
-export declare function normalizeHeaders(headers: Headers): Headers;
-export declare function constructMethodCallHeaders(schema: LexXrpcProcedure | LexXrpcQuery, data?: any, opts?: CallOptions): Headers;
-export declare function encodeMethodCallBody(headers: Headers, data?: any): ArrayBuffer | undefined;
-export declare function httpResponseCodeToEnum(status: number): ResponseType;
+export declare function constructMethodCallHeaders(schema: LexXrpcProcedure | LexXrpcQuery, data?: unknown, opts?: CallOptions): Headers;
+export declare function combineHeaders(headersInit: undefined | HeadersInit, defaultHeaders?: Iterable<[string, undefined | Gettable<null | string>]>): undefined | HeadersInit;
+export declare function isBodyInit(value: unknown): value is BodyInit;
+export declare function isIterable(value: unknown): value is Iterable<unknown> | AsyncIterable<unknown>;
+export declare function encodeMethodCallBody(headers: Headers, data?: unknown): BodyInit | undefined;
 export declare function httpResponseBodyParse(mimeType: string | null, data: ArrayBuffer | undefined): any;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAChB,YAAY,EAEb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,WAAW,EAEX,iBAAiB,EACjB,QAAQ,EACR,WAAW,EAGZ,MAAM,SAAS,CAAA;AAYhB,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,iBAAiB,CAEtE;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,gBAAgB,GAAG,YAAY,kBAMxC;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,gBAAgB,GAAG,YAAY,EACvC,UAAU,EAAE,GAAG,EACf,MAAM,CAAC,EAAE,WAAW,GACnB,MAAM,CAGR;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,gBAAgB,GAAG,YAAY,EACvC,MAAM,CAAC,EAAE,WAAW,GACnB,MAAM,CA6BR;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EACA,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GACT,UAAU,GACV,OAAO,GACP,SAAS,EACb,KAAK,EAAE,GAAG,GACT,MAAM,CAiBR;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,gBAAgB,GAAG,YAAY,EACvC,IAAI,CAAC,EAAE,OAAO,EACd,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAoET;AAED,wBAAgB,cAAc,CAC5B,WAAW,EAAE,SAAS,GAAG,WAAW,EACpC,cAAc,CAAC,EAAE,QAAQ,CAAC,CAAC,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,GACvE,SAAS,GAAG,WAAW,CAuBzB;AAmBD,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAgB5D;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC,CAMrD;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,IAAI,CAAC,EAAE,OAAO,GACb,QAAQ,GAAG,SAAS,CAqEtB;AA6FD,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,IAAI,EAAE,WAAW,GAAG,SAAS,GAC5B,GAAG,CAwBL"}

package/dist/util.js

@@ -0,0 +1,362 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpResponseBodyParse = exports.encodeMethodCallBody = exports.isIterable = exports.isBodyInit = exports.combineHeaders = exports.constructMethodCallHeaders = exports.encodeQueryParam = exports.constructMethodCallUrl = exports.constructMethodCallUri = exports.getMethodSchemaHTTPMethod = exports.isErrorResponseBody = void 0;
+const lexicon_1 = require("@atproto/lexicon");
+const types_1 = require("./types");
+const ReadableStream = globalThis.ReadableStream ||
+    class {
+        constructor() {
+            // This anonymous class will never pass any "instanceof" check and cannot
+            // be instantiated.
+            throw new Error('ReadableStream is not supported in this environment');
+        }
+    };
+function isErrorResponseBody(v) {
+    return types_1.errorResponseBody.safeParse(v).success;
+}
+exports.isErrorResponseBody = isErrorResponseBody;
+function getMethodSchemaHTTPMethod(schema) {
+    if (schema.type === 'procedure') {
+        return 'post';
+    }
+    return 'get';
+}
+exports.getMethodSchemaHTTPMethod = getMethodSchemaHTTPMethod;
+function constructMethodCallUri(nsid, schema, serviceUri, params) {
+    const uri = new URL(constructMethodCallUrl(nsid, schema, params), serviceUri);
+    return uri.toString();
+}
+exports.constructMethodCallUri = constructMethodCallUri;
+function constructMethodCallUrl(nsid, schema, params) {
+    const pathname = `/xrpc/${encodeURIComponent(nsid)}`;
+    if (!params)
+        return pathname;
+    const searchParams = [];
+    for (const [key, value] of Object.entries(params)) {
+        const paramSchema = schema.parameters?.properties?.[key];
+        if (!paramSchema) {
+            throw new Error(`Invalid query parameter: ${key}`);
+        }
+        if (value !== undefined) {
+            if (paramSchema.type === 'array') {
+                const values = Array.isArray(value) ? value : [value];
+                for (const val of values) {
+                    searchParams.push([
+                        key,
+                        encodeQueryParam(paramSchema.items.type, val),
+                    ]);
+                }
+            }
+            else {
+                searchParams.push([key, encodeQueryParam(paramSchema.type, value)]);
+            }
+        }
+    }
+    if (!searchParams.length)
+        return pathname;
+    return `${pathname}?${new URLSearchParams(searchParams).toString()}`;
+}
+exports.constructMethodCallUrl = constructMethodCallUrl;
+function encodeQueryParam(type, value) {
+    if (type === 'string' || type === 'unknown') {
+        return String(value);
+    }
+    if (type === 'float') {
+        return String(Number(value));
+    }
+    else if (type === 'integer') {
+        return String(Number(value) | 0);
+    }
+    else if (type === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    else if (type === 'datetime') {
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        return String(value);
+    }
+    throw new Error(`Unsupported query param type: ${type}`);
+}
+exports.encodeQueryParam = encodeQueryParam;
+function constructMethodCallHeaders(schema, data, opts) {
+    // Not using `new Headers(opts?.headers)` to avoid duplicating headers values
+    // due to inconsistent casing in headers name. In case of multiple headers
+    // with the same name (but using a different case), the last one will be used.
+    // new Headers({ 'content-type': 'foo', 'Content-Type': 'bar' }).get('content-type')
+    // => 'foo, bar'
+    const headers = new Headers();
+    if (opts?.headers) {
+        for (const name in opts.headers) {
+            if (headers.has(name)) {
+                throw new TypeError(`Duplicate header: ${name}`);
+            }
+            const value = opts.headers[name];
+            if (value != null) {
+                headers.set(name, value);
+            }
+        }
+    }
+    if (schema.type === 'procedure') {
+        if (opts?.encoding) {
+            headers.set('content-type', opts.encoding);
+        }
+        else if (!headers.has('content-type') && typeof data !== 'undefined') {
+            // Special handling of BodyInit types before falling back to JSON encoding
+            if (data instanceof ArrayBuffer ||
+                data instanceof ReadableStream ||
+                ArrayBuffer.isView(data)) {
+                headers.set('content-type', 'application/octet-stream');
+            }
+            else if (data instanceof FormData) {
+                // Note: The multipart form data boundary is missing from the header
+                // we set here, making that header invalid. This special case will be
+                // handled in encodeMethodCallBody()
+                headers.set('content-type', 'multipart/form-data');
+            }
+            else if (data instanceof URLSearchParams) {
+                headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+            }
+            else if (isBlobLike(data)) {
+                headers.set('content-type', data.type || 'application/octet-stream');
+            }
+            else if (typeof data === 'string') {
+                headers.set('content-type', 'text/plain;charset=UTF-8');
+            }
+            // At this point, data is not a valid BodyInit type.
+            else if (isIterable(data)) {
+                headers.set('content-type', 'application/octet-stream');
+            }
+            else if (typeof data === 'boolean' ||
+                typeof data === 'number' ||
+                typeof data === 'string' ||
+                typeof data === 'object' // covers "null"
+            ) {
+                headers.set('content-type', 'application/json');
+            }
+            else {
+                // symbol, function, bigint
+                throw new types_1.XRPCError(types_1.ResponseType.InvalidRequest, `Unsupported data type: ${typeof data}`);
+            }
+        }
+    }
+    return headers;
+}
+exports.constructMethodCallHeaders = constructMethodCallHeaders;
+function combineHeaders(headersInit, defaultHeaders) {
+    if (!defaultHeaders)
+        return headersInit;
+    let headers = undefined;
+    for (const [key, getter] of defaultHeaders) {
+        // Ignore undefined values (allowed for convenience when using
+        // Object.entries).
+        if (getter === undefined)
+            continue;
+        // Lazy initialization of the headers object
+        headers ?? (headers = new Headers(headersInit));
+        if (headers.has(key))
+            continue;
+        const value = typeof getter === 'function' ? getter() : getter;
+        if (typeof value === 'string')
+            headers.set(key, value);
+        else if (value === null)
+            headers.delete(key);
+        else
+            throw new TypeError(`Invalid "${key}" header value: ${typeof value}`);
+    }
+    return headers ?? headersInit;
+}
+exports.combineHeaders = combineHeaders;
+function isBlobLike(value) {
+    if (value == null)
+        return false;
+    if (typeof value !== 'object')
+        return false;
+    if (typeof Blob === 'function' && value instanceof Blob)
+        return true;
+    // Support for Blobs provided by libraries that don't use the native Blob
+    // (e.g. fetch-blob from node-fetch).
+    // https://github.com/node-fetch/fetch-blob/blob/a1a182e5978811407bef4ea1632b517567dda01f/index.js#L233-L244
+    const tag = value[Symbol.toStringTag];
+    if (tag === 'Blob' || tag === 'File') {
+        return 'stream' in value && typeof value.stream === 'function';
+    }
+    return false;
+}
+function isBodyInit(value) {
+    switch (typeof value) {
+        case 'string':
+            return true;
+        case 'object':
+            return (value instanceof ArrayBuffer ||
+                value instanceof FormData ||
+                value instanceof URLSearchParams ||
+                value instanceof ReadableStream ||
+                ArrayBuffer.isView(value) ||
+                isBlobLike(value));
+        default:
+            return false;
+    }
+}
+exports.isBodyInit = isBodyInit;
+function isIterable(value) {
+    return (value != null &&
+        typeof value === 'object' &&
+        (Symbol.iterator in value || Symbol.asyncIterator in value));
+}
+exports.isIterable = isIterable;
+function encodeMethodCallBody(headers, data) {
+    // Silently ignore the body if there is no content-type header.
+    const contentType = headers.get('content-type');
+    if (!contentType) {
+        return undefined;
+    }
+    if (typeof data === 'undefined') {
+        // This error would be returned by the server, but we can catch it earlier
+        // to avoid un-necessary requests. Note that a content-length of 0 does not
+        // necessary mean that the body is "empty" (e.g. an empty txt file).
+        throw new types_1.XRPCError(types_1.ResponseType.InvalidRequest, `A request body is expected but none was provided`);
+    }
+    if (isBodyInit(data)) {
+        if (data instanceof FormData && contentType === 'multipart/form-data') {
+            // fetch() will encode FormData payload itself, but it won't override the
+            // content-type header if already present. This would cause the boundary
+            // to be missing from the content-type header, resulting in a 400 error.
+            // Deleting the content-type header here to let fetch() re-create it.
+            headers.delete('content-type');
+        }
+        // Will be encoded by the fetch API.
+        return data;
+    }
+    if (isIterable(data)) {
+        // Note that some environments support using Iterable & AsyncIterable as the
+        // body (e.g. Node's fetch), but not all of them do (browsers).
+        return iterableToReadableStream(data);
+    }
+    if (contentType.startsWith('text/')) {
+        return new TextEncoder().encode(String(data));
+    }
+    if (contentType.startsWith('application/json')) {
+        const json = (0, lexicon_1.stringifyLex)(data);
+        // Server would return a 400 error if the JSON is invalid (e.g. trying to
+        // JSONify a function, or an object that implements toJSON() poorly).
+        if (json === undefined) {
+            throw new types_1.XRPCError(types_1.ResponseType.InvalidRequest, `Failed to encode request body as JSON`);
+        }
+        return new TextEncoder().encode(json);
+    }
+    // At this point, "data" is not a valid BodyInit value, and we don't know how
+    // to encode it into one. Passing it to fetch would result in an error. Let's
+    // throw our own error instead.
+    const type = !data || typeof data !== 'object'
+        ? typeof data
+        : data.constructor !== Object &&
+            typeof data.constructor === 'function' &&
+            typeof data.constructor?.name === 'string'
+            ? data.constructor.name
+            : 'object';
+    throw new types_1.XRPCError(types_1.ResponseType.InvalidRequest, `Unable to encode ${type} as ${contentType} data`);
+}
+exports.encodeMethodCallBody = encodeMethodCallBody;
+/**
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/from_static}
+ */
+function iterableToReadableStream(iterable) {
+    // Use the native ReadableStream.from() if available.
+    if ('from' in ReadableStream && typeof ReadableStream.from === 'function') {
+        return ReadableStream.from(iterable);
+    }
+    // Note, in environments where ReadableStream is not available either, we
+    // *could* load the iterable into memory and create an Arraybuffer from it.
+    // However, this would be a bad idea for large iterables. In order to keep
+    // things simple, we'll just allow the anonymous ReadableStream constructor
+    // to throw an error in those environments, hinting the user of the lib to find
+    // an alternate solution in that case (e.g. use a Blob if available).
+    let generator;
+    return new ReadableStream({
+        type: 'bytes',
+        start() {
+            // Wrap the iterable in an async generator to handle both sync and async
+            // iterables, and make sure that the return() method exists.
+            generator = (async function* () {
+                yield* iterable;
+            })();
+        },
+        async pull(controller) {
+            const { done, value } = await generator.next();
+            if (done) {
+                controller.close();
+            }
+            else {
+                try {
+                    const buf = toUint8Array(value);
+                    if (buf)
+                        controller.enqueue(buf);
+                }
+                catch (cause) {
+                    // ReadableStream won't call cancel() if the stream is errored.
+                    await generator.return();
+                    controller.error(new TypeError('Converting iterable body to ReadableStream requires Buffer, ArrayBuffer or string values', { cause }));
+                }
+            }
+        },
+        async cancel() {
+            await generator.return();
+        },
+    });
+}
+// Browsers don't have Buffer. This syntax is to avoid bundlers from including
+// a Buffer polyfill in the bundle if it's not used elsewhere.
+const globalName = `${{ toString: () => 'Buf' }}fer`;
+const Buffer = typeof globalThis[globalName] === 'function'
+    ? globalThis[globalName]
+    : undefined;
+const toUint8Array = Buffer
+    ? (value) => {
+        // @ts-expect-error Buffer.from will throw if value is not a valid input
+        const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
+        return buf.byteLength ? new Uint8Array(buf) : undefined;
+    }
+    : (value) => {
+        if (value instanceof ArrayBuffer) {
+            const buf = new Uint8Array(value);
+            return buf.byteLength ? buf : undefined;
+        }
+        // Simulate Buffer.from() behavior for strings and and coercion
+        if (typeof value === 'string') {
+            return value.length ? new TextEncoder().encode(value) : undefined;
+        }
+        else if (typeof value?.valueOf === 'function') {
+            const coerced = value.valueOf();
+            if (coerced instanceof ArrayBuffer) {
+                const buf = new Uint8Array(coerced);
+                return buf.byteLength ? buf : undefined;
+            }
+            else if (typeof coerced === 'string') {
+                return coerced.length ? new TextEncoder().encode(coerced) : undefined;
+            }
+        }
+        throw new TypeError(`Unable to convert "${typeof value}" to Uint8Array`);
+    };
+function httpResponseBodyParse(mimeType, data) {
+    try {
+        if (mimeType) {
+            if (mimeType.includes('application/json')) {
+                const str = new TextDecoder().decode(data);
+                return (0, lexicon_1.jsonStringToLex)(str);
+            }
+            if (mimeType.startsWith('text/')) {
+                return new TextDecoder().decode(data);
+            }
+        }
+        if (data instanceof ArrayBuffer) {
+            return new Uint8Array(data);
+        }
+        return data;
+    }
+    catch (cause) {
+        throw new types_1.XRPCError(types_1.ResponseType.InvalidResponse, undefined, `Failed to parse response body: ${String(cause)}`, undefined, { cause });
+    }
+}
+exports.httpResponseBodyParse = httpResponseBodyParse;
+//# sourceMappingURL=util.js.map