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

package/build/legacy/layout/button/DynamicButton.spec.js

@@ -0,0 +1,152 @@
+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";
+import { fireEvent, screen } from '@testing-library/react';
+import { renderWithProviders } from '../../test-utils';
+import DynamicButton from './DynamicButton';
+import { DynamicFlowProvider } from '../../common/contexts';
+describe('DynamicButton', function () {
+    describe('title', function () {
+        it('prefers component title over action.title', function () {
+            renderWithProviders(_jsx(DynamicButton, { component: {
+                    type: 'button',
+                    title: 'Button Title',
+                    action: {
+                        title: 'Action Title',
+                        url: '/example'
+                    }
+                }, onAction: jest.fn() }));
+            expect(screen.getByText('Button Title')).toBeInTheDocument();
+        });
+        it('uses the action.title in the abscence of component.title', function () {
+            renderWithProviders(_jsx(DynamicButton, { component: {
+                    type: 'button',
+                    action: {
+                        title: 'Action Title',
+                        url: '/example'
+                    }
+                }, onAction: jest.fn() }));
+            expect(screen.getByText('Action Title')).toBeInTheDocument();
+        });
+    });
+    describe('disabled', function () {
+        it('disables the button if the action is disabled', function () {
+            renderWithProviders(_jsx(DynamicButton, { component: {
+                    type: 'button',
+                    action: {
+                        title: 'Action Title',
+                        url: '/example',
+                        disabled: true
+                    }
+                }, onAction: jest.fn() }));
+            expect(screen.getByText('Action Title')).toBeDisabled();
+        });
+        it('disables the button if the component is disabled', function () {
+            renderWithProviders(_jsx(DynamicButton, { component: {
+                    type: 'button',
+                    title: 'Button Title',
+                    disabled: true,
+                    action: { url: '/example' }
+                }, onAction: jest.fn() }));
+            expect(screen.getByText('Button Title')).toBeDisabled();
+        });
+    });
+    describe('margin', function () {
+        it('uses the component margin to specify the bottom margin', function () {
+            renderWithProviders(_jsx(DynamicButton, { component: {
+                    type: 'button',
+                    title: 'Button Title',
+                    margin: 'md',
+                    disabled: true,
+                    action: { url: '/example' }
+                }, onAction: jest.fn() }));
+            expect(screen.getByText('Button Title')).toHaveClass('m-b-2');
+        });
+    });
+    describe('when the button is clicked', function () {
+        it('triggers the onAction callback passing the action object as argument', function () {
+            var component = {
+                type: 'button',
+                title: 'Button Title',
+                action: { url: '/example' }
+            };
+            var onAction = jest.fn();
+            renderWithProviders(_jsx(DynamicButton, { component: component, onAction: onAction }));
+            fireEvent.click(screen.getByRole('button'));
+            expect(onAction).toHaveBeenCalledWith(component.action);
+        });
+    });
+    describe('when loading context is set', function () {
+        it('should be disabled', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var component;
+            return __generator(this, function (_a) {
+                component = {
+                    type: 'button',
+                    title: 'Button Title',
+                    action: { url: '/example' }
+                };
+                renderWithProviders(_jsx(DynamicFlowProvider, __assign({ loading: true }, { children: _jsx(DynamicButton, { component: component, onAction: jest.fn() }) })));
+                expect(screen.getByRole('button')).toBeDisabled();
+                return [2 /*return*/];
+            });
+        }); });
+        it('should be disabled (even if `disabled: false`)', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var component;
+            return __generator(this, function (_a) {
+                component = {
+                    type: 'button',
+                    title: 'Button Title',
+                    action: { url: '/example' }
+                };
+                renderWithProviders(_jsx(DynamicFlowProvider, __assign({ loading: true }, { children: _jsx(DynamicButton, { component: component, onAction: jest.fn() }) })));
+                expect(screen.getByRole('button')).toBeDisabled();
+                return [2 /*return*/];
+            });
+        }); });
+    });
+});

package/build/legacy/layout/button/utils.spec.js

