Factory recreate mode; chunked uploads with progress everywhere

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Richard ZinkandClaude Sonnet 5.5 committed 2026-11-18 13:49:16 +01:00
1 parent 771c6f5245
commit b309778be8
17 files changed
+477 -47

No files matched your search

+125
View File
@@ -0,0 +1,125 @@
import { useSyncExternalStore } from "react";
/** One file of an upload batch. */
export interface UploadItem {
id: number;
name: string;
size: number;
sent: number;
status: "wait" | "run" | "done" | "error";
error?: string;
}
/** Uploads started together (a drop, a file dialog); shown as one panel with a total bar. */
export interface UploadBatch {
id: number;
items: UploadItem[];
closed: boolean;
}
const CHUNK = 8 * 1024 * 1024;
let seq = 0;
let batches: UploadBatch[] = [];
const listeners = new Set<() => void>();
const emit = () => {
batches = [...batches];
listeners.forEach((l) => l());
};
export const useUploads = () =>
useSyncExternalStore(
(l) => (listeners.add(l), () => listeners.delete(l)),
() => batches,
);
export const closeUploadBatch = (id: number) => {
batches = batches.filter((b) => b.id !== id);
emit();
};
/** PUT one chunk; `onBytes` reports the bytes of this chunk sent so far. */
function putChunk(url: string, chunk: Blob, onBytes: (n: number) => void): Promise<void> {
return new Promise((resolve, reject) => {
const xhr = new XMLHttpRequest();
xhr.open("PUT", url);
xhr.withCredentials = true;
xhr.upload.onprogress = (e) => e.lengthComputable && onBytes(e.loaded);
xhr.onload = () => {
if (xhr.status >= 200 && xhr.status < 300) return resolve();
let msg = `HTTP ${xhr.status}`;
try {
msg = JSON.parse(xhr.responseText).error ?? msg;
} catch {
if (xhr.status === 413) msg = "too large for the reverse proxy";
}
reject(new Error(msg));
};
xhr.onerror = () => reject(new Error("network error"));
xhr.send(chunk);
});
}
/**
* Upload a file in 8 MB chunks (stays below reverse proxy body limits; the server appends at `offset`).
* `onProgress` gets the bytes sent so far.
*/
export async function chunkedUpload(endpoint: string, file: Blob, onProgress?: (sent: number) => void): Promise<void> {
const sep = endpoint.includes("?") ? "&" : "?";
let offset = 0;
do {
const chunk = file.slice(offset, offset + CHUNK);
const base = offset;
await putChunk(`${endpoint}${sep}offset=${offset}`, chunk, (n) => onProgress?.(base + n));
offset += chunk.size;
onProgress?.(offset);
} while (offset < file.size);
}
export interface UploadJob {
file: File | Blob;
/** Absolute target path on the server (files upload). */
path: string;
/** Other chunked endpoint instead of /api/files/upload. */
endpoint?: string;
name?: string;
/** Called with the fraction 0..1 of this file. */
onProgress?: (fraction: number) => void;
}
/**
* Upload files one after the other with the progress panel (per file and in total).
* Resolves with the paths that arrived; failed files are listed in the panel.
*/
export async function uploadBatch(jobs: UploadJob[]): Promise<string[]> {
if (!jobs.length) return [];
const batch: UploadBatch = {
id: ++seq,
closed: false,
items: jobs.map((j) => ({ id: ++seq, name: j.name ?? (j.file as File).name ?? j.path.split("/").pop() ?? "file", size: j.file.size, sent: 0, status: "wait" as const })),
};
batches = [...batches, batch];
emit();
const done: string[] = [];
for (const [i, j] of jobs.entries()) {
const it = batch.items[i];
it.status = "run";
emit();
try {
await chunkedUpload(j.endpoint ?? `/api/files/upload?path=${encodeURIComponent(j.path)}`, j.file, (n) => {
it.sent = n;
j.onProgress?.(j.file.size ? n / j.file.size : 1);
emit();
});
it.sent = it.size;
it.status = "done";
done.push(j.path);
} catch (e: any) {
it.status = "error";
it.error = e.message ?? String(e);
}
emit();
}
// A clean batch fades away, one with errors stays until it is closed.
if (batch.items.every((x) => x.status === "done")) setTimeout(() => closeUploadBatch(batch.id), 2500);
return done;
}