ds-harness-remote-fast/apps/android/scripts/pdf-viewer.js

390 lines
13 KiB
JavaScript

// Inlined after the bundled pdf.js module by scripts/build-pdf.mjs. pdf.js resolves its worker
// through globalThis.pdfjsWorker, which the bundled worker module installs, so the worker runs on
// the main thread and this page spawns no Worker, fetches nothing and touches no file.
;(() => {
const MAX_BASE64_CHARS = Math.ceil((16 * 1024 * 1024) / 3) * 4
const MAX_CANVAS_PIXELS = 4000000
const MAX_CANVAS_DIMENSION = 8192
const MAX_RATIO = 2
const MAX_TEXT_ITEMS = 5000
const MIN_ZOOM = 0.25
const MAX_ZOOM = 8
/** Must match the #pdf-page margin in the generated page. */
const PAGE_MARGIN = 8
const RESIZE_DEBOUNCE_MS = 120
const BASE64 = /^[A-Za-z0-9+/]+={0,2}$/
if (typeof getDocument !== 'function' || typeof globalThis.pdfjsWorker?.WorkerMessageHandler?.setup !== 'function') {
throw new Error('The bundled pdf.js module is incomplete.')
}
const rootEl = document.getElementById('pdf-root')
const pageEl = document.getElementById('pdf-page')
const canvasEl = document.getElementById('pdf-canvas')
const textEl = document.getElementById('pdf-text')
const context = canvasEl.getContext('2d', { alpha: false })
const state = { status: 'idle', page: 0, pages: 0, zoom: 1, scale: 0, error: null }
window.pdfState = state
let session = null
let chunks = []
let chunkLength = 0
let beginToken = 0
let loadToken = 0
let pageToken = 0
let renderToken = 0
let loadingTask = null
let doc = null
let current = null
let pageNumber = 0
let pageCount = 0
let zoom = 1
let activeRender = null
let resizeTimer = 0
let lastWidth = 0
let disposed = false
const clamp = (value, min, max) => Math.min(Math.max(value, min), max)
const send = value => {
try { window.ReactNativeWebView.postMessage(JSON.stringify(value)) } catch { /* No bridge outside the app. */ }
}
const errorCode = error => {
const name = error?.name
if (name === 'PasswordException') return 'password'
if (name === 'InvalidPDFException') return 'invalid'
return 'failed'
}
const dropChunks = () => {
chunks = []
chunkLength = 0
}
const abortTask = async () => {
const task = loadingTask
loadingTask = null
if (task === null) return
try { await task.destroy() } catch { /* Already settled or destroyed. */ }
}
const fail = code => {
void abortTask()
dropChunks()
state.status = 'error'
state.error = code
send({ type: 'error', code, id: session })
}
const cancelRender = async () => {
const task = activeRender
activeRender = null
if (task === null) return
try { task.cancel() } catch { /* Already settled. */ }
try { await task.promise } catch { /* Reported by the render call that owns the token. */ }
}
const releasePage = () => {
const previous = current
current = null
textEl.replaceChildren()
canvasEl.width = 1
canvasEl.height = 1
try { previous?.cleanup() } catch { /* The document may already be destroyed. */ }
}
const reset = async () => {
renderToken += 1
pageToken += 1
loadToken += 1
session = null
dropChunks()
await cancelRender()
releasePage()
const previous = doc
doc = null
pageNumber = 0
pageCount = 0
zoom = 1
state.status = 'idle'
state.page = 0
state.pages = 0
state.zoom = 1
state.scale = 0
state.error = null
await abortTask()
if (previous !== null) {
try { await previous.destroy() } catch { /* Superseded loads own their own teardown. */ }
}
}
const drawText = async (target, scale, mine) => {
try {
const content = await target.getTextContent()
if (mine !== renderToken) return
const items = content?.items
if (!Array.isArray(items) || items.length > MAX_TEXT_ITEMS) return
const viewport = target.getViewport({ scale })
const fragment = document.createDocumentFragment()
for (const item of items) {
if (typeof item?.str !== 'string' || item.str.length === 0) {
if (item?.hasEOL === true) fragment.append(document.createElement('br'))
continue
}
const box = Util.transform(viewport.transform, item.transform)
const height = Math.hypot(box[2], box[3])
if (!Number.isFinite(height) || height <= 0) continue
const span = document.createElement('span')
span.textContent = item.str
span.style.left = `${box[4]}px`
span.style.top = `${box[5] - height * 0.85}px`
span.style.fontSize = `${height}px`
span.style.fontFamily = content.styles?.[item.fontName]?.fontFamily ?? 'sans-serif'
if (typeof item.dir === 'string' && item.dir !== 'auto') span.dir = item.dir
fragment.append(span)
if (item.hasEOL === true) fragment.append(document.createElement('br'))
}
textEl.replaceChildren(fragment)
} catch { /* The canvas already shows the page; a missing text overlay is not a render failure. */ }
}
const render = async () => {
const mine = ++renderToken
let task = null
try {
await cancelRender()
if (disposed || mine !== renderToken || current === null || context === null) return
const base = current.getViewport({ scale: 1 })
if (!Number.isFinite(base.width) || !Number.isFinite(base.height) || base.width <= 0 || base.height <= 0) {
throw new Error('The page has no usable size.')
}
const available = Math.max(64, rootEl.clientWidth - 2 * PAGE_MARGIN)
const cssScale = Math.min(
zoom * available / base.width,
MAX_CANVAS_DIMENSION / base.width,
MAX_CANVAS_DIMENSION / base.height,
)
const width = Math.max(1, base.width * cssScale)
const height = Math.max(1, base.height * cssScale)
const deviceScale = Math.min(
window.devicePixelRatio || 1,
MAX_RATIO,
Math.sqrt(MAX_CANVAS_PIXELS / (width * height)),
MAX_CANVAS_DIMENSION / width,
MAX_CANVAS_DIMENSION / height,
)
if (!Number.isFinite(deviceScale) || deviceScale <= 0) throw new Error('The page cannot be scaled.')
const viewport = current.getViewport({ scale: cssScale * deviceScale })
canvasEl.width = clamp(Math.floor(viewport.width), 1, MAX_CANVAS_DIMENSION)
canvasEl.height = clamp(Math.floor(viewport.height), 1, MAX_CANVAS_DIMENSION)
pageEl.style.width = `${width}px`
pageEl.style.height = `${height}px`
textEl.replaceChildren()
state.scale = cssScale
task = current.render({
canvasContext: context,
viewport,
annotationMode: AnnotationMode.DISABLE,
background: '#ffffff',
})
activeRender = task
await task.promise
if (disposed || mine !== renderToken) return
await drawText(current, cssScale, mine)
if (disposed || mine !== renderToken) return
state.status = 'rendered'
state.page = current.pageNumber
state.pages = pageCount
state.zoom = zoom
state.error = null
send({ type: 'rendered', id: session, page: current.pageNumber, pages: pageCount, zoom })
} catch (error) {
if (disposed || mine !== renderToken || error?.name === 'RenderingCancelledException') return
fail(errorCode(error))
} finally {
if (activeRender === task) activeRender = null
}
}
const goToPage = async target => {
const owner = doc
const mine = ++pageToken
renderToken += 1
// The requested page is recorded first so a newer request can never be undone by a stale one.
pageNumber = target
await cancelRender()
if (disposed || owner === null || mine !== pageToken || doc !== owner) return
releasePage()
let next
try {
next = await owner.getPage(target)
} catch (error) {
if (!disposed && mine === pageToken && doc === owner) fail(errorCode(error))
return
}
if (disposed || mine !== pageToken || doc !== owner) {
try { next.cleanup() } catch { /* Owned by a newer document now. */ }
return
}
current = next
await render()
}
const load = async value => {
const mine = ++loadToken
let reported = false
const stop = code => {
if (reported || disposed || mine !== loadToken) return
reported = true
fail(code)
}
if (typeof value !== 'string' || value.length === 0) { stop('invalid'); return }
if (value.length > MAX_BASE64_CHARS) { stop('tooLarge'); return }
if (!BASE64.test(value)) { stop('invalid'); return }
await abortTask()
if (disposed || mine !== loadToken) return
let bytes
try {
const binary = atob(value)
bytes = new Uint8Array(binary.length)
for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index)
} catch { stop('invalid'); return }
let task
try {
task = getDocument({
data: bytes,
/** Tooling stays quiet: the page silences the console, so failures travel as messages. */
verbosity: VerbosityLevel.ERRORS,
/** Every byte is in memory; no range, stream, fetch or wasm path may reach out. */
disableAutoFetch: true,
disableRange: true,
disableStream: true,
useWorkerFetch: false,
useWasm: false,
useSystemFonts: true,
stopAtErrors: false,
enableXfa: false,
enableHWA: false,
enableWebGPU: false,
canvasMaxAreaInBytes: MAX_CANVAS_PIXELS * 4,
})
} catch { stop('failed'); return }
loadingTask = task
/** Encrypted documents have no password prompt here, so they fail closed. */
task.onPassword = () => { stop('password') }
let loaded
try {
loaded = await task.promise
} catch (error) {
stop(errorCode(error))
return
} finally {
if (loadingTask === task) loadingTask = null
}
if (disposed || mine !== loadToken) {
try { await loaded.destroy() } catch { /* Superseded loads own their own teardown. */ }
return
}
doc = loaded
pageCount = loaded.numPages
if (pageCount < 1) { stop('invalid'); return }
pageNumber = 1
zoom = 1
let next
try {
next = await loaded.getPage(1)
} catch (error) {
stop(errorCode(error))
return
}
if (disposed || mine !== loadToken) {
try { next.cleanup() } catch { /* Superseded loads own their own teardown. */ }
return
}
current = next
await render()
}
const begin = async id => {
const mine = ++beginToken
await reset()
if (disposed || mine !== beginToken) return
session = typeof id === 'string' ? id : null
dropChunks()
state.status = 'loading'
state.error = null
state.page = 0
state.pages = 0
state.zoom = 1
state.scale = 0
send({ type: 'loading', id: session })
send({ type: 'ack', id: session, index: 0 })
}
const append = (id, chunk) => {
if (session === null || id !== session) return
if (typeof chunk !== 'string' || chunk.length === 0) { fail('invalid'); return }
if (chunkLength + chunk.length > MAX_BASE64_CHARS) { fail('tooLarge'); return }
chunks.push(chunk)
chunkLength += chunk.length
send({ type: 'ack', id: session, index: chunks.length })
}
const finish = async id => {
if (session === null || id !== session) return
const value = chunks.join('')
dropChunks()
await load(value)
}
const onResize = () => {
const width = rootEl.clientWidth
if (Math.abs(width - lastWidth) < 1) return
lastWidth = width
if (resizeTimer !== 0) clearTimeout(resizeTimer)
resizeTimer = setTimeout(() => {
resizeTimer = 0
if (doc !== null) void render()
}, RESIZE_DEBOUNCE_MS)
}
window.beginPdf = id => { void begin(id) }
window.appendPdfChunk = (id, chunk) => { append(id, chunk) }
window.finishPdf = id => { void finish(id) }
window.loadPdf = async base64 => {
await begin('local')
append('local', base64)
await finish('local')
}
window.showPage = value => {
const target = Math.floor(Number(value))
if (!Number.isFinite(target) || doc === null || pageCount < 1) return
const next = clamp(target, 1, pageCount)
if (next === pageNumber && current !== null) {
rootEl.scrollTo(0, 0)
return
}
void goToPage(next)
}
window.zoomPdf = value => {
const delta = Number(value)
if (!Number.isFinite(delta) || doc === null) return
zoom = clamp(Math.round(zoom * (1 + delta) * 1000) / 1000, MIN_ZOOM, MAX_ZOOM)
void render()
}
const observer = new ResizeObserver(onResize)
observer.observe(rootEl)
window.addEventListener('resize', onResize)
window.addEventListener('pagehide', () => {
disposed = true
if (resizeTimer !== 0) {
clearTimeout(resizeTimer)
resizeTimer = 0
}
observer.disconnect()
void reset()
})
lastWidth = rootEl.clientWidth
state.status = 'ready'
send({ type: 'ready' })
})()