@wise/dynamic-flow-client 3.11.4-experimental-node20-6554c5d → 3.11.4

package/build/legacy/common/validators/validationFailures/validation-failures.spec.js

@@ -1,198 +0,0 @@
-import { getValidationFailures } from './validation-failures';
-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 basic 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 a complex const schema', function () {
-        beforeEach(function () {
-            schema = { const: { abcd: 'abcd' } };
-        });
-        it('should return an empty array when the const matches', function () {
-            expect(getValidationFailures({ abcd: 'abcd' }, schema, false)).toStrictEqual([]);
-        });
-        it("should return ['const'] when the const does not match", function () {
-            expect(getValidationFailures({ abcd: '1234' }, schema, false)).toStrictEqual(['const']);
-        });
-    });
-    describe('when validating an array schema', function () {
-        beforeEach(function () {
-            schema = {
-                type: 'array',
-                addItemTitle: '',
-                editItemTitle: '',
-                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/legacy/common/validators/validationFailures/validation-failures.utils.js

@@ -1,40 +0,0 @@
-import { isArray, isNumber, isString, isUndefined } from '..';
-function isValidRequired(value, isRequired) {
-    if (isRequired === void 0) { isRequired = false; }
-    return !isRequired || !isUndefined(value);
-}
-function isValidRequiredArray(value, isRequired) {
-    if (isRequired === void 0) { isRequired = false; }
-    return !isRequired || isArray(value);
-}
-function isValidMinLength(value, minLength) {
-    return !isNumber(minLength) || (isString(value) && value.length >= minLength);
-}
-function isValidMaxLength(value, maxLength) {
-    return !isNumber(maxLength) || (isString(value) && value.length <= maxLength);
-}
-function isValidPattern(value, pattern) {
-    if (pattern === undefined) {
-        return true; // no pattern, therefore the value is valid
-    }
-    if (value === undefined || value === null) {
-        return false; // no value, but there's a pattern, therefore the value is NOT valid
-    }
-    var regex = new RegExp(pattern);
-    return Boolean(regex.test(value));
-}
-function isValidMaximum(value, maximum) {
-    return ((!isNumber(maximum) && !isString(maximum)) ||
-        ((isNumber(value) || isString(value)) && value <= maximum));
-}
-function isValidMinimum(value, minimum) {
-    return ((!isNumber(minimum) && !isString(minimum)) ||
-        ((isNumber(value) || isString(value)) && value >= minimum));
-}
-function isValidMinItems(value, minItems) {
-    return !isNumber(minItems) || (isArray(value) && value.length >= minItems);
-}
-function isValidMaxItems(value, maxItems) {
-    return !isNumber(maxItems) || (isArray(value) && value.length <= maxItems);
-}
-export { isValidRequired, isValidMinLength, isValidMaxLength, isValidPattern, isValidMaximum, isValidMinimum, isValidMinItems, isValidMaxItems, isValidRequiredArray, };

package/build/legacy/common/validators/validationFailures/validation-failures.utils.spec.js

@@ -1,145 +0,0 @@
-import { isValidRequired, isValidMinLength, isValidMaxLength, isValidMinimum, isValidMaximum, isValidPattern, isValidMinItems, isValidMaxItems, isValidRequiredArray, } from './validation-failures.utils';
-describe('Given a library for validating json schema rules', function () {
-    describe('when establishing if a value passes required validation', function () {
-        it('should return true if required and value defined', function () {
-            expect(isValidRequired('something', true)).toBe(true);
-        });
-        it('should return false if required and value undefined', function () {
-            expect(isValidRequired(undefined, true)).toBe(false);
-        });
-        it('should return true if not required', function () {
-            expect(isValidRequired(undefined, false)).toBe(true);
-            expect(isValidRequired('something', false)).toBe(true);
-        });
-    });
-    describe('when establishing if a value passes minLength validation', function () {
-        it('should return true if minLength exists and value matches or exceeds it', function () {
-            expect(isValidMinLength('a', 1)).toBe(true);
-            expect(isValidMinLength('ab', 1)).toBe(true);
-        });
-        it('should return false if minLength exists and value undefined', function () {
-            expect(isValidMinLength(undefined, 1)).toBe(false);
-        });
-        it('should return false if minLength exists and value too short', function () {
-            expect(isValidMinLength('', 1)).toBe(false);
-        });
-        it('should return true if minLength not defined', function () {
-            expect(isValidMinLength('a', undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if a value passes maxLength validation', function () {
-        it('should return true if maxLength exists and value matches or shorter than it', function () {
-            expect(isValidMaxLength('', 2)).toBe(true);
-            expect(isValidMaxLength('a', 2)).toBe(true);
-            expect(isValidMaxLength('ab', 2)).toBe(true);
-        });
-        it('should return false if maxLength exists and value undefined', function () {
-            expect(isValidMaxLength(undefined, 2)).toBe(false);
-        });
-        it('should return false if maxLength exists and value too long', function () {
-            expect(isValidMaxLength('abc', 2)).toBe(false);
-        });
-        it('should return true if maxLength not defined', function () {
-            expect(isValidMaxLength('a', undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if a value passes pattern validation', function () {
-        it('should return true if pattern exists and value matches it', function () {
-            expect(isValidPattern('a', '[a-z]+')).toBe(true);
-        });
-        it('should return false if pattern exists and value undefined', function () {
-            expect(isValidPattern(undefined, '[a-z]+')).toBe(false);
-        });
-        it('should return false if pattern exists and value invalid', function () {
-            expect(isValidPattern('012', '[a-z]+')).toBe(false);
-        });
-        it('should return true if pattern not defined', function () {
-            expect(isValidPattern('a', undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if a value passes minimum validation', function () {
-        it('should return true if min exists and value matches or exceeds it', function () {
-            expect(isValidMinimum(1, 1)).toBe(true);
-            expect(isValidMinimum(0, 0)).toBe(true);
-            // FIXME - these are not valid
-            // expect(isValidMinimum('2', '1')).toBe(true);
-            // expect(isValidMinimum('1', '1')).toBe(true);
-            // expect(isValidMinimum('0', '0')).toBe(true);
-        });
-        it('should return false if min exists and value undefined', function () {
-            expect(isValidMinimum(undefined, 1)).toBe(false);
-        });
-        it('should return false if min exists and value too low', function () {
-            expect(isValidMinimum(1, 2)).toBe(false);
-            expect(isValidMinimum(-1, 0)).toBe(false);
-        });
-        it('should return true if min not defined', function () {
-            expect(isValidMinimum(1, undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if a value passes maximum validation', function () {
-        it('should return true if max exists and value matches or is lower than it', function () {
-            expect(isValidMaximum(2, 2)).toBe(true);
-            expect(isValidMaximum(-1, 0)).toBe(true);
-            // FIXME - these are not valid
-            // expect(isValidMaximum('2', '2')).toBe(true);
-            // expect(isValidMaximum('0', '2')).toBe(true);
-        });
-        it('should return false if max exists and value undefined', function () {
-            expect(isValidMaximum(undefined, 2)).toBe(false);
-        });
-        it('should return false if max exists and value too high', function () {
-            expect(isValidMaximum(3, 2)).toBe(false);
-        });
-        it('should return true if max not defined', function () {
-            expect(isValidMaximum(2, undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if an array passes minItems validation', function () {
-        it('should return true if minItems exists and value length matches or exceeds it', function () {
-            expect(isValidMinItems([1], 1)).toBe(true);
-            expect(isValidMinItems([], 0)).toBe(true);
-        });
-        it('should return false if minItems exists and value undefined', function () {
-            expect(isValidMinItems(undefined, 1)).toBe(false);
-        });
-        it('should return false if minItems exists and value too short', function () {
-            expect(isValidMinItems([1], 2)).toBe(false);
-            expect(isValidMinItems([], 1)).toBe(false);
-        });
-        it('should return true if minItems not defined', function () {
-            expect(isValidMinItems([], undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if an array passes maxItems validation', function () {
-        it('should return true if maxItems exists and value length matches or is less than it', function () {
-            expect(isValidMaxItems([1], 1)).toBe(true);
-            expect(isValidMaxItems([], 0)).toBe(true);
-        });
-        it('should return false if maxItems exists and value undefined', function () {
-            expect(isValidMaxItems(undefined, 1)).toBe(false);
-        });
-        it('should return false if maxItems exists and value too long', function () {
-            expect(isValidMaxItems([1, 2], 1)).toBe(false);
-        });
-        it('should return true if maxItems not defined', function () {
-            expect(isValidMaxItems([], undefined)).toBe(true);
-        });
-    });
-    describe('when establishing validations an array', function () {
-        it('should return true all values for a non-required input', function () {
-            expect(isValidRequiredArray([1], false)).toBe(true);
-            expect(isValidRequiredArray([], false)).toBe(true);
-            expect(isValidRequiredArray(undefined, false)).toBe(true);
-            expect(isValidRequiredArray(null, false)).toBe(true);
-        });
-        it('should return true for only array values for a required input', function () {
-            expect(isValidRequiredArray([1], true)).toBe(true);
-            expect(isValidRequiredArray([], true)).toBe(true);
-        });
-        it('should return false for values for a required input', function () {
-            expect(isValidRequiredArray(null, true)).toBe(false);
-            expect(isValidRequiredArray(undefined, true)).toBe(false);
-        });
-    });
-});

package/build/legacy/common/validators/values/value-validators.js

@@ -1,6 +0,0 @@
-import { isString, isObject, isArray } from '../types/type-validators';
-var isEmpty = function (value) {
-    return (isString(value) && value.length === 0) ||
-        ((isObject(value) || isArray(value)) && Object.keys(value).length === 0);
-};
-export { isEmpty };

package/build/legacy/common/validators/values/value-validators.spec.js

@@ -1,22 +0,0 @@
-import { isEmpty } from './value-validators';
-describe('value-validators', function () {
-    describe('isEmpty', function () {
-        it('should return true for empty strings', function () {
-            expect(isEmpty('')).toBe(true);
-            expect(isEmpty('a')).toBe(false);
-        });
-        it('should return true for empty array', function () {
-            expect(isEmpty([])).toBe(true);
-            expect(isEmpty(['a'])).toBe(false);
-        });
-        it('should return true for empty object', function () {
-            expect(isEmpty({})).toBe(true);
-            expect(isEmpty({ a: 'a' })).toBe(false);
-        });
-        it('should return false when the value is not a string, array, or object', function () {
-            expect(isEmpty(1)).toBe(false);
-            expect(isEmpty(null)).toBe(false);
-            expect(isEmpty(undefined)).toBe(false);
-        });
-    });
-});

package/build/legacy/dynamic-flow-types.js

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

package/build/legacy/dynamicFlow/BackButton.js

@@ -1,22 +0,0 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Avatar } from '@transferwise/components';
-import { ArrowLeft } from '@transferwise/icons';
-function BackButton(_a) {
-    var title = _a.title, action = _a.action, onAction = _a.onAction;
-    return (_jsxs("a", { href: "/", className: "df-back-btn", "aria-label": title, onClick: function (event) {
-            event.preventDefault();
-            onAction(__assign(__assign({}, action), { skipValidation: true }));
-        }, children: [_jsx("span", { className: "sr-only", children: title }), _jsx(Avatar, { type: "icon", children: _jsx(ArrowLeft, { size: "24" }) })] }));
-}
-export default BackButton;