TypeScript PromiseWrapper.then方法代码示例

  load(template: ViewDefinition): Promise</*element*/ any> {
    if (isPresent(template.template)) {
      return PromiseWrapper.resolve(DOM.createTemplate(template.template));
    }
    var url = template.absUrl;
    if (isPresent(url)) {
      var promise = StringMapWrapper.get(this._htmlCache, url);

      if (isBlank(promise)) {
        // TODO(vicb): change error when TS gets fixed
        // https://github.com/angular/angular/issues/2280
        // throw new BaseException(`Failed to fetch url "${url}"`);
        promise = PromiseWrapper.then(this._xhr.get(url), html => {
          var template = DOM.createTemplate(html);
          return template;
        }, _ => PromiseWrapper.reject(new BaseException(`Failed to fetch url "${url}"`), null));

        StringMapWrapper.set(this._htmlCache, url, promise);
      }

      // We need to clone the result as others might change it
      // (e.g. the compiler).
      return promise.then((tplElement) => DOM.clone(tplElement));
    }

    throw new BaseException('View should have either the url or template property set');
  }

  zone.run(() => {
    // TODO(rado): prepopulate template cache, so applications with only
    // index.html and main.js are possible.

    var appInjector = _createAppInjector(appComponentType, componentInjectableBindings, zone);

    //TODO: get rid of the test bindings
    var renderer = appInjector.get(Renderer);
    var loader = appInjector.get(TemplateLoader);
    var inliner = appInjector.get(StyleInliner);
    //var loader = appInjector.get(DynamicComponentLoader);
    console.log(loader);

    PromiseWrapper.then(
        appInjector.asyncGet(appComponentRefToken),
        (componentRef) =>
        {
            var appChangeDetector = internalView(componentRef.hostView).changeDetector;
            // retrieve life cycle: may have already been created if injected in root component
            var lc = appInjector.get(LifeCycle);
            lc.registerWith(zone, appChangeDetector);
            lc.tick();  // the first tick that will bootstrap the app

            bootstrapProcess.resolve(new ApplicationRef(componentRef, appComponentType, appInjector));
        },

        (err, stackTrace) => {bootstrapProcess.reject(err, stackTrace)}
    );
  });

 function expectResponse(request, url, response, done = null) {
   function onResponse(text) {
     if (response === null) {
       throw `Unexpected response ${url} -> ${text}`;
     } else {
       expect(text).toEqual(response);
       if (isPresent(done))
         done();
     }
   }
   Object.defineProperty(onResponse, "parameters", {get: function() {
       return [[assert.type.string]];
     }});
   function onError(error) {
     if (response !== null) {
       throw `Unexpected error ${url}`;
     } else {
       expect(error).toEqual(`Failed to load ${url}`);
       if (isPresent(done))
         done();
     }
   }
   Object.defineProperty(onError, "parameters", {get: function() {
       return [[assert.type.string]];
     }});
   PromiseWrapper.then(request, onResponse, onError);
 }

 compile(view: ViewDefinition): Promise<ProtoViewDto> {
   var tplPromise = this._viewLoader.load(view);
   return PromiseWrapper.then(
       tplPromise, (el) => this._compileTemplate(view, el, ViewType.COMPONENT), (e) => {
         throw new BaseException(`Failed to load the template for "${view.componentId}" : ${e}`);
       });
 }

 compile(template: ViewDefinition):Promise<ProtoViewDto> {
   var tplPromise = this._templateLoader.load(template);
   return PromiseWrapper.then(tplPromise,
     (el) => this._compileTemplate(template, el),
     (_) => { throw new BaseException(`Failed to load the template "${template.componentId}"`); }
   );
 }

  _inlineImports(cssText: string, baseUrl: string,
                 inlinedUrls: List<string>): SyncAsyncResult<string> {
    var partIndex = 0;
    var parts = StringWrapper.split(cssText, _importRe);

    if (parts.length === 1) {
      // no @import rule found, return the original css
      return new SyncAsyncResult(cssText, null);
    }

    var promises = [];

    while (partIndex < parts.length - 1) {
      // prefix is the content before the @import rule
      var prefix = parts[partIndex];
      // rule is the parameter of the @import rule
      var rule = parts[partIndex + 1];
      var url = _extractUrl(rule);
      if (isPresent(url)) {
        url = this._urlResolver.resolve(baseUrl, url);
      }
      var mediaQuery = _extractMediaQuery(rule);
      var promise;

      if (isBlank(url)) {
        promise = PromiseWrapper.resolve(`/* Invalid import rule: "@import ${rule};" */`);
      } else if (ListWrapper.contains(inlinedUrls, url)) {
        // The current import rule has already been inlined, return the prefix only
        // Importing again might cause a circular dependency
        promise = PromiseWrapper.resolve(prefix);
      } else {
        ListWrapper.push(inlinedUrls, url);
        promise = PromiseWrapper.then(this._xhr.get(url), (rawCss) => {
          // resolve nested @import rules
          var inlinedCss = this._inlineImports(rawCss, url, inlinedUrls);
          if (isPresent(inlinedCss.asyncResult)) {
            // wait until nested @import are inlined
            return inlinedCss.asyncResult.then(
                (css) => {return prefix + this._transformImportedCss(css, mediaQuery, url) + '\n'});
          } else {
            // there are no nested @import, return the css
            return prefix + this._transformImportedCss(inlinedCss.syncResult, mediaQuery, url) +
                   '\n';
          }
        }, (error) => `/* failed to import ${url} */\n`);
      }
      ListWrapper.push(promises, promise);
      partIndex += 2;
    }

    return new SyncAsyncResult(null, PromiseWrapper.all(promises).then(function(cssParts) {
      var cssText = cssParts.join('');
      if (partIndex < parts.length) {
        // append then content located after the last @import rule
        cssText += parts[partIndex];
      }
      return cssText;
    }));
  }

 it('should throw if no Template found', inject([AsyncTestCompleter], (async) => {
   var injectorPromise = bootstrap(HelloRootMissingTemplate, testBindings, (e, t) => {
     throw e;
   });
   PromiseWrapper.then(injectorPromise, null, (reason) => {
     expect(reason.message).toContain('No template found for HelloRootMissingTemplate');
     async.done();
   });
 }));

 function expectCompileError(inlineTpl, errMessage, done) {
   tplResolver.setTemplate(MyComp, new Template({inline: inlineTpl}));
   PromiseWrapper.then(compiler.compile(MyComp), (value) => {
     throw new BaseException("Test failure: should not have come here as an exception was expected");
   }, (err) => {
     expect(err.message).toEqual(errMessage);
     done();
   });
 }