Method bind

packages/compiler/src/render3/view/t2_binder.ts:179–271

* Perform a binding operation on the given `Target` and return a `BoundTarget` which contains * metadata about the types referenced in the template.

(target: Target<DirectiveT>)

   * metadata about the types referenced in the template.
   */
  bind(target: Target<DirectiveT>): BoundTarget<DirectiveT> {
    if (!target.template && !target.host) {
      throw new Error('Empty bound targets are not supported');
    }

    const directives: MatchedDirectives<DirectiveT> = new Map();
    const eagerDirectives: DirectiveT[] = [];
    const missingDirectives = new Set<string>();
    const bindings: BindingsMap<DirectiveT> = new Map();
    const references: ReferenceMap<DirectiveT> = new Map();
    const scopedNodeEntities: ScopedNodeEntities = new Map();
    const expressions = new Map<AST, TemplateEntity>();
    const symbols = new Map<TemplateEntity, Template>();
    const nestingLevel = new Map<ScopedNode, number>();
    const usedPipes = new Set<string>();
    const eagerPipes = new Set<string>();
    const deferBlocks: DeferBlockScopes = [];
    const conflictingHostDirectiveBindings = new Map<
      DirectiveOwner,
      ConflictingHostDirectiveBinding<DirectiveT>[]
    >();

    if (target.template) {
      // First, parse the template into a `Scope` structure. This operation captures the syntactic
      // scopes in the template and makes them available for later use.
      const scope = Scope.apply(target.template);

      // Use the `Scope` to extract the entities present at every level of the template.
      extractScopedNodeEntities(scope, scopedNodeEntities);

      // Next, perform directive matching on the template using the `DirectiveBinder`. This returns:
      //   - directives: Map of nodes (elements & ng-templates) to the directives on them.
      //   - bindings: Map of inputs, outputs, and attributes to the directive/element that claims
      //     them. TODO(alxhub): handle multiple directives claiming an input/output/etc.
      //   - references: Map of #references to their targets.
      DirectiveBinder.apply(
        target.template,
        this.directiveMatcher,
        directives,
        eagerDirectives,
        missingDirectives,
        bindings,
        references,
        conflictingHostDirectiveBindings,
      );

      // Finally, run the TemplateBinder to bind references, variables, and other entities within the
      // template. This extracts all the metadata that doesn't depend on directive matching.
      TemplateBinder.applyWithScope(
        target.template,
        scope,
        expressions,
        symbols,
        nestingLevel,
        usedPipes,
        eagerPipes,
        deferBlocks,
      );