1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 | import { reflector } from './reflection/reflection';
|
9 | import { Type } from './facade/type';
|
10 | import { resolveForwardRef } from './forward_ref';
|
11 | import { InjectionToken } from './injection_token';
|
12 | import { Inject, Optional, Self, SkipSelf } from './metadata';
|
13 | import { invalidProviderError, mixingMultiProvidersWithRegularProvidersError, noAnnotationError } from './reflective_errors';
|
14 | import { ReflectiveKey } from './reflective_key';
|
15 |
|
16 |
|
17 |
|
18 |
|
19 | var ReflectiveDependency = (function () {
|
20 | function ReflectiveDependency(key, optional, visibility) {
|
21 | this.key = key;
|
22 | this.optional = optional;
|
23 | this.visibility = visibility;
|
24 | }
|
25 | ReflectiveDependency.fromKey = function (key) {
|
26 | return new ReflectiveDependency(key, false, null);
|
27 | };
|
28 | return ReflectiveDependency;
|
29 | }());
|
30 | export { ReflectiveDependency };
|
31 | var _EMPTY_LIST = [];
|
32 |
|
33 | var ResolvedReflectiveProvider_ = (function () {
|
34 | function ResolvedReflectiveProvider_(key, resolvedFactories, multiProvider) {
|
35 | this.key = key;
|
36 | this.resolvedFactories = resolvedFactories;
|
37 | this.multiProvider = multiProvider;
|
38 | }
|
39 | Object.defineProperty(ResolvedReflectiveProvider_.prototype, "resolvedFactory", {
|
40 | get: function () {
|
41 | return this.resolvedFactories[0];
|
42 | },
|
43 | enumerable: false,
|
44 | configurable: true
|
45 | });
|
46 | return ResolvedReflectiveProvider_;
|
47 | }());
|
48 | export { ResolvedReflectiveProvider_ };
|
49 |
|
50 |
|
51 |
|
52 |
|
53 |
|
54 | var ResolvedReflectiveFactory = (function () {
|
55 | function ResolvedReflectiveFactory(
|
56 | /**
|
57 | * Factory function which can return an instance of an object represented by a key.
|
58 | */
|
59 | factory,
|
60 | /**
|
61 | * Arguments (dependencies) to the `factory` function.
|
62 | */
|
63 | dependencies) {
|
64 | this.factory = factory;
|
65 | this.dependencies = dependencies;
|
66 | }
|
67 | return ResolvedReflectiveFactory;
|
68 | }());
|
69 | export { ResolvedReflectiveFactory };
|
70 |
|
71 |
|
72 |
|
73 | function resolveReflectiveFactory(provider) {
|
74 | var factoryFn;
|
75 | var resolvedDeps;
|
76 | if (provider.useClass) {
|
77 | var useClass = resolveForwardRef(provider.useClass);
|
78 | factoryFn = reflector.factory(useClass);
|
79 | resolvedDeps = _dependenciesFor(useClass);
|
80 | }
|
81 | else if (provider.useExisting) {
|
82 | factoryFn = function (aliasInstance) { return aliasInstance; };
|
83 | resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];
|
84 | }
|
85 | else if (provider.useFactory) {
|
86 | factoryFn = provider.useFactory;
|
87 | resolvedDeps = constructDependencies(provider.useFactory, provider.deps);
|
88 | }
|
89 | else {
|
90 | factoryFn = function () { return provider.useValue; };
|
91 | resolvedDeps = _EMPTY_LIST;
|
92 | }
|
93 | return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);
|
94 | }
|
95 |
|
96 |
|
97 |
|
98 |
|
99 |
|
100 |
|
101 | function resolveReflectiveProvider(provider) {
|
102 | return new ResolvedReflectiveProvider_(ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)], provider.multi || false);
|
103 | }
|
104 |
|
105 |
|
106 |
|
107 | export function resolveReflectiveProviders(providers) {
|
108 | var normalized = _normalizeProviders(providers, []);
|
109 | var resolved = normalized.map(resolveReflectiveProvider);
|
110 | var resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map());
|
111 | return Array.from(resolvedProviderMap.values());
|
112 | }
|
113 |
|
114 |
|
115 |
|
116 |
|
117 |
|
118 | export function mergeResolvedReflectiveProviders(providers, normalizedProvidersMap) {
|
119 | for (var i = 0; i < providers.length; i++) {
|
120 | var provider = providers[i];
|
121 | var existing = normalizedProvidersMap.get(provider.key.id);
|
122 | if (existing) {
|
123 | if (provider.multiProvider !== existing.multiProvider) {
|
124 | throw mixingMultiProvidersWithRegularProvidersError(existing, provider);
|
125 | }
|
126 | if (provider.multiProvider) {
|
127 | for (var j = 0; j < provider.resolvedFactories.length; j++) {
|
128 | existing.resolvedFactories.push(provider.resolvedFactories[j]);
|
129 | }
|
130 | }
|
131 | else {
|
132 | normalizedProvidersMap.set(provider.key.id, provider);
|
133 | }
|
134 | }
|
135 | else {
|
136 | var resolvedProvider = void 0;
|
137 | if (provider.multiProvider) {
|
138 | resolvedProvider = new ResolvedReflectiveProvider_(provider.key, provider.resolvedFactories.slice(), provider.multiProvider);
|
139 | }
|
140 | else {
|
141 | resolvedProvider = provider;
|
142 | }
|
143 | normalizedProvidersMap.set(provider.key.id, resolvedProvider);
|
144 | }
|
145 | }
|
146 | return normalizedProvidersMap;
|
147 | }
|
148 | function _normalizeProviders(providers, res) {
|
149 | providers.forEach(function (b) {
|
150 | if (b instanceof Type) {
|
151 | res.push({ provide: b, useClass: b });
|
152 | }
|
153 | else if (b && typeof b === 'object' && b.provide !== undefined) {
|
154 | res.push(b);
|
155 | }
|
156 | else if (b instanceof Array) {
|
157 | _normalizeProviders(b, res);
|
158 | }
|
159 | else {
|
160 | throw invalidProviderError(b);
|
161 | }
|
162 | });
|
163 | return res;
|
164 | }
|
165 | export function constructDependencies(typeOrFunc, dependencies) {
|
166 | if (!dependencies) {
|
167 | return _dependenciesFor(typeOrFunc);
|
168 | }
|
169 | else {
|
170 | var params_1 = dependencies.map(function (t) { return [t]; });
|
171 | return dependencies.map(function (t) { return _extractToken(typeOrFunc, t, params_1); });
|
172 | }
|
173 | }
|
174 | function _dependenciesFor(typeOrFunc) {
|
175 | var params = reflector.parameters(typeOrFunc);
|
176 | if (!params)
|
177 | return [];
|
178 | if (params.some(function (p) { return p == null; })) {
|
179 | throw noAnnotationError(typeOrFunc, params);
|
180 | }
|
181 | return params.map(function (p) { return _extractToken(typeOrFunc, p, params); });
|
182 | }
|
183 | function _extractToken(typeOrFunc, metadata, params) {
|
184 | var token = null;
|
185 | var optional = false;
|
186 | if (!Array.isArray(metadata)) {
|
187 | if (metadata instanceof Inject) {
|
188 | return _createDependency(metadata['token'], optional, null);
|
189 | }
|
190 | else {
|
191 | return _createDependency(metadata, optional, null);
|
192 | }
|
193 | }
|
194 | var visibility = null;
|
195 | for (var i = 0; i < metadata.length; ++i) {
|
196 | var paramMetadata = metadata[i];
|
197 | if (paramMetadata instanceof Type) {
|
198 | token = paramMetadata;
|
199 | }
|
200 | else if (paramMetadata instanceof Inject) {
|
201 | token = paramMetadata['token'];
|
202 | }
|
203 | else if (paramMetadata instanceof Optional) {
|
204 | optional = true;
|
205 | }
|
206 | else if (paramMetadata instanceof Self || paramMetadata instanceof SkipSelf) {
|
207 | visibility = paramMetadata;
|
208 | }
|
209 | else if (paramMetadata instanceof InjectionToken) {
|
210 | token = paramMetadata;
|
211 | }
|
212 | }
|
213 | token = resolveForwardRef(token);
|
214 | if (token != null) {
|
215 | return _createDependency(token, optional, visibility);
|
216 | }
|
217 | else {
|
218 | throw noAnnotationError(typeOrFunc, params);
|
219 | }
|
220 | }
|
221 | function _createDependency(token, optional, visibility) {
|
222 | return new ReflectiveDependency(ReflectiveKey.get(token), optional, visibility);
|
223 | }
|
224 |
|
\ | No newline at end of file |