From d3f40b6f0b0f507308f8dfd91e9cf6d4745dbce8 Mon Sep 17 00:00:00 2001 From: Cyril Sobierajewicz Date: Mon, 3 Dec 2018 16:07:05 +0100 Subject: Build v3.3.1 --- lib/index.js | 434 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 434 insertions(+) create mode 100644 lib/index.js (limited to 'lib/index.js') diff --git a/lib/index.js b/lib/index.js new file mode 100644 index 0000000..e648869 --- /dev/null +++ b/lib/index.js @@ -0,0 +1,434 @@ +'use strict'; + +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +var debug_ = require('debug'); + +var debug = debug_('purs-loader'); + +var debugVerbose = debug_('purs-loader:verbose'); + +var loaderUtils = require('loader-utils'); + +var Promise = require('bluebird'); + +var path = require('path'); + +var PsModuleMap = require('./purs-module-map'); + +var compile = require('./compile'); + +var bundle = require('./bundle'); + +var ide = require('./ide'); + +var toJavaScript = require('./to-javascript'); + +var sourceMaps = require('./source-maps'); + +var dargs = require('./dargs'); + +var utils = require('./utils'); + +var spawn = require('cross-spawn').sync; + +var eol = require('os').EOL; + +var CACHE_VAR = { + rebuild: false, + deferred: [], + bundleModules: [], + ideServer: null, + psModuleMap: null, + warnings: [], + errors: [], + compilationStarted: false, + compilationFinished: false, + compilationFailed: false, + installed: false, + srcOption: [] +}; + +module.exports = function purescriptLoader(source, map) { + var _this = this; + + this.cacheable && this.cacheable(); + + var webpackContext = this.options && this.options.context || this.rootContext; + + var callback = this.async(); + + var loaderOptions = loaderUtils.getOptions(this) || {}; + + var srcOption = function (pscPackage) { + var srcPath = path.join('src', '**', '*.purs'); + + var bowerPath = path.join('bower_components', 'purescript-*', 'src', '**', '*.purs'); + + if (CACHE_VAR.srcOption.length > 0) { + return CACHE_VAR.srcOption; + } else if (pscPackage) { + var pscPackageCommand = 'psc-package'; + + var pscPackageArgs = ['sources']; + + var loaderSrc = loaderOptions.src || [srcPath]; + + debug('psc-package %s %o', pscPackageCommand, pscPackageArgs); + + var cmd = spawn(pscPackageCommand, pscPackageArgs); + + if (cmd.error) { + throw new Error(cmd.error); + } else if (cmd.status !== 0) { + var error = cmd.stdout.toString(); + + throw new Error(error); + } else { + var result = cmd.stdout.toString().split(eol).filter(function (v) { + return v != ''; + }).concat(loaderSrc); + + debug('psc-package result: %o', result); + + CACHE_VAR.srcOption = result; + + return result; + } + } else { + var _result = loaderOptions.src || [bowerPath, srcPath]; + + CACHE_VAR.srcOption = _result; + + return _result; + } + }(loaderOptions.pscPackage); + + var options = Object.assign({ + context: webpackContext, + psc: null, + pscArgs: {}, + pscBundle: null, + pscBundleArgs: {}, + pscIdeClient: null, + pscIdeClientArgs: {}, + pscIdeServer: null, + pscIdeServerArgs: {}, + pscIde: false, + pscIdeColors: loaderOptions.psc === 'psa', + pscPackage: false, + bundleOutput: 'output/bundle.js', + bundleNamespace: 'PS', + bundle: false, + warnings: true, + watch: false, + output: 'output', + src: [] + }, loaderOptions, { + src: srcOption + }); + + if (!CACHE_VAR.installed) { + debugVerbose('installing purs-loader with options: %O', options); + + CACHE_VAR.installed = true; + + // invalidate loader CACHE_VAR when bundle is marked as invalid (in watch mode) + this._compiler.plugin('invalid', function () { + debugVerbose('invalidating loader CACHE_VAR'); + + CACHE_VAR = { + rebuild: options.pscIde, + deferred: [], + bundleModules: [], + ideServer: CACHE_VAR.ideServer, + psModuleMap: CACHE_VAR.psModuleMap, + warnings: [], + errors: [], + compilationStarted: false, + compilationFinished: false, + compilationFailed: false, + installed: CACHE_VAR.installed, + srcOption: [] + }; + }); + + // add psc warnings to webpack compilation warnings + this._compiler.plugin('after-compile', function (compilation, callback) { + CACHE_VAR.warnings.forEach(function (warning) { + compilation.warnings.push(warning); + }); + + CACHE_VAR.errors.forEach(function (error) { + compilation.errors.push(error); + }); + + callback(); + }); + } + + var psModuleName = PsModuleMap.matchModule(source); + + var psModule = { + name: psModuleName, + source: source, + load: function load(_ref) { + var js = _ref.js, + map = _ref.map; + return callback(null, js, map); + }, + reject: function reject(error) { + return callback(error); + }, + srcPath: this.resourcePath, + remainingRequest: loaderUtils.getRemainingRequest(this), + srcDir: path.dirname(this.resourcePath), + jsPath: path.resolve(path.join(options.output, psModuleName, 'index.js')), + options: options, + cache: CACHE_VAR, + emitWarning: function emitWarning(warning) { + if (options.warnings && warning.length) { + CACHE_VAR.warnings.push(warning); + } + }, + emitError: function emitError(pscMessage) { + if (pscMessage.length) { + var modules = []; + + var matchErrorsSeparator = /\n(?=Error)/; + var errors = pscMessage.split(matchErrorsSeparator); + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = errors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var error = _step.value; + + var matchErrLocation = /at (.+\.purs) line (\d+), column (\d+) - line (\d+), column (\d+)/; + + var _ref2 = matchErrLocation.exec(error) || [], + _ref3 = _slicedToArray(_ref2, 2), + filename = _ref3[1]; + + if (!filename) continue; + + var baseModulePath = path.join(_this.rootContext, filename); + _this.addDependency(baseModulePath); + + var matchErrModuleName = /in module ((?:\w+\.)*\w+)/; + + var _ref4 = matchErrModuleName.exec(error) || [], + _ref5 = _slicedToArray(_ref4, 2), + baseModuleName = _ref5[1]; + + if (!baseModuleName) continue; + + var matchMissingModuleName = /Module ((?:\w+\.)*\w+) was not found/; + var matchMissingImportFromModuleName = /Cannot import value \w+ from module ((?:\w+\.)*\w+)/; + var _arr = [matchMissingModuleName, matchMissingImportFromModuleName]; + for (var _i = 0; _i < _arr.length; _i++) { + var re = _arr[_i]; + var _ref6 = re.exec(error) || [], + _ref7 = _slicedToArray(_ref6, 2), + targetModuleName = _ref7[1]; + + if (targetModuleName) { + var resolved = utils.resolvePursModule({ + baseModulePath: baseModulePath, + baseModuleName: baseModuleName, + targetModuleName: targetModuleName + }); + _this.addDependency(resolved); + } + } + + var desc = { + name: baseModuleName, + filename: baseModulePath + }; + + if (typeof _this.describePscError === 'function') { + var _describePscError = _this.describePscError(error, desc), + _describePscError$dep = _describePscError.dependencies, + dependencies = _describePscError$dep === undefined ? [] : _describePscError$dep, + details = _describePscError.details; + + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; + + try { + + for (var _iterator2 = dependencies[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var dep = _step2.value; + + _this.addDependency(dep); + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + + Object.assign(desc, details); + } + + modules.push(desc); + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + + CACHE_VAR.errors.push(new utils.PscError(pscMessage, modules)); + } + } + }; + + debug('loading %s', psModule.name); + + if (options.bundle) { + CACHE_VAR.bundleModules.push(psModule.name); + } + + if (CACHE_VAR.rebuild) { + var connect = function connect() { + if (!CACHE_VAR.ideServer) { + CACHE_VAR.ideServer = true; + + return ide.connect(psModule).then(function (ideServer) { + CACHE_VAR.ideServer = ideServer; + return psModule; + }).then(ide.loadWithRetry).catch(function (error) { + if (CACHE_VAR.ideServer.kill) { + debug('ide failed to initially load modules, stopping the ide server process'); + + CACHE_VAR.ideServer.kill(); + } + + CACHE_VAR.ideServer = null; + + return Promise.reject(error); + }); + } else { + return Promise.resolve(psModule); + } + }; + + var rebuild = function rebuild() { + return ide.rebuild(psModule).then(function () { + return toJavaScript(psModule).then(function (js) { + return sourceMaps(psModule, js); + }).then(psModule.load).catch(psModule.reject); + }).catch(function (error) { + if (error instanceof ide.UnknownModuleError) { + // Store the modules that trigger a recompile due to an + // unknown module error. We need to wait until compilation is + // done before loading these files. + + CACHE_VAR.deferred.push(psModule); + + if (!CACHE_VAR.compilationStarted) { + CACHE_VAR.compilationStarted = true; + + return compile(psModule).then(function () { + CACHE_VAR.compilationFinished = true; + }).then(function () { + return Promise.map(CACHE_VAR.deferred, function (psModule) { + return ide.load(psModule).then(function () { + return toJavaScript(psModule); + }).then(function (js) { + return sourceMaps(psModule, js); + }).then(psModule.load); + }); + }).catch(function (error) { + CACHE_VAR.compilationFailed = true; + + CACHE_VAR.deferred[0].reject(error); + + CACHE_VAR.deferred.slice(1).forEach(function (psModule) { + psModule.reject(new Error('purs-loader failed')); + }); + }); + } else if (CACHE_VAR.compilationFailed) { + CACHE_VAR.deferred.pop().reject(new Error('purs-loader failed')); + } else { + // The compilation has started. We must wait until it is + // done in order to ensure the module map contains all of + // the unknown modules. + } + } else { + debug('ide rebuild failed due to an unhandled error: %o', error); + + psModule.reject(error); + } + }); + }; + + connect().then(rebuild); + } else if (CACHE_VAR.compilationFinished) { + debugVerbose('compilation is already finished, loading module %s', psModule.name); + + toJavaScript(psModule).then(function (js) { + return sourceMaps(psModule, js); + }).then(psModule.load).catch(psModule.reject); + } else { + // The compilation has not finished yet. We need to wait for + // compilation to finish before the loaders run so that references + // to compiled output are valid. Push the modules into the CACHE_VAR to + // be loaded once the complation is complete. + + CACHE_VAR.deferred.push(psModule); + + if (!CACHE_VAR.compilationStarted) { + CACHE_VAR.compilationStarted = true; + + compile(psModule).then(function () { + CACHE_VAR.compilationFinished = true; + }).then(function () { + if (options.bundle) { + return bundle(options, CACHE_VAR.bundleModules); + } + }).then(function () { + return Promise.map(CACHE_VAR.deferred, function (psModule) { + return toJavaScript(psModule).then(function (js) { + return sourceMaps(psModule, js); + }).then(psModule.load); + }); + }).catch(function (error) { + CACHE_VAR.compilationFailed = true; + + CACHE_VAR.deferred[0].reject(error); + + CACHE_VAR.deferred.slice(1).forEach(function (psModule) { + psModule.reject(new Error('purs-loader failed')); + }); + }); + } else if (CACHE_VAR.compilationFailed) { + CACHE_VAR.deferred.pop().reject(new Error('purs-loader failed')); + } else { + // The complation has started. Nothing to do but wait until it is + // done before loading all of the modules. + } + } +}; \ No newline at end of file -- cgit v1.2.3