source: trip-planner-front/node_modules/@angular/compiler/src/render3/view/t2_binder.js@ 6a3a178

Last change on this file since 6a3a178 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 79.8 KB
Line 
1/**
2 * @license
3 * Copyright Google LLC All Rights Reserved.
4 *
5 * Use of this source code is governed by an MIT-style license that can be
6 * found in the LICENSE file at https://angular.io/license
7 */
8(function (factory) {
9 if (typeof module === "object" && typeof module.exports === "object") {
10 var v = factory(require, exports);
11 if (v !== undefined) module.exports = v;
12 }
13 else if (typeof define === "function" && define.amd) {
14 define("@angular/compiler/src/render3/view/t2_binder", ["require", "exports", "tslib", "@angular/compiler/src/expression_parser/ast", "@angular/compiler/src/render3/r3_ast", "@angular/compiler/src/render3/view/template", "@angular/compiler/src/render3/view/util"], factory);
15 }
16})(function (require, exports) {
17 "use strict";
18 Object.defineProperty(exports, "__esModule", { value: true });
19 exports.R3BoundTarget = exports.R3TargetBinder = void 0;
20 var tslib_1 = require("tslib");
21 var ast_1 = require("@angular/compiler/src/expression_parser/ast");
22 var r3_ast_1 = require("@angular/compiler/src/render3/r3_ast");
23 var template_1 = require("@angular/compiler/src/render3/view/template");
24 var util_1 = require("@angular/compiler/src/render3/view/util");
25 /**
26 * Processes `Target`s with a given set of directives and performs a binding operation, which
27 * returns an object similar to TypeScript's `ts.TypeChecker` that contains knowledge about the
28 * target.
29 */
30 var R3TargetBinder = /** @class */ (function () {
31 function R3TargetBinder(directiveMatcher) {
32 this.directiveMatcher = directiveMatcher;
33 }
34 /**
35 * Perform a binding operation on the given `Target` and return a `BoundTarget` which contains
36 * metadata about the types referenced in the template.
37 */
38 R3TargetBinder.prototype.bind = function (target) {
39 if (!target.template) {
40 // TODO(alxhub): handle targets which contain things like HostBindings, etc.
41 throw new Error('Binding without a template not yet supported');
42 }
43 // First, parse the template into a `Scope` structure. This operation captures the syntactic
44 // scopes in the template and makes them available for later use.
45 var scope = Scope.apply(target.template);
46 // Use the `Scope` to extract the entities present at every level of the template.
47 var templateEntities = extractTemplateEntities(scope);
48 // Next, perform directive matching on the template using the `DirectiveBinder`. This returns:
49 // - directives: Map of nodes (elements & ng-templates) to the directives on them.
50 // - bindings: Map of inputs, outputs, and attributes to the directive/element that claims
51 // them. TODO(alxhub): handle multiple directives claiming an input/output/etc.
52 // - references: Map of #references to their targets.
53 var _a = DirectiveBinder.apply(target.template, this.directiveMatcher), directives = _a.directives, bindings = _a.bindings, references = _a.references;
54 // Finally, run the TemplateBinder to bind references, variables, and other entities within the
55 // template. This extracts all the metadata that doesn't depend on directive matching.
56 var _b = TemplateBinder.applyWithScope(target.template, scope), expressions = _b.expressions, symbols = _b.symbols, nestingLevel = _b.nestingLevel, usedPipes = _b.usedPipes;
57 return new R3BoundTarget(target, directives, bindings, references, expressions, symbols, nestingLevel, templateEntities, usedPipes);
58 };
59 return R3TargetBinder;
60 }());
61 exports.R3TargetBinder = R3TargetBinder;
62 /**
63 * Represents a binding scope within a template.
64 *
65 * Any variables, references, or other named entities declared within the template will
66 * be captured and available by name in `namedEntities`. Additionally, child templates will
67 * be analyzed and have their child `Scope`s available in `childScopes`.
68 */
69 var Scope = /** @class */ (function () {
70 function Scope(parentScope, template) {
71 this.parentScope = parentScope;
72 this.template = template;
73 /**
74 * Named members of the `Scope`, such as `Reference`s or `Variable`s.
75 */
76 this.namedEntities = new Map();
77 /**
78 * Child `Scope`s for immediately nested `Template`s.
79 */
80 this.childScopes = new Map();
81 }
82 Scope.newRootScope = function () {
83 return new Scope(null, null);
84 };
85 /**
86 * Process a template (either as a `Template` sub-template with variables, or a plain array of
87 * template `Node`s) and construct its `Scope`.
88 */
89 Scope.apply = function (template) {
90 var scope = Scope.newRootScope();
91 scope.ingest(template);
92 return scope;
93 };
94 /**
95 * Internal method to process the template and populate the `Scope`.
96 */
97 Scope.prototype.ingest = function (template) {
98 var _this = this;
99 if (template instanceof r3_ast_1.Template) {
100 // Variables on an <ng-template> are defined in the inner scope.
101 template.variables.forEach(function (node) { return _this.visitVariable(node); });
102 // Process the nodes of the template.
103 template.children.forEach(function (node) { return node.visit(_this); });
104 }
105 else {
106 // No overarching `Template` instance, so process the nodes directly.
107 template.forEach(function (node) { return node.visit(_this); });
108 }
109 };
110 Scope.prototype.visitElement = function (element) {
111 var _this = this;
112 // `Element`s in the template may have `Reference`s which are captured in the scope.
113 element.references.forEach(function (node) { return _this.visitReference(node); });
114 // Recurse into the `Element`'s children.
115 element.children.forEach(function (node) { return node.visit(_this); });
116 };
117 Scope.prototype.visitTemplate = function (template) {
118 var _this = this;
119 // References on a <ng-template> are defined in the outer scope, so capture them before
120 // processing the template's child scope.
121 template.references.forEach(function (node) { return _this.visitReference(node); });
122 // Next, create an inner scope and process the template within it.
123 var scope = new Scope(this, template);
124 scope.ingest(template);
125 this.childScopes.set(template, scope);
126 };
127 Scope.prototype.visitVariable = function (variable) {
128 // Declare the variable if it's not already.
129 this.maybeDeclare(variable);
130 };
131 Scope.prototype.visitReference = function (reference) {
132 // Declare the variable if it's not already.
133 this.maybeDeclare(reference);
134 };
135 // Unused visitors.
136 Scope.prototype.visitContent = function (content) { };
137 Scope.prototype.visitBoundAttribute = function (attr) { };
138 Scope.prototype.visitBoundEvent = function (event) { };
139 Scope.prototype.visitBoundText = function (text) { };
140 Scope.prototype.visitText = function (text) { };
141 Scope.prototype.visitTextAttribute = function (attr) { };
142 Scope.prototype.visitIcu = function (icu) { };
143 Scope.prototype.maybeDeclare = function (thing) {
144 // Declare something with a name, as long as that name isn't taken.
145 if (!this.namedEntities.has(thing.name)) {
146 this.namedEntities.set(thing.name, thing);
147 }
148 };
149 /**
150 * Look up a variable within this `Scope`.
151 *
152 * This can recurse into a parent `Scope` if it's available.
153 */
154 Scope.prototype.lookup = function (name) {
155 if (this.namedEntities.has(name)) {
156 // Found in the local scope.
157 return this.namedEntities.get(name);
158 }
159 else if (this.parentScope !== null) {
160 // Not in the local scope, but there's a parent scope so check there.
161 return this.parentScope.lookup(name);
162 }
163 else {
164 // At the top level and it wasn't found.
165 return null;
166 }
167 };
168 /**
169 * Get the child scope for a `Template`.
170 *
171 * This should always be defined.
172 */
173 Scope.prototype.getChildScope = function (template) {
174 var res = this.childScopes.get(template);
175 if (res === undefined) {
176 throw new Error("Assertion error: child scope for " + template + " not found");
177 }
178 return res;
179 };
180 return Scope;
181 }());
182 /**
183 * Processes a template and matches directives on nodes (elements and templates).
184 *
185 * Usually used via the static `apply()` method.
186 */
187 var DirectiveBinder = /** @class */ (function () {
188 function DirectiveBinder(matcher, directives, bindings, references) {
189 this.matcher = matcher;
190 this.directives = directives;
191 this.bindings = bindings;
192 this.references = references;
193 }
194 /**
195 * Process a template (list of `Node`s) and perform directive matching against each node.
196 *
197 * @param template the list of template `Node`s to match (recursively).
198 * @param selectorMatcher a `SelectorMatcher` containing the directives that are in scope for
199 * this template.
200 * @returns three maps which contain information about directives in the template: the
201 * `directives` map which lists directives matched on each node, the `bindings` map which
202 * indicates which directives claimed which bindings (inputs, outputs, etc), and the `references`
203 * map which resolves #references (`Reference`s) within the template to the named directive or
204 * template node.
205 */
206 DirectiveBinder.apply = function (template, selectorMatcher) {
207 var directives = new Map();
208 var bindings = new Map();
209 var references = new Map();
210 var matcher = new DirectiveBinder(selectorMatcher, directives, bindings, references);
211 matcher.ingest(template);
212 return { directives: directives, bindings: bindings, references: references };
213 };
214 DirectiveBinder.prototype.ingest = function (template) {
215 var _this = this;
216 template.forEach(function (node) { return node.visit(_this); });
217 };
218 DirectiveBinder.prototype.visitElement = function (element) {
219 this.visitElementOrTemplate(element.name, element);
220 };
221 DirectiveBinder.prototype.visitTemplate = function (template) {
222 this.visitElementOrTemplate('ng-template', template);
223 };
224 DirectiveBinder.prototype.visitElementOrTemplate = function (elementName, node) {
225 var _this = this;
226 // First, determine the HTML shape of the node for the purpose of directive matching.
227 // Do this by building up a `CssSelector` for the node.
228 var cssSelector = template_1.createCssSelector(elementName, util_1.getAttrsForDirectiveMatching(node));
229 // Next, use the `SelectorMatcher` to get the list of directives on the node.
230 var directives = [];
231 this.matcher.match(cssSelector, function (_, directive) { return directives.push(directive); });
232 if (directives.length > 0) {
233 this.directives.set(node, directives);
234 }
235 // Resolve any references that are created on this node.
236 node.references.forEach(function (ref) {
237 var dirTarget = null;
238 // If the reference expression is empty, then it matches the "primary" directive on the node
239 // (if there is one). Otherwise it matches the host node itself (either an element or
240 // <ng-template> node).
241 if (ref.value.trim() === '') {
242 // This could be a reference to a component if there is one.
243 dirTarget = directives.find(function (dir) { return dir.isComponent; }) || null;
244 }
245 else {
246 // This should be a reference to a directive exported via exportAs.
247 dirTarget =
248 directives.find(function (dir) { return dir.exportAs !== null && dir.exportAs.some(function (value) { return value === ref.value; }); }) ||
249 null;
250 // Check if a matching directive was found.
251 if (dirTarget === null) {
252 // No matching directive was found - this reference points to an unknown target. Leave it
253 // unmapped.
254 return;
255 }
256 }
257 if (dirTarget !== null) {
258 // This reference points to a directive.
259 _this.references.set(ref, { directive: dirTarget, node: node });
260 }
261 else {
262 // This reference points to the node itself.
263 _this.references.set(ref, node);
264 }
265 });
266 var setAttributeBinding = function (attribute, ioType) {
267 var dir = directives.find(function (dir) { return dir[ioType].hasBindingPropertyName(attribute.name); });
268 var binding = dir !== undefined ? dir : node;
269 _this.bindings.set(attribute, binding);
270 };
271 // Node inputs (bound attributes) and text attributes can be bound to an
272 // input on a directive.
273 node.inputs.forEach(function (input) { return setAttributeBinding(input, 'inputs'); });
274 node.attributes.forEach(function (attr) { return setAttributeBinding(attr, 'inputs'); });
275 if (node instanceof r3_ast_1.Template) {
276 node.templateAttrs.forEach(function (attr) { return setAttributeBinding(attr, 'inputs'); });
277 }
278 // Node outputs (bound events) can be bound to an output on a directive.
279 node.outputs.forEach(function (output) { return setAttributeBinding(output, 'outputs'); });
280 // Recurse into the node's children.
281 node.children.forEach(function (child) { return child.visit(_this); });
282 };
283 // Unused visitors.
284 DirectiveBinder.prototype.visitContent = function (content) { };
285 DirectiveBinder.prototype.visitVariable = function (variable) { };
286 DirectiveBinder.prototype.visitReference = function (reference) { };
287 DirectiveBinder.prototype.visitTextAttribute = function (attribute) { };
288 DirectiveBinder.prototype.visitBoundAttribute = function (attribute) { };
289 DirectiveBinder.prototype.visitBoundEvent = function (attribute) { };
290 DirectiveBinder.prototype.visitBoundAttributeOrEvent = function (node) { };
291 DirectiveBinder.prototype.visitText = function (text) { };
292 DirectiveBinder.prototype.visitBoundText = function (text) { };
293 DirectiveBinder.prototype.visitIcu = function (icu) { };
294 return DirectiveBinder;
295 }());
296 /**
297 * Processes a template and extract metadata about expressions and symbols within.
298 *
299 * This is a companion to the `DirectiveBinder` that doesn't require knowledge of directives matched
300 * within the template in order to operate.
301 *
302 * Expressions are visited by the superclass `RecursiveAstVisitor`, with custom logic provided
303 * by overridden methods from that visitor.
304 */
305 var TemplateBinder = /** @class */ (function (_super) {
306 tslib_1.__extends(TemplateBinder, _super);
307 function TemplateBinder(bindings, symbols, usedPipes, nestingLevel, scope, template, level) {
308 var _this = _super.call(this) || this;
309 _this.bindings = bindings;
310 _this.symbols = symbols;
311 _this.usedPipes = usedPipes;
312 _this.nestingLevel = nestingLevel;
313 _this.scope = scope;
314 _this.template = template;
315 _this.level = level;
316 _this.pipesUsed = [];
317 // Save a bit of processing time by constructing this closure in advance.
318 _this.visitNode = function (node) { return node.visit(_this); };
319 return _this;
320 }
321 // This method is defined to reconcile the type of TemplateBinder since both
322 // RecursiveAstVisitor and Visitor define the visit() method in their
323 // interfaces.
324 TemplateBinder.prototype.visit = function (node, context) {
325 if (node instanceof ast_1.AST) {
326 node.visit(this, context);
327 }
328 else {
329 node.visit(this);
330 }
331 };
332 /**
333 * Process a template and extract metadata about expressions and symbols within.
334 *
335 * @param template the nodes of the template to process
336 * @param scope the `Scope` of the template being processed.
337 * @returns three maps which contain metadata about the template: `expressions` which interprets
338 * special `AST` nodes in expressions as pointing to references or variables declared within the
339 * template, `symbols` which maps those variables and references to the nested `Template` which
340 * declares them, if any, and `nestingLevel` which associates each `Template` with a integer
341 * nesting level (how many levels deep within the template structure the `Template` is), starting
342 * at 1.
343 */
344 TemplateBinder.applyWithScope = function (template, scope) {
345 var expressions = new Map();
346 var symbols = new Map();
347 var nestingLevel = new Map();
348 var usedPipes = new Set();
349 // The top-level template has nesting level 0.
350 var binder = new TemplateBinder(expressions, symbols, usedPipes, nestingLevel, scope, template instanceof r3_ast_1.Template ? template : null, 0);
351 binder.ingest(template);
352 return { expressions: expressions, symbols: symbols, nestingLevel: nestingLevel, usedPipes: usedPipes };
353 };
354 TemplateBinder.prototype.ingest = function (template) {
355 if (template instanceof r3_ast_1.Template) {
356 // For <ng-template>s, process only variables and child nodes. Inputs, outputs, templateAttrs,
357 // and references were all processed in the scope of the containing template.
358 template.variables.forEach(this.visitNode);
359 template.children.forEach(this.visitNode);
360 // Set the nesting level.
361 this.nestingLevel.set(template, this.level);
362 }
363 else {
364 // Visit each node from the top-level template.
365 template.forEach(this.visitNode);
366 }
367 };
368 TemplateBinder.prototype.visitElement = function (element) {
369 // Visit the inputs, outputs, and children of the element.
370 element.inputs.forEach(this.visitNode);
371 element.outputs.forEach(this.visitNode);
372 element.children.forEach(this.visitNode);
373 };
374 TemplateBinder.prototype.visitTemplate = function (template) {
375 // First, visit inputs, outputs and template attributes of the template node.
376 template.inputs.forEach(this.visitNode);
377 template.outputs.forEach(this.visitNode);
378 template.templateAttrs.forEach(this.visitNode);
379 // References are also evaluated in the outer context.
380 template.references.forEach(this.visitNode);
381 // Next, recurse into the template using its scope, and bumping the nesting level up by one.
382 var childScope = this.scope.getChildScope(template);
383 var binder = new TemplateBinder(this.bindings, this.symbols, this.usedPipes, this.nestingLevel, childScope, template, this.level + 1);
384 binder.ingest(template);
385 };
386 TemplateBinder.prototype.visitVariable = function (variable) {
387 // Register the `Variable` as a symbol in the current `Template`.
388 if (this.template !== null) {
389 this.symbols.set(variable, this.template);
390 }
391 };
392 TemplateBinder.prototype.visitReference = function (reference) {
393 // Register the `Reference` as a symbol in the current `Template`.
394 if (this.template !== null) {
395 this.symbols.set(reference, this.template);
396 }
397 };
398 // Unused template visitors
399 TemplateBinder.prototype.visitText = function (text) { };
400 TemplateBinder.prototype.visitContent = function (content) { };
401 TemplateBinder.prototype.visitTextAttribute = function (attribute) { };
402 TemplateBinder.prototype.visitIcu = function (icu) {
403 var _this = this;
404 Object.keys(icu.vars).forEach(function (key) { return icu.vars[key].visit(_this); });
405 Object.keys(icu.placeholders).forEach(function (key) { return icu.placeholders[key].visit(_this); });
406 };
407 // The remaining visitors are concerned with processing AST expressions within template bindings
408 TemplateBinder.prototype.visitBoundAttribute = function (attribute) {
409 attribute.value.visit(this);
410 };
411 TemplateBinder.prototype.visitBoundEvent = function (event) {
412 event.handler.visit(this);
413 };
414 TemplateBinder.prototype.visitBoundText = function (text) {
415 text.value.visit(this);
416 };
417 TemplateBinder.prototype.visitPipe = function (ast, context) {
418 this.usedPipes.add(ast.name);
419 return _super.prototype.visitPipe.call(this, ast, context);
420 };
421 // These five types of AST expressions can refer to expression roots, which could be variables
422 // or references in the current scope.
423 TemplateBinder.prototype.visitPropertyRead = function (ast, context) {
424 this.maybeMap(context, ast, ast.name);
425 return _super.prototype.visitPropertyRead.call(this, ast, context);
426 };
427 TemplateBinder.prototype.visitSafePropertyRead = function (ast, context) {
428 this.maybeMap(context, ast, ast.name);
429 return _super.prototype.visitSafePropertyRead.call(this, ast, context);
430 };
431 TemplateBinder.prototype.visitPropertyWrite = function (ast, context) {
432 this.maybeMap(context, ast, ast.name);
433 return _super.prototype.visitPropertyWrite.call(this, ast, context);
434 };
435 TemplateBinder.prototype.visitMethodCall = function (ast, context) {
436 this.maybeMap(context, ast, ast.name);
437 return _super.prototype.visitMethodCall.call(this, ast, context);
438 };
439 TemplateBinder.prototype.visitSafeMethodCall = function (ast, context) {
440 this.maybeMap(context, ast, ast.name);
441 return _super.prototype.visitSafeMethodCall.call(this, ast, context);
442 };
443 TemplateBinder.prototype.maybeMap = function (scope, ast, name) {
444 // If the receiver of the expression isn't the `ImplicitReceiver`, this isn't the root of an
445 // `AST` expression that maps to a `Variable` or `Reference`.
446 if (!(ast.receiver instanceof ast_1.ImplicitReceiver)) {
447 return;
448 }
449 // Check whether the name exists in the current scope. If so, map it. Otherwise, the name is
450 // probably a property on the top-level component context.
451 var target = this.scope.lookup(name);
452 if (target !== null) {
453 this.bindings.set(ast, target);
454 }
455 };
456 return TemplateBinder;
457 }(ast_1.RecursiveAstVisitor));
458 /**
459 * Metadata container for a `Target` that allows queries for specific bits of metadata.
460 *
461 * See `BoundTarget` for documentation on the individual methods.
462 */
463 var R3BoundTarget = /** @class */ (function () {
464 function R3BoundTarget(target, directives, bindings, references, exprTargets, symbols, nestingLevel, templateEntities, usedPipes) {
465 this.target = target;
466 this.directives = directives;
467 this.bindings = bindings;
468 this.references = references;
469 this.exprTargets = exprTargets;
470 this.symbols = symbols;
471 this.nestingLevel = nestingLevel;
472 this.templateEntities = templateEntities;
473 this.usedPipes = usedPipes;
474 }
475 R3BoundTarget.prototype.getEntitiesInTemplateScope = function (template) {
476 var _a;
477 return (_a = this.templateEntities.get(template)) !== null && _a !== void 0 ? _a : new Set();
478 };
479 R3BoundTarget.prototype.getDirectivesOfNode = function (node) {
480 return this.directives.get(node) || null;
481 };
482 R3BoundTarget.prototype.getReferenceTarget = function (ref) {
483 return this.references.get(ref) || null;
484 };
485 R3BoundTarget.prototype.getConsumerOfBinding = function (binding) {
486 return this.bindings.get(binding) || null;
487 };
488 R3BoundTarget.prototype.getExpressionTarget = function (expr) {
489 return this.exprTargets.get(expr) || null;
490 };
491 R3BoundTarget.prototype.getTemplateOfSymbol = function (symbol) {
492 return this.symbols.get(symbol) || null;
493 };
494 R3BoundTarget.prototype.getNestingLevel = function (template) {
495 return this.nestingLevel.get(template) || 0;
496 };
497 R3BoundTarget.prototype.getUsedDirectives = function () {
498 var set = new Set();
499 this.directives.forEach(function (dirs) { return dirs.forEach(function (dir) { return set.add(dir); }); });
500 return Array.from(set.values());
501 };
502 R3BoundTarget.prototype.getUsedPipes = function () {
503 return Array.from(this.usedPipes);
504 };
505 return R3BoundTarget;
506 }());
507 exports.R3BoundTarget = R3BoundTarget;
508 function extractTemplateEntities(rootScope) {
509 var e_1, _a, e_2, _b;
510 var entityMap = new Map();
511 function extractScopeEntities(scope) {
512 if (entityMap.has(scope.template)) {
513 return entityMap.get(scope.template);
514 }
515 var currentEntities = scope.namedEntities;
516 var templateEntities;
517 if (scope.parentScope !== null) {
518 templateEntities = new Map(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(extractScopeEntities(scope.parentScope))), tslib_1.__read(currentEntities)));
519 }
520 else {
521 templateEntities = new Map(currentEntities);
522 }
523 entityMap.set(scope.template, templateEntities);
524 return templateEntities;
525 }
526 var scopesToProcess = [rootScope];
527 while (scopesToProcess.length > 0) {
528 var scope = scopesToProcess.pop();
529 try {
530 for (var _c = (e_1 = void 0, tslib_1.__values(scope.childScopes.values())), _d = _c.next(); !_d.done; _d = _c.next()) {
531 var childScope = _d.value;
532 scopesToProcess.push(childScope);
533 }
534 }
535 catch (e_1_1) { e_1 = { error: e_1_1 }; }
536 finally {
537 try {
538 if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
539 }
540 finally { if (e_1) throw e_1.error; }
541 }
542 extractScopeEntities(scope);
543 }
544 var templateEntities = new Map();
545 try {
546 for (var entityMap_1 = tslib_1.__values(entityMap), entityMap_1_1 = entityMap_1.next(); !entityMap_1_1.done; entityMap_1_1 = entityMap_1.next()) {
547 var _e = tslib_1.__read(entityMap_1_1.value, 2), template = _e[0], entities = _e[1];
548 templateEntities.set(template, new Set(entities.values()));
549 }
550 }
551 catch (e_2_1) { e_2 = { error: e_2_1 }; }
552 finally {
553 try {
554 if (entityMap_1_1 && !entityMap_1_1.done && (_b = entityMap_1.return)) _b.call(entityMap_1);
555 }
556 finally { if (e_2) throw e_2.error; }
557 }
558 return templateEntities;
559 }
560});
561//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"t2_binder.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler/src/render3/view/t2_binder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {AST, BindingPipe, ImplicitReceiver, MethodCall, PropertyRead, PropertyWrite, RecursiveAstVisitor, SafeMethodCall, SafePropertyRead} from '../../expression_parser/ast';\nimport {SelectorMatcher} from '../../selector';\nimport {BoundAttribute, BoundEvent, BoundText, Content, Element, Icu, Node, Reference, Template, Text, TextAttribute, Variable, Visitor} from '../r3_ast';\n\nimport {BoundTarget, DirectiveMeta, Target, TargetBinder} from './t2_api';\nimport {createCssSelector} from './template';\nimport {getAttrsForDirectiveMatching} from './util';\n\n\n/**\n * Processes `Target`s with a given set of directives and performs a binding operation, which\n * returns an object similar to TypeScript's `ts.TypeChecker` that contains knowledge about the\n * target.\n */\nexport class R3TargetBinder<DirectiveT extends DirectiveMeta> implements TargetBinder<DirectiveT> {\n  constructor(private directiveMatcher: SelectorMatcher<DirectiveT>) {}\n\n  /**\n   * Perform a binding operation on the given `Target` and return a `BoundTarget` which contains\n   * metadata about the types referenced in the template.\n   */\n  bind(target: Target): BoundTarget<DirectiveT> {\n    if (!target.template) {\n      // TODO(alxhub): handle targets which contain things like HostBindings, etc.\n      throw new Error('Binding without a template not yet supported');\n    }\n\n    // First, parse the template into a `Scope` structure. This operation captures the syntactic\n    // scopes in the template and makes them available for later use.\n    const scope = Scope.apply(target.template);\n\n\n    // Use the `Scope` to extract the entities present at every level of the template.\n    const templateEntities = extractTemplateEntities(scope);\n\n    // Next, perform directive matching on the template using the `DirectiveBinder`. This returns:\n    //   - directives: Map of nodes (elements & ng-templates) to the directives on them.\n    //   - bindings: Map of inputs, outputs, and attributes to the directive/element that claims\n    //     them. TODO(alxhub): handle multiple directives claiming an input/output/etc.\n    //   - references: Map of #references to their targets.\n    const {directives, bindings, references} =\n        DirectiveBinder.apply(target.template, this.directiveMatcher);\n    // Finally, run the TemplateBinder to bind references, variables, and other entities within the\n    // template. This extracts all the metadata that doesn't depend on directive matching.\n    const {expressions, symbols, nestingLevel, usedPipes} =\n        TemplateBinder.applyWithScope(target.template, scope);\n    return new R3BoundTarget(\n        target, directives, bindings, references, expressions, symbols, nestingLevel,\n        templateEntities, usedPipes);\n  }\n}\n\n/**\n * Represents a binding scope within a template.\n *\n * Any variables, references, or other named entities declared within the template will\n * be captured and available by name in `namedEntities`. Additionally, child templates will\n * be analyzed and have their child `Scope`s available in `childScopes`.\n */\nclass Scope implements Visitor {\n  /**\n   * Named members of the `Scope`, such as `Reference`s or `Variable`s.\n   */\n  readonly namedEntities = new Map<string, Reference|Variable>();\n\n  /**\n   * Child `Scope`s for immediately nested `Template`s.\n   */\n  readonly childScopes = new Map<Template, Scope>();\n\n  private constructor(readonly parentScope: Scope|null, readonly template: Template|null) {}\n\n  static newRootScope(): Scope {\n    return new Scope(null, null);\n  }\n\n  /**\n   * Process a template (either as a `Template` sub-template with variables, or a plain array of\n   * template `Node`s) and construct its `Scope`.\n   */\n  static apply(template: Node[]): Scope {\n    const scope = Scope.newRootScope();\n    scope.ingest(template);\n    return scope;\n  }\n\n  /**\n   * Internal method to process the template and populate the `Scope`.\n   */\n  private ingest(template: Template|Node[]): void {\n    if (template instanceof Template) {\n      // Variables on an <ng-template> are defined in the inner scope.\n      template.variables.forEach(node => this.visitVariable(node));\n\n      // Process the nodes of the template.\n      template.children.forEach(node => node.visit(this));\n    } else {\n      // No overarching `Template` instance, so process the nodes directly.\n      template.forEach(node => node.visit(this));\n    }\n  }\n\n  visitElement(element: Element) {\n    // `Element`s in the template may have `Reference`s which are captured in the scope.\n    element.references.forEach(node => this.visitReference(node));\n\n    // Recurse into the `Element`'s children.\n    element.children.forEach(node => node.visit(this));\n  }\n\n  visitTemplate(template: Template) {\n    // References on a <ng-template> are defined in the outer scope, so capture them before\n    // processing the template's child scope.\n    template.references.forEach(node => this.visitReference(node));\n\n    // Next, create an inner scope and process the template within it.\n    const scope = new Scope(this, template);\n    scope.ingest(template);\n    this.childScopes.set(template, scope);\n  }\n\n  visitVariable(variable: Variable) {\n    // Declare the variable if it's not already.\n    this.maybeDeclare(variable);\n  }\n\n  visitReference(reference: Reference) {\n    // Declare the variable if it's not already.\n    this.maybeDeclare(reference);\n  }\n\n  // Unused visitors.\n  visitContent(content: Content) {}\n  visitBoundAttribute(attr: BoundAttribute) {}\n  visitBoundEvent(event: BoundEvent) {}\n  visitBoundText(text: BoundText) {}\n  visitText(text: Text) {}\n  visitTextAttribute(attr: TextAttribute) {}\n  visitIcu(icu: Icu) {}\n\n  private maybeDeclare(thing: Reference|Variable) {\n    // Declare something with a name, as long as that name isn't taken.\n    if (!this.namedEntities.has(thing.name)) {\n      this.namedEntities.set(thing.name, thing);\n    }\n  }\n\n  /**\n   * Look up a variable within this `Scope`.\n   *\n   * This can recurse into a parent `Scope` if it's available.\n   */\n  lookup(name: string): Reference|Variable|null {\n    if (this.namedEntities.has(name)) {\n      // Found in the local scope.\n      return this.namedEntities.get(name)!;\n    } else if (this.parentScope !== null) {\n      // Not in the local scope, but there's a parent scope so check there.\n      return this.parentScope.lookup(name);\n    } else {\n      // At the top level and it wasn't found.\n      return null;\n    }\n  }\n\n  /**\n   * Get the child scope for a `Template`.\n   *\n   * This should always be defined.\n   */\n  getChildScope(template: Template): Scope {\n    const res = this.childScopes.get(template);\n    if (res === undefined) {\n      throw new Error(`Assertion error: child scope for ${template} not found`);\n    }\n    return res;\n  }\n}\n\n/**\n * Processes a template and matches directives on nodes (elements and templates).\n *\n * Usually used via the static `apply()` method.\n */\nclass DirectiveBinder<DirectiveT extends DirectiveMeta> implements Visitor {\n  constructor(\n      private matcher: SelectorMatcher<DirectiveT>,\n      private directives: Map<Element|Template, DirectiveT[]>,\n      private bindings: Map<BoundAttribute|BoundEvent|TextAttribute, DirectiveT|Element|Template>,\n      private references:\n          Map<Reference, {directive: DirectiveT, node: Element|Template}|Element|Template>) {}\n\n  /**\n   * Process a template (list of `Node`s) and perform directive matching against each node.\n   *\n   * @param template the list of template `Node`s to match (recursively).\n   * @param selectorMatcher a `SelectorMatcher` containing the directives that are in scope for\n   * this template.\n   * @returns three maps which contain information about directives in the template: the\n   * `directives` map which lists directives matched on each node, the `bindings` map which\n   * indicates which directives claimed which bindings (inputs, outputs, etc), and the `references`\n   * map which resolves #references (`Reference`s) within the template to the named directive or\n   * template node.\n   */\n  static apply<DirectiveT extends DirectiveMeta>(\n      template: Node[], selectorMatcher: SelectorMatcher<DirectiveT>): {\n    directives: Map<Element|Template, DirectiveT[]>,\n    bindings: Map<BoundAttribute|BoundEvent|TextAttribute, DirectiveT|Element|Template>,\n    references: Map<Reference, {directive: DirectiveT, node: Element|Template}|Element|Template>,\n  } {\n    const directives = new Map<Element|Template, DirectiveT[]>();\n    const bindings =\n        new Map<BoundAttribute|BoundEvent|TextAttribute, DirectiveT|Element|Template>();\n    const references =\n        new Map<Reference, {directive: DirectiveT, node: Element | Template}|Element|Template>();\n    const matcher = new DirectiveBinder(selectorMatcher, directives, bindings, references);\n    matcher.ingest(template);\n    return {directives, bindings, references};\n  }\n\n  private ingest(template: Node[]): void {\n    template.forEach(node => node.visit(this));\n  }\n\n  visitElement(element: Element): void {\n    this.visitElementOrTemplate(element.name, element);\n  }\n\n  visitTemplate(template: Template): void {\n    this.visitElementOrTemplate('ng-template', template);\n  }\n\n  visitElementOrTemplate(elementName: string, node: Element|Template): void {\n    // First, determine the HTML shape of the node for the purpose of directive matching.\n    // Do this by building up a `CssSelector` for the node.\n    const cssSelector = createCssSelector(elementName, getAttrsForDirectiveMatching(node));\n\n    // Next, use the `SelectorMatcher` to get the list of directives on the node.\n    const directives: DirectiveT[] = [];\n    this.matcher.match(cssSelector, (_, directive) => directives.push(directive));\n    if (directives.length > 0) {\n      this.directives.set(node, directives);\n    }\n\n    // Resolve any references that are created on this node.\n    node.references.forEach(ref => {\n      let dirTarget: DirectiveT|null = null;\n\n      // If the reference expression is empty, then it matches the \"primary\" directive on the node\n      // (if there is one). Otherwise it matches the host node itself (either an element or\n      // <ng-template> node).\n      if (ref.value.trim() === '') {\n        // This could be a reference to a component if there is one.\n        dirTarget = directives.find(dir => dir.isComponent) || null;\n      } else {\n        // This should be a reference to a directive exported via exportAs.\n        dirTarget =\n            directives.find(\n                dir => dir.exportAs !== null && dir.exportAs.some(value => value === ref.value)) ||\n            null;\n        // Check if a matching directive was found.\n        if (dirTarget === null) {\n          // No matching directive was found - this reference points to an unknown target. Leave it\n          // unmapped.\n          return;\n        }\n      }\n\n      if (dirTarget !== null) {\n        // This reference points to a directive.\n        this.references.set(ref, {directive: dirTarget, node});\n      } else {\n        // This reference points to the node itself.\n        this.references.set(ref, node);\n      }\n    });\n\n    // Associate attributes/bindings on the node with directives or with the node itself.\n    type BoundNode = BoundAttribute|BoundEvent|TextAttribute;\n    const setAttributeBinding =\n        (attribute: BoundNode, ioType: keyof Pick<DirectiveMeta, 'inputs'|'outputs'>) => {\n          const dir = directives.find(dir => dir[ioType].hasBindingPropertyName(attribute.name));\n          const binding = dir !== undefined ? dir : node;\n          this.bindings.set(attribute, binding);\n        };\n\n    // Node inputs (bound attributes) and text attributes can be bound to an\n    // input on a directive.\n    node.inputs.forEach(input => setAttributeBinding(input, 'inputs'));\n    node.attributes.forEach(attr => setAttributeBinding(attr, 'inputs'));\n    if (node instanceof Template) {\n      node.templateAttrs.forEach(attr => setAttributeBinding(attr, 'inputs'));\n    }\n    // Node outputs (bound events) can be bound to an output on a directive.\n    node.outputs.forEach(output => setAttributeBinding(output, 'outputs'));\n\n    // Recurse into the node's children.\n    node.children.forEach(child => child.visit(this));\n  }\n\n  // Unused visitors.\n  visitContent(content: Content): void {}\n  visitVariable(variable: Variable): void {}\n  visitReference(reference: Reference): void {}\n  visitTextAttribute(attribute: TextAttribute): void {}\n  visitBoundAttribute(attribute: BoundAttribute): void {}\n  visitBoundEvent(attribute: BoundEvent): void {}\n  visitBoundAttributeOrEvent(node: BoundAttribute|BoundEvent) {}\n  visitText(text: Text): void {}\n  visitBoundText(text: BoundText): void {}\n  visitIcu(icu: Icu): void {}\n}\n\n/**\n * Processes a template and extract metadata about expressions and symbols within.\n *\n * This is a companion to the `DirectiveBinder` that doesn't require knowledge of directives matched\n * within the template in order to operate.\n *\n * Expressions are visited by the superclass `RecursiveAstVisitor`, with custom logic provided\n * by overridden methods from that visitor.\n */\nclass TemplateBinder extends RecursiveAstVisitor implements Visitor {\n  private visitNode: (node: Node) => void;\n\n  private pipesUsed: string[] = [];\n\n  private constructor(\n      private bindings: Map<AST, Reference|Variable>,\n      private symbols: Map<Reference|Variable, Template>, private usedPipes: Set<string>,\n      private nestingLevel: Map<Template, number>, private scope: Scope,\n      private template: Template|null, private level: number) {\n    super();\n\n    // Save a bit of processing time by constructing this closure in advance.\n    this.visitNode = (node: Node) => node.visit(this);\n  }\n\n  // This method is defined to reconcile the type of TemplateBinder since both\n  // RecursiveAstVisitor and Visitor define the visit() method in their\n  // interfaces.\n  override visit(node: AST|Node, context?: any) {\n    if (node instanceof AST) {\n      node.visit(this, context);\n    } else {\n      node.visit(this);\n    }\n  }\n\n  /**\n   * Process a template and extract metadata about expressions and symbols within.\n   *\n   * @param template the nodes of the template to process\n   * @param scope the `Scope` of the template being processed.\n   * @returns three maps which contain metadata about the template: `expressions` which interprets\n   * special `AST` nodes in expressions as pointing to references or variables declared within the\n   * template, `symbols` which maps those variables and references to the nested `Template` which\n   * declares them, if any, and `nestingLevel` which associates each `Template` with a integer\n   * nesting level (how many levels deep within the template structure the `Template` is), starting\n   * at 1.\n   */\n  static applyWithScope(template: Node[], scope: Scope): {\n    expressions: Map<AST, Reference|Variable>,\n    symbols: Map<Variable|Reference, Template>,\n    nestingLevel: Map<Template, number>,\n    usedPipes: Set<string>,\n  } {\n    const expressions = new Map<AST, Reference|Variable>();\n    const symbols = new Map<Variable|Reference, Template>();\n    const nestingLevel = new Map<Template, number>();\n    const usedPipes = new Set<string>();\n    // The top-level template has nesting level 0.\n    const binder = new TemplateBinder(\n        expressions, symbols, usedPipes, nestingLevel, scope,\n        template instanceof Template ? template : null, 0);\n    binder.ingest(template);\n    return {expressions, symbols, nestingLevel, usedPipes};\n  }\n\n  private ingest(template: Template|Node[]): void {\n    if (template instanceof Template) {\n      // For <ng-template>s, process only variables and child nodes. Inputs, outputs, templateAttrs,\n      // and references were all processed in the scope of the containing template.\n      template.variables.forEach(this.visitNode);\n      template.children.forEach(this.visitNode);\n\n      // Set the nesting level.\n      this.nestingLevel.set(template, this.level);\n    } else {\n      // Visit each node from the top-level template.\n      template.forEach(this.visitNode);\n    }\n  }\n\n  visitElement(element: Element) {\n    // Visit the inputs, outputs, and children of the element.\n    element.inputs.forEach(this.visitNode);\n    element.outputs.forEach(this.visitNode);\n    element.children.forEach(this.visitNode);\n  }\n\n  visitTemplate(template: Template) {\n    // First, visit inputs, outputs and template attributes of the template node.\n    template.inputs.forEach(this.visitNode);\n    template.outputs.forEach(this.visitNode);\n    template.templateAttrs.forEach(this.visitNode);\n\n    // References are also evaluated in the outer context.\n    template.references.forEach(this.visitNode);\n\n    // Next, recurse into the template using its scope, and bumping the nesting level up by one.\n    const childScope = this.scope.getChildScope(template);\n    const binder = new TemplateBinder(\n        this.bindings, this.symbols, this.usedPipes, this.nestingLevel, childScope, template,\n        this.level + 1);\n    binder.ingest(template);\n  }\n\n  visitVariable(variable: Variable) {\n    // Register the `Variable` as a symbol in the current `Template`.\n    if (this.template !== null) {\n      this.symbols.set(variable, this.template);\n    }\n  }\n\n  visitReference(reference: Reference) {\n    // Register the `Reference` as a symbol in the current `Template`.\n    if (this.template !== null) {\n      this.symbols.set(reference, this.template);\n    }\n  }\n\n  // Unused template visitors\n\n  visitText(text: Text) {}\n  visitContent(content: Content) {}\n  visitTextAttribute(attribute: TextAttribute) {}\n  visitIcu(icu: Icu): void {\n    Object.keys(icu.vars).forEach(key => icu.vars[key].visit(this));\n    Object.keys(icu.placeholders).forEach(key => icu.placeholders[key].visit(this));\n  }\n\n  // The remaining visitors are concerned with processing AST expressions within template bindings\n\n  visitBoundAttribute(attribute: BoundAttribute) {\n    attribute.value.visit(this);\n  }\n\n  visitBoundEvent(event: BoundEvent) {\n    event.handler.visit(this);\n  }\n\n  visitBoundText(text: BoundText) {\n    text.value.visit(this);\n  }\n  override visitPipe(ast: BindingPipe, context: any): any {\n    this.usedPipes.add(ast.name);\n    return super.visitPipe(ast, context);\n  }\n\n  // These five types of AST expressions can refer to expression roots, which could be variables\n  // or references in the current scope.\n\n  override visitPropertyRead(ast: PropertyRead, context: any): any {\n    this.maybeMap(context, ast, ast.name);\n    return super.visitPropertyRead(ast, context);\n  }\n\n  override visitSafePropertyRead(ast: SafePropertyRead, context: any): any {\n    this.maybeMap(context, ast, ast.name);\n    return super.visitSafePropertyRead(ast, context);\n  }\n\n  override visitPropertyWrite(ast: PropertyWrite, context: any): any {\n    this.maybeMap(context, ast, ast.name);\n    return super.visitPropertyWrite(ast, context);\n  }\n\n  override visitMethodCall(ast: MethodCall, context: any): any {\n    this.maybeMap(context, ast, ast.name);\n    return super.visitMethodCall(ast, context);\n  }\n\n  override visitSafeMethodCall(ast: SafeMethodCall, context: any): any {\n    this.maybeMap(context, ast, ast.name);\n    return super.visitSafeMethodCall(ast, context);\n  }\n\n  private maybeMap(\n      scope: Scope, ast: PropertyRead|SafePropertyRead|PropertyWrite|MethodCall|SafeMethodCall,\n      name: string): void {\n    // If the receiver of the expression isn't the `ImplicitReceiver`, this isn't the root of an\n    // `AST` expression that maps to a `Variable` or `Reference`.\n    if (!(ast.receiver instanceof ImplicitReceiver)) {\n      return;\n    }\n\n    // Check whether the name exists in the current scope. If so, map it. Otherwise, the name is\n    // probably a property on the top-level component context.\n    let target = this.scope.lookup(name);\n    if (target !== null) {\n      this.bindings.set(ast, target);\n    }\n  }\n}\n\n/**\n * Metadata container for a `Target` that allows queries for specific bits of metadata.\n *\n * See `BoundTarget` for documentation on the individual methods.\n */\nexport class R3BoundTarget<DirectiveT extends DirectiveMeta> implements BoundTarget<DirectiveT> {\n  constructor(\n      readonly target: Target, private directives: Map<Element|Template, DirectiveT[]>,\n      private bindings: Map<BoundAttribute|BoundEvent|TextAttribute, DirectiveT|Element|Template>,\n      private references:\n          Map<BoundAttribute|BoundEvent|Reference|TextAttribute,\n              {directive: DirectiveT, node: Element|Template}|Element|Template>,\n      private exprTargets: Map<AST, Reference|Variable>,\n      private symbols: Map<Reference|Variable, Template>,\n      private nestingLevel: Map<Template, number>,\n      private templateEntities: Map<Template|null, ReadonlySet<Reference|Variable>>,\n      private usedPipes: Set<string>) {}\n\n  getEntitiesInTemplateScope(template: Template|null): ReadonlySet<Reference|Variable> {\n    return this.templateEntities.get(template) ?? new Set();\n  }\n\n  getDirectivesOfNode(node: Element|Template): DirectiveT[]|null {\n    return this.directives.get(node) || null;\n  }\n\n  getReferenceTarget(ref: Reference): {directive: DirectiveT, node: Element|Template}|Element\n      |Template|null {\n    return this.references.get(ref) || null;\n  }\n\n  getConsumerOfBinding(binding: BoundAttribute|BoundEvent|TextAttribute): DirectiveT|Element\n      |Template|null {\n    return this.bindings.get(binding) || null;\n  }\n\n  getExpressionTarget(expr: AST): Reference|Variable|null {\n    return this.exprTargets.get(expr) || null;\n  }\n\n  getTemplateOfSymbol(symbol: Reference|Variable): Template|null {\n    return this.symbols.get(symbol) || null;\n  }\n\n  getNestingLevel(template: Template): number {\n    return this.nestingLevel.get(template) || 0;\n  }\n\n  getUsedDirectives(): DirectiveT[] {\n    const set = new Set<DirectiveT>();\n    this.directives.forEach(dirs => dirs.forEach(dir => set.add(dir)));\n    return Array.from(set.values());\n  }\n\n  getUsedPipes(): string[] {\n    return Array.from(this.usedPipes);\n  }\n}\n\nfunction extractTemplateEntities(rootScope: Scope): Map<Template|null, Set<Reference|Variable>> {\n  const entityMap = new Map<Template|null, Map<string, Reference|Variable>>();\n\n  function extractScopeEntities(scope: Scope): Map<string, Reference|Variable> {\n    if (entityMap.has(scope.template)) {\n      return entityMap.get(scope.template)!;\n    }\n\n    const currentEntities = scope.namedEntities;\n\n    let templateEntities: Map<string, Reference|Variable>;\n    if (scope.parentScope !== null) {\n      templateEntities = new Map([...extractScopeEntities(scope.parentScope), ...currentEntities]);\n    } else {\n      templateEntities = new Map(currentEntities);\n    }\n\n    entityMap.set(scope.template, templateEntities);\n    return templateEntities;\n  }\n\n  const scopesToProcess: Scope[] = [rootScope];\n  while (scopesToProcess.length > 0) {\n    const scope = scopesToProcess.pop()!;\n    for (const childScope of scope.childScopes.values()) {\n      scopesToProcess.push(childScope);\n    }\n    extractScopeEntities(scope);\n  }\n\n  const templateEntities = new Map<Template|null, Set<Reference|Variable>>();\n  for (const [template, entities] of entityMap) {\n    templateEntities.set(template, new Set(entities.values()));\n  }\n  return templateEntities;\n}\n"]}
Note: See TracBrowser for help on using the repository browser.