unbundle/lib/processFile.js

`require()` and `import`/`export` in the browser, without the bundling

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.processFile = undefined;

var processFile = exports.processFile = function () {
  var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(file, output, destination) {
    var code, map, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step$value, plugins, presets, _transform;

    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            importResolveOptions.parse = (0, _importResolve.parse)(file, output, destination);

            _context.next = 3;
            return (0, _bluebird.promisify)(_fs.readFile)(file, 'utf8');

          case 3:
            code = _context.sent;
            map = null;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _iteratorError = undefined;
            _context.prev = 8;


            for (_iterator = stages[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
              _step$value = _step.value;
              plugins = _step$value.plugins;
              presets = _step$value.presets;
              _transform = (0, _babelCore.transform)(code, babelrc({
                filename: file,
                inputSourceMap: map
              }, plugins, presets));
              code = _transform.code;
              map = _transform.map;
            }

            _context.next = 16;
            break;

          case 12:
            _context.prev = 12;
            _context.t0 = _context['catch'](8);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 16:
            _context.prev = 16;
            _context.prev = 17;

            if (!_iteratorNormalCompletion && _iterator.return) {
              _iterator.return();
            }

          case 19:
            _context.prev = 19;

            if (!_didIteratorError) {
              _context.next = 22;
              break;
            }

            throw _iteratorError;

          case 22:
            return _context.finish(19);

          case 23:
            return _context.finish(16);

          case 24:
            _context.next = 26;
            return (0, _bluebird.promisify)(_mkdirp2.default)((0, _path.dirname)(output));

          case 26:
            _context.next = 28;
            return Promise.all([(0, _write.write)(code + '\n//# sourceMappingURL=' + (0, _path.basename)(output) + '.map', output), (0, _write.write)(JSON.stringify(map), output + '.map')]);

          case 28:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this, [[8, 12, 16, 24], [17,, 19, 23]]);
  }));

  return function processFile(_x4, _x5, _x6) {
    return _ref.apply(this, arguments);
  };
}();

var _path = require('path');

var _fs = require('fs');

var _babelCore = require('babel-core');

var _bluebird = require('bluebird');

var _write = require('./write');

var _mkdirp = require('mkdirp');

var _mkdirp2 = _interopRequireDefault(_mkdirp);

var _importResolve = require('./importResolve');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

var babelOptions = {
  babelrc: false,
  ignore: null,
  sourceMaps: true
};

var babelPlugins = ['syntax-async-generators', 'syntax-class-properties', 'syntax-decorators', 'syntax-do-expressions', 'syntax-export-extensions', 'syntax-function-bind', 'syntax-function-sent', 'syntax-object-rest-spread'];

var babelPresets = [];

function babelrc() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var plugins = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  var presets = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];

  var result = Object.assign({}, babelOptions, options);
  result.plugins = babelPlugins.concat(plugins);
  result.presets = babelPresets.concat(presets);
  return result;
}

var importResolveOptions = {};

var stages = [{
  // Inline NODE_ENV ("development"/"production")
  // Must run before minify-dead-code-elimination
  plugins: ['transform-node-env-inline'],
  // {plugins: ['transform-inline-environment-variables']},

  // Parse and transform JSX/Flow
  presets: ['react']
},

// Get rid of require() calls that are not used in the current prod/dev environment
{ plugins: ['minify-dead-code-elimination'] },

// Transform CommonJS to ES2015 modules
{ plugins: ['transform-commonjs-es2015-modules'] },

// Trace all import sources
{ plugins: [['transform-import-resolve', importResolveOptions]] },

// Transform ES2015 modules to SystemJS for client-side asynchronous loading
{ plugins: ['transform-es2015-modules-systemjs'] },

// Transform to minified ES5 code
{ presets: ['latest', 'stage-0', 'babili'] }];