pdfjs-dist 2.3.200 → 2.4.456

package/lib/shared/message_handler.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.
@@ -24,13 +24,16 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.MessageHandler = MessageHandler;
+exports.MessageHandler = void 0;
 
-var _util = require("./util");
+var _util = require("./util.js");
 
-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); }
-
-var StreamKind = {
+const CallbackKind = {
+  UNKNOWN: 0,
+  DATA: 1,
+  ERROR: 2
+};
+const StreamKind = {
   UNKNOWN: 0,
   CANCEL: 1,
   CANCEL_COMPLETE: 2,
@@ -43,21 +46,21 @@ var StreamKind = {
 };
 
 function wrapReason(reason) {
-  if (_typeof(reason) !== 'object') {
+  if (typeof reason !== "object" || reason === null) {
     return reason;
   }
 
   switch (reason.name) {
-    case 'AbortException':
+    case "AbortException":
       return new _util.AbortException(reason.message);
 
-    case 'MissingPDFException':
+    case "MissingPDFException":
       return new _util.MissingPDFException(reason.message);
 
-    case 'UnexpectedResponseException':
+    case "UnexpectedResponseException":
       return new _util.UnexpectedResponseException(reason.message, reason.status);
 
-    case 'UnknownErrorException':
+    case "UnknownErrorException":
       return new _util.UnknownErrorException(reason.message, reason.details);
 
     default:
@@ -65,195 +68,205 @@ function wrapReason(reason) {
   }
 }
 
-function MessageHandler(sourceName, targetName, comObj) {
-  var _this = this;
-
-  this.sourceName = sourceName;
-  this.targetName = targetName;
-  this.comObj = comObj;
-  this.callbackId = 1;
-  this.streamId = 1;
-  this.postMessageTransfers = true;
-  this.streamSinks = Object.create(null);
-  this.streamControllers = Object.create(null);
-  var callbacksCapabilities = this.callbacksCapabilities = Object.create(null);
-  var ah = this.actionHandler = Object.create(null);
-
-  this._onComObjOnMessage = function (event) {
-    var data = event.data;
-
-    if (data.targetName !== _this.sourceName) {
-      return;
-    }
+class MessageHandler {
+  constructor(sourceName, targetName, comObj) {
+    this.sourceName = sourceName;
+    this.targetName = targetName;
+    this.comObj = comObj;
+    this.callbackId = 1;
+    this.streamId = 1;
+    this.postMessageTransfers = true;
+    this.streamSinks = Object.create(null);
+    this.streamControllers = Object.create(null);
+    this.callbackCapabilities = Object.create(null);
+    this.actionHandler = Object.create(null);
+
+    this._onComObjOnMessage = event => {
+      const data = event.data;
+
+      if (data.targetName !== this.sourceName) {
+        return;
+      }
+
+      if (data.stream) {
+        this._processStreamMessage(data);
 
-    if (data.stream) {
-      _this._processStreamMessage(data);
-    } else if (data.isReply) {
-      var callbackId = data.callbackId;
+        return;
+      }
 
-      if (data.callbackId in callbacksCapabilities) {
-        var callback = callbacksCapabilities[callbackId];
-        delete callbacksCapabilities[callbackId];
+      if (data.callback) {
+        const callbackId = data.callbackId;
+        const capability = this.callbackCapabilities[callbackId];
 
-        if ('reason' in data) {
-          callback.reject(wrapReason(data.reason));
+        if (!capability) {
+          throw new Error(`Cannot resolve callback ${callbackId}`);
+        }
+
+        delete this.callbackCapabilities[callbackId];
+
+        if (data.callback === CallbackKind.DATA) {
+          capability.resolve(data.data);
+        } else if (data.callback === CallbackKind.ERROR) {
+          capability.reject(wrapReason(data.reason));
         } else {
-          callback.resolve(data.data);
+          throw new Error("Unexpected callback case");
         }
-      } else {
-        throw new Error("Cannot resolve callback ".concat(callbackId));
+
+        return;
+      }
+
+      const action = this.actionHandler[data.action];
+
+      if (!action) {
+        throw new Error(`Unknown action from worker: ${data.action}`);
       }
-    } else if (data.action in ah) {
-      var action = ah[data.action];
 
       if (data.callbackId) {
-        var _sourceName = _this.sourceName;
-        var _targetName = data.sourceName;
+        const sourceName = this.sourceName;
+        const targetName = data.sourceName;
         new Promise(function (resolve) {
           resolve(action(data.data));
         }).then(function (result) {
           comObj.postMessage({
-            sourceName: _sourceName,
-            targetName: _targetName,
-            isReply: true,
+            sourceName,
+            targetName,
+            callback: CallbackKind.DATA,
             callbackId: data.callbackId,
             data: result
           });
         }, function (reason) {
           comObj.postMessage({
-            sourceName: _sourceName,
-            targetName: _targetName,
-            isReply: true,
+            sourceName,
+            targetName,
+            callback: CallbackKind.ERROR,
             callbackId: data.callbackId,
             reason: wrapReason(reason)
           });
         });
-      } else if (data.streamId) {
-        _this._createStreamSink(data);
-      } else {
-        action(data.data);
+        return;
       }
-    } else {
-      throw new Error("Unknown action from worker: ".concat(data.action));
-    }
-  };
 
-  comObj.addEventListener('message', this._onComObjOnMessage);
-}
+      if (data.streamId) {
+        this._createStreamSink(data);
 
-MessageHandler.prototype = {
-  on: function on(actionName, handler) {
-    var ah = this.actionHandler;
+        return;
+      }
+
+      action(data.data);
+    };
+
+    comObj.addEventListener("message", this._onComObjOnMessage);
+  }
+
+  on(actionName, handler) {
+    const ah = this.actionHandler;
 
     if (ah[actionName]) {
-      throw new Error("There is already an actionName called \"".concat(actionName, "\""));
+      throw new Error(`There is already an actionName called "${actionName}"`);
     }
 
     ah[actionName] = handler;
-  },
-  send: function send(actionName, data, transfers) {
-    this.postMessage({
+  }
+
+  send(actionName, data, transfers) {
+    this._postMessage({
       sourceName: this.sourceName,
       targetName: this.targetName,
       action: actionName,
-      data: data
+      data
     }, transfers);
-  },
-  sendWithPromise: function sendWithPromise(actionName, data, transfers) {
-    var callbackId = this.callbackId++;
-    var capability = (0, _util.createPromiseCapability)();
-    this.callbacksCapabilities[callbackId] = capability;
+  }
+
+  sendWithPromise(actionName, data, transfers) {
+    const callbackId = this.callbackId++;
+    const capability = (0, _util.createPromiseCapability)();
+    this.callbackCapabilities[callbackId] = capability;
 
     try {
-      this.postMessage({
+      this._postMessage({
         sourceName: this.sourceName,
         targetName: this.targetName,
         action: actionName,
-        callbackId: callbackId,
-        data: data
+        callbackId,
+        data
       }, transfers);
     } catch (ex) {
       capability.reject(ex);
     }
 
     return capability.promise;
-  },
-  sendWithStream: function sendWithStream(actionName, data, queueingStrategy, transfers) {
-    var _this2 = this;
-
-    var streamId = this.streamId++;
-    var sourceName = this.sourceName;
-    var targetName = this.targetName;
-    var comObj = this.comObj;
-    return new _util.ReadableStream({
-      start: function start(controller) {
-        var startCapability = (0, _util.createPromiseCapability)();
-        _this2.streamControllers[streamId] = {
-          controller: controller,
+  }
+
+  sendWithStream(actionName, data, queueingStrategy, transfers) {
+    const streamId = this.streamId++;
+    const sourceName = this.sourceName;
+    const targetName = this.targetName;
+    const comObj = this.comObj;
+    return new ReadableStream({
+      start: controller => {
+        const startCapability = (0, _util.createPromiseCapability)();
+        this.streamControllers[streamId] = {
+          controller,
           startCall: startCapability,
           pullCall: null,
           cancelCall: null,
           isClosed: false
         };
 
-        _this2.postMessage({
-          sourceName: sourceName,
-          targetName: targetName,
+        this._postMessage({
+          sourceName,
+          targetName,
           action: actionName,
-          streamId: streamId,
-          data: data,
+          streamId,
+          data,
           desiredSize: controller.desiredSize
         }, transfers);
 
         return startCapability.promise;
       },
-      pull: function pull(controller) {
-        var pullCapability = (0, _util.createPromiseCapability)();
-        _this2.streamControllers[streamId].pullCall = pullCapability;
+      pull: controller => {
+        const pullCapability = (0, _util.createPromiseCapability)();
+        this.streamControllers[streamId].pullCall = pullCapability;
         comObj.postMessage({
-          sourceName: sourceName,
-          targetName: targetName,
+          sourceName,
+          targetName,
           stream: StreamKind.PULL,
-          streamId: streamId,
+          streamId,
           desiredSize: controller.desiredSize
         });
         return pullCapability.promise;
       },
-      cancel: function cancel(reason) {
-        (0, _util.assert)(reason instanceof Error, 'cancel must have a valid reason');
-        var cancelCapability = (0, _util.createPromiseCapability)();
-        _this2.streamControllers[streamId].cancelCall = cancelCapability;
-        _this2.streamControllers[streamId].isClosed = true;
+      cancel: reason => {
+        (0, _util.assert)(reason instanceof Error, "cancel must have a valid reason");
+        const cancelCapability = (0, _util.createPromiseCapability)();
+        this.streamControllers[streamId].cancelCall = cancelCapability;
+        this.streamControllers[streamId].isClosed = true;
         comObj.postMessage({
-          sourceName: sourceName,
-          targetName: targetName,
+          sourceName,
+          targetName,
           stream: StreamKind.CANCEL,
-          streamId: streamId,
+          streamId,
           reason: wrapReason(reason)
         });
         return cancelCapability.promise;
       }
     }, queueingStrategy);
-  },
-  _createStreamSink: function _createStreamSink(data) {
-    var self = this;
-    var action = this.actionHandler[data.action];
-    var streamId = data.streamId;
-    var desiredSize = data.desiredSize;
-    var sourceName = this.sourceName;
-    var targetName = data.sourceName;
-    var capability = (0, _util.createPromiseCapability)();
-    var comObj = this.comObj;
-    var streamSink = {
-      enqueue: function enqueue(chunk) {
-        var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-        var transfers = arguments.length > 2 ? arguments[2] : undefined;
+  }
 
+  _createStreamSink(data) {
+    const self = this;
+    const action = this.actionHandler[data.action];
+    const streamId = data.streamId;
+    const sourceName = this.sourceName;
+    const targetName = data.sourceName;
+    const comObj = this.comObj;
+    const streamSink = {
+      enqueue(chunk, size = 1, transfers) {
         if (this.isCancelled) {
           return;
         }
 
-        var lastDesiredSize = this.desiredSize;
+        const lastDesiredSize = this.desiredSize;
         this.desiredSize -= size;
 
         if (lastDesiredSize > 0 && this.desiredSize <= 0) {
@@ -261,30 +274,32 @@ MessageHandler.prototype = {
           this.ready = this.sinkCapability.promise;
         }
 
-        self.postMessage({
-          sourceName: sourceName,
-          targetName: targetName,
+        self._postMessage({
+          sourceName,
+          targetName,
           stream: StreamKind.ENQUEUE,
-          streamId: streamId,
-          chunk: chunk
+          streamId,
+          chunk
         }, transfers);
       },
-      close: function close() {
+
+      close() {
         if (this.isCancelled) {
           return;
         }
 
         this.isCancelled = true;
         comObj.postMessage({
-          sourceName: sourceName,
-          targetName: targetName,
+          sourceName,
+          targetName,
           stream: StreamKind.CLOSE,
-          streamId: streamId
+          streamId
         });
         delete self.streamSinks[streamId];
       },
-      error: function error(reason) {
-        (0, _util.assert)(reason instanceof Error, 'error must have a valid reason');
+
+      error(reason) {
+        (0, _util.assert)(reason instanceof Error, "error must have a valid reason");
 
         if (this.isCancelled) {
           return;
@@ -292,18 +307,19 @@ MessageHandler.prototype = {
 
         this.isCancelled = true;
         comObj.postMessage({
-          sourceName: sourceName,
-          targetName: targetName,
+          sourceName,
+          targetName,
           stream: StreamKind.ERROR,
-          streamId: streamId,
+          streamId,
           reason: wrapReason(reason)
         });
       },
-      sinkCapability: capability,
+
+      sinkCapability: (0, _util.createPromiseCapability)(),
       onPull: null,
       onCancel: null,
       isCancelled: false,
-      desiredSize: desiredSize,
+      desiredSize: data.desiredSize,
       ready: null
     };
     streamSink.sinkCapability.resolve();
@@ -313,37 +329,28 @@ MessageHandler.prototype = {
       resolve(action(data.data, streamSink));
     }).then(function () {
       comObj.postMessage({
-        sourceName: sourceName,
-        targetName: targetName,
+        sourceName,
+        targetName,
         stream: StreamKind.START_COMPLETE,
-        streamId: streamId,
+        streamId,
         success: true
       });
     }, function (reason) {
       comObj.postMessage({
-        sourceName: sourceName,
-        targetName: targetName,
+        sourceName,
+        targetName,
         stream: StreamKind.START_COMPLETE,
-        streamId: streamId,
+        streamId,
         reason: wrapReason(reason)
       });
     });
-  },
-  _processStreamMessage: function _processStreamMessage(data) {
-    var _this3 = this;
-
-    var sourceName = this.sourceName;
-    var targetName = data.sourceName;
-    var streamId = data.streamId;
-    var comObj = this.comObj;
-
-    var deleteStreamController = function deleteStreamController() {
-      Promise.all([_this3.streamControllers[streamId].startCall, _this3.streamControllers[streamId].pullCall, _this3.streamControllers[streamId].cancelCall].map(function (capability) {
-        return capability && capability.promise["catch"](function () {});
-      })).then(function () {
-        delete _this3.streamControllers[streamId];
-      });
-    };
+  }
+
+  _processStreamMessage(data) {
+    const streamId = data.streamId;
+    const sourceName = this.sourceName;
+    const targetName = data.sourceName;
+    const comObj = this.comObj;
 
     switch (data.stream) {
       case StreamKind.START_COMPLETE:
@@ -367,10 +374,10 @@ MessageHandler.prototype = {
       case StreamKind.PULL:
         if (!this.streamSinks[streamId]) {
           comObj.postMessage({
-            sourceName: sourceName,
-            targetName: targetName,
+            sourceName,
+            targetName,
             stream: StreamKind.PULL_COMPLETE,
-            streamId: streamId,
+            streamId,
             success: true
           });
           break;
@@ -381,30 +388,32 @@ MessageHandler.prototype = {
         }
 
         this.streamSinks[streamId].desiredSize = data.desiredSize;
-        var onPull = this.streamSinks[data.streamId].onPull;
+        const {
+          onPull
+        } = this.streamSinks[data.streamId];
         new Promise(function (resolve) {
           resolve(onPull && onPull());
         }).then(function () {
           comObj.postMessage({
-            sourceName: sourceName,
-            targetName: targetName,
+            sourceName,
+            targetName,
             stream: StreamKind.PULL_COMPLETE,
-            streamId: streamId,
+            streamId,
             success: true
           });
         }, function (reason) {
           comObj.postMessage({
-            sourceName: sourceName,
-            targetName: targetName,
+            sourceName,
+            targetName,
             stream: StreamKind.PULL_COMPLETE,
-            streamId: streamId,
+            streamId,
             reason: wrapReason(reason)
           });
         });
         break;
 
       case StreamKind.ENQUEUE:
-        (0, _util.assert)(this.streamControllers[streamId], 'enqueue should have stream controller');
+        (0, _util.assert)(this.streamControllers[streamId], "enqueue should have stream controller");
 
         if (this.streamControllers[streamId].isClosed) {
           break;
@@ -414,7 +423,7 @@ MessageHandler.prototype = {
         break;
 
       case StreamKind.CLOSE:
-        (0, _util.assert)(this.streamControllers[streamId], 'close should have stream controller');
+        (0, _util.assert)(this.streamControllers[streamId], "close should have stream controller");
 
         if (this.streamControllers[streamId].isClosed) {
           break;
@@ -422,13 +431,17 @@ MessageHandler.prototype = {
 
         this.streamControllers[streamId].isClosed = true;
         this.streamControllers[streamId].controller.close();
-        deleteStreamController();
+
+        this._deleteStreamController(streamId);
+
         break;
 
       case StreamKind.ERROR:
-        (0, _util.assert)(this.streamControllers[streamId], 'error should have stream controller');
+        (0, _util.assert)(this.streamControllers[streamId], "error should have stream controller");
         this.streamControllers[streamId].controller.error(wrapReason(data.reason));
-        deleteStreamController();
+
+        this._deleteStreamController(streamId);
+
         break;
 
       case StreamKind.CANCEL_COMPLETE:
@@ -438,7 +451,8 @@ MessageHandler.prototype = {
           this.streamControllers[streamId].cancelCall.reject(wrapReason(data.reason));
         }
 
-        deleteStreamController();
+        this._deleteStreamController(streamId);
+
         break;
 
       case StreamKind.CANCEL:
@@ -446,23 +460,25 @@ MessageHandler.prototype = {
           break;
         }
 
-        var onCancel = this.streamSinks[data.streamId].onCancel;
+        const {
+          onCancel
+        } = this.streamSinks[data.streamId];
         new Promise(function (resolve) {
           resolve(onCancel && onCancel(wrapReason(data.reason)));
         }).then(function () {
           comObj.postMessage({
-            sourceName: sourceName,
-            targetName: targetName,
+            sourceName,
+            targetName,
             stream: StreamKind.CANCEL_COMPLETE,
-            streamId: streamId,
+            streamId,
             success: true
           });
         }, function (reason) {
           comObj.postMessage({
-            sourceName: sourceName,
-            targetName: targetName,
+            sourceName,
+            targetName,
             stream: StreamKind.CANCEL_COMPLETE,
-            streamId: streamId,
+            streamId,
             reason: wrapReason(reason)
           });
         });
@@ -472,17 +488,29 @@ MessageHandler.prototype = {
         break;
 
       default:
-        throw new Error('Unexpected stream case');
+        throw new Error("Unexpected stream case");
     }
-  },
-  postMessage: function postMessage(message, transfers) {
+  }
+
+  async _deleteStreamController(streamId) {
+    await Promise.allSettled([this.streamControllers[streamId].startCall, this.streamControllers[streamId].pullCall, this.streamControllers[streamId].cancelCall].map(function (capability) {
+      return capability && capability.promise;
+    }));
+    delete this.streamControllers[streamId];
+  }
+
+  _postMessage(message, transfers) {
     if (transfers && this.postMessageTransfers) {
       this.comObj.postMessage(message, transfers);
     } else {
       this.comObj.postMessage(message);
     }
-  },
-  destroy: function destroy() {
-    this.comObj.removeEventListener('message', this._onComObjOnMessage);
   }
-};
+
+  destroy() {
+    this.comObj.removeEventListener("message", this._onComObjOnMessage);
+  }
+
+}
+
+exports.MessageHandler = MessageHandler;