625 lines
14 KiB
JavaScript
625 lines
14 KiB
JavaScript
/**
|
|
* @licstart The following is the entire license notice for the
|
|
* JavaScript code in this page
|
|
*
|
|
* Copyright 2022 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.
|
|
*
|
|
* @licend The above is the entire license notice for the
|
|
* JavaScript code in this page
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.PDFHistory = void 0;
|
|
exports.isDestArraysEqual = isDestArraysEqual;
|
|
exports.isDestHashesEqual = isDestHashesEqual;
|
|
|
|
var _ui_utils = require("./ui_utils.js");
|
|
|
|
var _event_utils = require("./event_utils.js");
|
|
|
|
const HASH_CHANGE_TIMEOUT = 1000;
|
|
const POSITION_UPDATED_THRESHOLD = 50;
|
|
const UPDATE_VIEWAREA_TIMEOUT = 1000;
|
|
|
|
function getCurrentHash() {
|
|
return document.location.hash;
|
|
}
|
|
|
|
class PDFHistory {
|
|
constructor({
|
|
linkService,
|
|
eventBus
|
|
}) {
|
|
this.linkService = linkService;
|
|
this.eventBus = eventBus;
|
|
this._initialized = false;
|
|
this._fingerprint = "";
|
|
this.reset();
|
|
this._boundEvents = null;
|
|
|
|
this.eventBus._on("pagesinit", () => {
|
|
this._isPagesLoaded = false;
|
|
|
|
this.eventBus._on("pagesloaded", evt => {
|
|
this._isPagesLoaded = !!evt.pagesCount;
|
|
}, {
|
|
once: true
|
|
});
|
|
});
|
|
}
|
|
|
|
initialize({
|
|
fingerprint,
|
|
resetHistory = false,
|
|
updateUrl = false
|
|
}) {
|
|
if (!fingerprint || typeof fingerprint !== "string") {
|
|
console.error('PDFHistory.initialize: The "fingerprint" must be a non-empty string.');
|
|
return;
|
|
}
|
|
|
|
if (this._initialized) {
|
|
this.reset();
|
|
}
|
|
|
|
const reInitialized = this._fingerprint !== "" && this._fingerprint !== fingerprint;
|
|
this._fingerprint = fingerprint;
|
|
this._updateUrl = updateUrl === true;
|
|
this._initialized = true;
|
|
|
|
this._bindEvents();
|
|
|
|
const state = window.history.state;
|
|
this._popStateInProgress = false;
|
|
this._blockHashChange = 0;
|
|
this._currentHash = getCurrentHash();
|
|
this._numPositionUpdates = 0;
|
|
this._uid = this._maxUid = 0;
|
|
this._destination = null;
|
|
this._position = null;
|
|
|
|
if (!this._isValidState(state, true) || resetHistory) {
|
|
const {
|
|
hash,
|
|
page,
|
|
rotation
|
|
} = this._parseCurrentHash(true);
|
|
|
|
if (!hash || reInitialized || resetHistory) {
|
|
this._pushOrReplaceState(null, true);
|
|
|
|
return;
|
|
}
|
|
|
|
this._pushOrReplaceState({
|
|
hash,
|
|
page,
|
|
rotation
|
|
}, true);
|
|
|
|
return;
|
|
}
|
|
|
|
const destination = state.destination;
|
|
|
|
this._updateInternalState(destination, state.uid, true);
|
|
|
|
if (destination.rotation !== undefined) {
|
|
this._initialRotation = destination.rotation;
|
|
}
|
|
|
|
if (destination.dest) {
|
|
this._initialBookmark = JSON.stringify(destination.dest);
|
|
this._destination.page = null;
|
|
} else if (destination.hash) {
|
|
this._initialBookmark = destination.hash;
|
|
} else if (destination.page) {
|
|
this._initialBookmark = `page=${destination.page}`;
|
|
}
|
|
}
|
|
|
|
reset() {
|
|
if (this._initialized) {
|
|
this._pageHide();
|
|
|
|
this._initialized = false;
|
|
|
|
this._unbindEvents();
|
|
}
|
|
|
|
if (this._updateViewareaTimeout) {
|
|
clearTimeout(this._updateViewareaTimeout);
|
|
this._updateViewareaTimeout = null;
|
|
}
|
|
|
|
this._initialBookmark = null;
|
|
this._initialRotation = null;
|
|
}
|
|
|
|
push({
|
|
namedDest = null,
|
|
explicitDest,
|
|
pageNumber
|
|
}) {
|
|
if (!this._initialized) {
|
|
return;
|
|
}
|
|
|
|
if (namedDest && typeof namedDest !== "string") {
|
|
console.error("PDFHistory.push: " + `"${namedDest}" is not a valid namedDest parameter.`);
|
|
return;
|
|
} else if (!Array.isArray(explicitDest)) {
|
|
console.error("PDFHistory.push: " + `"${explicitDest}" is not a valid explicitDest parameter.`);
|
|
return;
|
|
} else if (!this._isValidPage(pageNumber)) {
|
|
if (pageNumber !== null || this._destination) {
|
|
console.error("PDFHistory.push: " + `"${pageNumber}" is not a valid pageNumber parameter.`);
|
|
return;
|
|
}
|
|
}
|
|
|
|
const hash = namedDest || JSON.stringify(explicitDest);
|
|
|
|
if (!hash) {
|
|
return;
|
|
}
|
|
|
|
let forceReplace = false;
|
|
|
|
if (this._destination && (isDestHashesEqual(this._destination.hash, hash) || isDestArraysEqual(this._destination.dest, explicitDest))) {
|
|
if (this._destination.page) {
|
|
return;
|
|
}
|
|
|
|
forceReplace = true;
|
|
}
|
|
|
|
if (this._popStateInProgress && !forceReplace) {
|
|
return;
|
|
}
|
|
|
|
this._pushOrReplaceState({
|
|
dest: explicitDest,
|
|
hash,
|
|
page: pageNumber,
|
|
rotation: this.linkService.rotation
|
|
}, forceReplace);
|
|
|
|
if (!this._popStateInProgress) {
|
|
this._popStateInProgress = true;
|
|
Promise.resolve().then(() => {
|
|
this._popStateInProgress = false;
|
|
});
|
|
}
|
|
}
|
|
|
|
pushPage(pageNumber) {
|
|
if (!this._initialized) {
|
|
return;
|
|
}
|
|
|
|
if (!this._isValidPage(pageNumber)) {
|
|
console.error(`PDFHistory.pushPage: "${pageNumber}" is not a valid page number.`);
|
|
return;
|
|
}
|
|
|
|
if (this._destination?.page === pageNumber) {
|
|
return;
|
|
}
|
|
|
|
if (this._popStateInProgress) {
|
|
return;
|
|
}
|
|
|
|
this._pushOrReplaceState({
|
|
dest: null,
|
|
hash: `page=${pageNumber}`,
|
|
page: pageNumber,
|
|
rotation: this.linkService.rotation
|
|
});
|
|
|
|
if (!this._popStateInProgress) {
|
|
this._popStateInProgress = true;
|
|
Promise.resolve().then(() => {
|
|
this._popStateInProgress = false;
|
|
});
|
|
}
|
|
}
|
|
|
|
pushCurrentPosition() {
|
|
if (!this._initialized || this._popStateInProgress) {
|
|
return;
|
|
}
|
|
|
|
this._tryPushCurrentPosition();
|
|
}
|
|
|
|
back() {
|
|
if (!this._initialized || this._popStateInProgress) {
|
|
return;
|
|
}
|
|
|
|
const state = window.history.state;
|
|
|
|
if (this._isValidState(state) && state.uid > 0) {
|
|
window.history.back();
|
|
}
|
|
}
|
|
|
|
forward() {
|
|
if (!this._initialized || this._popStateInProgress) {
|
|
return;
|
|
}
|
|
|
|
const state = window.history.state;
|
|
|
|
if (this._isValidState(state) && state.uid < this._maxUid) {
|
|
window.history.forward();
|
|
}
|
|
}
|
|
|
|
get popStateInProgress() {
|
|
return this._initialized && (this._popStateInProgress || this._blockHashChange > 0);
|
|
}
|
|
|
|
get initialBookmark() {
|
|
return this._initialized ? this._initialBookmark : null;
|
|
}
|
|
|
|
get initialRotation() {
|
|
return this._initialized ? this._initialRotation : null;
|
|
}
|
|
|
|
_pushOrReplaceState(destination, forceReplace = false) {
|
|
const shouldReplace = forceReplace || !this._destination;
|
|
const newState = {
|
|
fingerprint: this._fingerprint,
|
|
uid: shouldReplace ? this._uid : this._uid + 1,
|
|
destination
|
|
};
|
|
|
|
this._updateInternalState(destination, newState.uid);
|
|
|
|
let newUrl;
|
|
|
|
if (this._updateUrl && destination?.hash) {
|
|
const baseUrl = document.location.href.split("#")[0];
|
|
|
|
if (!baseUrl.startsWith("file://")) {
|
|
newUrl = `${baseUrl}#${destination.hash}`;
|
|
}
|
|
}
|
|
|
|
if (shouldReplace) {
|
|
window.history.replaceState(newState, "", newUrl);
|
|
} else {
|
|
window.history.pushState(newState, "", newUrl);
|
|
}
|
|
}
|
|
|
|
_tryPushCurrentPosition(temporary = false) {
|
|
if (!this._position) {
|
|
return;
|
|
}
|
|
|
|
let position = this._position;
|
|
|
|
if (temporary) {
|
|
position = Object.assign(Object.create(null), this._position);
|
|
position.temporary = true;
|
|
}
|
|
|
|
if (!this._destination) {
|
|
this._pushOrReplaceState(position);
|
|
|
|
return;
|
|
}
|
|
|
|
if (this._destination.temporary) {
|
|
this._pushOrReplaceState(position, true);
|
|
|
|
return;
|
|
}
|
|
|
|
if (this._destination.hash === position.hash) {
|
|
return;
|
|
}
|
|
|
|
if (!this._destination.page && (POSITION_UPDATED_THRESHOLD <= 0 || this._numPositionUpdates <= POSITION_UPDATED_THRESHOLD)) {
|
|
return;
|
|
}
|
|
|
|
let forceReplace = false;
|
|
|
|
if (this._destination.page >= position.first && this._destination.page <= position.page) {
|
|
if (this._destination.dest !== undefined || !this._destination.first) {
|
|
return;
|
|
}
|
|
|
|
forceReplace = true;
|
|
}
|
|
|
|
this._pushOrReplaceState(position, forceReplace);
|
|
}
|
|
|
|
_isValidPage(val) {
|
|
return Number.isInteger(val) && val > 0 && val <= this.linkService.pagesCount;
|
|
}
|
|
|
|
_isValidState(state, checkReload = false) {
|
|
if (!state) {
|
|
return false;
|
|
}
|
|
|
|
if (state.fingerprint !== this._fingerprint) {
|
|
if (checkReload) {
|
|
if (typeof state.fingerprint !== "string" || state.fingerprint.length !== this._fingerprint.length) {
|
|
return false;
|
|
}
|
|
|
|
const [perfEntry] = performance.getEntriesByType("navigation");
|
|
|
|
if (perfEntry?.type !== "reload") {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!Number.isInteger(state.uid) || state.uid < 0) {
|
|
return false;
|
|
}
|
|
|
|
if (state.destination === null || typeof state.destination !== "object") {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
_updateInternalState(destination, uid, removeTemporary = false) {
|
|
if (this._updateViewareaTimeout) {
|
|
clearTimeout(this._updateViewareaTimeout);
|
|
this._updateViewareaTimeout = null;
|
|
}
|
|
|
|
if (removeTemporary && destination?.temporary) {
|
|
delete destination.temporary;
|
|
}
|
|
|
|
this._destination = destination;
|
|
this._uid = uid;
|
|
this._maxUid = Math.max(this._maxUid, uid);
|
|
this._numPositionUpdates = 0;
|
|
}
|
|
|
|
_parseCurrentHash(checkNameddest = false) {
|
|
const hash = unescape(getCurrentHash()).substring(1);
|
|
const params = (0, _ui_utils.parseQueryString)(hash);
|
|
const nameddest = params.get("nameddest") || "";
|
|
let page = params.get("page") | 0;
|
|
|
|
if (!this._isValidPage(page) || checkNameddest && nameddest.length > 0) {
|
|
page = null;
|
|
}
|
|
|
|
return {
|
|
hash,
|
|
page,
|
|
rotation: this.linkService.rotation
|
|
};
|
|
}
|
|
|
|
_updateViewarea({
|
|
location
|
|
}) {
|
|
if (this._updateViewareaTimeout) {
|
|
clearTimeout(this._updateViewareaTimeout);
|
|
this._updateViewareaTimeout = null;
|
|
}
|
|
|
|
this._position = {
|
|
hash: location.pdfOpenParams.substring(1),
|
|
page: this.linkService.page,
|
|
first: location.pageNumber,
|
|
rotation: location.rotation
|
|
};
|
|
|
|
if (this._popStateInProgress) {
|
|
return;
|
|
}
|
|
|
|
if (POSITION_UPDATED_THRESHOLD > 0 && this._isPagesLoaded && this._destination && !this._destination.page) {
|
|
this._numPositionUpdates++;
|
|
}
|
|
|
|
if (UPDATE_VIEWAREA_TIMEOUT > 0) {
|
|
this._updateViewareaTimeout = setTimeout(() => {
|
|
if (!this._popStateInProgress) {
|
|
this._tryPushCurrentPosition(true);
|
|
}
|
|
|
|
this._updateViewareaTimeout = null;
|
|
}, UPDATE_VIEWAREA_TIMEOUT);
|
|
}
|
|
}
|
|
|
|
_popState({
|
|
state
|
|
}) {
|
|
const newHash = getCurrentHash(),
|
|
hashChanged = this._currentHash !== newHash;
|
|
this._currentHash = newHash;
|
|
|
|
if (!state) {
|
|
this._uid++;
|
|
|
|
const {
|
|
hash,
|
|
page,
|
|
rotation
|
|
} = this._parseCurrentHash();
|
|
|
|
this._pushOrReplaceState({
|
|
hash,
|
|
page,
|
|
rotation
|
|
}, true);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!this._isValidState(state)) {
|
|
return;
|
|
}
|
|
|
|
this._popStateInProgress = true;
|
|
|
|
if (hashChanged) {
|
|
this._blockHashChange++;
|
|
(0, _event_utils.waitOnEventOrTimeout)({
|
|
target: window,
|
|
name: "hashchange",
|
|
delay: HASH_CHANGE_TIMEOUT
|
|
}).then(() => {
|
|
this._blockHashChange--;
|
|
});
|
|
}
|
|
|
|
const destination = state.destination;
|
|
|
|
this._updateInternalState(destination, state.uid, true);
|
|
|
|
if ((0, _ui_utils.isValidRotation)(destination.rotation)) {
|
|
this.linkService.rotation = destination.rotation;
|
|
}
|
|
|
|
if (destination.dest) {
|
|
this.linkService.goToDestination(destination.dest);
|
|
} else if (destination.hash) {
|
|
this.linkService.setHash(destination.hash);
|
|
} else if (destination.page) {
|
|
this.linkService.page = destination.page;
|
|
}
|
|
|
|
Promise.resolve().then(() => {
|
|
this._popStateInProgress = false;
|
|
});
|
|
}
|
|
|
|
_pageHide() {
|
|
if (!this._destination || this._destination.temporary) {
|
|
this._tryPushCurrentPosition();
|
|
}
|
|
}
|
|
|
|
_bindEvents() {
|
|
if (this._boundEvents) {
|
|
return;
|
|
}
|
|
|
|
this._boundEvents = {
|
|
updateViewarea: this._updateViewarea.bind(this),
|
|
popState: this._popState.bind(this),
|
|
pageHide: this._pageHide.bind(this)
|
|
};
|
|
|
|
this.eventBus._on("updateviewarea", this._boundEvents.updateViewarea);
|
|
|
|
window.addEventListener("popstate", this._boundEvents.popState);
|
|
window.addEventListener("pagehide", this._boundEvents.pageHide);
|
|
}
|
|
|
|
_unbindEvents() {
|
|
if (!this._boundEvents) {
|
|
return;
|
|
}
|
|
|
|
this.eventBus._off("updateviewarea", this._boundEvents.updateViewarea);
|
|
|
|
window.removeEventListener("popstate", this._boundEvents.popState);
|
|
window.removeEventListener("pagehide", this._boundEvents.pageHide);
|
|
this._boundEvents = null;
|
|
}
|
|
|
|
}
|
|
|
|
exports.PDFHistory = PDFHistory;
|
|
|
|
function isDestHashesEqual(destHash, pushHash) {
|
|
if (typeof destHash !== "string" || typeof pushHash !== "string") {
|
|
return false;
|
|
}
|
|
|
|
if (destHash === pushHash) {
|
|
return true;
|
|
}
|
|
|
|
const nameddest = (0, _ui_utils.parseQueryString)(destHash).get("nameddest");
|
|
|
|
if (nameddest === pushHash) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function isDestArraysEqual(firstDest, secondDest) {
|
|
function isEntryEqual(first, second) {
|
|
if (typeof first !== typeof second) {
|
|
return false;
|
|
}
|
|
|
|
if (Array.isArray(first) || Array.isArray(second)) {
|
|
return false;
|
|
}
|
|
|
|
if (first !== null && typeof first === "object" && second !== null) {
|
|
if (Object.keys(first).length !== Object.keys(second).length) {
|
|
return false;
|
|
}
|
|
|
|
for (const key in first) {
|
|
if (!isEntryEqual(first[key], second[key])) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return first === second || Number.isNaN(first) && Number.isNaN(second);
|
|
}
|
|
|
|
if (!(Array.isArray(firstDest) && Array.isArray(secondDest))) {
|
|
return false;
|
|
}
|
|
|
|
if (firstDest.length !== secondDest.length) {
|
|
return false;
|
|
}
|
|
|
|
for (let i = 0, ii = firstDest.length; i < ii; i++) {
|
|
if (!isEntryEqual(firstDest[i], secondDest[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
} |