@transferwise/components 46.130.1 → 46.130.3

package/src/inputs/SelectInput/Options/OptionsContainer/SelectInputOptionsContainer.tsx

@@ -0,0 +1,59 @@
+import { forwardRef, useEffect } from 'react';
+import { useEffectEvent } from '../../../../common/hooks/useEffectEvent';
+
+export interface SelectInputOptionsContainerProps extends React.ComponentPropsWithRef<'div'> {
+  onAriaActiveDescendantChange: (value: React.AriaAttributes['aria-activedescendant']) => void;
+}
+
+/**
+ * Container component for SelectInput options.
+ * Handles keyboard navigation and accessibility features.
+ */
+export const SelectInputOptionsContainer = forwardRef(function SelectInputOptionsContainer(
+  {
+    'aria-orientation': ariaOrientation,
+    'aria-activedescendant': ariaActiveDescendant,
+    role,
+    tabIndex,
+    onAriaActiveDescendantChange,
+    onKeyDown,
+    ...restProps
+  }: SelectInputOptionsContainerProps,
+  ref: React.ForwardedRef<HTMLDivElement | null>,
+) {
+  const handleAriaActiveDescendantChange = useEffectEvent(onAriaActiveDescendantChange);
+  useEffect(() => {
+    handleAriaActiveDescendantChange(ariaActiveDescendant);
+  }, [ariaActiveDescendant, handleAriaActiveDescendantChange]);
+
+  return (
+    <div
+      ref={ref}
+      role="none"
+      onKeyDown={(event) => {
+        // Prevent confirmation close without an active item
+        if (event.key === 'Enter' && ariaActiveDescendant == null) {
+          return;
+        }
+
+        // Required to make ListBox focusable
+        if (event.key === 'Tab') {
+          return;
+        }
+
+        // Prevent absorbing Escape early
+        if (event.key === 'Escape') {
+          onKeyDown?.({
+            ...event,
+            preventDefault: () => {},
+            stopPropagation: () => {},
+          });
+          return;
+        }
+
+        onKeyDown?.(event);
+      }}
+      {...restProps}
+    />
+  );
+});

package/src/inputs/SelectInput/Options/OptionsContainer/index.ts

@@ -0,0 +1,2 @@
+export { SelectInputOptionsContainer } from './SelectInputOptionsContainer';
+export type { SelectInputOptionsContainerProps } from './SelectInputOptionsContainer';

package/src/inputs/SelectInput/Options/SelectInputOptions.css

