@helpwave/hightide 0.1.25 → 0.1.26

package/dist/components/properties/MultiSelectProperty.mjs

@@ -1,6 +1,20 @@
 // src/components/properties/MultiSelectProperty.tsx
-import { List, Plus as Plus2 } from "lucide-react";
-import clsx12 from "clsx";
+import { List } from "lucide-react";
+import clsx6 from "clsx";
+
+// 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 clsx4 from "clsx";
 
 // src/localization/LanguageProvider.tsx
 import { createContext, useContext, useEffect, useState as useState2 } from "react";
@@ -89,33 +103,403 @@ var useTranslation = (translations, overwriteTranslation = {}) => {
   };
 };
 
-// src/components/user-action/MultiSelect.tsx
-import { useCallback as useCallback5 } from "react";
-import { useEffect as useEffect10, useState as useState10 } from "react";
-import clsx10 from "clsx";
-
-// src/components/user-action/Label.tsx
+// src/components/layout-and-navigation/Expandable.tsx
+import { forwardRef, useCallback as useCallback2, useEffect as useEffect2, useId, useState as useState3 } from "react";
+import { ChevronDown } from "lucide-react";
 import clsx from "clsx";
-import { jsx as jsx2 } from "react/jsx-runtime";
-var styleMapping = {
-  labelSmall: "textstyle-label-sm",
-  labelMedium: "textstyle-label-md",
-  labelBig: "textstyle-label-lg"
+
+// src/utils/noop.ts
+var noop = () => void 0;
+
+// src/components/layout-and-navigation/Expandable.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var ExpansionIcon = ({ isExpanded, className }) => {
+  return /* @__PURE__ */ jsx2(
+    ChevronDown,
+    {
+      "aria-hidden": true,
+      className: clsx(
+        "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
+      )
+    }
+  );
 };
