-
29 |
- 31 | {{cell}} 32 | 33 |
Hello world!
25 | ''',
26 | )
27 | class TestShadowedInheritedMembers {}
28 |
--------------------------------------------------------------------------------
/_tests/test/core/view/view_child_regression_test.dart:
--------------------------------------------------------------------------------
1 | import 'dart:html';
2 |
3 | import 'package:ngdart/angular.dart';
4 | import 'package:ngtest/angular_test.dart';
5 | import 'package:test/test.dart';
6 |
7 | import 'view_child_regression_test.template.dart' as ng;
8 |
9 | void main() {
10 | test('$ViewChild#nativeElement should be accessible', () async {
11 | final fixture =
12 | await NgTestBed
30 |
31 |
32 |
33 |
34 |
35 | ''',
36 | directives: [
37 | ChildHostDirective,
38 | NgIf,
39 | ],
40 | )
41 | class ViewChildTest {
42 | @ViewChild('portal', read: Element)
43 | Element? portalElement;
44 |
45 | @ViewChild('container', read: Element)
46 | Element? containerElement;
47 |
48 | @ViewChild('marker', read: ViewContainerRef)
49 | ViewContainerRef? markerViewContainer;
50 |
51 | var showChildHost = false;
52 | }
53 |
54 | @Directive(
55 | selector: '[childHost]',
56 | )
57 | class ChildHostDirective {}
58 |
--------------------------------------------------------------------------------
/_tests/test/integration/unicode_template_test.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngdart/angular.dart';
2 | import 'package:ngtest/angular_test.dart';
3 | import 'package:test/test.dart';
4 |
5 | import 'unicode_template_test.template.dart' as ng;
6 |
7 | // Source: https://github.com/angulardart/angular/issues/233.
8 | void main() {
9 | test('should be able to compile templates with unicode', () async {
10 | final testBed = NgTestBed🎂
20 | ΓΔ
21 | ↔↕
22 | ''',
23 | )
24 | class App {}
25 |
--------------------------------------------------------------------------------
/_tests/test/templates/additional_expression_lib.dart:
--------------------------------------------------------------------------------
1 | /// A support library imported by `additional_expression_test.dart`.
2 | library additional_expression_lib;
3 |
4 | /// A class with static members to be referenced by a template.
5 | class ExternalStaticClass {
6 | static String? nullString;
7 | static String returnsA() => 'A';
8 | static const valueB = 'staticB';
9 | }
10 |
11 | /// A top-level function to be referenced by a template.
12 | String toUppercase(String input) => input.toUpperCase();
13 |
14 | /// A top-level field to be referneced by a template.
15 | const valueB = 'topLevelB';
16 |
17 | /// A top-level field that is null.
18 | const String? nullString = null;
19 |
--------------------------------------------------------------------------------
/analysis_options.yaml:
--------------------------------------------------------------------------------
1 | # Extend the default sub-set of linter/analyzer rules used in google3.
2 | include: package:lints/recommended.yaml
3 |
4 | analyzer:
5 | language:
6 | strict-casts: true
7 | strict-raw-types: true
8 | errors:
9 | # Permanent inclusions: These are optional hints that are not default on.
10 | unused_element: warning
11 | unused_field: warning
12 | unused_local_variable: warning
13 |
14 | # Permanent exclusions: Unlikely to removed.
15 | # =====================
16 | # Ignore our own deprecated symbols (too noisy).
17 | deprecated_member_use_from_same_package: ignore
18 | # Allow having TODOs in the code (too noisy).
19 | todo: ignore
20 | # Allow importing .template.dart files without an [explicit] analyzer error.
21 | uri_has_not_been_generated: ignore
22 |
23 | # Security exclusions: We are security reviewed separate from these lints.
24 | # =====================
25 | unsafe_html: ignore
26 |
27 | # Temporary exclusions: Can be removed in the future.
28 | # =====================
29 | # Re-enable once we no longer have 200+ analyzer related deprecations.
30 | deprecated_member_use: ignore
31 |
32 | linter:
33 | rules:
34 | - always_declare_return_types
35 | - prefer_single_quotes
36 | - directives_ordering
37 | - unawaited_futures
38 | - unsafe_html
39 | - use_super_parameters
40 |
--------------------------------------------------------------------------------
/examples/README.md:
--------------------------------------------------------------------------------
1 | Various canonical example applications for AngularDart.
2 |
--------------------------------------------------------------------------------
/examples/hello_world/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License
2 |
3 | Copyright (c) 2014-2020 Dart Project Authors https://dart.dev
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 |
--------------------------------------------------------------------------------
/examples/hello_world/README.md:
--------------------------------------------------------------------------------
1 | An example of a simple "Hello World", using the normal bootstrap process.
2 |
3 | ## Running locally
4 |
5 | To debug locally with DDC:
6 |
7 | ```bash
8 | $ pub get
9 | $ webdev serve
10 | ```
11 |
12 | To debug locally with Dart2JS, minified:
13 |
14 | ```bash
15 | $ pub get
16 | $ webdev serve --release
17 | ```
18 |
19 | ## Building a binary
20 |
21 | ```bash
22 | $ pub get
23 | $ webdev build
24 | ```
25 |
--------------------------------------------------------------------------------
/examples/hello_world/_mono_pkg.yaml:
--------------------------------------------------------------------------------
1 | sdk:
2 | - 2.19.6
3 | - pubspec
4 |
5 | stages:
6 | - analyze:
7 | - format
8 | - analyze
9 | - build:
10 | - command: dart run build_runner build --fail-on-severe
11 |
--------------------------------------------------------------------------------
/examples/hello_world/analysis_options.yaml:
--------------------------------------------------------------------------------
1 | include: ../../analysis_options.yaml
2 |
3 | analyzer:
4 | errors:
5 | # False positive related to missing .template.dart files
6 | argument_type_not_assignable: ignore
7 |
--------------------------------------------------------------------------------
/examples/hello_world/build.yaml:
--------------------------------------------------------------------------------
1 | targets:
2 | $default:
3 | builders:
4 | build_web_compilers|entrypoint:
5 | generate_for:
6 | - web/main.dart
7 | release_options:
8 | dart2js_args:
9 | - -O4
10 |
--------------------------------------------------------------------------------
/examples/hello_world/melos_examples.hello_world.iml:
--------------------------------------------------------------------------------
1 |
2 |
25 | Show some {{value}}.
26 |
27 | -
28 |
- 29 | {{index}}: {{v}} ({{odd}}) 30 | 31 |
22 | Message 23 |
24 | 25 | 26 |
30 | This message
31 | contains multiple levels of nested HTML.
32 |
|
27 | |
34 |
30 | Welcome...
31 | To...
32 | Jurassic...
33 | Park!
34 |
35 |
36 | Default i18n text
37 |
38 | ''',
39 | preserveWhitespace: true,
40 | )
41 | class PreserveWhitespace {}
42 |
43 | @Component(
44 | selector: 'preserve-whitespace-false',
45 | template: r'''
46 |
47 | Welcome...
48 | To...
49 | Jurassic...
50 | Park!
51 |
52 |
53 | Default i18n text
54 |
55 | ''',
56 | )
57 | class MinifyWhitespace {}
58 |
--------------------------------------------------------------------------------
/goldens/tool/update.dart:
--------------------------------------------------------------------------------
1 | import 'package:glob/glob.dart';
2 | import 'package:glob/list_local_fs.dart';
3 | import 'package:path/path.dart' as path;
4 |
5 | const dartTool = '.dart_tool/build/generated/goldens';
6 | const template = '$dartTool/test/**/*.template.dart';
7 | const js = '$dartTool/test/**/*.js';
8 |
9 | void main() {
10 | for (var entity in Glob(template).listSync()) {
11 | var relative = path.relative(entity.path, from: dartTool);
12 | entity.renameSync('$relative.golden');
13 | }
14 |
15 | for (var entity in Glob(js).listSync()) {
16 | var relative = path.relative(entity.path, from: dartTool);
17 | entity.renameSync(relative.replaceAll('.dart.js', '.js.golden'));
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/melos.yaml:
--------------------------------------------------------------------------------
1 | name: angular
2 | repository: https://github.com/angulardart-community/angular
3 |
4 | packages:
5 | - "**"
6 | # - ngast
7 | # - ngcompiler
8 | # - ngdart
9 | # - ngforms
10 | # - ngrouter
11 | # - ngtest
12 |
13 | ignore:
14 | - _tests
15 | - examples
16 |
--------------------------------------------------------------------------------
/melos_angular.iml:
--------------------------------------------------------------------------------
1 |
2 | Hello World!
');
12 | /// ```
13 | class NgLexer {
14 | @literal
15 | const factory NgLexer() = NgLexer._;
16 |
17 | // Prevent inheritance.
18 | const NgLexer._();
19 |
20 | /// Return a series of tokens by incrementally scanning [template].
21 | IterableShowing {{items.length}} items:
3 |
8 |
9 | {{ngForm.dirty}}
10 |
11 |
12 |
13 | tokenize(String html) {
8 | exceptionHandler.exceptions.clear();
9 | return const NgLexer().tokenize(html, exceptionHandler);
10 | }
11 |
12 | String untokenize(Iterable tokens) => tokens
13 | .fold(StringBuffer(), (buffer, token) => buffer..write(token.lexeme))
14 | .toString();
15 |
16 | void main() {
17 | String input;
18 | while (true) {
19 | input = stdin.readLineSync(encoding: utf8)!;
20 | if (input == 'QUIT') {
21 | break;
22 | }
23 | try {
24 | var tokens = tokenize(input);
25 | var fixed = untokenize(tokens);
26 | if (exceptionHandler.exceptions.isEmpty) {
27 | print('CORRECT(UNCHANGED): $input');
28 | } else {
29 | print('ORGNL: $input');
30 | print('FIXED: $fixed');
31 | print('ERRORS:');
32 | for (var e in exceptionHandler.exceptions) {
33 | var context = input.substring(e.offset!, e.offset! + e.length!);
34 | print('${e.errorCode.message} :: $context at ${e.offset}');
35 | }
36 | }
37 | } catch (e) {
38 | print(e);
39 | }
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/ngast/test/e2e/e2e_template_tests.dart:
--------------------------------------------------------------------------------
1 | import 'dart:io';
2 |
3 | import 'package:ngast/ngast.dart';
4 | import 'package:path/path.dart' as p;
5 | import 'package:test/test.dart';
6 |
7 | void main() {
8 | var parse = const NgParser().parse;
9 | var templatesDir = p.join('test', 'e2e', 'templates');
10 |
11 | // Just assert that we can parse all of these templates without failing.
12 | Directory(templatesDir).listSync().forEach((file) {
13 | if (file is File) {
14 | test('should parse ${p.basenameWithoutExtension(file.path)}', () {
15 | parse(file.readAsStringSync(), sourceUrl: file.absolute.path);
16 | });
17 | }
18 | });
19 | }
20 |
--------------------------------------------------------------------------------
/ngast/test/e2e/templates/fixed_material_tab_strip.html:
--------------------------------------------------------------------------------
1 |
6 |
21 |
--------------------------------------------------------------------------------
/ngast/test/e2e/templates/material_button.html:
--------------------------------------------------------------------------------
1 |
6 |
7 |
14 |
15 |
--------------------------------------------------------------------------------
/ngast/test/e2e/templates/material_checkbox.html:
--------------------------------------------------------------------------------
1 |
6 |
7 |
26 |
--------------------------------------------------------------------------------
/ngast/test/e2e/templates/material_popup.html:
--------------------------------------------------------------------------------
1 |
6 |
7 | {
3 | 'aria-activedescendant',
4 | 'aria-atomic',
5 | 'aria-autocomplete',
6 | 'aria-busy',
7 | 'aria-checked',
8 | 'aria-colcount',
9 | 'aria-colindex',
10 | 'aria-colspan',
11 | 'aria-controls',
12 | 'aria-current',
13 | 'aria-describedat',
14 | 'aria-describedby',
15 | 'aria-disabled',
16 | 'aria-dropeffect',
17 | 'aria-errormessage',
18 | 'aria-expanded',
19 | 'aria-flowto',
20 | 'aria-grabbed',
21 | 'aria-haspopup',
22 | 'aria-hidden',
23 | 'aria-invalid',
24 | 'aria-keyshortcuts',
25 | 'aria-label',
26 | 'aria-labelledby',
27 | 'aria-level',
28 | 'aria-live',
29 | 'aria-modal',
30 | 'aria-multiline',
31 | 'aria-multiselectable',
32 | 'aria-orientation',
33 | 'aria-owns',
34 | 'aria-placeholder',
35 | 'aria-posinset',
36 | 'aria-pressed',
37 | 'aria-readonly',
38 | 'aria-relevant',
39 | 'aria-required',
40 | 'aria-roledescription',
41 | 'aria-rowcount',
42 | 'aria-rowindex',
43 | 'aria-rowspan',
44 | 'aria-selected',
45 | 'aria-setsize',
46 | 'aria-sort',
47 | 'aria-valuemax',
48 | 'aria-valuemin',
49 | 'aria-valuenow',
50 | 'aria-valuetext'
51 | };
52 |
53 | /// Returns true if input is a valid ARIA attribute.
54 | bool isAriaAttribute(String attribute) => _ariaAttributes.contains(attribute);
55 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/chars.dart:
--------------------------------------------------------------------------------
1 | const ngSpace = '\uE500';
2 |
3 | String replaceNgSpace(String value) {
4 | return value.replaceAll(ngSpace, ' ');
5 | }
6 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/compiler_utils.dart:
--------------------------------------------------------------------------------
1 | import 'compile_metadata.dart';
2 |
3 | const moduleSuffix = '.dart';
4 |
5 | String templateModuleUrl(CompileTypeMetadata type) {
6 | var moduleUrl = type.moduleUrl!;
7 | var urlWithoutSuffix =
8 | moduleUrl.substring(0, moduleUrl.length - moduleSuffix.length);
9 | return '$urlWithoutSuffix.template$moduleSuffix';
10 | }
11 |
12 | String stylesModuleUrl(String stylesheetUrl, bool shim) {
13 | return shim
14 | ? '$stylesheetUrl.shim$moduleSuffix'
15 | : '$stylesheetUrl$moduleSuffix';
16 | }
17 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/html_tags.dart:
--------------------------------------------------------------------------------
1 | HtmlTagDefinition getHtmlTagDefinition(String tagName) {
2 | var result = _tagDefinitions[tagName.toLowerCase()];
3 | return result ?? const HtmlTagDefinition();
4 | }
5 |
6 | class HtmlTagDefinition {
7 | final String? implicitNamespacePrefix;
8 | final bool isVoid;
9 |
10 | const HtmlTagDefinition({this.implicitNamespacePrefix, this.isVoid = false});
11 | }
12 | // see http://www.w3.org/TR/html51/syntax.html#optional-tags
13 |
14 | // This implementation does not fully conform to the HTML5 spec.
15 | const _tagDefinitions = {
16 | 'base': HtmlTagDefinition(isVoid: true),
17 | 'meta': HtmlTagDefinition(isVoid: true),
18 | 'area': HtmlTagDefinition(isVoid: true),
19 | 'embed': HtmlTagDefinition(isVoid: true),
20 | 'link': HtmlTagDefinition(isVoid: true),
21 | 'img': HtmlTagDefinition(isVoid: true),
22 | 'input': HtmlTagDefinition(isVoid: true),
23 | 'param': HtmlTagDefinition(isVoid: true),
24 | 'hr': HtmlTagDefinition(isVoid: true),
25 | 'br': HtmlTagDefinition(isVoid: true),
26 | 'source': HtmlTagDefinition(isVoid: true),
27 | 'track': HtmlTagDefinition(isVoid: true),
28 | 'wbr': HtmlTagDefinition(isVoid: true),
29 | 'col': HtmlTagDefinition(isVoid: true),
30 | 'svg': HtmlTagDefinition(implicitNamespacePrefix: 'svg'),
31 | 'math': HtmlTagDefinition(implicitNamespacePrefix: 'math'),
32 | };
33 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/i18n/message.dart:
--------------------------------------------------------------------------------
1 | import 'package:collection/collection.dart';
2 |
3 | import 'metadata.dart';
4 |
5 | const _map = MapEquality();
6 |
7 | /// An internationalized message.
8 | class I18nMessage {
9 | /// Arguments that appear as interpolations in [text].
10 | ///
11 | /// These are currently only used to support HTML nested within this message.
12 | final Map args;
13 |
14 | /// Metadata used for internationalization of this message.
15 | final I18nMetadata metadata;
16 |
17 | /// The message text to be translated for different locales.
18 | final String text;
19 |
20 | /// Creates an internationalized message from [text] with [metadata].
21 | ///
22 | /// Any arguments that appear as interpolations in [text] should be mapped
23 | /// to their value in [args].
24 | I18nMessage(
25 | this.text,
26 | this.metadata, {
27 | this.args = const {},
28 | });
29 |
30 | /// Whether this message contains nested HTML.
31 | bool get containsHtml => args.isNotEmpty;
32 |
33 | @override
34 | int get hashCode => metadata.hashCode ^ text.hashCode ^ _map.hash(args);
35 |
36 | @override
37 | bool operator ==(Object other) =>
38 | other is I18nMessage &&
39 | other.metadata == metadata &&
40 | other.text == text &&
41 | _map.equals(other.args, args);
42 | }
43 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/js_split_facade.dart:
--------------------------------------------------------------------------------
1 | /// A [String.split] implementation that is like JS' implementation.
2 | ///
3 | /// See https://dartpad.dartlang.org/37a53b0d5d4cced6c7312b2b965ed7fd.
4 | List jsSplit(String s, RegExp regExp) {
5 | var parts = [];
6 | var lastEnd = 0;
7 | for (var match in regExp.allMatches(s)) {
8 | parts.add(s.substring(lastEnd, match.start));
9 | lastEnd = match.end;
10 | for (var i = 0, len = match.groupCount; i < len; i++) {
11 | parts.add(match.group(i + 1)!);
12 | }
13 | }
14 | parts.add(s.substring(lastEnd));
15 | return parts;
16 | }
17 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/optimize_ir/merge_events.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngcompiler/v1/src/compiler/ir/model.dart' as ir;
2 |
3 | /// Combines multiple [ir.EventHandlers] together as an optimization.
4 | ///
5 | /// In the case that multiple bindings on a directive or element target the same
6 | /// event name, we can merge these handlers into a single method.
7 | List mergeEvents(List events) {
8 | final visitedEvents = {};
9 | for (var event in events) {
10 | var eventName = (event.target as ir.BoundEvent).name;
11 | var handler = visitedEvents[eventName];
12 | if (handler == null) {
13 | visitedEvents[eventName] = event;
14 | continue;
15 | }
16 | visitedEvents[eventName] = _merge(handler, event);
17 | }
18 | return visitedEvents.values.toList();
19 | }
20 |
21 | ir.Binding _merge(ir.Binding handler, ir.Binding event) => ir.Binding(
22 | target: handler.target,
23 | source: (handler.source as ir.EventHandler)
24 | .merge(event.source as ir.EventHandler));
25 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/optimize_ir/optimize_lifecycles.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngcompiler/v1/src/compiler/ir/model.dart' as ir;
2 |
3 | /// Optimizes lifecycle hooks in the directive.
4 | ///
5 | /// If there are no inputs declared, then nothing can every change for the
6 | /// matched directive. Thus, we do not need to call the `ngAfterChanges`
7 | /// lifecycle hook.
8 | ir.MatchedDirective optimizeLifecycles(ir.MatchedDirective directive) {
9 | if (directive.inputs.isNotEmpty ||
10 | !directive.hasLifecycle(ir.Lifecycle.afterChanges)) {
11 | return directive;
12 | }
13 |
14 | return ir.MatchedDirective(
15 | lifecycles: directive.lifecycles
16 | .where((lifecycle) => lifecycle != ir.Lifecycle.afterChanges)
17 | .toSet(),
18 | providerSource: directive.providerSource,
19 | inputs: directive.inputs,
20 | outputs: directive.outputs,
21 | hasInputs: directive.hasInputs,
22 | hasHostProperties: directive.hasHostProperties,
23 | isComponent: directive.isComponent,
24 | isOnPush: directive.isOnPush,
25 | );
26 | }
27 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/parse_util.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngast/ngast.dart';
2 | import 'package:ngcompiler/v2/context.dart';
3 | import 'package:source_span/source_span.dart';
4 |
5 | /// Collects parsing exceptions from `ngast`, converting to [BuildError].
6 | ///
7 | /// See [throwErrorsIfAny].
8 | class AstExceptionHandler extends RecoveringExceptionHandler {
9 | /// Contents of the source file.
10 | final String _contents;
11 |
12 | /// URL to the source file.
13 | final String _sourceUrl;
14 |
15 | /// Directive that is being compiled.
16 | final String _directiveName;
17 |
18 | AstExceptionHandler(
19 | this._contents,
20 | this._sourceUrl,
21 | this._directiveName,
22 | );
23 |
24 | /// Converts and throws [exceptions] as a [BuildError].
25 | ///
26 | /// If no [exceptions] were collected during parsing no error is thrown.
27 | void throwErrorsIfAny() {
28 | if (exceptions.isEmpty) {
29 | return;
30 | }
31 | final sourceFile = SourceFile.fromString(_contents, url: _sourceUrl);
32 | throw BuildError.fromMultiple(
33 | exceptions.map(
34 | (e) => BuildError.forSourceSpan(
35 | sourceFile.span(e.offset!, e.offset! + e.length!),
36 | e.errorCode.message,
37 | ),
38 | ),
39 | 'Errors in $_sourceUrl while compiling component $_directiveName',
40 | );
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/schema/element_schema_registry.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngcompiler/v1/src/compiler/security.dart';
2 |
3 | abstract class ElementSchemaRegistry {
4 | bool hasProperty(String tagName, String propName);
5 | bool hasAttribute(String tagName, String attributeName);
6 | bool hasEvent(String tagName, String eventName);
7 | String getMappedPropName(String propName);
8 | TemplateSecurityContext securityContext(String tagName, String propName);
9 | }
10 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/security.dart:
--------------------------------------------------------------------------------
1 | /// A [TemplateSecurityContext] specifies a category of security vulnerabilities
2 | /// if the content is not sanitized.
3 | ///
4 | /// Examples: A DOM property that is used as a url is classified as having
5 | /// the Url [HtmlSecurityContext].
6 | ///
7 | /// [innerHTML] that could cause Cross Site Scripting (XSS) security bugs when
8 | /// improperly handled is classified as HTML.
9 | enum TemplateSecurityContext {
10 | /// No security implication.
11 | none,
12 |
13 | /// Context for free form html content.
14 | html,
15 |
16 | /// Context for element style.
17 | style,
18 |
19 | /// Link such as a,href.
20 | url,
21 |
22 | /// Url pointing to a resource to be loaded.
23 | resourceUrl,
24 | }
25 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/source_module.dart:
--------------------------------------------------------------------------------
1 | /// [outputUrl] and the generated [sourceCode] related to view compilation.
2 | class DartSourceOutput {
3 | final String outputUrl;
4 | final String sourceCode;
5 |
6 | DartSourceOutput({
7 | required this.outputUrl,
8 | required this.sourceCode,
9 | });
10 | }
11 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/style_url_resolver.dart:
--------------------------------------------------------------------------------
1 | class StyleWithImports {
2 | final String style;
3 | final List styleUrls;
4 | StyleWithImports(this.style, this.styleUrls);
5 | }
6 |
7 | /// Whether [url] resides within the current package or a dependency.
8 | bool isStyleUrlResolvable(String? url) {
9 | if (url == null || url.isEmpty || url[0] == '/') return false;
10 | var schemeMatch = _urlWithSchemaRe.firstMatch(url);
11 | return schemeMatch == null ||
12 | schemeMatch[1] == 'package' ||
13 | schemeMatch[1] == 'asset';
14 | }
15 |
16 | /// Rewrites style sheets by resolving and removing the @import urls that
17 | /// are either relative or don't have a `package:` scheme
18 | StyleWithImports extractStyleUrls(String baseUrl, String cssText) {
19 | Uri? baseUri;
20 | var foundUrls = [];
21 | var modifiedCssText = cssText.replaceAllMapped(_cssImportRe, (m) {
22 | var url = m[1] ?? m[2];
23 | if (!isStyleUrlResolvable(url)) {
24 | // Do not attempt to resolve non-package absolute URLs with URI scheme
25 | return m[0]!;
26 | }
27 | baseUri ??= Uri.parse(baseUrl);
28 | foundUrls.add(baseUri!.resolve(url!).toString());
29 | return '';
30 | });
31 | return StyleWithImports(modifiedCssText, foundUrls);
32 | }
33 |
34 | final _cssImportRe = RegExp(r'@import\s+(?:url\()?\s*(?:(?:['
35 | "'"
36 | r'"]([^'
37 | "'"
38 | r'"]*))|([^;\)\s]*))[^;]*;?');
39 | final _urlWithSchemaRe = RegExp('^([^:/?#]+):');
40 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/stylesheet_compiler/builder.dart:
--------------------------------------------------------------------------------
1 | import 'package:build/build.dart';
2 | import 'package:ngcompiler/v1/cli.dart';
3 |
4 | import 'processor.dart';
5 |
6 | const _cssExtension = '.css';
7 | const _shimmedStylesheetExtension = '.css.shim.dart';
8 | const _nonShimmedStylesheetExtension = '.css.dart';
9 |
10 | /// Pre-compiles CSS stylesheet files to Dart code for Angular 2.
11 | class StylesheetCompiler implements Builder {
12 | final CompilerFlags _flags;
13 |
14 | const StylesheetCompiler(this._flags);
15 |
16 | @override
17 | final buildExtensions = const {
18 | _cssExtension: [
19 | _shimmedStylesheetExtension,
20 | _nonShimmedStylesheetExtension,
21 | ],
22 | };
23 |
24 | @override
25 | Future build(BuildStep buildStep) async {
26 | final outputs = await processStylesheet(
27 | buildStep,
28 | buildStep.inputId,
29 | _flags,
30 | );
31 | outputs.forEach(buildStep.writeAsString);
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/stylesheet_compiler/processor.dart:
--------------------------------------------------------------------------------
1 | import 'package:build/build.dart';
2 | import 'package:ngcompiler/v1/cli.dart';
3 | import 'package:ngcompiler/v1/src/compiler/module/ng_compiler_module.dart';
4 | import 'package:ngcompiler/v1/src/compiler/source_module.dart';
5 | import 'package:ngcompiler/v1/src/source_gen/common/url_resolver.dart';
6 |
7 | Future> processStylesheet(
8 | BuildStep buildStep,
9 | AssetId stylesheetId,
10 | CompilerFlags flags,
11 | ) async {
12 | final stylesheetUrl = toAssetUri(stylesheetId);
13 | final templateCompiler = createViewCompiler(buildStep, flags);
14 | final cssText = await buildStep.readAsString(stylesheetId);
15 | final sourceModules = templateCompiler.compileStylesheet(
16 | stylesheetUrl,
17 | cssText,
18 | );
19 | return _mapSourceByAssetId(sourceModules);
20 | }
21 |
22 | Map _mapSourceByAssetId(List modules) {
23 | final sourceByAssetId = {};
24 | for (final module in modules) {
25 | final assetId = AssetId.resolve(Uri.parse(module.outputUrl));
26 | sourceByAssetId[assetId] = module.sourceCode;
27 | }
28 | return sourceByAssetId;
29 | }
30 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/view_compiler/devtools.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngcompiler/v1/src/compiler/identifiers.dart';
2 | import 'package:ngcompiler/v1/src/compiler/ir/model.dart';
3 | import 'package:ngcompiler/v1/src/compiler/output/output_ast.dart';
4 |
5 | /// Optionally returns a statement that records a [binding] for developer tools.
6 | ///
7 | /// If [binding] is an `@Input()` binding, this returns an `if` statement that
8 | /// records the bound [value] for inspection when developer tooling is enabled:
9 | ///
10 | /// ```
11 | /// if (isDevToolsEnabled) {
12 | /// ComponentInspector.instance.recordInput(component, 'name', value);
13 | /// }
14 | /// ```
15 | ///
16 | /// Otherwise, this returns null.
17 | Statement? devToolsBindingStatement(
18 | Binding binding,
19 | Expression? receiver,
20 | Expression value,
21 | ) {
22 | var target = binding.target;
23 | if (target is InputBinding) {
24 | return IfStmt(importExpr(DevTools.isDevToolsEnabled), [
25 | _recordInputStatement(receiver!, literal(target.templateName), value),
26 | ]);
27 | }
28 |
29 | return null;
30 | }
31 |
32 | /// Returns a statement that records an input binding.
33 | ///
34 | /// ```
35 | /// ComponentInspector.instance.recordInput(component, name, value);
36 | /// ```
37 | Statement _recordInputStatement(
38 | Expression component,
39 | Expression name,
40 | Expression value,
41 | ) {
42 | return importExpr(DevTools.inspector)
43 | .callMethod('recordInput', [component, name, value]).toStmt();
44 | }
45 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/view_compiler/event_binder.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngcompiler/v1/src/compiler/ir/model.dart' as ir;
2 | import 'package:ngcompiler/v1/src/compiler/view_compiler/bound_value_converter.dart'
3 | show BoundValueConverter;
4 | import 'package:ngcompiler/v1/src/compiler/view_compiler/ir/provider_source.dart';
5 |
6 | import 'compile_element.dart' show CompileElement;
7 |
8 | void bindDirectiveOutputs(
9 | List outputs,
10 | ProviderSource directiveInstance,
11 | CompileElement compileElement,
12 | ) {
13 | var view = compileElement.view!;
14 | var converter = BoundValueConverter.forView(view);
15 | for (var output in outputs) {
16 | var handlerExpr = converter
17 | .scopeNamespace()
18 | .convertSourceToExpression(output.source, output.target.type)!;
19 | var nodeReference = view.createSubscription();
20 | view.addEventListener(
21 | nodeReference, output, handlerExpr, directiveInstance.build());
22 | }
23 | }
24 |
25 | void bindRenderOutputs(
26 | List outputs, CompileElement compileElement) {
27 | var converter = BoundValueConverter.forView(compileElement.view!);
28 | for (var output in outputs) {
29 | var handlerExpr = converter
30 | .scopeNamespace()
31 | .convertSourceToExpression(output.source, output.target.type)!;
32 | compileElement.view!
33 | .addEventListener(compileElement.renderNode, output, handlerExpr);
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/view_compiler/interpolation_utils.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngcompiler/v1/src/compiler/expression_parser/ast.dart' as ast;
2 | import 'package:ngcompiler/v1/src/compiler/ir/model.dart' as ir;
3 |
4 | bool isInterpolation(ir.BindingSource? source) =>
5 | source is ir.BoundExpression && source.expression.ast is ast.Interpolation;
6 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/view_compiler/ir/provider_source.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngcompiler/v1/src/compiler/compile_metadata.dart';
2 | import 'package:ngcompiler/v1/src/compiler/output/output_ast.dart' as o;
3 |
4 | /// Provider interface passed to view compiler backends to generate code
5 | /// to instantiate a provider and consume.
6 | ///
7 | /// This allows us to hide the hierarchical nature of provider lookups and
8 | /// the actual resolution from view compiler backend.
9 | abstract class ProviderSource {
10 | final CompileTokenMetadata? token;
11 |
12 | ProviderSource(this.token);
13 |
14 | /// Returns a reference to this provider instance.
15 | o.Expression build();
16 |
17 | /// Returns a reference to this provider's `ChangeDetectorRef`, if necessary.
18 | ///
19 | /// Returns a non-null result only if this provider instance is a component
20 | /// that uses `ChangeDetectionStrategy.onPush`. This result is used to
21 | /// implement `ChangeDetectorRef.markChildForCheck()`.
22 | ///
23 | /// Returns null otherwise.
24 | o.Expression? buildChangeDetectorRef() => null;
25 |
26 | /// Whether a dynamic `injectorGet(...)` is required to resolve this provider.
27 | ///
28 | /// For example:
29 | /// ```dart
30 | /// // DependencyService is dynamically required to resolve MyService.
31 | /// _MyService = MyService(injectorGet(DependencyService));
32 | /// ```
33 | bool get hasDynamicDependencies => false;
34 | }
35 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/view_compiler/ir/view_storage.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngcompiler/v1/src/compiler/output/output_ast.dart' as o;
2 |
3 | /// Interface implemented by compiler backend to provide persistant storage
4 | /// of instances for AppView.
5 | abstract class ViewStorage {
6 | ViewStorageItem allocate(
7 | String name, {
8 | o.OutputType outputType = o.objectType,
9 | required List modifiers,
10 | o.Expression? initializer,
11 | });
12 |
13 | o.Expression buildWriteExpr(ViewStorageItem item, o.Expression value);
14 | o.Expression buildReadExpr(ViewStorageItem item);
15 | }
16 |
17 | class ViewStorageItem {
18 | final String name;
19 | final o.OutputType? outputType;
20 | final List modifiers;
21 | final o.Expression? initializer;
22 | ViewStorageItem(this.name,
23 | {this.outputType, required this.modifiers, this.initializer});
24 |
25 | bool get isStatic => modifiers.contains(o.StmtModifier.staticStmt);
26 | }
27 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/view_compiler/parse_utils.dart:
--------------------------------------------------------------------------------
1 | import '../expression_parser/ast.dart'
2 | show AST, ImplicitReceiver, MethodCall, PropertyRead;
3 | import 'constants.dart';
4 |
5 | enum HandlerType { simpleNoArgs, simpleOneArg, notSimple }
6 |
7 | /// Classifies this event binding by it's form.
8 | ///
9 | /// The simple form looks like
10 | ///
11 | /// (event)="handler($event)"
12 | ///
13 | /// or
14 | ///
15 | /// (event)="handler()"
16 | ///
17 | /// Since these types of handlers are so common, we can optimize the code
18 | /// generated for them.
19 | HandlerType handlerTypeFromExpression(AST handler) {
20 | var eventHandler = handler;
21 | if (eventHandler is! MethodCall) {
22 | return HandlerType.notSimple;
23 | }
24 | var call = eventHandler;
25 | if (call.receiver is! ImplicitReceiver || call.namedArgs.isNotEmpty) {
26 | return HandlerType.notSimple;
27 | }
28 | if (call.args.isEmpty) {
29 | return HandlerType.simpleNoArgs;
30 | }
31 | if (call.args.length != 1) {
32 | return HandlerType.notSimple;
33 | }
34 | var singleArg = call.args.single;
35 | if (singleArg is! PropertyRead) {
36 | return HandlerType.notSimple;
37 | }
38 | var property = singleArg;
39 | if (property.name == EventHandlerVars.event.name &&
40 | property.receiver is ImplicitReceiver) {
41 | return HandlerType.simpleOneArg;
42 | } else {
43 | return HandlerType.notSimple;
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/compiler/view_type.dart:
--------------------------------------------------------------------------------
1 | /// What type of generated `AppView` an instance is.
2 | enum ViewType {
3 | /// A view that contains the host element with bound component directive.
4 | ///
5 | /// Contains a `@Component`'s root element.
6 | host,
7 |
8 | /// The view of `@Component` that contains 0 to n _embedded_ views.
9 | component,
10 |
11 | /// A view that is embedded into another view via a `` element.
12 | ///
13 | /// These are only inside a [component] view.
14 | embedded
15 | }
16 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/source_gen/template_compiler/generator.dart:
--------------------------------------------------------------------------------
1 | import 'package:build/build.dart';
2 | import 'package:ngcompiler/v1/cli.dart';
3 | import 'package:ngcompiler/v1/src/source_gen/common/url_resolver.dart';
4 | import 'package:source_gen/source_gen.dart';
5 |
6 | import 'code_builder.dart';
7 | import 'template_processor.dart';
8 |
9 | /// Given an input [library] `a.dart`, returns the code for `a.template.dart`.
10 | Future generate(
11 | LibraryReader library,
12 | BuildStep buildStep,
13 | CompilerFlags flags,
14 | ) {
15 | // Read the library and determine the outputs of `*.template.dart`.
16 | return processTemplates(library.element, buildStep, flags).then((outputs) {
17 | // Writes the output to disk (as a text file).
18 | return buildGeneratedCode(
19 | library.element,
20 | outputs,
21 | fileName(buildStep.inputId),
22 | flags,
23 | );
24 | });
25 | }
26 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/source_gen/template_compiler/lifecycle_hooks.dart:
--------------------------------------------------------------------------------
1 | import 'package:analyzer/dart/element/element.dart';
2 | import 'package:ngcompiler/v1/angular_compiler.dart';
3 | import 'package:ngcompiler/v1/src/compiler/compile_metadata.dart';
4 |
5 | final _typeCheckerToLifecycleHook = {
6 | $OnInit: LifecycleHooks.onInit,
7 | $OnDestroy: LifecycleHooks.onDestroy,
8 | $DoCheck: LifecycleHooks.doCheck,
9 | $AfterChanges: LifecycleHooks.afterChanges,
10 | $AfterContentInit: LifecycleHooks.afterContentInit,
11 | $AfterContentChecked: LifecycleHooks.afterContentChecked,
12 | $AfterViewInit: LifecycleHooks.afterViewInit,
13 | $AfterViewChecked: LifecycleHooks.afterViewChecked,
14 | };
15 |
16 | List extractLifecycleHooks(ClassElement element) {
17 | return _typeCheckerToLifecycleHook.keys
18 | .where((typeChecker) => typeChecker.isAssignableFrom(element))
19 | .map((typeChecker) => _typeCheckerToLifecycleHook[typeChecker]!)
20 | .toList();
21 | }
22 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/source_gen/template_compiler/template_compiler_outputs.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngcompiler/v1/angular_compiler.dart';
2 | import 'package:ngcompiler/v1/src/compiler/source_module.dart';
3 |
4 | /// Elements of a `.template.dart` file to be written to disk.
5 | class TemplateCompilerOutputs {
6 | /// For each `@GenerateInjector`, how to generate those injectors.
7 | final List injectorsOutput;
8 |
9 | /// For each `@Component`, how to generate the backing views.
10 | final DartSourceOutput? templateSource;
11 |
12 | const TemplateCompilerOutputs(
13 | this.templateSource,
14 | this.injectorsOutput,
15 | );
16 | }
17 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v1/src/source_gen/template_compiler/template_processor.dart:
--------------------------------------------------------------------------------
1 | import 'package:analyzer/dart/element/element.dart';
2 | import 'package:build/build.dart';
3 | import 'package:ngcompiler/v1/angular_compiler.dart';
4 | import 'package:ngcompiler/v1/cli.dart';
5 | import 'package:ngcompiler/v1/src/compiler/module/ng_compiler_module.dart';
6 |
7 | import 'check_injectables.dart';
8 | import 'template_compiler_outputs.dart';
9 |
10 | /// Given an input [library] `a.dart`, returns output for `a.template.dart`.
11 | ///
12 | /// "Output" here is defined in terms of [TemplateCompilerOutput], or an
13 | /// abstract collection of elements that need to be emitted into the
14 | /// corresponding `.template.dart` file. See [TemplateCompilerOutput].
15 | Future processTemplates(
16 | LibraryElement library,
17 | BuildStep buildStep,
18 | CompilerFlags flags,
19 | ) async {
20 | // Temporary replace for `resolveReflectables` which is also
21 | // checks elements with `@Injectable()` annotation.
22 | checkInjectables(library);
23 |
24 | // Collect the elements to implement `@GeneratedInjector`(s).
25 | final injectors = InjectorReader.findInjectors(library);
26 |
27 | // Collect the elements to implement views for `@Component`(s).
28 | final compiler = createTemplateCompiler(buildStep, flags);
29 | final sourceModule = await compiler.compile(library);
30 |
31 | // Return them to be emitted to disk as generated code in the future.
32 | return TemplateCompilerOutputs(sourceModule, injectors);
33 | }
34 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v2/analyzer.dart:
--------------------------------------------------------------------------------
1 | import 'package:analyzer/dart/element/nullability_suffix.dart';
2 | import 'package:analyzer/dart/element/type.dart';
3 |
4 | extension NullableDartType on DartType? {
5 | /// Whether the type is an opted-in library where it is explicitly non-null.
6 | bool get isExplicitlyNonNullable {
7 | var type = this;
8 | if (type == null || type.isDynamic) {
9 | return false;
10 | }
11 | if (_isFutureOrWithExplicitlyNullableValue) {
12 | return false;
13 | }
14 | return type.nullabilitySuffix == NullabilitySuffix.none;
15 | }
16 |
17 | /// Whether the type is an opted-in library where it explicitly nullable.
18 | bool get isExplicitlyNullable {
19 | var type = this;
20 | if (type == null || type.isDynamic) {
21 | return false;
22 | }
23 | if (_isFutureOrWithExplicitlyNullableValue) {
24 | return true;
25 | }
26 | return type.nullabilitySuffix == NullabilitySuffix.question;
27 | }
28 |
29 | /// A `FutureOr` can still be assigned null.
30 | bool get _isFutureOrWithExplicitlyNullableValue =>
31 | this!.isDartAsyncFutureOr &&
32 | (this as ParameterizedType).typeArguments.first.isExplicitlyNullable;
33 | }
34 |
--------------------------------------------------------------------------------
/ngcompiler/lib/v2/asset.dart:
--------------------------------------------------------------------------------
1 | import 'package:build/build.dart';
2 |
3 | extension NormalizedAssetId on AssetId {
4 | /// Returns `this` as an on-dik path (e.g. in a Bazel workspace).
5 | ///
6 | /// For example:
7 | /// ```
8 | /// // foo/bar/lib/baz.dart
9 | /// AssetId('foo.bar', 'lib/baz.dart').toRelativeUrl()
10 | /// ```
11 | String toRelativeUrl() {
12 | var directory = package.replaceAll('.', '/');
13 | // In Bazel, a directory that has no "." characters is assumed to be
14 | // relative to //third_party, not //. So for example:
15 | //
16 | // AssetId('foo', 'lib/bar.dart').toRelativeUrl()
17 | //
18 | // ... should resolve to "third_party/dart/foo/lib/bar.dart".
19 | if (directory == package) {
20 | directory = 'third_party/dart/$directory';
21 | }
22 | return '$directory/$path';
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/ngcompiler/melos_ngcompiler.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
6 |
12 |
16 |
--------------------------------------------------------------------------------
/ngcompiler/mono_pkg.yaml:
--------------------------------------------------------------------------------
1 | sdk:
2 | - pubspec
3 | - dev
4 | - stable
5 |
6 | stages:
7 | - analyze:
8 | - format:
9 | sdk:
10 | - pubspec
11 | - analyze: --fatal-infos .
12 | - unit_test:
13 | - test: -P ci
14 |
15 | cache:
16 | directories:
17 | - .dart_tool/build
18 |
--------------------------------------------------------------------------------
/ngcompiler/pubspec.yaml:
--------------------------------------------------------------------------------
1 | name: ngcompiler
2 | description: >
3 | The AngularDart compiler.
4 | It compiles your component files written in Dart into templates so that you
5 | don't have to worry about all the complicated hassle.
6 | version: 3.0.0-dev.3
7 | repository: https://github.com/angulardart-community/angular
8 |
9 | environment:
10 | sdk: ">=3.6.0 <4.0.0"
11 |
12 | resolution: workspace
13 |
14 | dependencies:
15 | analyzer: ^6.5.0
16 | args: ^2.6.0
17 | build: ^2.4.1
18 | code_builder: ^4.10.1
19 | collection: ^1.19.1
20 | csslib: ^1.0.2
21 | dart_style: ^2.3.7
22 | logging: ^1.3.0
23 | meta: ^1.16.0
24 | ngast: ^3.0.0-dev.2
25 | ngdart: ^8.0.0-dev.4
26 | path: ^1.9.1
27 | source_gen: ^1.5.0
28 | source_span: ^1.10.1
29 |
30 | dev_dependencies:
31 | build_test: ^2.2.2
32 | lints: ^5.0.0
33 | package_config: ^2.1.1
34 | test: ^1.25.9
35 |
--------------------------------------------------------------------------------
/ngdart/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License
2 |
3 | Copyright (c) 2014-2020 Dart Project Authors https://dart.dev
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 |
--------------------------------------------------------------------------------
/ngdart/analysis_options.yaml:
--------------------------------------------------------------------------------
1 | include: ../analysis_options.yaml
2 |
3 | analyzer:
4 | exclude:
5 | - lib/src/devtools/model.g.dart
6 |
--------------------------------------------------------------------------------
/ngdart/build.yaml:
--------------------------------------------------------------------------------
1 | targets:
2 | $default:
3 | builders:
4 | ngdart:
5 | generate_for:
6 | exclude:
7 | - "lib/src/build.dart"
8 | - "lib/src/compiler/**"
9 | - "lib/src/source_gen/**"
10 |
11 | builders:
12 | ngdart:
13 | import: "package:ngdart/src/build.dart"
14 | builder_factories:
15 | - templatePlaceholder
16 | - templateCompiler
17 | - stylesheetCompiler
18 | auto_apply: dependents
19 | applies_builders:
20 | - "ngdart|placeholder_cleanup"
21 | - "ngdart|component_source_cleanup"
22 | # See https://github.com/angulardart/angular/issues/988.
23 | is_optional: true
24 | required_inputs:
25 | - ".css"
26 | build_extensions:
27 | .css:
28 | - ".css.dart"
29 | - ".css.shim.dart"
30 | .dart:
31 | - ".template.dart"
32 | post_process_builders:
33 | placeholder_cleanup:
34 | import: "package:ngdart/src/build.dart"
35 | builder_factory: "placeholderCleanup"
36 | component_source_cleanup:
37 | import: "package:ngdart/src/build.dart"
38 | builder_factory: "componentSourceCleanup"
39 | defaults:
40 | generate_for: ["lib/**"]
41 | release_options:
42 | enabled: true
43 |
--------------------------------------------------------------------------------
/ngdart/example/README.md:
--------------------------------------------------------------------------------
1 | See https://angulardart.xyz for examples.
2 |
--------------------------------------------------------------------------------
/ngdart/lib/di.dart:
--------------------------------------------------------------------------------
1 | /// NOTE: As of 2020-08-12, this library is DEPRECATED.
2 | ///
3 | /// The actual deprecation notice is on the user-visible import located in
4 | /// //third_party/dart/angular/lib/di.dart, which exports this file.
5 | ///
6 | /// See go/angular-di.dart-deprecated.
7 | library;
8 |
9 | export 'src/di/injector.dart' show Injector, InjectorFactory;
10 | export 'src/meta.dart'
11 | show
12 | ClassProvider,
13 | Component,
14 | Directive,
15 | ExistingProvider,
16 | FactoryProvider,
17 | GenerateInjector,
18 | Host,
19 | Input,
20 | Inject,
21 | Injectable,
22 | Module,
23 | MultiToken,
24 | OpaqueToken,
25 | Optional,
26 | Output,
27 | Pipe,
28 | Provider,
29 | Self,
30 | SkipSelf,
31 | ValueProvider,
32 | provide,
33 | noValueProvided;
34 |
--------------------------------------------------------------------------------
/ngdart/lib/security.dart:
--------------------------------------------------------------------------------
1 | export 'src/security/dom_sanitization_service.dart';
2 | export 'src/security/safe_inner_html.dart';
3 |
--------------------------------------------------------------------------------
/ngdart/lib/src/bootstrap/modules.dart:
--------------------------------------------------------------------------------
1 | import 'dart:math';
2 |
3 | import 'package:ngdart/src/core/application_tokens.dart';
4 | import 'package:ngdart/src/core/exception_handler.dart';
5 | import 'package:ngdart/src/core/linker/component_loader.dart';
6 | import 'package:ngdart/src/di/injector.dart';
7 |
8 | /// Returns a simple application [Injector] that is hand-authored.
9 | ///
10 | /// Some of the services provided below ([ExceptionHandler], [appId]) may be
11 | /// overriden by the user-supplied injector - the returned [Injector] is
12 | /// used as the "base" application injector.
13 | Injector minimalApp() {
14 | return Injector.map({
15 | appId: _createRandomAppId(),
16 | ExceptionHandler: const ExceptionHandler(),
17 | ComponentLoader: const ComponentLoader(),
18 | });
19 | }
20 |
21 | /// Creates a random [appId] for use in CSS encapsulation.
22 | String _createRandomAppId() {
23 | final random = Random();
24 | String char() => String.fromCharCode(97 + random.nextInt(26));
25 | return '${char()}${char()}${char()}';
26 | }
27 |
--------------------------------------------------------------------------------
/ngdart/lib/src/common/directives.dart:
--------------------------------------------------------------------------------
1 | import 'directives/ng_class.dart' show NgClass;
2 | import 'directives/ng_for.dart' show NgFor;
3 | import 'directives/ng_if.dart' show NgIf;
4 | import 'directives/ng_style.dart' show NgStyle;
5 | import 'directives/ng_switch.dart' show NgSwitch, NgSwitchWhen, NgSwitchDefault;
6 | import 'directives/ng_template_outlet.dart' show NgTemplateOutlet;
7 |
8 | export 'directives/ng_class.dart' show NgClass;
9 | export 'directives/ng_for.dart' show NgFor;
10 | export 'directives/ng_if.dart' show NgIf;
11 | export 'directives/ng_style.dart' show NgStyle;
12 | export 'directives/ng_switch.dart' show NgSwitch, NgSwitchWhen, NgSwitchDefault;
13 | export 'directives/ng_template_outlet.dart' show NgTemplateOutlet;
14 |
15 | /// A collection of Angular core directives, such as [NgFor] and [NgIf].
16 | ///
17 | /// This collection is primarily provided for legacy/compatibility, and it is
18 | /// preferred to instead define exactly what directives you need/use in your
19 | /// `directives: [ ... ]` list instead.
20 | const coreDirectives = [
21 | NgClass,
22 | NgFor,
23 | NgIf,
24 | NgTemplateOutlet,
25 | NgStyle,
26 | NgSwitch,
27 | NgSwitchWhen,
28 | NgSwitchDefault,
29 | ];
30 |
--------------------------------------------------------------------------------
/ngdart/lib/src/common/directives/ng_for_identity.dart:
--------------------------------------------------------------------------------
1 | import 'package:meta/meta.dart';
2 | import 'package:ngdart/src/core/linker/template_ref.dart';
3 | import 'package:ngdart/src/core/linker/view_container_ref.dart';
4 | import 'package:ngdart/src/meta.dart';
5 |
6 | /// An alternative to [NgFor] optimized for immutable/unmodified collections.
7 | ///
8 | /// ```html
9 | ///
10 | /// Hello {{e}}!
11 | ///
12 | /// ```
13 | ///
14 | /// Unlike [NgFor], [NgForIdentity]:
15 | /// * Uses _identity_ not _contents_ of a collection to build child views.
16 | /// * Assumes all collections' contents will never change.
17 | /// * Only supports the `$implicit` and `index` local variables.
18 | ///
19 | /// This API is **experimental** and subject to change or removal.
20 | @Directive(
21 | selector: '[ngForIdentity][ngForIdentityOf]',
22 | )
23 | @experimental
24 | class NgForIdentity {
25 | final TemplateRef _template;
26 | final ViewContainerRef _container;
27 |
28 | const NgForIdentity(
29 | this._template,
30 | this._container,
31 | );
32 |
33 | @Input()
34 | set ngForIdentityOf(Iterable? elements) {
35 | _container.clear();
36 | if (elements == null || elements.isEmpty) {
37 | return;
38 | }
39 | var i = 0;
40 | for (final element in elements) {
41 | final view = _container.createEmbeddedView(_template);
42 | view.setLocal(r'$implicit', element);
43 | view.setLocal(r'index', i++);
44 | // TODO: Consider if we want all of the NgFor local variables available.
45 | }
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/ngdart/lib/src/common/pipes.dart:
--------------------------------------------------------------------------------
1 | // This module provides a set of common Pipes.
2 |
3 | export 'pipes/async_pipe.dart' show AsyncPipe;
4 | export 'pipes/common_pipes.dart' show commonPipes;
5 | export 'pipes/date_pipe.dart' show DatePipe;
6 | export 'pipes/lowercase_pipe.dart' show LowerCasePipe;
7 | export 'pipes/number_pipe.dart' show DecimalPipe, PercentPipe, CurrencyPipe;
8 | export 'pipes/replace_pipe.dart' show ReplacePipe;
9 | export 'pipes/slice_pipe.dart' show SlicePipe;
10 | export 'pipes/uppercase_pipe.dart' show UpperCasePipe;
11 |
--------------------------------------------------------------------------------
/ngdart/lib/src/common/pipes/common_pipes.dart:
--------------------------------------------------------------------------------
1 | import 'async_pipe.dart' show AsyncPipe;
2 | import 'date_pipe.dart' show DatePipe;
3 | import 'lowercase_pipe.dart' show LowerCasePipe;
4 | import 'number_pipe.dart' show DecimalPipe, PercentPipe, CurrencyPipe;
5 | import 'replace_pipe.dart' show ReplacePipe;
6 | import 'slice_pipe.dart' show SlicePipe;
7 | import 'uppercase_pipe.dart' show UpperCasePipe;
8 |
9 | /// A collection of built-in AngularDart core pipes.
10 | ///
11 | /// This collection can be used to quickly enumerate all the built-in pipes in
12 | /// the `pipes` property of the `@Component` annotation. For most applications
13 | /// it's recommended to only reference the _exact_ pipes you use, however.
14 | const commonPipes = [
15 | AsyncPipe,
16 | UpperCasePipe,
17 | LowerCasePipe,
18 | SlicePipe,
19 | DecimalPipe,
20 | PercentPipe,
21 | CurrencyPipe,
22 | DatePipe,
23 | ReplacePipe
24 | ];
25 |
--------------------------------------------------------------------------------
/ngdart/lib/src/common/pipes/invalid_pipe_argument_exception.dart:
--------------------------------------------------------------------------------
1 | class InvalidPipeArgumentException extends FormatException {
2 | InvalidPipeArgumentException(Type type, Object? value)
3 | : super("Invalid argument '$value' for pipe '$type'");
4 | }
5 |
--------------------------------------------------------------------------------
/ngdart/lib/src/common/pipes/lowercase_pipe.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngdart/src/meta.dart';
2 |
3 | /// Transforms text to lowercase.
4 | @Pipe('lowercase')
5 | class LowerCasePipe {
6 | String? transform(String? value) => value?.toLowerCase();
7 |
8 | const LowerCasePipe();
9 | }
10 |
--------------------------------------------------------------------------------
/ngdart/lib/src/common/pipes/uppercase_pipe.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngdart/src/meta.dart';
2 |
3 | /// Implements uppercase transforms to text.
4 | @Pipe('uppercase')
5 | class UpperCasePipe {
6 | String? transform(String? value) => value?.toUpperCase();
7 |
8 | const UpperCasePipe();
9 | }
10 |
--------------------------------------------------------------------------------
/ngdart/lib/src/core/application_tokens.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngdart/src/meta.dart';
2 |
3 | /// A dependency injection token representing a unique ID for the application.
4 | ///
5 | /// The identifier is used internally to apply CSS scoping behavior.
6 | ///
7 | /// To avoid a randomly generated value, a custom value can be provided:
8 | /// ```dart
9 | /// bootstrapStatic(
10 | /// YourAppComponent,
11 | /// const [
12 | /// const Provider(appId, useValue: 'my-unique-id'),
13 | /// ],
14 | /// )
15 | /// ```
16 | const appId = OpaqueToken('appId');
17 |
--------------------------------------------------------------------------------
/ngdart/lib/src/core/change_detection.dart:
--------------------------------------------------------------------------------
1 | /// Change detection enables data binding in Angular.
2 | library;
3 |
4 | export 'change_detection/change_detection.dart'
5 | show
6 | ChangeDetectionStrategy,
7 | ChangeDetectorRef,
8 | DeprecatedChangeDetectorRef,
9 | DeprecatedDetectChanges;
10 | export 'change_detection/differs/default_iterable_differ.dart' show TrackByFn;
11 |
--------------------------------------------------------------------------------
/ngdart/lib/src/core/change_detection/change_detection.dart:
--------------------------------------------------------------------------------
1 | export 'package:ngdart/src/meta.dart'
2 | show ChangeDetectionStrategy, ChangeDetectorState;
3 |
4 | export 'change_detector_ref.dart'
5 | show
6 | ChangeDetectorRef,
7 | DeprecatedChangeDetectorRef,
8 | DeprecatedDetectChanges;
9 |
--------------------------------------------------------------------------------
/ngdart/lib/src/core/change_detection/directive_change_detector.dart:
--------------------------------------------------------------------------------
1 | import 'dart:html';
2 |
3 | import 'package:ngdart/src/core/linker/views/render_view.dart';
4 |
5 | /// Base class for helpers generated for some classes annotated with @Directive.
6 | ///
7 | /// When a `@Directive`-annotated class has one or more `@HostBinding()`s those
8 | /// bindings and/or are hoisted into the [detectHostChanges] method of this
9 | /// class, and are re-used across the different call sites.
10 | abstract class DirectiveChangeDetector {
11 | /// Implements `detectChanges()`-like logic but for the directive instance.
12 | ///
13 | /// Currently, this implements and updates `@HostBinding()`s only.
14 | void detectHostChanges(RenderView view, Element hostElement);
15 | }
16 |
--------------------------------------------------------------------------------
/ngdart/lib/src/core/linker.dart:
--------------------------------------------------------------------------------
1 | // Public API for compiler
2 |
3 | export 'linker/component_factory.dart' show ComponentRef, ComponentFactory;
4 | export 'linker/component_loader.dart' show ComponentLoader;
5 | export 'linker/element_ref.dart' show ElementRef;
6 | export 'linker/ng_content_ref.dart' show NgContentRef;
7 | export 'linker/style_encapsulation.dart' show debugClearComponentStyles;
8 | export 'linker/template_ref.dart' show TemplateRef;
9 | export 'linker/view_container_ref.dart' show ViewContainerRef;
10 | export 'linker/view_ref.dart' show EmbeddedViewRef, ViewRef;
11 |
--------------------------------------------------------------------------------
/ngdart/lib/src/core/linker/app_view_utils.dart:
--------------------------------------------------------------------------------
1 | import 'dart:html' show DocumentFragment, NodeTreeSanitizer;
2 |
3 | import 'package:ngdart/src/core/application_tokens.dart' as tokens show appId;
4 | import 'package:ngdart/src/runtime/dom_events.dart' show EventManager;
5 |
6 | /// Application wide view utilities.
7 | late AppViewUtils appViewUtils;
8 |
9 | /// Utilities to create unique RenderComponentType instances for AppViews and
10 | /// provide access to root dom renderer.
11 | class AppViewUtils {
12 | final String appId;
13 | final EventManager eventManager;
14 |
15 | AppViewUtils(
16 | @tokens.appId this.appId,
17 | this.eventManager,
18 | );
19 | }
20 |
21 | /// Creates a document fragment from [trustedHtml].
22 | DocumentFragment createTrustedHtml(String trustedHtml) {
23 | return DocumentFragment.html(
24 | trustedHtml,
25 | treeSanitizer: NodeTreeSanitizer.trusted,
26 | );
27 | }
28 |
--------------------------------------------------------------------------------
/ngdart/lib/src/core/linker/element_ref.dart:
--------------------------------------------------------------------------------
1 | /// A wrapper around a native element inside of a View.
2 | ///
3 | /// An `ElementRef` is backed by a render-specific element. In the browser, this
4 | /// is usually a DOM element.
5 | ///
6 | /// **DEPRECATED**: A wrapper around a native DOM element inside of a View.
7 | ///
8 | /// Inject `Element` or `HtmlElement` from `dart:html` instead; this will be
9 | /// removed in a future version of AngularDart, and has unnecessary overhead.
10 | @Deprecated('Inject or reference dart:html Element or HtmlElement instead')
11 | class ElementRef {
12 | final dynamic nativeElement;
13 |
14 | // Requires that, if provided, this value is non-null.
15 | //
16 | // Then it is upcasted to dynamic for the public API to be non-breaking.
17 | // ignore: prefer_initializing_formals
18 | @Deprecated('Inject or reference dart:html Element or HtmlElement instead')
19 | const ElementRef(this.nativeElement);
20 | }
21 |
--------------------------------------------------------------------------------
/ngdart/lib/src/core/linker/ng_content_ref.dart:
--------------------------------------------------------------------------------
1 | import 'view_container.dart';
2 | import 'views/render_view.dart';
3 |
4 | /// Represents a reference to an `` element.
5 | ///
6 | /// This can be used to query whether an `` has any projected nodes.
7 | /// Users can access this class via a direct reference in the template, or a
8 | /// view query.
9 | ///
10 | /// ```
11 | /// @Component(
12 | /// selector: 'comp',
13 | /// template: '''
14 | /// Function(RenderView, int) _viewFactory;
23 |
24 | TemplateRef(this._viewContainer, this._viewFactory);
25 |
26 | /// Instantiates an instance of the provided template.
27 | EmbeddedViewRef createEmbeddedView() {
28 | // The unsafe cast is necessary because a view container's parent may be any
29 | // kind of view, but this method is only ever called when the parent view is
30 | // a `RenderView`.
31 | final parentView = unsafeCast(_viewContainer.parentView);
32 | final view = _viewFactory(parentView, _viewContainer.index);
33 | view.create();
34 | return view;
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/ngdart/lib/src/devtools/component_inspector.dart:
--------------------------------------------------------------------------------
1 | import 'inspector.dart';
2 |
3 | /// A service for inspecting components via service protocol extensions.
4 | // TODO(b/194920649): remove.
5 | @Deprecated('Use Inspector instead')
6 | class ComponentInspector {
7 | /// The current [ComponentInspector].
8 | static final instance = ComponentInspector._();
9 |
10 | @Deprecated('Use Inspector instead')
11 | ComponentInspector._();
12 |
13 | /// Returns the inputs bound to a component as a map from name to value.
14 | ///
15 | /// The component is identified using the [id] obtained from [getComponents].
16 | /// Returns an empty map if no inputs have been set on the component.
17 | Map getComponentInputs(int id) {
18 | return Inspector.instance.getComponentInputs(id);
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/ngdart/lib/src/devtools/error.dart:
--------------------------------------------------------------------------------
1 | /// An error thrown by developer tools.
2 | class DevToolsError extends Error {
3 | DevToolsError(this.message);
4 |
5 | /// A description of the error that occurred.
6 | final String message;
7 |
8 | @override
9 | String toString() => message;
10 | }
11 |
--------------------------------------------------------------------------------
/ngdart/lib/src/meta/di_generate_injector.dart:
--------------------------------------------------------------------------------
1 | import 'package:meta/meta_meta.dart';
2 |
3 | import 'di_modules.dart';
4 |
5 | /// Annotates a method to generate an [Injector] factory at compile-time.
6 | ///
7 | /// Using `@GenerateInjector` is conceptually similar to using `@Component` or
8 | /// `@Directive` with a `providers: const [ ... ]` argument, but like a
9 | /// component or directive that injector is generated ahead of time, during
10 | /// compilation:
11 | ///
12 | /// ```
13 | /// import 'my_file.template.dart' as ng;
14 | ///
15 | /// @GenerateInjector(const [
16 | /// const Provider(A, useClass: APrime),
17 | /// ])
18 | /// // The generated factory is your method's name, suffixed with `$Injector`.
19 | /// final InjectorFactory example = example$Injector;
20 | /// ```
21 | @Target({TargetKind.topLevelVariable})
22 | class GenerateInjector {
23 | // Used internally via analysis only.
24 | // ignore: unused_field
25 | final List
8 |
10 |
11 |
7 |
13 |
18 |
19 |
20 |
21 | {{label}}
22 |
24 |
--------------------------------------------------------------------------------
/ngast/test/e2e/templates/material_chip.html:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{label}}
8 |
10 |
--------------------------------------------------------------------------------
/ngast/test/e2e/templates/material_chips.html:
--------------------------------------------------------------------------------
1 |
6 |
7 |
14 |
--------------------------------------------------------------------------------
/ngast/test/e2e/templates/material_dialog.html:
--------------------------------------------------------------------------------
1 |
6 |
8 |
9 |
11 |
12 |
18 |
20 |
21 |
24 |
25 | {{error}}
13 |
14 |
17 |
33 |
34 |
--------------------------------------------------------------------------------
/ngast/test/e2e/templates/material_progress.html:
--------------------------------------------------------------------------------
1 |
6 |
20 |
32 |
21 |
22 |
24 |
25 |
27 |
30 |
31 |
13 |
15 |
17 |
18 |
--------------------------------------------------------------------------------
/ngast/test/e2e/templates/material_toggle.html:
--------------------------------------------------------------------------------
1 |
6 |
19 |
29 |
--------------------------------------------------------------------------------
/ngast/test/e2e/templates/scoreboard.html:
--------------------------------------------------------------------------------
1 |
6 | {{label}}
20 |
21 |
22 |
28 |
23 |
27 |
24 |
26 |
7 |
11 |
14 |
15 |
16 |
19 |
23 |
26 |
27 |
28 |
29 |
--------------------------------------------------------------------------------
/ngast/test/e2e/templates/scorecard.html:
--------------------------------------------------------------------------------
1 |
6 |
7 |
11 |
14 |
15 |
16 |
19 |
23 |
26 |
27 |
28 |
29 |
--------------------------------------------------------------------------------
/ngast/test/visitor_test.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngast/ngast.dart';
2 | import 'package:test/test.dart';
3 |
4 | void main() {
5 | // DesugarVisitor is tested by parser_test.dart
6 | var visitor = const HumanizingTemplateAstVisitor();
7 |
8 | test('should humanize a simple template and preserve inner spaces', () {
9 | var templateString = '';
10 | var template = parse(
11 | templateString,
12 | sourceUrl: '/test/visitor_test.dart#inline',
13 | );
14 | expect(
15 | template.map((t) => t.accept(visitor)).join(''),
16 | equals(templateString),
17 | );
18 | });
19 |
20 | test('should humanize a simple template *with* de-sugaring applied', () {
21 | var template = parse(
22 | '
16 | /// There was no projected content. Here is some default content!
17 | ///
18 | /// ''',
19 | /// )
20 | /// class FooComponent {
21 | /// @ViewChild(NgContentRef)
22 | /// NgContentRef child;
23 | /// }
24 | class NgContentRef {
25 | final RenderView _renderView;
26 | final int _index;
27 |
28 | NgContentRef(this._renderView, this._index);
29 |
30 | /// Returns whether this has any projected nodes.
31 | bool get hasContent {
32 | final nodesToProject = _renderView.projectedNodes[_index];
33 | for (var i = 0; i < nodesToProject.length; i++) {
34 | final node = nodesToProject[i];
35 | // Check for views inserted dynamically by a directive (such as *ngIf or
36 | // *ngFor).
37 | if (node is ViewContainer) {
38 | final nestedViews = node.nestedViews;
39 | if (nestedViews != null && nestedViews.isNotEmpty) {
40 | return true;
41 | }
42 | } else {
43 | return true;
44 | }
45 | }
46 | return false;
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/ngdart/lib/src/core/linker/template_ref.dart:
--------------------------------------------------------------------------------
1 | import 'package:ngdart/src/utilities.dart';
2 |
3 | import 'view_container.dart';
4 | import 'view_ref.dart' show EmbeddedViewRef;
5 | import 'views/embedded_view.dart';
6 | import 'views/render_view.dart';
7 |
8 | /// Represents an Embedded Template that can be used to instantiate Embedded
9 | /// Views.
10 | ///
11 | /// You can access a `TemplateRef`, in two ways. Via a directive placed on a
12 | /// `` element (or directive prefixed with `*`) and have the
13 | /// `TemplateRef` for this Embedded View injected into the constructor of the
14 | /// directive using the `TemplateRef` Token. Alternatively you can query for the
15 | /// `TemplateRef` from a Component or a Directive via [Query].
16 | ///
17 | /// To instantiate Embedded Views based on a Template, use
18 | /// [ViewContainerRef#createEmbeddedView], which will create the View and attach
19 | /// it to the View Container.
20 | class TemplateRef {
21 | final ViewContainer _viewContainer;
22 | final EmbeddedView