@angular-wave/angular.ts 0.0.65 → 0.0.67

package/src/services/http/http.js

@@ -23,6 +23,7 @@ import {
   uppercase,
   isPromiseLike,
 } from "../../shared/utils";
+import { getCookies } from "../cookie-reader";
 
 const APPLICATION_JSON = "application/json";
 const CONTENT_TYPE_APPLICATION_JSON = {
@@ -43,23 +44,18 @@ function serializeValue(v) {
   return v;
 }
 
+/**
+ * Default params serializer that converts objects to strings
+ * according to the following rules:
+ *
+ * * `{'foo': 'bar'}` results in `foo=bar`
+ * * `{'foo': Date.now()}` results in `foo=2015-04-01T09%3A50%3A49.262Z` (`toISOString()` and encoded representation of a Date object)
+ * * `{'foo': ['bar', 'baz']}` results in `foo=bar&foo=baz` (repeated key for each array element)
+ * * `{'foo': {'bar':'baz'}}` results in `foo=%7B%22bar%22%3A%22baz%22%7D` (stringified and encoded representation of an object)
+ *
+ * Note that serializer will sort the request parameters alphabetically.
+ */
 export function $HttpParamSerializerProvider() {
-  /**
-   * @ngdoc service
-   * @name $httpParamSerializer
-   * @description
-   *
-   * Default {@link $http `$http`} params serializer that converts objects to strings
-   * according to the following rules:
-   *
-   * * `{'foo': 'bar'}` results in `foo=bar`
-   * * `{'foo': Date.now()}` results in `foo=2015-04-01T09%3A50%3A49.262Z` (`toISOString()` and encoded representation of a Date object)
-   * * `{'foo': ['bar', 'baz']}` results in `foo=bar&foo=baz` (repeated key for each array element)
-   * * `{'foo': {'bar':'baz'}}` results in `foo=%7B%22bar%22%3A%22baz%22%7D` (stringified and encoded representation of an object)
-   *
-   * Note that serializer will sort the request parameters alphabetically.
-   */
-
   this.$get = function () {
     return function ngParamSerializer(params) {
       if (!params) return "";
@@ -67,7 +63,7 @@ export function $HttpParamSerializerProvider() {
       forEachSorted(params, (value, key) => {
         if (value === null || isUndefined(value) || isFunction(value)) return;
         if (Array.isArray(value)) {
-          forEach(value, (v) => {
+          value.forEach((v) => {
             parts.push(
               `${encodeUriQuery(key)}=${encodeUriQuery(serializeValue(v))}`,
             );
@@ -84,51 +80,47 @@ export function $HttpParamSerializerProvider() {
   };
 }
 
+/**
+ *
+ * Alternative {@link $http `$http`} params serializer that follows
+ * jQuery's [`param()`](http://api.jquery.com/jquery.param/) method logic.
+ * The serializer will also sort the params alphabetically.
+ *
+ * To use it for serializing `$http` request parameters, set it as the `paramSerializer` property:
+ *
+ * ```js
+ * $http({
+ *   url: myUrl,
+ *   method: 'GET',
+ *   params: myParams,
+ *   paramSerializer: '$httpParamSerializerJQLike'
+ * });
+ * ```
+ *
+ * It is also possible to set it as the default `paramSerializer` in the
+ * {@link $httpProvider#defaults `$httpProvider`}.
+ *
+ * Additionally, you can inject the serializer and use it explicitly, for example to serialize
+ * form data for submission:
+ *
+ * ```js
+ * .controller(function($http, $httpParamSerializerJQLike) {
+ *   //...
+ *
+ *   $http({
+ *     url: myUrl,
+ *     method: 'POST',
+ *     data: $httpParamSerializerJQLike(myData),
+ *     headers: {
+ *       'Content-Type': 'application/x-www-form-urlencoded'
+ *     }
+ *   });
+ *
+ * });
+ * ```
+ *
+ */
 export function $HttpParamSerializerJQLikeProvider() {
-  /**
-   * @ngdoc service
-   * @name $httpParamSerializerJQLike
-   *
-   * @description
-   *
-   * Alternative {@link $http `$http`} params serializer that follows
-   * jQuery's [`param()`](http://api.jquery.com/jquery.param/) method logic.
-   * The serializer will also sort the params alphabetically.
-   *
-   * To use it for serializing `$http` request parameters, set it as the `paramSerializer` property:
-   *
-   * ```js
-   * $http({
-   *   url: myUrl,
-   *   method: 'GET',
-   *   params: myParams,
-   *   paramSerializer: '$httpParamSerializerJQLike'
-   * });
-   * ```
-   *
-   * It is also possible to set it as the default `paramSerializer` in the
-   * {@link $httpProvider#defaults `$httpProvider`}.
-   *
-   * Additionally, you can inject the serializer and use it explicitly, for example to serialize
-   * form data for submission:
-   *
-   * ```js
-   * .controller(function($http, $httpParamSerializerJQLike) {
-   *   //...
-   *
-   *   $http({
-   *     url: myUrl,
-   *     method: 'POST',
-   *     data: $httpParamSerializerJQLike(myData),
-   *     headers: {
-   *       'Content-Type': 'application/x-www-form-urlencoded'
-   *     }
-   *   });
-   *
-   * });
-   * ```
-   *
-   */
   this.$get = function () {
     return function jQueryLikeParamSerializer(params) {
       if (!params) return "";
@@ -219,8 +211,7 @@ function parseHeaders(headers) {
   }
 
   if (isString(headers)) {
-    forEach(
-      headers.split("\n"),
+    headers.split("\n").forEach(
       /** @param {string} line */
       (line) => {
         i = line.indexOf(":");
@@ -308,10 +299,6 @@ function isSuccess(status) {
  */
 export function $HttpProvider() {
   /**
-   * @ngdoc property
-   * @name $httpProvider#defaults
-   * @description
-   *
    * Object containing default values for all {@link ng.$http $http} requests.
    *
    * - **`defaults.cache`** - {boolean|Object} - A boolean value or object created with
@@ -414,10 +401,6 @@ export function $HttpProvider() {
   };
 
   /**
-   * @ngdoc property
-   * @name $httpProvider#interceptors
-   * @description
-   *
    * Array containing service factories for all synchronous or asynchronous {@link ng.$http $http}
    * pre-processing of request or postprocessing of responses.
    *
@@ -429,10 +412,6 @@ export function $HttpProvider() {
   const interceptorFactories = (this.interceptors = []);
 
   /**
-   * @ngdoc property
-   * @name $httpProvider#xsrfTrustedOrigins
-   * @description
-   *
    * Array containing URLs whose origins are trusted to receive the XSRF token. See the
    * {@link ng.$http#security-considerations Security Considerations} sections for more details on
    * XSRF.
@@ -471,13 +450,6 @@ export function $HttpProvider() {
   const xsrfTrustedOrigins = (this.xsrfTrustedOrigins = []);
 
   /**
-   * @ngdoc property
-   * @name $httpProvider#xsrfWhitelistedOrigins
-   * @description
-   *
-   * @deprecated
-   * sinceVersion="1.8.1"
-   *
    * This property is deprecated. Use {@link $httpProvider#xsrfTrustedOrigins xsrfTrustedOrigins}
    * instead.
    */
@@ -493,16 +465,25 @@ export function $HttpProvider() {
   this.$get = [
     "$browser",
     "$httpBackend",
-    "$$cookieReader",
     "$cacheFactory",
     "$rootScope",
     "$q",
     "$injector",
     "$sce",
+    /**
+     *
+     * @param {*} $browser
+     * @param {*} $httpBackend
+     * @param {*} $cacheFactory
+     * @param {*} $rootScope
+     * @param {*} $q
+     * @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @param {*} $sce
+     * @returns
+     */
     function (
       $browser,
       $httpBackend,
-      $$cookieReader,
       $cacheFactory,
       $rootScope,
       $q,
@@ -525,7 +506,7 @@ export function $HttpProvider() {
        */
       const reversedInterceptors = [];
 
-      forEach(interceptorFactories, (interceptorFactory) => {
+      interceptorFactories.forEach((interceptorFactory) => {
         reversedInterceptors.unshift(
           isString(interceptorFactory)
             ? $injector.get(interceptorFactory)
@@ -539,478 +520,8 @@ export function $HttpProvider() {
       const urlIsAllowedOrigin = urlIsAllowedOriginFactory(xsrfTrustedOrigins);
 
       /**
-       * @ngdoc service
-       * @kind function
-       * @name $http
-       * @requires ng.$httpBackend
-       * @requires $cacheFactory
-       * @requires $rootScope
-       * @requires $q
-       * @requires $injector
-       *
-       * @description
-       * The `$http` service is a core AngularJS service that facilitates communication with the remote
-       * HTTP servers via the browser's [XMLHttpRequest](https://developer.mozilla.org/en/xmlhttprequest)
-       * object or via [JSONP](http://en.wikipedia.org/wiki/JSONP).
-       *
-       * For unit testing applications that use `$http` service, see
-       * {@link ngMock.$httpBackend $httpBackend mock}.
-       *
-       * For a higher level of abstraction, please check out the {@link ngResource.$resource
-       * $resource} service.
-       *
-       * The $http API is based on the {@link ng.$q deferred/promise APIs} exposed by
-       * the $q service. While for simple usage patterns this doesn't matter much, for advanced usage
-       * it is important to familiarize yourself with these APIs and the guarantees they provide.
-       *
-       *
-       * ## General usage
-       * The `$http` service is a function which takes a single argument — a {@link $http#usage configuration object} —
-       * that is used to generate an HTTP request and returns  a {@link ng.$q promise} that is
-       * resolved (request success) or rejected (request failure) with a
-       * {@link ng.$http#$http-returns response} object.
-       *
-       * ```js
-       *   // Simple GET request example:
-       *   $http({
-       *     method: 'GET',
-       *     url: '/someUrl'
-       *   }).then(function successCallback(response) {
-       *       // this callback will be called asynchronously
-       *       // when the response is available
-       *     }, function errorCallback(response) {
-       *       // called asynchronously if an error occurs
-       *       // or server returns response with an error status.
-       *     });
-       * ```
-       *
-       *
-       * ## Shortcut methods
-       *
-       * Shortcut methods are also available. All shortcut methods require passing in the URL, and
-       * request data must be passed in for POST/PUT requests. An optional config can be passed as the
-       * last argument.
-       *
-       * ```js
-       *   $http.get('/someUrl', config).then(successCallback, errorCallback);
-       *   $http.post('/someUrl', data, config).then(successCallback, errorCallback);
-       * ```
-       *
-       * Complete list of shortcut methods:
-       *
-       * - {@link ng.$http#get $http.get}
-       * - {@link ng.$http#head $http.head}
-       * - {@link ng.$http#post $http.post}
-       * - {@link ng.$http#put $http.put}
-       * - {@link ng.$http#delete $http.delete}
-       * - {@link ng.$http#patch $http.patch}
-       *
-       *
-       * ```
-       * $http.get(...);
-       * $httpBackend.flush();
-       * ```
-       *
-       * ## Setting HTTP Headers
-       *
-       * The $http service will automatically add certain HTTP headers to all requests. These defaults
-       * can be fully configured by accessing the `$httpProvider.defaults.headers` configuration
-       * object, which currently contains this default configuration:
-       *
-       * - `$httpProvider.defaults.headers.common` (headers that are common for all requests):
-       *   - <code>Accept: application/json, text/plain, \*&#65279;/&#65279;\*</code>
-       * - `$httpProvider.defaults.headers.post`: (header defaults for POST requests)
-       *   - `Content-Type: application/json`
-       * - `$httpProvider.defaults.headers.put` (header defaults for PUT requests)
-       *   - `Content-Type: application/json`
-       *
-       * To add or overwrite these defaults, simply add or remove a property from these configuration
-       * objects. To add headers for an HTTP method other than POST or PUT, simply add a new object
-       * with the lowercased HTTP method name as the key, e.g.
-       * `$httpProvider.defaults.headers.get = { 'My-Header' : 'value' }`.
-       *
-       * The defaults can also be set at runtime via the `$http.defaults` object in the same
-       * fashion. For example:
-       *
-       * ```
-       * module.run(function($http) {
-       *   $http.defaults.headers.common.Authorization = 'Basic YmVlcDpib29w';
-       * });
-       * ```
-       *
-       * In addition, you can supply a `headers` property in the config object passed when
-       * calling `$http(config)`, which overrides the defaults without changing them globally.
-       *
-       * To explicitly remove a header automatically added via $httpProvider.defaults.headers on a per request basis,
-       * Use the `headers` property, setting the desired header to `undefined`. For example:
-       *
-       * ```js
-       * let req = {
-       *  method: 'POST',
-       *  url: 'http://example.com',
-       *  headers: {
-       *    'Content-Type': undefined
-       *  },
-       *  data: { test: 'test' }
-       * }
-       *
-       * $http(req).then(function(){...}, function(){...});
-       * ```
-       *
-       * ## Transforming Requests and Responses
-       *
-       * Both requests and responses can be transformed using transformation functions: `transformRequest`
-       * and `transformResponse`. These properties can be a single function that returns
-       * the transformed value (`function(data, headersGetter, status)`) or an array of such transformation functions,
-       * which allows you to `push` or `unshift` a new transformation function into the transformation chain.
-       *
-       * <div class="alert alert-warning">
-       * **Note:** AngularJS does not make a copy of the `data` parameter before it is passed into the `transformRequest` pipeline.
-       * That means changes to the properties of `data` are not local to the transform function (since Javascript passes objects by reference).
-       * For example, when calling `$http.get(url, $scope.myObject)`, modifications to the object's properties in a transformRequest
-       * function will be reflected on the scope and in any templates where the object is data-bound.
-       * To prevent this, transform functions should have no side-effects.
-       * If you need to modify properties, it is recommended to make a copy of the data, or create new object to return.
-       * </div>
-       *
-       * ### Default Transformations
-       *
-       * The `$httpProvider` provider and `$http` service expose `defaults.transformRequest` and
-       * `defaults.transformResponse` properties. If a request does not provide its own transformations
-       * then these will be applied.
-       *
-       * You can augment or replace the default transformations by modifying these properties by adding to or
-       * replacing the array.
-       *
-       * AngularJS provides the following default transformations:
-       *
-       * Request transformations (`$httpProvider.defaults.transformRequest` and `$http.defaults.transformRequest`) is
-       * an array with one function that does the following:
-       *
-       * - If the `data` property of the request configuration object contains an object, serialize it
-       *   into JSON format.
-       *
-       * Response transformations (`$httpProvider.defaults.transformResponse` and `$http.defaults.transformResponse`) is
-       * an array with one function that does the following:
-       *
-       *  - If XSRF prefix is detected, strip it (see Security Considerations section below).
-       *  - If the `Content-Type` is `application/json` or the response looks like JSON,
-       *      deserialize it using a JSON parser.
-       *
-       *
-       * ### Overriding the Default Transformations Per Request
-       *
-       * If you wish to override the request/response transformations only for a single request then provide
-       * `transformRequest` and/or `transformResponse` properties on the configuration object passed
-       * into `$http`.
-       *
-       * Note that if you provide these properties on the config object the default transformations will be
-       * overwritten. If you wish to augment the default transformations then you must include them in your
-       * local transformation array.
-       *
-       * The following code demonstrates adding a new response transformation to be run after the default response
-       * transformations have been run.
-       *
-       * ```js
-       * function appendTransform(defaults, transform) {
-       *
-       *   // We can't guarantee that the default transformation is an array
-       *   defaults = angular.isArray(defaults) ? defaults : [defaults];
-       *
-       *   // Append the new transformation to the defaults
-       *   return defaults.concat(transform);
-       * }
-       *
-       * $http({
-       *   url: '...',
-       *   method: 'GET',
-       *   transformResponse: appendTransform($http.defaults.transformResponse, function(value) {
-       *     return doTransform(value);
-       *   })
-       * });
-       * ```
-       *
-       *
-       * ## Caching
-       *
-       * {@link ng.$http `$http`} responses are not cached by default. To enable caching, you must
-       * set the config.cache value or the default cache value to TRUE or to a cache object (created
-       * with {@link ng.$cacheFactory `$cacheFactory`}). If defined, the value of config.cache takes
-       * precedence over the default cache value.
-       *
-       * In order to:
-       *   * cache all responses - set the default cache value to TRUE or to a cache object
-       *   * cache a specific response - set config.cache value to TRUE or to a cache object
-       *
-       * If caching is enabled, but neither the default cache nor config.cache are set to a cache object,
-       * then the default `$cacheFactory("$http")` object is used.
-       *
-       * The default cache value can be set by updating the
-       * {@link ng.$http#defaults `$http.defaults.cache`} property or the
-       * {@link $httpProvider#defaults `$httpProvider.defaults.cache`} property.
-       *
-       * When caching is enabled, {@link ng.$http `$http`} stores the response from the server using
-       * the relevant cache object. The next time the same request is made, the response is returned
-       * from the cache without sending a request to the server.
-       *
-       * Take note that:
-       *
-       *   * Only GET and JSONP requests are cached.
-       *   * The cache key is the request URL including search parameters; headers are not considered.
-       *   * Cached responses are returned asynchronously, in the same way as responses from the server.
-       *   * If multiple identical requests are made using the same cache, which is not yet populated,
-       *     one request will be made to the server and remaining requests will return the same response.
-       *   * A cache-control header on the response does not affect if or how responses are cached.
-       *
-       *
-       * ## Interceptors
-       *
-       * Before you start creating interceptors, be sure to understand the
-       * {@link ng.$q $q and deferred/promise APIs}.
-       *
-       * For purposes of global error handling, authentication, or any kind of synchronous or
-       * asynchronous pre-processing of request or postprocessing of responses, it is desirable to be
-       * able to intercept requests before they are handed to the server and
-       * responses before they are handed over to the application code that
-       * initiated these requests. The interceptors leverage the {@link ng.$q
-       * promise APIs} to fulfill this need for both synchronous and asynchronous pre-processing.
-       *
-       * The interceptors are service factories that are registered with the `$httpProvider` by
-       * adding them to the `$httpProvider.interceptors` array. The factory is called and
-       * injected with dependencies (if specified) and returns the interceptor.
-       *
-       * There are two kinds of interceptors (and two kinds of rejection interceptors):
-       *
-       *   * `request`: interceptors get called with a http {@link $http#usage config} object. The function is free to
-       *     modify the `config` object or create a new one. The function needs to return the `config`
-       *     object directly, or a promise containing the `config` or a new `config` object.
-       *   * `requestError`: interceptor gets called when a previous interceptor threw an error or
-       *     resolved with a rejection.
-       *   * `response`: interceptors get called with http `response` object. The function is free to
-       *     modify the `response` object or create a new one. The function needs to return the `response`
-       *     object directly, or as a promise containing the `response` or a new `response` object.
-       *   * `responseError`: interceptor gets called when a previous interceptor threw an error or
-       *     resolved with a rejection.
-       *
-       *
-       * ```js
-       *   // register the interceptor as a service
-       *   $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {
-       *     return {
-       *       // optional method
-       *       'request': function(config) {
-       *         // do something on success
-       *         return config;
-       *       },
-       *
-       *       // optional method
-       *      'requestError': function(rejection) {
-       *         // do something on error
-       *         if (canRecover(rejection)) {
-       *           return responseOrNewPromise
-       *         }
-       *         return $q.reject(rejection);
-       *       },
-       *
-       *
-       *
-       *       // optional method
-       *       'response': function(response) {
-       *         // do something on success
-       *         return response;
-       *       },
-       *
-       *       // optional method
-       *      'responseError': function(rejection) {
-       *         // do something on error
-       *         if (canRecover(rejection)) {
-       *           return responseOrNewPromise
-       *         }
-       *         return $q.reject(rejection);
-       *       }
-       *     };
-       *   });
-       *
-       *   $httpProvider.interceptors.push('myHttpInterceptor');
-       *
-       *
-       *   // alternatively, register the interceptor via an anonymous factory
-       *   $httpProvider.interceptors.push(function($q, dependency1, dependency2) {
-       *     return {
-       *      'request': function(config) {
-       *          // same as above
-       *       },
-       *
-       *       'response': function(response) {
-       *          // same as above
-       *       }
-       *     };
-       *   });
-       * ```
-       *
-       * ## Security Considerations
-       *
-       * When designing web applications, consider security threats from:
-       *
-       * - [JSON vulnerability](http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx)
-       * - [XSRF](http://en.wikipedia.org/wiki/Cross-site_request_forgery)
-       *
-       * Both server and the client must cooperate in order to eliminate these threats. AngularJS comes
-       * pre-configured with strategies that address these issues, but for this to work backend server
-       * cooperation is required.
-       *
-       * ### JSON Vulnerability Protection
-       *
-       * A [JSON vulnerability](http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx)
-       * allows third party website to turn your JSON resource URL into
-       * [JSONP](http://en.wikipedia.org/wiki/JSONP) request under some conditions. To
-       * counter this your server can prefix all JSON requests with following string `")]}',\n"`.
-       * AngularJS will automatically strip the prefix before processing it as JSON.
-       *
-       * For example if your server needs to return:
-       * ```js
-       * ['one','two']
-       * ```
-       *
-       * which is vulnerable to attack, your server can return:
-       * ```js
-       * )]}',
-       * ['one','two']
-       * ```
-       *
-       * AngularJS will strip the prefix, before processing the JSON.
-       *
-       *
-       * ### Cross Site Request Forgery (XSRF) Protection
-       *
-       * [XSRF](http://en.wikipedia.org/wiki/Cross-site_request_forgery) is an attack technique by
-       * which the attacker can trick an authenticated user into unknowingly executing actions on your
-       * website. AngularJS provides a mechanism to counter XSRF. When performing XHR requests, the
-       * $http service reads a token from a cookie (by default, `XSRF-TOKEN`) and sets it as an HTTP
-       * header (by default `X-XSRF-TOKEN`). Since only JavaScript that runs on your domain could read
-       * the cookie, your server can be assured that the XHR came from JavaScript running on your
-       * domain.
-       *
-       * To take advantage of this, your server needs to set a token in a JavaScript readable session
-       * cookie called `XSRF-TOKEN` on the first HTTP GET request. On subsequent XHR requests the
-       * server can verify that the cookie matches the `X-XSRF-TOKEN` HTTP header, and therefore be
-       * sure that only JavaScript running on your domain could have sent the request. The token must
-       * be unique for each user and must be verifiable by the server (to prevent the JavaScript from
-       * making up its own tokens). We recommend that the token is a digest of your site's
-       * authentication cookie with a [salt](https://en.wikipedia.org/wiki/Salt_(cryptography&#41;)
-       * for added security.
-       *
-       * The header will &mdash; by default &mdash; **not** be set for cross-domain requests. This
-       * prevents unauthorized servers (e.g. malicious or compromised 3rd-party APIs) from gaining
-       * access to your users' XSRF tokens and exposing them to Cross Site Request Forgery. If you
-       * want to, you can trust additional origins to also receive the XSRF token, by adding them
-       * to {@link ng.$httpProvider#xsrfTrustedOrigins xsrfTrustedOrigins}. This might be
-       * useful, for example, if your application, served from `example.com`, needs to access your API
-       * at `api.example.com`.
-       * See {@link ng.$httpProvider#xsrfTrustedOrigins $httpProvider.xsrfTrustedOrigins} for
-       * more details.
-       *
-       * <div class="alert alert-danger">
-       *   **Warning**<br />
-       *   Only trusted origins that you have control over and make sure you understand the
-       *   implications of doing so.
-       * </div>
-       *
-       * The name of the cookie and the header can be specified using the `xsrfCookieName` and
-       * `xsrfHeaderName` properties of either `$httpProvider.defaults` at config-time,
-       * `$http.defaults` at run-time, or the per-request config object.
-       *
-       * In order to prevent collisions in environments where multiple AngularJS apps share the
-       * same domain or subdomain, we recommend that each application uses a unique cookie name.
-       *
-       *
-       * @param {object} config Object describing the request to be made and how it should be
-       *    processed. The object has following properties:
-       *
-       *    - **method** – `{string}` – HTTP method (e.g. 'GET', 'POST', etc)
-       *    - **url** – `{string|TrustedObject}` – Absolute or relative URL of the resource that is being requested;
-       *      or an object created by a call to `$sce.trustAsResourceUrl(url)`.
-       *    - **params** – `{Object.<string|Object>}` – Map of strings or objects which will be serialized
-       *      with the `paramSerializer` and appended as GET parameters.
-       *    - **data** – `{string|Object}` – Data to be sent as the request message data.
-       *    - **headers** – `{Object}` – Map of strings or functions which return strings representing
-       *      HTTP headers to send to the server. If the return value of a function is null, the
-       *      header will not be sent. Functions accept a config object as an argument.
-       *    - **eventHandlers** - `{Object}` - Event listeners to be bound to the XMLHttpRequest object.
-       *      To bind events to the XMLHttpRequest upload object, use `uploadEventHandlers`.
-       *      The handler will be called in the context of a `$apply` block.
-       *    - **uploadEventHandlers** - `{Object}` - Event listeners to be bound to the XMLHttpRequest upload
-       *      object. To bind events to the XMLHttpRequest object, use `eventHandlers`.
-       *      The handler will be called in the context of a `$apply` block.
-       *    - **xsrfHeaderName** – `{string}` – Name of HTTP header to populate with the XSRF token.
-       *    - **xsrfCookieName** – `{string}` – Name of cookie containing the XSRF token.
-       *    - **transformRequest** –
-       *      `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
-       *      transform function or an array of such functions. The transform function takes the http
-       *      request body and headers and returns its transformed (typically serialized) version.
-       *      See {@link ng.$http#overriding-the-default-transformations-per-request
-       *      Overriding the Default Transformations}
-       *    - **transformResponse** –
-       *      `{function(data, headersGetter, status)|Array.<function(data, headersGetter, status)>}` –
-       *      transform function or an array of such functions. The transform function takes the http
-       *      response body, headers and status and returns its transformed (typically deserialized) version.
-       *      See {@link ng.$http#overriding-the-default-transformations-per-request
-       *      Overriding the Default Transformations}
-       *    - **paramSerializer** - `{string|function(Object<string,string>):string}` - A function used to
-       *      prepare the string representation of request parameters (specified as an object).
-       *      If specified as string, it is interpreted as function registered with the
-       *      {@link $injector $injector}, which means you can create your own serializer
-       *      by registering it as a {@link auto.$provide#service service}.
-       *      The default serializer is the {@link $httpParamSerializer $httpParamSerializer};
-       *      alternatively, you can use the {@link $httpParamSerializerJQLike $httpParamSerializerJQLike}
-       *    - **cache** – `{boolean|Object}` – A boolean value or object created with
-       *      {@link ng.$cacheFactory `$cacheFactory`} to enable or disable caching of the HTTP response.
-       *      See {@link $http#caching $http Caching} for more information.
-       *    - **timeout** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise}
-       *      that should abort the request when resolved.
-       *
-       *      A numerical timeout or a promise returned from {@link ng.$timeout $timeout}, will set
-       *      the `xhrStatus` in the {@link $http#$http-returns response} to "timeout", and any other
-       *      resolved promise will set it to "abort", following standard XMLHttpRequest behavior.
-       *
-       *    - **withCredentials** - `{boolean}` - whether to set the `withCredentials` flag on the
-       *      XHR object. See [requests with credentials](https://developer.mozilla.org/docs/Web/HTTP/Access_control_CORS#Requests_with_credentials)
-       *      for more information.
-       *    - **responseType** - `{string}` - see
-       *      [XMLHttpRequest.responseType](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest#xmlhttprequest-responsetype).
-       *
-       * @returns {HttpPromise} A {@link ng.$q `Promise}` that will be resolved (request success)
-       *   or rejected (request failure) with a response object.
-       *
-       *   The response object has these properties:
-       *
-       *   - **data** – `{string|Object}` – The response body transformed with
-       *     the transform functions.
-       *   - **status** – `{number}` – HTTP status code of the response.
-       *   - **headers** – `{function([headerName])}` – Header getter function.
-       *   - **config** – `{Object}` – The configuration object that was used
-       *     to generate the request.
-       *   - **statusText** – `{string}` – HTTP status text of the response.
-       *   - **xhrStatus** – `{string}` – Status of the XMLHttpRequest
-       *     (`complete`, `error`, `timeout` or `abort`).
-       *
-       *
-       *   A response status code between 200 and 299 is considered a success status
-       *   and will result in the success callback being called. Any response status
-       *   code outside of that range is considered an error status and will result
-       *   in the error callback being called.
-       *   Also, status codes less than -1 are normalized to zero. -1 usually means
-       *   the request was aborted, e.g. using a `config.timeout`. More information
-       *   about the status might be available in the `xhrStatus` property.
-       *
-       *   Note that if the response is a redirect, XMLHttpRequest will transparently
-       *   follow it, meaning that the outcome (success or error) will be determined
-       *   by the final response status code.
-       *
-       *
-       * @property {Array.<Object>} pendingRequests Array of config objects for currently pending
-       *   requests. This is primarily meant to be used for debugging purposes.
-       *
+       * @property {Array.<Object>} requestConfig Array of config objects for currently pending
+       * requests. This is primarily meant to be used for debugging purposes.
        */
       function $http(requestConfig) {
         if (!isObject(requestConfig)) {
@@ -1177,13 +688,9 @@ export function $HttpProvider() {
       $http.pendingRequests = [];
 
       /**
-       * @ngdoc method
-       * @name $http#get
-       *
-       * @description
        * Shortcut method to perform `GET` request.
        *
-       * @param {string|TrustedObject} url Absolute or relative URL of the resource that is being requested;
+       * @param {string} url Absolute or relative URL of the resource that is being requested;
        *                                   or an object created by a call to `$sce.trustAsResourceUrl(url)`.
        * @param {Object=} config Optional configuration object. See {@link ng.$http#$http-arguments `$http()` arguments}.
        * @returns {HttpPromise}  A Promise that will be resolved or rejected with a response object.
@@ -1191,13 +698,9 @@ export function $HttpProvider() {
        */
 
       /**
-       * @ngdoc method
-       * @name $http#delete
-       *
-       * @description
        * Shortcut method to perform `DELETE` request.
        *
-       * @param {string|TrustedObject} url Absolute or relative URL of the resource that is being requested;
+       * @param {string} url Absolute or relative URL of the resource that is being requested;
        *                                   or an object created by a call to `$sce.trustAsResourceUrl(url)`.
        * @param {Object=} config Optional configuration object. See {@link ng.$http#$http-arguments `$http()` arguments}.
        * @returns {HttpPromise}  A Promise that will be resolved or rejected with a response object.
@@ -1205,13 +708,9 @@ export function $HttpProvider() {
        */
 
       /**
-       * @ngdoc method
-       * @name $http#head
-       *
-       * @description
        * Shortcut method to perform `HEAD` request.
        *
-       * @param {string|TrustedObject} url Absolute or relative URL of the resource that is being requested;
+       * @param {string} url Absolute or relative URL of the resource that is being requested;
        *                                   or an object created by a call to `$sce.trustAsResourceUrl(url)`.
        * @param {Object=} config Optional configuration object. See {@link ng.$http#$http-arguments `$http()` arguments}.
        * @returns {HttpPromise}  A Promise that will be resolved or rejected with a response object.
@@ -1219,10 +718,6 @@ export function $HttpProvider() {
        */
 
       /**
-       * @ngdoc method
-       * @name $http#jsonp
-       *
-       * @description
        * Shortcut method to perform `JSONP` request.
        *
        * Note that, since JSONP requests are sensitive because the response is given full access to the browser,
@@ -1246,7 +741,7 @@ export function $HttpProvider() {
        * If you would like to customise where and how the callbacks are stored then try overriding
        * or decorating the {@link $jsonpCallbacks} service.
        *
-       * @param {string|TrustedObject} url Absolute or relative URL of the resource that is being requested;
+       * @param {string} url Absolute or relative URL of the resource that is being requested;
        *                                   or an object created by a call to `$sce.trustAsResourceUrl(url)`.
        * @param {Object=} config Optional configuration object. See {@link ng.$http#$http-arguments `$http()` arguments}.
        * @returns {HttpPromise}  A Promise that will be resolved or rejected with a response object.
@@ -1255,10 +750,6 @@ export function $HttpProvider() {
       createShortMethods("get", "delete", "head");
 
       /**
-       * @ngdoc method
-       * @name $http#post
-       *
-       * @description
        * Shortcut method to perform `POST` request.
        *
        * @param {string} url Relative or absolute URL specifying the destination of the request
@@ -1269,10 +760,6 @@ export function $HttpProvider() {
        */
 
       /**
-       * @ngdoc method
-       * @name $http#put
-       *
-       * @description
        * Shortcut method to perform `PUT` request.
        *
        * @param {string} url Relative or absolute URL specifying the destination of the request
@@ -1407,7 +894,7 @@ export function $HttpProvider() {
         // send the request to the backend
         if (isUndefined(cachedResp)) {
           const xsrfValue = urlIsAllowedOrigin(config.url)
-            ? $$cookieReader()[config.xsrfCookieName || defaults.xsrfCookieName]
+            ? getCookies()[config.xsrfCookieName || defaults.xsrfCookieName]
             : undefined;
           if (xsrfValue) {
             reqHeaders[config.xsrfHeaderName || defaults.xsrfHeaderName] =