pdf-js-viewer.js 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428
  1. import PropTypes from 'prop-types'
  2. import { memo, useCallback, useEffect, useRef, useState } from 'react'
  3. import { debounce } from 'lodash'
  4. import PdfViewerControls from './pdf-viewer-controls'
  5. import { useProjectContext } from '../../../shared/context/project-context'
  6. import usePersistedState from '../../../shared/hooks/use-persisted-state'
  7. import { buildHighlightElement } from '../util/highlights'
  8. import PDFJSWrapper from '../util/pdf-js-wrapper'
  9. import withErrorBoundary from '../../../infrastructure/error-boundary'
  10. import PdfPreviewErrorBoundaryFallback from './pdf-preview-error-boundary-fallback'
  11. import { useDetachCompileContext as useCompileContext } from '../../../shared/context/detach-compile-context'
  12. import { captureException } from '../../../infrastructure/error-reporter'
  13. import * as eventTracking from '../../../infrastructure/event-tracking'
  14. import { getPdfCachingMetrics } from '../util/metrics'
  15. import { debugConsole } from '@/utils/debugging'
  16. function PdfJsViewer({ url, pdfFile }) {
  17. const { _id: projectId } = useProjectContext()
  18. const { setError, firstRenderDone, highlights, position, setPosition } =
  19. useCompileContext()
  20. // state values persisted in localStorage to restore on load
  21. const [scale, setScale] = usePersistedState(
  22. `pdf-viewer-scale:${projectId}`,
  23. 'page-width'
  24. )
  25. // local state values
  26. const [pdfJsWrapper, setPdfJsWrapper] = useState()
  27. const [initialised, setInitialised] = useState(false)
  28. // create the viewer when the container is mounted
  29. const handleContainer = useCallback(
  30. parent => {
  31. if (parent) {
  32. const wrapper = new PDFJSWrapper(parent.firstChild)
  33. wrapper
  34. .init()
  35. .then(() => {
  36. setPdfJsWrapper(wrapper)
  37. })
  38. .catch(error => {
  39. setError('pdf-viewer-loading-error')
  40. captureException(error)
  41. })
  42. return () => {
  43. setPdfJsWrapper(null)
  44. wrapper.destroy()
  45. }
  46. }
  47. },
  48. [setError]
  49. )
  50. const [startFetch, setStartFetch] = useState(0)
  51. // listen for events and trigger rendering.
  52. // Do everything in one effect to mitigate de-sync between events.
  53. useEffect(() => {
  54. if (!pdfJsWrapper || !firstRenderDone) return
  55. let timePDFFetched
  56. let timePDFRendered
  57. const submitLatencies = () => {
  58. if (!timePDFFetched) {
  59. // The pagerendered event was attached after pagesinit fired. :/
  60. return
  61. }
  62. const latencyFetch = Math.ceil(timePDFFetched - startFetch)
  63. let latencyRender
  64. if (timePDFRendered) {
  65. // The renderer does not yield in case the browser tab is hidden.
  66. // It will yield when the browser tab is visible again.
  67. // This will skew our performance metrics for rendering!
  68. // We are omitting the render time in case we detect this state.
  69. latencyRender = Math.ceil(timePDFRendered - timePDFFetched)
  70. }
  71. firstRenderDone({
  72. latencyFetch,
  73. latencyRender,
  74. // Let the pdfCachingMetrics round trip to account for pdf-detach.
  75. pdfCachingMetrics: getPdfCachingMetrics(),
  76. })
  77. }
  78. const handlePagesinit = () => {
  79. setInitialised(true)
  80. timePDFFetched = performance.now()
  81. if (document.hidden) {
  82. // Rendering does not start in case we are hidden. See comment above.
  83. submitLatencies()
  84. }
  85. }
  86. const handleRendered = () => {
  87. if (!document.hidden) {
  88. // The render time is not accurate in case we are hidden. See above.
  89. timePDFRendered = performance.now()
  90. }
  91. submitLatencies()
  92. // Only get the times for the first page.
  93. pdfJsWrapper.eventBus.off('pagerendered', handleRendered)
  94. }
  95. // `pagesinit` fires when the data for rendering the first page is ready.
  96. pdfJsWrapper.eventBus.on('pagesinit', handlePagesinit)
  97. // `pagerendered` fires when a page was actually rendered.
  98. pdfJsWrapper.eventBus.on('pagerendered', handleRendered)
  99. return () => {
  100. pdfJsWrapper.eventBus.off('pagesinit', handlePagesinit)
  101. pdfJsWrapper.eventBus.off('pagerendered', handleRendered)
  102. }
  103. }, [pdfJsWrapper, firstRenderDone, startFetch])
  104. // load the PDF document from the URL
  105. useEffect(() => {
  106. if (pdfJsWrapper && url) {
  107. setInitialised(false)
  108. setError(undefined)
  109. setStartFetch(performance.now())
  110. const abortController = new AbortController()
  111. const handleFetchError = err => {
  112. if (abortController.signal.aborted) return
  113. // The error is already logged at the call-site with additional context.
  114. if (err instanceof pdfJsWrapper.PDFJS.MissingPDFException) {
  115. setError('rendering-error-expected')
  116. } else {
  117. setError('rendering-error')
  118. }
  119. }
  120. pdfJsWrapper
  121. .loadDocument({ url, pdfFile, abortController, handleFetchError })
  122. .catch(error => {
  123. if (abortController.signal.aborted) return
  124. debugConsole.error(error)
  125. setError('rendering-error')
  126. })
  127. return () => {
  128. abortController.abort()
  129. pdfJsWrapper.abortDocumentLoading()
  130. }
  131. }
  132. }, [pdfJsWrapper, url, pdfFile, setError, setStartFetch])
  133. // listen for scroll events
  134. useEffect(() => {
  135. let storePositionTimer
  136. if (initialised && pdfJsWrapper) {
  137. if (!pdfJsWrapper.isVisible()) {
  138. return
  139. }
  140. // store the scroll position in localStorage, for the synctex button
  141. const storePosition = debounce(pdfViewer => {
  142. // set position for "sync to code" button
  143. try {
  144. setPosition(pdfViewer.currentPosition)
  145. } catch (error) {
  146. // debugConsole.error(error)
  147. }
  148. }, 500)
  149. storePositionTimer = window.setTimeout(() => {
  150. storePosition(pdfJsWrapper)
  151. }, 100)
  152. const scrollListener = () => {
  153. storePosition(pdfJsWrapper)
  154. }
  155. pdfJsWrapper.container.addEventListener('scroll', scrollListener)
  156. return () => {
  157. pdfJsWrapper.container.removeEventListener('scroll', scrollListener)
  158. if (storePositionTimer) {
  159. window.clearTimeout(storePositionTimer)
  160. }
  161. storePosition.cancel()
  162. }
  163. }
  164. }, [setPosition, pdfJsWrapper, initialised])
  165. // listen for double-click events
  166. useEffect(() => {
  167. if (pdfJsWrapper) {
  168. const handleTextlayerrendered = textLayer => {
  169. // handle both versions for backwards-compatibility
  170. const textLayerDiv =
  171. textLayer.source.textLayerDiv ?? textLayer.source.textLayer.div
  172. const pageElement = textLayerDiv.closest('.page')
  173. if (!pageElement.dataset.listeningForDoubleClick) {
  174. pageElement.dataset.listeningForDoubleClick = true
  175. const doubleClickListener = event => {
  176. const clickPosition = pdfJsWrapper.clickPosition(
  177. event,
  178. pageElement,
  179. textLayer
  180. )
  181. if (clickPosition) {
  182. eventTracking.sendMB('jump-to-location', {
  183. direction: 'pdf-location-in-code',
  184. method: 'double-click',
  185. })
  186. window.dispatchEvent(
  187. new CustomEvent('synctex:sync-to-position', {
  188. detail: clickPosition,
  189. })
  190. )
  191. }
  192. }
  193. pageElement.addEventListener('dblclick', doubleClickListener)
  194. }
  195. }
  196. pdfJsWrapper.eventBus.on('textlayerrendered', handleTextlayerrendered)
  197. return () =>
  198. pdfJsWrapper.eventBus.off('textlayerrendered', handleTextlayerrendered)
  199. }
  200. }, [pdfJsWrapper])
  201. // restore the saved scale and scroll position
  202. const positionRef = useRef(position)
  203. useEffect(() => {
  204. positionRef.current = position
  205. }, [position])
  206. const scaleRef = useRef(scale)
  207. useEffect(() => {
  208. scaleRef.current = scale
  209. }, [scale])
  210. useEffect(() => {
  211. if (initialised && pdfJsWrapper) {
  212. if (!pdfJsWrapper.isVisible()) {
  213. return
  214. }
  215. if (positionRef.current) {
  216. pdfJsWrapper.scrollToPosition(positionRef.current, scaleRef.current)
  217. } else {
  218. pdfJsWrapper.viewer.currentScaleValue = scaleRef.current
  219. }
  220. }
  221. }, [initialised, pdfJsWrapper, scaleRef, positionRef])
  222. // transmit scale value to the viewer when it changes
  223. useEffect(() => {
  224. if (pdfJsWrapper) {
  225. pdfJsWrapper.viewer.currentScaleValue = scale
  226. }
  227. }, [scale, pdfJsWrapper])
  228. // when highlights are created, build the highlight elements
  229. useEffect(() => {
  230. const timers = []
  231. let intersectionObserver
  232. if (pdfJsWrapper && highlights?.length) {
  233. // watch for the highlight elements to scroll into view
  234. intersectionObserver = new IntersectionObserver(
  235. entries => {
  236. for (const entry of entries) {
  237. if (entry.isIntersecting) {
  238. intersectionObserver.unobserve(entry.target)
  239. // fade the element in and out
  240. entry.target.style.opacity = '0.5'
  241. timers.push(
  242. window.setTimeout(() => {
  243. entry.target.style.opacity = '0'
  244. }, 1000)
  245. )
  246. }
  247. }
  248. },
  249. {
  250. threshold: 1.0, // the whole element must be visible
  251. }
  252. )
  253. const elements = []
  254. for (const highlight of highlights) {
  255. try {
  256. const element = buildHighlightElement(highlight, pdfJsWrapper)
  257. elements.push(element)
  258. intersectionObserver.observe(element)
  259. } catch (error) {
  260. // ignore invalid highlights
  261. }
  262. }
  263. const [firstElement] = elements
  264. if (firstElement) {
  265. // scroll to the first highlighted element
  266. firstElement.scrollIntoView({
  267. block: 'center',
  268. inline: 'start',
  269. behavior: 'smooth',
  270. })
  271. }
  272. return () => {
  273. for (const timer of timers) {
  274. window.clearTimeout(timer)
  275. }
  276. for (const element of elements) {
  277. element.remove()
  278. }
  279. intersectionObserver?.disconnect()
  280. }
  281. }
  282. }, [highlights, pdfJsWrapper])
  283. // set the scale in response to zoom option changes
  284. const setZoom = useCallback(
  285. zoom => {
  286. switch (zoom) {
  287. case 'fit-width':
  288. setScale('page-width')
  289. break
  290. case 'fit-height':
  291. setScale('page-height')
  292. break
  293. case 'zoom-in':
  294. if (pdfJsWrapper) {
  295. setScale(pdfJsWrapper.viewer.currentScale * 1.25)
  296. }
  297. break
  298. case 'zoom-out':
  299. if (pdfJsWrapper) {
  300. setScale(pdfJsWrapper.viewer.currentScale * 0.75)
  301. }
  302. break
  303. }
  304. },
  305. [pdfJsWrapper, setScale]
  306. )
  307. // adjust the scale when the container is resized
  308. useEffect(() => {
  309. if (pdfJsWrapper && 'ResizeObserver' in window) {
  310. const resizeListener = () => {
  311. pdfJsWrapper.updateOnResize()
  312. }
  313. const resizeObserver = new ResizeObserver(resizeListener)
  314. resizeObserver.observe(pdfJsWrapper.container)
  315. window.addEventListener('resize', resizeListener)
  316. return () => {
  317. resizeObserver.disconnect()
  318. window.removeEventListener('resize', resizeListener)
  319. }
  320. }
  321. }, [pdfJsWrapper])
  322. const handleKeyDown = useCallback(
  323. event => {
  324. if (!initialised) {
  325. return
  326. }
  327. if (event.metaKey || event.ctrlKey) {
  328. switch (event.key) {
  329. case '=':
  330. event.preventDefault()
  331. setZoom('zoom-in')
  332. break
  333. case '-':
  334. event.preventDefault()
  335. setZoom('zoom-out')
  336. break
  337. case '0':
  338. event.preventDefault()
  339. setZoom('fit-width')
  340. break
  341. }
  342. }
  343. },
  344. [initialised, setZoom]
  345. )
  346. /* eslint-disable jsx-a11y/no-noninteractive-tabindex */
  347. /* eslint-disable jsx-a11y/no-noninteractive-element-interactions */
  348. return (
  349. <div className="pdfjs-viewer pdfjs-viewer-outer" ref={handleContainer}>
  350. <div
  351. className="pdfjs-viewer-inner"
  352. role="tabpanel"
  353. tabIndex="0"
  354. onKeyDown={handleKeyDown}
  355. >
  356. <div className="pdfViewer" />
  357. </div>
  358. <div className="pdfjs-controls" tabIndex="0">
  359. <PdfViewerControls setZoom={setZoom} />
  360. </div>
  361. </div>
  362. )
  363. }
  364. PdfJsViewer.propTypes = {
  365. url: PropTypes.string.isRequired,
  366. pdfFile: PropTypes.object,
  367. }
  368. export default withErrorBoundary(memo(PdfJsViewer), () => (
  369. <PdfPreviewErrorBoundaryFallback type="pdf" />
  370. ))