@daasboard/embed 0.0.0-stage → 0.1.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.
@@ -0,0 +1,658 @@
1
+ import { hashAsset } from "@daasboard/render-core";
2
+ export class AssetServiceError extends Error {
3
+ code;
4
+ status;
5
+ reason;
6
+ constructor(code, status) {
7
+ super(`Asset service: ${code}`);
8
+ this.code = code;
9
+ this.status = status;
10
+ this.name = "AssetServiceError";
11
+ this.reason = status === 401 ? "store"
12
+ : code === "denied" || status === 403 ? "denied"
13
+ : code === "too_large" || code === "too_many_pixels" ? "too_large"
14
+ : code === "unsupported_type" ? "unsupported"
15
+ : ["bad_image", "hash_mismatch", "type_mismatch", "metadata_too_large"].includes(code) ? "bad_image"
16
+ : code === "missing" || status === 404 ? "missing" : "store";
17
+ }
18
+ }
19
+ const result = () => ({
20
+ stored: new Set(), missing: new Set(), denied: new Set(), pending: new Set(),
21
+ });
22
+ function requireHash(hash) {
23
+ if (!/^[0-9a-f]{64}$/.test(hash))
24
+ throw new AssetServiceError("invalid_hash");
25
+ }
26
+ function requireRoom(room) {
27
+ if (!room || room === "." || room === ".." || new TextEncoder().encode(room).length > 256 || /[\u0000-\u001f\u007f-\u009f]/.test(room)) {
28
+ throw new AssetServiceError("room_required");
29
+ }
30
+ }
31
+ function capacity(value, fallback) {
32
+ if (value === undefined)
33
+ return fallback;
34
+ if (!Number.isSafeInteger(value) || value < 1)
35
+ throw new AssetServiceError("invalid_cache_size");
36
+ return value;
37
+ }
38
+ function remember(map, key, value, maximum) {
39
+ map.delete(key);
40
+ map.set(key, value);
41
+ if (map.size > maximum)
42
+ map.delete(map.keys().next().value);
43
+ }
44
+ function abortable(promise, signal) {
45
+ if (!signal)
46
+ return promise;
47
+ return new Promise((resolve, reject) => {
48
+ const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason); };
49
+ signal.addEventListener("abort", abort, { once: true });
50
+ promise.then((value) => { signal.removeEventListener("abort", abort); resolve(value); }, (error) => { signal.removeEventListener("abort", abort); reject(error); });
51
+ if (signal.aborted)
52
+ abort();
53
+ });
54
+ }
55
+ export function assetServiceStore(options) {
56
+ const origin = new URL(options.endpoint);
57
+ if (!/^https?:$/.test(origin.protocol) || origin.username || origin.password || origin.search || origin.hash) {
58
+ throw new AssetServiceError("invalid_endpoint");
59
+ }
60
+ const endpoint = origin.href.replace(/\/$/, "").replace(/(?:\/assets\/v1)?$/, "/assets/v1");
61
+ const importOrigins = new Set((options.importOrigins ?? []).map((value) => {
62
+ let url;
63
+ try {
64
+ url = new URL(value);
65
+ }
66
+ catch {
67
+ throw new AssetServiceError("invalid_import_origin");
68
+ }
69
+ if (url.protocol !== "https:" || url.username || url.password || url.search || url.hash || url.pathname !== "/") {
70
+ throw new AssetServiceError("invalid_import_origin");
71
+ }
72
+ return url.origin;
73
+ }));
74
+ const signatureLimit = capacity(options.signatureCacheSize, 4096);
75
+ const roomLimit = capacity(options.roomCacheSize, 256);
76
+ const signatures = new Map();
77
+ const rooms = new Map();
78
+ const obligations = new Map();
79
+ const reads = new Map();
80
+ const lifetime = new AbortController();
81
+ let tenant;
82
+ let credential;
83
+ let refreshing;
84
+ let sequence = 0, disposed = false, reading = false, sharesBlocked = false;
85
+ let retryTimer;
86
+ function alive() { if (disposed)
87
+ throw new AssetServiceError("disposed"); }
88
+ async function token(rejected) {
89
+ alive();
90
+ if (credential && credential.expires > Date.now() + 120_000 && credential.value !== rejected)
91
+ return credential;
92
+ if (!refreshing) {
93
+ refreshing = (async () => {
94
+ const value = await options.token();
95
+ alive();
96
+ let claims;
97
+ try {
98
+ const encoded = value.split(".");
99
+ if (encoded.length !== 3)
100
+ throw new Error();
101
+ const payload = encoded[1].replace(/-/g, "+").replace(/_/g, "/");
102
+ claims = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(atob(payload), (c) => c.charCodeAt(0))));
103
+ }
104
+ catch {
105
+ throw new AssetServiceError("invalid_token");
106
+ }
107
+ if (typeof claims.tenant !== "string" || !claims.tenant || !Number.isSafeInteger(claims.exp))
108
+ throw new AssetServiceError("invalid_token");
109
+ if (tenant !== undefined && claims.tenant !== tenant)
110
+ throw new AssetServiceError("tenant_changed");
111
+ tenant ??= claims.tenant;
112
+ sharesBlocked = false;
113
+ credential = { value, expires: claims.exp * 1000 };
114
+ return credential;
115
+ })().catch((error) => { sharesBlocked = true; throw error; });
116
+ void refreshing.finally(() => { refreshing = undefined; }).catch(() => { });
117
+ }
118
+ return refreshing;
119
+ }
120
+ async function http(url, init, consume, timeout = 30_000) {
121
+ alive();
122
+ const request = new AbortController();
123
+ const listeners = [lifetime.signal, ...(init.signal ? [init.signal] : [])].map((signal) => {
124
+ const abort = () => request.abort(signal.reason);
125
+ signal.addEventListener("abort", abort, { once: true });
126
+ if (signal.aborted)
127
+ abort();
128
+ return () => signal.removeEventListener("abort", abort);
129
+ });
130
+ const timer = setTimeout(() => request.abort(new AssetServiceError("timeout")), timeout);
131
+ try {
132
+ return await consume(await fetch(url, { ...init, signal: request.signal, credentials: "omit", mode: "cors" }), request.signal);
133
+ }
134
+ finally {
135
+ clearTimeout(timer);
136
+ for (const remove of listeners)
137
+ remove();
138
+ }
139
+ }
140
+ async function responseError(response) {
141
+ let code = `http_${response.status}`;
142
+ try {
143
+ const body = await response.json();
144
+ if (typeof body.error === "string")
145
+ code = body.error;
146
+ }
147
+ catch { }
148
+ return new AssetServiceError(code, response.status);
149
+ }
150
+ async function json(path, body, signal, timeout = 30_000) {
151
+ let auth = await token();
152
+ for (let attempt = 0;; attempt++) {
153
+ const response = await http(`${endpoint}${path}`, { method: "POST", headers: {
154
+ Authorization: `Bearer ${auth.value}`, "Content-Type": "application/json",
155
+ }, body: JSON.stringify(body), ...(signal ? { signal } : {}) }, async (response) => {
156
+ if (response.status === 401 && attempt === 0) {
157
+ await response.body?.cancel();
158
+ return { unauthorized: true };
159
+ }
160
+ if (!response.ok)
161
+ throw await responseError(response);
162
+ return { body: await response.json() };
163
+ }, timeout);
164
+ if ("unauthorized" in response) {
165
+ auth = await token(auth.value);
166
+ continue;
167
+ }
168
+ return response.body;
169
+ }
170
+ }
171
+ async function copyAsset(hash, from, room, signal) {
172
+ const copyBudget = 360_000;
173
+ const deadline = Date.now() + copyBudget;
174
+ const operation = new AbortController();
175
+ const removeListeners = [lifetime.signal, ...(signal ? [signal] : [])].map((parent) => {
176
+ const abort = () => operation.abort(parent.reason);
177
+ parent.addEventListener("abort", abort, { once: true });
178
+ if (parent.aborted)
179
+ abort();
180
+ return () => parent.removeEventListener("abort", abort);
181
+ });
182
+ const timer = setTimeout(() => operation.abort(new AssetServiceError("timeout")), copyBudget);
183
+ const pause = (milliseconds) => new Promise((resolve, reject) => {
184
+ const done = () => { operation.signal.removeEventListener("abort", abort); resolve(); };
185
+ const delay = setTimeout(done, milliseconds);
186
+ const abort = () => { clearTimeout(delay); operation.signal.removeEventListener("abort", abort); reject(operation.signal.reason); };
187
+ operation.signal.addEventListener("abort", abort, { once: true });
188
+ if (operation.signal.aborted)
189
+ abort();
190
+ });
191
+ try {
192
+ let auth = await abortable(token(), operation.signal);
193
+ let refreshed = false, failures = 0;
194
+ for (;;) {
195
+ operation.signal.throwIfAborted();
196
+ let retryAfter = 0;
197
+ let answer;
198
+ try {
199
+ answer = await abortable(http(`${endpoint}/copy`, { method: "POST", headers: {
200
+ Authorization: `Bearer ${auth.value}`, "Content-Type": "application/json",
201
+ }, body: JSON.stringify({ hash, from, room }), signal: operation.signal }, async (response) => {
202
+ if (response.status === 401 && !refreshed) {
203
+ await response.body?.cancel();
204
+ return { unauthorized: true };
205
+ }
206
+ if (!response.ok) {
207
+ const header = response.headers.get("Retry-After");
208
+ if (header !== null) {
209
+ const value = /^\d+$/.test(header) ? Number(header) * 1000 : Date.parse(header) - Date.now();
210
+ if (Number.isFinite(value))
211
+ retryAfter = Math.max(0, value);
212
+ }
213
+ throw await responseError(response);
214
+ }
215
+ return await response.json();
216
+ }, Math.max(1, deadline - Date.now())), operation.signal);
217
+ }
218
+ catch (error) {
219
+ operation.signal.throwIfAborted();
220
+ const transient = error instanceof TypeError || error instanceof AssetServiceError
221
+ && !["denied", "missing", "hash_mismatch", "expired_share", "invalid_request"].includes(error.code)
222
+ && (error.code === "network" || error.code === "busy" || (error.status !== undefined && error.status >= 500));
223
+ if (!transient)
224
+ throw error;
225
+ const backoff = Math.min(10_000, 1000 * 2 ** Math.min(failures++, 4));
226
+ await pause(Math.min(Math.max(backoff, retryAfter), Math.max(0, deadline - Date.now())));
227
+ continue;
228
+ }
229
+ if ("unauthorized" in answer) {
230
+ refreshed = true;
231
+ auth = await abortable(token(auth.value), operation.signal);
232
+ continue;
233
+ }
234
+ if (!answer.asset || answer.asset.hash !== hash)
235
+ throw new AssetServiceError("invalid_response");
236
+ return answer.asset;
237
+ }
238
+ }
239
+ finally {
240
+ clearTimeout(timer);
241
+ for (const remove of removeListeners)
242
+ remove();
243
+ }
244
+ }
245
+ function schedule() {
246
+ if (retryTimer !== undefined)
247
+ clearTimeout(retryTimer);
248
+ retryTimer = undefined;
249
+ if (disposed)
250
+ return;
251
+ let next = Infinity;
252
+ for (const entry of obligations.values())
253
+ if (!entry.inFlight)
254
+ next = Math.min(next, entry.next);
255
+ if (next === Infinity)
256
+ return;
257
+ retryTimer = setTimeout(() => {
258
+ retryTimer = undefined;
259
+ send([...obligations.values()].filter((entry) => !entry.inFlight && entry.next <= Date.now()));
260
+ }, Math.max(0, next - Date.now()));
261
+ }
262
+ function send(entries) {
263
+ if (disposed)
264
+ return;
265
+ const batches = new Map();
266
+ for (const entry of entries) {
267
+ if (entry.answer || entry.inFlight)
268
+ continue;
269
+ entry.inFlight = true;
270
+ delete entry.error;
271
+ let groups = batches.get(entry.room);
272
+ if (!groups)
273
+ batches.set(entry.room, groups = [[]]);
274
+ let group = groups[groups.length - 1];
275
+ if (group.length === 256 || group.some((item) => item.hash === entry.hash))
276
+ groups.push(group = []);
277
+ group.push(entry);
278
+ }
279
+ for (const [room, groups] of batches)
280
+ for (const batch of groups)
281
+ void (async () => {
282
+ try {
283
+ const answer = await json("/touch", { room, hashes: batch.map((entry) => entry.hash) });
284
+ if (!Array.isArray(answer.stored) || !Array.isArray(answer.missing))
285
+ throw new AssetServiceError("invalid_response");
286
+ const stored = new Set(answer.stored), missing = new Set(answer.missing);
287
+ for (const entry of batch) {
288
+ if (stored.has(entry.hash) !== missing.has(entry.hash))
289
+ entry.answer = stored.has(entry.hash) ? "stored" : "missing";
290
+ }
291
+ }
292
+ catch (error) {
293
+ for (const entry of batch) {
294
+ if (error instanceof AssetServiceError && error.status === 403)
295
+ entry.answer = "denied";
296
+ else if (error instanceof AssetServiceError && error.code === "tenant_changed")
297
+ entry.error = error;
298
+ }
299
+ }
300
+ finally {
301
+ for (const entry of batch) {
302
+ entry.inFlight = false;
303
+ entry.attempts++;
304
+ if (entry.answer)
305
+ obligations.delete(entry.sequence);
306
+ else {
307
+ entry.failures++;
308
+ entry.next = Date.now() + Math.min(60_000, 1000 * 2 ** Math.min(entry.failures - 1, 6) * (0.8 + Math.random() * 0.4));
309
+ }
310
+ for (const listener of [...entry.listeners])
311
+ listener();
312
+ }
313
+ schedule();
314
+ }
315
+ })();
316
+ schedule();
317
+ }
318
+ function wait(entries, until, signal) {
319
+ const attempts = entries.map((entry) => entry.attempts);
320
+ return new Promise((resolve, reject) => {
321
+ const clean = () => {
322
+ for (const entry of entries)
323
+ entry.listeners.delete(check);
324
+ lifetime.signal.removeEventListener("abort", abort);
325
+ signal?.removeEventListener("abort", abort);
326
+ };
327
+ const abort = () => { clean(); reject(signal?.aborted ? signal.reason : lifetime.signal.reason); };
328
+ const check = () => {
329
+ const failed = entries.find((entry, i) => entry.error && entry.attempts > attempts[i]);
330
+ if (failed) {
331
+ clean();
332
+ reject(failed.error);
333
+ return;
334
+ }
335
+ if (!entries.every((entry, i) => entry.answer || (until === "attempt" && entry.attempts > attempts[i])))
336
+ return;
337
+ const answers = result();
338
+ for (const entry of entries)
339
+ answers[entry.answer ?? "pending"].add(entry.hash);
340
+ clean();
341
+ resolve(answers);
342
+ };
343
+ for (const entry of entries)
344
+ entry.listeners.add(check);
345
+ lifetime.signal.addEventListener("abort", abort, { once: true });
346
+ signal?.addEventListener("abort", abort, { once: true });
347
+ if (signal?.aborted || lifetime.signal.aborted)
348
+ abort();
349
+ else
350
+ check();
351
+ });
352
+ }
353
+ function signatureUrl(signature, hash, rung) {
354
+ return { url: `${signature.base}${hash}/${rung}?${signature.query}` };
355
+ }
356
+ function drainReads() {
357
+ reading = false;
358
+ const queued = [...reads];
359
+ reads.clear();
360
+ for (const [room, requests] of queued) {
361
+ const hashes = [...new Set(requests.map((request) => request.hash))];
362
+ for (let offset = 0; offset < hashes.length; offset += 256) {
363
+ const batch = hashes.slice(offset, offset + 256);
364
+ const listeners = requests.filter((request) => batch.includes(request.hash));
365
+ void (async () => {
366
+ try {
367
+ const signed = await json("/read", { ...(room === undefined ? {} : { room }), hashes: batch });
368
+ alive();
369
+ if (typeof signed.base !== "string" || !Number.isFinite(signed.expires) || !signed.sigs
370
+ || batch.some((hash) => typeof signed.sigs[hash] !== "string"))
371
+ throw new AssetServiceError("invalid_response");
372
+ const base = new URL(signed.base);
373
+ if (!/^https?:$/.test(base.protocol) || base.username || base.password || base.search || base.hash)
374
+ throw new AssetServiceError("invalid_response");
375
+ const values = new Map(batch.map((hash) => [hash, { base: signed.base, expires: signed.expires * 1000, query: signed.sigs[hash], shareable: true }]));
376
+ for (const [hash, value] of values)
377
+ remember(signatures, hash, value, signatureLimit);
378
+ remember(rooms, room, true, roomLimit);
379
+ for (const request of listeners)
380
+ request.resolve(signatureUrl(values.get(request.hash), request.hash, request.rung));
381
+ }
382
+ catch (error) {
383
+ for (const hash of batch) {
384
+ const cached = signatures.get(hash);
385
+ if (cached)
386
+ cached.shareable = false;
387
+ }
388
+ for (const request of listeners)
389
+ request.reject(error);
390
+ }
391
+ })();
392
+ }
393
+ }
394
+ }
395
+ async function upload(url, headers, bytes, signal, progress) {
396
+ const timeout = Math.min(300_000, 30_000 + Math.ceil(bytes.size / 131_072) * 1000);
397
+ if (typeof XMLHttpRequest === "undefined") {
398
+ progress?.(0, bytes.size);
399
+ await http(url, { method: "PUT", headers, body: bytes, ...(signal ? { signal } : {}) }, async (response) => {
400
+ if (!response.ok)
401
+ throw await responseError(response);
402
+ await response.body?.cancel();
403
+ }, timeout);
404
+ progress?.(bytes.size, bytes.size);
405
+ return;
406
+ }
407
+ await new Promise((resolve, reject) => {
408
+ const xhr = new XMLHttpRequest();
409
+ const stop = () => { xhr.abort(); finish(signal?.aborted ? signal.reason : lifetime.signal.reason); };
410
+ const finish = (error) => {
411
+ lifetime.signal.removeEventListener("abort", stop);
412
+ signal?.removeEventListener("abort", stop);
413
+ xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = null;
414
+ xhr.upload.onprogress = null;
415
+ if (error)
416
+ reject(error);
417
+ else
418
+ resolve();
419
+ };
420
+ xhr.open("PUT", url);
421
+ xhr.timeout = timeout;
422
+ for (const [key, value] of Object.entries(headers))
423
+ xhr.setRequestHeader(key, value);
424
+ xhr.upload.onprogress = (event) => progress?.(event.loaded, bytes.size);
425
+ xhr.onload = () => {
426
+ if (xhr.status >= 200 && xhr.status < 300) {
427
+ progress?.(bytes.size, bytes.size);
428
+ finish();
429
+ }
430
+ else
431
+ finish(new AssetServiceError(`http_${xhr.status}`, xhr.status));
432
+ };
433
+ xhr.onerror = () => finish(new AssetServiceError("network"));
434
+ xhr.ontimeout = () => finish(new AssetServiceError("timeout"));
435
+ xhr.onabort = () => finish(new DOMException("Upload aborted", "AbortError"));
436
+ lifetime.signal.addEventListener("abort", stop, { once: true });
437
+ signal?.addEventListener("abort", stop, { once: true });
438
+ if (signal?.aborted || lifetime.signal.aborted)
439
+ stop();
440
+ else {
441
+ progress?.(0, bytes.size);
442
+ xhr.send(bytes);
443
+ }
444
+ });
445
+ }
446
+ function canonicalShare(value, hash) {
447
+ let url;
448
+ try {
449
+ url = new URL(value);
450
+ }
451
+ catch {
452
+ throw new AssetServiceError("invalid_share");
453
+ }
454
+ const query = url.search.slice(1);
455
+ const fields = query.split("&");
456
+ const params = url.searchParams;
457
+ const expiry = params.get("e") ?? "";
458
+ if (url.protocol !== "https:" || url.href !== value || url.username || url.password || url.hash
459
+ || !new RegExp(`^/assets/v1/t/[0-9a-f]{32}/${hash}/orig$`).test(url.pathname)
460
+ || query.length > 128 || fields.length !== 3
461
+ || fields.some((field) => !/^(?:e=[0-9]+|k=[A-Za-z0-9_-]{1,64}|s=[A-Za-z0-9_-]{22})$/.test(field))
462
+ || ["e", "k", "s"].some((key) => params.getAll(key).length !== 1)
463
+ || !/^(?:0|[1-9][0-9]*)$/.test(expiry) || !Number.isSafeInteger(Number(expiry))) {
464
+ throw new AssetServiceError("invalid_share");
465
+ }
466
+ if (Number(expiry) * 1000 <= Date.now())
467
+ throw new AssetServiceError("expired_share");
468
+ return url;
469
+ }
470
+ async function foreignOriginal(url, hash, signal) {
471
+ const maximum = 32 * 1024 * 1024;
472
+ try {
473
+ return await http(url, { redirect: "error", ...(signal ? { signal } : {}) }, async (response, requestSignal) => {
474
+ if (!response.ok)
475
+ throw new AssetServiceError(`foreign_http_${response.status}`);
476
+ if (Number(response.headers.get("Content-Length")) > maximum) {
477
+ void response.body?.cancel().catch(() => { });
478
+ throw new AssetServiceError("too_large");
479
+ }
480
+ const mime = (response.headers.get("Content-Type") ?? "").split(";")[0].trim().toLowerCase();
481
+ if (!response.body)
482
+ throw new AssetServiceError("bad_image");
483
+ const reader = response.body.getReader();
484
+ const chunks = [];
485
+ let length = 0;
486
+ try {
487
+ for (;;) {
488
+ const chunk = await abortable(reader.read(), requestSignal);
489
+ if (chunk.done)
490
+ break;
491
+ length += chunk.value.byteLength;
492
+ if (length > maximum)
493
+ throw new AssetServiceError("too_large");
494
+ chunks.push(new Uint8Array(chunk.value));
495
+ }
496
+ }
497
+ finally {
498
+ void reader.cancel().catch(() => { });
499
+ reader.releaseLock();
500
+ }
501
+ const bytes = new Blob(chunks, { type: mime });
502
+ if (await hashAsset(bytes, { signal: requestSignal }) !== hash)
503
+ throw new AssetServiceError("hash_mismatch");
504
+ requestSignal.throwIfAborted();
505
+ return { bytes, mime };
506
+ }, 30_000);
507
+ }
508
+ catch (error) {
509
+ if (error instanceof AssetServiceError)
510
+ throw error;
511
+ if (signal?.aborted)
512
+ throw signal.reason;
513
+ if (lifetime.signal.aborted)
514
+ throw lifetime.signal.reason;
515
+ throw new AssetServiceError("network");
516
+ }
517
+ }
518
+ function pending() {
519
+ const seen = new Set();
520
+ return [...obligations.values()].filter((entry) => {
521
+ const key = JSON.stringify([entry.room, entry.hash]);
522
+ if (seen.has(key))
523
+ return false;
524
+ seen.add(key);
525
+ return true;
526
+ }).map(({ room, hash }) => ({ room, hash }));
527
+ }
528
+ const store = {
529
+ renders: ["image/svg+xml", "image/x-icon"],
530
+ async put(image, request) {
531
+ alive();
532
+ requireRoom(request.room);
533
+ requireHash(image.hash);
534
+ request.signal?.throwIfAborted();
535
+ const begin = await json("/uploads", {
536
+ hash: image.hash, size: image.bytes.size, mime: image.mime, room: request.room,
537
+ }, request.signal);
538
+ alive();
539
+ if (begin.status === "stored")
540
+ return begin.asset;
541
+ if (begin.status !== "upload" || typeof begin.ticket !== "string" || !begin.put || typeof begin.put.url !== "string")
542
+ throw new AssetServiceError("invalid_response");
543
+ await upload(begin.put.url, begin.put.headers, image.bytes, request.signal, request.onProgress);
544
+ request.signal?.throwIfAborted();
545
+ const timeout = Math.min(300_000, 30_000 + Math.ceil(image.bytes.size / 131_072) * 1000);
546
+ return (await json(`/uploads/${encodeURIComponent(begin.ticket)}/complete`, {}, request.signal, timeout)).asset;
547
+ },
548
+ share(hash) {
549
+ if (disposed || options.shareOnCopy === false || sharesBlocked)
550
+ return null;
551
+ const cached = signatures.get(hash);
552
+ if (!cached || !cached.shareable || cached.expires - Date.now() < 300_000)
553
+ return null;
554
+ const { url } = signatureUrl(cached, hash, "orig");
555
+ try {
556
+ canonicalShare(url, hash);
557
+ }
558
+ catch {
559
+ return null;
560
+ }
561
+ return { url, expires: cached.expires / 1000 };
562
+ },
563
+ async import(hash, from, request) {
564
+ alive();
565
+ requireRoom(request.room);
566
+ requireHash(hash);
567
+ request.signal?.throwIfAborted();
568
+ try {
569
+ return await copyAsset(hash, from.url, request.room, request.signal);
570
+ }
571
+ catch (error) {
572
+ if (!(error instanceof AssetServiceError) || error.code !== "foreign_source")
573
+ throw error;
574
+ }
575
+ const source = canonicalShare(from.url, hash);
576
+ if (!importOrigins.has(source.origin))
577
+ throw new AssetServiceError("foreign_source");
578
+ const image = await foreignOriginal(source.href, hash, request.signal);
579
+ return store.put({ hash, ...image, w: 0, h: 0 }, request);
580
+ },
581
+ async get(hash, rung, request = {}) {
582
+ alive();
583
+ if (request.room !== undefined)
584
+ requireRoom(request.room);
585
+ requireHash(hash);
586
+ request.signal?.throwIfAborted();
587
+ const cached = signatures.get(hash);
588
+ if (cached && cached.expires > Date.now() + 300_000 && rooms.has(request.room)) {
589
+ await abortable(token(), request.signal);
590
+ alive();
591
+ if (signatures.get(hash) === cached && cached.expires > Date.now() + 300_000 && rooms.has(request.room)) {
592
+ remember(signatures, hash, cached, signatureLimit);
593
+ remember(rooms, request.room, true, roomLimit);
594
+ return signatureUrl(cached, hash, rung);
595
+ }
596
+ }
597
+ const room = request.room;
598
+ const pending = new Promise((resolve, reject) => {
599
+ let batch = reads.get(room);
600
+ if (!batch)
601
+ reads.set(room, batch = []);
602
+ batch.push({ hash, rung, resolve, reject });
603
+ if (!reading) {
604
+ reading = true;
605
+ queueMicrotask(drainReads);
606
+ }
607
+ });
608
+ return abortable(pending, request.signal);
609
+ },
610
+ async refreshUrl(hash, rung, request) {
611
+ alive();
612
+ if (request.room !== undefined)
613
+ requireRoom(request.room);
614
+ requireHash(hash);
615
+ request.signal?.throwIfAborted();
616
+ const cached = signatures.get(hash);
617
+ if (cached && signatureUrl(cached, hash, rung).url === request.url)
618
+ signatures.delete(hash);
619
+ return store.get(hash, rung, request);
620
+ },
621
+ async touch(room, hashes, request = {}) {
622
+ alive();
623
+ requireRoom(room);
624
+ const unique = [...new Set(hashes)];
625
+ unique.forEach(requireHash);
626
+ const entries = unique.map((hash) => ({ sequence: ++sequence, room, hash,
627
+ attempts: 0, failures: 0, next: Date.now(), inFlight: false, listeners: new Set() }));
628
+ for (const entry of entries)
629
+ obligations.set(entry.sequence, entry);
630
+ const pending = wait(entries, request.until ?? "attempt", request.signal);
631
+ send(entries);
632
+ return pending;
633
+ },
634
+ async flush(room) {
635
+ alive();
636
+ requireRoom(room);
637
+ const entries = [...obligations.values()].filter((entry) => entry.room === room);
638
+ const pending = wait(entries, "attempt");
639
+ send(entries);
640
+ return pending;
641
+ },
642
+ pending,
643
+ dispose() {
644
+ if (!disposed) {
645
+ disposed = true;
646
+ if (retryTimer !== undefined)
647
+ clearTimeout(retryTimer);
648
+ lifetime.abort(new AssetServiceError("disposed"));
649
+ for (const batch of reads.values())
650
+ for (const request of batch)
651
+ request.reject(new AssetServiceError("disposed"));
652
+ reads.clear();
653
+ }
654
+ return pending();
655
+ },
656
+ };
657
+ return store;
658
+ }
@@ -0,0 +1,6 @@
1
+ import type { ImageStore, OnImageError } from "../images/types.js";
2
+ export type ClipboardAssetShares = Readonly<Record<string, {
3
+ url: string;
4
+ expires: number;
5
+ }>>;
6
+ export declare function importClipboardAssets(hashes: ReadonlySet<string>, shares: ClipboardAssetShares | undefined, store: ImageStore, room: string | undefined, signal: AbortSignal, report: OnImageError): Promise<void>;
@@ -0,0 +1,23 @@
1
+ export async function importClipboardAssets(hashes, shares, store, room, signal, report) {
2
+ for (const hash of hashes) {
3
+ signal.throwIfAborted();
4
+ const share = shares?.[hash];
5
+ if (!share || share.expires * 1000 <= Date.now() || !store.import) {
6
+ report(hash, 256, "missing");
7
+ continue;
8
+ }
9
+ try {
10
+ const stored = await store.import(hash, { url: share.url }, {
11
+ ...(room === undefined ? {} : { room }), signal,
12
+ });
13
+ signal.throwIfAborted();
14
+ if (stored && stored.hash !== hash)
15
+ report(hash, 256, "bad_image");
16
+ }
17
+ catch (error) {
18
+ signal.throwIfAborted();
19
+ const reason = error?.reason;
20
+ report(hash, 256, reason ?? "store");
21
+ }
22
+ }
23
+ }