@helpwave/hightide 0.1.24 → 0.1.26

package/dist/components/properties/SelectProperty.mjs

@@ -1,93 +1,6 @@
 // src/components/properties/SelectProperty.tsx
-import { List, Plus } from "lucide-react";
-import clsx10 from "clsx";
-
-// src/localization/LanguageProvider.tsx
-import { createContext, useContext, useEffect, useState as useState2 } from "react";
-
-// src/hooks/useLocalStorage.ts
-import { useCallback, useState } from "react";
-
-// src/localization/util.ts
-var languages = ["en", "de"];
-var languagesLocalNames = {
-  en: "English",
-  de: "Deutsch"
-};
-var DEFAULT_LANGUAGE = "en";
-var LanguageUtil = {
-  languages,
-  DEFAULT_LANGUAGE,
-  languagesLocalNames
-};
-
-// src/localization/LanguageProvider.tsx
-import { jsx } from "react/jsx-runtime";
-var LanguageContext = createContext({
-  language: LanguageUtil.DEFAULT_LANGUAGE,
-  setLanguage: (v) => v
-});
-var useLanguage = () => useContext(LanguageContext);
-
-// src/localization/useTranslation.ts
-var TranslationPluralCount = {
-  zero: 0,
-  one: 1,
-  two: 2,
-  few: 3,
-  many: 11,
-  other: -1
-};
-var useTranslation = (translations, overwriteTranslation = {}) => {
-  const { language: languageProp, translation: overwrite } = overwriteTranslation;
-  const { language: inferredLanguage } = useLanguage();
-  const usedLanguage = languageProp ?? inferredLanguage;
-  const usedTranslations = [...translations];
-  if (overwrite) {
-    usedTranslations.push(overwrite);
-  }
-  return (key, options) => {
-    const { count, replacements } = { ...{ count: 0, replacements: {} }, ...options };
-    try {
-      for (let i = translations.length - 1; i >= 0; i--) {
-        const translation = translations[i];
-        const localizedTranslation = translation[usedLanguage];
-        if (!localizedTranslation) {
-          continue;
-        }
-        const value = localizedTranslation[key];
-        if (!value) {
-          continue;
-        }
-        let forProcessing;
-        if (typeof value !== "string") {
-          if (count === TranslationPluralCount.zero && value?.zero) {
-            forProcessing = value.zero;
-          } else if (count === TranslationPluralCount.one && value?.one) {
-            forProcessing = value.one;
-          } else if (count === TranslationPluralCount.two && value?.two) {
-            forProcessing = value.two;
-          } else if (TranslationPluralCount.few <= count && count < TranslationPluralCount.many && value?.few) {
-            forProcessing = value.few;
-          } else if (count > TranslationPluralCount.many && value?.many) {
-            forProcessing = value.many;
-          } else {
-            forProcessing = value.other;
-          }
-        } else {
-          forProcessing = value;
-        }
-        forProcessing = forProcessing.replace(/\{\{(\w+)}}/g, (_, placeholder) => {
-          return replacements[placeholder] ?? `{{key:${placeholder}}}`;
-        });
-        return forProcessing;
-      }
-    } catch (e) {
-      console.error(e);
-    }
-    return `{{${usedLanguage}:${key}}}`;
-  };
-};
+import { List } from "lucide-react";
+import clsx6 from "clsx";
 
 // src/components/properties/PropertyBase.tsx
 import { AlertTriangle } from "lucide-react";
