@koine/react 1.0.4 → 1.0.9

package/Autocomplete/AutocompleteDownshiftMultiselect.js

@@ -0,0 +1,353 @@
+// TODO: remove, just use mui version...
+export const Autocomplete = null;
+// import {
+//   forwardRef,
+//   useCallback,
+//   useEffect,
+//   useRef,
+//   useState,
+//   ForwardedRef,
+//   ReactNode,
+//   ComponentPropsWithRef,
+//   CSSProperties,
+// } from "react";
+// import { SetRequired } from "@koine/utils";
+// import {
+//   useCombobox,
+//   useMultipleSelection,
+//   UseMultipleSelectionProps,
+//   UseMultipleSelectionStateChange,
+//   UseMultipleSelectionReturnValue,
+// } from "downshift";
+// import { usePopper } from "react-popper"; // imports from downshift demo
+// // import { useDeepCompareEffect } from "react-use"; // imports from downshift demo
+// import type { Option } from "../types";
+// import {
+//   normaliseOptions,
+//   defaultOptionsFilterFn,
+//   triggerOnChange,
+// } from "../Forms/helpers";
+// import {
+//   AutocompleteRoot,
+//   AutocompleteLabel,
+//   AutocompleteWrap,
+//   AutocompleteInner,
+//   AutocompleteItem,
+//   AutocompleteItemLabel,
+//   AutocompleteItemRemove,
+//   AutocompleteInputWrap,
+//   AutocompleteInput,
+//   AutocompleteInputArrow,
+//   AutocompleteMenu,
+//   AutocompleteMenuItem,
+// } from "./components";
+// const USE_POPPER = false;
+// export type AutocompleteItem = Option;
+// export type AutocompleteValue = AutocompleteItem[];
+// export type AutocompleteProps = SetRequired<
+//   Omit<ComponentPropsWithRef<"input">, "defaultValue" | "onSelect">,
+//   "onChange" | "name"
+// > & {
+//   selectedItems: UseMultipleSelectionReturnValue<AutocompleteItem>["selectedItems"];
+//   onSelectedItemsChange: UseMultipleSelectionProps<AutocompleteItem>["onSelectedItemsChange"];
+//   onCreateItem: (item?: AutocompleteItem) => any;
+//   creatable?: boolean;
+//   onSelect?: (value?: AutocompleteValue) => any;
+//   options?: AutocompleteItem[];
+//   loadOptions?: (query?: string) => Promise<AutocompleteItem[]>;
+//   label?: string | ReactNode;
+//   defaultValue?: AutocompleteValue | string[];
+//   className?: string;
+//   style?: CSSProperties;
+//   $ref?: ForwardedRef<HTMLInputElement>;
+// };
+// /**
+//  * @see https://www.downshift-js.com/use-multiple-selection
+//  * @see https://codesandbox.io/s/y34o5l3p61?file=/src/hooks/useMultipleSelection/combobox.js
+//  * @see https://codesandbox.io/s/y34o5l3p61?file=/src/downshift/ordered-examples/05-multi-create.js
+//  */
+// export const _Autocomplete = forwardRef<HTMLInputElement, AutocompleteProps>(
+//   function _Autocomplete(
+//     {
+//       selectedItems,
+//       onSelectedItemsChange,
+//       onCreateItem,
+//       creatable,
+//       onSelect,
+//       options = [],
+//       label,
+//       loadOptions,
+//       $ref,
+//       className,
+//       style,
+//       ...props
+//     },
+//     ref
+//   ) {
+//     options = normaliseOptions(options);
+//     const [isCreating, setIsCreating] = useState(false);
+//     const [filteredOptions, setFilteredOptions] = useState(options);
+//     const disclosureRef = useRef(null);
+//     const popoverRef = useRef(null);
+//     const { styles, attributes } = USE_POPPER
+//       ? usePopper(disclosureRef.current, popoverRef.current, {
+//           placement: "bottom-start",
+//         })
+//       : { styles: {}, attributes: {} };
+//     const {
+//       getSelectedItemProps,
+//       getDropdownProps,
+//       addSelectedItem,
+//       removeSelectedItem,
+//       // selectedItems,
+//       activeIndex,
+//     } = useMultipleSelection<AutocompleteItem>({
+//       selectedItems,
+//       onSelectedItemsChange,
+//       // onSelectedItemsChange: ({ selectedItems = [] }) => {
+//       //   triggerChange(selectedItems);
+//       // },
+//       // initialSelectedItems: normaliseOptions(defaultValue),
+//       stateReducer: (_, actionAndChanges) => {
+//         const { type, changes } = actionAndChanges;
+//         switch (type) {
+//           case useMultipleSelection.stateChangeTypes.FunctionRemoveSelectedItem:
+//             return {
+//               ...changes,
+//               activeIndex: undefined,
+//             };
+//           default:
+//             return changes;
+//         }
+//       },
+//     });
+//     const selectedItemsValues = selectedItems.map((item) => item.value);
+//     const {
+//       isOpen,
+//       getToggleButtonProps,
+//       getLabelProps,
+//       getMenuProps,
+//       getInputProps,
+//       getComboboxProps,
+//       highlightedIndex,
+//       getItemProps,
+//       openMenu,
+//       selectItem,
+//       setHighlightedIndex,
+//       inputValue,
+//     } = useCombobox<null | AutocompleteItem>({
+//       selectedItem: null,
+//       items: filteredOptions,
+//       onInputValueChange: ({ inputValue }) => {
+//         // perhaps allows the optionsFilterFn as prop
+//         const filteredItems = defaultOptionsFilterFn(options, inputValue);
+//         if (creatable && isCreating && filteredItems.length > 0) {
+//           setIsCreating(false);
+//         }
+//         setFilteredOptions(filteredItems);
+//       },
+//       stateReducer: (state, actionAndChanges) => {
+//         const { changes, type } = actionAndChanges;
+//         switch (type) {
+//           case useCombobox.stateChangeTypes.InputBlur:
+//             return {
+//               ...changes,
+//               highlightedIndex: state.highlightedIndex,
+//               // clear input on blur to avoid have "pending" uncompleted behaviours
+//               inputValue: "",
+//             };
+//           case useCombobox.stateChangeTypes.InputKeyDownEnter:
+//           case useCombobox.stateChangeTypes.ItemClick:
+//             return {
+//               ...changes,
+//               highlightedIndex: state.highlightedIndex,
+//               isOpen: true,
+//               inputValue: "",
+//             };
+//           default:
+//             return changes;
+//         }
+//       },
+//       onStateChange: ({ type, selectedItem }) => {
+//         switch (type) {
+//           case useCombobox.stateChangeTypes.InputKeyDownEnter:
+//           case useCombobox.stateChangeTypes.ItemClick:
+//             if (selectedItem) {
+//               if (selectedItemsValues.includes(selectedItem.value)) {
+//                 removeSelectedItem(selectedItem);
+//               } else {
+//                 if (creatable && onCreateItem) {
+//                   onCreateItem(selectedItem);
+//                 }
+//                 addSelectedItem(selectedItem);
+//                 if (isCreating) {
+//                   setIsCreating(false);
+//                   setFilteredOptions(options);
+//                 }
+//               }
+//               selectItem(null);
+//             }
+//             break;
+//           default:
+//             break;
+//         }
+//       },
+//     });
+//     useEffect(() => {
+//       if (
+//         creatable &&
+//         filteredOptions.length === 0 &&
+//         activeIndex === -1 &&
+//         inputValue.length > 0
+//       ) {
+//         setIsCreating(true);
+//         setFilteredOptions(normaliseOptions([inputValue]));
+//         setHighlightedIndex(0);
+//       }
+//     }, [
+//       creatable,
+//       filteredOptions,
+//       setIsCreating,
+//       setHighlightedIndex,
+//       inputValue,
+//       activeIndex,
+//     ]);
+//     // useEffect(() => {
+//     //   setSelectedItems(normaliseOptions(defaultValue));
+//     // }, [defaultValue]);
+//     // useDeepCompareEffect(() => {
+//     //   setFilteredOptions(options);
+//     // }, [options]);
+//     // useDeepCompareEffect(() => {
+//     //   triggerChange(values);
+//     // }, [values]);
+//     return (
+//       <AutocompleteRoot>
+//         {label && (
+//           <AutocompleteLabel {...getLabelProps()}>{label}</AutocompleteLabel>
+//         )}
+//         <AutocompleteWrap
+//           {...getComboboxProps({
+//             ref: disclosureRef,
+//           })}
+//         >
+//           <AutocompleteInner>
+//             {selectedItems.map((selectedItem, index) => (
+//               <AutocompleteItem
+//                 key={`selected-item-${index}`}
+//                 {...getSelectedItemProps({ selectedItem, index })}
+//               >
+//                 <AutocompleteItemLabel>
+//                   {selectedItem?.label || selectedItem}
+//                 </AutocompleteItemLabel>
+//                 <AutocompleteItemRemove
+//                   onClick={(e) => {
+//                     e.stopPropagation();
+//                     removeSelectedItem(selectedItem);
+//                   }}
+//                 >
+//                   &#10005;
+//                 </AutocompleteItemRemove>
+//               </AutocompleteItem>
+//             ))}
+//             <AutocompleteInputWrap>
+//               <AutocompleteInput
+//                 {...getInputProps({
+//                   ...getDropdownProps({
+//                     // this option used in the official example prevents the
+//                     // backspace key to behave correctly
+//                     // preventKeyAction: isOpen,
+//                     onClick: isOpen ? () => {} : openMenu,
+//                     onFocus: isOpen ? () => {} : openMenu,
+//                     ref: $ref || ref,
+//                     // ref: disclosureRef,
+//                   }),
+//                   // ref: $ref || ref,
+//                 })}
+//                 {...props}
+//               />
+//             </AutocompleteInputWrap>
+//           </AutocompleteInner>
+//           {!!filteredOptions.length && (
+//             <AutocompleteInputArrow
+//               {...getToggleButtonProps()}
+//               aria-label={"toggle menu"}
+//               isOpen={isOpen}
+//             />
+//           )}
+//         </AutocompleteWrap>
+//         <AutocompleteMenu
+//           style={styles.popper}
+//           {...attributes.popper}
+//           {...getMenuProps({ ref: popoverRef })}
+//         >
+//           {isOpen &&
+//             filteredOptions.map((item, index) => (
+//               <AutocompleteMenuItem
+//                 $active={highlightedIndex === index}
+//                 key={`${item.value}${index}`}
+//                 {...getItemProps({ item, index })}
+//               >
+//                 {isCreating ? (
+//                   <>
+//                     <span>+</span> <strong>{item.label}</strong>
+//                   </>
+//                 ) : (
+//                   <>
+//                     {/* {selectedItemsValues.includes(item.value) && (
+//                       <CheckboxToggle />
+//                     )} */}
+//                     {item.label}
+//                   </>
+//                 )}
+//               </AutocompleteMenuItem>
+//             ))}
+//         </AutocompleteMenu>
+//       </AutocompleteRoot>
+//     );
+//   }
+// );
+// /**
+//  * @see https://www.downshift-js.com/use-multiple-selection
+//  * @see https://codesandbox.io/s/y34o5l3p61?file=/src/hooks/useMultipleSelection/combobox.js
+//  * @see https://codesandbox.io/s/y34o5l3p61?file=/src/downshift/ordered-examples/05-multi-create.js
+//  */
+// export const Autocomplete = forwardRef<HTMLInputElement, AutocompleteProps>(
+//   function Autocomplete(
+//     { defaultValue = [], onChange, onSelect, name, ...props },
+//     ref
+//   ) {
+//     const [selectedItems, setSelectedItems] = useState(
+//       normaliseOptions(defaultValue)
+//     );
+//     const triggerChange = useCallback(
+//       (values: AutocompleteValue) => {
+//         triggerOnChange(
+//           onChange,
+//           name,
+//           values.map((item) => item.value || item)
+//         );
+//         if (onSelect) onSelect(values);
+//       },
+//       [onChange, onSelect, name]
+//     );
+//     const handleCreateItem = (item?: AutocompleteItem) => {
+//       // setSelectedItems((curr) => [...curr, item]);
+//     };
+//     const handleSelectedItemsChange = ({
+//       selectedItems = [],
+//     }: UseMultipleSelectionStateChange<AutocompleteItem>) => {
+//       setSelectedItems(selectedItems);
+//       triggerChange(selectedItems);
+//     };
+//     return (
+//       <_Autocomplete
+//         {...props}
+//         selectedItems={selectedItems}
+//         onSelectedItemsChange={handleSelectedItemsChange}
+//         onCreateItem={handleCreateItem}
+//         $ref={ref}
+//       />
+//     );
+//   }
+// );

