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

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

@@ -0,0 +1,198 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,145 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,22 @@
+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

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

package/build/legacy/dynamicFlow/BackButton.js

@@ -0,0 +1,22 @@
+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;