sb-babel-cli/lib/index.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _os = _interopRequireDefault(require("os"));

var _path = _interopRequireDefault(require("path"));

var _sbFs = _interopRequireDefault(require("sb-fs"));

var _chalk = _interopRequireDefault(require("chalk"));

var _pQueue = _interopRequireDefault(require("p-queue"));

var _makeDir = _interopRequireDefault(require("make-dir"));

var _chokidar = _interopRequireDefault(require("chokidar"));

var _anymatch = _interopRequireDefault(require("anymatch"));

var _debounce = _interopRequireDefault(require("lodash/debounce"));

var _child_process = _interopRequireDefault(require("child_process"));

var _package = _interopRequireDefault(require("../package.json"));

var _iterate = _interopRequireDefault(require("./iterate"));

var _helpers = require("./helpers");

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

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

function main(_x) {
  return _main.apply(this, arguments);
}

function _main() {
  _main = _asyncToGenerator(function* (config) {
    let spawnedProcess;

    const resolvedSourceDirectory = _path.default.resolve(config.root, config.sourceDirectory);

    const extensions = config.typescript ? ['.ts', '.tsx', '.js'] : ['.js'];
    const timestampCache = yield (0, _helpers.getCacheDB)(resolvedSourceDirectory, !config.disableCache);
    const babelTransformFile = (0, _helpers.getBabelTransformFile)(resolvedSourceDirectory);
    const transformationQueue = new _pQueue.default({
      concurrency: _os.default.cpus().length
    });

    const getOutputFilePath = filePath => {
      const extName = _path.default.extname(filePath);

      if (extName.length) {
        return `${filePath.slice(0, -1 * _path.default.extname(filePath).length)}.js`;
      }

      return filePath;
    };

    function log(...items) {
      if (config.execute) {
        console.log(`${_chalk.default.yellow('[sb-babel-cli]')}`, ...items);
      } else {
        console.log(...items);
      }
    }

    function processFile(_x2, _x3, _x4) {
      return _processFile.apply(this, arguments);
    }

    function _processFile() {
      _processFile = _asyncToGenerator(function* (sourceFile, outputFile, stats) {
        if (!extensions.includes(_path.default.extname(sourceFile))) return;
        const transformed = yield babelTransformFile(sourceFile, {
          root: config.root
        });
        yield (0, _makeDir.default)(_path.default.dirname(outputFile));
        yield _sbFs.default.writeFile(outputFile, transformed.code, {
          mode: stats.mode
        });
        log(sourceFile, '->', outputFile);

        if (config.writeFlowSources) {
          const flowOutputFile = `${outputFile}.flow`;

          try {
            yield _sbFs.default.unlink(flowOutputFile);
          } catch (_) {
            /* No Op */
          }

          try {
            yield _sbFs.default.symlink(_path.default.resolve(sourceFile), flowOutputFile);
            log(sourceFile, '->', flowOutputFile);
          } catch (error) {
            /* No Op */
          }
        }

        timestampCache.set((0, _helpers.getSha1)(sourceFile), stats.mtime.getTime()).write();
      });
      return _processFile.apply(this, arguments);
    }

    function execute() {
      if (!config.execute) return;

      if (!spawnedProcess) {
        log(_chalk.default.yellow(_package.default.version));
        log(_chalk.default.yellow('to restart at any time, enter `rs`'));
      }

      log(_chalk.default.green(`starting 'node ${config.execute}'`));

      if (spawnedProcess) {
        spawnedProcess.kill();
      }

      spawnedProcess = _child_process.default.spawn(process.execPath, [config.execute], {
        stdio: 'inherit'
      });
    }

    const debounceExecute = (0, _debounce.default)(function () {
      try {
        execute();
      } catch (error) {
        (0, _helpers.logError)(error);
      }
    }, config.executeDelay);
    yield (0, _iterate.default)({
      extensions,
      getOutputFilePath,
      rootDirectory: config.sourceDirectory,
      sourceDirectory: config.sourceDirectory,
      outputDirectory: config.outputDirectory,
      ignored: config.ignored,
      keepExtraFiles: config.keepExtraFiles,
      filesToKeep: input => input.concat(config.writeFlowSources ? input.map(i => `${i}.flow`) : []),

      callback(sourceFile, outputFile, stats) {
        return _asyncToGenerator(function* () {
          const cachedTimestamp = yield timestampCache.get((0, _helpers.getSha1)(sourceFile)).value();

          if (cachedTimestamp === stats.mtime.getTime()) {
            if (!config.execute) {
              log(sourceFile, 'is unchanged');
            }

            return;
          }

          transformationQueue.add(() => processFile(sourceFile, outputFile, stats)).catch(_helpers.logError);
        })();
      }

    });

    if (!config.watch) {
      yield transformationQueue.onIdle();
      return;
    }

    if (config.execute && process.stdin) {
      if (typeof process.stdin.unref === 'function') {
        process.stdin.unref();
      }

      process.stdin.on('data', function (chunk) {
        if (chunk.toString().trim() === 'rs') {
          debounceExecute();
        }
      });
    }

    const watcher = _chokidar.default.watch(resolvedSourceDirectory, {
      ignored: config.ignored,
      alwaysStat: true,
      ignoreInitial: true
    });

    watcher.on('add', function (givenFileName, stats) {
      const fileName = _path.default.relative(resolvedSourceDirectory, givenFileName);

      const sourceFile = _path.default.join(config.sourceDirectory, fileName);

      const outputFile = _path.default.join(config.outputDirectory, fileName);

      transformationQueue.add(() => processFile(sourceFile, getOutputFilePath(outputFile), stats)).catch(_helpers.logError).then(() => {
        if (!config.ignoredForRestart || !(0, _anymatch.default)(config.ignoredForRestart, sourceFile)) {
          debounceExecute();
        }
      });
    });
    watcher.on('change', function (givenFileName, stats) {
      const fileName = _path.default.relative(resolvedSourceDirectory, givenFileName);

      const sourceFile = _path.default.join(config.sourceDirectory, fileName);

      const outputFile = _path.default.join(config.outputDirectory, fileName);

      transformationQueue.add(() => processFile(sourceFile, getOutputFilePath(outputFile), stats)).catch(_helpers.logError).then(() => {
        if (!config.ignoredForRestart || !(0, _anymatch.default)(config.ignoredForRestart, sourceFile)) {
          debounceExecute();
        }
      });
    });
    watcher.on('unlink', function (givenFileName) {
      const fileName = _path.default.relative(resolvedSourceDirectory, givenFileName);

      const outputFile = _path.default.join(config.outputDirectory, fileName);

      _sbFs.default.unlink(outputFile).catch(function () {
        /* No Op */
      });
    });
    yield transformationQueue.onIdle();
    debounceExecute();
  });
  return _main.apply(this, arguments);
}

var _default = main;
exports.default = _default;