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>
1003 lines
32 KiB
JavaScript
1003 lines
32 KiB
JavaScript
// 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();
|