@wise/dynamic-flow-client 0.2.0 → 0.2.1

package/build/common/validation/validation-failures/spec.js

@@ -1,185 +0,0 @@
-import { getValidationFailures } from '.';
-describe('Given a library for identifying validation failures', function () {
-    var schema;
-    describe('when value is null and schema required', function () {
-        beforeEach(function () {
-            schema = {
-                type: 'string',
-                minLength: 3,
-                maxLength: 10,
-                pattern: '^[a-z]+$'
-            };
-        });
-        it('should return only required', function () {
-            expect(getValidationFailures(null, schema, true)).toStrictEqual(['required']);
-        });
-    });
-    describe('when validating a string schema', function () {
-        beforeEach(function () {
-            schema = {
-                type: 'string',
-                minLength: 3,
-                maxLength: 6,
-                pattern: '^[a-z]+$'
-            };
-        });
-        it('should return an empty array for valid string', function () {
-            expect(getValidationFailures('string', schema, false)).toStrictEqual([]);
-        });
-        it('should return an empty array for null if not required', function () {
-            expect(getValidationFailures(null, schema, false)).toStrictEqual([]);
-        });
-        it('should return minLength when too short', function () {
-            expect(getValidationFailures('st', schema, false)).toStrictEqual(['minLength']);
-        });
-        it('should return [maxLength] when too long', function () {
-            expect(getValidationFailures('strings', schema, false)).toStrictEqual(['maxLength']);
-        });
-        it('should return [pattern] when does not pass regex', function () {
-            expect(getValidationFailures('STRING', schema, false)).toStrictEqual(['pattern']);
-        });
-        it('should return [type] when incorrect data type', function () {
-            expect(getValidationFailures(1234, schema, false)).toStrictEqual(['type']);
-        });
-    });
-    describe('when validating a string date', function () {
-        beforeEach(function () {
-            schema = {
-                type: 'string',
-                minimum: '2000-01-01T00:00:00Z',
-                maximum: '2010-01-01T00:00:00Z'
-            };
-        });
-        it('should return an empty array for valid date', function () {
-            expect(getValidationFailures('2005-01-01T00:00:00Z', schema, false)).toStrictEqual([]);
-        });
-        it('should return [min] when date is too early', function () {
-            expect(getValidationFailures('1999-01-01T00:00:00Z', schema, false)).toStrictEqual([
-                'minimum',
-            ]);
-        });
-        it('should return [max] when date is too late', function () {
-            expect(getValidationFailures('2011-01-01T00:00:00Z', schema, false)).toStrictEqual([
-                'maximum',
-            ]);
-        });
-    });
-    describe('when validating a number schema', function () {
-        beforeEach(function () {
-            schema = {
-                type: 'number',
-                minimum: 0,
-                maximum: 20
-            };
-        });
-        it('should return an empty array for an integer in range', function () {
-            expect(getValidationFailures(10, schema, false)).toStrictEqual([]);
-        });
-        it('should return an empty array for a float in range', function () {
-            expect(getValidationFailures(12.34, schema, false)).toStrictEqual([]);
-        });
-        it('should return an empty array for a number that matches our min', function () {
-            expect(getValidationFailures(0, schema, false)).toStrictEqual([]);
-        });
-        it('should return an empty array for a number that matches our max', function () {
-            expect(getValidationFailures(20, schema, false)).toStrictEqual([]);
-        });
-        it('should return [min] when number is too low', function () {
-            expect(getValidationFailures(-1, schema, false)).toStrictEqual(['minimum']);
-        });
-        it('should return [max] when number is too high', function () {
-            expect(getValidationFailures(21, schema, false)).toStrictEqual(['maximum']);
-        });
-        it('should return [type] when incorrect data type', function () {
-            expect(getValidationFailures('string', schema, false)).toStrictEqual(['type']);
-        });
-    });
-    describe('when validating an integer schema', function () {
-        beforeEach(function () {
-            schema = { type: 'integer' };
-        });
-        it('should return an empty array for valid integer', function () {
-            expect(getValidationFailures(15, schema, false)).toStrictEqual([]);
-        });
-        it('should return [type] when a number is not an integer', function () {
-            expect(getValidationFailures(12.34, schema, false)).toStrictEqual(['type']);
-        });
-    });
-    describe('when validating a boolean schema', function () {
-        beforeEach(function () {
-            schema = { type: 'boolean' };
-        });
-        it('should return an empty array for valid boolean', function () {
-            expect(getValidationFailures(true, schema, false)).toStrictEqual([]);
-            expect(getValidationFailures(false, schema, false)).toStrictEqual([]);
-        });
-        it('should return [type] when incorrect data type', function () {
-            expect(getValidationFailures(1, schema, false)).toStrictEqual(['type']);
-        });
-    });
-    describe('when validating a const schema', function () {
-        beforeEach(function () {
-            schema = { "const": 'abcd' };
-        });
-        it('should return an empty array when the const matches', function () {
-            expect(getValidationFailures('abcd', schema, false)).toStrictEqual([]);
-        });
-        it("should return ['const'] when the const does not match", function () {
-            expect(getValidationFailures('1234', schema, false)).toStrictEqual(['const']);
-        });
-        it("should return ['const'] when null", function () {
-            expect(getValidationFailures(null, schema, false)).toStrictEqual(['const']);
-        });
-        it("should return ['const'] when undefined", function () {
-            expect(getValidationFailures(undefined, schema, false)) //
-                .toStrictEqual(['const']);
-        });
-    });
-    describe('when validating an array schema', function () {
-        beforeEach(function () {
-            schema = {
-                type: 'array',
-                items: {
-                    type: 'number'
-                },
-                minItems: 2,
-                maxItems: 2
-            };
-        });
-        it('should return an empty array for a valid array', function () {
-            expect(getValidationFailures([1, 2], schema, false)).toStrictEqual([]);
-        });
-        it('should return [minItems] when the array is too small', function () {
-            expect(getValidationFailures([1], schema, false)).toStrictEqual(['minItems']);
-        });
-        it('should return [maxItems] when the array is too big', function () {
-            expect(getValidationFailures([1, 2, 3], schema, false)).toStrictEqual(['maxItems']);
-        });
-        it('should return [type] when incorrect data type', function () {
-            expect(getValidationFailures({ a: 1 }, schema, false)).toStrictEqual(['type']);
-        });
-    });
-    describe('when validating an object schema', function () {
-        beforeEach(function () {
-            schema = {
-                type: 'object',
-                properties: {
-                    a: {
-                        type: 'number'
-                    }
-                },
-                required: ['a'],
-                displayOrder: ['a']
-            };
-        });
-        it('should return an empty array for a valid object', function () {
-            expect(getValidationFailures({ a: 1 }, schema, false)).toStrictEqual([]);
-        });
-        it('should return [required] when required properties are missing', function () {
-            expect(getValidationFailures({}, schema, false)).toStrictEqual(['required']);
-        });
-        it('should return [type] when incorrect data type', function () {
-            expect(getValidationFailures([1], schema, false)).toStrictEqual(['type']);
-        });
-    });
-});

