@helpwave/hightide 0.1.11 → 0.1.13

package/dist/components/properties/DateProperty.js

@@ -53,47 +53,44 @@ var formatDateTime = (date) => {
 var noop = () => void 0;
 
 // src/components/user-action/Input.tsx
-var import_react2 = require("react");
+var import_react4 = require("react");
 var import_clsx2 = __toESM(require("clsx"));
 
-// src/hooks/useSaveDelay.ts
+// src/hooks/useDelay.ts
 var import_react = require("react");
-function useSaveDelay(setNotificationStatus, delay) {
-  const [updateTimer, setUpdateTimer] = (0, import_react.useState)(void 0);
-  const [notificationTimer, setNotificationTimer] = (0, import_react.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_react.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_react.useEffect)(() => {
     return () => {
-      clearTimeout(updateTimer);
-      clearTimeout(notificationTimer);
+      clearTimeout(timer);
     };
-  }, []);
-  return { restartTimer, clearUpdateTimer };
+  }, [timer]);
+  (0, import_react.useEffect)(() => {
+    if (disabled) {
+      clearTimeout(timer);
+    }
+  }, [disabled, timer]);
+  return { restartTimer, clearTimer };
 }
 
 // src/components/user-action/Label.tsx
@@ -114,9 +111,104 @@ var Label = ({
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("label", { ...props, className: (0, import_clsx.default)(styleMapping[labelType], className), children: children ? children : name });
 };
 
+// src/hooks/useFocusManagement.ts
+var import_react2 = require("react");
+function useFocusManagement() {
+  const getFocusableElements = (0, import_react2.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_react2.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_react2.useCallback)(() => {
+    const nextElement = getNextFocusElement();
+    nextElement?.focus();
+  }, [getNextFocusElement]);
+  const getPreviousFocusElement = (0, import_react2.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_react2.useCallback)(() => {
+    const previousElement = getPreviousFocusElement();
+    if (previousElement) previousElement.focus();
+  }, [getPreviousFocusElement]);
+  return {
+    getFocusableElements,
+    getNextFocusElement,
+    getPreviousFocusElement,
+    focusNext,
+    focusPrevious
+  };
+}
+
+// src/hooks/useFocusOnceVisible.ts
+var import_react3 = __toESM(require("react"));
+var useFocusOnceVisible = (ref, disable = false) => {
+  const [hasUsedFocus, setHasUsedFocus] = import_react3.default.useState(false);
+  (0, import_react3.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_runtime2 = 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_react4.forwardRef)(function Input2({
   id,
   type = "text",
   value,
@@ -125,58 +217,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_react2.useRef)(null);
-  (0, import_react2.useEffect)(() => {
-    if (autoFocus) {
-      ref.current?.focus();
+    clearTimer
+  } = useDelay({ delay, disabled: !afterDelay });
+  const innerRef = (0, import_react4.useRef)(null);
+  const { focusNext } = useFocusManagement();
+  useFocusOnceVisible(innerRef, !autoFocus);
+  (0, import_react4.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_runtime2.jsxs)("div", { className: (0, import_clsx2.default)({ "w-full": expanded }, containerClassName), children: [
     label && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Label, { ...label, htmlFor: id, className: (0, import_clsx2.default)("mb-1", label.className) }),
     /* @__PURE__ */ (0, import_jsx_runtime2.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_react2.forwardRef)(function FormInput2({
+});
+var FormInput = (0, import_react4.forwardRef)(function FormInput2({
   id,
   labelText,
   errorText,
@@ -185,19 +292,18 @@ var FormInput = (0, import_react2.forwardRef)(function FormInput2({
   errorClassName,
   containerClassName,
   required,
+  disabled,
   ...restProps
 }, ref) {
   const input = /* @__PURE__ */ (0, import_jsx_runtime2.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
       )
     }
@@ -219,12 +325,21 @@ var import_clsx4 = __toESM(require("clsx"));
 // src/components/user-action/Button.tsx
 var import_clsx3 = __toESM(require("clsx"));
 var import_jsx_runtime3 = 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"
@@ -262,7 +377,7 @@ var TextButton = ({
       className: (0, import_clsx3.default)(
         {
           "text-disabled-text cursor-not-allowed": disabled,
-          [(0, import_clsx3.default)(colorClasses, "hover:bg-button-text-hover-background rounded-full")]: !disabled
+          [(0, import_clsx3.default)(colorClasses, "hover:bg-button-text-hover-background")]: !disabled
         },
         ButtonUtil.paddingMapping[size],
         className
@@ -296,10 +411,10 @@ var TextButton = ({
 };
 
 // src/localization/LanguageProvider.tsx
-var import_react4 = require("react");
+var import_react6 = require("react");
 
 // src/hooks/useLocalStorage.ts
-var import_react3 = require("react");
+var import_react5 = require("react");
 
 // src/localization/util.ts
 var languages = ["en", "de"];
@@ -316,11 +431,11 @@ var LanguageUtil = {
 
 // src/localization/LanguageProvider.tsx
 var import_jsx_runtime4 = require("react/jsx-runtime");
-var LanguageContext = (0, import_react4.createContext)({
+var LanguageContext = (0, import_react6.createContext)({
   language: LanguageUtil.DEFAULT_LANGUAGE,
   setLanguage: (v) => v
 });
-var useLanguage = () => (0, import_react4.useContext)(LanguageContext);
+var useLanguage = () => (0, import_react6.useContext)(LanguageContext);
 
 // src/localization/useTranslation.ts
 var TranslationPluralCount = {
@@ -386,6 +501,7 @@ var useTranslation = (translations, overwriteTranslation = {}) => {
 var formTranslation = {
   en: {
     all: "All",
+    apply: "Apply",
     back: "Back",
     cancel: "Cancel",
     change: "Change",
@@ -434,6 +550,7 @@ var formTranslation = {
   },
   de: {
     all: "Alle",
+    apply: "Anwenden",
     back: "Zur\xFCck",
     cancel: "Abbrechen",
     change: "\xC4ndern",