package/Autocomplete/AutocompleteMui.d.ts

@@ -1,47 +1,47 @@
-/// <reference types="react" />
-import type { Option } from "../types";
-import { FormControl } from "../Forms/helpers";
-export declare type AutocompleteOption = Option | string;
-export declare type AutocompleteValue<TMultiple extends boolean | undefined = undefined> = TMultiple extends undefined ? null | Option[] | string[] | Option | string : TMultiple extends true ? Option[] | string[] : null | Option | string;
-export declare type AutocompleteConfig<TOption extends AutocompleteOption, TValue extends AutocompleteValue> = {
-    creatable?: boolean;
-    multiple?: boolean;
-    autoComplete?: boolean;
-    options?: TOption[];
-    loadOptions?: (query?: string) => Promise<TOption[]>;
-    onChange?: (value: TValue) => any;
-    defaultValue?: TValue;
-    value?: TValue;
-    defaultInputValue?: string;
-};
-export declare type AutocompleteProps<TOption extends AutocompleteOption, TValue extends AutocompleteValue> = Omit<FormControl, keyof AutocompleteConfig<TOption, TValue>> & AutocompleteConfig<TOption, TValue> & {
-    className?: string;
-    style?: React.CSSProperties;
-    $ref?: React.ForwardedRef<HTMLInputElement>;
-};
-/**
- * Autocomplete/autocomplete component based on [`@mui useAutocomplete hook`](https://mui.com/components/autocomplete/#useautocomplete).
- *
- * This component is design to work out of the box with [`react-hook-form`](https://react-hook-form.com/)
- * and [`yup`](https://github.com/jquense/yup) alongside our custom `Field`
- * component.
- *
- * After a lot of tests and attempts with `downshift` and `@reach` this proved
- * the best headless hook, small in size and behaving correctly in all scenarios.
- * `downshift` had in fact problems treating the initial `defaultValue` which
- * here is elegantly managed by the `isOptionEqualToValue` option passed into
- * the `useAutocomplete` hook.
- *
- *
- * Validation with `yup` and `react-hook-form` example:
- *
- * ```ts
- * const schema = object({
- *   // the value must be an array with at least one non-empty string
- *   test1: array(string().required()).required().min(1),
- *   // the value must be an array of strings or an empty array
- *   test2: array(string().required()).required(),
- * }).required();
- * ```
- */
-export declare const Autocomplete: <TOption extends AutocompleteOption = AutocompleteOption, TValue extends string | Option | Option[] | string[] | null = string | Option | Option[] | string[] | null>({ creatable, multiple, autoComplete, loadOptions, options: defaultOptions, defaultValue, value: controlledValue, defaultInputValue, label, placeholder, register, setValue, name, onChange, $ref, children, ...props }: AutocompleteProps<TOption, TValue>) => JSX.Element;
+import React from "react";
+import type { Option } from "../types";
+import { FormControl } from "../Forms/helpers";
+export declare type AutocompleteOption = Option | string;
+export declare type AutocompleteValue<TMultiple extends boolean | undefined = undefined> = TMultiple extends undefined ? null | Option[] | string[] | Option | string : TMultiple extends true ? Option[] | string[] : null | Option | string;
+export declare type AutocompleteConfig<TOption extends AutocompleteOption, TValue extends AutocompleteValue> = {
+    creatable?: boolean;
+    multiple?: boolean;
+    autoComplete?: boolean;
+    options?: TOption[];
+    loadOptions?: (query?: string) => Promise<TOption[]>;
+    onChange?: (value: TValue) => any;
+    defaultValue?: TValue;
+    value?: TValue;
+    defaultInputValue?: string;
+};
+export declare type AutocompleteProps<TOption extends AutocompleteOption, TValue extends AutocompleteValue> = Omit<FormControl, keyof AutocompleteConfig<TOption, TValue>> & AutocompleteConfig<TOption, TValue> & {
+    className?: string;
+    style?: React.CSSProperties;
+    $ref?: React.ForwardedRef<HTMLInputElement>;
+};
+/**
+ * Autocomplete/autocomplete component based on [`@mui useAutocomplete hook`](https://mui.com/components/autocomplete/#useautocomplete).
+ *
+ * This component is design to work out of the box with [`react-hook-form`](https://react-hook-form.com/)
+ * and [`yup`](https://github.com/jquense/yup) alongside our custom `Field`
+ * component.
+ *
+ * After a lot of tests and attempts with `downshift` and `@reach` this proved
+ * the best headless hook, small in size and behaving correctly in all scenarios.
+ * `downshift` had in fact problems treating the initial `defaultValue` which
+ * here is elegantly managed by the `isOptionEqualToValue` option passed into
+ * the `useAutocomplete` hook.
+ *
+ *
+ * Validation with `yup` and `react-hook-form` example:
+ *
+ * ```ts
+ * const schema = object({
+ *   // the value must be an array with at least one non-empty string
+ *   test1: array(string().required()).required().min(1),
+ *   // the value must be an array of strings or an empty array
+ *   test2: array(string().required()).required(),
+ * }).required();
+ * ```
+ */
+export declare const Autocomplete: <TOption extends AutocompleteOption = AutocompleteOption, TValue extends string | string[] | Option | Option[] | null = string | string[] | Option | Option[] | null>({ creatable, multiple, autoComplete, loadOptions, options: defaultOptions, defaultValue, value: controlledValue, defaultInputValue, label, placeholder, register, setValue, name, onChange, $ref, children, ...props }: AutocompleteProps<TOption, TValue>) => JSX.Element;

