pdfjs-dist 2.1.266 → 2.5.207

package/lib/web/overlay_manager.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,277 +26,101 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.OverlayManager = void 0;
 
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-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 OverlayManager =
-/*#__PURE__*/
-function () {
-  function OverlayManager() {
-    _classCallCheck(this, OverlayManager);
-
+class OverlayManager {
+  constructor() {
     this._overlays = {};
     this._active = null;
     this._keyDownBound = this._keyDown.bind(this);
   }
 
-  _createClass(OverlayManager, [{
-    key: "register",
-    value: function () {
-      var _register = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator.default.mark(function _callee(name, element) {
-        var callerCloseMethod,
-            canForceClose,
-            container,
-            _args = arguments;
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                callerCloseMethod = _args.length > 2 && _args[2] !== undefined ? _args[2] : null;
-                canForceClose = _args.length > 3 && _args[3] !== undefined ? _args[3] : false;
-
-                if (!(!name || !element || !(container = element.parentNode))) {
-                  _context.next = 6;
-                  break;
-                }
-
-                throw new Error('Not enough parameters.');
-
-              case 6:
-                if (!this._overlays[name]) {
-                  _context.next = 8;
-                  break;
-                }
-
-                throw new Error('The overlay is already registered.');
-
-              case 8:
-                this._overlays[name] = {
-                  element: element,
-                  container: container,
-                  callerCloseMethod: callerCloseMethod,
-                  canForceClose: canForceClose
-                };
-
-              case 9:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-
-      function register(_x, _x2) {
-        return _register.apply(this, arguments);
-      }
-
-      return register;
-    }()
-  }, {
-    key: "unregister",
-    value: function () {
-      var _unregister = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator.default.mark(function _callee2(name) {
-        return _regenerator.default.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                if (this._overlays[name]) {
-                  _context2.next = 4;
-                  break;
-                }
-
-                throw new Error('The overlay does not exist.');
-
-              case 4:
-                if (!(this._active === name)) {
-                  _context2.next = 6;
-                  break;
-                }
-
-                throw new Error('The overlay cannot be removed while it is active.');
-
-              case 6:
-                delete this._overlays[name];
-
-              case 7:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2, this);
-      }));
-
-      function unregister(_x3) {
-        return _unregister.apply(this, arguments);
-      }
-
-      return unregister;
-    }()
-  }, {
-    key: "open",
-    value: function () {
-      var _open = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator.default.mark(function _callee3(name) {
-        return _regenerator.default.wrap(function _callee3$(_context3) {
-          while (1) {
-            switch (_context3.prev = _context3.next) {
-              case 0:
-                if (this._overlays[name]) {
-                  _context3.next = 4;
-                  break;
-                }
-
-                throw new Error('The overlay does not exist.');
-
-              case 4:
-                if (!this._active) {
-                  _context3.next = 14;
-                  break;
-                }
-
-                if (!this._overlays[name].canForceClose) {
-                  _context3.next = 9;
-                  break;
-                }
-
-                this._closeThroughCaller();
-
-                _context3.next = 14;
-                break;
-
-              case 9:
-                if (!(this._active === name)) {
-                  _context3.next = 13;
-                  break;
-                }
-
-                throw new Error('The overlay is already active.');
-
-              case 13:
-                throw new Error('Another overlay is currently active.');
+  get active() {
+    return this._active;
+  }
 
-              case 14:
-                this._active = name;
+  async register(name, element, callerCloseMethod = null, canForceClose = false) {
+    let container;
 
-                this._overlays[this._active].element.classList.remove('hidden');
+    if (!name || !element || !(container = element.parentNode)) {
+      throw new Error("Not enough parameters.");
+    } else if (this._overlays[name]) {
+      throw new Error("The overlay is already registered.");
+    }
 
-                this._overlays[this._active].container.classList.remove('hidden');
+    this._overlays[name] = {
+      element,
+      container,
+      callerCloseMethod,
+      canForceClose
+    };
+  }
 
-                window.addEventListener('keydown', this._keyDownBound);
+  async unregister(name) {
+    if (!this._overlays[name]) {
+      throw new Error("The overlay does not exist.");
+    } else if (this._active === name) {
+      throw new Error("The overlay cannot be removed while it is active.");
+    }
 
-              case 18:
-              case "end":
-                return _context3.stop();
-            }
-          }
-        }, _callee3, this);
-      }));
+    delete this._overlays[name];
+  }
 
-      function open(_x4) {
-        return _open.apply(this, arguments);
+  async open(name) {
+    if (!this._overlays[name]) {
+      throw new Error("The overlay does not exist.");
+    } else if (this._active) {
+      if (this._overlays[name].canForceClose) {
+        this._closeThroughCaller();
+      } else if (this._active === name) {
+        throw new Error("The overlay is already active.");
+      } else {
+        throw new Error("Another overlay is currently active.");
       }
+    }
 
-      return open;
-    }()
-  }, {
-    key: "close",
-    value: function () {
-      var _close = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator.default.mark(function _callee4(name) {
-        return _regenerator.default.wrap(function _callee4$(_context4) {
-          while (1) {
-            switch (_context4.prev = _context4.next) {
-              case 0:
-                if (this._overlays[name]) {
-                  _context4.next = 4;
-                  break;
-                }
-
-                throw new Error('The overlay does not exist.');
-
-              case 4:
-                if (this._active) {
-                  _context4.next = 8;
-                  break;
-                }
-
-                throw new Error('The overlay is currently not active.');
+    this._active = name;
 
-              case 8:
-                if (!(this._active !== name)) {
-                  _context4.next = 10;
-                  break;
-                }
+    this._overlays[this._active].element.classList.remove("hidden");
 
-                throw new Error('Another overlay is currently active.');
+    this._overlays[this._active].container.classList.remove("hidden");
 
-              case 10:
-                this._overlays[this._active].container.classList.add('hidden');
+    window.addEventListener("keydown", this._keyDownBound);
+  }
 
-                this._overlays[this._active].element.classList.add('hidden');
+  async close(name) {
+    if (!this._overlays[name]) {
+      throw new Error("The overlay does not exist.");
+    } else if (!this._active) {
+      throw new Error("The overlay is currently not active.");
+    } else if (this._active !== name) {
+      throw new Error("Another overlay is currently active.");
+    }
 
-                this._active = null;
-                window.removeEventListener('keydown', this._keyDownBound);
+    this._overlays[this._active].container.classList.add("hidden");
 
-              case 14:
-              case "end":
-                return _context4.stop();
-            }
-          }
-        }, _callee4, this);
-      }));
+    this._overlays[this._active].element.classList.add("hidden");
 
-      function close(_x5) {
-        return _close.apply(this, arguments);
-      }
+    this._active = null;
+    window.removeEventListener("keydown", this._keyDownBound);
+  }
 
-      return close;
-    }()
-  }, {
-    key: "_keyDown",
-    value: function _keyDown(evt) {
-      if (this._active && evt.keyCode === 27) {
-        this._closeThroughCaller();
+  _keyDown(evt) {
+    if (this._active && evt.keyCode === 27) {
+      this._closeThroughCaller();
 
-        evt.preventDefault();
-      }
+      evt.preventDefault();
     }
-  }, {
-    key: "_closeThroughCaller",
-    value: function _closeThroughCaller() {
-      if (this._overlays[this._active].callerCloseMethod) {
-        this._overlays[this._active].callerCloseMethod();
-      }
+  }
 
-      if (this._active) {
-        this.close(this._active);
-      }
+  _closeThroughCaller() {
+    if (this._overlays[this._active].callerCloseMethod) {
+      this._overlays[this._active].callerCloseMethod();
     }
-  }, {
-    key: "active",
-    get: function get() {
-      return this._active;
+
+    if (this._active) {
+      this.close(this._active);
     }
-  }]);
+  }
 
-  return OverlayManager;
-}();
+}
 
 exports.OverlayManager = OverlayManager;

package/lib/web/password_prompt.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,26 +26,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PasswordPrompt = void 0;
 
-var _ui_utils = require("./ui_utils");
+var _ui_utils = require("./ui_utils.js");
 
 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 PasswordPrompt =
-/*#__PURE__*/
-function () {
-  function PasswordPrompt(options, overlayManager) {
-    var _this = this;
-
-    var l10n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _ui_utils.NullL10n;
-
-    _classCallCheck(this, PasswordPrompt);
-
+class PasswordPrompt {
+  constructor(options, overlayManager, l10n = _ui_utils.NullL10n) {
     this.overlayName = options.overlayName;
     this.container = options.container;
     this.label = options.label;
@@ -56,65 +42,53 @@ function () {
     this.l10n = l10n;
     this.updateCallback = null;
     this.reason = null;
-    this.submitButton.addEventListener('click', this.verify.bind(this));
-    this.cancelButton.addEventListener('click', this.close.bind(this));
-    this.input.addEventListener('keydown', function (e) {
+    this.submitButton.addEventListener("click", this.verify.bind(this));
+    this.cancelButton.addEventListener("click", this.close.bind(this));
+    this.input.addEventListener("keydown", e => {
       if (e.keyCode === 13) {
-        _this.verify();
+        this.verify();
       }
     });
     this.overlayManager.register(this.overlayName, this.container, this.close.bind(this), true);
   }
 
-  _createClass(PasswordPrompt, [{
-    key: "open",
-    value: function open() {
-      var _this2 = this;
+  open() {
+    this.overlayManager.open(this.overlayName).then(() => {
+      this.input.focus();
+      let promptString;
 
-      this.overlayManager.open(this.overlayName).then(function () {
-        _this2.input.focus();
+      if (this.reason === _pdf.PasswordResponses.INCORRECT_PASSWORD) {
+        promptString = this.l10n.get("password_invalid", null, "Invalid password. Please try again.");
+      } else {
+        promptString = this.l10n.get("password_label", null, "Enter the password to open this PDF file.");
+      }
 
-        var promptString;
+      promptString.then(msg => {
+        this.label.textContent = msg;
+      });
+    });
+  }
 
-        if (_this2.reason === _pdf.PasswordResponses.INCORRECT_PASSWORD) {
-          promptString = _this2.l10n.get('password_invalid', null, 'Invalid password. Please try again.');
-        } else {
-          promptString = _this2.l10n.get('password_label', null, 'Enter the password to open this PDF file.');
-        }
+  close() {
+    this.overlayManager.close(this.overlayName).then(() => {
+      this.input.value = "";
+    });
+  }
 
-        promptString.then(function (msg) {
-          _this2.label.textContent = msg;
-        });
-      });
-    }
-  }, {
-    key: "close",
-    value: function close() {
-      var _this3 = this;
+  verify() {
+    const password = this.input.value;
 
-      this.overlayManager.close(this.overlayName).then(function () {
-        _this3.input.value = '';
-      });
+    if (password && password.length > 0) {
+      this.close();
+      this.updateCallback(password);
     }
-  }, {
-    key: "verify",
-    value: function verify() {
-      var password = this.input.value;
+  }
 
-      if (password && password.length > 0) {
-        this.close();
-        return this.updateCallback(password);
-      }
-    }
-  }, {
-    key: "setUpdateCallback",
-    value: function setUpdateCallback(updateCallback, reason) {
-      this.updateCallback = updateCallback;
-      this.reason = reason;
-    }
-  }]);
+  setUpdateCallback(updateCallback, reason) {
+    this.updateCallback = updateCallback;
+    this.reason = reason;
+  }
 
-  return PasswordPrompt;
-}();
+}
 
 exports.PasswordPrompt = PasswordPrompt;