Dateitransfer: Server, Seiten, Tests und Docker-Dateien

Hochladen mit Upload-Code, kurzer Link zum Herunterladen, automatische
Löschung nach Ablauf der Frist. Node.js ohne zusätzliche Pakete.

- src/: HTTP-Server, Ablage auf der Platte, Zugriffsbegrenzung
- pages/, public/: Oberfläche in Deutsch und Englisch
- tools/: Transfers auflisten und löschen
- test/: 34 automatische Tests
- Dockerfile, compose.yaml: Betrieb als Container auf 127.0.0.1:8083

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
DerSchandfleckandClaude Fable 5.2 committed 2026-11-16 00:59:41 +01:00
1 parent 51ff6f9d40
commit 278194b707
31 files changed
+5099

No files matched your search

+179
View File
@@ -0,0 +1,179 @@
// Gemeinsames für alle Seiten: Sprachumschalter, Formatierung, Aufrufe an den Server.
const root = document.documentElement;
const siteName = document.querySelector('meta[name="application-name"]')?.content ?? '';
// ---------------------------------------------------------------- Sprache
export function getLang() {
return root.lang === 'en' ? 'en' : 'de';
}
const listeners = new Set();
/** Meldet eine Funktion an, die nach einem Sprachwechsel neu zeichnet. */
export function onLangChange(fn) {
listeners.add(fn);
}
function applyLang() {
const lang = getLang();
for (const button of document.querySelectorAll('[data-set-lang]')) {
button.setAttribute('aria-pressed', String(button.dataset.setLang === lang));
}
const title = lang === 'en' ? root.dataset.titleEn : root.dataset.titleDe;
if (title) document.title = siteName ? `${title} – ${siteName}` : title;
}
export function setLang(lang) {
root.lang = lang === 'en' ? 'en' : 'de';
try {
localStorage.setItem('lang', root.lang);
} catch {
// Ohne Speicher gilt die Wahl nur für diese Seite.
}
applyLang();
for (const fn of listeners) fn(root.lang);
}
for (const button of document.querySelectorAll('[data-set-lang]')) {
button.addEventListener('click', () => setLang(button.dataset.setLang));
}
applyLang();
/** Setzt Platzhalter wie {name} in einen Text ein. */
export function fill(template, params = {}) {
return template.replace(/\{(\w+)\}/g, (match, key) => (key in params ? String(params[key]) : match));
}
// ----------------------------------------------------------- Formatierung
function locale() {
if (getLang() === 'de') return 'de-DE';
return /^en\b/i.test(navigator.language ?? '') ? navigator.language : 'en-GB';
}
const UNITS = ['B', 'KB', 'MB', 'GB', 'TB'];
/** 1536 -> "1,5 KB" (1 KB = 1024 B, wie es der Server rechnet). */
export function formatBytes(bytes) {
let value = bytes;
let unit = 0;
const digits = () => (unit === 0 || value >= 100 ? 0 : 1);
while (unit < UNITS.length - 1 && Number(value.toFixed(digits())) >= 1024) {
value /= 1024;
unit += 1;
}
const number = new Intl.NumberFormat(locale(), { maximumFractionDigits: digits() }).format(value);
return `${number}\u00a0${UNITS[unit]}`;
}
export function formatDate(timestamp) {
return new Intl.DateTimeFormat(locale(), { dateStyle: 'long', timeStyle: 'short' }).format(new Date(timestamp));
}
/** Grobe Dauer für Restzeiten: "20 Sekunden", "3 Minuten", "1 Std. 10 Min.". */
export function formatDuration(seconds) {
const de = getLang() === 'de';
if (seconds < 50) {
const s = Math.max(5, Math.round(seconds / 5) * 5);
return de ? `${s} Sekunden` : `${s} seconds`;
}
const minutes = Math.round(seconds / 60);
if (minutes < 60) {
if (minutes === 1) return de ? '1 Minute' : '1 minute';
return de ? `${minutes} Minuten` : `${minutes} minutes`;
}
const hours = Math.floor(minutes / 60);
const rest = minutes % 60;
return de ? `${hours} Std. ${rest} Min.` : `${hours} h ${rest} min`;
}
/**
* Baut die Anzeige eines Dateinamens: Ist er zu lang, wird in der Mitte
* gekürzt, die Endung bleibt immer sichtbar.
*/
export function fileNameElement(name) {
const dot = name.lastIndexOf('.');
const hasExt = dot > 0 && name.length - dot <= 11;
const wrap = document.createElement('span');
wrap.className = 'file-name';
wrap.title = name;
const stem = document.createElement('span');
stem.className = 'file-stem';
stem.textContent = hasExt ? name.slice(0, dot) : name;
wrap.append(stem);
if (hasExt) {
const ext = document.createElement('span');
ext.className = 'file-ext';
ext.textContent = name.slice(dot);
wrap.append(ext);
}
return wrap;
}
// ------------------------------------------------------------------ Server
/** Fehler eines Aufrufs. status 0 heißt: Server gar nicht erreicht. */
export class ApiError extends Error {
constructor(status, body) {
super(body?.error ?? `http_${status}`);
this.name = 'ApiError';
this.status = status;
this.code = body?.error ?? null;
this.body = body ?? {};
}
}
export async function api(method, url, { json, token } = {}) {
const headers = {};
if (json !== undefined) headers['Content-Type'] = 'application/json';
if (token) headers.Authorization = `Bearer ${token}`;
let response;
try {
response = await fetch(url, {
method,
headers,
body: json === undefined ? undefined : JSON.stringify(json),
cache: 'no-store',
});
} catch {
throw new ApiError(0, { error: 'network' });
}
let body = null;
if (response.status !== 204) {
try {
body = await response.json();
} catch {
body = null;
}
}
if (!response.ok) throw new ApiError(response.status, body);
return body;
}
/** Kopiert Text in die Zwischenablage; gibt zurück, ob es geklappt hat. */
export async function copyText(text) {
try {
await navigator.clipboard.writeText(text);
return true;
} catch {
// Ältere Browser oder fehlende Berechtigung: klassischer Weg.
}
const area = document.createElement('textarea');
area.value = text;
area.readOnly = true;
area.className = 'visually-hidden';
document.body.append(area);
area.select();
let ok = false;
try {
ok = document.execCommand('copy');
} catch {
ok = false;
}
area.remove();
return ok;
}
+100
View File
@@ -0,0 +1,100 @@
// Download-Seite: zeigt die Dateien eines Transfers.
import { ApiError, api, fileNameElement, fill, formatBytes, formatDate, formatDuration, getLang, onLangChange } from './common.js';
const TEXT = {
de: {
title: (n) => (n === 1 ? '1 Datei zum Herunterladen' : `${n} Dateien zum Herunterladen`),
meta: '{size} · verfügbar bis {date}',
metaTotal: 'Zusammen {size} · verfügbar bis {date}',
download: 'Herunterladen',
downloadName: '„{name}“ herunterladen',
network: 'Der Server ist nicht erreichbar. Prüf bitte deine Internetverbindung.',
rateLimited: 'Zu viele Anfragen. Bitte warte {time} und versuch es dann noch einmal.',
generic: 'Die Dateiliste konnte nicht geladen werden (Fehler {code}).',
},
en: {
title: (n) => (n === 1 ? '1 file to download' : `${n} files to download`),
meta: '{size} · available until {date}',
metaTotal: '{size} in total · available until {date}',
download: 'Download',
downloadName: 'Download “{name}”',
network: 'The server cannot be reached. Please check your internet connection.',
rateLimited: 'Too many requests. Please wait {time} and try again.',
generic: 'The file list could not be loaded (error {code}).',
},
};
function t(key, params) {
const value = TEXT[getLang()][key];
return typeof value === 'function' ? value(params) : fill(value, params);
}
const root = document.documentElement;
const el = {
title: document.getElementById('dl-title'),
meta: document.getElementById('dl-meta'),
list: document.getElementById('dl-list'),
errorText: document.getElementById('dl-error-text'),
retry: document.getElementById('dl-retry'),
};
const id = (location.pathname.split('/')[2] ?? '').toLowerCase();
let transfer = null;
let failure = null;
function render() {
if (root.dataset.state === 'ready' && transfer) {
const count = transfer.files.length;
el.title.textContent = t('title', count);
el.meta.textContent = t(count === 1 ? 'meta' : 'metaTotal', {
size: formatBytes(transfer.totalBytes),
date: formatDate(transfer.expiresAt),
});
el.list.replaceChildren(
...transfer.files.map((file, index) => {
const item = document.createElement('li');
const size = document.createElement('span');
size.className = 'file-size';
size.textContent = formatBytes(file.size);
const link = document.createElement('a');
link.className = 'button button-secondary button-small';
link.href = `/d/${transfer.id}/${index}`;
link.download = file.name;
link.textContent = t('download');
link.setAttribute('aria-label', t('downloadName', { name: file.name }));
item.append(fileNameElement(file.name), size, link);
return item;
}),
);
} else if (root.dataset.state === 'error' && failure) {
if (failure instanceof ApiError && failure.status === 0) {
el.errorText.textContent = t('network');
} else if (failure instanceof ApiError && failure.status === 429) {
el.errorText.textContent = t('rateLimited', { time: formatDuration(Number(failure.body.retryAfter) || 60) });
} else {
el.errorText.textContent = t('generic', { code: failure?.code ?? failure?.status ?? '?' });
}
}
}
async function load() {
// Der Server hat schon mitgeteilt, dass es den Link nicht gibt.
if (root.dataset.state === 'missing') return;
root.dataset.state = 'loading';
try {
transfer = await api('GET', `/api/transfers/${encodeURIComponent(id)}`);
root.dataset.state = 'ready';
} catch (err) {
if (err instanceof ApiError && err.status === 404) {
root.dataset.state = 'missing';
} else {
failure = err;
root.dataset.state = 'error';
}
}
render();
}
el.retry.addEventListener('click', load);
onLangChange(render);
await load();
+15
View File
@@ -0,0 +1,15 @@
// Stellt die Sprache ein, bevor die Seite gezeichnet wird (deshalb ohne "defer"
// im <head>). Reihenfolge: gespeicherte Wahl, sonst Browsersprache, sonst Deutsch.
(function () {
var lang = null;
try {
lang = localStorage.getItem('lang');
} catch (e) {
// Speicher gesperrt (z. B. privates Fenster): dann entscheidet der Browser.
}
if (lang !== 'de' && lang !== 'en') {
var preferred = (navigator.languages && navigator.languages[0]) || navigator.language || 'de';
lang = /^de\b/i.test(preferred) ? 'de' : 'en';
}
document.documentElement.lang = lang;
})();
+983
View File
@@ -0,0 +1,983 @@
// 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',
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',
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'),
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;
el.limitHint.textContent = cfg ? t('limitHint', { size: formatBytes(cfg.maxTransferBytes) }) : '';
// 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.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();