pdfjs-dist 2.1.266 → 2.5.207

package/lib/web/pdf_outline_viewer.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.
@@ -28,223 +28,188 @@ exports.PDFOutlineViewer = void 0;
 
 var _pdf = require("../pdf");
 
-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 DEFAULT_TITLE = "\u2013";
-
-var PDFOutlineViewer =
-/*#__PURE__*/
-function () {
-  function PDFOutlineViewer(_ref) {
-    var container = _ref.container,
-        linkService = _ref.linkService,
-        eventBus = _ref.eventBus;
-
-    _classCallCheck(this, PDFOutlineViewer);
+const DEFAULT_TITLE = "\u2013";
 
+class PDFOutlineViewer {
+  constructor({
+    container,
+    linkService,
+    eventBus
+  }) {
     this.container = container;
     this.linkService = linkService;
     this.eventBus = eventBus;
     this.reset();
-    eventBus.on('toggleoutlinetree', this.toggleOutlineTree.bind(this));
+
+    eventBus._on("toggleoutlinetree", this.toggleOutlineTree.bind(this));
   }
 
-  _createClass(PDFOutlineViewer, [{
-    key: "reset",
-    value: function reset() {
-      this.outline = null;
-      this.lastToggleIsShow = true;
-      this.container.textContent = '';
-      this.container.classList.remove('outlineWithDeepNesting');
-    }
-  }, {
-    key: "_dispatchEvent",
-    value: function _dispatchEvent(outlineCount) {
-      this.eventBus.dispatch('outlineloaded', {
-        source: this,
-        outlineCount: outlineCount
+  reset() {
+    this.outline = null;
+    this.lastToggleIsShow = true;
+    this.container.textContent = "";
+    this.container.classList.remove("outlineWithDeepNesting");
+  }
+
+  _dispatchEvent(outlineCount) {
+    this.eventBus.dispatch("outlineloaded", {
+      source: this,
+      outlineCount
+    });
+  }
+
+  _bindLink(element, {
+    url,
+    newWindow,
+    dest
+  }) {
+    const {
+      linkService
+    } = this;
+
+    if (url) {
+      (0, _pdf.addLinkAttributes)(element, {
+        url,
+        target: newWindow ? _pdf.LinkTarget.BLANK : linkService.externalLinkTarget,
+        rel: linkService.externalLinkRel,
+        enabled: linkService.externalLinkEnabled
       });
+      return;
     }
-  }, {
-    key: "_bindLink",
-    value: function _bindLink(element, _ref2) {
-      var url = _ref2.url,
-          newWindow = _ref2.newWindow,
-          dest = _ref2.dest;
-      var linkService = this.linkService;
-
-      if (url) {
-        (0, _pdf.addLinkAttributes)(element, {
-          url: url,
-          target: newWindow ? _pdf.LinkTarget.BLANK : linkService.externalLinkTarget,
-          rel: linkService.externalLinkRel
-        });
-        return;
+
+    element.href = linkService.getDestinationHash(dest);
+
+    element.onclick = () => {
+      if (dest) {
+        linkService.navigateTo(dest);
       }
 
-      element.href = linkService.getDestinationHash(dest);
+      return false;
+    };
+  }
 
-      element.onclick = function () {
-        if (dest) {
-          linkService.navigateTo(dest);
-        }
+  _setStyles(element, {
+    bold,
+    italic
+  }) {
+    if (bold) {
+      element.style.fontWeight = "bold";
+    }
 
-        return false;
-      };
+    if (italic) {
+      element.style.fontStyle = "italic";
     }
-  }, {
-    key: "_setStyles",
-    value: function _setStyles(element, _ref3) {
-      var bold = _ref3.bold,
-          italic = _ref3.italic;
-      var styleStr = '';
-
-      if (bold) {
-        styleStr += 'font-weight: bold;';
-      }
+  }
 
-      if (italic) {
-        styleStr += 'font-style: italic;';
-      }
+  _addToggleButton(div, {
+    count,
+    items
+  }) {
+    const toggler = document.createElement("div");
+    toggler.className = "outlineItemToggler";
 
-      if (styleStr) {
-        element.setAttribute('style', styleStr);
-      }
+    if (count < 0 && Math.abs(count) === items.length) {
+      toggler.classList.add("outlineItemsHidden");
     }
-  }, {
-    key: "_addToggleButton",
-    value: function _addToggleButton(div) {
-      var _this = this;
 
-      var toggler = document.createElement('div');
-      toggler.className = 'outlineItemToggler';
+    toggler.onclick = evt => {
+      evt.stopPropagation();
+      toggler.classList.toggle("outlineItemsHidden");
 
-      toggler.onclick = function (evt) {
-        evt.stopPropagation();
-        toggler.classList.toggle('outlineItemsHidden');
+      if (evt.shiftKey) {
+        const shouldShowAll = !toggler.classList.contains("outlineItemsHidden");
 
-        if (evt.shiftKey) {
-          var shouldShowAll = !toggler.classList.contains('outlineItemsHidden');
+        this._toggleOutlineItem(div, shouldShowAll);
+      }
+    };
 
-          _this._toggleOutlineItem(div, shouldShowAll);
-        }
-      };
+    div.insertBefore(toggler, div.firstChild);
+  }
 
-      div.insertBefore(toggler, div.firstChild);
-    }
-  }, {
-    key: "_toggleOutlineItem",
-    value: function _toggleOutlineItem(root) {
-      var show = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      this.lastToggleIsShow = show;
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
-
-      try {
-        for (var _iterator = root.querySelectorAll('.outlineItemToggler')[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var toggler = _step.value;
-          toggler.classList.toggle('outlineItemsHidden', !show);
-        }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator.return != null) {
-            _iterator.return();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
-        }
-      }
+  _toggleOutlineItem(root, show = false) {
+    this.lastToggleIsShow = show;
+
+    for (const toggler of root.querySelectorAll(".outlineItemToggler")) {
+      toggler.classList.toggle("outlineItemsHidden", !show);
     }
-  }, {
-    key: "toggleOutlineTree",
-    value: function toggleOutlineTree() {
-      if (!this.outline) {
-        return;
-      }
+  }
 
-      this._toggleOutlineItem(this.container, !this.lastToggleIsShow);
+  toggleOutlineTree() {
+    if (!this.outline) {
+      return;
     }
-  }, {
-    key: "render",
-    value: function render(_ref4) {
-      var outline = _ref4.outline;
-      var outlineCount = 0;
-
-      if (this.outline) {
-        this.reset();
-      }
 
-      this.outline = outline || null;
+    this._toggleOutlineItem(this.container, !this.lastToggleIsShow);
+  }
 
-      if (!outline) {
-        this._dispatchEvent(outlineCount);
+  render({
+    outline
+  }) {
+    let outlineCount = 0;
 
-        return;
-      }
+    if (this.outline) {
+      this.reset();
+    }
 
-      var fragment = document.createDocumentFragment();
-      var queue = [{
-        parent: fragment,
-        items: this.outline
-      }];
-      var hasAnyNesting = false;
+    this.outline = outline || null;
 
-      while (queue.length > 0) {
-        var levelData = queue.shift();
+    if (!outline) {
+      this._dispatchEvent(outlineCount);
+
+      return;
+    }
 
-        for (var i = 0, len = levelData.items.length; i < len; i++) {
-          var item = levelData.items[i];
-          var div = document.createElement('div');
-          div.className = 'outlineItem';
-          var element = document.createElement('a');
+    const fragment = document.createDocumentFragment();
+    const queue = [{
+      parent: fragment,
+      items: this.outline
+    }];
+    let hasAnyNesting = false;
 
-          this._bindLink(element, item);
+    while (queue.length > 0) {
+      const levelData = queue.shift();
 
-          this._setStyles(element, item);
+      for (const item of levelData.items) {
+        const div = document.createElement("div");
+        div.className = "outlineItem";
+        const element = document.createElement("a");
 
-          element.textContent = (0, _pdf.removeNullCharacters)(item.title) || DEFAULT_TITLE;
-          div.appendChild(element);
+        this._bindLink(element, item);
 
-          if (item.items.length > 0) {
-            hasAnyNesting = true;
+        this._setStyles(element, item);
 
-            this._addToggleButton(div);
+        element.textContent = (0, _pdf.removeNullCharacters)(item.title) || DEFAULT_TITLE;
+        div.appendChild(element);
 
-            var itemsDiv = document.createElement('div');
-            itemsDiv.className = 'outlineItems';
-            div.appendChild(itemsDiv);
-            queue.push({
-              parent: itemsDiv,
-              items: item.items
-            });
-          }
+        if (item.items.length > 0) {
+          hasAnyNesting = true;
 
-          levelData.parent.appendChild(div);
-          outlineCount++;
+          this._addToggleButton(div, item);
+
+          const itemsDiv = document.createElement("div");
+          itemsDiv.className = "outlineItems";
+          div.appendChild(itemsDiv);
+          queue.push({
+            parent: itemsDiv,
+            items: item.items
+          });
         }
-      }
 
-      if (hasAnyNesting) {
-        this.container.classList.add('outlineWithDeepNesting');
+        levelData.parent.appendChild(div);
+        outlineCount++;
       }
+    }
 
-      this.container.appendChild(fragment);
-
-      this._dispatchEvent(outlineCount);
+    if (hasAnyNesting) {
+      this.container.classList.add("outlineWithDeepNesting");
+      this.lastToggleIsShow = fragment.querySelectorAll(".outlineItemsHidden").length === 0;
     }
-  }]);
 
-  return PDFOutlineViewer;
-}();
+    this.container.appendChild(fragment);
+
+    this._dispatchEvent(outlineCount);
+  }
+
+}
 
 exports.PDFOutlineViewer = PDFOutlineViewer;