-var Label = ({
+var Expandable = forwardRef(function Expandable2({
   children,
-  name,
-  labelType = "labelSmall",
+  id: providedId,
+  label,
+  icon,
+  isExpanded = false,
+  onChange = noop,
+  clickOnlyOnHeader = true,
+  disabled = false,
   className,
+  headerClassName,
+  contentClassName,
+  contentExpandedClassName
+}, ref) {
+  const defaultIcon = useCallback2((expanded) => /* @__PURE__ */ jsx2(ExpansionIcon, { isExpanded: expanded }), []);
+  icon ??= defaultIcon;
+  const generatedId = useId();
+  const id = providedId ?? generatedId;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref,
+      onClick: () => !clickOnlyOnHeader && !disabled && onChange(!isExpanded),
+      className: clsx(
+        "flex-col-0 bg-surface text-on-surface group rounded-lg shadow-sm",
+        { "cursor-pointer": !clickOnlyOnHeader && !disabled },
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            onClick: () => clickOnlyOnHeader && !disabled && onChange(!isExpanded),
+            className: clsx(
+              "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,
+                "hover:brightness-97": isExpanded && !disabled,
+                "cursor-pointer": clickOnlyOnHeader && !disabled
+              },
+              headerClassName
+            ),
+            "aria-expanded": isExpanded,
+            "aria-controls": `${id}-content`,
+            "aria-disabled": disabled ?? void 0,
+            children: [
+              label,
+              icon(isExpanded)
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "div",
+          {
+            id: `${id}-content`,
+            className: clsx(
+              "flex-col-2 px-4 transition-all duration-300 ease-in-out",
+              {
+                [clsx("max-h-96 opacity-100 pb-2 overflow-y-auto", contentExpandedClassName)]: isExpanded,
+                "max-h-0 opacity-0 overflow-hidden": !isExpanded
+              },
+              contentClassName
+            ),
+            role: "region",
+            children
+          }
+        )
+      ]
+    }
+  );
+});
+var ExpandableUncontrolled = forwardRef(function ExpandableUncontrolled2({
+  isExpanded,
+  onChange = noop,
   ...props
+}, ref) {
+  const [usedIsExpanded, setUsedIsExpanded] = useState3(isExpanded);
+  useEffect2(() => {
+    setUsedIsExpanded(isExpanded);
+  }, [isExpanded]);
+  return /* @__PURE__ */ jsx2(
+    Expandable,
+    {
+      ...props,
+      ref,
+      isExpanded: usedIsExpanded,
+      onChange: (value) => {
+        onChange(value);
+        setUsedIsExpanded(value);
+      }
+    }
+  );
+});
+
+// src/hooks/focus/useFocusTrap.ts
+import { useCallback as useCallback3, useEffect as useEffect4, useId as useId2, useRef, useState as useState5 } from "react";
+
+// 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 () => {
+      setIsMounted(false);
+    };
+  }, []);
+  return isMounted;
+};
+
+// 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;
+};
+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();
+      }
+    }
+  }
+  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();
+    }
+    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 () => {
+        service.unregister(id);
+        lastFocusRef.current = void 0;
+      };
+    }
+  }, [active, container, focusElement, id, initialFocus, isMounted]);
+  useEffect4(() => {
+    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);
+      };
+    }
+  }, [active, paused, isMounted, container, initialFocus, focusFirst, focusElement]);
+};
+
+// src/utils/match.ts
+var match = (key, values) => {
+  return values[key];
+};
+
+// src/components/user-action/select/Select.tsx
+import { CheckIcon, Plus, XIcon } from "lucide-react";
+
+// src/components/layout-and-navigation/Chip.tsx
+import clsx2 from "clsx";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var Chip = ({
+  children,
+  trailingIcon,
+  color = "default",
+  size = "md",
+  icon = false,
+  variant = "normal",
+  className = "",
+  ...restProps
 }) => {
-  return /* @__PURE__ */ jsx2("label", { ...props, className: clsx(styleMapping[labelType], className), children: children ? children : name });
+  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__ */ jsxs2(
+    "div",
+    {
+      ...restProps,
+      className: clsx2(
+        `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__ */ jsx3("span", { className: colorMappingIcon, children: trailingIcon })
+      ]
+    }
+  );
 };
 
 // src/components/user-action/Button.tsx
-import { forwardRef } from "react";
-import clsx2 from "clsx";
-import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+import { forwardRef as forwardRef2 } from "react";
+import clsx3 from "clsx";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 var ButtonColorUtil = {
   solid: ["primary", "secondary", "tertiary", "positive", "warning", "negative", "neutral"],
   text: ["primary", "negative", "neutral"],
@@ -139,7 +523,7 @@ var ButtonUtil = {
   paddingMapping,
   iconPaddingMapping
 };
-var SolidButton = forwardRef(function SolidButton2({
+var SolidButton = forwardRef2(function SolidButton2({
   children,
   color = "primary",
   size = "medium",
@@ -167,12 +551,12 @@ var SolidButton = forwardRef(function SolidButton2({
     negative: "not-group-disabled:text-button-solid-negative-icon",
     neutral: "not-group-disabled:text-button-solid-neutral-icon"
   }[color];
-  return /* @__PURE__ */ jsxs(
+  return /* @__PURE__ */ jsxs3(
     "button",
     {
       ref,
       onClick,
-      className: clsx2(
+      className: clsx3(
         "group font-semibold",
         colorClasses,
         "not-disabled:hover:brightness-90",
@@ -182,10 +566,10 @@ var SolidButton = forwardRef(function SolidButton2({
       ),
       ...restProps,
       children: [
-        startIcon && /* @__PURE__ */ jsx3(
+        startIcon && /* @__PURE__ */ jsx4(
           "span",
           {
-            className: clsx2(
+            className: clsx3(
               iconColorClasses,
               "group-disabled:text-disabled-icon"
             ),
@@ -193,10 +577,10 @@ var SolidButton = forwardRef(function SolidButton2({
           }
         ),
         children,
-        endIcon && /* @__PURE__ */ jsx3(
+        endIcon && /* @__PURE__ */ jsx4(
           "span",
           {
-            className: clsx2(
+            className: clsx3(
               iconColorClasses,
               "group-disabled:text-disabled-icon"
             ),
@@ -219,25 +603,25 @@ var TextButton = ({
   ...restProps
 }) => {
   const colorClasses = {
-    primary: "not-disabled:bg-transparent not-disabled:text-button-text-primary-text",
-    negative: "not-disabled:bg-transparent not-disabled:text-button-text-negative-text",
-    neutral: "not-disabled:bg-transparent not-disabled: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: "not-disabled:hover:bg-button-text-primary-text/20",
-    negative: "not-disabled:hover:bg-button-text-negative-text/20",
-    neutral: "not-disabled: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: "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(
+  return /* @__PURE__ */ jsxs3(
     "button",
     {
       onClick,
-      className: clsx2(
+      className: clsx3(
         "group font-semibold",
         "disabled:text-disabled-text",
         colorClasses,
@@ -250,10 +634,10 @@ var TextButton = ({
       ),
       ...restProps,
       children: [
-        startIcon && /* @__PURE__ */ jsx3(
+        startIcon && /* @__PURE__ */ jsx4(
           "span",
           {
-            className: clsx2(
+            className: clsx3(
               iconColorClasses,
               "group-disabled:text-disabled-icon"
             ),
@@ -261,10 +645,10 @@ var TextButton = ({
           }
         ),
         children,
-        endIcon && /* @__PURE__ */ jsx3(
+        endIcon && /* @__PURE__ */ jsx4(
           "span",
           {
-            className: clsx2(
+            className: clsx3(
               iconColorClasses,
               "group-disabled:text-disabled-icon"
             ),
@@ -275,13 +659,13 @@ var TextButton = ({
     }
   );
 };
-var IconButton = ({
+var IconButton = forwardRef2(function IconButton2({
   children,
   color = "primary",
   size = "medium",
   className,
   ...restProps
-}) => {
+}, ref) {
   const colorClasses = {
     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",
@@ -292,10 +676,11 @@ var IconButton = ({
     neutral: "not-disabled:bg-button-solid-neutral-background not-disabled:text-button-solid-neutral-text",
     transparent: "not-disabled:bg-transparent"
   }[color];
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx4(
     "button",
     {
-      className: clsx2(
+      ref,
+      className: clsx3(
         colorClasses,
         "not-disabled:hover:brightness-90",
         "disabled:text-disabled-text",
@@ -311,72 +696,690 @@ var IconButton = ({
       children
     }
   );
+});
+
+// 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);
 };
 
-// src/components/layout-and-navigation/Chip.tsx
-import clsx3 from "clsx";
-import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
-var Chip = ({
+// 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 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,
+    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/select/Select.tsx
+import { createPortal } from "react-dom";
+import { Fragment, jsx as jsx5, jsxs as jsxs4 } 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 ctx;
+}
+var SelectRoot = ({
   children,
-  trailingIcon,
-  color = "default",
-  variant = "normal",
-  className = "",
-  ...restProps
+  id,
+  value,
+  onValueChanged,
+  values,
+  onValuesChanged,
+  isOpen = false,
+  disabled = false,
+  invalid = false,
+  isMultiSelect = false
 }) => {
-  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"
-  }[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"
-  }[color];
-  return /* @__PURE__ */ jsxs2(
-    "div",
-    {
-      ...restProps,
-      className: clsx3(
-        `row w-fit px-2 py-1 font-semibold`,
-        colorMapping,
-        {
-          "rounded-md": variant === "normal",
-          "rounded-full": variant === "fullyRounded"
+  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 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;
+    });
+  }, []);
+  const unregisterItem = useCallback5((value2) => {
+    optionsRef.current = optionsRef.current.filter((i) => i.value !== value2);
+  }, []);
+  const toggleSelection = (value2, isSelected) => {
+    if (disabled) {
+      return;
+    }
+    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];
+      }
+    } else {
+      newValue = [value2];
+    }
+    if (!isMultiSelect) {
+      onValueChanged?.(newValue[0]);
+    } else {
+      onValuesChanged?.(newValue);
+    }
+    setInternalState((prevState) => ({
+      ...prevState,
+      highlightedValue: value2
+    }));
+  };
+  const highlightItem = (value2) => {
+    if (disabled) {
+      return;
+    }
+    setInternalState((prevState) => ({
+      ...prevState,
+      highlightedValue: value2
+    }));
+  };
+  const registerTrigger = useCallback5((ref) => {
+    triggerRef.current = ref.current;
+  }, []);
+  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);
+    }
+    if (highlightedIndex === -1 || highlightedIndex === optionsRef.current.length) {
+      highlightedIndex = 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;
+    }
+    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;
+      }
+    }
+    setInternalState((prevState) => ({
+      ...prevState,
+      highlightedValue
+    }));
+  };
+  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})`);
+    }
+  }, [internalState.highlightedValue]);
+  const contextValue = {
+    state,
+    item: {
+      register: registerItem,
+      unregister: unregisterItem,
+      toggleSelection,
+      highlightItem,
+      moveHighlightedIndex
+    },
+    trigger: {
+      ref: triggerRef,
+      register: registerTrigger,
+      unregister: unregisterTrigger,
+      toggleOpen
+    }
+  };
+  return /* @__PURE__ */ jsx5(SelectContext.Provider, { value: contextValue, children });
+};
+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__ */ jsxs4(
+      "li",
+      {
+        ...restProps,
+        ref: (node) => {
+          itemRef.current = node;
+          if (typeof ref === "function") ref(node);
+          else if (ref) ref.current = node;
         },
-        className
+        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: clsx4(
+          "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__ */ jsx5(
+            CheckIcon,
+            {
+              className: clsx4("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__ */ jsxs4(
+    "button",
+    {
+      ...props,
+      ref: innerRef,
+      id: state.id,
+      className: clsx4(
+        "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: [
-        children,
-        trailingIcon && /* @__PURE__ */ jsx4("span", { className: colorMappingIcon, children: trailingIcon })
+        hasValue ? selectedDisplay?.(state.value) ?? state.value.join(", ") : placeholder ?? translation("clickToSelect"),
+        /* @__PURE__ */ jsx5(ExpansionIcon, { isExpanded: state.isOpen })
       ]
     }
   );
-};
-var ChipList = ({
-  list,
-  className = ""
-}) => {
-  return /* @__PURE__ */ jsx4("div", { className: clsx3("flex flex-wrap gap-x-2 gap-y-2", className), children: list.map((value, index) => /* @__PURE__ */ jsx4(
-    Chip,
+});
+var SelectChipDisplay = forwardRef3(function SelectChipDisplay2({ ...props }, ref) {
+  const { state, trigger, item } = 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;
+  return /* @__PURE__ */ jsxs4(
+    "div",
     {
-      ...value,
-      color: value.color ?? "default",
-      variant: value.variant ?? "normal",
-      children: value.children
-    },
-    index
-  )) });
-};
+      ...props,
+      ref: innerRef,
+      className: clsx4(
+        "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__ */ jsxs4(Chip, { className: "gap-x-2", children: [
+          value,
+          /* @__PURE__ */ jsx5(
+            "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__ */ jsx5(XIcon, {})
+            }
+          )
+        ] }, value)),
+        /* @__PURE__ */ jsx5(
+          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__ */ jsx5(Plus, {})
+          }
+        )
+      ]
+    }
+  );
+});
+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__ */ jsxs4(Fragment, { children: [
+        /* @__PURE__ */ jsx5(
+          "div",
+          {
+            hidden: !state.isOpen,
+            onClick: () => trigger.toggleOpen(false),
+            className: clsx4("fixed w-screen h-screen inset-0")
+          }
+        ),
+        /* @__PURE__ */ jsx5(
+          "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: clsx4("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
+          }
+        )
+      ] }),
+      document.body
+    );
+  }
+);
+var Select = forwardRef3(function Select2({
+  children,
+  contentPanelProps,
+  buttonProps,
+  ...props
+}, ref) {
+  return /* @__PURE__ */ jsxs4(SelectRoot, { ...props, isMultiSelect: false, children: [
+    /* @__PURE__ */ jsx5(
+      SelectButton,
+      {
+        ref,
+        ...buttonProps,
+        selectedDisplay: (values) => {
+          const value = values[0];
+          if (!buttonProps?.selectedDisplay) return void 0;
+          return buttonProps.selectedDisplay(value);
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx5(SelectContent, { ...contentPanelProps, children })
+  ] });
+});
+var SelectUncontrolled = forwardRef3(function SelectUncontrolled2({
+  value: initialValue,
+  onValueChanged,
+  ...props
+}, ref) {
+  const [value, setValue] = useState7(initialValue);
+  useEffect6(() => {
+    setValue(initialValue);
+  }, [initialValue]);
+  return /* @__PURE__ */ jsx5(
+    Select,
+    {
+      ...props,
+      ref,
+      value,
+      onValueChanged: (value2) => {
+        setValue(value2);
+        onValueChanged?.(value2);
+      }
+    }
+  );
+});
+var MultiSelect = forwardRef3(function MultiSelect2({
+  children,
+  contentPanelProps,
+  buttonProps,
+  ...props
+}, ref) {
+  return /* @__PURE__ */ jsxs4(SelectRoot, { ...props, isMultiSelect: true, children: [
+    /* @__PURE__ */ jsx5(SelectButton, { ref, ...buttonProps }),
+    /* @__PURE__ */ jsx5(SelectContent, { ...contentPanelProps, children })
+  ] });
+});
+var MultiSelectUncontrolled = forwardRef3(function MultiSelectUncontrolled2({
+  values: initialValues,
+  onValuesChanged,
+  ...props
+}, ref) {
+  const [values, setValues] = useState7(initialValues);
+  useEffect6(() => {
+    setValues(initialValues);
+  }, [initialValues]);
+  return /* @__PURE__ */ jsx5(
+    MultiSelect,
+    {
+      ...props,
+      ref,
+      values,
+      onValuesChanged: (value) => {
+        setValues(value);
+        onValuesChanged?.(value);
+      }
+    }
+  );
+});
+var MultiSelectChipDisplay = forwardRef3(function MultiSelectChipDisplay2({
+  children,
+  contentPanelProps,
+  chipDisplayProps,
+  ...props
+}, ref) {
+  return /* @__PURE__ */ jsxs4(SelectRoot, { ...props, isMultiSelect: true, children: [
+    /* @__PURE__ */ jsx5(SelectChipDisplay, { ref, ...chipDisplayProps }),
+    /* @__PURE__ */ jsx5(SelectContent, { ...contentPanelProps, children })
+  ] });
+});
+var MultiSelectChipDisplayUncontrolled = forwardRef3(function MultiSelectChipDisplayUncontrolled2({
+  values: initialValues,
+  onValuesChanged,
+  ...props
+}, ref) {
+  const [values, setValues] = useState7(initialValues);
+  useEffect6(() => {
+    setValues(initialValues);
+  }, [initialValues]);
+  return /* @__PURE__ */ jsx5(
+    MultiSelectChipDisplay,
+    {
+      ...props,
+      ref,
+      values,
+      onValuesChanged: (value) => {
+        setValues(value);
+        onValuesChanged?.(value);
+      }
+    }
+  );
+});
+
+// src/components/properties/PropertyBase.tsx
+import { AlertTriangle } from "lucide-react";
+import clsx5 from "clsx";
 
 // src/localization/defaults/form.ts
 var formTranslation = {
@@ -414,6 +1417,7 @@ var formTranslation = {
     next: "Next",
     no: "No",
     none: "None",
+    nothingFound: "Nothing found",
     of: "of",
     optional: "Optional",
     pleaseWait: "Please wait...",
@@ -470,6 +1474,7 @@ var formTranslation = {
     next: "Weiter",
     no: "Nein",
     none: "Nichts",
+    nothingFound: "Nichts gefunden",
     of: "von",
     optional: "Optional",
     pleaseWait: "Bitte warten...",
@@ -494,1027 +1499,43 @@ var formTranslation = {
   }
 };
 
-// src/components/user-action/Menu.tsx
-import { useEffect as useEffect4, useRef, useState as useState4 } from "react";
-import clsx4 from "clsx";
-
-// src/hooks/useOutsideClick.ts
-import { useEffect as useEffect2 } from "react";
-var useOutsideClick = (refs, handler) => {
-  useEffect2(() => {
-    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);
-    return () => {
-      document.removeEventListener("mousedown", listener);
-      document.removeEventListener("touchstart", listener);
-    };
-  }, [refs, handler]);
-};
-
-// src/hooks/useHoverState.ts
-import { useEffect as useEffect3, useState as useState3 } from "react";
-var defaultUseHoverStateProps = {
-  closingDelay: 200,
-  isDisabled: false
-};
-var useHoverState = (props = void 0) => {
-  const { closingDelay, isDisabled } = { ...defaultUseHoverStateProps, ...props };
-  const [isHovered, setIsHovered] = useState3(false);
-  const [timer, setTimer] = useState3();
-  const onMouseEnter = () => {
-    if (isDisabled) {
-      return;
-    }
-    clearTimeout(timer);
-    setIsHovered(true);
-  };
-  const onMouseLeave = () => {
-    if (isDisabled) {
-      return;
-    }
-    setTimer(setTimeout(() => {
-      setIsHovered(false);
-    }, closingDelay));
-  };
-  useEffect3(() => {
-    if (timer) {
-      return () => {
-        clearTimeout(timer);
-      };
-    }
-  });
-  useEffect3(() => {
-    if (timer) {
-      clearTimeout(timer);
-    }
-  }, [isDisabled]);
-  return {
-    isHovered,
-    setIsHovered,
-    handlers: { onMouseEnter, onMouseLeave }
-  };
-};
-
-// src/util/PropsWithFunctionChildren.ts
-var resolve = (children, bag) => {
-  if (typeof children === "function") {
-    return children(bag);
-  }
-  return children ?? void 0;
-};
-var BagFunctionUtil = {
-  resolve
-};
-
-// src/hooks/usePopoverPosition.ts
-var defaultPopoverPositionOptions = {
-  edgePadding: 16,
-  outerGap: 4,
-  horizontalAlignment: "leftInside",
-  verticalAlignment: "bottomOutside",
-  disabled: false
-};
-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%"
-  }[horizontalAlignment];
-  const translateY = {
-    topOutside: "-100%",
-    topInside: void 0,
-    bottomOutside: void 0,
-    bottomInside: "-100%",
-    center: "-50%"
-  }[verticalAlignment];
-  return {
-    left: Math.max(left, edgePadding),
-    top: Math.max(top, edgePadding),
-    translate: [translateX ?? "0", translateY ?? "0"].join(" ")
-  };
-};
-
-// src/components/user-action/Menu.tsx
-import { createPortal } from "react-dom";
-import { Fragment, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
-function getScrollableParents(element) {
-  const scrollables = [];
-  let parent = element.parentElement;
-  while (parent) {
-    scrollables.push(parent);
-    parent = parent.parentElement;
-  }
-  return scrollables;
-}
-var Menu = ({
-  trigger,
-  children,
-  alignmentHorizontal = "leftInside",
-  alignmentVertical = "bottomOutside",
-  showOnHover = false,
-  disabled = false,
-  menuClassName = ""
+// src/components/properties/PropertyBase.tsx
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var PropertyBase = ({
+  overwriteTranslation,
+  name,
+  input,
+  softRequired = false,
+  hasValue,
+  icon,
+  readOnly,
+  onRemove,
+  className = ""
 }) => {
-  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] = useState4(true);
-  const bag = {
-    isOpen,
-    close: () => setIsOpen(false),
-    toggleOpen: () => setIsOpen((prevState) => !prevState),
-    disabled
-  };
-  const menuPosition = usePopoverPosition(
-    triggerRef.current?.getBoundingClientRect(),
-    { verticalAlignment: alignmentVertical, horizontalAlignment: alignmentHorizontal, disabled }
-  );
-  useEffect4(() => {
-    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);
-    });
-    window.addEventListener("resize", close);
-    return () => {
-      scrollableParents.forEach((parent) => {
-        parent.removeEventListener("scroll", close);
-      });
-      window.removeEventListener("resize", close);
-    };
-  }, [isOpen, setIsOpen]);
-  useEffect4(() => {
-    if (isOpen) {
-      setIsHidden(false);
-    }
-  }, [isOpen]);
-  return /* @__PURE__ */ jsxs3(Fragment, { children: [
-    trigger(bag, triggerRef),
-    createPortal(/* @__PURE__ */ jsx5(
+  const translation = useTranslation([formTranslation], overwriteTranslation);
+  const requiredAndNoValue = softRequired && !hasValue;
+  return /* @__PURE__ */ jsxs5("div", { className: clsx5("flex-row-0 group", className), children: [
+    /* @__PURE__ */ jsxs5(
       "div",
       {
-        ref: menuRef,
-        onClick: (e) => e.stopPropagation(),
-        className: clsx4(
-          "absolute rounded-md bg-menu-background text-menu-text shadow-around-lg shadow-strong z-[300]",
+        className: clsx5(
+          "flex-row-2 max-w-48 min-w-48 px-3 py-2 items-center rounded-l-xl border-2 border-r-0",
           {
-            "animate-pop-in": isOpen,
-            "animate-pop-out": !isOpen,
-            "hidden": isHidden
+            "bg-property-title-background text-property-title-text group-hover:border-primary": !requiredAndNoValue,
+            "bg-warning text-surface-warning group-hover:border-warning border-warning/90": requiredAndNoValue
           },
-          menuClassName
+          className
         ),
-        onAnimationEnd: () => {
-          if (!isOpen) {
-            setIsHidden(true);
-          }
-        },
-        style: {
-          ...menuPosition
-        },
-        children: BagFunctionUtil.resolve(children, bag)
-      }
-    ), document.body)
-  ] });
-};
-
-// src/components/layout-and-navigation/Expandable.tsx
-import { forwardRef as forwardRef2, useCallback as useCallback2, useEffect as useEffect5, useState as useState5 } from "react";
-import { ChevronDown } from "lucide-react";
-import clsx5 from "clsx";
-
-// src/util/noop.ts
-var noop = () => void 0;
-
-// src/components/layout-and-navigation/Expandable.tsx
-import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
-var ExpansionIcon = ({ isExpanded, className }) => {
-  return /* @__PURE__ */ jsx6(
-    ChevronDown,
-    {
-      className: clsx5(
-        "min-w-6 w-6 min-h-6 h-6 transition-transform duration-200 ease-in-out",
-        { "rotate-180": isExpanded },
-        className
-      )
-    }
-  );
-};
-var Expandable = forwardRef2(function Expandable2({
-  children,
-  label,
-  icon,
-  isExpanded = false,
-  onChange = noop,
-  clickOnlyOnHeader = true,
-  disabled = false,
-  className,
-  headerClassName,
-  contentClassName,
-  contentExpandedClassName
-}, ref) {
-  const defaultIcon = useCallback2((expanded) => /* @__PURE__ */ jsx6(ExpansionIcon, { isExpanded: expanded }), []);
-  icon ??= defaultIcon;
-  return /* @__PURE__ */ jsxs4(
-    "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),
-      children: [
-        /* @__PURE__ */ jsxs4(
-          "div",
-          {
-            className: clsx5(
-              "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,
-                "hover:brightness-97": isExpanded && !disabled,
-                "cursor-pointer": clickOnlyOnHeader && !disabled
-              },
-              headerClassName
-            ),
-            onClick: () => clickOnlyOnHeader && !disabled && onChange(!isExpanded),
-            children: [
-              label,
-              icon(isExpanded)
-            ]
-          }
-        ),
-        /* @__PURE__ */ jsx6(
-          "div",
-          {
-            className: clsx5(
-              "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,
-                "max-h-0 opacity-0 overflow-hidden": !isExpanded
-              },
-              contentClassName
-            ),
-            children
-          }
-        )
-      ]
-    }
-  );
-});
-var ExpandableUncontrolled = forwardRef2(function ExpandableUncontrolled2({
-  isExpanded,
-  onChange = noop,
-  ...props
-}, ref) {
-  const [usedIsExpanded, setUsedIsExpanded] = useState5(isExpanded);
-  useEffect5(() => {
-    setUsedIsExpanded(isExpanded);
-  }, [isExpanded]);
-  return /* @__PURE__ */ jsx6(
-    Expandable,
-    {
-      ...props,
-      ref,
-      isExpanded: usedIsExpanded,
-      onChange: (value) => {
-        onChange(value);
-        setUsedIsExpanded(value);
-      }
-    }
-  );
-});
-
-// src/components/user-action/Input.tsx
-import { forwardRef as forwardRef3, useEffect as useEffect8, useImperativeHandle, useRef as useRef2, useState as useState7 } from "react";
-import clsx6 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);
-  };
-  const restartTimer = (onDelayFinish) => {
-    if (disabled) {
-      return;
-    }
-    clearTimeout(timer);
-    setTimer(setTimeout(() => {
-      onDelayFinish();
-      setTimer(void 0);
-    }, delay));
-  };
-  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 getNextFocusElement = useCallback3(() => {
-    const elements = getFocusableElements();
-    if (elements.length === 0) {
-      return void 0;
-    }
-    let nextElement = elements[0];
-    if (document.activeElement instanceof HTMLElement) {
-      const currentIndex = elements.indexOf(document.activeElement);
-      nextElement = elements[(currentIndex + 1) % elements.length];
-    }
-    return nextElement;
-  }, [getFocusableElements]);
-  const focusNext = useCallback3(() => {
-    const nextElement = getNextFocusElement();
-    nextElement?.focus();
-  }, [getNextFocusElement]);
-  const getPreviousFocusElement = useCallback3(() => {
-    const elements = getFocusableElements();
-    if (elements.length === 0) {
-      return void 0;
-    }
-    let previousElement = elements[0];
-    if (document.activeElement instanceof HTMLElement) {
-      const currentIndex = elements.indexOf(document.activeElement);
-      if (currentIndex === 0) {
-        previousElement = elements[elements.length - 1];
-      } else {
-        previousElement = elements[currentIndex - 1];
-      }
-    }
-    return previousElement;
-  }, [getFocusableElements]);
-  const focusPrevious = useCallback3(() => {
-    const previousElement = getPreviousFocusElement();
-    if (previousElement) previousElement.focus();
-  }, [getPreviousFocusElement]);
-  return {
-    getFocusableElements,
-    getNextFocusElement,
-    getPreviousFocusElement,
-    focusNext,
-    focusPrevious
-  };
-}
-
-// 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;
-    }
-    const observer = new IntersectionObserver(([entry]) => {
-      if (entry.isIntersecting && !hasUsedFocus) {
-        ref.current?.focus();
-        setHasUsedFocus(hasUsedFocus);
-      }
-    }, {
-      threshold: 0.1
-    });
-    if (ref.current) {
-      observer.observe(ref.current);
-    }
-    return () => observer.disconnect();
-  }, [disable, hasUsedFocus, ref]);
-};
-
-// src/components/user-action/Input.tsx
-import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
-var getInputClassName = ({ disabled = false, hasError = false }) => {
-  return clsx6(
-    "px-2 py-1.5 rounded-md border-2",
-    {
-      "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
-    }
-  );
-};
-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 });
-  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();
-    }
-  };
-  return /* @__PURE__ */ jsxs5("div", { className: clsx6({ "w-full": expanded }, containerClassName), children: [
-    label && /* @__PURE__ */ jsx7(Label, { ...label, htmlFor: id, className: clsx6("mb-1", label.className) }),
-    /* @__PURE__ */ jsx7(
-      "input",
-      {
-        ...restProps,
-        ref: innerRef,
-        value,
-        id,
-        type,
-        disabled,
-        className: clsx6(getInputClassName({ disabled }), className),
-        onKeyDown: allowEnterComplete ? handleKeyDown : void 0,
-        onBlur: (event) => {
-          onBlur?.(event);
-          if (onEditCompleted && allowEditCompleteOnBlur) {
-            onEditCompleted(event.target.value);
-            clearTimer();
-          }
-        },
-        onChange: (e) => {
-          const value2 = e.target.value;
-          if (onEditCompleted) {
-            restartTimer(() => {
-              if (innerRef.current) {
-                innerRef.current.blur();
-                if (!allowEditCompleteOnBlur) {
-                  onEditCompleted(value2);
-                }
-              } else {
-                onEditCompleted(value2);
-              }
-            });
-          }
-          onChange(e);
-          onChangeText(value2);
-        }
-      }
-    )
-  ] });
-});
-var FormInput = forwardRef3(function FormInput2({
-  id,
-  labelText,
-  errorText,
-  className,
-  labelClassName,
-  errorClassName,
-  containerClassName,
-  required,
-  disabled,
-  ...restProps
-}, ref) {
-  const input = /* @__PURE__ */ jsx7(
-    "input",
-    {
-      ...restProps,
-      ref,
-      id,
-      disabled,
-      className: clsx6(
-        getInputClassName({ disabled, hasError: !!errorText }),
-        className
-      )
-    }
-  );
-  return /* @__PURE__ */ jsxs5("div", { className: clsx6("flex flex-col gap-y-1", containerClassName), children: [
-    labelText && /* @__PURE__ */ jsxs5("label", { htmlFor: id, className: clsx6("textstyle-label-md", labelClassName), children: [
-      labelText,
-      required && /* @__PURE__ */ jsx7("span", { className: "text-primary font-bold", children: "*" })
-    ] }),
-    input,
-    errorText && /* @__PURE__ */ jsx7("label", { htmlFor: id, className: clsx6("text-negative", errorClassName), children: errorText })
-  ] });
-});
-
-// src/components/user-action/SearchBar.tsx
-import { Search } from "lucide-react";
-import { clsx as clsx7 } from "clsx";
-import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
-var SearchBar = ({
-  placeholder,
-  onSearch,
-  disableOnSearch,
-  containerClassName,
-  ...inputProps
-}) => {
-  const translation = useTranslation([formTranslation]);
-  return /* @__PURE__ */ jsxs6("div", { className: clsx7("flex-row-2 justify-between items-center", containerClassName), children: [
-    /* @__PURE__ */ jsx8(
-      Input,
-      {
-        ...inputProps,
-        placeholder: placeholder ?? translation("search")
-      }
-    ),
-    onSearch && /* @__PURE__ */ jsx8(IconButton, { color: "neutral", disabled: disableOnSearch, onClick: onSearch, children: /* @__PURE__ */ jsx8(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/Checkbox.tsx
-import { useState as useState9 } from "react";
-import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
-import { Check, Minus } from "lucide-react";
-import clsx8 from "clsx";
-import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
-var checkboxSizeMapping = {
-  small: "size-5",
-  medium: "size-6",
-  large: "size-8"
-};
-var checkboxIconSizeMapping = {
-  small: "size-4",
-  medium: "size-5",
-  large: "size-7"
-};
-var Checkbox = ({
-  id,
-  label,
-  checked,
-  disabled,
-  onChange,
-  onChangeTristate,
-  size = "medium",
-  className = "",
-  containerClassName
-}) => {
-  const usedSizeClass = checkboxSizeMapping[size];
-  const innerIconSize = checkboxIconSizeMapping[size];
-  const propagateChange = (checked2) => {
-    if (onChangeTristate) {
-      onChangeTristate(checked2);
-    }
-    if (onChange) {
-      onChange(checked2 === "indeterminate" ? false : checked2);
-    }
-  };
-  const changeValue = () => {
-    if (disabled) {
-      return;
-    }
-    const newValue = checked === "indeterminate" ? false : !checked;
-    propagateChange(newValue);
-  };
-  return /* @__PURE__ */ jsxs7(
-    "div",
-    {
-      className: clsx8("group flex-row-2 items-center", {
-        "cursor-pointer": !disabled,
-        "cursor-not-allowed": disabled
-      }, containerClassName),
-      onClick: changeValue,
-      children: [
-        /* @__PURE__ */ jsx9(
-          CheckboxPrimitive.Root,
-          {
-            onCheckedChange: propagateChange,
-            checked,
-            disabled,
-            id,
-            className: clsx8(usedSizeClass, `items-center border-2 rounded outline-none `, {
-              "text-disabled-text border-disabled-outline bg-disabled-background cursor-not-allowed": disabled,
-              "focus:border-primary group-hover:border-primary ": !disabled,
-              "bg-input-background": !disabled && !checked,
-              "bg-primary/30 border-primary text-primary": !disabled && checked === true || checked === "indeterminate"
-            }, className),
-            children: /* @__PURE__ */ jsxs7(CheckboxPrimitive.Indicator, { children: [
-              checked === true && /* @__PURE__ */ jsx9(Check, { className: innerIconSize }),
-              checked === "indeterminate" && /* @__PURE__ */ jsx9(Minus, { className: innerIconSize })
-            ] })
-          }
-        ),
-        label && /* @__PURE__ */ jsx9(
-          Label,
-          {
-            ...label,
-            className: clsx8(
-              label.className,
-              {
-                "cursor-pointer": !disabled,
-                "cursor-not-allowed": disabled
-              }
-            ),
-            htmlFor: id
-          }
-        )
-      ]
-    }
-  );
-};
-
-// src/components/user-action/MultiSelect.tsx
-import { Plus } from "lucide-react";
-
-// src/components/layout-and-navigation/Tile.tsx
-import clsx9 from "clsx";
-import { Check as Check2 } from "lucide-react";
-import { jsx as jsx10, jsxs as jsxs8 } 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__ */ jsxs8(
-    "div",
-    {
-      className: clsx9(
-        "flex-row-2 w-full items-center",
-        {
-          [normalClassName]: onClick && !disabled,
-          [selectedClassName]: isSelected && !disabled,
-          [disabledClassName]: disabled
-        },
-        className
-      ),
-      onClick: disabled ? void 0 : onClick,
-      children: [
-        prefix,
-        /* @__PURE__ */ jsxs8("div", { className: "flex-col-0 w-full", children: [
-          /* @__PURE__ */ jsx10("span", { className: clsx9(titleClassName ?? "textstyle-title-normal"), children: title }),
-          !!description && /* @__PURE__ */ jsx10("span", { className: clsx9(descriptionClassName ?? "textstyle-description"), children: description })
-        ] }),
-        suffix ?? (isSelected ? /* @__PURE__ */ jsx10(Check2, { size: 24 }) : void 0)
-      ]
-    }
-  );
-};
-var ListTile = ({
-  ...props
-}) => {
-  return /* @__PURE__ */ jsx10(
-    Tile,
-    {
-      ...props,
-      titleClassName: props.titleClassName ?? "font-semibold",
-      className: clsx9("px-2 py-1 rounded-md", props.className),
-      disabledClassName: props.disabledClassName ?? "text-disabled-text cursor-not-allowed"
-    }
-  );
-};
-
-// src/components/user-action/MultiSelect.tsx
-import { Fragment as Fragment2, jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
-var defaultMultiSelectTranslation = {
-  en: {
-    selected: `{{amount}} selected`
-  },
-  de: {
-    selected: `{{amount}} ausgew\xE4hlt`
-  }
-};
-var MultiSelect = ({
-  overwriteTranslation,
-  label,
-  options,
-  onChange,
-  hintText,
-  selectedDisplayOverwrite,
-  searchOptions,
-  additionalItems,
-  useChipDisplay = false,
-  className,
-  triggerClassName,
-  hintTextClassName,
-  ...menuProps
-}) => {
-  const translation = useTranslation([formTranslation, defaultMultiSelectTranslation], overwriteTranslation);
-  const { result, search, setSearch } = useSearch({
-    list: options,
-    searchMapping: useCallback5((item) => item.searchTags, []),
-    ...searchOptions
-  });
-  const selectedItems = options.filter((value) => value.selected);
-  const isShowingHint = !selectedDisplayOverwrite && selectedItems.length === 0;
-  return /* @__PURE__ */ jsxs9("div", { className: clsx10(className), children: [
-    label && /* @__PURE__ */ jsx11(
-      Label,
-      {
-        ...label,
-        htmlFor: label.name,
-        className: clsx10(" mb-1", label.className),
-        labelType: label.labelType ?? "labelSmall"
-      }
-    ),
-    /* @__PURE__ */ jsx11(
-      Menu,
-      {
-        ...menuProps,
-        trigger: ({ toggleOpen, isOpen, disabled }, ref) => /* @__PURE__ */ jsx11(
-          "button",
-          {
-            ref,
-            className: clsx10(
-              "group btn-md justify-between w-full border-2 h-auto",
-              "not-disabled:bg-input-background not-disabled:text-input-text not-disabled:hover:border-primary",
-              "disabled:bg-disabled-background disabled:text-disabled-text disabled:border-disabled-border",
-              {
-                "min-h-14": useChipDisplay
-              },
-              triggerClassName
-            ),
-            onClick: toggleOpen,
-            disabled,
-            children: useChipDisplay ? /* @__PURE__ */ jsx11(Fragment2, { children: isShowingHint ? /* @__PURE__ */ jsx11(
-              "div",
-              {
-                className: clsx10(
-                  "icon-btn-sm ",
-                  {
-                    "bg-button-solid-neutral-background text-button-solid-neutral-text hover:brightness-90 group-hover:brightness-90": !disabled,
-                    "bg-disabled-background text-disabled-text": disabled
-                  }
-                ),
-                children: /* @__PURE__ */ jsx11(Plus, {})
-              }
-            ) : /* @__PURE__ */ jsx11(ChipList, { list: selectedItems.map((value) => ({ children: value.label })) }) }) : /* @__PURE__ */ jsxs9(Fragment2, { children: [
-              !isShowingHint && /* @__PURE__ */ jsx11("span", { className: "font-semibold", children: selectedDisplayOverwrite ?? translation("selected", { replacements: { amount: selectedItems.length.toString() } }) }),
-              isShowingHint && /* @__PURE__ */ jsx11("span", { className: clsx10("textstyle-description", hintTextClassName), children: hintText ?? translation("select") }),
-              /* @__PURE__ */ jsx11(ExpansionIcon, { isExpanded: isOpen })
-            ] })
-          }
-        ),
-        menuClassName: clsx10("flex-col-2 p-2 max-h-96 overflow-hidden", menuProps.menuClassName),
-        children: (bag) => {
-          const { close } = bag;
-          return /* @__PURE__ */ jsxs9(Fragment2, { children: [
-            !searchOptions?.disabled && /* @__PURE__ */ jsx11(
-              SearchBar,
-              {
-                value: search,
-                onChangeText: setSearch,
-                autoFocus: true
-              }
-            ),
-            /* @__PURE__ */ jsxs9("div", { className: "flex-col-2 overflow-y-auto", children: [
-              result.map((option, index) => {
-                const update = () => {
-                  onChange(options.map((value) => value.value === option.value ? {
-                    ...option,
-                    selected: !value.selected
-                  } : value));
-                };
-                return /* @__PURE__ */ jsx11(
-                  ListTile,
-                  {
-                    prefix: /* @__PURE__ */ jsx11(
-                      Checkbox,
-                      {
-                        checked: option.selected,
-                        onChange: update,
-                        size: "small",
-                        disabled: option.disabled
-                      }
-                    ),
-                    title: option.label,
-                    onClick: update,
-                    disabled: option.disabled
-                  },
-                  index
-                );
-              }),
-              additionalItems && additionalItems({ ...bag, search })
-            ] }),
-            /* @__PURE__ */ jsxs9("div", { className: "flex-row-2 justify-between", children: [
-              /* @__PURE__ */ jsxs9("div", { className: "flex-row-2", children: [
-                /* @__PURE__ */ jsx11(
-                  SolidButton,
-                  {
-                    color: "neutral",
-                    size: "small",
-                    onClick: () => {
-                      onChange(options.map((option) => ({
-                        ...option,
-                        selected: !option.disabled
-                      })));
-                    },
-                    disabled: options.every((value) => value.selected || value.disabled),
-                    children: translation("all")
-                  }
-                ),
-                /* @__PURE__ */ jsx11(
-                  SolidButton,
-                  {
-                    color: "neutral",
-                    size: "small",
-                    onClick: () => {
-                      onChange(options.map((option) => ({
-                        ...option,
-                        selected: false
-                      })));
-                    },
-                    children: translation("none")
-                  }
-                )
-              ] }),
-              /* @__PURE__ */ jsx11(SolidButton, { size: "small", onClick: close, children: "Done" })
-            ] })
-          ] });
-        }
-      }
-    )
-  ] });
-};
-
-// src/components/properties/PropertyBase.tsx
-import { AlertTriangle } from "lucide-react";
-import clsx11 from "clsx";
-import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
-var PropertyBase = ({
-  overwriteTranslation,
-  name,
-  input,
-  softRequired = false,
-  hasValue,
-  icon,
-  readOnly,
-  onRemove,
-  className = ""
-}) => {
-  const translation = useTranslation([formTranslation], overwriteTranslation);
-  const requiredAndNoValue = softRequired && !hasValue;
-  return /* @__PURE__ */ jsxs10("div", { className: clsx11("flex-row-0 group", className), children: [
-    /* @__PURE__ */ jsxs10(
-      "div",
-      {
-        className: clsx11(
-          "flex-row-2 max-w-48 min-w-48 px-3 py-2 items-center rounded-l-xl border-2 border-r-0",
-          {
-            "bg-property-title-background text-property-title-text group-hover:border-primary": !requiredAndNoValue,
-            "bg-warning text-surface-warning group-hover:border-warning border-warning/90": requiredAndNoValue
-          },
-          className
-        ),
-        children: [
-          /* @__PURE__ */ jsx12("div", { className: "max-w-6 min-w-6 text-text-primary", children: icon }),
-          /* @__PURE__ */ jsx12("span", { className: "font-semibold", children: name })
-        ]
+        children: [
+          /* @__PURE__ */ jsx6("div", { className: "max-w-6 min-w-6 text-text-primary", children: icon }),
+          /* @__PURE__ */ jsx6("span", { className: "font-semibold", children: name })
+        ]
       }
     ),
-    /* @__PURE__ */ jsxs10(
+    /* @__PURE__ */ jsxs5(
       "div",
       {
-        className: clsx11(
+        className: clsx5(
           "flex-row-2 grow px-3 py-2 justify-between items-center rounded-r-xl border-2 border-l-0 min-h-15",
           {
             "bg-input-background text-input-text group-hover:border-primary": !requiredAndNoValue,
@@ -1524,14 +1545,14 @@ var PropertyBase = ({
         ),
         children: [
           input({ softRequired, hasValue }),
-          requiredAndNoValue && /* @__PURE__ */ jsx12("div", { className: "text-warning", children: /* @__PURE__ */ jsx12(AlertTriangle, { size: 24 }) }),
-          onRemove && hasValue && /* @__PURE__ */ jsx12(
+          requiredAndNoValue && /* @__PURE__ */ jsx6("div", { className: "text-warning", children: /* @__PURE__ */ jsx6(AlertTriangle, { size: 24 }) }),
+          onRemove && !readOnly && /* @__PURE__ */ jsx6(
             TextButton,
             {
               onClick: onRemove,
               color: "negative",
-              className: clsx11("items-center", { "!text-transparent": !hasValue || readOnly }),
-              disabled: !hasValue || readOnly,
+              className: clsx5("items-center"),
+              disabled: !hasValue,
               children: translation("remove")
             }
           )
@@ -1542,65 +1563,37 @@ var PropertyBase = ({
 };
 
 // src/components/properties/MultiSelectProperty.tsx
-import { jsx as jsx13 } from "react/jsx-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
 var MultiSelectProperty = ({
-  overwriteTranslation,
+  values,
   options,
-  name,
-  readOnly = false,
-  softRequired,
-  onRemove,
-  onAddNew,
-  ...multiSelectProps
+  onValuesChanged,
+  ...props
 }) => {
-  const translation = useTranslation([formTranslation], overwriteTranslation);
-  const hasValue = options.some((value) => value.selected);
-  return /* @__PURE__ */ jsx13(
+  const hasValue = values.length > 0;
+  return /* @__PURE__ */ jsx7(
     PropertyBase,
     {
-      name,
-      onRemove,
-      readOnly,
-      softRequired,
+      ...props,
       hasValue,
-      icon: /* @__PURE__ */ jsx13(List, { size: 24 }),
-      input: ({ softRequired: softRequired2 }) => /* @__PURE__ */ jsx13(
-        MultiSelect,
+      icon: /* @__PURE__ */ jsx7(List, { size: 24 }),
+      input: ({ softRequired }) => /* @__PURE__ */ jsx7(
+        MultiSelectChipDisplay,
         {
-          ...multiSelectProps,
-          className: clsx12("w-full", { "bg-surface-warning": softRequired2 && !hasValue }),
-          options,
-          disabled: readOnly,
-          useChipDisplay: true,
-          hintText: `${translation("select")}...`,
-          searchOptions: {
-            sortingFunction: (a, b) => a.value.localeCompare(b.value),
-            ...multiSelectProps?.searchOptions
+          values,
+          onValuesChanged,
+          disabled: props.readOnly,
+          contentPanelProps: {
+            className: clsx6(
+              "!border-none !min-h-10"
+            )
           },
-          additionalItems: ({ close, search }) => {
-            if (!onAddNew && !search.trim()) {
-              return void 0;
-            }
-            return /* @__PURE__ */ jsx13(
-              ListTile,
-              {
-                prefix: /* @__PURE__ */ jsx13(Plus2, {}),
-                title: `${translation("add")} ${search.trim()}`,
-                onClick: () => {
-                  onAddNew(search);
-                  close();
-                },
-                disabled: options.some((value) => value.value === search.trim())
-              }
-            );
+          chipDisplayProps: {
+            className: clsx6({
+              "!bg-warning !text-surface-warning": softRequired && !hasValue
+            })
           },
-          triggerClassName: clsx12(
-            "!border-none !p-0 !min-h-10",
-            {
-              "!bg-warning !text-surface-warning": softRequired2 && !hasValue,
-              "": !softRequired2 || hasValue
-            }
-          )
+          children: options.map((value) => /* @__PURE__ */ jsx7(SelectOption, { value }, value))
         }
       )
     }