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:
1 parent
51ff6f9d40
commit
278194b707
31 files changed
+5099
No files matched your search
@@ -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;
|
||||
}
|
||||
@@ -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();
|
||||
@@ -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;
|
||||
})();
|
||||
@@ -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();
|
||||
Reference in new issue
Block a user