pdfjs-dist 2.1.266 → 2.5.207

package/lib/web/pdf_print_service.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,43 +26,43 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFPrintService = PDFPrintService;
 
-var _ui_utils = require("./ui_utils");
+var _ui_utils = require("./ui_utils.js");
 
-var _app = require("./app");
+var _app = require("./app.js");
 
-var _pdf = require("../pdf");
+var _app_options = require("./app_options.js");
 
-var activeService = null;
-var overlayManager = null;
+let activeService = null;
+let overlayManager = null;
 
 function renderPage(activeServiceOnEntry, pdfDocument, pageNumber, size) {
-  var scratchCanvas = activeService.scratchCanvas;
-  var PRINT_RESOLUTION = 150;
-  var PRINT_UNITS = PRINT_RESOLUTION / 72.0;
+  const scratchCanvas = activeService.scratchCanvas;
+  const PRINT_RESOLUTION = _app_options.AppOptions.get("printResolution") || 150;
+  const PRINT_UNITS = PRINT_RESOLUTION / 72.0;
   scratchCanvas.width = Math.floor(size.width * PRINT_UNITS);
   scratchCanvas.height = Math.floor(size.height * PRINT_UNITS);
-  var width = Math.floor(size.width * _ui_utils.CSS_UNITS) + 'px';
-  var height = Math.floor(size.height * _ui_utils.CSS_UNITS) + 'px';
-  var ctx = scratchCanvas.getContext('2d');
+  const width = Math.floor(size.width * _ui_utils.CSS_UNITS) + "px";
+  const height = Math.floor(size.height * _ui_utils.CSS_UNITS) + "px";
+  const ctx = scratchCanvas.getContext("2d");
   ctx.save();
-  ctx.fillStyle = 'rgb(255, 255, 255)';
+  ctx.fillStyle = "rgb(255, 255, 255)";
   ctx.fillRect(0, 0, scratchCanvas.width, scratchCanvas.height);
   ctx.restore();
   return pdfDocument.getPage(pageNumber).then(function (pdfPage) {
-    var renderContext = {
+    const renderContext = {
       canvasContext: ctx,
       transform: [PRINT_UNITS, 0, 0, PRINT_UNITS, 0, 0],
       viewport: pdfPage.getViewport({
         scale: 1,
         rotation: size.rotation
       }),
-      intent: 'print'
+      intent: "print"
     };
     return pdfPage.render(renderContext).promise;
   }).then(function () {
     return {
-      width: width,
-      height: height
+      width,
+      height
     };
   });
 }
@@ -72,35 +72,38 @@ function PDFPrintService(pdfDocument, pagesOverview, printContainer, l10n) {
   this.pagesOverview = pagesOverview;
   this.printContainer = printContainer;
   this.l10n = l10n || _ui_utils.NullL10n;
-  this.disableCreateObjectURL = pdfDocument.loadingParams['disableCreateObjectURL'];
+  this.disableCreateObjectURL = _app_options.AppOptions.get("disableCreateObjectURL");
   this.currentPage = -1;
-  this.scratchCanvas = document.createElement('canvas');
+  this.scratchCanvas = document.createElement("canvas");
 }
 
 PDFPrintService.prototype = {
-  layout: function layout() {
+  layout() {
     this.throwIfInactive();
-    var body = document.querySelector('body');
-    body.setAttribute('data-pdfjsprinting', true);
-    var hasEqualPageSizes = this.pagesOverview.every(function (size) {
+    const body = document.querySelector("body");
+    body.setAttribute("data-pdfjsprinting", true);
+    const hasEqualPageSizes = this.pagesOverview.every(function (size) {
       return size.width === this.pagesOverview[0].width && size.height === this.pagesOverview[0].height;
     }, this);
 
     if (!hasEqualPageSizes) {
-      console.warn('Not all pages have the same size. The printed ' + 'result may be incorrect!');
+      console.warn("Not all pages have the same size. The printed " + "result may be incorrect!");
     }
 
-    this.pageStyleSheet = document.createElement('style');
-    var pageSize = this.pagesOverview[0];
-    this.pageStyleSheet.textContent = '@supports ((size:A4) and (size:1pt 1pt)) {' + '@page { size: ' + pageSize.width + 'pt ' + pageSize.height + 'pt;}' + '}';
+    this.pageStyleSheet = document.createElement("style");
+    const pageSize = this.pagesOverview[0];
+    this.pageStyleSheet.textContent = "@supports ((size:A4) and (size:1pt 1pt)) {" + "@page { size: " + pageSize.width + "pt " + pageSize.height + "pt;}" + "}";
     body.appendChild(this.pageStyleSheet);
   },
-  destroy: function destroy() {
+
+  destroy() {
     if (activeService !== this) {
       return;
     }
 
-    this.printContainer.textContent = '';
+    this.printContainer.textContent = "";
+    const body = document.querySelector("body");
+    body.removeAttribute("data-pdfjsprinting");
 
     if (this.pageStyleSheet) {
       this.pageStyleSheet.remove();
@@ -111,52 +114,52 @@ PDFPrintService.prototype = {
     this.scratchCanvas = null;
     activeService = null;
     ensureOverlay().then(function () {
-      if (overlayManager.active !== 'printServiceOverlay') {
+      if (overlayManager.active !== "printServiceOverlay") {
         return;
       }
 
-      overlayManager.close('printServiceOverlay');
+      overlayManager.close("printServiceOverlay");
     });
   },
-  renderPages: function renderPages() {
-    var _this = this;
 
-    var pageCount = this.pagesOverview.length;
+  renderPages() {
+    const pageCount = this.pagesOverview.length;
 
-    var renderNextPage = function renderNextPage(resolve, reject) {
-      _this.throwIfInactive();
+    const renderNextPage = (resolve, reject) => {
+      this.throwIfInactive();
 
-      if (++_this.currentPage >= pageCount) {
-        renderProgress(pageCount, pageCount, _this.l10n);
+      if (++this.currentPage >= pageCount) {
+        renderProgress(pageCount, pageCount, this.l10n);
         resolve();
         return;
       }
 
-      var index = _this.currentPage;
-      renderProgress(index, pageCount, _this.l10n);
-      renderPage(_this, _this.pdfDocument, index + 1, _this.pagesOverview[index]).then(_this.useRenderedPage.bind(_this)).then(function () {
+      const index = this.currentPage;
+      renderProgress(index, pageCount, this.l10n);
+      renderPage(this, this.pdfDocument, index + 1, this.pagesOverview[index]).then(this.useRenderedPage.bind(this)).then(function () {
         renderNextPage(resolve, reject);
       }, reject);
     };
 
     return new Promise(renderNextPage);
   },
-  useRenderedPage: function useRenderedPage(printItem) {
+
+  useRenderedPage(printItem) {
     this.throwIfInactive();
-    var img = document.createElement('img');
+    const img = document.createElement("img");
     img.style.width = printItem.width;
     img.style.height = printItem.height;
-    var scratchCanvas = this.scratchCanvas;
+    const scratchCanvas = this.scratchCanvas;
 
-    if ('toBlob' in scratchCanvas && !this.disableCreateObjectURL) {
+    if ("toBlob" in scratchCanvas && !this.disableCreateObjectURL) {
       scratchCanvas.toBlob(function (blob) {
-        img.src = _pdf.URL.createObjectURL(blob);
+        img.src = URL.createObjectURL(blob);
       });
     } else {
       img.src = scratchCanvas.toDataURL();
     }
 
-    var wrapper = document.createElement('div');
+    const wrapper = document.createElement("div");
     wrapper.appendChild(img);
     this.printContainer.appendChild(wrapper);
     return new Promise(function (resolve, reject) {
@@ -164,13 +167,12 @@ PDFPrintService.prototype = {
       img.onerror = reject;
     });
   },
-  performPrint: function performPrint() {
-    var _this2 = this;
 
+  performPrint() {
     this.throwIfInactive();
-    return new Promise(function (resolve) {
-      setTimeout(function () {
-        if (!_this2.active) {
+    return new Promise(resolve => {
+      setTimeout(() => {
+        if (!this.active) {
           resolve();
           return;
         }
@@ -185,40 +187,41 @@ PDFPrintService.prototype = {
     return this === activeService;
   },
 
-  throwIfInactive: function throwIfInactive() {
+  throwIfInactive() {
     if (!this.active) {
-      throw new Error('This print request was cancelled or completed.');
+      throw new Error("This print request was cancelled or completed.");
     }
   }
+
 };
-var print = window.print;
+const print = window.print;
 
-window.print = function print() {
+window.print = function () {
   if (activeService) {
-    console.warn('Ignored window.print() because of a pending print job.');
+    console.warn("Ignored window.print() because of a pending print job.");
     return;
   }
 
   ensureOverlay().then(function () {
     if (activeService) {
-      overlayManager.open('printServiceOverlay');
+      overlayManager.open("printServiceOverlay");
     }
   });
 
   try {
-    dispatchEvent('beforeprint');
+    dispatchEvent("beforeprint");
   } finally {
     if (!activeService) {
-      console.error('Expected print service to be initialized.');
+      console.error("Expected print service to be initialized.");
       ensureOverlay().then(function () {
-        if (overlayManager.active === 'printServiceOverlay') {
-          overlayManager.close('printServiceOverlay');
+        if (overlayManager.active === "printServiceOverlay") {
+          overlayManager.close("printServiceOverlay");
         }
       });
       return;
     }
 
-    var activeServiceOnEntry = activeService;
+    const activeServiceOnEntry = activeService;
     activeService.renderPages().then(function () {
       return activeServiceOnEntry.performPrint();
     }).catch(function () {}).then(function () {
@@ -230,40 +233,34 @@ window.print = function print() {
 };
 
 function dispatchEvent(eventType) {
-  var event = document.createEvent('CustomEvent');
-  event.initCustomEvent(eventType, false, false, 'custom');
+  const event = document.createEvent("CustomEvent");
+  event.initCustomEvent(eventType, false, false, "custom");
   window.dispatchEvent(event);
 }
 
 function abort() {
   if (activeService) {
     activeService.destroy();
-    dispatchEvent('afterprint');
+    dispatchEvent("afterprint");
   }
 }
 
 function renderProgress(index, total, l10n) {
-  var progressContainer = document.getElementById('printServiceOverlay');
-  var progress = Math.round(100 * index / total);
-  var progressBar = progressContainer.querySelector('progress');
-  var progressPerc = progressContainer.querySelector('.relative-progress');
+  const progressContainer = document.getElementById("printServiceOverlay");
+  const progress = Math.round(100 * index / total);
+  const progressBar = progressContainer.querySelector("progress");
+  const progressPerc = progressContainer.querySelector(".relative-progress");
   progressBar.value = progress;
-  l10n.get('print_progress_percent', {
-    progress: progress
-  }, progress + '%').then(function (msg) {
+  l10n.get("print_progress_percent", {
+    progress
+  }, progress + "%").then(msg => {
     progressPerc.textContent = msg;
   });
 }
 
-var hasAttachEvent = !!document.attachEvent;
-window.addEventListener('keydown', function (event) {
+window.addEventListener("keydown", function (event) {
   if (event.keyCode === 80 && (event.ctrlKey || event.metaKey) && !event.altKey && (!event.shiftKey || window.chrome || window.opera)) {
     window.print();
-
-    if (hasAttachEvent) {
-      return;
-    }
-
     event.preventDefault();
 
     if (event.stopImmediatePropagation) {
@@ -271,45 +268,32 @@ window.addEventListener('keydown', function (event) {
     } else {
       event.stopPropagation();
     }
-
-    return;
   }
 }, true);
 
-if (hasAttachEvent) {
-  document.attachEvent('onkeydown', function (event) {
-    event = event || window.event;
-
-    if (event.keyCode === 80 && event.ctrlKey) {
-      event.keyCode = 0;
-      return false;
-    }
-  });
-}
-
-if ('onbeforeprint' in window) {
-  var stopPropagationIfNeeded = function stopPropagationIfNeeded(event) {
-    if (event.detail !== 'custom' && event.stopImmediatePropagation) {
+if ("onbeforeprint" in window) {
+  const stopPropagationIfNeeded = function (event) {
+    if (event.detail !== "custom" && event.stopImmediatePropagation) {
       event.stopImmediatePropagation();
     }
   };
 
-  window.addEventListener('beforeprint', stopPropagationIfNeeded);
-  window.addEventListener('afterprint', stopPropagationIfNeeded);
+  window.addEventListener("beforeprint", stopPropagationIfNeeded);
+  window.addEventListener("afterprint", stopPropagationIfNeeded);
 }
 
-var overlayPromise;
+let overlayPromise;
 
 function ensureOverlay() {
   if (!overlayPromise) {
     overlayManager = _app.PDFViewerApplication.overlayManager;
 
     if (!overlayManager) {
-      throw new Error('The overlay manager has not yet been initialized.');
+      throw new Error("The overlay manager has not yet been initialized.");
     }
 
-    overlayPromise = overlayManager.register('printServiceOverlay', document.getElementById('printServiceOverlay'), abort, true);
-    document.getElementById('printCancel').onclick = abort;
+    overlayPromise = overlayManager.register("printServiceOverlay", document.getElementById("printServiceOverlay"), abort, true);
+    document.getElementById("printCancel").onclick = abort;
   }
 
   return overlayPromise;
@@ -317,12 +301,14 @@ function ensureOverlay() {
 
 _app.PDFPrintServiceFactory.instance = {
   supportsPrinting: true,
-  createPrintService: function createPrintService(pdfDocument, pagesOverview, printContainer, l10n) {
+
+  createPrintService(pdfDocument, pagesOverview, printContainer, l10n) {
     if (activeService) {
-      throw new Error('The print service is created and active.');
+      throw new Error("The print service is created and active.");
     }
 
     activeService = new PDFPrintService(pdfDocument, pagesOverview, printContainer, l10n);
     return activeService;
   }
+
 };

package/lib/web/pdf_rendering_queue.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,15 +25,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.PDFRenderingQueue = exports.RenderingStates = void 0;
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-var CLEANUP_TIMEOUT = 30000;
-var RenderingStates = {
+const CLEANUP_TIMEOUT = 30000;
+const RenderingStates = {
   INITIAL: 0,
   RUNNING: 1,
   PAUSED: 2,
@@ -41,12 +34,8 @@ var RenderingStates = {
 };
 exports.RenderingStates = RenderingStates;
 
-var PDFRenderingQueue =
-/*#__PURE__*/
-function () {
-  function PDFRenderingQueue() {
-    _classCallCheck(this, PDFRenderingQueue);
-
+class PDFRenderingQueue {
+  constructor() {
     this.pdfViewer = null;
     this.pdfThumbnailViewer = null;
     this.onIdle = null;
@@ -56,120 +45,107 @@ function () {
     this.isThumbnailViewEnabled = false;
   }
 
-  _createClass(PDFRenderingQueue, [{
-    key: "setViewer",
-    value: function setViewer(pdfViewer) {
-      this.pdfViewer = pdfViewer;
-    }
-  }, {
-    key: "setThumbnailViewer",
-    value: function setThumbnailViewer(pdfThumbnailViewer) {
-      this.pdfThumbnailViewer = pdfThumbnailViewer;
-    }
-  }, {
-    key: "isHighestPriority",
-    value: function isHighestPriority(view) {
-      return this.highestPriorityPage === view.renderingId;
-    }
-  }, {
-    key: "renderHighestPriority",
-    value: function renderHighestPriority(currentlyVisiblePages) {
-      if (this.idleTimeout) {
-        clearTimeout(this.idleTimeout);
-        this.idleTimeout = null;
-      }
-
-      if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {
-        return;
-      }
+  setViewer(pdfViewer) {
+    this.pdfViewer = pdfViewer;
+  }
 
-      if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) {
-        if (this.pdfThumbnailViewer.forceRendering()) {
-          return;
-        }
-      }
+  setThumbnailViewer(pdfThumbnailViewer) {
+    this.pdfThumbnailViewer = pdfThumbnailViewer;
+  }
 
-      if (this.printing) {
-        return;
-      }
+  isHighestPriority(view) {
+    return this.highestPriorityPage === view.renderingId;
+  }
 
-      if (this.onIdle) {
-        this.idleTimeout = setTimeout(this.onIdle.bind(this), CLEANUP_TIMEOUT);
-      }
+  renderHighestPriority(currentlyVisiblePages) {
+    if (this.idleTimeout) {
+      clearTimeout(this.idleTimeout);
+      this.idleTimeout = null;
     }
-  }, {
-    key: "getHighestPriority",
-    value: function getHighestPriority(visible, views, scrolledDown) {
-      var visibleViews = visible.views;
-      var numVisible = visibleViews.length;
 
-      if (numVisible === 0) {
-        return false;
-      }
-
-      for (var i = 0; i < numVisible; ++i) {
-        var view = visibleViews[i].view;
+    if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {
+      return;
+    }
 
-        if (!this.isViewFinished(view)) {
-          return view;
-        }
+    if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) {
+      if (this.pdfThumbnailViewer.forceRendering()) {
+        return;
       }
+    }
 
-      if (scrolledDown) {
-        var nextPageIndex = visible.last.id;
+    if (this.printing) {
+      return;
+    }
 
-        if (views[nextPageIndex] && !this.isViewFinished(views[nextPageIndex])) {
-          return views[nextPageIndex];
-        }
-      } else {
-        var previousPageIndex = visible.first.id - 2;
+    if (this.onIdle) {
+      this.idleTimeout = setTimeout(this.onIdle.bind(this), CLEANUP_TIMEOUT);
+    }
+  }
 
-        if (views[previousPageIndex] && !this.isViewFinished(views[previousPageIndex])) {
-          return views[previousPageIndex];
-        }
-      }
+  getHighestPriority(visible, views, scrolledDown) {
+    const visibleViews = visible.views;
+    const numVisible = visibleViews.length;
 
+    if (numVisible === 0) {
       return null;
     }
-  }, {
-    key: "isViewFinished",
-    value: function isViewFinished(view) {
-      return view.renderingState === RenderingStates.FINISHED;
+
+    for (let i = 0; i < numVisible; ++i) {
+      const view = visibleViews[i].view;
+
+      if (!this.isViewFinished(view)) {
+        return view;
+      }
     }
-  }, {
-    key: "renderView",
-    value: function renderView(view) {
-      var _this = this;
 
-      switch (view.renderingState) {
-        case RenderingStates.FINISHED:
-          return false;
+    if (scrolledDown) {
+      const nextPageIndex = visible.last.id;
 
-        case RenderingStates.PAUSED:
-          this.highestPriorityPage = view.renderingId;
-          view.resume();
-          break;
+      if (views[nextPageIndex] && !this.isViewFinished(views[nextPageIndex])) {
+        return views[nextPageIndex];
+      }
+    } else {
+      const previousPageIndex = visible.first.id - 2;
 
-        case RenderingStates.RUNNING:
-          this.highestPriorityPage = view.renderingId;
-          break;
+      if (views[previousPageIndex] && !this.isViewFinished(views[previousPageIndex])) {
+        return views[previousPageIndex];
+      }
+    }
 
-        case RenderingStates.INITIAL:
-          this.highestPriorityPage = view.renderingId;
+    return null;
+  }
 
-          var continueRendering = function continueRendering() {
-            _this.renderHighestPriority();
-          };
+  isViewFinished(view) {
+    return view.renderingState === RenderingStates.FINISHED;
+  }
 
-          view.draw().then(continueRendering, continueRendering);
-          break;
-      }
+  renderView(view) {
+    switch (view.renderingState) {
+      case RenderingStates.FINISHED:
+        return false;
 
-      return true;
+      case RenderingStates.PAUSED:
+        this.highestPriorityPage = view.renderingId;
+        view.resume();
+        break;
+
+      case RenderingStates.RUNNING:
+        this.highestPriorityPage = view.renderingId;
+        break;
+
+      case RenderingStates.INITIAL:
+        this.highestPriorityPage = view.renderingId;
+        view.draw().finally(() => {
+          this.renderHighestPriority();
+        }).catch(reason => {
+          console.error(`renderView: "${reason}"`);
+        });
+        break;
     }
-  }]);
 
-  return PDFRenderingQueue;
-}();
+    return true;
+  }
+
+}
 
 exports.PDFRenderingQueue = PDFRenderingQueue;