@transferwise/components 46.51.0 → 46.52.1

package/src/inputs/SelectInput.tsx

@@ -6,6 +6,7 @@ import {
   createContext,
   forwardRef,
   useContext,
+  useDeferredValue,
   useEffect,
   useId,
   useMemo,
@@ -13,6 +14,7 @@ import {
   useState,
 } from 'react';
 import { useIntl } from 'react-intl';
+import { Virtualizer } from 'virtua';
 
 import { useEffectEvent } from '../common/hooks/useEffectEvent';
 import { useScreenSize } from '../common/hooks/useScreenSize';
@@ -29,6 +31,8 @@ import { InputGroup } from './InputGroup';
 import { SearchInput } from './SearchInput';
 import messages from './SelectInput.messages';
 
+const MAX_ITEMS_WITHOUT_VIRTUALIZATION = 50;
+
 function searchableString(value: string) {
   return value.trim().replace(/\s+/gu, ' ').normalize('NFKC').toLowerCase();
 }
@@ -40,22 +44,13 @@ function inferSearchableStrings(value: unknown) {
 
   if (typeof value === 'object' && value != null) {
     return Object.values(value)
-      .filter((innerValue): innerValue is string => typeof innerValue === 'string')
+      .filter((innerValue) => typeof innerValue === 'string')
       .map((innerValue) => searchableString(innerValue));
   }
 
   return [];
 }
 
-const SelectInputTriggerButtonPropsContext = createContext<{
-  ref?: React.ForwardedRef<HTMLButtonElement | null>;
-  id?: string;
-  onClick?: (event: React.MouseEvent) => void;
-  onKeyDown?: (event: React.KeyboardEvent) => void;
-  [key: string]: unknown;
-}>({});
-const SelectInputOptionContentWithinTriggerContext = createContext(false);
-
 export interface SelectInputOptionItem<T = string> {
   type: 'option';
   value: T;
@@ -89,6 +84,11 @@ function dedupeSelectInputOptionItem<T>(
   return { ...item, value: undefined };
 }
 
+/**
+ * Sets the `value` of duplicate option items to `undefined`, hiding them when
+ * rendered. Indexes are kept intact within groups to preserve the active item
+ * between filter changes when possible.
+ */
 function dedupeSelectInputItems<T>(
   items: readonly SelectInputItem<T>[],
 ): SelectInputItem<T | undefined>[] {
@@ -112,20 +112,23 @@ function dedupeSelectInputItems<T>(
   });
 }
 
-function filterSelectInputOptionItem<T>(item: SelectInputOptionItem<T>, needle: string) {
+function selectInputOptionItemIncludesNeedle<T>(item: SelectInputOptionItem<T>, needle: string) {
   return inferSearchableStrings(item.filterMatchers ?? item.value).some((haystack) =>
     haystack.includes(needle),
   );
 }
 
-function filterSelectInputItems<T>(items: readonly SelectInputItem<T>[], needle: string) {
+function filterSelectInputItems<T>(
+  items: readonly SelectInputItem<T>[],
+  predicate: (item: SelectInputOptionItem<T>) => boolean,
+) {
   return items.filter((item) => {
     switch (item.type) {
       case 'option': {
-        return filterSelectInputOptionItem(item, needle);
+        return predicate(item);
       }
       case 'group': {
-        return item.options.some((option) => filterSelectInputOptionItem(option, needle));
+        return item.options.some((option) => predicate(option));
       }
       default:
     }
@@ -271,12 +274,15 @@ export function SelectInput<T = string, M extends boolean = false>({
   }, [handleClose, open]);
 
   const [filterQuery, _setFilterQuery] = useState('');
+  const deferredFilterQuery = useDeferredValue(filterQuery);
   const setFilterQuery = useEffectEvent((query: string) => {
     _setFilterQuery(query);
-    onFilterChange({
-      query,
-      queryNormalized: query ? searchableString(query) : null,
-    });
+    if (query !== filterQuery) {
+      onFilterChange({
+        query,
+        queryNormalized: query ? searchableString(query) : null,
+      });
+    }
   });
 
   const triggerRef = useRef<HTMLButtonElement | null>(null);
@@ -294,9 +300,7 @@ export function SelectInput<T = string, M extends boolean = false>({
       multiple={multiple}
       defaultValue={defaultValue}
       value={controlledValue}
-      // TODO: Remove assertion when upgrading TypeScript to v5
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      by={compareValues as any}
+      by={compareValues}
       disabled={disabled}
       onChange={
         ((value) => {
@@ -349,8 +353,8 @@ export function SelectInput<T = string, M extends boolean = false>({
                   content: !placeholderShown ? (
                     <SelectInputOptionContentWithinTriggerContext.Provider value>
                       {multiple && Array.isArray(value)
-                        ? value
-                            .map((option: NonNullable<T>) => renderValue(option, true))
+                        ? (value as readonly NonNullable<T>[])
+                            .map((option) => renderValue(option, true))
                             .filter((node) => node != null)
                             .join(', ')
                         : renderValue(value as NonNullable<T>, true)}
@@ -379,9 +383,7 @@ export function SelectInput<T = string, M extends boolean = false>({
               setOpen(false);
             }}
             onCloseEnd={() => {
-              if (filterQuery !== '') {
-                setFilterQuery('');
-              }
+              setFilterQuery('');
             }}
           >
             <SelectInputOptions
@@ -392,7 +394,7 @@ export function SelectInput<T = string, M extends boolean = false>({
               filterPlaceholder={filterPlaceholder}
               searchInputRef={searchInputRef}
               listboxRef={listboxRef}
-              filterQuery={filterQuery}
+              filterQuery={deferredFilterQuery}
               onFilterChange={setFilterQuery}
             />
           </OptionsOverlay>
@@ -402,6 +404,14 @@ export function SelectInput<T = string, M extends boolean = false>({
   );
 }
 
+const SelectInputTriggerButtonPropsContext = createContext<{
+  ref?: React.ForwardedRef<HTMLButtonElement | null>;
+  id?: string;
+  onClick?: (event: React.MouseEvent) => void;
+  onKeyDown?: (event: React.KeyboardEvent) => void;
+  [key: string]: unknown;
+}>({});
+
 type SelectInputTriggerButtonElementType = 'button' | React.ComponentType;
 
 export type SelectInputTriggerButtonProps<
@@ -506,7 +516,51 @@ function SelectInputOptions<T = string>({
     }
     return undefined;
   }, [filterQuery, filterable]);
-  const resultsEmpty = needle != null && filterSelectInputItems(items, needle).length === 0;
+  useEffect(() => {
+    if (needle) {
+      // Ensure having an active option while filtering.
+      // Without `requestAnimationFrame` upon which React depends for scheduling
+      // updates, the active status would only show for a split second and then
+      // disappear inadvertently.
+      requestAnimationFrame(() => {
+        if (
+          controllerRef.current != null &&
+          !controllerRef.current.hasAttribute('aria-activedescendant')
+        ) {
+          // Activate first option via synthetic key press
+          controllerRef.current.dispatchEvent(
+            new KeyboardEvent('keydown', { key: 'Home', bubbles: true }),
+          );
+        }
+      });
+    }
+  }, [controllerRef, needle]);
+
+  const filteredItems: readonly SelectInputItem<NonNullable<T> | undefined>[] =
+    needle != null
+      ? filterSelectInputItems(dedupeSelectInputItems(items), (item) =>
+          selectInputOptionItemIncludesNeedle(item, needle),
+        )
+      : items;
+  const resultsEmpty = needle != null && filteredItems.length === 0;
+
+  const virtualized = filteredItems.length > MAX_ITEMS_WITHOUT_VIRTUALIZATION;
+
+  // Items shown once shall be kept mounted until the needle changes, otherwise
+  // the scroll position may jump around inadvertently. Pattern adopted from:
+  // https://inokawa.github.io/virtua/?path=/story/advanced-keep-offscreen-items--append-only
+  const [mountedIndexes, setMountedIndexes] = useState<number[]>([]);
+  useEffect(() => {
+    // Ensure the 'End' key works as intended by keeping the last item mounted
+    setMountedIndexes((prevMountedIndexes) => {
+      const indexes = new Set(prevMountedIndexes);
+      indexes.add(filteredItems.length - 1);
+      return [...indexes]; // Sorting is redundant by nature here
+    });
+  }, [
+    needle, // Needed as `filteredItems.length` may be equal between two updates
+    filteredItems.length,
+  ]);
 
   const listboxContainerRef = useRef<HTMLDivElement>(null);
   useEffect(() => {
@@ -522,6 +576,19 @@ function SelectInputOptions<T = string>({
   const statusId = useId();
   const listboxId = useId();
 
+  const getItemNode = (index: number) => {
+    const item = filteredItems[index];
+    return (
+      <SelectInputItemView
+        // eslint-disable-next-line react/no-array-index-key
+        key={index}
+        item={item}
+        renderValue={renderValue}
+        needle={needle}
+      />
+    );
+  };
+
   return (
     <ListboxBase.Options
       as={SelectInputOptionsContainer}
@@ -533,12 +600,6 @@ function SelectInputOptions<T = string>({
             controllerRef.current.setAttribute('aria-activedescendant', value);
           } else {
             controllerRef.current.removeAttribute('aria-activedescendant');
-            if (filterQuery) {
-              // Ensure having an active option while filtering
-              controllerRef.current.dispatchEvent(
-                new KeyboardEvent('keydown', { key: 'Home', bubbles: true }),
-              );
-            }
           }
         }
       }}
@@ -549,7 +610,7 @@ function SelectInputOptions<T = string>({
             ref={searchInputRef}
             shape="rectangle"
             placeholder={filterPlaceholder}
-            value={filterQuery}
+            defaultValue={filterQuery}
             aria-controls={listboxId}
             aria-describedby={showStatus ? statusId : undefined}
             onKeyDown={(event) => {
@@ -560,6 +621,9 @@ function SelectInputOptions<T = string>({
               }
             }}
             onChange={(event) => {
+              // Free up resources and ensure not to go out of bounds when the
+              // resulting item count is less than before
+              setMountedIndexes([]);
               onFilterChange(event.currentTarget.value);
             }}
           />
@@ -571,7 +635,9 @@ function SelectInputOptions<T = string>({
         tabIndex={-1}
         className={clsx(
           'np-select-input-listbox-container',
-          items.some((item) => item.type === 'group') &&
+          virtualized && 'np-select-input-listbox-container--virtualized',
+          needle == null && // Groups aren't shown when filtering
+            items.some((item) => item.type === 'group') &&
             'np-select-input-listbox-container--has-group',
         )}
       >
@@ -590,15 +656,35 @@ function SelectInputOptions<T = string>({
           tabIndex={0}
           className="np-select-input-listbox"
         >
-          {(needle != null ? dedupeSelectInputItems(items) : items).map((item, index) => (
-            <SelectInputItemView
-              // eslint-disable-next-line react/no-array-index-key
-              key={index}
-              item={item}
-              renderValue={renderValue}
-              needle={needle}
-            />
-          ))}
+          {!virtualized ? (
+            filteredItems.map((_, index) => getItemNode(index))
+          ) : (
+            <Virtualizer
+              key={needle}
+              count={filteredItems.length}
+              keepMounted={mountedIndexes}
+              scrollRef={listboxRef} // `VList` doesn't expose this
+              onRangeChange={(startIndex, endIndex) => {
+                setMountedIndexes((prevMountedIndexes) => {
+                  const indexes = new Set(prevMountedIndexes);
+                  for (let index = startIndex; index <= endIndex; index += 1) {
+                    indexes.add(index);
+                  }
+                  return [...indexes].sort((a, b) => a - b);
+                });
+              }}
+            >
+              {(index) => (
+                // The position of each item can't be inferred by browsers when
+                // virtualizing, as some of the items may not be in the DOM
+                <SelectInputItemsCountContext.Provider value={filteredItems.length}>
+                  <SelectInputItemPositionContext.Provider value={index + 1}>
+                    {getItemNode(index)}
+                  </SelectInputItemPositionContext.Provider>
+                </SelectInputItemsCountContext.Provider>
+              )}
+            </Virtualizer>
+          )}
         </div>
 
         {renderFooter != null ? (
@@ -639,7 +725,10 @@ function SelectInputItemView<T = string>({
 }: SelectInputItemViewProps<T>) {
   switch (item.type) {
     case 'option': {
-      if (item.value != null && (needle == null || filterSelectInputOptionItem(item, needle))) {
+      if (
+        item.value != null &&
+        (needle == null || selectInputOptionItemIncludesNeedle(item, needle))
+      ) {
         return (
           <SelectInputOption value={item.value} disabled={item.disabled}>
             {renderValue(item.value, false)}
@@ -701,6 +790,9 @@ function SelectInputGroupItemView<T = string>({
   );
 }
 
+const SelectInputItemsCountContext = createContext<number | undefined>(undefined);
+const SelectInputItemPositionContext = createContext<number | undefined>(undefined);
+
 interface SelectInputOptionProps<T = string> {
   value: T;
   disabled?: boolean;
@@ -708,10 +800,14 @@ interface SelectInputOptionProps<T = string> {
 }
 
 function SelectInputOption<T = string>({ value, disabled, children }: SelectInputOptionProps<T>) {
+  const itemsCount = useContext(SelectInputItemsCountContext);
+  const itemPosition = useContext(SelectInputItemPositionContext);
   return (
     <ListboxBase.Option
       as="div"
       value={value}
+      aria-setsize={itemsCount}
+      aria-posinset={itemPosition}
       disabled={disabled}
       className={({ active, disabled: uiDisabled }) =>
         clsx(
@@ -737,6 +833,8 @@ function SelectInputOption<T = string>({ value, disabled, children }: SelectInpu
   );
 }
 
+const SelectInputOptionContentWithinTriggerContext = createContext(false);
+
 export interface SelectInputOptionContentProps {
   title: string;
   note?: string;

package/src/main.css

@@ -2655,6 +2655,10 @@ html:not([dir="rtl"]) .np-flow-navigation--sm .np-flow-navigation__stepper {
     height: auto;
   }
 }
+.np-select-input-listbox-container--virtualized {
+  /* The wrapping element shrinks this as needed */
+  height: 100vh;
+}
 .np-select-input-listbox-container--has-group {
   scroll-padding-top: 32px;
   scroll-padding-top: var(--size-32);
@@ -2673,6 +2677,12 @@ html:not([dir="rtl"]) .np-flow-navigation--sm .np-flow-navigation__stepper {
   outline: var(--ring-outline-color) solid var(--ring-outline-width);
   outline-offset: var(--ring-outline-offset);
 }
+.np-select-input-listbox-container--virtualized .np-select-input-listbox {
+  /* Adopted from `VList` in virtua: https://github.com/inokawa/virtua/blob/7f6ed5b37df6b480d4ff350f3960067c5b3519d2/src/react/VList.tsx#L113-L116 */
+  overflow-y: auto;
+  contain: strict;
+  height: 100%;
+}
 .np-select-input-separator-item {
   margin: 8px;
   margin: var(--size-8);

package/src/typeahead/Typeahead.messages.ts

@@ -0,0 +1,9 @@
+import { defineMessages } from 'react-intl';
+
+export default defineMessages({
+  clearLabel: {
+    id: 'neptune.ClearButton.ariaLabel',
+    defaultMessage: 'Clear',
+    description: 'Description of clear button',
+  },
+});

package/src/typeahead/Typeahead.rtl.spec.tsx

@@ -1,14 +1,26 @@
 import { Field } from '../field/Field';
 import { mockMatchMedia, render, screen } from '../test-utils';
 import Typeahead from './Typeahead';
+import { createIntl, createIntlCache } from 'react-intl';
+import messages from '../i18n';
+import { DEFAULT_LANG, DEFAULT_LOCALE } from '../common';
 
 mockMatchMedia();
 
+const cache = createIntlCache();
+const intl = createIntl({ locale: DEFAULT_LOCALE, messages: messages[DEFAULT_LANG] }, cache);
+
 describe('Typeahead', () => {
   it('supports `Field` for labeling', () => {
     render(
       <Field id="test" label="Tags">
-        <Typeahead id="test" name="test" options={[{ label: 'Test' }]} onChange={() => {}} />
+        <Typeahead
+          id="test"
+          name="test"
+          options={[{ label: 'Test' }]}
+          intl={intl}
+          onChange={() => {}}
+        />
       </Field>,
     );
     expect(screen.getAllByRole('group')[0]).toHaveAccessibleName(/^Tags/);

package/src/typeahead/Typeahead.spec.js

@@ -8,15 +8,17 @@ import { fakeEvent, fakeKeyDownEventForKey } from '../common/fakeEvents';
 import Typeahead from './Typeahead';
 
 const defaultLocale = 'en-GB';
-
-jest.mock('react-intl', () => ({
-  injectIntl: (Component) =>
-    function (props) {
-      return <Component {...props} intl={{ locale: defaultLocale }} />;
-    },
-  useIntl: () => ({ locale: defaultLocale, formatMessage: (id) => `${id}` }),
-  defineMessages: (translations) => translations,
-}));
+jest.mock('react-intl', () => {
+  const mockedIntl = {
+    locale: defaultLocale,
+    formatMessage: (id) => String(id),
+  };
+  return {
+    injectIntl: (Component) => (props) => <Component {...props} intl={mockedIntl} />,
+    defineMessages: (translations) => translations,
+    useIntl: () => mockedIntl,
+  };
+});
 
 describe('Typeahead', () => {
   let component;
@@ -317,7 +319,7 @@ describe('Typeahead', () => {
       onChange: (selections) => {
         selectedOption = selections[0];
       },
-      options: options,
+      options,
     });
 
     input().simulate('change', { target: { value: text } });