@orpc/client 0.0.0-next.d74cac4 → 0.0.0-next.d760838

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,175 @@
1
+ import { isObject, isTypescriptObject } from '@orpc/shared';
2
+ import { getEventMeta, withEventMeta } from '@orpc/standard-server';
3
+
4
+ const COMMON_ORPC_ERROR_DEFS = {
5
+ BAD_REQUEST: {
6
+ status: 400,
7
+ message: "Bad Request"
8
+ },
9
+ UNAUTHORIZED: {
10
+ status: 401,
11
+ message: "Unauthorized"
12
+ },
13
+ FORBIDDEN: {
14
+ status: 403,
15
+ message: "Forbidden"
16
+ },
17
+ NOT_FOUND: {
18
+ status: 404,
19
+ message: "Not Found"
20
+ },
21
+ METHOD_NOT_SUPPORTED: {
22
+ status: 405,
23
+ message: "Method Not Supported"
24
+ },
25
+ NOT_ACCEPTABLE: {
26
+ status: 406,
27
+ message: "Not Acceptable"
28
+ },
29
+ TIMEOUT: {
30
+ status: 408,
31
+ message: "Request Timeout"
32
+ },
33
+ CONFLICT: {
34
+ status: 409,
35
+ message: "Conflict"
36
+ },
37
+ PRECONDITION_FAILED: {
38
+ status: 412,
39
+ message: "Precondition Failed"
40
+ },
41
+ PAYLOAD_TOO_LARGE: {
42
+ status: 413,
43
+ message: "Payload Too Large"
44
+ },
45
+ UNSUPPORTED_MEDIA_TYPE: {
46
+ status: 415,
47
+ message: "Unsupported Media Type"
48
+ },
49
+ UNPROCESSABLE_CONTENT: {
50
+ status: 422,
51
+ message: "Unprocessable Content"
52
+ },
53
+ TOO_MANY_REQUESTS: {
54
+ status: 429,
55
+ message: "Too Many Requests"
56
+ },
57
+ CLIENT_CLOSED_REQUEST: {
58
+ status: 499,
59
+ message: "Client Closed Request"
60
+ },
61
+ INTERNAL_SERVER_ERROR: {
62
+ status: 500,
63
+ message: "Internal Server Error"
64
+ },
65
+ NOT_IMPLEMENTED: {
66
+ status: 501,
67
+ message: "Not Implemented"
68
+ },
69
+ BAD_GATEWAY: {
70
+ status: 502,
71
+ message: "Bad Gateway"
72
+ },
73
+ SERVICE_UNAVAILABLE: {
74
+ status: 503,
75
+ message: "Service Unavailable"
76
+ },
77
+ GATEWAY_TIMEOUT: {
78
+ status: 504,
79
+ message: "Gateway Timeout"
80
+ }
81
+ };
82
+ function fallbackORPCErrorStatus(code, status) {
83
+ return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
84
+ }
85
+ function fallbackORPCErrorMessage(code, message) {
86
+ return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
87
+ }
88
+ class ORPCError extends Error {
89
+ defined;
90
+ code;
91
+ status;
92
+ data;
93
+ constructor(code, ...[options]) {
94
+ if (options?.status && !isORPCErrorStatus(options.status)) {
95
+ throw new Error("[ORPCError] Invalid error status code.");
96
+ }
97
+ const message = fallbackORPCErrorMessage(code, options?.message);
98
+ super(message, options);
99
+ this.code = code;
100
+ this.status = fallbackORPCErrorStatus(code, options?.status);
101
+ this.defined = options?.defined ?? false;
102
+ this.data = options?.data;
103
+ }
104
+ toJSON() {
105
+ return {
106
+ defined: this.defined,
107
+ code: this.code,
108
+ status: this.status,
109
+ message: this.message,
110
+ data: this.data
111
+ };
112
+ }
113
+ }
114
+ function isDefinedError(error) {
115
+ return error instanceof ORPCError && error.defined;
116
+ }
117
+ function toORPCError(error) {
118
+ return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
119
+ message: "Internal server error",
120
+ cause: error
121
+ });
122
+ }
123
+ function isORPCErrorStatus(status) {
124
+ return status < 200 || status >= 400;
125
+ }
126
+ function isORPCErrorJson(json) {
127
+ if (!isObject(json)) {
128
+ return false;
129
+ }
130
+ const validKeys = ["defined", "code", "status", "message", "data"];
131
+ if (Object.keys(json).some((k) => !validKeys.includes(k))) {
132
+ return false;
133
+ }
134
+ return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && isORPCErrorStatus(json.status) && "message" in json && typeof json.message === "string";
135
+ }
136
+ function createORPCErrorFromJson(json, options = {}) {
137
+ return new ORPCError(json.code, {
138
+ ...options,
139
+ ...json
140
+ });
141
+ }
142
+
143
+ function mapEventIterator(iterator, maps) {
144
+ return async function* () {
145
+ try {
146
+ while (true) {
147
+ const { done, value } = await iterator.next();
148
+ let mappedValue = await maps.value(value, done);
149
+ if (mappedValue !== value) {
150
+ const meta = getEventMeta(value);
151
+ if (meta && isTypescriptObject(mappedValue)) {
152
+ mappedValue = withEventMeta(mappedValue, meta);
153
+ }
154
+ }
155
+ if (done) {
156
+ return mappedValue;
157
+ }
158
+ yield mappedValue;
159
+ }
160
+ } catch (error) {
161
+ let mappedError = await maps.error(error);
162
+ if (mappedError !== error) {
163
+ const meta = getEventMeta(error);
164
+ if (meta && isTypescriptObject(mappedError)) {
165
+ mappedError = withEventMeta(mappedError, meta);
166
+ }
167
+ }
168
+ throw mappedError;
169
+ } finally {
170
+ await iterator.return?.();
171
+ }
172
+ }();
173
+ }
174
+
175
+ export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, isORPCErrorStatus as b, isORPCErrorJson as c, createORPCErrorFromJson as d, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, toORPCError as t };
@@ -0,0 +1,87 @@
1
+ import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.CipPQkhk.mjs';
2
+ import { e as StandardLinkCodec, b as StandardLinkOptions } from './client.C7z5zk4v.mjs';
3
+ import { Segment, Value } from '@orpc/shared';
4
+ import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
5
+
6
+ declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
7
+ readonly BIGINT: 0;
8
+ readonly DATE: 1;
9
+ readonly NAN: 2;
10
+ readonly UNDEFINED: 3;
11
+ readonly URL: 4;
12
+ readonly REGEXP: 5;
13
+ readonly SET: 6;
14
+ readonly MAP: 7;
15
+ };
16
+ type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
17
+ type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
18
+ interface StandardRPCCustomJsonSerializer {
19
+ type: number;
20
+ condition(data: unknown): boolean;
21
+ serialize(data: any): unknown;
22
+ deserialize(serialized: any): unknown;
23
+ }
24
+ interface StandardRPCJsonSerializerOptions {
25
+ customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
26
+ }
27
+ declare class StandardRPCJsonSerializer {
28
+ private readonly customSerializers;
29
+ constructor(options?: StandardRPCJsonSerializerOptions);
30
+ serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
31
+ deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
32
+ deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
33
+ }
34
+
35
+ declare class StandardRPCSerializer {
36
+ #private;
37
+ private readonly jsonSerializer;
38
+ constructor(jsonSerializer: StandardRPCJsonSerializer);
39
+ serialize(data: unknown): object;
40
+ deserialize(data: unknown): unknown;
41
+ }
42
+
43
+ interface StandardRPCLinkCodecOptions<T extends ClientContext> {
44
+ /**
45
+ * Base url for all requests.
46
+ */
47
+ url: Value<string | URL, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
48
+ /**
49
+ * The maximum length of the URL.
50
+ *
51
+ * @default 2083
52
+ */
53
+ maxUrlLength?: Value<number, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
54
+ /**
55
+ * The method used to make the request.
56
+ *
57
+ * @default 'POST'
58
+ */
59
+ method?: Value<HTTPMethod, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
60
+ /**
61
+ * The method to use when the payload cannot safely pass to the server with method return from method function.
62
+ * GET is not allowed, it's very dangerous.
63
+ *
64
+ * @default 'POST'
65
+ */
66
+ fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
67
+ /**
68
+ * Inject headers to the request.
69
+ */
70
+ headers?: Value<StandardHeaders, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
71
+ }
72
+ declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
73
+ private readonly serializer;
74
+ private readonly baseUrl;
75
+ private readonly maxUrlLength;
76
+ private readonly fallbackMethod;
77
+ private readonly expectedMethod;
78
+ private readonly headers;
79
+ constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
80
+ encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
81
+ decode(response: StandardLazyResponse): Promise<unknown>;
82
+ }
83
+
84
+ interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
85
+ }
86
+
87
+ export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, type StandardRPCJsonSerializedMetaItem as a, type StandardRPCJsonSerialized as b, type StandardRPCCustomJsonSerializer as c, type StandardRPCJsonSerializerOptions as d, StandardRPCJsonSerializer as e, type StandardRPCLinkOptions as f, type StandardRPCLinkCodecOptions as g, StandardRPCLinkCodec as h, StandardRPCSerializer as i };
@@ -0,0 +1,29 @@
1
+ import { PromiseWithError } from '@orpc/shared';
2
+
3
+ type HTTPPath = `/${string}`;
4
+ type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
5
+ type ClientContext = Record<PropertyKey, any>;
6
+ interface ClientOptions<T extends ClientContext> {
7
+ signal?: AbortSignal;
8
+ lastEventId?: string | undefined;
9
+ context: T;
10
+ }
11
+ type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (Record<never, never> extends T ? {
12
+ context?: T;
13
+ } : {
14
+ context: T;
15
+ });
16
+ type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
17
+ type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
18
+ interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
19
+ (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
20
+ }
21
+ type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
22
+ [k: string]: NestedClient<TClientContext>;
23
+ };
24
+ type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
25
+ interface ClientLink<TClientContext extends ClientContext> {
26
+ call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
27
+ }
28
+
29
+ export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };
@@ -0,0 +1,29 @@
1
+ import { PromiseWithError } from '@orpc/shared';
2
+
3
+ type HTTPPath = `/${string}`;
4
+ type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
5
+ type ClientContext = Record<PropertyKey, any>;
6
+ interface ClientOptions<T extends ClientContext> {
7
+ signal?: AbortSignal;
8
+ lastEventId?: string | undefined;
9
+ context: T;
10
+ }
11
+ type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (Record<never, never> extends T ? {
12
+ context?: T;
13
+ } : {
14
+ context: T;
15
+ });
16
+ type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
17
+ type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
18
+ interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
19
+ (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
20
+ }
21
+ type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
22
+ [k: string]: NestedClient<TClientContext>;
23
+ };
24
+ type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
25
+ interface ClientLink<TClientContext extends ClientContext> {
26
+ call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
27
+ }
28
+
29
+ export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };
@@ -0,0 +1,337 @@
1
+ import { toArray, intercept, isObject, value, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
2
+ import { mergeStandardHeaders, ErrorEvent } from '@orpc/standard-server';
3
+ import { C as COMMON_ORPC_ERROR_DEFS, b as isORPCErrorStatus, c as isORPCErrorJson, d as createORPCErrorFromJson, O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.CRWEpqLB.mjs';
4
+
5
+ class InvalidEventIteratorRetryResponse extends Error {
6
+ }
7
+ class StandardLink {
8
+ constructor(codec, sender, options = {}) {
9
+ this.codec = codec;
10
+ this.sender = sender;
11
+ for (const plugin of toArray(options.plugins)) {
12
+ plugin.init?.(options);
13
+ }
14
+ this.interceptors = toArray(options.interceptors);
15
+ this.clientInterceptors = toArray(options.clientInterceptors);
16
+ }
17
+ interceptors;
18
+ clientInterceptors;
19
+ call(path, input, options) {
20
+ return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
21
+ const output = await this.#call(path2, input2, options2);
22
+ return output;
23
+ });
24
+ }
25
+ async #call(path, input, options) {
26
+ const request = await this.codec.encode(path, input, options);
27
+ const response = await intercept(
28
+ this.clientInterceptors,
29
+ { ...options, input, path, request },
30
+ ({ input: input2, path: path2, request: request2, ...options2 }) => this.sender.call(request2, options2, path2, input2)
31
+ );
32
+ const output = await this.codec.decode(response, options, path, input);
33
+ return output;
34
+ }
35
+ }
36
+
37
+ const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES = {
38
+ BIGINT: 0,
39
+ DATE: 1,
40
+ NAN: 2,
41
+ UNDEFINED: 3,
42
+ URL: 4,
43
+ REGEXP: 5,
44
+ SET: 6,
45
+ MAP: 7
46
+ };
47
+ class StandardRPCJsonSerializer {
48
+ customSerializers;
49
+ constructor(options = {}) {
50
+ this.customSerializers = options.customJsonSerializers ?? [];
51
+ if (this.customSerializers.length !== new Set(this.customSerializers.map((custom) => custom.type)).size) {
52
+ throw new Error("Custom serializer type must be unique.");
53
+ }
54
+ }
55
+ serialize(data, segments = [], meta = [], maps = [], blobs = []) {
56
+ for (const custom of this.customSerializers) {
57
+ if (custom.condition(data)) {
58
+ const result = this.serialize(custom.serialize(data), segments, meta, maps, blobs);
59
+ meta.push([custom.type, ...segments]);
60
+ return result;
61
+ }
62
+ }
63
+ if (data instanceof Blob) {
64
+ maps.push(segments);
65
+ blobs.push(data);
66
+ return [data, meta, maps, blobs];
67
+ }
68
+ if (typeof data === "bigint") {
69
+ meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT, ...segments]);
70
+ return [data.toString(), meta, maps, blobs];
71
+ }
72
+ if (data instanceof Date) {
73
+ meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE, ...segments]);
74
+ if (Number.isNaN(data.getTime())) {
75
+ return [null, meta, maps, blobs];
76
+ }
77
+ return [data.toISOString(), meta, maps, blobs];
78
+ }
79
+ if (Number.isNaN(data)) {
80
+ meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN, ...segments]);
81
+ return [null, meta, maps, blobs];
82
+ }
83
+ if (data instanceof URL) {
84
+ meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL, ...segments]);
85
+ return [data.toString(), meta, maps, blobs];
86
+ }
87
+ if (data instanceof RegExp) {
88
+ meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP, ...segments]);
89
+ return [data.toString(), meta, maps, blobs];
90
+ }
91
+ if (data instanceof Set) {
92
+ const result = this.serialize(Array.from(data), segments, meta, maps, blobs);
93
+ meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET, ...segments]);
94
+ return result;
95
+ }
96
+ if (data instanceof Map) {
97
+ const result = this.serialize(Array.from(data.entries()), segments, meta, maps, blobs);
98
+ meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP, ...segments]);
99
+ return result;
100
+ }
101
+ if (Array.isArray(data)) {
102
+ const json = data.map((v, i) => {
103
+ if (v === void 0) {
104
+ meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED, ...segments, i]);
105
+ return v;
106
+ }
107
+ return this.serialize(v, [...segments, i], meta, maps, blobs)[0];
108
+ });
109
+ return [json, meta, maps, blobs];
110
+ }
111
+ if (isObject(data)) {
112
+ const json = {};
113
+ for (const k in data) {
114
+ if (k === "toJSON" && typeof data[k] === "function") {
115
+ continue;
116
+ }
117
+ json[k] = this.serialize(data[k], [...segments, k], meta, maps, blobs)[0];
118
+ }
119
+ return [json, meta, maps, blobs];
120
+ }
121
+ return [data, meta, maps, blobs];
122
+ }
123
+ deserialize(json, meta, maps, getBlob) {
124
+ const ref = { data: json };
125
+ if (maps && getBlob) {
126
+ maps.forEach((segments, i) => {
127
+ let currentRef = ref;
128
+ let preSegment = "data";
129
+ segments.forEach((segment) => {
130
+ currentRef = currentRef[preSegment];
131
+ preSegment = segment;
132
+ });
133
+ currentRef[preSegment] = getBlob(i);
134
+ });
135
+ }
136
+ for (const item of meta) {
137
+ const type = item[0];
138
+ let currentRef = ref;
139
+ let preSegment = "data";
140
+ for (let i = 1; i < item.length; i++) {
141
+ currentRef = currentRef[preSegment];
142
+ preSegment = item[i];
143
+ }
144
+ for (const custom of this.customSerializers) {
145
+ if (custom.type === type) {
146
+ currentRef[preSegment] = custom.deserialize(currentRef[preSegment]);
147
+ break;
148
+ }
149
+ }
150
+ switch (type) {
151
+ case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT:
152
+ currentRef[preSegment] = BigInt(currentRef[preSegment]);
153
+ break;
154
+ case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE:
155
+ currentRef[preSegment] = new Date(currentRef[preSegment] ?? "Invalid Date");
156
+ break;
157
+ case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN:
158
+ currentRef[preSegment] = Number.NaN;
159
+ break;
160
+ case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED:
161
+ currentRef[preSegment] = void 0;
162
+ break;
163
+ case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL:
164
+ currentRef[preSegment] = new URL(currentRef[preSegment]);
165
+ break;
166
+ case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP: {
167
+ const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
168
+ currentRef[preSegment] = new RegExp(pattern, flags);
169
+ break;
170
+ }
171
+ case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET:
172
+ currentRef[preSegment] = new Set(currentRef[preSegment]);
173
+ break;
174
+ case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP:
175
+ currentRef[preSegment] = new Map(currentRef[preSegment]);
176
+ break;
177
+ }
178
+ }
179
+ return ref.data;
180
+ }
181
+ }
182
+
183
+ function toHttpPath(path) {
184
+ return `/${path.map(encodeURIComponent).join("/")}`;
185
+ }
186
+ function getMalformedResponseErrorCode(status) {
187
+ return Object.entries(COMMON_ORPC_ERROR_DEFS).find(([, def]) => def.status === status)?.[0] ?? "MALFORMED_ORPC_ERROR_RESPONSE";
188
+ }
189
+
190
+ class StandardRPCLinkCodec {
191
+ constructor(serializer, options) {
192
+ this.serializer = serializer;
193
+ this.baseUrl = options.url;
194
+ this.maxUrlLength = options.maxUrlLength ?? 2083;
195
+ this.fallbackMethod = options.fallbackMethod ?? "POST";
196
+ this.expectedMethod = options.method ?? this.fallbackMethod;
197
+ this.headers = options.headers ?? {};
198
+ }
199
+ baseUrl;
200
+ maxUrlLength;
201
+ fallbackMethod;
202
+ expectedMethod;
203
+ headers;
204
+ async encode(path, input, options) {
205
+ const expectedMethod = await value(this.expectedMethod, options, path, input);
206
+ let headers = await value(this.headers, options, path, input);
207
+ const baseUrl = await value(this.baseUrl, options, path, input);
208
+ const url = new URL(baseUrl);
209
+ url.pathname = `${url.pathname.replace(/\/$/, "")}${toHttpPath(path)}`;
210
+ if (options.lastEventId !== void 0) {
211
+ headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
212
+ }
213
+ const serialized = this.serializer.serialize(input);
214
+ if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
215
+ const maxUrlLength = await value(this.maxUrlLength, options, path, input);
216
+ const getUrl = new URL(url);
217
+ getUrl.searchParams.append("data", stringifyJSON(serialized));
218
+ if (getUrl.toString().length <= maxUrlLength) {
219
+ return {
220
+ body: void 0,
221
+ method: expectedMethod,
222
+ headers,
223
+ url: getUrl,
224
+ signal: options.signal
225
+ };
226
+ }
227
+ }
228
+ return {
229
+ url,
230
+ method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
231
+ headers,
232
+ body: serialized,
233
+ signal: options.signal
234
+ };
235
+ }
236
+ async decode(response) {
237
+ const isOk = !isORPCErrorStatus(response.status);
238
+ const deserialized = await (async () => {
239
+ let isBodyOk = false;
240
+ try {
241
+ const body = await response.body();
242
+ isBodyOk = true;
243
+ return this.serializer.deserialize(body);
244
+ } catch (error) {
245
+ if (!isBodyOk) {
246
+ throw new Error("Cannot parse response body, please check the response body and content-type.", {
247
+ cause: error
248
+ });
249
+ }
250
+ throw new Error("Invalid RPC response format.", {
251
+ cause: error
252
+ });
253
+ }
254
+ })();
255
+ if (!isOk) {
256
+ if (isORPCErrorJson(deserialized)) {
257
+ throw createORPCErrorFromJson(deserialized);
258
+ }
259
+ throw new ORPCError(getMalformedResponseErrorCode(response.status), {
260
+ status: response.status,
261
+ data: deserialized
262
+ });
263
+ }
264
+ return deserialized;
265
+ }
266
+ }
267
+
268
+ class StandardRPCSerializer {
269
+ constructor(jsonSerializer) {
270
+ this.jsonSerializer = jsonSerializer;
271
+ }
272
+ serialize(data) {
273
+ if (isAsyncIteratorObject(data)) {
274
+ return mapEventIterator(data, {
275
+ value: async (value) => this.#serialize(value, false),
276
+ error: async (e) => {
277
+ return new ErrorEvent({
278
+ data: this.#serialize(toORPCError(e).toJSON(), false),
279
+ cause: e
280
+ });
281
+ }
282
+ });
283
+ }
284
+ return this.#serialize(data, true);
285
+ }
286
+ #serialize(data, enableFormData) {
287
+ const [json, meta_, maps, blobs] = this.jsonSerializer.serialize(data);
288
+ const meta = meta_.length === 0 ? void 0 : meta_;
289
+ if (!enableFormData || blobs.length === 0) {
290
+ return {
291
+ json,
292
+ meta
293
+ };
294
+ }
295
+ const form = new FormData();
296
+ form.set("data", stringifyJSON({ json, meta, maps }));
297
+ blobs.forEach((blob, i) => {
298
+ form.set(i.toString(), blob);
299
+ });
300
+ return form;
301
+ }
302
+ deserialize(data) {
303
+ if (isAsyncIteratorObject(data)) {
304
+ return mapEventIterator(data, {
305
+ value: async (value) => this.#deserialize(value),
306
+ error: async (e) => {
307
+ if (!(e instanceof ErrorEvent)) {
308
+ return e;
309
+ }
310
+ const deserialized = this.#deserialize(e.data);
311
+ if (isORPCErrorJson(deserialized)) {
312
+ return createORPCErrorFromJson(deserialized, { cause: e });
313
+ }
314
+ return new ErrorEvent({
315
+ data: deserialized,
316
+ cause: e
317
+ });
318
+ }
319
+ });
320
+ }
321
+ return this.#deserialize(data);
322
+ }
323
+ #deserialize(data) {
324
+ if (!(data instanceof FormData)) {
325
+ return this.jsonSerializer.deserialize(data.json, data.meta ?? []);
326
+ }
327
+ const serialized = JSON.parse(data.get("data"));
328
+ return this.jsonSerializer.deserialize(
329
+ serialized.json,
330
+ serialized.meta ?? [],
331
+ serialized.maps,
332
+ (i) => data.get(i.toString())
333
+ );
334
+ }
335
+ }
336
+
337
+ export { InvalidEventIteratorRetryResponse as I, StandardLink as S, STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as a, StandardRPCJsonSerializer as b, StandardRPCLinkCodec as c, StandardRPCSerializer as d, getMalformedResponseErrorCode as g, toHttpPath as t };