batch + stamping

src/lib/batch.ts

@@ -0,0 +1,71 @@
+export type BatchItemStatus = 'pending' | 'processing' | 'done' | 'error';
+
+export type BatchItem = {
+	id: string;
+	file: File;
+	status: BatchItemStatus;
+	resultBytes?: Uint8Array;
+	resultName?: string;
+	errorMessage?: string | null;
+};
+
+export type BatchProcessResult = { bytes: Uint8Array; name: string };
+
+export type BatchRunOptions = {
+	/** Error message written to a row when `process` throws for it. */
+	errorMessage?: string;
+	/**
+	 * Optional predicate consulted before each item; when it returns `false`
+	 * (for example because the row was removed mid-run), the item is skipped.
+	 */
+	shouldProcess?: (id: string) => boolean;
+};
+
+export const createBatchItem = (file: File): BatchItem => ({
+	id: crypto.randomUUID(),
+	file,
+	status: 'pending'
+});
+
+/**
+ * Processes the given items strictly one after another so only one PDF is in
+ * flight at a time. Never throws: a failing item is marked as an error row and
+ * the queue continues with the remaining files.
+ */
+export const runBatch = async (
+	items: BatchItem[],
+	process: (file: File) => Promise<BatchProcessResult>,
+	update: (id: string, patch: Partial<BatchItem>) => void,
+	options: BatchRunOptions = {}
+): Promise<void> => {
+	const { errorMessage = 'Die Datei konnte nicht verarbeitet werden.', shouldProcess } = options;
+
+	for (const item of items) {
+		if (shouldProcess && !shouldProcess(item.id)) continue;
+
+		update(item.id, { status: 'processing', errorMessage: null });
+		try {
+			const result = await process(item.file);
+			update(item.id, {
+				status: 'done',
+				resultBytes: result.bytes,
+				resultName: result.name,
+				errorMessage: null
+			});
+		} catch (error) {
+			console.error(`Batch processing failed for ${item.file.name}:`, error);
+			update(item.id, {
+				status: 'error',
+				resultBytes: undefined,
+				resultName: undefined,
+				errorMessage
+			});
+		}
+	}
+};
+
+export const formatBytes = (bytes: number) => {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+};