pdfjs-dist 2.2.228 → 2.6.347

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 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.
@@ -28,248 +28,155 @@ 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"); } }
+var _base_tree_viewer = require("./base_tree_viewer.js");
 
-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); } }
+class PDFOutlineViewer extends _base_tree_viewer.BaseTreeViewer {
+  constructor(options) {
+    super(options);
+    this.linkService = options.linkService;
 
-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;
+    this.eventBus._on("toggleoutlinetree", this._toggleAllTreeItems.bind(this));
+  }
 
-    _classCallCheck(this, PDFOutlineViewer);
+  reset() {
+    super.reset();
+    this._outline = null;
+  }
 
-    this.container = container;
-    this.linkService = linkService;
-    this.eventBus = eventBus;
-    this.reset();
-    eventBus.on('toggleoutlinetree', this.toggleOutlineTree.bind(this));
+  _dispatchEvent(outlineCount) {
+    this.eventBus.dispatch("outlineloaded", {
+      source: this,
+      outlineCount
+    });
   }
 
-  _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
+  _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 = function () {
-        if (dest) {
-          linkService.navigateTo(dest);
-        }
+    element.href = linkService.getDestinationHash(dest);
 
-        return false;
-      };
-    }
-  }, {
-    key: "_setStyles",
-    value: function _setStyles(element, _ref3) {
-      var bold = _ref3.bold,
-          italic = _ref3.italic;
-      var styleStr = '';
-
-      if (bold) {
-        styleStr += 'font-weight: bold;';
+    element.onclick = () => {
+      if (dest) {
+        linkService.navigateTo(dest);
       }
 
-      if (italic) {
-        styleStr += 'font-style: italic;';
-      }
+      return false;
+    };
+  }
 
-      if (styleStr) {
-        element.setAttribute('style', styleStr);
-      }
+  _setStyles(element, {
+    bold,
+    italic
+  }) {
+    if (bold) {
+      element.style.fontWeight = "bold";
     }
-  }, {
-    key: "_addToggleButton",
-    value: function _addToggleButton(div, _ref4) {
-      var _this = this;
-
-      var count = _ref4.count,
-          items = _ref4.items;
-      var toggler = document.createElement('div');
-      toggler.className = 'outlineItemToggler';
-
-      if (count < 0 && Math.abs(count) === items.length) {
-        toggler.classList.add('outlineItemsHidden');
-      }
 
-      toggler.onclick = function (evt) {
-        evt.stopPropagation();
-        toggler.classList.toggle('outlineItemsHidden');
+    if (italic) {
+      element.style.fontStyle = "italic";
+    }
+  }
 
-        if (evt.shiftKey) {
-          var shouldShowAll = !toggler.classList.contains('outlineItemsHidden');
+  _addToggleButton(div, {
+    count,
+    items
+  }) {
+    const hidden = count < 0 && Math.abs(count) === items.length;
 
-          _this._toggleOutlineItem(div, shouldShowAll);
-        }
-      };
+    super._addToggleButton(div, hidden);
+  }
 
-      div.insertBefore(toggler, div.firstChild);
+  _toggleAllTreeItems() {
+    if (!this._outline) {
+      return;
     }
-  }, {
-    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;
-          }
-        }
-      }
+
+    super._toggleAllTreeItems();
+  }
+
+  render({
+    outline
+  }) {
+    if (this._outline) {
+      this.reset();
     }
-  }, {
-    key: "toggleOutlineTree",
-    value: function toggleOutlineTree() {
-      if (!this.outline) {
-        return;
-      }
 
-      this._toggleOutlineItem(this.container, !this.lastToggleIsShow);
+    this._outline = outline || null;
+
+    if (!outline) {
+      this._dispatchEvent(0);
+
+      return;
     }
-  }, {
-    key: "render",
-    value: function render(_ref5) {
-      var outline = _ref5.outline;
-      var outlineCount = 0;
-
-      if (this.outline) {
-        this.reset();
-      }
 
-      this.outline = outline || null;
+    const fragment = document.createDocumentFragment();
+    const queue = [{
+      parent: fragment,
+      items: outline
+    }];
+    let outlineCount = 0,
+        hasAnyNesting = false;
 
-      if (!outline) {
-        this._dispatchEvent(outlineCount);
+    while (queue.length > 0) {
+      const levelData = queue.shift();
 
-        return;
-      }
+      for (const item of levelData.items) {
+        const div = document.createElement("div");
+        div.className = "treeItem";
+        const element = document.createElement("a");
+
+        this._bindLink(element, item);
+
+        this._setStyles(element, item);
 
-      var fragment = document.createDocumentFragment();
-      var queue = [{
-        parent: fragment,
-        items: this.outline
-      }];
-      var hasAnyNesting = false;
-
-      while (queue.length > 0) {
-        var levelData = queue.shift();
-        var _iteratorNormalCompletion2 = true;
-        var _didIteratorError2 = false;
-        var _iteratorError2 = undefined;
-
-        try {
-          for (var _iterator2 = levelData.items[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-            var item = _step2.value;
-            var div = document.createElement('div');
-            div.className = 'outlineItem';
-            var element = document.createElement('a');
-
-            this._bindLink(element, item);
-
-            this._setStyles(element, item);
-
-            element.textContent = (0, _pdf.removeNullCharacters)(item.title) || DEFAULT_TITLE;
-            div.appendChild(element);
-
-            if (item.items.length > 0) {
-              hasAnyNesting = true;
-
-              this._addToggleButton(div, item);
-
-              var itemsDiv = document.createElement('div');
-              itemsDiv.className = 'outlineItems';
-              div.appendChild(itemsDiv);
-              queue.push({
-                parent: itemsDiv,
-                items: item.items
-              });
-            }
-
-            levelData.parent.appendChild(div);
-            outlineCount++;
-          }
-        } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
-              _iterator2["return"]();
-            }
-          } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
-            }
-          }
+        element.textContent = this._normalizeTextContent(item.title);
+        div.appendChild(element);
+
+        if (item.items.length > 0) {
+          hasAnyNesting = true;
+
+          this._addToggleButton(div, item);
+
+          const itemsDiv = document.createElement("div");
+          itemsDiv.className = "treeItems";
+          div.appendChild(itemsDiv);
+          queue.push({
+            parent: itemsDiv,
+            items: item.items
+          });
         }
-      }
 
-      if (hasAnyNesting) {
-        this.container.classList.add('outlineWithDeepNesting');
-        this.lastToggleIsShow = fragment.querySelectorAll('.outlineItemsHidden').length === 0;
+        levelData.parent.appendChild(div);
+        outlineCount++;
       }
+    }
 
-      this.container.appendChild(fragment);
-
-      this._dispatchEvent(outlineCount);
+    if (hasAnyNesting) {
+      this.container.classList.add("treeWithDeepNesting");
+      this._lastToggleIsShow = fragment.querySelectorAll(".treeItemsHidden").length === 0;
     }
-  }]);
 
-  return PDFOutlineViewer;
-}();
+    this.container.appendChild(fragment);
+
+    this._dispatchEvent(outlineCount);
+  }
+
+}
 
 exports.PDFOutlineViewer = PDFOutlineViewer;