/* Copyright 2015 Mozilla Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { parseQueryString } from './ui_utils.js'
/**
* @typedef {Object} PDFLinkServiceOptions
* @property {EventBus} eventBus - The application event bus.
* @property {number} [externalLinkTarget] - Specifies the `target` attribute
* for external links. Must use one of the values from {LinkTarget}.
* Defaults to using no target.
* @property {string} [externalLinkRel] - Specifies the `rel` attribute for
* external links. Defaults to stripping the referrer.
* @property {boolean} [ignoreDestinationZoom] - Ignores the zoom argument,
* thus preserving the current zoom level in the viewer, when navigating
* to internal destinations. The default value is `false`.
*/
/**
* Performs navigation functions inside PDF, such as opening specified page,
* or destination.
* @implements {IPDFLinkService}
*/
class PDFLinkService {
/**
* @param {PDFLinkServiceOptions} options
*/
constructor({
eventBus,
externalLinkTarget = null,
externalLinkRel = null,
externalLinkEnabled = true,
ignoreDestinationZoom = false,
} = {}) {
this.eventBus = eventBus
this.externalLinkTarget = externalLinkTarget
this.externalLinkRel = externalLinkRel
this.externalLinkEnabled = externalLinkEnabled
this._ignoreDestinationZoom = ignoreDestinationZoom
this.baseUrl = null
this.pdfDocument = null
this.pdfViewer = null
this.pdfHistory = null
this._pagesRefCache = null
}
setDocument(pdfDocument, baseUrl = null) {
this.baseUrl = baseUrl
this.pdfDocument = pdfDocument
this._pagesRefCache = Object.create(null)
}
setViewer(pdfViewer) {
this.pdfViewer = pdfViewer
}
setHistory(pdfHistory) {
this.pdfHistory = pdfHistory
}
/**
* @type {number}
*/
get pagesCount() {
return this.pdfDocument ? this.pdfDocument.numPages : 0
}
/**
* @type {number}
*/
get page() {
return this.pdfViewer.currentPageNumber
}
/**
* @param {number} value
*/
set page(value) {
this.pdfViewer.currentPageNumber = value
}
/**
* @type {number}
*/
get rotation() {
return this.pdfViewer.pagesRotation
}
/**
* @param {number} value
*/
set rotation(value) {
this.pdfViewer.pagesRotation = value
}
/**
* @param {string|Array} dest - The named, or explicit, PDF destination.
*/
navigateTo(dest) {
const goToDestination = ({ namedDest, explicitDest }) => {
// Dest array looks like that: <page-ref> </XYZ|/FitXXX> <args..>
const destRef = explicitDest[0]
let pageNumber
if (destRef instanceof Object) {
pageNumber = this._cachedPageNumber(destRef)
if (pageNumber === null) {
// Fetch the page reference if it's not yet available. This could
// only occur during loading, before all pages have been resolved.
this.pdfDocument
.getPageIndex(destRef)
.then((pageIndex) => {
this.cachePageRef(pageIndex + 1, destRef)
goToDestination({ namedDest, explicitDest })
})
.catch(() => {
console.error(
`PDFLinkService.navigateTo: "${destRef}" is not ` +
`a valid page reference, for dest="${dest}".`
)
})
return
}
} else if (Number.isInteger(destRef)) {
pageNumber = destRef + 1
} else {
console.error(
`PDFLinkService.navigateTo: "${destRef}" is not ` +
`a valid destination reference, for dest="${dest}".`
)
return
}
if (!pageNumber || pageNumber < 1 || pageNumber > this.pagesCount) {
console.error(
`PDFLinkService.navigateTo: "${pageNumber}" is not ` +
`a valid page number, for dest="${dest}".`
)
return
}
if (this.pdfHistory) {
// Update the browser history before scrolling the new destination into
// view, to be able to accurately capture the current document position.
this.pdfHistory.pushCurrentPosition()
this.pdfHistory.push({ namedDest, explicitDest, pageNumber })
}
this.pdfViewer.scrollPageIntoView({
pageNumber,
destArray: explicitDest,
ignoreDestinationZoom: this._ignoreDestinationZoom,
})
}
new Promise((resolve, reject) => {
if (typeof dest === 'string') {
this.pdfDocument.getDestination(dest).then((destArray) => {
resolve({
namedDest: dest,
explicitDest: destArray,
})
})
return
}
resolve({
namedDest: '',
explicitDest: dest,
})
}).then((data) => {
if (!Array.isArray(data.explicitDest)) {
console.error(
`PDFLinkService.navigateTo: "${data.explicitDest}" is` +
` not a valid destination array, for dest="${dest}".`
)
return
}
goToDestination(data)
})
}
/**
* @param {string|Array} dest - The PDF destination object.
* @returns {string} The hyperlink to the PDF object.
*/
getDestinationHash(dest) {
if (typeof dest === 'string') {
return this.getAnchorUrl('#' + escape(dest))
}
if (Array.isArray(dest)) {
const str = JSON.stringify(dest)
return this.getAnchorUrl('#' + escape(str))
}
return this.getAnchorUrl('')
}
/**
* Prefix the full url on anchor links to make sure that links are resolved
* relative to the current URL instead of the one defined in <base href>.
* @param {string} anchor The anchor hash, including the #.
* @returns {string} The hyperlink to the PDF object.
*/
getAnchorUrl(anchor) {
return (this.baseUrl || '') + anchor
}
/**
* @param {string} hash
*/
setHash(hash) {
let pageNumber, dest
if (hash.includes('=')) {
const params = parseQueryString(hash)
if ('search' in params) {
this.eventBus.dispatch('findfromurlhash', {
source: this,
query: params.search.replace(/"/g, ''),
phraseSearch: params.phrase === 'true',
})
}
// borrowing syntax from "Parameters for Opening PDF Files"
if ('page' in params) {
pageNumber = params.page | 0 || 1
}
if ('zoom' in params) {
// Build the destination array.
const zoomArgs = params.zoom.split(',') // scale,left,top
const zoomArg = zoomArgs[0]
const zoomArgNumber = parseFloat(zoomArg)
if (!zoomArg.includes('Fit')) {
// If the zoomArg is a number, it has to get divided by 100. If it's
// a string, it should stay as it is.
dest = [
null,
{ name: 'XYZ' },
zoomArgs.length > 1 ? zoomArgs[1] | 0 : null,
zoomArgs.length > 2 ? zoomArgs[2] | 0 : null,
zoomArgNumber ? zoomArgNumber / 100 : zoomArg,
]
} else {
if (zoomArg === 'Fit' || zoomArg === 'FitB') {
dest = [null, { name: zoomArg }]
} else if (
zoomArg === 'FitH' ||
zoomArg === 'FitBH' ||
zoomArg === 'FitV' ||
zoomArg === 'FitBV'
) {
dest = [
null,
{ name: zoomArg },
zoomArgs.length > 1 ? zoomArgs[1] | 0 : null,
]
} else if (zoomArg === 'FitR') {
if (zoomArgs.length !== 5) {
console.error(
'PDFLinkService.setHash: Not enough parameters for "FitR".'
)
} else {
dest = [
null,
{ name: zoomArg },
zoomArgs[1] | 0,
zoomArgs[2] | 0,
zoomArgs[3] | 0,
zoomArgs[4] | 0,
]
}
} else {
console.error(
`PDFLinkService.setHash: "${zoomArg}" is not ` +
'a valid zoom value.'
)
}
}
}
if (dest) {
this.pdfViewer.scrollPageIntoView({
pageNumber: pageNumber || this.page,
destArray: dest,
allowNegativeOffset: true,
})
} else if (pageNumber) {
this.page = pageNumber // simple page
}
if ('pagemode' in params) {
this.eventBus.dispatch('pagemode', {
source: this,
mode: params.pagemode,
})
}
// Ensure that this parameter is *always* handled last, in order to
// guarantee that it won't be overridden (e.g. by the "page" parameter).
if ('nameddest' in params) {
this.navigateTo(params.nameddest)
}
} else {
// Named (or explicit) destination.
dest = unescape(hash)
try {
dest = JSON.parse(dest)
if (!Array.isArray(dest)) {
// Avoid incorrectly rejecting a valid named destination, such as
// e.g. "4.3" or "true", because `JSON.parse` converted its type.
dest = dest.toString()
}
} catch (ex) {}
if (typeof dest === 'string' || isValidExplicitDestination(dest)) {
this.navigateTo(dest)
return
}
console.error(
`PDFLinkService.setHash: "${unescape(hash)}" is not ` +
'a valid destination.'
)
}
}
/**
* @param {string} action
*/
executeNamedAction(action) {
// See PDF reference, table 8.45 - Named action
switch (action) {
case 'GoBack':
if (this.pdfHistory) {
this.pdfHistory.back()
}
break
case 'GoForward':
if (this.pdfHistory) {
this.pdfHistory.forward()
}
break
case 'NextPage':
if (this.page < this.pagesCount) {
this.page++
}
break
case 'PrevPage':
if (this.page > 1) {
this.page--
}
break
case 'LastPage':
this.page = this.pagesCount
break
case 'FirstPage':
this.page = 1
break
default:
break // No action according to spec
}
this.eventBus.dispatch('namedaction', {
source: this,
action,
})
}
/**
* @param {number} pageNum - page number.
* @param {Object} pageRef - reference to the page.
*/
cachePageRef(pageNum, pageRef) {
if (!pageRef) {
return
}
const refStr =
pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`
this._pagesRefCache[refStr] = pageNum
}
_cachedPageNumber(pageRef) {
const refStr =
pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`
return (this._pagesRefCache && this._pagesRefCache[refStr]) || null
}
/**
* @param {number} pageNumber
*/
isPageVisible(pageNumber) {
return this.pdfViewer.isPageVisible(pageNumber)
}
}
function isValidExplicitDestination(dest) {
if (!Array.isArray(dest)) {
return false
}
const destLength = dest.length
if (destLength < 2) {
return false
}
const page = dest[0]
if (
!(
typeof page === 'object' &&
Number.isInteger(page.num) &&
Number.isInteger(page.gen)
) &&
!(Number.isInteger(page) && page >= 0)
) {
return false
}
const zoom = dest[1]
if (!(typeof zoom === 'object' && typeof zoom.name === 'string')) {
return false
}
let allowNull = true
switch (zoom.name) {
case 'XYZ':
if (destLength !== 5) {
return false
}
break
case 'Fit':
case 'FitB':
return destLength === 2
case 'FitH':
case 'FitBH':
case 'FitV':
case 'FitBV':
if (destLength !== 3) {
return false
}
break
case 'FitR':
if (destLength !== 6) {
return false
}
allowNull = false
break
default:
return false
}
for (let i = 2; i < destLength; i++) {
const param = dest[i]
if (!(typeof param === 'number' || (allowNull && param === null))) {
return false
}
}
return true
}
/**
* @implements {IPDFLinkService}
*/
class SimpleLinkService {
constructor() {
this.externalLinkTarget = null
this.externalLinkRel = null
this.externalLinkEnabled = true
this._ignoreDestinationZoom = false
}
/**
* @type {number}
*/
get pagesCount() {
return 0
}
/**
* @type {number}
*/
get page() {
return 0
}
/**
* @param {number} value
*/
set page(value) {}
/**
* @type {number}
*/
get rotation() {
return 0
}
/**
* @param {number} value
*/
set rotation(value) {}
/**
* @param dest - The PDF destination object.
*/
navigateTo(dest) {}
/**
* @param dest - The PDF destination object.
* @returns {string} The hyperlink to the PDF object.
*/
getDestinationHash(dest) {
return '#'
}
/**
* @param hash - The PDF parameters/hash.
* @returns {string} The hyperlink to the PDF object.
*/
getAnchorUrl(hash) {
return '#'
}
/**
* @param {string} hash
*/
setHash(hash) {}
/**
* @param {string} action
*/
executeNamedAction(action) {}
/**
* @param {number} pageNum - page number.
* @param {Object} pageRef - reference to the page.
*/
cachePageRef(pageNum, pageRef) {}
/**
* @param {number} pageNumber
*/
isPageVisible(pageNumber) {
return true
}
}
export { PDFLinkService, SimpleLinkService }