ae-biu/bin/utils/read-dir-recursive.js

Born For AE, Born To Do

'use strict';

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

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _util = require('util');

var _minimatch = require('minimatch');

var _minimatch2 = _interopRequireDefault(_minimatch);

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

var readDirRecursive = exports.readDirRecursive = function () {
  var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(dir, ext) {
    var files, list;
    return _regenerator2.default.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            files = [];
            _context2.next = 3;
            return (0, _util.promisify)(_fs2.default.readdir)(dir);

          case 3:
            list = _context2.sent;
            _context2.next = 6;
            return _promise2.default.all(list.map(function () {
              var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(file) {
                var stat, temp;
                return _regenerator2.default.wrap(function _callee$(_context) {
                  while (1) {
                    switch (_context.prev = _context.next) {
                      case 0:
                        file = _path2.default.resolve(dir, file);
                        _context.next = 3;
                        return (0, _util.promisify)(_fs2.default.stat)(file);

                      case 3:
                        stat = _context.sent;

                        if (!(stat && stat.isDirectory())) {
                          _context.next = 11;
                          break;
                        }

                        _context.next = 7;
                        return readDirRecursive(file, ext);

                      case 7:
                        temp = _context.sent;

                        files = files.concat(temp);
                        _context.next = 12;
                        break;

                      case 11:
                        if (ext) {
                          if ((0, _minimatch2.default)(file, ext, {})) {
                            files.push(file);
                          }
                        } else {
                          files.push(file);
                        }

                      case 12:
                      case 'end':
                        return _context.stop();
                    }
                  }
                }, _callee, undefined);
              }));

              return function (_x3) {
                return _ref2.apply(this, arguments);
              };
            }()));

          case 6:
            return _context2.abrupt('return', files);

          case 7:
          case 'end':
            return _context2.stop();
        }
      }
    }, _callee2, undefined);
  }));

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

var readDirRecursiveSync = exports.readDirRecursiveSync = function readDirRecursiveSync(dir, ext) {
  var files = [];
  var list = _fs2.default.readdirSync(dir);
  list.map(function (file) {
    file = _path2.default.resolve(dir, file);
    var stat = _fs2.default.statSync(file);
    if (stat && stat.isDirectory()) {
      var temp = readDirRecursiveSync(file, ext);
      files = [].concat((0, _toConsumableArray3.default)(files), (0, _toConsumableArray3.default)(temp));
    } else {
      if (ext) {
        if ((0, _minimatch2.default)(file, ext, { matchBase: true })) {
          files.push(file);
        }
      } else {
        files.push(file);
      }
    }
  });

  return files;
};

exports.default = readDirRecursive;