oors-autoloader/build/index.js

"use strict";

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

var _easevalidation = require("easevalidation");

var _oors = require("oors");

var _minimatch = _interopRequireDefault(require("minimatch"));

var _glob = _interopRequireDefault(require("glob"));

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

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

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

class AutoloaderModule extends _oors.Module {
  constructor(...args) {
    super(...args);
    this.name = 'oors.autoloader';
    this.filesTree = {};

    this.relative = (module, toPath) => _path.default.resolve(_path.default.dirname(module.filePath), toPath);

    this.glob = (module, pattern, options) => new Promise((resolve, reject) => {
      (0, _glob.default)(this.relative(module, pattern), options, (err, files) => {
        if (err) {
          reject(err);
        } else {
          resolve(files);
        }
      });
    });

    this.find = async (module, pattern) => (await this.scan(module)).filter(_minimatch.default.filter(this.relative(module, pattern)));

    this.scan = async module => {
      if (!this.filesTree[module.name]) {
        this.filesTree[module.name] = await this.glob(module, '**/*.js');
      }

      return this.filesTree[module.name];
    };

    this.import = async (module, pattern, {
      resolveDefault = true
    } = {}) => (await this.glob(module, pattern, {
      nodir: true
    })).map(file => {
      const imported = require(file); // eslint-disable-line global-require, import/no-dynamic-require


      return resolveDefault ? imported.default : imported;
    });

    this.pathExists = async (module, pathToFind) => (await this.scan(module))[pathToFind];
  }

  async setup({
    scan
  }) {
    if (scan) {
      await this.runHook('scan', module => this.scan(module));
    }

    this.export({
      wrap: module => ['glob', 'import', 'pathExists', 'relative', 'find'].reduce((acc, method) => _objectSpread({}, acc, {
        [method]: (...args) => this[method](module, ...args)
      }), {
        module
      })
    });
  }

}

AutoloaderModule.validateConfig = (0, _easevalidation.validate)(_easevalidation.validators.isSchema({
  scan: [_easevalidation.validators.isDefault(false), _easevalidation.validators.isBoolean()]
}));
var _default = AutoloaderModule;
exports.default = _default;