mana-syringe
Version:
IoC library for mana, easily to use.
241 lines (205 loc) • 9.41 kB
JavaScript
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
import { isInversifyRegister } from './inversify';
import { bindNamed, bindGeneralToken, bindMonoToken, bindLifecycle } from './inversify';
import { Utils, Syringe } from './core';
import { OptionSymbol } from './side-option';
import { Container } from './container';
export function toRegistryOption(options) {
var token = Utils.toArray(options.token);
var useClass = Utils.toArray(options.useClass);
var useDynamic = Utils.toArray(options.useDynamic);
var useFactory = Utils.toArray(options.useFactory);
var contrib = Utils.toArray(options.contrib);
var lifecycle = options.lifecycle || Syringe.Lifecycle.transient;
var generalOption = {
token: token,
useClass: useClass,
lifecycle: contrib.length > 0 ? Syringe.Lifecycle.singleton : lifecycle,
contrib: contrib,
useDynamic: useDynamic,
useFactory: useFactory
};
if ('useValue' in options) {
generalOption.useValue = options.useValue;
}
return generalOption;
}
export var Register = /*#__PURE__*/function () {
function Register(register, token, option) {
_classCallCheck(this, Register);
this.token = void 0;
this.rawToken = void 0;
this.named = void 0;
this.generalToken = void 0;
this.option = void 0;
this.register = void 0;
this.mutiple = void 0;
this.register = register;
this.token = token;
this.option = option;
this.rawToken = Utils.isNamedToken(token) ? token.token : token;
this.named = Utils.isNamedToken(token) ? token.named : undefined;
this.mutiple = !!this.named || Utils.isMultipleEnabled(this.rawToken);
this.generalToken = this.rawToken;
}
/**
* multi or mono register
* mono bind 优先级 useValue > useDynamic > useFactory > useClass
*/
_createClass(Register, [{
key: "resolve",
value: function resolve() {
var _this = this;
var register = this.register;
if (!isInversifyRegister(register)) {
return;
}
if (this.mutiple) {
this.resolveMutilple(register);
} else {
this.resolveMono(register);
if (!this.named && this.option.contrib.length > 0) {
this.option.contrib.forEach(function (contribution) {
if (Utils.isMultipleEnabled(contribution)) {
bindGeneralToken(contribution, register).toService(_this.generalToken);
} else {
bindMonoToken(contribution, register).toService(_this.generalToken);
}
});
}
}
} // eslint-disable-next-line consistent-return
}, {
key: "resolveMono",
value: function resolveMono(register) {
if ('useValue' in this.option) {
return bindMonoToken(this.generalToken, register).toConstantValue(this.option.useValue);
}
if (this.option.useDynamic.length > 0) {
var dynamic = this.option.useDynamic[this.option.useDynamic.length - 1];
return bindLifecycle(bindMonoToken(this.generalToken, register).toDynamicValue(function (ctx) {
var container = Container.getContainer(ctx.container);
return dynamic({
container: container
});
}), this.option);
}
if (this.option.useFactory.length > 0) {
var factrory = this.option.useFactory[this.option.useFactory.length - 1];
return bindMonoToken(this.generalToken, register).toFactory(function (ctx) {
var container = Container.getContainer(ctx.container);
return factrory({
container: container
});
});
}
if (this.option.useClass.length > 0) {
var newable = this.option.useClass[this.option.useClass.length - 1];
return bindLifecycle(bindMonoToken(this.generalToken, register).to(newable), this.option);
}
}
}, {
key: "resolveMutilple",
value: function resolveMutilple(register) {
var _this2 = this;
var classesList = this.option.useClass.map(function (newable) {
return bindLifecycle(bindGeneralToken(_this2.generalToken, register).to(newable), _this2.option);
});
var dynamicList = this.option.useDynamic.map(function (dynamic) {
return bindLifecycle(bindGeneralToken(_this2.generalToken, register).toDynamicValue(function (ctx) {
var container = Container.getContainer(ctx.container);
return dynamic({
container: container
});
}), _this2.option);
});
var factoryList = this.option.useFactory.map(function (factrory) {
return bindGeneralToken(_this2.generalToken, register).toFactory(function (ctx) {
var container = Container.getContainer(ctx.container);
return factrory({
container: container
});
});
});
var valueToBind = 'useValue' in this.option ? bindGeneralToken(this.generalToken, register).toConstantValue(this.option.useValue) : undefined;
if (this.named) {
classesList.forEach(function (tobind) {
return _this2.named && bindNamed(tobind, _this2.named);
});
dynamicList.forEach(function (tobind) {
return _this2.named && bindNamed(tobind, _this2.named);
});
factoryList.forEach(function (tobind) {
return _this2.named && bindNamed(tobind, _this2.named);
});
if (valueToBind) {
bindNamed(valueToBind, this.named);
}
}
}
}], [{
key: "resolveTarget",
value: // eslint-disable-next-line @typescript-eslint/no-explicit-any
/**
* 注册目标 token，合并 token 配置后基于配置注册
*/
function resolveTarget(register, target) {
var option = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
try {
try {
var sideOption = Reflect.getMetadata(OptionSymbol, target);
if (sideOption) {
Register.resolveOption(register, sideOption);
}
} catch (ex) {// noop
} // 当 target 为类时，将其插入 useClass 配置中
if (Utils.isClass(target)) {
if (!option.useClass) {
option.useClass = [target];
} else {
var classes = Utils.toArray(option.useClass);
classes.unshift(target);
option.useClass = classes;
}
}
var mixedOption;
try {
mixedOption = Reflect.getMetadata(Syringe.ClassOptionSymbol, target);
} catch (ex) {// noop
}
mixedOption = _objectSpread(_objectSpread({}, mixedOption || {}), option);
if (!mixedOption.token) {
mixedOption.token = [target];
} else {
var tokens = Utils.toArray(mixedOption.token);
tokens.unshift(target);
mixedOption.token = tokens;
}
Register.resolveOption(register, mixedOption);
} catch (ex) {// noop
}
}
/**
* 基于配置注册
*/
}, {
key: "resolveOption",
value: function resolveOption(iRegister, baseOption) {
var parsedOption = toRegistryOption(_objectSpread(_objectSpread({}, Register.globalConfig), baseOption));
if (parsedOption.useClass.length === 0 && parsedOption.useDynamic.length === 0 && parsedOption.useFactory.length === 0 && !('useValue' in parsedOption)) {
return;
}
parsedOption.token.forEach(function (token) {
var register = new Register(iRegister, token, _objectSpread({}, parsedOption));
register.resolve();
});
}
}]);
return Register;
}();
Register.globalConfig = Syringe.DefaultOption;