@navikt/ds-react 4.6.0 → 4.7.0

package/src/form/combobox/Input/Input.tsx

@@ -0,0 +1,170 @@
+import { omit } from "../../..";
+import React, {
+  useCallback,
+  forwardRef,
+  InputHTMLAttributes,
+  ChangeEvent,
+} from "react";
+import cl from "clsx";
+import { useSelectedOptionsContext } from "../SelectedOptions/selectedOptionsContext";
+import { useFilteredOptionsContext } from "../FilteredOptions/filteredOptionsContext";
+import { useInputContext } from "./inputContext";
+
+interface InputProps
+  extends Omit<InputHTMLAttributes<HTMLInputElement>, "value"> {
+  ref: React.Ref<HTMLInputElement>;
+  inputClassName?: string;
+  errorId?: string;
+  value?: string;
+  error?: React.ReactNode;
+}
+
+const Input = forwardRef<HTMLInputElement, InputProps>(
+  ({ inputClassName, error, errorId, ...rest }, ref) => {
+    const { clearInput, inputProps, onChange, size, value } = useInputContext();
+    const { selectedOptions, removeSelectedOption, toggleOption } =
+      useSelectedOptionsContext();
+    const {
+      activeDecendantId,
+      allowNewValues,
+      currentOption,
+      filteredOptions,
+      toggleIsListOpen,
+      isListOpen,
+      filteredOptionsIndex,
+      moveFocusUp,
+      moveFocusDown,
+      ariaDescribedBy,
+      moveFocusToInput,
+      moveFocusToEnd,
+      shouldAutocomplete,
+    } = useFilteredOptionsContext();
+
+    const onEnter = useCallback(
+      (event: React.KeyboardEvent) => {
+        if (currentOption) {
+          event.preventDefault();
+          // Selecting a value from the dropdown / FilteredOptions
+          toggleOption(currentOption, event);
+          clearInput(event);
+        } else if (shouldAutocomplete && selectedOptions.includes(value)) {
+          event.preventDefault();
+          // Trying to set the same value that is already set, so just clearing the input
+          clearInput(event);
+        } else if ((allowNewValues || shouldAutocomplete) && value !== "") {
+          event.preventDefault();
+          // Autocompleting or adding a new value
+          toggleOption(value, event);
+          clearInput(event);
+        }
+      },
+      [
+        allowNewValues,
+        clearInput,
+        currentOption,
+        selectedOptions,
+        shouldAutocomplete,
+        toggleOption,
+        value,
+      ]
+    );
+
+    const handleKeyUp = (e: React.KeyboardEvent<HTMLInputElement>) => {
+      e.preventDefault();
+      switch (e.key) {
+        case "Escape":
+          clearInput(e);
+          toggleIsListOpen(false);
+          break;
+        case "Enter":
+        case "Accept":
+          onEnter(e);
+          break;
+        case "Home":
+          moveFocusToInput();
+          break;
+        case "End":
+          moveFocusToEnd();
+          break;
+        default:
+          break;
+      }
+    };
+
+    const handleKeyDown = useCallback(
+      (e) => {
+        if (e.key === "Backspace") {
+          if (value === "") {
+            const lastSelectedOption =
+              selectedOptions[selectedOptions.length - 1];
+            removeSelectedOption(lastSelectedOption);
+          }
+        } else if (e.key === "ArrowDown") {
+          // Check that cursor position is at the end of the input field,
+          // so we don't interfere with text editing
+          if (e.target.selectionStart === value?.length) {
+            e.preventDefault();
+            moveFocusDown();
+          }
+        } else if (e.key === "ArrowUp") {
+          // Check that the FilteredOptions list is open and has virtual focus.
+          // Otherwise ignore keystrokes, so it doesn't interfere with text editing
+          if (isListOpen && filteredOptionsIndex !== null) {
+            e.preventDefault();
+            moveFocusUp();
+          }
+        }
+      },
+      [
+        value,
+        selectedOptions,
+        removeSelectedOption,
+        moveFocusDown,
+        isListOpen,
+        filteredOptionsIndex,
+        moveFocusUp,
+      ]
+    );
+
+    const onChangeHandler = useCallback(
+      (event: ChangeEvent<HTMLInputElement>) => {
+        const newValue = event.target.value;
+        if (newValue && newValue !== "") {
+          toggleIsListOpen(true);
+        } else if (filteredOptions.length === 0) {
+          toggleIsListOpen(false);
+        }
+        onChange(event);
+      },
+      [filteredOptions.length, onChange, toggleIsListOpen]
+    );
+
+    return (
+      <input
+        {...rest}
+        {...omit(inputProps, ["aria-invalid"])}
+        ref={ref}
+        value={value}
+        onChange={onChangeHandler}
+        type="text"
+        role="combobox"
+        onKeyUp={handleKeyUp}
+        onKeyDown={handleKeyDown}
+        aria-controls={`${inputProps.id}-filtered-options`}
+        aria-expanded={!!isListOpen}
+        autoComplete="off"
+        aria-autocomplete={shouldAutocomplete ? "both" : "list"}
+        aria-activedescendant={activeDecendantId}
+        aria-describedby={ariaDescribedBy}
+        className={cl(
+          inputClassName,
+          "navds-combobox__input",
+          "navds-body-short",
+          `navds-body-${size}`
+        )}
+      />
+    );
+  }
+);
+
+export default Input;

