TypeScript PromiseWrapper.resolve方法代码示例

 logs(type) {
   this._log.push(['logs', type]);
   if (type === 'performance') {
     return PromiseWrapper.resolve(this._events.map((event) => {
       return {
         'message': Json.stringify({'message': {'method': this._messageMethod, 'params': event}})
       };
     }));
   } else {
     return null;
   }
 }

function componentHandlerToComponentType(handler): Promise<any> {
  var componentDeclaration = handler['component'], type = componentDeclaration['type'];

  if (type == 'constructor') {
    return PromiseWrapper.resolve(componentDeclaration['constructor']);
  } else if (type == 'loader') {
    var resolverFunction = componentDeclaration['loader'];
    return resolverFunction();
  } else {
    throw new BaseException(`Cannot extract the component type from a '${type}' component`);
  }
}

      it('should run Promise created in Promise', fakeAsync(() => {
           var log = new Log();

           PromiseWrapper.resolve(null).then((_) => {
             log.add(1);
             PromiseWrapper.resolve(null).then((_) => log.add(2));
           });

           expect(log.result()).toEqual('');

           flushMicrotasks();
           expect(log.result()).toEqual('1; 2');
         }));

 logs(type) {
   this._log.push(['logs', type]);
   if (type === 'performance') {
     return PromiseWrapper.resolve(this._perfRecords.map(function(record) {
       return {
         'message': Json.stringify(
             {'message': {'method': 'Timeline.eventRecorded', 'params': {'record': record}}})
       };
     }));
   } else {
     return null;
   }
 }

  _compileTemplate(viewDef: ViewDefinition, tplElement,
                   protoViewType: number): Promise<ProtoViewDto> {
    var subTaskPromises = [];
    var pipeline = new CompilePipeline(this._stepFactory.createSteps(viewDef, subTaskPromises));
    var compileElements = pipeline.process(tplElement, protoViewType, viewDef.componentId);

    var protoView = compileElements[0].inheritedProtoView.build();

    if (subTaskPromises.length > 0) {
      return PromiseWrapper.all(subTaskPromises).then((_) => protoView);
    } else {
      return PromiseWrapper.resolve(protoView);
    }
  }

 _iterate(lastState): Promise<SampleState> {
   var resultPromise: Promise<any>;
   if (isPresent(this._prepare)) {
     resultPromise = this._driver.waitFor(this._prepare);
   } else {
     resultPromise = PromiseWrapper.resolve(null);
   }
   if (isPresent(this._prepare) || lastState.completeSample.length === 0) {
     resultPromise = resultPromise.then((_) => this._metric.beginMeasure());
   }
   return resultPromise.then((_) => this._driver.waitFor(this._execute))
       .then((_) => this._metric.endMeasure(isBlank(this._prepare)))
       .then((measureValues) => this._report(lastState, measureValues));
 }

 reportSample(completeSample: MeasureValues[], validSamples: MeasureValues[]): Promise<any> {
   this._printStringRow(this._metricNames.map((_) => ''), '=');
   this._printStringRow(this._metricNames.map(metricName => {
     var samples = validSamples.map(measureValues => measureValues.values[metricName]);
     var mean = Statistic.calculateMean(samples);
     var cv = Statistic.calculateCoefficientOfVariation(samples, mean);
     var formattedMean = ConsoleReporter._formatNum(mean)
                             // Note: Don't use the unicode character for +- as it might cause
                             // hickups for consoles...
                             return NumberWrapper.isNaN(cv) ?
                             formattedMean :
                             `${formattedMean}+-${Math.floor(cv)}%`;
   }));
   return PromiseWrapper.resolve(null);
 }

export function bootstrapRender(
    workerScriptUri: string,
    customProviders?: Array<any /*Type | Provider | any[]*/>): Promise<ApplicationRef> {
  var pf = ReflectiveInjector.resolveAndCreate(WORKER_RENDER_PLATFORM);
  var app = ReflectiveInjector.resolveAndCreate(
      [
        WORKER_RENDER_APPLICATION,
        /* @ts2dart_Provider */ {provide: WORKER_SCRIPT, useValue: workerScriptUri},
        isPresent(customProviders) ? customProviders : []
      ],
      workerRenderPlatform().injector);
  // Return a promise so that we keep the same semantics as Dart,
  // and we might want to wait for the app side to come up
  // in the future...
  return PromiseWrapper.resolve(app.get(ApplicationRef));
}

 load(template) {
   if (isPresent(template.inline)) {
     return PromiseWrapper.resolve(DOM.createTemplate(template.inline));
   }
   var url = template.absUrl;
   if (isPresent(url)) {
     var promise = StringMapWrapper.get(this._htmlCache, url);
     if (isBlank(promise)) {
       promise = this._xhr.get(url).then(function(html) {
         var template = DOM.createTemplate(html);
         return template;
       });
       StringMapWrapper.set(this._htmlCache, url, promise);
     }
     return promise;
   }
   throw new BaseException('Templates should have either their url or inline property set');
 }