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

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

@@ -0,0 +1,445 @@
+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 { Checkbox, DateInput, DateLookup, RadioGroup, SelectInput, Tabs, } from '@transferwise/components';
+import { shallow, mount } from 'enzyme';
+import FormControl from '.';
+jest.mock('react-intl', function () { return ({
+    injectIntl: function (Component) { return function (props) { return _jsx(Component, __assign({}, props, { intl: { locale: 'en' } })); }; },
+    useIntl: function () { return ({ locale: 'en', formatMessage: function (id) { return String(id); } }); },
+    defineMessages: function (translations) { return translations; },
+}); });
+describe('FormControl', function () {
+    var props;
+    var component;
+    var defaultProps;
+    var currentValue;
+    beforeEach(function () {
+        defaultProps = {
+            id: 'control',
+            placeholder: 'placeholder',
+            name: 'control',
+            disabled: false,
+            readOnly: false,
+            required: true,
+            value: undefined,
+            size: 'md',
+            onChange: jest.fn(),
+            onBlur: jest.fn(),
+            onFocus: jest.fn(),
+        };
+    });
+    testSimpleControl('text', 'input[type="text"]', 'example', 'Example text');
+    testSimpleControl('email', 'input[type="email"]', 'email@email.com', 'Enter your email');
+    testSimpleControl('password', 'input[type="password"]', 'qwerty', 'Enter your password');
+    testSimpleControl('number', 'input[type="number"]', 123456, 'Enter your numeric value here');
+    testSimpleControl('numeric', 'input[type="number"]', '123456', 'Enter your numeric value here');
+    testSimpleControl('textarea', 'textarea', 'Lorem ipsum', 'Please enter your feedback');
+    // The DateInput component was converted to TS and its propTypes removed.
+    // testCustomControl depends on the given component's propTypes to work.
+    // testCustomControl('date', DateInput);
+    // expect more of these components to be migrated to TS in the near future,
+    // rendering these tests obsolete.
+    testCustomControl('checkbox', Checkbox);
+    // testCustomControl('date-lookup', DateLookup);
+    describe('type: select', function () {
+        beforeEach(function () {
+            props = {
+                type: 'select',
+                options: [
+                    {
+                        value: '1',
+                        label: 'one',
+                    },
+                    {
+                        value: '2',
+                        label: 'two',
+                    },
+                ],
+                onChange: jest.fn().mockImplementation(function (event) {
+                    currentValue = event;
+                }),
+            };
+            component = mount(_jsx(FormControl, __assign({}, defaultProps, props)));
+        });
+        afterEach(function () {
+            component.unmount();
+        });
+        testChangeHandler(function () {
+            component.find('button.np-form-control').simulate('click');
+            component.find('div.np-select-input-option-container').last().simulate('click');
+        }, '2');
+        it('should enable search when number of options exceeds predefined amount', function () {
+            var options = [];
+            for (var i = 0; i < 20; i += 1) {
+                options.push({ value: i, label: 'something' });
+            }
+            props = {
+                type: 'select',
+                options: options,
+            };
+            component = mount(_jsx(FormControl, __assign({}, defaultProps, props)));
+            expect(component.find(SelectInput).prop('filterable')).toBe(true);
+        });
+        it('should disable search when number of options is less than predefined amount', function () {
+            var options = [];
+            for (var i = 1; i < 8; i += 1) {
+                options.push({ value: i, label: 'something' });
+            }
+            props = {
+                type: 'select',
+                options: options,
+            };
+            component = mount(_jsx(FormControl, __assign({}, defaultProps, props)));
+            expect(component.find(SelectInput).prop('filterable')).toBe(false);
+        });
+    });
+    describe('type: select: selecting nothing', function () {
+        it('should call onChange with null when no option (the placeholder) is selected', function () {
+            var onChange = jest.fn();
+            props = {
+                type: 'select',
+                placeholder: 'hola',
+                options: new Array(3).fill(null).map(function (_, i) { return ({ value: i, label: "Something ".concat(i) }); }),
+                onChange: onChange,
+            };
+            var component = mount(_jsx(FormControl, __assign({}, defaultProps, props)));
+            component.find(SelectInput).props().onChange(null);
+            expect(onChange).toHaveBeenCalledWith(null);
+            component.unmount();
+        });
+    });
+    describe('type: checkbox', function () {
+        var checkbox;
+        beforeEach(function () {
+            props = {
+                type: 'checkbox',
+                placeholder: 'Accept Terms and Conditions',
+                onChange: jest.fn().mockImplementation(function () {
+                    currentValue = true;
+                }),
+            };
+            component = shallow(_jsx(FormControl, __assign({}, defaultProps, props)));
+            checkbox = component.find(Checkbox);
+        });
+        it('should render a checkbox input', function () {
+            expect(checkbox.exists()).toBeTruthy();
+        });
+        testFocusHandler(function () {
+            checkbox.simulate('focus');
+        });
+        testChangeHandler(function () {
+            checkbox.simulate('change');
+        }, true);
+        testBlurHandler(function () {
+            checkbox.simulate('blur');
+        });
+        // testRequiredValidation(() => {
+        //   checkbox.simulate('click');
+        // }, true);
+    });
+    describe('type: radio', function () {
+        var radioGroup;
+        beforeEach(function () {
+            props = {
+                type: 'radio',
+                options: [
+                    { value: 1, label: 'One' },
+                    { value: 2, label: 'Two', secondary: 'Secondary label' },
+                ],
+                onChange: jest.fn().mockImplementation(function (newValue) {
+                    currentValue = newValue;
+                }),
+            };
+            component = shallow(_jsx(FormControl, __assign({}, defaultProps, props)));
+            radioGroup = component.find(RadioGroup);
+        });
+        afterEach(function () {
+            component.unmount();
+        });
+        it('should render a radio group', function () {
+            expect(radioGroup.exists()).toBeTruthy();
+        });
+        testChangeHandler(function () {
+            radioGroup.simulate('change', 1);
+        }, 1);
+    });
+    describe('type: tabs', function () {
+        var tabs;
+        beforeEach(function () {
+            props = {
+                type: 'tab',
+                options: [
+                    { value: 0, label: 'Zero' },
+                    { value: 1, label: 'One' },
+                ],
+                onChange: jest.fn().mockImplementation(function (newValue) {
+                    currentValue = newValue;
+                }),
+            };
+            component = shallow(_jsx(FormControl, __assign({}, defaultProps, props)));
+            tabs = component.find(Tabs);
+        });
+        afterEach(function () {
+            component.unmount();
+        });
+        it('should render tab', function () {
+            expect(tabs.exists()).toBeTruthy();
+        });
+        testChangeHandler(function () {
+            tabs.simulate('tabSelect', 1);
+        }, 1);
+    });
+    describe('type: date', function () {
+        var dateInput;
+        beforeEach(function () {
+            props = {
+                type: 'date',
+                onChange: jest.fn().mockImplementation(function () {
+                    currentValue = '2016-01-01';
+                }),
+            };
+            component = shallow(_jsx(FormControl, __assign({}, defaultProps, props)));
+            dateInput = component.find(DateInput);
+        });
+        testFocusHandler(function () {
+            dateInput.simulate('focus');
+        });
+        testChangeHandler(function () {
+            dateInput.simulate('change');
+        }, '2016-01-01');
+        testBlurHandler(function () {
+            dateInput.simulate('blur');
+        });
+    });
+    describe('type: hidden', function () {
+        var input;
+        beforeEach(function () {
+            props = { type: 'hidden', model: null };
+            component = shallow(_jsx(FormControl, __assign({}, defaultProps, props)));
+            input = component.find('input');
+        });
+        it('should render a hidden input', function () {
+            expect(input.exists()).toBeTruthy();
+            expect(input.prop('type')).toBe('hidden');
+        });
+    });
+    describe('type: date-lookup', function () {
+        it("converts the string value into a Date object, taking into account the client's timezone", function () {
+            component = shallow(_jsx(FormControl, __assign({}, getPropsForControlType('date-lookup'), { value: "2000-01-01" })));
+            expect(component.find(DateLookup).props('value').value).toStrictEqual(new Date(2000, 0, 1));
+        });
+    });
+    describe('autocomplete', function () {
+        it('should set the autocomplete attribute', function () {
+            component = shallow(_jsx(FormControl, __assign({}, defaultProps, { autocompleteHint: ['name', 'shipping'] })));
+            expect(component.find('input').prop('autoComplete')).toBe('name shipping');
+        });
+        it('should prefer autocompleteHint', function () {
+            component = shallow(_jsx(FormControl, __assign({}, defaultProps, { autoComplete: "on", autocompleteHint: ['name', 'shipping'] })));
+            expect(component.find('input').prop('autoComplete')).toBe('name shipping');
+        });
+        it('should set autocomplete', function () {
+            component = shallow(_jsx(FormControl, __assign({}, defaultProps, { autoComplete: true })));
+            expect(component.find('input').prop('autoComplete')).toBe('on');
+        });
+        it('should set autocomplete to off if autoComplete is false', function () {
+            component = shallow(_jsx(FormControl, __assign({}, defaultProps, { autoComplete: false })));
+            expect(component.find('input').prop('autoComplete')).toBe('off');
+        });
+        // This behaviour will change in the next major release
+        it('should set autocomplete to on if not provided', function () {
+            component = shallow(_jsx(FormControl, __assign({}, defaultProps)));
+            expect(component.find('input').prop('autoComplete')).toBe('on');
+        });
+    });
+    function testSimpleControl(controlType, selector, valueToSet, placeholder) {
+        var input;
+        describe("type: ".concat(controlType), function () {
+            beforeEach(function () {
+                props = {
+                    type: controlType,
+                    onChange: jest.fn().mockImplementation(function (newValue) {
+                        currentValue = newValue;
+                    }),
+                    placeholder: placeholder,
+                };
+                component = shallow(_jsx(FormControl, __assign({}, defaultProps, props)));
+                input = component.find(selector);
+            });
+            if (controlType === 'text' || controlType === 'textarea') {
+                describe('when the value is a primitive', function () {
+                    it("should normally pass it as value", function () {
+                        component = shallow(_jsx(FormControl, __assign({}, defaultProps, props, { value: 'A' })));
+                        expect(component.find(selector).prop('value')).toBe('A');
+                    });
+                });
+                describe('when the value is an object', function () {
+                    jest.spyOn(console, 'error').mockImplementation(jest.fn()); // Remove expected console spam
+                    jest.spyOn(console, 'warn').mockImplementation(jest.fn()); // Remove expected console spam
+                    it("should pass undefined as value", function () {
+                        component = shallow(_jsx(FormControl, __assign({}, defaultProps, props, { value: {} })));
+                        expect(component.find(selector).prop('value')).toBeUndefined();
+                    });
+                    jest.clearAllMocks();
+                });
+            }
+            it("should render a ".concat(controlType, " control"), function () {
+                expect(input.exists()).toBeTruthy();
+            });
+            if (placeholder) {
+                it("should render the ".concat(controlType, " control with a placeholder"), function () {
+                    expect(component.prop('placeholder')).toBe(placeholder);
+                    expect(input.prop('placeholder')).toBe(placeholder);
+                });
+            }
+            testFocusHandler(function () {
+                component.simulate('focus');
+            });
+            testChangeHandler(function () {
+                component.simulate('change', { target: { value: valueToSet } });
+            }, valueToSet);
+            testBlurHandler(function () {
+                component.simulate('blur');
+            });
+        });
+    }
+    function getPropsForControlType(controlType) {
+        var customProps = {};
+        switch (controlType) {
+            case 'radio':
+            case 'select': {
+                customProps = {
+                    options: [
+                        { value: 1, label: 'One' },
+                        { value: 2, label: 'Two', secondary: 'Secondary text' },
+                    ],
+                };
+                break;
+            }
+            case 'date': {
+                customProps = { value: new Date() };
+                break;
+            }
+            case 'tel': {
+                customProps = {
+                    value: '+441234567',
+                    searchPlaceholder: 'Search placeholder',
+                    size: 'md',
+                    placeholder: 'Telephone',
+                };
+                break;
+            }
+            case 'checkbox': {
+                customProps = { placeholder: 'label' };
+                break;
+            }
+            case 'upload': {
+                customProps = {
+                    uploadProps: {},
+                };
+                break;
+            }
+            case 'text':
+            case 'textarea': {
+                customProps = {
+                    displayPattern: '**-**',
+                };
+                break;
+            }
+            default:
+                customProps = defaultProps;
+        }
+        customProps = __assign(__assign({}, customProps), { type: controlType });
+        return __assign(__assign({}, defaultProps), customProps);
+    }
+    function getPropsToPassDown(controlType, customComponent) {
+        var PROPS = Object.keys(getPropsForControlType(controlType));
+        if (controlType === 'select') {
+            return Object.keys(getPropsForControlType('select'));
+        }
+        // eslint-disable-next-line react/forbid-foreign-prop-types
+        return Object.keys(customComponent.propTypes).filter(function (key) { return PROPS.includes(key); });
+    }
+    function testCustomControl(controlType, customComponent) {
+        var custom;
+        var EVENT = {
+            onChange: 'change',
+            onBlur: 'blur',
+            onFocus: 'focus',
+        };
+        var PASSED_DOWN_PROPS = getPropsToPassDown(controlType, customComponent);
+        var CALLBACK_PROPS = ['onChange', 'onBlur', 'onFocus'];
+        if (!controlType) {
+            throw new Error('Missing mandatory value in `controlType` argument!');
+        }
+        if (!customComponent) {
+            throw new Error('Missing mandatory value in `customComponent` argument!');
+        }
+        describe("type: ".concat(controlType), function () {
+            beforeEach(function () {
+                props = getPropsForControlType(controlType);
+                component = shallow(_jsx(FormControl, __assign({}, defaultProps, props, { displayPattern: "**-**" })));
+                var child = component.find(customComponent);
+                custom = child.length > 1 ? child.first() : child;
+            });
+            PASSED_DOWN_PROPS.forEach(function (key) {
+                it("should pass the ".concat(key, " prop to the child component"), function () {
+                    expect(custom.prop(key)).toStrictEqual(props[key]);
+                });
+            });
+            if (controlType === 'upload') {
+                it("should call the onStart handler when a a file is dropped", function () {
+                    component = mount(_jsx(FormControl, __assign({}, defaultProps, props)));
+                    expect(component.find(customComponent)).toHaveLength(1);
+                });
+            }
+            else {
+                CALLBACK_PROPS.forEach(function (key) {
+                    if (key === 'onChange' || controlType !== 'select') {
+                        it("should call the ".concat(key, " handler when a ").concat(EVENT[key], " event triggered"), function () {
+                            component.simulate(EVENT[key], {});
+                            expect(props[key]).toHaveBeenCalledTimes(1);
+                        });
+                    }
+                });
+            }
+        });
+    }
+    function testFocusHandler(performFocus) {
+        describe('when focused', function () {
+            beforeEach(performFocus);
+            it('should call the focus handler', function () {
+                expect(defaultProps.onFocus).toHaveBeenCalledTimes(1);
+            });
+        });
+    }
+    function testChangeHandler(performChange, expectedValue) {
+        describe('when changed', function () {
+            beforeEach(performChange);
+            it('should call the change handler', function () {
+                expect(props.onChange).toHaveBeenCalledTimes(1);
+            });
+            it('should set the correct value', function () {
+                expect(currentValue).toStrictEqual(expectedValue);
+            });
+        });
+    }
+    function testBlurHandler(performBlur) {
+        describe('when blurred', function () {
+            beforeEach(performBlur);
+            it('should call the blur handler', function () {
+                expect(defaultProps.onBlur).toHaveBeenCalledTimes(1);
+            });
+        });
+    }
+});

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({}, 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/index.js

@@ -0,0 +1 @@
+export { default } from './FormControl';

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

@@ -0,0 +1,80 @@
+export var getAutocompleteString = function (hints, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.prefix, prefix = _c === void 0 ? '' : _c, _d = _b.suffix, suffix = _d === void 0 ? '' : _d;
+    var autoCompleteString = hints
+        .map(function (hint) {
+        var builtHint = "".concat(prefix).concat(hint).concat(suffix);
+        return isAutocompleteToken(builtHint) ? autocompleteTokenMap[builtHint] : undefined;
+    })
+        .filter(function (str) { return str; })
+        .join(' ');
+    return autoCompleteString || 'off';
+};
+var isAutocompleteToken = function (str) {
+    return Object.keys(autocompleteTokenMap).some(function (hint) { return hint === str; });
+};
+var autocompleteTokenMap = {
+    on: 'on',
+    name: 'name',
+    'name-prefix': 'honorific-prefix',
+    'given-name': 'given-name',
+    'additional-name': 'additional-name',
+    'family-name': 'family-name',
+    'name-suffix': 'honorific-suffix',
+    nickname: 'nickname',
+    email: 'email',
+    // Web doesn't have a specific mapping for new username, but this is semantically close enough
+    'new-username': 'username',
+    username: 'username',
+    'new-password': 'new-password',
+    password: 'current-password',
+    'one-time-code': 'one-time-code',
+    'job-title': 'organization-title',
+    'organization-name': 'organization',
+    'full-street-address': 'street-address',
+    'street-address-line-1': 'address-line1',
+    'street-address-line-2': 'address-line2',
+    'street-address-line-3': 'address-line3',
+    'address-level-1': 'address-level1',
+    'address-level-2': 'address-level2',
+    'address-level-3': 'address-level3',
+    'address-level-4': 'address-level4',
+    'country-code': 'country',
+    'country-name': 'country-name',
+    'postal-code': 'postal-code',
+    'credit-card-name': 'cc-name',
+    'credit-card-given-name': 'cc-given-name',
+    'credit-card-middle-name': 'cc-additional-name',
+    'credit-card-family-name': 'cc-family-name',
+    'credit-card-number': 'cc-number',
+    'credit-card-expiration': 'cc-exp',
+    'credit-card-expiration-month': 'cc-exp-month',
+    'credit-card-expiration-year': 'cc-exp-year',
+    'credit-card-security-code': 'cc-csc',
+    'credit-card-type': 'cc-type',
+    'transaction-currency': 'transaction-currency',
+    'transaction-amount': 'transaction-amount',
+    language: 'language',
+    birthdate: 'bday',
+    'birthdate-day': 'bday-day',
+    'birthdate-month': 'bday-month',
+    'birthdate-year': 'bday-year',
+    gender: 'sex',
+    'phone-number': 'tel',
+    'phone-country-code': 'tel-country-code',
+    'phone-national': 'tel-national',
+    'phone-area-code': 'tel-area-code',
+    'phone-local': 'tel-local',
+    'phone-local-prefix': 'tel-local-prefix',
+    'phone-local-suffix': 'tel-local-suffix',
+    'phone-extension': 'tel-extension',
+    url: 'url',
+    photo: 'photo',
+    impp: 'impp',
+    shipping: 'shipping',
+    billing: 'billing',
+    home: 'home',
+    work: 'work',
+    mobile: 'mobile',
+    fax: 'fax',
+    pager: 'pager',
+};

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/index.js

@@ -0,0 +1,2 @@
+export * from './value-utils';
+export { getAutocompleteString } from './getAutocompleteString';