@koine/react 1.0.10 → 1.0.13

package/Autocomplete/AutocompleteDownshiftMultiselect.js

@@ -0,0 +1,353 @@
+// TODO: remove, just use mui version...
+export var 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

@@ -0,0 +1,47 @@
+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,182 @@
+import { __assign, __awaiter, __generator, __rest } from "tslib";
+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 var Autocomplete = function (_a) {
+    var creatable = _a.creatable, multiple = _a.multiple, autoComplete = _a.autoComplete, loadOptions = _a.loadOptions, _b = _a.options, defaultOptions = _b === void 0 ? [] : _b, defaultValue = _a.defaultValue, controlledValue = _a.value, defaultInputValue = _a.defaultInputValue, label = _a.label, placeholder = _a.placeholder, register = _a.register, setValue = _a.setValue, 
+    // trigger,
+    name = _a.name, onChange = _a.onChange, $ref = _a.$ref, children = _a.children, props = __rest(_a, ["creatable", "multiple", "autoComplete", "loadOptions", "options", "defaultValue", "value", "defaultInputValue", "label", "placeholder", "register", "setValue", "name", "onChange", "$ref", "children"]);
+    var defaultOptionsMemo = useMemo(function () { return normaliseOptions(defaultOptions); }, [defaultOptions]);
+    var _c = useState(defaultOptionsMemo), options = _c[0], setOptions = _c[1];
+    var _d = useState(false), loading = _d[0], setLoading = _d[1];
+    var _e = 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: defaultValue,
+        // @ts-expect-error FIXME: how?
+        value: controlledValue,
+        // defaultValue: useMemo(
+        //   () => normaliseAutocompleteValue(defaultValue, multiple),
+        //   [defaultValue]
+        // ),
+        options: useMemo(function () { return (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(function (_event, inputValue) { return __awaiter(void 0, void 0, void 0, function () {
+            var newOptions, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!loadOptions) {
+                            return [2 /*return*/];
+                        }
+                        if (!inputValue) return [3 /*break*/, 6];
+                        setLoading(true);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, 4, 5]);
+                        return [4 /*yield*/, loadOptions(inputValue)];
+                    case 2:
+                        newOptions = _a.sent();
+                        setOptions(newOptions);
+                        return [3 /*break*/, 5];
+                    case 3:
+                        e_1 = _a.sent();
+                        console.warn(e_1);
+                        return [3 /*break*/, 5];
+                    case 4:
+                        setLoading(false);
+                        return [7 /*endfinally*/];
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        setOptions(options);
+                        _a.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); }, [loadOptions, options]),
+        // TODO: check if we need this, probably, and check how to structure the
+        // callback, here we get the actual input event
+        onChange: function (event, newValue) {
+            var 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: function (option, value) {
+            var optValue = isString(option) ? option : option.value;
+            var valValue = isString(value) ? value : value.value;
+            return optValue === valValue;
+        },
+        getOptionLabel: function (option) {
+            // @ts-expect-error TODO: I don't get this error
+            return isString(option) ? option : option.label || "";
+        },
+    }), getRootProps = _e.getRootProps, getInputLabelProps = _e.getInputLabelProps, getInputProps = _e.getInputProps, getTagProps = _e.getTagProps, getListboxProps = _e.getListboxProps, getOptionProps = _e.getOptionProps, getPopupIndicatorProps = _e.getPopupIndicatorProps, groupedOptions = _e.groupedOptions, stateValue = _e.value, setAnchorEl = _e.setAnchorEl, popupOpen = _e.popupOpen, focused = _e.focused;
+    var value = typeof controlledValue !== "undefined" ? controlledValue : stateValue;
+    var inputProps = function () {
+        var autocompleteProps = getInputProps();
+        // here we merge the mui's `useAutocomplete` props with the react-hook-form's
+        // `register` props
+        var 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 __assign(__assign({}, registerProps), autocompleteProps);
+    };
+    // 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, __assign({}, getInputLabelProps(), { children: label }))), _jsxs(AutocompleteWrap, __assign({}, getRootProps(), { "data-focus": focused }, { children: [_jsxs(AutocompleteInner, __assign({ ref: setAnchorEl }, { children: [multiple &&
+                                value.map(function (valueItem, index) {
+                                    var _a = getTagProps({ index: index }), onDelete = _a.onDelete, key = _a.key, tagProps = __rest(_a, ["onDelete", "key"]);
+                                    return (_jsxs(AutocompleteItem, __assign({}, tagProps, { children: [_jsx(AutocompleteItemLabel, { children: isString(valueItem)
+                                                    ? valueItem
+                                                    : valueItem.Label || valueItem.label }), _jsx(AutocompleteItemRemove, __assign({ onClick: onDelete }, { children: "\u2715" }))] }), key));
+                                }), _jsx(AutocompleteInput, __assign({}, inputProps(), { placeholder: placeholder }))] })), !!options.length && (_jsx(AutocompleteInputArrow, __assign({}, getPopupIndicatorProps(), { isOpen: popupOpen }))), loading && _jsx(InputProgress, {})] })), groupedOptions.length ? (_jsx(AutocompleteMenu, __assign({}, getListboxProps(), { children: groupedOptions.map(function (option, index) { return (_jsx(AutocompleteMenuItem, __assign({}, getOptionProps({ option: option, index: index }), { children: isString(option) ? option : option.Label || option.label }), index)); }) }))) : null, children] }));
+    // });
+};

package/Autocomplete/AutocompleteReach.d.ts

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