@calmlens/sdk 0.16.3 → 0.18.0

package/esm/UploadController-qjoYGCwx.js

@@ -0,0 +1,589 @@
+import { O as CalmLensError, k as SDK_ERROR_CODES } from "./ModerationContextLimits-BaX2QnU8.js";
+import { t as CalmLensAppClient } from "./CalmLensAppClient-DuFas_dW.js";
+// src/contract/PlaceholderHashDecode.js
+/**
+* Decodes a ThumbHash to an RGBA image. RGB is not be premultiplied by A.
+*
+* @param hash The bytes of the ThumbHash.
+* @returns The width, height, and pixels of the rendered placeholder image.
+*/
+function thumbHashToRGBA(hash) {
+	const { PI, min, max, cos, round } = Math;
+	const header24 = hash[0] | hash[1] << 8 | hash[2] << 16;
+	const header16 = hash[3] | hash[4] << 8;
+	const l_dc = (header24 & 63) / 63;
+	const p_dc = (header24 >> 6 & 63) / 31.5 - 1;
+	const q_dc = (header24 >> 12 & 63) / 31.5 - 1;
+	const l_scale = (header24 >> 18 & 31) / 31;
+	const hasAlpha = header24 >> 23;
+	const p_scale = (header16 >> 3 & 63) / 63;
+	const q_scale = (header16 >> 9 & 63) / 63;
+	const isLandscape = header16 >> 15;
+	const lx = max(3, isLandscape ? hasAlpha ? 5 : 7 : header16 & 7);
+	const ly = max(3, isLandscape ? header16 & 7 : hasAlpha ? 5 : 7);
+	const a_dc = hasAlpha ? (hash[5] & 15) / 15 : 1;
+	const a_scale = (hash[5] >> 4) / 15;
+	const ac_start = hasAlpha ? 6 : 5;
+	let ac_index = 0;
+	const decodeChannel = (nx, ny, scale) => {
+		const ac = [];
+		for (let cy = 0; cy < ny; cy++) for (let cx = cy ? 0 : 1; cx * ny < nx * (ny - cy); cx++) ac.push(((hash[ac_start + (ac_index >> 1)] >> ((ac_index++ & 1) << 2) & 15) / 7.5 - 1) * scale);
+		return ac;
+	};
+	const l_ac = decodeChannel(lx, ly, l_scale);
+	const p_ac = decodeChannel(3, 3, p_scale * 1.25);
+	const q_ac = decodeChannel(3, 3, q_scale * 1.25);
+	const a_ac = hasAlpha && decodeChannel(5, 5, a_scale);
+	const ratio = thumbHashToApproximateAspectRatio(hash);
+	const w = round(ratio > 1 ? 32 : 32 * ratio);
+	const h = round(ratio > 1 ? 32 / ratio : 32);
+	const rgba = new Uint8Array(w * h * 4);
+	const fx = [];
+	const fy = [];
+	for (let y = 0, i = 0; y < h; y++) for (let x = 0; x < w; x++, i += 4) {
+		let l = l_dc;
+		let p = p_dc;
+		let q = q_dc;
+		let a = a_dc;
+		for (let cx = 0, n = max(lx, hasAlpha ? 5 : 3); cx < n; cx++) fx[cx] = cos(PI / w * (x + .5) * cx);
+		for (let cy = 0, n = max(ly, hasAlpha ? 5 : 3); cy < n; cy++) fy[cy] = cos(PI / h * (y + .5) * cy);
+		for (let cy = 0, j = 0; cy < ly; cy++) for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx * ly < lx * (ly - cy); cx++, j++) l += l_ac[j] * fx[cx] * fy2;
+		for (let cy = 0, j = 0; cy < 3; cy++) for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 3 - cy; cx++, j++) {
+			const f = fx[cx] * fy2;
+			p += p_ac[j] * f;
+			q += q_ac[j] * f;
+		}
+		if (hasAlpha) for (let cy = 0, j = 0; cy < 5; cy++) for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 5 - cy; cx++, j++) a += a_ac[j] * fx[cx] * fy2;
+		const b = l - 2 / 3 * p;
+		const r = (3 * l - b + q) / 2;
+		const g = r - q;
+		rgba[i] = max(0, 255 * min(1, r));
+		rgba[i + 1] = max(0, 255 * min(1, g));
+		rgba[i + 2] = max(0, 255 * min(1, b));
+		rgba[i + 3] = max(0, 255 * min(1, a));
+	}
+	return {
+		w,
+		h,
+		rgba
+	};
+}
+/**
+* Extracts the approximate aspect ratio of the original image.
+*
+* @param hash The bytes of the ThumbHash.
+* @returns The approximate aspect ratio (i.e. width / height).
+*/
+function thumbHashToApproximateAspectRatio(hash) {
+	const header = hash[3];
+	const hasAlpha = hash[2] & 128;
+	const isLandscape = hash[4] & 128;
+	return (isLandscape ? hasAlpha ? 5 : 7 : header & 7) / (isLandscape ? header & 7 : hasAlpha ? 5 : 7);
+}
+/**
+* Encodes an RGBA image to PNG bytes. RGB should not be premultiplied by
+* A. This is optimized for speed and simplicity and does not optimize for size
+* at all. This doesn't do any compression (all values are stored uncompressed).
+*
+* @param w The width of the input image. Must be between 1 and 16383px.
+* @param h The height of the input image. Must be between 1 and 65535px.
+* @param rgba The pixels in the input image, row-by-row. Must have w*h*4 elements.
+* @returns The bytes of a PNG for the input image.
+*/
+function rgbaToPng(w, h, rgba) {
+	if (!Number.isInteger(w) || !Number.isInteger(h) || w < 1 || w > 16383 || h < 1 || h > 65535 || rgba.length !== w * h * 4) throw new RangeError("Invalid PNG dimensions or pixels");
+	const row = w * 4 + 1;
+	const idat = 6 + h * (5 + row);
+	const bytes = [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10,
+		0,
+		0,
+		0,
+		13,
+		73,
+		72,
+		68,
+		82,
+		0,
+		0,
+		w >> 8,
+		w & 255,
+		0,
+		0,
+		h >> 8,
+		h & 255,
+		8,
+		6,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		idat >>> 24,
+		idat >> 16 & 255,
+		idat >> 8 & 255,
+		idat & 255,
+		73,
+		68,
+		65,
+		84,
+		120,
+		1
+	];
+	const table = [
+		0,
+		498536548,
+		997073096,
+		651767980,
+		1994146192,
+		1802195444,
+		1303535960,
+		1342533948,
+		-306674912,
+		-267414716,
+		-690576408,
+		-882789492,
+		-1687895376,
+		-2032938284,
+		-1609899400,
+		-1111625188
+	];
+	let a = 1;
+	let b = 0;
+	for (let y = 0, i = 0, end = row - 1; y < h; y++, end += row - 1) {
+		bytes.push(y + 1 < h ? 0 : 1, row & 255, row >> 8, ~row & 255, row >> 8 ^ 255, 0);
+		for (b = (b + a) % 65521; i < end; i++) {
+			const u = rgba[i] & 255;
+			bytes.push(u);
+			a = (a + u) % 65521;
+			b = (b + a) % 65521;
+		}
+	}
+	bytes.push(b >> 8, b & 255, a >> 8, a & 255, 0, 0, 0, 0, 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130);
+	for (let [start, end] of [[12, 29], [37, 41 + idat]]) {
+		let c = -1;
+		for (let i = start; i < end; i++) {
+			c ^= bytes[i];
+			c = c >>> 4 ^ table[c & 15];
+			c = c >>> 4 ^ table[c & 15];
+		}
+		c = ~c;
+		bytes[end++] = c >>> 24;
+		bytes[end++] = c >> 16 & 255;
+		bytes[end++] = c >> 8 & 255;
+		bytes[end++] = c & 255;
+	}
+	return Uint8Array.from(bytes);
+}
+/**
+* Decodes a ThumbHash to a PNG data URL. This is a convenience function that
+* just calls "thumbHashToRGBA" followed by "rgbaToDataURL".
+*
+* @param hash The bytes of the ThumbHash.
+* @returns A data URL containing a PNG for the rendered ThumbHash.
+*/
+const placeholderHashToBytes = (hash) => Uint8Array.from(atob(hash), (c) => c.charCodeAt(0));
+/** Renders a base64 ThumbHash as a small PNG, which the browser scales to the element's size. */
+function placeholderHashToPng(hash) {
+	const image = thumbHashToRGBA(placeholderHashToBytes(hash));
+	return rgbaToPng(image.w, image.h, image.rgba);
+}
+function placeholderHashToDataURL(hash) {
+	return `data:image/png;base64,${btoa(String.fromCharCode(...placeholderHashToPng(hash)))}`;
+}
+// src/ui/ProgressFetch.ts
+/**
+* A `fetch` that reports how many bytes of the request body have been sent, which `fetch` itself
+* can't do. It sends through `XMLHttpRequest`, so the upload components pass it to
+* `CalmLensAppClient` as `uploadFetch`. Without `XMLHttpRequest` it falls back to `fetch` and
+* reports nothing.
+*/
+const createProgressFetch = (onProgress) => {
+	if (typeof XMLHttpRequest === "undefined") return (input, init) => fetch(input, init);
+	return (input, init = {}) => new Promise((resolve, reject) => {
+		const signal = init.signal;
+		const abortError = () => signal?.reason ?? new DOMException("The upload was cancelled", "AbortError");
+		if (signal?.aborted) {
+			reject(abortError());
+			return;
+		}
+		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+		const xhr = new XMLHttpRequest();
+		xhr.open(init.method ?? "GET", url);
+		xhr.responseType = "arraybuffer";
+		for (const [name, value] of new Headers(init.headers)) xhr.setRequestHeader(name, value);
+		xhr.upload.onprogress = (event) => {
+			if (event.lengthComputable) onProgress(event.loaded, event.total);
+		};
+		const onAbort = () => xhr.abort();
+		signal?.addEventListener("abort", onAbort, { once: true });
+		const done = () => signal?.removeEventListener("abort", onAbort);
+		xhr.onload = () => {
+			done();
+			const headers = new Headers();
+			for (const line of xhr.getAllResponseHeaders().trim().split(/[\r\n]+/)) {
+				const separator = line.indexOf(":");
+				if (separator > 0) headers.append(line.slice(0, separator).trim(), line.slice(separator + 1).trim());
+			}
+			const empty = [
+				101,
+				204,
+				205,
+				304
+			].includes(xhr.status);
+			resolve(new Response(empty ? null : xhr.response, {
+				status: xhr.status,
+				statusText: xhr.statusText,
+				headers
+			}));
+		};
+		xhr.onerror = () => {
+			done();
+			reject(/* @__PURE__ */ new TypeError("Network request failed"));
+		};
+		xhr.ontimeout = xhr.onerror;
+		xhr.onabort = () => {
+			done();
+			reject(abortError());
+		};
+		xhr.send(init.body ?? null);
+	});
+};
+// src/ui/UploadController.ts
+const DEFAULT_MAX_FILES = 10;
+const DEFAULT_CONCURRENCY = 3;
+const DEFAULT_DECISION_TIMEOUT_MS = 15e3;
+/** Whether a file matches an `accept` list such as `image/*,.pdf`. */
+const isFileAccepted = (file, accept) => {
+	const patterns = (accept ?? "").split(",").map((pattern) => pattern.trim().toLowerCase()).filter(Boolean);
+	if (patterns.length === 0) return true;
+	const type = file.type.toLowerCase();
+	const name = file.name.toLowerCase();
+	return patterns.some((pattern) => {
+		if (pattern === "*" || pattern === "*/*") return true;
+		if (pattern.endsWith("/*")) return type.startsWith(pattern.slice(0, -1));
+		if (pattern.startsWith(".")) return name.endsWith(pattern);
+		return type === pattern;
+	});
+};
+/** A browser file or blob, which uploads as it is. A file with a `uri` is read for its bytes. */
+const isBlob = (file) => !file.uri && typeof Blob !== "undefined" && file instanceof Blob;
+/** An image preview for a picked file: its own URI, or an object URL for a browser file. */
+const createPreviewUrl = (file) => {
+	if (!file.type.startsWith("image/")) return void 0;
+	if (file.uri) return file.uri;
+	return isBlob(file) && typeof URL.createObjectURL === "function" ? URL.createObjectURL(file) : void 0;
+};
+/** Releases an object URL `createPreviewUrl` made; a file's own URI is left alone. */
+const revokePreviewUrl = (url) => {
+	if (url?.startsWith("blob:")) URL.revokeObjectURL(url);
+};
+const isRejected = (status) => status === "blocked" || status === "purged";
+const sleep = (ms, signal) => new Promise((resolve) => {
+	const timer = setTimeout(resolve, ms);
+	signal.addEventListener("abort", () => {
+		clearTimeout(timer);
+		resolve();
+	});
+});
+let nextKey = 0;
+/**
+* Uploads files through an upload preset and tracks each one until it has a moderation
+* decision. It holds no UI: the React, Vue, Svelte and web components render its snapshot, and
+* you can render your own with `subscribe`, which also makes it a Svelte store.
+*/
+var UploadController = class {
+	#options;
+	#snapshot;
+	#listeners;
+	#aborts;
+	/** How to check each upload again, with the client and token it was uploaded with. */
+	#checks;
+	constructor(options) {
+		this.#snapshot = {
+			items: [],
+			busy: false
+		};
+		this.#listeners = /* @__PURE__ */ new Set();
+		this.#aborts = /* @__PURE__ */ new Map();
+		this.#checks = /* @__PURE__ */ new Map();
+		this.getSnapshot = () => this.#snapshot;
+		this.subscribe = (listener) => {
+			this.#listeners.add(listener);
+			listener(this.#snapshot);
+			return () => {
+				this.#listeners.delete(listener);
+			};
+		};
+		this.#options = options;
+	}
+	/** The current options. */
+	get options() {
+		return this.#options;
+	}
+	/** Replaces the options, for example when a component's props change. */
+	setOptions(options) {
+		this.#options = options;
+	}
+	/**
+	* Adds files from a file input, a drop, a paste or a phone's picker, and starts uploading them,
+	* or keeps them `selected` with `autoUpload: false`.
+	*/
+	addFiles(files) {
+		const { multiple = false, maxFiles = DEFAULT_MAX_FILES, accept, maxFileSize, autoUpload = true } = this.#options;
+		let picked = Array.from(files);
+		if (picked.length === 0) return;
+		if (!multiple) {
+			picked = picked.slice(0, 1);
+			for (const item of this.#snapshot.items) this.remove(item.key);
+		}
+		const room = (multiple ? maxFiles : 1) - this.#snapshot.items.length;
+		const added = picked.slice(0, Math.max(0, room)).map((file) => {
+			const key = `upload-${++nextKey}`;
+			const previewUrl = createPreviewUrl(file);
+			const errorCode = !isFileAccepted(file, accept) ? "file/not-accepted" : maxFileSize !== void 0 && file.size > maxFileSize ? "file/too-large" : void 0;
+			return errorCode ? {
+				key,
+				file,
+				previewUrl,
+				stage: "failed",
+				progress: null,
+				errorCode
+			} : {
+				key,
+				file,
+				previewUrl,
+				stage: autoUpload ? "queued" : "selected",
+				progress: null
+			};
+		});
+		this.#set([...this.#snapshot.items, ...added]);
+		for (const item of added) if (item.stage === "failed") this.#options.onFailed?.(item);
+		this.#pump();
+	}
+	/** Uploads every `selected` file, for an uploader with `autoUpload: false`. */
+	start() {
+		for (const item of this.#snapshot.items) if (item.stage === "selected") this.#update(item.key, { stage: "queued" });
+		this.#pump();
+	}
+	/**
+	* Tries a failed file again: an upload that finished but couldn't be checked is checked again,
+	* anything else is uploaded again. A finished upload still `pending` is checked again too.
+	*/
+	retry(key) {
+		const item = this.#find(key);
+		if (!item || item.errorCode?.startsWith("file/")) return;
+		const pending = item.stage === "complete" && item.status === "pending";
+		if (item.stage !== "failed" && !(pending && this.#checks.has(key))) return;
+		this.#update(key, {
+			stage: "queued",
+			progress: null,
+			errorCode: void 0,
+			assetId: this.#checks.has(key) ? item.assetId : void 0
+		});
+		this.#pump();
+	}
+	/**
+	* Stops a queued or running file and keeps it in the list as failed with `sdk/cancelled`, so
+	* `retry` can upload it again. Finished files are left as they are.
+	*/
+	cancel(key) {
+		const item = this.#find(key);
+		if (!item || item.stage !== "queued" && item.stage !== "uploading" && item.stage !== "checking") return;
+		this.#aborts.get(key)?.abort();
+		this.#aborts.delete(key);
+		this.#checks.delete(key);
+		this.#update(key, {
+			stage: "failed",
+			progress: null,
+			errorCode: SDK_ERROR_CODES.CANCELLED
+		});
+		this.#pump();
+	}
+	/** Cancels a file's upload if it's running and removes it from the list. */
+	remove(key) {
+		const item = this.#find(key);
+		if (!item) return;
+		this.#aborts.get(key)?.abort();
+		this.#aborts.delete(key);
+		this.#checks.delete(key);
+		revokePreviewUrl(item.previewUrl);
+		this.#set(this.#snapshot.items.filter((other) => other.key !== key));
+		this.#options.onRemoved?.(item);
+		this.#pump();
+	}
+	/** Cancels every upload and empties the list, without calling `onRemoved`. */
+	clear() {
+		for (const abort of this.#aborts.values()) abort.abort();
+		this.#aborts.clear();
+		this.#checks.clear();
+		for (const item of this.#snapshot.items) revokePreviewUrl(item.previewUrl);
+		this.#set([]);
+	}
+	#find(key) {
+		return this.#snapshot.items.find((item) => item.key === key);
+	}
+	#set(items) {
+		const busy = items.some((item) => item.stage === "queued" || item.stage === "uploading" || item.stage === "checking");
+		this.#snapshot = {
+			items,
+			busy
+		};
+		for (const listener of this.#listeners) listener(this.#snapshot);
+	}
+	#update(key, changes) {
+		if (!this.#find(key)) return;
+		this.#set(this.#snapshot.items.map((item) => item.key === key ? {
+			...item,
+			...changes
+		} : item));
+	}
+	#pump() {
+		const limit = this.#options.concurrency ?? DEFAULT_CONCURRENCY;
+		for (const item of this.#snapshot.items) {
+			if (this.#aborts.size >= limit) return;
+			if (item.stage === "queued" && !this.#aborts.has(item.key)) this.#upload(item);
+		}
+	}
+	async #upload({ key, file, assetId }) {
+		const abort = new AbortController();
+		this.#aborts.set(key, abort);
+		this.#update(key, {
+			stage: "uploading",
+			progress: 0
+		});
+		const options = this.#options;
+		try {
+			const onProgress = (sent, total) => {
+				if (!abort.signal.aborted) this.#update(key, { progress: total ? sent / total : null });
+			};
+			let check = assetId ? this.#checks.get(key) : void 0;
+			let asset;
+			if (assetId && check) {
+				this.#update(key, {
+					stage: "checking",
+					progress: null
+				});
+				asset = await check(assetId);
+			} else {
+				const client = await this.#clientFor(file, abort.signal, onProgress);
+				asset = await client.create();
+				check = client.retrieve;
+				if (check) this.#checks.set(key, check);
+				this.#update(key, {
+					stage: "checking",
+					progress: null,
+					assetId: asset.id
+				});
+			}
+			const deadline = Date.now() + (options.decisionTimeoutMs ?? DEFAULT_DECISION_TIMEOUT_MS);
+			for (let delay = 1e3; asset.status === "pending" && check && Date.now() < deadline; delay *= 2) {
+				await sleep(Math.min(delay, Math.max(0, deadline - Date.now())), abort.signal);
+				if (abort.signal.aborted) return;
+				asset = await check(asset.id);
+			}
+			if (abort.signal.aborted) return;
+			this.#update(key, {
+				stage: "complete",
+				status: asset.status
+			});
+			const item = this.#find(key);
+			if (!item) return;
+			if (isRejected(asset.status)) options.onRejected?.(item);
+			else options.onUploaded?.({
+				assetId: asset.id,
+				status: asset.status,
+				file
+			});
+		} catch (error) {
+			if (abort.signal.aborted) return;
+			const errorCode = CalmLensError.isCalmLensError(error) ? error.code : SDK_ERROR_CODES.TRANSPORT_ERROR;
+			this.#update(key, {
+				stage: "failed",
+				progress: null,
+				errorCode
+			});
+			const item = this.#find(key);
+			if (item) options.onFailed?.(item);
+		} finally {
+			if (this.#aborts.get(key) === abort) this.#aborts.delete(key);
+			this.#pump();
+		}
+	}
+	/** Creates and checks one file's upload, through `upload` or the upload preset. */
+	async #clientFor(file, signal, onProgress) {
+		const { upload, checkStatus, uploadPresetId, createClient, baseUrl } = this.#options;
+		if (upload) return {
+			create: async () => {
+				const { assetId, status } = await upload(file, {
+					signal,
+					onProgress
+				});
+				return {
+					id: assetId,
+					status
+				};
+			},
+			retrieve: checkStatus ? async (assetId) => ({
+				id: assetId,
+				status: await checkStatus(assetId, { signal })
+			}) : void 0
+		};
+		if (!uploadPresetId) throw new CalmLensError(SDK_ERROR_CODES.INVALID_CONFIG, { message: "The uploader needs an uploadPresetId or an upload function" });
+		const options = {
+			uploadPresetId,
+			token: await this.#tokenFor(file, signal),
+			baseUrl,
+			signal,
+			uploadFetch: createProgressFetch(onProgress)
+		};
+		const client = createClient ? createClient(options) : new CalmLensAppClient(options);
+		return {
+			create: async () => {
+				const type = file.type || "application/octet-stream";
+				return client.assets.create({
+					name: file.name,
+					content: isBlob(file) ? {
+						data: file,
+						type
+					} : {
+						uint8Array: new Uint8Array(await file.arrayBuffer()),
+						type
+					}
+				});
+			},
+			retrieve: (assetId) => client.assets.retrieve({ assetId })
+		};
+	}
+	async #tokenFor(file, signal) {
+		const { token, tokenUrl } = this.#options;
+		if (typeof token === "function") return await token(file);
+		if (token !== void 0) return token;
+		if (!tokenUrl) return void 0;
+		const response = await fetch(tokenUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				name: file.name,
+				type: file.type,
+				size: file.size
+			}),
+			credentials: "same-origin",
+			signal
+		});
+		const body = await response.json().catch(() => ({}));
+		if (!response.ok || typeof body.token !== "string") throw new CalmLensError(typeof body.code === "string" ? body.code : "upload-token/refused", { message: `Your token endpoint answered ${response.status} without a token` });
+		return body.token;
+	}
+};
+const createUploadController = (options) => new UploadController(options);
+export { placeholderHashToDataURL as a, createProgressFetch as i, createUploadController as n, isFileAccepted as r, UploadController as t };