@@ -0,0 +1,50 @@
+import { getButtonPriority, getButtonType } from './utils';
+describe('getButtonPriority', function () {
+    it('prefers control over action.type property', function () {
+        var button = {
+            type: 'button',
+            action: { type: 'primary' },
+            control: 'secondary'
+        };
+        expect(getButtonPriority(button)).toBe('secondary');
+    });
+    it('maps action types to priorities', function () {
+        var button = {
+            type: 'button',
+            action: { type: 'link' }
+        };
+        expect(getButtonPriority(button)).toBe('tertiary');
+    });
+    it('defaults to secondary if neither action.type nor control are provided', function () {
+        var button = {
+            type: 'button',
+            action: { title: '' }
+        };
+        expect(getButtonPriority(button)).toBe('secondary');
+    });
+});
+describe('getButtonType', function () {
+    it('prefers context over action.type property', function () {
+        var button = {
+            type: 'button',
+            action: { title: '', type: 'negative' },
+            context: 'positive'
+        };
+        expect(getButtonType(button)).toBe('positive');
+    });
+    it('maps action types to button types', function () {
+        var button = {
+            type: 'button',
+            action: { title: '' },
+            context: 'neutral'
+        };
+        expect(getButtonType(button)).toBe('accent');
+    });
+    it('defaults to accent if neither action.type nor context are provided', function () {
+        var button = {
+            type: 'button',
+            action: { title: '' }
+        };
+        expect(getButtonType(button)).toBe('accent');
+    });
+});

package/build/legacy/layout/icon/DynamicIcon.spec.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import DynamicIcon from './DynamicIcon';
+describe('DynamicIcon', function () {
+    it('renders a NamedIcon', function () {
+        var iconName = 'lightning-bolt';
+        render(_jsx(DynamicIcon, { type: iconName }));
+        expect(screen.getByTestId('lightning-bolt-icon')).toBeInTheDocument();
+    });
+    it('renders a FlagIcon', function () {
+        var iconName = 'flag-ars';
+        render(_jsx(DynamicIcon, { type: iconName }));
+        expect(screen.getByTestId('img-flag-ars')).toBeInTheDocument();
+    });
+    it('renders null when icon name is invalid', function () {
+        var iconName = 'some-invalid-string';
+        var container = render(_jsx(DynamicIcon, { type: iconName })).container;
+        expect(container).toBeEmptyDOMElement();
+    });
+});

package/build/legacy/layout/list/DynamicStatusList.spec.js

@@ -0,0 +1,111 @@
+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 { render, screen } from '@testing-library/react';
+import { Provider, translations as componentTranslations } from '@transferwise/components';
+import DynamicFlow from '../../dynamicFlow/DynamicFlow';
+import { getMockHttpClient } from '../../../test-utils';
+var mockHttpClient = getMockHttpClient({});
+var onError = jest.fn();
+var onCompletion = jest.fn();
+var i18n = { locale: 'en-GB', messages: __assign({}, componentTranslations.en) };
+var renderComponent = function (step) {
+    render(_jsx(Provider, __assign({ i18n: i18n }, { children: _jsx(DynamicFlow, { flowId: "test", initialStep: step, httpClient: mockHttpClient, onCompletion: onCompletion, onError: onError }) })));
+};
+var makeStatusListStep = function (items) {
+    return ({
+        layout: [{ type: 'status-list', title: 'This is a status List', items: items }]
+    });
+};
+var makeListStep = function (items) {
+    return ({
+        layout: [{ type: 'list', title: 'This is a List', items: items }]
+    });
+};
+describe('DynamicStatusList', function () {
+    describe('status-list', function () {
+        var items = [
+            {
+                title: 'Item 1',
+                description: 'The first item is positive',
+                icon: { name: 'bank' },
+                status: 'done'
+            },
+            {
+                title: 'Item 2',
+                description: 'The second item is neutral',
+                icon: { name: 'emoji' },
+                status: 'not-done'
+            },
+            {
+                title: 'Item 3',
+                description: 'The third item is warning',
+                icon: { name: 'gift-box' },
+                status: 'pending'
+            },
+        ];
+        it('renders the list title', function () {
+            renderComponent(makeStatusListStep([]));
+            expect(screen.getByText('This is a status List')).toBeInTheDocument();
+        });
+        it('renders the item titles', function () {
+            renderComponent(makeStatusListStep(items));
+            expect(screen.getByText('Item 1')).toBeInTheDocument();
+            expect(screen.getByText('Item 2')).toBeInTheDocument();
+            expect(screen.getByText('Item 3')).toBeInTheDocument();
+        });
+        it('renders the item descriptions', function () {
+            renderComponent(makeStatusListStep(items));
+            expect(screen.getByText('The first item is positive')).toBeInTheDocument();
+            expect(screen.getByText('The second item is neutral')).toBeInTheDocument();
+            expect(screen.getByText('The third item is warning')).toBeInTheDocument();
+        });
+    });
+    describe('list', function () {
+        var items = [
+            {
+                title: 'Item 1',
+                description: 'The first item is positive',
+                icon: { name: 'bank' },
+                status: 'positive'
+            },
+            {
+                title: 'Item 2',
+                description: 'The second item is neutral',
+                icon: { name: 'emoji' },
+                status: 'neutral'
+            },
+            {
+                title: 'Item 3',
+                description: 'The third item is warning',
+                icon: { name: 'gift-box' },
+                status: 'warning'
+            },
+        ];
+        it('renders the list title', function () {
+            renderComponent(makeListStep([]));
+            expect(screen.getByText('This is a List')).toBeInTheDocument();
+        });
+        it('renders the item titles', function () {
+            renderComponent(makeListStep(items));
+            expect(screen.getByText('Item 1')).toBeInTheDocument();
+            expect(screen.getByText('Item 2')).toBeInTheDocument();
+            expect(screen.getByText('Item 3')).toBeInTheDocument();
+        });
+        it('renders the item descriptions', function () {
+            renderComponent(makeListStep(items));
+            expect(screen.getByText('The first item is positive')).toBeInTheDocument();
+            expect(screen.getByText('The second item is neutral')).toBeInTheDocument();
+            expect(screen.getByText('The third item is warning')).toBeInTheDocument();
+        });
+    });
+});

