@jbrowse/core 1.4.1 → 1.5.2

package/PluginLoader.js

@@ -2,17 +2,20 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = exports.PluginSourceConfigurationSchema = void 0;
+exports.isCJSPluginDefinition = isCJSPluginDefinition;
+exports.isESMPluginDefinition = isESMPluginDefinition;
+exports.isUMDPluginDefinition = isUMDPluginDefinition;
 
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
@@ -21,15 +24,22 @@ var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/creat
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _url = _interopRequireDefault(require("url"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
 var _loadScript = _interopRequireDefault(require("load-script2"));
 
+var _sanitizeFilename = _interopRequireDefault(require("sanitize-filename"));
+
 var _configuration = require("./configuration");
 
 var _ReExports = _interopRequireDefault(require("./ReExports"));
 
-/* eslint-disable no-restricted-globals */
+var _util = require("./util");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
 var PluginSourceConfigurationSchema = (0, _configuration.ConfigurationSchema)('PluginSource', {
   name: {
     type: 'string',
@@ -42,6 +52,32 @@ var PluginSourceConfigurationSchema = (0, _configuration.ConfigurationSchema)('P
 });
 exports.PluginSourceConfigurationSchema = PluginSourceConfigurationSchema;
 
+function isUMDPluginDefinition(pluginDefinition) {
+  return (pluginDefinition.umdUrl !== undefined || pluginDefinition.url !== undefined) && pluginDefinition.name !== undefined;
+}
+
+function isESMPluginDefinition(pluginDefinition) {
+  return pluginDefinition.esmUrl !== undefined;
+}
+
+function isCJSPluginDefinition(pluginDefinition) {
+  return pluginDefinition.cjsUrl !== undefined;
+}
+
+function getGlobalObject() {
+  // Based on window-or-global
+  // https://github.com/purposeindustries/window-or-global/blob/322abc71de0010c9e5d9d0729df40959e1ef8775/lib/index.js
+  return (
+    /* eslint-disable-next-line no-restricted-globals */
+    (typeof self === "undefined" ? "undefined" : (0, _typeof2.default)(self)) === 'object' && self.self === self && self || (typeof global === "undefined" ? "undefined" : (0, _typeof2.default)(global)) === 'object' && global.global === global && global || // @ts-ignore
+    this
+  );
+}
+
+function isInWebWorker(globalObject) {
+  return Boolean('WorkerGlobalScope' in globalObject);
+}
+
 var PluginLoader = /*#__PURE__*/function () {
   function PluginLoader() {
     var pluginDefinitions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
@@ -53,16 +89,18 @@ var PluginLoader = /*#__PURE__*/function () {
   (0, _createClass2.default)(PluginLoader, [{
     key: "loadScript",
     value: function loadScript(scriptUrl) {
-      if (document && document.getElementsByTagName) {
+      var globalObject = getGlobalObject();
+
+      if (!isInWebWorker(globalObject)) {
         return (0, _loadScript.default)(scriptUrl);
       } // @ts-ignore
 
 
-      if (self && self.importScripts) {
+      if (globalObject && globalObject.importScripts) {
         return new Promise(function (resolve, reject) {
           try {
             // @ts-ignore
-            self.importScripts(scriptUrl);
+            globalObject.importScripts(scriptUrl);
           } catch (error) {
             reject(error || new Error("failed to load ".concat(scriptUrl)));
             return;
@@ -75,55 +113,305 @@ var PluginLoader = /*#__PURE__*/function () {
       throw new Error('cannot figure out how to load external JS scripts in this environment');
     }
   }, {
-    key: "loadPlugin",
+    key: "loadCJSPlugin",
     value: function () {
-      var _loadPlugin = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(definition) {
-        var parsedUrl, moduleName, umdName, scope, plugin;
+      var _loadCJSPlugin = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(pluginDefinition) {
+        var parsedUrl, fs, path, os, http, fsPromises, systemTmp, tmpDir, plugin, pluginLocation, pluginLocationRelative, pluginDownload;
         return _regenerator.default.wrap(function _callee$(_context) {
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
-                parsedUrl = _url.default.parse(definition.url);
+                _context.prev = 0;
+                parsedUrl = new URL(pluginDefinition.cjsUrl, getGlobalObject().location.href);
+                _context.next = 8;
+                break;
 
-                if (!(!parsedUrl.protocol || parsedUrl.protocol === 'http:' || parsedUrl.protocol === 'https:')) {
-                  _context.next = 11;
+              case 4:
+                _context.prev = 4;
+                _context.t0 = _context["catch"](0);
+                console.error(_context.t0);
+                throw new Error("Error parsing URL: ".concat(pluginDefinition.cjsUrl));
+
+              case 8:
+                if (!(parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:')) {
+                  _context.next = 10;
+                  break;
+                }
+
+                throw new Error("cannot load plugins using protocol \"".concat(parsedUrl.protocol, "\""));
+
+              case 10:
+                fs = require('fs');
+                path = require('path');
+                os = require('os');
+                http = require('http');
+                fsPromises = fs.promises; // On macOS `os.tmpdir()` returns the path to a symlink, see:
+                // https://github.com/nodejs/node/issues/11422
+
+                _context.next = 17;
+                return fsPromises.realpath(os.tmpdir());
+
+              case 17:
+                systemTmp = _context.sent;
+                _context.next = 20;
+                return fsPromises.mkdtemp(path.join(systemTmp, 'jbrowse-plugin-'));
+
+              case 20:
+                tmpDir = _context.sent;
+                plugin = undefined;
+                _context.prev = 22;
+                pluginLocation = path.join(tmpDir, (0, _sanitizeFilename.default)(parsedUrl.href));
+                pluginLocationRelative = path.relative('.', pluginLocation);
+                pluginDownload = new Promise(function (resolve, reject) {
+                  var file = fs.createWriteStream(pluginLocation);
+                  http.get(parsedUrl.href, function (response) {
+                    response.pipe(file);
+                    file.on('finish', function () {
+                      resolve();
+                    });
+                  }).on('error', function (err) {
+                    fs.unlinkSync(pluginLocation);
+                    reject(err);
+                  });
+                });
+                _context.next = 28;
+                return pluginDownload;
+
+              case 28:
+                plugin = __non_webpack_require__(pluginLocationRelative);
+
+              case 29:
+                _context.prev = 29;
+                fsPromises.rmdir(tmpDir, {
+                  recursive: true
+                });
+                return _context.finish(29);
+
+              case 32:
+                if (plugin) {
+                  _context.next = 34;
                   break;
                 }
 
-                _context.next = 4;
-                return this.loadScript(definition.url);
+                throw new Error("Could not load CJS plugin: ".concat(parsedUrl));
+
+              case 34:
+                return _context.abrupt("return", plugin);
+
+              case 35:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, null, [[0, 4], [22,, 29, 32]]);
+      }));
+
+      function loadCJSPlugin(_x) {
+        return _loadCJSPlugin.apply(this, arguments);
+      }
+
+      return loadCJSPlugin;
+    }()
+  }, {
+    key: "loadESMPlugin",
+    value: function () {
+      var _loadESMPlugin = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(pluginDefinition) {
+        var parsedUrl, plugin;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.prev = 0;
+                parsedUrl = new URL(pluginDefinition.esmUrl, getGlobalObject().location.href);
+                _context2.next = 8;
+                break;
 
               case 4:
-                moduleName = definition.name;
-                umdName = "JBrowsePlugin".concat(moduleName); // Based on window-or-global
-                // https://github.com/purposeindustries/window-or-global/blob/322abc71de0010c9e5d9d0729df40959e1ef8775/lib/index.js
+                _context2.prev = 4;
+                _context2.t0 = _context2["catch"](0);
+                console.error(_context2.t0);
+                throw new Error("Error parsing URL: ".concat(pluginDefinition.esmUrl));
+
+              case 8:
+                if (!(parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:')) {
+                  _context2.next = 10;
+                  break;
+                }
 
-                scope = (typeof self === "undefined" ? "undefined" : (0, _typeof2.default)(self)) === 'object' && self.self === self && self || (typeof global === "undefined" ? "undefined" : (0, _typeof2.default)(global)) === 'object' && global.global === global && global || this; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                throw new Error("cannot load plugins using protocol \"".concat(parsedUrl.protocol, "\""));
 
-                plugin = scope[umdName];
+              case 10:
+                _context2.next = 12;
+                return Promise.resolve("".concat(
+                /* webpackIgnore: true */
+                parsedUrl.href)).then(function (s) {
+                  return _interopRequireWildcard(require(s));
+                });
+
+              case 12:
+                plugin = _context2.sent;
 
                 if (plugin) {
-                  _context.next = 10;
+                  _context2.next = 15;
                   break;
                 }
 
-                throw new Error("plugin ".concat(moduleName, " failed to load, ").concat(scope.constructor.name, ".").concat(umdName, " is undefined"));
+                throw new Error("Could not load ESM plugin: ".concat(parsedUrl));
 
-              case 10:
-                return _context.abrupt("return", plugin.default);
+              case 15:
+                return _context2.abrupt("return", plugin);
+
+              case 16:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, null, [[0, 4]]);
+      }));
+
+      function loadESMPlugin(_x2) {
+        return _loadESMPlugin.apply(this, arguments);
+      }
+
+      return loadESMPlugin;
+    }()
+  }, {
+    key: "loadUMDPlugin",
+    value: function () {
+      var _loadUMDPlugin = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(pluginDefinition) {
+        var umdUrl, parsedUrl, moduleName, umdName, globalObject, plugin;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                umdUrl = 'url' in pluginDefinition ? pluginDefinition.url : pluginDefinition.umdUrl;
+                _context3.prev = 1;
+                parsedUrl = new URL(umdUrl, getGlobalObject().location.href);
+                _context3.next = 9;
+                break;
+
+              case 5:
+                _context3.prev = 5;
+                _context3.t0 = _context3["catch"](1);
+                console.error(_context3.t0);
+                throw new Error("Error parsing URL: ".concat(umdUrl));
+
+              case 9:
+                if (!(parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:')) {
+                  _context3.next = 11;
+                  break;
+                }
 
-              case 11:
                 throw new Error("cannot load plugins using protocol \"".concat(parsedUrl.protocol, "\""));
 
+              case 11:
+                _context3.next = 13;
+                return this.loadScript(parsedUrl.href);
+
+              case 13:
+                moduleName = pluginDefinition.name;
+                umdName = "JBrowsePlugin".concat(moduleName);
+                globalObject = getGlobalObject(); // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+                plugin = globalObject[umdName];
+
+                if (plugin) {
+                  _context3.next = 19;
+                  break;
+                }
+
+                throw new Error("Failed to load UMD bundle for ".concat(moduleName, ", ").concat(globalObject.constructor.name, ".").concat(umdName, " is undefined"));
+
+              case 19:
+                return _context3.abrupt("return", plugin);
+
+              case 20:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this, [[1, 5]]);
+      }));
+
+      function loadUMDPlugin(_x3) {
+        return _loadUMDPlugin.apply(this, arguments);
+      }
+
+      return loadUMDPlugin;
+    }()
+  }, {
+    key: "loadPlugin",
+    value: function () {
+      var _loadPlugin = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(definition) {
+        var plugin;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                if (!(_util.isElectron && isCJSPluginDefinition(definition))) {
+                  _context4.next = 6;
+                  break;
+                }
+
+                _context4.next = 3;
+                return this.loadCJSPlugin(definition);
+
+              case 3:
+                plugin = _context4.sent;
+                _context4.next = 23;
+                break;
+
+              case 6:
+                if (!isESMPluginDefinition(definition)) {
+                  _context4.next = 12;
+                  break;
+                }
+
+                _context4.next = 9;
+                return this.loadESMPlugin(definition);
+
+              case 9:
+                plugin = _context4.sent;
+                _context4.next = 23;
+                break;
+
               case 12:
+                if (!isUMDPluginDefinition(definition)) {
+                  _context4.next = 18;
+                  break;
+                }
+
+                _context4.next = 15;
+                return this.loadUMDPlugin(definition);
+
+              case 15:
+                plugin = _context4.sent;
+                _context4.next = 23;
+                break;
+
+              case 18:
+                if (!(!_util.isElectron && isCJSPluginDefinition(definition))) {
+                  _context4.next = 22;
+                  break;
+                }
+
+                throw new Error("Only CommonJS plugin found, but not in a NodeJS environment: ".concat(JSON.stringify(definition)));
+
+              case 22:
+                throw new Error("Could not determine plugin type: ".concat(JSON.stringify(definition)));
+
+              case 23:
+                return _context4.abrupt("return", plugin.default);
+
+              case 24:
               case "end":
-                return _context.stop();
+                return _context4.stop();
             }
           }
-        }, _callee, this);
+        }, _callee4, this);
       }));
 
-      function loadPlugin(_x) {
+      function loadPlugin(_x4) {
         return _loadPlugin.apply(this, arguments);
       }
 
@@ -133,62 +421,60 @@ var PluginLoader = /*#__PURE__*/function () {
     key: "installGlobalReExports",
     value: function installGlobalReExports(target) {
       // @ts-ignore
-      target.JBrowseExports = {};
-      Object.entries(_ReExports.default).forEach(function (_ref) {
+      target.JBrowseExports = Object.fromEntries(Object.entries(_ReExports.default).map(function (_ref) {
         var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
             moduleName = _ref2[0],
             module = _ref2[1];
 
-        // @ts-ignore
-        target.JBrowseExports[moduleName] = module;
-      });
+        return [moduleName, module];
+      }));
     }
   }, {
     key: "load",
     value: function () {
-      var _load = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+      var _load = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
         var _this = this;
 
-        return _regenerator.default.wrap(function _callee3$(_context3) {
+        return _regenerator.default.wrap(function _callee6$(_context6) {
           while (1) {
-            switch (_context3.prev = _context3.next) {
+            switch (_context6.prev = _context6.next) {
               case 0:
-                return _context3.abrupt("return", Promise.all(this.definitions.map( /*#__PURE__*/function () {
-                  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(definition) {
-                    return _regenerator.default.wrap(function _callee2$(_context2) {
+                return _context6.abrupt("return", Promise.all(this.definitions.map( /*#__PURE__*/function () {
+                  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(definition) {
+                    return _regenerator.default.wrap(function _callee5$(_context5) {
                       while (1) {
-                        switch (_context2.prev = _context2.next) {
+                        switch (_context5.prev = _context5.next) {
                           case 0:
-                            _context2.next = 2;
+                            _context5.next = 2;
                             return _this.loadPlugin(definition);
 
                           case 2:
-                            _context2.t0 = _context2.sent;
-                            _context2.t1 = definition;
-                            return _context2.abrupt("return", {
-                              plugin: _context2.t0,
-                              definition: _context2.t1
+                            _context5.t0 = _context5.sent;
+                            _context5.t1 = definition;
+                            return _context5.abrupt("return", {
+                              plugin: _context5.t0,
+                              definition: _context5.t1
                             });
 
                           case 5:
                           case "end":
-                            return _context2.stop();
+                            return _context5.stop();
                         }
                       }
-                    }, _callee2);
+                    }, _callee5);
                   }));
 
-                  return function (_x2) {
+                  return function (_x5) {
                     return _ref3.apply(this, arguments);
                   };
                 }())));
 
               case 1:
               case "end":
-                return _context3.stop();
+                return _context6.stop();
             }
           }
-        }, _callee3, this);
+        }, _callee6, this);
       }));
 
       function load() {