pdfjs-dist 2.2.228 → 2.6.347

package/lib/web/pdf_sidebar_resizer.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2019 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,28 +26,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFSidebarResizer = void 0;
 
-var _ui_utils = require("./ui_utils");
+var _ui_utils = require("./ui_utils.js");
 
-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 SIDEBAR_WIDTH_VAR = '--sidebar-width';
-var SIDEBAR_MIN_WIDTH = 200;
-var SIDEBAR_RESIZING_CLASS = 'sidebarResizing';
-
-var PDFSidebarResizer =
-/*#__PURE__*/
-function () {
-  function PDFSidebarResizer(options, eventBus) {
-    var _this = this;
-
-    var l10n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _ui_utils.NullL10n;
-
-    _classCallCheck(this, PDFSidebarResizer);
+const SIDEBAR_WIDTH_VAR = "--sidebar-width";
+const SIDEBAR_MIN_WIDTH = 200;
+const SIDEBAR_RESIZING_CLASS = "sidebarResizing";
 
+class PDFSidebarResizer {
+  constructor(options, eventBus, l10n = _ui_utils.NullL10n) {
     this.enabled = false;
     this.isRTL = false;
     this.sidebarOpen = false;
@@ -60,132 +46,119 @@ function () {
     this.eventBus = eventBus;
     this.l10n = l10n;
 
-    if (typeof CSS === 'undefined' || typeof CSS.supports !== 'function' || !CSS.supports(SIDEBAR_WIDTH_VAR, "calc(-1 * ".concat(SIDEBAR_MIN_WIDTH, "px)"))) {
-      console.warn('PDFSidebarResizer: ' + 'The browser does not support resizing of the sidebar.');
+    if (typeof CSS === "undefined" || typeof CSS.supports !== "function" || !CSS.supports(SIDEBAR_WIDTH_VAR, `calc(-1 * ${SIDEBAR_MIN_WIDTH}px)`)) {
+      console.warn("PDFSidebarResizer: " + "The browser does not support resizing of the sidebar.");
       return;
     }
 
     this.enabled = true;
-    this.resizer.classList.remove('hidden');
-    this.l10n.getDirection().then(function (dir) {
-      _this.isRTL = dir === 'rtl';
+    this.resizer.classList.remove("hidden");
+    this.l10n.getDirection().then(dir => {
+      this.isRTL = dir === "rtl";
     });
 
     this._addEventListeners();
   }
 
-  _createClass(PDFSidebarResizer, [{
-    key: "_updateWidth",
-    value: function _updateWidth() {
-      var width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  get outerContainerWidth() {
+    if (!this._outerContainerWidth) {
+      this._outerContainerWidth = this.outerContainer.clientWidth;
+    }
 
-      if (!this.enabled) {
-        return false;
-      }
+    return this._outerContainerWidth;
+  }
 
-      var maxWidth = Math.floor(this.outerContainerWidth / 2);
+  _updateWidth(width = 0) {
+    if (!this.enabled) {
+      return false;
+    }
 
-      if (width > maxWidth) {
-        width = maxWidth;
-      }
+    const newWidth = (0, _ui_utils.clamp)(width, SIDEBAR_MIN_WIDTH, Math.floor(this.outerContainerWidth / 2));
+
+    if (newWidth === this._width) {
+      return false;
+    }
+
+    this._width = newWidth;
+    this.doc.style.setProperty(SIDEBAR_WIDTH_VAR, `${newWidth}px`);
+    return true;
+  }
+
+  _mouseMove(evt) {
+    let width = evt.clientX;
+
+    if (this.isRTL) {
+      width = this.outerContainerWidth - width;
+    }
 
-      if (width < SIDEBAR_MIN_WIDTH) {
-        width = SIDEBAR_MIN_WIDTH;
+    this._updateWidth(width);
+  }
+
+  _mouseUp(evt) {
+    this.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
+    this.eventBus.dispatch("resize", {
+      source: this
+    });
+    const _boundEvents = this._boundEvents;
+    window.removeEventListener("mousemove", _boundEvents.mouseMove);
+    window.removeEventListener("mouseup", _boundEvents.mouseUp);
+  }
+
+  _addEventListeners() {
+    if (!this.enabled) {
+      return;
+    }
+
+    const _boundEvents = this._boundEvents;
+    _boundEvents.mouseMove = this._mouseMove.bind(this);
+    _boundEvents.mouseUp = this._mouseUp.bind(this);
+    this.resizer.addEventListener("mousedown", evt => {
+      if (evt.button !== 0) {
+        return;
       }
 
-      if (width === this._width) {
-        return false;
+      this.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
+      window.addEventListener("mousemove", _boundEvents.mouseMove);
+      window.addEventListener("mouseup", _boundEvents.mouseUp);
+    });
+
+    this.eventBus._on("sidebarviewchanged", evt => {
+      this.sidebarOpen = !!(evt && evt.view);
+    });
+
+    this.eventBus._on("resize", evt => {
+      if (!evt || evt.source !== window) {
+        return;
       }
 
-      this._width = width;
-      this.doc.style.setProperty(SIDEBAR_WIDTH_VAR, "".concat(width, "px"));
-      return true;
-    }
-  }, {
-    key: "_mouseMove",
-    value: function _mouseMove(evt) {
-      var width = evt.clientX;
+      this._outerContainerWidth = null;
 
-      if (this.isRTL) {
-        width = this.outerContainerWidth - width;
+      if (!this._width) {
+        return;
       }
 
-      this._updateWidth(width);
-    }
-  }, {
-    key: "_mouseUp",
-    value: function _mouseUp(evt) {
-      this.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
-      this.eventBus.dispatch('resize', {
-        source: this
-      });
-      var _boundEvents = this._boundEvents;
-      window.removeEventListener('mousemove', _boundEvents.mouseMove);
-      window.removeEventListener('mouseup', _boundEvents.mouseUp);
-    }
-  }, {
-    key: "_addEventListeners",
-    value: function _addEventListeners() {
-      var _this2 = this;
+      if (!this.sidebarOpen) {
+        this._updateWidth(this._width);
 
-      if (!this.enabled) {
         return;
       }
 
-      var _boundEvents = this._boundEvents;
-      _boundEvents.mouseMove = this._mouseMove.bind(this);
-      _boundEvents.mouseUp = this._mouseUp.bind(this);
-      this.resizer.addEventListener('mousedown', function (evt) {
-        if (evt.button !== 0) {
-          return;
-        }
+      this.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
 
-        _this2.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
+      const updated = this._updateWidth(this._width);
 
-        window.addEventListener('mousemove', _boundEvents.mouseMove);
-        window.addEventListener('mouseup', _boundEvents.mouseUp);
-      });
-      this.eventBus.on('sidebarviewchanged', function (evt) {
-        _this2.sidebarOpen = !!(evt && evt.view);
-      });
-      this.eventBus.on('resize', function (evt) {
-        if (evt && evt.source === window) {
-          _this2._outerContainerWidth = null;
-
-          if (_this2._width) {
-            if (_this2.sidebarOpen) {
-              _this2.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
-
-              var updated = _this2._updateWidth(_this2._width);
-
-              Promise.resolve().then(function () {
-                _this2.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
-
-                if (updated) {
-                  _this2.eventBus.dispatch('resize', {
-                    source: _this2
-                  });
-                }
-              });
-            } else {
-              _this2._updateWidth(_this2._width);
-            }
-          }
+      Promise.resolve().then(() => {
+        this.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
+
+        if (updated) {
+          this.eventBus.dispatch("resize", {
+            source: this
+          });
         }
       });
-    }
-  }, {
-    key: "outerContainerWidth",
-    get: function get() {
-      if (!this._outerContainerWidth) {
-        this._outerContainerWidth = this.outerContainer.clientWidth;
-      }
-
-      return this._outerContainerWidth;
-    }
-  }]);
+    });
+  }
 
-  return PDFSidebarResizer;
-}();
+}
 
 exports.PDFSidebarResizer = PDFSidebarResizer;

package/lib/web/pdf_single_page_viewer.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2019 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,161 +26,112 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFSinglePageViewer = void 0;
 
-var _base_viewer = require("./base_viewer");
+var _base_viewer = require("./base_viewer.js");
 
 var _pdf = require("../pdf");
 
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+class PDFSinglePageViewer extends _base_viewer.BaseViewer {
+  constructor(options) {
+    super(options);
 
-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; }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+    this.eventBus._on("pagesinit", evt => {
+      this._ensurePageViewVisible();
+    });
+  }
 
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+  get _viewerElement() {
+    return (0, _pdf.shadow)(this, "_viewerElement", this._shadowViewer);
+  }
 
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+  _resetView() {
+    super._resetView();
 
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+    this._previousPageNumber = 1;
+    this._shadowViewer = document.createDocumentFragment();
+    this._updateScrollDown = null;
+  }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+  _ensurePageViewVisible() {
+    const pageView = this._pages[this._currentPageNumber - 1];
+    const previousPageView = this._pages[this._previousPageNumber - 1];
+    const viewerNodes = this.viewer.childNodes;
 
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+    switch (viewerNodes.length) {
+      case 0:
+        this.viewer.appendChild(pageView.div);
+        break;
 
-var PDFSinglePageViewer =
-/*#__PURE__*/
-function (_BaseViewer) {
-  _inherits(PDFSinglePageViewer, _BaseViewer);
+      case 1:
+        if (viewerNodes[0] !== previousPageView.div) {
+          throw new Error("_ensurePageViewVisible: Unexpected previously visible page.");
+        }
 
-  function PDFSinglePageViewer(options) {
-    var _this;
+        if (pageView === previousPageView) {
+          break;
+        }
 
-    _classCallCheck(this, PDFSinglePageViewer);
+        this._shadowViewer.appendChild(previousPageView.div);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(PDFSinglePageViewer).call(this, options));
+        this.viewer.appendChild(pageView.div);
+        this.container.scrollTop = 0;
+        break;
 
-    _this.eventBus.on('pagesinit', function (evt) {
-      _this._ensurePageViewVisible();
-    });
+      default:
+        throw new Error("_ensurePageViewVisible: Only one page should be visible at a time.");
+    }
 
-    return _this;
+    this._previousPageNumber = this._currentPageNumber;
   }
 
-  _createClass(PDFSinglePageViewer, [{
-    key: "_resetView",
-    value: function _resetView() {
-      _get(_getPrototypeOf(PDFSinglePageViewer.prototype), "_resetView", this).call(this);
-
-      this._previousPageNumber = 1;
-      this._shadowViewer = document.createDocumentFragment();
-      this._updateScrollDown = null;
+  _scrollUpdate() {
+    if (this._updateScrollDown) {
+      this._updateScrollDown();
     }
-  }, {
-    key: "_ensurePageViewVisible",
-    value: function _ensurePageViewVisible() {
-      var pageView = this._pages[this._currentPageNumber - 1];
-      var previousPageView = this._pages[this._previousPageNumber - 1];
-      var viewerNodes = this.viewer.childNodes;
-
-      switch (viewerNodes.length) {
-        case 0:
-          this.viewer.appendChild(pageView.div);
-          break;
-
-        case 1:
-          if (viewerNodes[0] !== previousPageView.div) {
-            throw new Error('_ensurePageViewVisible: Unexpected previously visible page.');
-          }
 
-          if (pageView === previousPageView) {
-            break;
-          }
+    super._scrollUpdate();
+  }
 
-          this._shadowViewer.appendChild(previousPageView.div);
+  _scrollIntoView({
+    pageDiv,
+    pageSpot = null,
+    pageNumber = null
+  }) {
+    if (pageNumber) {
+      this._setCurrentPageNumber(pageNumber);
+    }
 
-          this.viewer.appendChild(pageView.div);
-          this.container.scrollTop = 0;
-          break;
+    const scrolledDown = this._currentPageNumber >= this._previousPageNumber;
 
-        default:
-          throw new Error('_ensurePageViewVisible: Only one page should be visible at a time.');
-      }
+    this._ensurePageViewVisible();
 
-      this._previousPageNumber = this._currentPageNumber;
-    }
-  }, {
-    key: "_scrollUpdate",
-    value: function _scrollUpdate() {
-      if (this._updateScrollDown) {
-        this._updateScrollDown();
-      }
-
-      _get(_getPrototypeOf(PDFSinglePageViewer.prototype), "_scrollUpdate", this).call(this);
-    }
-  }, {
-    key: "_scrollIntoView",
-    value: function _scrollIntoView(_ref) {
-      var _this2 = this;
+    this.update();
 
-      var pageDiv = _ref.pageDiv,
-          _ref$pageSpot = _ref.pageSpot,
-          pageSpot = _ref$pageSpot === void 0 ? null : _ref$pageSpot,
-          _ref$pageNumber = _ref.pageNumber,
-          pageNumber = _ref$pageNumber === void 0 ? null : _ref$pageNumber;
+    super._scrollIntoView({
+      pageDiv,
+      pageSpot,
+      pageNumber
+    });
 
-      if (pageNumber) {
-        this._setCurrentPageNumber(pageNumber);
-      }
+    this._updateScrollDown = () => {
+      this.scroll.down = scrolledDown;
+      this._updateScrollDown = null;
+    };
+  }
 
-      var scrolledDown = this._currentPageNumber >= this._previousPageNumber;
+  _getVisiblePages() {
+    return this._getCurrentVisiblePage();
+  }
 
-      this._ensurePageViewVisible();
+  _updateHelper(visiblePages) {}
 
-      this.update();
+  get _isScrollModeHorizontal() {
+    return (0, _pdf.shadow)(this, "_isScrollModeHorizontal", false);
+  }
 
-      _get(_getPrototypeOf(PDFSinglePageViewer.prototype), "_scrollIntoView", this).call(this, {
-        pageDiv: pageDiv,
-        pageSpot: pageSpot,
-        pageNumber: pageNumber
-      });
+  _updateScrollMode() {}
 
-      this._updateScrollDown = function () {
-        _this2.scroll.down = scrolledDown;
-        _this2._updateScrollDown = null;
-      };
-    }
-  }, {
-    key: "_getVisiblePages",
-    value: function _getVisiblePages() {
-      return this._getCurrentVisiblePage();
-    }
-  }, {
-    key: "_updateHelper",
-    value: function _updateHelper(visiblePages) {}
-  }, {
-    key: "_updateScrollMode",
-    value: function _updateScrollMode() {}
-  }, {
-    key: "_updateSpreadMode",
-    value: function _updateSpreadMode() {}
-  }, {
-    key: "_setDocumentViewerElement",
-    get: function get() {
-      return (0, _pdf.shadow)(this, '_setDocumentViewerElement', this._shadowViewer);
-    }
-  }, {
-    key: "_isScrollModeHorizontal",
-    get: function get() {
-      return (0, _pdf.shadow)(this, '_isScrollModeHorizontal', false);
-    }
-  }]);
+  _updateSpreadMode() {}
 
-  return PDFSinglePageViewer;
-}(_base_viewer.BaseViewer);
+}
 
 exports.PDFSinglePageViewer = PDFSinglePageViewer;