package/build/legacy/layout/loadingIndicator/DynamicLoadingIndicator.spec.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import DynamicLoadingIndicator from './DynamicLoadingIndicator';
+describe('Given a component for dynamically rendering a loading indicator', function () {
+    describe('when initialised without any properties', function () {
+        it('renders a loading indicator of the default "md" size', function () {
+            render(_jsx(DynamicLoadingIndicator, { component: { type: 'loading-indicator' } }));
+            var loader = screen.getByTestId('loading-indicator');
+            expect(loader).toHaveClass('tw-loader--md');
+        });
+    });
+    describe.each([
+        ['xs', 'tw-loader--sm'],
+        ['sm', 'tw-loader--sm'],
+        ['md', 'tw-loader--md'],
+        ['lg', 'tw-loader--md'],
+        ['xl', 'tw-loader--md'],
+    ])("when initialised with size: %p", function (size, expectedClass) {
+        it("renders a loading indicator with class: ".concat(expectedClass), function () {
+            render(_jsx(DynamicLoadingIndicator, { component: { type: 'loading-indicator', size: size } }));
+            var loader = screen.getByTestId('loading-indicator');
+            expect(loader).toHaveClass(expectedClass);
+        });
+    });
+});

package/build/legacy/layout/markdown/DynamicMarkdown.spec.js

@@ -0,0 +1,58 @@
+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 { render, screen } from '@testing-library/react';
+import { DynamicInfo, DynamicMarkdown } from './DynamicMarkdown';
+describe('Given a component for dynamically rendering information with markdown', function () {
+    var props = function () { return ({
+        component: {
+            type: 'info',
+            markdown: '### Title ###\n[first link](./first-link)'
+        }
+    }); };
+    it('should render the markdown as HTML', function () {
+        render(_jsx(DynamicInfo, __assign({}, props())));
+        var title = screen.getByText('Title');
+        expect(title).toBeInTheDocument();
+        expect(title.nodeName).toBe('H3');
+    });
+    it('should render links with target=_blank', function () {
+        render(_jsx(DynamicInfo, __assign({}, props())));
+        var link = screen.getByText('first link');
+        expect(link).toBeInTheDocument();
+        expect(link.nodeName).toBe('A');
+        expect(link).toHaveAttribute('href', './first-link');
+        expect(link).toHaveAttribute('target', '_blank');
+    });
+});
+describe('Given a "markdown" component', function () {
+    var props = function () { return ({
+        component: {
+            type: 'markdown',
+            content: '### Title ###\n[first link](./first-link)'
+        }
+    }); };
+    it('should render the markdown as HTML', function () {
+        render(_jsx(DynamicMarkdown, __assign({}, props())));
+        var title = screen.getByText('Title');
+        expect(title).toBeInTheDocument();
+        expect(title.nodeName).toBe('H3');
+    });
+    it('should render links with target=_blank', function () {
+        render(_jsx(DynamicMarkdown, __assign({}, props())));
+        var link = screen.getByText('first link');
+        expect(link).toBeInTheDocument();
+        expect(link.nodeName).toBe('A');
+        expect(link).toHaveAttribute('href', './first-link');
+        expect(link).toHaveAttribute('target', '_blank');
+    });
+});

