soya/lib/Provider.js

'use strict';

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

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

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

/**
 * Used to store context-agnostic dependencies, object instances
 * (services, router, etc.) and data (config, etc.).
 *
 * @CLIENT_SERVER
 */
var Provider = function () {

  /**
   * @param {Object} config
   * @param {ReverseRouter} router
   * @param {boolean} isServerInstance
   */


  /**
   * @type {{[key: string]: any}}
   */


  /**
   * @type {Object}
   */
  function Provider(config, router, isServerInstance) {
    _classCallCheck(this, Provider);

    this._config = config;
    this._router = router;
    this._cache = {};
    this._factories = {};
    this._isServerInstance = isServerInstance;
  }

  /**
   * @param {Function} factory
   */


  /**
   * @type {boolean}
   */


  /**
   * @type {{[key: string}: Function}}
   */

  /**
   * @type {ReverseRouter}
   */


  _createClass(Provider, [{
    key: 'provide',
    value: function provide(factory) {
      var name = factory.factoryName;
      if (typeof name != 'string') {
        throw new Error('Factory registered doesn\'t have a name: ' + factory + '.');
      }
      if (this._factories.hasOwnProperty(name)) {
        if (this._factories[name] == factory) {
          // Return cache if the factory is the same.
          return this._cache[name];
        }
        if (this._isServerInstance) {
          // Disallow replacement of factories at server side. The same Provider
          // instance is shared with plenty of requests at server side. We don't
          // want anything fishy to happen.
          throw new Error('Factory name clash! The name \'' + name + '\' is claimed by two different factories!');
        }
      }

      // Allow replacement of factories if at client side. This comes in handy if
      // the user is hot reloading factories. Since new page instances are created
      // per request anyway, this doesn't matter in client.
      this._factories[name] = factory;
      this._cache = factory(this._config);
    }

    /**
     * @returns {ReverseRouter}
     */

  }, {
    key: 'getRouter',
    value: function getRouter() {
      return this._router;
    }

    /**
     * @returns {Object}
     */

  }, {
    key: 'getConfig',
    value: function getConfig() {
      return this._config;
    }
  }]);

  return Provider;
}();

exports.default = Provider;
//# sourceMappingURL=Provider.js.map