start-split/dist/index.js

Input task splitter for Start

'use strict';

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

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _start = require('start');

var _start2 = _interopRequireDefault(_start);

var _startInputConnector = require('start-input-connector');

var _startInputConnector2 = _interopRequireDefault(_startInputConnector);

var _startConcurrent = require('start-concurrent');

var _startConcurrent2 = _interopRequireDefault(_startConcurrent);

var _convertSourceMap = require('convert-source-map');

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

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var extendPath = function extendPath(filepath, depth) {
  return _path2.default.join('..'.repeat(depth), filepath);
};

var split = function split(input, dirs, add) {
  return Object.keys(dirs).reduce(function (tasks, dir) {
    var depth = dir.split(_path2.default.sep).length;
    var srcDir = _path2.default.resolve(process.cwd(), dir);
    var filter = function filter(file) {
      return file.path.startsWith(srcDir);
    };

    add(tasks, [(0, _startInputConnector2.default)(input.filter(filter).map(function (file) {
      if (file.map) {
        // eslint-disable-next-line immutable/no-mutation
        file.map.sourceRoot = extendPath(file.map.sourceRoot, depth);
      } else {
        var sourceMap = (0, _convertSourceMap.fromSource)(file.data, true);

        if (sourceMap) {
          // eslint-disable-next-line max-len
          sourceMap.setProperty('sourceRoot', extendPath(sourceMap.getProperty('sourceRoot'), depth));
          // eslint-disable-next-line immutable/no-mutation
          file.data = (0, _convertSourceMap.removeComments)(file.data) + '\n' + sourceMap.toComment();
        }
      }

      return file;
    }))].concat(_toConsumableArray(dirs[dir]())));

    return tasks;
  }, []);
};

var splitCon = function splitCon(input, dirs) {
  return function splitConcurrent(log, reporter) {
    var start = (0, _start2.default)(reporter);

    return start(_startConcurrent2.default.apply(undefined, _toConsumableArray(split(input, dirs, function (tasks, subtasks) {
      return tasks.push(function () {
        return start.apply(undefined, _toConsumableArray(subtasks));
      });
    }, log))));
  };
};

var splitSeq = function splitSeq(input, dirs) {
  return function splitSequential(log, reporter) {
    return (0, _start2.default)(reporter).apply(undefined, _toConsumableArray(split(input, dirs, function (tasks, subtasks) {
      return tasks.push.apply(tasks, _toConsumableArray(subtasks));
    }, log)));
  };
};

exports.default = function (dirs) {
  var concurr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
  return function (input) {
    if (!input) {
      return function () {
        return Promise.reject(new Error('no input to split'));
      };
    }

    // eslint-disable-next-line no-ternary
    return concurr ? splitCon(input, dirs) : splitSeq(input, dirs);
  };
};