blossom-client-sdk 5.1.0 → 5.2.0

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.
@@ -1,11 +1,12 @@
1
1
  import { ServerType, UploadType } from "../types.js";
2
2
  import { BlobDescriptor } from "../types.js";
3
3
  import { getBlobSha256, getBlobSize, getBlobType } from "../helpers/index.js";
4
- import { mergeHeaders } from "../helpers/headers.js";
4
+ import { handleChallenges } from "../internal/challenges.js";
5
5
  import HTTPError from "../error.js";
6
6
  import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from "../auth.js";
7
7
  import { SignedEvent } from "../types.js";
8
8
  import { UploadOptions } from "./upload.js";
9
+ import { toWebBytes } from "../internal/bytes.js";
9
10
 
10
11
  /** Error thrown when /media endpoint is not present on a server */
11
12
  export class MediaEndpointMissingError extends Error {}
@@ -20,6 +21,7 @@ export async function uploadMedia<S extends ServerType, B extends UploadType>(
20
21
  ): Promise<BlobDescriptor> {
21
22
  const url = new URL("/media", server);
22
23
  const sha256 = await getBlobSha256(blob);
24
+ const body = blob instanceof Blob ? blob : toWebBytes(blob);
23
25
  const authEvents = opts?.authEvents as Set<SignedEvent> | undefined;
24
26
  const resolveAuth = async (preset: boolean = false) => {
25
27
  const reused = authEvents
@@ -56,69 +58,44 @@ export async function uploadMedia<S extends ServerType, B extends UploadType>(
56
58
  if (type) checkHeaders["X-Content-Type"] = type;
57
59
 
58
60
  // check upload with HEAD /media
59
- let firstTry = await fetch(url, {
61
+ const firstTry = await fetch(url, {
60
62
  method: "HEAD",
61
63
  signal: opts?.signal,
62
64
  headers: checkHeaders,
63
65
  });
64
66
 
65
- let upload: Response | undefined = undefined;
66
-
67
67
  if (firstTry.status === 404) {
68
68
  // HEAD endpoint is not supported. abort
69
69
  throw new MediaEndpointMissingError("/media endpoint not supported");
70
70
  }
71
71
 
72
- // handle auth and payment
73
- switch (firstTry.status) {
74
- case 401: {
75
- // throw an error if auth is requested and disabled
76
- if (opts?.auth === false) throw new Error("Authorization disabled");
77
-
78
- // Request authorization event for this upload
79
- const auth = await resolveAuth();
80
-
81
- // Try upload with auth
82
- upload = await fetch(url, {
83
- signal: opts?.signal,
84
- method: "PUT",
85
- body: blob,
86
- headers: { ...headers, Authorization: encodeAuthorizationHeader(auth) },
87
- });
88
- break;
89
- }
90
- case 402: {
91
- let paymentHeaders: HeadersInit;
92
- if (opts?.onPaymentRequired)
93
- paymentHeaders = await opts.onPaymentRequired(server, sha256, blob, firstTry.headers);
94
- else if (opts?.onPayment) {
95
- const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
96
- const request = await getPaymentRequestFromHeaders(firstTry.headers);
97
- paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, sha256, blob, request)) };
98
- } else throw new Error("Missing payment handler");
72
+ if (![401, 402].includes(firstTry.status)) await HTTPError.handleErrorResponse(firstTry);
99
73
 
100
- // Try upload with payment
101
- upload = await fetch(url, {
102
- signal: opts?.signal,
103
- method: "PUT",
104
- body: blob,
105
- headers: mergeHeaders(headers, paymentHeaders),
106
- });
107
- break;
108
- }
109
- }
110
-
111
- if (firstTry.status >= 500) throw new Error("Server error");
112
-
113
- // check passed, upload
114
- if (!upload)
115
- upload = await fetch(url, {
74
+ const request = (headers: HeadersInit) =>
75
+ fetch(url, {
116
76
  signal: opts?.signal,
117
77
  method: "PUT",
118
- body: blob,
119
- headers: { ...headers },
78
+ body,
79
+ headers,
120
80
  });
121
81
 
82
+ const upload = await handleChallenges(firstTry.ok ? await request(headers) : firstTry, headers, request, {
83
+ signal: opts?.signal,
84
+ auth: async () => {
85
+ if (opts?.auth === false) throw new Error("Authorization disabled");
86
+ return { Authorization: encodeAuthorizationHeader(await resolveAuth()) };
87
+ },
88
+ payment: async (headers) => {
89
+ if (opts?.onPaymentRequired) return opts.onPaymentRequired(server, sha256, blob, headers);
90
+ if (opts?.onPayment) {
91
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
92
+ const request = await getPaymentRequestFromHeaders(headers);
93
+ return { "X-Cashu": encodePaymentToken(await opts.onPayment(server, sha256, blob, request)) };
94
+ }
95
+ throw new Error("Missing payment handler");
96
+ },
97
+ });
98
+
122
99
  // handle errors
123
100
  await HTTPError.handleErrorResponse(upload);
124
101
 
@@ -2,7 +2,7 @@ import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from
2
2
  import { ServerType } from "../types.js";
3
3
  import HTTPError from "../error.js";
4
4
  import { fetchWithTimeout } from "../helpers/index.js";
5
- import { mergeHeaders } from "../helpers/headers.js";
5
+ import { handleChallenges } from "../internal/challenges.js";
6
6
  import { BlobDescriptor, PaymentRequest, PaymentToken, SignedEvent } from "../types.js";
7
7
 
8
8
  export type MirrorOptions<S extends ServerType> = {
@@ -71,53 +71,24 @@ export async function mirrorBlob<S extends ServerType>(
71
71
  }
72
72
 
73
73
  const body = JSON.stringify({ url: blob.url });
74
- let mirror = await fetchWithTimeout(url, {
75
- method: "PUT",
74
+ const request = (headers: HeadersInit) =>
75
+ fetchWithTimeout(url, { method: "PUT", body, headers, signal: opts?.signal, timeout: opts?.timeout });
76
+ const mirror = await handleChallenges(await request(headers), headers, request, {
76
77
  signal: opts?.signal,
77
- headers,
78
- body,
79
- timeout: opts?.timeout,
80
- });
81
-
82
- switch (mirror.status) {
83
- case 401: {
84
- // throw an error if auth is requested and disabled
78
+ auth: async () => {
85
79
  if (opts?.auth === false) throw new Error("Authorization disabled");
86
-
87
- // Request authorization event for this mirror
88
- const auth = await resolveAuth();
89
-
90
- // Try mirror with auth
91
- mirror = await fetchWithTimeout(url, {
92
- signal: opts?.signal,
93
- method: "PUT",
94
- body,
95
- headers: { ...headers, Authorization: encodeAuthorizationHeader(auth) },
96
- timeout: opts?.timeout,
97
- });
98
- break;
99
- }
100
- case 402: {
101
- let paymentHeaders: HeadersInit;
102
- if (opts?.onPaymentRequired)
103
- paymentHeaders = await opts.onPaymentRequired(server, blob.sha256, blob, mirror.headers);
104
- else if (opts?.onPayment) {
80
+ return { Authorization: encodeAuthorizationHeader(await resolveAuth()) };
81
+ },
82
+ payment: async (headers) => {
83
+ if (opts?.onPaymentRequired) return opts.onPaymentRequired(server, blob.sha256, blob, headers);
84
+ if (opts?.onPayment) {
105
85
  const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
106
- const request = await getPaymentRequestFromHeaders(mirror.headers);
107
- paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, blob.sha256, blob, request)) };
108
- } else throw new Error("Missing payment handler");
109
-
110
- // Try mirror with payment
111
- mirror = await fetchWithTimeout(url, {
112
- signal: opts?.signal,
113
- method: "PUT",
114
- body,
115
- headers: mergeHeaders(headers, paymentHeaders),
116
- timeout: opts?.timeout,
117
- });
118
- break;
119
- }
120
- }
86
+ const request = await getPaymentRequestFromHeaders(headers);
87
+ return { "X-Cashu": encodePaymentToken(await opts.onPayment(server, blob.sha256, blob, request)) };
88
+ }
89
+ throw new Error("Missing payment handler");
90
+ },
91
+ });
121
92
 
122
93
  // handle errors
123
94
  await HTTPError.handleErrorResponse(mirror);
@@ -100,10 +100,12 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
100
100
  opts?: MultiServerUploadOptions<S, B>,
101
101
  ) {
102
102
  const options = { ...defaultMultiServerOptions, ...opts };
103
+ options.signal?.throwIfAborted();
103
104
  let initialUpload: BlobDescriptor | undefined;
104
105
  const results = new Map<S, BlobDescriptor>();
105
106
  const authEvents = options.authEvents ?? new Set<SignedEvent>();
106
107
  const blobSha256 = await getBlobSha256(blob);
108
+ options.signal?.throwIfAborted();
107
109
 
108
110
  if (typeof options.auth === "object") authEvents.add(options.auth);
109
111
 
@@ -151,6 +153,7 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
151
153
  return { server, exists };
152
154
  }),
