@helpwave/hightide 0.1.45 → 0.1.47

package/dist/{components/index.js → index.mjs}

@@ -34,17 +34,17 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var require_use_sync_external_store_shim_production = __commonJS({
   "node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js"(exports) {
     "use strict";
-    var React20 = __require("react");
+    var React21 = __require("react");
     function is(x, y) {
       return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
     }
     var objectIs = "function" === typeof Object.is ? Object.is : is;
-    var useState35 = React20.useState;
-    var useEffect36 = React20.useEffect;
-    var useLayoutEffect3 = React20.useLayoutEffect;
-    var useDebugValue = React20.useDebugValue;
+    var useState36 = React21.useState;
+    var useEffect39 = React21.useEffect;
+    var useLayoutEffect3 = React21.useLayoutEffect;
+    var useDebugValue = React21.useDebugValue;
     function useSyncExternalStore$2(subscribe2, getSnapshot) {
-      var value = getSnapshot(), _useState = useState35({ inst: { value, getSnapshot } }), inst = _useState[0].inst, forceUpdate = _useState[1];
+      var value = getSnapshot(), _useState = useState36({ inst: { value, getSnapshot } }), inst = _useState[0].inst, forceUpdate = _useState[1];
       useLayoutEffect3(
         function() {
           inst.value = value;
@@ -53,7 +53,7 @@ var require_use_sync_external_store_shim_production = __commonJS({
         },
         [subscribe2, value, getSnapshot]
       );
-      useEffect36(
+      useEffect39(
         function() {
           checkIfSnapshotChanged(inst) && forceUpdate({ inst });
           return subscribe2(function() {
@@ -79,7 +79,7 @@ var require_use_sync_external_store_shim_production = __commonJS({
       return getSnapshot();
     }
     var shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
-    exports.useSyncExternalStore = void 0 !== React20.useSyncExternalStore ? React20.useSyncExternalStore : shim;
+    exports.useSyncExternalStore = void 0 !== React21.useSyncExternalStore ? React21.useSyncExternalStore : shim;
   }
 });
 
@@ -92,7 +92,7 @@ var require_use_sync_external_store_shim_development = __commonJS({
         return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
       }
       function useSyncExternalStore$2(subscribe2, getSnapshot) {
-        didWarnOld18Alpha || void 0 === React20.startTransition || (didWarnOld18Alpha = true, console.error(
+        didWarnOld18Alpha || void 0 === React21.startTransition || (didWarnOld18Alpha = true, console.error(
           "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
         ));
         var value = getSnapshot();
@@ -102,7 +102,7 @@ var require_use_sync_external_store_shim_development = __commonJS({
             "The result of getSnapshot should be cached to avoid an infinite loop"
           ), didWarnUncachedGetSnapshot = true);
         }
-        cachedValue = useState35({
+        cachedValue = useState36({
           inst: { value, getSnapshot }
         });
         var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
@@ -114,7 +114,7 @@ var require_use_sync_external_store_shim_development = __commonJS({
           },
           [subscribe2, value, getSnapshot]
         );
-        useEffect36(
+        useEffect39(
           function() {
             checkIfSnapshotChanged(inst) && forceUpdate({ inst });
             return subscribe2(function() {
@@ -140,8 +140,8 @@ var require_use_sync_external_store_shim_development = __commonJS({
         return getSnapshot();
       }
       "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
-      var React20 = __require("react"), objectIs = "function" === typeof Object.is ? Object.is : is, useState35 = React20.useState, useEffect36 = React20.useEffect, useLayoutEffect3 = React20.useLayoutEffect, useDebugValue = React20.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
-      exports.useSyncExternalStore = void 0 !== React20.useSyncExternalStore ? React20.useSyncExternalStore : shim;
+      var React21 = __require("react"), objectIs = "function" === typeof Object.is ? Object.is : is, useState36 = React21.useState, useEffect39 = React21.useEffect, useLayoutEffect3 = React21.useLayoutEffect, useDebugValue = React21.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+      exports.useSyncExternalStore = void 0 !== React21.useSyncExternalStore ? React21.useSyncExternalStore : shim;
       "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
     }();
   }
@@ -6365,6 +6365,50 @@ var require_link2 = __commonJS({
   }
 });
 
+// src/coloring/shading.ts
+import tinycolor from "tinycolor2";
+
+// src/coloring/types.ts
+var shadingColorValues = [0, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500, 550, 600, 650, 700, 750, 800, 850, 900, 950, 1e3];
+
+// src/coloring/shading.ts
+var generateShadingColors = (partialShading) => {
+  const shading = {
+    0: "#FFFFFF",
+    1e3: "#000000"
+  };
+  let index = 1;
+  while (index < shadingColorValues.length - 1) {
+    const previous = shadingColorValues[index - 1];
+    const current = shadingColorValues[index];
+    if (partialShading[current] !== void 0) {
+      shading[current] = partialShading[current];
+      index++;
+      continue;
+    }
+    let j = index + 1;
+    while (j < shadingColorValues.length) {
+      if (partialShading[shadingColorValues[j]] !== void 0) {
+        break;
+      }
+      j++;
+    }
+    if (j === shadingColorValues.length) {
+      j = shadingColorValues.length - 1;
+    }
+    const nextFound = shadingColorValues[j];
+    const interval = nextFound - previous;
+    for (let k = index; k < j; k++) {
+      const current2 = shadingColorValues[k];
+      const previousValue = partialShading[previous] ?? shading[previous];
+      const nextValue = partialShading[nextFound] ?? shading[nextFound];
+      shading[current2] = tinycolor.mix(tinycolor(previousValue), tinycolor(nextValue), (current2 - previous) / interval * 100).toHexString();
+    }
+    index = j;
+  }
+  return shading;
+};
+
 // src/components/icons-and-geometry/HelpwaveLogo.tsx
 import { clsx } from "clsx";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -6561,6 +6605,9 @@ var createLoopingListWithIndex = (list, startIndex = 0, length = 0, forwards = t
   }
   return returnList;
 };
+var createLoopingList = (list, startIndex = 0, length = 0, forwards = true) => {
+  return createLoopingListWithIndex(list, startIndex, length, forwards).map(([_, item]) => item);
+};
 var moveItems = (list, move = 0) => {
   const result = [];
   let start = move;
@@ -6615,6 +6662,10 @@ var formatDateTime = (date) => {
   const minutes = date.getMinutes().toString().padStart(2, "0");
   return `${dateString}T${hours}:${minutes}`;
 };
+var getDaysInMonth = (year, month) => {
+  const lastDayOfMonth = new Date(year, month + 1, 0);
+  return lastDayOfMonth.getDate();
+};
 var changeDuration = (date, duration, isAdding) => {
   const {
     years = 0,
@@ -6670,6 +6721,28 @@ var addDuration = (date, duration) => {
 var subtractDuration = (date, duration) => {
   return changeDuration(date, duration, false);
 };
+var getBetweenDuration = (startDate, endDate) => {
+  const durationInMilliseconds = endDate.getTime() - startDate.getTime();
+  const millisecondsInSecond = 1e3;
+  const millisecondsInMinute = 60 * millisecondsInSecond;
+  const millisecondsInHour = 60 * millisecondsInMinute;
+  const millisecondsInDay = 24 * millisecondsInHour;
+  const millisecondsInMonth = 30 * millisecondsInDay;
+  const years = Math.floor(durationInMilliseconds / (365.25 * millisecondsInDay));
+  const months = Math.floor(durationInMilliseconds / millisecondsInMonth);
+  const days = Math.floor(durationInMilliseconds / millisecondsInDay);
+  const hours = Math.floor(durationInMilliseconds % millisecondsInDay / millisecondsInHour);
+  const seconds = Math.floor(durationInMilliseconds % millisecondsInHour / millisecondsInSecond);
+  const milliseconds = durationInMilliseconds % millisecondsInSecond;
+  return {
+    years,
+    months,
+    days,
+    hours,
+    seconds,
+    milliseconds
+  };
+};
 var isInTimeSpan = (value, startDate, endDate) => {
   if (startDate && endDate) {
     console.assert(startDate <= endDate);
@@ -6737,6 +6810,72 @@ import { createContext, useContext, useEffect as useEffect2, useMemo, useState a
 // src/hooks/useLocalStorage.ts
 import { useCallback, useState as useState2 } from "react";
 
+// src/utils/storage.ts
+var StorageService = class {
+  // this seems to be a bug in eslint as 'paramter-properties' is a special syntax of typescript
+  constructor(storage) {
+    this.storage = storage;
+  }
+  get(key) {
+    const value = this.storage.getItem(key);
+    if (value === null) {
+      return null;
+    }
+    return JSON.parse(value);
+  }
+  set(key, value) {
+    this.storage.setItem(key, JSON.stringify(value));
+  }
+  delete(key) {
+    this.storage.removeItem(key);
+  }
+  deleteAll() {
+    this.storage.clear();
+  }
+};
+var LocalStorageService = class extends StorageService {
+  constructor() {
+    super(window.localStorage);
+  }
+};
+var SessionStorageService = class extends StorageService {
+  constructor() {
+    super(window.sessionStorage);
+  }
+};
+
+// src/hooks/useLocalStorage.ts
+var useLocalStorage = (key, backupValue) => {
+  const get = useCallback(() => {
+    if (typeof window === "undefined") {
+      return backupValue;
+    }
+    const storageService = new LocalStorageService();
+    try {
+      const value = storageService.get(key);
+      return value || backupValue;
+    } catch (_) {
+      console.warn("useLocalStorage: Error while reading the stored value. Make sure your typing is correct.");
+      storageService.delete(key);
+      console.info(`useLocalStorage: deleted erroneous value for key: ${key}`);
+      return backupValue;
+    }
+  }, [backupValue, key]);
+  const [storedValue, setStoredValue] = useState2(get);
+  const setValue = useCallback((action) => {
+    const newValue = resolveSetState(action, storedValue);
+    const storageService = new LocalStorageService();
+    storageService.set(key, newValue);
+    setStoredValue(newValue);
+  }, [storedValue, setStoredValue, key]);
+  const deleteValue = () => {
+    const storageService = new LocalStorageService();
+    storageService.delete(key);
+    setStoredValue(backupValue);
+  };
+  return { value: storedValue, setValue, deleteValue };
+};
+
 // src/i18n/translations.ts
 import { TranslationGen } from "@helpwave/internationalization";
 var hightideTranslationLocales = ["de-DE", "en-US"];
@@ -7237,6 +7376,62 @@ var LocaleContext = createContext({
   locale: LocalizationUtil.DEFAULT_LOCALE,
   setLocale: (v) => v
 });
+var LocaleProvider = ({ children, locale, onChangedLocale }) => {
+  const {
+    value: storedLocale,
+    setValue: setStoredLocale,
+    deleteValue: deleteStoredLocale
+  } = useLocalStorage("locale", "system");
+  const [localePreference, setLocalePreference] = useState3("system");
+  const resolvedLocale = useMemo(() => {
+    if (locale && locale !== "system") {
+      return locale;
+    }
+    if (storedLocale && storedLocale !== "system") {
+      return storedLocale;
+    }
+    if (localePreference !== "system") {
+      return localePreference;
+    }
+    return LocalizationUtil.DEFAULT_LOCALE;
+  }, [locale, localePreference, storedLocale]);
+  useEffect2(() => {
+    if (!locale) return;
+    if (locale === "system") {
+      deleteStoredLocale();
+    } else {
+      setStoredLocale(locale);
+    }
+  }, [locale]);
+  useEffect2(() => {
+    onChangedLocale?.(resolvedLocale);
+  }, [resolvedLocale]);
+  useEffect2(() => {
+    const localesToTestAgainst = Object.values(LocalizationUtil.locals);
+    const detectLanguage = () => {
+      const matchingBrowserLanguage = window.navigator.languages.map((locale2) => localesToTestAgainst.find(
+        (test) => locale2 === test || locale2.split("-")[0] === LocalizationUtil.localToLanguage(test)
+      )).filter((entry) => entry !== void 0);
+      if (matchingBrowserLanguage.length === 0) return;
+      const firstMatch = matchingBrowserLanguage[0];
+      setLocalePreference(firstMatch);
+    };
+    detectLanguage();
+    window.addEventListener("languagechange", detectLanguage);
+    return () => {
+      window.removeEventListener("languagechange", detectLanguage);
+    };
+  }, []);
+  return /* @__PURE__ */ jsx3(LocaleContext.Provider, { value: {
+    locale: resolvedLocale,
+    setLocale: (newLocale) => {
+      if (locale !== "system") {
+        console.warn("LocaleProvider: Attempting to change the locale while setting a fixed locale won't have any effect. Change the locale provided to the LocaleProvider instead.");
+      }
+      setStoredLocale(newLocale);
+    }
+  }, children });
+};
 var useLocale = () => {
   const context = useContext(LocaleContext);
   if (!context) {
@@ -7244,6 +7439,13 @@ var useLocale = () => {
   }
   return context;
 };
+var useLanguage = () => {
+  const context = useContext(LocaleContext);
+  if (!context) {
+    throw new Error("useLanguage must be used within LocaleContext. Try adding a LocaleProvider around your app.");
+  }
+  return { language: LocalizationUtil.localToLanguage(context.locale) };
+};
 
 // src/components/date/DayPicker.tsx
 import { useEffect as useEffect3, useState as useState4 } from "react";
@@ -7774,6 +7976,25 @@ var YearMonthPickerUncontrolled = ({
 
 // src/i18n/useHightideTranslation.ts
 import { combineTranslation, ICUUtil } from "@helpwave/internationalization";
+function useICUTranslation(translations, locale) {
+  translations = Array.isArray(translations) ? translations : [translations];
+  return function translate(key, values) {
+    try {
+      for (let i = 0; i < translations.length; i++) {
+        const localizedTranslation = translations[i][locale];
+        if (!localizedTranslation) continue;
+        const msg = localizedTranslation[key];
+        if (typeof msg === "string") {
+          return ICUUtil.interpret(msg, values);
+        }
+      }
+      console.warn(`useTranslation: No translation for key "${key}" found.`);
+    } catch (e) {
+      console.error(`useTranslation: Error translating key "${String(key)}"`, e);
+    }
+    return `{{${String(locale)}:${String(key)}}}`;
+  };
+}
 function useHightideTranslation(extensions, overwrites) {
   const { locale: inferredLocale } = useLocale();
   const locale = overwrites?.locale ?? inferredLocale;
@@ -9629,6 +9850,74 @@ var ThemeUtil = {
   themes
 };
 var ThemeContext = createContext3(null);
+var ThemeProvider = ({ children, theme }) => {
+  const {
+    value: storedTheme,
+    setValue: setStoredTheme,
+    deleteValue: deleteStoredTheme
+  } = useLocalStorage("theme", "system");
+  const [themePreference, setThemePreference] = useState13("system");
+  const resolvedTheme = useMemo3(() => {
+    if (theme && theme !== "system") {
+      return theme;
+    }
+    if (storedTheme && storedTheme !== "system") {
+      return storedTheme;
+    }
+    if (themePreference !== "system") {
+      return themePreference;
+    }
+    return "light";
+  }, [storedTheme, theme, themePreference]);
+  useEffect14(() => {
+    if (!theme) return;
+    if (theme === "system") {
+      deleteStoredTheme();
+    } else {
+      setStoredTheme(theme);
+    }
+  }, [theme]);
+  useEffect14(() => {
+    document.documentElement.setAttribute("data-theme", resolvedTheme);
+  }, [resolvedTheme]);
+  const getPreference = useCallback7(() => {
+    const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
+    const prefersLight = window.matchMedia("(prefers-color-scheme: light)").matches;
+    setThemePreference(prefersDark ? "dark" : prefersLight ? "light" : "system");
+  }, []);
+  useEffect14(() => {
+    getPreference();
+  }, [getPreference]);
+  useEffect14(() => {
+    const darkQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const lightQuery = window.matchMedia("(prefers-color-scheme: light)");
+    const noPrefQuery = window.matchMedia("(prefers-color-scheme: no-preference)");
+    darkQuery.addEventListener("change", getPreference);
+    lightQuery.addEventListener("change", getPreference);
+    noPrefQuery.addEventListener("change", getPreference);
+    return () => {
+      darkQuery.removeEventListener("change", getPreference);
+      lightQuery.removeEventListener("change", getPreference);
+      noPrefQuery.removeEventListener("change", getPreference);
+    };
+  }, [getPreference]);
+  return /* @__PURE__ */ jsx19(
+    ThemeContext.Provider,
+    {
+      value: {
+        theme: storedTheme,
+        resolvedTheme,
+        setTheme: (newTheme) => {
+          if (theme && theme !== "system") {
+            console.warn("ThemeProvider: Attempting to change the theme while setting a fixed theme won't have any effect. Change the theme provided to the ThemeProvider instead.");
+          }
+          setStoredTheme(newTheme);
+        }
+      },
+      children
+    }
+  );
+};
 var useTheme = () => {
   const context = useContext3(ThemeContext);
   if (!context) {
@@ -10565,7 +10854,7 @@ var RadialRings = ({
 };
 
 // src/components/icons-and-geometry/Tag.tsx
-var import_image = __toESM(require_image(), 1);
+var import_image = __toESM(require_image());
 import { jsx as jsx30 } from "react/jsx-runtime";
 var TagIcon = ({
   className,
@@ -12737,7 +13026,7 @@ var ProgressIndicator = ({
 };
 
 // src/components/navigation/BreadCrumb.tsx
-var import_link = __toESM(require_link2(), 1);
+var import_link = __toESM(require_link2());
 import clsx32 from "clsx";
 import { Fragment as Fragment7 } from "react";
 import { jsx as jsx48, jsxs as jsxs27 } from "react/jsx-runtime";
@@ -12760,7 +13049,7 @@ var BreadCrumb = ({ crumbs, linkClassName, containerClassName }) => {
 };
 
 // src/components/navigation/Navigation.tsx
-var import_link2 = __toESM(require_link2(), 1);
+var import_link2 = __toESM(require_link2());
 import { Menu as MenuIcon, XIcon as XIcon2 } from "lucide-react";
 import { useEffect as useEffect22 } from "react";
 import { useCallback as useCallback14, useId as useId7, useRef as useRef14, useState as useState21 } from "react";
@@ -15455,12 +15744,367 @@ function Transition({
   };
   return BagFunctionUtil.resolve(children, bag);
 }
+
+// src/hooks/focus/useFocusGuards.ts
+import { useEffect as useEffect36 } from "react";
+var selectorName = "data-hw-focus-guard";
+function FocusGuard() {
+  const element = document.createElement("div");
+  element.setAttribute(selectorName, "");
+  element.tabIndex = 0;
+  element.style.border = "none";
+  element.style.outline = "none";
+  element.style.boxShadow = "none";
+  element.style.opacity = "0";
+  element.style.position = "fixed";
+  element.style.pointerEvents = "none";
+  return element;
+}
+var FocusGuardsService = class _FocusGuardsService {
+  constructor() {
+    this.count = 0;
+  }
+  static getInstance() {
+    if (!_FocusGuardsService.instance) {
+      _FocusGuardsService.instance = new _FocusGuardsService();
+    }
+    return _FocusGuardsService.instance;
+  }
+  add() {
+    const edgeGuards = document.querySelectorAll(`[${selectorName}]`);
+    document.body.insertAdjacentElement("afterbegin", edgeGuards[0] ?? FocusGuard());
+    document.body.insertAdjacentElement("beforeend", edgeGuards[1] ?? FocusGuard());
+    this.count++;
+  }
+  remove() {
+    if (this.count === 1) {
+      document.querySelectorAll(`[${selectorName}]`).forEach((node) => node.remove());
+    }
+    this.count--;
+  }
+};
+var useFocusGuards = () => {
+  useEffect36(() => {
+    FocusGuardsService.getInstance().add();
+    return () => {
+      FocusGuardsService.getInstance().remove();
+    };
+  }, []);
+};
+
+// src/hooks/focus/useFocusOnceVisible.ts
+import React20, { useEffect as useEffect37 } from "react";
+var useFocusOnceVisible = (ref, disable = false) => {
+  const [hasUsedFocus, setHasUsedFocus] = React20.useState(false);
+  useEffect37(() => {
+    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/hooks/useRerender.ts
+import { useReducer as useReducer4 } from "react";
+var useRerender = () => {
+  return useReducer4(() => ({}), {})[1];
+};
+
+// src/hooks/useSearch.ts
+import { useCallback as useCallback18, useEffect as useEffect38, useMemo as useMemo11, useState as useState35 } from "react";
+
+// src/utils/simpleSearch.ts
+var MultiSubjectSearchWithMapping = (search, objects, mapping) => {
+  return objects.filter((object) => {
+    const mappedSearchKeywords = mapping(object)?.map((value) => value.toLowerCase().trim());
+    if (!mappedSearchKeywords) {
+      return true;
+    }
+    return search.every((searchValue) => !!mappedSearchKeywords.find((value) => !!value && value.includes(searchValue.toLowerCase().trim())));
+  });
+};
+var MultiSearchWithMapping = (search, objects, mapping) => {
+  return objects.filter((object) => {
+    const mappedSearchKeywords = mapping(object)?.map((value) => value.toLowerCase().trim());
+    if (!mappedSearchKeywords) {
+      return true;
+    }
+    return !!mappedSearchKeywords.find((value) => value.includes(search.toLowerCase().trim()));
+  });
+};
+var SimpleSearchWithMapping = (search, objects, mapping) => {
+  return MultiSearchWithMapping(search, objects, (value) => [mapping(value)]);
+};
+var SimpleSearch = (search, objects) => {
+  return SimpleSearchWithMapping(search, objects, (value) => value);
+};
+
+// src/hooks/useSearch.ts
+var useSearch = ({
+  list,
+  initialSearch,
+  searchMapping,
+  additionalSearchTags,
+  isSearchInstant = true,
+  sortingFunction,
+  filter,
+  disabled = false
+}) => {
+  const [search, setSearch] = useState35(initialSearch ?? "");
+  const [result, setResult] = useState35(list);
+  const searchTags = useMemo11(() => additionalSearchTags ?? [], [additionalSearchTags]);
+  const updateSearch = useCallback18((newSearch) => {
+    const usedSearch = newSearch ?? search;
+    if (newSearch) {
+      setSearch(search);
+    }
+    setResult(MultiSubjectSearchWithMapping([usedSearch, ...searchTags], list, searchMapping));
+  }, [searchTags, list, search, searchMapping]);
+  useEffect38(() => {
+    if (isSearchInstant) {
+      setResult(MultiSubjectSearchWithMapping([search, ...searchTags], list, searchMapping));
+    }
+  }, [searchTags, isSearchInstant, list, search, searchMapping, additionalSearchTags]);
+  const filteredResult = useMemo11(() => {
+    if (!filter) {
+      return result;
+    }
+    return result.filter(filter);
+  }, [result, filter]);
+  const sortedAndFilteredResult = useMemo11(() => {
+    if (!sortingFunction) {
+      return filteredResult;
+    }
+    return filteredResult.sort(sortingFunction);
+  }, [filteredResult, sortingFunction]);
+  const usedResult = useMemo11(() => {
+    if (!disabled) {
+      return sortedAndFilteredResult;
+    }
+    return list;
+  }, [disabled, list, sortedAndFilteredResult]);
+  return {
+    result: usedResult,
+    hasResult: usedResult.length > 0,
+    allItems: list,
+    updateSearch,
+    search,
+    setSearch
+  };
+};
+
+// src/utils/emailValidation.ts
+var validateEmail = (email) => {
+  return /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i.test(email);
+};
+
+// src/hooks/useValidators.ts
+var notEmpty = (value) => {
+  if (!value) {
+    return "notEmpty";
+  }
+};
+var boundsValidator = (length, bounds) => {
+  const [min, max] = bounds;
+  if (min !== void 0 && max !== void 0 && (length === void 0 || length < min || length > max)) {
+    return "range";
+  }
+  if (min !== void 0 && (length === void 0 || length < min)) {
+    return "lower";
+  }
+  if (max !== void 0 && length !== void 0 && length > max) {
+    return "upper";
+  }
+  return "none";
+};
+var lengthValidator = (value, bounds) => {
+  const mapping = {
+    range: "outOfRangeString",
+    lower: "tooShort",
+    upper: "tooLong",
+    none: void 0
+  };
+  return mapping[boundsValidator(value?.length, bounds)];
+};
+var selectionValidator = (value, bounds) => {
+  const mapping = {
+    range: "outOfRangeSelectionItems",
+    lower: "tooFewSelectionItems",
+    upper: "tooManySelectionItems",
+    none: void 0
+  };
+  return mapping[boundsValidator(value?.length, bounds)];
+};
+var emailValidator = (value) => {
+  if (!value || !validateEmail(value)) {
+    return "invalidEmail";
+  }
+};
+var UseValidators = {
+  notEmpty,
+  length: lengthValidator,
+  email: emailValidator,
+  selection: selectionValidator
+};
+var useTranslatedValidators = () => {
+  const translation = useHightideTranslation();
+  return {
+    notEmpty: (value) => {
+      const result = notEmpty(value);
+      if (result) {
+        return translation(result);
+      }
+    },
+    length: (value, length) => {
+      const [min, max] = length;
+      const result = lengthValidator(value, length);
+      if (result) {
+        return translation(result, { min, max });
+      }
+    },
+    email: (value) => {
+      const result = emailValidator(value);
+      if (result) {
+        return translation(result);
+      }
+    },
+    selection: (value, length) => {
+      const [min, max] = length;
+      const result = selectionValidator(value, length);
+      if (result) {
+        return translation(
+          result,
+          { min, max }
+        );
+      }
+    }
+  };
+};
+
+// src/utils/builder.ts
+var builder = (value, update) => {
+  update(value);
+  return value;
+};
+
+// src/utils/easeFunctions.ts
+var EaseFunctions = class _EaseFunctions {
+  static cubicBezierGeneric(x1, y1, x2, y2) {
+    const cx = 3 * x1;
+    const bx = 3 * (x2 - x1) - cx;
+    const ax = 1 - cx - bx;
+    const cy = 3 * y1;
+    const by = 3 * (y2 - y1) - cy;
+    const ay = 1 - cy - by;
+    const x = (t) => ((ax * t + bx) * t + cx) * t;
+    const y = (t) => ((ay * t + by) * t + cy) * t;
+    return {
+      x,
+      y
+    };
+  }
+  static cubicBezier(x1, y1, x2, y2) {
+    const { y } = _EaseFunctions.cubicBezierGeneric(x1, y1, x2, y2);
+    return (t) => {
+      t = clamp(t);
+      return y(t);
+    };
+  }
+  static easeInEaseOut(t) {
+    return _EaseFunctions.cubicBezier(0.65, 0, 0.35, 1)(t);
+  }
+};
+
+// src/utils/loopingArray.ts
+var LoopingArrayCalculator = class _LoopingArrayCalculator {
+  constructor(length, isLooping = true, allowedOverScroll = 0.1) {
+    if (allowedOverScroll < 0 || length < 1) {
+      throw new Error("Invalid parameters: allowedOverScroll >= 0 and length >= 1 must be true");
+    }
+    this.length = length;
+    this.isLooping = isLooping;
+    this.allowedOverScroll = allowedOverScroll;
+  }
+  getCorrectedPosition(position) {
+    if (!this.isLooping) {
+      return Math.max(-this.allowedOverScroll, Math.min(this.allowedOverScroll + this.length - 1, position));
+    }
+    if (position >= this.length) {
+      return position % this.length;
+    }
+    if (position < 0) {
+      return this.length - Math.abs(position) % this.length;
+    }
+    return position;
+  }
+  static withoutOffset(position) {
+    return position + _LoopingArrayCalculator.getOffset(position);
+  }
+  static getOffset(position) {
+    return Math.round(position) - position;
+  }
+  /**
+   * @return absolute distance forwards or Infinity when the target cannot be reached (only possible when not isLooping)
+   */
+  getDistanceDirectional(position, target, direction) {
+    if (!this.isLooping && (position < -this.allowedOverScroll || position > this.allowedOverScroll + this.length - 1)) {
+      throw new Error("Invalid parameters: position is out of bounds.");
+    }
+    const isForwardInvalid = direction === 1 && position > target;
+    const isBackwardInvalid = direction === -1 && target < position;
+    if (!this.isLooping && (isForwardInvalid || isBackwardInvalid)) {
+      return Infinity;
+    }
+    if (direction === -1) {
+      return this.getDistanceDirectional(target, position, 1);
+    }
+    position = this.getCorrectedPosition(position);
+    target = this.getCorrectedPosition(target);
+    let distance = (target - position) * direction;
+    if (distance < 0) {
+      distance = this.length - Math.abs(position) % this.length + target;
+    }
+    return distance;
+  }
+  getDistanceForward(position, target) {
+    return this.getDistanceDirectional(position, target, 1);
+  }
+  getDistanceBackward(position, target) {
+    return this.getDistanceDirectional(position, target, -1);
+  }
+  getDistance(position, target) {
+    const forwardDistance = this.getDistanceForward(position, target);
+    const backwardDistance = this.getDistanceBackward(position, target);
+    return Math.min(forwardDistance, backwardDistance);
+  }
+  getBestDirection(position, target) {
+    const forwardDistance = this.getDistanceForward(position, target);
+    const backwardDistance = this.getDistanceBackward(position, target);
+    return forwardDistance < backwardDistance ? 1 : -1;
+  }
+};
+
+// src/utils/noop.ts
+var noop = () => void 0;
 export {
   ASTNodeInterpreter,
   AnimatedRing,
+  ArrayUtil,
   Avatar2 as Avatar,
   AvatarGroup,
   AvatarUtil,
+  BagFunctionUtil,
   BreadCrumb,
   ButtonColorUtil,
   ButtonUtil,
@@ -15484,6 +16128,7 @@ export {
   Dialog,
   DiscardChangesDialog,
   DividerInserter,
+  EaseFunctions,
   ErrorComponent,
   Expandable,
   ExpandableUncontrolled,
@@ -15514,14 +16159,21 @@ export {
   LoadingAnimation,
   LoadingButton,
   LoadingContainer,
+  LocalStorageService,
+  LocaleContext,
+  LocaleProvider,
+  LocalizationUtil,
+  LoopingArrayCalculator,
   MarkdownInterpreter,
   Menu,
   MenuItem,
+  MultiSearchWithMapping,
   MultiSelect,
   MultiSelectChipDisplay,
   MultiSelectChipDisplayUncontrolled,
   MultiSelectProperty,
   MultiSelectUncontrolled,
+  MultiSubjectSearchWithMapping,
   Navigation,
   NavigationItemList,
   NumberProperty,
@@ -15542,6 +16194,9 @@ export {
   SelectOption,
   SelectRoot,
   SelectUncontrolled,
+  SessionStorageService,
+  SimpleSearch,
+  SimpleSearchWithMapping,
   SingleSelectProperty,
   SolidButton,
   StepperBar,
@@ -15560,7 +16215,10 @@ export {
   Textarea,
   TextareaUncontrolled,
   TextareaWithHeadline,
+  ThemeContext,
   ThemeDialog,
+  ThemeProvider,
+  ThemeUtil,
   TimeDisplay,
   TimePicker,
   TimePickerUncontrolled,
@@ -15568,9 +16226,61 @@ export {
   ToggleableInputUncontrolled,
   Tooltip,
   Transition,
+  UseValidators,
   VerticalDivider,
   YearMonthPicker,
-  YearMonthPickerUncontrolled
+  YearMonthPickerUncontrolled,
+  addDuration,
+  builder,
+  changeDuration,
+  clamp,
+  closestMatch,
+  createLoopingList,
+  createLoopingListWithIndex,
+  equalDate,
+  equalSizeGroups,
+  formatDate,
+  formatDateTime,
+  generateShadingColors,
+  getBetweenDuration,
+  getDaysInMonth,
+  getNeighbours,
+  getWeeksForCalenderMonth,
+  hightideTranslation,
+  hightideTranslationLocales,
+  isInTimeSpan,
+  match,
+  monthsList,
+  noop,
+  range,
+  resolveSetState,
+  shadingColorValues,
+  subtractDuration,
+  useDelay,
+  useFloatingElement,
+  useFocusGuards,
+  useFocusManagement,
+  useFocusOnceVisible,
+  useFocusTrap,
+  useHightideTranslation,
+  useHoverState,
+  useICUTranslation,
+  useIsMounted,
+  useLanguage,
+  useLocalStorage,
+  useLocale,
+  useLogOnce,
+  useOutsideClick,
+  useOverwritableState,
+  usePopoverPosition,
+  useRerender,
+  useResizeCallbackWrapper,
+  useSearch,
+  useTheme,
+  useTranslatedValidators,
+  validateEmail,
+  weekDayList,
+  writeToClipboard
 };
 /*! Bundled license information:
 
@@ -15596,4 +16306,4 @@ use-sync-external-store/cjs/use-sync-external-store-shim.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.mjs.map