@wise/dynamic-flow-client 3.11.4-experiment-node20-aa45bc2 → 3.11.4

package/build/legacy/dynamicFlow/utils/responseParsers/response-parsers.js

@@ -1,185 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            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) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import { isObject } from '../../../common/validators';
-var parseFetchResponseByResponseType = function (response, type) { return __awaiter(void 0, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-        switch (type) {
-            case 'step':
-                return [2 /*return*/, parseStepResponse(response)];
-            case 'exit':
-                return [2 /*return*/, parseExitResponse(response)];
-            case 'action':
-                return [2 /*return*/, parseActionResponse(response)];
-            default:
-                throw new Error("Unsupported X-Df-Response-Type. Allowed values are 'step', 'action', 'exit'.");
-        }
-        return [2 /*return*/];
-    });
-}); };
-var parseStepResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
-    var jsonBody, etag;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, parseResponseJson(response)];
-            case 1:
-                jsonBody = _a.sent();
-                if (!isObject(jsonBody)) {
-                    throw new Error('Incorrect response body in response. Expected an object.');
-                }
-                etag = response.headers.get('etag') || undefined;
-                return [2 /*return*/, { type: 'step', step: jsonBody, etag: etag }];
-        }
-    });
-}); };
-var parseActionResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
-    var jsonBody, action;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, parseResponseJson(response)];
-            case 1:
-                jsonBody = _a.sent();
-                if (!isObject(jsonBody)) {
-                    throw new Error('Incorrect response body in response. Expected an object.');
-                }
-                if (!isObject(jsonBody.action)) {
-                    throw new Error('Incorrect response body in action response. Expected an object satisfying the type { action: Action }.');
-                }
-                action = jsonBody.action;
-                if (action.exit === true && isObject(action.result)) {
-                    return [2 /*return*/, { type: 'exit', result: action.result }];
-                }
-                return [2 /*return*/, { type: 'action', action: jsonBody.action }];
-        }
-    });
-}); };
-var parseExitResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                _a = { type: 'exit' };
-                return [4 /*yield*/, getJsonObjectOrNull(response)];
-            case 1: return [2 /*return*/, (_a.result = _b.sent(), _a)];
-        }
-    });
-}); };
-export var parseFetchResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
-    var type, jsonBody;
-    var _a, _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                assertResponseIsValid(response);
-                if ((_a = response.headers) === null || _a === void 0 ? void 0 : _a.has('X-Df-Response-Type')) {
-                    type = response.headers.get('X-Df-Response-Type');
-                    return [2 /*return*/, parseFetchResponseByResponseType(response, type)];
-                }
-                if ((_b = response.headers) === null || _b === void 0 ? void 0 : _b.has('X-Df-Exit')) {
-                    return [2 /*return*/, parseExitResponse(response)];
-                }
-                return [4 /*yield*/, parseResponseJson(response.clone())];
-            case 1:
-                jsonBody = _c.sent();
-                if (isObject(jsonBody) && jsonBody.action) {
-                    return [2 /*return*/, parseActionResponse(response)];
-                }
-                return [2 /*return*/, parseStepResponse(response)];
-        }
-    });
-}); };
-export var parseErrorResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
-    var jsonBody;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                assertResponseIsValid(response);
-                return [4 /*yield*/, parseResponseJson(response)];
-            case 1:
-                jsonBody = _a.sent();
-                if (!isObject(jsonBody)) {
-                    throw new Error('Incorrect response body in error response. Expected an object.');
-                }
-                if (!jsonBody.refreshFormUrl && !jsonBody.refreshUrl && !jsonBody.validation && !jsonBody.error) {
-                    // eslint-disable-next-line @typescript-eslint/only-throw-error
-                    throw jsonBody;
-                }
-                return [2 /*return*/, jsonBody];
-        }
-    });
-}); };
-export var getJsonObjectOrNull = function (response) { return __awaiter(void 0, void 0, void 0, function () {
-    var result;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                assertResponseIsValid(response);
-                return [4 /*yield*/, parseResponseJson(response)];
-            case 1:
-                result = _a.sent();
-                return [2 /*return*/, isObject(result) ? result : null];
-        }
-    });
-}); };
-var parseResponseJson = function (response) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                _b.trys.push([0, 2, , 3]);
-                return [4 /*yield*/, response.json()];
-            case 1: return [2 /*return*/, (_b.sent())];
-            case 2:
-                _a = _b.sent();
-                return [2 /*return*/, null];
-            case 3: return [2 /*return*/];
-        }
-    });
-}); };
-var assertResponseIsValid = function (response) {
-    if (!isResponse(response)) {
-        throw new Error('Incorrect type of response from fetch. Expected object of type Response.');
-    }
-    if (response.bodyUsed) {
-        throw new Error('The body of the provided Response object has already been used. Every request must respond with a new Response object.');
-    }
-};
-var isResponse = function (response) {
-    return typeof response === 'object' &&
-        response !== null &&
-        'clone' in response &&
-        'bodyUsed' in response;
-};

