TypeScript DOM.childNodes方法代码示例

    it('should not coalesque text nodes', () => {
      var el1 = el('<div>a</div>');
      var el2 = el('<div>b</div>');
      DOM.appendChild(el2, DOM.firstChild(el1));
      expect(DOM.childNodes(el2).length).toBe(2);

      var el2Clone = DOM.clone(el2);
      expect(DOM.childNodes(el2Clone).length).toBe(2);
    });

 compile('<input (change)="$event.target.value">', []).then((pvRefs) => {
   var viewRef = renderer.createView(pvRefs[0])[1];
   var dispatcher = new LoggingEventDispatcher();
   renderer.setEventDispatcher(viewRef, dispatcher);
   var inputEl = DOM.childNodes(rootEl)[0];
   inputEl.value = 'hello';
   eventPlugin.dispatchEvent('change', new FakeEvent(inputEl));
   expect(dispatcher.log).toEqual([[0, 'change', ['hello']]]);
   async.done();
 });

export function queryBoundTextNodeIndices(parentNode: Node, boundTextNodes: Map<Node, any>,
                                          resultCallback: Function) {
  var childNodes = DOM.childNodes(parentNode);
  for (var j = 0; j < childNodes.length; j++) {
    var node = childNodes[j];
    if (boundTextNodes.has(node)) {
      resultCallback(node, j, boundTextNodes.get(node));
    }
  }
}

 function createView(pv = null, boundElementCount = 0) {
   if (isBlank(pv)) {
     pv = createProtoView();
   }
   var root = el('<div><div></div></div>');
   var boundElements = [];
   for (var i = 0; i < boundElementCount; i++) {
     boundElements.push(new DomElement(pv.elementBinders[i], el('<span></span'), null));
   }
   return new DomView(pv, [DOM.childNodes(root)[0]], [], boundElements);
 }

function queryBoundTextNodes(templateContent: Node, rootTextNodeIndices: number[],
                             boundElements: Element[], elementBinders: DomElementBinder[],
                             boundTextNodeCount: number): Node[] {
  var boundTextNodes = ListWrapper.createFixedSize(boundTextNodeCount);
  var textNodeIndex = 0;
  if (rootTextNodeIndices.length > 0) {
    var rootChildNodes = DOM.childNodes(templateContent);
    for (var i = 0; i < rootTextNodeIndices.length; i++) {
      boundTextNodes[textNodeIndex++] = rootChildNodes[rootTextNodeIndices[i]];
    }
  }
  for (var i = 0; i < elementBinders.length; i++) {
    var binder = elementBinders[i];
    var element: Node = boundElements[i];
    if (binder.textNodeIndices.length > 0) {
      var childNodes = DOM.childNodes(element);
      for (var j = 0; j < binder.textNodeIndices.length; j++) {
        boundTextNodes[textNodeIndex++] = childNodes[binder.textNodeIndices[j]];
      }
    }
  }
  return boundTextNodes;
}

 process(parent: CompileElement, current: CompileElement, control: CompileControl) {
   if (!current.compileChildren) {
     return;
   }
   var element = current.element;
   var childNodes = DOM.childNodes(DOM.templateAwareRoot(element));
   for (var i = 0; i < childNodes.length; i++) {
     var node = childNodes[i];
     if (DOM.isTextNode(node)) {
       var text = DOM.nodeValue(node);
       var expr = this._parser.parseInterpolation(text, current.elementDescription);
       if (isPresent(expr)) {
         DOM.setText(node, ' ');
         current.bindElement().bindText(node, expr);
       }
     }
   }
 }

export function stringifyElement(el): string {
  var result = '';
  if (DOM.isElementNode(el)) {
    var tagName = StringWrapper.toLowerCase(DOM.tagName(el));

    // Opening tag
    result += `<${tagName}`;

    // Attributes in an ordered way
    var attributeMap = DOM.attributeMap(el);
    var keys = [];
    MapWrapper.forEach(attributeMap, (v, k) => { keys.push(k); });
    ListWrapper.sort(keys);
    for (let i = 0; i < keys.length; i++) {
      var key = keys[i];
      var attValue = MapWrapper.get(attributeMap, key);
      if (!isString(attValue)) {
        result += ` ${key}`;
      } else {
        result += ` ${key}="${attValue}"`;
      }
    }
    result += '>';

    // Children
    var children = DOM.childNodes(DOM.templateAwareRoot(el));
    for (let j = 0; j < children.length; j++) {
      result += stringifyElement(children[j]);
    }

    // Closing tag
    if (!ListWrapper.contains(_singleTagWhitelist, tagName)) {
      result += `</${tagName}>`;
    }
  } else {
    result += DOM.getText(el);
  }

  return result;
}

 function assertElementTextBinding(elementBinderBuilder: ElementBinderBuilder, nodeIndex: number,
                                   expression: string) {
   var node = DOM.childNodes(DOM.templateAwareRoot(elementBinderBuilder.element))[nodeIndex];
   expect(elementBinderBuilder.textBindings.get(node).source).toEqual(expression);
 }