@bud.sh/app 0.1.0 → 0.3.0

package/dist/node-host/assets/project-branches-1zs_0J_y.js

@@ -0,0 +1,600 @@
+import { Cr as parseElementAnchor, S as writeRows, b as plainRow, c as previewKey, l as projectStore, ni as parsePreviewBranch, oi as parsePreviewPins, ti as parsePreview, v as projectLive, y as routes } from "./comment-data-nUlI0szN.js";
+import { array, boolean, enum_, nullable, number, object, parseSafe, string } from "remix/data-schema";
+//#region app/client/project-previews.ts
+/**
+* A preview's capture in a theme at a viewport. Captures from before viewports existed name
+* none and belong to the viewport of their width.
+* @param preview - The route's preview.
+* @param theme - The color scheme.
+* @param size - The viewport.
+* @returns The capture, or undefined.
+*/
+function captureFor(preview, theme, size) {
+	return preview?.captures.find((capture) => capture.theme === theme && (capture.viewport ? capture.viewport === size.id : capture.width === size.width));
+}
+/**
+* The key of a theme at a viewport among a route's pictures.
+* @param theme - The color scheme.
+* @param size - The viewport.
+* @returns The key.
+*/
+function pictureKey(theme, size) {
+	return `${theme}\0${size.id}`;
+}
+/**
+* Where an element is in a route's page at the capture width, in page pixels, as the route's
+* screenshot tab finds it now.
+* @param token - The project's capability.
+* @param id - The route identity.
+* @param theme - The color scheme whose tab to ask.
+* @param element - The element's anchor.
+* @param signal - Ends the request.
+* @param viewport - The viewport whose tab to ask; the first configured one by default.
+* @returns The point, or null when the page has no picker or the element isn't found.
+*/
+async function locatePreview(token, id, theme, element, signal, viewport) {
+	try {
+		let response = await fetch(routes.previewsApi.locate.href({ id }), {
+			method: "POST",
+			headers: {
+				"X-Bud-Token": token,
+				"Content-Type": "application/json"
+			},
+			credentials: "same-origin",
+			redirect: "error",
+			signal,
+			body: JSON.stringify({
+				theme,
+				element,
+				...viewport ? { viewport } : {}
+			})
+		});
+		if (!response.ok) return null;
+		let { pin } = await response.json();
+		if (pin === null) return null;
+		let [found] = parsePreviewPins([pin]);
+		return found && found.match !== "missing" && found.x !== null && found.y !== null ? {
+			x: found.x,
+			y: found.y
+		} : null;
+	} catch {
+		return null;
+	}
+}
+/** Earlier captures kept per route and theme, so undoing a change shows its picture at once. */
+var KEPT_CAPTURES = 2;
+/** Bytes of stored images beyond which earlier images go first, oldest first. */
+var IMAGE_BUDGET = 268435456;
+/**
+* The stored images to delete: slices of captures no preview shows, beyond the latest few
+* captures each route and theme showed before, and then the oldest of the rest until the store
+* fits its budget. Slices of a capture a preview shows always stay, and a capture's slices go
+* together.
+* @param previews - Every stored preview.
+* @param images - Every stored image.
+* @param budget - The most bytes to keep, when earlier images allow it.
+* @returns The hashes to delete.
+*/
+function staleImages(previews, images, budget = IMAGE_BUDGET) {
+	let shown = new Set(previews.flatMap((preview) => preview.captures.map(({ hash }) => hash)));
+	let captures = /* @__PURE__ */ new Map();
+	for (let image of images.filter((image) => !shown.has(image.capture)).toSorted((left, right) => right.storedAt - left.storedAt)) captures.set(image.capture, [...captures.get(image.capture) ?? [], image]);
+	let kept = /* @__PURE__ */ new Map();
+	let stale = [];
+	let earlier = [];
+	for (let slices of captures.values()) {
+		let key = `${slices[0].theme}\0${slices[0].route}`;
+		let count = (kept.get(key) ?? 0) + 1;
+		kept.set(key, count);
+		if (count > KEPT_CAPTURES) stale.push(...slices.map((image) => image.hash));
+		else earlier.push(slices);
+	}
+	let removed = new Set(stale);
+	let bytes = images.reduce((total, image) => total + (removed.has(image.hash) ? 0 : image.image.size), 0);
+	for (let slices of earlier.toReversed()) {
+		if (bytes <= budget) break;
+		for (let image of slices) {
+			stale.push(image.hash);
+			bytes -= image.image.size;
+		}
+	}
+	return stale;
+}
+/**
+* Stores an image and evicts what the store no longer needs. A full store evicts every
+* earlier image and tries once more; failing that, the image is shown but not kept.
+* @param store - The project store.
+* @param image - The downloaded image.
+* @returns Whether the image was stored.
+*/
+async function storeImage(store, image) {
+	let evict = (budget) => {
+		let stale = staleImages(store.previews.toArray.map(plainRow), store.images.toArray.map(plainRow), budget);
+		return stale.length ? writeRows(store.images, { delete: stale }) : void 0;
+	};
+	try {
+		await writeRows(store.images, { upsert: [image] });
+	} catch {
+		try {
+			await evict(0);
+			await writeRows(store.images, { upsert: [image] });
+		} catch {
+			return false;
+		}
+	}
+	await evict()?.catch(() => {});
+	return true;
+}
+var downloads = {
+	active: 0,
+	waiting: [],
+	limit: /^h[23]/.test((globalThis.performance?.getEntriesByType("navigation")[0])?.nextHopProtocol ?? "") ? 12 : 4
+};
+/**
+* Downloads a picture by its hash once one of the few download slots is free.
+* @param hash - The picture's content hash.
+* @param token - The project's capability.
+* @param signal - Ends the download, also while it waits for a slot.
+* @returns The picture.
+*/
+async function downloadImage(hash, token, signal) {
+	while (downloads.active >= downloads.limit) {
+		await new Promise((resolve) => downloads.waiting.push(resolve));
+		if (signal.aborted) {
+			downloads.waiting.shift()?.();
+			signal.throwIfAborted();
+		}
+	}
+	downloads.active++;
+	try {
+		return await (await request(routes.previewsApi.image.href({ hash }), token, signal)).blob();
+	} finally {
+		downloads.active--;
+		downloads.waiting.shift()?.();
+	}
+}
+async function request(url, token, signal, method = "GET") {
+	let response = await fetch(url, {
+		method,
+		headers: { "X-Bud-Token": token },
+		credentials: "same-origin",
+		redirect: "error",
+		signal
+	});
+	if (!response.ok) {
+		let body = await response.json().catch(() => null);
+		throw new Error(typeof body?.error === "string" ? body.error : `Preview request failed (${response.status}).`);
+	}
+	return response;
+}
+function message(cause) {
+	return cause instanceof Error ? cause.message : "Bud could not load this preview.";
+}
+/**
+* Shows server-captured route screenshots for one canvas from the project's local store,
+* which the live channel keeps current. Images are fetched once per content hash with the
+* capability header, kept in IndexedDB and shown through object URLs.
+* @param options - The project and the canvas lifetime.
+* @returns Per-route views; each route's listeners update only that artboard.
+*/
+function createProjectPreviews(options) {
+	let { project, signal } = options;
+	let branch = options.branch ?? null;
+	let key = (id) => previewKey(branch, id);
+	let route = (rowKey) => branch ? rowKey.startsWith(`${branch}\0`) ? rowKey.slice(branch.length + 1) : null : rowKey.includes("\0") ? null : rowKey;
+	let query = branch ? `?branch=${encodeURIComponent(branch)}` : "";
+	let token = project.token;
+	let store = null;
+	let views = /* @__PURE__ */ new Map();
+	let listeners = /* @__PURE__ */ new Map();
+	let shownSizes = /* @__PURE__ */ new Map();
+	let loading = /* @__PURE__ */ new Map();
+	let sequences = /* @__PURE__ */ new Map();
+	function view(id) {
+		return views.get(id) ?? {
+			images: {},
+			refreshing: false,
+			error: ""
+		};
+	}
+	function notify(id) {
+		for (let listener of listeners.get(id) ?? []) listener();
+	}
+	function update(id, change) {
+		views.set(id, {
+			...view(id),
+			...change
+		});
+		notify(id);
+	}
+	function preview(id) {
+		let row = store?.previews.get(key(id));
+		return row ? plainRow(row) : null;
+	}
+	async function save(next) {
+		if (!store || (sequences.get(next.id) ?? -1) > next.sequence) return;
+		sequences.set(next.id, next.sequence);
+		await writeRows(store.previews, { upsert: [next] });
+	}
+	let arrived = /* @__PURE__ */ new Map();
+	function arrive(preview) {
+		if ((preview.branch ?? null) !== branch) return;
+		arrived.set(preview.id, preview);
+		if (arrived.size === 1) requestAnimationFrame(() => void flush());
+	}
+	async function flush() {
+		if (!store || !arrived.size) return;
+		let previews = [...arrived.values()];
+		arrived.clear();
+		for (let preview of previews) sequences.set(preview.id, preview.sequence);
+		await writeRows(store.previews, { upsert: previews });
+	}
+	function revoke(picture) {
+		for (let src of [...picture?.srcs ?? [], ...picture?.thumbnails ?? []]) URL.revokeObjectURL(src);
+	}
+	async function stored(id, theme, capture, hash) {
+		let image = store.images.get(hash)?.image;
+		if (image) return image;
+		image = await downloadImage(hash, token, signal);
+		await storeImage(store, {
+			hash,
+			capture,
+			image,
+			route: id,
+			theme,
+			storedAt: Date.now()
+		});
+		return image;
+	}
+	let slicing = /* @__PURE__ */ new Set();
+	async function slices(id, theme, size) {
+		let picture = pictureKey(theme, size);
+		let shown = view(id).images[picture];
+		let key = `${picture}\0${id}\0${shown?.capture.hash}`;
+		if (!store || !shown || shown.srcs.length || slicing.has(key)) return;
+		slicing.add(key);
+		let wanted = shown.capture;
+		let srcs = [];
+		try {
+			srcs = (await Promise.all(wanted.tiles.map((tile) => stored(id, theme, wanted.hash, tile.hash)))).map((image) => URL.createObjectURL(image));
+			let current = view(id).images[picture];
+			if (signal.aborted || current?.capture.hash !== wanted.hash || current.srcs.length) {
+				for (let src of srcs) URL.revokeObjectURL(src);
+				return;
+			}
+			update(id, { images: {
+				...view(id).images,
+				[picture]: {
+					...current,
+					srcs
+				}
+			} });
+		} catch (cause) {
+			for (let src of srcs) URL.revokeObjectURL(src);
+			if (!signal.aborted && view(id).images[picture]?.capture.hash === wanted.hash) update(id, { error: message(cause) });
+		} finally {
+			slicing.delete(key);
+		}
+	}
+	async function load(id, theme, size) {
+		let picture = pictureKey(theme, size);
+		let wanted = captureFor(preview(id), theme, size);
+		let shown = view(id).images[picture];
+		let key = `${picture}\0${id}`;
+		if (!store || !wanted || loading.get(key) === wanted.hash) return;
+		if (shown?.capture.hash === wanted.hash) {
+			if (shown.capture.revision !== wanted.revision) update(id, { images: {
+				...view(id).images,
+				[picture]: {
+					...shown,
+					capture: wanted
+				}
+			} });
+			return;
+		}
+		loading.set(key, wanted.hash);
+		let srcs = [];
+		try {
+			let first = wanted.thumbnails.length ? wanted.thumbnails : wanted.tiles;
+			srcs = (await Promise.all(first.map((image) => stored(id, theme, wanted.hash, image.hash)))).map((image) => URL.createObjectURL(image));
+			let latest = captureFor(preview(id), theme, size);
+			if (signal.aborted || latest?.hash !== wanted.hash) {
+				for (let src of srcs) URL.revokeObjectURL(src);
+				return;
+			}
+			revoke(view(id).images[picture]);
+			let next = wanted.thumbnails.length ? {
+				capture: latest,
+				srcs: [],
+				thumbnails: srcs
+			} : {
+				capture: latest,
+				srcs,
+				thumbnails: []
+			};
+			update(id, {
+				images: {
+					...view(id).images,
+					[picture]: next
+				},
+				error: ""
+			});
+		} catch (cause) {
+			for (let src of srcs) URL.revokeObjectURL(src);
+			let latest = captureFor(preview(id), theme, size);
+			if (!signal.aborted && latest?.hash === wanted.hash) update(id, { error: message(cause) });
+		} finally {
+			if (loading.get(key) === wanted.hash) loading.delete(key);
+		}
+	}
+	async function open(id) {
+		try {
+			let response = await request(`${routes.previewsApi.show.href({ id })}${query}`, token, signal);
+			await save(parsePreview(await response.json()));
+		} catch (cause) {
+			if (!signal.aborted) update(id, { error: message(cause) });
+		}
+	}
+	function changed(id) {
+		notify(id);
+		for (let { theme, size } of shownSizes.get(id)?.values() ?? []) load(id, theme, size);
+	}
+	let stopLive = projectLive(token).subscribe("previews", {
+		onEvent(data) {
+			arrive(parsePreview(data));
+		},
+		onResync() {
+			sequences.clear();
+			for (let id of listeners.keys()) open(id);
+		}
+	});
+	let stopStore = () => {};
+	let opening = projectStore(project);
+	opening.then(async (opened) => {
+		if (signal.aborted) return;
+		store = opened;
+		let configured = new Set(project.routes.map((route) => route.id));
+		let removed = opened.previews.toArray.filter((row) => !configured.has(row.id));
+		writeRows(opened.previews, { delete: removed.map((row) => previewKey(row.branch ?? null, row.id)) });
+		let subscription = opened.previews.subscribeChanges((changes) => {
+			for (let change of changes) {
+				let id = route(String(change.key));
+				if (id !== null) changed(id);
+			}
+		});
+		stopStore = () => subscription.unsubscribe();
+		flush();
+		for (let id of listeners.keys()) {
+			changed(id);
+			open(id);
+		}
+	});
+	signal.addEventListener("abort", () => {
+		stopLive();
+		stopStore();
+		for (let { images } of views.values()) for (let picture of Object.values(images)) revoke(picture);
+	}, { once: true });
+	return {
+		get: (id) => ({
+			preview: preview(id),
+			...view(id)
+		}),
+		watch(id, listener) {
+			let set = listeners.get(id);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				listeners.set(id, set);
+				if (store) open(id);
+			}
+			set.add(listener);
+			return () => {
+				set.delete(listener);
+			};
+		},
+		slices(id, theme, size) {
+			slices(id, theme, size);
+		},
+		show(id, theme, size) {
+			let shown = shownSizes.get(id) ?? /* @__PURE__ */ new Map();
+			let key = pictureKey(theme, size);
+			if (shown.has(key)) return;
+			shownSizes.set(id, shown.set(key, {
+				theme,
+				size
+			}));
+			load(id, theme, size);
+		},
+		async describe(id, capture, x, y) {
+			try {
+				let response = await fetch(routes.previewsApi.describe.href({ id }), {
+					method: "POST",
+					headers: {
+						"X-Bud-Token": token,
+						"Content-Type": "application/json"
+					},
+					credentials: "same-origin",
+					redirect: "error",
+					signal,
+					body: JSON.stringify({
+						theme: capture.theme,
+						hash: capture.hash,
+						x,
+						y,
+						...branch ? { branch } : {}
+					})
+				});
+				if (!response.ok) return null;
+				let { element } = await response.json();
+				return element === null ? null : parseElementAnchor(element);
+			} catch {
+				return null;
+			}
+		},
+		locate: (id, theme, element, size) => locatePreview(token, id, theme, element, signal, size?.id),
+		async picture(id, theme, size) {
+			let opened = await opening;
+			if (!preview(id)) await open(id);
+			let capture = captureFor(preview(id), theme, size);
+			if (!capture) return null;
+			return {
+				capture,
+				images: await Promise.all(capture.tiles.map(async (tile) => opened.images.get(tile.hash)?.image ?? await downloadImage(tile.hash, token, signal)))
+			};
+		},
+		async refresh(id) {
+			if (branch) return;
+			update(id, {
+				refreshing: true,
+				error: ""
+			});
+			try {
+				let response = await request(routes.previewsApi.refresh.href({ id }), token, signal, "POST");
+				await save(parsePreview(await response.json()));
+				update(id, { refreshing: false });
+			} catch (cause) {
+				if (!signal.aborted) update(id, {
+					refreshing: false,
+					error: message(cause)
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region app/client/project-branches.ts
+var name = string().refine((value) => {
+	try {
+		return parsePreviewBranch(value) === value;
+	} catch {
+		return false;
+	}
+});
+var commit = string().refine((value) => /^[a-f0-9]{40,64}$/.test(value));
+var BranchListSchema = object({
+	working: nullable(name),
+	main: nullable(name),
+	branches: array(object({
+		name,
+		main: boolean(),
+		active: boolean(),
+		commit,
+		subject: nullable(string().refine((value) => value.length <= 1e3)),
+		captured: nullable(commit),
+		state: enum_([
+			"idle",
+			"queued",
+			"building",
+			"capturing",
+			"ready",
+			"failed"
+		]),
+		error: nullable(string().refine((value) => value.length <= 8e3)),
+		progress: nullable(object({
+			captured: number(),
+			total: number()
+		}))
+	})).refine((branches) => branches.length <= 500)
+});
+/**
+* Validates the companion's branch list.
+* @param value - Untrusted JSON.
+* @returns The list.
+*/
+function parseBranchList(value) {
+	let result = parseSafe(BranchListSchema, value);
+	if (!result.success) throw new TypeError("The companion returned an invalid branch list.");
+	return result.value;
+}
+/**
+* The canvas's branches, kept current by the live channel: main and the activated branches with
+* where their pictures stand, and the repository's other branches to activate.
+* @param options - The project, the canvas lifetime and a change callback.
+* @returns The list and its operations.
+*/
+function createProjectBranches(options) {
+	let { project, signal } = options;
+	let list = {
+		working: null,
+		main: null,
+		branches: []
+	};
+	let loaded = false;
+	let busy = false;
+	let error = "";
+	function changed() {
+		if (!signal.aborted) options.onChange();
+	}
+	async function call(url, method = "GET") {
+		let response = await fetch(url, {
+			method,
+			headers: { "X-Bud-Token": project.token },
+			credentials: "same-origin",
+			redirect: "error",
+			signal
+		});
+		let body = await response.json().catch(() => null);
+		if (!response.ok) throw new Error(typeof body?.error === "string" ? body.error : "Bud could not load branches.");
+		return parseBranchList(body);
+	}
+	async function load() {
+		try {
+			list = await call(routes.branchesApi.list.href());
+			loaded = true;
+			error = "";
+		} catch (cause) {
+			if (!signal.aborted) error = cause instanceof Error ? cause.message : String(cause);
+		}
+		changed();
+	}
+	let stop = projectLive(project.token).subscribe("branches", {
+		onEvent(data) {
+			try {
+				list = parseBranchList(data);
+				loaded = true;
+				changed();
+			} catch {
+				load();
+			}
+		},
+		onResync() {
+			load();
+		}
+	});
+	signal.addEventListener("abort", stop, { once: true });
+	load();
+	let change = async (href) => {
+		busy = true;
+		changed();
+		try {
+			list = await call(href, "POST");
+			error = "";
+		} catch (cause) {
+			if (!signal.aborted) error = cause instanceof Error ? cause.message : String(cause);
+		} finally {
+			busy = false;
+			changed();
+		}
+	};
+	return {
+		get list() {
+			return list;
+		},
+		get loaded() {
+			return loaded;
+		},
+		get busy() {
+			return busy;
+		},
+		get error() {
+			return error;
+		},
+		activate(branch, active) {
+			return change(active ? routes.branchesApi.activate.href({ name: branch }) : routes.branchesApi.deactivate.href({ name: branch }));
+		},
+		capture(branch) {
+			return change(routes.branchesApi.capture.href({ name: branch }));
+		}
+	};
+}
+//#endregion
+export { pictureKey as i, createProjectPreviews as n, locatePreview as r, createProjectBranches as t };