@@ -0,0 +1,81 @@
+.np-select-input-options-container {
+  display: flex;
+  height: 100%;
+  flex-direction: column;
+}
+.np-select-input-options-container:focus {
+  outline: none;
+}
+@media (min-width: 576px) {
+  .np-select-input-options-container {
+    max-height: 28rem /* 448px */;
+  }
+}
+.np-select-input-options-status {
+  display: flex;
+  align-items: center;
+  -moz-column-gap: 8px;
+       column-gap: 8px;
+  -moz-column-gap: var(--size-8);
+       column-gap: var(--size-8);
+  padding: 8px 24px 0px;
+  padding: var(--size-8) var(--size-24) 0px;
+}
+.np-select-input-options-status-icon {
+  padding: 0 4px;
+  padding: 0 var(--size-4);
+  color: #768e9c;
+  color: var(--color-content-tertiary);
+}
+.np-select-input-query-container {
+  display: flex;
+  flex-direction: column;
+  padding: 8px;
+  padding: var(--size-8);
+}
+.np-select-input-listbox-container {
+  position: relative;
+  height: var(--initial-height);
+  scroll-padding-top: 8px;
+  scroll-padding-top: var(--size-8);
+  scroll-padding-bottom: 8px;
+  scroll-padding-bottom: var(--size-8);
+  overflow-y: auto;
+}
+@media (min-width: 576px) {
+  .np-select-input-listbox-container {
+    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);
+}
+.np-select-input-listbox {
+  border-radius: 10px;
+  border-radius: var(--radius-small);
+  padding: 8px;
+  padding: var(--size-8);
+  --ring-outline-offset: calc(-1 * var(--ring-outline-width));
+}
+.np-select-input-listbox:focus {
+  outline: none;
+}
+.np-select-input-listbox:focus-visible {
+  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-footer {
+  padding: 4px 24px 16px;
+  padding: var(--size-4) var(--size-24) var(--size-16);
+}

package/src/inputs/SelectInput/Options/SelectInputOptions.less

@@ -0,0 +1,77 @@
+@import (reference) "../../../../node_modules/@transferwise/neptune-css/src/less/ring.less";
+
+.np-select-input-options-container {
+  display: flex;
+  height: 100%;
+  flex-direction: column;
+
+  &:focus {
+    outline: none;
+  }
+
+  @media (--screen-sm) {
+    & {
+      max-height: 28rem /* 448px */;
+    }
+  }
+}
+
+.np-select-input-options-status {
+  display: flex;
+  align-items: center;
+  column-gap: var(--size-8);
+  padding: var(--size-8) var(--size-24) 0px;
+}
+
+.np-select-input-options-status-icon {
+  padding: 0 var(--size-4);
+  color: var(--color-content-tertiary);
+}
+
+.np-select-input-query-container {
+  display: flex;
+  flex-direction: column;
+  padding: var(--size-8);
+}
+
+.np-select-input-listbox-container {
+  position: relative;
+  height: var(--initial-height);
+  scroll-padding-top: var(--size-8);
+  scroll-padding-bottom: var(--size-8);
+  overflow-y: auto;
+
+  @media (--screen-sm) {
+    & {
+      height: auto;
+    }
+  }
+
+  &--virtualized {
+    /* The wrapping element shrinks this as needed */
+    height: 100vh;
+  }
+
+  &--has-group {
+    scroll-padding-top: var(--size-32);
+  }
+}
+
+.np-select-input-listbox {
+  border-radius: var(--radius-small);
+  padding: var(--size-8);
+
+  .focus-ring();
+  --ring-outline-offset: calc(-1 * var(--ring-outline-width));
+
+  .np-select-input-listbox-container--virtualized & {
+    /* 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-footer {
+  padding: var(--size-4) var(--size-24) var(--size-16);
+}

package/src/inputs/SelectInput/Options/SelectInputOptions.tsx

@@ -0,0 +1,411 @@
+import { CrossCircle } from '@transferwise/icons';
+import { ListboxOptions } from '@headlessui/react';
+import { clsx } from 'clsx';
+import { useEffect, useId, useMemo, useRef, useState } from 'react';
+import { useIntl } from 'react-intl';
+import { Virtualizer, type VirtualizerHandle } from 'virtua';
+
+import { SearchInput } from '../../SearchInput';
+import {
+  SelectInputItemsCountContext,
+  SelectInputItemPositionContext,
+} from '../SelectInput.contexts';
+import {
+  dedupeSelectInputItems,
+  filterSelectInputItems,
+  MAX_ITEMS_WITHOUT_VIRTUALIZATION,
+  searchableString,
+  selectInputOptionItemIncludesNeedle,
+  sortSelectInputItems,
+} from '../SelectInput.utils';
+import { SelectInputOptionItem, SelectInputProps, SelectInputItem } from '../SelectInput.types';
+import messages from '../SelectInput.messages';
+
+import { SelectInputItemView } from '../ItemView';
+import { SelectInputOptionsContainer } from './OptionsContainer';
+
+/**
+ * Props for the SelectInputOptions component.
+ */
+export interface SelectInputOptionsProps<T = string> extends Pick<
+  SelectInputProps<T>,
+  | 'items'
+  | 'renderValue'
+  | 'renderFooter'
+  | 'filterable'
+  | 'filterPlaceholder'
+  | 'id'
+  | 'parentId'
+  | 'compareValues'
+  | 'sortFilteredOptions'
+> {
+  searchInputRef: React.MutableRefObject<HTMLInputElement | null>;
+  listboxRef: React.MutableRefObject<HTMLDivElement | null>;
+  filterQuery: string;
+  onFilterChange: (query: string) => void;
+  listBoxLabel?: string;
+  listBoxLabelledBy?: string;
+  autocomplete?: string;
+  name?: string;
+  onAutocompleteSelect?: (value: T) => void;
+}
+
+/**
+ * The main options container component for SelectInput.
+ * Manages filtering, virtualisation, and rendering of options.
+ */
+export function SelectInputOptions<T = string>({
+  id,
+  parentId,
+  items,
+  compareValues: compareValuesProp,
+  renderValue = String,
+  renderFooter,
+  filterable = false,
+  filterPlaceholder,
+  sortFilteredOptions,
+  searchInputRef,
+  listboxRef,
+  filterQuery,
+  onFilterChange,
+  listBoxLabel,
+  listBoxLabelledBy,
+  autocomplete,
+  name,
+  onAutocompleteSelect,
+}: SelectInputOptionsProps<T>) {
+  const intl = useIntl();
+  const virtualiserHandlerRef = useRef<VirtualizerHandle>(null);
+  const controllerRef = filterable ? searchInputRef : listboxRef;
+  const [initialRender, setInitialRender] = useState(true);
+
+  const needle = useMemo(() => {
+    if (filterable) {
+      return filterQuery ? searchableString(filterQuery) : null;
+    }
+    return undefined;
+  }, [filterQuery, filterable]);
+  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 compareValues = useMemo(() => {
+    if (!compareValuesProp) {
+      return undefined;
+    }
+
+    if (typeof compareValuesProp === 'function') {
+      return (a: NonNullable<T>, b: NonNullable<T>) => compareValuesProp(a, b);
+    }
+
+    const key = compareValuesProp;
+    return (a: NonNullable<T>, b: NonNullable<T>) => {
+      if (typeof a === 'object' && a != null && typeof b === 'object' && b != null) {
+        return (a as Record<string, unknown>)[key] === (b as Record<string, unknown>)[key];
+      }
+      return a === b;
+    };
+  }, [compareValuesProp]);
+
+  const filteredItems: readonly SelectInputItem<NonNullable<T> | undefined>[] = useMemo(() => {
+    if (needle == null) {
+      return items;
+    }
+
+    const dedupedItems = dedupeSelectInputItems(items, compareValues);
+
+    if (sortFilteredOptions) {
+      // When sorting, filter out non-matching items completely to avoid ghost items
+      const filtered = dedupedItems.map((item) => {
+        if (item.type === 'option') {
+          return selectInputOptionItemIncludesNeedle(item, needle)
+            ? item
+            : { ...item, value: undefined };
+        }
+        if (item.type === 'group') {
+          return {
+            ...item,
+            options: item.options.map((option) =>
+              selectInputOptionItemIncludesNeedle(option, needle)
+                ? option
+                : { ...option, value: undefined },
+            ),
+          };
+        }
+        return item;
+      });
+
+      return sortSelectInputItems(filtered, sortFilteredOptions, filterQuery);
+    }
+
+    return filterSelectInputItems(dedupedItems, (item) =>
+      selectInputOptionItemIncludesNeedle(item, needle),
+    );
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [needle, items, compareValues]);
+  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[]>([]);
+  const prevNeedleRef = useRef(needle);
+
+  useEffect(() => {
+    const needleChanged = prevNeedleRef.current !== needle;
+    prevNeedleRef.current = needle;
+
+    if (needleChanged) {
+      // Reset mounted indexes when search changes to avoid stale scroll positions
+      setMountedIndexes([]);
+      return;
+    }
+
+    // Ensure the 'End' key works as intended by keeping the last item mounted.
+    // Skipped on needle change to prevent auto-scrolling on search.
+    if (filteredItems.length > 0) {
+      setMountedIndexes((prevMountedIndexes) => {
+        // Create a new array with existing indexes plus the last item index
+        return [...new Set([...prevMountedIndexes, filteredItems.length - 1])]; // Sorting is redundant by nature here
+      });
+    }
+  }, [needle, filteredItems.length]);
+
+  const listboxContainerRef = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    if (listboxContainerRef.current != null) {
+      listboxContainerRef.current.style.setProperty(
+        '--initial-height',
+        `${listboxContainerRef.current.offsetHeight}px`,
+      );
+    }
+  }, []);
+
+  useEffect(() => {
+    setInitialRender(false);
+  }, []);
+
+  const showStatus = resultsEmpty;
+  const statusId = useId();
+  const listboxId = useId();
+
+  const getItemNode = (index: number) => {
+    const item = filteredItems[index];
+    return (
+      <SelectInputItemView key={index} item={item} renderValue={renderValue} needle={needle} />
+    );
+  };
+
+  const findMatchingItem = (autocompleteValue: string): T | null => {
+    const flatOptions = items
+      .flatMap((item) =>
+        item.type === 'group' ? item.options : item.type === 'option' ? [item] : [],
+      )
+      .filter(
+        (item): item is SelectInputOptionItem<NonNullable<T>> =>
+          item.type === 'option' && item.value != null,
+      );
+
+    const exactMatch = flatOptions.find(
+      (option) =>
+        String(option.value) === autocompleteValue ||
+        option.filterMatchers?.some((matcher) => matcher === autocompleteValue),
+    );
+
+    if (exactMatch) {
+      return exactMatch.value;
+    }
+
+    const fuzzyMatch = flatOptions.find((option) =>
+      option.filterMatchers?.some((matcher) =>
+        matcher.toLowerCase().includes(autocompleteValue.toLowerCase()),
+      ),
+    );
+
+    return fuzzyMatch ? fuzzyMatch.value : null;
+  };
+
+  return (
+    <ListboxOptions
+      modal
+      as={SelectInputOptionsContainer}
+      static
+      className="np-select-input-options-container"
+      onAriaActiveDescendantChange={(value: React.AriaAttributes['aria-activedescendant']) => {
+        if (controllerRef.current != null) {
+          if (!initialRender && value != null) {
+            controllerRef.current.setAttribute('aria-activedescendant', value);
+          } else {
+            controllerRef.current.removeAttribute('aria-activedescendant');
+          }
+        }
+      }}
+    >
+      {filterable ? (
+        <div className="np-select-input-query-container">
+          <SearchInput
+            ref={searchInputRef}
+            id={id}
+            name={name}
+            autoComplete={autocomplete}
+            role="combobox"
+            shape="rectangle"
+            placeholder={filterPlaceholder}
+            aria-label={filterPlaceholder}
+            defaultValue={filterQuery}
+            aria-autocomplete="list"
+            aria-expanded
+            aria-controls={listboxId}
+            aria-describedby={showStatus ? statusId : undefined}
+            onKeyDown={(event: React.KeyboardEvent<HTMLInputElement>) => {
+              // Prevent interfering with the matcher of Headless UI
+              // https://mathiasbynens.be/notes/javascript-unicode#regex
+              if (/^.$/u.test(event.key)) {
+                event.stopPropagation();
+              }
+            }}
+            onChange={(event) => {
+              // Free up resources and ensure not to go out of bounds when the
+              // resulting item count is less than before
+              const inputValue = event.currentTarget.value;
+
+              // Free up resources and ensure not to go out of bounds
+              setMountedIndexes([]);
+              onFilterChange(inputValue);
+            }}
+            onInput={(event) => {
+              const inputValue = event.currentTarget.value;
+              const inputElement = event.currentTarget;
+
+              if (autocomplete && onAutocompleteSelect && inputValue) {
+                setTimeout(() => {
+                  if (inputElement.value === inputValue && inputValue.length > 2) {
+                    const matchedValue = findMatchingItem(inputValue);
+                    if (matchedValue !== null) {
+                      onAutocompleteSelect(matchedValue);
+                    }
+                  }
+                }, 50);
+              }
+            }}
+          />
+        </div>
+      ) : null}
+
+      <section
+        ref={listboxContainerRef}
+        tabIndex={-1}
+        className={clsx(
+          'np-select-input-listbox-container',
+          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',
+        )}
+        data-wds-parent={parentId ?? undefined}
+      >
+        {resultsEmpty ? (
+          <div id={statusId} className="np-select-input-options-status">
+            <CrossCircle size={16} className="np-select-input-options-status-icon" />
+            {intl.formatMessage(messages.noResultsFound)}
+          </div>
+        ) : null}
+
+        <div
+          ref={listboxRef}
+          id={listboxId}
+          role="listbox"
+          aria-orientation="vertical"
+          aria-label={listBoxLabel}
+          aria-labelledby={listBoxLabelledBy}
+          tabIndex={0}
+          className="np-select-input-listbox"
+        >
+          {!virtualized ? (
+            filteredItems.map((_, index) => getItemNode(index))
+          ) : (
+            <Virtualizer
+              ref={virtualiserHandlerRef}
+              data={filteredItems}
+              keepMounted={mountedIndexes}
+              scrollRef={listboxRef} // `VList` doesn't expose this
+              onScroll={async () => {
+                if (!virtualiserHandlerRef.current) return;
+
+                const startIndex = virtualiserHandlerRef.current.findItemIndex(
+                  virtualiserHandlerRef.current.scrollOffset,
+                );
+                const endIndex = virtualiserHandlerRef.current.findItemIndex(
+                  virtualiserHandlerRef.current.scrollOffset +
+                    virtualiserHandlerRef.current.viewportSize,
+                );
+
+                setMountedIndexes((prevMountedIndexes) => {
+                  // Create an array of all indexes that should be visible
+
+                  const visibleIndexes = [];
+                  for (let index = startIndex; index <= endIndex; index += 1) {
+                    // eslint-disable-next-line functional/immutable-data
+                    visibleIndexes.push(index);
+                  }
+
+                  // Combine with previous indexes and sort
+                  return [...new Set([...prevMountedIndexes, ...visibleIndexes])].sort(
+                    (a, b) => a - b,
+                  );
+                });
+              }}
+            >
+              {(item, 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 ? (
+          <footer className="np-select-input-footer">
+            <div
+              role="none"
+              onKeyDown={(event) => {
+                // Prevent interfering with Headless UI
+                if (event.key !== 'Escape') {
+                  event.stopPropagation();
+                }
+              }}
+            >
+              {renderFooter({
+                resultsEmpty,
+                queryNormalized: needle,
+              })}
+            </div>
+          </footer>
+        ) : null}
+      </section>
+    </ListboxOptions>
+  );
+}

package/src/inputs/SelectInput/Options/index.ts

@@ -0,0 +1,3 @@
+export { SelectInputOptions } from './SelectInputOptions';
+export type { SelectInputOptionsProps } from './SelectInputOptions';
+export * from './OptionsContainer';

package/src/inputs/SelectInput/Popover/SelectInputPopover.css

@@ -0,0 +1,46 @@
+.np-popover-v2-container {
+  z-index: 1060;
+  display: flex;
+  max-height: var(--max-height);
+  width: var(--width);
+  flex-direction: column;
+  overflow: hidden;
+  border-radius: 10px;
+  border-radius: var(--radius-small);
+  background-color: #ffffff;
+  background-color: var(--color-background-elevated);
+  box-shadow: 0 0 40px rgba(69, 71, 69, 0.2);
+}
+.np-popover-v2-container--size-md {
+  min-width: 20rem;
+}
+.np-popover-v2-container--size-lg {
+  min-width: 24rem;
+}
+.np-popover-v2-container:focus {
+  outline: none;
+}
+.np-popover-v2 {
+  display: grid;
+  grid-row-gap: 8px;
+  grid-row-gap: var(--size-8);
+  row-gap: 8px;
+  row-gap: var(--size-8);
+  overflow-y: auto;
+  grid-template-rows: minmax(0, 1fr);
+}
+.np-popover-v2--has-title {
+  grid-template-rows: auto minmax(0, 1fr);
+}
+.np-popover-v2--padding-md {
+  padding: 16px;
+  padding: var(--size-16);
+}
+.np-popover-v2-title {
+  color: #37517e;
+  color: var(--color-content-primary);
+}
+.np-popover-v2-content {
+  color: #5d7079;
+  color: var(--color-content-secondary);
+}