repackaging: all the file moves

modules/@angular/http/src/backends/browser_jsonp.ts

@@ -0,0 +1,48 @@
+import {Injectable} from 'angular2/core';
+import {global} from 'angular2/src/facade/lang';
+
+let _nextRequestId = 0;
+export const JSONP_HOME = '__ng_jsonp__';
+var _jsonpConnections: {[key: string]: any} = null;
+
+function _getJsonpConnections(): {[key: string]: any} {
+  if (_jsonpConnections === null) {
+    _jsonpConnections = (<{[key: string]: any}>global)[JSONP_HOME] = {};
+  }
+  return _jsonpConnections;
+}
+
+// Make sure not to evaluate this in a non-browser environment!
+@Injectable()
+export class BrowserJsonp {
+  // Construct a <script> element with the specified URL
+  build(url: string): any {
+    let node = document.createElement('script');
+    node.src = url;
+    return node;
+  }
+
+  nextRequestID(): string { return `__req${_nextRequestId++}`; }
+
+  requestCallback(id: string): string { return `${JSONP_HOME}.${id}.finished`; }
+
+  exposeConnection(id: string, connection: any) {
+    let connections = _getJsonpConnections();
+    connections[id] = connection;
+  }
+
+  removeConnection(id: string) {
+    var connections = _getJsonpConnections();
+    connections[id] = null;
+  }
+
+  // Attach the <script> element to the DOM
+  send(node: any) { document.body.appendChild(<Node>(node)); }
+
+  // Remove <script> element from the DOM
+  cleanup(node: any) {
+    if (node.parentNode) {
+      node.parentNode.removeChild(<Node>(node));
+    }
+  }
+}

modules/@angular/http/src/backends/browser_xhr.ts

@@ -0,0 +1,12 @@
+import {Injectable} from 'angular2/core';
+
+/**
+ * A backend for http that uses the `XMLHttpRequest` browser API.
+ *
+ * Take care not to evaluate this in non-browser contexts.
+ */
+@Injectable()
+export class BrowserXhr {
+  constructor() {}
+  build(): any { return <any>(new XMLHttpRequest()); }
+}

modules/@angular/http/src/backends/jsonp_backend.ts

