angular-cn/modules/@angular/core/src/view/query.ts

/**
 * @license
 * Copyright Google Inc. All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

import {ElementRef} from '../linker/element_ref';
import {QueryList} from '../linker/query_list';
import {TemplateRef} from '../linker/template_ref';
import {ViewContainerRef} from '../linker/view_container_ref';

import {createTemplateRef, createViewContainerRef} from './refs';
import {NodeDef, NodeFlags, NodeType, QueryBindingDef, QueryBindingType, QueryDef, QueryValueType, Services, ViewData, asElementData, asProviderData, asQueryList} from './types';
import {declaredViewContainer, viewParentElIndex} from './util';

export function queryDef(
    flags: NodeFlags, id: string, bindings: {[propName: string]: QueryBindingType}): NodeDef {
  let bindingDefs: QueryBindingDef[] = [];
  for (let propName in bindings) {
    const bindingType = bindings[propName];
    bindingDefs.push({propName, bindingType});
  }

  return {
    type: NodeType.Query,
    // will bet set by the view definition
    index: undefined,
    reverseChildIndex: undefined,
    parent: undefined,
    childFlags: undefined,
    childMatchedQueries: undefined,
    bindingIndex: undefined,
    disposableIndex: undefined,
    // regular values
    flags,
    ngContentIndex: undefined,
    matchedQueries: {},
    childCount: 0,
    bindings: [],
    disposableCount: 0,
    element: undefined,
    provider: undefined,
    text: undefined,
    pureExpression: undefined,
    query: {id, bindings: bindingDefs},
    ngContent: undefined
  };
}

export function createQuery(): QueryList<any> {
  return new QueryList();
}

export function dirtyParentQuery(queryId: string, view: ViewData) {
  let elIndex = viewParentElIndex(view);
  view = view.parent;
  let queryIdx: number;
  while (view) {
    if (elIndex != null) {
      const elementDef = view.def.nodes[elIndex];
      queryIdx = elementDef.element.providerIndices[queryId];
      if (queryIdx != null) {
        break;
      }
    }
    elIndex = viewParentElIndex(view);
    view = view.parent;
  }
  if (!view) {
    throw new Error(
        `Illegal State: Tried to dirty parent query ${queryId} but the query could not be found!`);
  }
  asQueryList(view, queryIdx).setDirty();
}

export function checkAndUpdateQuery(view: ViewData, nodeDef: NodeDef) {
  const queryList = asQueryList(view, nodeDef.index);
  if (!queryList.dirty) {
    return;
  }
  const queryId = nodeDef.query.id;
  const providerDef = view.def.nodes[nodeDef.parent];
  const providerData = asProviderData(view, providerDef.index);
  let newValues: any[];
  if (nodeDef.flags & NodeFlags.HasContentQuery) {
    const elementDef = view.def.nodes[providerDef.parent];
    newValues = calcQueryValues(
        view, elementDef.index, elementDef.index + elementDef.childCount, queryId, []);
  } else if (nodeDef.flags & NodeFlags.HasViewQuery) {
    const compView = providerData.componentView;
    newValues = calcQueryValues(compView, 0, compView.def.nodes.length - 1, queryId, []);
  }
  queryList.reset(newValues);
  let boundValue: any;
  const bindings = nodeDef.query.bindings;
  for (let i = 0; i < bindings.length; i++) {
    const binding = bindings[i];
    switch (binding.bindingType) {
      case QueryBindingType.First:
        boundValue = queryList.first;
        break;
      case QueryBindingType.All:
        boundValue = queryList;
        break;
    }
    providerData.instance[binding.propName] = boundValue;
  }
}

function calcQueryValues(
    view: ViewData, startIndex: number, endIndex: number, queryId: string, values: any[]): any[] {
  const len = view.def.nodes.length;
  for (let i = startIndex; i <= endIndex; i++) {
    const nodeDef = view.def.nodes[i];
    const value = getQueryValue(view, nodeDef, queryId);
    if (value != null) {
      // a match
      values.push(value);
    }
    if (nodeDef.flags & NodeFlags.HasEmbeddedViews &&
        queryId in nodeDef.element.template.nodeMatchedQueries) {
      // check embedded views that were attached at the place of their template.
      const elementData = asElementData(view, i);
      const embeddedViews = elementData.embeddedViews;
      for (let k = 0; k < embeddedViews.length; k++) {
        const embeddedView = embeddedViews[k];
        const dvc = declaredViewContainer(embeddedView);
        if (dvc && dvc === elementData) {
          calcQueryValues(embeddedView, 0, embeddedView.def.nodes.length - 1, queryId, values);
        }
      }
      const projectedViews = elementData.projectedViews;
      if (projectedViews) {
        for (let k = 0; k < projectedViews.length; k++) {
          const projectedView = projectedViews[k];
          calcQueryValues(projectedView, 0, projectedView.def.nodes.length - 1, queryId, values);
        }
      }
    }
    if (!(queryId in nodeDef.childMatchedQueries)) {
      // If don't check descendants, skip the children.
      // Or: no child matches the query, then skip the children as well.
      i += nodeDef.childCount;
    }
  }
  return values;
}

export function getQueryValue(view: ViewData, nodeDef: NodeDef, queryId: string): any {
  const queryValueType = <QueryValueType>nodeDef.matchedQueries[queryId];
  if (queryValueType != null) {
    // a match
    let value: any;
    switch (queryValueType) {
      case QueryValueType.RenderElement:
        value = asElementData(view, nodeDef.index).renderElement;
        break;
      case QueryValueType.ElementRef:
        value = new ElementRef(asElementData(view, nodeDef.index).renderElement);
        break;
      case QueryValueType.TemplateRef:
        value = createTemplateRef(view, nodeDef);
        break;
      case QueryValueType.ViewContainerRef:
        value = createViewContainerRef(view, nodeDef.index);
        break;
      case QueryValueType.Provider:
        value = asProviderData(view, nodeDef.index).instance;
        break;
    }
    return value;
  }
}