@onewelcome/react-lib-components 0.1.0-alpha → 0.1.3-alpha

package/src/Notifications/DiscardChangesModal/DiscardChangesModal.test.tsx

@@ -0,0 +1,162 @@
+import React, { useEffect, useRef } from 'react';
+import { DiscardChangesModal, Props } from './DiscardChangesModal';
+import { findByTestId, getAllByRole, render, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+const defaultParams: Props = {
+  id: 'modal',
+  open: true,
+  hasUnsavedChanges: jest.fn(),
+  onClose: jest.fn(),
+  headerProps: {
+    title: 'Header',
+  },
+  discardChangedDialogProps: {
+    'data-testid': 'discardChangesDialog',
+    discardChangesButtonLabel: 'Discard',
+    keepEditingButtonLabel: 'Keep editing',
+    contentLabel: 'Unsaved changes',
+    titleLabel: 'Dialog',
+  },
+  children: <span>children</span>,
+};
+
+const createDiscardChangesModal = (params?: (defaultParams: Props) => Props) => {
+  let parameters: Props = defaultParams;
+  if (params) {
+    parameters = params(defaultParams);
+  }
+  const queries = render(<DiscardChangesModal {...parameters} data-testid="discardChangesModal" />);
+  const discardChangesModal = queries.getByTestId('discardChangesModal');
+  const closeBtn = queries.getByRole('button', { name: 'close modal' });
+
+  return {
+    ...queries,
+    discardChangesModal,
+    closeBtn,
+  };
+};
+
+const getDiscardChangesButtons = (container: HTMLElement) =>
+  getAllByRole(container, 'button', {
+    name: new RegExp(
+      `(${defaultParams.discardChangedDialogProps.discardChangesButtonLabel}|${defaultParams.discardChangedDialogProps.keepEditingButtonLabel})`
+    ),
+  });
+
+const findDiscardChangesDialog = (container: HTMLElement) =>
+  findByTestId(container, 'discardChangesDialog');
+
+describe('DiscardChangesModal should render', () => {
+  it('renders without crashing', () => {
+    const { discardChangesModal, container } = createDiscardChangesModal();
+
+    expect(discardChangesModal).toBeDefined();
+    expect(discardChangesModal).toHaveTextContent('children');
+    expect(discardChangesModal).toHaveTextContent(defaultParams.headerProps.title);
+    expect(container).not.toHaveTextContent(defaultParams.discardChangedDialogProps.titleLabel);
+  });
+
+  it('clicking on close button without making any changes close the modal', () => {
+    (
+      defaultParams.hasUnsavedChanges as jest.MockedFunction<typeof defaultParams.hasUnsavedChanges>
+    ).mockReturnValue(false);
+    const { closeBtn } = createDiscardChangesModal();
+
+    userEvent.click(closeBtn);
+    expect(defaultParams.onClose).toBeCalledTimes(1);
+  });
+});
+
+describe('DiscardChangesModal should show DiscardChangesDialog', () => {
+  it('showing DiscardChangesDialog and clicking on `keep editing` button', async () => {
+    (
+      defaultParams.hasUnsavedChanges as jest.MockedFunction<typeof defaultParams.hasUnsavedChanges>
+    ).mockReturnValue(true);
+    const { closeBtn } = createDiscardChangesModal();
+    const container = document.body;
+    expect(defaultParams.onClose).not.toBeCalled();
+
+    userEvent.click(closeBtn);
+
+    expect(defaultParams.onClose).not.toBeCalled();
+    await findDiscardChangesDialog(container);
+    const [_, keepEditingBtn] = getDiscardChangesButtons(container);
+    expect(container).toHaveTextContent(defaultParams.discardChangedDialogProps.titleLabel);
+    expect(container).toHaveTextContent(defaultParams.discardChangedDialogProps.contentLabel);
+
+    userEvent.click(keepEditingBtn);
+    expect(defaultParams.onClose).not.toBeCalled();
+    await waitFor(() =>
+      expect(container).not.toHaveTextContent(defaultParams.discardChangedDialogProps.titleLabel)
+    );
+  });
+
+  it('showing DiscardChangesDialog and clicking on `discard` button', async () => {
+    (
+      defaultParams.hasUnsavedChanges as jest.MockedFunction<typeof defaultParams.hasUnsavedChanges>
+    ).mockReturnValue(true);
+    const { closeBtn } = createDiscardChangesModal();
+    const container = document.body;
+
+    userEvent.click(closeBtn);
+
+    await findDiscardChangesDialog(container);
+    const [discardBtn] = getDiscardChangesButtons(container);
+    expect(container).toHaveTextContent(defaultParams.discardChangedDialogProps.titleLabel);
+
+    userEvent.click(discardBtn);
+    expect(defaultParams.onClose).toBeCalled();
+  });
+});
+
+describe('ref should work', () => {
+  it('should give back the proper data prop, this also checks if the component propagates ...rest properly', () => {
+    const ExampleComponent = ({
+      propagateRef,
+    }: {
+      propagateRef?: (
+        ref1: React.RefObject<HTMLElement>,
+        ref2: React.RefObject<HTMLElement>
+      ) => void;
+    }) => {
+      const modalRef = useRef(null);
+      const dialogRef = useRef(null);
+
+      useEffect(() => {
+        if (dialogRef.current && modalRef.current) {
+          propagateRef && propagateRef(modalRef, dialogRef);
+        }
+      }, [modalRef, dialogRef]);
+
+      return (
+        <DiscardChangesModal
+          modalRef={modalRef}
+          dialogRef={dialogRef}
+          data-ref="testing"
+          hasUnsavedChanges={jest.fn()}
+          onClose={jest.fn()}
+          headerProps={{ title: 'test' }}
+          open={false}
+          children="test"
+          discardChangedDialogProps={{
+            contentLabel: 'test',
+            discardChangesButtonLabel: 'test',
+            keepEditingButtonLabel: 'test',
+            titleLabel: 'test',
+            'data-ref': 'testing',
+          }}
+          title="test"
+          id="test"
+        />
+      );
+    };
+
+    const refCheck = (ref1: React.RefObject<HTMLElement>, ref2: React.RefObject<HTMLElement>) => {
+      expect(ref1.current).toHaveAttribute('data-ref', 'testing');
+      expect(ref2.current).toHaveAttribute('data-ref', 'testing');
+    };
+
+    render(<ExampleComponent propagateRef={refCheck} />);
+  });
+});

package/src/Notifications/DiscardChangesModal/DiscardChangesModal.tsx

@@ -0,0 +1,61 @@
+import React, { Fragment, useState } from 'react';
+import { Modal, Props as ModalProps } from '../Modal/Modal';
+import { ModalHeader, Props as ModalHeaderProps } from '../Modal/ModalHeader/ModalHeader';
+import {
+  DiscardChangesDialog,
+  Props as DiscardChangesDialogProps,
+} from './DiscardChangesDialog/DiscardChangesDialog';
+
+export interface Props extends Omit<ModalProps, 'onClose'> {
+  hasUnsavedChanges: () => boolean;
+  onClose: (event?: React.MouseEvent<HTMLElement>) => unknown;
+  headerProps: Omit<ModalHeaderProps, 'onClose' | 'id'>;
+  discardChangedDialogProps: Omit<
+    DiscardChangesDialogProps,
+    'open' | 'onKeepEditing' | 'onDiscardChanges'
+  >;
+  modalRef?: React.RefObject<HTMLDivElement>;
+  dialogRef?: React.RefObject<HTMLDivElement>;
+}
+
+export const DiscardChangesModal = ({
+  id,
+  children,
+  headerProps,
+  discardChangedDialogProps,
+  modalRef,
+  dialogRef,
+  onClose,
+  hasUnsavedChanges,
+  ...rest
+}: Props) => {
+  const [openDiscardChangesDialog, setOpenDiscardChangesDialog] = useState(false);
+
+  const onCloseWrapper = () =>
+    hasUnsavedChanges() ? setOpenDiscardChangesDialog(true) : onClose();
+
+  const onDialogKeepEditing = () => {
+    setOpenDiscardChangesDialog(false);
+  };
+
+  const onDialogDiscardChanges = () => {
+    setOpenDiscardChangesDialog(false);
+    onClose();
+  };
+
+  return (
+    <Fragment>
+      <Modal id={id} ref={modalRef} onClose={onCloseWrapper} {...rest}>
+        <ModalHeader {...headerProps} id={`${id}-label`} onClose={onCloseWrapper} />
+        {children}
+      </Modal>
+      <DiscardChangesDialog
+        {...discardChangedDialogProps}
+        ref={dialogRef}
+        open={openDiscardChangesDialog}
+        onKeepEditing={onDialogKeepEditing}
+        onDiscardChanges={onDialogDiscardChanges}
+      />
+    </Fragment>
+  );
+};

package/src/{Snackbar → Notifications/Snackbar}/SnackbarItem/SnackbarItem.module.scss

@@ -1,4 +1,4 @@
-@import '../../readyclasses.module.scss';
+@import '../../../readyclasses.module.scss';
 
 .snackbar {
   padding: 1rem 1.25rem;

package/src/{Snackbar → Notifications/Snackbar}/SnackbarItem/SnackbarItem.tsx

@@ -1,11 +1,11 @@
 import React, { useEffect, useRef } from 'react';
-import { IconButton } from '../../Button/IconButton';
-import { Icon, Icons } from '../../Icon/Icon';
+import { IconButton } from '../../../Button/IconButton';
+import { Icon, Icons } from '../../../Icon/Icon';
 import { Variant, Actions } from '../interfaces';
 import classes from './SnackbarItem.module.scss';
-import readyclasses from '../../readyclasses.module.scss';
-import { useAnimation } from '../../hooks/useAnimation';
-import { Typography } from '../../Typography/Typography';
+import readyclasses from '../../../readyclasses.module.scss';
+import { useAnimation } from '../../../hooks/useAnimation';
+import { Typography } from '../../../Typography/Typography';
 
 const textColor = 'var(--snackbar-text-color)';
 
@@ -51,7 +51,7 @@ export const SnackbarItem = ({
 
   const getVariantIcon = () => {
     if (variant === 'error') {
-      return Icons.TimesCircleAlt;
+      return Icons.Error;
     }
     return variant === 'success' ? Icons.CheckmarkCircleBreakout : Icons.InfoCircle;
   };
@@ -92,7 +92,6 @@ export const SnackbarItem = ({
             <Icon icon={Icons.Times} color={textColor} />
           </IconButton>
         </div>
-        {/* @TODO: change it to Typography*/}
         {!!content && (
           <Typography className={classes['content']} variant="body">
             {content}

package/src/{Snackbar → Notifications/Snackbar}/SnackbarProvider/SnackbarProvider.tsx

@@ -3,7 +3,7 @@ import { createPortal } from 'react-dom';
 import { SnackbarContextProvider } from './SnackbarStateProvider';
 import { Actions, SnackbarOptionsProps, Variant } from '../interfaces';
 import { Placement, SnackbarContainer } from '../SnackbarContainer/SnackbarContainer';
-import { generateID } from '../../util/helper';
+import { generateID } from '../../../util/helper';
 import { SnackbarItem } from '../SnackbarItem/SnackbarItem';
 
 /** Short msg is when only title is provided. Long one when content or/and actions are provided (or type is error). */
@@ -14,7 +14,7 @@ interface Duration {
 
 export interface Props {
   closeButtonTitle: string;
-  children?: ReactNode | ReactNode[];
+  children?: ReactNode;
   placement?: Placement;
   stackSize?: number;
   domRoot?: HTMLElement;

package/src/Pagination/Pagination.module.scss

@@ -0,0 +1,120 @@
+.pagination-wrapper {
+  font-family: var(--font-family);
+  font-size: var(--font-size);
+  color: var(--greyed-out);
+  display: flex;
+  flex-direction: column;
+}
+
+.form-element {
+  height: 2.5rem;
+
+  button {
+    min-height: 2.5rem;
+  }
+}
+
+.total {
+  flex: 1 0 auto;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+
+  span > span {
+    font-weight: 700;
+    font-family: var(--font-family);
+    font-size: var(--font-size);
+    margin-left: 0.25rem;
+  }
+}
+
+.pagination {
+  flex: 1 0 auto;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-top: 1rem;
+
+  .previous,
+  .next {
+    display: flex;
+    align-items: center;
+
+    button {
+      margin: 0.25rem;
+    }
+
+    button span:before {
+      font-size: 0.75rem;
+    }
+  }
+}
+
+.per-page {
+  display: none;
+  align-items: center;
+}
+
+.page {
+  display: flex;
+  align-items: center;
+  flex-basis: min-content;
+}
+
+.page-size-select {
+  border-color: #fff;
+  margin: 0 0.25rem;
+
+  button {
+    min-width: 55px;
+    padding: 0;
+
+    div[data-display] {
+      left: 0.5rem;
+    }
+
+    div:not([data-display]) {
+      right: 0.5rem;
+    }
+  }
+}
+
+.current-value-input {
+  margin: 0 0.25rem 0 0;
+  padding: 0;
+
+  input {
+    border-radius: var(--input-border-radius);
+    padding: 0 1rem;
+    width: auto;
+    text-align: center;
+  }
+}
+
+@media screen and (min-width: 30em) {
+  .pagination-wrapper {
+    flex-direction: row;
+  }
+
+  .total {
+    justify-content: flex-start;
+  }
+
+  .pagination {
+    margin-top: 0;
+    justify-content: flex-end;
+
+    .previous,
+    .next {
+      button {
+        margin: 0.5rem;
+      }
+    }
+  }
+}
+
+@media screen and (min-width: 48em) {
+  .per-page {
+    display: flex;
+  }
+}

package/src/Pagination/Pagination.test.tsx

@@ -0,0 +1,176 @@
+import React, { useEffect, useRef } from 'react';
+import { Pagination, Props } from './Pagination';
+import { render, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+const defaultParams: Props = {
+  currentPage: 1,
+  totalElements: 500,
+  onPageChange: jest.fn(),
+  onPageSizeChange: jest.fn(),
+};
+
+const createPagination = (params?: (defaultParams: Props) => Props) => {
+  let parameters: Props = defaultParams;
+
+  if (params) {
+    parameters = params(defaultParams);
+  }
+
+  const queries = render(<Pagination data-testid="pagination" {...parameters} />);
+
+  const pagination = queries.getByTestId('pagination');
+
+  return {
+    ...queries,
+    pagination,
+  };
+};
+
+describe('Pagination should render', () => {
+  it('renders without crashing', () => {
+    const { pagination } = createPagination();
+
+    expect(pagination).toBeTruthy();
+  });
+});
+
+describe('Pagination events', () => {
+  it('should give us the correct values', async () => {
+    const onPageChange = jest.fn();
+
+    const onPageSizeChange = jest.fn();
+
+    const { pagination } = createPagination((defaultParams) => ({
+      ...defaultParams,
+      currentPage: 10,
+      onPageChange: onPageChange,
+      onPageSizeChange: onPageSizeChange,
+    }));
+
+    const next = pagination.querySelector('[data-paginate="next"]')!;
+    const previous = pagination.querySelector('[data-paginate="previous"]')!;
+    const first = pagination.querySelector('[data-paginate="first"]')!;
+    const last = pagination.querySelector('[data-paginate="last"]')!;
+    const pageSizeSelect = pagination.querySelector('.page-size-select')!;
+    const currentPageInput = pagination.querySelector('#current-value-input')!;
+
+    userEvent.click(next);
+
+    await waitFor(() => expect(onPageChange).toHaveBeenCalledWith(11));
+
+    userEvent.click(previous);
+    await waitFor(() => expect(onPageChange).toHaveBeenCalledWith(9));
+
+    userEvent.click(first);
+    await waitFor(() => expect(onPageChange).toHaveBeenCalledWith(0));
+
+    userEvent.click(last);
+    await waitFor(() => expect(onPageChange).toHaveBeenCalledWith(50));
+
+    userEvent.click(pageSizeSelect);
+
+    const option25 = pageSizeSelect.querySelector('[data-value="25"]')!;
+
+    userEvent.click(option25);
+
+    await waitFor(() => expect(onPageSizeChange).toHaveBeenCalledWith(25));
+
+    (currentPageInput as HTMLInputElement).focus();
+
+    userEvent.keyboard('{backspace}{backspace}30{enter}');
+
+    await waitFor(() => expect(onPageChange).toHaveBeenCalledWith(30));
+  });
+});
+
+describe('different current pages and their effect on what renders', () => {
+  it('is on the first page and does not render previous and first', () => {
+    const { pagination } = createPagination();
+
+    expect(pagination.querySelector('.next')).toBeTruthy();
+    expect(pagination.querySelector('.previous')).toBeFalsy();
+  });
+
+  it('is on the second page and does not render first', () => {
+    const { pagination } = createPagination((defaultParams) => ({
+      ...defaultParams,
+      currentPage: 2,
+    }));
+
+    expect(pagination.querySelector('[data-paginate="first"]')).toBeFalsy();
+    expect((pagination.querySelector('.current-value-input input') as HTMLInputElement).value).toBe(
+      '2'
+    );
+  });
+
+  it('is on the second to last page and does not render last', () => {
+    const { pagination } = createPagination((defaultParams) => ({
+      ...defaultParams,
+      currentPage: 499,
+    }));
+
+    expect(pagination.querySelector('[data-paginate="last"]')).toBeFalsy();
+  });
+
+  it('is on the last page and does not render next & last', () => {
+    const { pagination } = createPagination((defaultParams) => ({
+      ...defaultParams,
+      currentPage: 500,
+    }));
+
+    expect(pagination.querySelector('[data-paginate="last"]')).toBeFalsy();
+    expect(pagination.querySelector('[data-paginate="next"]')).toBeFalsy();
+  });
+});
+
+describe('omitted attributes still renders correctly', () => {
+  it("still renders next if totalItems prop isn't given and we're on the first page", () => {
+    const { pagination } = createPagination((defaultParams) => ({
+      ...defaultParams,
+      totalElements: undefined,
+    }));
+
+    expect(pagination.querySelector('.page')).toBeFalsy();
+    expect(pagination.querySelector('.next')).toBeTruthy();
+    expect(pagination.querySelector('.previous')).toBeFalsy();
+  });
+
+  it("still renders next if totalItems prop isn't given and we're on the first page", () => {
+    const { pagination } = createPagination((defaultParams) => ({
+      ...defaultParams,
+      currentPage: 4,
+      totalElements: undefined,
+    }));
+
+    expect(pagination.querySelector('.page')).toBeFalsy();
+    expect(pagination.querySelector('.next')).toBeTruthy();
+    expect(pagination.querySelector('.previous')).toBeTruthy();
+  });
+});
+
+describe('ref should work', () => {
+  it('should give back the proper data prop, this also checks if the component propagates ...rest properly', () => {
+    const ExampleComponent = ({
+      propagateRef,
+    }: {
+      propagateRef?: (ref: React.RefObject<HTMLElement>) => void;
+    }) => {
+      const ref = useRef(null);
+
+      useEffect(() => {
+        if (ref.current) {
+          propagateRef && propagateRef(ref);
+        }
+      }, [ref]);
+
+      return <Pagination {...defaultParams} data-ref="testing" ref={ref} />;
+    };
+
+    const refCheck = (ref: React.RefObject<HTMLElement>) => {
+      expect(ref.current).toHaveAttribute('data-ref', 'testing');
+    };
+
+    render(<ExampleComponent propagateRef={refCheck} />);
+  });
+});