Files
SHiNE-server/shine-UI/js/services/attachment-format.js
T

491 lines
18 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { openMediaViewer } from '../components/media-viewer.js';
import { buildArweaveDataUrl, sha256HexFromArrayBuffer, validateArweaveTxId, validateSha256Hex } from './arweave-file-service.js';
import { resolvePublicFileUrl } from './public-file-service.js';
const ATTACH_BLOCK_RE = /^<(?:SHiNE|S):(attach|att);([^>]*)>\n?/u;
export const MAX_MESSAGE_ATTACHMENTS = 10;
const RECENT_UNAVAILABLE_MS = 20 * 60 * 1000;
const IMAGE_EXTENSIONS = new Set(['apng', 'avif', 'bmp', 'gif', 'jpeg', 'jpg', 'png', 'svg', 'webp']);
const VIDEO_EXTENSIONS = new Set(['avi', 'm4v', 'mkv', 'mov', 'mp4', 'mpeg', 'mpg', 'ogg', 'ogv', 'webm']);
export function escapeHtml(text) {
return String(text || '')
.replaceAll('&', '&amp;')
.replaceAll('<', '&lt;')
.replaceAll('>', '&gt;')
.replaceAll('"', '&quot;')
.replaceAll("'", '&#39;');
}
export function formatBytes(bytes) {
const value = Number(bytes || 0);
if (!Number.isFinite(value) || value <= 0) return '0 B';
if (value < 1024) return `${value} B`;
if (value < 1024 * 1024) return `${(value / 1024).toFixed(1)} KB`;
return `${(value / (1024 * 1024)).toFixed(2)} MB`;
}
function normalizeName(name) {
const clean = String(name || 'file')
.replace(/[\u0000-\u001f\u007f]/g, '')
.replace(/[\\/]/g, '_')
.trim();
return clean || 'file';
}
export function normalizeAttachment(input = {}) {
const txId = String(input.ar || input.txId || '').trim();
const sha256Hex = String(input.sha256 || input.sha256Hex || '').trim().toLowerCase();
const size = Number(input.sz || input.size || input.sizeBytes || 0);
const name = normalizeName(input.nm || input.name || input.fileName || 'file');
if (txId && !validateArweaveTxId(txId)) throw new Error('Некорректный Transaction ID Arweave.');
if (!validateSha256Hex(sha256Hex)) throw new Error('Некорректный SHA-256 файла.');
if (!Number.isInteger(size) || size <= 0) throw new Error('Некорректный размер файла.');
const out = {
v: 1,
name,
size,
sha256: sha256Hex,
ar: txId,
uploadedAtMs: Number(input.uploadedAtMs || 0) || Date.now(),
};
return out;
}
export function buildAttachmentBlock(attachment) {
const item = normalizeAttachment(attachment);
const encodedName = encodeURIComponent(item.name);
const arPart = item.ar ? `;ar=${item.ar}` : '';
return `<S:att;v=1;nm=${encodedName};sz=${item.size};sha256=${item.sha256}${arPart}>`;
}
export function composeMessageWithAttachments(text, attachments = []) {
const cleanText = String(text || '').trim();
const rows = (Array.isArray(attachments) ? attachments : [])
.slice(0, MAX_MESSAGE_ATTACHMENTS)
.map(buildAttachmentBlock);
if (!rows.length) return cleanText;
return `${rows.join('\n')}${cleanText ? `\n${cleanText}` : ''}`;
}
function parseFields(rawFields) {
const out = {};
String(rawFields || '').split(';').forEach((part) => {
const eq = part.indexOf('=');
if (eq <= 0) return;
const key = part.slice(0, eq).trim();
const value = part.slice(eq + 1).trim();
if (key) out[key] = value;
});
return out;
}
export function parseMessageAttachments(rawText) {
let rest = String(rawText || '');
const attachments = [];
while (true) {
const match = rest.match(ATTACH_BLOCK_RE);
if (!match) break;
const fields = parseFields(match[2]);
try {
const version = Number(fields.v || 0);
if (version !== 1 && version !== 2) {
throw new Error('unsupported attachment version');
}
attachments.push(normalizeAttachment({
nm: decodeURIComponent(String(fields.nm || fields.name || 'file')),
sz: fields.sz || fields.size,
sha256: fields.sha256,
ar: fields.ar,
}));
} catch {
// Битый attach-блок скрываем из UI, но не ломаем отображение текста.
}
rest = rest.slice(match[0].length);
}
return {
attachments,
text: rest.replace(/^\n+/u, ''),
};
}
export function getAttachmentExtension(name) {
const clean = String(name || '').trim().toLowerCase();
const dot = clean.lastIndexOf('.');
if (dot < 0 || dot === clean.length - 1) return '';
return clean.slice(dot + 1).replace(/[^a-z0-9]/g, '');
}
export function getAttachmentKind(attachment = {}) {
const ext = getAttachmentExtension(attachment.name);
if (IMAGE_EXTENSIONS.has(ext)) return 'image';
if (VIDEO_EXTENSIONS.has(ext)) return 'video';
return 'file';
}
function isRecentMessage(messageTimestampMs) {
const ts = Number(messageTimestampMs || 0);
if (!Number.isFinite(ts) || ts <= 0) return false;
return Date.now() - ts < RECENT_UNAVAILABLE_MS;
}
function attachmentStorage(item) {
return item?.ar ? 'arweave' : 'server';
}
function buildCurrentServerDebugUrl(item) {
const sha = String(item?.sha256 || '').trim().toLowerCase();
if (!validateSha256Hex(sha)) return '';
return `${window.location.origin.replace(/\/$/, '')}/files/${sha}`;
}
function createUnavailableBlock(messageTimestampMs, storage = 'arweave', detail = null) {
const block = document.createElement('div');
block.className = 'message-attachment-unavailable';
if (storage === 'server') {
block.textContent = 'Файл недоступен на сервере доступа автора.';
} else {
block.textContent = isRecentMessage(messageTimestampMs)
? 'Скорее всего файл недоступен, потому что сообщение было создано недавно и файл ещё не распространился в Arweave. Попробуйте повторить через несколько минут.'
: 'Файл недоступен.';
}
if (detail) {
const debug = document.createElement('pre');
debug.className = 'message-attachment-debug';
debug.textContent = [
'DEBUG server attachment',
detail.name ? `name: ${detail.name}` : '',
detail.sha256 ? `sha256: ${detail.sha256}` : '',
detail.url ? `url: ${detail.url}` : '',
detail.error ? `error: ${detail.error}` : '',
].filter(Boolean).join('\n');
block.append(debug);
}
return block;
}
function stopVideos(root) {
root.querySelectorAll('video').forEach((video) => {
try {
video.pause();
video.currentTime = 0;
} catch {
// Если браузер не даёт управлять видео, просто продолжаем перелистывание.
}
});
}
function replaceWithUnavailable(slide, messageTimestampMs, storage = 'arweave', detail = null) {
if (!slide || slide.dataset.unavailable === '1') return;
slide.dataset.unavailable = '1';
slide.replaceChildren(createUnavailableBlock(messageTimestampMs, storage, detail));
}
function createFileCard({ item, url, messageTimestampMs, slide }) {
const card = document.createElement('div');
card.className = 'message-attachment-file-card';
card.role = 'button';
card.tabIndex = 0;
card.title = 'Скачать файл';
card.innerHTML = `
<div class="message-attachment-file-ext">Файл</div>
<div class="message-attachment-file-main">
<div class="message-attachment-name">${escapeHtml(item.name)}</div>
<div class="message-attachment-meta">${escapeHtml(formatBytes(item.size))}</div>
</div>
`;
const openFile = () => window.open(url, '_blank', 'noopener');
card.addEventListener('click', (event) => {
event.stopPropagation();
openFile();
});
card.addEventListener('keydown', (event) => {
if (event.key !== 'Enter' && event.key !== ' ') return;
event.preventDefault();
openFile();
});
void fetch(url, { method: 'HEAD', cache: 'no-store' })
.then((response) => {
if (!response.ok) replaceWithUnavailable(slide, messageTimestampMs, attachmentStorage(item));
})
.catch(() => replaceWithUnavailable(slide, messageTimestampMs, attachmentStorage(item)));
return card;
}
function createMediaSlide({ item, url, kind, messageTimestampMs, slide, onOpen }) {
const frame = document.createElement('div');
frame.className = `message-attachment-media-frame message-attachment-media-frame--${kind}`;
frame.role = 'button';
frame.tabIndex = 0;
frame.title = kind === 'video' ? 'Открыть видео' : 'Открыть изображение';
frame.addEventListener('click', (event) => {
event.stopPropagation();
onOpen?.();
});
frame.addEventListener('keydown', (event) => {
if (event.key !== 'Enter' && event.key !== ' ') return;
event.preventDefault();
onOpen?.();
});
const bindImageLayout = (img) => {
img.addEventListener('load', () => {
frame.classList.add('is-loaded');
const naturalWidth = Number(img.naturalWidth || 0);
const naturalHeight = Number(img.naturalHeight || 0);
const isLandscape = naturalWidth > 0 && naturalHeight > 0 && naturalWidth > naturalHeight;
img.classList.toggle('is-landscape', isLandscape);
frame.classList.toggle('is-landscape', isLandscape);
slide.classList.toggle('has-landscape-media', isLandscape);
slide.parentElement?.classList.toggle('has-landscape-media', isLandscape);
}, { once: true });
};
if (kind === 'image') {
const img = document.createElement('img');
img.className = 'message-attachment-media';
img.src = url;
img.alt = item.name;
img.loading = 'lazy';
bindImageLayout(img);
img.addEventListener('error', () => replaceWithUnavailable(slide, messageTimestampMs, attachmentStorage(item)), { once: true });
frame.append(img);
} else {
const video = document.createElement('video');
video.className = 'message-attachment-media';
video.src = url;
video.preload = 'metadata';
video.muted = true;
video.playsInline = true;
video.addEventListener('error', () => replaceWithUnavailable(slide, messageTimestampMs, attachmentStorage(item)), { once: true });
video.addEventListener('loadeddata', () => frame.classList.add('is-loaded'), { once: true });
const play = document.createElement('span');
play.className = 'message-attachment-play';
play.textContent = '▶';
frame.append(video, play);
}
return frame;
}
function mimeTypeForAttachment(item, kind) {
const ext = getAttachmentExtension(item?.name);
if (kind === 'image') {
if (ext === 'svg') return 'image/svg+xml';
if (ext === 'jpg' || ext === 'jpeg') return 'image/jpeg';
if (ext === 'png') return 'image/png';
if (ext === 'gif') return 'image/gif';
if (ext === 'webp') return 'image/webp';
if (ext === 'avif') return 'image/avif';
if (ext === 'bmp') return 'image/bmp';
if (ext === 'apng') return 'image/apng';
return 'application/octet-stream';
}
if (kind === 'video') {
if (ext === 'mp4' || ext === 'm4v') return 'video/mp4';
if (ext === 'webm') return 'video/webm';
if (ext === 'ogg' || ext === 'ogv') return 'video/ogg';
if (ext === 'mov') return 'video/quicktime';
if (ext === 'mpeg' || ext === 'mpg') return 'video/mpeg';
if (ext === 'avi') return 'video/x-msvideo';
if (ext === 'mkv') return 'video/x-matroska';
}
return 'application/octet-stream';
}
const attachmentObjectUrls = new Map();
let attachmentObjectUrlObserver = null;
function registerAttachmentObjectUrl(owner, url) {
if (!owner || !url) return;
if (!owner.isConnected) {
URL.revokeObjectURL(url);
return;
}
const urls = attachmentObjectUrls.get(owner) || new Set();
urls.add(url);
attachmentObjectUrls.set(owner, urls);
if (attachmentObjectUrlObserver) return;
attachmentObjectUrlObserver = new MutationObserver(() => {
attachmentObjectUrls.forEach((ownedUrls, element) => {
if (element.isConnected) return;
ownedUrls.forEach((ownedUrl) => URL.revokeObjectURL(ownedUrl));
attachmentObjectUrls.delete(element);
});
if (!attachmentObjectUrls.size) {
attachmentObjectUrlObserver.disconnect();
attachmentObjectUrlObserver = null;
}
});
attachmentObjectUrlObserver.observe(document.documentElement, { childList: true, subtree: true });
}
async function resolveAttachmentDisplayUrl(item, options = {}) {
if (item.ar) {
return { url: buildArweaveDataUrl({ gateway: options.gateway, txId: item.ar }), objectUrl: false };
}
const serverUrl = await resolvePublicFileUrl({
sha256: item.sha256,
authorLogin: options.authorLogin,
solanaEndpoint: options.solanaEndpoint,
fallbackServerLogin: options.fallbackServerLogin,
});
const kind = getAttachmentKind(item);
if (kind === 'file') return { url: serverUrl, objectUrl: false };
// /files хранит только байты и SHA-256. Для media тип задаёт клиент по имени из S:att.
const response = await fetch(serverUrl);
if (!response.ok) throw new Error(`HTTP ${response.status} ${serverUrl}`);
const buffer = await response.arrayBuffer();
const actualSha = await sha256HexFromArrayBuffer(buffer);
if (actualSha !== item.sha256) throw new Error(`SHA-256 скачанного файла не совпал с блокчейном: ${actualSha} != ${item.sha256} (${serverUrl})`);
const blob = new Blob([buffer], { type: mimeTypeForAttachment(item, kind) });
return { url: URL.createObjectURL(blob), sourceUrl: serverUrl, objectUrl: true };
}
export function createAttachmentCarouselElement(attachments = [], {
gateway = '',
messageTimestampMs = 0,
authorLogin = '',
solanaEndpoint = '',
fallbackServerLogin = '',
} = {}) {
const items = (Array.isArray(attachments) ? attachments : [])
.slice(0, MAX_MESSAGE_ATTACHMENTS)
.map((raw) => {
try {
return normalizeAttachment(raw);
} catch {
return null;
}
})
.filter(Boolean);
const wrap = document.createElement('div');
wrap.className = 'message-attachments message-attachment-carousel';
wrap.addEventListener('click', (event) => event.stopPropagation());
if (!items.length) return wrap;
let index = 0;
let pointerStartX = 0;
let renderGeneration = 0;
const resolved = new Map();
const pending = new Map();
const options = { gateway, authorLogin, solanaEndpoint, fallbackServerLogin };
const viewport = document.createElement('div');
viewport.className = 'message-attachment-carousel-viewport';
const slide = document.createElement('div');
slide.className = 'message-attachment-slide';
const prev = document.createElement('button');
prev.type = 'button';
prev.className = 'ui-button message-attachment-arrow message-attachment-arrow--prev';
prev.textContent = '‹';
prev.setAttribute('aria-label', 'Предыдущее вложение');
const next = document.createElement('button');
next.type = 'button';
next.className = 'ui-button message-attachment-arrow message-attachment-arrow--next';
next.textContent = '›';
next.setAttribute('aria-label', 'Следующее вложение');
const counter = document.createElement('div');
counter.className = 'message-attachment-counter';
wrap.classList.toggle('has-single-attachment', items.length <= 1);
const getResolved = (itemIndex) => {
if (resolved.has(itemIndex)) return Promise.resolve(resolved.get(itemIndex));
if (pending.has(itemIndex)) return pending.get(itemIndex);
const promise = resolveAttachmentDisplayUrl(items[itemIndex], options)
.then((value) => {
resolved.set(itemIndex, value);
pending.delete(itemIndex);
if (value.objectUrl) registerAttachmentObjectUrl(wrap, value.url);
return value;
})
.catch((error) => {
pending.delete(itemIndex);
throw error;
});
pending.set(itemIndex, promise);
return promise;
};
const openViewer = (itemIndex) => {
const entries = items
.map((item, i) => {
const kind = getAttachmentKind(item);
if (kind !== 'image' && kind !== 'video') return null;
if (item.ar) return { i, kind, url: buildArweaveDataUrl({ gateway, txId: item.ar }), name: item.name };
const cached = resolved.get(i);
return cached ? { i, kind, url: cached.url, name: item.name } : null;
})
.filter(Boolean);
const viewerIndex = Math.max(0, entries.findIndex((entry) => entry.i === itemIndex));
if (entries.length) openMediaViewer(entries, viewerIndex);
};
const render = () => {
const generation = ++renderGeneration;
stopVideos(wrap);
const item = items[index];
const currentIndex = index;
const kind = getAttachmentKind(item);
viewport.classList.remove('has-landscape-media');
slide.className = 'message-attachment-slide';
slide.dataset.unavailable = '0';
slide.replaceChildren();
const loading = document.createElement('div');
loading.className = 'message-attachment-unavailable';
loading.textContent = 'Загружаем файл…';
slide.append(loading);
void getResolved(currentIndex)
.then(({ url }) => {
if (generation !== renderGeneration || currentIndex !== index || !wrap.isConnected) return;
slide.replaceChildren(kind === 'file'
? createFileCard({ item, url, messageTimestampMs, slide })
: createMediaSlide({ item, url, kind, messageTimestampMs, slide, onOpen: () => openViewer(currentIndex) }));
})
.catch((error) => {
if (generation !== renderGeneration || currentIndex !== index || !wrap.isConnected) return;
replaceWithUnavailable(slide, messageTimestampMs, attachmentStorage(item), {
name: item?.name || '',
sha256: item?.sha256 || '',
url: buildCurrentServerDebugUrl(item) || error?.message?.match(/https?:\/\/\S+/)?.[0] || '',
error: error?.message || String(error || ''),
});
});
prev.hidden = items.length <= 1 || index <= 0;
next.hidden = items.length <= 1 || index >= items.length - 1;
counter.hidden = items.length <= 1;
counter.textContent = items.length > 1 ? `${index + 1} из ${items.length}` : '';
};
const move = (delta) => {
const nextIndex = Math.max(0, Math.min(items.length - 1, index + delta));
if (nextIndex === index) return;
index = nextIndex;
render();
};
prev.addEventListener('click', (event) => { event.stopPropagation(); move(-1); });
next.addEventListener('click', (event) => { event.stopPropagation(); move(1); });
viewport.addEventListener('pointerdown', (event) => { pointerStartX = event.clientX; });
viewport.addEventListener('pointerup', (event) => {
const dx = event.clientX - pointerStartX;
if (Math.abs(dx) >= 40) move(dx < 0 ? 1 : -1);
});
viewport.append(slide, prev, next);
wrap.append(viewport, counter);
render();
return wrap;
}
export function createAttachmentListElement(attachments = [], options = {}) {
return createAttachmentCarouselElement(attachments, options);
}