card-sharing/build/core/config.js

card sharing config generator by parsing online sources

'use strict';

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

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; };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _crypto = require('crypto');

var _crypto2 = _interopRequireDefault(_crypto);

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"); }); }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Config = function () {
  _createClass(Config, [{
    key: 'hash',
    get: function get() {
      return _crypto2.default.createHash('md5').update(this.id).digest('hex');
    }
  }, {
    key: 'id',
    get: function get() {
      var id = '';
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = this.constructor.ensureOptions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var key = _step.value;

          id += this[key];
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }

      return id;
    }
  }, {
    key: 'similar',
    get: function get() {
      return this.host + ' ' + this.port;
    }
  }]);

  function Config(options) {
    _classCallCheck(this, Config);

    var constructor = this.constructor;

    options = _extends({}, constructor.defaultOptions, options);

    // ensure options
    if (constructor.ensureOptions) {
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = constructor.ensureOptions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          var key = _step2.value;

          if (!options[key]) {
            throw new TypeError('please provide a options.' + key);
          }
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }
    }

    // save supplied options on instance
    for (var option in options) {
      this[option] = options[option];
    }
  }

  _createClass(Config, [{
    key: 'blacklisted',
    value: function () {
      var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
        var _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, method;

        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _iteratorNormalCompletion3 = true;
                _didIteratorError3 = false;
                _iteratorError3 = undefined;
                _context.prev = 3;
                _iterator3 = this.constructor.blacklist[Symbol.iterator]();

              case 5:
                if (_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done) {
                  _context.next = 14;
                  break;
                }

                method = _step3.value;
                _context.next = 9;
                return method(this);

              case 9:
                if (!_context.sent) {
                  _context.next = 11;
                  break;
                }

                return _context.abrupt('return', true);

              case 11:
                _iteratorNormalCompletion3 = true;
                _context.next = 5;
                break;

              case 14:
                _context.next = 20;
                break;

              case 16:
                _context.prev = 16;
                _context.t0 = _context['catch'](3);
                _didIteratorError3 = true;
                _iteratorError3 = _context.t0;

              case 20:
                _context.prev = 20;
                _context.prev = 21;

                if (!_iteratorNormalCompletion3 && _iterator3.return) {
                  _iterator3.return();
                }

              case 23:
                _context.prev = 23;

                if (!_didIteratorError3) {
                  _context.next = 26;
                  break;
                }

                throw _iteratorError3;

              case 26:
                return _context.finish(23);

              case 27:
                return _context.finish(20);

              case 28:
                return _context.abrupt('return', false);

              case 29:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, this, [[3, 16, 20, 28], [21,, 23, 27]]);
      }));

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

      return blacklisted;
    }()
  }, {
    key: 'unusable',
    value: function () {
      var _ref2 = _asyncToGenerator(regeneratorRuntime.mark(function _callee2() {
        return regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                return _context2.abrupt('return', false);

              case 1:
              case 'end':
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

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

      return unusable;
    }()
  }]);

  return Config;
}();

Config.ensureOptions = [];
Config.blacklist = [];
Config.defaultOptions = {};
exports.default = Config;