package/src/form/combobox/Input/inputContext.tsx

@@ -0,0 +1,127 @@
+import React, {
+  ChangeEvent,
+  ChangeEventHandler,
+  createContext,
+  useCallback,
+  useContext,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+import { useFormField, FormFieldType } from "../../useFormField";
+
+interface InputContextType extends FormFieldType {
+  clearInput: (event: React.PointerEvent | React.KeyboardEvent) => void;
+  focusInput: () => void;
+  inputRef: React.RefObject<HTMLInputElement>;
+  value: string;
+  setValue: (text: string) => void;
+  onChange: ChangeEventHandler<HTMLInputElement>;
+  searchTerm: string;
+  setSearchTerm: React.Dispatch<React.SetStateAction<string>>;
+  shouldAutocomplete?: boolean;
+}
+
+const InputContext = createContext<InputContextType>({} as InputContextType);
+
+export const InputContextProvider = ({ children, value: props }) => {
+  const {
+    defaultValue = "",
+    description,
+    disabled,
+    error,
+    errorId,
+    id: externalId,
+    value: externalValue,
+    onChange: externalOnChange,
+    onClear,
+    shouldAutocomplete,
+    size,
+  } = props;
+  const formFieldProps = useFormField(
+    {
+      description,
+      disabled,
+      error,
+      errorId,
+      id: externalId,
+      size,
+    },
+    "comboboxfield"
+  );
+  const inputRef = useRef<HTMLInputElement | null>(null);
+  const [internalValue, setInternalValue] = useState<string>(defaultValue);
+
+  const value = useMemo(
+    () => String(externalValue ?? internalValue),
+    [externalValue, internalValue]
+  );
+
+  const [searchTerm, setSearchTerm] = useState(value);
+
+  const onChange = useCallback(
+    (event: ChangeEvent<HTMLInputElement>) => {
+      const value = event.currentTarget.value;
+      externalValue ?? setInternalValue(value);
+      externalOnChange?.(event);
+      setSearchTerm(value);
+    },
+    [externalValue, externalOnChange]
+  );
+
+  const setValue = useCallback(
+    (text) => {
+      setInternalValue(text);
+    },
+    [setInternalValue]
+  );
+
+  const clearInput = useCallback(
+    (event: React.PointerEvent | React.KeyboardEvent) => {
+      onClear?.(event);
+      setValue("");
+      setSearchTerm("");
+    },
+    [onClear, setSearchTerm, setValue]
+  );
+
+  const focusInput = useCallback(() => {
+    inputRef.current?.focus?.();
+  }, []);
+
+  useLayoutEffect(() => {
+    if (shouldAutocomplete && inputRef && value !== searchTerm) {
+      inputRef.current?.setSelectionRange?.(searchTerm.length, value.length);
+    }
+  }, [value, searchTerm, shouldAutocomplete]);
+
+  return (
+    <InputContext.Provider
+      value={{
+        ...formFieldProps,
+        clearInput,
+        focusInput,
+        inputRef,
+        value,
+        setValue,
+        onChange,
+        searchTerm,
+        setSearchTerm,
+        shouldAutocomplete,
+      }}
+    >
+      {children}
+    </InputContext.Provider>
+  );
+};
+
+export const useInputContext = () => {
+  const context = useContext(InputContext);
+  if (!context) {
+    throw new Error(
+      "useInputContext must be used within an InputContextProvider"
+    );
+  }
+  return context;
+};

package/src/form/combobox/SelectedOptions/SelectedOptions.tsx

@@ -0,0 +1,45 @@
+import React from "react";
+import { Chips } from "../../..";
+import { useSelectedOptionsContext } from "./selectedOptionsContext";
+
+interface SelectedOptionsProps {
+  selectedOptions?: string[];
+  size?: "medium" | "small";
+  children: React.ReactNode;
+}
+
+const Option = ({ option }: { option: string }) => {
+  const { isMultiSelect, removeSelectedOption } = useSelectedOptionsContext();
+
+  const onClick = (e) => {
+    e.stopPropagation();
+    removeSelectedOption(option);
+  };
+
+  if (!isMultiSelect) {
+    return (
+      <div className="navds-combobox__selected-options--no-bg">{option}</div>
+    );
+  }
+
+  return <Chips.Removable onClick={onClick}>{option}</Chips.Removable>;
+};
+
+const SelectedOptions: React.FC<SelectedOptionsProps> = ({
+  selectedOptions = [],
+  size,
+  children,
+}) => {
+  return (
+    <Chips className="navds-combobox__selected-options" size={size}>
+      {selectedOptions.length
+        ? selectedOptions.map((option, i) => (
+            <Option key={option + i} option={option} />
+          ))
+        : []}
+      {children}
+    </Chips>
+  );
+};
+
+export default SelectedOptions;

package/src/form/combobox/SelectedOptions/selectedOptionsContext.tsx

@@ -0,0 +1,147 @@
+import React, {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useState,
+} from "react";
+import usePrevious from "../../../util/usePrevious";
+import { useInputContext } from "../Input/inputContext";
+import { ComboboxProps } from "../types";
+import { useCustomOptionsContext } from "../customOptionsContext";
+
+type SelectedOptionsContextType = {
+  addSelectedOption: (option: string) => void;
+  isMultiSelect?: boolean;
+  removeSelectedOption: (option: string) => void;
+  prevSelectedOptions?: string[];
+  selectedOptions: string[];
+  setSelectedOptions: (any) => void;
+  toggleOption: (
+    option: string,
+    event: React.KeyboardEvent | React.PointerEvent
+  ) => void;
+};
+
+const SelectedOptionsContext = createContext<SelectedOptionsContextType>(
+  {} as SelectedOptionsContextType
+);
+
+export const SelectedOptionsProvider = ({
+  children,
+  value,
+}: {
+  children: any;
+  value: Pick<
+    ComboboxProps,
+    | "allowNewValues"
+    | "isMultiSelect"
+    | "options"
+    | "selectedOptions"
+    | "onToggleSelected"
+  >;
+}) => {
+  const { clearInput, focusInput } = useInputContext();
+  const { customOptions, removeCustomOption, addCustomOption } =
+    useCustomOptionsContext();
+  const {
+    allowNewValues,
+    isMultiSelect,
+    selectedOptions: externalSelectedOptions,
+    onToggleSelected,
+    options,
+  } = value;
+  const [internalSelectedOptions, setSelectedOptions] = useState<string[]>([]);
+  const selectedOptions = useMemo(
+    () =>
+      externalSelectedOptions ?? [...customOptions, ...internalSelectedOptions],
+    [customOptions, externalSelectedOptions, internalSelectedOptions]
+  );
+
+  const addSelectedOption = useCallback(
+    (option: string) => {
+      if (
+        !options
+          .map((opt) => opt.toLowerCase())
+          .includes(option?.toLowerCase?.())
+      ) {
+        allowNewValues && addCustomOption(option);
+      } else if (isMultiSelect) {
+        setSelectedOptions((prevSelectedOptions) => [
+          ...prevSelectedOptions,
+          option,
+        ]);
+      } else {
+        setSelectedOptions([option]);
+      }
+      onToggleSelected?.(option, true);
+    },
+    [addCustomOption, allowNewValues, isMultiSelect, onToggleSelected, options]
+  );
+
+  const removeSelectedOption = useCallback(
+    (option: string) => {
+      if (customOptions.includes(option)) {
+        removeCustomOption(option);
+      } else {
+        setSelectedOptions((prevSelectedOptions) =>
+          prevSelectedOptions.filter(
+            (selectedOption) => selectedOption !== option
+          )
+        );
+      }
+      onToggleSelected?.(option, false);
+    },
+    [customOptions, onToggleSelected, removeCustomOption]
+  );
+
+  const toggleOption = useCallback(
+    (option: string, event: React.KeyboardEvent | React.PointerEvent) => {
+      if (selectedOptions.includes(option)) {
+        removeSelectedOption(option);
+      } else {
+        addSelectedOption(option);
+      }
+      if (!isMultiSelect) {
+        clearInput(event);
+      }
+      focusInput();
+    },
+    [
+      addSelectedOption,
+      clearInput,
+      focusInput,
+      isMultiSelect,
+      removeSelectedOption,
+      selectedOptions,
+    ]
+  );
+
+  const prevSelectedOptions = usePrevious<string[]>(selectedOptions);
+
+  const selectedOptionsState = {
+    addSelectedOption,
+    isMultiSelect,
+    removeSelectedOption,
+    prevSelectedOptions,
+    selectedOptions,
+    setSelectedOptions,
+    toggleOption,
+  };
+
+  return (
+    <SelectedOptionsContext.Provider value={selectedOptionsState}>
+      {children}
+    </SelectedOptionsContext.Provider>
+  );
+};
+
+export const useSelectedOptionsContext = () => {
+  const context = useContext(SelectedOptionsContext);
+  if (!context) {
+    throw new Error(
+      "useSelectedOptionsContext must be used within a SelectedOptionsProvider"
+    );
+  }
+  return context;
+};

package/src/form/combobox/ToggleListButton.tsx

@@ -0,0 +1,37 @@
+import React, { forwardRef } from "react";
+import { ChevronUpIcon, ChevronDownIcon } from "@navikt/aksel-icons";
+
+import { useFilteredOptionsContext } from "./FilteredOptions/filteredOptionsContext";
+
+interface ToggleListButtonProps {
+  toggleListButtonLabel?: string;
+}
+
+export const ToggleListButton = forwardRef<
+  HTMLButtonElement,
+  ToggleListButtonProps
+>(({ toggleListButtonLabel }, ref) => {
+  const { isListOpen, toggleIsListOpen } = useFilteredOptionsContext();
+  return (
+    <button
+      type="button"
+      onPointerUp={() => toggleIsListOpen()}
+      onKeyDown={({ key }) => key === "Enter" && toggleIsListOpen()}
+      className="navds-combobox__button-toggle-list"
+      aria-expanded={isListOpen}
+      tabIndex={-1}
+      ref={ref}
+    >
+      <span className="navds-sr-only">
+        {toggleListButtonLabel ?? "Alternativer"}
+      </span>
+      {isListOpen ? (
+        <ChevronUpIcon aria-hidden />
+      ) : (
+        <ChevronDownIcon aria-hidden />
+      )}
+    </button>
+  );
+});
+
+export default ToggleListButton;