@@ -0,0 +1,148 @@
+import {ConnectionBackend, Connection} from '../interfaces';
+import {ReadyState, RequestMethod, ResponseType} from '../enums';
+import {Request} from '../static_request';
+import {Response} from '../static_response';
+import {ResponseOptions, BaseResponseOptions} from '../base_response_options';
+import {Injectable} from 'angular2/core';
+import {BrowserJsonp} from './browser_jsonp';
+import {makeTypeError} from 'angular2/src/facade/exceptions';
+import {StringWrapper, isPresent} from 'angular2/src/facade/lang';
+import {Observable} from 'rxjs/Observable';
+import {Observer} from 'rxjs/Observer';
+
+const JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';
+const JSONP_ERR_WRONG_METHOD = 'JSONP requests must use GET request method.';
+
+/**
+ * Abstract base class for an in-flight JSONP request.
+ */
+export abstract class JSONPConnection implements Connection {
+  /**
+   * The {@link ReadyState} of this request.
+   */
+  readyState: ReadyState;
+
+  /**
+   * The outgoing HTTP request.
+   */
+  request: Request;
+
+  /**
+   * An observable that completes with the response, when the request is finished.
+   */
+  response: Observable<Response>;
+
+  /**
+   * Callback called when the JSONP request completes, to notify the application
+   * of the new data.
+   */
+  abstract finished(data?: any): void;
+}
+
+export class JSONPConnection_ extends JSONPConnection {
+  private _id: string;
+  private _script: Element;
+  private _responseData: any;
+  private _finished: boolean = false;
+
+  constructor(req: Request, private _dom: BrowserJsonp,
+              private baseResponseOptions?: ResponseOptions) {
+    super();
+    if (req.method !== RequestMethod.Get) {
+      throw makeTypeError(JSONP_ERR_WRONG_METHOD);
+    }
+    this.request = req;
+    this.response = new Observable<Response>((responseObserver: Observer<Response>) => {
+
+      this.readyState = ReadyState.Loading;
+      let id = this._id = _dom.nextRequestID();
+
+      _dom.exposeConnection(id, this);
+
+      // Workaround Dart
+      // url = url.replace(/=JSONP_CALLBACK(&|$)/, `generated method`);
+      let callback = _dom.requestCallback(this._id);
+      let url: string = req.url;
+      if (url.indexOf('=JSONP_CALLBACK&') > -1) {
+        url = StringWrapper.replace(url, '=JSONP_CALLBACK&', `=${callback}&`);
+      } else if (url.lastIndexOf('=JSONP_CALLBACK') === url.length - '=JSONP_CALLBACK'.length) {
+        url = url.substring(0, url.length - '=JSONP_CALLBACK'.length) + `=${callback}`;
+      }
+
+      let script = this._script = _dom.build(url);
+
+      let onLoad = (event: Event) => {
+        if (this.readyState === ReadyState.Cancelled) return;
+        this.readyState = ReadyState.Done;
+        _dom.cleanup(script);
+        if (!this._finished) {
+          let responseOptions =
+              new ResponseOptions({body: JSONP_ERR_NO_CALLBACK, type: ResponseType.Error, url});
+          if (isPresent(baseResponseOptions)) {
+            responseOptions = baseResponseOptions.merge(responseOptions);
+          }
+          responseObserver.error(new Response(responseOptions));
+          return;
+        }
+
+        let responseOptions = new ResponseOptions({body: this._responseData, url});
+        if (isPresent(this.baseResponseOptions)) {
+          responseOptions = this.baseResponseOptions.merge(responseOptions);
+        }
+
+        responseObserver.next(new Response(responseOptions));
+        responseObserver.complete();
+      };
+
+      let onError = (error: Error) => {
+        if (this.readyState === ReadyState.Cancelled) return;
+        this.readyState = ReadyState.Done;
+        _dom.cleanup(script);
+        let responseOptions = new ResponseOptions({body: error.message, type: ResponseType.Error});
+        if (isPresent(baseResponseOptions)) {
+          responseOptions = baseResponseOptions.merge(responseOptions);
+        }
+        responseObserver.error(new Response(responseOptions));
+      };
+
+      script.addEventListener('load', onLoad);
+      script.addEventListener('error', onError);
+
+      _dom.send(script);
+
+      return () => {
+        this.readyState = ReadyState.Cancelled;
+        script.removeEventListener('load', onLoad);
+        script.removeEventListener('error', onError);
+        if (isPresent(script)) {
+          this._dom.cleanup(script);
+        }
+
+      };
+    });
+  }
+
+  finished(data?: any) {
+    // Don't leak connections
+    this._finished = true;
+    this._dom.removeConnection(this._id);
+    if (this.readyState === ReadyState.Cancelled) return;
+    this._responseData = data;
+  }
+}
+
+/**
+ * A {@link ConnectionBackend} that uses the JSONP strategy of making requests.
+ */
+export abstract class JSONPBackend extends ConnectionBackend {}
+
+@Injectable()
+export class JSONPBackend_ extends JSONPBackend {
+  constructor(private _browserJSONP: BrowserJsonp, private _baseResponseOptions: ResponseOptions) {
+    super();
+  }
+
+  createConnection(request: Request): JSONPConnection {
+    return new JSONPConnection_(request, this._browserJSONP, this._baseResponseOptions);
+  }
+}

modules/@angular/http/src/backends/xhr_backend.ts

