exports.configure = function(registry) {
var registryConfig = globalConfig.config.registries[registry] || {},
RegistryClass;
if (!registryConfig.handler)
throw 'Registry %' + registry + '% not found.';
var handler = registryConfig.handler;
delete registryConfig.handler;
try {
RegistryClass = registryRequireContext.require(handler);
}
catch(e) {
throw 'Registry handler `' + handler + '` not installed.';
}
registryConfig.name = registry;
registryConfig.strictSSL = globalConfig.config.strictSSL;
return Promise.resolve(RegistryClass.configure && RegistryClass.configure(registryConfig, ui) || registryConfig)
.then(function(_config) {
delete _config.name;
delete _config.strictSSL;
_config.handler = handler;
globalConfig.config.registries[registry] = _config;
})
.then(function() {
globalConfig.save();
});
};
exports.requireRelative = function (requestedPath) {
var rootPath = process.cwd();
if (requestedPath[0] !== '.') {
requestedPath = './' + requestedPath;
}
var rootName = path.join(rootPath, '@root');
var root = new Module(rootName);
root.filename = rootName;
root.paths = Module._nodeModulePaths(rootPath);
return root.require(requestedPath);
};
function getModules() {
try {
// avoid importing a local copy of eslint, try to find a peer dependency
var eslintLoc = Module._resolveFilename("eslint", module.parent);
} catch (err) {
try {
// avoids breaking in jest where module.parent is undefined
eslintLoc = require.resolve("eslint");
} catch (err) {
throw new ReferenceError("couldn't resolve eslint");
}
}
// get modules relative to what eslint will load
var eslintMod = new Module(eslintLoc);
eslintMod.filename = eslintLoc;
eslintMod.paths = Module._nodeModulePaths(path.dirname(eslintLoc));
try {
var escope = eslintMod.require("eslint-scope");
var Definition = eslintMod.require("eslint-scope/lib/definition")
.Definition;
var referencer = eslintMod.require("eslint-scope/lib/referencer");
} catch (err) {
escope = eslintMod.require("escope");
Definition = eslintMod.require("escope/lib/definition").Definition;
referencer = eslintMod.require("escope/lib/referencer");
}
var estraverse = eslintMod.require("estraverse");
if (referencer.__esModule) referencer = referencer.default;
return {
Definition,
escope,
estraverse,
referencer,
};
}
function require(path) {
return module.require(path);
}
import RegisterLoader from '../core/register-loader.js';
// sync require SystemJS in this scope
import Module from 'module';
import { fileUrlToPath } from '../core/common.js';
var base = fileUrlToPath(__moduleName);
var parentModuleContext = new Module(base);
parentModuleContext.paths = Module._nodeModulePaths(base);
var curSystem = global.System;
var SystemJS = parentModuleContext.require('systemjs');
global.System = curSystem;
function declareBundle(loader) {
loader.register('_e.js', ['_c.js'], function (_export, _context) {
"use strict";
var e;
return {
setters: [function (_cJs) {
var _exportObj = {};
_exportObj.c = _cJs.c;
_export(_exportObj);
}],
execute: function () {
_export('e', e = 'e');
_export('e', e);
}
};
requireFunc = function(request) {
return newModule.require(request);
};
exports.load = function(registry) {
if (registryClasses[registry])
return registryClasses[registry];
try {
// ensure the tmpDir exists
var tmpDir = path.resolve(HOME, '.jspm', registry + '-cache');
if (!fs.existsSync(tmpDir))
fs.mkdirSync(tmpDir);
var options = dextend({
timeouts: {
lookup: 60,
download: 300,
process: 120
},
tmpDir: tmpDir,
apiVersion: '2.0'
}, globalConfig.config.registries[registry] || {});
options.name = registry;
if (globalConfig.config.strictSSL === false || globalConfig.config.strictSSL == 'false')
options.strictSSL = false;
if (!options.handler)
throw 'Registry %' + registry + '% not found.';
var RegistryClass = registryRequireContext.require(options.handler);
var registryPackageJSON = registryRequireContext.require(options.handler + '/package.json');
var versionString = registryPackageJSON.name + '@' + registryPackageJSON.version.split('.').splice(0, 2).join('.');
options.versionString = versionString;
var registryInstance = registryClasses[registry] = new RegistryClass(options, ui);
registryInstance.constructor = RegistryClass;
var timeoutLookup = options.timeouts.lookup * 1000;
var timeoutDownload = options.timeouts.download * 1000;
var timeoutProcess = options.timeouts.process * 1000;
registryInstance.versionString = registryInstance.versionString || versionString;
var maxRetries = globalConfig.config.maxRetries || 3;
if (registryInstance.build) {
ui.log('warn', 'Registry handler %' + options.handler + '% provides a `build` hook, which has been deprecated for `processPackage`.');
registryInstance.processPackage = function(packageConfig, packageName, packageDir) {
return this.build(packageConfig, packageDir);
};
}
// patch the calls to apply timeout and retry logic
registryHooks.forEach(function(hook) {
if (!registryInstance[hook])
return;
var runHook = registryInstance[hook];
registryInstance[hook] = function() {
var self = this;
var args = arguments;
var retries = 0;
var timeout;
if (hook == 'download')
timeout = timeoutDownload;
else if (hook == 'processPackage')
timeout = timeoutProcess;
else
timeout = timeoutLookup;
return new Promise(function(resolve, reject) {
function tryHook() {
var active = true;
var timer = setTimeout(function() {
active = false;
checkRetry();
}, timeout);
// in case registry is being reconfigured, chain on a promise
// which delivers the registry to use, when it is ready
(self.reconfigPromise_ || Promise.resolve(self))
.then(function(endpoint) {
self = endpoint;
return runHook.apply(self, args);
})
.then(function(result) {
clearTimeout(timer);
if (active)
resolve(result);
}, function(err) {
clearTimeout(timer);
if (!active)
return;
active = false;
return checkConfigure(err) || checkRetry(err);
});
}
/* When err.config is set, that indicates config credentials are somehow the cause.
* Call the configure hook and reinstantiate the registry with new config */
function checkConfigure(err) {
if (err && err.config && !self.triedConfig) {
// Place promise chain on existing instance, to block subsequent hooks.
// Also print warning for only for first such error, if multiple in a batch
if (!self.reconfigPromise_) {
ui.log('warn', err.message);
self.reconfigPromise_ = exports.configure(registry)
.then(function() {
// replace registered instance
delete registryClasses[registry];
var instance = exports.load(registry);
instance.triedConfig = true;
return instance;
});
}
tryHook();
return true;
}
}
function checkRetry(err) {
// don't retry process or processPackageConfig
if (hook === 'processPackage' || hook === 'processPackageConfig')
retries = maxRetries;
retries++;
var retriable = !err || err.retriable;
var retry = retriable && retries <= maxRetries;
var msg = (err ? 'Error' : 'Timed out') + ' on ' + hook +
(typeof args[0] === 'string' ? ' for `' + registry + ':' + args[0] + '`' : '') +
(retry ? ', retrying (' + retries + ').' : '') +
(!err ? '\nTo increase the timeout run %jspm config registries.' + registry + '.timeouts.' + (hook == 'download' || hook == 'build' ? hook : 'lookup') + ' ' + timeout / 1000 * 2 + '%' : '') +
(err ? '\n' + (!err.hideStack && err.stack || err) : '');
if (retry) {
ui.log('warn', msg);
return tryHook();
}
else {
return reject(msg);
}
}
tryHook();
});
};
});
return registryInstance;
}
catch(e) {
ui.log('err', !e.hideStack && e.stack || e);
throw 'Unable to load registry %' + registry + '%';
}
};