@primer/components 30.3.0-rc.2010c7d4 → 30.3.0-rc.9dbc85a9

package/lib-esm/__tests__/Autocomplete.test.js

@@ -0,0 +1,494 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import React from 'react';
+import { render } from '../utils/testing';
+import { render as HTMLRender, fireEvent } from '@testing-library/react';
+import { toHaveNoViolations } from 'jest-axe';
+import 'babel-polyfill';
+import Autocomplete from '../Autocomplete';
+import { SSRProvider } from '../index';
+import theme from '../theme';
+import BaseStyles from '../BaseStyles';
+import { ThemeProvider } from '../ThemeProvider';
+import userEvent from '@testing-library/user-event';
+expect.extend(toHaveNoViolations);
+const mockItems = [{
+  text: 'zero',
+  id: 0
+}, {
+  text: 'one',
+  id: 1
+}, {
+  text: 'two',
+  id: 2
+}, {
+  text: 'three',
+  id: 3
+}, {
+  text: 'four',
+  id: 4
+}, {
+  text: 'five',
+  id: 5
+}, {
+  text: 'six',
+  id: 6
+}, {
+  text: 'seven',
+  id: 7
+}, {
+  text: 'twenty',
+  id: 20
+}, {
+  text: 'twentyone',
+  id: 21
+}]; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+const AUTOCOMPLETE_LABEL = 'Autocomplete field';
+
+const LabelledAutocomplete = ({
+  inputProps = {},
+  menuProps
+}) => {
+  const {
+    ['aria-labelledby']: ariaLabelledBy = 'autocompleteLabel',
+    ...menuPropsRest
+  } = menuProps;
+  const {
+    id = 'autocompleteInput',
+    ...inputPropsRest
+  } = inputProps;
+  return /*#__PURE__*/React.createElement(ThemeProvider, {
+    theme: theme
+  }, /*#__PURE__*/React.createElement(SSRProvider, null, /*#__PURE__*/React.createElement(BaseStyles, null, /*#__PURE__*/React.createElement("label", {
+    htmlFor: id,
+    id: ariaLabelledBy
+  }, "Autocomplete field"), /*#__PURE__*/React.createElement(Autocomplete, {
+    id: "autocompleteId"
+  }, /*#__PURE__*/React.createElement(Autocomplete.Input, _extends({
+    id: id
+  }, inputPropsRest)), /*#__PURE__*/React.createElement(Autocomplete.Overlay, null, /*#__PURE__*/React.createElement(Autocomplete.Menu, _extends({
+    "aria-labelledby": ariaLabelledBy
+  }, menuPropsRest)))))));
+};
+
+LabelledAutocomplete.displayName = "LabelledAutocomplete";
+describe('Autocomplete', () => {
+  describe('snapshots', () => {
+    it('renders a single select input', () => {
+      expect(render( /*#__PURE__*/React.createElement(SSRProvider, null, /*#__PURE__*/React.createElement(Autocomplete, {
+        id: "autocompleteId"
+      }, /*#__PURE__*/React.createElement(Autocomplete.Input, null), /*#__PURE__*/React.createElement(Autocomplete.Menu, {
+        "aria-labelledby": "labelId",
+        items: mockItems,
+        selectedItemIds: []
+      }))))).toMatchSnapshot();
+    });
+    it('renders a multiselect input', () => {
+      expect(render( /*#__PURE__*/React.createElement(SSRProvider, null, /*#__PURE__*/React.createElement(Autocomplete, {
+        id: "autocompleteId"
+      }, /*#__PURE__*/React.createElement(Autocomplete.Input, null), /*#__PURE__*/React.createElement(Autocomplete.Menu, {
+        "aria-labelledby": "labelId",
+        items: mockItems,
+        selectedItemIds: [],
+        selectionVariant: "multiple"
+      }))))).toMatchSnapshot();
+    });
+    it('renders a multiselect input with selected menu items', () => {
+      expect(render( /*#__PURE__*/React.createElement(SSRProvider, null, /*#__PURE__*/React.createElement(Autocomplete, {
+        id: "autocompleteId"
+      }, /*#__PURE__*/React.createElement(Autocomplete.Input, null), /*#__PURE__*/React.createElement(Autocomplete.Menu, {
+        "aria-labelledby": "labelId",
+        items: mockItems,
+        selectedItemIds: [0, 1, 2],
+        selectionVariant: "multiple"
+      }))))).toMatchSnapshot();
+    });
+    it('renders a menu that contains an item to add to the menu', () => {
+      const handleAddItemMock = jest.fn();
+      expect(render( /*#__PURE__*/React.createElement(SSRProvider, null, /*#__PURE__*/React.createElement(Autocomplete, {
+        id: "autocompleteId"
+      }, /*#__PURE__*/React.createElement(Autocomplete.Input, null), /*#__PURE__*/React.createElement(Autocomplete.Menu, {
+        "aria-labelledby": "labelId",
+        items: mockItems,
+        selectionVariant: "multiple",
+        selectedItemIds: [],
+        addNewItem: {
+          text: 'Add new item',
+          handleAddItem: handleAddItemMock
+        }
+      }))))).toMatchSnapshot();
+    });
+    it('renders a custom empty state message', () => {
+      expect(render( /*#__PURE__*/React.createElement(SSRProvider, null, /*#__PURE__*/React.createElement(Autocomplete, {
+        id: "autocompleteId"
+      }, /*#__PURE__*/React.createElement(Autocomplete.Input, null), /*#__PURE__*/React.createElement(Autocomplete.Menu, {
+        "aria-labelledby": "labelId",
+        items: [],
+        selectedItemIds: [],
+        emptyStateText: "No results"
+      }))))).toMatchSnapshot();
+    });
+    it('renders a loading state', () => {
+      expect(render( /*#__PURE__*/React.createElement(SSRProvider, null, /*#__PURE__*/React.createElement(Autocomplete, {
+        id: "autocompleteId"
+      }, /*#__PURE__*/React.createElement(Autocomplete.Input, null), /*#__PURE__*/React.createElement(Autocomplete.Menu, {
+        "aria-labelledby": "labelId",
+        loading: true,
+        items: [],
+        selectedItemIds: []
+      }))))).toMatchSnapshot();
+    });
+    it('renders with a custom text input component', () => {
+      expect(render( /*#__PURE__*/React.createElement(SSRProvider, null, /*#__PURE__*/React.createElement(Autocomplete, {
+        id: "autocompleteId"
+      }, /*#__PURE__*/React.createElement(Autocomplete.Input, {
+        as: () => /*#__PURE__*/React.createElement("input", {
+          type: "text",
+          id: "customInput"
+        })
+      }), /*#__PURE__*/React.createElement(Autocomplete.Menu, {
+        "aria-labelledby": "labelId",
+        items: mockItems,
+        selectedItemIds: []
+      }))))).toMatchSnapshot();
+    });
+    it('renders with an input value', () => {
+      expect(render( /*#__PURE__*/React.createElement(SSRProvider, null, /*#__PURE__*/React.createElement(Autocomplete, {
+        id: "autocompleteId"
+      }, /*#__PURE__*/React.createElement(Autocomplete.Input, {
+        value: "test"
+      }), /*#__PURE__*/React.createElement(Autocomplete.Menu, {
+        "aria-labelledby": "labelId",
+        items: mockItems,
+        selectedItemIds: []
+      }))))).toMatchSnapshot();
+    });
+  });
+  describe('Autocomplete.Input', () => {
+    it('calls onChange', () => {
+      const onChangeMock = jest.fn();
+      const {
+        container
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        inputProps: {
+          onChange: onChangeMock
+        },
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: []
+        }
+      }));
+      const inputNode = container.querySelector('#autocompleteInput');
+      expect(onChangeMock).not.toHaveBeenCalled();
+      inputNode && userEvent.type(inputNode, 'z');
+      expect(onChangeMock).toHaveBeenCalled();
+    });
+    it('calls onFocus', () => {
+      const onFocusMock = jest.fn();
+      const {
+        container
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        inputProps: {
+          onFocus: onFocusMock
+        },
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: []
+        }
+      }));
+      const inputNode = container.querySelector('#autocompleteInput');
+      expect(onFocusMock).not.toHaveBeenCalled();
+      inputNode && fireEvent.focus(inputNode);
+      expect(onFocusMock).toHaveBeenCalled();
+    });
+    it('calls onKeyDown', () => {
+      const onKeyDownMock = jest.fn();
+      const {
+        getByLabelText
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        inputProps: {
+          onKeyDown: onKeyDownMock
+        },
+        menuProps: {
+          items: [],
+          selectedItemIds: []
+        }
+      }));
+      const inputNode = getByLabelText(AUTOCOMPLETE_LABEL);
+      expect(onKeyDownMock).not.toHaveBeenCalled();
+      fireEvent.keyDown(inputNode, {
+        key: 'Shift'
+      });
+      expect(onKeyDownMock).toHaveBeenCalled();
+    });
+    it('calls onKeyUp', () => {
+      const onKeyUpMock = jest.fn();
+      const {
+        getByLabelText
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        inputProps: {
+          onKeyUp: onKeyUpMock
+        },
+        menuProps: {
+          items: [],
+          selectedItemIds: []
+        }
+      }));
+      const inputNode = getByLabelText(AUTOCOMPLETE_LABEL);
+      expect(onKeyUpMock).not.toHaveBeenCalled();
+      fireEvent.keyUp(inputNode, {
+        key: 'Shift'
+      });
+      expect(onKeyUpMock).toHaveBeenCalled();
+    });
+    it('calls onKeyPress', () => {
+      const onKeyPressMock = jest.fn();
+      const {
+        getByLabelText
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        inputProps: {
+          onKeyPress: onKeyPressMock
+        },
+        menuProps: {
+          items: [],
+          selectedItemIds: []
+        }
+      }));
+      const inputNode = getByLabelText(AUTOCOMPLETE_LABEL);
+      expect(onKeyPressMock).not.toHaveBeenCalled();
+      userEvent.type(inputNode, '{enter}');
+      expect(onKeyPressMock).toHaveBeenCalled();
+    });
+    it('opens the menu when the input is focused', () => {
+      const {
+        getByLabelText
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: [],
+          selectedItemIds: []
+        }
+      }));
+      const inputNode = getByLabelText(AUTOCOMPLETE_LABEL);
+      expect(inputNode.getAttribute('aria-expanded')).not.toBe('true');
+      fireEvent.focus(inputNode);
+      expect(inputNode.getAttribute('aria-expanded')).toBe('true');
+    });
+    it('closes the menu when the input is blurred', () => {
+      const {
+        getByLabelText
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: [],
+          selectedItemIds: []
+        }
+      }));
+      const inputNode = getByLabelText(AUTOCOMPLETE_LABEL);
+      expect(inputNode.getAttribute('aria-expanded')).not.toBe('true');
+      fireEvent.focus(inputNode);
+      expect(inputNode.getAttribute('aria-expanded')).toBe('true'); // eslint-disable-next-line github/no-blur
+
+      fireEvent.blur(inputNode); // wait a tick for blur to finish
+
+      setTimeout(() => {
+        expect(inputNode.getAttribute('aria-expanded')).not.toBe('true');
+      }, 0);
+    });
+    it('sets the input value to the suggested item text and highlights the untyped part of the word', () => {
+      const {
+        container,
+        getByDisplayValue
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: []
+        }
+      }));
+      const inputNode = container.querySelector('#autocompleteInput');
+      inputNode && userEvent.type(inputNode, 'ze');
+      expect(getByDisplayValue('zero')).toBeDefined();
+    });
+    it('does not show or highlight suggestion text after the user hits Backspace until they hit another key', () => {
+      const {
+        container,
+        getByDisplayValue
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: []
+        }
+      }));
+      const inputNode = container.querySelector('#autocompleteInput');
+      expect(inputNode.selectionStart).toBe(0);
+      inputNode && userEvent.type(inputNode, 'ze');
+      expect(getByDisplayValue('zero')).toBeDefined();
+      expect(inputNode.selectionStart).toBe(2);
+      expect(inputNode.selectionEnd).toBe(4);
+      inputNode && userEvent.type(inputNode, '{backspace}');
+      expect(inputNode.selectionStart).toBe(2);
+      expect(getByDisplayValue('ze')).toBeDefined();
+      inputNode && userEvent.type(inputNode, 'r');
+      expect(inputNode.selectionStart).toBe(3);
+      expect(inputNode.selectionEnd).toBe(4);
+      expect(getByDisplayValue('zero')).toBeDefined();
+    });
+    it('clears the input value when when the user hits Escape', () => {
+      const {
+        container
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: []
+        }
+      }));
+      const inputNode = container.querySelector('#autocompleteInput');
+      expect(inputNode === null || inputNode === void 0 ? void 0 : inputNode.getAttribute('aria-expanded')).not.toBe('true');
+      inputNode && userEvent.type(inputNode, 'ze');
+      expect(inputNode === null || inputNode === void 0 ? void 0 : inputNode.getAttribute('aria-expanded')).toBe('true');
+      inputNode && userEvent.type(inputNode, '{esc}');
+      expect(inputNode === null || inputNode === void 0 ? void 0 : inputNode.getAttribute('aria-expanded')).not.toBe('true');
+    });
+  });
+  describe('Autocomplete.Menu', () => {
+    it('calls a custom filter function', () => {
+      const filterFnMock = jest.fn();
+      const {
+        container
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: [],
+          filterFn: filterFnMock
+        }
+      }));
+      const inputNode = container.querySelector('#autocompleteInput');
+      inputNode && userEvent.type(inputNode, 'ze');
+      expect(filterFnMock).toHaveBeenCalled();
+    });
+    it('calls a custom sort function when the menu closes', () => {
+      const sortOnCloseFnMock = jest.fn();
+      const {
+        container
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: [],
+          sortOnCloseFn: sortOnCloseFnMock
+        }
+      }));
+      const inputNode = container.querySelector('#autocompleteInput'); // `sortOnCloseFnMock` will be called in a `.sort()` on render to check if the
+      // current sort order matches the result of `sortOnCloseFnMock`
+
+      expect(sortOnCloseFnMock).toHaveBeenCalledTimes(mockItems.length - 1);
+
+      if (inputNode) {
+        userEvent.type(inputNode, 'ze'); // eslint-disable-next-line github/no-blur
+
+        fireEvent.blur(inputNode);
+      } // wait a tick for blur to finish
+
+
+      setTimeout(() => {
+        expect(sortOnCloseFnMock).toHaveBeenCalledTimes(mockItems.length);
+      }, 0);
+    });
+    it("calls onOpenChange with the menu's open state", () => {
+      const onOpenChangeMock = jest.fn();
+      const {
+        container
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: [],
+          onOpenChange: onOpenChangeMock
+        }
+      }));
+      const inputNode = container.querySelector('#autocompleteInput');
+      inputNode && userEvent.type(inputNode, 'ze');
+      expect(onOpenChangeMock).toHaveBeenCalled();
+    });
+    it('calls onSelectedChange with the data for the selected items', () => {
+      const onSelectedChangeMock = jest.fn();
+      const {
+        container
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: [],
+          onSelectedChange: onSelectedChangeMock
+        }
+      }));
+      const inputNode = container.querySelector('#autocompleteInput');
+      expect(onSelectedChangeMock).not.toHaveBeenCalled();
+
+      if (inputNode) {
+        fireEvent.focus(inputNode);
+        userEvent.type(inputNode, '{enter}');
+      } // wait a tick for the keyboard event to be dispatched to the menu item
+
+
+      setTimeout(() => {
+        expect(onSelectedChangeMock).toHaveBeenCalledWith([mockItems[0]]);
+      }, 0);
+    });
+    it('does not close the menu when clicking an item in the menu if selectionVariant=multiple', () => {
+      const {
+        getByText,
+        container
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: [],
+          selectionVariant: 'multiple'
+        }
+      }));
+      const inputNode = container.querySelector('#autocompleteInput');
+      const itemToClickNode = getByText(mockItems[1].text);
+      expect(inputNode === null || inputNode === void 0 ? void 0 : inputNode.getAttribute('aria-expanded')).not.toBe('true');
+      inputNode && fireEvent.focus(inputNode);
+      expect(inputNode === null || inputNode === void 0 ? void 0 : inputNode.getAttribute('aria-expanded')).toBe('true');
+      fireEvent.click(itemToClickNode);
+      inputNode && userEvent.type(inputNode, '{enter}');
+      expect(inputNode === null || inputNode === void 0 ? void 0 : inputNode.getAttribute('aria-expanded')).toBe('true');
+    });
+    it('closes the menu when clicking an item in the menu if selectionVariant=single', () => {
+      const {
+        getByText,
+        container
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: [],
+          selectionVariant: 'single'
+        }
+      }));
+      const inputNode = container.querySelector('#autocompleteInput');
+      const itemToClickNode = getByText(mockItems[1].text);
+      expect(inputNode === null || inputNode === void 0 ? void 0 : inputNode.getAttribute('aria-expanded')).not.toBe('true');
+      inputNode && fireEvent.focus(inputNode);
+      expect(inputNode === null || inputNode === void 0 ? void 0 : inputNode.getAttribute('aria-expanded')).toBe('true');
+      fireEvent.click(itemToClickNode);
+      expect(inputNode === null || inputNode === void 0 ? void 0 : inputNode.getAttribute('aria-expanded')).not.toBe('true');
+    });
+    it('calls handleAddItem with new item data when passing addNewItem', () => {
+      const handleAddItemMock = jest.fn();
+      const {
+        getByText
+      } = HTMLRender( /*#__PURE__*/React.createElement(LabelledAutocomplete, {
+        menuProps: {
+          items: mockItems,
+          selectedItemIds: [],
+          selectionVariant: 'multiple',
+          addNewItem: {
+            text: 'Add new item',
+            handleAddItem: handleAddItemMock
+          }
+        }
+      }));
+      const addNewItemNode = getByText('Add new item');
+      expect(handleAddItemMock).not.toHaveBeenCalled();
+      fireEvent.click(addNewItemNode);
+      expect(handleAddItemMock).toHaveBeenCalled();
+    });
+  });
+});

package/lib-esm/__tests__/behaviors/scrollIntoViewingArea.test.d.ts

@@ -0,0 +1 @@
+export {};