Interface InterceptableRequest

Represents an intercepted HTTP request which can be modified.

interface InterceptableRequest {
    body: RequestBody;
    closed: boolean;
    headers: HTTPHeaders;
    mediaType: MediaType;
    method: RequestMethod;
    responseType: ResponseType;
    subType: RequestSubType;
    type: RequestType;
    url: string;
    useCredentials: boolean;
    redirect(request: RequestLike): void;
    respondWith(response: ResponseInit): void;
    waitUntil(fn: WaitUntilCallback): void;
    waitUntil(promise: PromiseLike<any>): void;
}

Hierarchy (View Summary)

Request
- InterceptableRequest

Index

Properties

body closed headers mediaType method responseType subType type url useCredentials

Methods

redirect respondWith waitUntil

Properties

`Readonly`body

body: RequestBody

The request's body.

`Readonly`closed

closed: boolean

Whether the request is closed.

Remarks

- Request is closed by InterceptableRequest.redirect and InterceptableRequest.respondWith.

`Readonly`headers

headers: HTTPHeaders

The request's HTTP headers.

`Readonly`mediaType

mediaType: MediaType

The request's media type.

`Readonly`method

method: RequestMethod

The request's HTTP method.

`Readonly`responseType

responseType: ResponseType

The request's response type.

`Readonly`subType

subType: RequestSubType

The request's subtype.

`Readonly`type

type: RequestType

The request's type.

`Readonly`url

url: string

The request's URL.

`Readonly`useCredentials

useCredentials: boolean

Whether the player is allowed to use credentials for cross-origin requests.

Methods

redirect

redirect(request: RequestLike): void
Replaces the original request with the provided request.
Parameters
- request: RequestLike
  A RequestInit or a string which is shorthand for RequestInit.url.
Returns void
Remarks

- Invocation closes the request.
- Invocation while the request is closed will throw an error.

respondWith

respondWith(response: ResponseInit): void
Immediately respond with the provided response.
Parameters
- response: ResponseInit
  A ResponseInit.
Returns void
Remarks

- Invocation closes the request.
- Invocation while the request is closed will throw an error.
- The original request will not be performed.

waitUntil

waitUntil(fn: WaitUntilCallback): void
Wait until the given callback is done before closing and executing this request.
Parameters
- fn: WaitUntilCallback
  A WaitUntilCallback
Returns void
Remarks

- The first argument of the callback is a done function, which must be called to resolve the callback.
- Alternatively, the callback can return a PromiseLike.
- Invocation of the done function closes the request.
- Invocation while the request is closed will throw an error.
waitUntil(promise: PromiseLike<any>): void
Wait until the given promise is resolved before closing and executing this request.
Parameters
- promise: PromiseLike<any>
  A PromiseLike.
Returns void
Remarks

- Resolution of the promise closes the request.
- Invocation while the request is closed will throw an error.
- This is equivalent to:
```
request.waitUntil(function (done) {
  promise.then(function () {
    done();
  }).catch(function (error) {
    done(error);
  });
})
```