morpha/lib/app/common/PackageManager.js

A Web-IDE or Desktop-IDE creator.

'use strict';

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

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _WHITE_LIST = require('../../common/WHITE_LIST');

var _isPlainObject = require('lodash/isPlainObject');

var _isPlainObject2 = _interopRequireDefault(_isPlainObject);

var _utils = require('./utils');

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

var PackageManager = function () {
  function PackageManager() {
    var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    (0, _classCallCheck3.default)(this, PackageManager);

    this.args = args;
    this._packages = {};
  }

  (0, _createClass3.default)(PackageManager, [{
    key: 'getPackages',
    value: function getPackages() {
      return this._packages;
    }
  }, {
    key: 'loadServices',
    value: function loadServices(services) {
      var _this = this;

      services.forEach(function (service) {
        return _this.loadService(service);
      });
    }
  }, {
    key: 'loadService',
    value: function loadService(_ref) {
      var _this2 = this;

      var packageName = _ref.name,
          _ref$dependencies = _ref.dependencies,
          dependencies = _ref$dependencies === undefined ? [] : _ref$dependencies,
          _ref$styles = _ref.styles,
          styles = _ref$styles === undefined ? [] : _ref$styles,
          mainFn = _ref.fn,
          type = _ref.type;

      if (_WHITE_LIST.CONFIG_NAMES.includes(packageName)) throw new Error('Package name ' + packageName + ' illegal.');
      var currentPack = this._packages[packageName];
      if (!currentPack) currentPack = this._packages[packageName] = createEmptyPackage();
      dependencies.forEach(function (dep) {
        if (!_this2._packages[dep]) _this2._packages[dep] = createEmptyPackage();
      });
      dependencies.forEach(function (dep) {
        _this2._packages[dep].subPacks[packageName] = {
          services: {}
        };
      });
      if (typeof mainFn !== 'function') throw new Error('Package main must be a function in ' + packageName + '.');
      currentPack.mainFn = mainFn;
      currentPack.name = packageName;
      currentPack.type = type;
      currentPack.styles = styles;
      currentPack.dependencies = dependencies;
    }
  }, {
    key: '_initPackages',
    value: function _initPackages() {
      var packages = this._packages;
      var globalConfig = this.args.config || {};
      var preInitPack = function preInitPack(packName) {
        var pack = packages[packName];
        if (pack.preLoaded) return;
        var serviceArgs = { globalConfig: globalConfig[packName] || {}, config: pack.config };
        (0, _utils.each)(pack.subPacks, function (subPack, subPackKey) {
          preInitPack(subPackKey);
        });
        pack.dependencies.forEach(function (dep) {
          serviceArgs[(0, _utils.toCamelCase)(dep)] = packages[dep].subPacks[packName].services;
        });
        // Exec service main function
        var context = pack.context = pack.mainFn(serviceArgs) || {};
        // For service function context
        context.packageName = packName;
        context.dependencies = pack.dependencies;
        (0, _utils.each)(context, function (config, key) {
          // Get config from context
          if (packages[key] && !_WHITE_LIST.CONFIG_NAMES.includes(key)) {
            if (!(0, _isPlainObject2.default)(config)) throw new Error('Package config must be a plain object in "' + packName + '/' + key + '".');
            packages[key].config[packName] = config;
          }
        });
        pack.preLoaded = true;
      };
      (0, _keys2.default)(packages).forEach(function (pack) {
        return preInitPack(pack);
      });
    }
  }, {
    key: '_bootstrapPackages',
    value: function _bootstrapPackages() {
      var packages = this._packages;
      var args = this.args;
      var bootstrapPack = function bootstrapPack(packName) {
        var pack = packages[packName];
        if (pack.loaded) return;
        pack.dependencies.forEach(function (subPack) {
          return bootstrapPack(subPack);
        });
        // Add services to package context
        if (pack.context.services) {
          (0, _utils.each)(pack.subPacks, function (subPack, subPackName) {
            (0, _utils.each)(pack.context.services, function (service, key) {
              subPack.services[key] = pack.context.serviceBind && typeof service === 'function' ? service.bind(subPack, packages[subPackName].context) : service;
            });
          });
        }
        if (typeof pack.context.bootstrap === 'function') pack.context.bootstrap();
        pack.loaded = true;
        if (args.devMode) {
          console.log('Loaded package: ' + packName);
        }
      };
      (0, _keys2.default)(packages).forEach(function (pack) {
        return bootstrapPack(pack);
      });
    }
  }]);
  return PackageManager;
}();

exports.default = PackageManager;


function createEmptyPackage() {
  return { subPacks: {}, config: {}, context: null, preLoaded: false, loaded: false };
}