@@ -96,7 +9,7 @@ import clsx2 from "clsx";
 // src/components/user-action/Button.tsx
 import { forwardRef } from "react";
 import clsx from "clsx";
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 var ButtonColorUtil = {
   solid: ["primary", "secondary", "tertiary", "positive", "warning", "negative", "neutral"],
   text: ["primary", "negative", "neutral"],
@@ -122,7 +35,6 @@ var ButtonUtil = {
 };
 var SolidButton = forwardRef(function SolidButton2({
   children,
-  disabled = false,
   color = "primary",
   size = "medium",
   startIcon,
@@ -132,58 +44,56 @@ var SolidButton = forwardRef(function SolidButton2({
   ...restProps
 }, ref) {
   const colorClasses = {
-    primary: "bg-button-solid-primary-background text-button-solid-primary-text",
-    secondary: "bg-button-solid-secondary-background text-button-solid-secondary-text",
-    tertiary: "bg-button-solid-tertiary-background text-button-solid-tertiary-text",
-    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"
+    primary: "not-disabled:bg-button-solid-primary-background not-disabled:text-button-solid-primary-text",
+    secondary: "not-disabled:bg-button-solid-secondary-background not-disabled:text-button-solid-secondary-text",
+    tertiary: "not-disabled:bg-button-solid-tertiary-background not-disabled:text-button-solid-tertiary-text",
+    positive: "not-disabled:bg-button-solid-positive-background not-disabled:text-button-solid-positive-text",
+    warning: "not-disabled:bg-button-solid-warning-background not-disabled:text-button-solid-warning-text",
+    negative: "not-disabled:bg-button-solid-negative-background not-disabled:text-button-solid-negative-text",
+    neutral: "not-disabled:bg-button-solid-neutral-background not-disabled:text-button-solid-neutral-text"
   }[color];
   const iconColorClasses = {
-    primary: "text-button-solid-primary-icon",
-    secondary: "text-button-solid-secondary-icon",
-    tertiary: "text-button-solid-tertiary-icon",
-    positive: "text-button-solid-positive-icon",
-    warning: "text-button-solid-warning-icon",
-    negative: "text-button-solid-negative-icon",
-    neutral: "text-button-solid-neutral-icon"
+    primary: "not-group-disabled:text-button-solid-primary-icon",
+    secondary: "not-group-disabled:text-button-solid-secondary-icon",
+    tertiary: "not-group-disabled:text-button-solid-tertiary-icon",
+    positive: "not-group-disabled:text-button-solid-positive-icon",
+    warning: "not-group-disabled:text-button-solid-warning-icon",
+    negative: "not-group-disabled:text-button-solid-negative-icon",
+    neutral: "not-group-disabled:text-button-solid-neutral-icon"
   }[color];
   return /* @__PURE__ */ jsxs(
     "button",
     {
       ref,
       onClick,
-      disabled,
       className: clsx(
-        "font-semibold",
-        {
-          "text-disabled-text bg-disabled-background cursor-not-allowed": disabled,
-          [clsx(colorClasses, "hover:brightness-90")]: !disabled
-        },
+        "group font-semibold",
+        colorClasses,
+        "not-disabled:hover:brightness-90",
+        "disabled:text-disabled-text disabled:bg-disabled-background",
         ButtonUtil.paddingMapping[size],
         className
       ),
       ...restProps,
       children: [
-        startIcon && /* @__PURE__ */ jsx2(
+        startIcon && /* @__PURE__ */ jsx(
           "span",
           {
-            className: clsx({
-              [iconColorClasses]: !disabled,
-              [`text-disabled-icon`]: disabled
-            }),
+            className: clsx(
+              iconColorClasses,
+              "group-disabled:text-disabled-icon"
+            ),
             children: startIcon
           }
         ),
         children,
-        endIcon && /* @__PURE__ */ jsx2(
+        endIcon && /* @__PURE__ */ jsx(
           "span",
           {
-            className: clsx({
-              [iconColorClasses]: !disabled,
-              [`text-disabled-icon`]: disabled
-            }),
+            className: clsx(
+              iconColorClasses,
+              "group-disabled:text-disabled-icon"
+            ),
             children: endIcon
           }
         )
@@ -193,7 +103,6 @@ var SolidButton = forwardRef(function SolidButton2({
 });
 var TextButton = ({
   children,
-  disabled = false,
   color = "neutral",
   size = "medium",
   startIcon,
@@ -204,56 +113,55 @@ var TextButton = ({
   ...restProps
 }) => {
   const colorClasses = {
-    primary: "bg-transparent text-button-text-primary-text",
-    negative: "bg-transparent text-button-text-negative-text",
-    neutral: "bg-transparent text-button-text-neutral-text"
+    primary: "not-disabled:bg-transparent not-disabled:text-button-text-primary-text focus-style-none focus-visible:ring-2 not-disabled:focus-visible:ring-button-text-primary-text",
+    negative: "not-disabled:bg-transparent not-disabled:text-button-text-negative-text focus-style-none focus-visible:ring-2 not-disabled:focus-visible:ring-button-text-negative-text",
+    neutral: "not-disabled:bg-transparent not-disabled:text-button-text-neutral-text focus-style-none focus-visible:ring-2 not-disabled:focus-visible:ring-button-text-neutral-text"
   }[color];
   const backgroundColor = {
-    primary: "hover:bg-button-text-primary-text/20",
-    negative: "hover:bg-button-text-negative-text/20",
-    neutral: "hover:bg-button-text-neutral-text/20"
+    primary: "not-disabled:hover:bg-button-text-primary-text/20 not-disabled:focus-visible:bg-button-text-primary-text/20",
+    negative: "not-disabled:hover:bg-button-text-negative-text/20 not-disabled:focus-visible:bg-button-text-negative-text/20",
+    neutral: "not-disabled:hover:bg-button-text-neutral-text/20 not-disabled:focus-visible:bg-button-text-neutral-text/20"
   }[color];
   const iconColorClasses = {
-    primary: "text-button-text-primary-icon",
-    negative: "text-button-text-negative-icon",
-    neutral: "text-button-text-neutral-icon"
+    primary: "not-group-disabled:text-button-text-primary-icon",
+    negative: "not-group-disabled:text-button-text-negative-icon",
+    neutral: "not-group-disabled:text-button-text-neutral-icon"
   }[color];
   return /* @__PURE__ */ jsxs(
     "button",
     {
       onClick,
-      disabled,
       className: clsx(
-        "font-semibold",
+        "group font-semibold",
+        "disabled:text-disabled-text",
+        colorClasses,
         {
-          "text-disabled-text cursor-not-allowed": disabled,
-          [colorClasses]: !disabled,
-          [backgroundColor]: !disabled && coloredHoverBackground,
-          "hover:bg-button-text-hover-background": !disabled && !coloredHoverBackground
+          [backgroundColor]: coloredHoverBackground,
+          "not-disabled:hover:bg-button-text-hover-background": !coloredHoverBackground
         },
         ButtonUtil.paddingMapping[size],
         className
       ),
       ...restProps,
       children: [
-        startIcon && /* @__PURE__ */ jsx2(
+        startIcon && /* @__PURE__ */ jsx(
           "span",
           {
-            className: clsx({
-              [iconColorClasses]: !disabled,
-              [`text-disabled-icon`]: disabled
-            }),
+            className: clsx(
+              iconColorClasses,
+              "group-disabled:text-disabled-icon"
+            ),
             children: startIcon
           }
         ),
         children,
-        endIcon && /* @__PURE__ */ jsx2(
+        endIcon && /* @__PURE__ */ jsx(
           "span",
           {
-            className: clsx({
-              [iconColorClasses]: !disabled,
-              [`text-disabled-icon`]: disabled
-            }),
+            className: clsx(
+              iconColorClasses,
+              "group-disabled:text-disabled-icon"
+            ),
             children: endIcon
           }
         )
@@ -261,34 +169,35 @@ var TextButton = ({
     }
   );
 };
-var IconButton = ({
+var IconButton = forwardRef(function IconButton2({
   children,
-  disabled = false,
   color = "primary",
   size = "medium",
   className,
   ...restProps
-}) => {
+}, ref) {
   const colorClasses = {
-    primary: "bg-button-solid-primary-background text-button-solid-primary-text",
-    secondary: "bg-button-solid-secondary-background text-button-solid-secondary-text",
-    tertiary: "bg-button-solid-tertiary-background text-button-solid-tertiary-text",
-    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",
-    transparent: "bg-transparent"
+    primary: "not-disabled:bg-button-solid-primary-background not-disabled:text-button-solid-primary-text",
+    secondary: "not-disabled:bg-button-solid-secondary-background not-disabled:text-button-solid-secondary-text",
+    tertiary: "not-disabled:bg-button-solid-tertiary-background not-disabled:text-button-solid-tertiary-text",
+    positive: "not-disabled:bg-button-solid-positive-background not-disabled:text-button-solid-positive-text",
+    warning: "not-disabled:bg-button-solid-warning-background not-disabled:text-button-solid-warning-text",
+    negative: "not-disabled:bg-button-solid-negative-background not-disabled:text-button-solid-negative-text",
+    neutral: "not-disabled:bg-button-solid-neutral-background not-disabled:text-button-solid-neutral-text",
+    transparent: "not-disabled:bg-transparent"
   }[color];
-  return /* @__PURE__ */ jsx2(
+  return /* @__PURE__ */ jsx(
     "button",
     {
-      disabled,
+      ref,
       className: clsx(
+        colorClasses,
+        "not-disabled:hover:brightness-90",
+        "disabled:text-disabled-text",
         {
-          "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
+          "disabled:bg-disabled-background": color !== "transparent",
+          "disabled:opacity-70": color === "transparent",
+          "not-disabled:hover:bg-button-text-hover-background": color === "transparent"
         },
         ButtonUtil.iconPaddingMapping[size],
         className
@@ -297,6 +206,93 @@ var IconButton = ({
       children
     }
   );
+});
+
+// src/localization/LanguageProvider.tsx
+import { createContext, useContext, useEffect, useState as useState2 } from "react";
+
+// src/hooks/useLocalStorage.ts
+import { useCallback, useState } from "react";
+
+// src/localization/util.ts
+var languages = ["en", "de"];
+var languagesLocalNames = {
+  en: "English",
+  de: "Deutsch"
+};
+var DEFAULT_LANGUAGE = "en";
+var LanguageUtil = {
+  languages,
+  DEFAULT_LANGUAGE,
+  languagesLocalNames
+};
+
+// src/localization/LanguageProvider.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var LanguageContext = createContext({
+  language: LanguageUtil.DEFAULT_LANGUAGE,
+  setLanguage: (v) => v
+});
+var useLanguage = () => useContext(LanguageContext);
+
+// src/localization/useTranslation.ts
+var TranslationPluralCount = {
+  zero: 0,
+  one: 1,
+  two: 2,
+  few: 3,
+  many: 11,
+  other: -1
+};
+var useTranslation = (translations, overwriteTranslation = {}) => {
+  const { language: languageProp, translation: overwrite } = overwriteTranslation;
+  const { language: inferredLanguage } = useLanguage();
+  const usedLanguage = languageProp ?? inferredLanguage;
+  const usedTranslations = [...translations];
+  if (overwrite) {
+    usedTranslations.push(overwrite);
+  }
+  return (key, options) => {
+    const { count, replacements } = { ...{ count: 0, replacements: {} }, ...options };
+    try {
+      for (let i = translations.length - 1; i >= 0; i--) {
+        const translation = translations[i];
+        const localizedTranslation = translation[usedLanguage];
+        if (!localizedTranslation) {
+          continue;
+        }
+        const value = localizedTranslation[key];
+        if (!value) {
+          continue;
+        }
+        let forProcessing;
+        if (typeof value !== "string") {
+          if (count === TranslationPluralCount.zero && value?.zero) {
+            forProcessing = value.zero;
+          } else if (count === TranslationPluralCount.one && value?.one) {
+            forProcessing = value.one;
+          } else if (count === TranslationPluralCount.two && value?.two) {
+            forProcessing = value.two;
+          } else if (TranslationPluralCount.few <= count && count < TranslationPluralCount.many && value?.few) {
+            forProcessing = value.few;
+          } else if (count > TranslationPluralCount.many && value?.many) {
+            forProcessing = value.many;
+          } else {
+            forProcessing = value.other;
+          }
+        } else {
+          forProcessing = value;
+        }
+        forProcessing = forProcessing.replace(/\{\{(\w+)}}/g, (_, placeholder) => {
+          return replacements[placeholder] ?? `{{key:${placeholder}}}`;
+        });
+        return forProcessing;
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    return `{{${usedLanguage}:${key}}}`;
+  };
 };
 
 // src/localization/defaults/form.ts
@@ -335,6 +331,7 @@ var formTranslation = {
     next: "Next",
     no: "No",
     none: "None",
+    nothingFound: "Nothing found",
     of: "of",
     optional: "Optional",
     pleaseWait: "Please wait...",
@@ -391,6 +388,7 @@ var formTranslation = {
     next: "Weiter",
     no: "Nein",
     none: "Nichts",
+    nothingFound: "Nichts gefunden",
     of: "von",
     optional: "Optional",
     pleaseWait: "Bitte warten...",
@@ -462,13 +460,13 @@ var PropertyBase = ({
         children: [
           input({ softRequired, hasValue }),
           requiredAndNoValue && /* @__PURE__ */ jsx3("div", { className: "text-warning", children: /* @__PURE__ */ jsx3(AlertTriangle, { size: 24 }) }),
-          onRemove && hasValue && /* @__PURE__ */ jsx3(
+          onRemove && !readOnly && /* @__PURE__ */ jsx3(
             TextButton,
             {
               onClick: onRemove,
               color: "negative",
-              className: clsx2("items-center", { "!text-transparent": !hasValue || readOnly }),
-              disabled: !hasValue || readOnly,
+              className: clsx2("items-center"),
+              disabled: !hasValue,
               children: translation("remove")
             }
           )
@@ -478,102 +476,37 @@ var PropertyBase = ({
   ] });
 };
 
-// src/components/user-action/Select.tsx
-import { useCallback as useCallback5 } from "react";
-import { useEffect as useEffect10, useState as useState9 } from "react";
-import clsx9 from "clsx";
-
-// src/components/user-action/Label.tsx
-import clsx3 from "clsx";
-import { jsx as jsx4 } from "react/jsx-runtime";
-var styleMapping = {
-  labelSmall: "textstyle-label-sm",
-  labelMedium: "textstyle-label-md",
-  labelBig: "textstyle-label-lg"
-};
-var Label = ({
-  children,
-  name,
-  labelType = "labelSmall",
-  className,
-  ...props
-}) => {
-  return /* @__PURE__ */ jsx4("label", { ...props, className: clsx3(styleMapping[labelType], className), children: children ? children : name });
-};
-
-// src/components/layout-and-navigation/Tile.tsx
-import clsx4 from "clsx";
-import { Check } from "lucide-react";
-import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
-var Tile = ({
-  title,
-  titleClassName,
-  description,
-  descriptionClassName,
-  onClick,
-  isSelected = false,
-  disabled = false,
-  prefix,
-  suffix,
-  normalClassName = "hover:bg-primary/40 cursor-pointer",
-  selectedClassName = "bg-primary/20",
-  disabledClassName = "text-disabled-text bg-disabled-background cursor-not-allowed",
-  className
-}) => {
-  return /* @__PURE__ */ jsxs3(
-    "div",
-    {
-      className: clsx4(
-        "flex-row-2 w-full items-center",
-        {
-          [normalClassName]: onClick && !disabled,
-          [selectedClassName]: isSelected && !disabled,
-          [disabledClassName]: disabled
-        },
-        className
-      ),
-      onClick: disabled ? void 0 : onClick,
-      children: [
-        prefix,
-        /* @__PURE__ */ jsxs3("div", { className: "flex-col-0 w-full", children: [
-          /* @__PURE__ */ jsx5("span", { className: clsx4(titleClassName ?? "textstyle-title-normal"), children: title }),
-          !!description && /* @__PURE__ */ jsx5("span", { className: clsx4(descriptionClassName ?? "textstyle-description"), children: description })
-        ] }),
-        suffix ?? (isSelected ? /* @__PURE__ */ jsx5(Check, { size: 24 }) : void 0)
-      ]
-    }
-  );
-};
-var ListTile = ({
-  ...props
-}) => {
-  return /* @__PURE__ */ jsx5(
-    Tile,
-    {
-      ...props,
-      titleClassName: props.titleClassName ?? "font-semibold",
-      className: clsx4("px-2 py-1 rounded-md", props.className),
-      disabledClassName: props.disabledClassName ?? "text-disabled-text cursor-not-allowed"
-    }
-  );
-};
+// src/components/user-action/select/Select.tsx
+import {
+  createContext as createContext2,
+  forwardRef as forwardRef3,
+  useCallback as useCallback5,
+  useContext as useContext2,
+  useEffect as useEffect6,
+  useId as useId3,
+  useImperativeHandle,
+  useRef as useRef2,
+  useState as useState7
+} from "react";
+import clsx5 from "clsx";
 
 // src/components/layout-and-navigation/Expandable.tsx
-import { forwardRef as forwardRef2, useCallback as useCallback2, useEffect as useEffect2, useState as useState3 } from "react";
+import { forwardRef as forwardRef2, useCallback as useCallback2, useEffect as useEffect2, useId, useState as useState3 } from "react";
 import { ChevronDown } from "lucide-react";
-import clsx5 from "clsx";
+import clsx3 from "clsx";
 
-// src/util/noop.ts
+// src/utils/noop.ts
 var noop = () => void 0;
 
 // src/components/layout-and-navigation/Expandable.tsx
-import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 var ExpansionIcon = ({ isExpanded, className }) => {
-  return /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsx4(
     ChevronDown,
     {
-      className: clsx5(
-        "min-w-6 w-6 min-h-6 h-6 transition-transform duration-200 ease-in-out",
+      "aria-hidden": true,
+      className: clsx3(
+        "min-w-6 w-6 min-h-6 h-6 transition-transform motion-safe:duration-200 motion-reduce:duration-0 ease-in-out",
         { "rotate-180": isExpanded },
         className
       )
@@ -582,6 +515,7 @@ var ExpansionIcon = ({ isExpanded, className }) => {
 };
 var Expandable = forwardRef2(function Expandable2({
   children,
+  id: providedId,
   label,
   icon,
   isExpanded = false,
@@ -593,19 +527,26 @@ var Expandable = forwardRef2(function Expandable2({
   contentClassName,
   contentExpandedClassName
 }, ref) {
-  const defaultIcon = useCallback2((expanded) => /* @__PURE__ */ jsx6(ExpansionIcon, { isExpanded: expanded }), []);
+  const defaultIcon = useCallback2((expanded) => /* @__PURE__ */ jsx4(ExpansionIcon, { isExpanded: expanded }), []);
   icon ??= defaultIcon;
-  return /* @__PURE__ */ jsxs4(
+  const generatedId = useId();
+  const id = providedId ?? generatedId;
+  return /* @__PURE__ */ jsxs3(
     "div",
     {
       ref,
-      className: clsx5("flex-col-0 bg-surface text-on-surface group rounded-lg shadow-sm", { "cursor-pointer": !clickOnlyOnHeader && !disabled }, className),
       onClick: () => !clickOnlyOnHeader && !disabled && onChange(!isExpanded),
+      className: clsx3(
+        "flex-col-0 bg-surface text-on-surface group rounded-lg shadow-sm",
+        { "cursor-pointer": !clickOnlyOnHeader && !disabled },
+        className
+      ),
       children: [
-        /* @__PURE__ */ jsxs4(
-          "div",
+        /* @__PURE__ */ jsxs3(
+          "button",
           {
-            className: clsx5(
+            onClick: () => clickOnlyOnHeader && !disabled && onChange(!isExpanded),
+            className: clsx3(
               "flex-row-2 py-2 px-4 rounded-lg justify-between items-center bg-surface text-on-surface select-none",
               {
                 "group-hover:brightness-97": !isExpanded,
@@ -614,24 +555,28 @@ var Expandable = forwardRef2(function Expandable2({
               },
               headerClassName
             ),
-            onClick: () => clickOnlyOnHeader && !disabled && onChange(!isExpanded),
+            "aria-expanded": isExpanded,
+            "aria-controls": `${id}-content`,
+            "aria-disabled": disabled ?? void 0,
             children: [
               label,
               icon(isExpanded)
             ]
           }
         ),
-        /* @__PURE__ */ jsx6(
+        /* @__PURE__ */ jsx4(
           "div",
           {
-            className: clsx5(
+            id: `${id}-content`,
+            className: clsx3(
               "flex-col-2 px-4 transition-all duration-300 ease-in-out",
               {
-                [clsx5("max-h-96 opacity-100 pb-2 overflow-y-auto", contentExpandedClassName)]: isExpanded,
+                [clsx3("max-h-96 opacity-100 pb-2 overflow-y-auto", contentExpandedClassName)]: isExpanded,
                 "max-h-0 opacity-0 overflow-hidden": !isExpanded
               },
               contentClassName
             ),
+            role: "region",
             children
           }
         )
@@ -648,7 +593,7 @@ var ExpandableUncontrolled = forwardRef2(function ExpandableUncontrolled2({
   useEffect2(() => {
     setUsedIsExpanded(isExpanded);
   }, [isExpanded]);
-  return /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsx4(
     Expandable,
     {
       ...props,
@@ -662,721 +607,991 @@ var ExpandableUncontrolled = forwardRef2(function ExpandableUncontrolled2({
   );
 });
 
-// src/components/user-action/Menu.tsx
-import { useEffect as useEffect5, useRef, useState as useState5 } from "react";
-import clsx6 from "clsx";
+// src/hooks/focus/useFocusTrap.ts
+import { useCallback as useCallback3, useEffect as useEffect4, useId as useId2, useRef, useState as useState5 } from "react";
 
-// src/hooks/useOutsideClick.ts
-import { useEffect as useEffect3 } from "react";
-var useOutsideClick = (refs, handler) => {
-  useEffect3(() => {
-    const listener = (event) => {
-      if (event.target === null) return;
-      if (refs.some((ref) => !ref.current || ref.current.contains(event.target))) {
-        return;
-      }
-      handler();
-    };
-    document.addEventListener("mousedown", listener);
-    document.addEventListener("touchstart", listener);
+// src/hooks/focus/useIsMounted.ts
+import { useEffect as useEffect3, useLayoutEffect, useState as useState4 } from "react";
+var isClient = typeof window !== "undefined" && typeof document !== "undefined";
+var useIsomorphicEffect = isClient ? useLayoutEffect : useEffect3;
+var useIsMounted = () => {
+  const [isMounted, setIsMounted] = useState4(false);
+  useIsomorphicEffect(() => {
+    setIsMounted(true);
     return () => {
-      document.removeEventListener("mousedown", listener);
-      document.removeEventListener("touchstart", listener);
+      setIsMounted(false);
     };
-  }, [refs, handler]);
+  }, []);
+  return isMounted;
 };
 
-// src/hooks/useHoverState.ts
-import { useEffect as useEffect4, useState as useState4 } from "react";
-var defaultUseHoverStateProps = {
-  closingDelay: 200,
-  isDisabled: false
+// src/hooks/focus/useFocusTrap.ts
+var createFocusGuard = () => {
+  const div = document.createElement("div");
+  Object.assign(div.style, {
+    opacity: "0",
+    outline: "none",
+    boxShadow: "none",
+    position: "fixed",
+    pointerEvents: "none",
+    touchAction: "none"
+  });
+  div.tabIndex = 0;
+  div.setAttribute("data-hw-focus-guard", "");
+  document.body.appendChild(div);
+  return div;
 };
-var useHoverState = (props = void 0) => {
-  const { closingDelay, isDisabled } = { ...defaultUseHoverStateProps, ...props };
-  const [isHovered, setIsHovered] = useState4(false);
-  const [timer, setTimer] = useState4();
-  const onMouseEnter = () => {
-    if (isDisabled) {
-      return;
+function getContainedFocusableElements(element) {
+  return element?.querySelectorAll('button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])');
+}
+var FocusTrapService = class {
+  constructor() {
+    // The last entry is always the active one
+    this.listeners = [];
+    this.onFocusIn = (event) => {
+      const active = this.getActive();
+      if (!active || !active.container.current) return;
+      const { container } = active;
+      if (!container.current.contains(event.target)) {
+        this.focusElement();
+      }
+    };
+  }
+  getActive() {
+    if (this.listeners.length === 0) return void 0;
+    return this.listeners[this.listeners.length - 1];
+  }
+  focusElement() {
+    const active = this.getActive();
+    if (!active) return;
+    const { container, initialFocusElement } = active;
+    const containerElement = container.current;
+    if (initialFocusElement?.current) {
+      initialFocusElement.current.focus();
+    } else {
+      const elements = getContainedFocusableElements(containerElement);
+      if (elements && elements.length > 0) {
+        const first = elements.item(0);
+        first.focus();
+      } else {
+        containerElement.focus();
+      }
     }
-    clearTimeout(timer);
-    setIsHovered(true);
-  };
-  const onMouseLeave = () => {
-    if (isDisabled) {
-      return;
+  }
+  removeGuards() {
+    document.querySelectorAll("[data-hw-focus-guard]").forEach((node) => node.remove());
+  }
+  addGuards() {
+    document.body.insertAdjacentElement("afterbegin", createFocusGuard());
+    document.body.insertAdjacentElement("beforeend", createFocusGuard());
+  }
+  activate() {
+    document.addEventListener("focusin", this.onFocusIn);
+    this.addGuards();
+  }
+  deactivate() {
+    document.removeEventListener("focusin", this.onFocusIn);
+    this.removeGuards();
+  }
+  register(listener) {
+    this.listeners.push(listener);
+    if (this.listeners.length === 1) {
+      this.activate();
     }
-    setTimer(setTimeout(() => {
-      setIsHovered(false);
-    }, closingDelay));
-  };
-  useEffect4(() => {
-    if (timer) {
+    const active = listener;
+    this.listeners.forEach((listener2) => {
+      const { focus, pause } = listener2;
+      if (listener2 === active) {
+        focus();
+      } else {
+        pause();
+      }
+    });
+  }
+  unregister(id) {
+    const index = this.listeners.findIndex((trap) => trap.id === id);
+    if (index !== -1) {
+      const isActive = index === this.listeners.length - 1;
+      const listener = this.listeners[index];
+      this.listeners = this.listeners.filter((listener2) => listener2.id !== id);
+      if (isActive) {
+        this.deactivate();
+        listener.focusLast();
+        const active = this.getActive();
+        this.listeners.forEach((listener2) => {
+          const { pause, unpause } = listener2;
+          if (listener2 === active) {
+            unpause();
+          } else {
+            pause();
+          }
+        });
+        if (this.listeners.length > 0) {
+          this.activate();
+        }
+      }
+    } else {
+      console.warn(`Unable to unregister id ${id}: not found`);
+    }
+  }
+};
+var service = new FocusTrapService();
+var useFocusTrap = ({
+  container,
+  active = true,
+  initialFocus,
+  focusFirst = true
+}) => {
+  const lastFocusRef = useRef(null);
+  const [paused, setPaused] = useState5(false);
+  const isMounted = useIsMounted();
+  const id = useId2();
+  const focusElement = useCallback3(() => {
+    const containerElement = container.current;
+    if (initialFocus?.current) {
+      initialFocus.current.focus();
+    } else {
+      const elements = getContainedFocusableElements(containerElement);
+      if (elements && elements.length > 0) {
+        const first = elements.item(0);
+        first.focus();
+      } else {
+        containerElement.focus();
+      }
+    }
+  }, [container, initialFocus]);
+  useEffect4(() => {
+    if (active && isMounted) {
+      let pause = function() {
+        setPaused(true);
+      }, unpause = function() {
+        setPaused(false);
+        if (!container.current.contains(document.activeElement)) {
+          focusElement();
+        }
+      }, focus = function() {
+        focusElement();
+        setPaused(false);
+      }, focusLast = function() {
+        lastFocusRef.current?.focus();
+      };
+      if (!lastFocusRef.current) {
+        lastFocusRef.current = document.activeElement;
+      }
+      service.register({ id, pause, focus, focusLast, unpause, container, initialFocusElement: initialFocus });
       return () => {
-        clearTimeout(timer);
+        service.unregister(id);
+        lastFocusRef.current = void 0;
       };
     }
-  });
+  }, [active, container, focusElement, id, initialFocus, isMounted]);
   useEffect4(() => {
-    if (timer) {
-      clearTimeout(timer);
+    if (active && !paused && isMounted) {
+      let onKeyDown = function(event) {
+        const key = event.key;
+        const elements = getContainedFocusableElements(containerElement);
+        const active2 = document.activeElement;
+        const index = [...elements].findIndex((value) => value === active2);
+        if (index === -1 || event.altKey || event.ctrlKey || event.metaKey) {
+          return;
+        }
+        if (key === "Tab") {
+          const next = event.shiftKey ? -1 : 1;
+          const nextIndex = (index + next + elements.length) % elements.length;
+          const nextElement = elements[nextIndex];
+          nextElement.focus();
+          event.preventDefault();
+        }
+      };
+      const containerElement = container.current;
+      containerElement.addEventListener("keydown", onKeyDown);
+      return () => {
+        containerElement.removeEventListener("keydown", onKeyDown);
+      };
     }
-  }, [isDisabled]);
-  return {
-    isHovered,
-    setIsHovered,
-    handlers: { onMouseEnter, onMouseLeave }
-  };
+  }, [active, paused, isMounted, container, initialFocus, focusFirst, focusElement]);
 };
 
-// src/util/PropsWithFunctionChildren.ts
-var resolve = (children, bag) => {
-  if (typeof children === "function") {
-    return children(bag);
-  }
-  return children ?? void 0;
+// src/utils/match.ts
+var match = (key, values) => {
+  return values[key];
 };
-var BagFunctionUtil = {
-  resolve
+
+// src/components/user-action/select/Select.tsx
+import { CheckIcon, Plus, XIcon } from "lucide-react";
+
+// src/components/layout-and-navigation/Chip.tsx
+import clsx4 from "clsx";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var Chip = ({
+  children,
+  trailingIcon,
+  color = "default",
+  size = "md",
+  icon = false,
+  variant = "normal",
+  className = "",
+  ...restProps
+}) => {
+  const colorMapping = {
+    default: "text-tag-default-text bg-tag-default-background",
+    dark: "text-tag-dark-text bg-tag-dark-background",
+    red: "text-tag-red-text bg-tag-red-background",
+    yellow: "text-tag-yellow-text bg-tag-yellow-background",
+    green: "text-tag-green-text bg-tag-green-background",
+    blue: "text-tag-blue-text bg-tag-blue-background",
+    pink: "text-tag-pink-text bg-tag-pink-background",
+    orange: "text-tag-orange-text bg-tag-orange-background"
+  }[color];
+  const colorMappingIcon = {
+    default: "text-tag-default-icon",
+    dark: "text-tag-dark-icon",
+    red: "text-tag-red-icon",
+    yellow: "text-tag-yellow-icon",
+    green: "text-tag-green-icon",
+    blue: "text-tag-blue-icon",
+    pink: "text-tag-pink-icon",
+    orange: "text-tag-orange-icon"
+  }[color];
+  return /* @__PURE__ */ jsxs4(
+    "div",
+    {
+      ...restProps,
+      className: clsx4(
+        `flex-row-0 w-fit font-semibold`,
+        colorMapping,
+        !icon ? {
+          "px-1 py-0.5": size === "sm",
+          "px-2 py-1": size === "md",
+          "px-4 py-2": size === "lg"
+        } : {
+          "p-0.5": size === "sm",
+          "p-1": size === "md",
+          "p-2": size === "lg"
+        },
+        {
+          "rounded-md": variant === "normal",
+          "rounded-full": variant === "fullyRounded"
+        },
+        className
+      ),
+      children: [
+        children,
+        trailingIcon && /* @__PURE__ */ jsx5("span", { className: colorMappingIcon, children: trailingIcon })
+      ]
+    }
+  );
 };
 
-// src/hooks/usePopoverPosition.ts
-var defaultPopoverPositionOptions = {
-  edgePadding: 16,
-  outerGap: 4,
-  horizontalAlignment: "leftInside",
-  verticalAlignment: "bottomOutside",
-  disabled: false
+// src/hooks/useFloatingElement.ts
+import { useCallback as useCallback4, useEffect as useEffect5, useState as useState6 } from "react";
+
+// src/utils/math.ts
+var clamp = (value, range = [0, 1]) => {
+  const [min, max] = range;
+  return Math.min(Math.max(value, min), max);
 };
-var usePopoverPosition = (trigger, options) => {
-  const {
-    edgePadding,
-    outerGap,
-    verticalAlignment,
-    horizontalAlignment,
-    disabled
-  } = { ...defaultPopoverPositionOptions, ...options };
-  if (disabled || !trigger) {
-    return {};
-  }
-  const left = {
-    leftOutside: trigger.left - outerGap,
-    leftInside: trigger.left,
-    rightOutside: trigger.right + outerGap,
-    rightInside: trigger.right,
-    center: trigger.left + trigger.width / 2
-  }[horizontalAlignment];
-  const top = {
-    topOutside: trigger.top - outerGap,
-    topInside: trigger.top,
-    bottomOutside: trigger.bottom + outerGap,
-    bottomInside: trigger.bottom,
-    center: trigger.top + trigger.height / 2
-  }[verticalAlignment];
-  const translateX = {
-    leftOutside: "-100%",
-    leftInside: void 0,
-    rightOutside: void 0,
-    rightInside: "-100%",
-    center: "-50%"
+
+// src/hooks/useFloatingElement.ts
+function calculatePosition({
+  windowRect,
+  containerRect,
+  anchorRect,
+  options
+}) {
+  const { verticalAlignment, horizontalAlignment, gap, screenPadding } = options;
+  const windowWidth = windowRect.width;
+  const windowHeight = windowRect.height;
+  const maxWidth = windowWidth - 2 * screenPadding;
+  const maxHeight = windowHeight - 2 * screenPadding;
+  const width = Math.min(containerRect.width, maxWidth);
+  const height = Math.min(containerRect.height, maxHeight);
+  const leftSuggestion = {
+    beforeStart: anchorRect.left - width - gap,
+    afterStart: anchorRect.left,
+    center: anchorRect.left + anchorRect.width / 2 - width / 2,
+    beforeEnd: anchorRect.right - width,
+    afterEnd: anchorRect.right + gap
   }[horizontalAlignment];
-  const translateY = {
-    topOutside: "-100%",
-    topInside: void 0,
-    bottomOutside: void 0,
-    bottomInside: "-100%",
-    center: "-50%"
+  const topSuggestion = {
+    beforeStart: anchorRect.top - height - gap,
+    afterStart: anchorRect.top,
+    center: anchorRect.top + anchorRect.height / 2 - height / 2,
+    beforeEnd: anchorRect.bottom - height,
+    afterEnd: anchorRect.bottom + gap
   }[verticalAlignment];
+  const left = clamp(leftSuggestion, [
+    screenPadding,
+    windowWidth - screenPadding - width
+  ]);
+  const top = clamp(topSuggestion, [
+    screenPadding,
+    windowHeight - screenPadding - height
+  ]);
   return {
-    left: Math.max(left, edgePadding),
-    top: Math.max(top, edgePadding),
-    translate: [translateX ?? "0", translateY ?? "0"].join(" ")
+    left,
+    top,
+    maxWidth,
+    maxHeight
   };
-};
+}
+function useFloatingElement({
+  active = true,
+  windowRef,
+  anchorRef,
+  containerRef,
+  isPolling = false,
+  pollingInterval = 100,
+  verticalAlignment = "afterEnd",
+  horizontalAlignment = "afterStart",
+  screenPadding = 16,
+  gap = 4
+}) {
+  const [style, setStyle] = useState6();
+  const isMounted = useIsMounted();
+  const calculate = useCallback4(() => {
+    const containerRect = containerRef.current.getBoundingClientRect();
+    const windowRect = windowRef?.current.getBoundingClientRect() ?? {
+      top: 0,
+      bottom: window.innerHeight,
+      left: 0,
+      right: window.innerWidth,
+      width: window.innerWidth,
+      height: window.innerHeight
+    };
+    const anchorElement = anchorRef?.current;
+    if (anchorRef && !anchorElement) {
+      console.warn("FloatingContainer anchor provided, but its value is undefined");
+    }
+    const anchorRect = anchorElement?.getBoundingClientRect() ?? windowRect;
+    const calculateProps = {
+      windowRect,
+      anchorRect,
+      containerRect,
+      options: {
+        horizontalAlignment,
+        verticalAlignment,
+        screenPadding,
+        gap
+      }
+    };
+    setStyle(calculatePosition(calculateProps));
+  }, [anchorRef, containerRef, gap, horizontalAlignment, screenPadding, verticalAlignment, windowRef]);
+  const height = containerRef.current?.getBoundingClientRect().height;
+  const width = containerRef.current?.getBoundingClientRect().width;
+  useEffect5(() => {
+    if (active && isMounted) {
+      calculate();
+    } else {
+      setStyle(void 0);
+    }
+  }, [calculate, active, isMounted, height, width]);
+  useEffect5(() => {
+    window.addEventListener("resize", calculate);
+    let timeout;
+    if (isPolling) {
+      timeout = setInterval(calculate, pollingInterval);
+    }
+    return () => {
+      window.removeEventListener("resize", calculate);
+      if (timeout) {
+        clearInterval(timeout);
+      }
+    };
+  }, [calculate, isPolling, pollingInterval]);
+  return style;
+}
 
-// src/components/user-action/Menu.tsx
+// src/components/user-action/select/Select.tsx
 import { createPortal } from "react-dom";
-import { Fragment, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
-function getScrollableParents(element) {
-  const scrollables = [];
-  let parent = element.parentElement;
-  while (parent) {
-    scrollables.push(parent);
-    parent = parent.parentElement;
+import { Fragment, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var defaultToggleOpenOptions = {
+  highlightStartPosition: "first"
+};
+var SelectContext = createContext2(null);
+function useSelectContext() {
+  const ctx = useContext2(SelectContext);
+  if (!ctx) {
+    throw new Error("SelectContext must be used within a ListBoxPrimitive");
   }
-  return scrollables;
+  return ctx;
 }
-var Menu = ({
-  trigger,
+var SelectRoot = ({
   children,
-  alignmentHorizontal = "leftInside",
-  alignmentVertical = "bottomOutside",
-  showOnHover = false,
+  id,
+  value,
+  onValueChanged,
+  values,
+  onValuesChanged,
+  isOpen = false,
   disabled = false,
-  menuClassName = ""
+  invalid = false,
+  isMultiSelect = false
 }) => {
-  const { isHovered: isOpen, setIsHovered: setIsOpen } = useHoverState({ isDisabled: !showOnHover || disabled });
-  const triggerRef = useRef(null);
-  const menuRef = useRef(null);
-  useOutsideClick([triggerRef, menuRef], () => setIsOpen(false));
-  const [isHidden, setIsHidden] = useState5(true);
-  const bag = {
-    isOpen,
-    close: () => setIsOpen(false),
-    toggleOpen: () => setIsOpen((prevState) => !prevState),
-    disabled
+  const optionsRef = useRef2([]);
+  const triggerRef = useRef2(null);
+  const generatedId = useId3();
+  const usedId = id ?? generatedId;
+  const [internalState, setInternalState] = useState7({
+    isOpen
+  });
+  const state = {
+    ...internalState,
+    id: usedId,
+    disabled,
+    invalid,
+    value: isMultiSelect ? values ?? [] : [value].filter(Boolean),
+    isMultiSelect
   };
-  const menuPosition = usePopoverPosition(
-    triggerRef.current?.getBoundingClientRect(),
-    { verticalAlignment: alignmentVertical, horizontalAlignment: alignmentHorizontal, disabled }
-  );
-  useEffect5(() => {
-    if (!isOpen) return;
-    const triggerEl = triggerRef.current;
-    if (!triggerEl) return;
-    const scrollableParents = getScrollableParents(triggerEl);
-    const close = () => setIsOpen(false);
-    scrollableParents.forEach((parent) => {
-      parent.addEventListener("scroll", close);
+  const registerItem = useCallback5((item) => {
+    optionsRef.current.push(item);
+    optionsRef.current.sort((a, b) => {
+      const aEl = a.ref.current;
+      const bEl = b.ref.current;
+      if (!aEl || !bEl) return 0;
+      return aEl.compareDocumentPosition(bEl) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
     });
-    window.addEventListener("resize", close);
-    return () => {
-      scrollableParents.forEach((parent) => {
-        parent.removeEventListener("scroll", close);
-      });
-      window.removeEventListener("resize", close);
-    };
-  }, [isOpen, setIsOpen]);
-  useEffect5(() => {
-    if (isOpen) {
-      setIsHidden(false);
+  }, []);
+  const unregisterItem = useCallback5((value2) => {
+    optionsRef.current = optionsRef.current.filter((i) => i.value !== value2);
+  }, []);
+  const toggleSelection = (value2, isSelected) => {
+    if (disabled) {
+      return;
     }
-  }, [isOpen]);
-  return /* @__PURE__ */ jsxs5(Fragment, { children: [
-    trigger(bag, triggerRef),
-    createPortal(/* @__PURE__ */ jsx7(
-      "div",
-      {
-        ref: menuRef,
-        onClick: (e) => e.stopPropagation(),
-        className: clsx6(
-          "absolute rounded-md bg-menu-background text-menu-text shadow-around-lg shadow-strong z-[300]",
-          {
-            "animate-pop-in": isOpen,
-            "animate-pop-out": !isOpen,
-            "hidden": isHidden
-          },
-          menuClassName
-        ),
-        onAnimationEnd: () => {
-          if (!isOpen) {
-            setIsHidden(true);
-          }
-        },
-        style: {
-          ...menuPosition
-        },
-        children: BagFunctionUtil.resolve(children, bag)
+    const option = optionsRef.current.find((i) => i.value === value2);
+    if (!option) {
+      console.error(`SelectOption with value: ${value2} not found`);
+      return;
+    }
+    let newValue;
+    if (isMultiSelect) {
+      const isSelectedBefore = state.value.includes(value2);
+      const isSelectedAfter = isSelected ?? !isSelectedBefore;
+      if (!isSelectedAfter) {
+        newValue = state.value.filter((v) => v !== value2);
+      } else {
+        newValue = [...state.value, value2];
       }
-    ), document.body)
-  ] });
-};
-
-// src/components/user-action/Input.tsx
-import { forwardRef as forwardRef3, useEffect as useEffect8, useImperativeHandle, useRef as useRef2, useState as useState7 } from "react";
-import clsx7 from "clsx";
-
-// src/hooks/useDelay.ts
-import { useEffect as useEffect6, useState as useState6 } from "react";
-var defaultOptions = {
-  delay: 3e3,
-  disabled: false
-};
-function useDelay(options) {
-  const [timer, setTimer] = useState6(void 0);
-  const { delay, disabled } = {
-    ...defaultOptions,
-    ...options
-  };
-  const clearTimer = () => {
-    clearTimeout(timer);
-    setTimer(void 0);
+    } else {
+      newValue = [value2];
+    }
+    if (!isMultiSelect) {
+      onValueChanged?.(newValue[0]);
+    } else {
+      onValuesChanged?.(newValue);
+    }
+    setInternalState((prevState) => ({
+      ...prevState,
+      highlightedValue: value2
+    }));
   };
-  const restartTimer = (onDelayFinish) => {
+  const highlightItem = (value2) => {
     if (disabled) {
       return;
     }
-    clearTimeout(timer);
-    setTimer(setTimeout(() => {
-      onDelayFinish();
-      setTimer(void 0);
-    }, delay));
+    setInternalState((prevState) => ({
+      ...prevState,
+      highlightedValue: value2
+    }));
   };
-  useEffect6(() => {
-    return () => {
-      clearTimeout(timer);
-    };
-  }, [timer]);
-  useEffect6(() => {
-    if (disabled) {
-      clearTimeout(timer);
-      setTimer(void 0);
-    }
-  }, [disabled, timer]);
-  return { restartTimer, clearTimer, hasActiveTimer: !!timer };
-}
-
-// src/hooks/useFocusManagement.ts
-import { useCallback as useCallback3 } from "react";
-function useFocusManagement() {
-  const getFocusableElements = useCallback3(() => {
-    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 registerTrigger = useCallback5((ref) => {
+    triggerRef.current = ref.current;
   }, []);
-  const getNextFocusElement = useCallback3(() => {
-    const elements = getFocusableElements();
-    if (elements.length === 0) {
-      return void 0;
+  const unregisterTrigger = useCallback5(() => {
+    triggerRef.current = null;
+  }, []);
+  const toggleOpen = (isOpen2, options) => {
+    const { highlightStartPosition } = { ...defaultToggleOpenOptions, ...options };
+    let highlightedIndex;
+    if (highlightStartPosition === "first") {
+      highlightedIndex = optionsRef.current.findIndex((option) => !option.disabled);
+    } else {
+      highlightedIndex = optionsRef.current.length - 1 - [...optionsRef.current].reverse().findIndex((option) => !option.disabled);
     }
-    let nextElement = elements[0];
-    if (document.activeElement instanceof HTMLElement) {
-      const currentIndex = elements.indexOf(document.activeElement);
-      nextElement = elements[(currentIndex + 1) % elements.length];
+    if (highlightedIndex === -1 || highlightedIndex === optionsRef.current.length) {
+      highlightedIndex = 0;
     }
-    return nextElement;
-  }, [getFocusableElements]);
-  const focusNext = useCallback3(() => {
-    const nextElement = getNextFocusElement();
-    nextElement?.focus();
-  }, [getNextFocusElement]);
-  const getPreviousFocusElement = useCallback3(() => {
-    const elements = getFocusableElements();
-    if (elements.length === 0) {
-      return void 0;
+    setInternalState((prevState) => ({
+      ...prevState,
+      isOpen: isOpen2 ?? !prevState.isOpen,
+      highlightedValue: optionsRef.current[highlightedIndex].value
+    }));
+  };
+  const moveHighlightedIndex = (delta) => {
+    let highlightedIndex = optionsRef.current.findIndex((value2) => value2.value === internalState.highlightedValue);
+    if (highlightedIndex === -1) {
+      highlightedIndex = 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];
+    const optionLength = optionsRef.current.length;
+    const startIndex = (highlightedIndex + delta % optionLength + optionLength) % optionLength;
+    const isForward = delta >= 0;
+    let highlightedValue = optionsRef.current[startIndex].value;
+    for (let i = 0; i < optionsRef.current.length; i++) {
+      const index = (startIndex + (isForward ? i : -i) + optionLength) % optionLength;
+      if (!optionsRef.current[index].disabled) {
+        highlightedValue = optionsRef.current[index].value;
+        break;
       }
     }
-    return previousElement;
-  }, [getFocusableElements]);
-  const focusPrevious = useCallback3(() => {
-    const previousElement = getPreviousFocusElement();
-    if (previousElement) previousElement.focus();
-  }, [getPreviousFocusElement]);
-  return {
-    getFocusableElements,
-    getNextFocusElement,
-    getPreviousFocusElement,
-    focusNext,
-    focusPrevious
+    setInternalState((prevState) => ({
+      ...prevState,
+      highlightedValue
+    }));
   };
-}
-
-// src/hooks/useFocusOnceVisible.ts
-import React, { useEffect as useEffect7 } from "react";
-var useFocusOnceVisible = (ref, disable = false) => {
-  const [hasUsedFocus, setHasUsedFocus] = React.useState(false);
-  useEffect7(() => {
-    if (disable || hasUsedFocus) {
-      return;
+  useEffect6(() => {
+    if (!internalState.highlightedValue) return;
+    const highlighted = optionsRef.current.find((value2) => value2.value === internalState.highlightedValue);
+    if (highlighted) {
+      highlighted.ref.current.scrollIntoView({ behavior: "instant", block: "nearest" });
+    } else {
+      console.error(`SelectRoot: Could not find highlighted value (${internalState.highlightedValue})`);
     }
-    const observer = new IntersectionObserver(([entry]) => {
-      if (entry.isIntersecting && !hasUsedFocus) {
-        ref.current?.focus();
-        setHasUsedFocus(hasUsedFocus);
-      }
-    }, {
-      threshold: 0.1
-    });
-    if (ref.current) {
-      observer.observe(ref.current);
+  }, [internalState.highlightedValue]);
+  const contextValue = {
+    state,
+    item: {
+      register: registerItem,
+      unregister: unregisterItem,
+      toggleSelection,
+      highlightItem,
+      moveHighlightedIndex
+    },
+    trigger: {
+      ref: triggerRef,
+      register: registerTrigger,
+      unregister: unregisterTrigger,
+      toggleOpen
     }
-    return () => observer.disconnect();
-  }, [disable, hasUsedFocus, ref]);
+  };
+  return /* @__PURE__ */ jsx6(SelectContext.Provider, { value: contextValue, children });
 };
-
-// src/components/user-action/Input.tsx
-import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
-var getInputClassName = ({ disabled = false, hasError = false }) => {
-  return clsx7(
-    "px-2 py-1.5 rounded-md border-2",
+var SelectOption = forwardRef3(
+  function SelectOption2({ value, disabled = false, children, className, ...restProps }, ref) {
+    const { state, item, trigger } = useSelectContext();
+    const { register, unregister, toggleSelection, highlightItem } = item;
+    const itemRef = useRef2(null);
+    useEffect6(() => {
+      register({
+        value,
+        disabled,
+        ref: itemRef
+      });
+      return () => unregister(value);
+    }, [value, disabled, register, unregister, children]);
+    const isHighlighted = state.highlightedValue === value;
+    const isSelected = state.value.includes(value);
+    return /* @__PURE__ */ jsxs5(
+      "li",
+      {
+        ...restProps,
+        ref: (node) => {
+          itemRef.current = node;
+          if (typeof ref === "function") ref(node);
+          else if (ref) ref.current = node;
+        },
+        id: value,
+        role: "option",
+        "aria-disabled": disabled,
+        "aria-selected": isSelected,
+        "data-highlighted": isHighlighted ? "" : void 0,
+        "data-selected": isSelected ? "" : void 0,
+        "data-disabled": disabled ? "" : void 0,
+        className: clsx5(
+          "flex-row-1 items-center px-2 py-1 rounded-md",
+          "data-highlighted:bg-primary/20",
+          "data-disabled:text-disabled data-disabled:cursor-not-allowed",
+          "not-data-disabled:cursor-pointer",
+          className
+        ),
+        onClick: (event) => {
+          if (!disabled) {
+            toggleSelection(value);
+            if (!state.isMultiSelect) {
+              trigger.toggleOpen(false);
+            }
+            restProps.onClick?.(event);
+          }
+        },
+        onMouseEnter: (event) => {
+          if (!disabled) {
+            highlightItem(value);
+            restProps.onMouseEnter?.(event);
+          }
+        },
+        children: [
+          /* @__PURE__ */ jsx6(
+            CheckIcon,
+            {
+              className: clsx5("w-4 h-4", { "opacity-0": !isSelected || disabled }),
+              "aria-hidden": true
+            }
+          ),
+          children ?? value
+        ]
+      }
+    );
+  }
+);
+var defaultSelectButtonTranslation = {
+  en: {
+    clickToSelect: "Click to select"
+  },
+  de: {
+    clickToSelect: "Zum ausw\xE4hlen dr\xFCcken"
+  }
+};
+var SelectButton = forwardRef3(function SelectButton2({ placeholder, selectedDisplay, ...props }, ref) {
+  const translation = useTranslation([defaultSelectButtonTranslation]);
+  const { state, trigger } = useSelectContext();
+  const { register, unregister, toggleOpen } = trigger;
+  const innerRef = useRef2(null);
+  useImperativeHandle(ref, () => innerRef.current);
+  useEffect6(() => {
+    register(innerRef);
+    return () => unregister();
+  }, [register, unregister]);
+  const disabled = !!props?.disabled || !!state.disabled;
+  const invalid = state.invalid;
+  const hasValue = state.value.length > 0;
+  return /* @__PURE__ */ jsxs5(
+    "button",
     {
-      "bg-input-background text-input-text 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
+      ...props,
+      ref: innerRef,
+      id: state.id,
+      className: clsx5(
+        "flex-row-2 items-center justify-between bg-input-background text-input-text rounded-md px-2.5 py-2.5",
+        "data-placeholder:text-description",
+        props.className
+      ),
+      onClick: () => toggleOpen(!state.isOpen),
+      onKeyDown: (event) => {
+        switch (event.key) {
+          case "ArrowDown":
+            toggleOpen(true, { highlightStartPosition: "first" });
+            break;
+          case "ArrowUp":
+            toggleOpen(true, { highlightStartPosition: "last" });
+            break;
+        }
+      },
+      "data-placeholder": !hasValue ? "" : void 0,
+      "data-disabled": disabled ? "" : void 0,
+      "data-invalid": invalid ? "" : void 0,
+      "aria-invalid": invalid,
+      "aria-disabled": disabled,
+      "aria-haspopup": "listbox",
+      "aria-expanded": state.isOpen,
+      "aria-controls": state.isOpen ? `${state.id}-listbox` : void 0,
+      children: [
+        hasValue ? selectedDisplay?.(state.value) ?? state.value.join(", ") : placeholder ?? translation("clickToSelect"),
+        /* @__PURE__ */ jsx6(ExpansionIcon, { isExpanded: state.isOpen })
+      ]
     }
   );
-};
-var defaultEditCompleteOptions = {
-  onBlur: true,
-  afterDelay: true,
-  delay: 2500
-};
-var Input = forwardRef3(function Input2({
-  id,
-  type = "text",
-  value,
-  label,
-  onChange = noop,
-  onChangeText = noop,
-  onEditCompleted,
-  className = "",
-  allowEnterComplete = true,
-  expanded = true,
-  autoFocus = false,
-  onBlur,
-  editCompleteOptions,
-  containerClassName,
-  disabled,
-  ...restProps
-}, forwardedRef) {
-  const { onBlur: allowEditCompleteOnBlur, afterDelay, delay } = { ...defaultEditCompleteOptions, ...editCompleteOptions };
-  const {
-    restartTimer,
-    clearTimer
-  } = useDelay({ delay, disabled: !afterDelay });
+});
+var SelectChipDisplay = forwardRef3(function SelectChipDisplay2({ ...props }, ref) {
+  const { state, trigger, item } = useSelectContext();
+  const { register, unregister, toggleOpen } = trigger;
   const innerRef = useRef2(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();
+  useImperativeHandle(ref, () => innerRef.current);
+  useEffect6(() => {
+    register(innerRef);
+    return () => unregister();
+  }, [register, unregister]);
+  const disabled = !!props?.disabled || !!state.disabled;
+  const invalid = state.invalid;
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      ...props,
+      ref: innerRef,
+      className: clsx5(
+        "flex flex-wrap flex-row gap-2 items-center bg-input-background text-input-text rounded-md px-2.5 py-2.5",
+        props.className
+      ),
+      "data-disabled": disabled ? "" : void 0,
+      "data-invalid": invalid ? "" : void 0,
+      "aria-invalid": invalid,
+      "aria-disabled": disabled,
+      children: [
+        state.value.map((value) => /* @__PURE__ */ jsxs5(Chip, { className: "gap-x-2", children: [
+          value,
+          /* @__PURE__ */ jsx6(
+            "button",
+            {
+              onClick: () => {
+                item.toggleSelection(value, false);
+              },
+              className: "focus-within:text-negative hover:bg-negative/20 hover:text-negative rounded-md focus-style-none focus-visible:ring-2 focus-visible:ring-negative focus-visible:bg-negative/20",
+              children: /* @__PURE__ */ jsx6(XIcon, {})
+            }
+          )
+        ] }, value)),
+        /* @__PURE__ */ jsx6(
+          IconButton,
+          {
+            id: state.id,
+            onClick: () => toggleOpen(),
+            onKeyDown: (event) => {
+              switch (event.key) {
+                case "ArrowDown":
+                  toggleOpen(true, { highlightStartPosition: "first" });
+                  break;
+                case "ArrowUp":
+                  toggleOpen(true, { highlightStartPosition: "last" });
+              }
+            },
+            size: "small",
+            color: "neutral",
+            "aria-invalid": invalid,
+            "aria-disabled": disabled,
+            "aria-haspopup": "listbox",
+            "aria-expanded": state.isOpen,
+            "aria-controls": state.isOpen ? `${state.id}-listbox` : void 0,
+            children: /* @__PURE__ */ jsx6(Plus, {})
+          }
+        )
+      ]
     }
-  };
-  return /* @__PURE__ */ jsxs6("div", { className: clsx7({ "w-full": expanded }, containerClassName), children: [
-    label && /* @__PURE__ */ jsx8(Label, { ...label, htmlFor: id, className: clsx7("mb-1", label.className) }),
-    /* @__PURE__ */ jsx8(
-      "input",
-      {
-        ...restProps,
-        ref: innerRef,
-        value,
-        id,
-        type,
-        disabled,
-        className: clsx7(getInputClassName({ disabled }), className),
-        onKeyDown: allowEnterComplete ? handleKeyDown : void 0,
-        onBlur: (event) => {
-          onBlur?.(event);
-          if (onEditCompleted && allowEditCompleteOnBlur) {
-            onEditCompleted(event.target.value);
-            clearTimer();
+  );
+});
+var SelectContent = forwardRef3(
+  function SelectContent2({
+    alignment,
+    orientation = "vertical",
+    ...props
+  }, ref) {
+    const innerRef = useRef2(null);
+    useImperativeHandle(ref, () => innerRef.current);
+    const { trigger, state, item } = useSelectContext();
+    const position = useFloatingElement({
+      active: state.isOpen,
+      anchorRef: trigger.ref,
+      containerRef: innerRef,
+      ...alignment
+    });
+    useFocusTrap({
+      container: innerRef,
+      active: state.isOpen && !!position
+    });
+    return createPortal(
+      /* @__PURE__ */ jsxs5(Fragment, { children: [
+        /* @__PURE__ */ jsx6(
+          "div",
+          {
+            hidden: !state.isOpen,
+            onClick: () => trigger.toggleOpen(false),
+            className: clsx5("fixed w-screen h-screen inset-0")
           }
-        },
-        onChange: (e) => {
-          const value2 = e.target.value;
-          if (onEditCompleted) {
-            restartTimer(() => {
-              if (innerRef.current) {
-                innerRef.current.blur();
-                if (!allowEditCompleteOnBlur) {
-                  onEditCompleted(value2);
-                }
-              } else {
-                onEditCompleted(value2);
+        ),
+        /* @__PURE__ */ jsx6(
+          "ul",
+          {
+            ...props,
+            id: `${state.id}-listbox`,
+            ref: innerRef,
+            hidden: !state.isOpen,
+            onKeyDown: (event) => {
+              switch (event.key) {
+                case "Escape":
+                  trigger.toggleOpen(false);
+                  event.preventDefault();
+                  event.stopPropagation();
+                  break;
+                case match(orientation, {
+                  vertical: "ArrowDown",
+                  horizontal: "ArrowUp"
+                }):
+                  item.moveHighlightedIndex(1);
+                  event.preventDefault();
+                  break;
+                case match(orientation, {
+                  vertical: "ArrowUp",
+                  horizontal: "ArrowDown"
+                }):
+                  item.moveHighlightedIndex(-1);
+                  event.preventDefault();
+                  break;
+                case "Home":
+                  event.preventDefault();
+                  break;
+                case "End":
+                  event.preventDefault();
+                  break;
+                case "Enter":
+                // Fall through
+                case " ":
+                  if (state.highlightedValue) {
+                    item.toggleSelection(state.highlightedValue);
+                    if (!state.isMultiSelect) {
+                      trigger.toggleOpen(false);
+                    }
+                    event.preventDefault();
+                  }
+                  break;
               }
-            });
+            },
+            className: clsx5("flex-col-0 p-2 bg-menu-background text-menu-text rounded-md shadow-hw-bottom focus-style-within overflow-auto", props.className),
+            style: {
+              opacity: position ? void 0 : 0,
+              position: "fixed",
+              ...position
+            },
+            role: "listbox",
+            "aria-multiselectable": state.isMultiSelect,
+            "aria-orientation": orientation,
+            tabIndex: position ? 0 : void 0,
+            children: props.children
           }
-          onChange(e);
-          onChangeText(value2);
+        )
+      ] }),
+      document.body
+    );
+  }
+);
+var Select = forwardRef3(function Select2({
+  children,
+  contentPanelProps,
+  buttonProps,
+  ...props
+}, ref) {
+  return /* @__PURE__ */ jsxs5(SelectRoot, { ...props, isMultiSelect: false, children: [
+    /* @__PURE__ */ jsx6(
+      SelectButton,
+      {
+        ref,
+        ...buttonProps,
+        selectedDisplay: (values) => {
+          const value = values[0];
+          if (!buttonProps?.selectedDisplay) return void 0;
+          return buttonProps.selectedDisplay(value);
         }
       }
-    )
+    ),
+    /* @__PURE__ */ jsx6(SelectContent, { ...contentPanelProps, children })
   ] });
 });
-var FormInput = forwardRef3(function FormInput2({
-  id,
-  labelText,
-  errorText,
-  className,
-  labelClassName,
-  errorClassName,
-  containerClassName,
-  required,
-  disabled,
-  ...restProps
+var SelectUncontrolled = forwardRef3(function SelectUncontrolled2({
+  value: initialValue,
+  onValueChanged,
+  ...props
 }, ref) {
-  const input = /* @__PURE__ */ jsx8(
-    "input",
+  const [value, setValue] = useState7(initialValue);
+  useEffect6(() => {
+    setValue(initialValue);
+  }, [initialValue]);
+  return /* @__PURE__ */ jsx6(
+    Select,
     {
-      ...restProps,
+      ...props,
       ref,
-      id,
-      disabled,
-      className: clsx7(
-        getInputClassName({ disabled, hasError: !!errorText }),
-        className
-      )
+      value,
+      onValueChanged: (value2) => {
+        setValue(value2);
+        onValueChanged?.(value2);
+      }
     }
   );
-  return /* @__PURE__ */ jsxs6("div", { className: clsx7("flex flex-col gap-y-1", containerClassName), children: [
-    labelText && /* @__PURE__ */ jsxs6("label", { htmlFor: id, className: clsx7("textstyle-label-md", labelClassName), children: [
-      labelText,
-      required && /* @__PURE__ */ jsx8("span", { className: "text-primary font-bold", children: "*" })
-    ] }),
-    input,
-    errorText && /* @__PURE__ */ jsx8("label", { htmlFor: id, className: clsx7("text-negative", errorClassName), children: errorText })
+});
+var MultiSelect = forwardRef3(function MultiSelect2({
+  children,
+  contentPanelProps,
+  buttonProps,
+  ...props
+}, ref) {
+  return /* @__PURE__ */ jsxs5(SelectRoot, { ...props, isMultiSelect: true, children: [
+    /* @__PURE__ */ jsx6(SelectButton, { ref, ...buttonProps }),
+    /* @__PURE__ */ jsx6(SelectContent, { ...contentPanelProps, children })
   ] });
 });
-
-// src/components/user-action/SearchBar.tsx
-import { Search } from "lucide-react";
-import { clsx as clsx8 } from "clsx";
-import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
-var SearchBar = ({
-  placeholder,
-  onSearch,
-  disableOnSearch,
-  containerClassName,
-  ...inputProps
-}) => {
-  const translation = useTranslation([formTranslation]);
-  return /* @__PURE__ */ jsxs7("div", { className: clsx8("flex-row-2 justify-between items-center", containerClassName), children: [
-    /* @__PURE__ */ jsx9(
-      Input,
-      {
-        ...inputProps,
-        placeholder: placeholder ?? translation("search")
+var MultiSelectUncontrolled = forwardRef3(function MultiSelectUncontrolled2({
+  values: initialValues,
+  onValuesChanged,
+  ...props
+}, ref) {
+  const [values, setValues] = useState7(initialValues);
+  useEffect6(() => {
+    setValues(initialValues);
+  }, [initialValues]);
+  return /* @__PURE__ */ jsx6(
+    MultiSelect,
+    {
+      ...props,
+      ref,
+      values,
+      onValuesChanged: (value) => {
+        setValues(value);
+        onValuesChanged?.(value);
       }
-    ),
-    onSearch && /* @__PURE__ */ jsx9(IconButton, { color: "neutral", disabled: disableOnSearch, onClick: onSearch, children: /* @__PURE__ */ jsx9(Search, { className: "w-full h-full" }) })
-  ] });
-};
-
-// src/hooks/useSearch.ts
-import { useCallback as useCallback4, useEffect as useEffect9, useMemo, useState as useState8 } from "react";
-
-// src/util/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())));
-  });
-};
-
-// src/hooks/useSearch.ts
-var useSearch = ({
-  list,
-  initialSearch,
-  searchMapping,
-  additionalSearchTags,
-  isSearchInstant = true,
-  sortingFunction,
-  filter,
-  disabled = false
-}) => {
-  const [search, setSearch] = useState8(initialSearch ?? "");
-  const [result, setResult] = useState8(list);
-  const searchTags = useMemo(() => additionalSearchTags ?? [], [additionalSearchTags]);
-  const updateSearch = useCallback4((newSearch) => {
-    const usedSearch = newSearch ?? search;
-    if (newSearch) {
-      setSearch(search);
-    }
-    setResult(MultiSubjectSearchWithMapping([usedSearch, ...searchTags], list, searchMapping));
-  }, [searchTags, list, search, searchMapping]);
-  useEffect9(() => {
-    if (isSearchInstant) {
-      setResult(MultiSubjectSearchWithMapping([search, ...searchTags], list, searchMapping));
-    }
-  }, [searchTags, isSearchInstant, list, search, searchMapping, additionalSearchTags]);
-  const filteredResult = useMemo(() => {
-    if (!filter) {
-      return result;
-    }
-    return result.filter(filter);
-  }, [result, filter]);
-  const sortedAndFilteredResult = useMemo(() => {
-    if (!sortingFunction) {
-      return filteredResult;
     }
-    return filteredResult.sort(sortingFunction);
-  }, [filteredResult, sortingFunction]);
-  const usedResult = useMemo(() => {
-    if (!disabled) {
-      return sortedAndFilteredResult;
-    }
-    return list;
-  }, [disabled, list, sortedAndFilteredResult]);
-  return {
-    result: usedResult,
-    hasResult: usedResult.length > 0,
-    allItems: list,
-    updateSearch,
-    search,
-    setSearch
-  };
-};
-
-// src/components/user-action/Select.tsx
-import { Fragment as Fragment2, jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
-var Select = ({
-  value,
-  label,
-  options,
-  onChange,
-  hintText = "",
-  selectedDisplayOverwrite,
-  searchOptions,
-  additionalItems,
-  className,
-  triggerClassName,
-  hintTextClassName,
-  ...menuProps
-}) => {
-  const selectedOption = options.find((option) => option.value === value);
-  if (value !== void 0 && selectedOption === void 0 && selectedDisplayOverwrite === void 0) {
-    console.warn("The selected value is not found in the options list. This might be an error on your part or default behavior if it is complex data type on which === does not work. In case of the latter use selectedDisplayOverwrite to set your selected text or component");
-  }
-  const isShowingHint = !selectedDisplayOverwrite && !selectedOption?.label;
-  const { result, search, setSearch } = useSearch({
-    list: options,
-    searchMapping: useCallback5((item) => item.searchTags, []),
-    ...searchOptions
-  });
-  return /* @__PURE__ */ jsxs8("div", { className: clsx9(className), children: [
-    label && /* @__PURE__ */ jsx10(Label, { ...label, labelType: label.labelType ?? "labelBig", className: clsx9("mb-1", label.className) }),
-    /* @__PURE__ */ jsx10(
-      Menu,
-      {
-        ...menuProps,
-        trigger: ({ toggleOpen, isOpen, disabled }, ref) => /* @__PURE__ */ jsxs8(
-          "button",
-          {
-            ref,
-            className: clsx9(
-              "btn-md justify-between w-full border-2",
-              {
-                "rounded-b-lg": !open,
-                "bg-input-background text-input-text hover:border-primary": !disabled,
-                "bg-disabled-background text-disabled-text border-disabled-background cursor-not-allowed": disabled
-              },
-              triggerClassName
-            ),
-            onClick: toggleOpen,
-            disabled,
-            children: [
-              !isShowingHint && /* @__PURE__ */ jsx10("span", { className: "font-semibold", children: selectedDisplayOverwrite ?? selectedOption?.label }),
-              isShowingHint && /* @__PURE__ */ jsx10("span", { className: clsx9("textstyle-description", hintTextClassName), children: hintText }),
-              /* @__PURE__ */ jsx10(ExpansionIcon, { isExpanded: isOpen })
-            ]
-          }
-        ),
-        menuClassName: clsx9("flex-col-2 p-2 max-h-96 overflow-hidden", menuProps.menuClassName),
-        children: (bag) => {
-          const { close } = bag;
-          return /* @__PURE__ */ jsxs8(Fragment2, { children: [
-            !searchOptions?.disabled && /* @__PURE__ */ jsx10(
-              SearchBar,
-              {
-                value: search,
-                onChangeText: setSearch,
-                autoFocus: true
-              }
-            ),
-            /* @__PURE__ */ jsxs8("div", { className: "flex-col-2 overflow-y-auto", children: [
-              result.map((option, index) => /* @__PURE__ */ jsx10(
-                ListTile,
-                {
-                  isSelected: option === selectedOption,
-                  title: option.label,
-                  onClick: () => {
-                    onChange(option.value);
-                    close();
-                  },
-                  disabled: option.disabled
-                },
-                index
-              )),
-              additionalItems && additionalItems({ ...bag, search, selected: value })
-            ] })
-          ] });
-        }
-      }
-    )
+  );
+});
+var MultiSelectChipDisplay = forwardRef3(function MultiSelectChipDisplay2({
+  children,
+  contentPanelProps,
+  chipDisplayProps,
+  ...props
+}, ref) {
+  return /* @__PURE__ */ jsxs5(SelectRoot, { ...props, isMultiSelect: true, children: [
+    /* @__PURE__ */ jsx6(SelectChipDisplay, { ref, ...chipDisplayProps }),
+    /* @__PURE__ */ jsx6(SelectContent, { ...contentPanelProps, children })
   ] });
-};
+});
+var MultiSelectChipDisplayUncontrolled = forwardRef3(function MultiSelectChipDisplayUncontrolled2({
+  values: initialValues,
+  onValuesChanged,
+  ...props
+}, ref) {
+  const [values, setValues] = useState7(initialValues);
+  useEffect6(() => {
+    setValues(initialValues);
+  }, [initialValues]);
+  return /* @__PURE__ */ jsx6(
+    MultiSelectChipDisplay,
+    {
+      ...props,
+      ref,
+      values,
+      onValuesChanged: (value) => {
+        setValues(value);
+        onValuesChanged?.(value);
+      }
+    }
+  );
+});
 
 // src/components/properties/SelectProperty.tsx
-import { jsx as jsx11 } from "react/jsx-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
 var SingleSelectProperty = ({
-  overwriteTranslation,
   value,
   options,
-  name,
-  readOnly = false,
-  softRequired,
-  onRemove,
-  onAddNew,
-  ...selectProps
+  onValueChanged,
+  ...props
 }) => {
-  const translation = useTranslation([formTranslation], overwriteTranslation);
   const hasValue = value !== void 0;
-  return /* @__PURE__ */ jsx11(
+  return /* @__PURE__ */ jsx7(
     PropertyBase,
     {
-      name,
-      onRemove,
-      readOnly,
-      softRequired,
+      ...props,
       hasValue,
-      icon: /* @__PURE__ */ jsx11(List, { size: 24 }),
-      input: ({ softRequired: softRequired2 }) => /* @__PURE__ */ jsx11(
+      icon: /* @__PURE__ */ jsx7(List, { size: 24 }),
+      input: ({ softRequired }) => /* @__PURE__ */ jsx7(
         Select,
         {
-          ...selectProps,
           value,
-          options,
-          disabled: readOnly,
-          className: clsx10("w-full"),
-          hintText: `${translation("select")}...`,
-          searchOptions: {
-            sortingFunction: (a, b) => a.value.localeCompare(b.value),
-            ...selectProps?.searchOptions
-          },
-          additionalItems: ({ close, search }) => {
-            if (!onAddNew && !search.trim()) {
-              return void 0;
-            }
-            return /* @__PURE__ */ jsx11(
-              ListTile,
+          onValueChanged,
+          disabled: props.readOnly,
+          buttonProps: {
+            className: clsx6(
+              "border-none w-full",
               {
-                prefix: /* @__PURE__ */ jsx11(Plus, {}),
-                title: `${translation("add")} ${search.trim()}`,
-                onClick: () => {
-                  onAddNew(search);
-                  close();
-                },
-                disabled: options.some((value2) => value2.value === search.trim())
+                "!bg-warning !text-surface-warning": softRequired && !hasValue
               }
-            );
+            )
           },
-          triggerClassName: clsx10(
-            "!border-none",
-            {
-              "!bg-warning !text-surface-warning": softRequired2 && !hasValue,
-              "!bg-property-title-background": !softRequired2 || hasValue
-            }
-          ),
-          hintTextClassName: softRequired2 && !hasValue ? "text-surface-warning" : void 0
+          children: options.map((value2) => /* @__PURE__ */ jsx7(SelectOption, { value: value2 }, value2))
         }
       )
     }