TypeScript promise.PromiseWrapper类代码示例

  get(url: string): Promise<string> {
    var completer: PromiseCompleter < string >= PromiseWrapper.completer();
    var xhr = new XMLHttpRequest();
    xhr.open('GET', url, true);
    xhr.responseType = 'text';

    xhr.onload = function() {
      // responseText is the old-school way of retrieving response (supported by IE8 & 9)
      // response/responseType properties were introduced in XHR Level2 spec (supported by IE10)
      var response = isPresent(xhr.response) ? xhr.response : xhr.responseText;

      // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
      var status = xhr.status === 1223 ? 204 : xhr.status;

      // fix status code when it is 0 (0 status is undocumented).
      // Occurs when accessing file resources or on Android 4.1 stock browser
      // while retrieving files from application cache.
      if (status === 0) {
        status = response ? 200 : 0;
      }

      if (200 <= status && status <= 300) {
        completer.resolve(response);
      } else {
        completer.reject(`Failed to load ${url}`, null);
      }
    };

    xhr.onerror = function() { completer.reject(`Failed to load ${url}`, null); };

    xhr.send();
    return completer.promise;
  }

  get(templateUrl: string): Promise<string> {
    let completer: PromiseCompleter<string> = PromiseWrapper.completer(),
      parsedUrl = url.parse(templateUrl);

    http.get(templateUrl, (res) => {
      res.setEncoding('utf8');

      // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
      var status = res.statusCode === 1223 ? 204 : res.statusCode;

      if (200 <= status && status <= 300) {
        let data = '';

        res.on('data', (chunk) => {
          data += chunk;
        });
        res.on('end', () => {
          completer.resolve(data);
        });

      } else {
        completer.reject(`Failed to load ${templateUrl}`, null);
      }

      // consume response body
      res.resume();
    }).on('error', (e) => {
      completer.reject(`Failed to load ${templateUrl}`, null);
    });

    return completer.promise;
  }

  get(templateUrl: string): Promise<string> {
    const completer: PromiseCompleter<string> = PromiseWrapper.completer();
    const parsedUrl = url.parse(templateUrl);

    http.get(parsedUrl, (res) => {
      res.setEncoding('utf8');

      const status = res.statusCode;

      if (200 <= status && status <= 300) {
        let data = '';

        res.on('data', (chunk) => {
          data += chunk;
        });
        res.on('end', () => {
          completer.resolve(data);
        });

      } else {
        completer.reject(`Failed to load ${templateUrl}`, null);
      }

      // consume response body
      res.resume();
    }).on('error', (e) => {
      completer.reject(`Failed to load ${templateUrl}`, null);
    });

    return completer.promise;
  }

  getToken(): Promise<string> {
    if (this.localStorage.get('VP_TOKEN')) {
      return PromiseWrapper.resolve(this.localStorage.get('VP_TOKEN'));
    }

    return this.sqlStorage.get('VP_TOKEN');
  }

        return (c) => {
          var emitter = new EventEmitter();
          var res = c.value != expected ? response : null;

          PromiseWrapper.scheduleMicrotask(() => {
            ObservableWrapper.callEmit(emitter, res);
            // this is required because of a bug in ObservableWrapper
            // where callComplete can fire before callEmit
            // remove this one the bug is fixed
            TimerWrapper.setTimeout(() => { ObservableWrapper.callComplete(emitter); }, 0);
          });
          return emitter;
        };

function _recognize(componentResolver: ComponentResolver, type: Type, url: Tree<UrlSegment>,
                    current: UrlSegment): Promise<RouteSegment[]> {
  let metadata = _readMetadata(type);  // should read from the factory instead

  let matched;
  try {
    matched = _match(metadata, url, current);
  } catch (e) {
    return PromiseWrapper.reject(e, null);
  }

  return componentResolver.resolveComponent(matched.route.component)
      .then(factory => {
        let segment = new RouteSegment(matched.consumedUrlSegments, matched.parameters, "",
                                       matched.route.component, factory);

        if (isPresent(matched.leftOver)) {
          return _recognize(componentResolver, matched.route.component, url, matched.leftOver)
              .then(children => [segment].concat(children));
        } else {
          return [segment];
        }
      });
}

function recognize(recognizer: RuleSet, url: string): Promise<RouteMatch[]> {
  var parsedUrl = parser.parse(url);
  return PromiseWrapper.all(recognizer.recognize(parsedUrl));
}

function _convertToPromise(obj: any): any {
  return PromiseWrapper.isPromise(obj) ? obj : ObservableWrapper.toPromise(obj);
}

 return function(control: modelModule.AbstractControl) {
   let promises = _executeAsyncValidators(control, presentValidators).map(_convertToPromise);
   return PromiseWrapper.all(promises).then(_mergeErrors);
 };

 function asyncValidator(_) { return PromiseWrapper.resolve(null); }