@angular/http
Version:
Angular - the http service
234 lines • 21.8 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { Body } from './body';
import { ContentType } from './enums';
import { Headers } from './headers';
import { normalizeMethodName } from './http_utils';
import { URLSearchParams } from './url_search_params';
// TODO(jeffbcross): properly implement body accessors
/**
* Creates `Request` instances from provided values.
*
* The Request's interface is inspired by the Request constructor defined in the [Fetch
* Spec](https://fetch.spec.whatwg.org/#request-class),
* but is considered a static value whose body can be accessed many times. There are other
* differences in the implementation, but this is the most significant.
*
* `Request` instances are typically created by higher-level classes, like {\@link Http} and
* {\@link Jsonp}, but it may occasionally be useful to explicitly create `Request` instances.
* One such example is when creating services that wrap higher-level services, like {\@link Http},
* where it may be useful to generate a `Request` with arbitrary headers and search params.
*
* ```typescript
* import {Injectable, Injector} from '\@angular/core';
* import {HTTP_PROVIDERS, Http, Request, RequestMethod} from '\@angular/http';
*
* \@Injectable()
* class AutoAuthenticator {
* constructor(public http:Http) {}
* request(url:string) {
* return this.http.request(new Request({
* method: RequestMethod.Get,
* url: url,
* search: 'password=123'
* }));
* }
* }
*
* var injector = Injector.resolveAndCreate([HTTP_PROVIDERS, AutoAuthenticator]);
* var authenticator = injector.get(AutoAuthenticator);
* authenticator.request('people.json').subscribe(res => {
* //URL should have included '?password=123'
* console.log('people', res.json());
* });
* ```
*
* @deprecated see https://angular.io/guide/http
* \@publicApi
*/
export class Request extends Body {
/**
* @param {?} requestOptions
*/
constructor(requestOptions) {
super();
// TODO: assert that url is present
/** @type {?} */
const url = requestOptions.url;
this.url = (/** @type {?} */ (requestOptions.url));
/** @type {?} */
const paramsArg = requestOptions.params || requestOptions.search;
if (paramsArg) {
/** @type {?} */
let params;
if (typeof paramsArg === 'object' && !(paramsArg instanceof URLSearchParams)) {
params = urlEncodeParams(paramsArg).toString();
}
else {
params = paramsArg.toString();
}
if (params.length > 0) {
/** @type {?} */
let prefix = '?';
if (this.url.indexOf('?') != -1) {
prefix = (this.url[this.url.length - 1] == '&') ? '' : '&';
}
// TODO: just delete search-query-looking string in url?
this.url = url + prefix + params;
}
}
this._body = requestOptions.body;
this.method = normalizeMethodName((/** @type {?} */ (requestOptions.method)));
// TODO(jeffbcross): implement behavior
// Defaults to 'omit', consistent with browser
this.headers = new Headers(requestOptions.headers);
this.contentType = this.detectContentType();
this.withCredentials = (/** @type {?} */ (requestOptions.withCredentials));
this.responseType = (/** @type {?} */ (requestOptions.responseType));
}
/**
* Returns the content type enum based on header options.
* @return {?}
*/
detectContentType() {
switch (this.headers.get('content-type')) {
case 'application/json':
return ContentType.JSON;
case 'application/x-www-form-urlencoded':
return ContentType.FORM;
case 'multipart/form-data':
return ContentType.FORM_DATA;
case 'text/plain':
case 'text/html':
return ContentType.TEXT;
case 'application/octet-stream':
return this._body instanceof ArrayBuffer ? ContentType.ARRAY_BUFFER : ContentType.BLOB;
default:
return this.detectContentTypeFromBody();
}
}
/**
* Returns the content type of request's body based on its type.
* @return {?}
*/
detectContentTypeFromBody() {
if (this._body == null) {
return ContentType.NONE;
}
else if (this._body instanceof URLSearchParams) {
return ContentType.FORM;
}
else if (this._body instanceof FormData) {
return ContentType.FORM_DATA;
}
else if (this._body instanceof Blob) {
return ContentType.BLOB;
}
else if (this._body instanceof ArrayBuffer) {
return ContentType.ARRAY_BUFFER;
}
else if (this._body && typeof this._body === 'object') {
return ContentType.JSON;
}
else {
return ContentType.TEXT;
}
}
/**
* Returns the request's body according to its type. If body is undefined, return
* null.
* @return {?}
*/
getBody() {
switch (this.contentType) {
case ContentType.JSON:
return this.text();
case ContentType.FORM:
return this.text();
case ContentType.FORM_DATA:
return this._body;
case ContentType.TEXT:
return this.text();
case ContentType.BLOB:
return this.blob();
case ContentType.ARRAY_BUFFER:
return this.arrayBuffer();
default:
return null;
}
}
}
if (false) {
/**
* Http method with which to perform the request.
* @type {?}
*/
Request.prototype.method;
/**
* {\@link Headers} instance
* @type {?}
*/
Request.prototype.headers;
/**
* Url of the remote resource
* @type {?}
*/
Request.prototype.url;
/**
* Type of the request body *
* @type {?}
* @private
*/
Request.prototype.contentType;
/**
* Enable use credentials
* @type {?}
*/
Request.prototype.withCredentials;
/**
* Buffer to store the response
* @type {?}
*/
Request.prototype.responseType;
}
/**
* @param {?} params
* @return {?}
*/
function urlEncodeParams(params) {
/** @type {?} */
const searchParams = new URLSearchParams();
Object.keys(params).forEach(key => {
/** @type {?} */
const value = params[key];
if (value && Array.isArray(value)) {
value.forEach(element => searchParams.append(key, element.toString()));
}
else {
searchParams.append(key, value.toString());
}
});
return searchParams;
}
/** @type {?} */
const noop = function () { };
const ɵ0 = noop;
/** @type {?} */
const w = typeof window == 'object' ? window : noop;
/** @type {?} */
const FormData = ((/** @type {?} */ (w)))['FormData'] || noop;
/** @type {?} */
const Blob = ((/** @type {?} */ (w)))['Blob'] || noop;
/** @type {?} */
export const ArrayBuffer = ((/** @type {?} */ (w)))['ArrayBuffer'] || noop;
export { ɵ0 };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"static_request.js","sourceRoot":"","sources":["../../../../../../packages/http/src/static_request.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Body} from './body';\nimport {ContentType, RequestMethod, ResponseContentType} from './enums';\nimport {Headers} from './headers';\nimport {normalizeMethodName} from './http_utils';\nimport {RequestArgs} from './interfaces';\nimport {URLSearchParams} from './url_search_params';\n\n\n// TODO(jeffbcross): properly implement body accessors\n/**\n * Creates `Request` instances from provided values.\n *\n * The Request's interface is inspired by the Request constructor defined in the [Fetch\n * Spec](https://fetch.spec.whatwg.org/#request-class),\n * but is considered a static value whose body can be accessed many times. There are other\n * differences in the implementation, but this is the most significant.\n *\n * `Request` instances are typically created by higher-level classes, like {@link Http} and\n * {@link Jsonp}, but it may occasionally be useful to explicitly create `Request` instances.\n * One such example is when creating services that wrap higher-level services, like {@link Http},\n * where it may be useful to generate a `Request` with arbitrary headers and search params.\n *\n * ```typescript\n * import {Injectable, Injector} from '@angular/core';\n * import {HTTP_PROVIDERS, Http, Request, RequestMethod} from '@angular/http';\n *\n * @Injectable()\n * class AutoAuthenticator {\n *   constructor(public http:Http) {}\n *   request(url:string) {\n *     return this.http.request(new Request({\n *       method: RequestMethod.Get,\n *       url: url,\n *       search: 'password=123'\n *     }));\n *   }\n * }\n *\n * var injector = Injector.resolveAndCreate([HTTP_PROVIDERS, AutoAuthenticator]);\n * var authenticator = injector.get(AutoAuthenticator);\n * authenticator.request('people.json').subscribe(res => {\n *   //URL should have included '?password=123'\n *   console.log('people', res.json());\n * });\n * ```\n *\n * @deprecated see https://angular.io/guide/http\n * @publicApi\n */\nexport class Request extends Body {\n  /**\n   * Http method with which to perform the request.\n   */\n  method: RequestMethod;\n  /**\n   * {@link Headers} instance\n   */\n  headers: Headers;\n  /** Url of the remote resource */\n  url: string;\n  /** Type of the request body **/\n  private contentType: ContentType;\n  /** Enable use credentials */\n  withCredentials: boolean;\n  /** Buffer to store the response */\n  responseType: ResponseContentType;\n  constructor(requestOptions: RequestArgs) {\n    super();\n    // TODO: assert that url is present\n    const url = requestOptions.url;\n    this.url = requestOptions.url !;\n    const paramsArg = requestOptions.params || requestOptions.search;\n    if (paramsArg) {\n      let params: string;\n      if (typeof paramsArg === 'object' && !(paramsArg instanceof URLSearchParams)) {\n        params = urlEncodeParams(paramsArg).toString();\n      } else {\n        params = paramsArg.toString();\n      }\n      if (params.length > 0) {\n        let prefix = '?';\n        if (this.url.indexOf('?') != -1) {\n          prefix = (this.url[this.url.length - 1] == '&') ? '' : '&';\n        }\n        // TODO: just delete search-query-looking string in url?\n        this.url = url + prefix + params;\n      }\n    }\n    this._body = requestOptions.body;\n    this.method = normalizeMethodName(requestOptions.method !);\n    // TODO(jeffbcross): implement behavior\n    // Defaults to 'omit', consistent with browser\n    this.headers = new Headers(requestOptions.headers);\n    this.contentType = this.detectContentType();\n    this.withCredentials = requestOptions.withCredentials !;\n    this.responseType = requestOptions.responseType !;\n  }\n\n  /**\n   * Returns the content type enum based on header options.\n   */\n  detectContentType(): ContentType {\n    switch (this.headers.get('content-type')) {\n      case 'application/json':\n        return ContentType.JSON;\n      case 'application/x-www-form-urlencoded':\n        return ContentType.FORM;\n      case 'multipart/form-data':\n        return ContentType.FORM_DATA;\n      case 'text/plain':\n      case 'text/html':\n        return ContentType.TEXT;\n      case 'application/octet-stream':\n        return this._body instanceof ArrayBuffer ? ContentType.ARRAY_BUFFER : ContentType.BLOB;\n      default:\n        return this.detectContentTypeFromBody();\n    }\n  }\n\n  /**\n   * Returns the content type of request's body based on its type.\n   */\n  detectContentTypeFromBody(): ContentType {\n    if (this._body == null) {\n      return ContentType.NONE;\n    } else if (this._body instanceof URLSearchParams) {\n      return ContentType.FORM;\n    } else if (this._body instanceof FormData) {\n      return ContentType.FORM_DATA;\n    } else if (this._body instanceof Blob) {\n      return ContentType.BLOB;\n    } else if (this._body instanceof ArrayBuffer) {\n      return ContentType.ARRAY_BUFFER;\n    } else if (this._body && typeof this._body === 'object') {\n      return ContentType.JSON;\n    } else {\n      return ContentType.TEXT;\n    }\n  }\n\n  /**\n   * Returns the request's body according to its type. If body is undefined, return\n   * null.\n   */\n  getBody(): any {\n    switch (this.contentType) {\n      case ContentType.JSON:\n        return this.text();\n      case ContentType.FORM:\n        return this.text();\n      case ContentType.FORM_DATA:\n        return this._body;\n      case ContentType.TEXT:\n        return this.text();\n      case ContentType.BLOB:\n        return this.blob();\n      case ContentType.ARRAY_BUFFER:\n        return this.arrayBuffer();\n      default:\n        return null;\n    }\n  }\n}\n\nfunction urlEncodeParams(params: {[key: string]: any}): URLSearchParams {\n  const searchParams = new URLSearchParams();\n  Object.keys(params).forEach(key => {\n    const value = params[key];\n    if (value && Array.isArray(value)) {\n      value.forEach(element => searchParams.append(key, element.toString()));\n    } else {\n      searchParams.append(key, value.toString());\n    }\n  });\n  return searchParams;\n}\n\nconst noop = function() {};\nconst w = typeof window == 'object' ? window : noop;\nconst FormData = (w as any /** TODO #9100 */)['FormData'] || noop;\nconst Blob = (w as any /** TODO #9100 */)['Blob'] || noop;\nexport const ArrayBuffer: ArrayBufferConstructor =\n    (w as any /** TODO #9100 */)['ArrayBuffer'] || noop;\n"]}