@helpwave/hightide 0.1.11 → 0.1.13

package/dist/components/modals/InputModal.mjs

@@ -1,45 +1,42 @@
 // src/components/user-action/Input.tsx
-import { forwardRef, useEffect as useEffect2, useRef, useState as useState2 } from "react";
+import { forwardRef, useEffect as useEffect3, useImperativeHandle, useRef, useState as useState2 } from "react";
 import clsx2 from "clsx";
 
-// src/hooks/useSaveDelay.ts
+// src/hooks/useDelay.ts
 import { useEffect, useState } from "react";
-function useSaveDelay(setNotificationStatus, delay) {
-  const [updateTimer, setUpdateTimer] = useState(void 0);
-  const [notificationTimer, setNotificationTimer] = 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] = 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);
   };
   useEffect(() => {
     return () => {
-      clearTimeout(updateTimer);
-      clearTimeout(notificationTimer);
+      clearTimeout(timer);
     };
-  }, []);
-  return { restartTimer, clearUpdateTimer };
+  }, [timer]);
+  useEffect(() => {
+    if (disabled) {
+      clearTimeout(timer);
+    }
+  }, [disabled, timer]);
+  return { restartTimer, clearTimer };
 }
 
 // src/util/noop.ts
@@ -63,9 +60,104 @@ var Label = ({
   return /* @__PURE__ */ jsx("label", { ...props, className: clsx(styleMapping[labelType], className), children: children ? children : name });
 };
 
+// src/hooks/useFocusManagement.ts
+import { useCallback } from "react";
+function useFocusManagement() {
+  const getFocusableElements = 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 = 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 = useCallback(() => {
+    const nextElement = getNextFocusElement();
+    nextElement?.focus();
+  }, [getNextFocusElement]);
+  const getPreviousFocusElement = 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 = useCallback(() => {
+    const previousElement = getPreviousFocusElement();
+    if (previousElement) previousElement.focus();
+  }, [getPreviousFocusElement]);
+  return {
+    getFocusableElements,
+    getNextFocusElement,
+    getPreviousFocusElement,
+    focusNext,
+    focusPrevious
+  };
+}
+
+// src/hooks/useFocusOnceVisible.ts
+import React, { useEffect as useEffect2 } from "react";
+var useFocusOnceVisible = (ref, disable = false) => {
+  const [hasUsedFocus, setHasUsedFocus] = React.useState(false);
+  useEffect2(() => {
+    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
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
-var Input = ({
+var getInputClassName = ({ disabled = false, hasError = false }) => {
+  return clsx2(
+    "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 = forwardRef(function Input2({
   id,
   type = "text",
   value,
@@ -74,57 +166,72 @@ 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 = useRef(null);
-  useEffect2(() => {
-    if (autoFocus) {
-      ref.current?.focus();
+    clearTimer
+  } = useDelay({ delay, disabled: !afterDelay });
+  const innerRef = useRef(null);
+  const { focusNext } = useFocusManagement();
+  useFocusOnceVisible(innerRef, !autoFocus);
+  useImperativeHandle(forwardedRef, () => innerRef.current);
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      innerRef.current?.blur();
+      focusNext();
     }
-  }, [autoFocus]);
+  };
   return /* @__PURE__ */ jsxs("div", { className: clsx2({ "w-full": expanded }, containerClassName), children: [
     label && /* @__PURE__ */ jsx2(Label, { ...label, htmlFor: id, className: clsx2("mb-1", label.className) }),
     /* @__PURE__ */ jsx2(
       "input",
       {
-        ref,
+        ...restProps,
+        ref: innerRef,
         value,
         id,
         type,
-        className,
+        disabled,
+        className: clsx2(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 = forwardRef(function FormInput2({
   id,
   labelText,
@@ -134,19 +241,18 @@ var FormInput = forwardRef(function FormInput2({
   errorClassName,
   containerClassName,
   required,
+  disabled,
   ...restProps
 }, ref) {
   const input = /* @__PURE__ */ jsx2(
     "input",
     {
+      ...restProps,
       ref,
       id,
-      ...restProps,
+      disabled,
       className: clsx2(
-        {
-          "focus:border-primary focus:ring-primary": !errorText,
-          "focus:border-negative focus:ring-negative text-negative": !!errorText
-        },
+        getInputClassName({ disabled, hasError: !!errorText }),
         className
       )
     }
@@ -164,12 +270,21 @@ var FormInput = forwardRef(function FormInput2({
 // src/components/user-action/Button.tsx
 import clsx3 from "clsx";
 import { jsx as jsx3, jsxs as jsxs2 } from "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"
@@ -263,7 +378,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__ */ jsx3(
     "button",
@@ -272,7 +388,9 @@ var IconButton = ({
       disabled: disabled || onClick === void 0,
       className: clsx3(
         {
-          "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",
           [clsx3(colorClasses, "hover:brightness-90")]: !disabled
         },
         ButtonUtil.iconPaddingMapping[size],
@@ -285,10 +403,10 @@ var IconButton = ({
 };
 
 // src/localization/LanguageProvider.tsx
-import { createContext, useContext, useEffect as useEffect4, useState as useState4 } from "react";
+import { createContext, useContext, useEffect as useEffect5, useState as useState4 } from "react";
 
 // src/hooks/useLocalStorage.ts
-import { useCallback, useEffect as useEffect3, useState as useState3 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect4, useState as useState3 } from "react";
 
 // src/localization/util.ts
 var languages = ["en", "de"];
@@ -375,12 +493,12 @@ var useTranslation = (translations, overwriteTranslation = {}) => {
 import clsx6 from "clsx";
 
 // src/components/layout-and-navigation/Overlay.tsx
-import { useEffect as useEffect6, useRef as useRef2, useState as useState6 } from "react";
+import { useEffect as useEffect7, useRef as useRef2, useState as useState6 } from "react";
 import ReactDOM from "react-dom";
 import clsx5 from "clsx";
 
 // src/hooks/useHoverState.ts
-import { useEffect as useEffect5, useState as useState5 } from "react";
+import { useEffect as useEffect6, useState as useState5 } from "react";
 var defaultUseHoverStateProps = {
   closingDelay: 200,
   isDisabled: false
@@ -404,14 +522,14 @@ var useHoverState = (props = void 0) => {
       setIsHovered(false);
     }, closingDelay));
   };
-  useEffect5(() => {
+  useEffect6(() => {
     if (timer) {
       return () => {
         clearTimeout(timer);
       };
     }
   });
-  useEffect5(() => {
+  useEffect6(() => {
     if (timer) {
       clearTimeout(timer);
     }
@@ -496,6 +614,7 @@ import { X } from "lucide-react";
 var formTranslation = {
   en: {
     all: "All",
+    apply: "Apply",
     back: "Back",
     cancel: "Cancel",
     change: "Change",
@@ -544,6 +663,7 @@ var formTranslation = {
   },
   de: {
     all: "Alle",
+    apply: "Anwenden",
     back: "Zur\xFCck",
     cancel: "Abbrechen",
     change: "\xC4ndern",
@@ -601,7 +721,7 @@ var Overlay = ({
   backgroundClassName
 }) => {
   const [root, setRoot] = useState6();
-  useEffect6(() => {
+  useEffect7(() => {
     setRoot(document.body);
   }, []);
   if (!root || !isOpen) return null;
@@ -664,7 +784,7 @@ var Modal = ({
   headerProps
 }) => {
   const ref = useRef2(null);
-  useEffect6(() => {
+  useEffect7(() => {
     if (!isOpen) return;
     const modal = ref.current;
     if (!modal) {