@sqrzro/admin 1.0.0-beta.1

package/src/hooks/useLayout.spec.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+import useLayout from './useLayout';
+
+describe('useLayout', () => {
+    it('should return the layout', () => {
+        jest.spyOn(React, 'useContext').mockImplementationOnce(() => ({
+            style: { layout: 'lorem' },
+        }));
+
+        const { layout } = useLayout();
+        expect(layout).toBe('lorem');
+    });
+
+    it('should apply classnames', () => {
+        jest.spyOn(React, 'useContext').mockImplementationOnce(() => ({
+            style: { layout: 'lorem' },
+        }));
+
+        const styles = { rootLorem: 'lorem' };
+        const { applyLayoutClassName } = useLayout();
+
+        expect(applyLayoutClassName(styles)).toEqual('lorem');
+    });
+
+    it('should not apply classnames if no style', () => {
+        jest.spyOn(React, 'useContext').mockImplementationOnce(() => ({}));
+
+        const styles = { rootLorem: 'lorem' };
+        const { applyLayoutClassName } = useLayout();
+
+        expect(applyLayoutClassName(styles)).toEqual(null);
+    });
+
+    it('should not apply classnames if no layout', () => {
+        jest.spyOn(React, 'useContext').mockImplementationOnce(() => ({
+            style: {},
+        }));
+
+        const styles = { rootLorem: 'lorem' };
+        const { applyLayoutClassName } = useLayout();
+
+        expect(applyLayoutClassName(styles)).toEqual(null);
+    });
+
+    it('should not apply classnames if no styles', () => {
+        jest.spyOn(React, 'useContext').mockImplementationOnce(() => ({
+            style: { layout: 'lorem' },
+        }));
+
+        const styles = {};
+        const { applyLayoutClassName } = useLayout();
+
+        expect(applyLayoutClassName(styles)).toEqual(null);
+    });
+});

package/src/hooks/useLayout.ts

@@ -0,0 +1,29 @@
+import { ucwords } from '@sqrzro/utility';
+
+import useAppContext from '@hooks/useAppContext';
+
+interface UseLayoutReturn {
+    layout: string | null;
+    applyLayoutClassName: (styles: Record<string, string>, prefix?: string) => string | null;
+}
+
+const useLayout = (): UseLayoutReturn => {
+    const { style } = useAppContext();
+
+    const applyLayoutClassName = (
+        styles: Record<string, string>,
+        prefix = 'root'
+    ): string | null => {
+        const layout = style?.layout;
+
+        if (!layout) {
+            return null;
+        }
+
+        return styles[`${prefix}${ucwords(layout)}`] || null;
+    };
+
+    return { layout: style?.layout || null, applyLayoutClassName };
+};
+
+export default useLayout;

package/src/hooks/useModal.spec.tsx

