| 1 | /**
|
|---|
| 2 | * @license Angular v12.2.13
|
|---|
| 3 | * (c) 2010-2021 Google LLC. https://angular.io/
|
|---|
| 4 | * License: MIT
|
|---|
| 5 | */
|
|---|
| 6 |
|
|---|
| 7 | (function (global, factory) {
|
|---|
| 8 | typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common'), require('@angular/core'), require('rxjs'), require('rxjs/operators')) :
|
|---|
| 9 | typeof define === 'function' && define.amd ? define('@angular/common/http', ['exports', '@angular/common', '@angular/core', 'rxjs', 'rxjs/operators'], factory) :
|
|---|
| 10 | (global = global || self, factory((global.ng = global.ng || {}, global.ng.common = global.ng.common || {}, global.ng.common.http = {}), global.ng.common, global.ng.core, global.rxjs, global.rxjs.operators));
|
|---|
| 11 | }(this, (function (exports, common, core, rxjs, operators) { 'use strict';
|
|---|
| 12 |
|
|---|
| 13 | /**
|
|---|
| 14 | * @license
|
|---|
| 15 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 16 | *
|
|---|
| 17 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 18 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 19 | */
|
|---|
| 20 | /**
|
|---|
| 21 | * Transforms an `HttpRequest` into a stream of `HttpEvent`s, one of which will likely be a
|
|---|
| 22 | * `HttpResponse`.
|
|---|
| 23 | *
|
|---|
| 24 | * `HttpHandler` is injectable. When injected, the handler instance dispatches requests to the
|
|---|
| 25 | * first interceptor in the chain, which dispatches to the second, etc, eventually reaching the
|
|---|
| 26 | * `HttpBackend`.
|
|---|
| 27 | *
|
|---|
| 28 | * In an `HttpInterceptor`, the `HttpHandler` parameter is the next interceptor in the chain.
|
|---|
| 29 | *
|
|---|
| 30 | * @publicApi
|
|---|
| 31 | */
|
|---|
| 32 | var HttpHandler = /** @class */ (function () {
|
|---|
| 33 | function HttpHandler() {
|
|---|
| 34 | }
|
|---|
| 35 | return HttpHandler;
|
|---|
| 36 | }());
|
|---|
| 37 | /**
|
|---|
| 38 | * A final `HttpHandler` which will dispatch the request via browser HTTP APIs to a backend.
|
|---|
| 39 | *
|
|---|
| 40 | * Interceptors sit between the `HttpClient` interface and the `HttpBackend`.
|
|---|
| 41 | *
|
|---|
| 42 | * When injected, `HttpBackend` dispatches requests directly to the backend, without going
|
|---|
| 43 | * through the interceptor chain.
|
|---|
| 44 | *
|
|---|
| 45 | * @publicApi
|
|---|
| 46 | */
|
|---|
| 47 | var HttpBackend = /** @class */ (function () {
|
|---|
| 48 | function HttpBackend() {
|
|---|
| 49 | }
|
|---|
| 50 | return HttpBackend;
|
|---|
| 51 | }());
|
|---|
| 52 |
|
|---|
| 53 | /*! *****************************************************************************
|
|---|
| 54 | Copyright (c) Microsoft Corporation.
|
|---|
| 55 |
|
|---|
| 56 | Permission to use, copy, modify, and/or distribute this software for any
|
|---|
| 57 | purpose with or without fee is hereby granted.
|
|---|
| 58 |
|
|---|
| 59 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
|---|
| 60 | REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
|---|
| 61 | AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
|---|
| 62 | INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
|---|
| 63 | LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
|---|
| 64 | OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|---|
| 65 | PERFORMANCE OF THIS SOFTWARE.
|
|---|
| 66 | ***************************************************************************** */
|
|---|
| 67 | /* global Reflect, Promise */
|
|---|
| 68 | var extendStatics = function (d, b) {
|
|---|
| 69 | extendStatics = Object.setPrototypeOf ||
|
|---|
| 70 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|---|
| 71 | function (d, b) { for (var p in b)
|
|---|
| 72 | if (Object.prototype.hasOwnProperty.call(b, p))
|
|---|
| 73 | d[p] = b[p]; };
|
|---|
| 74 | return extendStatics(d, b);
|
|---|
| 75 | };
|
|---|
| 76 | function __extends(d, b) {
|
|---|
| 77 | if (typeof b !== "function" && b !== null)
|
|---|
| 78 | throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|---|
| 79 | extendStatics(d, b);
|
|---|
| 80 | function __() { this.constructor = d; }
|
|---|
| 81 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|---|
| 82 | }
|
|---|
| 83 | var __assign = function () {
|
|---|
| 84 | __assign = Object.assign || function __assign(t) {
|
|---|
| 85 | for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|---|
| 86 | s = arguments[i];
|
|---|
| 87 | for (var p in s)
|
|---|
| 88 | if (Object.prototype.hasOwnProperty.call(s, p))
|
|---|
| 89 | t[p] = s[p];
|
|---|
| 90 | }
|
|---|
| 91 | return t;
|
|---|
| 92 | };
|
|---|
| 93 | return __assign.apply(this, arguments);
|
|---|
| 94 | };
|
|---|
| 95 | function __rest(s, e) {
|
|---|
| 96 | var t = {};
|
|---|
| 97 | for (var p in s)
|
|---|
| 98 | if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
|
|---|
| 99 | t[p] = s[p];
|
|---|
| 100 | if (s != null && typeof Object.getOwnPropertySymbols === "function")
|
|---|
| 101 | for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
|---|
| 102 | if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
|
|---|
| 103 | t[p[i]] = s[p[i]];
|
|---|
| 104 | }
|
|---|
| 105 | return t;
|
|---|
| 106 | }
|
|---|
| 107 | function __decorate(decorators, target, key, desc) {
|
|---|
| 108 | var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
|---|
| 109 | if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
|
|---|
| 110 | r = Reflect.decorate(decorators, target, key, desc);
|
|---|
| 111 | else
|
|---|
| 112 | for (var i = decorators.length - 1; i >= 0; i--)
|
|---|
| 113 | if (d = decorators[i])
|
|---|
| 114 | r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
|---|
| 115 | return c > 3 && r && Object.defineProperty(target, key, r), r;
|
|---|
| 116 | }
|
|---|
| 117 | function __param(paramIndex, decorator) {
|
|---|
| 118 | return function (target, key) { decorator(target, key, paramIndex); };
|
|---|
| 119 | }
|
|---|
| 120 | function __metadata(metadataKey, metadataValue) {
|
|---|
| 121 | if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
|
|---|
| 122 | return Reflect.metadata(metadataKey, metadataValue);
|
|---|
| 123 | }
|
|---|
| 124 | function __awaiter(thisArg, _arguments, P, generator) {
|
|---|
| 125 | function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|---|
| 126 | return new (P || (P = Promise))(function (resolve, reject) {
|
|---|
| 127 | function fulfilled(value) { try {
|
|---|
| 128 | step(generator.next(value));
|
|---|
| 129 | }
|
|---|
| 130 | catch (e) {
|
|---|
| 131 | reject(e);
|
|---|
| 132 | } }
|
|---|
| 133 | function rejected(value) { try {
|
|---|
| 134 | step(generator["throw"](value));
|
|---|
| 135 | }
|
|---|
| 136 | catch (e) {
|
|---|
| 137 | reject(e);
|
|---|
| 138 | } }
|
|---|
| 139 | function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|---|
| 140 | step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|---|
| 141 | });
|
|---|
| 142 | }
|
|---|
| 143 | function __generator(thisArg, body) {
|
|---|
| 144 | var _ = { label: 0, sent: function () { if (t[0] & 1)
|
|---|
| 145 | throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
|---|
| 146 | return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
|
|---|
| 147 | function verb(n) { return function (v) { return step([n, v]); }; }
|
|---|
| 148 | function step(op) {
|
|---|
| 149 | if (f)
|
|---|
| 150 | throw new TypeError("Generator is already executing.");
|
|---|
| 151 | while (_)
|
|---|
| 152 | try {
|
|---|
| 153 | if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
|
|---|
| 154 | return t;
|
|---|
| 155 | if (y = 0, t)
|
|---|
| 156 | op = [op[0] & 2, t.value];
|
|---|
| 157 | switch (op[0]) {
|
|---|
| 158 | case 0:
|
|---|
| 159 | case 1:
|
|---|
| 160 | t = op;
|
|---|
| 161 | break;
|
|---|
| 162 | case 4:
|
|---|
| 163 | _.label++;
|
|---|
| 164 | return { value: op[1], done: false };
|
|---|
| 165 | case 5:
|
|---|
| 166 | _.label++;
|
|---|
| 167 | y = op[1];
|
|---|
| 168 | op = [0];
|
|---|
| 169 | continue;
|
|---|
| 170 | case 7:
|
|---|
| 171 | op = _.ops.pop();
|
|---|
| 172 | _.trys.pop();
|
|---|
| 173 | continue;
|
|---|
| 174 | default:
|
|---|
| 175 | if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
|
|---|
| 176 | _ = 0;
|
|---|
| 177 | continue;
|
|---|
| 178 | }
|
|---|
| 179 | if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
|
|---|
| 180 | _.label = op[1];
|
|---|
| 181 | break;
|
|---|
| 182 | }
|
|---|
| 183 | if (op[0] === 6 && _.label < t[1]) {
|
|---|
| 184 | _.label = t[1];
|
|---|
| 185 | t = op;
|
|---|
| 186 | break;
|
|---|
| 187 | }
|
|---|
| 188 | if (t && _.label < t[2]) {
|
|---|
| 189 | _.label = t[2];
|
|---|
| 190 | _.ops.push(op);
|
|---|
| 191 | break;
|
|---|
| 192 | }
|
|---|
| 193 | if (t[2])
|
|---|
| 194 | _.ops.pop();
|
|---|
| 195 | _.trys.pop();
|
|---|
| 196 | continue;
|
|---|
| 197 | }
|
|---|
| 198 | op = body.call(thisArg, _);
|
|---|
| 199 | }
|
|---|
| 200 | catch (e) {
|
|---|
| 201 | op = [6, e];
|
|---|
| 202 | y = 0;
|
|---|
| 203 | }
|
|---|
| 204 | finally {
|
|---|
| 205 | f = t = 0;
|
|---|
| 206 | }
|
|---|
| 207 | if (op[0] & 5)
|
|---|
| 208 | throw op[1];
|
|---|
| 209 | return { value: op[0] ? op[1] : void 0, done: true };
|
|---|
| 210 | }
|
|---|
| 211 | }
|
|---|
| 212 | var __createBinding = Object.create ? (function (o, m, k, k2) {
|
|---|
| 213 | if (k2 === undefined)
|
|---|
| 214 | k2 = k;
|
|---|
| 215 | Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
|
|---|
| 216 | }) : (function (o, m, k, k2) {
|
|---|
| 217 | if (k2 === undefined)
|
|---|
| 218 | k2 = k;
|
|---|
| 219 | o[k2] = m[k];
|
|---|
| 220 | });
|
|---|
| 221 | function __exportStar(m, o) {
|
|---|
| 222 | for (var p in m)
|
|---|
| 223 | if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
|
|---|
| 224 | __createBinding(o, m, p);
|
|---|
| 225 | }
|
|---|
| 226 | function __values(o) {
|
|---|
| 227 | var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|---|
| 228 | if (m)
|
|---|
| 229 | return m.call(o);
|
|---|
| 230 | if (o && typeof o.length === "number")
|
|---|
| 231 | return {
|
|---|
| 232 | next: function () {
|
|---|
| 233 | if (o && i >= o.length)
|
|---|
| 234 | o = void 0;
|
|---|
| 235 | return { value: o && o[i++], done: !o };
|
|---|
| 236 | }
|
|---|
| 237 | };
|
|---|
| 238 | throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|---|
| 239 | }
|
|---|
| 240 | function __read(o, n) {
|
|---|
| 241 | var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|---|
| 242 | if (!m)
|
|---|
| 243 | return o;
|
|---|
| 244 | var i = m.call(o), r, ar = [], e;
|
|---|
| 245 | try {
|
|---|
| 246 | while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
|
|---|
| 247 | ar.push(r.value);
|
|---|
| 248 | }
|
|---|
| 249 | catch (error) {
|
|---|
| 250 | e = { error: error };
|
|---|
| 251 | }
|
|---|
| 252 | finally {
|
|---|
| 253 | try {
|
|---|
| 254 | if (r && !r.done && (m = i["return"]))
|
|---|
| 255 | m.call(i);
|
|---|
| 256 | }
|
|---|
| 257 | finally {
|
|---|
| 258 | if (e)
|
|---|
| 259 | throw e.error;
|
|---|
| 260 | }
|
|---|
| 261 | }
|
|---|
| 262 | return ar;
|
|---|
| 263 | }
|
|---|
| 264 | /** @deprecated */
|
|---|
| 265 | function __spread() {
|
|---|
| 266 | for (var ar = [], i = 0; i < arguments.length; i++)
|
|---|
| 267 | ar = ar.concat(__read(arguments[i]));
|
|---|
| 268 | return ar;
|
|---|
| 269 | }
|
|---|
| 270 | /** @deprecated */
|
|---|
| 271 | function __spreadArrays() {
|
|---|
| 272 | for (var s = 0, i = 0, il = arguments.length; i < il; i++)
|
|---|
| 273 | s += arguments[i].length;
|
|---|
| 274 | for (var r = Array(s), k = 0, i = 0; i < il; i++)
|
|---|
| 275 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
|
|---|
| 276 | r[k] = a[j];
|
|---|
| 277 | return r;
|
|---|
| 278 | }
|
|---|
| 279 | function __spreadArray(to, from, pack) {
|
|---|
| 280 | if (pack || arguments.length === 2)
|
|---|
| 281 | for (var i = 0, l = from.length, ar; i < l; i++) {
|
|---|
| 282 | if (ar || !(i in from)) {
|
|---|
| 283 | if (!ar)
|
|---|
| 284 | ar = Array.prototype.slice.call(from, 0, i);
|
|---|
| 285 | ar[i] = from[i];
|
|---|
| 286 | }
|
|---|
| 287 | }
|
|---|
| 288 | return to.concat(ar || Array.prototype.slice.call(from));
|
|---|
| 289 | }
|
|---|
| 290 | function __await(v) {
|
|---|
| 291 | return this instanceof __await ? (this.v = v, this) : new __await(v);
|
|---|
| 292 | }
|
|---|
| 293 | function __asyncGenerator(thisArg, _arguments, generator) {
|
|---|
| 294 | if (!Symbol.asyncIterator)
|
|---|
| 295 | throw new TypeError("Symbol.asyncIterator is not defined.");
|
|---|
| 296 | var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
|---|
| 297 | return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
|
|---|
| 298 | function verb(n) { if (g[n])
|
|---|
| 299 | i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
|
|---|
| 300 | function resume(n, v) { try {
|
|---|
| 301 | step(g[n](v));
|
|---|
| 302 | }
|
|---|
| 303 | catch (e) {
|
|---|
| 304 | settle(q[0][3], e);
|
|---|
| 305 | } }
|
|---|
| 306 | function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
|
|---|
| 307 | function fulfill(value) { resume("next", value); }
|
|---|
| 308 | function reject(value) { resume("throw", value); }
|
|---|
| 309 | function settle(f, v) { if (f(v), q.shift(), q.length)
|
|---|
| 310 | resume(q[0][0], q[0][1]); }
|
|---|
| 311 | }
|
|---|
| 312 | function __asyncDelegator(o) {
|
|---|
| 313 | var i, p;
|
|---|
| 314 | return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
|
|---|
| 315 | function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
|
|---|
| 316 | }
|
|---|
| 317 | function __asyncValues(o) {
|
|---|
| 318 | if (!Symbol.asyncIterator)
|
|---|
| 319 | throw new TypeError("Symbol.asyncIterator is not defined.");
|
|---|
| 320 | var m = o[Symbol.asyncIterator], i;
|
|---|
| 321 | return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
|---|
| 322 | function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
|---|
| 323 | function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
|
|---|
| 324 | }
|
|---|
| 325 | function __makeTemplateObject(cooked, raw) {
|
|---|
| 326 | if (Object.defineProperty) {
|
|---|
| 327 | Object.defineProperty(cooked, "raw", { value: raw });
|
|---|
| 328 | }
|
|---|
| 329 | else {
|
|---|
| 330 | cooked.raw = raw;
|
|---|
| 331 | }
|
|---|
| 332 | return cooked;
|
|---|
| 333 | }
|
|---|
| 334 | ;
|
|---|
| 335 | var __setModuleDefault = Object.create ? (function (o, v) {
|
|---|
| 336 | Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|---|
| 337 | }) : function (o, v) {
|
|---|
| 338 | o["default"] = v;
|
|---|
| 339 | };
|
|---|
| 340 | function __importStar(mod) {
|
|---|
| 341 | if (mod && mod.__esModule)
|
|---|
| 342 | return mod;
|
|---|
| 343 | var result = {};
|
|---|
| 344 | if (mod != null)
|
|---|
| 345 | for (var k in mod)
|
|---|
| 346 | if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
|
|---|
| 347 | __createBinding(result, mod, k);
|
|---|
| 348 | __setModuleDefault(result, mod);
|
|---|
| 349 | return result;
|
|---|
| 350 | }
|
|---|
| 351 | function __importDefault(mod) {
|
|---|
| 352 | return (mod && mod.__esModule) ? mod : { default: mod };
|
|---|
| 353 | }
|
|---|
| 354 | function __classPrivateFieldGet(receiver, state, kind, f) {
|
|---|
| 355 | if (kind === "a" && !f)
|
|---|
| 356 | throw new TypeError("Private accessor was defined without a getter");
|
|---|
| 357 | if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
|
|---|
| 358 | throw new TypeError("Cannot read private member from an object whose class did not declare it");
|
|---|
| 359 | return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
|
|---|
| 360 | }
|
|---|
| 361 | function __classPrivateFieldSet(receiver, state, value, kind, f) {
|
|---|
| 362 | if (kind === "m")
|
|---|
| 363 | throw new TypeError("Private method is not writable");
|
|---|
| 364 | if (kind === "a" && !f)
|
|---|
| 365 | throw new TypeError("Private accessor was defined without a setter");
|
|---|
| 366 | if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
|
|---|
| 367 | throw new TypeError("Cannot write private member to an object whose class did not declare it");
|
|---|
| 368 | return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
|
|---|
| 369 | }
|
|---|
| 370 |
|
|---|
| 371 | /**
|
|---|
| 372 | * @license
|
|---|
| 373 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 374 | *
|
|---|
| 375 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 376 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 377 | */
|
|---|
| 378 | /**
|
|---|
| 379 | * Represents the header configuration options for an HTTP request.
|
|---|
| 380 | * Instances are immutable. Modifying methods return a cloned
|
|---|
| 381 | * instance with the change. The original object is never changed.
|
|---|
| 382 | *
|
|---|
| 383 | * @publicApi
|
|---|
| 384 | */
|
|---|
| 385 | var HttpHeaders = /** @class */ (function () {
|
|---|
| 386 | /** Constructs a new HTTP header object with the given values.*/
|
|---|
| 387 | function HttpHeaders(headers) {
|
|---|
| 388 | var _this = this;
|
|---|
| 389 | /**
|
|---|
| 390 | * Internal map of lowercased header names to the normalized
|
|---|
| 391 | * form of the name (the form seen first).
|
|---|
| 392 | */
|
|---|
| 393 | this.normalizedNames = new Map();
|
|---|
| 394 | /**
|
|---|
| 395 | * Queued updates to be materialized the next initialization.
|
|---|
| 396 | */
|
|---|
| 397 | this.lazyUpdate = null;
|
|---|
| 398 | if (!headers) {
|
|---|
| 399 | this.headers = new Map();
|
|---|
| 400 | }
|
|---|
| 401 | else if (typeof headers === 'string') {
|
|---|
| 402 | this.lazyInit = function () {
|
|---|
| 403 | _this.headers = new Map();
|
|---|
| 404 | headers.split('\n').forEach(function (line) {
|
|---|
| 405 | var index = line.indexOf(':');
|
|---|
| 406 | if (index > 0) {
|
|---|
| 407 | var name = line.slice(0, index);
|
|---|
| 408 | var key = name.toLowerCase();
|
|---|
| 409 | var value = line.slice(index + 1).trim();
|
|---|
| 410 | _this.maybeSetNormalizedName(name, key);
|
|---|
| 411 | if (_this.headers.has(key)) {
|
|---|
| 412 | _this.headers.get(key).push(value);
|
|---|
| 413 | }
|
|---|
| 414 | else {
|
|---|
| 415 | _this.headers.set(key, [value]);
|
|---|
| 416 | }
|
|---|
| 417 | }
|
|---|
| 418 | });
|
|---|
| 419 | };
|
|---|
| 420 | }
|
|---|
| 421 | else {
|
|---|
| 422 | this.lazyInit = function () {
|
|---|
| 423 | _this.headers = new Map();
|
|---|
| 424 | Object.keys(headers).forEach(function (name) {
|
|---|
| 425 | var values = headers[name];
|
|---|
| 426 | var key = name.toLowerCase();
|
|---|
| 427 | if (typeof values === 'string') {
|
|---|
| 428 | values = [values];
|
|---|
| 429 | }
|
|---|
| 430 | if (values.length > 0) {
|
|---|
| 431 | _this.headers.set(key, values);
|
|---|
| 432 | _this.maybeSetNormalizedName(name, key);
|
|---|
| 433 | }
|
|---|
| 434 | });
|
|---|
| 435 | };
|
|---|
| 436 | }
|
|---|
| 437 | }
|
|---|
| 438 | /**
|
|---|
| 439 | * Checks for existence of a given header.
|
|---|
| 440 | *
|
|---|
| 441 | * @param name The header name to check for existence.
|
|---|
| 442 | *
|
|---|
| 443 | * @returns True if the header exists, false otherwise.
|
|---|
| 444 | */
|
|---|
| 445 | HttpHeaders.prototype.has = function (name) {
|
|---|
| 446 | this.init();
|
|---|
| 447 | return this.headers.has(name.toLowerCase());
|
|---|
| 448 | };
|
|---|
| 449 | /**
|
|---|
| 450 | * Retrieves the first value of a given header.
|
|---|
| 451 | *
|
|---|
| 452 | * @param name The header name.
|
|---|
| 453 | *
|
|---|
| 454 | * @returns The value string if the header exists, null otherwise
|
|---|
| 455 | */
|
|---|
| 456 | HttpHeaders.prototype.get = function (name) {
|
|---|
| 457 | this.init();
|
|---|
| 458 | var values = this.headers.get(name.toLowerCase());
|
|---|
| 459 | return values && values.length > 0 ? values[0] : null;
|
|---|
| 460 | };
|
|---|
| 461 | /**
|
|---|
| 462 | * Retrieves the names of the headers.
|
|---|
| 463 | *
|
|---|
| 464 | * @returns A list of header names.
|
|---|
| 465 | */
|
|---|
| 466 | HttpHeaders.prototype.keys = function () {
|
|---|
| 467 | this.init();
|
|---|
| 468 | return Array.from(this.normalizedNames.values());
|
|---|
| 469 | };
|
|---|
| 470 | /**
|
|---|
| 471 | * Retrieves a list of values for a given header.
|
|---|
| 472 | *
|
|---|
| 473 | * @param name The header name from which to retrieve values.
|
|---|
| 474 | *
|
|---|
| 475 | * @returns A string of values if the header exists, null otherwise.
|
|---|
| 476 | */
|
|---|
| 477 | HttpHeaders.prototype.getAll = function (name) {
|
|---|
| 478 | this.init();
|
|---|
| 479 | return this.headers.get(name.toLowerCase()) || null;
|
|---|
| 480 | };
|
|---|
| 481 | /**
|
|---|
| 482 | * Appends a new value to the existing set of values for a header
|
|---|
| 483 | * and returns them in a clone of the original instance.
|
|---|
| 484 | *
|
|---|
| 485 | * @param name The header name for which to append the values.
|
|---|
| 486 | * @param value The value to append.
|
|---|
| 487 | *
|
|---|
| 488 | * @returns A clone of the HTTP headers object with the value appended to the given header.
|
|---|
| 489 | */
|
|---|
| 490 | HttpHeaders.prototype.append = function (name, value) {
|
|---|
| 491 | return this.clone({ name: name, value: value, op: 'a' });
|
|---|
| 492 | };
|
|---|
| 493 | /**
|
|---|
| 494 | * Sets or modifies a value for a given header in a clone of the original instance.
|
|---|
| 495 | * If the header already exists, its value is replaced with the given value
|
|---|
| 496 | * in the returned object.
|
|---|
| 497 | *
|
|---|
| 498 | * @param name The header name.
|
|---|
| 499 | * @param value The value or values to set or overide for the given header.
|
|---|
| 500 | *
|
|---|
| 501 | * @returns A clone of the HTTP headers object with the newly set header value.
|
|---|
| 502 | */
|
|---|
| 503 | HttpHeaders.prototype.set = function (name, value) {
|
|---|
| 504 | return this.clone({ name: name, value: value, op: 's' });
|
|---|
| 505 | };
|
|---|
| 506 | /**
|
|---|
| 507 | * Deletes values for a given header in a clone of the original instance.
|
|---|
| 508 | *
|
|---|
| 509 | * @param name The header name.
|
|---|
| 510 | * @param value The value or values to delete for the given header.
|
|---|
| 511 | *
|
|---|
| 512 | * @returns A clone of the HTTP headers object with the given value deleted.
|
|---|
| 513 | */
|
|---|
| 514 | HttpHeaders.prototype.delete = function (name, value) {
|
|---|
| 515 | return this.clone({ name: name, value: value, op: 'd' });
|
|---|
| 516 | };
|
|---|
| 517 | HttpHeaders.prototype.maybeSetNormalizedName = function (name, lcName) {
|
|---|
| 518 | if (!this.normalizedNames.has(lcName)) {
|
|---|
| 519 | this.normalizedNames.set(lcName, name);
|
|---|
| 520 | }
|
|---|
| 521 | };
|
|---|
| 522 | HttpHeaders.prototype.init = function () {
|
|---|
| 523 | var _this = this;
|
|---|
| 524 | if (!!this.lazyInit) {
|
|---|
| 525 | if (this.lazyInit instanceof HttpHeaders) {
|
|---|
| 526 | this.copyFrom(this.lazyInit);
|
|---|
| 527 | }
|
|---|
| 528 | else {
|
|---|
| 529 | this.lazyInit();
|
|---|
| 530 | }
|
|---|
| 531 | this.lazyInit = null;
|
|---|
| 532 | if (!!this.lazyUpdate) {
|
|---|
| 533 | this.lazyUpdate.forEach(function (update) { return _this.applyUpdate(update); });
|
|---|
| 534 | this.lazyUpdate = null;
|
|---|
| 535 | }
|
|---|
| 536 | }
|
|---|
| 537 | };
|
|---|
| 538 | HttpHeaders.prototype.copyFrom = function (other) {
|
|---|
| 539 | var _this = this;
|
|---|
| 540 | other.init();
|
|---|
| 541 | Array.from(other.headers.keys()).forEach(function (key) {
|
|---|
| 542 | _this.headers.set(key, other.headers.get(key));
|
|---|
| 543 | _this.normalizedNames.set(key, other.normalizedNames.get(key));
|
|---|
| 544 | });
|
|---|
| 545 | };
|
|---|
| 546 | HttpHeaders.prototype.clone = function (update) {
|
|---|
| 547 | var clone = new HttpHeaders();
|
|---|
| 548 | clone.lazyInit =
|
|---|
| 549 | (!!this.lazyInit && this.lazyInit instanceof HttpHeaders) ? this.lazyInit : this;
|
|---|
| 550 | clone.lazyUpdate = (this.lazyUpdate || []).concat([update]);
|
|---|
| 551 | return clone;
|
|---|
| 552 | };
|
|---|
| 553 | HttpHeaders.prototype.applyUpdate = function (update) {
|
|---|
| 554 | var key = update.name.toLowerCase();
|
|---|
| 555 | switch (update.op) {
|
|---|
| 556 | case 'a':
|
|---|
| 557 | case 's':
|
|---|
| 558 | var value = update.value;
|
|---|
| 559 | if (typeof value === 'string') {
|
|---|
| 560 | value = [value];
|
|---|
| 561 | }
|
|---|
| 562 | if (value.length === 0) {
|
|---|
| 563 | return;
|
|---|
| 564 | }
|
|---|
| 565 | this.maybeSetNormalizedName(update.name, key);
|
|---|
| 566 | var base = (update.op === 'a' ? this.headers.get(key) : undefined) || [];
|
|---|
| 567 | base.push.apply(base, __spreadArray([], __read(value)));
|
|---|
| 568 | this.headers.set(key, base);
|
|---|
| 569 | break;
|
|---|
| 570 | case 'd':
|
|---|
| 571 | var toDelete_1 = update.value;
|
|---|
| 572 | if (!toDelete_1) {
|
|---|
| 573 | this.headers.delete(key);
|
|---|
| 574 | this.normalizedNames.delete(key);
|
|---|
| 575 | }
|
|---|
| 576 | else {
|
|---|
| 577 | var existing = this.headers.get(key);
|
|---|
| 578 | if (!existing) {
|
|---|
| 579 | return;
|
|---|
| 580 | }
|
|---|
| 581 | existing = existing.filter(function (value) { return toDelete_1.indexOf(value) === -1; });
|
|---|
| 582 | if (existing.length === 0) {
|
|---|
| 583 | this.headers.delete(key);
|
|---|
| 584 | this.normalizedNames.delete(key);
|
|---|
| 585 | }
|
|---|
| 586 | else {
|
|---|
| 587 | this.headers.set(key, existing);
|
|---|
| 588 | }
|
|---|
| 589 | }
|
|---|
| 590 | break;
|
|---|
| 591 | }
|
|---|
| 592 | };
|
|---|
| 593 | /**
|
|---|
| 594 | * @internal
|
|---|
| 595 | */
|
|---|
| 596 | HttpHeaders.prototype.forEach = function (fn) {
|
|---|
| 597 | var _this = this;
|
|---|
| 598 | this.init();
|
|---|
| 599 | Array.from(this.normalizedNames.keys())
|
|---|
| 600 | .forEach(function (key) { return fn(_this.normalizedNames.get(key), _this.headers.get(key)); });
|
|---|
| 601 | };
|
|---|
| 602 | return HttpHeaders;
|
|---|
| 603 | }());
|
|---|
| 604 |
|
|---|
| 605 | /**
|
|---|
| 606 | * @license
|
|---|
| 607 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 608 | *
|
|---|
| 609 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 610 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 611 | */
|
|---|
| 612 | /**
|
|---|
| 613 | * Provides encoding and decoding of URL parameter and query-string values.
|
|---|
| 614 | *
|
|---|
| 615 | * Serializes and parses URL parameter keys and values to encode and decode them.
|
|---|
| 616 | * If you pass URL query parameters without encoding,
|
|---|
| 617 | * the query parameters can be misinterpreted at the receiving end.
|
|---|
| 618 | *
|
|---|
| 619 | *
|
|---|
| 620 | * @publicApi
|
|---|
| 621 | */
|
|---|
| 622 | var HttpUrlEncodingCodec = /** @class */ (function () {
|
|---|
| 623 | function HttpUrlEncodingCodec() {
|
|---|
| 624 | }
|
|---|
| 625 | /**
|
|---|
| 626 | * Encodes a key name for a URL parameter or query-string.
|
|---|
| 627 | * @param key The key name.
|
|---|
| 628 | * @returns The encoded key name.
|
|---|
| 629 | */
|
|---|
| 630 | HttpUrlEncodingCodec.prototype.encodeKey = function (key) {
|
|---|
| 631 | return standardEncoding(key);
|
|---|
| 632 | };
|
|---|
| 633 | /**
|
|---|
| 634 | * Encodes the value of a URL parameter or query-string.
|
|---|
| 635 | * @param value The value.
|
|---|
| 636 | * @returns The encoded value.
|
|---|
| 637 | */
|
|---|
| 638 | HttpUrlEncodingCodec.prototype.encodeValue = function (value) {
|
|---|
| 639 | return standardEncoding(value);
|
|---|
| 640 | };
|
|---|
| 641 | /**
|
|---|
| 642 | * Decodes an encoded URL parameter or query-string key.
|
|---|
| 643 | * @param key The encoded key name.
|
|---|
| 644 | * @returns The decoded key name.
|
|---|
| 645 | */
|
|---|
| 646 | HttpUrlEncodingCodec.prototype.decodeKey = function (key) {
|
|---|
| 647 | return decodeURIComponent(key);
|
|---|
| 648 | };
|
|---|
| 649 | /**
|
|---|
| 650 | * Decodes an encoded URL parameter or query-string value.
|
|---|
| 651 | * @param value The encoded value.
|
|---|
| 652 | * @returns The decoded value.
|
|---|
| 653 | */
|
|---|
| 654 | HttpUrlEncodingCodec.prototype.decodeValue = function (value) {
|
|---|
| 655 | return decodeURIComponent(value);
|
|---|
| 656 | };
|
|---|
| 657 | return HttpUrlEncodingCodec;
|
|---|
| 658 | }());
|
|---|
| 659 | function paramParser(rawParams, codec) {
|
|---|
| 660 | var map = new Map();
|
|---|
| 661 | if (rawParams.length > 0) {
|
|---|
| 662 | // The `window.location.search` can be used while creating an instance of the `HttpParams` class
|
|---|
| 663 | // (e.g. `new HttpParams({ fromString: window.location.search })`). The `window.location.search`
|
|---|
| 664 | // may start with the `?` char, so we strip it if it's present.
|
|---|
| 665 | var params = rawParams.replace(/^\?/, '').split('&');
|
|---|
| 666 | params.forEach(function (param) {
|
|---|
| 667 | var eqIdx = param.indexOf('=');
|
|---|
| 668 | var _b = __read(eqIdx == -1 ?
|
|---|
| 669 | [codec.decodeKey(param), ''] :
|
|---|
| 670 | [codec.decodeKey(param.slice(0, eqIdx)), codec.decodeValue(param.slice(eqIdx + 1))], 2), key = _b[0], val = _b[1];
|
|---|
| 671 | var list = map.get(key) || [];
|
|---|
| 672 | list.push(val);
|
|---|
| 673 | map.set(key, list);
|
|---|
| 674 | });
|
|---|
| 675 | }
|
|---|
| 676 | return map;
|
|---|
| 677 | }
|
|---|
| 678 | /**
|
|---|
| 679 | * Encode input string with standard encodeURIComponent and then un-encode specific characters.
|
|---|
| 680 | */
|
|---|
| 681 | var STANDARD_ENCODING_REGEX = /%(\d[a-f0-9])/gi;
|
|---|
| 682 | var STANDARD_ENCODING_REPLACEMENTS = {
|
|---|
| 683 | '40': '@',
|
|---|
| 684 | '3A': ':',
|
|---|
| 685 | '24': '$',
|
|---|
| 686 | '2C': ',',
|
|---|
| 687 | '3B': ';',
|
|---|
| 688 | '2B': '+',
|
|---|
| 689 | '3D': '=',
|
|---|
| 690 | '3F': '?',
|
|---|
| 691 | '2F': '/',
|
|---|
| 692 | };
|
|---|
| 693 | function standardEncoding(v) {
|
|---|
| 694 | return encodeURIComponent(v).replace(STANDARD_ENCODING_REGEX, function (s, t) { var _a; return (_a = STANDARD_ENCODING_REPLACEMENTS[t]) !== null && _a !== void 0 ? _a : s; });
|
|---|
| 695 | }
|
|---|
| 696 | function valueToString(value) {
|
|---|
| 697 | return "" + value;
|
|---|
| 698 | }
|
|---|
| 699 | /**
|
|---|
| 700 | * An HTTP request/response body that represents serialized parameters,
|
|---|
| 701 | * per the MIME type `application/x-www-form-urlencoded`.
|
|---|
| 702 | *
|
|---|
| 703 | * This class is immutable; all mutation operations return a new instance.
|
|---|
| 704 | *
|
|---|
| 705 | * @publicApi
|
|---|
| 706 | */
|
|---|
| 707 | var HttpParams = /** @class */ (function () {
|
|---|
| 708 | function HttpParams(options) {
|
|---|
| 709 | var _this = this;
|
|---|
| 710 | if (options === void 0) { options = {}; }
|
|---|
| 711 | this.updates = null;
|
|---|
| 712 | this.cloneFrom = null;
|
|---|
| 713 | this.encoder = options.encoder || new HttpUrlEncodingCodec();
|
|---|
| 714 | if (!!options.fromString) {
|
|---|
| 715 | if (!!options.fromObject) {
|
|---|
| 716 | throw new Error("Cannot specify both fromString and fromObject.");
|
|---|
| 717 | }
|
|---|
| 718 | this.map = paramParser(options.fromString, this.encoder);
|
|---|
| 719 | }
|
|---|
| 720 | else if (!!options.fromObject) {
|
|---|
| 721 | this.map = new Map();
|
|---|
| 722 | Object.keys(options.fromObject).forEach(function (key) {
|
|---|
| 723 | var value = options.fromObject[key];
|
|---|
| 724 | _this.map.set(key, Array.isArray(value) ? value : [value]);
|
|---|
| 725 | });
|
|---|
| 726 | }
|
|---|
| 727 | else {
|
|---|
| 728 | this.map = null;
|
|---|
| 729 | }
|
|---|
| 730 | }
|
|---|
| 731 | /**
|
|---|
| 732 | * Reports whether the body includes one or more values for a given parameter.
|
|---|
| 733 | * @param param The parameter name.
|
|---|
| 734 | * @returns True if the parameter has one or more values,
|
|---|
| 735 | * false if it has no value or is not present.
|
|---|
| 736 | */
|
|---|
| 737 | HttpParams.prototype.has = function (param) {
|
|---|
| 738 | this.init();
|
|---|
| 739 | return this.map.has(param);
|
|---|
| 740 | };
|
|---|
| 741 | /**
|
|---|
| 742 | * Retrieves the first value for a parameter.
|
|---|
| 743 | * @param param The parameter name.
|
|---|
| 744 | * @returns The first value of the given parameter,
|
|---|
| 745 | * or `null` if the parameter is not present.
|
|---|
| 746 | */
|
|---|
| 747 | HttpParams.prototype.get = function (param) {
|
|---|
| 748 | this.init();
|
|---|
| 749 | var res = this.map.get(param);
|
|---|
| 750 | return !!res ? res[0] : null;
|
|---|
| 751 | };
|
|---|
| 752 | /**
|
|---|
| 753 | * Retrieves all values for a parameter.
|
|---|
| 754 | * @param param The parameter name.
|
|---|
| 755 | * @returns All values in a string array,
|
|---|
| 756 | * or `null` if the parameter not present.
|
|---|
| 757 | */
|
|---|
| 758 | HttpParams.prototype.getAll = function (param) {
|
|---|
| 759 | this.init();
|
|---|
| 760 | return this.map.get(param) || null;
|
|---|
| 761 | };
|
|---|
| 762 | /**
|
|---|
| 763 | * Retrieves all the parameters for this body.
|
|---|
| 764 | * @returns The parameter names in a string array.
|
|---|
| 765 | */
|
|---|
| 766 | HttpParams.prototype.keys = function () {
|
|---|
| 767 | this.init();
|
|---|
| 768 | return Array.from(this.map.keys());
|
|---|
| 769 | };
|
|---|
| 770 | /**
|
|---|
| 771 | * Appends a new value to existing values for a parameter.
|
|---|
| 772 | * @param param The parameter name.
|
|---|
| 773 | * @param value The new value to add.
|
|---|
| 774 | * @return A new body with the appended value.
|
|---|
| 775 | */
|
|---|
| 776 | HttpParams.prototype.append = function (param, value) {
|
|---|
| 777 | return this.clone({ param: param, value: value, op: 'a' });
|
|---|
| 778 | };
|
|---|
| 779 | /**
|
|---|
| 780 | * Constructs a new body with appended values for the given parameter name.
|
|---|
| 781 | * @param params parameters and values
|
|---|
| 782 | * @return A new body with the new value.
|
|---|
| 783 | */
|
|---|
| 784 | HttpParams.prototype.appendAll = function (params) {
|
|---|
| 785 | var updates = [];
|
|---|
| 786 | Object.keys(params).forEach(function (param) {
|
|---|
| 787 | var value = params[param];
|
|---|
| 788 | if (Array.isArray(value)) {
|
|---|
| 789 | value.forEach(function (_value) {
|
|---|
| 790 | updates.push({ param: param, value: _value, op: 'a' });
|
|---|
| 791 | });
|
|---|
| 792 | }
|
|---|
| 793 | else {
|
|---|
| 794 | updates.push({ param: param, value: value, op: 'a' });
|
|---|
| 795 | }
|
|---|
| 796 | });
|
|---|
| 797 | return this.clone(updates);
|
|---|
| 798 | };
|
|---|
| 799 | /**
|
|---|
| 800 | * Replaces the value for a parameter.
|
|---|
| 801 | * @param param The parameter name.
|
|---|
| 802 | * @param value The new value.
|
|---|
| 803 | * @return A new body with the new value.
|
|---|
| 804 | */
|
|---|
| 805 | HttpParams.prototype.set = function (param, value) {
|
|---|
| 806 | return this.clone({ param: param, value: value, op: 's' });
|
|---|
| 807 | };
|
|---|
| 808 | /**
|
|---|
| 809 | * Removes a given value or all values from a parameter.
|
|---|
| 810 | * @param param The parameter name.
|
|---|
| 811 | * @param value The value to remove, if provided.
|
|---|
| 812 | * @return A new body with the given value removed, or with all values
|
|---|
| 813 | * removed if no value is specified.
|
|---|
| 814 | */
|
|---|
| 815 | HttpParams.prototype.delete = function (param, value) {
|
|---|
| 816 | return this.clone({ param: param, value: value, op: 'd' });
|
|---|
| 817 | };
|
|---|
| 818 | /**
|
|---|
| 819 | * Serializes the body to an encoded string, where key-value pairs (separated by `=`) are
|
|---|
| 820 | * separated by `&`s.
|
|---|
| 821 | */
|
|---|
| 822 | HttpParams.prototype.toString = function () {
|
|---|
| 823 | var _this = this;
|
|---|
| 824 | this.init();
|
|---|
| 825 | return this.keys()
|
|---|
| 826 | .map(function (key) {
|
|---|
| 827 | var eKey = _this.encoder.encodeKey(key);
|
|---|
| 828 | // `a: ['1']` produces `'a=1'`
|
|---|
| 829 | // `b: []` produces `''`
|
|---|
| 830 | // `c: ['1', '2']` produces `'c=1&c=2'`
|
|---|
| 831 | return _this.map.get(key).map(function (value) { return eKey + '=' + _this.encoder.encodeValue(value); })
|
|---|
| 832 | .join('&');
|
|---|
| 833 | })
|
|---|
| 834 | // filter out empty values because `b: []` produces `''`
|
|---|
| 835 | // which results in `a=1&&c=1&c=2` instead of `a=1&c=1&c=2` if we don't
|
|---|
| 836 | .filter(function (param) { return param !== ''; })
|
|---|
| 837 | .join('&');
|
|---|
| 838 | };
|
|---|
| 839 | HttpParams.prototype.clone = function (update) {
|
|---|
| 840 | var clone = new HttpParams({ encoder: this.encoder });
|
|---|
| 841 | clone.cloneFrom = this.cloneFrom || this;
|
|---|
| 842 | clone.updates = (this.updates || []).concat(update);
|
|---|
| 843 | return clone;
|
|---|
| 844 | };
|
|---|
| 845 | HttpParams.prototype.init = function () {
|
|---|
| 846 | var _this = this;
|
|---|
| 847 | if (this.map === null) {
|
|---|
| 848 | this.map = new Map();
|
|---|
| 849 | }
|
|---|
| 850 | if (this.cloneFrom !== null) {
|
|---|
| 851 | this.cloneFrom.init();
|
|---|
| 852 | this.cloneFrom.keys().forEach(function (key) { return _this.map.set(key, _this.cloneFrom.map.get(key)); });
|
|---|
| 853 | this.updates.forEach(function (update) {
|
|---|
| 854 | switch (update.op) {
|
|---|
| 855 | case 'a':
|
|---|
| 856 | case 's':
|
|---|
| 857 | var base = (update.op === 'a' ? _this.map.get(update.param) : undefined) || [];
|
|---|
| 858 | base.push(valueToString(update.value));
|
|---|
| 859 | _this.map.set(update.param, base);
|
|---|
| 860 | break;
|
|---|
| 861 | case 'd':
|
|---|
| 862 | if (update.value !== undefined) {
|
|---|
| 863 | var base_1 = _this.map.get(update.param) || [];
|
|---|
| 864 | var idx = base_1.indexOf(valueToString(update.value));
|
|---|
| 865 | if (idx !== -1) {
|
|---|
| 866 | base_1.splice(idx, 1);
|
|---|
| 867 | }
|
|---|
| 868 | if (base_1.length > 0) {
|
|---|
| 869 | _this.map.set(update.param, base_1);
|
|---|
| 870 | }
|
|---|
| 871 | else {
|
|---|
| 872 | _this.map.delete(update.param);
|
|---|
| 873 | }
|
|---|
| 874 | }
|
|---|
| 875 | else {
|
|---|
| 876 | _this.map.delete(update.param);
|
|---|
| 877 | break;
|
|---|
| 878 | }
|
|---|
| 879 | }
|
|---|
| 880 | });
|
|---|
| 881 | this.cloneFrom = this.updates = null;
|
|---|
| 882 | }
|
|---|
| 883 | };
|
|---|
| 884 | return HttpParams;
|
|---|
| 885 | }());
|
|---|
| 886 |
|
|---|
| 887 | /**
|
|---|
| 888 | * @license
|
|---|
| 889 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 890 | *
|
|---|
| 891 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 892 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 893 | */
|
|---|
| 894 | /**
|
|---|
| 895 | * A token used to manipulate and access values stored in `HttpContext`.
|
|---|
| 896 | *
|
|---|
| 897 | * @publicApi
|
|---|
| 898 | */
|
|---|
| 899 | var HttpContextToken = /** @class */ (function () {
|
|---|
| 900 | function HttpContextToken(defaultValue) {
|
|---|
| 901 | this.defaultValue = defaultValue;
|
|---|
| 902 | }
|
|---|
| 903 | return HttpContextToken;
|
|---|
| 904 | }());
|
|---|
| 905 | /**
|
|---|
| 906 | * Http context stores arbitrary user defined values and ensures type safety without
|
|---|
| 907 | * actually knowing the types. It is backed by a `Map` and guarantees that keys do not clash.
|
|---|
| 908 | *
|
|---|
| 909 | * This context is mutable and is shared between cloned requests unless explicitly specified.
|
|---|
| 910 | *
|
|---|
| 911 | * @usageNotes
|
|---|
| 912 | *
|
|---|
| 913 | * ### Usage Example
|
|---|
| 914 | *
|
|---|
| 915 | * ```typescript
|
|---|
| 916 | * // inside cache.interceptors.ts
|
|---|
| 917 | * export const IS_CACHE_ENABLED = new HttpContextToken<boolean>(() => false);
|
|---|
| 918 | *
|
|---|
| 919 | * export class CacheInterceptor implements HttpInterceptor {
|
|---|
| 920 | *
|
|---|
| 921 | * intercept(req: HttpRequest<any>, delegate: HttpHandler): Observable<HttpEvent<any>> {
|
|---|
| 922 | * if (req.context.get(IS_CACHE_ENABLED) === true) {
|
|---|
| 923 | * return ...;
|
|---|
| 924 | * }
|
|---|
| 925 | * return delegate.handle(req);
|
|---|
| 926 | * }
|
|---|
| 927 | * }
|
|---|
| 928 | *
|
|---|
| 929 | * // inside a service
|
|---|
| 930 | *
|
|---|
| 931 | * this.httpClient.get('/api/weather', {
|
|---|
| 932 | * context: new HttpContext().set(IS_CACHE_ENABLED, true)
|
|---|
| 933 | * }).subscribe(...);
|
|---|
| 934 | * ```
|
|---|
| 935 | *
|
|---|
| 936 | * @publicApi
|
|---|
| 937 | */
|
|---|
| 938 | var HttpContext = /** @class */ (function () {
|
|---|
| 939 | function HttpContext() {
|
|---|
| 940 | this.map = new Map();
|
|---|
| 941 | }
|
|---|
| 942 | /**
|
|---|
| 943 | * Store a value in the context. If a value is already present it will be overwritten.
|
|---|
| 944 | *
|
|---|
| 945 | * @param token The reference to an instance of `HttpContextToken`.
|
|---|
| 946 | * @param value The value to store.
|
|---|
| 947 | *
|
|---|
| 948 | * @returns A reference to itself for easy chaining.
|
|---|
| 949 | */
|
|---|
| 950 | HttpContext.prototype.set = function (token, value) {
|
|---|
| 951 | this.map.set(token, value);
|
|---|
| 952 | return this;
|
|---|
| 953 | };
|
|---|
| 954 | /**
|
|---|
| 955 | * Retrieve the value associated with the given token.
|
|---|
| 956 | *
|
|---|
| 957 | * @param token The reference to an instance of `HttpContextToken`.
|
|---|
| 958 | *
|
|---|
| 959 | * @returns The stored value or default if one is defined.
|
|---|
| 960 | */
|
|---|
| 961 | HttpContext.prototype.get = function (token) {
|
|---|
| 962 | if (!this.map.has(token)) {
|
|---|
| 963 | this.map.set(token, token.defaultValue());
|
|---|
| 964 | }
|
|---|
| 965 | return this.map.get(token);
|
|---|
| 966 | };
|
|---|
| 967 | /**
|
|---|
| 968 | * Delete the value associated with the given token.
|
|---|
| 969 | *
|
|---|
| 970 | * @param token The reference to an instance of `HttpContextToken`.
|
|---|
| 971 | *
|
|---|
| 972 | * @returns A reference to itself for easy chaining.
|
|---|
| 973 | */
|
|---|
| 974 | HttpContext.prototype.delete = function (token) {
|
|---|
| 975 | this.map.delete(token);
|
|---|
| 976 | return this;
|
|---|
| 977 | };
|
|---|
| 978 | /**
|
|---|
| 979 | * @returns a list of tokens currently stored in the context.
|
|---|
| 980 | */
|
|---|
| 981 | HttpContext.prototype.keys = function () {
|
|---|
| 982 | return this.map.keys();
|
|---|
| 983 | };
|
|---|
| 984 | return HttpContext;
|
|---|
| 985 | }());
|
|---|
| 986 |
|
|---|
| 987 | /**
|
|---|
| 988 | * @license
|
|---|
| 989 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 990 | *
|
|---|
| 991 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 992 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 993 | */
|
|---|
| 994 | /**
|
|---|
| 995 | * Determine whether the given HTTP method may include a body.
|
|---|
| 996 | */
|
|---|
| 997 | function mightHaveBody(method) {
|
|---|
| 998 | switch (method) {
|
|---|
| 999 | case 'DELETE':
|
|---|
| 1000 | case 'GET':
|
|---|
| 1001 | case 'HEAD':
|
|---|
| 1002 | case 'OPTIONS':
|
|---|
| 1003 | case 'JSONP':
|
|---|
| 1004 | return false;
|
|---|
| 1005 | default:
|
|---|
| 1006 | return true;
|
|---|
| 1007 | }
|
|---|
| 1008 | }
|
|---|
| 1009 | /**
|
|---|
| 1010 | * Safely assert whether the given value is an ArrayBuffer.
|
|---|
| 1011 | *
|
|---|
| 1012 | * In some execution environments ArrayBuffer is not defined.
|
|---|
| 1013 | */
|
|---|
| 1014 | function isArrayBuffer(value) {
|
|---|
| 1015 | return typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer;
|
|---|
| 1016 | }
|
|---|
| 1017 | /**
|
|---|
| 1018 | * Safely assert whether the given value is a Blob.
|
|---|
| 1019 | *
|
|---|
| 1020 | * In some execution environments Blob is not defined.
|
|---|
| 1021 | */
|
|---|
| 1022 | function isBlob(value) {
|
|---|
| 1023 | return typeof Blob !== 'undefined' && value instanceof Blob;
|
|---|
| 1024 | }
|
|---|
| 1025 | /**
|
|---|
| 1026 | * Safely assert whether the given value is a FormData instance.
|
|---|
| 1027 | *
|
|---|
| 1028 | * In some execution environments FormData is not defined.
|
|---|
| 1029 | */
|
|---|
| 1030 | function isFormData(value) {
|
|---|
| 1031 | return typeof FormData !== 'undefined' && value instanceof FormData;
|
|---|
| 1032 | }
|
|---|
| 1033 | /**
|
|---|
| 1034 | * Safely assert whether the given value is a URLSearchParams instance.
|
|---|
| 1035 | *
|
|---|
| 1036 | * In some execution environments URLSearchParams is not defined.
|
|---|
| 1037 | */
|
|---|
| 1038 | function isUrlSearchParams(value) {
|
|---|
| 1039 | return typeof URLSearchParams !== 'undefined' && value instanceof URLSearchParams;
|
|---|
| 1040 | }
|
|---|
| 1041 | /**
|
|---|
| 1042 | * An outgoing HTTP request with an optional typed body.
|
|---|
| 1043 | *
|
|---|
| 1044 | * `HttpRequest` represents an outgoing request, including URL, method,
|
|---|
| 1045 | * headers, body, and other request configuration options. Instances should be
|
|---|
| 1046 | * assumed to be immutable. To modify a `HttpRequest`, the `clone`
|
|---|
| 1047 | * method should be used.
|
|---|
| 1048 | *
|
|---|
| 1049 | * @publicApi
|
|---|
| 1050 | */
|
|---|
| 1051 | var HttpRequest = /** @class */ (function () {
|
|---|
| 1052 | function HttpRequest(method, url, third, fourth) {
|
|---|
| 1053 | this.url = url;
|
|---|
| 1054 | /**
|
|---|
| 1055 | * The request body, or `null` if one isn't set.
|
|---|
| 1056 | *
|
|---|
| 1057 | * Bodies are not enforced to be immutable, as they can include a reference to any
|
|---|
| 1058 | * user-defined data type. However, interceptors should take care to preserve
|
|---|
| 1059 | * idempotence by treating them as such.
|
|---|
| 1060 | */
|
|---|
| 1061 | this.body = null;
|
|---|
| 1062 | /**
|
|---|
| 1063 | * Whether this request should be made in a way that exposes progress events.
|
|---|
| 1064 | *
|
|---|
| 1065 | * Progress events are expensive (change detection runs on each event) and so
|
|---|
| 1066 | * they should only be requested if the consumer intends to monitor them.
|
|---|
| 1067 | */
|
|---|
| 1068 | this.reportProgress = false;
|
|---|
| 1069 | /**
|
|---|
| 1070 | * Whether this request should be sent with outgoing credentials (cookies).
|
|---|
| 1071 | */
|
|---|
| 1072 | this.withCredentials = false;
|
|---|
| 1073 | /**
|
|---|
| 1074 | * The expected response type of the server.
|
|---|
| 1075 | *
|
|---|
| 1076 | * This is used to parse the response appropriately before returning it to
|
|---|
| 1077 | * the requestee.
|
|---|
| 1078 | */
|
|---|
| 1079 | this.responseType = 'json';
|
|---|
| 1080 | this.method = method.toUpperCase();
|
|---|
| 1081 | // Next, need to figure out which argument holds the HttpRequestInit
|
|---|
| 1082 | // options, if any.
|
|---|
| 1083 | var options;
|
|---|
| 1084 | // Check whether a body argument is expected. The only valid way to omit
|
|---|
| 1085 | // the body argument is to use a known no-body method like GET.
|
|---|
| 1086 | if (mightHaveBody(this.method) || !!fourth) {
|
|---|
| 1087 | // Body is the third argument, options are the fourth.
|
|---|
| 1088 | this.body = (third !== undefined) ? third : null;
|
|---|
| 1089 | options = fourth;
|
|---|
| 1090 | }
|
|---|
| 1091 | else {
|
|---|
| 1092 | // No body required, options are the third argument. The body stays null.
|
|---|
| 1093 | options = third;
|
|---|
| 1094 | }
|
|---|
| 1095 | // If options have been passed, interpret them.
|
|---|
| 1096 | if (options) {
|
|---|
| 1097 | // Normalize reportProgress and withCredentials.
|
|---|
| 1098 | this.reportProgress = !!options.reportProgress;
|
|---|
| 1099 | this.withCredentials = !!options.withCredentials;
|
|---|
| 1100 | // Override default response type of 'json' if one is provided.
|
|---|
| 1101 | if (!!options.responseType) {
|
|---|
| 1102 | this.responseType = options.responseType;
|
|---|
| 1103 | }
|
|---|
| 1104 | // Override headers if they're provided.
|
|---|
| 1105 | if (!!options.headers) {
|
|---|
| 1106 | this.headers = options.headers;
|
|---|
| 1107 | }
|
|---|
| 1108 | if (!!options.context) {
|
|---|
| 1109 | this.context = options.context;
|
|---|
| 1110 | }
|
|---|
| 1111 | if (!!options.params) {
|
|---|
| 1112 | this.params = options.params;
|
|---|
| 1113 | }
|
|---|
| 1114 | }
|
|---|
| 1115 | // If no headers have been passed in, construct a new HttpHeaders instance.
|
|---|
| 1116 | if (!this.headers) {
|
|---|
| 1117 | this.headers = new HttpHeaders();
|
|---|
| 1118 | }
|
|---|
| 1119 | // If no context have been passed in, construct a new HttpContext instance.
|
|---|
| 1120 | if (!this.context) {
|
|---|
| 1121 | this.context = new HttpContext();
|
|---|
| 1122 | }
|
|---|
| 1123 | // If no parameters have been passed in, construct a new HttpUrlEncodedParams instance.
|
|---|
| 1124 | if (!this.params) {
|
|---|
| 1125 | this.params = new HttpParams();
|
|---|
| 1126 | this.urlWithParams = url;
|
|---|
| 1127 | }
|
|---|
| 1128 | else {
|
|---|
| 1129 | // Encode the parameters to a string in preparation for inclusion in the URL.
|
|---|
| 1130 | var params = this.params.toString();
|
|---|
| 1131 | if (params.length === 0) {
|
|---|
| 1132 | // No parameters, the visible URL is just the URL given at creation time.
|
|---|
| 1133 | this.urlWithParams = url;
|
|---|
| 1134 | }
|
|---|
| 1135 | else {
|
|---|
| 1136 | // Does the URL already have query parameters? Look for '?'.
|
|---|
| 1137 | var qIdx = url.indexOf('?');
|
|---|
| 1138 | // There are 3 cases to handle:
|
|---|
| 1139 | // 1) No existing parameters -> append '?' followed by params.
|
|---|
| 1140 | // 2) '?' exists and is followed by existing query string ->
|
|---|
| 1141 | // append '&' followed by params.
|
|---|
| 1142 | // 3) '?' exists at the end of the url -> append params directly.
|
|---|
| 1143 | // This basically amounts to determining the character, if any, with
|
|---|
| 1144 | // which to join the URL and parameters.
|
|---|
| 1145 | var sep = qIdx === -1 ? '?' : (qIdx < url.length - 1 ? '&' : '');
|
|---|
| 1146 | this.urlWithParams = url + sep + params;
|
|---|
| 1147 | }
|
|---|
| 1148 | }
|
|---|
| 1149 | }
|
|---|
| 1150 | /**
|
|---|
| 1151 | * Transform the free-form body into a serialized format suitable for
|
|---|
| 1152 | * transmission to the server.
|
|---|
| 1153 | */
|
|---|
| 1154 | HttpRequest.prototype.serializeBody = function () {
|
|---|
| 1155 | // If no body is present, no need to serialize it.
|
|---|
| 1156 | if (this.body === null) {
|
|---|
| 1157 | return null;
|
|---|
| 1158 | }
|
|---|
| 1159 | // Check whether the body is already in a serialized form. If so,
|
|---|
| 1160 | // it can just be returned directly.
|
|---|
| 1161 | if (isArrayBuffer(this.body) || isBlob(this.body) || isFormData(this.body) ||
|
|---|
| 1162 | isUrlSearchParams(this.body) || typeof this.body === 'string') {
|
|---|
| 1163 | return this.body;
|
|---|
| 1164 | }
|
|---|
| 1165 | // Check whether the body is an instance of HttpUrlEncodedParams.
|
|---|
| 1166 | if (this.body instanceof HttpParams) {
|
|---|
| 1167 | return this.body.toString();
|
|---|
| 1168 | }
|
|---|
| 1169 | // Check whether the body is an object or array, and serialize with JSON if so.
|
|---|
| 1170 | if (typeof this.body === 'object' || typeof this.body === 'boolean' ||
|
|---|
| 1171 | Array.isArray(this.body)) {
|
|---|
| 1172 | return JSON.stringify(this.body);
|
|---|
| 1173 | }
|
|---|
| 1174 | // Fall back on toString() for everything else.
|
|---|
| 1175 | return this.body.toString();
|
|---|
| 1176 | };
|
|---|
| 1177 | /**
|
|---|
| 1178 | * Examine the body and attempt to infer an appropriate MIME type
|
|---|
| 1179 | * for it.
|
|---|
| 1180 | *
|
|---|
| 1181 | * If no such type can be inferred, this method will return `null`.
|
|---|
| 1182 | */
|
|---|
| 1183 | HttpRequest.prototype.detectContentTypeHeader = function () {
|
|---|
| 1184 | // An empty body has no content type.
|
|---|
| 1185 | if (this.body === null) {
|
|---|
| 1186 | return null;
|
|---|
| 1187 | }
|
|---|
| 1188 | // FormData bodies rely on the browser's content type assignment.
|
|---|
| 1189 | if (isFormData(this.body)) {
|
|---|
| 1190 | return null;
|
|---|
| 1191 | }
|
|---|
| 1192 | // Blobs usually have their own content type. If it doesn't, then
|
|---|
| 1193 | // no type can be inferred.
|
|---|
| 1194 | if (isBlob(this.body)) {
|
|---|
| 1195 | return this.body.type || null;
|
|---|
| 1196 | }
|
|---|
| 1197 | // Array buffers have unknown contents and thus no type can be inferred.
|
|---|
| 1198 | if (isArrayBuffer(this.body)) {
|
|---|
| 1199 | return null;
|
|---|
| 1200 | }
|
|---|
| 1201 | // Technically, strings could be a form of JSON data, but it's safe enough
|
|---|
| 1202 | // to assume they're plain strings.
|
|---|
| 1203 | if (typeof this.body === 'string') {
|
|---|
| 1204 | return 'text/plain';
|
|---|
| 1205 | }
|
|---|
| 1206 | // `HttpUrlEncodedParams` has its own content-type.
|
|---|
| 1207 | if (this.body instanceof HttpParams) {
|
|---|
| 1208 | return 'application/x-www-form-urlencoded;charset=UTF-8';
|
|---|
| 1209 | }
|
|---|
| 1210 | // Arrays, objects, boolean and numbers will be encoded as JSON.
|
|---|
| 1211 | if (typeof this.body === 'object' || typeof this.body === 'number' ||
|
|---|
| 1212 | typeof this.body === 'boolean') {
|
|---|
| 1213 | return 'application/json';
|
|---|
| 1214 | }
|
|---|
| 1215 | // No type could be inferred.
|
|---|
| 1216 | return null;
|
|---|
| 1217 | };
|
|---|
| 1218 | HttpRequest.prototype.clone = function (update) {
|
|---|
| 1219 | if (update === void 0) { update = {}; }
|
|---|
| 1220 | var _a;
|
|---|
| 1221 | // For method, url, and responseType, take the current value unless
|
|---|
| 1222 | // it is overridden in the update hash.
|
|---|
| 1223 | var method = update.method || this.method;
|
|---|
| 1224 | var url = update.url || this.url;
|
|---|
| 1225 | var responseType = update.responseType || this.responseType;
|
|---|
| 1226 | // The body is somewhat special - a `null` value in update.body means
|
|---|
| 1227 | // whatever current body is present is being overridden with an empty
|
|---|
| 1228 | // body, whereas an `undefined` value in update.body implies no
|
|---|
| 1229 | // override.
|
|---|
| 1230 | var body = (update.body !== undefined) ? update.body : this.body;
|
|---|
| 1231 | // Carefully handle the boolean options to differentiate between
|
|---|
| 1232 | // `false` and `undefined` in the update args.
|
|---|
| 1233 | var withCredentials = (update.withCredentials !== undefined) ? update.withCredentials : this.withCredentials;
|
|---|
| 1234 | var reportProgress = (update.reportProgress !== undefined) ? update.reportProgress : this.reportProgress;
|
|---|
| 1235 | // Headers and params may be appended to if `setHeaders` or
|
|---|
| 1236 | // `setParams` are used.
|
|---|
| 1237 | var headers = update.headers || this.headers;
|
|---|
| 1238 | var params = update.params || this.params;
|
|---|
| 1239 | // Pass on context if needed
|
|---|
| 1240 | var context = (_a = update.context) !== null && _a !== void 0 ? _a : this.context;
|
|---|
| 1241 | // Check whether the caller has asked to add headers.
|
|---|
| 1242 | if (update.setHeaders !== undefined) {
|
|---|
| 1243 | // Set every requested header.
|
|---|
| 1244 | headers =
|
|---|
| 1245 | Object.keys(update.setHeaders)
|
|---|
| 1246 | .reduce(function (headers, name) { return headers.set(name, update.setHeaders[name]); }, headers);
|
|---|
| 1247 | }
|
|---|
| 1248 | // Check whether the caller has asked to set params.
|
|---|
| 1249 | if (update.setParams) {
|
|---|
| 1250 | // Set every requested param.
|
|---|
| 1251 | params = Object.keys(update.setParams)
|
|---|
| 1252 | .reduce(function (params, param) { return params.set(param, update.setParams[param]); }, params);
|
|---|
| 1253 | }
|
|---|
| 1254 | // Finally, construct the new HttpRequest using the pieces from above.
|
|---|
| 1255 | return new HttpRequest(method, url, body, {
|
|---|
| 1256 | params: params,
|
|---|
| 1257 | headers: headers,
|
|---|
| 1258 | context: context,
|
|---|
| 1259 | reportProgress: reportProgress,
|
|---|
| 1260 | responseType: responseType,
|
|---|
| 1261 | withCredentials: withCredentials,
|
|---|
| 1262 | });
|
|---|
| 1263 | };
|
|---|
| 1264 | return HttpRequest;
|
|---|
| 1265 | }());
|
|---|
| 1266 |
|
|---|
| 1267 | (function (HttpEventType) {
|
|---|
| 1268 | /**
|
|---|
| 1269 | * The request was sent out over the wire.
|
|---|
| 1270 | */
|
|---|
| 1271 | HttpEventType[HttpEventType["Sent"] = 0] = "Sent";
|
|---|
| 1272 | /**
|
|---|
| 1273 | * An upload progress event was received.
|
|---|
| 1274 | */
|
|---|
| 1275 | HttpEventType[HttpEventType["UploadProgress"] = 1] = "UploadProgress";
|
|---|
| 1276 | /**
|
|---|
| 1277 | * The response status code and headers were received.
|
|---|
| 1278 | */
|
|---|
| 1279 | HttpEventType[HttpEventType["ResponseHeader"] = 2] = "ResponseHeader";
|
|---|
| 1280 | /**
|
|---|
| 1281 | * A download progress event was received.
|
|---|
| 1282 | */
|
|---|
| 1283 | HttpEventType[HttpEventType["DownloadProgress"] = 3] = "DownloadProgress";
|
|---|
| 1284 | /**
|
|---|
| 1285 | * The full response including the body was received.
|
|---|
| 1286 | */
|
|---|
| 1287 | HttpEventType[HttpEventType["Response"] = 4] = "Response";
|
|---|
| 1288 | /**
|
|---|
| 1289 | * A custom event from an interceptor or a backend.
|
|---|
| 1290 | */
|
|---|
| 1291 | HttpEventType[HttpEventType["User"] = 5] = "User";
|
|---|
| 1292 | })(exports.HttpEventType || (exports.HttpEventType = {}));
|
|---|
| 1293 | /**
|
|---|
| 1294 | * Base class for both `HttpResponse` and `HttpHeaderResponse`.
|
|---|
| 1295 | *
|
|---|
| 1296 | * @publicApi
|
|---|
| 1297 | */
|
|---|
| 1298 | var HttpResponseBase = /** @class */ (function () {
|
|---|
| 1299 | /**
|
|---|
| 1300 | * Super-constructor for all responses.
|
|---|
| 1301 | *
|
|---|
| 1302 | * The single parameter accepted is an initialization hash. Any properties
|
|---|
| 1303 | * of the response passed there will override the default values.
|
|---|
| 1304 | */
|
|---|
| 1305 | function HttpResponseBase(init, defaultStatus /* Ok */, defaultStatusText) {
|
|---|
| 1306 | if (defaultStatus === void 0) { defaultStatus = 200; }
|
|---|
| 1307 | if (defaultStatusText === void 0) { defaultStatusText = 'OK'; }
|
|---|
| 1308 | // If the hash has values passed, use them to initialize the response.
|
|---|
| 1309 | // Otherwise use the default values.
|
|---|
| 1310 | this.headers = init.headers || new HttpHeaders();
|
|---|
| 1311 | this.status = init.status !== undefined ? init.status : defaultStatus;
|
|---|
| 1312 | this.statusText = init.statusText || defaultStatusText;
|
|---|
| 1313 | this.url = init.url || null;
|
|---|
| 1314 | // Cache the ok value to avoid defining a getter.
|
|---|
| 1315 | this.ok = this.status >= 200 && this.status < 300;
|
|---|
| 1316 | }
|
|---|
| 1317 | return HttpResponseBase;
|
|---|
| 1318 | }());
|
|---|
| 1319 | /**
|
|---|
| 1320 | * A partial HTTP response which only includes the status and header data,
|
|---|
| 1321 | * but no response body.
|
|---|
| 1322 | *
|
|---|
| 1323 | * `HttpHeaderResponse` is a `HttpEvent` available on the response
|
|---|
| 1324 | * event stream, only when progress events are requested.
|
|---|
| 1325 | *
|
|---|
| 1326 | * @publicApi
|
|---|
| 1327 | */
|
|---|
| 1328 | var HttpHeaderResponse = /** @class */ (function (_super) {
|
|---|
| 1329 | __extends(HttpHeaderResponse, _super);
|
|---|
| 1330 | /**
|
|---|
| 1331 | * Create a new `HttpHeaderResponse` with the given parameters.
|
|---|
| 1332 | */
|
|---|
| 1333 | function HttpHeaderResponse(init) {
|
|---|
| 1334 | if (init === void 0) { init = {}; }
|
|---|
| 1335 | var _this = _super.call(this, init) || this;
|
|---|
| 1336 | _this.type = exports.HttpEventType.ResponseHeader;
|
|---|
| 1337 | return _this;
|
|---|
| 1338 | }
|
|---|
| 1339 | /**
|
|---|
| 1340 | * Copy this `HttpHeaderResponse`, overriding its contents with the
|
|---|
| 1341 | * given parameter hash.
|
|---|
| 1342 | */
|
|---|
| 1343 | HttpHeaderResponse.prototype.clone = function (update) {
|
|---|
| 1344 | if (update === void 0) { update = {}; }
|
|---|
| 1345 | // Perform a straightforward initialization of the new HttpHeaderResponse,
|
|---|
| 1346 | // overriding the current parameters with new ones if given.
|
|---|
| 1347 | return new HttpHeaderResponse({
|
|---|
| 1348 | headers: update.headers || this.headers,
|
|---|
| 1349 | status: update.status !== undefined ? update.status : this.status,
|
|---|
| 1350 | statusText: update.statusText || this.statusText,
|
|---|
| 1351 | url: update.url || this.url || undefined,
|
|---|
| 1352 | });
|
|---|
| 1353 | };
|
|---|
| 1354 | return HttpHeaderResponse;
|
|---|
| 1355 | }(HttpResponseBase));
|
|---|
| 1356 | /**
|
|---|
| 1357 | * A full HTTP response, including a typed response body (which may be `null`
|
|---|
| 1358 | * if one was not returned).
|
|---|
| 1359 | *
|
|---|
| 1360 | * `HttpResponse` is a `HttpEvent` available on the response event
|
|---|
| 1361 | * stream.
|
|---|
| 1362 | *
|
|---|
| 1363 | * @publicApi
|
|---|
| 1364 | */
|
|---|
| 1365 | var HttpResponse = /** @class */ (function (_super) {
|
|---|
| 1366 | __extends(HttpResponse, _super);
|
|---|
| 1367 | /**
|
|---|
| 1368 | * Construct a new `HttpResponse`.
|
|---|
| 1369 | */
|
|---|
| 1370 | function HttpResponse(init) {
|
|---|
| 1371 | if (init === void 0) { init = {}; }
|
|---|
| 1372 | var _this = _super.call(this, init) || this;
|
|---|
| 1373 | _this.type = exports.HttpEventType.Response;
|
|---|
| 1374 | _this.body = init.body !== undefined ? init.body : null;
|
|---|
| 1375 | return _this;
|
|---|
| 1376 | }
|
|---|
| 1377 | HttpResponse.prototype.clone = function (update) {
|
|---|
| 1378 | if (update === void 0) { update = {}; }
|
|---|
| 1379 | return new HttpResponse({
|
|---|
| 1380 | body: (update.body !== undefined) ? update.body : this.body,
|
|---|
| 1381 | headers: update.headers || this.headers,
|
|---|
| 1382 | status: (update.status !== undefined) ? update.status : this.status,
|
|---|
| 1383 | statusText: update.statusText || this.statusText,
|
|---|
| 1384 | url: update.url || this.url || undefined,
|
|---|
| 1385 | });
|
|---|
| 1386 | };
|
|---|
| 1387 | return HttpResponse;
|
|---|
| 1388 | }(HttpResponseBase));
|
|---|
| 1389 | /**
|
|---|
| 1390 | * A response that represents an error or failure, either from a
|
|---|
| 1391 | * non-successful HTTP status, an error while executing the request,
|
|---|
| 1392 | * or some other failure which occurred during the parsing of the response.
|
|---|
| 1393 | *
|
|---|
| 1394 | * Any error returned on the `Observable` response stream will be
|
|---|
| 1395 | * wrapped in an `HttpErrorResponse` to provide additional context about
|
|---|
| 1396 | * the state of the HTTP layer when the error occurred. The error property
|
|---|
| 1397 | * will contain either a wrapped Error object or the error response returned
|
|---|
| 1398 | * from the server.
|
|---|
| 1399 | *
|
|---|
| 1400 | * @publicApi
|
|---|
| 1401 | */
|
|---|
| 1402 | var HttpErrorResponse = /** @class */ (function (_super) {
|
|---|
| 1403 | __extends(HttpErrorResponse, _super);
|
|---|
| 1404 | function HttpErrorResponse(init) {
|
|---|
| 1405 | var _this =
|
|---|
| 1406 | // Initialize with a default status of 0 / Unknown Error.
|
|---|
| 1407 | _super.call(this, init, 0, 'Unknown Error') || this;
|
|---|
| 1408 | _this.name = 'HttpErrorResponse';
|
|---|
| 1409 | /**
|
|---|
| 1410 | * Errors are never okay, even when the status code is in the 2xx success range.
|
|---|
| 1411 | */
|
|---|
| 1412 | _this.ok = false;
|
|---|
| 1413 | // If the response was successful, then this was a parse error. Otherwise, it was
|
|---|
| 1414 | // a protocol-level failure of some sort. Either the request failed in transit
|
|---|
| 1415 | // or the server returned an unsuccessful status code.
|
|---|
| 1416 | if (_this.status >= 200 && _this.status < 300) {
|
|---|
| 1417 | _this.message = "Http failure during parsing for " + (init.url || '(unknown url)');
|
|---|
| 1418 | }
|
|---|
| 1419 | else {
|
|---|
| 1420 | _this.message = "Http failure response for " + (init.url || '(unknown url)') + ": " + init.status + " " + init.statusText;
|
|---|
| 1421 | }
|
|---|
| 1422 | _this.error = init.error || null;
|
|---|
| 1423 | return _this;
|
|---|
| 1424 | }
|
|---|
| 1425 | return HttpErrorResponse;
|
|---|
| 1426 | }(HttpResponseBase));
|
|---|
| 1427 |
|
|---|
| 1428 | /**
|
|---|
| 1429 | * @license
|
|---|
| 1430 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 1431 | *
|
|---|
| 1432 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 1433 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 1434 | */
|
|---|
| 1435 | /**
|
|---|
| 1436 | * Constructs an instance of `HttpRequestOptions<T>` from a source `HttpMethodOptions` and
|
|---|
| 1437 | * the given `body`. This function clones the object and adds the body.
|
|---|
| 1438 | *
|
|---|
| 1439 | * Note that the `responseType` *options* value is a String that identifies the
|
|---|
| 1440 | * single data type of the response.
|
|---|
| 1441 | * A single overload version of the method handles each response type.
|
|---|
| 1442 | * The value of `responseType` cannot be a union, as the combined signature could imply.
|
|---|
| 1443 | *
|
|---|
| 1444 | */
|
|---|
| 1445 | function addBody(options, body) {
|
|---|
| 1446 | return {
|
|---|
| 1447 | body: body,
|
|---|
| 1448 | headers: options.headers,
|
|---|
| 1449 | context: options.context,
|
|---|
| 1450 | observe: options.observe,
|
|---|
| 1451 | params: options.params,
|
|---|
| 1452 | reportProgress: options.reportProgress,
|
|---|
| 1453 | responseType: options.responseType,
|
|---|
| 1454 | withCredentials: options.withCredentials,
|
|---|
| 1455 | };
|
|---|
| 1456 | }
|
|---|
| 1457 | /**
|
|---|
| 1458 | * Performs HTTP requests.
|
|---|
| 1459 | * This service is available as an injectable class, with methods to perform HTTP requests.
|
|---|
| 1460 | * Each request method has multiple signatures, and the return type varies based on
|
|---|
| 1461 | * the signature that is called (mainly the values of `observe` and `responseType`).
|
|---|
| 1462 | *
|
|---|
| 1463 | * Note that the `responseType` *options* value is a String that identifies the
|
|---|
| 1464 | * single data type of the response.
|
|---|
| 1465 | * A single overload version of the method handles each response type.
|
|---|
| 1466 | * The value of `responseType` cannot be a union, as the combined signature could imply.
|
|---|
| 1467 |
|
|---|
| 1468 | *
|
|---|
| 1469 | * @usageNotes
|
|---|
| 1470 | * Sample HTTP requests for the [Tour of Heroes](/tutorial/toh-pt0) application.
|
|---|
| 1471 | *
|
|---|
| 1472 | * ### HTTP Request Example
|
|---|
| 1473 | *
|
|---|
| 1474 | * ```
|
|---|
| 1475 | * // GET heroes whose name contains search term
|
|---|
| 1476 | * searchHeroes(term: string): observable<Hero[]>{
|
|---|
| 1477 | *
|
|---|
| 1478 | * const params = new HttpParams({fromString: 'name=term'});
|
|---|
| 1479 | * return this.httpClient.request('GET', this.heroesUrl, {responseType:'json', params});
|
|---|
| 1480 | * }
|
|---|
| 1481 | * ```
|
|---|
| 1482 | *
|
|---|
| 1483 | * Alternatively, the parameter string can be used without invoking HttpParams
|
|---|
| 1484 | * by directly joining to the URL.
|
|---|
| 1485 | * ```
|
|---|
| 1486 | * this.httpClient.request('GET', this.heroesUrl + '?' + 'name=term', {responseType:'json'});
|
|---|
| 1487 | * ```
|
|---|
| 1488 | *
|
|---|
| 1489 | *
|
|---|
| 1490 | * ### JSONP Example
|
|---|
| 1491 | * ```
|
|---|
| 1492 | * requestJsonp(url, callback = 'callback') {
|
|---|
| 1493 | * return this.httpClient.jsonp(this.heroesURL, callback);
|
|---|
| 1494 | * }
|
|---|
| 1495 | * ```
|
|---|
| 1496 | *
|
|---|
| 1497 | * ### PATCH Example
|
|---|
| 1498 | * ```
|
|---|
| 1499 | * // PATCH one of the heroes' name
|
|---|
| 1500 | * patchHero (id: number, heroName: string): Observable<{}> {
|
|---|
| 1501 | * const url = `${this.heroesUrl}/${id}`; // PATCH api/heroes/42
|
|---|
| 1502 | * return this.httpClient.patch(url, {name: heroName}, httpOptions)
|
|---|
| 1503 | * .pipe(catchError(this.handleError('patchHero')));
|
|---|
| 1504 | * }
|
|---|
| 1505 | * ```
|
|---|
| 1506 | *
|
|---|
| 1507 | * @see [HTTP Guide](guide/http)
|
|---|
| 1508 | * @see [HTTP Request](api/common/http/HttpRequest)
|
|---|
| 1509 | *
|
|---|
| 1510 | * @publicApi
|
|---|
| 1511 | */
|
|---|
| 1512 | var HttpClient = /** @class */ (function () {
|
|---|
| 1513 | function HttpClient(handler) {
|
|---|
| 1514 | this.handler = handler;
|
|---|
| 1515 | }
|
|---|
| 1516 | /**
|
|---|
| 1517 | * Constructs an observable for a generic HTTP request that, when subscribed,
|
|---|
| 1518 | * fires the request through the chain of registered interceptors and on to the
|
|---|
| 1519 | * server.
|
|---|
| 1520 | *
|
|---|
| 1521 | * You can pass an `HttpRequest` directly as the only parameter. In this case,
|
|---|
| 1522 | * the call returns an observable of the raw `HttpEvent` stream.
|
|---|
| 1523 | *
|
|---|
| 1524 | * Alternatively you can pass an HTTP method as the first parameter,
|
|---|
| 1525 | * a URL string as the second, and an options hash containing the request body as the third.
|
|---|
| 1526 | * See `addBody()`. In this case, the specified `responseType` and `observe` options determine the
|
|---|
| 1527 | * type of returned observable.
|
|---|
| 1528 | * * The `responseType` value determines how a successful response body is parsed.
|
|---|
| 1529 | * * If `responseType` is the default `json`, you can pass a type interface for the resulting
|
|---|
| 1530 | * object as a type parameter to the call.
|
|---|
| 1531 | *
|
|---|
| 1532 | * The `observe` value determines the return type, according to what you are interested in
|
|---|
| 1533 | * observing.
|
|---|
| 1534 | * * An `observe` value of events returns an observable of the raw `HttpEvent` stream, including
|
|---|
| 1535 | * progress events by default.
|
|---|
| 1536 | * * An `observe` value of response returns an observable of `HttpResponse<T>`,
|
|---|
| 1537 | * where the `T` parameter depends on the `responseType` and any optionally provided type
|
|---|
| 1538 | * parameter.
|
|---|
| 1539 | * * An `observe` value of body returns an observable of `<T>` with the same `T` body type.
|
|---|
| 1540 | *
|
|---|
| 1541 | */
|
|---|
| 1542 | HttpClient.prototype.request = function (first, url, options) {
|
|---|
| 1543 | var _this = this;
|
|---|
| 1544 | if (options === void 0) { options = {}; }
|
|---|
| 1545 | var req;
|
|---|
| 1546 | // First, check whether the primary argument is an instance of `HttpRequest`.
|
|---|
| 1547 | if (first instanceof HttpRequest) {
|
|---|
| 1548 | // It is. The other arguments must be undefined (per the signatures) and can be
|
|---|
| 1549 | // ignored.
|
|---|
| 1550 | req = first;
|
|---|
| 1551 | }
|
|---|
| 1552 | else {
|
|---|
| 1553 | // It's a string, so it represents a URL. Construct a request based on it,
|
|---|
| 1554 | // and incorporate the remaining arguments (assuming `GET` unless a method is
|
|---|
| 1555 | // provided.
|
|---|
| 1556 | // Figure out the headers.
|
|---|
| 1557 | var headers = undefined;
|
|---|
| 1558 | if (options.headers instanceof HttpHeaders) {
|
|---|
| 1559 | headers = options.headers;
|
|---|
| 1560 | }
|
|---|
| 1561 | else {
|
|---|
| 1562 | headers = new HttpHeaders(options.headers);
|
|---|
| 1563 | }
|
|---|
| 1564 | // Sort out parameters.
|
|---|
| 1565 | var params = undefined;
|
|---|
| 1566 | if (!!options.params) {
|
|---|
| 1567 | if (options.params instanceof HttpParams) {
|
|---|
| 1568 | params = options.params;
|
|---|
| 1569 | }
|
|---|
| 1570 | else {
|
|---|
| 1571 | params = new HttpParams({ fromObject: options.params });
|
|---|
| 1572 | }
|
|---|
| 1573 | }
|
|---|
| 1574 | // Construct the request.
|
|---|
| 1575 | req = new HttpRequest(first, url, (options.body !== undefined ? options.body : null), {
|
|---|
| 1576 | headers: headers,
|
|---|
| 1577 | context: options.context,
|
|---|
| 1578 | params: params,
|
|---|
| 1579 | reportProgress: options.reportProgress,
|
|---|
| 1580 | // By default, JSON is assumed to be returned for all calls.
|
|---|
| 1581 | responseType: options.responseType || 'json',
|
|---|
| 1582 | withCredentials: options.withCredentials,
|
|---|
| 1583 | });
|
|---|
| 1584 | }
|
|---|
| 1585 | // Start with an Observable.of() the initial request, and run the handler (which
|
|---|
| 1586 | // includes all interceptors) inside a concatMap(). This way, the handler runs
|
|---|
| 1587 | // inside an Observable chain, which causes interceptors to be re-run on every
|
|---|
| 1588 | // subscription (this also makes retries re-run the handler, including interceptors).
|
|---|
| 1589 | var events$ = rxjs.of(req).pipe(operators.concatMap(function (req) { return _this.handler.handle(req); }));
|
|---|
| 1590 | // If coming via the API signature which accepts a previously constructed HttpRequest,
|
|---|
| 1591 | // the only option is to get the event stream. Otherwise, return the event stream if
|
|---|
| 1592 | // that is what was requested.
|
|---|
| 1593 | if (first instanceof HttpRequest || options.observe === 'events') {
|
|---|
| 1594 | return events$;
|
|---|
| 1595 | }
|
|---|
| 1596 | // The requested stream contains either the full response or the body. In either
|
|---|
| 1597 | // case, the first step is to filter the event stream to extract a stream of
|
|---|
| 1598 | // responses(s).
|
|---|
| 1599 | var res$ = events$.pipe(operators.filter(function (event) { return event instanceof HttpResponse; }));
|
|---|
| 1600 | // Decide which stream to return.
|
|---|
| 1601 | switch (options.observe || 'body') {
|
|---|
| 1602 | case 'body':
|
|---|
| 1603 | // The requested stream is the body. Map the response stream to the response
|
|---|
| 1604 | // body. This could be done more simply, but a misbehaving interceptor might
|
|---|
| 1605 | // transform the response body into a different format and ignore the requested
|
|---|
| 1606 | // responseType. Guard against this by validating that the response is of the
|
|---|
| 1607 | // requested type.
|
|---|
| 1608 | switch (req.responseType) {
|
|---|
| 1609 | case 'arraybuffer':
|
|---|
| 1610 | return res$.pipe(operators.map(function (res) {
|
|---|
| 1611 | // Validate that the body is an ArrayBuffer.
|
|---|
| 1612 | if (res.body !== null && !(res.body instanceof ArrayBuffer)) {
|
|---|
| 1613 | throw new Error('Response is not an ArrayBuffer.');
|
|---|
| 1614 | }
|
|---|
| 1615 | return res.body;
|
|---|
| 1616 | }));
|
|---|
| 1617 | case 'blob':
|
|---|
| 1618 | return res$.pipe(operators.map(function (res) {
|
|---|
| 1619 | // Validate that the body is a Blob.
|
|---|
| 1620 | if (res.body !== null && !(res.body instanceof Blob)) {
|
|---|
| 1621 | throw new Error('Response is not a Blob.');
|
|---|
| 1622 | }
|
|---|
| 1623 | return res.body;
|
|---|
| 1624 | }));
|
|---|
| 1625 | case 'text':
|
|---|
| 1626 | return res$.pipe(operators.map(function (res) {
|
|---|
| 1627 | // Validate that the body is a string.
|
|---|
| 1628 | if (res.body !== null && typeof res.body !== 'string') {
|
|---|
| 1629 | throw new Error('Response is not a string.');
|
|---|
| 1630 | }
|
|---|
| 1631 | return res.body;
|
|---|
| 1632 | }));
|
|---|
| 1633 | case 'json':
|
|---|
| 1634 | default:
|
|---|
| 1635 | // No validation needed for JSON responses, as they can be of any type.
|
|---|
| 1636 | return res$.pipe(operators.map(function (res) { return res.body; }));
|
|---|
| 1637 | }
|
|---|
| 1638 | case 'response':
|
|---|
| 1639 | // The response stream was requested directly, so return it.
|
|---|
| 1640 | return res$;
|
|---|
| 1641 | default:
|
|---|
| 1642 | // Guard against new future observe types being added.
|
|---|
| 1643 | throw new Error("Unreachable: unhandled observe type " + options.observe + "}");
|
|---|
| 1644 | }
|
|---|
| 1645 | };
|
|---|
| 1646 | /**
|
|---|
| 1647 | * Constructs an observable that, when subscribed, causes the configured
|
|---|
| 1648 | * `DELETE` request to execute on the server. See the individual overloads for
|
|---|
| 1649 | * details on the return type.
|
|---|
| 1650 | *
|
|---|
| 1651 | * @param url The endpoint URL.
|
|---|
| 1652 | * @param options The HTTP options to send with the request.
|
|---|
| 1653 | *
|
|---|
| 1654 | */
|
|---|
| 1655 | HttpClient.prototype.delete = function (url, options) {
|
|---|
| 1656 | if (options === void 0) { options = {}; }
|
|---|
| 1657 | return this.request('DELETE', url, options);
|
|---|
| 1658 | };
|
|---|
| 1659 | /**
|
|---|
| 1660 | * Constructs an observable that, when subscribed, causes the configured
|
|---|
| 1661 | * `GET` request to execute on the server. See the individual overloads for
|
|---|
| 1662 | * details on the return type.
|
|---|
| 1663 | */
|
|---|
| 1664 | HttpClient.prototype.get = function (url, options) {
|
|---|
| 1665 | if (options === void 0) { options = {}; }
|
|---|
| 1666 | return this.request('GET', url, options);
|
|---|
| 1667 | };
|
|---|
| 1668 | /**
|
|---|
| 1669 | * Constructs an observable that, when subscribed, causes the configured
|
|---|
| 1670 | * `HEAD` request to execute on the server. The `HEAD` method returns
|
|---|
| 1671 | * meta information about the resource without transferring the
|
|---|
| 1672 | * resource itself. See the individual overloads for
|
|---|
| 1673 | * details on the return type.
|
|---|
| 1674 | */
|
|---|
| 1675 | HttpClient.prototype.head = function (url, options) {
|
|---|
| 1676 | if (options === void 0) { options = {}; }
|
|---|
| 1677 | return this.request('HEAD', url, options);
|
|---|
| 1678 | };
|
|---|
| 1679 | /**
|
|---|
| 1680 | * Constructs an `Observable` that, when subscribed, causes a request with the special method
|
|---|
| 1681 | * `JSONP` to be dispatched via the interceptor pipeline.
|
|---|
| 1682 | * The [JSONP pattern](https://en.wikipedia.org/wiki/JSONP) works around limitations of certain
|
|---|
| 1683 | * API endpoints that don't support newer,
|
|---|
| 1684 | * and preferable [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) protocol.
|
|---|
| 1685 | * JSONP treats the endpoint API as a JavaScript file and tricks the browser to process the
|
|---|
| 1686 | * requests even if the API endpoint is not located on the same domain (origin) as the client-side
|
|---|
| 1687 | * application making the request.
|
|---|
| 1688 | * The endpoint API must support JSONP callback for JSONP requests to work.
|
|---|
| 1689 | * The resource API returns the JSON response wrapped in a callback function.
|
|---|
| 1690 | * You can pass the callback function name as one of the query parameters.
|
|---|
| 1691 | * Note that JSONP requests can only be used with `GET` requests.
|
|---|
| 1692 | *
|
|---|
| 1693 | * @param url The resource URL.
|
|---|
| 1694 | * @param callbackParam The callback function name.
|
|---|
| 1695 | *
|
|---|
| 1696 | */
|
|---|
| 1697 | HttpClient.prototype.jsonp = function (url, callbackParam) {
|
|---|
| 1698 | return this.request('JSONP', url, {
|
|---|
| 1699 | params: new HttpParams().append(callbackParam, 'JSONP_CALLBACK'),
|
|---|
| 1700 | observe: 'body',
|
|---|
| 1701 | responseType: 'json',
|
|---|
| 1702 | });
|
|---|
| 1703 | };
|
|---|
| 1704 | /**
|
|---|
| 1705 | * Constructs an `Observable` that, when subscribed, causes the configured
|
|---|
| 1706 | * `OPTIONS` request to execute on the server. This method allows the client
|
|---|
| 1707 | * to determine the supported HTTP methods and other capabilities of an endpoint,
|
|---|
| 1708 | * without implying a resource action. See the individual overloads for
|
|---|
| 1709 | * details on the return type.
|
|---|
| 1710 | */
|
|---|
| 1711 | HttpClient.prototype.options = function (url, options) {
|
|---|
| 1712 | if (options === void 0) { options = {}; }
|
|---|
| 1713 | return this.request('OPTIONS', url, options);
|
|---|
| 1714 | };
|
|---|
| 1715 | /**
|
|---|
| 1716 | * Constructs an observable that, when subscribed, causes the configured
|
|---|
| 1717 | * `PATCH` request to execute on the server. See the individual overloads for
|
|---|
| 1718 | * details on the return type.
|
|---|
| 1719 | */
|
|---|
| 1720 | HttpClient.prototype.patch = function (url, body, options) {
|
|---|
| 1721 | if (options === void 0) { options = {}; }
|
|---|
| 1722 | return this.request('PATCH', url, addBody(options, body));
|
|---|
| 1723 | };
|
|---|
| 1724 | /**
|
|---|
| 1725 | * Constructs an observable that, when subscribed, causes the configured
|
|---|
| 1726 | * `POST` request to execute on the server. The server responds with the location of
|
|---|
| 1727 | * the replaced resource. See the individual overloads for
|
|---|
| 1728 | * details on the return type.
|
|---|
| 1729 | */
|
|---|
| 1730 | HttpClient.prototype.post = function (url, body, options) {
|
|---|
| 1731 | if (options === void 0) { options = {}; }
|
|---|
| 1732 | return this.request('POST', url, addBody(options, body));
|
|---|
| 1733 | };
|
|---|
| 1734 | /**
|
|---|
| 1735 | * Constructs an observable that, when subscribed, causes the configured
|
|---|
| 1736 | * `PUT` request to execute on the server. The `PUT` method replaces an existing resource
|
|---|
| 1737 | * with a new set of values.
|
|---|
| 1738 | * See the individual overloads for details on the return type.
|
|---|
| 1739 | */
|
|---|
| 1740 | HttpClient.prototype.put = function (url, body, options) {
|
|---|
| 1741 | if (options === void 0) { options = {}; }
|
|---|
| 1742 | return this.request('PUT', url, addBody(options, body));
|
|---|
| 1743 | };
|
|---|
| 1744 | return HttpClient;
|
|---|
| 1745 | }());
|
|---|
| 1746 | HttpClient.decorators = [
|
|---|
| 1747 | { type: core.Injectable }
|
|---|
| 1748 | ];
|
|---|
| 1749 | HttpClient.ctorParameters = function () { return [
|
|---|
| 1750 | { type: HttpHandler }
|
|---|
| 1751 | ]; };
|
|---|
| 1752 |
|
|---|
| 1753 | /**
|
|---|
| 1754 | * @license
|
|---|
| 1755 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 1756 | *
|
|---|
| 1757 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 1758 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 1759 | */
|
|---|
| 1760 | /**
|
|---|
| 1761 | * `HttpHandler` which applies an `HttpInterceptor` to an `HttpRequest`.
|
|---|
| 1762 | *
|
|---|
| 1763 | *
|
|---|
| 1764 | */
|
|---|
| 1765 | var HttpInterceptorHandler = /** @class */ (function () {
|
|---|
| 1766 | function HttpInterceptorHandler(next, interceptor) {
|
|---|
| 1767 | this.next = next;
|
|---|
| 1768 | this.interceptor = interceptor;
|
|---|
| 1769 | }
|
|---|
| 1770 | HttpInterceptorHandler.prototype.handle = function (req) {
|
|---|
| 1771 | return this.interceptor.intercept(req, this.next);
|
|---|
| 1772 | };
|
|---|
| 1773 | return HttpInterceptorHandler;
|
|---|
| 1774 | }());
|
|---|
| 1775 | /**
|
|---|
| 1776 | * A multi-provider token that represents the array of registered
|
|---|
| 1777 | * `HttpInterceptor` objects.
|
|---|
| 1778 | *
|
|---|
| 1779 | * @publicApi
|
|---|
| 1780 | */
|
|---|
| 1781 | var HTTP_INTERCEPTORS = new core.InjectionToken('HTTP_INTERCEPTORS');
|
|---|
| 1782 | var NoopInterceptor = /** @class */ (function () {
|
|---|
| 1783 | function NoopInterceptor() {
|
|---|
| 1784 | }
|
|---|
| 1785 | NoopInterceptor.prototype.intercept = function (req, next) {
|
|---|
| 1786 | return next.handle(req);
|
|---|
| 1787 | };
|
|---|
| 1788 | return NoopInterceptor;
|
|---|
| 1789 | }());
|
|---|
| 1790 | NoopInterceptor.decorators = [
|
|---|
| 1791 | { type: core.Injectable }
|
|---|
| 1792 | ];
|
|---|
| 1793 |
|
|---|
| 1794 | /**
|
|---|
| 1795 | * @license
|
|---|
| 1796 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 1797 | *
|
|---|
| 1798 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 1799 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 1800 | */
|
|---|
| 1801 | // Every request made through JSONP needs a callback name that's unique across the
|
|---|
| 1802 | // whole page. Each request is assigned an id and the callback name is constructed
|
|---|
| 1803 | // from that. The next id to be assigned is tracked in a global variable here that
|
|---|
| 1804 | // is shared among all applications on the page.
|
|---|
| 1805 | var nextRequestId = 0;
|
|---|
| 1806 | // Error text given when a JSONP script is injected, but doesn't invoke the callback
|
|---|
| 1807 | // passed in its URL.
|
|---|
| 1808 | var JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';
|
|---|
| 1809 | // Error text given when a request is passed to the JsonpClientBackend that doesn't
|
|---|
| 1810 | // have a request method JSONP.
|
|---|
| 1811 | var JSONP_ERR_WRONG_METHOD = 'JSONP requests must use JSONP request method.';
|
|---|
| 1812 | var JSONP_ERR_WRONG_RESPONSE_TYPE = 'JSONP requests must use Json response type.';
|
|---|
| 1813 | /**
|
|---|
| 1814 | * DI token/abstract type representing a map of JSONP callbacks.
|
|---|
| 1815 | *
|
|---|
| 1816 | * In the browser, this should always be the `window` object.
|
|---|
| 1817 | *
|
|---|
| 1818 | *
|
|---|
| 1819 | */
|
|---|
| 1820 | var JsonpCallbackContext = /** @class */ (function () {
|
|---|
| 1821 | function JsonpCallbackContext() {
|
|---|
| 1822 | }
|
|---|
| 1823 | return JsonpCallbackContext;
|
|---|
| 1824 | }());
|
|---|
| 1825 | /**
|
|---|
| 1826 | * Processes an `HttpRequest` with the JSONP method,
|
|---|
| 1827 | * by performing JSONP style requests.
|
|---|
| 1828 | * @see `HttpHandler`
|
|---|
| 1829 | * @see `HttpXhrBackend`
|
|---|
| 1830 | *
|
|---|
| 1831 | * @publicApi
|
|---|
| 1832 | */
|
|---|
| 1833 | var JsonpClientBackend = /** @class */ (function () {
|
|---|
| 1834 | function JsonpClientBackend(callbackMap, document) {
|
|---|
| 1835 | this.callbackMap = callbackMap;
|
|---|
| 1836 | this.document = document;
|
|---|
| 1837 | /**
|
|---|
| 1838 | * A resolved promise that can be used to schedule microtasks in the event handlers.
|
|---|
| 1839 | */
|
|---|
| 1840 | this.resolvedPromise = Promise.resolve();
|
|---|
| 1841 | }
|
|---|
| 1842 | /**
|
|---|
| 1843 | * Get the name of the next callback method, by incrementing the global `nextRequestId`.
|
|---|
| 1844 | */
|
|---|
| 1845 | JsonpClientBackend.prototype.nextCallback = function () {
|
|---|
| 1846 | return "ng_jsonp_callback_" + nextRequestId++;
|
|---|
| 1847 | };
|
|---|
| 1848 | /**
|
|---|
| 1849 | * Processes a JSONP request and returns an event stream of the results.
|
|---|
| 1850 | * @param req The request object.
|
|---|
| 1851 | * @returns An observable of the response events.
|
|---|
| 1852 | *
|
|---|
| 1853 | */
|
|---|
| 1854 | JsonpClientBackend.prototype.handle = function (req) {
|
|---|
| 1855 | var _this = this;
|
|---|
| 1856 | // Firstly, check both the method and response type. If either doesn't match
|
|---|
| 1857 | // then the request was improperly routed here and cannot be handled.
|
|---|
| 1858 | if (req.method !== 'JSONP') {
|
|---|
| 1859 | throw new Error(JSONP_ERR_WRONG_METHOD);
|
|---|
| 1860 | }
|
|---|
| 1861 | else if (req.responseType !== 'json') {
|
|---|
| 1862 | throw new Error(JSONP_ERR_WRONG_RESPONSE_TYPE);
|
|---|
| 1863 | }
|
|---|
| 1864 | // Everything else happens inside the Observable boundary.
|
|---|
| 1865 | return new rxjs.Observable(function (observer) {
|
|---|
| 1866 | // The first step to make a request is to generate the callback name, and replace the
|
|---|
| 1867 | // callback placeholder in the URL with the name. Care has to be taken here to ensure
|
|---|
| 1868 | // a trailing &, if matched, gets inserted back into the URL in the correct place.
|
|---|
| 1869 | var callback = _this.nextCallback();
|
|---|
| 1870 | var url = req.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/, "=" + callback + "$1");
|
|---|
| 1871 | // Construct the <script> tag and point it at the URL.
|
|---|
| 1872 | var node = _this.document.createElement('script');
|
|---|
| 1873 | node.src = url;
|
|---|
| 1874 | // A JSONP request requires waiting for multiple callbacks. These variables
|
|---|
| 1875 | // are closed over and track state across those callbacks.
|
|---|
| 1876 | // The response object, if one has been received, or null otherwise.
|
|---|
| 1877 | var body = null;
|
|---|
| 1878 | // Whether the response callback has been called.
|
|---|
| 1879 | var finished = false;
|
|---|
| 1880 | // Whether the request has been cancelled (and thus any other callbacks)
|
|---|
| 1881 | // should be ignored.
|
|---|
| 1882 | var cancelled = false;
|
|---|
| 1883 | // Set the response callback in this.callbackMap (which will be the window
|
|---|
| 1884 | // object in the browser. The script being loaded via the <script> tag will
|
|---|
| 1885 | // eventually call this callback.
|
|---|
| 1886 | _this.callbackMap[callback] = function (data) {
|
|---|
| 1887 | // Data has been received from the JSONP script. Firstly, delete this callback.
|
|---|
| 1888 | delete _this.callbackMap[callback];
|
|---|
| 1889 | // Next, make sure the request wasn't cancelled in the meantime.
|
|---|
| 1890 | if (cancelled) {
|
|---|
| 1891 | return;
|
|---|
| 1892 | }
|
|---|
| 1893 | // Set state to indicate data was received.
|
|---|
| 1894 | body = data;
|
|---|
| 1895 | finished = true;
|
|---|
| 1896 | };
|
|---|
| 1897 | // cleanup() is a utility closure that removes the <script> from the page and
|
|---|
| 1898 | // the response callback from the window. This logic is used in both the
|
|---|
| 1899 | // success, error, and cancellation paths, so it's extracted out for convenience.
|
|---|
| 1900 | var cleanup = function () {
|
|---|
| 1901 | // Remove the <script> tag if it's still on the page.
|
|---|
| 1902 | if (node.parentNode) {
|
|---|
| 1903 | node.parentNode.removeChild(node);
|
|---|
| 1904 | }
|
|---|
| 1905 | // Remove the response callback from the callbackMap (window object in the
|
|---|
| 1906 | // browser).
|
|---|
| 1907 | delete _this.callbackMap[callback];
|
|---|
| 1908 | };
|
|---|
| 1909 | // onLoad() is the success callback which runs after the response callback
|
|---|
| 1910 | // if the JSONP script loads successfully. The event itself is unimportant.
|
|---|
| 1911 | // If something went wrong, onLoad() may run without the response callback
|
|---|
| 1912 | // having been invoked.
|
|---|
| 1913 | var onLoad = function (event) {
|
|---|
| 1914 | // Do nothing if the request has been cancelled.
|
|---|
| 1915 | if (cancelled) {
|
|---|
| 1916 | return;
|
|---|
| 1917 | }
|
|---|
| 1918 | // We wrap it in an extra Promise, to ensure the microtask
|
|---|
| 1919 | // is scheduled after the loaded endpoint has executed any potential microtask itself,
|
|---|
| 1920 | // which is not guaranteed in Internet Explorer and EdgeHTML. See issue #39496
|
|---|
| 1921 | _this.resolvedPromise.then(function () {
|
|---|
| 1922 | // Cleanup the page.
|
|---|
| 1923 | cleanup();
|
|---|
| 1924 | // Check whether the response callback has run.
|
|---|
| 1925 | if (!finished) {
|
|---|
| 1926 | // It hasn't, something went wrong with the request. Return an error via
|
|---|
| 1927 | // the Observable error path. All JSONP errors have status 0.
|
|---|
| 1928 | observer.error(new HttpErrorResponse({
|
|---|
| 1929 | url: url,
|
|---|
| 1930 | status: 0,
|
|---|
| 1931 | statusText: 'JSONP Error',
|
|---|
| 1932 | error: new Error(JSONP_ERR_NO_CALLBACK),
|
|---|
| 1933 | }));
|
|---|
| 1934 | return;
|
|---|
| 1935 | }
|
|---|
| 1936 | // Success. body either contains the response body or null if none was
|
|---|
| 1937 | // returned.
|
|---|
| 1938 | observer.next(new HttpResponse({
|
|---|
| 1939 | body: body,
|
|---|
| 1940 | status: 200 /* Ok */,
|
|---|
| 1941 | statusText: 'OK',
|
|---|
| 1942 | url: url,
|
|---|
| 1943 | }));
|
|---|
| 1944 | // Complete the stream, the response is over.
|
|---|
| 1945 | observer.complete();
|
|---|
| 1946 | });
|
|---|
| 1947 | };
|
|---|
| 1948 | // onError() is the error callback, which runs if the script returned generates
|
|---|
| 1949 | // a Javascript error. It emits the error via the Observable error channel as
|
|---|
| 1950 | // a HttpErrorResponse.
|
|---|
| 1951 | var onError = function (error) {
|
|---|
| 1952 | // If the request was already cancelled, no need to emit anything.
|
|---|
| 1953 | if (cancelled) {
|
|---|
| 1954 | return;
|
|---|
| 1955 | }
|
|---|
| 1956 | cleanup();
|
|---|
| 1957 | // Wrap the error in a HttpErrorResponse.
|
|---|
| 1958 | observer.error(new HttpErrorResponse({
|
|---|
| 1959 | error: error,
|
|---|
| 1960 | status: 0,
|
|---|
| 1961 | statusText: 'JSONP Error',
|
|---|
| 1962 | url: url,
|
|---|
| 1963 | }));
|
|---|
| 1964 | };
|
|---|
| 1965 | // Subscribe to both the success (load) and error events on the <script> tag,
|
|---|
| 1966 | // and add it to the page.
|
|---|
| 1967 | node.addEventListener('load', onLoad);
|
|---|
| 1968 | node.addEventListener('error', onError);
|
|---|
| 1969 | _this.document.body.appendChild(node);
|
|---|
| 1970 | // The request has now been successfully sent.
|
|---|
| 1971 | observer.next({ type: exports.HttpEventType.Sent });
|
|---|
| 1972 | // Cancellation handler.
|
|---|
| 1973 | return function () {
|
|---|
| 1974 | // Track the cancellation so event listeners won't do anything even if already scheduled.
|
|---|
| 1975 | cancelled = true;
|
|---|
| 1976 | // Remove the event listeners so they won't run if the events later fire.
|
|---|
| 1977 | node.removeEventListener('load', onLoad);
|
|---|
| 1978 | node.removeEventListener('error', onError);
|
|---|
| 1979 | // And finally, clean up the page.
|
|---|
| 1980 | cleanup();
|
|---|
| 1981 | };
|
|---|
| 1982 | });
|
|---|
| 1983 | };
|
|---|
| 1984 | return JsonpClientBackend;
|
|---|
| 1985 | }());
|
|---|
| 1986 | JsonpClientBackend.decorators = [
|
|---|
| 1987 | { type: core.Injectable }
|
|---|
| 1988 | ];
|
|---|
| 1989 | JsonpClientBackend.ctorParameters = function () { return [
|
|---|
| 1990 | { type: JsonpCallbackContext },
|
|---|
| 1991 | { type: undefined, decorators: [{ type: core.Inject, args: [common.DOCUMENT,] }] }
|
|---|
| 1992 | ]; };
|
|---|
| 1993 | /**
|
|---|
| 1994 | * Identifies requests with the method JSONP and
|
|---|
| 1995 | * shifts them to the `JsonpClientBackend`.
|
|---|
| 1996 | *
|
|---|
| 1997 | * @see `HttpInterceptor`
|
|---|
| 1998 | *
|
|---|
| 1999 | * @publicApi
|
|---|
| 2000 | */
|
|---|
| 2001 | var JsonpInterceptor = /** @class */ (function () {
|
|---|
| 2002 | function JsonpInterceptor(jsonp) {
|
|---|
| 2003 | this.jsonp = jsonp;
|
|---|
| 2004 | }
|
|---|
| 2005 | /**
|
|---|
| 2006 | * Identifies and handles a given JSONP request.
|
|---|
| 2007 | * @param req The outgoing request object to handle.
|
|---|
| 2008 | * @param next The next interceptor in the chain, or the backend
|
|---|
| 2009 | * if no interceptors remain in the chain.
|
|---|
| 2010 | * @returns An observable of the event stream.
|
|---|
| 2011 | */
|
|---|
| 2012 | JsonpInterceptor.prototype.intercept = function (req, next) {
|
|---|
| 2013 | if (req.method === 'JSONP') {
|
|---|
| 2014 | return this.jsonp.handle(req);
|
|---|
| 2015 | }
|
|---|
| 2016 | // Fall through for normal HTTP requests.
|
|---|
| 2017 | return next.handle(req);
|
|---|
| 2018 | };
|
|---|
| 2019 | return JsonpInterceptor;
|
|---|
| 2020 | }());
|
|---|
| 2021 | JsonpInterceptor.decorators = [
|
|---|
| 2022 | { type: core.Injectable }
|
|---|
| 2023 | ];
|
|---|
| 2024 | JsonpInterceptor.ctorParameters = function () { return [
|
|---|
| 2025 | { type: JsonpClientBackend }
|
|---|
| 2026 | ]; };
|
|---|
| 2027 |
|
|---|
| 2028 | /**
|
|---|
| 2029 | * @license
|
|---|
| 2030 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 2031 | *
|
|---|
| 2032 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 2033 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 2034 | */
|
|---|
| 2035 | var XSSI_PREFIX = /^\)\]\}',?\n/;
|
|---|
| 2036 | /**
|
|---|
| 2037 | * Determine an appropriate URL for the response, by checking either
|
|---|
| 2038 | * XMLHttpRequest.responseURL or the X-Request-URL header.
|
|---|
| 2039 | */
|
|---|
| 2040 | function getResponseUrl(xhr) {
|
|---|
| 2041 | if ('responseURL' in xhr && xhr.responseURL) {
|
|---|
| 2042 | return xhr.responseURL;
|
|---|
| 2043 | }
|
|---|
| 2044 | if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
|
|---|
| 2045 | return xhr.getResponseHeader('X-Request-URL');
|
|---|
| 2046 | }
|
|---|
| 2047 | return null;
|
|---|
| 2048 | }
|
|---|
| 2049 | /**
|
|---|
| 2050 | * Uses `XMLHttpRequest` to send requests to a backend server.
|
|---|
| 2051 | * @see `HttpHandler`
|
|---|
| 2052 | * @see `JsonpClientBackend`
|
|---|
| 2053 | *
|
|---|
| 2054 | * @publicApi
|
|---|
| 2055 | */
|
|---|
| 2056 | var HttpXhrBackend = /** @class */ (function () {
|
|---|
| 2057 | function HttpXhrBackend(xhrFactory) {
|
|---|
| 2058 | this.xhrFactory = xhrFactory;
|
|---|
| 2059 | }
|
|---|
| 2060 | /**
|
|---|
| 2061 | * Processes a request and returns a stream of response events.
|
|---|
| 2062 | * @param req The request object.
|
|---|
| 2063 | * @returns An observable of the response events.
|
|---|
| 2064 | */
|
|---|
| 2065 | HttpXhrBackend.prototype.handle = function (req) {
|
|---|
| 2066 | var _this = this;
|
|---|
| 2067 | // Quick check to give a better error message when a user attempts to use
|
|---|
| 2068 | // HttpClient.jsonp() without installing the HttpClientJsonpModule
|
|---|
| 2069 | if (req.method === 'JSONP') {
|
|---|
| 2070 | throw new Error("Attempted to construct Jsonp request without HttpClientJsonpModule installed.");
|
|---|
| 2071 | }
|
|---|
| 2072 | // Everything happens on Observable subscription.
|
|---|
| 2073 | return new rxjs.Observable(function (observer) {
|
|---|
| 2074 | // Start by setting up the XHR object with request method, URL, and withCredentials flag.
|
|---|
| 2075 | var xhr = _this.xhrFactory.build();
|
|---|
| 2076 | xhr.open(req.method, req.urlWithParams);
|
|---|
| 2077 | if (!!req.withCredentials) {
|
|---|
| 2078 | xhr.withCredentials = true;
|
|---|
| 2079 | }
|
|---|
| 2080 | // Add all the requested headers.
|
|---|
| 2081 | req.headers.forEach(function (name, values) { return xhr.setRequestHeader(name, values.join(',')); });
|
|---|
| 2082 | // Add an Accept header if one isn't present already.
|
|---|
| 2083 | if (!req.headers.has('Accept')) {
|
|---|
| 2084 | xhr.setRequestHeader('Accept', 'application/json, text/plain, */*');
|
|---|
| 2085 | }
|
|---|
| 2086 | // Auto-detect the Content-Type header if one isn't present already.
|
|---|
| 2087 | if (!req.headers.has('Content-Type')) {
|
|---|
| 2088 | var detectedType = req.detectContentTypeHeader();
|
|---|
| 2089 | // Sometimes Content-Type detection fails.
|
|---|
| 2090 | if (detectedType !== null) {
|
|---|
| 2091 | xhr.setRequestHeader('Content-Type', detectedType);
|
|---|
| 2092 | }
|
|---|
| 2093 | }
|
|---|
| 2094 | // Set the responseType if one was requested.
|
|---|
| 2095 | if (req.responseType) {
|
|---|
| 2096 | var responseType = req.responseType.toLowerCase();
|
|---|
| 2097 | // JSON responses need to be processed as text. This is because if the server
|
|---|
| 2098 | // returns an XSSI-prefixed JSON response, the browser will fail to parse it,
|
|---|
| 2099 | // xhr.response will be null, and xhr.responseText cannot be accessed to
|
|---|
| 2100 | // retrieve the prefixed JSON data in order to strip the prefix. Thus, all JSON
|
|---|
| 2101 | // is parsed by first requesting text and then applying JSON.parse.
|
|---|
| 2102 | xhr.responseType = ((responseType !== 'json') ? responseType : 'text');
|
|---|
| 2103 | }
|
|---|
| 2104 | // Serialize the request body if one is present. If not, this will be set to null.
|
|---|
| 2105 | var reqBody = req.serializeBody();
|
|---|
| 2106 | // If progress events are enabled, response headers will be delivered
|
|---|
| 2107 | // in two events - the HttpHeaderResponse event and the full HttpResponse
|
|---|
| 2108 | // event. However, since response headers don't change in between these
|
|---|
| 2109 | // two events, it doesn't make sense to parse them twice. So headerResponse
|
|---|
| 2110 | // caches the data extracted from the response whenever it's first parsed,
|
|---|
| 2111 | // to ensure parsing isn't duplicated.
|
|---|
| 2112 | var headerResponse = null;
|
|---|
| 2113 | // partialFromXhr extracts the HttpHeaderResponse from the current XMLHttpRequest
|
|---|
| 2114 | // state, and memoizes it into headerResponse.
|
|---|
| 2115 | var partialFromXhr = function () {
|
|---|
| 2116 | if (headerResponse !== null) {
|
|---|
| 2117 | return headerResponse;
|
|---|
| 2118 | }
|
|---|
| 2119 | // Read status and normalize an IE9 bug (https://bugs.jquery.com/ticket/1450).
|
|---|
| 2120 | var status = xhr.status === 1223 ? 204 /* NoContent */ : xhr.status;
|
|---|
| 2121 | var statusText = xhr.statusText || 'OK';
|
|---|
| 2122 | // Parse headers from XMLHttpRequest - this step is lazy.
|
|---|
| 2123 | var headers = new HttpHeaders(xhr.getAllResponseHeaders());
|
|---|
| 2124 | // Read the response URL from the XMLHttpResponse instance and fall back on the
|
|---|
| 2125 | // request URL.
|
|---|
| 2126 | var url = getResponseUrl(xhr) || req.url;
|
|---|
| 2127 | // Construct the HttpHeaderResponse and memoize it.
|
|---|
| 2128 | headerResponse = new HttpHeaderResponse({ headers: headers, status: status, statusText: statusText, url: url });
|
|---|
| 2129 | return headerResponse;
|
|---|
| 2130 | };
|
|---|
| 2131 | // Next, a few closures are defined for the various events which XMLHttpRequest can
|
|---|
| 2132 | // emit. This allows them to be unregistered as event listeners later.
|
|---|
| 2133 | // First up is the load event, which represents a response being fully available.
|
|---|
| 2134 | var onLoad = function () {
|
|---|
| 2135 | // Read response state from the memoized partial data.
|
|---|
| 2136 | var _a = partialFromXhr(), headers = _a.headers, status = _a.status, statusText = _a.statusText, url = _a.url;
|
|---|
| 2137 | // The body will be read out if present.
|
|---|
| 2138 | var body = null;
|
|---|
| 2139 | if (status !== 204 /* NoContent */) {
|
|---|
| 2140 | // Use XMLHttpRequest.response if set, responseText otherwise.
|
|---|
| 2141 | body = (typeof xhr.response === 'undefined') ? xhr.responseText : xhr.response;
|
|---|
| 2142 | }
|
|---|
| 2143 | // Normalize another potential bug (this one comes from CORS).
|
|---|
| 2144 | if (status === 0) {
|
|---|
| 2145 | status = !!body ? 200 /* Ok */ : 0;
|
|---|
| 2146 | }
|
|---|
| 2147 | // ok determines whether the response will be transmitted on the event or
|
|---|
| 2148 | // error channel. Unsuccessful status codes (not 2xx) will always be errors,
|
|---|
| 2149 | // but a successful status code can still result in an error if the user
|
|---|
| 2150 | // asked for JSON data and the body cannot be parsed as such.
|
|---|
| 2151 | var ok = status >= 200 && status < 300;
|
|---|
| 2152 | // Check whether the body needs to be parsed as JSON (in many cases the browser
|
|---|
| 2153 | // will have done that already).
|
|---|
| 2154 | if (req.responseType === 'json' && typeof body === 'string') {
|
|---|
| 2155 | // Save the original body, before attempting XSSI prefix stripping.
|
|---|
| 2156 | var originalBody = body;
|
|---|
| 2157 | body = body.replace(XSSI_PREFIX, '');
|
|---|
| 2158 | try {
|
|---|
| 2159 | // Attempt the parse. If it fails, a parse error should be delivered to the user.
|
|---|
| 2160 | body = body !== '' ? JSON.parse(body) : null;
|
|---|
| 2161 | }
|
|---|
| 2162 | catch (error) {
|
|---|
| 2163 | // Since the JSON.parse failed, it's reasonable to assume this might not have been a
|
|---|
| 2164 | // JSON response. Restore the original body (including any XSSI prefix) to deliver
|
|---|
| 2165 | // a better error response.
|
|---|
| 2166 | body = originalBody;
|
|---|
| 2167 | // If this was an error request to begin with, leave it as a string, it probably
|
|---|
| 2168 | // just isn't JSON. Otherwise, deliver the parsing error to the user.
|
|---|
| 2169 | if (ok) {
|
|---|
| 2170 | // Even though the response status was 2xx, this is still an error.
|
|---|
| 2171 | ok = false;
|
|---|
| 2172 | // The parse error contains the text of the body that failed to parse.
|
|---|
| 2173 | body = { error: error, text: body };
|
|---|
| 2174 | }
|
|---|
| 2175 | }
|
|---|
| 2176 | }
|
|---|
| 2177 | if (ok) {
|
|---|
| 2178 | // A successful response is delivered on the event stream.
|
|---|
| 2179 | observer.next(new HttpResponse({
|
|---|
| 2180 | body: body,
|
|---|
| 2181 | headers: headers,
|
|---|
| 2182 | status: status,
|
|---|
| 2183 | statusText: statusText,
|
|---|
| 2184 | url: url || undefined,
|
|---|
| 2185 | }));
|
|---|
| 2186 | // The full body has been received and delivered, no further events
|
|---|
| 2187 | // are possible. This request is complete.
|
|---|
| 2188 | observer.complete();
|
|---|
| 2189 | }
|
|---|
| 2190 | else {
|
|---|
| 2191 | // An unsuccessful request is delivered on the error channel.
|
|---|
| 2192 | observer.error(new HttpErrorResponse({
|
|---|
| 2193 | // The error in this case is the response body (error from the server).
|
|---|
| 2194 | error: body,
|
|---|
| 2195 | headers: headers,
|
|---|
| 2196 | status: status,
|
|---|
| 2197 | statusText: statusText,
|
|---|
| 2198 | url: url || undefined,
|
|---|
| 2199 | }));
|
|---|
| 2200 | }
|
|---|
| 2201 | };
|
|---|
| 2202 | // The onError callback is called when something goes wrong at the network level.
|
|---|
| 2203 | // Connection timeout, DNS error, offline, etc. These are actual errors, and are
|
|---|
| 2204 | // transmitted on the error channel.
|
|---|
| 2205 | var onError = function (error) {
|
|---|
| 2206 | var url = partialFromXhr().url;
|
|---|
| 2207 | var res = new HttpErrorResponse({
|
|---|
| 2208 | error: error,
|
|---|
| 2209 | status: xhr.status || 0,
|
|---|
| 2210 | statusText: xhr.statusText || 'Unknown Error',
|
|---|
| 2211 | url: url || undefined,
|
|---|
| 2212 | });
|
|---|
| 2213 | observer.error(res);
|
|---|
| 2214 | };
|
|---|
| 2215 | // The sentHeaders flag tracks whether the HttpResponseHeaders event
|
|---|
| 2216 | // has been sent on the stream. This is necessary to track if progress
|
|---|
| 2217 | // is enabled since the event will be sent on only the first download
|
|---|
| 2218 | // progerss event.
|
|---|
| 2219 | var sentHeaders = false;
|
|---|
| 2220 | // The download progress event handler, which is only registered if
|
|---|
| 2221 | // progress events are enabled.
|
|---|
| 2222 | var onDownProgress = function (event) {
|
|---|
| 2223 | // Send the HttpResponseHeaders event if it hasn't been sent already.
|
|---|
| 2224 | if (!sentHeaders) {
|
|---|
| 2225 | observer.next(partialFromXhr());
|
|---|
| 2226 | sentHeaders = true;
|
|---|
| 2227 | }
|
|---|
| 2228 | // Start building the download progress event to deliver on the response
|
|---|
| 2229 | // event stream.
|
|---|
| 2230 | var progressEvent = {
|
|---|
| 2231 | type: exports.HttpEventType.DownloadProgress,
|
|---|
| 2232 | loaded: event.loaded,
|
|---|
| 2233 | };
|
|---|
| 2234 | // Set the total number of bytes in the event if it's available.
|
|---|
| 2235 | if (event.lengthComputable) {
|
|---|
| 2236 | progressEvent.total = event.total;
|
|---|
| 2237 | }
|
|---|
| 2238 | // If the request was for text content and a partial response is
|
|---|
| 2239 | // available on XMLHttpRequest, include it in the progress event
|
|---|
| 2240 | // to allow for streaming reads.
|
|---|
| 2241 | if (req.responseType === 'text' && !!xhr.responseText) {
|
|---|
| 2242 | progressEvent.partialText = xhr.responseText;
|
|---|
| 2243 | }
|
|---|
| 2244 | // Finally, fire the event.
|
|---|
| 2245 | observer.next(progressEvent);
|
|---|
| 2246 | };
|
|---|
| 2247 | // The upload progress event handler, which is only registered if
|
|---|
| 2248 | // progress events are enabled.
|
|---|
| 2249 | var onUpProgress = function (event) {
|
|---|
| 2250 | // Upload progress events are simpler. Begin building the progress
|
|---|
| 2251 | // event.
|
|---|
| 2252 | var progress = {
|
|---|
| 2253 | type: exports.HttpEventType.UploadProgress,
|
|---|
| 2254 | loaded: event.loaded,
|
|---|
| 2255 | };
|
|---|
| 2256 | // If the total number of bytes being uploaded is available, include
|
|---|
| 2257 | // it.
|
|---|
| 2258 | if (event.lengthComputable) {
|
|---|
| 2259 | progress.total = event.total;
|
|---|
| 2260 | }
|
|---|
| 2261 | // Send the event.
|
|---|
| 2262 | observer.next(progress);
|
|---|
| 2263 | };
|
|---|
| 2264 | // By default, register for load and error events.
|
|---|
| 2265 | xhr.addEventListener('load', onLoad);
|
|---|
| 2266 | xhr.addEventListener('error', onError);
|
|---|
| 2267 | xhr.addEventListener('timeout', onError);
|
|---|
| 2268 | xhr.addEventListener('abort', onError);
|
|---|
| 2269 | // Progress events are only enabled if requested.
|
|---|
| 2270 | if (req.reportProgress) {
|
|---|
| 2271 | // Download progress is always enabled if requested.
|
|---|
| 2272 | xhr.addEventListener('progress', onDownProgress);
|
|---|
| 2273 | // Upload progress depends on whether there is a body to upload.
|
|---|
| 2274 | if (reqBody !== null && xhr.upload) {
|
|---|
| 2275 | xhr.upload.addEventListener('progress', onUpProgress);
|
|---|
| 2276 | }
|
|---|
| 2277 | }
|
|---|
| 2278 | // Fire the request, and notify the event stream that it was fired.
|
|---|
| 2279 | xhr.send(reqBody);
|
|---|
| 2280 | observer.next({ type: exports.HttpEventType.Sent });
|
|---|
| 2281 | // This is the return from the Observable function, which is the
|
|---|
| 2282 | // request cancellation handler.
|
|---|
| 2283 | return function () {
|
|---|
| 2284 | // On a cancellation, remove all registered event listeners.
|
|---|
| 2285 | xhr.removeEventListener('error', onError);
|
|---|
| 2286 | xhr.removeEventListener('abort', onError);
|
|---|
| 2287 | xhr.removeEventListener('load', onLoad);
|
|---|
| 2288 | xhr.removeEventListener('timeout', onError);
|
|---|
| 2289 | if (req.reportProgress) {
|
|---|
| 2290 | xhr.removeEventListener('progress', onDownProgress);
|
|---|
| 2291 | if (reqBody !== null && xhr.upload) {
|
|---|
| 2292 | xhr.upload.removeEventListener('progress', onUpProgress);
|
|---|
| 2293 | }
|
|---|
| 2294 | }
|
|---|
| 2295 | // Finally, abort the in-flight request.
|
|---|
| 2296 | if (xhr.readyState !== xhr.DONE) {
|
|---|
| 2297 | xhr.abort();
|
|---|
| 2298 | }
|
|---|
| 2299 | };
|
|---|
| 2300 | });
|
|---|
| 2301 | };
|
|---|
| 2302 | return HttpXhrBackend;
|
|---|
| 2303 | }());
|
|---|
| 2304 | HttpXhrBackend.decorators = [
|
|---|
| 2305 | { type: core.Injectable }
|
|---|
| 2306 | ];
|
|---|
| 2307 | HttpXhrBackend.ctorParameters = function () { return [
|
|---|
| 2308 | { type: common.XhrFactory }
|
|---|
| 2309 | ]; };
|
|---|
| 2310 |
|
|---|
| 2311 | /**
|
|---|
| 2312 | * @license
|
|---|
| 2313 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 2314 | *
|
|---|
| 2315 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 2316 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 2317 | */
|
|---|
| 2318 | var XSRF_COOKIE_NAME = new core.InjectionToken('XSRF_COOKIE_NAME');
|
|---|
| 2319 | var XSRF_HEADER_NAME = new core.InjectionToken('XSRF_HEADER_NAME');
|
|---|
| 2320 | /**
|
|---|
| 2321 | * Retrieves the current XSRF token to use with the next outgoing request.
|
|---|
| 2322 | *
|
|---|
| 2323 | * @publicApi
|
|---|
| 2324 | */
|
|---|
| 2325 | var HttpXsrfTokenExtractor = /** @class */ (function () {
|
|---|
| 2326 | function HttpXsrfTokenExtractor() {
|
|---|
| 2327 | }
|
|---|
| 2328 | return HttpXsrfTokenExtractor;
|
|---|
| 2329 | }());
|
|---|
| 2330 | /**
|
|---|
| 2331 | * `HttpXsrfTokenExtractor` which retrieves the token from a cookie.
|
|---|
| 2332 | */
|
|---|
| 2333 | var HttpXsrfCookieExtractor = /** @class */ (function () {
|
|---|
| 2334 | function HttpXsrfCookieExtractor(doc, platform, cookieName) {
|
|---|
| 2335 | this.doc = doc;
|
|---|
| 2336 | this.platform = platform;
|
|---|
| 2337 | this.cookieName = cookieName;
|
|---|
| 2338 | this.lastCookieString = '';
|
|---|
| 2339 | this.lastToken = null;
|
|---|
| 2340 | /**
|
|---|
| 2341 | * @internal for testing
|
|---|
| 2342 | */
|
|---|
| 2343 | this.parseCount = 0;
|
|---|
| 2344 | }
|
|---|
| 2345 | HttpXsrfCookieExtractor.prototype.getToken = function () {
|
|---|
| 2346 | if (this.platform === 'server') {
|
|---|
| 2347 | return null;
|
|---|
| 2348 | }
|
|---|
| 2349 | var cookieString = this.doc.cookie || '';
|
|---|
| 2350 | if (cookieString !== this.lastCookieString) {
|
|---|
| 2351 | this.parseCount++;
|
|---|
| 2352 | this.lastToken = common.ɵparseCookieValue(cookieString, this.cookieName);
|
|---|
| 2353 | this.lastCookieString = cookieString;
|
|---|
| 2354 | }
|
|---|
| 2355 | return this.lastToken;
|
|---|
| 2356 | };
|
|---|
| 2357 | return HttpXsrfCookieExtractor;
|
|---|
| 2358 | }());
|
|---|
| 2359 | HttpXsrfCookieExtractor.decorators = [
|
|---|
| 2360 | { type: core.Injectable }
|
|---|
| 2361 | ];
|
|---|
| 2362 | HttpXsrfCookieExtractor.ctorParameters = function () { return [
|
|---|
| 2363 | { type: undefined, decorators: [{ type: core.Inject, args: [common.DOCUMENT,] }] },
|
|---|
| 2364 | { type: String, decorators: [{ type: core.Inject, args: [core.PLATFORM_ID,] }] },
|
|---|
| 2365 | { type: String, decorators: [{ type: core.Inject, args: [XSRF_COOKIE_NAME,] }] }
|
|---|
| 2366 | ]; };
|
|---|
| 2367 | /**
|
|---|
| 2368 | * `HttpInterceptor` which adds an XSRF token to eligible outgoing requests.
|
|---|
| 2369 | */
|
|---|
| 2370 | var HttpXsrfInterceptor = /** @class */ (function () {
|
|---|
| 2371 | function HttpXsrfInterceptor(tokenService, headerName) {
|
|---|
| 2372 | this.tokenService = tokenService;
|
|---|
| 2373 | this.headerName = headerName;
|
|---|
| 2374 | }
|
|---|
| 2375 | HttpXsrfInterceptor.prototype.intercept = function (req, next) {
|
|---|
| 2376 | var lcUrl = req.url.toLowerCase();
|
|---|
| 2377 | // Skip both non-mutating requests and absolute URLs.
|
|---|
| 2378 | // Non-mutating requests don't require a token, and absolute URLs require special handling
|
|---|
| 2379 | // anyway as the cookie set
|
|---|
| 2380 | // on our origin is not the same as the token expected by another origin.
|
|---|
| 2381 | if (req.method === 'GET' || req.method === 'HEAD' || lcUrl.startsWith('http://') ||
|
|---|
| 2382 | lcUrl.startsWith('https://')) {
|
|---|
| 2383 | return next.handle(req);
|
|---|
| 2384 | }
|
|---|
| 2385 | var token = this.tokenService.getToken();
|
|---|
| 2386 | // Be careful not to overwrite an existing header of the same name.
|
|---|
| 2387 | if (token !== null && !req.headers.has(this.headerName)) {
|
|---|
| 2388 | req = req.clone({ headers: req.headers.set(this.headerName, token) });
|
|---|
| 2389 | }
|
|---|
| 2390 | return next.handle(req);
|
|---|
| 2391 | };
|
|---|
| 2392 | return HttpXsrfInterceptor;
|
|---|
| 2393 | }());
|
|---|
| 2394 | HttpXsrfInterceptor.decorators = [
|
|---|
| 2395 | { type: core.Injectable }
|
|---|
| 2396 | ];
|
|---|
| 2397 | HttpXsrfInterceptor.ctorParameters = function () { return [
|
|---|
| 2398 | { type: HttpXsrfTokenExtractor },
|
|---|
| 2399 | { type: String, decorators: [{ type: core.Inject, args: [XSRF_HEADER_NAME,] }] }
|
|---|
| 2400 | ]; };
|
|---|
| 2401 |
|
|---|
| 2402 | /**
|
|---|
| 2403 | * @license
|
|---|
| 2404 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 2405 | *
|
|---|
| 2406 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 2407 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 2408 | */
|
|---|
| 2409 | /**
|
|---|
| 2410 | * An injectable `HttpHandler` that applies multiple interceptors
|
|---|
| 2411 | * to a request before passing it to the given `HttpBackend`.
|
|---|
| 2412 | *
|
|---|
| 2413 | * The interceptors are loaded lazily from the injector, to allow
|
|---|
| 2414 | * interceptors to themselves inject classes depending indirectly
|
|---|
| 2415 | * on `HttpInterceptingHandler` itself.
|
|---|
| 2416 | * @see `HttpInterceptor`
|
|---|
| 2417 | */
|
|---|
| 2418 | var HttpInterceptingHandler = /** @class */ (function () {
|
|---|
| 2419 | function HttpInterceptingHandler(backend, injector) {
|
|---|
| 2420 | this.backend = backend;
|
|---|
| 2421 | this.injector = injector;
|
|---|
| 2422 | this.chain = null;
|
|---|
| 2423 | }
|
|---|
| 2424 | HttpInterceptingHandler.prototype.handle = function (req) {
|
|---|
| 2425 | if (this.chain === null) {
|
|---|
| 2426 | var interceptors = this.injector.get(HTTP_INTERCEPTORS, []);
|
|---|
| 2427 | this.chain = interceptors.reduceRight(function (next, interceptor) { return new HttpInterceptorHandler(next, interceptor); }, this.backend);
|
|---|
| 2428 | }
|
|---|
| 2429 | return this.chain.handle(req);
|
|---|
| 2430 | };
|
|---|
| 2431 | return HttpInterceptingHandler;
|
|---|
| 2432 | }());
|
|---|
| 2433 | HttpInterceptingHandler.decorators = [
|
|---|
| 2434 | { type: core.Injectable }
|
|---|
| 2435 | ];
|
|---|
| 2436 | HttpInterceptingHandler.ctorParameters = function () { return [
|
|---|
| 2437 | { type: HttpBackend },
|
|---|
| 2438 | { type: core.Injector }
|
|---|
| 2439 | ]; };
|
|---|
| 2440 | /**
|
|---|
| 2441 | * Constructs an `HttpHandler` that applies interceptors
|
|---|
| 2442 | * to a request before passing it to the given `HttpBackend`.
|
|---|
| 2443 | *
|
|---|
| 2444 | * Use as a factory function within `HttpClientModule`.
|
|---|
| 2445 | *
|
|---|
| 2446 | *
|
|---|
| 2447 | */
|
|---|
| 2448 | function interceptingHandler(backend, interceptors) {
|
|---|
| 2449 | if (interceptors === void 0) { interceptors = []; }
|
|---|
| 2450 | if (!interceptors) {
|
|---|
| 2451 | return backend;
|
|---|
| 2452 | }
|
|---|
| 2453 | return interceptors.reduceRight(function (next, interceptor) { return new HttpInterceptorHandler(next, interceptor); }, backend);
|
|---|
| 2454 | }
|
|---|
| 2455 | /**
|
|---|
| 2456 | * Factory function that determines where to store JSONP callbacks.
|
|---|
| 2457 | *
|
|---|
| 2458 | * Ordinarily JSONP callbacks are stored on the `window` object, but this may not exist
|
|---|
| 2459 | * in test environments. In that case, callbacks are stored on an anonymous object instead.
|
|---|
| 2460 | *
|
|---|
| 2461 | *
|
|---|
| 2462 | */
|
|---|
| 2463 | function jsonpCallbackContext() {
|
|---|
| 2464 | if (typeof window === 'object') {
|
|---|
| 2465 | return window;
|
|---|
| 2466 | }
|
|---|
| 2467 | return {};
|
|---|
| 2468 | }
|
|---|
| 2469 | /**
|
|---|
| 2470 | * Configures XSRF protection support for outgoing requests.
|
|---|
| 2471 | *
|
|---|
| 2472 | * For a server that supports a cookie-based XSRF protection system,
|
|---|
| 2473 | * use directly to configure XSRF protection with the correct
|
|---|
| 2474 | * cookie and header names.
|
|---|
| 2475 | *
|
|---|
| 2476 | * If no names are supplied, the default cookie name is `XSRF-TOKEN`
|
|---|
| 2477 | * and the default header name is `X-XSRF-TOKEN`.
|
|---|
| 2478 | *
|
|---|
| 2479 | * @publicApi
|
|---|
| 2480 | */
|
|---|
| 2481 | var HttpClientXsrfModule = /** @class */ (function () {
|
|---|
| 2482 | function HttpClientXsrfModule() {
|
|---|
| 2483 | }
|
|---|
| 2484 | /**
|
|---|
| 2485 | * Disable the default XSRF protection.
|
|---|
| 2486 | */
|
|---|
| 2487 | HttpClientXsrfModule.disable = function () {
|
|---|
| 2488 | return {
|
|---|
| 2489 | ngModule: HttpClientXsrfModule,
|
|---|
| 2490 | providers: [
|
|---|
| 2491 | { provide: HttpXsrfInterceptor, useClass: NoopInterceptor },
|
|---|
| 2492 | ],
|
|---|
| 2493 | };
|
|---|
| 2494 | };
|
|---|
| 2495 | /**
|
|---|
| 2496 | * Configure XSRF protection.
|
|---|
| 2497 | * @param options An object that can specify either or both
|
|---|
| 2498 | * cookie name or header name.
|
|---|
| 2499 | * - Cookie name default is `XSRF-TOKEN`.
|
|---|
| 2500 | * - Header name default is `X-XSRF-TOKEN`.
|
|---|
| 2501 | *
|
|---|
| 2502 | */
|
|---|
| 2503 | HttpClientXsrfModule.withOptions = function (options) {
|
|---|
| 2504 | if (options === void 0) { options = {}; }
|
|---|
| 2505 | return {
|
|---|
| 2506 | ngModule: HttpClientXsrfModule,
|
|---|
| 2507 | providers: [
|
|---|
| 2508 | options.cookieName ? { provide: XSRF_COOKIE_NAME, useValue: options.cookieName } : [],
|
|---|
| 2509 | options.headerName ? { provide: XSRF_HEADER_NAME, useValue: options.headerName } : [],
|
|---|
| 2510 | ],
|
|---|
| 2511 | };
|
|---|
| 2512 | };
|
|---|
| 2513 | return HttpClientXsrfModule;
|
|---|
| 2514 | }());
|
|---|
| 2515 | HttpClientXsrfModule.decorators = [
|
|---|
| 2516 | { type: core.NgModule, args: [{
|
|---|
| 2517 | providers: [
|
|---|
| 2518 | HttpXsrfInterceptor,
|
|---|
| 2519 | { provide: HTTP_INTERCEPTORS, useExisting: HttpXsrfInterceptor, multi: true },
|
|---|
| 2520 | { provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor },
|
|---|
| 2521 | { provide: XSRF_COOKIE_NAME, useValue: 'XSRF-TOKEN' },
|
|---|
| 2522 | { provide: XSRF_HEADER_NAME, useValue: 'X-XSRF-TOKEN' },
|
|---|
| 2523 | ],
|
|---|
| 2524 | },] }
|
|---|
| 2525 | ];
|
|---|
| 2526 | /**
|
|---|
| 2527 | * Configures the [dependency injector](guide/glossary#injector) for `HttpClient`
|
|---|
| 2528 | * with supporting services for XSRF. Automatically imported by `HttpClientModule`.
|
|---|
| 2529 | *
|
|---|
| 2530 | * You can add interceptors to the chain behind `HttpClient` by binding them to the
|
|---|
| 2531 | * multiprovider for built-in [DI token](guide/glossary#di-token) `HTTP_INTERCEPTORS`.
|
|---|
| 2532 | *
|
|---|
| 2533 | * @publicApi
|
|---|
| 2534 | */
|
|---|
| 2535 | var HttpClientModule = /** @class */ (function () {
|
|---|
| 2536 | function HttpClientModule() {
|
|---|
| 2537 | }
|
|---|
| 2538 | return HttpClientModule;
|
|---|
| 2539 | }());
|
|---|
| 2540 | HttpClientModule.decorators = [
|
|---|
| 2541 | { type: core.NgModule, args: [{
|
|---|
| 2542 | /**
|
|---|
| 2543 | * Optional configuration for XSRF protection.
|
|---|
| 2544 | */
|
|---|
| 2545 | imports: [
|
|---|
| 2546 | HttpClientXsrfModule.withOptions({
|
|---|
| 2547 | cookieName: 'XSRF-TOKEN',
|
|---|
| 2548 | headerName: 'X-XSRF-TOKEN',
|
|---|
| 2549 | }),
|
|---|
| 2550 | ],
|
|---|
| 2551 | /**
|
|---|
| 2552 | * Configures the [dependency injector](guide/glossary#injector) where it is imported
|
|---|
| 2553 | * with supporting services for HTTP communications.
|
|---|
| 2554 | */
|
|---|
| 2555 | providers: [
|
|---|
| 2556 | HttpClient,
|
|---|
| 2557 | { provide: HttpHandler, useClass: HttpInterceptingHandler },
|
|---|
| 2558 | HttpXhrBackend,
|
|---|
| 2559 | { provide: HttpBackend, useExisting: HttpXhrBackend },
|
|---|
| 2560 | ],
|
|---|
| 2561 | },] }
|
|---|
| 2562 | ];
|
|---|
| 2563 | /**
|
|---|
| 2564 | * Configures the [dependency injector](guide/glossary#injector) for `HttpClient`
|
|---|
| 2565 | * with supporting services for JSONP.
|
|---|
| 2566 | * Without this module, Jsonp requests reach the backend
|
|---|
| 2567 | * with method JSONP, where they are rejected.
|
|---|
| 2568 | *
|
|---|
| 2569 | * You can add interceptors to the chain behind `HttpClient` by binding them to the
|
|---|
| 2570 | * multiprovider for built-in [DI token](guide/glossary#di-token) `HTTP_INTERCEPTORS`.
|
|---|
| 2571 | *
|
|---|
| 2572 | * @publicApi
|
|---|
| 2573 | */
|
|---|
| 2574 | var HttpClientJsonpModule = /** @class */ (function () {
|
|---|
| 2575 | function HttpClientJsonpModule() {
|
|---|
| 2576 | }
|
|---|
| 2577 | return HttpClientJsonpModule;
|
|---|
| 2578 | }());
|
|---|
| 2579 | HttpClientJsonpModule.decorators = [
|
|---|
| 2580 | { type: core.NgModule, args: [{
|
|---|
| 2581 | providers: [
|
|---|
| 2582 | JsonpClientBackend,
|
|---|
| 2583 | { provide: JsonpCallbackContext, useFactory: jsonpCallbackContext },
|
|---|
| 2584 | { provide: HTTP_INTERCEPTORS, useClass: JsonpInterceptor, multi: true },
|
|---|
| 2585 | ],
|
|---|
| 2586 | },] }
|
|---|
| 2587 | ];
|
|---|
| 2588 |
|
|---|
| 2589 | /**
|
|---|
| 2590 | * @license
|
|---|
| 2591 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 2592 | *
|
|---|
| 2593 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 2594 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 2595 | */
|
|---|
| 2596 | /**
|
|---|
| 2597 | * A wrapper around the `XMLHttpRequest` constructor.
|
|---|
| 2598 | *
|
|---|
| 2599 | * @publicApi
|
|---|
| 2600 | * @see `XhrFactory`
|
|---|
| 2601 | * @deprecated
|
|---|
| 2602 | * `XhrFactory` has moved, please import `XhrFactory` from `@angular/common` instead.
|
|---|
| 2603 | */
|
|---|
| 2604 | var XhrFactory = common.XhrFactory;
|
|---|
| 2605 |
|
|---|
| 2606 | /**
|
|---|
| 2607 | * @license
|
|---|
| 2608 | * Copyright Google LLC All Rights Reserved.
|
|---|
| 2609 | *
|
|---|
| 2610 | * Use of this source code is governed by an MIT-style license that can be
|
|---|
| 2611 | * found in the LICENSE file at https://angular.io/license
|
|---|
| 2612 | */
|
|---|
| 2613 |
|
|---|
| 2614 | /**
|
|---|
| 2615 | * Generated bundle index. Do not edit.
|
|---|
| 2616 | */
|
|---|
| 2617 |
|
|---|
| 2618 | exports.HTTP_INTERCEPTORS = HTTP_INTERCEPTORS;
|
|---|
| 2619 | exports.HttpBackend = HttpBackend;
|
|---|
| 2620 | exports.HttpClient = HttpClient;
|
|---|
| 2621 | exports.HttpClientJsonpModule = HttpClientJsonpModule;
|
|---|
| 2622 | exports.HttpClientModule = HttpClientModule;
|
|---|
| 2623 | exports.HttpClientXsrfModule = HttpClientXsrfModule;
|
|---|
| 2624 | exports.HttpContext = HttpContext;
|
|---|
| 2625 | exports.HttpContextToken = HttpContextToken;
|
|---|
| 2626 | exports.HttpErrorResponse = HttpErrorResponse;
|
|---|
| 2627 | exports.HttpHandler = HttpHandler;
|
|---|
| 2628 | exports.HttpHeaderResponse = HttpHeaderResponse;
|
|---|
| 2629 | exports.HttpHeaders = HttpHeaders;
|
|---|
| 2630 | exports.HttpParams = HttpParams;
|
|---|
| 2631 | exports.HttpRequest = HttpRequest;
|
|---|
| 2632 | exports.HttpResponse = HttpResponse;
|
|---|
| 2633 | exports.HttpResponseBase = HttpResponseBase;
|
|---|
| 2634 | exports.HttpUrlEncodingCodec = HttpUrlEncodingCodec;
|
|---|
| 2635 | exports.HttpXhrBackend = HttpXhrBackend;
|
|---|
| 2636 | exports.HttpXsrfTokenExtractor = HttpXsrfTokenExtractor;
|
|---|
| 2637 | exports.JsonpClientBackend = JsonpClientBackend;
|
|---|
| 2638 | exports.JsonpInterceptor = JsonpInterceptor;
|
|---|
| 2639 | exports.XhrFactory = XhrFactory;
|
|---|
| 2640 | exports.ɵHttpInterceptingHandler = HttpInterceptingHandler;
|
|---|
| 2641 | exports.ɵangular_packages_common_http_http_a = NoopInterceptor;
|
|---|
| 2642 | exports.ɵangular_packages_common_http_http_b = JsonpCallbackContext;
|
|---|
| 2643 | exports.ɵangular_packages_common_http_http_c = jsonpCallbackContext;
|
|---|
| 2644 | exports.ɵangular_packages_common_http_http_d = XSRF_COOKIE_NAME;
|
|---|
| 2645 | exports.ɵangular_packages_common_http_http_e = XSRF_HEADER_NAME;
|
|---|
| 2646 | exports.ɵangular_packages_common_http_http_f = HttpXsrfCookieExtractor;
|
|---|
| 2647 | exports.ɵangular_packages_common_http_http_g = HttpXsrfInterceptor;
|
|---|
| 2648 |
|
|---|
| 2649 | Object.defineProperty(exports, '__esModule', { value: true });
|
|---|
| 2650 |
|
|---|
| 2651 | })));
|
|---|
| 2652 | //# sourceMappingURL=common-http.umd.js.map
|
|---|
