1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 | import { Injector, THROW_IF_NOT_FOUND } from './injector';
|
9 | import { Self, SkipSelf } from './metadata';
|
10 | import { cyclicDependencyError, instantiationError, noProviderError, outOfBoundsError } from './reflective_errors';
|
11 | import { ReflectiveKey } from './reflective_key';
|
12 | import { resolveReflectiveProviders, } from './reflective_provider';
|
13 |
|
14 | var UNDEFINED = new Object();
|
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 | var ReflectiveInjector = (function () {
|
51 | function ReflectiveInjector() {
|
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 | ReflectiveInjector.resolve = function (providers) {
|
87 | return resolveReflectiveProviders(providers);
|
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 | ReflectiveInjector.resolveAndCreate = function (providers, parent) {
|
116 | var ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
|
117 | return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);
|
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 | ReflectiveInjector.fromResolvedProviders = function (providers, parent) {
|
143 |
|
144 | return new ReflectiveInjector_(providers, parent);
|
145 | };
|
146 | return ReflectiveInjector;
|
147 | }());
|
148 | export { ReflectiveInjector };
|
149 |
|
150 | var ReflectiveInjector_ = (function () {
|
151 | |
152 |
|
153 |
|
154 | function ReflectiveInjector_(_providers, _parent) {
|
155 |
|
156 | this._constructionCounter = 0;
|
157 | this._providers = _providers;
|
158 | this._parent = _parent || null;
|
159 | var len = _providers.length;
|
160 | this.keyIds = new Array(len);
|
161 | this.objs = new Array(len);
|
162 | for (var i = 0; i < len; i++) {
|
163 | this.keyIds[i] = _providers[i].key.id;
|
164 | this.objs[i] = UNDEFINED;
|
165 | }
|
166 | }
|
167 | ReflectiveInjector_.prototype.get = function (token, notFoundValue) {
|
168 | if (notFoundValue === void 0) { notFoundValue = THROW_IF_NOT_FOUND; }
|
169 | return this._getByKey(ReflectiveKey.get(token), null, notFoundValue);
|
170 | };
|
171 | Object.defineProperty(ReflectiveInjector_.prototype, "parent", {
|
172 | get: function () {
|
173 | return this._parent;
|
174 | },
|
175 | enumerable: false,
|
176 | configurable: true
|
177 | });
|
178 | ReflectiveInjector_.prototype.resolveAndCreateChild = function (providers) {
|
179 | var ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
|
180 | return this.createChildFromResolved(ResolvedReflectiveProviders);
|
181 | };
|
182 | ReflectiveInjector_.prototype.createChildFromResolved = function (providers) {
|
183 | var inj = new ReflectiveInjector_(providers);
|
184 | inj._parent = this;
|
185 | return inj;
|
186 | };
|
187 | ReflectiveInjector_.prototype.resolveAndInstantiate = function (provider) {
|
188 | return this.instantiateResolved(ReflectiveInjector.resolve([provider])[0]);
|
189 | };
|
190 | ReflectiveInjector_.prototype.instantiateResolved = function (provider) {
|
191 | return this._instantiateProvider(provider);
|
192 | };
|
193 | ReflectiveInjector_.prototype.getProviderAtIndex = function (index) {
|
194 | if (index < 0 || index >= this._providers.length) {
|
195 | throw outOfBoundsError(index);
|
196 | }
|
197 | return this._providers[index];
|
198 | };
|
199 |
|
200 | ReflectiveInjector_.prototype._new = function (provider) {
|
201 | if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {
|
202 | throw cyclicDependencyError(this, provider.key);
|
203 | }
|
204 | return this._instantiateProvider(provider);
|
205 | };
|
206 | ReflectiveInjector_.prototype._getMaxNumberOfObjects = function () {
|
207 | return this.objs.length;
|
208 | };
|
209 | ReflectiveInjector_.prototype._instantiateProvider = function (provider) {
|
210 | if (provider.multiProvider) {
|
211 | var res = new Array(provider.resolvedFactories.length);
|
212 | for (var i = 0; i < provider.resolvedFactories.length; ++i) {
|
213 | res[i] = this._instantiate(provider, provider.resolvedFactories[i]);
|
214 | }
|
215 | return res;
|
216 | }
|
217 | else {
|
218 | return this._instantiate(provider, provider.resolvedFactories[0]);
|
219 | }
|
220 | };
|
221 | ReflectiveInjector_.prototype._instantiate = function (provider, ResolvedReflectiveFactory) {
|
222 | var _this = this;
|
223 | var factory = ResolvedReflectiveFactory.factory;
|
224 | var deps;
|
225 | try {
|
226 | deps = ResolvedReflectiveFactory.dependencies.map(function (dep) { return _this._getByReflectiveDependency(dep); });
|
227 | }
|
228 | catch (e) {
|
229 | if (e.addKey) {
|
230 | e.addKey(this, provider.key);
|
231 | }
|
232 | throw e;
|
233 | }
|
234 | var obj;
|
235 | try {
|
236 | obj = factory.apply(void 0, deps);
|
237 | }
|
238 | catch (e) {
|
239 | throw instantiationError(this, e, e.stack, provider.key);
|
240 | }
|
241 | return obj;
|
242 | };
|
243 | ReflectiveInjector_.prototype._getByReflectiveDependency = function (dep) {
|
244 | return this._getByKey(dep.key, dep.visibility, dep.optional ? null : THROW_IF_NOT_FOUND);
|
245 | };
|
246 | ReflectiveInjector_.prototype._getByKey = function (key, visibility, notFoundValue) {
|
247 |
|
248 | if (key === INJECTOR_KEY) {
|
249 | return this;
|
250 | }
|
251 | if (visibility instanceof Self) {
|
252 | return this._getByKeySelf(key, notFoundValue);
|
253 | }
|
254 | else {
|
255 | return this._getByKeyDefault(key, notFoundValue, visibility);
|
256 | }
|
257 | };
|
258 | ReflectiveInjector_.prototype._getObjByKeyId = function (keyId) {
|
259 | for (var i = 0; i < this.keyIds.length; i++) {
|
260 | if (this.keyIds[i] === keyId) {
|
261 | if (this.objs[i] === UNDEFINED) {
|
262 | this.objs[i] = this._new(this._providers[i]);
|
263 | }
|
264 | return this.objs[i];
|
265 | }
|
266 | }
|
267 | return UNDEFINED;
|
268 | };
|
269 |
|
270 | ReflectiveInjector_.prototype._throwOrNull = function (key, notFoundValue) {
|
271 | if (notFoundValue !== THROW_IF_NOT_FOUND) {
|
272 | return notFoundValue;
|
273 | }
|
274 | else {
|
275 | throw noProviderError(this, key);
|
276 | }
|
277 | };
|
278 |
|
279 | ReflectiveInjector_.prototype._getByKeySelf = function (key, notFoundValue) {
|
280 | var obj = this._getObjByKeyId(key.id);
|
281 | return obj !== UNDEFINED ? obj : this._throwOrNull(key, notFoundValue);
|
282 | };
|
283 |
|
284 | ReflectiveInjector_.prototype._getByKeyDefault = function (key, notFoundValue, visibility) {
|
285 | var inj;
|
286 | if (visibility instanceof SkipSelf) {
|
287 | inj = this._parent;
|
288 | }
|
289 | else {
|
290 | inj = this;
|
291 | }
|
292 | while (inj instanceof ReflectiveInjector_) {
|
293 | var inj_ = inj;
|
294 | var obj = inj_._getObjByKeyId(key.id);
|
295 | if (obj !== UNDEFINED)
|
296 | return obj;
|
297 | inj = inj_._parent;
|
298 | }
|
299 | if (inj !== null) {
|
300 | return inj.get(key.token, notFoundValue);
|
301 | }
|
302 | else {
|
303 | return this._throwOrNull(key, notFoundValue);
|
304 | }
|
305 | };
|
306 | Object.defineProperty(ReflectiveInjector_.prototype, "displayName", {
|
307 | get: function () {
|
308 | var providers = _mapProviders(this, function (b) { return ' "' + b.key.displayName + '" '; }).join(', ');
|
309 | return "ReflectiveInjector(providers: [" + providers + "])";
|
310 | },
|
311 | enumerable: false,
|
312 | configurable: true
|
313 | });
|
314 | ReflectiveInjector_.prototype.toString = function () {
|
315 | return this.displayName;
|
316 | };
|
317 | return ReflectiveInjector_;
|
318 | }());
|
319 | export { ReflectiveInjector_ };
|
320 | var INJECTOR_KEY = ReflectiveKey.get(Injector);
|
321 | function _mapProviders(injector, fn) {
|
322 | var res = new Array(injector._providers.length);
|
323 | for (var i = 0; i < injector._providers.length; ++i) {
|
324 | res[i] = fn(injector.getProviderAtIndex(i));
|
325 | }
|
326 | return res;
|
327 | }
|
328 |
|
\ | No newline at end of file |