package/build/legacy/layout/review/DynamicReview.spec.js

@@ -0,0 +1,152 @@
+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";
+import { screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { renderWithProviders } from '../../test-utils';
+import DynamicReview from './DynamicReview';
+var user = userEvent.setup();
+describe('Given a component for dynamically rendering reviews', function () {
+    var getComponent = function () { return ({
+        type: 'review',
+        title: 'Review Layout Title',
+        fields: [
+            {
+                label: 'First Field Label',
+                value: 'First Field Value'
+            },
+            {
+                label: 'Second Field Label',
+                value: 'Second Field Value',
+                help: {
+                    markdown: '# This is a help title \n This is a help description'
+                }
+            },
+        ],
+        margin: 'md'
+    }); };
+    it('should render the title and fields', function () {
+        renderWithProviders(_jsx(DynamicReview, { component: getComponent(), onAction: jest.fn() }));
+        expect(screen.getByText('Review Layout Title')).toBeInTheDocument();
+        expect(screen.getByText('First Field Label')).toBeInTheDocument();
+        expect(screen.getByText('First Field Value')).toBeInTheDocument();
+        expect(screen.getByText('Second Field Label')).toBeInTheDocument();
+        expect(screen.getByText('Second Field Value')).toBeInTheDocument();
+    });
+    describe('when a callToAction is provided and its title clicked', function () {
+        var component = __assign(__assign({}, getComponent()), { callToAction: {
+                title: 'Call To Action Title',
+                action: { url: '/action-url' }
+            } });
+        it('should call onAction callback with the action object', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var onAction;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        onAction = jest.fn();
+                        renderWithProviders(_jsx(DynamicReview, { component: component, onAction: onAction }));
+                        return [4 /*yield*/, user.click(screen.getByText('Call To Action Title'))];
+                    case 1:
+                        _a.sent();
+                        expect(onAction).toHaveBeenCalledWith(component.callToAction.action);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('when a (deprecated) action is provided and its title clicked', function () {
+        var component = __assign(__assign({}, getComponent()), { action: { title: 'Legacy Action Title', url: '/action-url' } });
+        it('should call onAction callback with the action object', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var onAction;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        onAction = jest.fn();
+                        renderWithProviders(_jsx(DynamicReview, { component: component, onAction: onAction }));
+                        return [4 /*yield*/, user.click(screen.getByText('Legacy Action Title'))];
+                    case 1:
+                        _a.sent();
+                        expect(onAction).toHaveBeenCalledWith(component.action);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('when both callToAction and action are provided', function () {
+        var component = __assign(__assign({}, getComponent()), { callToAction: {
+                title: 'Call To Action Title',
+                action: { url: '/action-url' }
+            }, action: { title: 'Legacy Action Title', url: '/action-url' } });
+        it('prefers callToAction over action', function () {
+            var onAction = jest.fn();
+            renderWithProviders(_jsx(DynamicReview, { component: component, onAction: onAction }));
+            expect(screen.getByText('Call To Action Title')).toBeInTheDocument();
+            expect(screen.queryByText('Legacy Action Title')).not.toBeInTheDocument();
+        });
+    });
+    describe('when a help prop is provided', function () {
+        it('a popover element should be rendered when the Info element is clicked', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        renderWithProviders(_jsx(DynamicReview, { component: getComponent(), onAction: jest.fn() }));
+                        expect(screen.queryByText('This is a help title')).not.toBeInTheDocument();
+                        return [4 /*yield*/, user.click(screen.getByRole('button'))];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, waitFor(function () {
+                                expect(screen.getByText('This is a help title')).toBeInTheDocument();
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});