package/build/legacy/dynamicFlow/utils/responseParsers/response-parsers.spec.js

@@ -1,463 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            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) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import { parseFetchResponse, parseErrorResponse, getJsonObjectOrNull } from './response-parsers';
-describe('parseFetchResponse', function () {
-    describe('when the response object is not an instance of Response', function () {
-        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        response = { invalid: 'response' };
-                        return [4 /*yield*/, expect(parseFetchResponse(response)).rejects.toThrow('Incorrect type of response from fetch. Expected object of type Response.')];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe('when the Response body has already been parsed', function () {
-        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        response = new Response("{}");
-                        return [4 /*yield*/, response.json()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, expect(parseFetchResponse(response)).rejects.toThrow('The body of the provided Response object has already been used. Every request must respond with a new Response object.')];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe('when response contains the X-DF-Response-Type header', function () {
-        describe('step (with etag)', function () {
-            var headers = { 'X-Df-Response-Type': 'step', etag: '4be5c814' };
-            it('returns a "step" object with the step taken from the response body and etag', function () { return __awaiter(void 0, void 0, void 0, function () {
-                var parsedBody;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, parseFetchResponse(new Response("{ \"id\": \"step-id\" }", { headers: headers }))];
-                        case 1:
-                            parsedBody = _a.sent();
-                            expect(parsedBody).toStrictEqual({
-                                type: 'step',
-                                step: { id: 'step-id' },
-                                etag: '4be5c814',
-                            });
-                            return [2 /*return*/];
-                    }
-                });
-            }); });
-        });
-        describe('step (but no etag)', function () {
-            var headers = { 'X-Df-Response-Type': 'step' };
-            it('returns a "step" object with the step taken from the response body and an etag property as undefined', function () { return __awaiter(void 0, void 0, void 0, function () {
-                var parsedBody;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, parseFetchResponse(new Response("{ \"id\": \"step-id\" }", { headers: headers }))];
-                        case 1:
-                            parsedBody = _a.sent();
-                            expect(parsedBody).toStrictEqual({
-                                type: 'step',
-                                step: { id: 'step-id' },
-                                etag: undefined,
-                            });
-                            return [2 /*return*/];
-                    }
-                });
-            }); });
-        });
-        describe('action', function () {
-            describe('when the body contains a valid action', function () {
-                var headers = { 'X-Df-Response-Type': 'action' };
-                it('returns an "action" object with the response body action', function () { return __awaiter(void 0, void 0, void 0, function () {
-                    var parsedBody;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4 /*yield*/, parseFetchResponse(new Response("{ \"action\": { \"$id\": \"action-id\" } }", { headers: headers }))];
-                            case 1:
-                                parsedBody = _a.sent();
-                                expect(parsedBody).toStrictEqual({
-                                    type: 'action',
-                                    action: { $id: 'action-id' },
-                                });
-                                return [2 /*return*/];
-                        }
-                    });
-                }); });
-            });
-            describe('when the body contains an invalid action', function () {
-                var headers = { 'X-Df-Response-Type': 'action' };
-                it('throws an error', function () { return __awaiter(void 0, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4 /*yield*/, expect(parseFetchResponse(new Response("{ \"action\": \"this is not an action\" }", { headers: headers }))).rejects.toThrow('Incorrect response body in action response. Expected an object satisfying the type { action: Action }.')];
-                            case 1:
-                                _a.sent();
-                                return [2 /*return*/];
-                        }
-                    });
-                }); });
-            });
-            describe('when the body contains an exit action', function () {
-                var headers = { 'X-Df-Response-Type': 'action' };
-                it('returns an "exit" object with the response body action.result as result', function () { return __awaiter(void 0, void 0, void 0, function () {
-                    var parsedBody;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4 /*yield*/, parseFetchResponse(new Response("{ \"action\": { \"exit\": true, \"result\": {\"my-result\": 1234 } } }", {
-                                    headers: headers,
-                                }))];
-                            case 1:
-                                parsedBody = _a.sent();
-                                expect(parsedBody).toStrictEqual({
-                                    type: 'exit',
-                                    result: { 'my-result': 1234 },
-                                });
-                                return [2 /*return*/];
-                        }
-                    });
-                }); });
-            });
-        });
-        describe('exit', function () {
-            var headers = { 'X-Df-Response-Type': 'exit' };
-            it('returns "exit" with the response body as result', function () { return __awaiter(void 0, void 0, void 0, function () {
-                var parsedBody;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, parseFetchResponse(new Response('{"id": 12345, "name": "Bob Loblaw", "url": "bobloblaw.law.blog" }', {
-                                headers: headers,
-                            }))];
-                        case 1:
-                            parsedBody = _a.sent();
-                            expect(parsedBody).toStrictEqual({
-                                type: 'exit',
-                                result: { id: 12345, name: 'Bob Loblaw', url: 'bobloblaw.law.blog' },
-                            });
-                            return [2 /*return*/];
-                    }
-                });
-            }); });
-        });
-    });
-    describe('when response contains the X-DF-Exit header', function () {
-        var headers = { 'X-Df-Exit': 'true' };
-        describe('and response body can be json-parsed as an object', function () {
-            it('should return exit result', function () { return __awaiter(void 0, void 0, void 0, function () {
-                var response, parsedBody;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            response = new Response("{ \"exitResult\": \"exit result\" }", { headers: headers });
-                            return [4 /*yield*/, parseFetchResponse(response)];
-                        case 1:
-                            parsedBody = _a.sent();
-                            expect(parsedBody).toStrictEqual({
-                                type: 'exit',
-                                result: { exitResult: 'exit result' },
-                            });
-                            return [2 /*return*/];
-                    }
-                });
-            }); });
-        });
-        describe('but response body cannot be json-parsed as an object', function () {
-            describe.each(getNonObjectBodyCases())('when the body is %s', function (_, body) {
-                it("returns exit result with null", function () { return __awaiter(void 0, void 0, void 0, function () {
-                    var parsedBody;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4 /*yield*/, parseFetchResponse(new Response(body, { headers: headers }))];
-                            case 1:
-                                parsedBody = _a.sent();
-                                expect(parsedBody).toStrictEqual({ type: 'exit', result: null });
-                                return [2 /*return*/];
-                        }
-                    });
-                }); });
-            });
-        });
-    });
-    describe('when response does not contain the X-DF-Exit header', function () {
-        var headers = { etag: 'etag' };
-        describe('and response body can be json-parsed as an object', function () {
-            describe('and it contains an action property', function () {
-                describe('and the action property is an object', function () {
-                    it('assumes the action property is of type Action, and returns type action and the action', function () { return __awaiter(void 0, void 0, void 0, function () {
-                        var parsedBody;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, parseFetchResponse(new Response('{ "action": { "url": "/path", "method": "POST" } }'))];
-                                case 1:
-                                    parsedBody = _a.sent();
-                                    expect(parsedBody).toStrictEqual({
-                                        type: 'action',
-                                        action: { url: '/path', method: 'POST' },
-                                    });
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); });
-                    it('assumes the action property is of type Action, even if its NOT', function () { return __awaiter(void 0, void 0, void 0, function () {
-                        var parsedBody;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, parseFetchResponse(new Response('{ "action": { "random": "property" } }'))];
-                                case 1:
-                                    parsedBody = _a.sent();
-                                    expect(parsedBody).toStrictEqual({ type: 'action', action: { random: 'property' } });
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); });
-                });
-                describe('and the action property is NOT an object', function () {
-                    it('throws an error', function () { return __awaiter(void 0, void 0, void 0, function () {
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, expect(parseFetchResponse(new Response('{ "action": 123 }'))).rejects.toThrow('Incorrect response body in action response. Expected an object satisfying the type { action: Action }.')];
-                                case 1:
-                                    _a.sent();
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); });
-                });
-            });
-            describe('when the body is NOT an object with an action property', function () {
-                it('assumes the response is a step and returns step and etag', function () { return __awaiter(void 0, void 0, void 0, function () {
-                    var response, parsedBody;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                response = new Response("{ \"stepResult\": \"step result\" }", { headers: headers });
-                                return [4 /*yield*/, parseFetchResponse(response)];
-                            case 1:
-                                parsedBody = _a.sent();
-                                expect(parsedBody).toStrictEqual({
-                                    type: 'step',
-                                    step: { stepResult: 'step result' },
-                                    etag: 'etag',
-                                });
-                                return [2 /*return*/];
-                        }
-                    });
-                }); });
-            });
-        });
-        describe('but response body cannot be json-parsed as an object', function () {
-            describe.each(getNonObjectBodyCases())('when the body is %s', function (_, body) {
-                it("throws an error", function () { return __awaiter(void 0, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4 /*yield*/, expect(parseFetchResponse(new Response(body))).rejects.toThrow('Incorrect response body in response. Expected an object.')];
-                            case 1:
-                                _a.sent();
-                                return [2 /*return*/];
-                        }
-                    });
-                }); });
-            });
-        });
-    });
-});
-describe('parseErrorResponse', function () {
-    describe('when the response object is not an instance of Response', function () {
-        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        response = { invalid: 'response' };
-                        return [4 /*yield*/, expect(parseErrorResponse(response)).rejects.toThrow('Incorrect type of response from fetch. Expected object of type Response.')];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe('when the Response body has already been parsed', function () {
-        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        response = new Response("{}");
-                        return [4 /*yield*/, response.json()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, expect(parseErrorResponse(response)).rejects.toThrow('The body of the provided Response object has already been used. Every request must respond with a new Response object.')];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe('when response body can be json-parsed as an object', function () {
-        it('returns the response body', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var response, parsedBody;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        response = new Response(JSON.stringify({
-                            error: 'This is a global error',
-                            validation: { field: 'This is a field error' },
-                        }), { status: 422 });
-                        return [4 /*yield*/, parseErrorResponse(response)];
-                    case 1:
-                        parsedBody = _a.sent();
-                        expect(parsedBody).toStrictEqual({
-                            error: 'This is a global error',
-                            validation: { field: 'This is a field error' },
-                        });
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe('when response body CANNOT be json-parsed as an object', function () {
-        describe.each(getNonObjectBodyCases())('when the body is %s', function (_, body) {
-            it("throws an error", function () { return __awaiter(void 0, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, expect(parseErrorResponse(new Response(body))).rejects.toThrow('Incorrect response body in error response. Expected an object.')];
-                        case 1:
-                            _a.sent();
-                            return [2 /*return*/];
-                    }
-                });
-            }); });
-        });
-    });
-});
-describe('getJsonObjectOrNull', function () {
-    describe('when the response object is not an instance of Response', function () {
-        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        response = { invalid: 'response' };
-                        return [4 /*yield*/, expect(getJsonObjectOrNull(response)).rejects.toThrow('Incorrect type of response from fetch. Expected object of type Response.')];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe('when the Response body has already been parsed', function () {
-        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        response = new Response("{}");
-                        return [4 /*yield*/, response.json()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, expect(getJsonObjectOrNull(response)).rejects.toThrow('The body of the provided Response object has already been used. Every request must respond with a new Response object.')];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe('when response body can be json-parsed as an object', function () {
-        it('returns the parsed response body', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        response = new Response("{ \"exitResult\": \"exit result\" }");
-                        return [4 /*yield*/, expect(getJsonObjectOrNull(response)).resolves.toStrictEqual({
-                                exitResult: 'exit result',
-                            })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe('when response body CANNOT be json-parsed as an object', function () {
-        describe.each(getNonObjectBodyCases())('when the body is %s', function (_, body) {
-            it("returns null", function () { return __awaiter(void 0, void 0, void 0, function () {
-                var parsedBody;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, getJsonObjectOrNull(new Response(body))];
-                        case 1:
-                            parsedBody = _a.sent();
-                            expect(parsedBody).toBeNull();
-                            return [2 /*return*/];
-                    }
-                });
-            }); });
-        });
-    });
-});
-function getNonObjectBodyCases() {
-    return [
-        ['parseable as number', '1234'],
-        ['parseable as a string', '"json string"'],
-        ['parseable as an empty string', '""'],
-        ['parseable as an array', '[]'],
-        ['parseable as true', 'true'],
-        ['parseable as false', 'false'],
-        ['parseable as null', 'null'],
-        ['an empty string', ''],
-        ['non-json parseable string', 'non-json string'],
-        ['a number', 1234],
-        ['NaN', NaN],
-        ['undefined', undefined],
-        ['a Blob instance', new Blob()],
-        ['a FormData instance', new FormData()],
-        ['a URLSearchParams instance', new URLSearchParams('foo=bar')],
-    ];
-}