@yamada-ui/autocomplete 1.5.1 → 1.5.2-dev-20240917033401

package/dist/chunk-GM7RV2YY.mjs

@@ -0,0 +1,959 @@
+"use client"
+import {
+  AutocompleteOptionGroup
+} from "./chunk-FZM3BH3D.mjs";
+import {
+  AutocompleteOption
+} from "./chunk-QQFSHTTC.mjs";
+import {
+  useAutocompleteContext,
+  useAutocompleteDescendants,
+  useAutocompleteDescendantsContext
+} from "./chunk-JPUKYLBW.mjs";
+
+// src/use-autocomplete.tsx
+import { layoutStyleProperties } from "@yamada-ui/core";
+import {
+  formControlProperties,
+  useFormControlProps
+} from "@yamada-ui/form-control";
+import { useControllableState } from "@yamada-ui/use-controllable-state";
+import { useDisclosure } from "@yamada-ui/use-disclosure";
+import { useOutsideClick } from "@yamada-ui/use-outside-click";
+import {
+  dataAttr,
+  funcAll,
+  getEventRelatedTarget,
+  handlerAll,
+  isArray,
+  isContains,
+  mergeRefs,
+  pickObject,
+  splitObject,
+  useUnmountEffect,
+  useUpdateEffect,
+  getValidChildren,
+  isUndefined
+} from "@yamada-ui/utils";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+var kanaMap = {
+  \uFF76\uFF9E: "\u30AC",
+  \uFF77\uFF9E: "\u30AE",
+  \uFF78\uFF9E: "\u30B0",
+  \uFF79\uFF9E: "\u30B2",
+  \uFF7A\uFF9E: "\u30B4",
+  \uFF7B\uFF9E: "\u30B6",
+  \uFF7C\uFF9E: "\u30B8",
+  \uFF7D\uFF9E: "\u30BA",
+  \uFF7E\uFF9E: "\u30BC",
+  \uFF7F\uFF9E: "\u30BE",
+  \uFF80\uFF9E: "\u30C0",
+  \uFF81\uFF9E: "\u30C2",
+  \uFF82\uFF9E: "\u30C5",
+  \uFF83\uFF9E: "\u30C7",
+  \uFF84\uFF9E: "\u30C9",
+  \uFF8A\uFF9E: "\u30D0",
+  \uFF8B\uFF9E: "\u30D3",
+  \uFF8C\uFF9E: "\u30D6",
+  \uFF8D\uFF9E: "\u30D9",
+  \uFF8E\uFF9E: "\u30DC",
+  \uFF8A\uFF9F: "\u30D1",
+  \uFF8B\uFF9F: "\u30D4",
+  \uFF8C\uFF9F: "\u30D7",
+  \uFF8D\uFF9F: "\u30DA",
+  \uFF8E\uFF9F: "\u30DD",
+  \uFF73\uFF9E: "\u30F4",
+  \uFF9C\uFF9E: "\u30F7",
+  \uFF66\uFF9E: "\u30FA",
+  \uFF71: "\u30A2",
+  \uFF72: "\u30A4",
+  \uFF73: "\u30A6",
+  \uFF74: "\u30A8",
+  \uFF75: "\u30AA",
+  \uFF76: "\u30AB",
+  \uFF77: "\u30AD",
+  \uFF78: "\u30AF",
+  \uFF79: "\u30B1",
+  \uFF7A: "\u30B3",
+  \uFF7B: "\u30B5",
+  \uFF7C: "\u30B7",
+  \uFF7D: "\u30B9",
+  \uFF7E: "\u30BB",
+  \uFF7F: "\u30BD",
+  \uFF80: "\u30BF",
+  \uFF81: "\u30C1",
+  \uFF82: "\u30C4",
+  \uFF83: "\u30C6",
+  \uFF84: "\u30C8",
+  \uFF85: "\u30CA",
+  \uFF86: "\u30CB",
+  \uFF87: "\u30CC",
+  \uFF88: "\u30CD",
+  \uFF89: "\u30CE",
+  \uFF8A: "\u30CF",
+  \uFF8B: "\u30D2",
+  \uFF8C: "\u30D5",
+  \uFF8D: "\u30D8",
+  \uFF8E: "\u30DB",
+  \uFF8F: "\u30DE",
+  \uFF90: "\u30DF",
+  \uFF91: "\u30E0",
+  \uFF92: "\u30E1",
+  \uFF93: "\u30E2",
+  \uFF94: "\u30E4",
+  \uFF95: "\u30E6",
+  \uFF96: "\u30E8",
+  \uFF97: "\u30E9",
+  \uFF98: "\u30EA",
+  \uFF99: "\u30EB",
+  \uFF9A: "\u30EC",
+  \uFF9B: "\u30ED",
+  \uFF9C: "\u30EF",
+  \uFF66: "\u30F2",
+  \uFF9D: "\u30F3",
+  \uFF67: "\u30A1",
+  \uFF68: "\u30A3",
+  \uFF69: "\u30A5",
+  \uFF6A: "\u30A7",
+  \uFF6B: "\u30A9",
+  \uFF6F: "\u30C3",
+  \uFF6C: "\u30E3",
+  \uFF6D: "\u30E5",
+  \uFF6E: "\u30E7",
+  "\uFF61": "\u3002",
+  "\uFF64": "\u3001",
+  \uFF70: "\u30FC",
+  "\uFF62": "\u300C",
+  "\uFF63": "\u300D",
+  "\uFF65": "\u30FB"
+};
+var defaultFormat = (value) => {
+  value = value.replace(
+    /[！-～]/g,
+    (v) => String.fromCharCode(v.charCodeAt(0) - 65248)
+  );
+  const reg = new RegExp("(" + Object.keys(kanaMap).join("|") + ")", "g");
+  value = value.replace(reg, (v) => kanaMap[v]).replace(/ﾞ/g, "\u309B").replace(/ﾟ/g, "\u309C");
+  value = value.toUpperCase();
+  return value;
+};
+var flattenItems = (items) => {
+  const filterItems = (items2) => items2.map((item) => {
+    var _a;
+    const { isDisabled, isFocusable } = item;
+    const trulyDisabled = !!isDisabled && !isFocusable;
+    if (trulyDisabled) return;
+    if ("items" in item) {
+      return filterItems((_a = item.items) != null ? _a : []);
+    } else {
+      return item;
+    }
+  }).filter(Boolean);
+  return filterItems(items).flat(Infinity);
+};
+var useAutocomplete = (props) => {
+  const {
+    value: valueProp,
+    defaultValue,
+    onChange: onChangeProp,
+    onCreate: onCreateProp,
+    onSearch: onSearchProp,
+    closeOnSelect = true,
+    omitSelectedValues = false,
+    maxSelectValues,
+    allowCreate = false,
+    allowFree = false,
+    insertPositionItem = "first",
+    emptyMessage = "No results found",
+    format = defaultFormat,
+    optionProps,
+    placeholder,
+    onKeyDown: onKeyDownProp,
+    isOpen: isOpenProp,
+    defaultIsOpen,
+    onOpen: onOpenProp,
+    onClose: onCloseProp,
+    closeOnBlur = true,
+    closeOnEsc = true,
+    openDelay,
+    closeDelay,
+    isLazy,
+    lazyBehavior,
+    animation,
+    duration = 0.2,
+    offset,
+    gutter,
+    preventOverflow,
+    flip,
+    matchWidth = true,
+    boundary,
+    eventListeners,
+    strategy,
+    placement = "bottom-start",
+    modifiers,
+    items,
+    children,
+    ...rest
+  } = useFormControlProps(props);
+  const {
+    "aria-readonly": _ariaReadonly,
+    onFocus: onFocusProp,
+    ...formControlProps
+  } = pickObject(rest, formControlProperties);
+  const [containerProps, inputProps] = splitObject(rest, layoutStyleProperties);
+  const { id } = rest;
+  const descendants = useAutocompleteDescendants();
+  const containerRef = useRef(null);
+  const listRef = useRef(null);
+  const inputRef = useRef(null);
+  const timeoutIds = useRef(/* @__PURE__ */ new Set([]));
+  const isComposition = useRef(false);
+  const prevValue = useRef(void 0);
+  const [resolvedItems, setResolvedItems] = useState(items ? JSON.parse(JSON.stringify(items)) : void 0);
+  const [value, setValue] = useControllableState({
+    value: valueProp,
+    defaultValue,
+    onChange: onChangeProp
+  });
+  const [label, setLabel] = useState(void 0);
+  const [inputValue, setInputValue] = useState("");
+  const [focusedIndex, setFocusedIndex] = useState(-1);
+  const [isAllSelected, setIsAllSelected] = useState(false);
+  const [isHit, setIsHit] = useState(true);
+  const {
+    isOpen,
+    onOpen: onInternalOpen,
+    onClose
+  } = useDisclosure({
+    isOpen: isOpenProp,
+    defaultIsOpen,
+    onOpen: onOpenProp,
+    onClose: onCloseProp
+  });
+  const isFocused = focusedIndex > -1;
+  const isCreate = focusedIndex === -2 && allowCreate;
+  const isMulti = isArray(value);
+  const isEmptyValue = !isMulti ? !value : !value.length;
+  const [firstInsertPositionItem, secondInsertPositionItem] = useMemo(() => {
+    if (isArray(insertPositionItem)) {
+      return insertPositionItem;
+    } else {
+      return [insertPositionItem, "first"];
+    }
+  }, [insertPositionItem]);
+  if (allowCreate && !isUndefined(children)) {
+    console.warn(
+      `${!isMulti ? "Autocomplete" : "MultiAutocomplete"}: ${!isMulti ? "Autocomplete" : "MultiAutocomplete"} internally prefers 'children'. If 'allowCreate' is true, it will not be reflected correctly. If want to reflect, please set 'items' in props.`
+    );
+  }
+  const selectedValues = descendants.enabledValues(
+    ({ node }) => {
+      var _a;
+      return isMulti && value.includes((_a = node.dataset.value) != null ? _a : "");
+    }
+  );
+  const selectedIndexes = selectedValues.map(({ index }) => index);
+  const enabledValues = descendants.enabledValues(
+    ({ node, index }) => "target" in node.dataset && !selectedIndexes.includes(index)
+  );
+  const validChildren = getValidChildren(children);
+  const computedChildren = useMemo(
+    () => resolvedItems == null ? void 0 : resolvedItems.map((item, i) => {
+      if ("value" in item) {
+        const { label: label2, value: value2, ...props2 } = item;
+        return /* @__PURE__ */ jsx(AutocompleteOption, { value: value2, ...props2, children: label2 }, i);
+      } else if ("items" in item) {
+        const { label: label2, items: items2 = [], ...props2 } = item;
+        return /* @__PURE__ */ jsx(AutocompleteOptionGroup, { label: label2, ...props2, children: items2.map(({ label: label3, value: value2, ...props3 }, i2) => /* @__PURE__ */ jsx(AutocompleteOption, { value: value2, ...props3, children: label3 }, i2)) }, i);
+      }
+    }),
+    [resolvedItems]
+  );
+  const isEmpty = !validChildren.length && !(computedChildren == null ? void 0 : computedChildren.length);
+  const onOpen = useCallback(() => {
+    if (formControlProps.disabled || formControlProps.readOnly) return;
+    if (!allowCreate && (isEmpty || isAllSelected)) return;
+    onInternalOpen();
+    if (inputRef.current) inputRef.current.focus();
+  }, [allowCreate, formControlProps, isAllSelected, isEmpty, onInternalOpen]);
+  const onFocusFirst = useCallback(() => {
+    const id2 = setTimeout(() => {
+      if (isEmpty || isAllSelected) return;
+      const first = descendants.enabledFirstValue(
+        ({ node }) => "target" in node.dataset
+      );
+      if (!first) return;
+      if (!isMulti || !omitSelectedValues) {
+        setFocusedIndex(first.index);
+      } else {
+        if (selectedIndexes.includes(first.index)) {
+          const enabledFirst = enabledValues[0];
+          setFocusedIndex(enabledFirst.index);
+        } else {
+          setFocusedIndex(first.index);
+        }
+      }
+    });
+    timeoutIds.current.add(id2);
+  }, [
+    descendants,
+    enabledValues,
+    isAllSelected,
+    isEmpty,
+    isMulti,
+    omitSelectedValues,
+    selectedIndexes
+  ]);
+  const onFocusLast = useCallback(() => {
+    const id2 = setTimeout(() => {
+      if (isEmpty || isAllSelected) return;
+      const last = descendants.enabledLastValue(
+        ({ node }) => "target" in node.dataset
+      );
+      if (!last) return;
+      if (!isMulti || !omitSelectedValues) {
+        setFocusedIndex(last.index);
+      } else {
+        if (selectedIndexes.includes(last.index)) {
+          const enabledLast = enabledValues.reverse()[0];
+          setFocusedIndex(enabledLast.index);
+        } else {
+          setFocusedIndex(last.index);
+        }
+      }
+    });
+    timeoutIds.current.add(id2);
+  }, [
+    descendants,
+    enabledValues,
+    isAllSelected,
+    isEmpty,
+    isMulti,
+    omitSelectedValues,
+    selectedIndexes
+  ]);
+  const onFocusSelected = useCallback(() => {
+    const id2 = setTimeout(() => {
+      const values = descendants.enabledValues();
+      const selected = values.find(
+        ({ node }) => {
+          var _a;
+          return !isMulti ? node.dataset.value === value : value.includes((_a = node.dataset.value) != null ? _a : "");
+        }
+      );
+      if (selected) setFocusedIndex(selected.index);
+    });
+    timeoutIds.current.add(id2);
+  }, [descendants, isMulti, value]);
+  const onFocusNext = useCallback(
+    (index = focusedIndex) => {
+      const id2 = setTimeout(() => {
+        var _a;
+        const next = descendants.enabledNextValue(
+          index,
+          ({ node }) => "target" in node.dataset
+        );
+        if (!next) return;
+        if (!isMulti || !omitSelectedValues) {
+          setFocusedIndex(next.index);
+        } else {
+          if (selectedIndexes.includes(next.index)) {
+            const enabledNext = (_a = enabledValues.find(({ index: index2 }) => next.index < index2)) != null ? _a : enabledValues[0];
+            setFocusedIndex(enabledNext.index);
+          } else {
+            setFocusedIndex(next.index);
+          }
+        }
+      });
+      timeoutIds.current.add(id2);
+    },
+    [
+      descendants,
+      enabledValues,
+      focusedIndex,
+      isMulti,
+      omitSelectedValues,
+      selectedIndexes
+    ]
+  );
+  const onFocusPrev = useCallback(
+    (index = focusedIndex) => {
+      const id2 = setTimeout(() => {
+        var _a;
+        const prev = descendants.enabledPrevValue(
+          index,
+          ({ node }) => "target" in node.dataset
+        );
+        if (!prev) return;
+        if (!isMulti || !omitSelectedValues) {
+          setFocusedIndex(prev.index);
+        } else {
+          if (selectedIndexes.includes(prev.index)) {
+            const enabledPrev = (_a = enabledValues.reverse().find(({ index: index2 }) => index2 < prev.index)) != null ? _a : enabledValues[0];
+            setFocusedIndex(enabledPrev.index);
+          } else {
+            setFocusedIndex(prev.index);
+          }
+        }
+      });
+      timeoutIds.current.add(id2);
+    },
+    [
+      descendants,
+      enabledValues,
+      focusedIndex,
+      isMulti,
+      omitSelectedValues,
+      selectedIndexes
+    ]
+  );
+  const onFocusFirstOrSelected = isEmptyValue || omitSelectedValues ? onFocusFirst : onFocusSelected;
+  const onFocusLastOrSelected = isEmptyValue || omitSelectedValues ? onFocusLast : onFocusSelected;
+  const pickOptions = useCallback(
+    (value2) => {
+      const values = descendants.values();
+      let isHit2 = false;
+      let isFocused2 = false;
+      values.forEach(({ node, index }) => {
+        var _a;
+        if (format((_a = node.textContent) != null ? _a : "").includes(value2)) {
+          isHit2 = true;
+          const isDisabled = "disabled" in node.dataset;
+          node.dataset.target = "";
+          if (!isFocused2 && !isDisabled) {
+            isFocused2 = true;
+            setFocusedIndex(index);
+          }
+        } else {
+          delete node.dataset.target;
+        }
+      });
+      setIsHit(isHit2);
+    },
+    [descendants, format]
+  );
+  const rebirthOptions = useCallback(
+    (runFocus = true) => {
+      const values = descendants.values();
+      values.forEach(({ node }) => {
+        node.dataset.target = "";
+      });
+      if (runFocus) onFocusFirst();
+      setIsHit(true);
+    },
+    [descendants, onFocusFirst]
+  );
+  const getSelectedValues = useCallback(
+    (newValues) => {
+      const enabledValues2 = descendants.enabledValues();
+      const resolvedValues = isArray(newValues) ? newValues : [newValues];
+      const selectedValues2 = resolvedValues.map((value2) => {
+        var _a, _b;
+        const { node } = (_a = enabledValues2.find(({ node: node2 }) => node2.dataset.value === value2)) != null ? _a : {};
+        if (node) {
+          const el = Array.from(node.children).find(
+            (child) => child.getAttribute("data-label") !== null
+          );
+          return (_b = el == null ? void 0 : el.textContent) != null ? _b : void 0;
+        } else {
+          return allowFree ? value2 : void 0;
+        }
+      }).filter(Boolean);
+      return selectedValues2;
+    },
+    [allowFree, descendants]
+  );
+  const onChangeLabel = useCallback(
+    (newValue, { forceUpdate, runOmit = true } = {}) => {
+      const selectedValues2 = getSelectedValues(newValue);
+      if (!forceUpdate && !selectedValues2.length) return;
+      setLabel((prev) => {
+        if (!isMulti) {
+          return selectedValues2[0];
+        } else {
+          selectedValues2.forEach((selectedValue) => {
+            const isSelected = isArray(prev) && prev.includes(selectedValue != null ? selectedValue : "");
+            if (!isSelected) {
+              prev = [...isArray(prev) ? prev : [], selectedValue];
+            } else if (runOmit) {
+              prev = isArray(prev) ? prev.filter((value2) => value2 !== selectedValue) : void 0;
+            }
+          });
+          return prev;
+        }
+      });
+    },
+    [getSelectedValues, isMulti]
+  );
+  const onChange = useCallback(
+    (newValue, { forceUpdate, runRebirth = true } = {}) => {
+      setValue((prev) => {
+        let next;
+        if (!isArray(prev)) {
+          next = newValue;
+        } else {
+          const isSelected = prev.includes(newValue);
+          if (!isSelected) {
+            next = [...prev, newValue];
+          } else {
+            next = prev.filter((value2) => value2 !== newValue);
+          }
+        }
+        prevValue.current = next;
+        return next;
+      });
+      const isHit2 = descendants.values().filter(
+        ({ node }) => {
+          var _a;
+          return format((_a = node.textContent) != null ? _a : "").includes(newValue);
+        }
+      ).length > 0;
+      onChangeLabel(newValue, { forceUpdate });
+      if (allowFree || isHit2) setInputValue("");
+      if (isMulti && runRebirth) rebirthOptions(false);
+    },
+    [
+      allowFree,
+      isMulti,
+      onChangeLabel,
+      rebirthOptions,
+      setValue,
+      descendants,
+      format
+    ]
+  );
+  const onSelect = useCallback(() => {
+    var _a, _b;
+    let enabledValue = descendants.value(focusedIndex);
+    if ("disabled" in ((_a = enabledValue == null ? void 0 : enabledValue.node.dataset) != null ? _a : {}))
+      enabledValue = void 0;
+    if (!enabledValue) return;
+    const value2 = (_b = enabledValue.node.dataset.value) != null ? _b : "";
+    onChange(value2);
+    if (closeOnSelect) onClose();
+    if (omitSelectedValues) onFocusNext();
+  }, [
+    closeOnSelect,
+    descendants,
+    focusedIndex,
+    omitSelectedValues,
+    onChange,
+    onClose,
+    onFocusNext
+  ]);
+  const onSearch = useCallback(
+    (ev) => {
+      if (!isOpen) onOpen();
+      onSearchProp == null ? void 0 : onSearchProp(ev);
+      const value2 = ev.target.value;
+      const computedValue = format(value2);
+      if (computedValue) {
+        pickOptions(computedValue);
+      } else {
+        rebirthOptions();
+      }
+      setInputValue(value2);
+    },
+    [isOpen, onOpen, format, onSearchProp, pickOptions, rebirthOptions]
+  );
+  const onCompositionStart = useCallback(() => {
+    isComposition.current = true;
+  }, []);
+  const onCompositionEnd = useCallback(() => {
+    isComposition.current = false;
+  }, []);
+  const onCreate = useCallback(() => {
+    var _a, _b;
+    if (!listRef.current) return;
+    const newItem = { label: inputValue, value: inputValue };
+    let newItems = [];
+    if (resolvedItems) newItems = [...resolvedItems];
+    if (firstInsertPositionItem === "first") {
+      newItems = [newItem, ...newItems];
+    } else if (firstInsertPositionItem === "last") {
+      newItems = [...newItems, newItem];
+    } else {
+      const i = newItems.findIndex(
+        ({ label: label2 }) => label2 === firstInsertPositionItem
+      );
+      const targetItem = newItems[i];
+      if (i !== -1 && "items" in targetItem) {
+        if (secondInsertPositionItem === "first") {
+          targetItem.items = [newItem, ...(_a = targetItem.items) != null ? _a : []];
+        } else {
+          targetItem.items = [...(_b = targetItem.items) != null ? _b : [], newItem];
+        }
+        newItems[i] = targetItem;
+      } else {
+        console.warn(
+          `${!isMulti ? "Autocomplete" : "MultiAutocomplete"}: '${firstInsertPositionItem}' specified in insertPositionItem does not exist in the option group.`
+        );
+      }
+    }
+    setResolvedItems(newItems);
+    onChange(inputValue);
+    rebirthOptions(false);
+    const index = flattenItems(newItems).findIndex(
+      ({ value: value2 }) => value2 === inputValue
+    );
+    setFocusedIndex(index);
+    onCreateProp == null ? void 0 : onCreateProp(newItem, newItems);
+  }, [
+    inputValue,
+    resolvedItems,
+    firstInsertPositionItem,
+    onChange,
+    rebirthOptions,
+    onCreateProp,
+    secondInsertPositionItem,
+    isMulti
+  ]);
+  const onClick = useCallback(() => {
+    if (isOpen) {
+      if (inputRef.current) inputRef.current.focus();
+    } else {
+      onOpen();
+      onFocusFirstOrSelected();
+    }
+  }, [isOpen, onFocusFirstOrSelected, onOpen]);
+  const onFocus = useCallback(() => {
+    if (isOpen) return;
+    onOpen();
+    onFocusFirstOrSelected();
+  }, [isOpen, onFocusFirstOrSelected, onOpen]);
+  const onBlur = useCallback(
+    (ev) => {
+      const relatedTarget = getEventRelatedTarget(ev);
+      if (isContains(containerRef.current, relatedTarget)) return;
+      if (!closeOnBlur && isHit) return;
+      if (allowFree && !!inputValue) onChange(inputValue, { runRebirth: false });
+      setInputValue("");
+      if (isOpen) onClose();
+    },
+    [closeOnBlur, isHit, isOpen, inputValue, allowFree, onClose, onChange]
+  );
+  const onDelete = useCallback(() => {
+    if (!isMulti) {
+      onChange("", { forceUpdate: true });
+    } else {
+      onChange(value[value.length - 1]);
+    }
+    if (!isOpen) onFocus();
+  }, [isMulti, isOpen, onChange, onFocus, value]);
+  const onClear = useCallback(
+    (ev) => {
+      ev.stopPropagation();
+      prevValue.current = [];
+      setValue([]);
+      setLabel(void 0);
+      setInputValue("");
+      rebirthOptions();
+      if (isOpen && inputRef.current) inputRef.current.focus();
+    },
+    [isOpen, setLabel, setInputValue, setValue, rebirthOptions]
+  );
+  const onKeyDown = useCallback(
+    (ev) => {
+      if (ev.key === " ") ev.key = ev.code;
+      if (formControlProps.disabled || formControlProps.readOnly) return;
+      if (isComposition.current) return;
+      const enabledDelete = label === inputValue || !inputValue.length;
+      const actions = {
+        ArrowDown: isFocused ? () => onFocusNext() : !isOpen ? funcAll(onOpen, onFocusFirstOrSelected) : void 0,
+        ArrowUp: isFocused ? () => onFocusPrev() : !isOpen ? funcAll(onOpen, onFocusLastOrSelected) : void 0,
+        Space: isCreate ? onCreate : isFocused ? onSelect : !isOpen ? funcAll(onOpen, onFocusFirstOrSelected) : void 0,
+        Enter: isCreate ? onCreate : isFocused ? onSelect : !isOpen ? funcAll(onOpen, onFocusFirstOrSelected) : allowFree && isMulti ? () => {
+          if (inputValue) onChange(inputValue);
+          setFocusedIndex(0);
+        } : void 0,
+        Home: isOpen ? onFocusFirst : void 0,
+        End: isOpen ? onFocusLast : void 0,
+        Escape: closeOnEsc ? onClose : void 0,
+        Backspace: !isEmptyValue && enabledDelete ? onDelete : void 0
+      };
+      const action = actions[ev.key];
+      if (!action) return;
+      ev.preventDefault();
+      ev.stopPropagation();
+      action(ev);
+    },
+    [
+      allowFree,
+      formControlProps,
+      label,
+      inputValue,
+      onOpen,
+      isFocused,
+      isMulti,
+      onFocusFirstOrSelected,
+      onFocusNext,
+      onFocusLastOrSelected,
+      onFocusPrev,
+      isCreate,
+      onCreate,
+      onSelect,
+      isOpen,
+      onFocusFirst,
+      onFocusLast,
+      closeOnEsc,
+      onClose,
+      isEmptyValue,
+      onDelete,
+      onChange
+    ]
+  );
+  useEffect(() => {
+    if (!isMulti) return;
+    if (!omitSelectedValues && isUndefined(maxSelectValues)) return;
+    const isAll = value.length > 0 && value.length === descendants.count();
+    const isMax = value.length === maxSelectValues;
+    if (isAll || isMax) {
+      onClose();
+      setIsAllSelected(true);
+    } else {
+      setIsAllSelected(false);
+    }
+  }, [
+    omitSelectedValues,
+    value,
+    descendants,
+    isMulti,
+    onClose,
+    maxSelectValues
+  ]);
+  useEffect(() => {
+    var _a;
+    if (isMulti) {
+      if (JSON.stringify((_a = prevValue.current) != null ? _a : []) === JSON.stringify(value != null ? value : []))
+        return;
+      const label2 = getSelectedValues(value);
+      setLabel(label2);
+    } else {
+      if (prevValue.current === value) return;
+      onChangeLabel(value, { runOmit: false });
+    }
+  }, [isMulti, value, onChangeLabel, getSelectedValues]);
+  useUpdateEffect(() => {
+    if (isOpen || allowFree) return;
+    setFocusedIndex(-1);
+    setInputValue("");
+  }, [isOpen]);
+  useUpdateEffect(() => {
+    if (!isHit) setFocusedIndex(-2);
+  }, [isHit]);
+  useUpdateEffect(() => {
+    setResolvedItems(items ? JSON.parse(JSON.stringify(items)) : void 0);
+  }, [items]);
+  useUnmountEffect(() => {
+    timeoutIds.current.forEach((id2) => clearTimeout(id2));
+    timeoutIds.current.clear();
+  });
+  useOutsideClick({
+    ref: containerRef,
+    handler: onClose,
+    enabled: isOpen && (closeOnBlur || !isHit)
+  });
+  const getPopoverProps = useCallback(
+    (props2) => ({
+      closeOnBlur,
+      openDelay,
+      closeDelay,
+      isLazy,
+      lazyBehavior,
+      animation,
+      duration,
+      offset,
+      gutter,
+      preventOverflow,
+      flip,
+      matchWidth,
+      boundary,
+      eventListeners,
+      strategy,
+      placement,
+      modifiers,
+      ...props2,
+      trigger: "never",
+      closeOnButton: false,
+      isOpen,
+      onOpen,
+      onClose
+    }),
+    [
+      closeOnBlur,
+      openDelay,
+      closeDelay,
+      isLazy,
+      lazyBehavior,
+      animation,
+      duration,
+      offset,
+      gutter,
+      preventOverflow,
+      flip,
+      matchWidth,
+      boundary,
+      eventListeners,
+      strategy,
+      placement,
+      modifiers,
+      isOpen,
+      onOpen,
+      onClose
+    ]
+  );
+  const getContainerProps = useCallback(
+    (props2 = {}, ref = null) => ({
+      ref: mergeRefs(containerRef, ref),
+      ...containerProps,
+      ...props2,
+      ...formControlProps,
+      onClick: handlerAll(props2.onClick, rest.onClick, onClick),
+      onBlur: handlerAll(props2.onBlur, rest.onBlur, onBlur)
+    }),
+    [containerProps, formControlProps, onBlur, onClick, rest]
+  );
+  const getFieldProps = useCallback(
+    (props2 = {}, ref = null) => ({
+      ref,
+      tabIndex: -1,
+      ...props2,
+      ...formControlProps,
+      placeholder,
+      "data-active": dataAttr(isOpen),
+      "aria-expanded": dataAttr(isOpen),
+      onFocus: handlerAll(props2.onFocus, onFocusProp, onFocus),
+      onKeyDown: handlerAll(props2.onKeyDown, onKeyDownProp, onKeyDown)
+    }),
+    [
+      formControlProps,
+      placeholder,
+      isOpen,
+      onFocusProp,
+      onFocus,
+      onKeyDownProp,
+      onKeyDown
+    ]
+  );
+  return {
+    id,
+    descendants,
+    value,
+    label,
+    inputValue,
+    isHit,
+    isEmpty,
+    computedChildren,
+    focusedIndex,
+    omitSelectedValues,
+    closeOnSelect,
+    allowCreate,
+    allowFree,
+    emptyMessage,
+    isOpen,
+    isAllSelected,
+    listRef,
+    inputRef,
+    optionProps,
+    formControlProps,
+    setFocusedIndex,
+    onChangeLabel,
+    onChange,
+    onSearch,
+    onCreate,
+    onClear,
+    onCompositionStart,
+    onCompositionEnd,
+    pickOptions,
+    rebirthOptions,
+    onOpen,
+    onClose,
+    onFocusFirst,
+    onFocusLast,
+    onFocusSelected,
+    onFocusNext,
+    onFocusPrev,
+    getPopoverProps,
+    getContainerProps,
+    getFieldProps,
+    inputProps
+  };
+};
+var useAutocompleteInput = () => {
+  const {
+    id,
+    inputRef,
+    onSearch,
+    onCompositionStart,
+    onCompositionEnd,
+    isAllSelected,
+    formControlProps,
+    inputProps,
+    isOpen,
+    focusedIndex,
+    listRef
+  } = useAutocompleteContext();
+  const { value } = useAutocompleteDescendantsContext();
+  useUpdateEffect(() => {
+    if (isAllSelected && inputRef.current) inputRef.current.blur();
+  }, [isAllSelected]);
+  const getInputProps = useCallback(
+    (props = {}, ref = null) => {
+      var _a, _b;
+      return {
+        ref: mergeRefs(inputRef, ref),
+        ...formControlProps,
+        role: "combobox",
+        "aria-haspopup": "listbox",
+        "aria-autocomplete": "list",
+        "aria-expanded": isOpen,
+        "aria-activedescendant": (_a = value(focusedIndex)) == null ? void 0 : _a.node.id,
+        "aria-controls": (_b = listRef.current) == null ? void 0 : _b.id,
+        autoCapitalize: "none",
+        autoComplete: "off",
+        spellCheck: "false",
+        ...inputProps,
+        ...props,
+        id,
+        cursor: formControlProps.readOnly ? "default" : "text",
+        pointerEvents: formControlProps.disabled || isAllSelected ? "none" : "auto",
+        tabIndex: isAllSelected ? -1 : 0,
+        onChange: handlerAll(props.onChange, onSearch),
+        onCompositionStart: handlerAll(
+          props.onCompositionStart,
+          inputProps.onCompositionStart,
+          onCompositionStart
+        ),
+        onCompositionEnd: handlerAll(
+          props.onCompositionEnd,
+          inputProps.onCompositionEnd,
+          onCompositionEnd
+        )
+      };
+    },
+    [
+      listRef,
+      focusedIndex,
+      isOpen,
+      inputProps,
+      inputRef,
+      formControlProps,
+      id,
+      isAllSelected,
+      value,
+      onSearch,
+      onCompositionStart,
+      onCompositionEnd
+    ]
+  );
+  return {
+    getInputProps
+  };
+};
+
+export {
+  useAutocomplete,
+  useAutocompleteInput
+};
+//# sourceMappingURL=chunk-GM7RV2YY.mjs.map