package/Autocomplete/AutocompleteMui.js

@@ -0,0 +1,177 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { 
+// forwardRef,
+useCallback, useMemo, useState, } from "react";
+import { useAutocomplete } from "@mui/base/AutocompleteUnstyled";
+import { isString } from "@koine/utils";
+import { 
+// triggerOnChange,
+normaliseOptions, } from "../Forms/helpers";
+import { normaliseAutocompleteValue } from "./helpers";
+import { AutocompleteRoot, AutocompleteLabel, AutocompleteWrap, AutocompleteInner, AutocompleteItem, AutocompleteItemLabel, AutocompleteItemRemove, 
+// AutocompleteInputWrap,
+AutocompleteInput, AutocompleteInputArrow, AutocompleteMenu, AutocompleteMenuItem, } from "./components";
+import { InputProgress } from "../Forms/styles";
+/**
+ * Autocomplete/autocomplete component based on [`@mui useAutocomplete hook`](https://mui.com/components/autocomplete/#useautocomplete).
+ *
+ * This component is design to work out of the box with [`react-hook-form`](https://react-hook-form.com/)
+ * and [`yup`](https://github.com/jquense/yup) alongside our custom `Field`
+ * component.
+ *
+ * After a lot of tests and attempts with `downshift` and `@reach` this proved
+ * the best headless hook, small in size and behaving correctly in all scenarios.
+ * `downshift` had in fact problems treating the initial `defaultValue` which
+ * here is elegantly managed by the `isOptionEqualToValue` option passed into
+ * the `useAutocomplete` hook.
+ *
+ *
+ * Validation with `yup` and `react-hook-form` example:
+ *
+ * ```ts
+ * const schema = object({
+ *   // the value must be an array with at least one non-empty string
+ *   test1: array(string().required()).required().min(1),
+ *   // the value must be an array of strings or an empty array
+ *   test2: array(string().required()).required(),
+ * }).required();
+ * ```
+ */
+// export const Autocomplete = <TOption, TValue>forwardRef<
+//  HTMLInputElement,
+//  PropsWithChildren<AutocompleteProps<TOption, TValue>
+// >(function Autocomplete(
+//  {
+//    creatable,
+//    multiple,
+//    autoComplete,
+//    loadOptions,
+//    options: defaultOptions = [],
+//    defaultValue = [],
+//    label,
+//    register,
+//    setValue,
+//    // trigger,
+//    name,
+//    onChange,
+//    $ref,
+//    children,
+//    ...props
+//  },
+//  ref
+// ) {
+export const Autocomplete = ({ creatable, multiple, autoComplete, loadOptions, options: defaultOptions = [], defaultValue, value: controlledValue, defaultInputValue, label, placeholder, register, setValue, 
+// trigger,
+name, onChange, $ref, children, ...props }) => {
+    const defaultOptionsMemo = useMemo(() => normaliseOptions(defaultOptions), [defaultOptions]);
+    const [options, setOptions] = useState(defaultOptionsMemo);
+    const [loading, setLoading] = useState(false);
+    const { getRootProps, getInputLabelProps, getInputProps, getTagProps, getListboxProps, getOptionProps, getPopupIndicatorProps, groupedOptions, value: stateValue, setAnchorEl, popupOpen, focused, } = useAutocomplete({
+        id: "Autocomplete",
+        multiple: multiple ? true : undefined,
+        freeSolo: creatable ? true : undefined,
+        // autoComplete: autoComplete ? true : undefined,
+        disableCloseOnSelect: true,
+        openOnFocus: true,
+        blurOnSelect: autoComplete && !multiple,
+        selectOnFocus: creatable,
+        // TODO: passing the defaultInputValue makes the input controlled, which is
+        // not what I want, so we probably need to handle the input default value
+        // ourselves
+        // inputValue: defaultInputValue,
+        // @ts-expect-error FIXME: how?
+        defaultValue,
+        // @ts-expect-error FIXME: how?
+        value: controlledValue,
+        // defaultValue: useMemo(
+        //   () => normaliseAutocompleteValue(defaultValue, multiple),
+        //   [defaultValue]
+        // ),
+        options: useMemo(() => (loadOptions ? options : defaultOptions), [loadOptions, options, defaultOptions]),
+        // update input change only if we are searching as you type, @see
+        // https://mui.com/components/autocomplete/#search-as-you-type
+        onInputChange: useCallback(async (_event, inputValue) => {
+            if (!loadOptions) {
+                return;
+            }
+            if (inputValue) {
+                setLoading(true);
+                try {
+                    const newOptions = await loadOptions(inputValue);
+                    setOptions(newOptions);
+                }
+                catch (e) {
+                    console.warn(e);
+                }
+                finally {
+                    setLoading(false);
+                }
+            }
+            else {
+                setOptions(options);
+                // TODO: clear like behaviour?
+                // triggerChange({ value: "", label: "" });
+            }
+        }, [loadOptions, options]),
+        // TODO: check if we need this, probably, and check how to structure the
+        // callback, here we get the actual input event
+        onChange: (event, newValue) => {
+            const value = normaliseAutocompleteValue(newValue, multiple);
+            // @ts-expect-error FIXME: how?
+            if (onChange)
+                onChange(newValue);
+            if (setValue)
+                setValue(name, value, { shouldValidate: true });
+            // triggerOnChange(onChange, name, value);
+        },
+        // support both freeSolo free text and full option structure
+        isOptionEqualToValue: (option, value) => {
+            const optValue = isString(option) ? option : option.value;
+            const valValue = isString(value) ? value : value.value;
+            return optValue === valValue;
+        },
+        getOptionLabel: (option) => {
+            // @ts-expect-error TODO: I don't get this error
+            return isString(option) ? option : option.label || "";
+        },
+    });
+    const value = typeof controlledValue !== "undefined" ? controlledValue : stateValue;
+    const inputProps = () => {
+        const autocompleteProps = getInputProps();
+        // here we merge the mui's `useAutocomplete` props with the react-hook-form's
+        // `register` props
+        const registerProps = register
+            ? register(name, {
+                // @ts-expect-error FIXME: can't remember
+                ref: autocompleteProps.ref.current,
+                // this makes the validation works when a valid `defaultValue`
+                // is provided
+                value: normaliseAutocompleteValue(value, multiple),
+            })
+            : {};
+        return {
+            ...registerProps,
+            ...autocompleteProps,
+            // onChange: (event: FormEvent<HTMLInputElement>) => {
+            //   registerProps.onChange(event);
+            //   autocompleteProps?.onChange(event);
+            // },
+        };
+    };
+    // to focus the input on error this works too
+    // @see https://react-hook-form.com/faqs#question12 but probably it is
+    // better to do as now passing the input ref to the register options
+    // useEffect(() => {
+    //   if (errors[name]) {
+    //     inputProps.ref.current.focus();
+    //   }
+    // }, [errors, name, inputProps.ref]);
+    return (_jsxs(AutocompleteRoot, { children: [label && (_jsx(AutocompleteLabel, { ...getInputLabelProps(), children: label })), _jsxs(AutocompleteWrap, { ...getRootProps(), "data-focus": focused, children: [_jsxs(AutocompleteInner, { ref: setAnchorEl, children: [multiple &&
+                                value.map((valueItem, index) => {
+                                    const { onDelete, key, ...tagProps } = getTagProps({ index });
+                                    return (_jsxs(AutocompleteItem, { ...tagProps, children: [_jsx(AutocompleteItemLabel, { children: isString(valueItem)
+                                                    ? valueItem
+                                                    : valueItem.Label || valueItem.label }), _jsx(AutocompleteItemRemove, { onClick: onDelete, children: "\u2715" })] }, key));
+                                }), _jsx(AutocompleteInput, { ...inputProps(), placeholder: placeholder })] }), !!options.length && (_jsx(AutocompleteInputArrow, { ...getPopupIndicatorProps(), isOpen: popupOpen })), loading && _jsx(InputProgress, {})] }), groupedOptions.length ? (_jsx(AutocompleteMenu, { ...getListboxProps(), children: groupedOptions.map((option, index) => (_jsx(AutocompleteMenuItem, { ...getOptionProps({ option, index }), children: isString(option) ? option : option.Label || option.label }, index))) })) : null, children] }));
+    // });
+};

package/Autocomplete/AutocompleteReach.d.ts

@@ -1 +1 @@
-export declare const Autocomplete: null;
+export declare const Autocomplete: null;