@ztes/corejs/core_dist/container/Container.js

Core-js is a better Javascript's framework

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

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

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _Lib = _interopRequireDefault(require("../spanners/Lib"));

var _Exception = _interopRequireDefault(require("../spanners/Exception"));

/**
 * Class Container 容器类
 */
// Lib 常用函数库
var Container = /*#__PURE__*/function () {
  // 闭包[回调/函数]
  // 实例
  // 别名
  // 实例
  function Container() {
    (0, _classCallCheck2.default)(this, Container);
    (0, _defineProperty2.default)(this, "_binds", {});
    (0, _defineProperty2.default)(this, "_instances", {});
    (0, _defineProperty2.default)(this, "_aliases", {});
  }
  /**
   * Method bind :: 绑定注册到容器
   * @param {*} abstract 
   * @param {*} concrete function(){} function(){return new Class()}
   * @param {*} shared 是否为共享
   */


  (0, _createClass2.default)(Container, [{
    key: "bind",
    value: function bind(abstract, concrete) {
      var shared = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

      if (!abstract) {
        throw new _Exception.default('abstract not null', 'FunctionParameterError');
      }

      if (_Lib.default.isFunction(concrete)) {
        this._binds[abstract] = concrete;
      } else {
        this._instances[abstract] = concrete;
      }
    }
    /**
     * Method make :: 实例化 new Class()
     * @param {*} abstract 
     * @param  {...any} args 
     * @returns 
     */

  }, {
    key: "make",
    value: function make(abstract) {
      if (this._instances.hasOwnProperty(abstract)) {
        var _this$_instances;

        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }

        return (_this$_instances = this._instances)[abstract].apply(_this$_instances, args);
      } else {
        throw new _Exception.default('instances is undefined', 'InstancesError');
      }
    }
  }, {
    key: "resolving",
    value: function resolving(abstract, concrete) {}
    /**
     * Method isAlias 确定字符串是否为别名
     * @param {*} name 
     * @returns 
     */

  }, {
    key: "isAlias",
    value: function isAlias(name) {
      return this._aliases[name] ? ture : false;
    }
  }, {
    key: "extend",
    value: function extend(abstract, concrete) {}
    /**
     * Method singleton 单例
     * @param {*} abstract 
     * @param {*} concrete 
     */

  }, {
    key: "singleton",
    value: function singleton(abstract, concrete) {
      // 绑定共享实例
      this.bind(abstract, concrete, true);
    }
    /**
     * Method get
     * @param {*} name 
     * @returns 
     */

  }, {
    key: "get",
    value: function get(name) {
      var binds = this._binds;
      var hasProperty = binds.hasOwnProperty(name);
      return hasProperty ? this._binds[name]() : this._binds;
    }
  }, {
    key: "warp",
    value: function warp() {}
    /**
     * Static method getInstance
     * @returns 
     */

  }, {
    key: "proxyInstance",
    value:
    /**
     * Method proxyInstance
     * @returns 
     */
    function proxyInstance() {
      return new Proxy(this, {
        get: function get(target, propKey) {
          return target[propKey];
        }
      });
    }
    /**
     * Method instance 注册共享实例
     * @param {*} abstract 
     * @param {*} instance 
     * @returns 
     */

  }, {
    key: "instance",
    value: function instance(abstract, _instance) {
      // 未处理
      this._instances[abstract] = _instance; // 未处理

      return _instance;
    }
  }], [{
    key: "getInstance",
    value: function getInstance() {
      var instance = Container._instance;

      if (!instance) {
        instance = Container._instance = new Container();
      }

      return instance.proxyInstance();
    }
  }, {
    key: "setInstance",
    value: function setInstance() {}
  }]);
  return Container;
}();

exports.default = Container;
(0, _defineProperty2.default)(Container, "_instance", null);