@@ -0,0 +1,127 @@
+import {ConnectionBackend, Connection} from '../interfaces';
+import {ReadyState, RequestMethod, ResponseType} from '../enums';
+import {Request} from '../static_request';
+import {Response} from '../static_response';
+import {Headers} from '../headers';
+import {ResponseOptions, BaseResponseOptions} from '../base_response_options';
+import {Injectable} from 'angular2/core';
+import {BrowserXhr} from './browser_xhr';
+import {isPresent} from 'angular2/src/facade/lang';
+import {Observable} from 'rxjs/Observable';
+import {Observer} from 'rxjs/Observer';
+import {isSuccess, getResponseURL} from '../http_utils';
+
+/**
+* Creates connections using `XMLHttpRequest`. Given a fully-qualified
+* request, an `XHRConnection` will immediately create an `XMLHttpRequest` object and send the
+* request.
+*
+* This class would typically not be created or interacted with directly inside applications, though
+* the {@link MockConnection} may be interacted with in tests.
+*/
+export class XHRConnection implements Connection {
+  request: Request;
+  /**
+   * Response {@link EventEmitter} which emits a single {@link Response} value on load event of
+   * `XMLHttpRequest`.
+   */
+  response: Observable<Response>;
+  readyState: ReadyState;
+  constructor(req: Request, browserXHR: BrowserXhr, baseResponseOptions?: ResponseOptions) {
+    this.request = req;
+    this.response = new Observable<Response>((responseObserver: Observer<Response>) => {
+      let _xhr: XMLHttpRequest = browserXHR.build();
+      _xhr.open(RequestMethod[req.method].toUpperCase(), req.url);
+      // load event handler
+      let onLoad = () => {
+        // 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)
+        let body = isPresent(_xhr.response) ? _xhr.response : _xhr.responseText;
+
+        let headers = Headers.fromResponseHeaderString(_xhr.getAllResponseHeaders());
+
+        let url = getResponseURL(_xhr);
+
+        // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
+        let status: number = _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 = body ? 200 : 0;
+        }
+        var responseOptions = new ResponseOptions({body, status, headers, url});
+        if (isPresent(baseResponseOptions)) {
+          responseOptions = baseResponseOptions.merge(responseOptions);
+        }
+        let response = new Response(responseOptions);
+        if (isSuccess(status)) {
+          responseObserver.next(response);
+          // TODO(gdi2290): defer complete if array buffer until done
+          responseObserver.complete();
+          return;
+        }
+        responseObserver.error(response);
+      };
+      // error event handler
+      let onError = (err: any) => {
+        var responseOptions = new ResponseOptions({body: err, type: ResponseType.Error});
+        if (isPresent(baseResponseOptions)) {
+          responseOptions = baseResponseOptions.merge(responseOptions);
+        }
+        responseObserver.error(new Response(responseOptions));
+      };
+
+      if (isPresent(req.headers)) {
+        req.headers.forEach((values, name) => _xhr.setRequestHeader(name, values.join(',')));
+      }
+
+      _xhr.addEventListener('load', onLoad);
+      _xhr.addEventListener('error', onError);
+
+      _xhr.send(this.request.text());
+
+      return () => {
+        _xhr.removeEventListener('load', onLoad);
+        _xhr.removeEventListener('error', onError);
+        _xhr.abort();
+      };
+    });
+  }
+}
+
+/**
+ * Creates {@link XHRConnection} instances.
+ *
+ * This class would typically not be used by end users, but could be
+ * overridden if a different backend implementation should be used,
+ * such as in a node backend.
+ *
+ * ### Example
+ *
+ * ```
+ * import {Http, MyNodeBackend, HTTP_PROVIDERS, BaseRequestOptions} from 'angular2/http';
+ * @Component({
+ *   viewProviders: [
+ *     HTTP_PROVIDERS,
+ *     provide(Http, {useFactory: (backend, options) => {
+ *       return new Http(backend, options);
+ *     }, deps: [MyNodeBackend, BaseRequestOptions]})]
+ * })
+ * class MyComponent {
+ *   constructor(http:Http) {
+ *     http.request('people.json').subscribe(res => this.people = res.json());
+ *   }
+ * }
+ * ```
+ *
+ **/
+@Injectable()
+export class XHRBackend implements ConnectionBackend {
+  constructor(private _browserXHR: BrowserXhr, private _baseResponseOptions: ResponseOptions) {}
+  createConnection(request: Request): XHRConnection {
+    return new XHRConnection(request, this._browserXHR, this._baseResponseOptions);
+  }
+}