@@ -0,0 +1,63 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import Button from '@components/Button';
+
+import useModal from './useModal';
+
+interface WrapProps {
+    options?: { onClose?: React.MouseEventHandler<HTMLButtonElement> };
+}
+
+const Wrap: React.FunctionComponent<WrapProps> = ({ options }) => {
+    const { closeModal, Modal, openModal } = useModal(options);
+
+    return (
+        <div>
+            <Button onClick={openModal}>Open Modal</Button>
+            <Button onClick={closeModal}>Close Modal</Button>
+            <Modal>Modal Content</Modal>
+        </div>
+    );
+};
+
+describe('useModal', () => {
+    it('should not render if not open', () => {
+        render(<Wrap />);
+        expect(screen.queryByText('Modal Content')).not.toBeInTheDocument();
+    });
+
+    it('should render if open', () => {
+        render(<Wrap />);
+        userEvent.click(screen.getByRole('button', { name: 'Open Modal' }));
+        expect(screen.getByText('Modal Content')).toBeInTheDocument();
+    });
+
+    it('should handle closing from modal', () => {
+        const mockFn = jest.fn();
+        render(<Wrap options={{ onClose: mockFn }} />);
+
+        userEvent.click(screen.getByRole('button', { name: 'Open Modal' }));
+        userEvent.click(screen.getByRole('button', { name: 'Close' }));
+
+        expect(mockFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle closing from modal (empty options)', () => {
+        const mockFn = jest.fn();
+        render(<Wrap />);
+
+        userEvent.click(screen.getByRole('button', { name: 'Open Modal' }));
+        userEvent.click(screen.getByRole('button', { name: 'Close' }));
+
+        expect(mockFn).toHaveBeenCalledTimes(0);
+    });
+
+    it('should handle closing from outside modal', () => {
+        render(<Wrap />);
+        userEvent.click(screen.getByRole('button', { name: 'Open Modal' }));
+        userEvent.click(screen.getByRole('button', { name: 'Close Modal' }));
+        expect(screen.queryByText('Modal Content')).not.toBeInTheDocument();
+    });
+});

package/src/hooks/useModal.ts

@@ -0,0 +1,60 @@
+import { createElement, useCallback, useLayoutEffect, useState } from 'react';
+
+import Modal from '@core/Modal';
+import type { ModalProps } from '@core/Modal';
+
+interface UseModalOptions {
+    onClose?: React.MouseEventHandler<HTMLButtonElement>;
+}
+
+interface UseModalReturn {
+    closeModal: () => void;
+    Modal: React.FunctionComponent<ModalProps>;
+    openModal: () => void;
+}
+
+const useModal = (options?: UseModalOptions): UseModalReturn => {
+    const [isOpen, setIsOpen] = useState(false);
+    const [offset, setOffset] = useState(0);
+
+    useLayoutEffect(() => {
+        /*
+         * Using document body in jest is complex. This can be ignored by test coverage for now.
+         */
+        /* istanbul ignore next */
+        if (document.body.firstChild) {
+            const wrap = document.body.firstChild as HTMLDivElement;
+            setOffset(window.innerWidth - wrap.offsetWidth);
+        }
+    }, []);
+
+    useLayoutEffect(() => {
+        /*
+         * Using document body in jest is complex. This can be ignored by test coverage for now.
+         */
+        /* istanbul ignore next */
+        if (document.body.firstChild) {
+            document.body.style.overflowY = isOpen ? 'hidden' : 'scroll';
+            const wrap = document.body.firstChild as HTMLDivElement;
+            wrap.style.marginRight = isOpen ? `${offset}px` : '0';
+        }
+    }, [isOpen]);
+
+    const handleClose = (event: React.MouseEvent<HTMLButtonElement>): void => {
+        setIsOpen(false);
+
+        if (options?.onClose) {
+            options.onClose(event);
+        }
+    };
+
+    const modalProps: ModalProps = { children: false, isOpen, onClose: handleClose };
+
+    return {
+        closeModal: (): void => setIsOpen(false),
+        Modal: useCallback((props) => createElement(Modal, { ...modalProps, ...props }), [isOpen]),
+        openModal: (): void => setIsOpen(true),
+    };
+};
+
+export default useModal;

package/src/hooks/useVariant.spec.ts

@@ -0,0 +1,14 @@
+import useVariant from './useVariant';
+
+describe('useVariant', () => {
+    it('should handle nullable variants', () => {
+        type NullableVariant = 'lorem' | null;
+
+        const styles = { rootLorem: 'lorem' };
+        const variant: NullableVariant[] = ['lorem', null];
+        const { applyVariantClassName } = useVariant<NullableVariant>(variant);
+
+        const className = applyVariantClassName(styles);
+        expect(className).toBe('lorem');
+    });
+});

package/src/hooks/useVariant.ts

@@ -0,0 +1,34 @@
+import { isString, isStringArray } from '@utility/interfaces';
+import type { StyleVariant } from '@utility/interfaces';
+
+import { ucwords } from '@sqrzro/utility';
+
+interface UseVariantReturn {
+    applyVariantClassName: (styles: Record<string, string>, prefix?: string) => string | null;
+}
+
+const useVariant = <T = StyleVariant>(variant?: T | T[]): UseVariantReturn => {
+    const applyVariantClassName = (
+        styles: Record<string, string>,
+        prefix = 'root'
+    ): string | null => {
+        if (!variant || (!isString(variant) && !isStringArray(variant))) {
+            return null;
+        }
+
+        if (!Array.isArray(variant)) {
+            return styles[`${prefix}${ucwords(variant)}`];
+        }
+
+        const orderedVariant = variant
+            .map((item) => ucwords(isString(item) ? item : ''))
+            .sort((first, second) => first.localeCompare(second))
+            .join('');
+
+        return styles[`${prefix}${orderedVariant}`];
+    };
+
+    return { applyVariantClassName };
+};
+
+export default useVariant;

package/src/index.ts

@@ -0,0 +1,194 @@
+/*
+ * This file has been generated by 'scripts/create-exports'.
+ * Any changes made directly to this file will be overwritten.
+ */
+
+import 'regenerator-runtime/runtime.js';
+
+export * from './utility/interfaces';
+export { default as createApp } from './utility/create-app';
+
+export { ApiService, AuthService, EventService, StorageService } from '@sqrzro/utility';
+export * from './components/Alert';
+export { default as Alert } from './components/Alert';
+export * from './components/Allow';
+export { default as Allow } from './components/Allow';
+export * from './components/App';
+export { default as App } from './components/App';
+export * from './components/AutoSuggest';
+export { default as AutoSuggest } from './components/AutoSuggest';
+export * from './components/Button';
+export { default as Button } from './components/Button';
+export * from './components/CalendarInput';
+export { default as CalendarInput } from './components/CalendarInput';
+export * from './components/CheckboxList';
+export { default as CheckboxList } from './components/CheckboxList';
+export * from './components/ConnectedDropdown';
+export { default as ConnectedDropdown } from './components/ConnectedDropdown';
+export * from './components/ConnectedList';
+export { default as ConnectedList } from './components/ConnectedList';
+export * from './components/ConnectedScene';
+export { default as ConnectedScene } from './components/ConnectedScene';
+export * from './components/ConnectedTable';
+export { default as ConnectedTable } from './components/ConnectedTable';
+export * from './components/ContentBlock';
+export { default as ContentBlock } from './components/ContentBlock';
+export * from './components/DateInput';
+export { default as DateInput } from './components/DateInput';
+export * from './components/Document';
+export { default as Document } from './components/Document';
+export * from './components/Dropdown';
+export { default as Dropdown } from './components/Dropdown';
+export * from './components/Fieldset';
+export { default as Fieldset } from './components/Fieldset';
+export * from './components/FileInput';
+export { default as FileInput } from './components/FileInput';
+export * from './components/FilterLink';
+export { default as FilterLink } from './components/FilterLink';
+export * from './components/Form';
+export { default as Form } from './components/Form';
+export * from './components/FormActions';
+export { default as FormActions } from './components/FormActions';
+export * from './components/FormField';
+export { default as FormField } from './components/FormField';
+export * from './components/FormRepeater';
+export { default as FormRepeater } from './components/FormRepeater';
+export * from './components/ImageInput';
+export { default as ImageInput } from './components/ImageInput';
+export * from './components/InfoPanel';
+export { default as InfoPanel } from './components/InfoPanel';
+export * from './components/Link';
+export { default as Link } from './components/Link';
+export * from './components/List';
+export { default as List } from './components/List';
+export * from './components/ListActions';
+export { default as ListActions } from './components/ListActions';
+export * from './components/LoginForm';
+export { default as LoginForm } from './components/LoginForm';
+export * from './components/Message';
+export { default as Message } from './components/Message';
+export * from './components/ModalActions';
+export { default as ModalActions } from './components/ModalActions';
+export * from './components/MoneyInput';
+export { default as MoneyInput } from './components/MoneyInput';
+export * from './components/PasswordForm';
+export { default as PasswordForm } from './components/PasswordForm';
+export * from './components/PasswordInput';
+export { default as PasswordInput } from './components/PasswordInput';
+export * from './components/RadioList';
+export { default as RadioList } from './components/RadioList';
+export * from './components/Scene';
+export { default as Scene } from './components/Scene';
+export * from './components/SummaryList';
+export { default as SummaryList } from './components/SummaryList';
+export * from './components/Switch';
+export { default as Switch } from './components/Switch';
+export * from './components/Table';
+export { default as Table } from './components/Table';
+export * from './components/Tag';
+export { default as Tag } from './components/Tag';
+export * from './components/TextArea';
+export { default as TextArea } from './components/TextArea';
+export * from './components/TextInput';
+export { default as TextInput } from './components/TextInput';
+export * from './components/WebsiteInput';
+export { default as WebsiteInput } from './components/WebsiteInput';
+export * from './components/WeekCalendar';
+export { default as WeekCalendar } from './components/WeekCalendar';
+export * from './core/AppHeader';
+export * from './core/AppLogo';
+export * from './core/AppLogoImage';
+export * from './core/AppLogoPlaceholder';
+export * from './core/Assistive';
+export * from './core/Banner';
+export * from './core/BuildModal';
+export * from './core/Calendar';
+export * from './core/CalendarDay';
+export * from './core/CalendarMonth';
+export * from './core/CalendarNavigation';
+export * from './core/CalendarWeek';
+export * from './core/ChkRad';
+export * from './core/ChkRadIcon';
+export * from './core/ChkRadList';
+export * from './core/CloseButton';
+export * from './core/ConfirmModal';
+export * from './core/ConnectedRepeater';
+export * from './core/ConnectedRepeaterComponent';
+export * from './core/Container';
+export * from './core/DropdownPanel';
+export * from './core/EmptyMessage';
+export * from './core/ErrorBoundary';
+export * from './core/ErrorMessage';
+export * from './core/FilterItem';
+export * from './core/Filters';
+export * from './core/FixedActions';
+export * from './core/FormError';
+export * from './core/FormLabel';
+export * from './core/FormLegend';
+export * from './core/Header';
+export * from './core/Icon';
+export * from './core/IconButton';
+export * from './core/InputPanel';
+export * from './core/ListItem';
+export * from './core/ListItemAction';
+export * from './core/ListItemActions';
+export * from './core/ListItemMetaItem';
+export * from './core/ListItemTitle';
+export * from './core/Loader';
+export * from './core/MeActions';
+export * from './core/MePanel';
+export * from './core/Modal';
+export * from './core/Navigation';
+export * from './core/NavigationDivider';
+export * from './core/NavigationItem';
+export * from './core/Pagination';
+export * from './core/PaginationItem';
+export * from './core/Panel';
+export * from './core/RadialProgress';
+export * from './core/StaticTextInput';
+export * from './core/Styled';
+export * from './core/SummaryListItem';
+export * from './core/TableActionsCell';
+export * from './core/TableCell';
+export * from './core/TableHead';
+export * from './core/TableRow';
+export * from './core/Tabs';
+export * from './core/TextInputAncillary';
+export * from './core/Toast';
+export * from './core/WeekCalendarDay';
+export * from './hooks/useAccessiblePanel';
+export { default as useAccessiblePanel } from './hooks/useAccessiblePanel';
+export * from './hooks/useAppContext';
+export { default as useAppContext } from './hooks/useAppContext';
+export * from './hooks/useClickOutside';
+export { default as useClickOutside } from './hooks/useClickOutside';
+export * from './hooks/useConnectedList';
+export { default as useConnectedList } from './hooks/useConnectedList';
+export * from './hooks/useFilters';
+export { default as useFilters } from './hooks/useFilters';
+export * from './hooks/useForm';
+export { default as useForm } from './hooks/useForm';
+export * from './hooks/useFormData';
+export { default as useFormData } from './hooks/useFormData';
+export * from './hooks/useLayout';
+export { default as useLayout } from './hooks/useLayout';
+export * from './hooks/useModal';
+export { default as useModal } from './hooks/useModal';
+export * from './hooks/useVariant';
+export { default as useVariant } from './hooks/useVariant';
+export * from './services/BuildService';
+export { default as BuildService } from './services/BuildService';
+export * from './services/ConfirmService';
+export { default as ConfirmService } from './services/ConfirmService';
+export * from './services/DateService';
+export { default as DateService } from './services/DateService';
+export * from './services/DownloadService';
+export { default as DownloadService } from './services/DownloadService';
+export * from './services/FilterComponentService';
+export { default as FilterComponentService } from './services/FilterComponentService';
+export * from './services/FilterService';
+export { default as FilterService } from './services/FilterService';
+export * from './services/FormatService';
+export { default as FormatService } from './services/FormatService';
+export * from './services/ToastService';
+export { default as ToastService } from './services/ToastService';

package/src/scenes/Error404Scene.tsx

@@ -0,0 +1,5 @@
+import React from 'react';
+
+const Error404Scene: React.FunctionComponent = () => <div>Error404Scene</div>;
+
+export default Error404Scene;

package/src/services/BuildService.spec.ts

@@ -0,0 +1,56 @@
+import { ApiService, EventService, StorageService } from '@sqrzro/utility';
+
+import BuildService from './BuildService';
+
+describe('BuildService', () => {
+    beforeEach(() => {
+        (EventService.publish as jest.Mock).mockClear();
+    });
+
+    it('should open', () => {
+        expect(EventService.publish).toHaveBeenCalledTimes(0);
+        BuildService.open();
+        expect(EventService.publish).toHaveBeenCalledTimes(1);
+        expect(EventService.publish).toHaveBeenLastCalledWith('@build/open');
+    });
+
+    it('should start with hash error', async () => {
+        jest.spyOn(ApiService, 'get').mockImplementationOnce(() => {
+            throw new Error('lorem');
+        });
+
+        expect(EventService.publish).toHaveBeenCalledTimes(0);
+        await BuildService.start();
+        expect(EventService.publish).toHaveBeenCalledTimes(2);
+        expect(EventService.publish).toHaveBeenCalledWith('@build/status', 'PENDING');
+        expect(EventService.publish).toHaveBeenCalledWith('@build/status', 'ERROR');
+    });
+
+    it('should start with hash success, poll error', async () => {
+        // @ts-expect-error APIResponse not being available
+        jest.spyOn(ApiService, 'get').mockImplementationOnce(() => ({ data: { hash: 'lorem' } }));
+
+        jest.spyOn(ApiService, 'pollForResponse').mockImplementationOnce(() => {
+            throw new Error('lorem');
+        });
+
+        await BuildService.start();
+        expect(StorageService.set).toHaveBeenCalledTimes(1);
+        expect(StorageService.set).toHaveBeenLastCalledWith('build_hash', 'lorem');
+
+        expect(StorageService.remove).toHaveBeenCalledTimes(1);
+        expect(StorageService.remove).toHaveBeenLastCalledWith('build_hash');
+
+        expect(EventService.publish).toHaveBeenCalledTimes(2);
+        expect(EventService.publish).toHaveBeenCalledWith('@build/status', 'ERROR');
+    });
+
+    it('should start with success', async () => {
+        // @ts-expect-error APIResponse not being available
+        jest.spyOn(ApiService, 'get').mockImplementationOnce(() => ({ data: { hash: 'lorem' } }));
+
+        await BuildService.start();
+        expect(EventService.publish).toHaveBeenCalledTimes(2);
+        expect(EventService.publish).toHaveBeenCalledWith('@build/status', 'SUCCESS');
+    });
+});

package/src/services/BuildService.ts

@@ -0,0 +1,34 @@
+import { ApiService, EventService, StorageService } from '@sqrzro/utility';
+
+const start = async (): Promise<void> => {
+    EventService.publish('@build/status', 'PENDING');
+
+    try {
+        const response = await ApiService.get<{ hash: string }>('build');
+
+        StorageService.set('build_hash', response.data.hash);
+    } catch (err) {
+        EventService.publish('@build/status', 'ERROR');
+        return;
+    }
+
+    try {
+        await ApiService.pollForResponse([
+            'build/status',
+            {
+                hash: StorageService.get('build_hash'),
+            },
+        ]);
+        EventService.publish('@build/status', 'SUCCESS');
+    } catch (err) {
+        EventService.publish('@build/status', 'ERROR');
+    }
+
+    StorageService.remove('build_hash');
+};
+
+const open = (): boolean => EventService.publish('@build/open');
+
+const BuildService = { start, open };
+
+export default BuildService;

package/src/services/ConfirmService.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from 'react';
+import { EventService } from '@sqrzro/utility';
+
+export interface ConfirmModalData {
+    description: ReactNode;
+    label?: string;
+    onConfirm?: () => void;
+}
+
+export interface ConfirmObject {
+    ask: (data: ConfirmModalData) => boolean;
+    close: () => boolean;
+}
+
+const ask = (data: ConfirmModalData): boolean => EventService.publish('@confirm/send', data);
+
+const close = (): boolean => EventService.publish('@confirm/send', null);
+
+const ConfirmService: ConfirmObject = { ask, close };
+
+export default ConfirmService;

package/src/services/DateService.spec.ts

@@ -0,0 +1,87 @@
+import MockDate from 'mockdate';
+
+import DateService from './DateService';
+
+describe('DateService', () => {
+    it('should addMonths', () => {
+        expect(DateService.addMonths('2020-01', 4)).toBe('2020-05');
+        expect(DateService.addMonths('1946-07', 12)).toBe('1947-07');
+        expect(DateService.addMonths('2050-02', 1)).toBe('2050-03');
+        expect(DateService.addMonths('2021-02', 0)).toBe('2021-02');
+        expect(DateService.addMonths('lorem', 5)).toBe('');
+    });
+
+    it('should getDaysInMonth', () => {
+        expect(DateService.getDaysInMonth('2020-01')).toBe(31);
+        expect(DateService.getDaysInMonth('2020-02')).toBe(29);
+        expect(DateService.getDaysInMonth('1950-09')).toBe(30);
+        expect(DateService.getDaysInMonth('lorem')).toBe(-1);
+    });
+
+    it('should getDayOfWeek', () => {
+        expect(DateService.getDayOfWeek('1987-04-18')).toBe(5);
+        expect(DateService.getDayOfWeek('2018-06-17')).toBe(6);
+        expect(DateService.getDayOfWeek('2028-05-18')).toBe(3);
+        expect(DateService.getDayOfWeek('2045-08-07')).toBe(0);
+        expect(DateService.getDayOfWeek('2046-01-02')).toBe(1);
+        expect(DateService.getDayOfWeek('lorem')).toBe(-1);
+    });
+
+    it('should getDays', () => {
+        const days = DateService.getDays();
+
+        expect(days[0]).toEqual({ id: 1, name: '1' });
+        expect(days[17]).toEqual({ id: 18, name: '18' });
+        expect(days[40]).toBeUndefined();
+    });
+
+    it('should getMonths', () => {
+        const months = DateService.getMonths();
+
+        expect(months[0]).toEqual({ id: 1, name: 'January' });
+        expect(months[7]).toEqual({ id: 8, name: 'August' });
+        expect(months[14]).toBeUndefined();
+    });
+
+    it('should getQuickDates', () => {
+        MockDate.set('2000-11-22');
+        const dates = DateService.getQuickDates();
+
+        expect(dates[0]).toEqual({ id: '2000-11-22,2000-11-22', name: 'Today' });
+        expect(dates[1]).toEqual({ id: '2000-11-21,2000-11-21', name: 'Yesterday' });
+        expect(dates[2]).toEqual({ id: '2000-11-15,2000-11-22', name: 'Last 7 Days' });
+        expect(dates[3]).toEqual({ id: '2000-10-23,2000-11-22', name: 'Last 30 Days' });
+        expect(dates[4]).toEqual({ id: '2000-11-01,2000-11-22', name: 'This Month' });
+        expect(dates[5]).toEqual({ id: '2000-10-01,2000-10-31', name: 'Last Month' });
+    });
+
+    describe('should getYears', () => {
+        it('should get default years', () => {
+            MockDate.set('2021-11-22');
+            const years = DateService.getYears();
+
+            expect(years[0]).toEqual({ id: 2021, name: '2021' });
+            expect(years[17]).toEqual({ id: 2004, name: '2004' });
+            expect(years[200]).toBeUndefined();
+        });
+
+        it('should get custom years', () => {
+            expect(DateService.getYears(2000, 2016)[3]).toEqual({ id: 2013, name: '2013' });
+        });
+    });
+
+    describe('should isToday', () => {
+        MockDate.set('2000-11-22');
+        expect(DateService.isToday('2000-11-22')).toBe(true);
+        expect(DateService.isToday('2001-11-22')).toBe(false);
+        expect(DateService.isToday('lorem')).toBe(false);
+    });
+
+    describe('should subMonths', () => {
+        expect(DateService.subMonths('2020-01', 4)).toBe('2019-09');
+        expect(DateService.subMonths('1946-07', 12)).toBe('1945-07');
+        expect(DateService.subMonths('2050-02', 1)).toBe('2050-01');
+        expect(DateService.subMonths('2021-02', 0)).toBe('2021-02');
+        expect(DateService.subMonths('lorem', 5)).toBe('');
+    });
+});