1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
import { BindingCount } from "../bindings/binding_count";
import * as ERROR_MSGS from "../constants/error_msgs";
import { BindingTypeEnum, TargetTypeEnum } from "../constants/literal_types";
import * as METADATA_KEY from "../constants/metadata_keys";
import { isStackOverflowExeption } from "../utils/exceptions";
import { circularDependencyToException, getServiceIdentifierAsString, listMetadataForTarget, listRegisteredBindingsForServiceIdentifier } from "../utils/serialization";
import { Context } from "./context";
import { Metadata } from "./metadata";
import { Plan } from "./plan";
import { getBaseClassDependencyCount, getDependencies, getFunctionName } from "./reflection_utils";
import { Request } from "./request";
import { Target } from "./target";
function getBindingDictionary(cntnr) {
return cntnr._bindingDictionary;
}
function _createTarget(isMultiInject, targetType, serviceIdentifier, name, key, value) {
var metadataKey = isMultiInject ? METADATA_KEY.MULTI_INJECT_TAG : METADATA_KEY.INJECT_TAG;
var injectMetadata = new Metadata(metadataKey, serviceIdentifier);
var target = new Target(targetType, name, serviceIdentifier, injectMetadata);
if (key !== undefined) {
var tagMetadata = new Metadata(key, value);
target.metadata.push(tagMetadata);
}
return target;
}
function _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target) {
var bindings = getBindings(context.container, target.serviceIdentifier);
var activeBindings = [];
if (bindings.length === BindingCount.NoBindingsAvailable &&
context.container.options.autoBindInjectable &&
typeof target.serviceIdentifier === "function" &&
metadataReader.getConstructorMetadata(target.serviceIdentifier).compilerGeneratedMetadata) {
context.container.bind(target.serviceIdentifier).toSelf();
bindings = getBindings(context.container, target.serviceIdentifier);
}
if (!avoidConstraints) {
activeBindings = bindings.filter(function (binding) {
var request = new Request(binding.serviceIdentifier, context, parentRequest, binding, target);
return binding.constraint(request);
});
}
else {
activeBindings = bindings;
}
_validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container);
return activeBindings;
}
function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
switch (bindings.length) {
case BindingCount.NoBindingsAvailable:
if (target.isOptional()) {
return bindings;
}
else {
var serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
var msg = ERROR_MSGS.NOT_REGISTERED;
msg += listMetadataForTarget(serviceIdentifierString, target);
msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
throw new Error(msg);
}
case BindingCount.OnlyOneBindingAvailable:
if (!target.isArray()) {
return bindings;
}
case BindingCount.MultipleBindingsAvailable:
default:
if (!target.isArray()) {
var serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
var msg = ERROR_MSGS.AMBIGUOUS_MATCH + " " + serviceIdentifierString;
msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
throw new Error(msg);
}
else {
return bindings;
}
}
}
function _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, parentRequest, target) {
var activeBindings;
var childRequest;
if (parentRequest === null) {
activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, null, target);
childRequest = new Request(serviceIdentifier, context, null, activeBindings, target);
var thePlan = new Plan(context, childRequest);
context.addPlan(thePlan);
}
else {
activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target);
childRequest = parentRequest.addChildRequest(target.serviceIdentifier, activeBindings, target);
}
activeBindings.forEach(function (binding) {
var subChildRequest = null;
if (target.isArray()) {
subChildRequest = childRequest.addChildRequest(binding.serviceIdentifier, binding, target);
}
else {
if (binding.cache) {
return;
}
subChildRequest = childRequest;
}
if (binding.type === BindingTypeEnum.Instance && binding.implementationType !== null) {
var dependencies = getDependencies(metadataReader, binding.implementationType);
if (!context.container.options.skipBaseClassChecks) {
var baseClassDependencyCount = getBaseClassDependencyCount(metadataReader, binding.implementationType);
if (dependencies.length < baseClassDependencyCount) {
var error = ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH(getFunctionName(binding.implementationType));
throw new Error(error);
}
}
dependencies.forEach(function (dependency) {
_createSubRequests(metadataReader, false, dependency.serviceIdentifier, context, subChildRequest, dependency);
});
}
});
}
function getBindings(container, serviceIdentifier) {
var bindings = [];
var bindingDictionary = getBindingDictionary(container);
if (bindingDictionary.hasKey(serviceIdentifier)) {
bindings = bindingDictionary.get(serviceIdentifier);
}
else if (container.parent !== null) {
bindings = getBindings(container.parent, serviceIdentifier);
}
return bindings;
}
function plan(metadataReader, container, isMultiInject, targetType, serviceIdentifier, key, value, avoidConstraints) {
if (avoidConstraints === void 0) { avoidConstraints = false; }
var context = new Context(container);
var target = _createTarget(isMultiInject, targetType, serviceIdentifier, "", key, value);
try {
_createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, null, target);
return context;
}
catch (error) {
if (isStackOverflowExeption(error)) {
if (context.plan) {
circularDependencyToException(context.plan.rootRequest);
}
}
throw error;
}
}
function createMockRequest(container, serviceIdentifier, key, value) {
var target = new Target(TargetTypeEnum.Variable, "", serviceIdentifier, new Metadata(key, value));
var context = new Context(container);
var request = new Request(serviceIdentifier, context, null, [], target);
return request;
}
export { plan, createMockRequest, getBindingDictionary };
|
