mana-syringe/lib/core.js

IoC library for mana, easily to use.

"use strict";

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

require("reflect-metadata");

function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }

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

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

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

var Syringe;
exports.Syringe = Syringe;

(function (Syringe) {
  /**
   * 定义注入标识，默认允许多重注入
   */
  Syringe.defineToken = function (name) {
    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
      multiple: true
    };
    return new Syringe.DefinedToken(name, option);
  };

  var DefinedToken = /*#__PURE__*/_createClass(
  /**
   * 兼容 inversify identifier
   */
  function DefinedToken(name) {
    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    _classCallCheck(this, DefinedToken);

    this.prototype = {};
    this.name = void 0;
    this.multiple = void 0;
    this.symbol = void 0;
    var _option$multiple = option.multiple,
        multiple = _option$multiple === void 0 ? false : _option$multiple;
    this.name = name;
    this.symbol = Symbol(this.name);
    this.multiple = multiple;
  });

  Syringe.DefinedToken = DefinedToken;

  function isModule(data) {
    return !!data && _typeof(data) === 'object' && 'id' in data;
  }

  Syringe.isModule = isModule;
  var Lifecycle;

  (function (Lifecycle) {
    Lifecycle["singleton"] = "singleton";
    Lifecycle["transient"] = "transient";
  })(Lifecycle = Syringe.Lifecycle || (Syringe.Lifecycle = {}));

  Syringe.ClassOptionSymbol = Symbol('SyringeClassOptionSymbol');
  Syringe.DefaultOption = {
    lifecycle: Lifecycle.transient
  };
})(Syringe || (exports.Syringe = Syringe = {})); // eslint-disable-next-line @typescript-eslint/no-explicit-any


var Utils;
exports.Utils = Utils;

(function (Utils) {
  function toArray(maybeArray) {
    if (Array.isArray(maybeArray)) {
      return maybeArray;
    }

    if (maybeArray === undefined) {
      return [];
    }

    return [maybeArray];
  }

  Utils.toArray = toArray;

  function isClass(data) {
    return !!(data && typeof data === 'function' && 'prototype' in data);
  }

  Utils.isClass = isClass;

  function isDefinedToken(data) {
    return !!(data && _typeof(data) === 'object' && 'symbol' in data && 'multiple' in data);
  }

  Utils.isDefinedToken = isDefinedToken;

  function isInjectOption(data) {
    return !!(data && _typeof(data) === 'object' && 'token' in data);
  }

  Utils.isInjectOption = isInjectOption;

  function isNamedToken(data) {
    return !!(data && _typeof(data) === 'object' && 'token' in data && 'named' in data);
  }

  Utils.isNamedToken = isNamedToken;

  function isMultipleEnabled(token) {
    return Utils.isDefinedToken(token) && token.multiple;
  }

  Utils.isMultipleEnabled = isMultipleEnabled;
})(Utils || (exports.Utils = Utils = {}));