TypeScript ListWrapper.concat方法代码示例

 expandedDomNodes() {
   var res = [];
   var roots = this._roots();
   for (var i = 0; i < roots.length; ++i) {
     var root = roots[i];
     if (isPresent(root.viewContainer)) {
       res = ListWrapper.concat(res, root.viewContainer.nodes());
     } else if (isPresent(root.content)) {
       res = ListWrapper.concat(res, root.content.nodes());
     } else {
       ListWrapper.push(res, root.node);
     }
   }
   return res;
 }

 nodes() {
   var r = [];
   for (var i = 0; i < this._views.length; ++i) {
     r = ListWrapper.concat(r, this._views[i].nodes);
   }
   return r;
 }

 nodes(): List</*node*/ any> {
   var r = [];
   for (var i = 0; i < this.views.length; ++i) {
     r = ListWrapper.concat(r, this.views[i].rootNodes);
   }
   return r;
 }

 insertChildrenAfter(child: DebugNode, newChildren: DebugNode[]) {
   var siblingIndex = this.childNodes.indexOf(child);
   if (siblingIndex !== -1) {
     var previousChildren = this.childNodes.slice(0, siblingIndex + 1);
     var nextChildren = this.childNodes.slice(siblingIndex + 1);
     this.childNodes =
         ListWrapper.concat(ListWrapper.concat(previousChildren, newChildren), nextChildren);
     for (var i = 0; i < newChildren.length; ++i) {
       var newChild = newChildren[i];
       if (isPresent(newChild.parent)) {
         newChild.parent.removeChild(newChild);
       }
       newChild.parent = this;
     }
   }
 }

function _createAppInjector(appComponentType, bindings, zone) {
  if (isBlank(_rootInjector))
    _rootInjector = new Injector(_rootBindings);
  var mergedBindings = isPresent(bindings) ? ListWrapper.concat(_injectorBindings(appComponentType), bindings) : _injectorBindings(appComponentType);
  ListWrapper.push(mergedBindings, bind(VmTurnZone).toValue(zone));
  return _rootInjector.createChild(mergedBindings);
}

export function createEventRecords(definition: ChangeDetectorDefinition): EventBinding[] {
  // TODO: vsavkin: remove $event when the compiler handles render-side variables properly
  var varNames = ListWrapper.concat(['$event'], definition.variableNames);
  return definition.eventRecords.map(er => {
    var records = _ConvertAstIntoProtoRecords.create(er, varNames);
    var dirIndex = er.implicitReceiver instanceof DirectiveIndex ? er.implicitReceiver : null;
    return new EventBinding(er.eventName, er.elementIndex, dirIndex, records);
  });
}

function _createAppInjector(appComponentType: Type, bindings: List<Type | Binding | List<any>>,
                            zone: NgZone): Injector {
  if (isBlank(_rootInjector)) _rootInjector = Injector.resolveAndCreate(_rootBindings);
  var mergedBindings: any[] =
      isPresent(bindings) ? ListWrapper.concat(_injectorBindings(appComponentType), bindings) :
                            _injectorBindings(appComponentType);
  mergedBindings.push(bind(NgZone).toValue(zone));
  return _rootInjector.resolveAndCreateChild(mergedBindings);
}

function diff(actual: string[], expected: string[]): string[] {
  ListWrapper.sort(actual, compareIgnoreLang);
  ListWrapper.sort(expected, compareIgnoreLang);
  let mode = IS_DART ? "dart" : "js";
  let missing = actual.filter(i => expected.indexOf(i) < 0 && expected.indexOf(`${i}:${mode}`) < 0)
                    .map(s => `+${s}`);
  let extra = expected.filter(i => shouldIgnore(i) ? false : (actual.indexOf(stripLang(i)) < 0))
                  .map(s => `-${s}`);
  return ListWrapper.concat(missing, extra);
}

 _report(state: SampleState, metricValues: StringMap<string, any>): Promise<SampleState> {
   var measureValues = new MeasureValues(state.completeSample.length, this._now(), metricValues);
   var completeSample = ListWrapper.concat(state.completeSample, [measureValues]);
   var validSample = this._validator.validate(completeSample);
   var resultPromise = this._reporter.reportMeasureValues(measureValues);
   if (isPresent(validSample)) {
     resultPromise =
         resultPromise.then((_) => this._reporter.reportSample(completeSample, validSample))
   }
   return resultPromise.then((_) => new SampleState(completeSample, validSample));
 }

 addAst(ast, bindingMemento, directiveMemento = null, variableBindings = null) {
   var last = ListWrapper.last(this.records);
   if (isPresent(last) && last.directiveMemento == directiveMemento) {
     last.lastInDirective = false;
   }
   var pr = _ConvertAstIntoProtoRecords.convert(ast, bindingMemento, directiveMemento, this.records.length, variableBindings);
   if (!ListWrapper.isEmpty(pr)) {
     var last = ListWrapper.last(pr);
     last.lastInBinding = true;
     last.lastInDirective = true;
     this.records = ListWrapper.concat(this.records, pr);
   }
 }