@loaders.gl/worker-utils 3.1.0-beta.5 → 3.1.1

package/dist/es5/lib/worker-farm/worker-body.js

@@ -1,76 +1,88 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 
-var _getTransferList = require("../worker-utils/get-transfer-list");
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
-const onMessageWrapperMap = new Map();
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-class WorkerBody {
-  static set onmessage(onMessage) {
-    self.onmessage = message => {
-      if (!isKnownMessage(message)) {
-        return;
-      }
+var _getTransferList = require("../worker-utils/get-transfer-list");
 
-      const {
-        type,
-        payload
-      } = message.data;
-      onMessage(type, payload);
-    };
-  }
+var onMessageWrapperMap = new Map();
 
-  static addEventListener(onMessage) {
-    let onMessageWrapper = onMessageWrapperMap.get(onMessage);
+var WorkerBody = function () {
+  function WorkerBody() {
+    (0, _classCallCheck2.default)(this, WorkerBody);
+  }
 
-    if (!onMessageWrapper) {
-      onMessageWrapper = message => {
+  (0, _createClass2.default)(WorkerBody, null, [{
+    key: "onmessage",
+    set: function set(onMessage) {
+      self.onmessage = function (message) {
         if (!isKnownMessage(message)) {
           return;
         }
 
-        const {
-          type,
-          payload
-        } = message.data;
+        var _message$data = message.data,
+            type = _message$data.type,
+            payload = _message$data.payload;
         onMessage(type, payload);
       };
     }
+  }, {
+    key: "addEventListener",
+    value: function addEventListener(onMessage) {
+      var onMessageWrapper = onMessageWrapperMap.get(onMessage);
 
-    self.addEventListener('message', onMessageWrapper);
-  }
+      if (!onMessageWrapper) {
+        onMessageWrapper = function onMessageWrapper(message) {
+          if (!isKnownMessage(message)) {
+            return;
+          }
 
-  static removeEventListener(onMessage) {
-    const onMessageWrapper = onMessageWrapperMap.get(onMessage);
-    onMessageWrapperMap.delete(onMessage);
-    self.removeEventListener('message', onMessageWrapper);
-  }
+          var _message$data2 = message.data,
+              type = _message$data2.type,
+              payload = _message$data2.payload;
+          onMessage(type, payload);
+        };
+      }
 
-  static postMessage(type, payload) {
-    if (self) {
-      const data = {
-        source: 'loaders.gl',
-        type,
-        payload
-      };
-      const transferList = (0, _getTransferList.getTransferList)(payload);
-      self.postMessage(data, transferList);
+      self.addEventListener('message', onMessageWrapper);
     }
-  }
-
-}
+  }, {
+    key: "removeEventListener",
+    value: function removeEventListener(onMessage) {
+      var onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      onMessageWrapperMap.delete(onMessage);
+      self.removeEventListener('message', onMessageWrapper);
+    }
+  }, {
+    key: "postMessage",
+    value: function postMessage(type, payload) {
+      if (self) {
+        var data = {
+          source: 'loaders.gl',
+          type: type,
+          payload: payload
+        };
+        var transferList = (0, _getTransferList.getTransferList)(payload);
+        self.postMessage(data, transferList);
+      }
+    }
+  }]);
+  return WorkerBody;
+}();
 
 exports.default = WorkerBody;
 
 function isKnownMessage(message) {
-  const {
-    type,
-    data
-  } = message;
+  var type = message.type,
+      data = message.data;
   return type === 'message' && data && typeof data.source === 'string' && data.source.startsWith('loaders.gl');
 }
 //# sourceMappingURL=worker-body.js.map

package/dist/es5/lib/worker-farm/worker-body.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/worker-farm/worker-body.ts"],"names":["onMessageWrapperMap","Map","WorkerBody","onmessage","onMessage","self","message","isKnownMessage","type","payload","data","addEventListener","onMessageWrapper","get","removeEventListener","delete","postMessage","source","transferList","startsWith"],"mappings":";;;;;;;AACA;;AAEA,MAAMA,mBAAmB,GAAG,IAAIC,GAAJ,EAA5B;;AAKe,MAAMC,UAAN,CAAiB;AAIV,aAATC,SAAS,CAACC,SAAD,EAA6E;AAE/FC,IAAAA,IAAI,CAACF,SAAL,GAAkBG,OAAD,IAAa;AAC5B,UAAI,CAACC,cAAc,CAACD,OAAD,CAAnB,EAA8B;AAC5B;AACD;;AAGD,YAAM;AAACE,QAAAA,IAAD;AAAOC,QAAAA;AAAP,UAAkBH,OAAO,CAACI,IAAhC;AACAN,MAAAA,SAAS,CAACI,IAAD,EAAOC,OAAP,CAAT;AACD,KARD;AASD;;AAEsB,SAAhBE,gBAAgB,CACrBP,SADqB,EAErB;AACA,QAAIQ,gBAAgB,GAAGZ,mBAAmB,CAACa,GAApB,CAAwBT,SAAxB,CAAvB;;AAEA,QAAI,CAACQ,gBAAL,EAAuB;AACrBA,MAAAA,gBAAgB,GAAIN,OAAD,IAAgC;AACjD,YAAI,CAACC,cAAc,CAACD,OAAD,CAAnB,EAA8B;AAC5B;AACD;;AAGD,cAAM;AAACE,UAAAA,IAAD;AAAOC,UAAAA;AAAP,YAAkBH,OAAO,CAACI,IAAhC;AACAN,QAAAA,SAAS,CAACI,IAAD,EAAOC,OAAP,CAAT;AACD,OARD;AASD;;AAGDJ,IAAAA,IAAI,CAACM,gBAAL,CAAsB,SAAtB,EAAiCC,gBAAjC;AACD;;AAEyB,SAAnBE,mBAAmB,CACxBV,SADwB,EAExB;AACA,UAAMQ,gBAAgB,GAAGZ,mBAAmB,CAACa,GAApB,CAAwBT,SAAxB,CAAzB;AACAJ,IAAAA,mBAAmB,CAACe,MAApB,CAA2BX,SAA3B;AAEAC,IAAAA,IAAI,CAACS,mBAAL,CAAyB,SAAzB,EAAoCF,gBAApC;AACD;;AAOiB,SAAXI,WAAW,CAACR,IAAD,EAA0BC,OAA1B,EAA+D;AAC/E,QAAIJ,IAAJ,EAAU;AACR,YAAMK,IAAuB,GAAG;AAACO,QAAAA,MAAM,EAAE,YAAT;AAAuBT,QAAAA,IAAvB;AAA6BC,QAAAA;AAA7B,OAAhC;AACA,YAAMS,YAAY,GAAG,sCAAgBT,OAAhB,CAArB;AAGAJ,MAAAA,IAAI,CAACW,WAAL,CAAiBN,IAAjB,EAAuBQ,YAAvB;AACD;AACF;;AA5D6B;;;;AAgEhC,SAASX,cAAT,CAAwBD,OAAxB,EAAoD;AAClD,QAAM;AAACE,IAAAA,IAAD;AAAOE,IAAAA;AAAP,MAAeJ,OAArB;AACA,SACEE,IAAI,KAAK,SAAT,IACAE,IADA,IAEA,OAAOA,IAAI,CAACO,MAAZ,KAAuB,QAFvB,IAGAP,IAAI,CAACO,MAAL,CAAYE,UAAZ,CAAuB,YAAvB,CAJF;AAMD","sourcesContent":["import type {WorkerMessageData, WorkerMessageType, WorkerMessagePayload} from '../../types';\nimport {getTransferList} from '../worker-utils/get-transfer-list';\n\nconst onMessageWrapperMap = new Map();\n\n/**\n * Type safe wrapper for worker code\n */\nexport default class WorkerBody {\n  /*\n   * (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n   */\n  static set onmessage(onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any) {\n    // eslint-disable-next-line no-restricted-globals\n    self.onmessage = (message) => {\n      if (!isKnownMessage(message)) {\n        return;\n      }\n\n      // Confusingly the message itself also has a 'type' field which is always set to 'message'\n      const {type, payload} = message.data;\n      onMessage(type, payload);\n    };\n  }\n\n  static addEventListener(\n    onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n  ) {\n    let onMessageWrapper = onMessageWrapperMap.get(onMessage);\n\n    if (!onMessageWrapper) {\n      onMessageWrapper = (message: MessageEvent<any>) => {\n        if (!isKnownMessage(message)) {\n          return;\n        }\n\n        // Confusingly the message itself also has a 'type' field which is always set to 'message'\n        const {type, payload} = message.data;\n        onMessage(type, payload);\n      };\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    self.addEventListener('message', onMessageWrapper);\n  }\n\n  static removeEventListener(\n    onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n  ) {\n    const onMessageWrapper = onMessageWrapperMap.get(onMessage);\n    onMessageWrapperMap.delete(onMessage);\n    // eslint-disable-next-line no-restricted-globals\n    self.removeEventListener('message', onMessageWrapper);\n  }\n\n  /**\n   * Send a message from a worker to creating thread (main thread)\n   * @param type\n   * @param payload\n   */\n  static postMessage(type: WorkerMessageType, payload: WorkerMessagePayload): void {\n    if (self) {\n      const data: WorkerMessageData = {source: 'loaders.gl', type, payload};\n      const transferList = getTransferList(payload);\n      // eslint-disable-next-line no-restricted-globals\n      // @ts-ignore\n      self.postMessage(data, transferList);\n    }\n  }\n}\n\n// Filter out noise messages sent to workers\nfunction isKnownMessage(message: MessageEvent<any>) {\n  const {type, data} = message;\n  return (\n    type === 'message' &&\n    data &&\n    typeof data.source === 'string' &&\n    data.source.startsWith('loaders.gl')\n  );\n}\n"],"file":"worker-body.js"}
+{"version":3,"sources":["../../../../src/lib/worker-farm/worker-body.ts"],"names":["onMessageWrapperMap","Map","WorkerBody","onMessage","self","onmessage","message","isKnownMessage","data","type","payload","onMessageWrapper","get","addEventListener","delete","removeEventListener","source","transferList","postMessage","startsWith"],"mappings":";;;;;;;;;;;;;AACA;;AAEA,IAAMA,mBAAmB,GAAG,IAAIC,GAAJ,EAA5B;;IAKqBC,U;;;;;;;SAInB,aAAqBC,SAArB,EAAiG;AAE/FC,MAAAA,IAAI,CAACC,SAAL,GAAiB,UAACC,OAAD,EAAa;AAC5B,YAAI,CAACC,cAAc,CAACD,OAAD,CAAnB,EAA8B;AAC5B;AACD;;AAGD,4BAAwBA,OAAO,CAACE,IAAhC;AAAA,YAAOC,IAAP,iBAAOA,IAAP;AAAA,YAAaC,OAAb,iBAAaA,OAAb;AACAP,QAAAA,SAAS,CAACM,IAAD,EAAOC,OAAP,CAAT;AACD,OARD;AASD;;;WAED,0BACEP,SADF,EAEE;AACA,UAAIQ,gBAAgB,GAAGX,mBAAmB,CAACY,GAApB,CAAwBT,SAAxB,CAAvB;;AAEA,UAAI,CAACQ,gBAAL,EAAuB;AACrBA,QAAAA,gBAAgB,GAAG,0BAACL,OAAD,EAAgC;AACjD,cAAI,CAACC,cAAc,CAACD,OAAD,CAAnB,EAA8B;AAC5B;AACD;;AAGD,+BAAwBA,OAAO,CAACE,IAAhC;AAAA,cAAOC,IAAP,kBAAOA,IAAP;AAAA,cAAaC,OAAb,kBAAaA,OAAb;AACAP,UAAAA,SAAS,CAACM,IAAD,EAAOC,OAAP,CAAT;AACD,SARD;AASD;;AAGDN,MAAAA,IAAI,CAACS,gBAAL,CAAsB,SAAtB,EAAiCF,gBAAjC;AACD;;;WAED,6BACER,SADF,EAEE;AACA,UAAMQ,gBAAgB,GAAGX,mBAAmB,CAACY,GAApB,CAAwBT,SAAxB,CAAzB;AACAH,MAAAA,mBAAmB,CAACc,MAApB,CAA2BX,SAA3B;AAEAC,MAAAA,IAAI,CAACW,mBAAL,CAAyB,SAAzB,EAAoCJ,gBAApC;AACD;;;WAOD,qBAAmBF,IAAnB,EAA4CC,OAA5C,EAAiF;AAC/E,UAAIN,IAAJ,EAAU;AACR,YAAMI,IAAuB,GAAG;AAACQ,UAAAA,MAAM,EAAE,YAAT;AAAuBP,UAAAA,IAAI,EAAJA,IAAvB;AAA6BC,UAAAA,OAAO,EAAPA;AAA7B,SAAhC;AACA,YAAMO,YAAY,GAAG,sCAAgBP,OAAhB,CAArB;AAGAN,QAAAA,IAAI,CAACc,WAAL,CAAiBV,IAAjB,EAAuBS,YAAvB;AACD;AACF;;;;;;;AAIH,SAASV,cAAT,CAAwBD,OAAxB,EAAoD;AAClD,MAAOG,IAAP,GAAqBH,OAArB,CAAOG,IAAP;AAAA,MAAaD,IAAb,GAAqBF,OAArB,CAAaE,IAAb;AACA,SACEC,IAAI,KAAK,SAAT,IACAD,IADA,IAEA,OAAOA,IAAI,CAACQ,MAAZ,KAAuB,QAFvB,IAGAR,IAAI,CAACQ,MAAL,CAAYG,UAAZ,CAAuB,YAAvB,CAJF;AAMD","sourcesContent":["import type {WorkerMessageData, WorkerMessageType, WorkerMessagePayload} from '../../types';\nimport {getTransferList} from '../worker-utils/get-transfer-list';\n\nconst onMessageWrapperMap = new Map();\n\n/**\n * Type safe wrapper for worker code\n */\nexport default class WorkerBody {\n  /*\n   * (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n   */\n  static set onmessage(onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any) {\n    // eslint-disable-next-line no-restricted-globals\n    self.onmessage = (message) => {\n      if (!isKnownMessage(message)) {\n        return;\n      }\n\n      // Confusingly the message itself also has a 'type' field which is always set to 'message'\n      const {type, payload} = message.data;\n      onMessage(type, payload);\n    };\n  }\n\n  static addEventListener(\n    onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n  ) {\n    let onMessageWrapper = onMessageWrapperMap.get(onMessage);\n\n    if (!onMessageWrapper) {\n      onMessageWrapper = (message: MessageEvent<any>) => {\n        if (!isKnownMessage(message)) {\n          return;\n        }\n\n        // Confusingly the message itself also has a 'type' field which is always set to 'message'\n        const {type, payload} = message.data;\n        onMessage(type, payload);\n      };\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    self.addEventListener('message', onMessageWrapper);\n  }\n\n  static removeEventListener(\n    onMessage: (type: WorkerMessageType, payload: WorkerMessagePayload) => any\n  ) {\n    const onMessageWrapper = onMessageWrapperMap.get(onMessage);\n    onMessageWrapperMap.delete(onMessage);\n    // eslint-disable-next-line no-restricted-globals\n    self.removeEventListener('message', onMessageWrapper);\n  }\n\n  /**\n   * Send a message from a worker to creating thread (main thread)\n   * @param type\n   * @param payload\n   */\n  static postMessage(type: WorkerMessageType, payload: WorkerMessagePayload): void {\n    if (self) {\n      const data: WorkerMessageData = {source: 'loaders.gl', type, payload};\n      const transferList = getTransferList(payload);\n      // eslint-disable-next-line no-restricted-globals\n      // @ts-ignore\n      self.postMessage(data, transferList);\n    }\n  }\n}\n\n// Filter out noise messages sent to workers\nfunction isKnownMessage(message: MessageEvent<any>) {\n  const {type, data} = message;\n  return (\n    type === 'message' &&\n    data &&\n    typeof data.source === 'string' &&\n    data.source.startsWith('loaders.gl')\n  );\n}\n"],"file":"worker-body.js"}

package/dist/es5/lib/worker-farm/worker-farm.js

@@ -7,88 +7,127 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _workerPool = _interopRequireDefault(require("./worker-pool"));
 
 var _workerThread = _interopRequireDefault(require("./worker-thread"));
 
-const DEFAULT_PROPS = {
-  maxConcurrency: 3,
-  maxMobileConcurrency: 1,
-  onDebug: () => {},
-  reuseWorkers: true
-};
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
-class WorkerFarm {
-  static isSupported() {
-    return _workerThread.default.isSupported();
-  }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-  static getWorkerFarm(props = {}) {
-    WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-    WorkerFarm._workerFarm.setProps(props);
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-    return WorkerFarm._workerFarm;
-  }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var DEFAULT_PROPS = {
+  maxConcurrency: 3,
+  maxMobileConcurrency: 1,
+  onDebug: function onDebug() {},
+  reuseWorkers: true
+};
 
-  constructor(props) {
+var WorkerFarm = function () {
+  function WorkerFarm(props) {
+    (0, _classCallCheck2.default)(this, WorkerFarm);
     (0, _defineProperty2.default)(this, "props", void 0);
     (0, _defineProperty2.default)(this, "workerPools", new Map());
-    this.props = { ...DEFAULT_PROPS
-    };
+    this.props = _objectSpread({}, DEFAULT_PROPS);
     this.setProps(props);
     this.workerPools = new Map();
   }
 
-  destroy() {
-    for (const workerPool of this.workerPools.values()) {
-      workerPool.destroy();
+  (0, _createClass2.default)(WorkerFarm, [{
+    key: "destroy",
+    value: function destroy() {
+      var _iterator = _createForOfIteratorHelper(this.workerPools.values()),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var workerPool = _step.value;
+          workerPool.destroy();
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
     }
-  }
-
-  setProps(props) {
-    this.props = { ...this.props,
-      ...props
-    };
-
-    for (const workerPool of this.workerPools.values()) {
-      workerPool.setProps(this._getWorkerPoolProps());
+  }, {
+    key: "setProps",
+    value: function setProps(props) {
+      this.props = _objectSpread(_objectSpread({}, this.props), props);
+
+      var _iterator2 = _createForOfIteratorHelper(this.workerPools.values()),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var workerPool = _step2.value;
+          workerPool.setProps(this._getWorkerPoolProps());
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
     }
-  }
-
-  getWorkerPool(options) {
-    const {
-      name,
-      source,
-      url
-    } = options;
-    let workerPool = this.workerPools.get(name);
-
-    if (!workerPool) {
-      workerPool = new _workerPool.default({
-        name,
-        source,
-        url
-      });
-      workerPool.setProps(this._getWorkerPoolProps());
-      this.workerPools.set(name, workerPool);
+  }, {
+    key: "getWorkerPool",
+    value: function getWorkerPool(options) {
+      var name = options.name,
+          source = options.source,
+          url = options.url;
+      var workerPool = this.workerPools.get(name);
+
+      if (!workerPool) {
+        workerPool = new _workerPool.default({
+          name: name,
+          source: source,
+          url: url
+        });
+        workerPool.setProps(this._getWorkerPoolProps());
+        this.workerPools.set(name, workerPool);
+      }
+
+      return workerPool;
     }
+  }, {
+    key: "_getWorkerPoolProps",
+    value: function _getWorkerPoolProps() {
+      return {
+        maxConcurrency: this.props.maxConcurrency,
+        maxMobileConcurrency: this.props.maxMobileConcurrency,
+        reuseWorkers: this.props.reuseWorkers,
+        onDebug: this.props.onDebug
+      };
+    }
+  }], [{
+    key: "isSupported",
+    value: function isSupported() {
+      return _workerThread.default.isSupported();
+    }
+  }, {
+    key: "getWorkerFarm",
+    value: function getWorkerFarm() {
+      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
 
-    return workerPool;
-  }
-
-  _getWorkerPoolProps() {
-    return {
-      maxConcurrency: this.props.maxConcurrency,
-      maxMobileConcurrency: this.props.maxMobileConcurrency,
-      reuseWorkers: this.props.reuseWorkers,
-      onDebug: this.props.onDebug
-    };
-  }
+      WorkerFarm._workerFarm.setProps(props);
 
-}
+      return WorkerFarm._workerFarm;
+    }
+  }]);
+  return WorkerFarm;
+}();
 
 exports.default = WorkerFarm;
 (0, _defineProperty2.default)(WorkerFarm, "_workerFarm", void 0);

package/dist/es5/lib/worker-farm/worker-farm.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/worker-farm/worker-farm.ts"],"names":["DEFAULT_PROPS","maxConcurrency","maxMobileConcurrency","onDebug","reuseWorkers","WorkerFarm","isSupported","WorkerThread","getWorkerFarm","props","_workerFarm","setProps","constructor","Map","workerPools","destroy","workerPool","values","_getWorkerPoolProps","getWorkerPool","options","name","source","url","get","WorkerPool","set"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AAYA,MAAMA,aAA8B,GAAG;AACrCC,EAAAA,cAAc,EAAE,CADqB;AAErCC,EAAAA,oBAAoB,EAAE,CAFe;AAGrCC,EAAAA,OAAO,EAAE,MAAM,CAAE,CAHoB;AAIrCC,EAAAA,YAAY,EAAE;AAJuB,CAAvC;;AAUe,MAAMC,UAAN,CAAiB;AAOZ,SAAXC,WAAW,GAAY;AAC5B,WAAOC,sBAAaD,WAAb,EAAP;AACD;;AAGmB,SAAbE,aAAa,CAACC,KAAsB,GAAG,EAA1B,EAA0C;AAC5DJ,IAAAA,UAAU,CAACK,WAAX,GAAyBL,UAAU,CAACK,WAAX,IAA0B,IAAIL,UAAJ,CAAe,EAAf,CAAnD;;AACAA,IAAAA,UAAU,CAACK,WAAX,CAAuBC,QAAvB,CAAgCF,KAAhC;;AACA,WAAOJ,UAAU,CAACK,WAAlB;AACD;;AAGOE,EAAAA,WAAW,CAACH,KAAD,EAAyB;AAAA;AAAA,uDAjBtB,IAAII,GAAJ,EAiBsB;AAC1C,SAAKJ,KAAL,GAAa,EAAC,GAAGT;AAAJ,KAAb;AACA,SAAKW,QAAL,CAAcF,KAAd;AAEA,SAAKK,WAAL,GAAmB,IAAID,GAAJ,EAAnB;AACD;;AAMDE,EAAAA,OAAO,GAAS;AACd,SAAK,MAAMC,UAAX,IAAyB,KAAKF,WAAL,CAAiBG,MAAjB,EAAzB,EAAoD;AAClDD,MAAAA,UAAU,CAACD,OAAX;AACD;AACF;;AAMDJ,EAAAA,QAAQ,CAACF,KAAD,EAA+B;AACrC,SAAKA,KAAL,GAAa,EAAC,GAAG,KAAKA,KAAT;AAAgB,SAAGA;AAAnB,KAAb;;AAEA,SAAK,MAAMO,UAAX,IAAyB,KAAKF,WAAL,CAAiBG,MAAjB,EAAzB,EAAoD;AAClDD,MAAAA,UAAU,CAACL,QAAX,CAAoB,KAAKO,mBAAL,EAApB;AACD;AACF;;AAWDC,EAAAA,aAAa,CAACC,OAAD,EAAqE;AAChF,UAAM;AAACC,MAAAA,IAAD;AAAOC,MAAAA,MAAP;AAAeC,MAAAA;AAAf,QAAsBH,OAA5B;AACA,QAAIJ,UAAU,GAAG,KAAKF,WAAL,CAAiBU,GAAjB,CAAqBH,IAArB,CAAjB;;AACA,QAAI,CAACL,UAAL,EAAiB;AACfA,MAAAA,UAAU,GAAG,IAAIS,mBAAJ,CAAe;AAC1BJ,QAAAA,IAD0B;AAE1BC,QAAAA,MAF0B;AAG1BC,QAAAA;AAH0B,OAAf,CAAb;AAKAP,MAAAA,UAAU,CAACL,QAAX,CAAoB,KAAKO,mBAAL,EAApB;AACA,WAAKJ,WAAL,CAAiBY,GAAjB,CAAqBL,IAArB,EAA2BL,UAA3B;AACD;;AACD,WAAOA,UAAP;AACD;;AAEDE,EAAAA,mBAAmB,GAAG;AACpB,WAAO;AACLjB,MAAAA,cAAc,EAAE,KAAKQ,KAAL,CAAWR,cADtB;AAELC,MAAAA,oBAAoB,EAAE,KAAKO,KAAL,CAAWP,oBAF5B;AAGLE,MAAAA,YAAY,EAAE,KAAKK,KAAL,CAAWL,YAHpB;AAILD,MAAAA,OAAO,EAAE,KAAKM,KAAL,CAAWN;AAJf,KAAP;AAMD;;AA/E6B;;;8BAAXE,U","sourcesContent":["import WorkerPool from './worker-pool';\nimport WorkerThread from './worker-thread';\n\n/**\n * @param maxConcurrency {number} - max count of workers\n */\nexport type WorkerFarmProps = {\n  maxConcurrency?: number;\n  maxMobileConcurrency?: number;\n  reuseWorkers?: boolean;\n  onDebug?: () => void;\n};\n\nconst DEFAULT_PROPS: WorkerFarmProps = {\n  maxConcurrency: 3,\n  maxMobileConcurrency: 1,\n  onDebug: () => {},\n  reuseWorkers: true\n};\n\n/**\n * Process multiple jobs with a \"farm\" of different workers in worker pools.\n */\nexport default class WorkerFarm {\n  private props: WorkerFarmProps;\n  private workerPools = new Map<string, WorkerPool>();\n  // singleton\n  private static _workerFarm?: WorkerFarm;\n\n  /** Check if Workers are supported */\n  static isSupported(): boolean {\n    return WorkerThread.isSupported();\n  }\n\n  /** Get the singleton instance of the global worker farm */\n  static getWorkerFarm(props: WorkerFarmProps = {}): WorkerFarm {\n    WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});\n    WorkerFarm._workerFarm.setProps(props);\n    return WorkerFarm._workerFarm;\n  }\n\n  /** get global instance with WorkerFarm.getWorkerFarm() */\n  private constructor(props: WorkerFarmProps) {\n    this.props = {...DEFAULT_PROPS};\n    this.setProps(props);\n    /** @type Map<string, WorkerPool>} */\n    this.workerPools = new Map();\n  }\n\n  /**\n   * Terminate all workers in the farm\n   * @note Can free up significant memory\n   */\n  destroy(): void {\n    for (const workerPool of this.workerPools.values()) {\n      workerPool.destroy();\n    }\n  }\n\n  /**\n   * Set props used when initializing worker pools\n   * @param props\n   */\n  setProps(props: WorkerFarmProps): void {\n    this.props = {...this.props, ...props};\n    // Update worker pool props\n    for (const workerPool of this.workerPools.values()) {\n      workerPool.setProps(this._getWorkerPoolProps());\n    }\n  }\n\n  /**\n   * Returns a worker pool for the specified worker\n   * @param options - only used first time for a specific worker name\n   * @param options.name - the name of the worker - used to identify worker pool\n   * @param options.url -\n   * @param options.source -\n   * @example\n   *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);\n   */\n  getWorkerPool(options: {name: string; source?: string; url?: string}): WorkerPool {\n    const {name, source, url} = options;\n    let workerPool = this.workerPools.get(name);\n    if (!workerPool) {\n      workerPool = new WorkerPool({\n        name,\n        source,\n        url\n      });\n      workerPool.setProps(this._getWorkerPoolProps());\n      this.workerPools.set(name, workerPool);\n    }\n    return workerPool;\n  }\n\n  _getWorkerPoolProps() {\n    return {\n      maxConcurrency: this.props.maxConcurrency,\n      maxMobileConcurrency: this.props.maxMobileConcurrency,\n      reuseWorkers: this.props.reuseWorkers,\n      onDebug: this.props.onDebug\n    };\n  }\n}\n"],"file":"worker-farm.js"}
+{"version":3,"sources":["../../../../src/lib/worker-farm/worker-farm.ts"],"names":["DEFAULT_PROPS","maxConcurrency","maxMobileConcurrency","onDebug","reuseWorkers","WorkerFarm","props","Map","setProps","workerPools","values","workerPool","destroy","_getWorkerPoolProps","options","name","source","url","get","WorkerPool","set","WorkerThread","isSupported","_workerFarm"],"mappings":";;;;;;;;;;;;;;;AAAA;;AACA;;;;;;;;;;;;AAYA,IAAMA,aAA8B,GAAG;AACrCC,EAAAA,cAAc,EAAE,CADqB;AAErCC,EAAAA,oBAAoB,EAAE,CAFe;AAGrCC,EAAAA,OAAO,EAAE,mBAAM,CAAE,CAHoB;AAIrCC,EAAAA,YAAY,EAAE;AAJuB,CAAvC;;IAUqBC,U;AAmBnB,sBAAoBC,KAApB,EAA4C;AAAA;AAAA;AAAA,uDAjBtB,IAAIC,GAAJ,EAiBsB;AAC1C,SAAKD,KAAL,qBAAiBN,aAAjB;AACA,SAAKQ,QAAL,CAAcF,KAAd;AAEA,SAAKG,WAAL,GAAmB,IAAIF,GAAJ,EAAnB;AACD;;;;WAMD,mBAAgB;AAAA,iDACW,KAAKE,WAAL,CAAiBC,MAAjB,EADX;AAAA;;AAAA;AACd,4DAAoD;AAAA,cAAzCC,UAAyC;AAClDA,UAAAA,UAAU,CAACC,OAAX;AACD;AAHa;AAAA;AAAA;AAAA;AAAA;AAIf;;;WAMD,kBAASN,KAAT,EAAuC;AACrC,WAAKA,KAAL,mCAAiB,KAAKA,KAAtB,GAAgCA,KAAhC;;AADqC,kDAGZ,KAAKG,WAAL,CAAiBC,MAAjB,EAHY;AAAA;;AAAA;AAGrC,+DAAoD;AAAA,cAAzCC,UAAyC;AAClDA,UAAAA,UAAU,CAACH,QAAX,CAAoB,KAAKK,mBAAL,EAApB;AACD;AALoC;AAAA;AAAA;AAAA;AAAA;AAMtC;;;WAWD,uBAAcC,OAAd,EAAkF;AAChF,UAAOC,IAAP,GAA4BD,OAA5B,CAAOC,IAAP;AAAA,UAAaC,MAAb,GAA4BF,OAA5B,CAAaE,MAAb;AAAA,UAAqBC,GAArB,GAA4BH,OAA5B,CAAqBG,GAArB;AACA,UAAIN,UAAU,GAAG,KAAKF,WAAL,CAAiBS,GAAjB,CAAqBH,IAArB,CAAjB;;AACA,UAAI,CAACJ,UAAL,EAAiB;AACfA,QAAAA,UAAU,GAAG,IAAIQ,mBAAJ,CAAe;AAC1BJ,UAAAA,IAAI,EAAJA,IAD0B;AAE1BC,UAAAA,MAAM,EAANA,MAF0B;AAG1BC,UAAAA,GAAG,EAAHA;AAH0B,SAAf,CAAb;AAKAN,QAAAA,UAAU,CAACH,QAAX,CAAoB,KAAKK,mBAAL,EAApB;AACA,aAAKJ,WAAL,CAAiBW,GAAjB,CAAqBL,IAArB,EAA2BJ,UAA3B;AACD;;AACD,aAAOA,UAAP;AACD;;;WAED,+BAAsB;AACpB,aAAO;AACLV,QAAAA,cAAc,EAAE,KAAKK,KAAL,CAAWL,cADtB;AAELC,QAAAA,oBAAoB,EAAE,KAAKI,KAAL,CAAWJ,oBAF5B;AAGLE,QAAAA,YAAY,EAAE,KAAKE,KAAL,CAAWF,YAHpB;AAILD,QAAAA,OAAO,EAAE,KAAKG,KAAL,CAAWH;AAJf,OAAP;AAMD;;;WAxED,uBAA8B;AAC5B,aAAOkB,sBAAaC,WAAb,EAAP;AACD;;;WAGD,yBAA8D;AAAA,UAAzChB,KAAyC,uEAAhB,EAAgB;AAC5DD,MAAAA,UAAU,CAACkB,WAAX,GAAyBlB,UAAU,CAACkB,WAAX,IAA0B,IAAIlB,UAAJ,CAAe,EAAf,CAAnD;;AACAA,MAAAA,UAAU,CAACkB,WAAX,CAAuBf,QAAvB,CAAgCF,KAAhC;;AACA,aAAOD,UAAU,CAACkB,WAAlB;AACD;;;;;;8BAhBkBlB,U","sourcesContent":["import WorkerPool from './worker-pool';\nimport WorkerThread from './worker-thread';\n\n/**\n * @param maxConcurrency {number} - max count of workers\n */\nexport type WorkerFarmProps = {\n  maxConcurrency?: number;\n  maxMobileConcurrency?: number;\n  reuseWorkers?: boolean;\n  onDebug?: () => void;\n};\n\nconst DEFAULT_PROPS: WorkerFarmProps = {\n  maxConcurrency: 3,\n  maxMobileConcurrency: 1,\n  onDebug: () => {},\n  reuseWorkers: true\n};\n\n/**\n * Process multiple jobs with a \"farm\" of different workers in worker pools.\n */\nexport default class WorkerFarm {\n  private props: WorkerFarmProps;\n  private workerPools = new Map<string, WorkerPool>();\n  // singleton\n  private static _workerFarm?: WorkerFarm;\n\n  /** Check if Workers are supported */\n  static isSupported(): boolean {\n    return WorkerThread.isSupported();\n  }\n\n  /** Get the singleton instance of the global worker farm */\n  static getWorkerFarm(props: WorkerFarmProps = {}): WorkerFarm {\n    WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});\n    WorkerFarm._workerFarm.setProps(props);\n    return WorkerFarm._workerFarm;\n  }\n\n  /** get global instance with WorkerFarm.getWorkerFarm() */\n  private constructor(props: WorkerFarmProps) {\n    this.props = {...DEFAULT_PROPS};\n    this.setProps(props);\n    /** @type Map<string, WorkerPool>} */\n    this.workerPools = new Map();\n  }\n\n  /**\n   * Terminate all workers in the farm\n   * @note Can free up significant memory\n   */\n  destroy(): void {\n    for (const workerPool of this.workerPools.values()) {\n      workerPool.destroy();\n    }\n  }\n\n  /**\n   * Set props used when initializing worker pools\n   * @param props\n   */\n  setProps(props: WorkerFarmProps): void {\n    this.props = {...this.props, ...props};\n    // Update worker pool props\n    for (const workerPool of this.workerPools.values()) {\n      workerPool.setProps(this._getWorkerPoolProps());\n    }\n  }\n\n  /**\n   * Returns a worker pool for the specified worker\n   * @param options - only used first time for a specific worker name\n   * @param options.name - the name of the worker - used to identify worker pool\n   * @param options.url -\n   * @param options.source -\n   * @example\n   *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);\n   */\n  getWorkerPool(options: {name: string; source?: string; url?: string}): WorkerPool {\n    const {name, source, url} = options;\n    let workerPool = this.workerPools.get(name);\n    if (!workerPool) {\n      workerPool = new WorkerPool({\n        name,\n        source,\n        url\n      });\n      workerPool.setProps(this._getWorkerPoolProps());\n      this.workerPools.set(name, workerPool);\n    }\n    return workerPool;\n  }\n\n  _getWorkerPoolProps() {\n    return {\n      maxConcurrency: this.props.maxConcurrency,\n      maxMobileConcurrency: this.props.maxMobileConcurrency,\n      reuseWorkers: this.props.reuseWorkers,\n      onDebug: this.props.onDebug\n    };\n  }\n}\n"],"file":"worker-farm.js"}

package/dist/es5/lib/worker-farm/worker-job.js

@@ -7,12 +7,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _assert = require("../env-utils/assert");
 
-class WorkerJob {
-  constructor(jobName, workerThread) {
+var WorkerJob = function () {
+  function WorkerJob(jobName, workerThread) {
+    var _this = this;
+
+    (0, _classCallCheck2.default)(this, WorkerJob);
     (0, _defineProperty2.default)(this, "name", void 0);
     (0, _defineProperty2.default)(this, "workerThread", void 0);
     (0, _defineProperty2.default)(this, "isRunning", void 0);
@@ -23,39 +30,44 @@ class WorkerJob {
     this.workerThread = workerThread;
     this.isRunning = true;
 
-    this._resolve = () => {};
+    this._resolve = function () {};
 
-    this._reject = () => {};
-
-    this.result = new Promise((resolve, reject) => {
-      this._resolve = resolve;
-      this._reject = reject;
-    });
-  }
+    this._reject = function () {};
 
-  postMessage(type, payload) {
-    this.workerThread.postMessage({
-      source: 'loaders.gl',
-      type,
-      payload
+    this.result = new Promise(function (resolve, reject) {
+      _this._resolve = resolve;
+      _this._reject = reject;
     });
   }
 
-  done(value) {
-    (0, _assert.assert)(this.isRunning);
-    this.isRunning = false;
-
-    this._resolve(value);
-  }
+  (0, _createClass2.default)(WorkerJob, [{
+    key: "postMessage",
+    value: function postMessage(type, payload) {
+      this.workerThread.postMessage({
+        source: 'loaders.gl',
+        type: type,
+        payload: payload
+      });
+    }
+  }, {
+    key: "done",
+    value: function done(value) {
+      (0, _assert.assert)(this.isRunning);
+      this.isRunning = false;
 
-  error(error) {
-    (0, _assert.assert)(this.isRunning);
-    this.isRunning = false;
-
-    this._reject(error);
-  }
+      this._resolve(value);
+    }
+  }, {
+    key: "error",
+    value: function error(_error) {
+      (0, _assert.assert)(this.isRunning);
+      this.isRunning = false;
 
-}
+      this._reject(_error);
+    }
+  }]);
+  return WorkerJob;
+}();
 
 exports.default = WorkerJob;
 //# sourceMappingURL=worker-job.js.map

package/dist/es5/lib/worker-farm/worker-job.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/worker-farm/worker-job.ts"],"names":["WorkerJob","constructor","jobName","workerThread","name","isRunning","_resolve","_reject","result","Promise","resolve","reject","postMessage","type","payload","source","done","value","error"],"mappings":";;;;;;;;;;;AAEA;;AAKe,MAAMA,SAAN,CAAgB;AAU7BC,EAAAA,WAAW,CAACC,OAAD,EAAkBC,YAAlB,EAA8C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACvD,SAAKC,IAAL,GAAYF,OAAZ;AACA,SAAKC,YAAL,GAAoBA,YAApB;AACA,SAAKE,SAAL,GAAiB,IAAjB;;AACA,SAAKC,QAAL,GAAgB,MAAM,CAAE,CAAxB;;AACA,SAAKC,OAAL,GAAe,MAAM,CAAE,CAAvB;;AACA,SAAKC,MAAL,GAAc,IAAIC,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;AAC7C,WAAKL,QAAL,GAAgBI,OAAhB;AACA,WAAKH,OAAL,GAAeI,MAAf;AACD,KAHa,CAAd;AAID;;AAMDC,EAAAA,WAAW,CAACC,IAAD,EAA0BC,OAA1B,EAA+D;AACxE,SAAKX,YAAL,CAAkBS,WAAlB,CAA8B;AAC5BG,MAAAA,MAAM,EAAE,YADoB;AAE5BF,MAAAA,IAF4B;AAG5BC,MAAAA;AAH4B,KAA9B;AAKD;;AAKDE,EAAAA,IAAI,CAACC,KAAD,EAAmB;AACrB,wBAAO,KAAKZ,SAAZ;AACA,SAAKA,SAAL,GAAiB,KAAjB;;AACA,SAAKC,QAAL,CAAcW,KAAd;AACD;;AAKDC,EAAAA,KAAK,CAACA,KAAD,EAAqB;AACxB,wBAAO,KAAKb,SAAZ;AACA,SAAKA,SAAL,GAAiB,KAAjB;;AACA,SAAKE,OAAL,CAAaW,KAAb;AACD;;AAlD4B","sourcesContent":["import type {WorkerMessageType, WorkerMessagePayload} from '../../types';\nimport WorkerThread from './worker-thread';\nimport {assert} from '../env-utils/assert';\n\n/**\n * Represents one Job handled by a WorkerPool or WorkerFarm\n */\nexport default class WorkerJob {\n  readonly name: string;\n  readonly workerThread: WorkerThread;\n  isRunning: boolean;\n  /** Promise that resolves when Job is done */\n  readonly result: Promise<any>;\n\n  private _resolve: (value: any) => void;\n  private _reject: (reason?: any) => void;\n\n  constructor(jobName: string, workerThread: WorkerThread) {\n    this.name = jobName;\n    this.workerThread = workerThread;\n    this.isRunning = true;\n    this._resolve = () => {};\n    this._reject = () => {};\n    this.result = new Promise((resolve, reject) => {\n      this._resolve = resolve;\n      this._reject = reject;\n    });\n  }\n\n  /**\n   * Send a message to the job's worker thread\n   * @param data any data structure, ideally consisting mostly of transferrable objects\n   */\n  postMessage(type: WorkerMessageType, payload: WorkerMessagePayload): void {\n    this.workerThread.postMessage({\n      source: 'loaders.gl', // Lets worker ignore unrelated messages\n      type,\n      payload\n    });\n  }\n\n  /**\n   * Call to resolve the `result` Promise with the supplied value\n   */\n  done(value: any): void {\n    assert(this.isRunning);\n    this.isRunning = false;\n    this._resolve(value);\n  }\n\n  /**\n   * Call to reject the `result` Promise with the supplied error\n   */\n  error(error: Error): void {\n    assert(this.isRunning);\n    this.isRunning = false;\n    this._reject(error);\n  }\n}\n"],"file":"worker-job.js"}
+{"version":3,"sources":["../../../../src/lib/worker-farm/worker-job.ts"],"names":["WorkerJob","jobName","workerThread","name","isRunning","_resolve","_reject","result","Promise","resolve","reject","type","payload","postMessage","source","value","error"],"mappings":";;;;;;;;;;;;;;;AAEA;;IAKqBA,S;AAUnB,qBAAYC,OAAZ,EAA6BC,YAA7B,EAAyD;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACvD,SAAKC,IAAL,GAAYF,OAAZ;AACA,SAAKC,YAAL,GAAoBA,YAApB;AACA,SAAKE,SAAL,GAAiB,IAAjB;;AACA,SAAKC,QAAL,GAAgB,YAAM,CAAE,CAAxB;;AACA,SAAKC,OAAL,GAAe,YAAM,CAAE,CAAvB;;AACA,SAAKC,MAAL,GAAc,IAAIC,OAAJ,CAAY,UAACC,OAAD,EAAUC,MAAV,EAAqB;AAC7C,MAAA,KAAI,CAACL,QAAL,GAAgBI,OAAhB;AACA,MAAA,KAAI,CAACH,OAAL,GAAeI,MAAf;AACD,KAHa,CAAd;AAID;;;;WAMD,qBAAYC,IAAZ,EAAqCC,OAArC,EAA0E;AACxE,WAAKV,YAAL,CAAkBW,WAAlB,CAA8B;AAC5BC,QAAAA,MAAM,EAAE,YADoB;AAE5BH,QAAAA,IAAI,EAAJA,IAF4B;AAG5BC,QAAAA,OAAO,EAAPA;AAH4B,OAA9B;AAKD;;;WAKD,cAAKG,KAAL,EAAuB;AACrB,0BAAO,KAAKX,SAAZ;AACA,WAAKA,SAAL,GAAiB,KAAjB;;AACA,WAAKC,QAAL,CAAcU,KAAd;AACD;;;WAKD,eAAMC,MAAN,EAA0B;AACxB,0BAAO,KAAKZ,SAAZ;AACA,WAAKA,SAAL,GAAiB,KAAjB;;AACA,WAAKE,OAAL,CAAaU,MAAb;AACD","sourcesContent":["import type {WorkerMessageType, WorkerMessagePayload} from '../../types';\nimport WorkerThread from './worker-thread';\nimport {assert} from '../env-utils/assert';\n\n/**\n * Represents one Job handled by a WorkerPool or WorkerFarm\n */\nexport default class WorkerJob {\n  readonly name: string;\n  readonly workerThread: WorkerThread;\n  isRunning: boolean;\n  /** Promise that resolves when Job is done */\n  readonly result: Promise<any>;\n\n  private _resolve: (value: any) => void;\n  private _reject: (reason?: any) => void;\n\n  constructor(jobName: string, workerThread: WorkerThread) {\n    this.name = jobName;\n    this.workerThread = workerThread;\n    this.isRunning = true;\n    this._resolve = () => {};\n    this._reject = () => {};\n    this.result = new Promise((resolve, reject) => {\n      this._resolve = resolve;\n      this._reject = reject;\n    });\n  }\n\n  /**\n   * Send a message to the job's worker thread\n   * @param data any data structure, ideally consisting mostly of transferrable objects\n   */\n  postMessage(type: WorkerMessageType, payload: WorkerMessagePayload): void {\n    this.workerThread.postMessage({\n      source: 'loaders.gl', // Lets worker ignore unrelated messages\n      type,\n      payload\n    });\n  }\n\n  /**\n   * Call to resolve the `result` Promise with the supplied value\n   */\n  done(value: any): void {\n    assert(this.isRunning);\n    this.isRunning = false;\n    this._resolve(value);\n  }\n\n  /**\n   * Call to reject the `result` Promise with the supplied error\n   */\n  error(error: Error): void {\n    assert(this.isRunning);\n    this.isRunning = false;\n    this._reject(error);\n  }\n}\n"],"file":"worker-job.js"}