package/build/flow/response-parsers/spec.d.ts

@@ -1 +0,0 @@
-export {};

package/build/flow/response-parsers/spec.js

@@ -1,263 +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 { parseErrorResponse, parseExitResponse, parseFetchResponse } from '.';
-describe('parseFetchResponse', function () {
-    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 () {
-            getNonObjectBodyCases().forEach(function (_a) {
-                var description = _a[0], body = _a[1];
-                describe("when the body is ".concat(description), function () {
-                    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 () {
-            getNonObjectBodyCases().forEach(function (_a) {
-                var description = _a[0], body = _a[1];
-                describe("when the body is ".concat(description), 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(body))).rejects.toThrow('Incorrect response body in response. Expected an object.')];
-                                case 1:
-                                    _a.sent();
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); });
-                });
-            });
-        });
-    });
-});
-describe('parseErrorResponse', function () {
-    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 () {
-        getNonObjectBodyCases().forEach(function (_a) {
-            var description = _a[0], body = _a[1];
-            describe("when the body is ".concat(description), 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(parseErrorResponse(new Response(body))).rejects.toThrow('Incorrect response body in error response. Expected an object.')];
-                            case 1:
-                                _a.sent();
-                                return [2 /*return*/];
-                        }
-                    });
-                }); });
-            });
-        });
-    });
-});
-describe('parseExitResponse', function () {
-    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(parseExitResponse(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 () {
-        getNonObjectBodyCases().forEach(function (_a) {
-            var description = _a[0], body = _a[1];
-            describe("when the body is ".concat(description), function () {
-                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*/, parseExitResponse(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')],
-    ];
-}

package/build/layout/loading-indicator/spec.d.ts

@@ -1 +0,0 @@
-export {};

package/build/layout/loading-indicator/spec.js

@@ -1,11 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { render } from '@testing-library/react';
-import { DynamicLoadingIndicator } from '.';
-describe('Given a component for dynamically rendering a loading indicator', function () {
-    describe('when initialised without any properties', function () {
-        it('renders a loading indicator of the default "md" size', function () {
-            var baseElement = render(_jsx(DynamicLoadingIndicator, { component: { type: 'loading-indicator' } })).baseElement;
-            expect(baseElement).toMatchInlineSnapshot("\n<body>\n  <div>\n    <div\n      class=\"tw-loader m-x-auto  tw-loader--md\"\n    >\n      <div\n        class=\"tw-loader__stripe\"\n      />\n      <div\n        class=\"tw-loader__stripe\"\n      />\n      <div\n        class=\"tw-loader__stripe\"\n      />\n      <div\n        class=\"tw-loader__stripe\"\n      />\n      <div\n        class=\"tw-loader__stripe\"\n      />\n    </div>\n  </div>\n</body>\n");
-        });
-    });
-});