@wise/dynamic-flow-client 3.5.0-experimental-b041af5 → 3.5.0-experimental-63c768d

package/build/legacy/dynamicFlow/utils/useDebouncedRefresh/useDebouncedRefresh.js

@@ -0,0 +1,26 @@
+import { useRef } from 'react';
+import { debounce, getSchemaType } from '../../../common/utils';
+var DEBOUNCE_DELAY = 1000; // milliseconds
+export function useDebouncedRefresh(fetchRefresh) {
+    var map = useRef(new Map());
+    var retrieveOrCreate = function (key) {
+        if (map.current.has(key)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return map.current.get(key);
+        }
+        var debouncedFetchRefresh = debounce(function (url, data, etag) { return fetchRefresh(url, data, etag); }, DEBOUNCE_DELAY);
+        map.current.set(key, debouncedFetchRefresh);
+        return debouncedFetchRefresh;
+    };
+    return function (url, data, etag, schema) {
+        var debouncedFetchRefresh = retrieveOrCreate(url);
+        debouncedFetchRefresh(url, data, etag);
+        if (!schema || !shouldDebounceSchema(schema)) {
+            debouncedFetchRefresh.flush();
+        }
+    };
+}
+// TODO: only exporting for testing. we should improve the tests
+export var shouldDebounceSchema = function (schema) {
+    return getSchemaType(schema) === 'basic' && schema.type !== 'boolean' && schema.format !== 'base64url';
+};

package/build/legacy/dynamicFlow/utils/useDynamicFlowState.js

@@ -0,0 +1,137 @@
+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);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { useMemo, useState } from 'react';
+import { isValidSchema, getValidObjectModelParts } from '../../common/validators';
+export var useDynamicFlowState = function (initialStep) {
+    var _a, _b;
+    var _c = useState((_a = initialStep === null || initialStep === void 0 ? void 0 : initialStep.errors) === null || _a === void 0 ? void 0 : _a.validation), formErrors = _c[0], setFormErrors = _c[1];
+    var _d = useState((_b = initialStep === null || initialStep === void 0 ? void 0 : initialStep.errors) === null || _b === void 0 ? void 0 : _b.error), globalError = _d[0], setGlobalError = _d[1];
+    var _e = useState({
+        step: initialStep || undefined,
+        models: (initialStep === null || initialStep === void 0 ? void 0 : initialStep.model)
+            ? buildInitialModels(initialStep.model, getAllSchemas(initialStep))
+            : {},
+        etag: undefined
+    }), stepAndModels = _e[0], setStepAndModels = _e[1];
+    var step = stepAndModels.step, models = stepAndModels.models, etag = stepAndModels.etag;
+    var setStepAndEtag = function (step, etag) {
+        var _a, _b, _c, _d;
+        setStepAndModels({
+            step: step,
+            models: step.model ? buildInitialModels(step.model, getAllSchemas(step)) : {},
+            etag: etag
+        });
+        setFormErrors((_b = (_a = step === null || step === void 0 ? void 0 : step.errors) === null || _a === void 0 ? void 0 : _a.validation) !== null && _b !== void 0 ? _b : null);
+        setGlobalError((_d = (_c = step === null || step === void 0 ? void 0 : step.errors) === null || _c === void 0 ? void 0 : _c.error) !== null && _d !== void 0 ? _d : null);
+    };
+    var setSchemaModel = function (schemaId, objectModel, onModelsUpdated) {
+        setStepAndModels(function (previous) {
+            var _a;
+            var updatedModels = __assign(__assign({}, previous.models), (_a = {}, _a[schemaId] = objectModel, _a));
+            var updatedState = {
+                step: previous.step,
+                models: updatedModels,
+                etag: previous.etag
+            };
+            onModelsUpdated(updatedModels);
+            return updatedState;
+        });
+    };
+    var modelIsValid = useMemo(function () { return areModelsValid(models, getAllValidatableSchemas(step)); }, [models, step]);
+    return {
+        formErrors: formErrors,
+        globalError: globalError,
+        step: step,
+        models: models,
+        etag: etag,
+        modelIsValid: modelIsValid,
+        setFormErrors: setFormErrors,
+        setGlobalError: setGlobalError,
+        setStepAndEtag: setStepAndEtag,
+        setSchemaModel: setSchemaModel
+    };
+};
+var buildInitialModels = function (model, schemas) {
+    if (schemas === void 0) { schemas = []; }
+    return schemas.reduce(function (acc, schema) {
+        var _a;
+        if (!schema.$id) {
+            // TODO: DF-473 - Remove type assertions once we're confident people have had time to fix any errors
+            // eslint-disable-next-line no-console
+            console.warn('Schema without $id property found.');
+        }
+        return __assign(__assign({}, acc), (_a = {}, _a[schema.$id || ''] = getValidObjectModelParts(model, schema) || {}, _a));
+    }, {});
+};
+var getAllSchemas = function (step) { return __spreadArray(__spreadArray([], getAllSchemasInLayout((step === null || step === void 0 ? void 0 : step.layout) || []), true), ((step === null || step === void 0 ? void 0 : step.schemas) || []), true); };
+var getAllSchemasInLayout = function (components) {
+    return components.flatMap(function (component) {
+        switch (component.type) {
+            case 'columns':
+                return __spreadArray([], getAllSchemasInLayout(__spreadArray(__spreadArray([], component.left, true), component.right, true)), true);
+            case 'box':
+                return getAllSchemasInLayout(component.components);
+            case 'form':
+                return isInlineSchema(component.schema) ? [component.schema] : [];
+            default:
+                return [];
+        }
+    });
+};
+var getAllValidatableSchemas = function (step) { return __spreadArray(__spreadArray([], getAllReferencedSchemaIds((step === null || step === void 0 ? void 0 : step.layout) || [])
+    .map(function (id) { return ((step === null || step === void 0 ? void 0 : step.schemas) || []).find(function (schema) { return schema.$id === id; }); })
+    .filter(Boolean), true), getAllSchemasInLayout((step === null || step === void 0 ? void 0 : step.layout) || []), true); };
+var getAllReferencedSchemaIds = function (components) {
+    return components
+        .flatMap(function (component) {
+        switch (component.type) {
+            case 'columns':
+                return __spreadArray([], getAllReferencedSchemaIds(__spreadArray(__spreadArray([], component.left, true), component.right, true)), true);
+            case 'box':
+                return getAllReferencedSchemaIds(component.components);
+            case 'form':
+                return [getSchemaReference(component)];
+            default:
+                return [];
+        }
+    })
+        .filter(Boolean);
+};
+var areModelsValid = function (formModels, schemas) {
+    if (schemas === void 0) { schemas = []; }
+    return !(schemas === null || schemas === void 0 ? void 0 : schemas.some(function (schema) {
+        if (!schema.$id) {
+            // TODO: DF-473
+            // eslint-disable-next-line no-console
+            console.warn('Schema without $id property found.');
+        }
+        return !isValidSchema(formModels[schema.$id || ''] || {}, schema);
+    }));
+};
+var getSchemaReference = function (component) {
+    if (component.schema && !isInlineSchema(component.schema)) {
+        return component.schema.$ref;
+    }
+    return component.schemaId;
+};
+var isInlineSchema = function (schema) {
+    return schema !== undefined && typeof schema === 'object' && !Object.hasOwnProperty.call(schema, '$ref');
+};

