1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 | import { Injectable, Inject, ɵstringify, NgModule, Directive, Component, Pipe, createPlatformFactory, COMPILER_OPTIONS, Injector, CompilerFactory } from '@angular/core';
|
8 | import { TestComponentRenderer, ɵMetadataOverrider, ɵTestingCompilerFactory } from '@angular/core/testing';
|
9 | import { ɵplatformCoreDynamic, ɵINTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS } from '@angular/platform-browser-dynamic';
|
10 | import { BrowserTestingModule } from '@angular/platform-browser/testing';
|
11 | import { ɵgetDOM, DOCUMENT } from '@angular/common';
|
12 | import { CompileReflector, PipeResolver, DirectiveResolver, NgModuleResolver, ERROR_COMPONENT_TYPE } from '@angular/compiler';
|
13 | import { MockPipeResolver, MockDirectiveResolver, MockNgModuleResolver } from '@angular/compiler/testing';
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 | class DOMTestComponentRenderer extends TestComponentRenderer {
|
24 | |
25 |
|
26 |
|
27 | constructor(_doc) {
|
28 | super();
|
29 | this._doc = _doc;
|
30 | }
|
31 | |
32 |
|
33 |
|
34 |
|
35 | insertRootElement(rootElId) {
|
36 |
|
37 | const template = ɵgetDOM().getDefaultDocument().createElement('template');
|
38 | template.innerHTML = `<div id="${rootElId}"></div>`;
|
39 |
|
40 | const rootEl = ( (getContent(template).firstChild));
|
41 |
|
42 |
|
43 | const oldRoots = this._doc.querySelectorAll('[id^=root]');
|
44 | for (let i = 0; i < oldRoots.length; i++) {
|
45 | ɵgetDOM().remove(oldRoots[i]);
|
46 | }
|
47 | this._doc.body.appendChild(rootEl);
|
48 | }
|
49 | }
|
50 | DOMTestComponentRenderer.decorators = [
|
51 | { type: Injectable }
|
52 | ];
|
53 |
|
54 | DOMTestComponentRenderer.ctorParameters = () => [
|
55 | { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
|
56 | ];
|
57 | if (false) {
|
58 | |
59 |
|
60 |
|
61 |
|
62 | DOMTestComponentRenderer.prototype._doc;
|
63 | }
|
64 |
|
65 |
|
66 |
|
67 |
|
68 | function getContent(node) {
|
69 | if ('content' in node) {
|
70 | return (( (node))).content;
|
71 | }
|
72 | else {
|
73 | return node;
|
74 | }
|
75 | }
|
76 |
|
77 |
|
78 |
|
79 |
|
80 |
|
81 |
|
82 |
|
83 |
|
84 |
|
85 |
|
86 |
|
87 |
|
88 |
|
89 | const COMPILER_PROVIDERS = [
|
90 | { provide: MockPipeResolver, deps: [CompileReflector] },
|
91 | { provide: PipeResolver, useExisting: MockPipeResolver },
|
92 | { provide: MockDirectiveResolver, deps: [CompileReflector] },
|
93 | { provide: DirectiveResolver, useExisting: MockDirectiveResolver },
|
94 | { provide: MockNgModuleResolver, deps: [CompileReflector] },
|
95 | { provide: NgModuleResolver, useExisting: MockNgModuleResolver },
|
96 | ];
|
97 | class TestingCompilerFactoryImpl {
|
98 | |
99 |
|
100 |
|
101 |
|
102 | constructor(_injector, _compilerFactory) {
|
103 | this._injector = _injector;
|
104 | this._compilerFactory = _compilerFactory;
|
105 | }
|
106 | |
107 |
|
108 |
|
109 |
|
110 | createTestingCompiler(options) {
|
111 |
|
112 | const compiler = ( (this._compilerFactory.createCompiler(options)));
|
113 | return new TestingCompilerImpl(compiler, compiler.injector.get(MockDirectiveResolver), compiler.injector.get(MockPipeResolver), compiler.injector.get(MockNgModuleResolver));
|
114 | }
|
115 | }
|
116 | if (false) {
|
117 | |
118 |
|
119 |
|
120 |
|
121 | TestingCompilerFactoryImpl.prototype._injector;
|
122 | |
123 |
|
124 |
|
125 |
|
126 | TestingCompilerFactoryImpl.prototype._compilerFactory;
|
127 | }
|
128 | class TestingCompilerImpl {
|
129 | |
130 |
|
131 |
|
132 |
|
133 |
|
134 |
|
135 | constructor(_compiler, _directiveResolver, _pipeResolver, _moduleResolver) {
|
136 | this._compiler = _compiler;
|
137 | this._directiveResolver = _directiveResolver;
|
138 | this._pipeResolver = _pipeResolver;
|
139 | this._moduleResolver = _moduleResolver;
|
140 | this._overrider = new ɵMetadataOverrider();
|
141 | }
|
142 | |
143 |
|
144 |
|
145 | get injector() { return this._compiler.injector; }
|
146 | |
147 |
|
148 |
|
149 |
|
150 |
|
151 | compileModuleSync(moduleType) {
|
152 | return this._compiler.compileModuleSync(moduleType);
|
153 | }
|
154 | |
155 |
|
156 |
|
157 |
|
158 |
|
159 | compileModuleAsync(moduleType) {
|
160 | return this._compiler.compileModuleAsync(moduleType);
|
161 | }
|
162 | |
163 |
|
164 |
|
165 |
|
166 |
|
167 | compileModuleAndAllComponentsSync(moduleType) {
|
168 | return this._compiler.compileModuleAndAllComponentsSync(moduleType);
|
169 | }
|
170 | |
171 |
|
172 |
|
173 |
|
174 |
|
175 | compileModuleAndAllComponentsAsync(moduleType) {
|
176 | return this._compiler.compileModuleAndAllComponentsAsync(moduleType);
|
177 | }
|
178 | |
179 |
|
180 |
|
181 |
|
182 |
|
183 | getComponentFactory(component) {
|
184 | return this._compiler.getComponentFactory(component);
|
185 | }
|
186 | |
187 |
|
188 |
|
189 |
|
190 | checkOverrideAllowed(type) {
|
191 | if (this._compiler.hasAotSummary(type)) {
|
192 | throw new Error(`${ɵstringify(type)} was AOT compiled, so its metadata cannot be changed.`);
|
193 | }
|
194 | }
|
195 | |
196 |
|
197 |
|
198 |
|
199 |
|
200 | overrideModule(ngModule, override) {
|
201 | this.checkOverrideAllowed(ngModule);
|
202 |
|
203 | const oldMetadata = this._moduleResolver.resolve(ngModule, false);
|
204 | this._moduleResolver.setNgModule(ngModule, this._overrider.overrideMetadata(NgModule, oldMetadata, override));
|
205 | this.clearCacheFor(ngModule);
|
206 | }
|
207 | |
208 |
|
209 |
|
210 |
|
211 |
|
212 | overrideDirective(directive, override) {
|
213 | this.checkOverrideAllowed(directive);
|
214 |
|
215 | const oldMetadata = this._directiveResolver.resolve(directive, false);
|
216 | this._directiveResolver.setDirective(directive, this._overrider.overrideMetadata(Directive, ( (oldMetadata)), override));
|
217 | this.clearCacheFor(directive);
|
218 | }
|
219 | |
220 |
|
221 |
|
222 |
|
223 |
|
224 | overrideComponent(component, override) {
|
225 | this.checkOverrideAllowed(component);
|
226 |
|
227 | const oldMetadata = this._directiveResolver.resolve(component, false);
|
228 | this._directiveResolver.setDirective(component, this._overrider.overrideMetadata(Component, ( (oldMetadata)), override));
|
229 | this.clearCacheFor(component);
|
230 | }
|
231 | |
232 |
|
233 |
|
234 |
|
235 |
|
236 | overridePipe(pipe, override) {
|
237 | this.checkOverrideAllowed(pipe);
|
238 |
|
239 | const oldMetadata = this._pipeResolver.resolve(pipe, false);
|
240 | this._pipeResolver.setPipe(pipe, this._overrider.overrideMetadata(Pipe, oldMetadata, override));
|
241 | this.clearCacheFor(pipe);
|
242 | }
|
243 | |
244 |
|
245 |
|
246 |
|
247 | loadAotSummaries(summaries) { this._compiler.loadAotSummaries(summaries); }
|
248 | |
249 |
|
250 |
|
251 | clearCache() { this._compiler.clearCache(); }
|
252 | |
253 |
|
254 |
|
255 |
|
256 | clearCacheFor(type) { this._compiler.clearCacheFor(type); }
|
257 | |
258 |
|
259 |
|
260 |
|
261 | getComponentFromError(error) { return (( (error)))[ERROR_COMPONENT_TYPE] || null; }
|
262 | |
263 |
|
264 |
|
265 |
|
266 | getModuleId(moduleType) {
|
267 | return this._moduleResolver.resolve(moduleType, true).id;
|
268 | }
|
269 | }
|
270 | if (false) {
|
271 | |
272 |
|
273 |
|
274 |
|
275 | TestingCompilerImpl.prototype._overrider;
|
276 | |
277 |
|
278 |
|
279 |
|
280 | TestingCompilerImpl.prototype._compiler;
|
281 | |
282 |
|
283 |
|
284 |
|
285 | TestingCompilerImpl.prototype._directiveResolver;
|
286 | |
287 |
|
288 |
|
289 |
|
290 | TestingCompilerImpl.prototype._pipeResolver;
|
291 | |
292 |
|
293 |
|
294 |
|
295 | TestingCompilerImpl.prototype._moduleResolver;
|
296 | }
|
297 |
|
298 |
|
299 |
|
300 |
|
301 |
|
302 |
|
303 | const ɵ0 = { providers: COMPILER_PROVIDERS };
|
304 |
|
305 |
|
306 |
|
307 |
|
308 |
|
309 |
|
310 | const platformCoreDynamicTesting = createPlatformFactory(ɵplatformCoreDynamic, 'coreDynamicTesting', [
|
311 | { provide: COMPILER_OPTIONS, useValue: ɵ0, multi: true }, {
|
312 | provide: ɵTestingCompilerFactory,
|
313 | useClass: TestingCompilerFactoryImpl,
|
314 | deps: [Injector, CompilerFactory]
|
315 | }
|
316 | ]);
|
317 |
|
318 |
|
319 |
|
320 |
|
321 |
|
322 |
|
323 |
|
324 |
|
325 |
|
326 |
|
327 |
|
328 |
|
329 |
|
330 |
|
331 |
|
332 |
|
333 | const platformBrowserDynamicTesting = createPlatformFactory(platformCoreDynamicTesting, 'browserDynamicTesting', ɵINTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS);
|
334 |
|
335 |
|
336 |
|
337 |
|
338 |
|
339 | class BrowserDynamicTestingModule {
|
340 | }
|
341 | BrowserDynamicTestingModule.decorators = [
|
342 | { type: NgModule, args: [{
|
343 | exports: [BrowserTestingModule],
|
344 | providers: [
|
345 | { provide: TestComponentRenderer, useClass: DOMTestComponentRenderer },
|
346 | ]
|
347 | },] }
|
348 | ];
|
349 |
|
350 |
|
351 |
|
352 |
|
353 |
|
354 |
|
355 |
|
356 |
|
357 |
|
358 |
|
359 |
|
360 |
|
361 |
|
362 |
|
363 |
|
364 |
|
365 |
|
366 | export { BrowserDynamicTestingModule, platformBrowserDynamicTesting, DOMTestComponentRenderer as ɵDOMTestComponentRenderer, COMPILER_PROVIDERS as ɵangular_packages_platform_browser_dynamic_testing_testing_a, TestingCompilerFactoryImpl as ɵangular_packages_platform_browser_dynamic_testing_testing_b, platformCoreDynamicTesting as ɵplatformCoreDynamicTesting };
|
367 |
|