Interface InterceptableResponse

Represents an intercepted HTTP response which can be modified.

interface InterceptableResponse {
    body: ResponseBody;
    closed: boolean;
    headers: HTTPHeaders;
    request: Request;
    status: number;
    statusText: string;
    url: string;
    respondWith(response: ResponseInit): void;
    waitUntil(fn: WaitUntilCallback): void;
    waitUntil(promise: PromiseLike<any>): void;
}

Index

Properties

body closed headers request status statusText url

Methods

respondWith waitUntil

Properties

`Readonly`body

body: ResponseBody

The response's body.

`Readonly`closed

closed: boolean

Whether the response is closed.

Remarks

- Response is closed by InterceptableResponse.respondWith.

`Readonly`headers

headers: HTTPHeaders

The response's HTTP headers.

`Readonly`request

request: Request

The response's request.

`Readonly`status

status: number

The response's status code.

`Readonly`statusText

statusText: string

The response's status text.

`Readonly`url

url: string

The response's url.

Remarks

- This can differ from the request.url when redirected.

Methods

respondWith

respondWith(response: ResponseInit): void
Replaces the original response with the provided response.
Parameters
- response: ResponseInit
  A ResponseLike.
Returns void
Remarks

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

waitUntil

waitUntil(fn: WaitUntilCallback): void
Wait until the given callback is done before closing this response.
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.
- Invocation of the done function closes the response.
- Invocation while the response is closed will throw an error.
waitUntil(promise: PromiseLike<any>): void
Wait until the given promise is resolved before closing this response.
Parameters
- promise: PromiseLike<any>
  PromiseLike.
Returns void
Remarks

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