package/build/legacy/dynamicFlow/utils/useLoader.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 } from "react/jsx-runtime";
+import { Loader, Size } from '@transferwise/components';
+import { useState } from 'react';
+export function useLoader(loaderConfig, initialState) {
+    var config = __assign({ size: Size.EXTRA_LARGE, initial: true, submission: false }, loaderConfig);
+    var _a = useState(initialState), loadingState = _a[0], setLoadingState = _a[1];
+    var shouldDisplayLoader = (config.initial && loadingState === 'initial') ||
+        (config.submission && loadingState === 'submission');
+    var loader = shouldDisplayLoader ? (_jsx(Loader, { size: config.size, classNames: { 'tw-loader': 'tw-loader m-x-auto' }, "data-testid": "loader" })) : null;
+    return { isLoading: loadingState !== 'idle', setLoadingState: setLoadingState, loader: loader };
+}

package/build/legacy/formControl/Select.spec.js

@@ -0,0 +1,104 @@
+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);
+};
+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 { jsx as _jsx } from "react/jsx-runtime";
+// patching tests that won't work in Enzyme
+import { screen } from '@testing-library/react';
+import { userEvent } from '@testing-library/user-event';
+import { renderWithProviders } from '../test-utils';
+import FormControl from './FormControl';
+describe('FormControl', function () {
+    var user = userEvent.setup();
+    var defaultProps = {
+        id: 'control',
+        placeholder: 'placeholder',
+        name: 'control',
+        disabled: false,
+        readOnly: false,
+        required: true,
+        value: undefined,
+        size: undefined,
+        describedBy: undefined,
+        onChange: jest.fn(),
+        onBlur: jest.fn(),
+        onFocus: jest.fn()
+    };
+    describe('SelectInput', function () {
+        it('should call the search change handler if search is enabled', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var options, onSearchChange, i, props;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = [];
+                        onSearchChange = jest.fn();
+                        for (i = 0; i < 20; i += 1) {
+                            options.push({ value: i, label: 'something' });
+                        }
+                        props = {
+                            type: 'select',
+                            options: options,
+                            search: true,
+                            onSearchChange: onSearchChange
+                        };
+                        renderWithProviders(_jsx(FormControl, __assign({}, __assign(__assign({}, defaultProps), props))));
+                        return [4 /*yield*/, user.click(screen.getByText('placeholder'))];
+                    case 1:
+                        _a.sent();
+                        expect(screen.getByRole('searchbox')).toBeInTheDocument();
+                        return [4 /*yield*/, user.click(screen.getByRole('searchbox'))];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, user.keyboard('test')];
+                    case 3:
+                        _a.sent();
+                        expect(onSearchChange).toHaveBeenCalledWith('test');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

package/build/legacy/formControl/utils/getAutocompleteString.spec.js

@@ -0,0 +1,30 @@
+import { getAutocompleteString } from './getAutocompleteString';
+describe('getAutocompleteString', function () {
+    it('should return "off" if no hints are provided', function () {
+        expect(getAutocompleteString([])).toBe('off');
+    });
+    it('should return a string for valid hints', function () {
+        expect(getAutocompleteString(['name-prefix'])).toBe('honorific-prefix');
+    });
+    it('should return a space delimited, concatenated string for multiple valid hints', function () {
+        expect(getAutocompleteString(['name', 'billing'])).toBe('name billing');
+    });
+    it('should discard invalid hints', function () {
+        // @ts-expect-error testing an invalid hint
+        expect(getAutocompleteString(['name', 'cats'])).toBe('name');
+    });
+    it('should return "off" if no valid hints are provided', function () {
+        // @ts-expect-error testing an invalid hint
+        expect(getAutocompleteString(['cats'])).toBe('off');
+    });
+    it('should return built strings for valid hints', function () {
+        expect(getAutocompleteString(['birthdate'], { suffix: '-day' })).toBe('bday-day');
+    });
+    it("should return \"off\" when given a valid hint, which when the suffix is added is not a valid hint", function () {
+        expect(getAutocompleteString(['postal-code'], { suffix: '-day' })).toBe('off');
+    });
+    it('should discard invalid hints, even when suffix is present', function () {
+        // @ts-expect-error testing an invalid hint
+        expect(getAutocompleteString(['country', 'cats'], { suffix: '-name' })).toBe('country-name');
+    });
+});

package/build/legacy/formControl/utils/value-utils.spec.js

@@ -0,0 +1,158 @@
+import { getSafeBooleanValue, getSafeDateOrStringValue, getSafeDateStringValue, getSafeStringOrNumberValue, getSafeStringValue, } from './value-utils';
+describe('getSafeStringValue', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('returns undefined when value is null', function () {
+        expect(getSafeStringValue(null)).toBeUndefined();
+    });
+    it('returns undefined and logs a warning if value is an object', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeStringValue({ value: 1, label: 'One' })).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(1);
+    });
+    it('returns undefined and logs a warning if value is not a string', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeStringValue(1)).toBeUndefined();
+        expect(getSafeStringValue(false)).toBeUndefined();
+        expect(getSafeStringValue(new Date())).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(3);
+    });
+    it('returns value when value is a string', function () {
+        expect(getSafeStringValue('')).toBe('');
+        expect(getSafeStringValue('cat')).toBe('cat');
+    });
+    describe('when coerceValue is true', function () {
+        it('returns coerced value and logs a warning if value is not a string', function () {
+            var mockWarn = jest.fn();
+            jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+            expect(getSafeStringValue(1, { coerceValue: true })).toBe('1');
+            expect(getSafeStringValue(false, { coerceValue: true })).toBe('false');
+            expect(mockWarn).toHaveBeenCalledTimes(2);
+        });
+    });
+});
+describe('getSafeStringOrNumberValue', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('returns undefined when value is null', function () {
+        expect(getSafeStringOrNumberValue(null)).toBeUndefined();
+    });
+    it('returns undefined when value is NaN', function () {
+        expect(getSafeStringOrNumberValue(NaN)).toBeUndefined();
+    });
+    it('returns value if value is a valid number', function () {
+        expect(getSafeStringOrNumberValue(10)).toBe(10);
+        expect(getSafeStringOrNumberValue(10.5)).toBe(10.5);
+    });
+    it('returns undefined and logs a warning if value is an object', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeStringOrNumberValue({ value: 1, label: 'One' })).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(1);
+    });
+    it('returns undefined and logs a warning if value is not a string', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeStringOrNumberValue(false)).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(1);
+    });
+    it('returns value when value is a string', function () {
+        expect(getSafeStringOrNumberValue('')).toBe('');
+        expect(getSafeStringOrNumberValue('cat')).toBe('cat');
+    });
+    describe('when coerceValue is true', function () {
+        it('returns coerced value and logs a warning if value is not a string', function () {
+            var mockWarn = jest.fn();
+            jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+            expect(getSafeStringOrNumberValue(false, { coerceValue: true })).toBe('false');
+            expect(mockWarn).toHaveBeenCalledTimes(1);
+        });
+    });
+});
+describe('getSafeBooleanValue', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('returns false when value is null', function () {
+        expect(getSafeBooleanValue(null)).toBe(false);
+    });
+    it('returns undefined and logs a warning if value is not a boolean', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeBooleanValue(1)).toBeUndefined();
+        expect(getSafeBooleanValue(NaN)).toBeUndefined();
+        expect(getSafeBooleanValue(new Date())).toBeUndefined();
+        expect(getSafeBooleanValue('cat')).toBeUndefined();
+        expect(getSafeBooleanValue({ value: 1, label: 'One' })).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(5);
+    });
+    it('returns value when value is a boolean', function () {
+        expect(getSafeBooleanValue(true)).toBe(true);
+        expect(getSafeBooleanValue(false)).toBe(false);
+    });
+    describe('when coerceValue is true', function () {
+        it('returns coerced value and logs a warning if value is not a boolean', function () {
+            var mockWarn = jest.fn();
+            jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+            expect(getSafeBooleanValue(1, { coerceValue: true })).toBe(true);
+            expect(getSafeBooleanValue(NaN, { coerceValue: true })).toBe(false);
+            expect(getSafeBooleanValue('cat', { coerceValue: true })).toBe(true);
+            expect(getSafeBooleanValue(new Date(), { coerceValue: true })).toBe(true);
+            expect(getSafeBooleanValue({ value: 1, label: 'One' }, { coerceValue: true })).toBe(true);
+            expect(mockWarn).toHaveBeenCalledTimes(5);
+        });
+    });
+});
+describe('getSafeDateOrStringValue', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('returns undefined when value is null', function () {
+        expect(getSafeDateOrStringValue(null)).toBeUndefined();
+    });
+    it('returns value if value is a string', function () {
+        expect(getSafeDateOrStringValue('2019-04-06')).toBe('2019-04-06');
+    });
+    it('returns value if value is a Date', function () {
+        var date = new Date();
+        expect(getSafeDateOrStringValue(date)).toBe(date);
+    });
+    it('returns undefined and logs a warning if value is not a date or a string', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeDateOrStringValue(1)).toBeUndefined();
+        expect(getSafeDateOrStringValue(false)).toBeUndefined();
+        expect(getSafeDateOrStringValue({ value: 1, label: 'One' })).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(3);
+    });
+});
+describe('getSafeDateStringValue', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('returns null when value is null', function () {
+        expect(getSafeDateStringValue(null)).toBeNull();
+    });
+    it('returns null and logs a warning if value is not a string', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeDateStringValue(1)).toBeNull();
+        expect(getSafeDateStringValue(false)).toBeNull();
+        expect(getSafeDateStringValue(new Date())).toBeNull();
+        expect(getSafeDateStringValue({ value: 1, label: 'One' })).toBeNull();
+        expect(mockWarn).toHaveBeenCalledTimes(4);
+    });
+    it('returns value as a date if value is a correctly formatted date string', function () {
+        var _a;
+        expect((_a = getSafeDateStringValue('2019-04-06')) === null || _a === void 0 ? void 0 : _a.toDateString()).toStrictEqual(new Date(2019, 3, 6).toDateString());
+    });
+    it('returns null if value is an incorrectly formatted date string', function () {
+        expect(getSafeDateStringValue('')).toBeNull();
+        expect(getSafeDateStringValue('cat')).toBeNull();
+        expect(getSafeDateStringValue('2022')).toBeNull();
+    });
+});