@helpwave/hightide 0.1.11 → 0.1.13

package/dist/components/properties/SelectProperty.mjs

@@ -96,12 +96,21 @@ import clsx2 from "clsx";
 // src/components/user-action/Button.tsx
 import clsx from "clsx";
 import { jsx as jsx2, jsxs } 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"
@@ -139,7 +148,7 @@ var TextButton = ({
       className: clsx(
         {
           "text-disabled-text cursor-not-allowed": disabled,
-          [clsx(colorClasses, "hover:bg-button-text-hover-background rounded-full")]: !disabled
+          [clsx(colorClasses, "hover:bg-button-text-hover-background")]: !disabled
         },
         ButtonUtil.paddingMapping[size],
         className
@@ -187,7 +196,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__ */ jsx2(
     "button",
@@ -196,7 +206,9 @@ var IconButton = ({
       disabled: disabled || onClick === void 0,
       className: clsx(
         {
-          "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",
           [clsx(colorClasses, "hover:brightness-90")]: !disabled
         },
         ButtonUtil.iconPaddingMapping[size],
@@ -212,6 +224,7 @@ var IconButton = ({
 var formTranslation = {
   en: {
     all: "All",
+    apply: "Apply",
     back: "Back",
     cancel: "Cancel",
     change: "Change",
@@ -260,6 +273,7 @@ var formTranslation = {
   },
   de: {
     all: "Alle",
+    apply: "Anwenden",
     back: "Zur\xFCck",
     cancel: "Abbrechen",
     change: "\xC4ndern",
@@ -365,7 +379,7 @@ var PropertyBase = ({
 
 // src/components/user-action/Select.tsx
 import { ChevronDown, ChevronUp } from "lucide-react";
-import { useEffect as useEffect7, useRef as useRef2, useState as useState6 } from "react";
+import { useEffect as useEffect8, useRef as useRef2, useState as useState6 } from "react";
 import clsx7 from "clsx";
 
 // src/components/user-action/Label.tsx
@@ -391,55 +405,147 @@ import { Search } from "lucide-react";
 import clsx5 from "clsx";
 
 // src/components/user-action/Input.tsx
-import { forwardRef, useEffect as useEffect4, useRef, useState as useState4 } from "react";
+import { forwardRef, useEffect as useEffect5, useImperativeHandle, useRef, useState as useState4 } from "react";
 import clsx4 from "clsx";
 
-// src/hooks/useSaveDelay.ts
+// src/hooks/useDelay.ts
 import { useEffect as useEffect3, useState as useState3 } from "react";
-function useSaveDelay(setNotificationStatus, delay) {
-  const [updateTimer, setUpdateTimer] = useState3(void 0);
-  const [notificationTimer, setNotificationTimer] = useState3(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] = useState3(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);
   };
   useEffect3(() => {
     return () => {
-      clearTimeout(updateTimer);
-      clearTimeout(notificationTimer);
+      clearTimeout(timer);
     };
-  }, []);
-  return { restartTimer, clearUpdateTimer };
+  }, [timer]);
+  useEffect3(() => {
+    if (disabled) {
+      clearTimeout(timer);
+    }
+  }, [disabled, timer]);
+  return { restartTimer, clearTimer };
 }
 
 // src/util/noop.ts
 var noop = () => void 0;
 
+// src/hooks/useFocusManagement.ts
+import { useCallback as useCallback2 } from "react";
+function useFocusManagement() {
+  const getFocusableElements = useCallback2(() => {
+    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 = useCallback2(() => {
+    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 = useCallback2(() => {
+    const nextElement = getNextFocusElement();
+    nextElement?.focus();
+  }, [getNextFocusElement]);
+  const getPreviousFocusElement = useCallback2(() => {
+    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 = useCallback2(() => {
+    const previousElement = getPreviousFocusElement();
+    if (previousElement) previousElement.focus();
+  }, [getPreviousFocusElement]);
+  return {
+    getFocusableElements,
+    getNextFocusElement,
+    getPreviousFocusElement,
+    focusNext,
+    focusPrevious
+  };
+}
+
+// src/hooks/useFocusOnceVisible.ts
+import React, { useEffect as useEffect4 } from "react";
+var useFocusOnceVisible = (ref, disable = false) => {
+  const [hasUsedFocus, setHasUsedFocus] = React.useState(false);
+  useEffect4(() => {
+    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 jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
-var Input = ({
+var getInputClassName = ({ disabled = false, hasError = false }) => {
+  return clsx4(
+    "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,
@@ -448,57 +554,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);
-  useEffect4(() => {
-    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__ */ jsxs3("div", { className: clsx4({ "w-full": expanded }, containerClassName), children: [
     label && /* @__PURE__ */ jsx5(Label, { ...label, htmlFor: id, className: clsx4("mb-1", label.className) }),
     /* @__PURE__ */ jsx5(
       "input",
       {
-        ref,
+        ...restProps,
+        ref: innerRef,
         value,
         id,
         type,
-        className,
+        disabled,
+        className: clsx4(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,
@@ -508,19 +629,18 @@ var FormInput = forwardRef(function FormInput2({
   errorClassName,
   containerClassName,
   required,
+  disabled,
   ...restProps
 }, ref) {
   const input = /* @__PURE__ */ jsx5(
     "input",
     {
+      ...restProps,
       ref,
       id,
-      ...restProps,
+      disabled,
       className: clsx4(
-        {
-          "focus:border-primary focus:ring-primary": !errorText,
-          "focus:border-negative focus:ring-negative text-negative": !!errorText
-        },
+        getInputClassName({ disabled, hasError: !!errorText }),
         className
       )
     }
@@ -536,7 +656,7 @@ var FormInput = forwardRef(function FormInput2({
 });
 
 // src/hooks/useSearch.ts
-import { useEffect as useEffect5, useMemo, useState as useState5 } from "react";
+import { useEffect as useEffect6, useMemo, useState as useState5 } from "react";
 
 // src/util/simpleSearch.ts
 var MultiSearchWithMapping = (search, objects, mapping) => {
@@ -557,7 +677,7 @@ var useSearch = ({
 }) => {
   const [items, setItems] = useState5(list);
   const [search, setSearch] = useState5(initialSearch);
-  useEffect5(() => {
+  useEffect6(() => {
     setItems(list);
   }, [list]);
   const result = useMemo(
@@ -658,9 +778,9 @@ var Tile = ({
 };
 
 // src/hooks/useOutsideClick.ts
-import { useEffect as useEffect6 } from "react";
+import { useEffect as useEffect7 } from "react";
 var useOutsideClick = (refs, handler) => {
-  useEffect6(() => {
+  useEffect7(() => {
     const listener = (event) => {
       if (event.target === null) return;
       if (refs.some((ref) => !ref.current || ref.current.contains(event.target))) {