@navikt/ds-react 6.2.0 → 6.3.0

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

@@ -43,17 +43,17 @@ const Input = forwardRef<HTMLInputElement, InputProps>(
 
     const onEnter = useCallback(
       (event: React.KeyboardEvent) => {
-        const isTextInSelectedOptions = (text: string) => {
-          return selectedOptions.find(
-            (item) => item.toLocaleLowerCase() === text.toLocaleLowerCase(),
+        const isTextInSelectedOptions = (text: string) =>
+          selectedOptions.some(
+            (option) =>
+              option.label.toLocaleLowerCase() === text.toLocaleLowerCase(),
           );
-        };
 
         if (currentOption) {
           event.preventDefault();
           // Selecting a value from the dropdown / FilteredOptions
           toggleOption(currentOption, event);
-          if (!isMultiSelect && !isTextInSelectedOptions(currentOption)) {
+          if (!isMultiSelect && !isTextInSelectedOptions(currentOption.label)) {
             toggleIsListOpen(false);
           }
         } else if (shouldAutocomplete && isTextInSelectedOptions(value)) {
@@ -64,11 +64,15 @@ const Input = forwardRef<HTMLInputElement, InputProps>(
           event.preventDefault();
           // Autocompleting or adding a new value
           const selectedValue =
-            allowNewValues && isValueNew ? value : filteredOptions[0];
+            allowNewValues && isValueNew
+              ? { label: value, value }
+              : filteredOptions[0];
           toggleOption(selectedValue, event);
           if (
             !isMultiSelect &&
-            !isTextInSelectedOptions(filteredOptions[0] || selectedValue)
+            !isTextInSelectedOptions(
+              filteredOptions[0].label || selectedValue.label,
+            )
           ) {
             toggleIsListOpen(false);
           }
@@ -120,7 +124,9 @@ const Input = forwardRef<HTMLInputElement, InputProps>(
           if (value === "") {
             const lastSelectedOption =
               selectedOptions[selectedOptions.length - 1];
-            removeSelectedOption(lastSelectedOption);
+            if (lastSelectedOption) {
+              removeSelectedOption(lastSelectedOption);
+            }
           }
         } else if (e.key === "ArrowDown") {
           // Check that cursor position is at the end of the input field,

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

@@ -1,15 +1,16 @@
 import React from "react";
 import { Chips } from "../../../chips";
 import { useInputContext } from "../Input/inputContext";
+import { ComboboxOption } from "../types";
 import { useSelectedOptionsContext } from "./selectedOptionsContext";
 
 interface SelectedOptionsProps {
-  selectedOptions?: string[];
+  selectedOptions?: ComboboxOption[];
   size?: "medium" | "small";
   children: React.ReactNode;
 }
 
-const Option = ({ option }: { option: string }) => {
+const Option = ({ option }: { option: ComboboxOption }) => {
   const { isMultiSelect, removeSelectedOption } = useSelectedOptionsContext();
   const { focusInput } = useInputContext();
 
@@ -21,11 +22,13 @@ const Option = ({ option }: { option: string }) => {
 
   if (!isMultiSelect) {
     return (
-      <div className="navds-combobox__selected-options--no-bg">{option}</div>
+      <div className="navds-combobox__selected-options--no-bg">
+        {option.label}
+      </div>
     );
   }
 
-  return <Chips.Removable onClick={onClick}>{option}</Chips.Removable>;
+  return <Chips.Removable onClick={onClick}>{option.label}</Chips.Removable>;
 };
 
 const SelectedOptions: React.FC<SelectedOptionsProps> = ({
@@ -37,7 +40,7 @@ const SelectedOptions: React.FC<SelectedOptionsProps> = ({
     <Chips className="navds-combobox__selected-options" size={size}>
       {selectedOptions.length
         ? selectedOptions.map((option, i) => (
-            <Option key={option + i} option={option} />
+            <Option key={option.label + i} option={option} />
           ))
         : []}
       {children}

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

@@ -7,19 +7,20 @@ import React, {
 } from "react";
 import { usePrevious } from "../../../util/hooks";
 import { useInputContext } from "../Input/inputContext";
+import { isInList } from "../combobox-utils";
 import { useCustomOptionsContext } from "../customOptionsContext";
-import { ComboboxProps, MaxSelected } from "../types";
+import { ComboboxOption, ComboboxProps, MaxSelected } from "../types";
 
 type SelectedOptionsContextType = {
-  addSelectedOption: (option: string) => void;
+  addSelectedOption: (option: ComboboxOption) => void;
   isMultiSelect?: boolean;
-  removeSelectedOption: (option: string) => void;
-  prevSelectedOptions?: string[];
-  selectedOptions: string[];
+  removeSelectedOption: (option: ComboboxOption) => void;
+  prevSelectedOptions?: ComboboxOption[];
+  selectedOptions: ComboboxOption[];
   maxSelected?: MaxSelected & { isLimitReached: boolean };
   setSelectedOptions: (any) => void;
   toggleOption: (
-    option: string,
+    option: ComboboxOption,
     event: React.KeyboardEvent | React.PointerEvent,
   ) => void;
 };
@@ -35,13 +36,8 @@ export const SelectedOptionsProvider = ({
   children: any;
   value: Pick<
     ComboboxProps,
-    | "allowNewValues"
-    | "isMultiSelect"
-    | "options"
-    | "selectedOptions"
-    | "onToggleSelected"
-    | "maxSelected"
-  >;
+    "allowNewValues" | "isMultiSelect" | "onToggleSelected" | "maxSelected"
+  > & { options: ComboboxOption[]; selectedOptions?: ComboboxOption[] };
 }) => {
   const { clearInput, focusInput } = useInputContext();
   const {
@@ -58,7 +54,9 @@ export const SelectedOptionsProvider = ({
     options,
     maxSelected,
   } = value;
-  const [internalSelectedOptions, setSelectedOptions] = useState<string[]>([]);
+  const [internalSelectedOptions, setSelectedOptions] = useState<
+    ComboboxOption[]
+  >([]);
   const selectedOptions = useMemo(
     () =>
       externalSelectedOptions ?? [...customOptions, ...internalSelectedOptions],
@@ -66,10 +64,8 @@ export const SelectedOptionsProvider = ({
   );
 
   const addSelectedOption = useCallback(
-    (option: string) => {
-      const isCustomOption = !options
-        .map((opt) => opt.toLowerCase())
-        .includes(option?.toLowerCase?.());
+    (option: ComboboxOption) => {
+      const isCustomOption = !isInList(option, options);
       if (isCustomOption) {
         allowNewValues && addCustomOption(option);
         !isMultiSelect && setSelectedOptions([]);
@@ -82,7 +78,7 @@ export const SelectedOptionsProvider = ({
         setSelectedOptions([option]);
         setCustomOptions([]);
       }
-      onToggleSelected?.(option, true, isCustomOption);
+      onToggleSelected?.(option.value, true, isCustomOption);
     },
     [
       addCustomOption,
@@ -95,8 +91,8 @@ export const SelectedOptionsProvider = ({
   );
 
   const removeSelectedOption = useCallback(
-    (option: string) => {
-      const isCustomOption = customOptions.includes(option);
+    (option: ComboboxOption) => {
+      const isCustomOption = isInList(option, customOptions);
       if (isCustomOption) {
         removeCustomOption(option);
       } else {
@@ -106,14 +102,17 @@ export const SelectedOptionsProvider = ({
           ),
         );
       }
-      onToggleSelected?.(option, false, isCustomOption);
+      onToggleSelected?.(option.value, false, isCustomOption);
     },
     [customOptions, onToggleSelected, removeCustomOption],
   );
 
   const toggleOption = useCallback(
-    (option: string, event: React.KeyboardEvent | React.PointerEvent) => {
-      if (selectedOptions.includes(option)) {
+    (
+      option: ComboboxOption,
+      event: React.KeyboardEvent | React.PointerEvent,
+    ) => {
+      if (isInList(option.value, selectedOptions)) {
         removeSelectedOption(option);
       } else {
         addSelectedOption(option);
@@ -130,7 +129,7 @@ export const SelectedOptionsProvider = ({
     ],
   );
 
-  const prevSelectedOptions = usePrevious<string[]>(selectedOptions);
+  const prevSelectedOptions = usePrevious<ComboboxOption[]>(selectedOptions);
 
   const isLimitReached =
     !!maxSelected?.limit && selectedOptions.length >= maxSelected.limit;

package/src/form/combobox/combobox-utils.test.ts

@@ -0,0 +1,67 @@
+import {
+  isInList,
+  mapToComboboxOptionArray,
+  toComboboxOption,
+} from "./combobox-utils";
+
+const list = [
+  { label: "Hjelpemidler", value: "HJE" },
+  { label: "Oppfølging", value: "OPP" },
+  { label: "Sykepenger", value: "SYK" },
+  { label: "Sykemelding", value: "SYM" },
+];
+
+describe("isInList", () => {
+  test("finds a string value in a list of ComboboxOptions", () => {
+    expect(isInList("Oppfølging", list)).toBe(true);
+    expect(isInList("SYM", list)).toBe(true);
+    expect(isInList("Arbeidsavklaringspenger", list)).toBe(false);
+    expect(isInList("AAP", list)).toBe(false);
+  });
+
+  test("finds a ComboboxOption in a list of ComboboxOptions", () => {
+    expect(isInList({ label: "Oppfølging", value: "OPP" }, list)).toBe(true);
+    expect(isInList({ label: "Sykemelding", value: "SYM" }, list)).toBe(true);
+    expect(
+      isInList({ label: "Arbeidsavklaringspenger", value: "AAP" }, list),
+    ).toBe(false);
+    expect(
+      isInList({ label: "Arbeidsavklaringspenger", value: "AAP" }, list),
+    ).toBe(false);
+  });
+
+  test("returns false for ComboboxOptions which do not match both label and value", () => {
+    expect(isInList({ label: "Oppfølging", value: "SYM" }, list)).toBe(false);
+    expect(isInList({ label: "Sykemelding", value: "OPP" }, list)).toBe(false);
+  });
+});
+
+describe("mapToComboboxOptionArray", () => {
+  test("maps an array of strings to an array of ComboboxOptions", () => {
+    const stringArray = ["Hjelpemidler", "Oppfølging", "Sykepenger"];
+    const comboboxOptions = [
+      { label: "Hjelpemidler", value: "Hjelpemidler" },
+      { label: "Oppfølging", value: "Oppfølging" },
+      { label: "Sykepenger", value: "Sykepenger" },
+    ];
+    expect(mapToComboboxOptionArray(stringArray)).toEqual(comboboxOptions);
+  });
+
+  test("does not change an array of ComboboxOptions", () => {
+    const comboboxOptions = [
+      { label: "Hjelpemidler", value: "Hjelpemidler" },
+      { label: "Oppfølging", value: "Oppfølging" },
+      { label: "Sykepenger", value: "Sykepenger" },
+    ];
+    expect(mapToComboboxOptionArray(comboboxOptions)).toEqual(comboboxOptions);
+  });
+});
+
+describe("toComboboxOption", () => {
+  test("creates a ComboboxOption from a string", () => {
+    expect(toComboboxOption("Hjelpemidler")).toEqual({
+      label: "Hjelpemidler",
+      value: "Hjelpemidler",
+    });
+  });
+});

package/src/form/combobox/combobox-utils.ts

@@ -0,0 +1,32 @@
+import { ComboboxOption } from "./types";
+
+/**
+ *
+ * @param option ComboboxOption will be compared by both label and value, while a string option is checked if it matches either the label or value in the list.
+ * @param list
+ */
+const isInList = (option: ComboboxOption | string, list: ComboboxOption[]) => {
+  if (typeof option === "string") {
+    return list.some(
+      (listItem) => listItem.label === option || listItem.value === option,
+    );
+  } else {
+    return list.some(
+      (listItem) =>
+        listItem.label === option.label && listItem.value === option.value,
+    );
+  }
+};
+
+const toComboboxOption = (value: string): ComboboxOption => ({
+  label: value,
+  value,
+});
+
+const mapToComboboxOptionArray = (options?: string[] | ComboboxOption[]) => {
+  return options?.map((option: string | ComboboxOption) =>
+    typeof option === "string" ? toComboboxOption(option) : option,
+  );
+};
+
+export { isInList, mapToComboboxOptionArray, toComboboxOption };

package/src/form/combobox/combobox.stories.tsx

@@ -1,6 +1,6 @@
 import { Meta, StoryFn, StoryObj } from "@storybook/react";
 import { expect, fn, userEvent, within } from "@storybook/test";
-import React, { useId, useMemo, useRef, useState } from "react";
+import React, { useMemo, useRef, useState } from "react";
 import { Chips } from "../../chips";
 import { TextField } from "../textfield";
 import { ComboboxProps, UNSAFE_Combobox } from "./index";
@@ -30,10 +30,10 @@ const options = [
   "grape fruit",
 ];
 
-export const Default: StoryFunction = (props) => {
-  const id = useId();
-  return <UNSAFE_Combobox {...props} id={id} />;
-};
+export const Default: StoryFunction = (props) => (
+  <UNSAFE_Combobox {...props} id="combobox" />
+);
+
 Default.args = {
   options,
   label: "Hva er dine favorittfrukter?",
@@ -57,10 +57,9 @@ Default.argTypes = {
 };
 
 export const MultiSelect: StoryFunction = (props) => {
-  const id = useId();
   return (
     <UNSAFE_Combobox
-      id={id}
+      id="combobox-with-multiselect"
       label="Komboboks - velg flere"
       options={props.options}
       isMultiSelect={props.isMultiSelect}
@@ -75,11 +74,55 @@ MultiSelect.args = {
   size: "medium",
 };
 
+export const MultiSelectWithComplexOptions: StoryFunction = (props) => {
+  const [selectedOptions, setSelectedOptions] = useState<string[]>([]);
+  return (
+    <>
+      <UNSAFE_Combobox
+        {...props}
+        options={props.options.map((option) => ({
+          ...option,
+          label: `${option.label} [${option.value}]`,
+        }))}
+        id="combobox-with-complex-options"
+        label="Velg temakoder"
+        allowNewValues
+        onToggleSelected={(value, isSelected) =>
+          isSelected
+            ? setSelectedOptions([...selectedOptions, value])
+            : setSelectedOptions(selectedOptions.filter((o) => o !== value))
+        }
+        selectedOptions={selectedOptions}
+      />
+    </>
+  );
+};
+
+MultiSelectWithComplexOptions.args = {
+  options: [
+    { label: "Hjelpemidler", value: "HJE" },
+    { label: "Oppfølging", value: "OPP" },
+    { label: "Sykepenger", value: "SYK" },
+    { label: "Sykemelding", value: "SYM" },
+    { label: "Foreldre- og svangerskapspenger", value: "FOR" },
+    { label: "Arbeidsavklaringspenger", value: "AAP" },
+    { label: "Uføretrygd", value: "UFO" },
+    { label: "Pensjon", value: "PEN" },
+    { label: "Barnetrygd", value: "BAR" },
+    { label: "Kontantstøtte", value: "KON" },
+    { label: "Bostøtte", value: "BOS" },
+    { label: "Barnebidrag", value: "BBI" },
+    { label: "Bidragsforskudd", value: "BIF" },
+    { label: "Grunn- og hjelpestønad", value: "GRU" },
+  ],
+  isMultiSelect: true,
+  size: "medium",
+};
+
 export const WithAddNewOptions: StoryFunction = (props) => {
-  const id = useId();
   return (
     <UNSAFE_Combobox
-      id={id}
+      id="combobox-with-add-new-options"
       label="Komboboks med mulighet for å legge til nye verdier"
       options={props.options}
       allowNewValues={props.allowNewValues}
@@ -95,10 +138,9 @@ WithAddNewOptions.args = {
 };
 
 export const MultiSelectWithAddNewOptions: StoryFunction = (props) => {
-  const id = useId();
   return (
     <UNSAFE_Combobox
-      id={id}
+      id="combobox-with-multiselect-and-add-new-options"
       isMultiSelect={props.isMultiSelect}
       label="Multiselect komboboks med mulighet for å legge til nye verdier"
       options={props.options}
@@ -120,7 +162,6 @@ export const MultiSelectWithExternalChips: StoryFn<{
 }> = (props) => {
   const [selectedOptions, setSelectedOptions] = useState<string[]>([]);
   const [value, setValue] = useState("");
-  const id = useId();
 
   const toggleSelected = (option: string) =>
     selectedOptions.includes(option)
@@ -142,6 +183,7 @@ export const MultiSelectWithExternalChips: StoryFn<{
         </Chips>
       )}
       <UNSAFE_Combobox
+        id="combobox-with-external-chips"
         options={props.options}
         selectedOptions={selectedOptions}
         onToggleSelected={(option) => toggleSelected(option)}
@@ -154,7 +196,6 @@ export const MultiSelectWithExternalChips: StoryFn<{
         }
         label="Komboboks"
         size="medium"
-        id={id}
         shouldShowSelectedOptions={false}
       />
     </>
@@ -166,19 +207,16 @@ MultiSelectWithExternalChips.args = {
   options,
 };
 
-export const Loading: StoryFunction = (props) => {
-  const id = useId();
-  return (
-    <UNSAFE_Combobox
-      id={id}
-      label="Komboboks (laster)"
-      options={[]}
-      selectedOptions={[]}
-      isListOpen={props.isListOpen}
-      isLoading={props.isLoading}
-    />
-  );
-};
+export const Loading: StoryFunction = (props) => (
+  <UNSAFE_Combobox
+    id="combobox-with-loading-indicator"
+    label="Komboboks (laster)"
+    options={[]}
+    selectedOptions={[]}
+    isListOpen={props.isListOpen}
+    isLoading={props.isLoading}
+  />
+);
 
 Loading.args = {
   isLoading: true,
@@ -186,11 +224,10 @@ Loading.args = {
 };
 
 export const ComboboxWithNoHits: StoryFunction = (props) => {
-  const id = useId();
   const [value, setValue] = useState(props.value);
   return (
     <UNSAFE_Combobox
-      id={id}
+      id="combobox-with-no-hits"
       label="Komboboks (uten søketreff)"
       options={props.options}
       value={value}
@@ -210,7 +247,6 @@ export const Controlled: StoryFn<{
   options: string[];
   initialSelectedOptions: string[];
 }> = (props) => {
-  const id = useId();
   const [value, setValue] = useState(props.value);
   const [selectedOptions, setSelectedOptions] = useState(
     props.initialSelectedOptions,
@@ -238,7 +274,7 @@ export const Controlled: StoryFn<{
       <br />
       <UNSAFE_Combobox
         label="Hva er dine favorittfrukter?"
-        id={id}
+        id="combobox-controlled"
         filteredOptions={filteredOptions}
         isMultiSelect
         options={props.options}
@@ -292,7 +328,6 @@ export const ComboboxSizes = () => (
 );
 
 export const MaxSelectedOptions: StoryFunction = () => {
-  const id = useId();
   const [value, setValue] = useState<string | undefined>("");
   const [selectedOptions, setSelectedOptions] = useState([
     options[0],
@@ -301,7 +336,7 @@ export const MaxSelectedOptions: StoryFunction = () => {
   const comboboxRef = useRef<HTMLInputElement>(null);
   return (
     <UNSAFE_Combobox
-      id={id}
+      id="combobox-with-max-selected-options"
       label="Komboboks med begrenset antall valg"
       options={options}
       maxSelected={{ limit: 2 }}

package/src/form/combobox/combobox.test.tsx

@@ -3,7 +3,7 @@ import { render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import React, { useId } from "react";
 import { act } from "react-dom/test-utils";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { UNSAFE_Combobox } from "./index";
 
 const options = [
@@ -123,4 +123,35 @@ describe("Combobox state-handling", () => {
       await screen.findByRole("option", { name: "banana" }),
     ).toBeInTheDocument();
   });
+
+  test("Should handle complex options with label and value", async () => {
+    const onToggleSelected = vi.fn();
+    render(
+      <App
+        options={[
+          { label: "Hjelpemidler [HJE]", value: "HJE" },
+          { label: "Oppfølging [OPP]", value: "OPP" },
+          { label: "Sykepenger [SYK]", value: "SYK" },
+          { label: "Sykemelding [SYM]", value: "SYM" },
+        ]}
+        onToggleSelected={onToggleSelected}
+      />,
+    );
+
+    expect(screen.getByRole("combobox")).toBeInTheDocument();
+    const bananaOption = screen.getByRole("option", {
+      name: "Hjelpemidler [HJE]",
+      selected: false,
+    });
+    await act(async () => {
+      await userEvent.click(bananaOption);
+    });
+    expect(onToggleSelected).toHaveBeenCalledWith("HJE", true, false);
+    expect(
+      screen.getByRole("option", {
+        name: "Hjelpemidler [HJE]",
+        selected: true,
+      }),
+    ).toBeInTheDocument();
+  });
 });

package/src/form/combobox/customOptionsContext.tsx

@@ -1,11 +1,12 @@
 import React, { createContext, useCallback, useContext, useState } from "react";
 import { useInputContext } from "./Input/inputContext";
+import { ComboboxOption } from "./types";
 
 type CustomOptionsContextType = {
-  customOptions: string[];
-  removeCustomOption: (option: string) => void;
-  addCustomOption: (option: string) => void;
-  setCustomOptions: React.Dispatch<React.SetStateAction<string[]>>;
+  customOptions: ComboboxOption[];
+  removeCustomOption: (option: ComboboxOption) => void;
+  addCustomOption: (option: ComboboxOption) => void;
+  setCustomOptions: React.Dispatch<React.SetStateAction<ComboboxOption[]>>;
 };
 
 const CustomOptionsContext = createContext<CustomOptionsContextType>(
@@ -19,14 +20,14 @@ export const CustomOptionsProvider = ({
   children: any;
   value: { isMultiSelect?: boolean };
 }) => {
-  const [customOptions, setCustomOptions] = useState<string[]>([]);
+  const [customOptions, setCustomOptions] = useState<ComboboxOption[]>([]);
   const { focusInput } = useInputContext();
   const { isMultiSelect } = value;
 
   const removeCustomOption = useCallback(
-    (option: string) => {
+    (option: ComboboxOption) => {
       setCustomOptions((prevCustomOptions) =>
-        prevCustomOptions.filter((o) => o !== option),
+        prevCustomOptions.filter((o) => o.label !== option.label),
       );
       focusInput();
     },
@@ -34,7 +35,7 @@ export const CustomOptionsProvider = ({
   );
 
   const addCustomOption = useCallback(
-    (option: string) => {
+    (option: ComboboxOption) => {
       if (isMultiSelect) {
         setCustomOptions((prevOptions) => [...prevOptions, option]);
       } else {

package/src/form/combobox/types.ts

@@ -1,6 +1,21 @@
 import React, { ChangeEvent, InputHTMLAttributes } from "react";
 import { FormFieldProps } from "../useFormField";
 
+/**
+ * A more complex version of options for the Combobox.
+ * Used for separating the label and the value of the option.
+ */
+export type ComboboxOption = {
+  /**
+   * The label to display in the dropdown list
+   */
+  label: string;
+  /**
+   * The programmatic value of the option, for use internally. Will be returned from onToggleSelected.
+   */
+  value: string;
+};
+
 export type MaxSelected = {
   /**
    * The limit for maximum selected options
@@ -20,9 +35,9 @@ export interface ComboboxProps
    */
   label: React.ReactNode;
   /**
-   * List of options to use for autocompletion.
+   * List of options
    */
-  options: string[];
+  options: string[] | ComboboxOption[];
   /**
    * If enabled, adds an option to add the value of the input as an option whenever there are no options matching the value.
    */
@@ -42,7 +57,7 @@ export interface ComboboxProps
    * If provided, this overrides the internal search logic in the component.
    * Useful for e.g. searching on a server or when overriding the search algorithm to search for synonyms or similar.
    */
-  filteredOptions?: string[];
+  filteredOptions?: string[] | ComboboxOption[];
   /**
    * Optionally hide the label visually.
    * Not recommended, but can be considered for e.g. search fields in the top menu.
@@ -75,7 +90,6 @@ export interface ComboboxProps
    * Callback function triggered whenever the value of the input field is triggered.
    *
    * @param event
-   * @returns
    */
   onChange?: (
     event: ChangeEvent<HTMLInputElement> | null,
@@ -85,19 +99,17 @@ export interface ComboboxProps
    * Callback function triggered whenever the input field is cleared.
    *
    * @param event
-   * @returns
    */
   onClear?: (event: React.PointerEvent | React.KeyboardEvent) => void;
   /**
    * Callback function triggered whenever an option is selected or de-selected.
    *
-   * @param option The selected option.
-   * @param isSelected Whether the option has been selected or unselected.
-   * @param isCustomOption Whether the option comes from user input, instead of from the list.
-   * @returns
+   * @param option The option value
+   * @param isSelected Whether the option has been selected or unselected
+   * @param isCustomOption Whether the option comes from user input, instead of from the list
    */
   onToggleSelected?: (
-    option: string,
+    option: ComboboxOption["value"],
     isSelected: boolean,
     isCustomOption: boolean,
   ) => void;
@@ -107,7 +119,7 @@ export interface ComboboxProps
    * Use this prop when controlling the selected state outside for the component,
    * e.g. for a filter, where options can be toggled elsewhere/programmatically.
    */
-  selectedOptions?: string[];
+  selectedOptions?: string[] | ComboboxOption[];
   /**
    * Options for the maximum number of selected options.
    */