@angular/common
Version:
Angular - commonly needed directives and services
289 lines • 27.6 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { DOCUMENT } from '@angular/common';
import { Inject, Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { HttpErrorResponse, HttpEventType, HttpResponse } from './response';
// Every request made through JSONP needs a callback name that's unique across the
// whole page. Each request is assigned an id and the callback name is constructed
// from that. The next id to be assigned is tracked in a global variable here that
// is shared among all applications on the page.
/** @type {?} */
let nextRequestId = 0;
// Error text given when a JSONP script is injected, but doesn't invoke the callback
// passed in its URL.
/** @type {?} */
export const JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';
// Error text given when a request is passed to the JsonpClientBackend that doesn't
// have a request method JSONP.
/** @type {?} */
export const JSONP_ERR_WRONG_METHOD = 'JSONP requests must use JSONP request method.';
/** @type {?} */
export const JSONP_ERR_WRONG_RESPONSE_TYPE = 'JSONP requests must use Json response type.';
/**
* DI token/abstract type representing a map of JSONP callbacks.
*
* In the browser, this should always be the `window` object.
*
*
* @abstract
*/
export class JsonpCallbackContext {
}
/**
* Processes an `HttpRequest` with the JSONP method,
* by performing JSONP style requests.
* @see `HttpHandler`
* @see `HttpXhrBackend`
*
* \@publicApi
*/
export class JsonpClientBackend {
/**
* @param {?} callbackMap
* @param {?} document
*/
constructor(callbackMap, document) {
this.callbackMap = callbackMap;
this.document = document;
}
/**
* Get the name of the next callback method, by incrementing the global `nextRequestId`.
* @private
* @return {?}
*/
nextCallback() { return `ng_jsonp_callback_${nextRequestId++}`; }
/**
* Processes a JSONP request and returns an event stream of the results.
* @param {?} req The request object.
* @return {?} An observable of the response events.
*
*/
handle(req) {
// Firstly, check both the method and response type. If either doesn't match
// then the request was improperly routed here and cannot be handled.
if (req.method !== 'JSONP') {
throw new Error(JSONP_ERR_WRONG_METHOD);
}
else if (req.responseType !== 'json') {
throw new Error(JSONP_ERR_WRONG_RESPONSE_TYPE);
}
// Everything else happens inside the Observable boundary.
return new Observable((/**
* @param {?} observer
* @return {?}
*/
(observer) => {
// The first step to make a request is to generate the callback name, and replace the
// callback placeholder in the URL with the name. Care has to be taken here to ensure
// a trailing &, if matched, gets inserted back into the URL in the correct place.
/** @type {?} */
const callback = this.nextCallback();
/** @type {?} */
const url = req.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/, `=${callback}$1`);
// Construct the <script> tag and point it at the URL.
/** @type {?} */
const node = this.document.createElement('script');
node.src = url;
// A JSONP request requires waiting for multiple callbacks. These variables
// are closed over and track state across those callbacks.
// The response object, if one has been received, or null otherwise.
/** @type {?} */
let body = null;
// Whether the response callback has been called.
/** @type {?} */
let finished = false;
// Whether the request has been cancelled (and thus any other callbacks)
// should be ignored.
/** @type {?} */
let cancelled = false;
// Set the response callback in this.callbackMap (which will be the window
// object in the browser. The script being loaded via the <script> tag will
// eventually call this callback.
this.callbackMap[callback] = (/**
* @param {?=} data
* @return {?}
*/
(data) => {
// Data has been received from the JSONP script. Firstly, delete this callback.
delete this.callbackMap[callback];
// Next, make sure the request wasn't cancelled in the meantime.
if (cancelled) {
return;
}
// Set state to indicate data was received.
body = data;
finished = true;
});
// cleanup() is a utility closure that removes the <script> from the page and
// the response callback from the window. This logic is used in both the
// success, error, and cancellation paths, so it's extracted out for convenience.
/** @type {?} */
const cleanup = (/**
* @return {?}
*/
() => {
// Remove the <script> tag if it's still on the page.
if (node.parentNode) {
node.parentNode.removeChild(node);
}
// Remove the response callback from the callbackMap (window object in the
// browser).
delete this.callbackMap[callback];
});
// onLoad() is the success callback which runs after the response callback
// if the JSONP script loads successfully. The event itself is unimportant.
// If something went wrong, onLoad() may run without the response callback
// having been invoked.
/** @type {?} */
const onLoad = (/**
* @param {?} event
* @return {?}
*/
(event) => {
// Do nothing if the request has been cancelled.
if (cancelled) {
return;
}
// Cleanup the page.
cleanup();
// Check whether the response callback has run.
if (!finished) {
// It hasn't, something went wrong with the request. Return an error via
// the Observable error path. All JSONP errors have status 0.
observer.error(new HttpErrorResponse({
url,
status: 0,
statusText: 'JSONP Error',
error: new Error(JSONP_ERR_NO_CALLBACK),
}));
return;
}
// Success. body either contains the response body or null if none was
// returned.
observer.next(new HttpResponse({
body,
status: 200,
statusText: 'OK', url,
}));
// Complete the stream, the response is over.
observer.complete();
});
// onError() is the error callback, which runs if the script returned generates
// a Javascript error. It emits the error via the Observable error channel as
// a HttpErrorResponse.
/** @type {?} */
const onError = (/**
* @param {?} error
* @return {?}
*/
(error) => {
// If the request was already cancelled, no need to emit anything.
if (cancelled) {
return;
}
cleanup();
// Wrap the error in a HttpErrorResponse.
observer.error(new HttpErrorResponse({
error,
status: 0,
statusText: 'JSONP Error', url,
}));
});
// Subscribe to both the success (load) and error events on the <script> tag,
// and add it to the page.
node.addEventListener('load', onLoad);
node.addEventListener('error', onError);
this.document.body.appendChild(node);
// The request has now been successfully sent.
observer.next({ type: HttpEventType.Sent });
// Cancellation handler.
return (/**
* @return {?}
*/
() => {
// Track the cancellation so event listeners won't do anything even if already scheduled.
cancelled = true;
// Remove the event listeners so they won't run if the events later fire.
node.removeEventListener('load', onLoad);
node.removeEventListener('error', onError);
// And finally, clean up the page.
cleanup();
});
}));
}
}
JsonpClientBackend.decorators = [
{ type: Injectable }
];
/** @nocollapse */
JsonpClientBackend.ctorParameters = () => [
{ type: JsonpCallbackContext },
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
];
if (false) {
/**
* @type {?}
* @private
*/
JsonpClientBackend.prototype.callbackMap;
/**
* @type {?}
* @private
*/
JsonpClientBackend.prototype.document;
}
/**
* Identifies requests with the method JSONP and
* shifts them to the `JsonpClientBackend`.
*
* @see `HttpInterceptor`
*
* \@publicApi
*/
export class JsonpInterceptor {
/**
* @param {?} jsonp
*/
constructor(jsonp) {
this.jsonp = jsonp;
}
/**
* Identifies and handles a given JSONP request.
* @param {?} req The outgoing request object to handle.
* @param {?} next The next interceptor in the chain, or the backend
* if no interceptors remain in the chain.
* @return {?} An observable of the event stream.
*/
intercept(req, next) {
if (req.method === 'JSONP') {
return this.jsonp.handle((/** @type {?} */ (req)));
}
// Fall through for normal HTTP requests.
return next.handle(req);
}
}
JsonpInterceptor.decorators = [
{ type: Injectable }
];
/** @nocollapse */
JsonpInterceptor.ctorParameters = () => [
{ type: JsonpClientBackend }
];
if (false) {
/**
* @type {?}
* @private
*/
JsonpInterceptor.prototype.jsonp;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsonp.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/jsonp.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {DOCUMENT} from '@angular/common';\nimport {Inject, Injectable} from '@angular/core';\nimport {Observable, Observer} from 'rxjs';\n\nimport {HttpBackend, HttpHandler} from './backend';\nimport {HttpRequest} from './request';\nimport {HttpErrorResponse, HttpEvent, HttpEventType, HttpResponse} from './response';\n\n// Every request made through JSONP needs a callback name that's unique across the\n// whole page. Each request is assigned an id and the callback name is constructed\n// from that. The next id to be assigned is tracked in a global variable here that\n// is shared among all applications on the page.\nlet nextRequestId: number = 0;\n\n// Error text given when a JSONP script is injected, but doesn't invoke the callback\n// passed in its URL.\nexport const JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';\n\n// Error text given when a request is passed to the JsonpClientBackend that doesn't\n// have a request method JSONP.\nexport const JSONP_ERR_WRONG_METHOD = 'JSONP requests must use JSONP request method.';\nexport const JSONP_ERR_WRONG_RESPONSE_TYPE = 'JSONP requests must use Json response type.';\n\n/**\n * DI token/abstract type representing a map of JSONP callbacks.\n *\n * In the browser, this should always be the `window` object.\n *\n *\n */\nexport abstract class JsonpCallbackContext { [key: string]: (data: any) => void; }\n\n/**\n * Processes an `HttpRequest` with the JSONP method,\n * by performing JSONP style requests.\n * @see `HttpHandler`\n * @see `HttpXhrBackend`\n *\n * @publicApi\n */\n@Injectable()\nexport class JsonpClientBackend implements HttpBackend {\n  constructor(private callbackMap: JsonpCallbackContext, @Inject(DOCUMENT) private document: any) {}\n\n  /**\n   * Get the name of the next callback method, by incrementing the global `nextRequestId`.\n   */\n  private nextCallback(): string { return `ng_jsonp_callback_${nextRequestId++}`; }\n\n  /**\n   * Processes a JSONP request and returns an event stream of the results.\n   * @param req The request object.\n   * @returns An observable of the response events.\n   *\n   */\n  handle(req: HttpRequest<never>): Observable<HttpEvent<any>> {\n    // Firstly, check both the method and response type. If either doesn't match\n    // then the request was improperly routed here and cannot be handled.\n    if (req.method !== 'JSONP') {\n      throw new Error(JSONP_ERR_WRONG_METHOD);\n    } else if (req.responseType !== 'json') {\n      throw new Error(JSONP_ERR_WRONG_RESPONSE_TYPE);\n    }\n\n    // Everything else happens inside the Observable boundary.\n    return new Observable<HttpEvent<any>>((observer: Observer<HttpEvent<any>>) => {\n      // The first step to make a request is to generate the callback name, and replace the\n      // callback placeholder in the URL with the name. Care has to be taken here to ensure\n      // a trailing &, if matched, gets inserted back into the URL in the correct place.\n      const callback = this.nextCallback();\n      const url = req.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/, `=${callback}$1`);\n\n      // Construct the <script> tag and point it at the URL.\n      const node = this.document.createElement('script');\n      node.src = url;\n\n      // A JSONP request requires waiting for multiple callbacks. These variables\n      // are closed over and track state across those callbacks.\n\n      // The response object, if one has been received, or null otherwise.\n      let body: any|null = null;\n\n      // Whether the response callback has been called.\n      let finished: boolean = false;\n\n      // Whether the request has been cancelled (and thus any other callbacks)\n      // should be ignored.\n      let cancelled: boolean = false;\n\n      // Set the response callback in this.callbackMap (which will be the window\n      // object in the browser. The script being loaded via the <script> tag will\n      // eventually call this callback.\n      this.callbackMap[callback] = (data?: any) => {\n        // Data has been received from the JSONP script. Firstly, delete this callback.\n        delete this.callbackMap[callback];\n\n        // Next, make sure the request wasn't cancelled in the meantime.\n        if (cancelled) {\n          return;\n        }\n\n        // Set state to indicate data was received.\n        body = data;\n        finished = true;\n      };\n\n      // cleanup() is a utility closure that removes the <script> from the page and\n      // the response callback from the window. This logic is used in both the\n      // success, error, and cancellation paths, so it's extracted out for convenience.\n      const cleanup = () => {\n        // Remove the <script> tag if it's still on the page.\n        if (node.parentNode) {\n          node.parentNode.removeChild(node);\n        }\n\n        // Remove the response callback from the callbackMap (window object in the\n        // browser).\n        delete this.callbackMap[callback];\n      };\n\n      // onLoad() is the success callback which runs after the response callback\n      // if the JSONP script loads successfully. The event itself is unimportant.\n      // If something went wrong, onLoad() may run without the response callback\n      // having been invoked.\n      const onLoad = (event: Event) => {\n        // Do nothing if the request has been cancelled.\n        if (cancelled) {\n          return;\n        }\n\n        // Cleanup the page.\n        cleanup();\n\n        // Check whether the response callback has run.\n        if (!finished) {\n          // It hasn't, something went wrong with the request. Return an error via\n          // the Observable error path. All JSONP errors have status 0.\n          observer.error(new HttpErrorResponse({\n            url,\n            status: 0,\n            statusText: 'JSONP Error',\n            error: new Error(JSONP_ERR_NO_CALLBACK),\n          }));\n          return;\n        }\n\n        // Success. body either contains the response body or null if none was\n        // returned.\n        observer.next(new HttpResponse({\n          body,\n          status: 200,\n          statusText: 'OK', url,\n        }));\n\n        // Complete the stream, the response is over.\n        observer.complete();\n      };\n\n      // onError() is the error callback, which runs if the script returned generates\n      // a Javascript error. It emits the error via the Observable error channel as\n      // a HttpErrorResponse.\n      const onError: any = (error: Error) => {\n        // If the request was already cancelled, no need to emit anything.\n        if (cancelled) {\n          return;\n        }\n        cleanup();\n\n        // Wrap the error in a HttpErrorResponse.\n        observer.error(new HttpErrorResponse({\n          error,\n          status: 0,\n          statusText: 'JSONP Error', url,\n        }));\n      };\n\n      // Subscribe to both the success (load) and error events on the <script> tag,\n      // and add it to the page.\n      node.addEventListener('load', onLoad);\n      node.addEventListener('error', onError);\n      this.document.body.appendChild(node);\n\n      // The request has now been successfully sent.\n      observer.next({type: HttpEventType.Sent});\n\n      // Cancellation handler.\n      return () => {\n        // Track the cancellation so event listeners won't do anything even if already scheduled.\n        cancelled = true;\n\n        // Remove the event listeners so they won't run if the events later fire.\n        node.removeEventListener('load', onLoad);\n        node.removeEventListener('error', onError);\n\n        // And finally, clean up the page.\n        cleanup();\n      };\n    });\n  }\n}\n\n/**\n * Identifies requests with the method JSONP and\n * shifts them to the `JsonpClientBackend`.\n *\n * @see `HttpInterceptor`\n *\n * @publicApi\n */\n@Injectable()\nexport class JsonpInterceptor {\n  constructor(private jsonp: JsonpClientBackend) {}\n\n  /**\n   * Identifies and handles a given JSONP request.\n   * @param req The outgoing request object to handle.\n   * @param next The next interceptor in the chain, or the backend\n   * if no interceptors remain in the chain.\n   * @returns An observable of the event stream.\n   */\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n    if (req.method === 'JSONP') {\n      return this.jsonp.handle(req as HttpRequest<never>);\n    }\n    // Fall through for normal HTTP requests.\n    return next.handle(req);\n  }\n}\n"]}