Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.
Go agentagenticaichatbotdsh-pluginembeddingsevaluationgenerative-aigolangknowledge-basellmmulti-tenantollamaopenaiquestion-answeringragrerankingsemantic-searchvector-searchwiki
<script setup lang="ts">
import { computed, nextTick, onBeforeUnmount, onMounted, reactive, ref, shallowRef, watch } from 'vue'
import { useI18n } from 'vue-i18n'
import type { SourceLocateRequest } from '@/utils/sourceLocator'
import { resolvePdfSource, mergeSourceRects, type PdfTarget } from '@/utils/pdfSourceLocate'
import { findTextRanges } from '@/utils/sourceLocatorDom'
import { loadPdfJs, type PdfJs } from './pdfjsLoader'
type PdfDocument = Awaited<ReturnType<PdfJs['getDocument']>['promise']>
type PdfPage = Awaited<ReturnType<PdfDocument['getPage']>>
/** A highlight drawn on a page, in fractions of the page box. */
type Mark = { left: number; top: number; width: number; height: number; kind: 'box' | 'text' | 'page'; target: number }
export type PdfLocateResult = { found: boolean; precise: boolean; page?: number; granularity?: string; reason?: string }
const props = defineProps<{
data: ArrayBuffer | null
fileName?: string
locate?: SourceLocateRequest | null
}>()
const emit = defineEmits<{
located: [result: PdfLocateResult]
error: [message: string]
}>()
const { t } = useI18n()
const scroller = ref<HTMLElement | null>(null)
const pageCount = ref(0)
const currentPage = ref(1)
const zoom = ref(1)
const loading = ref(false)
const error = ref('')
/** Height / width of each page; unknown pages borrow the first page's. */
const ratios = reactive<Record<number, number>>({})
const marks = reactive<Record<number, Mark[]>>({})
const pdf = shallowRef<PdfDocument | null>(null)
const pageElements = new Map<number, HTMLElement>()
type RenderEntry = {
scale: number
task?: { cancel: () => void }
textLayer?: { cancel: () => void }
/** Settles once the canvas and text layer are in place (or abandoned). */
done?: Promise<void>
}
const rendered = new Map<number, RenderEntry>()
const renderOrder: number[] = []
const pageTexts = new Map<number, string>()
let pdfjs: PdfJs | null = null
let loadingTask: { destroy: () => Promise<void> } | null = null
let observer: IntersectionObserver | null = null
let resizeObserver: ResizeObserver | null = null
let containerWidth = 0
let disposed = false
let locateVersion = 0
const MAX_RENDERED_PAGES = 12
const PAGE_GAP = 12
function defaultRatio(): number {
return ratios[1] || 1.414
}
function pageRatio(page: number): number {
return ratios[page] || defaultRatio()
}
function pageStyle(page: number) {
return { aspectRatio: `1 / ${pageRatio(page)}`, width: `${zoom.value * 100}%` }
}
function setPageRef(page: number, el: unknown) {
const node = el as HTMLElement | null
const previous = pageElements.get(page)
if (previous && previous !== node) observer?.unobserve(previous)
if (node) {
pageElements.set(page, node)
observer?.observe(node)
} else {
pageElements.delete(page)
}
}
async function openDocument(data: ArrayBuffer) {
const lib = await loadPdfJs()
pdfjs = lib
if (disposed) return
// pdf.js takes ownership of the buffer; keep the caller's copy intact.
const task = lib.getDocument({
data: new Uint8Array(data.slice(0)),
wasmUrl: `${import.meta.env.BASE_URL}pdfjs/wasm/`,
})
loadingTask = task
const doc = await task.promise
if (disposed) {
await task.destroy()
return
}
pdf.value = doc
pageCount.value = doc.numPages
const first = await doc.getPage(1)
const vp = first.getViewport({ scale: 1 })
ratios[1] = vp.height / vp.width
}
function renderScale(page: PdfPage): number {
const vp = page.getViewport({ scale: 1 })
const width = Math.max(200, containerWidth * zoom.value)
return width / vp.width
}
async function renderPage(pageNumber: number): Promise<void> {
const doc = pdf.value
const el = pageElements.get(pageNumber)
if (!doc || !el || !pdfjs) return
let page: PdfPage
try { page = await doc.getPage(pageNumber) } catch { return }
if (disposed || pdf.value !== doc) return
const scale = renderScale(page)
const existing = rendered.get(pageNumber)
if (existing && Math.abs(existing.scale - scale) < 0.01) {
// Wait for a render still in flight, so callers find its text layer.
await existing.done
return
}
existing?.task?.cancel()
existing?.textLayer?.cancel()
const viewport = page.getViewport({ scale })
ratios[pageNumber] = viewport.height / viewport.width
const dpr = Math.min(window.devicePixelRatio || 1, 2)
const canvas = document.createElement('canvas')
canvas.width = Math.floor(viewport.width * dpr)
canvas.height = Math.floor(viewport.height * dpr)
canvas.className = 'pdf-source-page__canvas'
const entry: RenderEntry = { scale }
rendered.set(pageNumber, entry)
touchRendered(pageNumber)
entry.done = paintPage(pageNumber, page, el, canvas, viewport, dpr, entry)
await entry.done
}
async function paintPage(
pageNumber: number,
page: PdfPage,
el: HTMLElement,
canvas: HTMLCanvasElement,
viewport: ReturnType<PdfPage['getViewport']>,
dpr: number,
entry: RenderEntry,
): Promise<void> {
const lib = pdfjs
if (!lib) return
const task = page.render({
canvas,
viewport,
transform: dpr !== 1 ? [dpr, 0, 0, dpr, 0, 0] : undefined,
})
entry.task = task
try {
await task.promise
} catch (err) {
if (rendered.get(pageNumber) === entry) {
console.error('PDF page render failed:', err)
error.value = t('preview.loadFailed')
emit('error', error.value)
}
return // cancelled by a newer render or unrender
}
if (rendered.get(pageNumber) !== entry) return
const textDiv = document.createElement('div')
textDiv.className = 'textLayer'
el.style.setProperty('--scale-factor', String(entry.scale))
el.style.setProperty('--total-scale-factor', String(entry.scale))
const oldCanvas = el.querySelector('.pdf-source-page__canvas')
const oldText = el.querySelector('.textLayer')
oldCanvas?.replaceWith(canvas)
if (!oldCanvas) el.prepend(canvas)
oldText?.remove()
canvas.after(textDiv)
const textLayer = new lib.TextLayer({
textContentSource: page.streamTextContent(),
container: textDiv,
viewport,
})
entry.textLayer = textLayer
try {
await textLayer.render()
} catch {
// Text layers are best-effort; the page is still readable.
}
}
function touchRendered(pageNumber: number) {
const i = renderOrder.indexOf(pageNumber)
if (i >= 0) renderOrder.splice(i, 1)
renderOrder.push(pageNumber)
while (renderOrder.length > MAX_RENDERED_PAGES) {
const evict = renderOrder.shift()!
unrenderPage(evict)
}
}
function unrenderPage(pageNumber: number) {
const entry = rendered.get(pageNumber)
entry?.task?.cancel()
entry?.textLayer?.cancel()
rendered.delete(pageNumber)
const el = pageElements.get(pageNumber)
el?.querySelector('.pdf-source-page__canvas')?.remove()
el?.querySelector('.textLayer')?.remove()
}
function onIntersect(entries: IntersectionObserverEntry[]) {
for (const entry of entries) {
if (!entry.isIntersecting) continue
const page = Number((entry.target as HTMLElement).dataset.page)
if (page) void renderPage(page)
}
}
function onScroll() {
const box = scroller.value
if (!box) return
const mid = box.scrollTop + box.clientHeight / 3
for (const [page, el] of pageElements) {
if (el.offsetTop <= mid && el.offsetTop + el.offsetHeight + PAGE_GAP > mid) {
currentPage.value = page
break
}
}
}
function rerenderVisible() {
const pages = [...rendered.keys()]
for (const p of pages) void renderPage(p)
}
function setZoom(next: number) {
const box = scroller.value
const anchor = box ? box.scrollTop / Math.max(1, box.scrollHeight) : 0
zoom.value = Math.max(0.5, Math.min(3, Math.round(next * 10) / 10))
void nextTick(() => {
if (box) box.scrollTop = anchor * box.scrollHeight
rerenderVisible()
})
}
// ---------------------------------------------------------------------------
// Locating
function clearMarks() {
for (const key of Object.keys(marks)) delete marks[Number(key)]
}
function addMark(page: number, mark: Mark) {
;(marks[page] ||= []).push(mark)
}
function scrollToPageFraction(page: number, fraction: number) {
const box = scroller.value
const el = pageElements.get(page)
if (!box || !el) return
// Instant, like scrollRectIntoContainer: nothing can cancel it mid-way.
box.scrollTop = Math.max(0, el.offsetTop + el.offsetHeight * fraction - box.clientHeight / 3)
}
async function pageText(pageNumber: number): Promise<string> {
const cached = pageTexts.get(pageNumber)
if (cached !== undefined) return cached
const doc = pdf.value
if (!doc) return ''
const page = await doc.getPage(pageNumber)
const content = await page.getTextContent()
const text = content.items.map((item) => ('str' in item ? item.str + (item.hasEOL ? '\n' : ' ') : '')).join('')
pageTexts.set(pageNumber, text)
return text
}
/** Refine only within the recorded region, or at a verified text occurrence. */
async function markTarget(target: PdfTarget, version: number, targetIndex: number): Promise<number | null> {
const pageNumber = target.page
await renderPage(pageNumber)
await rendered.get(pageNumber)?.done
await nextTick()
if (version !== locateVersion) return null
const el = pageElements.get(pageNumber)
const layer = el?.querySelector('.textLayer')
if (!el || !layer || !target.quote) return null
const pageBox = el.getBoundingClientRect()
const ranges = findTextRanges(layer, target.quote)
const candidates = ranges.map((range) => mergeSourceRects([...range.getClientRects()]))
const inside = (rects: ReturnType<typeof mergeSourceRects>) => {
if (!rects.length) return false
if (!target.bbox) return true
const [x0, y0, x1, y1] = target.bbox
return rects.every((r) => {
const x = (r.left + r.width / 2 - pageBox.left) / pageBox.width
const y = (r.top + r.height / 2 - pageBox.top) / pageBox.height
return x >= x0 && x <= x1 && y >= y0 && y <= y1
})
}
const eligible = target.bbox ? candidates.filter(inside) : candidates
const lines = target.bbox ? (eligible.length === 1 ? eligible[0] : undefined)
: (target.occurrence !== undefined && target.occurrence >= 0 ? eligible[target.occurrence] : eligible.length === 1 ? eligible[0] : undefined)
if (!lines?.length) return null
let top = 1
for (const r of lines) {
const mark: Mark = { kind: 'text', target: targetIndex, left: (r.left - pageBox.left) / pageBox.width,
top: (r.top - pageBox.top) / pageBox.height, width: r.width / pageBox.width, height: r.height / pageBox.height }
addMark(pageNumber, mark)
top = Math.min(top, mark.top)
}
return top
}
async function applyLocate(request: SourceLocateRequest | null | undefined) {
const version = ++locateVersion
clearMarks()
locatedTargets.value = []
selectedTarget.value = 0
if (!request || !pdf.value) return
try {
const result = await resolvePdfSource(request, pageCount.value, pageText, () => version !== locateVersion)
if (version !== locateVersion) return
const destinations: Array<{ page: number; top: number }> = []
const levels: string[] = []
for (const target of result.targets) {
// Use the navigation index: unresolved targets do not get a stop.
const targetIndex = destinations.length
let top = await markTarget(target, version, targetIndex)
if (version !== locateVersion) return
if (top !== null) levels.push('text')
else if (target.bbox) {
const [x0, y0, x1, y1] = target.bbox
addMark(target.page, { kind: 'box', target: targetIndex, left: x0, top: y0, width: x1 - x0, height: y1 - y0 })
top = y0
levels.push('block')
} else if (target.granularity === 'page') {
top = 0
levels.push('page')
addMark(target.page, { kind: 'page', target: targetIndex, left: 0, top: 0, width: 1, height: 1 })
}
if (top !== null) destinations.push({ page: target.page, top })
}
await nextTick()
if (version !== locateVersion) return
locatedTargets.value = destinations
selectedTarget.value = 0
if (destinations.length) jumpToTarget(0)
const granularity = levels.includes('page') ? 'page' : levels.includes('block') ? 'block' : 'text'
emit('located', { found: destinations.length > 0, precise: destinations.length === result.targets.length && levels.every((l) => l === 'text') && !result.reason,
page: destinations[0]?.page, granularity, reason: result.reason || (destinations.length < result.targets.length ? 'missing' : undefined) })
} catch {
if (version !== locateVersion) return
clearMarks()
emit('located', { found: false, precise: false, reason: 'unavailable' })
}
}
const locatedTargets = ref<Array<{ page: number; top: number }>>([])
const selectedTarget = ref(0)
function jumpToTarget(index: number) {
const target = locatedTargets.value[index]
if (!target) return
selectedTarget.value = index
scrollToPageFraction(target.page, target.top)
currentPage.value = target.page
}
watch(
() => props.locate?.token,
() => {
if (pdf.value) void applyLocate(props.locate)
},
)
async function load() {
error.value = ''
if (!props.data) return
loading.value = true
try {
await openDocument(props.data)
await nextTick()
containerWidth = scroller.value?.clientWidth ? scroller.value.clientWidth - 24 : 600
if (props.locate) await applyLocate(props.locate)
} catch (err) {
console.error('PDF preview failed:', err)
error.value = t('preview.loadFailed')
emit('error', error.value)
emit('located', { found: false, precise: false, reason: 'unavailable' })
} finally {
loading.value = false
}
}
onMounted(() => {
observer = new IntersectionObserver(onIntersect, { root: scroller.value, rootMargin: '600px 0px' })
for (const el of pageElements.values()) observer.observe(el)
resizeObserver = new ResizeObserver(() => {
const width = scroller.value?.clientWidth ? scroller.value.clientWidth - 24 : 0
if (width && Math.abs(width - containerWidth) > 8) {
containerWidth = width
rerenderVisible()
}
})
if (scroller.value) resizeObserver.observe(scroller.value)
void load()
})
onBeforeUnmount(() => {
disposed = true
locateVersion++
observer?.disconnect()
resizeObserver?.disconnect()
for (const p of [...rendered.keys()]) unrenderPage(p)
// Destroying the loading task also destroys the document and its worker.
void loadingTask?.destroy().catch(() => {})
})
const pageLabel = computed(() => (pageCount.value ? `${currentPage.value} / ${pageCount.value}` : ''))
defineExpose({ relocate: () => applyLocate(props.locate) })
</script>
<template>
<div class="pdf-source-viewer">
<div v-if="error" class="pdf-source-viewer__error">{{ error }}</div>
<div
ref="scroller"
class="pdf-source-viewer__scroller"
tabindex="0"
:aria-label="fileName"
@scroll.passive="onScroll"
>
<div v-if="loading && !pageCount" class="pdf-source-viewer__loading">
<t-loading size="small" />
</div>
<div
v-for="page in pageCount"
:key="page"
:ref="(el) => setPageRef(page, el)"
class="pdf-source-page"
:data-page="page"
:style="pageStyle(page)"
>
<div class="pdf-source-page__marks" aria-hidden="true">
<div
v-for="(mark, i) in marks[page] || []"
:key="i"
class="pdf-source-mark"
:class="[`pdf-source-mark--${mark.kind}`, { 'is-active': mark.target === selectedTarget }]"
:style="{
left: `${mark.left * 100}%`,
top: `${mark.top * 100}%`,
width: `${mark.width * 100}%`,
height: `${mark.height * 100}%`,
}"
/>
</div>
</div>
</div>
<div v-if="pageCount" class="pdf-source-viewer__bar">
<template v-if="locatedTargets.length > 1">
<t-button variant="text" size="small" :disabled="selectedTarget === 0" :aria-label="t('chat.referenceSourcePrevious')" @click="jumpToTarget(selectedTarget - 1)">‹</t-button>
<span>{{ selectedTarget + 1 }} / {{ locatedTargets.length }}</span>
<t-button variant="text" size="small" :disabled="selectedTarget === locatedTargets.length - 1" :aria-label="t('chat.referenceSourceNext')" @click="jumpToTarget(selectedTarget + 1)">›</t-button>
</template>
<span class="pdf-source-viewer__page">{{ pageLabel }}</span>
<t-button
theme="default" variant="text" size="small" shape="square"
:aria-label="t('preview.zoomOut')" :title="t('preview.zoomOut')"
@click="setZoom(zoom - 0.2)"
>
<template #icon><t-icon name="zoom-out" /></template>
</t-button>
<span class="pdf-source-viewer__zoom">{{ Math.round(zoom * 100) }}%</span>
<t-button
theme="default" variant="text" size="small" shape="square"
:aria-label="t('preview.zoomIn')" :title="t('preview.zoomIn')"
@click="setZoom(zoom + 0.2)"
>
<template #icon><t-icon name="zoom-in" /></template>
</t-button>
</div>
</div>
</template>
<style scoped lang="less">
.pdf-source-viewer {
position: relative;
display: flex;
flex-direction: column;
height: 100%;
min-height: 0;
background: var(--td-bg-color-secondarycontainer);
}
.pdf-source-viewer__scroller {
// Positioned so page offsetTop is measured from the scroll content.
position: relative;
flex: 1;
min-height: 0;
overflow: auto;
padding: 12px;
outline: none;
}
.pdf-source-viewer__loading,
.pdf-source-viewer__error {
padding: 24px;
text-align: center;
color: var(--td-text-color-placeholder);
}
.pdf-source-page {
position: relative;
isolation: isolate;
// The PDF canvas stays white even when the surrounding app is dark.
--app-source-highlight-bg: rgba(250, 204, 75, 0.34);
--app-source-highlight-soft-bg: rgba(250, 204, 75, 0.09);
--app-source-highlight-border: rgba(183, 130, 22, 0.5);
// Block flow with auto margins keeps zoomed pages scrollable to the left.
margin: 0 auto 12px;
max-width: none;
background: #fff;
box-shadow: 0 1px 3px rgba(0, 0, 0, 0.12);
// Text layers size themselves in these units.
--scale-round-x: 1px;
--scale-round-y: 1px;
:deep(.pdf-source-page__canvas) {
position: absolute;
inset: 0;
width: 100%;
height: 100%;
}
}
.pdf-source-page__marks {
position: absolute;
inset: 0;
z-index: 2;
pointer-events: none;
// Blend the whole layer once, so overlapping glyph rectangles do not
// darken the printed text independently.
mix-blend-mode: multiply;
}
.pdf-source-mark {
position: absolute;
border-radius: var(--app-radius-xs);
background: var(--app-source-highlight-soft-bg);
&--text.is-active {
background: var(--app-source-highlight-bg);
}
&--box {
outline: 1px solid var(--app-source-highlight-border);
&.is-active {
box-shadow: inset 3px 0 var(--app-source-highlight-border);
}
}
&--page {
background: transparent;
box-shadow: inset 0 0 0 1px var(--app-source-highlight-border);
&.is-active {
box-shadow: inset 3px 0 var(--app-source-highlight-border), inset 0 0 0 1px var(--app-source-highlight-border);
}
}
}
.pdf-source-viewer__bar {
position: absolute;
right: 16px;
bottom: 12px;
z-index: 3;
display: flex;
align-items: center;
gap: 2px;
padding: 2px 6px;
border-radius: var(--app-radius-md);
background: var(--td-bg-color-container);
box-shadow: 0 2px 8px rgba(0, 0, 0, 0.12);
font-size: var(--app-text-sm);
color: var(--td-text-color-secondary);
}
.pdf-source-viewer__page {
padding: 0 6px;
font-variant-numeric: tabular-nums;
}
.pdf-source-viewer__zoom {
min-width: 40px;
text-align: center;
font-variant-numeric: tabular-nums;
}
</style>
<style lang="less">
/* Minimal pdf.js text layer rules (from pdfjs-dist/web/pdf_viewer.css), so
text is selectable and searchable without the full viewer stylesheet. */
.pdf-source-page .textLayer {
position: absolute;
text-align: initial;
inset: 0;
overflow: clip;
opacity: 1;
line-height: 1;
letter-spacing: normal;
word-spacing: normal;
text-size-adjust: none;
forced-color-adjust: none;
transform-origin: 0 0;
z-index: 1;
--min-font-size: 1;
--text-scale-factor: calc(var(--total-scale-factor) * var(--min-font-size));
--min-font-size-inv: calc(1 / var(--min-font-size));
:is(span, br) {
color: transparent;
position: absolute;
white-space: pre;
cursor: text;
transform-origin: 0% 0%;
}
> :not(.markedContent),
.markedContent span:not(.markedContent) {
z-index: 1;
--font-height: 0;
font-size: calc(var(--text-scale-factor) * var(--font-height));
--scale-x: 1;
--rotate: 0deg;
transform: rotate(var(--rotate)) scaleX(var(--scale-x)) scale(var(--min-font-size-inv));
}
.markedContent {
display: contents;
}
::selection {
background: color-mix(in srgb, AccentColor, transparent 50%);
color: transparent;
}
&[data-main-rotation="90"] { transform: rotate(90deg) translateY(-100%); }
&[data-main-rotation="180"] { transform: rotate(180deg) translate(-100%, -100%); }
&[data-main-rotation="270"] { transform: rotate(270deg) translateX(-100%); }
}
</style>