index.js
5.42 KB
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
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* @module
* @description
* Entry point for all APIs of the compiler package.
*
* <div class="callout is-critical">
* <header>Unstable APIs</header>
* <p>
* All compiler apis are currently considered experimental and private!
* </p>
* <p>
* We expect the APIs in this package to keep on changing. Do not rely on them.
* </p>
* </div>
*/
export * from './schema_registry_mock';
export * from './directive_resolver_mock';
export * from './ng_module_resolver_mock';
export * from './pipe_resolver_mock';
import { createPlatformFactory, Injectable, COMPILER_OPTIONS, CompilerFactory, NgModule, Component, Directive, Pipe } from '@angular/core';
import { TestingCompilerFactory } from './private_import_core';
import { platformCoreDynamic, DirectiveResolver, NgModuleResolver, PipeResolver } from '@angular/compiler';
import { MockDirectiveResolver } from './directive_resolver_mock';
import { MockNgModuleResolver } from './ng_module_resolver_mock';
import { MockPipeResolver } from './pipe_resolver_mock';
import { MetadataOverrider } from './metadata_overrider';
export var TestingCompilerFactoryImpl = (function () {
function TestingCompilerFactoryImpl(_compilerFactory) {
this._compilerFactory = _compilerFactory;
}
TestingCompilerFactoryImpl.prototype.createTestingCompiler = function (options) {
var compiler = this._compilerFactory.createCompiler(options);
return new TestingCompilerImpl(compiler, compiler.injector.get(MockDirectiveResolver), compiler.injector.get(MockPipeResolver), compiler.injector.get(MockNgModuleResolver));
};
TestingCompilerFactoryImpl.decorators = [
{ type: Injectable },
];
/** @nocollapse */
TestingCompilerFactoryImpl.ctorParameters = function () { return [
{ type: CompilerFactory, },
]; };
return TestingCompilerFactoryImpl;
}());
export var TestingCompilerImpl = (function () {
function TestingCompilerImpl(_compiler, _directiveResolver, _pipeResolver, _moduleResolver) {
this._compiler = _compiler;
this._directiveResolver = _directiveResolver;
this._pipeResolver = _pipeResolver;
this._moduleResolver = _moduleResolver;
this._overrider = new MetadataOverrider();
}
Object.defineProperty(TestingCompilerImpl.prototype, "injector", {
get: function () { return this._compiler.injector; },
enumerable: true,
configurable: true
});
TestingCompilerImpl.prototype.compileModuleSync = function (moduleType) {
return this._compiler.compileModuleSync(moduleType);
};
TestingCompilerImpl.prototype.compileModuleAsync = function (moduleType) {
return this._compiler.compileModuleAsync(moduleType);
};
TestingCompilerImpl.prototype.compileModuleAndAllComponentsSync = function (moduleType) {
return this._compiler.compileModuleAndAllComponentsSync(moduleType);
};
TestingCompilerImpl.prototype.compileModuleAndAllComponentsAsync = function (moduleType) {
return this._compiler.compileModuleAndAllComponentsAsync(moduleType);
};
TestingCompilerImpl.prototype.getNgContentSelectors = function (component) {
return this._compiler.getNgContentSelectors(component);
};
TestingCompilerImpl.prototype.overrideModule = function (ngModule, override) {
var oldMetadata = this._moduleResolver.resolve(ngModule, false);
this._moduleResolver.setNgModule(ngModule, this._overrider.overrideMetadata(NgModule, oldMetadata, override));
};
TestingCompilerImpl.prototype.overrideDirective = function (directive, override) {
var oldMetadata = this._directiveResolver.resolve(directive, false);
this._directiveResolver.setDirective(directive, this._overrider.overrideMetadata(Directive, oldMetadata, override));
};
TestingCompilerImpl.prototype.overrideComponent = function (component, override) {
var oldMetadata = this._directiveResolver.resolve(component, false);
this._directiveResolver.setDirective(component, this._overrider.overrideMetadata(Component, oldMetadata, override));
};
TestingCompilerImpl.prototype.overridePipe = function (pipe, override) {
var oldMetadata = this._pipeResolver.resolve(pipe, false);
this._pipeResolver.setPipe(pipe, this._overrider.overrideMetadata(Pipe, oldMetadata, override));
};
TestingCompilerImpl.prototype.clearCache = function () { this._compiler.clearCache(); };
TestingCompilerImpl.prototype.clearCacheFor = function (type) { this._compiler.clearCacheFor(type); };
return TestingCompilerImpl;
}());
/**
* Platform for dynamic tests
*
* @experimental
*/
export var platformCoreDynamicTesting = createPlatformFactory(platformCoreDynamic, 'coreDynamicTesting', [
{
provide: COMPILER_OPTIONS,
useValue: {
providers: [
MockPipeResolver, { provide: PipeResolver, useExisting: MockPipeResolver },
MockDirectiveResolver, { provide: DirectiveResolver, useExisting: MockDirectiveResolver },
MockNgModuleResolver, { provide: NgModuleResolver, useExisting: MockNgModuleResolver }
]
},
multi: true
},
{ provide: TestingCompilerFactory, useClass: TestingCompilerFactoryImpl }
]);
//# sourceMappingURL=index.js.map