@helpwave/hightide 0.1.11 → 0.1.13

package/dist/components/user-action/MultiSelect.js

@@ -33,7 +33,7 @@ __export(MultiSelect_exports, {
   MultiSelectUncontrolled: () => MultiSelectUncontrolled
 });
 module.exports = __toCommonJS(MultiSelect_exports);
-var import_react7 = require("react");
+var import_react9 = require("react");
 var import_lucide_react3 = require("lucide-react");
 
 // src/localization/LanguageProvider.tsx
@@ -149,55 +149,147 @@ var import_lucide_react = require("lucide-react");
 var import_clsx4 = __toESM(require("clsx"));
 
 // src/components/user-action/Input.tsx
-var import_react4 = require("react");
+var import_react6 = require("react");
 var import_clsx2 = __toESM(require("clsx"));
 
-// src/hooks/useSaveDelay.ts
+// src/hooks/useDelay.ts
 var import_react3 = require("react");
-function useSaveDelay(setNotificationStatus, delay) {
-  const [updateTimer, setUpdateTimer] = (0, import_react3.useState)(void 0);
-  const [notificationTimer, setNotificationTimer] = (0, import_react3.useState)(void 0);
-  const restartTimer = (onSave) => {
-    clearTimeout(updateTimer);
-    setUpdateTimer(setTimeout(() => {
-      onSave();
-      setNotificationStatus(true);
-      clearTimeout(notificationTimer);
-      setNotificationTimer(setTimeout(() => {
-        setNotificationStatus(false);
-        clearTimeout(notificationTimer);
-      }, delay));
-      clearTimeout(updateTimer);
-    }, delay));
+var defaultOptions = {
+  delay: 3e3,
+  disabled: false
+};
+function useDelay(options) {
+  const [timer, setTimer] = (0, import_react3.useState)(void 0);
+  const { delay, disabled } = {
+    ...defaultOptions,
+    ...options
   };
-  const clearUpdateTimer = (hasSaved = true) => {
-    clearTimeout(updateTimer);
-    if (hasSaved) {
-      setNotificationStatus(true);
-      clearTimeout(notificationTimer);
-      setNotificationTimer(setTimeout(() => {
-        setNotificationStatus(false);
-        clearTimeout(notificationTimer);
-      }, delay));
-    } else {
-      setNotificationStatus(false);
+  const restartTimer = (onDelayFinish) => {
+    if (disabled) {
+      return;
     }
+    clearTimeout(timer);
+    setTimer(setTimeout(() => {
+      onDelayFinish();
+    }, delay));
+  };
+  const clearTimer = () => {
+    clearTimeout(timer);
   };
   (0, import_react3.useEffect)(() => {
     return () => {
-      clearTimeout(updateTimer);
-      clearTimeout(notificationTimer);
+      clearTimeout(timer);
     };
-  }, []);
-  return { restartTimer, clearUpdateTimer };
+  }, [timer]);
+  (0, import_react3.useEffect)(() => {
+    if (disabled) {
+      clearTimeout(timer);
+    }
+  }, [disabled, timer]);
+  return { restartTimer, clearTimer };
 }
 
 // src/util/noop.ts
 var noop = () => void 0;
 
+// src/hooks/useFocusManagement.ts
+var import_react4 = require("react");
+function useFocusManagement() {
+  const getFocusableElements = (0, import_react4.useCallback)(() => {
+    return Array.from(
+      document.querySelectorAll(
+        'input, button, select, textarea, a[href], [tabindex]:not([tabindex="-1"])'
+      )
+    ).filter(
+      (el) => el instanceof HTMLElement && !el.hasAttribute("disabled") && !el.hasAttribute("hidden") && el.tabIndex !== -1
+    );
+  }, []);
+  const getNextFocusElement = (0, import_react4.useCallback)(() => {
+    const elements = getFocusableElements();
+    if (elements.length === 0) {
+      return void 0;
+    }
+    let nextElement = elements[0];
+    if (document.activeElement instanceof HTMLElement) {
+      const currentIndex = elements.indexOf(document.activeElement);
+      nextElement = elements[(currentIndex + 1) % elements.length];
+    }
+    return nextElement;
+  }, [getFocusableElements]);
+  const focusNext = (0, import_react4.useCallback)(() => {
+    const nextElement = getNextFocusElement();
+    nextElement?.focus();
+  }, [getNextFocusElement]);
+  const getPreviousFocusElement = (0, import_react4.useCallback)(() => {
+    const elements = getFocusableElements();
+    if (elements.length === 0) {
+      return void 0;
+    }
+    let previousElement = elements[0];
+    if (document.activeElement instanceof HTMLElement) {
+      const currentIndex = elements.indexOf(document.activeElement);
+      if (currentIndex === 0) {
+        previousElement = elements[elements.length - 1];
+      } else {
+        previousElement = elements[currentIndex - 1];
+      }
+    }
+    return previousElement;
+  }, [getFocusableElements]);
+  const focusPrevious = (0, import_react4.useCallback)(() => {
+    const previousElement = getPreviousFocusElement();
+    if (previousElement) previousElement.focus();
+  }, [getPreviousFocusElement]);
+  return {
+    getFocusableElements,
+    getNextFocusElement,
+    getPreviousFocusElement,
+    focusNext,
+    focusPrevious
+  };
+}
+
+// src/hooks/useFocusOnceVisible.ts
+var import_react5 = __toESM(require("react"));
+var useFocusOnceVisible = (ref, disable = false) => {
+  const [hasUsedFocus, setHasUsedFocus] = import_react5.default.useState(false);
+  (0, import_react5.useEffect)(() => {
+    if (disable || hasUsedFocus) {
+      return;
+    }
+    const observer = new IntersectionObserver(([entry]) => {
+      if (entry.isIntersecting && !hasUsedFocus) {
+        ref.current?.focus();
+        setHasUsedFocus(hasUsedFocus);
+      }
+    }, {
+      threshold: 0.1
+    });
+    if (ref.current) {
+      observer.observe(ref.current);
+    }
+    return () => observer.disconnect();
+  }, [disable, hasUsedFocus, ref]);
+};
+
 // src/components/user-action/Input.tsx
 var import_jsx_runtime3 = require("react/jsx-runtime");
-var Input = ({
+var getInputClassName = ({ disabled = false, hasError = false }) => {
+  return (0, import_clsx2.default)(
+    "px-2 py-1.5 rounded-md border-2",
+    {
+      "bg-surface text-on-surface hover:border-primary focus:border-primary": !disabled && !hasError,
+      "bg-on-negative text-negative border-negative-border hover:border-negative-border-hover": !disabled && hasError,
+      "bg-disabled-background text-disabled-text border-disabled-border": disabled
+    }
+  );
+};
+var defaultEditCompleteOptions = {
+  onBlur: true,
+  afterDelay: true,
+  delay: 2500
+};
+var Input = (0, import_react6.forwardRef)(function Input2({
   id,
   type = "text",
   value,
@@ -206,58 +298,73 @@ var Input = ({
   onChangeText = noop,
   onEditCompleted,
   className = "",
+  allowEnterComplete = true,
   expanded = true,
-  autoFocus,
+  autoFocus = false,
   onBlur,
+  editCompleteOptions,
   containerClassName,
+  disabled,
   ...restProps
-}) => {
+}, forwardedRef) {
+  const { onBlur: allowEditCompleteOnBlur, afterDelay, delay } = { ...defaultEditCompleteOptions, ...editCompleteOptions };
   const {
     restartTimer,
-    clearUpdateTimer
-  } = useSaveDelay(() => void 0, 3e3);
-  const ref = (0, import_react4.useRef)(null);
-  (0, import_react4.useEffect)(() => {
-    if (autoFocus) {
-      ref.current?.focus();
+    clearTimer
+  } = useDelay({ delay, disabled: !afterDelay });
+  const innerRef = (0, import_react6.useRef)(null);
+  const { focusNext } = useFocusManagement();
+  useFocusOnceVisible(innerRef, !autoFocus);
+  (0, import_react6.useImperativeHandle)(forwardedRef, () => innerRef.current);
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      innerRef.current?.blur();
+      focusNext();
     }
-  }, [autoFocus]);
+  };
   return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: (0, import_clsx2.default)({ "w-full": expanded }, containerClassName), children: [
     label && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Label, { ...label, htmlFor: id, className: (0, import_clsx2.default)("mb-1", label.className) }),
     /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
       "input",
       {
-        ref,
+        ...restProps,
+        ref: innerRef,
         value,
         id,
         type,
-        className,
+        disabled,
+        className: (0, import_clsx2.default)(getInputClassName({ disabled }), className),
+        onKeyDown: allowEnterComplete ? handleKeyDown : void 0,
         onBlur: (event) => {
-          if (onBlur) {
-            onBlur(event);
-          }
-          if (onEditCompleted) {
+          onBlur?.(event);
+          if (onEditCompleted && allowEditCompleteOnBlur) {
             onEditCompleted(event.target.value);
-            clearUpdateTimer();
+            clearTimer();
           }
         },
         onChange: (e) => {
           const value2 = e.target.value;
           if (onEditCompleted) {
             restartTimer(() => {
-              onEditCompleted(value2);
-              clearUpdateTimer();
+              if (innerRef.current) {
+                innerRef.current.blur();
+                if (!allowEditCompleteOnBlur) {
+                  onEditCompleted(value2);
+                }
+              } else {
+                onEditCompleted(value2);
+              }
             });
           }
           onChange(e);
           onChangeText(value2);
-        },
-        ...restProps
+        }
       }
     )
   ] });
-};
-var FormInput = (0, import_react4.forwardRef)(function FormInput2({
+});
+var FormInput = (0, import_react6.forwardRef)(function FormInput2({
   id,
   labelText,
   errorText,
@@ -266,19 +373,18 @@ var FormInput = (0, import_react4.forwardRef)(function FormInput2({
   errorClassName,
   containerClassName,
   required,
+  disabled,
   ...restProps
 }, ref) {
   const input = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
     "input",
     {
+      ...restProps,
       ref,
       id,
-      ...restProps,
+      disabled,
       className: (0, import_clsx2.default)(
-        {
-          "focus:border-primary focus:ring-primary": !errorText,
-          "focus:border-negative focus:ring-negative text-negative": !!errorText
-        },
+        getInputClassName({ disabled, hasError: !!errorText }),
         className
       )
     }
@@ -296,12 +402,21 @@ var FormInput = (0, import_react4.forwardRef)(function FormInput2({
 // src/components/user-action/Button.tsx
 var import_clsx3 = __toESM(require("clsx"));
 var import_jsx_runtime4 = require("react/jsx-runtime");
+var ButtonColorUtil = {
+  solid: ["primary", "secondary", "tertiary", "positive", "warning", "negative", "neutral"],
+  text: ["primary", "negative", "neutral"],
+  outline: ["primary"]
+};
+var IconButtonUtil = {
+  icon: [...ButtonColorUtil.solid, "transparent"]
+};
 var paddingMapping = {
   small: "btn-sm",
   medium: "btn-md",
   large: "btn-lg"
 };
 var iconPaddingMapping = {
+  tiny: "icon-btn-xs",
   small: "icon-btn-sm",
   medium: "icon-btn-md",
   large: "icon-btn-lg"
@@ -395,7 +510,8 @@ var IconButton = ({
     positive: "bg-button-solid-positive-background text-button-solid-positive-text",
     warning: "bg-button-solid-warning-background text-button-solid-warning-text",
     negative: "bg-button-solid-negative-background text-button-solid-negative-text",
-    neutral: "bg-button-solid-neutral-background text-button-solid-neutral-text"
+    neutral: "bg-button-solid-neutral-background text-button-solid-neutral-text",
+    transparent: "bg-transparent"
   }[color];
   return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
     "button",
@@ -404,7 +520,9 @@ var IconButton = ({
       disabled: disabled || onClick === void 0,
       className: (0, import_clsx3.default)(
         {
-          "text-disabled-text bg-disabled-background cursor-not-allowed": disabled,
+          "text-disabled-text bg-disabled-background cursor-not-allowed": disabled && color !== "transparent",
+          "text-disabled-text cursor-not-allowed opacity-70": disabled && color === "transparent",
+          "hover:bg-button-text-hover-background": !disabled && color === "transparent",
           [(0, import_clsx3.default)(colorClasses, "hover:brightness-90")]: !disabled
         },
         ButtonUtil.iconPaddingMapping[size],
@@ -417,7 +535,7 @@ var IconButton = ({
 };
 
 // src/hooks/useSearch.ts
-var import_react5 = require("react");
+var import_react7 = require("react");
 
 // src/util/simpleSearch.ts
 var MultiSearchWithMapping = (search, objects, mapping) => {
@@ -436,12 +554,12 @@ var useSearch = ({
   initialSearch,
   searchMapping
 }) => {
-  const [items, setItems] = (0, import_react5.useState)(list);
-  const [search, setSearch] = (0, import_react5.useState)(initialSearch);
-  (0, import_react5.useEffect)(() => {
+  const [items, setItems] = (0, import_react7.useState)(list);
+  const [search, setSearch] = (0, import_react7.useState)(initialSearch);
+  (0, import_react7.useEffect)(() => {
     setItems(list);
   }, [list]);
-  const result = (0, import_react5.useMemo)(
+  const result = (0, import_react7.useMemo)(
     () => MultiSearchWithMapping(search, items, searchMapping),
     [search, items, searchMapping]
   );
@@ -459,6 +577,7 @@ var useSearch = ({
 var formTranslation = {
   en: {
     all: "All",
+    apply: "Apply",
     back: "Back",
     cancel: "Cancel",
     change: "Change",
@@ -507,6 +626,7 @@ var formTranslation = {
   },
   de: {
     all: "Alle",
+    apply: "Anwenden",
     back: "Zur\xFCck",
     cancel: "Abbrechen",
     change: "\xC4ndern",
@@ -704,9 +824,9 @@ var ChipList = ({
 };
 
 // src/hooks/useOutsideClick.ts
-var import_react6 = require("react");
+var import_react8 = require("react");
 var useOutsideClick = (refs, handler) => {
-  (0, import_react6.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     const listener = (event) => {
       if (event.target === null) return;
       if (refs.some((ref) => !ref.current || ref.current.contains(event.target))) {
@@ -746,9 +866,9 @@ var MultiSelect = ({
   className = ""
 }) => {
   const translation = useTranslation([formTranslation, defaultMultiSelectTranslation], overwriteTranslation);
-  const triggerRef = (0, import_react7.useRef)(null);
-  const menuRef = (0, import_react7.useRef)(null);
-  const [isOpen, setIsOpen] = (0, import_react7.useState)(false);
+  const triggerRef = (0, import_react9.useRef)(null);
+  const menuRef = (0, import_react9.useRef)(null);
+  const [isOpen, setIsOpen] = (0, import_react9.useState)(false);
   useOutsideClick([triggerRef, menuRef], () => setIsOpen(false));
   const selectedItems = options.filter((value) => value.selected);
   const isShowingHint = !selectedDisplayOverwrite && selectedItems.length === 0;
@@ -860,8 +980,8 @@ var MultiSelectUncontrolled = ({
   onChange,
   ...props
 }) => {
-  const [usedOptions, setUsedOptions] = (0, import_react7.useState)(options);
-  (0, import_react7.useEffect)(() => {
+  const [usedOptions, setUsedOptions] = (0, import_react9.useState)(options);
+  (0, import_react9.useEffect)(() => {
     setUsedOptions(options);
   }, [options]);
   return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(