153
155
  );
156
+ options.signal?.throwIfAborted();
154
157
 
155
158
  for (const result of preflightResults) {
156
159
  if (result.status === "fulfilled" && result.value.exists) {
@@ -161,6 +164,7 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
161
164
 
162
165
  // upload to each server
163
166
  for (const server of uploadServers) {
167
+ options.signal?.throwIfAborted();
164
168
  const serverHasBlob = serversWithBlob.has(server);
165
169
 
166
170
  try {
@@ -187,6 +191,7 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
187
191
  timeout: options.mirrorTimeout,
188
192
  });
189
193
  } catch (error) {
194
+ options.signal?.throwIfAborted();
190
195
  // mirror failed, if server already has blob skip upload fallback
191
196
  if (serverHasBlob) continue;
192
197
  }
@@ -211,6 +216,7 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
211
216
  results.set(server, metadata);
212
217
  options.onUpload?.(server, metadata.sha256, blob);
213
218
  } catch (error) {
219
+ options.signal?.throwIfAborted();
214
220
  const rejection = await handleRejection(server, blobSha256, error);
215
221
  if (rejection === "cancel") return results;
216
222
  if (!rejection && error instanceof Error) options.onError?.(server, blobSha256, blob, error);
@@ -244,10 +250,12 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
244
250
  opts?: MultiServerMediaUploadOptions<S, B>,
245
251
  ) {
246
252
  const options = { ...defaultMediaUploadOptions, ...opts };
253
+ options.signal?.throwIfAborted();
247
254
  let initialUpload: BlobDescriptor | undefined;
248
255
  const results = new Map<S, BlobDescriptor>();
249
256
  const authEvents = options.authEvents ?? new Set<SignedEvent>();
250
257
  const blobSha256 = await getBlobSha256(blob);
258
+ options.signal?.throwIfAborted();
251
259
 
252
260
  if (typeof options.auth === "object") authEvents.add(options.auth);
253
261
 
@@ -287,6 +295,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
287
295
 
288
296
  // phase 1: upload to /media on one server for optimization
289
297
  for (const server of mediaServers) {
298
+ options.signal?.throwIfAborted();
290
299
  try {
291
300
  options.onStart?.(server, blobSha256, blob);
292
301
 
@@ -302,6 +311,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
302
311
  mediaUploadServer = server;
303
312
  options.onUpload?.(server, initialUpload.sha256, blob);
304
313
  } catch (error) {
314
+ options.signal?.throwIfAborted();
305
315
  if (error instanceof MediaEndpointMissingError) {
306
316
  // ignore, try next server
307
317
  } else {
@@ -341,6 +351,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
341
351
  return { server, exists };
342
352
  }),
343
353
  );
354
+ options.signal?.throwIfAborted();
344
355
 
345
356
  for (const result of preflightResults) {
346
357
  if (result.status === "fulfilled" && result.value.exists) {
@@ -351,6 +362,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
351
362
 
352
363
  // mirror to remaining servers
353
364
  for (const server of remainingServers) {
365
+ options.signal?.throwIfAborted();
354
366
  try {
355
367
  options.onStart?.(server, initialUpload.sha256, blob);
356
368
 
@@ -366,6 +378,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
366
378
  results.set(server, metadata);
367
379
  options.onUpload?.(server, metadata.sha256, blob);
368
380
  } catch (error) {
381
+ options.signal?.throwIfAborted();
369
382
  const rejection = await handleRejection(server, initialUpload.sha256, error);
370
383
  if (rejection === "cancel") return results;
371
384
  if (!rejection && error instanceof Error) options.onError?.(server, initialUpload.sha256, blob, error);
@@ -90,12 +90,14 @@ export async function getBlobUrls(uri: string | URL | BlossomURI, opts?: GetBlob
90
90
 
91
91
  /** Resolves a blossom URI to a downloaded blob by trying servers from hints sequentially */
92
92
  export async function resolveBlob(uri: string | URL | BlossomURI, opts?: ResolveOptions): Promise<Response> {
93
+ opts?.signal?.throwIfAborted();
93
94
  const parsed = parseInput(uri);
94
95
  const collector = createServerCollector(buildBlobPath(parsed.sha256, parsed.ext));
95
96
 
96
97
  /** Try GET on each URL, return the first successful response */
97
98
  const tryUrls = async (urls: string[]): Promise<Response | undefined> => {
98
99
  for (const url of urls) {
100
+ opts?.signal?.throwIfAborted();
99
101
  try {
100
102
  const res = await fetchWithTimeout(new URL(url), {
101
103
  signal: opts?.signal,
@@ -104,6 +106,7 @@ export async function resolveBlob(uri: string | URL | BlossomURI, opts?: Resolve
104
106
 
105
107
  if (res.ok) return res;
106
108
  } catch {
109
+ opts?.signal?.throwIfAborted();
107
110
  // server unreachable or error — try next
108
111
  continue;
109
112
  }
@@ -121,7 +124,9 @@ export async function resolveBlob(uri: string | URL | BlossomURI, opts?: Resolve
121
124
  // 2. resolve and try author hints (deferred — requires relay queries)
122
125
  if (opts?.getServers) {
123
126
  for (const pubkey of parsed.authors) {
127
+ opts?.signal?.throwIfAborted();
124
128
  const authorServers = await opts.getServers(pubkey);
129
+ opts?.signal?.throwIfAborted();
125
130
  if (authorServers) {
126
131
  const urls = collector.add(authorServers);
127
132
  if (urls.length > 0) {
@@ -2,8 +2,9 @@ import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from
2
2
  import { ServerType, UploadType } from "../types.js";
3
3
  import HTTPError from "../error.js";
4
4
  import { fetchWithTimeout, getBlobSha256, getBlobSize, getBlobType } from "../helpers/index.js";
5
- import { mergeHeaders } from "../helpers/headers.js";
5
+ import { handleChallenges } from "../internal/challenges.js";
6
6
  import { BlobDescriptor, PaymentRequest, PaymentToken, SignedEvent } from "../types.js";
7
+ import { toWebBytes } from "../internal/bytes.js";
7
8
 
8
9
  export type UploadOptions<S extends ServerType, B extends UploadType> = {
9
10
  /** AbortSignal to cancel the action */
@@ -42,6 +43,7 @@ export async function uploadBlob<S extends ServerType, B extends UploadType>(
42
43
  ): Promise<BlobDescriptor> {
43
44
  const url = new URL("/upload", server);
44
45
  const sha256 = await getBlobSha256(blob);
46
+ const body = blob instanceof Blob ? blob : toWebBytes(blob);
45
47
  const resolveAuth = async (preset: boolean = false) => {
46
48
  const reused = opts?.authEvents
47
49
  ? await getReusableAuthEvent(opts.authEvents, { server, type: "upload", blob: sha256 })
@@ -86,69 +88,45 @@ export async function uploadBlob<S extends ServerType, B extends UploadType>(
86
88
 
87
89
  let upload: Response | undefined = undefined;
88
90
 
91
+ if (![401, 402, 404].includes(firstTry.status)) await HTTPError.handleErrorResponse(firstTry);
92
+
89
93
  if (firstTry.status === 404) {
90
94
  // BUD-06 HEAD endpoint is not supported. attempt to upload
91
95
  upload = firstTry = await fetchWithTimeout(url, {
92
- body: blob,
96
+ body,
93
97
  method: "PUT",
98
+ headers,
94
99
  signal: opts?.signal,
95
100
  timeout: opts?.timeout,
96
101
  });
97
102
  }
98
103
 
99
- // handle auth and payment
100
- switch (firstTry.status) {
101
- case 401: {
102
- // throw an error if auth is requested and disabled
103
- if (opts?.auth === false) throw new Error("Authorization disabled");
104
-
105
- // Request authorization event for this upload
106
- const auth = await resolveAuth();
107
-
108
- // Try upload with auth
109
- upload = await fetchWithTimeout(url, {
110
- method: "PUT",
111
- body: blob,
112
- headers: { ...headers, Authorization: encodeAuthorizationHeader(auth) },
113
- signal: opts?.signal,
114
- timeout: opts?.timeout,
115
- });
116
- break;
117
- }
118
- case 402: {
119
- let paymentHeaders: HeadersInit;
120
- if (opts?.onPaymentRequired)
121
- paymentHeaders = await opts.onPaymentRequired(server, sha256, blob, firstTry.headers);
122
- else if (opts?.onPayment) {
123
- const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
124
- const request = await getPaymentRequestFromHeaders(firstTry.headers);
125
- paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, sha256, blob, request)) };
126
- } else throw new Error("Missing payment handler");
127
-
128
- // Try upload with payment
129
- upload = await fetchWithTimeout(url, {
130
- method: "PUT",
131
- body: blob,
132
- headers: mergeHeaders(headers, paymentHeaders),
133
- signal: opts?.signal,
134
- timeout: opts?.timeout,
135
- });
136
- break;
137
- }
138
- }
139
-
140
- if (firstTry.status >= 500) throw new Error("Server error");
141
-
142
- // check passed, upload
143
- if (!upload)
144
- upload = await fetchWithTimeout(url, {
104
+ const request = (headers: HeadersInit) =>
105
+ fetchWithTimeout(url, {
145
106
  method: "PUT",
146
- body: blob,
147
- headers: { ...headers },
107
+ body,
108
+ headers,
148
109
  signal: opts?.signal,
149
110
  timeout: opts?.timeout,
150
111
  });
151
112
 
113
+ upload = await handleChallenges(upload ?? (firstTry.ok ? await request(headers) : firstTry), headers, request, {
114
+ signal: opts?.signal,
115
+ auth: async () => {
116
+ if (opts?.auth === false) throw new Error("Authorization disabled");
117
+ return { Authorization: encodeAuthorizationHeader(await resolveAuth()) };
118
+ },
119
+ payment: async (headers) => {
120
+ if (opts?.onPaymentRequired) return opts.onPaymentRequired(server, sha256, blob, headers);
121
+ if (opts?.onPayment) {
122
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
123
+ const request = await getPaymentRequestFromHeaders(headers);
124
+ return { "X-Cashu": encodePaymentToken(await opts.onPayment(server, sha256, blob, request)) };
125
+ }
126
+ throw new Error("Missing payment handler");
127
+ },
128
+ });
129
+
152
130
  // handle errors
153
131
  await HTTPError.handleErrorResponse(upload);
154
132
 
@@ -1,5 +1,6 @@
1
- import { bytesToHex } from "@noble/hashes/utils";
1
+ import { bytesToHex } from "@noble/hashes/utils.js";
2
2
  import { UploadType } from "../types.js";
3
+ import { toWebBytes } from "../internal/bytes.js";
3
4
 
4
5
  /** Checks if a string is a 64 length hex string */
5
6
  export function isSha256(str: string) {
@@ -21,14 +22,14 @@ export function getBlobSha256(blob: UploadType) {
21
22
 
22
23
  /** Calculates the sha2456 of a Blob */
23
24
  export async function computeBlobSha256(blob: UploadType) {
24
- let buffer: ArrayBuffer | Buffer;
25
+ let buffer: ArrayBuffer | Uint8Array<ArrayBuffer>;
25
26
 
26
27
  // NOTE: use typeof File !== "undefined" to check if File is supported (required to support node 18)
27
28
  if ((typeof File !== "undefined" && blob instanceof File) || blob instanceof Blob) {
28
29
  buffer = await blob.arrayBuffer();
29
30
  } else {
30
31
  // nodejs Buffer
31
- buffer = blob;
32
+ buffer = toWebBytes(blob);
32
33
  }
33
34
 
34
35
  let hash: Uint8Array;
@@ -36,7 +37,7 @@ export async function computeBlobSha256(blob: UploadType) {
36
37
  const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
37
38
  hash = new Uint8Array(hashBuffer);
38
39
  } else {
39
- const { sha256 } = await import("@noble/hashes/sha2");
40
+ const { sha256 } = await import("@noble/hashes/sha2.js");
40
41
  hash = sha256.create().update(new Uint8Array(buffer)).digest();
41
42
  }
42
43
 
@@ -1,4 +1,6 @@
1
- export class TimeoutError extends Error {}
1
+ export class TimeoutError extends Error {
2
+ name = "TimeoutError";
3
+ }
2
4
 
3
5
  /** Creates and optionally wraps an AbortSignal with a timeout */
4
6
  export function wrapSignalWithTimeout(
@@ -8,13 +10,13 @@ export function wrapSignalWithTimeout(
8
10
  ): { cancel: () => void; signal: AbortSignal } {
9
11
  const controller = new AbortController();
10
12
 
11
- if (signal) signal.addEventListener("abort", (err) => controller.abort(err), { once: true });
12
-
13
13
  const t = setTimeout(() => {
14
14
  controller.abort(new TimeoutError(message));
15
15
  }, timeout);
16
16
 
17
17
  const cancel = () => clearTimeout(t);
18
18
 
19
- return { cancel, signal: controller.signal };
19
+ // Native composition preserves existing abort reasons and avoids retaining listeners
20
+ // on a caller's long-lived signal. It also keeps cancellation working after headers arrive.
21
+ return { cancel, signal: signal ? AbortSignal.any([signal, controller.signal]) : controller.signal };
20
22
  }
package/src/index.ts CHANGED
@@ -4,5 +4,6 @@ export * from "./helpers/index.js";
4
4
  export * from "./media.js";
5
5
  export * from "./nostr.js";
6
6
  export * from "./error.js";
7
+ export { default as HTTPError } from "./error.js";
7
8
  export * from "./types.js";
8
9
  export * as Actions from "./actions/index.js";
@@ -0,0 +1,6 @@
1
+ /** Return a Web API-compatible view, copying only shared-memory-backed inputs. */
2
+ export function toWebBytes(bytes: Uint8Array): Uint8Array<ArrayBuffer> {
3
+ return bytes.buffer instanceof ArrayBuffer
4
+ ? new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
5
+ : Uint8Array.from(bytes);
6
+ }
@@ -0,0 +1,25 @@
1
+ import { mergeHeaders } from "../helpers/headers.js";
2
+
3
+ /** Handle each challenge at most once, including challenges from a preflight response. */
4
+ export async function handleChallenges(
5
+ response: Response,
6
+ headers: HeadersInit,
7
+ request: (headers: HeadersInit) => Promise<Response>,
8
+ handlers: {
9
+ auth: () => Promise<HeadersInit>;
10
+ payment: (headers: Headers) => Promise<HeadersInit>;
11
+ signal?: AbortSignal;
12
+ },
13
+ ): Promise<Response> {
14
+ const handled = new Set<number>();
15
+ while ((response.status === 401 || response.status === 402) && !handled.has(response.status)) {
16
+ handlers.signal?.throwIfAborted();
17
+ handled.add(response.status);
18
+ const nextHeaders = response.status === 401 ? await handlers.auth() : await handlers.payment(response.headers);
19
+ handlers.signal?.throwIfAborted();
20
+ headers = mergeHeaders(headers, nextHeaders);
21
+ await response.body?.cancel();
22
+ response = await request(headers);
23
+ }
24
+ return response;
25
+ }