babel-backwards/lib/cli.js

Upgrade ES5 to newer language features; lebab but with babel

'use strict';

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

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 _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

exports.transformFile = transformFile;

var _commander = require('commander');

var _commander2 = _interopRequireDefault(_commander);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _glob = require('glob');

var _glob2 = _interopRequireDefault(_glob);

var _mkdirp = require('mkdirp');

var _readStdin = require('./readStdin');

var _readStdin2 = _interopRequireDefault(_readStdin);

var _recast = require('recast');

var _recast2 = _interopRequireDefault(_recast);

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

var babel = _interopRequireWildcard(_babelCore);

var _babelPlugin5to6ObjShorthand = require('babel-plugin-5to6-obj-shorthand');

var _babelPlugin5to6ObjShorthand2 = _interopRequireDefault(_babelPlugin5to6ObjShorthand);

var _babelPlugin5to6CommonjsToImport = require('babel-plugin-5to6-commonjs-to-import');

var _babelPlugin5to6CommonjsToImport2 = _interopRequireDefault(_babelPlugin5to6CommonjsToImport);

var _babelPlugin5to6NoStrict = require('babel-plugin-5to6-no-strict');

var _babelPlugin5to6NoStrict2 = _interopRequireDefault(_babelPlugin5to6NoStrict);

var _package = require('../package.json');

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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 usage = _commander2.default.version(_package.version).usage('[options] [file|indir]').description('Transforms infile with the transforms specified by -t. If -d is\n  specified, reads all files from indir and transforms them into files\n  in outdir.').option('-d, --out-dir <output directory>', 'Transform entire directory.').option('-t, --transform <transform>', 'Transform to apply. Can appear multiple times.', function (val, acc) {
  return acc.concat(val);
}, []);

var transforms = {
  'obj-shorthand': {
    description: '{a:a} => {a}',
    plugin: _babelPlugin5to6ObjShorthand2.default
  },
  'no-strict': {
    description: '"use strict"; => (nothing!)',
    plugin: _babelPlugin5to6NoStrict2.default
  },
  commonjs: {
    description: 'var a = require("./b"); => import a from "b";',
    plugin: _babelPlugin5to6CommonjsToImport2.default
  }
};

var defaultBabelOpts = {
  sourceType: 'module',
  babelrc: false,
  parserOpts: {
    parser: _recast2.default.parse,
    allowImportExportEverywhere: false,
    allowReturnOutsideFunction: false,
    plugins: ['asyncGenerators', 'classConstructorCall', 'classProperties', 'decorators', 'doExpressions', 'exportExtensions', 'flow', 'functionSent', 'functionBind', 'jsx', 'objectRestSpread', 'dynamicImport']
  },
  generatorOpts: {
    generator: function generator() {
      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      // Forces recast to reprint _everything_; maybe a bit
      // dangerous/unperformant, but needs to be here or recast
      // will throw an exception (TODO: still trying to isolate a
      // minimal reproduction of this)
      delete args[0].tokens;

      // Print AST
      //console.log(require('util').inspect(args[0], {depth: null}));

      return _recast2.default.print.apply(_recast2.default, args);
    }
  }
};

// From babel-cli:
function toErrorStack(err) {
  if (err._babel && err instanceof SyntaxError) {
    return err.name + ': ' + err.message + '\n' + err.codeFrame;
  } else {
    return err.stack;
  }
}

function transformFile(filename, plugins) {
  var input = filename === '-' ? (0, _readStdin2.default)() : _fs2.default.readFileSync(filename, 'utf8'),
      output = babel.transform(input, _extends({
    filename: filename,
    plugins: plugins
  }, defaultBabelOpts)).code;

  if (input.endsWith('\n') && !output.endsWith('\n')) {
    return output + '\n';
  }

  return output;
}

exports.default = function () {
  var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(argv) {
    var _usage$parse, _usage$parse$args, _usage$parse$args$, filename, _usage$parse$transfor, desiredTransforms, outDir, plugins, stat, dirname, files;

    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _usage$parse = usage.parse(argv), _usage$parse$args = _slicedToArray(_usage$parse.args, 1), _usage$parse$args$ = _usage$parse$args[0], filename = _usage$parse$args$ === undefined ? '-' : _usage$parse$args$, _usage$parse$transfor = _usage$parse.transform, desiredTransforms = _usage$parse$transfor === undefined ? [] : _usage$parse$transfor, outDir = _usage$parse.outDir;
            plugins = desiredTransforms.map(function (name) {
              if (transforms[name]) {
                return transforms[name].plugin;
              } else {
                var plugin = void 0;
                try {
                  plugin = require('babel-plugin-' + name);
                } catch (e) {}

                if (plugin) {
                  return plugin;
                } else {
                  console.warn('Unknown transform: "' + name + '", skipping.');
                }
              }
            }).filter(Boolean);


            try {
              if (!outDir) {
                process.stdout.write(transformFile(filename, plugins));
              } else {
                stat = _fs2.default.statSync(filename);


                if (stat.isDirectory(filename)) {
                  dirname = filename;
                  files = _glob2.default.sync('./**/*.@(js|jsx)', {
                    cwd: dirname
                  });


                  files.forEach(function (filename) {
                    var src = _path2.default.join(dirname, filename),
                        dest = _path2.default.join(outDir, filename);

                    (0, _mkdirp.sync)(_path2.default.dirname(dest));

                    console.log(src + ' -> ' + dest);

                    _fs2.default.writeFileSync(dest, transformFile(src, plugins));
                  });
                }
              }
            } catch (e) {
              console.error(toErrorStack(e));
            }

          case 3:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this);
  }));

  function cli(_x) {
    return _ref.apply(this, arguments);
  }

  return cli;
}();