ninoandClaude Opus 5.5
be19e35156
Los EPUB se convierten en el servidor en una lista cerrada de bloques y el navegador los maqueta en páginas según su pantalla. Cada página se dibuja en un canvas y llega al lector como una imagen más, así que hoja, sombra, hendidura y sonido no cambian. El libro se lee de corrido: cada capítulo empieza debajo del anterior y el progreso se sigue guardando por capítulo. El catálogo sale del OPDS de gutenberg.org, con reintentos. Ajustes: mostrar solo manga, solo libros o ambos, por usuario. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
452 lines
22 KiB
JavaScript
452 lines
22 KiB
JavaScript
// Libros de texto (EPUB). El EPUB se convierte aquí en una lista cerrada de bloques: al navegador nunca llega
|
||
// HTML del libro, y es él quien maqueta los bloques en páginas según su pantalla (ver maquetado en app.js).
|
||
// bloque: { k: 'p' | 'q' | 'h' | 'hr' | 'img', l?: nivel de título, n?: imagen, c?: centrado, v?: verso,
|
||
// r?: [[texto, estilo]] } estilo: 1 cursiva, 2 negrita (sumables)
|
||
// Fuente en línea: Project Gutenberg, con su propio catálogo OPDS. IDs: libro "gb~<n>", capítulo "gb~<n>~<i>".
|
||
// Título, autores e idioma salen del propio EPUB, así que abrir un libro solo necesita el archivo.
|
||
// En <DATA_DIR>/books/ se guardan el EPUB (de ahí salen las imágenes) y el libro ya convertido.
|
||
import fs from 'node:fs'
|
||
import zlib from 'node:zlib'
|
||
import path from 'node:path'
|
||
import { readZipIndex, readCbzEntry, imageType } from './cbz.js'
|
||
|
||
export const isBookId = id => /^(gb|ws|ub)~/.test(id || '')
|
||
const GUTENBERG = 'https://www.gutenberg.org'
|
||
const OPDS_PAGE = 25
|
||
// El buscador de Gutenberg filtra por el nombre del idioma, no por el código.
|
||
const LANG_NAMES = { es: 'spanish', en: 'english', fr: 'french', pt: 'portuguese', it: 'italian', de: 'german', ru: 'russian', ja: 'japanese', zh: 'chinese', ko: 'korean', ca: 'catalan', nl: 'dutch', pl: 'polish' }
|
||
const PARSER_VERSION = 2
|
||
const MAX_EPUB_BYTES = 100 * 1024 * 1024
|
||
const MAX_UNZIPPED_ENTRY = 64 * 1024 * 1024 // un XHTML o una imagen
|
||
const MAX_UNZIPPED_TOTAL = 512 * 1024 * 1024 // todo el libro: lo que pase de aquí es una ZIP bomb
|
||
const BOOK_IMAGE = /\.(jpe?g|png|gif|webp)$/i
|
||
|
||
const ENTITIES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ', mdash: '—', ndash: '–', hellip: '…', laquo: '«', raquo: '»', ldquo: '“', rdquo: '”', lsquo: '‘', rsquo: '’', iexcl: '¡', iquest: '¿', aacute: 'á', eacute: 'é', iacute: 'í', oacute: 'ó', uacute: 'ú', ntilde: 'ñ', uuml: 'ü', Aacute: 'Á', Eacute: 'É', Iacute: 'Í', Oacute: 'Ó', Uacute: 'Ú', Ntilde: 'Ñ', Uuml: 'Ü', agrave: 'à', egrave: 'è', igrave: 'ì', ograve: 'ò', ugrave: 'ù', ccedil: 'ç', shy: '', ensp: ' ', emsp: ' ', thinsp: ' ', zwnj: '', zwj: '', copy: '©', deg: '°', ordm: 'º', ordf: 'ª', sect: '§', para: '¶', middot: '·', dagger: '†', Dagger: '‡', bull: '•', times: '×' }
|
||
const entities = s => s.replace(/&(#x?[0-9a-f]+|[a-z0-9]+);/gi, (all, e) => {
|
||
if (e[0] !== '#') return ENTITIES[e] ?? all
|
||
const n = e[1].toLowerCase() === 'x' ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10)
|
||
return n > 0 && n <= 0x10ffff ? String.fromCodePoint(n) : ''
|
||
})
|
||
const attr = (attrs, name) => {
|
||
const m = new RegExp(`(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`, 'i').exec(attrs)
|
||
return m ? entities(m[1] ?? m[2]) : null
|
||
}
|
||
// Ruta dentro del ZIP de un enlace relativo a un archivo del libro.
|
||
function resolveHref(base, href) {
|
||
let rel = href.split('#')[0]
|
||
try { rel = decodeURIComponent(rel) } catch {}
|
||
return path.posix.normalize(path.posix.join(path.posix.dirname(base), rel)).replace(/^\.\//, '')
|
||
}
|
||
|
||
// ---------- XHTML a bloques ----------
|
||
const SKIP = new Set(['head', 'script', 'style', 'template', 'noscript', 'iframe', 'object', 'embed', 'audio', 'video', 'math', 'select', 'form', 'nav'])
|
||
const BLOCK = new Set(['p', 'div', 'section', 'article', 'aside', 'header', 'footer', 'figure', 'figcaption', 'main', 'body', 'ul', 'ol', 'li', 'dl', 'dt', 'dd', 'table', 'thead', 'tbody', 'tfoot', 'tr', 'caption', 'pre', 'address', 'center', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'blockquote'])
|
||
const VOID = new Set(['br', 'hr', 'img', 'image', 'meta', 'link', 'input', 'col', 'area', 'base', 'wbr'])
|
||
const TOKEN = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<[?!][^>]*>|<(\/?)([a-zA-Z][a-zA-Z0-9:_-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/g
|
||
|
||
// onAnchor(id) se llama con cada id del documento; devuelve true si ahí empieza un capítulo.
|
||
function xhtmlToBlocks(xml, file, imageOf, onBlock, onAnchor) {
|
||
let skip = 0, skipTag = null
|
||
let italic = 0, bold = 0, quote = 0, center = 0, verse = 0
|
||
const stack = [] // etiquetas de bloque con estilo, para deshacerlo al cerrarlas
|
||
let runs = [], heading = 0
|
||
const flush = () => {
|
||
// Espacios del código fuente fuera; los saltos de línea reales (<br>) son \n.
|
||
const out = []
|
||
let atStart = true
|
||
for (const [text, style] of runs) {
|
||
let t = text === '\n' ? text : text.replace(/[ \t\r\n\f]+/g, ' ') // el \n solo viene de un <br>
|
||
if (atStart) t = t.replace(/^ +/, '')
|
||
if (!t) continue
|
||
atStart = t.endsWith('\n')
|
||
const last = out.at(-1)
|
||
if (last && last[1] === style) last[0] += t
|
||
else out.push([t, style])
|
||
}
|
||
while (out.length) {
|
||
const last = out.at(-1)
|
||
last[0] = last[0].replace(/[ \n]+$/, '')
|
||
if (last[0]) break
|
||
out.pop()
|
||
}
|
||
runs = []
|
||
if (out.length && out.some(([t]) => t.trim())) {
|
||
const b = heading ? { k: 'h', l: heading, r: out } : { k: quote ? 'q' : 'p', r: out }
|
||
if (center || heading) b.c = 1
|
||
if (verse || out.some(([t]) => t.includes('\n'))) b.v = 1
|
||
onBlock(b)
|
||
}
|
||
}
|
||
const body = xml.search(/<body[\s>]/i)
|
||
let pos = body >= 0 ? body : 0
|
||
TOKEN.lastIndex = pos
|
||
for (let m; (m = TOKEN.exec(xml));) {
|
||
if (!skip && m.index > pos) {
|
||
const text = entities(xml.slice(pos, m.index))
|
||
if (text) runs.push([text, (italic ? 1 : 0) + (bold ? 2 : 0)])
|
||
}
|
||
pos = TOKEN.lastIndex
|
||
const tag = m[2]?.toLowerCase().replace(/^.*:/, '')
|
||
if (!tag) { // comentario, DOCTYPE; CDATA se pierde a propósito (no es texto de libro)
|
||
continue
|
||
}
|
||
const closing = m[1] === '/'
|
||
const rawAttrs = m[3] || ''
|
||
const selfClosed = /\/\s*$/.test(rawAttrs)
|
||
if (skip) {
|
||
if (tag === skipTag) {
|
||
if (closing) { if (--skip === 0) skipTag = null } else if (!selfClosed) skip++
|
||
}
|
||
continue
|
||
}
|
||
if (closing) {
|
||
if (BLOCK.has(tag)) {
|
||
flush()
|
||
const top = stack.findLastIndex(s => s.tag === tag)
|
||
if (top >= 0) {
|
||
for (const s of stack.splice(top)) {
|
||
quote -= s.quote; center -= s.center; verse -= s.verse; italic -= s.italic; bold -= s.bold
|
||
if (s.heading) heading = 0
|
||
}
|
||
}
|
||
} else if (tag === 'i' || tag === 'em' || tag === 'cite' || tag === 'dfn') italic = Math.max(0, italic - 1)
|
||
else if (tag === 'b' || tag === 'strong') bold = Math.max(0, bold - 1)
|
||
continue
|
||
}
|
||
const id = attr(rawAttrs, 'id') ?? (tag === 'a' ? attr(rawAttrs, 'name') : null)
|
||
if (id && onAnchor(id, flush)) { /* el capítulo nuevo ya vació lo pendiente */ }
|
||
const cls = (attr(rawAttrs, 'class') || '').toLowerCase()
|
||
const type = (attr(rawAttrs, 'epub:type') || '').toLowerCase()
|
||
// Números de página de la edición impresa: ruido entre el texto.
|
||
if (SKIP.has(tag) || /\bpage-?num(ber)?\b|\bpageno\b/.test(cls) || type.includes('pagebreak') || attr(rawAttrs, 'hidden') !== null) {
|
||
if (!selfClosed && !VOID.has(tag)) { skip = 1; skipTag = tag }
|
||
continue
|
||
}
|
||
if (tag === 'br') { runs.push(['\n', 0]); continue }
|
||
if (tag === 'hr') { flush(); onBlock({ k: 'hr' }); continue }
|
||
if (tag === 'img' || tag === 'image') {
|
||
const src = attr(rawAttrs, 'src') ?? attr(rawAttrs, 'xlink:href') ?? attr(rawAttrs, 'href')
|
||
const n = src != null && !/^[a-z]+:/i.test(src) ? imageOf(resolveHref(file, src)) : null
|
||
if (n != null) { flush(); onBlock({ k: 'img', n }) }
|
||
continue
|
||
}
|
||
if (BLOCK.has(tag)) {
|
||
flush()
|
||
const style = attr(rawAttrs, 'style') || ''
|
||
const s = {
|
||
tag,
|
||
quote: tag === 'blockquote' ? 1 : 0,
|
||
center: tag === 'center' || /\bcent(er|re)\b/.test(cls) || /text-align\s*:\s*center/i.test(style) ? 1 : 0,
|
||
verse: tag === 'pre' || /\b(verse|poem|poetry|stanza|line-?block)\b/.test(cls) ? 1 : 0,
|
||
italic: 0, bold: 0, heading: 0,
|
||
}
|
||
if (/^h[1-6]$/.test(tag)) { heading = Number(tag[1]); s.heading = 1 }
|
||
quote += s.quote; center += s.center; verse += s.verse
|
||
if (!selfClosed) stack.push(s)
|
||
else { quote -= s.quote; center -= s.center; verse -= s.verse; if (s.heading) heading = 0 }
|
||
continue
|
||
}
|
||
if (selfClosed) continue
|
||
if (tag === 'i' || tag === 'em' || tag === 'cite' || tag === 'dfn') italic++
|
||
else if (tag === 'b' || tag === 'strong') bold++
|
||
else if (tag === 'td' || tag === 'th') { if (runs.length) runs.push([' ', 0]) }
|
||
}
|
||
if (!skip && pos < xml.length) {
|
||
const text = entities(xml.slice(pos).replace(/<[^>]*$/, ''))
|
||
if (text.trim()) runs.push([text, 0])
|
||
}
|
||
flush()
|
||
}
|
||
|
||
// Ancho y alto de una imagen PNG, GIF, JPEG o WebP, por su cabecera.
|
||
function imageSize(b) {
|
||
if (b.length > 24 && b.readUInt32BE(0) === 0x89504e47) return { w: b.readUInt32BE(16), h: b.readUInt32BE(20) }
|
||
if (b.length > 10 && b.toString('latin1', 0, 3) === 'GIF') return { w: b.readUInt16LE(6), h: b.readUInt16LE(8) }
|
||
if (b.length > 4 && b[0] === 0xff && b[1] === 0xd8) {
|
||
for (let p = 2; p + 9 < b.length;) {
|
||
if (b[p] !== 0xff) { p++; continue }
|
||
const m = b[p + 1]
|
||
if (m >= 0xc0 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) return { w: b.readUInt16BE(p + 7), h: b.readUInt16BE(p + 5) }
|
||
if (m === 0xff) { p++; continue }
|
||
p += 2 + b.readUInt16BE(p + 2)
|
||
}
|
||
}
|
||
if (b.length > 30 && b.toString('latin1', 0, 4) === 'RIFF' && b.toString('latin1', 8, 12) === 'WEBP') {
|
||
const kind = b.toString('latin1', 12, 16)
|
||
if (kind === 'VP8X') return { w: b.readUIntLE(24, 3) + 1, h: b.readUIntLE(27, 3) + 1 }
|
||
if (kind === 'VP8 ') return { w: b.readUInt16LE(26) & 0x3fff, h: b.readUInt16LE(28) & 0x3fff }
|
||
if (kind === 'VP8L') { const v = b.readUInt32LE(21); return { w: (v & 0x3fff) + 1, h: ((v >> 14) & 0x3fff) + 1 } }
|
||
}
|
||
return {}
|
||
}
|
||
|
||
// ---------- EPUB ----------
|
||
|
||
// Índice del libro en orden: [{ file, anchor, title }]. EPUB 3 (nav) o EPUB 2 (toc.ncx).
|
||
function readToc(read, opf, manifest) {
|
||
const navItem = [...manifest.values()].find(it => /\bnav\b/.test(it.props))
|
||
if (navItem) {
|
||
const xml = read(navItem.path)
|
||
const nav = /<nav\b[^>]*(?:epub:)?type\s*=\s*["']toc["'][^>]*>([\s\S]*?)<\/nav>/i.exec(xml)?.[1]
|
||
if (nav) {
|
||
const out = []
|
||
for (const m of nav.matchAll(/<a\b([^>]*)>([\s\S]*?)<\/a>/gi)) {
|
||
const href = attr(m[1], 'href')
|
||
if (!href) continue
|
||
out.push({ file: resolveHref(navItem.path, href), anchor: href.split('#')[1] || null, title: clean(m[2]) })
|
||
}
|
||
if (out.length) return out
|
||
}
|
||
}
|
||
const spineToc = /<spine\b[^>]*\btoc\s*=\s*["']([^"']+)["']/i.exec(opf)?.[1]
|
||
const ncx = manifest.get(spineToc) || [...manifest.values()].find(it => /ncx/.test(it.type))
|
||
if (!ncx) return []
|
||
const xml = read(ncx.path)
|
||
const out = []
|
||
// Solo la etiqueta y el contenido propios de cada entrada: los navPoint se anidan.
|
||
for (const m of xml.matchAll(/<navPoint\b[^>]*>\s*<navLabel\b[^>]*>\s*<text\b[^>]*>([\s\S]*?)<\/text>\s*<\/navLabel>\s*<content\b([^>]*)\/?>/gi)) {
|
||
const src = attr(m[2], 'src')
|
||
if (src) out.push({ file: resolveHref(ncx.path, src), anchor: src.split('#')[1] || null, title: clean(m[1]) })
|
||
}
|
||
return out
|
||
}
|
||
const clean = s => entities(String(s).replace(/<[^>]*>/g, ' ')).replace(/\s+/g, ' ').trim()
|
||
|
||
export function parseEpub(file) {
|
||
const index = readZipIndex(file)
|
||
const entries = new Map(index.map(e => [e.name, e]))
|
||
if (index.reduce((n, e) => n + e.unzipped, 0) > MAX_UNZIPPED_TOTAL) throw new Error('EPUB demasiado grande al descomprimir')
|
||
const readBuf = name => {
|
||
const e = entries.get(name)
|
||
if (!e) throw new Error(`Falta ${name} en el EPUB`)
|
||
if (e.unzipped > MAX_UNZIPPED_ENTRY) throw new Error('Archivo demasiado grande dentro del EPUB')
|
||
return readCbzEntry(file, e, MAX_UNZIPPED_ENTRY)
|
||
}
|
||
const read = name => readBuf(name).toString('utf8').replace(/^/, '')
|
||
|
||
const container = read('META-INF/container.xml')
|
||
const opfPath = attr(/<rootfile\b([^>]*)>/i.exec(container)?.[1] || '', 'full-path')
|
||
if (!opfPath) throw new Error('EPUB sin paquete')
|
||
const opf = read(opfPath)
|
||
const dc = name => clean(new RegExp(`<dc:${name}\\b[^>]*>([\\s\\S]*?)</dc:${name}>`, 'i').exec(opf)?.[1] || '')
|
||
const manifest = new Map()
|
||
for (const m of opf.matchAll(/<item\b([^>]*)>/gi)) {
|
||
const id = attr(m[1], 'id'), href = attr(m[1], 'href')
|
||
if (id && href) manifest.set(id, { path: resolveHref(opfPath, href), type: attr(m[1], 'media-type') || '', props: attr(m[1], 'properties') || '' })
|
||
}
|
||
const spine = [...opf.matchAll(/<itemref\b([^>]*)>/gi)].map(m => manifest.get(attr(m[1], 'idref'))).filter(it => it && /x?html/i.test(it.type))
|
||
if (!spine.length) throw new Error('EPUB sin contenido')
|
||
let toc = []
|
||
try { toc = readToc(read, opf, manifest) } catch {}
|
||
|
||
const images = []
|
||
const imageIdx = new Map()
|
||
const imageOf = name => {
|
||
const e = entries.get(name)
|
||
if (!e || !BOOK_IMAGE.test(name) || e.unzipped > MAX_UNZIPPED_ENTRY) return null
|
||
if (!imageIdx.has(name)) { imageIdx.set(name, images.length); images.push(name) }
|
||
return imageIdx.get(name)
|
||
}
|
||
|
||
// Las entradas del índice que apuntan a cada archivo. Un capítulo empieza en su ancla, o en el archivo si no tiene.
|
||
const targets = new Map()
|
||
for (const t of toc) {
|
||
if (!targets.has(t.file)) targets.set(t.file, new Map())
|
||
targets.get(t.file).set(t.anchor, t.title)
|
||
}
|
||
const chapters = []
|
||
const start = title => chapters.push({ title, blocks: [] })
|
||
for (const item of spine) {
|
||
const here = targets.get(item.path)
|
||
if (here?.has(null) || (!toc.length)) start(here?.get(null) || '')
|
||
if (!chapters.length) start('')
|
||
xhtmlToBlocks(read(item.path), item.path, imageOf,
|
||
b => chapters.at(-1).blocks.push(b),
|
||
(id, flush) => {
|
||
if (!here?.has(id)) return false
|
||
flush()
|
||
start(here.get(id))
|
||
here.delete(id) // un id repetido no abre otro capítulo
|
||
return true
|
||
})
|
||
}
|
||
|
||
// Limpieza: fuera los vacíos; un capítulo que solo trae su título ("Parte primera") se une al siguiente.
|
||
const merged = []
|
||
let carry = null
|
||
for (const c of chapters) {
|
||
if (!c.blocks.length) continue
|
||
const blocks = carry ? [...carry.blocks, ...c.blocks] : c.blocks
|
||
const title = c.title || carry?.title || ''
|
||
carry = null
|
||
if (blocks.every(b => b.k === 'h' || b.k === 'hr') && c !== chapters.at(-1)) { carry = { title, blocks }; continue }
|
||
merged.push({ title, blocks })
|
||
}
|
||
if (carry) merged.push(carry)
|
||
const out = merged
|
||
if (!out.length) throw new Error('EPUB sin texto')
|
||
out.forEach((c, i) => { if (!c.title) c.title = `Sección ${i + 1}` })
|
||
// El navegador maqueta el libro entero sin cargar las imágenes: necesita saber su tamaño.
|
||
for (const c of out) {
|
||
for (const b of c.blocks) {
|
||
if (b.k !== 'img') continue
|
||
try { Object.assign(b, imageSize(readBuf(images[b.n]))) } catch {}
|
||
}
|
||
}
|
||
const year = parseInt(dc('date'), 10)
|
||
return {
|
||
version: PARSER_VERSION,
|
||
title: dc('title'), authors: [...opf.matchAll(/<dc:creator\b[^>]*>([\s\S]*?)<\/dc:creator>/gi)].map(m => clean(m[1])).filter(Boolean),
|
||
language: dc('language').slice(0, 2).toLowerCase(), description: dc('description'), year: year > 0 && year < 2100 ? year : null,
|
||
images, chapters: out,
|
||
}
|
||
}
|
||
|
||
// ---------- Fuente y caché ----------
|
||
export function setupBooks({ DATA_DIR, cached, HttpError, coverUrl, UA, net, safeFetch }) {
|
||
const DIR = path.join(DATA_DIR, 'books')
|
||
fs.mkdirSync(DIR, { recursive: true })
|
||
const epubFile = id => path.join(DIR, `${id.replace('~', '-')}.epub`)
|
||
const jsonFile = id => path.join(DIR, `${id.replace('~', '-')}.json`)
|
||
|
||
// Hasta 3 intentos: un fallo de red o un 5xx de Gutenberg suele durar poco. El motivo real queda en el log.
|
||
async function gutenberg(url, timeout) {
|
||
for (let i = 1; ; i++) {
|
||
net.guard()
|
||
let why
|
||
try {
|
||
const r = await safeFetch(url, { headers: { 'User-Agent': UA }, signal: AbortSignal.timeout(timeout) })
|
||
if (r.ok) return r
|
||
if (r.status === 404) throw new HttpError(404, 'Ese libro no está en Project Gutenberg')
|
||
if (r.status < 500 && r.status !== 429) throw new HttpError(502, `Project Gutenberg respondió ${r.status}`)
|
||
why = `HTTP ${r.status}`
|
||
} catch (e) {
|
||
if (e instanceof HttpError) throw e
|
||
why = e.cause?.code || e.cause?.message || e.message
|
||
net.failed()
|
||
}
|
||
console.warn(`Gutenberg ${url}: intento ${i}: ${why}`)
|
||
if (i >= 3) throw new HttpError(502, 'Project Gutenberg no responde ahora mismo. Prueba en un rato.')
|
||
await new Promise(r => setTimeout(r, 800 * i))
|
||
}
|
||
}
|
||
const coverOf = (n, id) => coverUrl(`${GUTENBERG}/cache/epub/${n}/pg${n}.cover.medium.jpg`, id)
|
||
// "Cervantes Saavedra, Miguel de" -> "Miguel de Cervantes Saavedra"
|
||
const authorName = a => a.split(', ').reverse().join(' ')
|
||
const entryText = (xml, tag) => clean(new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)</${tag}>`).exec(xml)?.[1] || '')
|
||
function parseFeed(xml) {
|
||
const out = []
|
||
for (const [entry] of xml.matchAll(/<entry>[\s\S]*?<\/entry>/g)) {
|
||
const n = /<id>[^<]*\/ebooks\/(\d+)\.opds<\/id>/.exec(entry)?.[1]
|
||
if (!n) continue // "Ordenar por…" y otras entradas de navegación
|
||
const id = `gb~${n}`
|
||
// El buscador añade el idioma al título: "Las Fábulas de Esopo (Spanish)".
|
||
const title = entryText(entry, 'title').replace(/\s*\([A-Z][a-z]+\)$/, '')
|
||
out.push({ id, source: 'gb', title, cover: coverOf(n, id), sub: entryText(entry, 'content') || undefined })
|
||
}
|
||
return out
|
||
}
|
||
// lang del usuario ("es-la") a idioma del catálogo ("spanish").
|
||
async function search(q, mode, page, lang) {
|
||
const name = LANG_NAMES[String(lang || 'es').slice(0, 2)]
|
||
const text = q.trim().replace(/\s+/g, ' ')
|
||
const qs = new URLSearchParams({ query: [text, name && `l.${name}`].filter(Boolean).join(' '), sort_order: mode === 'latest' && !text ? 'release_date' : 'downloads' })
|
||
const start = (Math.max(1, page | 0) - 1) * OPDS_PAGE + 1
|
||
if (start > 1) qs.set('start_index', String(start))
|
||
return cached(`gb:${qs}`, 30 * 60e3, async () => parseFeed(await (await gutenberg(`${GUTENBERG}/ebooks/search.opds/?${qs}`, 15e3)).text()))
|
||
}
|
||
|
||
// Una sola descarga y conversión a la vez por libro.
|
||
const loading = new Map()
|
||
const memory = new Map() // últimos libros convertidos
|
||
function remember(id, book) {
|
||
memory.delete(id)
|
||
memory.set(id, book)
|
||
if (memory.size > 4) memory.delete(memory.keys().next().value)
|
||
return book
|
||
}
|
||
async function downloadEpub(id) {
|
||
const r = await gutenberg(`${GUTENBERG}/ebooks/${id.slice(3)}.epub3.images`, 120e3)
|
||
if (Number(r.headers.get('content-length')) > MAX_EPUB_BYTES) throw new HttpError(502, 'El libro es demasiado grande')
|
||
const buf = Buffer.from(await r.arrayBuffer())
|
||
if (buf.length > MAX_EPUB_BYTES) throw new HttpError(502, 'El libro es demasiado grande')
|
||
const tmp = `${epubFile(id)}.part`
|
||
fs.writeFileSync(tmp, buf)
|
||
fs.renameSync(tmp, epubFile(id))
|
||
}
|
||
function loadBook(id) {
|
||
const hit = memory.get(id)
|
||
if (hit) return Promise.resolve(remember(id, hit))
|
||
if (loading.has(id)) return loading.get(id)
|
||
const p = (async () => {
|
||
try {
|
||
const saved = JSON.parse(fs.readFileSync(jsonFile(id), 'utf8'))
|
||
if (saved.version === PARSER_VERSION) return remember(id, saved)
|
||
} catch {}
|
||
if (!fs.existsSync(epubFile(id))) await downloadEpub(id)
|
||
let book
|
||
try { book = parseEpub(epubFile(id)) } catch (e) {
|
||
console.warn(`EPUB ${id}: ${e.message}`)
|
||
fs.rmSync(epubFile(id), { force: true }) // descarga mala: que el siguiente intento la repita
|
||
throw new HttpError(502, 'No se pudo leer el EPUB de este libro')
|
||
}
|
||
const tmp = `${jsonFile(id)}.part`
|
||
fs.writeFileSync(tmp, JSON.stringify(book))
|
||
fs.renameSync(tmp, jsonFile(id))
|
||
return remember(id, book)
|
||
})().finally(() => loading.delete(id))
|
||
loading.set(id, p)
|
||
return p
|
||
}
|
||
|
||
async function manga(id) {
|
||
const book = await loadBook(id)
|
||
return {
|
||
manga: {
|
||
id, source: 'gb', type: 'Libro',
|
||
title: book.title || `Libro ${id.slice(3)}`,
|
||
description: book.description || '',
|
||
status: null, year: null, // la fecha del EPUB es la de la edición digital, no la de la obra
|
||
tags: [],
|
||
authors: book.authors.map(authorName),
|
||
languages: book.language ? [book.language] : [],
|
||
cover: coverOf(id.slice(3), id),
|
||
},
|
||
chapters: book.chapters.map((c, i) => ({ id: `${id}~${i}`, num: String(i + 1), volume: null, title: c.title, pages: null, group: '', publishAt: null })),
|
||
}
|
||
}
|
||
async function chapter(chapterId) {
|
||
const cut = chapterId.lastIndexOf('~')
|
||
const book = await loadBook(chapterId.slice(0, cut))
|
||
const c = book.chapters[Number(chapterId.slice(cut + 1))]
|
||
if (!c) throw new HttpError(404, 'Ese capítulo no existe')
|
||
return { title: c.title }
|
||
}
|
||
// El libro entero (lo maqueta el navegador), comprimido una sola vez: son megas de texto.
|
||
const packed = new Map()
|
||
async function sendText(req, res, id) {
|
||
const book = await loadBook(id)
|
||
let hit = packed.get(id)
|
||
if (hit?.book !== book) {
|
||
hit = { book, gz: zlib.gzipSync(JSON.stringify({ title: book.title, chapters: book.chapters })) }
|
||
packed.delete(id)
|
||
packed.set(id, hit)
|
||
if (packed.size > 4) packed.delete(packed.keys().next().value)
|
||
}
|
||
const headers = { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'private, no-cache', Vary: 'Accept-Encoding' }
|
||
if (/\bgzip\b/.test(req.headers['accept-encoding'] || '')) { res.writeHead(200, { ...headers, 'Content-Encoding': 'gzip' }); return res.end(hit.gz) }
|
||
res.writeHead(200, headers)
|
||
res.end(zlib.gunzipSync(hit.gz))
|
||
}
|
||
async function sendImage(res, id, n) {
|
||
const book = await loadBook(id)
|
||
const name = book.images[n]
|
||
const entry = name && readZipIndex(epubFile(id)).find(e => e.name === name)
|
||
if (!entry) throw new HttpError(404, 'Imagen no encontrada')
|
||
const data = readCbzEntry(epubFile(id), entry, MAX_UNZIPPED_ENTRY)
|
||
res.writeHead(200, { 'Content-Type': imageType(name), 'Cache-Control': 'private, max-age=604800', 'X-Content-Type-Options': 'nosniff' })
|
||
res.end(data)
|
||
}
|
||
return { search, manga, chapter, sendText, sendImage }
|
||
}
|