Files
DerSchandfleckandClaude Fable 5.2 90500811df Vorgaben: 20 GB je Transfer, Frist 1 Tag
Bei nur einer Frist entfällt das Auswahlfeld; die Frist steht dann im
Hinweis unter der Dateiauswahl. Ohne DEFAULT_EXPIRY_DAYS ist die
kürzeste Frist vorausgewählt.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-16 01:32:07 +01:00

1003 lines
32 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Upload-Seite: Dateien auswählen, stückweise hochladen, Link anzeigen.
import {
ApiError,
api,
copyText,
fileNameElement,
fill,
formatBytes,
formatDate,
formatDuration,
getLang,
onLangChange,
} from './common.js';
const TEXT = {
de: {
days: (n) => (n === 1 ? '1 Tag' : `${n} Tage`),
files: (n) => (n === 1 ? '1 Datei' : `${n} Dateien`),
limitHint: 'Bis zu {size} pro Transfer',
limitHintFixed: 'Bis zu {size} pro Transfer · wird {after} gelöscht',
afterDays: (n) => (n === 1 ? 'nach 1 Tag' : `nach ${n} Tagen`),
remove: '„{name}“ entfernen',
tooLarge: 'Zusammen sind das {size} – erlaubt sind höchstens {max}.',
tooMany: 'Das sind {count} Dateien – erlaubt sind höchstens {max}.',
folderSkipped: 'Ordner lassen sich nicht hochladen. Pack sie vorher in eine ZIP-Datei.',
codeMissing: 'Bitte gib den Upload-Code ein.',
codeInvalid: 'Dieser Upload-Code stimmt nicht.',
rateLimited: 'Zu viele Versuche. Bitte warte {time} und versuch es dann noch einmal.',
storageFull: 'Auf dem Server ist gerade nicht genug Platz frei.',
uploadsDisabled: 'Das Hochladen ist auf dieser Seite gerade abgeschaltet.',
network: 'Der Server ist nicht erreichbar. Prüf bitte deine Internetverbindung.',
gone: 'Der angefangene Upload ist auf dem Server nicht mehr vorhanden. Bitte starte ihn neu.',
unreadable: '„{name}“ lässt sich nicht lesen. Wurde die Datei verschoben oder verändert?',
generic: 'Das hat nicht geklappt (Fehler {code}).',
progressDetail: '{done} von {total}',
eta: 'noch etwa {time}',
finishing: 'Wird abgeschlossen …',
currentFile: 'Datei {index} von {count}: {name}',
uploadedSoFar: 'Bisher hochgeladen: {done} von {total}',
doneInfo: '{files} · {size} · verfügbar bis {date}',
copy: 'Kopieren',
copied: 'Kopiert',
copyLink: 'Link kopieren',
more: (n) => (n === 1 ? '+ 1 weitere' : `+ ${n} weitere`),
recentMeta: '{size} · verfügbar bis {date}',
delete: 'Löschen',
confirmDelete: 'Wirklich löschen?',
deleteFailed: 'Löschen hat nicht geklappt. Versuch es später noch einmal.',
},
en: {
days: (n) => (n === 1 ? '1 day' : `${n} days`),
files: (n) => (n === 1 ? '1 file' : `${n} files`),
limitHint: 'Up to {size} per transfer',
limitHintFixed: 'Up to {size} per transfer · deleted {after}',
afterDays: (n) => (n === 1 ? 'after 1 day' : `after ${n} days`),
remove: 'Remove “{name}”',
tooLarge: 'That is {size} in total – the limit is {max}.',
tooMany: 'That is {count} files – the limit is {max}.',
folderSkipped: 'Folders cannot be uploaded. Put them into a ZIP file first.',
codeMissing: 'Please enter the upload code.',
codeInvalid: 'This upload code is not correct.',
rateLimited: 'Too many attempts. Please wait {time} and try again.',
storageFull: 'There is not enough free space on the server right now.',
uploadsDisabled: 'Uploading is switched off on this site at the moment.',
network: 'The server cannot be reached. Please check your internet connection.',
gone: 'The upload you started no longer exists on the server. Please start it again.',
unreadable: '“{name}” cannot be read. Was the file moved or changed?',
generic: 'That did not work (error {code}).',
progressDetail: '{done} of {total}',
eta: 'about {time} left',
finishing: 'Finishing …',
currentFile: 'File {index} of {count}: {name}',
uploadedSoFar: 'Uploaded so far: {done} of {total}',
doneInfo: '{files} · {size} · available until {date}',
copy: 'Copy',
copied: 'Copied',
copyLink: 'Copy link',
more: (n) => `+ ${n} more`,
recentMeta: '{size} · available until {date}',
delete: 'Delete',
confirmDelete: 'Really delete?',
deleteFailed: 'Deleting did not work. Please try again later.',
},
};
/** Text in der aktuellen Sprache; Funktionen werden mit `params` aufgerufen. */
function t(key, params) {
const value = TEXT[getLang()][key];
return typeof value === 'function' ? value(params) : fill(value, params);
}
const $ = (id) => document.getElementById(id);
const el = {
stepSelect: $('step-select'),
stepProgress: $('step-progress'),
stepDone: $('step-done'),
stepError: $('step-error'),
dropzone: $('dropzone'),
fileInput: $('file-input'),
limitHint: $('limit-hint'),
fields: $('fields'),
expiryField: $('expiry-field'),
selection: $('selection'),
fileList: $('file-list'),
selectionTotal: $('selection-total'),
clearFiles: $('clear-files'),
expiry: $('expiry'),
codeField: $('code-field'),
code: $('code'),
rememberCode: $('remember-code'),
codeHint: $('code-hint'),
formError: $('form-error'),
start: $('start-upload'),
progressTitle: $('progress-title'),
progressBar: $('progress-bar'),
progressPercent: $('progress-percent'),
progressDetail: $('progress-detail'),
progressFile: $('progress-file'),
progressRetry: $('progress-retry'),
cancel: $('cancel-upload'),
doneTitle: $('done-title'),
shareLink: $('share-link'),
copyLink: $('copy-link'),
doneInfo: $('done-info'),
openLink: $('open-link'),
newUpload: $('new-upload'),
errorTitle: $('error-title'),
uploadError: $('upload-error'),
errorProgress: $('error-progress'),
resume: $('resume-upload'),
discard: $('discard-upload'),
recent: $('recent'),
recentList: $('recent-list'),
recentError: $('recent-error'),
};
const ID_PATTERN = /^[2-9a-hjkmnp-z]{10}$/;
const MAX_ATTEMPTS = 8; // Versuche je Stück, bevor der Upload als unterbrochen gilt
const STALL_MS = 90_000; // so lange darf sich bei einem Stück nichts bewegen
const CANCELLED = Symbol('abgebrochen');
const state = {
config: null, // Grenzen und Fristen vom Server
files: [], // ausgewählte File-Objekte
phase: 'select', // select | uploading | finishing | done | error
formError: null, // { key, params } – Meldung im Formular
job: null, // laufender Upload
result: null, // fertiger Transfer
copiedUntil: 0,
deleteArmed: null, // Kennung, bei der „Löschen“ gerade nachfragt
recentError: null, // { key } – Meldung unter der Liste
};
// ------------------------------------------------------------- Speicher
function storageGet(storage, key) {
try {
return storage.getItem(key);
} catch {
return null;
}
}
function storageSet(storage, key, value) {
try {
if (value === null) storage.removeItem(key);
else storage.setItem(key, value);
} catch {
// Speicher gesperrt oder voll: dann eben ohne.
}
}
function loadRecent() {
let list;
try {
list = JSON.parse(storageGet(localStorage, 'uploads') ?? '[]');
} catch {
list = [];
}
if (!Array.isArray(list)) return [];
const now = Date.now();
return list.filter(
(item) =>
item &&
typeof item.id === 'string' &&
ID_PATTERN.test(item.id) &&
typeof item.deleteToken === 'string' &&
typeof item.name === 'string' &&
Number.isFinite(item.expiresAt) &&
item.expiresAt > now &&
Number.isFinite(item.count) &&
Number.isFinite(item.bytes),
);
}
function saveRecent(list) {
storageSet(localStorage, 'uploads', JSON.stringify(list.slice(0, 20)));
}
function rememberCode(code) {
if (el.rememberCode.checked) {
storageSet(localStorage, 'uploadCode', code);
storageSet(sessionStorage, 'uploadCode', null);
} else {
storageSet(localStorage, 'uploadCode', null);
storageSet(sessionStorage, 'uploadCode', code);
}
}
function forgetCode() {
storageSet(localStorage, 'uploadCode', null);
storageSet(sessionStorage, 'uploadCode', null);
}
// ------------------------------------------------------------ Auswahl
function totalBytes(files) {
return files.reduce((sum, file) => sum + file.size, 0);
}
/** Prüft die Auswahl gegen die Grenzen des Servers. */
function selectionProblem() {
const cfg = state.config;
if (!cfg || state.files.length === 0) return null;
if (state.files.length > cfg.maxFiles) {
return { key: 'tooMany', params: { count: state.files.length, max: cfg.maxFiles } };
}
const total = totalBytes(state.files);
if (total > cfg.maxTransferBytes) {
return { key: 'tooLarge', params: { size: formatBytes(total), max: formatBytes(cfg.maxTransferBytes) } };
}
return null;
}
function addFiles(list, { skippedFolder = false } = {}) {
const known = new Set(state.files.map((f) => `${f.name}\n${f.size}\n${f.lastModified}`));
for (const file of list) {
const key = `${file.name}\n${file.size}\n${file.lastModified}`;
if (known.has(key)) continue;
known.add(key);
state.files.push(file);
}
state.formError = skippedFolder ? { key: 'folderSkipped' } : null;
render();
}
/** Liest die Dateien aus einem Drag-and-drop; Ordner werden ausgelassen. */
function filesFromDrop(dataTransfer) {
const files = [];
let skippedFolder = false;
if (dataTransfer.items && dataTransfer.items.length > 0) {
for (const item of dataTransfer.items) {
if (item.kind !== 'file') continue;
if (item.webkitGetAsEntry?.()?.isDirectory) {
skippedFolder = true;
continue;
}
const file = item.getAsFile();
if (file) files.push(file);
}
} else {
files.push(...dataTransfer.files);
}
return { files, skippedFolder };
}
// ------------------------------------------------------------- Zeichnen
function show(step) {
for (const [name, node] of [
['select', el.stepSelect],
['progress', el.stepProgress],
['done', el.stepDone],
['error', el.stepError],
]) {
node.hidden = name !== step;
}
}
function renderSelect() {
const cfg = state.config;
// Gibt es nur eine Frist, steht sie im Hinweis; ein Auswahlfeld wäre überflüssig.
const fixedExpiry = cfg && cfg.expiryDays.length === 1 ? cfg.expiryDays[0] : null;
if (!cfg) {
el.limitHint.textContent = '';
} else if (fixedExpiry !== null) {
el.limitHint.textContent = t('limitHintFixed', {
size: formatBytes(cfg.maxTransferBytes),
after: t('afterDays', fixedExpiry),
});
} else {
el.limitHint.textContent = t('limitHint', { size: formatBytes(cfg.maxTransferBytes) });
}
el.expiryField.hidden = !cfg || fixedExpiry !== null;
// Fristen: Auswahl beim Neuzeichnen behalten
if (cfg) {
const chosen = Number(el.expiry.value) || cfg.defaultExpiryDays;
el.expiry.replaceChildren(
...cfg.expiryDays.map((days) => {
const option = document.createElement('option');
option.value = String(days);
option.textContent = t('days', days);
option.selected = days === chosen;
return option;
}),
);
}
const codeNeeded = !cfg || cfg.codeRequired;
el.codeField.hidden = !codeNeeded;
el.codeHint.hidden = !codeNeeded;
el.fields.hidden = el.expiryField.hidden && el.codeField.hidden;
el.selection.hidden = state.files.length === 0;
el.fileList.replaceChildren(
...state.files.map((file, index) => {
const item = document.createElement('li');
const size = document.createElement('span');
size.className = 'file-size';
size.textContent = formatBytes(file.size);
const remove = document.createElement('button');
remove.type = 'button';
remove.className = 'icon-button';
remove.textContent = '×';
remove.setAttribute('aria-label', t('remove', { name: file.name }));
remove.addEventListener('click', () => {
state.files.splice(index, 1);
state.formError = null;
render();
});
item.append(fileNameElement(file.name), size, remove);
return item;
}),
);
el.selectionTotal.textContent = `${t('files', state.files.length)} · ${formatBytes(totalBytes(state.files))}`;
const problem = selectionProblem() ?? state.formError;
el.formError.hidden = !problem;
el.formError.textContent = problem ? t(problem.key, problem.params) : '';
const enabled = Boolean(cfg?.uploadsEnabled);
el.start.disabled = !enabled || state.files.length === 0 || selectionProblem() !== null;
}
function uploadedBytes(job) {
return job.offsets.reduce((sum, offset) => sum + offset, 0) + job.chunkLoaded;
}
function renderProgress() {
const job = state.job;
if (!job) return;
const done = Math.min(uploadedBytes(job), job.totalBytes);
const share = job.totalBytes > 0 ? done / job.totalBytes : 1;
el.progressBar.value = Math.round(share * 1000);
el.progressPercent.textContent = `${Math.floor(share * 100)}\u00a0%`;
let detail = t('progressDetail', { done: formatBytes(done), total: formatBytes(job.totalBytes) });
if (state.phase === 'finishing') {
detail = t('finishing');
} else if (!job.retrying && job.speed > 0 && Date.now() - job.startedAt > 4000 && done < job.totalBytes) {
detail += ` · ${t('eta', { time: formatDuration((job.totalBytes - done) / job.speed) })}`;
}
el.progressDetail.textContent = detail;
const file = job.files[job.current];
el.progressFile.textContent =
job.files.length > 1 && file
? t('currentFile', { index: job.current + 1, count: job.files.length, name: file.name })
: (file?.name ?? '');
el.progressRetry.hidden = !job.retrying;
}
let progressQueued = false;
function queueProgress() {
if (progressQueued) return;
progressQueued = true;
requestAnimationFrame(() => {
progressQueued = false;
if (state.phase === 'uploading' || state.phase === 'finishing') renderProgress();
});
}
function shareUrl(id) {
return `${location.origin}/d/${id}`;
}
function renderDone() {
const result = state.result;
if (!result) return;
el.shareLink.value = shareUrl(result.id);
el.openLink.href = `/d/${result.id}`;
el.copyLink.textContent = Date.now() < state.copiedUntil ? t('copied') : t('copy');
el.doneInfo.textContent = t('doneInfo', {
files: t('files', result.count),
size: formatBytes(result.bytes),
date: formatDate(result.expiresAt),
});
}
/** Übersetzt einen Fehler in eine Meldung: { key, params }. */
function describeError(err, { duringUpload = false } = {}) {
if (err?.unreadable) return { key: 'unreadable', params: { name: err.unreadable } };
if (!(err instanceof ApiError)) return { key: 'generic', params: { code: '?' } };
if (err.status === 0) return { key: 'network' };
switch (err.code) {
case 'code_required':
return { key: 'codeMissing' };
case 'code_invalid':
return { key: 'codeInvalid' };
case 'rate_limited':
return { key: 'rateLimited', params: { time: formatDuration(Number(err.body.retryAfter) || 60) } };
case 'storage_full':
return { key: 'storageFull' };
case 'uploads_disabled':
return { key: 'uploadsDisabled' };
case 'too_large':
return {
key: 'tooLarge',
params: { size: formatBytes(totalBytes(state.files)), max: formatBytes(Number(err.body.maxBytes) || 0) },
};
case 'too_many_files':
return { key: 'tooMany', params: { count: state.files.length, max: Number(err.body.maxFiles) || 0 } };
default:
if (duringUpload && (err.status === 404 || err.status === 403)) return { key: 'gone' };
return { key: 'generic', params: { code: err.code ?? err.status } };
}
}
function renderError() {
const job = state.job;
if (!job?.error) return;
const message = describeError(job.error, { duringUpload: true });
el.uploadError.textContent = t(message.key, message.params);
// Fortsetzen ergibt nur Sinn, wenn der Transfer auf dem Server noch existiert.
el.resume.hidden = message.key === 'gone' || message.key === 'unreadable';
el.errorProgress.textContent = t('uploadedSoFar', {
done: formatBytes(Math.min(uploadedBytes(job), job.totalBytes)),
total: formatBytes(job.totalBytes),
});
}
function renderRecent() {
const list = loadRecent();
el.recent.hidden = list.length === 0;
el.recentError.hidden = !state.recentError;
el.recentError.textContent = state.recentError ? t(state.recentError.key) : '';
el.recentList.replaceChildren(
...list.map((entry) => {
const item = document.createElement('li');
const main = document.createElement('div');
main.className = 'recent-main';
const link = document.createElement('a');
link.className = 'recent-link';
link.href = `/d/${entry.id}`;
link.append(fileNameElement(entry.name));
if (entry.count > 1) {
const more = document.createElement('span');
more.className = 'recent-more';
more.textContent = t('more', entry.count - 1);
link.append(more);
}
const meta = document.createElement('div');
meta.className = 'recent-meta';
meta.textContent = t('recentMeta', { size: formatBytes(entry.bytes), date: formatDate(entry.expiresAt) });
main.append(link, meta);
const actions = document.createElement('div');
actions.className = 'recent-actions';
const copy = document.createElement('button');
copy.type = 'button';
copy.className = 'button button-secondary button-small';
copy.textContent = t('copyLink');
copy.addEventListener('click', async () => {
if (await copyText(shareUrl(entry.id))) {
copy.textContent = t('copied');
setTimeout(() => {
copy.textContent = t('copyLink');
}, 1800);
}
});
// Löschen braucht zwei Klicks: Der erste fragt nach, der zweite löscht.
const armed = state.deleteArmed === entry.id;
const remove = document.createElement('button');
remove.type = 'button';
remove.className = `button button-small ${armed ? 'button-danger' : 'button-secondary'}`;
remove.textContent = armed ? t('confirmDelete') : t('delete');
remove.dataset.deleteId = entry.id;
remove.addEventListener('click', () => (armed ? deleteRecent(entry, remove) : armDelete(entry)));
actions.append(copy, remove);
item.append(main, actions);
return item;
}),
);
}
function render() {
if (state.phase === 'select') {
show('select');
renderSelect();
} else if (state.phase === 'uploading' || state.phase === 'finishing') {
show('progress');
renderProgress();
} else if (state.phase === 'done') {
show('done');
renderDone();
} else {
show('error');
renderError();
}
renderRecent();
}
// -------------------------------------------------------------- Upload
function isRetryable(err) {
if (!(err instanceof ApiError)) return false;
if (err.status === 0 || err.status === 408 || err.status === 429) return true;
if (err.status === 409 && err.code === 'busy') return true;
return err.status >= 500 && err.status !== 507;
}
function retryDelay(err, attempt) {
if (err instanceof ApiError && err.status === 429) {
return Math.min((Number(err.body.retryAfter) || 30) * 1000, 120_000);
}
return Math.min(1000 * 2 ** attempt, 30_000);
}
function checkCancelled(job) {
if (job.cancelled) throw CANCELLED;
}
/** Wartet; ein Abbruch des Uploads beendet das Warten sofort. */
function sleep(job, ms) {
return new Promise((resolve, reject) => {
const timer = setTimeout(() => {
job.wake = null;
resolve();
}, ms);
job.wake = () => {
clearTimeout(timer);
job.wake = null;
reject(CANCELLED);
};
});
}
function setRetrying(job, retrying) {
if (job.retrying === retrying) return;
job.retrying = retrying;
queueProgress();
}
function noteSpeed(job) {
const now = Date.now();
const elapsed = now - job.sampleAt;
if (elapsed < 1000) return;
const bytes = uploadedBytes(job);
const current = ((bytes - job.sampleBytes) * 1000) / elapsed;
if (current >= 0) job.speed = job.speed > 0 ? job.speed * 0.7 + current * 0.3 : current;
job.sampleAt = now;
job.sampleBytes = bytes;
}
/** Schickt ein Stück einer Datei. Liefert den neuen Stand vom Server. */
function sendChunk(job, index, offset, blob) {
return new Promise((resolve, reject) => {
const xhr = new XMLHttpRequest();
let stalled = false;
let watchdog = null;
const arm = () => {
clearTimeout(watchdog);
watchdog = setTimeout(() => {
stalled = true;
xhr.abort();
}, STALL_MS);
};
const settle = () => {
clearTimeout(watchdog);
if (job.xhr === xhr) job.xhr = null;
};
xhr.open('PUT', `/api/transfers/${job.id}/files/${index}?offset=${offset}`);
xhr.setRequestHeader('Authorization', `Bearer ${job.uploadToken}`);
xhr.setRequestHeader('Content-Type', 'application/octet-stream');
xhr.responseType = 'json';
xhr.upload.onprogress = (event) => {
arm();
job.chunkLoaded = event.loaded;
noteSpeed(job);
queueProgress();
};
xhr.onload = () => {
settle();
const body = xhr.response;
if (xhr.status >= 200 && xhr.status < 300 && Number.isSafeInteger(body?.received)) resolve(body.received);
else reject(new ApiError(xhr.status, body));
};
xhr.onerror = () => {
settle();
reject(new ApiError(0, { error: 'network' }));
};
xhr.onabort = () => {
settle();
reject(job.cancelled && !stalled ? CANCELLED : new ApiError(0, { error: 'network' }));
};
job.xhr = xhr;
arm();
xhr.send(blob);
});
}
function checkedOffset(received, size) {
if (!Number.isSafeInteger(received) || received < 0 || received > size) {
throw new ApiError(500, { error: 'bad_offset' });
}
return received;
}
/** Fragt den Server, wie viel von jeder Datei schon angekommen ist. */
async function syncOffsets(job) {
const status = await api('GET', `/api/transfers/${job.id}/upload`, { token: job.uploadToken });
if (!Array.isArray(status?.files) || status.files.length !== job.files.length) {
throw new ApiError(500, { error: 'bad_status' });
}
job.offsets = status.files.map((file, i) => checkedOffset(file.received, job.files[i].size));
job.chunkLoaded = 0;
}
/** Schickt ein Stück und wiederholt es bei Verbindungsproblemen. */
async function sendChunkReliably(job, index, offset, blob) {
const size = job.files[index].size;
for (let attempt = 0; ; attempt += 1) {
checkCancelled(job);
try {
const received = await sendChunk(job, index, offset, blob);
setRetrying(job, false);
return checkedOffset(received, size);
} catch (err) {
job.chunkLoaded = 0;
if (err === CANCELLED) throw err;
// Der Server ist an einer anderen Stelle: dort weitermachen.
if (err instanceof ApiError && err.status === 409 && Number.isSafeInteger(err.body.received)) {
return checkedOffset(err.body.received, size);
}
if (!isRetryable(err) || attempt >= MAX_ATTEMPTS - 1) throw err;
// Liegt es an der Datei selbst (verschoben, geändert)? Dann hilft Warten nicht.
try {
await blob.slice(0, 1).arrayBuffer();
} catch {
throw Object.assign(new Error('unreadable'), { unreadable: job.files[index].name });
}
setRetrying(job, true);
await sleep(job, retryDelay(err, attempt));
try {
await syncOffsets(job);
if (job.offsets[index] !== offset) return job.offsets[index];
} catch (syncErr) {
if (!isRetryable(syncErr)) throw syncErr;
}
}
}
}
/** Wiederholt einen kurzen Aufruf bei Verbindungsproblemen. */
async function withRetries(job, call) {
for (let attempt = 0; ; attempt += 1) {
checkCancelled(job);
try {
const result = await call();
setRetrying(job, false);
return result;
} catch (err) {
if (!isRetryable(err) || attempt >= MAX_ATTEMPTS - 1) throw err;
setRetrying(job, true);
await sleep(job, retryDelay(err, attempt));
}
}
}
async function runUpload(job) {
state.phase = 'uploading';
job.error = null;
job.retrying = false;
job.sampleAt = Date.now();
job.sampleBytes = uploadedBytes(job);
render();
try {
if (job.needsSync) {
await withRetries(job, () => syncOffsets(job));
job.needsSync = false;
job.sampleBytes = uploadedBytes(job);
}
for (let index = 0; index < job.files.length; index += 1) {
const file = job.files[index];
job.current = index;
while (job.offsets[index] < file.size) {
checkCancelled(job);
const offset = job.offsets[index];
const blob = file.slice(offset, Math.min(offset + job.chunkBytes, file.size));
job.offsets[index] = await sendChunkReliably(job, index, offset, blob);
job.chunkLoaded = 0;
queueProgress();
}
}
state.phase = 'finishing';
renderProgress();
const done = await withRetries(job, () =>
api('POST', `/api/transfers/${job.id}/finish`, { token: job.uploadToken }),
);
checkCancelled(job);
state.result = {
id: job.id,
deleteToken: job.deleteToken,
expiresAt: done.expiresAt,
count: job.files.length,
bytes: job.totalBytes,
name: job.files[0].name,
};
saveRecent([state.result, ...loadRecent().filter((entry) => entry.id !== job.id)]);
state.job = null;
state.files = [];
state.phase = 'done';
render();
el.doneTitle.focus();
} catch (err) {
if (err === CANCELLED || job.cancelled) return;
job.error = err;
job.needsSync = true;
state.phase = 'error';
render();
el.errorTitle.focus();
}
}
async function startUpload() {
const cfg = state.config;
if (!cfg?.uploadsEnabled || state.files.length === 0 || selectionProblem()) return;
const code = el.code.value.trim();
if (cfg.codeRequired && code === '') {
state.formError = { key: 'codeMissing' };
render();
el.code.setAttribute('aria-invalid', 'true');
el.code.focus();
return;
}
const files = [...state.files];
const job = {
files,
totalBytes: totalBytes(files),
offsets: files.map(() => 0),
chunkLoaded: 0,
current: 0,
id: null,
uploadToken: null,
deleteToken: null,
chunkBytes: 0,
xhr: null,
wake: null,
cancelled: false,
retrying: false,
needsSync: false,
error: null,
speed: 0,
sampleAt: Date.now(),
sampleBytes: 0,
startedAt: Date.now(),
};
state.job = job;
state.formError = null;
state.phase = 'uploading';
render();
el.progressTitle.focus();
try {
const created = await api('POST', '/api/transfers', {
json: {
code: cfg.codeRequired ? code : undefined,
expiryDays: Number(el.expiry.value) || cfg.defaultExpiryDays,
files: files.map((file) => ({ name: file.name, size: file.size })),
},
});
if (cfg.codeRequired) rememberCode(code);
job.id = created.id;
job.uploadToken = created.uploadToken;
job.deleteToken = created.deleteToken;
job.chunkBytes = created.chunkBytes;
} catch (err) {
// Noch ist nichts hochgeladen: zurück zum Formular mit einer Meldung.
if (state.job !== job) return;
state.job = null;
state.phase = 'select';
state.formError = describeError(err);
render();
if (err instanceof ApiError && (err.code === 'code_invalid' || err.code === 'code_required')) {
if (err.code === 'code_invalid') forgetCode();
el.code.setAttribute('aria-invalid', 'true');
el.code.focus();
el.code.select();
}
return;
}
if (job.cancelled) {
discardOnServer(job);
return;
}
await runUpload(job);
}
function discardOnServer(job) {
if (!job.id) return;
api('DELETE', `/api/transfers/${job.id}`, { token: job.deleteToken }).catch(() => {
// Nicht schlimm: Angefangene Uploads räumt der Server später selbst weg.
});
}
/** Bricht den laufenden oder unterbrochenen Upload ab und verwirft ihn. */
function cancelUpload() {
const job = state.job;
if (!job) return;
job.cancelled = true;
job.xhr?.abort();
job.wake?.();
discardOnServer(job);
state.job = null;
state.phase = 'select';
render();
el.start.focus();
}
let disarmTimer = null;
/** Erster Klick auf „Löschen“: Der Knopf fragt für ein paar Sekunden nach. */
function armDelete(entry) {
clearTimeout(disarmTimer);
state.deleteArmed = entry.id;
state.recentError = null;
renderRecent();
el.recentList.querySelector(`[data-delete-id="${entry.id}"]`)?.focus();
disarmTimer = setTimeout(() => {
state.deleteArmed = null;
renderRecent();
}, 5000);
}
async function deleteRecent(entry, button) {
clearTimeout(disarmTimer);
button.disabled = true;
state.deleteArmed = null;
try {
await api('DELETE', `/api/transfers/${entry.id}`, { token: entry.deleteToken });
} catch (err) {
// 404/403: Der Transfer ist schon weg – dann nur aus der Liste nehmen.
if (!(err instanceof ApiError) || (err.status !== 404 && err.status !== 403)) {
state.recentError = { key: 'deleteFailed' };
renderRecent();
return;
}
}
saveRecent(loadRecent().filter((item) => item.id !== entry.id));
if (state.phase === 'done' && state.result?.id === entry.id) {
state.result = null;
state.phase = 'select';
}
render();
}
// ----------------------------------------------------------- Ereignisse
el.fileInput.addEventListener('change', () => {
addFiles(el.fileInput.files);
el.fileInput.value = '';
});
el.clearFiles.addEventListener('click', () => {
state.files = [];
state.formError = null;
render();
});
// Die ganze Seite nimmt Dateien an, damit ein danebengezogenes Bild nicht
// versehentlich im Browser geöffnet wird.
let dragDepth = 0;
const hasFiles = (event) => [...(event.dataTransfer?.types ?? [])].includes('Files');
window.addEventListener('dragenter', (event) => {
if (!hasFiles(event)) return;
event.preventDefault();
dragDepth += 1;
if (state.phase === 'select') el.dropzone.classList.add('is-dragover');
});
window.addEventListener('dragover', (event) => {
if (!hasFiles(event)) return;
event.preventDefault();
event.dataTransfer.dropEffect = state.phase === 'select' ? 'copy' : 'none';
});
window.addEventListener('dragleave', (event) => {
if (!hasFiles(event)) return;
dragDepth = Math.max(0, dragDepth - 1);
if (dragDepth === 0) el.dropzone.classList.remove('is-dragover');
});
window.addEventListener('drop', (event) => {
if (!hasFiles(event)) return;
event.preventDefault();
dragDepth = 0;
el.dropzone.classList.remove('is-dragover');
if (state.phase !== 'select') return;
const { files, skippedFolder } = filesFromDrop(event.dataTransfer);
addFiles(files, { skippedFolder });
});
// Dateien aus der Zwischenablage (z. B. ein kopiertes Bildschirmfoto)
document.addEventListener('paste', (event) => {
const files = event.clipboardData?.files;
if (state.phase !== 'select' || !files || files.length === 0) return;
event.preventDefault();
addFiles(files);
});
el.code.addEventListener('input', () => {
el.code.removeAttribute('aria-invalid');
if (state.formError && ['codeMissing', 'codeInvalid'].includes(state.formError.key)) {
state.formError = null;
renderSelect();
}
});
el.stepSelect.addEventListener('submit', (event) => {
event.preventDefault();
startUpload();
});
el.cancel.addEventListener('click', cancelUpload);
el.discard.addEventListener('click', cancelUpload);
el.resume.addEventListener('click', () => {
if (state.job && state.phase === 'error') {
runUpload(state.job);
el.progressTitle.focus();
}
});
el.copyLink.addEventListener('click', async () => {
if (await copyText(el.shareLink.value)) {
state.copiedUntil = Date.now() + 2000;
renderDone();
setTimeout(() => {
if (state.phase === 'done') renderDone();
}, 2100);
} else {
el.shareLink.focus();
el.shareLink.select();
}
});
el.shareLink.addEventListener('focus', () => el.shareLink.select());
el.newUpload.addEventListener('click', () => {
state.result = null;
state.phase = 'select';
render();
el.dropzone.scrollIntoView({ block: 'nearest' });
});
window.addEventListener('beforeunload', (event) => {
if (state.phase === 'uploading' || state.phase === 'finishing') {
event.preventDefault();
event.returnValue = '';
}
});
onLangChange(render);
// ---------------------------------------------------------------- Start
const savedCode = storageGet(localStorage, 'uploadCode');
if (savedCode) {
el.code.value = savedCode;
el.rememberCode.checked = true;
} else {
el.code.value = storageGet(sessionStorage, 'uploadCode') ?? '';
}
render();
try {
state.config = await api('GET', '/api/config');
if (!state.config.uploadsEnabled) state.formError = { key: 'uploadsDisabled' };
} catch (err) {
state.formError = describeError(err);
}
render();