slock/lib/index.js

promise-based and functional reactive bindings to Slack's API

'use strict';

var _createClass = require('babel-runtime/helpers/create-class')['default'];

var _classCallCheck = require('babel-runtime/helpers/class-call-check')['default'];

var _slicedToArray = require('babel-runtime/helpers/sliced-to-array')['default'];

var _getIterator = require('babel-runtime/core-js/get-iterator')['default'];

var _Object$defineProperty = require('babel-runtime/core-js/object/define-property')['default'];

var _interopRequireDefault = require('babel-runtime/helpers/interop-require-default')['default'];

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

var _baconjs = require('baconjs');

var _baconjs2 = _interopRequireDefault(_baconjs);

var _baseApi = require('./base-api');

var _baseApi2 = _interopRequireDefault(_baseApi);

var _rtmEvents = require('./rtm-events');

var _rtmEvents2 = _interopRequireDefault(_rtmEvents);

var _webMethods = require('./web-methods');

var _webMethods2 = _interopRequireDefault(_webMethods);

var Slack = (function () {
  function Slack(opts) {
    var _this = this;

    _classCallCheck(this, Slack);

    this.slack = new _baseApi2['default'](opts);
    this.events = {};

    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = _getIterator(_rtmEvents2['default']), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var _event = _step.value;

        _Object$defineProperty(this.events, _event, {
          get: Slack.getEventOfType.bind(this, _event)
        });
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator['return']) {
          _iterator['return']();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }

    var _iteratorNormalCompletion2 = true;
    var _didIteratorError2 = false;
    var _iteratorError2 = undefined;

    try {
      var _loop = function () {
        var method = _step2.value;

        var name = method.name;

        var _name$split = name.split('.');

        var _name$split2 = _slicedToArray(_name$split, 2);

        var namespace = _name$split2[0];
        var submethod = _name$split2[1];

        if (_this[namespace] == null) _this[namespace] = {};
        _this[namespace][submethod] = function (opts) {
          return _baconjs2['default'].fromPromise(_this.slack.method(name, opts));
        };
      };

      for (var _iterator2 = _getIterator(_webMethods2['default']), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
        _loop();
      }
    } catch (err) {
      _didIteratorError2 = true;
      _iteratorError2 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion2 && _iterator2['return']) {
          _iterator2['return']();
        }
      } finally {
        if (_didIteratorError2) {
          throw _iteratorError2;
        }
      }
    }
  }

  _createClass(Slack, [{
    key: 'getChannelName',
    value: function getChannelName(message) {
      if (this.slack.connection.channels != null) {
        return this.slack.connection.channels.filter(function (channel) {
          return channel.id === message.channel;
        }).map(function (channel) {
          return channel.name;
        })[0];
      }
    }
  }, {
    key: 'getUserName',
    value: function getUserName(message) {
      if (this.slack.connection.users != null) {
        return this.slack.connection.users.filter(function (user) {
          return user.id === message.user;
        }).map(function (user) {
          return user.name;
        })[0];
      }
    }
  }, {
    key: 'connect',
    value: function connect(opts) {
      return _baconjs2['default'].fromPromise(this.slack.connect(opts));
    }
  }, {
    key: 'send',
    value: function send(opts) {
      var _context;

      return _baconjs2['default'].fromCallback((_context = this.slack).send.bind(_context), opts);
    }
  }], [{
    key: 'getEventOfType',
    value: function getEventOfType(type) {
      return _baconjs2['default'].fromEvent(this.slack, 'message').filter(function (event) {
        return event.type === type;
      });
    }
  }]);

  return Slack;
})();

exports['default'] = Slack;
module.exports = exports['default'];