node-warp/lib/component.js

Web-agnostic Rapid Prototyping tools

'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 _Object$assign = require('babel-runtime/core-js/object/assign')['default'];

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

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

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

var _debug = require('debug');

var _debug2 = _interopRequireDefault(_debug);

var _co = require('co');

var _co2 = _interopRequireDefault(_co);

/**
 * @desc Represents pluggable application extension through mixins and event-hooks
 * @class
 */

var Component = (function () {
  _createClass(Component, null, [{
    key: 'defaults',
    value: {
      priority: 0
    },

    /**
     * @param {string} id
     * @param {Bus} bus
     */
    enumerable: true
  }]);

  function Component(id, bus) {
    _classCallCheck(this, Component);

    this.id = id;
    this.config = {};
    this.imports = {};
    this._bus = bus;
    this.debug = (0, _debug2['default'])(this.id);
    this._setStatus(Component.Status.created);
  }

  _createClass(Component, [{
    key: 'init',
    value: function* init() {}
  }, {
    key: 'start',
    value: function* start() {}
  }, {
    key: 'afterStart',
    value: function* afterStart() {}
  }, {
    key: 'beforeDestroy',
    value: function* beforeDestroy() {}
  }, {
    key: 'destroy',
    value: function* destroy() {}

    /** Bus delegator proxy */

  }, {
    key: 'emit',
    value: function emit(event, data) {
      return this._bus.emit(event, data, { from: this.id });
    }
  }, {
    key: 'wait',
    value: function wait(event) {
      var timeout = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];

      return this._bus.wait(event, timeout);
    }
  }, {
    key: 'request',
    value: function request(event, data) {
      var timeout = arguments.length <= 2 || arguments[2] === undefined ? 0 : arguments[2];

      return this._bus.request(event, data, timeout, this.id);
    }
  }, {
    key: 'on',
    value: function on(event, callback) {
      this.emit('listen', event);
      return this._bus.on(event, callback, this);
    }
  }, {
    key: 'once',
    value: function once(event, callback) {
      this.emit('listen', event);
      return this._bus.once(event, callback, this);
    }
  }, {
    key: 'onRequest',
    value: function onRequest(event, callback) {
      this.emit('listen', event);
      return this._bus.onRequest(event, callback, this);
    }
  }, {
    key: 'off',
    value: function off(event, callback) {
      return this._bus.off(event, callback);
    }

    /** Bus delegator proxy end */

    /**
     * @param {Object} config
     * @param {Object<string, Component>} imports
     * @return {Promise}
     */
  }, {
    key: 'onInit',
    value: function onInit(config, imports) {
      this.config = _Object$assign({}, this.constructor.defaults, config);
      this.imports = _Object$assign({}, imports);

      return _co2['default'].call(this, function* _init() {
        yield this._setStatus(Component.Status.initializing);
        yield this.init(config, imports);
        yield this._setStatus(Component.Status.initialized);
      });
    }

    /**
     * @return {Promise}
     */
  }, {
    key: 'onStart',
    value: function onStart() {
      return _co2['default'].call(this, function* _start() {
        this._setStatus(Component.Status.starting);
        yield this.start();
        this._mapHandlers();
        this._setStatus(Component.Status.started);
      });
    }

    /**
     * @return {Promise}
     */
  }, {
    key: 'onAfterStart',
    value: function onAfterStart() {
      return _co2['default'].call(this, function* _afterStart() {
        yield this.afterStart();
      });
    }

    /**
     * @return {Promise}
     */
  }, {
    key: 'onBeforeDestroy',
    value: function onBeforeDestroy() {
      return _co2['default'].call(this, function* _beforeDestroy() {
        yield this.beforeDestroy();
      });
    }

    /**
     * @return {Promise}
     */
  }, {
    key: 'onDestroy',
    value: function onDestroy() {
      return _co2['default'].call(this, function* _destroy() {
        this._setStatus(Component.Status.destroying);
        yield this.destroy();
        this._unmapHandlers();
        this._setStatus(Component.Status.destroyed);
      });
    }
  }, {
    key: '_setStatus',
    value: function _setStatus(status) {
      var _status = Component.Status[status];
      if (!_status) {
        throw new Error('bad status: ' + status);
      }
      this.status = _status;
      return this.emit('component.' + _status, {
        id: this.id
      });
    }
  }, {
    key: '_mapHandlers',
    value: function _mapHandlers() {
      var _this = this;

      _Object$entries(this.handlers || {}).forEach(function (_ref) {
        var _ref2 = _slicedToArray(_ref, 2);

        var msg = _ref2[0];
        var fn = _ref2[1];
        return _this.on(msg, fn);
      });

      _Object$entries(this.requests || {}).forEach(function (_ref3) {
        var _ref32 = _slicedToArray(_ref3, 2);

        var msg = _ref32[0];
        var fn = _ref32[1];
        return _this.onRequest(msg, fn);
      });
    }
  }, {
    key: '_unmapHandlers',
    value: function _unmapHandlers() {
      var _this2 = this;

      _Object$entries(this.handlers || {}).concat(_Object$entries(this.requests || {})).forEach(function (_ref4) {
        var _ref42 = _slicedToArray(_ref4, 2);

        var msg = _ref42[0];
        var fn = _ref42[1];
        return _this2.off(msg, fn);
      });
    }
  }]);

  return Component;
})();

Component.Status = {
  created: 'created',
  initializing: 'initializing',
  initialized: 'initialized',
  starting: 'starting',
  started: 'started',
  destroying: 'destroying',
  destroyed: 'destroyed'
};

exports['default'] = Component;
module.exports = exports['default'];
//# sourceMappingURL=component.js.map