@helpwave/hightide 0.1.25 → 0.1.26

package/dist/components/table/Table.mjs

@@ -1,15 +1,674 @@
 // src/components/table/Table.tsx
-import { useCallback as useCallback3, useEffect as useEffect11, useMemo, useRef as useRef3, useState as useState10 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect15, useMemo as useMemo4, useRef as useRef8, useState as useState14 } from "react";
+import clsx9 from "clsx";
+import {
+  flexRender,
+  getCoreRowModel,
+  getFilteredRowModel,
+  getPaginationRowModel,
+  getSortedRowModel,
+  useReactTable
+} from "@tanstack/react-table";
 
-// src/components/layout-and-navigation/Pagination.tsx
-import { ChevronFirst, ChevronLast, ChevronLeft, ChevronRight } from "lucide-react";
+// src/utils/array.ts
+var defaultRangeOptions = {
+  allowEmptyRange: false,
+  stepSize: 1,
+  exclusiveStart: false,
+  exclusiveEnd: true
+};
+var range = (endOrRange, options) => {
+  const { allowEmptyRange, stepSize, exclusiveStart, exclusiveEnd } = { ...defaultRangeOptions, ...options };
+  let start = 0;
+  let end;
+  if (typeof endOrRange === "number") {
+    end = endOrRange;
+  } else {
+    start = endOrRange[0];
+    end = endOrRange[1];
+  }
+  if (!exclusiveEnd) {
+    end -= 1;
+  }
+  if (exclusiveStart) {
+    start += 1;
+  }
+  if (end - 1 < start) {
+    if (!allowEmptyRange) {
+      console.warn(`range: end (${end}) < start (${start}) should be allowed explicitly, set options.allowEmptyRange to true`);
+    }
+    return [];
+  }
+  return Array.from({ length: end - start }, (_, index) => index * stepSize + start);
+};
+
+// src/components/table/Table.tsx
+import { Scrollbars } from "react-custom-scrollbars-2";
+
+// src/utils/math.ts
+var clamp = (value, range2 = [0, 1]) => {
+  const [min, max] = range2;
+  return Math.min(Math.max(value, min), max);
+};
+
+// src/utils/noop.ts
+var noop = () => void 0;
+
+// src/components/table/TableCell.tsx
+import { clsx } from "clsx";
+import { jsx } from "react/jsx-runtime";
+var TableCell = ({
+  children,
+  className
+}) => {
+  return /* @__PURE__ */ jsx("span", { className: clsx("block max-w-full overflow-ellipsis truncate", className), children });
+};
+
+// src/components/table/Filter.ts
+var dateRange = (row, columnId, filterValue) => {
+  const [min, max] = filterValue;
+  const value = row.getValue(columnId);
+  const date = value instanceof Date ? value : new Date(value);
+  if (isNaN(date.getTime())) return false;
+  if (min && date < min) return false;
+  if (max && date > max) return false;
+  return true;
+};
+var TableFilters = {
+  dateRange
+};
+
+// src/hooks/useResizeCallbackWrapper.ts
+import { useEffect } from "react";
+var useResizeCallbackWrapper = (callback) => {
+  useEffect(() => {
+    window.addEventListener("resize", callback);
+    return () => {
+      window.removeEventListener("resize", callback);
+    };
+  }, [callback]);
+};
+
+// src/components/table/TableSortButton.tsx
+import { ChevronDown, ChevronsUpDown, ChevronUp } from "lucide-react";
+
+// src/components/user-action/Button.tsx
+import { forwardRef } from "react";
+import clsx2 from "clsx";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var ButtonColorUtil = {
+  solid: ["primary", "secondary", "tertiary", "positive", "warning", "negative", "neutral"],
+  text: ["primary", "negative", "neutral"],
+  outline: ["primary"]
+};
+var IconButtonUtil = {
+  icon: [...ButtonColorUtil.solid, "transparent"]
+};
+var paddingMapping = {
+  small: "btn-sm",
+  medium: "btn-md",
+  large: "btn-lg"
+};
+var iconPaddingMapping = {
+  tiny: "icon-btn-xs",
+  small: "icon-btn-sm",
+  medium: "icon-btn-md",
+  large: "icon-btn-lg"
+};
+var ButtonUtil = {
+  paddingMapping,
+  iconPaddingMapping
+};
+var SolidButton = forwardRef(function SolidButton2({
+  children,
+  color = "primary",
+  size = "medium",
+  startIcon,
+  endIcon,
+  onClick,
+  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",
+    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: "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,
+      className: clsx2(
+        "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(
+          "span",
+          {
+            className: clsx2(
+              iconColorClasses,
+              "group-disabled:text-disabled-icon"
+            ),
+            children: startIcon
+          }
+        ),
+        children,
+        endIcon && /* @__PURE__ */ jsx2(
+          "span",
+          {
+            className: clsx2(
+              iconColorClasses,
+              "group-disabled:text-disabled-icon"
+            ),
+            children: endIcon
+          }
+        )
+      ]
+    }
+  );
+});
+var IconButton = forwardRef(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",
+    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(
+    "button",
+    {
+      ref,
+      className: clsx2(
+        colorClasses,
+        "not-disabled:hover:brightness-90",
+        "disabled:text-disabled-text",
+        {
+          "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
+      ),
+      ...restProps,
+      children
+    }
+  );
+});
+
+// src/components/table/TableSortButton.tsx
+import clsx3 from "clsx";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var TableSortButton = ({
+  sortDirection,
+  invert = false,
+  color = "neutral",
+  className,
+  ...buttonProps
+}) => {
+  let icon = /* @__PURE__ */ jsx3(ChevronsUpDown, { className: "w-full h-full" });
+  if (sortDirection) {
+    let usedSortDirection = sortDirection;
+    if (invert) {
+      usedSortDirection = usedSortDirection === "desc" ? "asc" : "desc";
+    }
+    icon = usedSortDirection === "asc" ? /* @__PURE__ */ jsx3(ChevronUp, { className: "w-full h-full" }) : /* @__PURE__ */ jsx3(ChevronDown, { className: "w-full h-full" });
+  }
+  return /* @__PURE__ */ jsx3(
+    IconButton,
+    {
+      size: "tiny",
+      color,
+      className: clsx3(className),
+      ...buttonProps,
+      children: icon
+    }
+  );
+};
+
+// src/components/user-action/input/Input.tsx
+import { forwardRef as forwardRef2, useEffect as useEffect3, useImperativeHandle, useRef, useState as useState2 } from "react";
 import clsx4 from "clsx";
 
+// src/hooks/useDelay.ts
+import { useEffect as useEffect2, useState } from "react";
+var defaultOptions = {
+  delay: 3e3,
+  disabled: false
+};
+function useDelay(options) {
+  const [timer, setTimer] = useState(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));
+  };
+  useEffect2(() => {
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [timer]);
+  useEffect2(() => {
+    if (disabled) {
+      clearTimeout(timer);
+      setTimer(void 0);
+    }
+  }, [disabled, timer]);
+  return { restartTimer, clearTimer, hasActiveTimer: !!timer };
+}
+
+// src/hooks/focus/useFocusManagement.ts
+import { useCallback } from "react";
+function useFocusManagement() {
+  const getFocusableElements = useCallback(() => {
+    return Array.from(
+      document.querySelectorAll(
+        'input, button, select, textarea, a[href], [tabindex]:not([tabindex="-1"])'
+      )
+    ).filter(
+      (el) => el instanceof HTMLElement && !el.hasAttribute("disabled") && !el.hasAttribute("hidden") && el.tabIndex !== -1
+    );
+  }, []);
+  const getNextFocusElement = useCallback(() => {
+    const elements = getFocusableElements();
+    if (elements.length === 0) {
+      return void 0;
+    }
+    let nextElement = elements[0];
+    if (document.activeElement instanceof HTMLElement) {
+      const currentIndex = elements.indexOf(document.activeElement);
+      nextElement = elements[(currentIndex + 1) % elements.length];
+    }
+    return nextElement;
+  }, [getFocusableElements]);
+  const focusNext = useCallback(() => {
+    const nextElement = getNextFocusElement();
+    nextElement?.focus();
+  }, [getNextFocusElement]);
+  const getPreviousFocusElement = useCallback(() => {
+    const elements = getFocusableElements();
+    if (elements.length === 0) {
+      return void 0;
+    }
+    let previousElement = elements[0];
+    if (document.activeElement instanceof HTMLElement) {
+      const currentIndex = elements.indexOf(document.activeElement);
+      if (currentIndex === 0) {
+        previousElement = elements[elements.length - 1];
+      } else {
+        previousElement = elements[currentIndex - 1];
+      }
+    }
+    return previousElement;
+  }, [getFocusableElements]);
+  const focusPrevious = useCallback(() => {
+    const previousElement = getPreviousFocusElement();
+    if (previousElement) previousElement.focus();
+  }, [getPreviousFocusElement]);
+  return {
+    getFocusableElements,
+    getNextFocusElement,
+    getPreviousFocusElement,
+    focusNext,
+    focusPrevious
+  };
+}
+
+// src/components/user-action/input/Input.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var defaultEditCompleteOptions = {
+  allowEnterComplete: false,
+  onBlur: true,
+  afterDelay: true,
+  delay: 2500
+};
+var Input = forwardRef2(function Input2({
+  value,
+  onChange,
+  onChangeText,
+  onEditCompleted,
+  editCompleteOptions,
+  disabled = false,
+  invalid = false,
+  defaultStyle = true,
+  className,
+  ...props
+}, forwardedRef) {
+  const {
+    onBlur: allowEditCompleteOnBlur,
+    afterDelay,
+    delay,
+    allowEnterComplete
+  } = { ...defaultEditCompleteOptions, ...editCompleteOptions };
+  const {
+    restartTimer,
+    clearTimer
+  } = useDelay({ delay, disabled: !afterDelay });
+  const innerRef = useRef(null);
+  useImperativeHandle(forwardedRef, () => innerRef.current);
+  const { focusNext } = useFocusManagement();
+  return /* @__PURE__ */ jsx4(
+    "input",
+    {
+      ...props,
+      ref: innerRef,
+      value,
+      disabled,
+      className: defaultStyle ? clsx4(
+        "px-2.5 py-1.75 rounded-md border-1 text-sm",
+        {
+          "bg-input-background text-input-text hover:border-primary focus:border-primary": !disabled && !invalid,
+          "bg-on-negative text-negative border-negative-border hover:border-negative-border-hover focus-visible:ring-negative-border": !disabled && invalid,
+          "bg-disabled-background text-disabled-text border-disabled-border": disabled
+        },
+        className
+      ) : className,
+      onKeyDown: (event) => {
+        props.onKeyDown?.(event);
+        if (!allowEnterComplete) {
+          return;
+        }
+        if (event.key === "Enter" && !event.shiftKey) {
+          event.preventDefault();
+          innerRef.current?.blur();
+          onEditCompleted?.(event.target.value);
+          focusNext();
+        }
+      },
+      onBlur: (event) => {
+        props.onBlur?.(event);
+        if (allowEditCompleteOnBlur) {
+          onEditCompleted?.(event.target.value);
+          clearTimer();
+        }
+      },
+      onChange: (event) => {
+        onChange?.(event);
+        const value2 = event.target.value;
+        restartTimer(() => {
+          innerRef.current?.blur();
+          onEditCompleted?.(value2);
+        });
+        onChangeText?.(value2);
+      },
+      "aria-invalid": props["aria-invalid"] ?? invalid,
+      "aria-disabled": props["aria-disabled"] ?? disabled
+    }
+  );
+});
+
+// src/components/table/TableFilterButton.tsx
+import { FilterIcon } from "lucide-react";
+
+// src/components/user-action/Menu.tsx
+import { useEffect as useEffect6, useRef as useRef2, useState as useState4 } from "react";
+import clsx5 from "clsx";
+
+// src/hooks/useOutsideClick.ts
+import { useEffect as useEffect4 } from "react";
+var useOutsideClick = (refs, handler) => {
+  useEffect4(() => {
+    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 useEffect5, 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));
+  };
+  useEffect5(() => {
+    if (timer) {
+      return () => {
+        clearTimeout(timer);
+      };
+    }
+  });
+  useEffect5(() => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }, [isDisabled]);
+  return {
+    isHovered,
+    setIsHovered,
+    handlers: { onMouseEnter, onMouseLeave }
+  };
+};
+
+// src/utils/bagFunctions.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 jsxs2 } 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 = ""
+}) => {
+  const { isHovered: isOpen, setIsHovered: setIsOpen } = useHoverState({ isDisabled: !showOnHover || disabled });
+  const triggerRef = useRef2(null);
+  const menuRef = useRef2(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 }
+  );
+  useEffect6(() => {
+    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]);
+  useEffect6(() => {
+    if (isOpen) {
+      setIsHidden(false);
+    }
+  }, [isOpen]);
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    trigger(bag, triggerRef),
+    createPortal(/* @__PURE__ */ jsx5(
+      "div",
+      {
+        ref: menuRef,
+        onClick: (e) => e.stopPropagation(),
+        className: clsx5(
+          "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)
+      }
+    ), document.body)
+  ] });
+};
+
 // src/localization/LanguageProvider.tsx
-import { createContext, useContext, useEffect, useState as useState2 } from "react";
+import { createContext, useContext, useEffect as useEffect7, useState as useState6 } from "react";
 
 // src/hooks/useLocalStorage.ts
-import { useCallback, useState } from "react";
+import { useCallback as useCallback2, useState as useState5 } from "react";
 
 // src/localization/util.ts
 var languages = ["en", "de"];
@@ -25,7 +684,7 @@ var LanguageUtil = {
 };
 
 // src/localization/LanguageProvider.tsx
-import { jsx } from "react/jsx-runtime";
+import { jsx as jsx6 } from "react/jsx-runtime";
 var LanguageContext = createContext({
   language: LanguageUtil.DEFAULT_LANGUAGE,
   setLanguage: (v) => v
@@ -128,6 +787,7 @@ var formTranslation = {
     next: "Next",
     no: "No",
     none: "None",
+    nothingFound: "Nothing found",
     of: "of",
     optional: "Optional",
     pleaseWait: "Please wait...",
@@ -184,6 +844,7 @@ var formTranslation = {
     next: "Weiter",
     no: "Nein",
     none: "Nichts",
+    nothingFound: "Nichts gefunden",
     of: "von",
     optional: "Optional",
     pleaseWait: "Bitte warten...",
@@ -207,422 +868,150 @@ var formTranslation = {
     yes: "Ja"
   }
 };
-
-// src/components/user-action/Input.tsx
-import { forwardRef, useEffect as useEffect4, useImperativeHandle, useRef, useState as useState4 } from "react";
-import clsx2 from "clsx";
-
-// src/hooks/useDelay.ts
-import { useEffect as useEffect2, useState as useState3 } from "react";
-var defaultOptions = {
-  delay: 3e3,
-  disabled: false
-};
-function useDelay(options) {
-  const [timer, setTimer] = useState3(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));
-  };
-  useEffect2(() => {
-    return () => {
-      clearTimeout(timer);
-    };
-  }, [timer]);
-  useEffect2(() => {
-    if (disabled) {
-      clearTimeout(timer);
-      setTimer(void 0);
-    }
-  }, [disabled, timer]);
-  return { restartTimer, clearTimer, hasActiveTimer: !!timer };
-}
-
-// src/util/noop.ts
-var noop = () => void 0;
-
-// src/components/user-action/Label.tsx
-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"
-};
-var Label = ({
-  children,
-  name,
-  labelType = "labelSmall",
-  className,
-  ...props
-}) => {
-  return /* @__PURE__ */ jsx2("label", { ...props, className: clsx(styleMapping[labelType], className), children: children ? children : name });
-};
-
-// src/hooks/useFocusManagement.ts
-import { useCallback as useCallback2 } from "react";
-function useFocusManagement() {
-  const getFocusableElements = useCallback2(() => {
-    return Array.from(
-      document.querySelectorAll(
-        'input, button, select, textarea, a[href], [tabindex]:not([tabindex="-1"])'
-      )
-    ).filter(
-      (el) => el instanceof HTMLElement && !el.hasAttribute("disabled") && !el.hasAttribute("hidden") && el.tabIndex !== -1
-    );
-  }, []);
-  const getNextFocusElement = useCallback2(() => {
-    const elements = getFocusableElements();
-    if (elements.length === 0) {
-      return void 0;
-    }
-    let nextElement = elements[0];
-    if (document.activeElement instanceof HTMLElement) {
-      const currentIndex = elements.indexOf(document.activeElement);
-      nextElement = elements[(currentIndex + 1) % elements.length];
-    }
-    return nextElement;
-  }, [getFocusableElements]);
-  const focusNext = useCallback2(() => {
-    const nextElement = getNextFocusElement();
-    nextElement?.focus();
-  }, [getNextFocusElement]);
-  const getPreviousFocusElement = useCallback2(() => {
-    const elements = getFocusableElements();
-    if (elements.length === 0) {
-      return void 0;
-    }
-    let previousElement = elements[0];
-    if (document.activeElement instanceof HTMLElement) {
-      const currentIndex = elements.indexOf(document.activeElement);
-      if (currentIndex === 0) {
-        previousElement = elements[elements.length - 1];
-      } else {
-        previousElement = elements[currentIndex - 1];
-      }
-    }
-    return previousElement;
-  }, [getFocusableElements]);
-  const focusPrevious = useCallback2(() => {
-    const previousElement = getPreviousFocusElement();
-    if (previousElement) previousElement.focus();
-  }, [getPreviousFocusElement]);
-  return {
-    getFocusableElements,
-    getNextFocusElement,
-    getPreviousFocusElement,
-    focusNext,
-    focusPrevious
-  };
-}
-
-// src/hooks/useFocusOnceVisible.ts
-import React, { useEffect as useEffect3 } from "react";
-var useFocusOnceVisible = (ref, disable = false) => {
-  const [hasUsedFocus, setHasUsedFocus] = React.useState(false);
-  useEffect3(() => {
-    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 jsx3, jsxs } from "react/jsx-runtime";
-var getInputClassName = ({ disabled = false, hasError = false }) => {
-  return clsx2(
-    "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 = forwardRef(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 = useRef(null);
-  const { focusNext } = useFocusManagement();
-  useFocusOnceVisible(innerRef, !autoFocus);
-  useImperativeHandle(forwardedRef, () => innerRef.current);
-  const handleKeyDown = (e) => {
-    if (e.key === "Enter" && !e.shiftKey) {
-      e.preventDefault();
-      innerRef.current?.blur();
-      focusNext();
-    }
-  };
-  return /* @__PURE__ */ jsxs("div", { className: clsx2({ "w-full": expanded }, containerClassName), children: [
-    label && /* @__PURE__ */ jsx3(Label, { ...label, htmlFor: id, className: clsx2("mb-1", label.className) }),
-    /* @__PURE__ */ jsx3(
-      "input",
-      {
-        ...restProps,
-        ref: innerRef,
-        value,
-        id,
-        type,
-        disabled,
-        className: clsx2(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 = forwardRef(function FormInput2({
-  id,
-  labelText,
-  errorText,
-  className,
-  labelClassName,
-  errorClassName,
-  containerClassName,
-  required,
-  disabled,
-  ...restProps
-}, ref) {
-  const input = /* @__PURE__ */ jsx3(
-    "input",
-    {
-      ...restProps,
-      ref,
-      id,
-      disabled,
-      className: clsx2(
-        getInputClassName({ disabled, hasError: !!errorText }),
-        className
-      )
-    }
-  );
-  return /* @__PURE__ */ jsxs("div", { className: clsx2("flex flex-col gap-y-1", containerClassName), children: [
-    labelText && /* @__PURE__ */ jsxs("label", { htmlFor: id, className: clsx2("textstyle-label-md", labelClassName), children: [
-      labelText,
-      required && /* @__PURE__ */ jsx3("span", { className: "text-primary font-bold", children: "*" })
-    ] }),
-    input,
-    errorText && /* @__PURE__ */ jsx3("label", { htmlFor: id, className: clsx2("text-negative", errorClassName), children: errorText })
-  ] });
-});
-
-// src/util/math.ts
-var clamp = (value, min = 0, max = 1) => {
-  return Math.min(Math.max(value, min), max);
-};
-
-// src/components/layout-and-navigation/Pagination.tsx
-import { useEffect as useEffect5, useState as useState5 } from "react";
-
-// src/components/user-action/Button.tsx
-import { forwardRef as forwardRef2 } from "react";
-import clsx3 from "clsx";
-import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
-var ButtonColorUtil = {
-  solid: ["primary", "secondary", "tertiary", "positive", "warning", "negative", "neutral"],
-  text: ["primary", "negative", "neutral"],
-  outline: ["primary"]
-};
-var IconButtonUtil = {
-  icon: [...ButtonColorUtil.solid, "transparent"]
-};
-var paddingMapping = {
-  small: "btn-sm",
-  medium: "btn-md",
-  large: "btn-lg"
-};
-var iconPaddingMapping = {
-  tiny: "icon-btn-xs",
-  small: "icon-btn-sm",
-  medium: "icon-btn-md",
-  large: "icon-btn-lg"
-};
-var ButtonUtil = {
-  paddingMapping,
-  iconPaddingMapping
-};
-var SolidButton = forwardRef2(function SolidButton2({
-  children,
-  color = "primary",
-  size = "medium",
-  startIcon,
-  endIcon,
-  onClick,
-  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",
-    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: "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__ */ jsxs2(
-    "button",
+
+// src/components/table/TableFilterButton.tsx
+import { useEffect as useEffect8, useState as useState7 } from "react";
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+var defaultTableFilterTranslation = {
+  en: {
+    filter: "Filter",
+    min: "Min",
+    max: "Max",
+    startDate: "Start",
+    endDate: "End",
+    text: "Text..."
+  },
+  de: {
+    filter: "Filter",
+    min: "Min",
+    max: "Max",
+    startDate: "Start",
+    endDate: "Ende",
+    text: "Text..."
+  }
+};
+var TableFilterButton = ({
+  filterType,
+  column
+}) => {
+  const translation = useTranslation([formTranslation, defaultTableFilterTranslation]);
+  const columnFilterValue = column.getFilterValue();
+  const [filterValue, setFilterValue] = useState7(columnFilterValue);
+  const hasFilter = !!filterValue;
+  useEffect8(() => {
+    setFilterValue(columnFilterValue);
+  }, [columnFilterValue]);
+  return /* @__PURE__ */ jsx7(
+    Menu,
     {
-      ref,
-      onClick,
-      className: clsx3(
-        "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__ */ jsx4(
-          "span",
+      trigger: ({ toggleOpen }, ref) => /* @__PURE__ */ jsxs3("div", { ref, className: "relative", children: [
+        /* @__PURE__ */ jsx7(IconButton, { color: "neutral", size: "tiny", onClick: toggleOpen, children: /* @__PURE__ */ jsx7(FilterIcon, {}) }),
+        hasFilter && /* @__PURE__ */ jsx7(
+          "div",
           {
-            className: clsx3(
-              iconColorClasses,
-              "group-disabled:text-disabled-icon"
-            ),
-            children: startIcon
+            className: "absolute top-0.5 right-0.5 w-2 h-2 rounded-full bg-primary pointer-events-none",
+            "aria-hidden": true
           }
-        ),
-        children,
-        endIcon && /* @__PURE__ */ jsx4(
-          "span",
+        )
+      ] }),
+      children: ({ close }) => /* @__PURE__ */ jsxs3("div", { className: "flex-col-1 p-2 items-start font-normal text-menu-text", children: [
+        /* @__PURE__ */ jsx7("h4", { className: "typography-label-md-semibold", children: translation("filter") }),
+        filterType === "text" && /* @__PURE__ */ jsx7(
+          Input,
           {
-            className: clsx3(
-              iconColorClasses,
-              "group-disabled:text-disabled-icon"
-            ),
-            children: endIcon
+            value: filterValue ?? "",
+            autoFocus: true,
+            placeholder: translation("text"),
+            onChangeText: setFilterValue,
+            className: "h-10"
           }
-        )
-      ]
+        ),
+        filterType === "range" && /* @__PURE__ */ jsxs3("div", { className: "flex-row-2 items-center", children: [
+          /* @__PURE__ */ jsx7(
+            Input,
+            {
+              value: filterValue?.[0] ?? "",
+              type: "number",
+              placeholder: translation("min"),
+              onChangeText: (text) => {
+                const num = Number(text);
+                setFilterValue((old) => [num, old?.[1]]);
+              },
+              className: "h-10 input-indicator-hidden w-40"
+            }
+          ),
+          /* @__PURE__ */ jsx7("span", { className: "font-bold", children: "-" }),
+          /* @__PURE__ */ jsx7(
+            Input,
+            {
+              value: filterValue?.[1] ?? "",
+              type: "number",
+              placeholder: translation("max"),
+              onChangeText: (text) => {
+                const num = Number(text);
+                setFilterValue((old) => [old?.[0], num]);
+              },
+              className: "h-10 input-indicator-hidden w-40"
+            }
+          )
+        ] }),
+        filterType === "dateRange" && /* @__PURE__ */ jsxs3(Fragment2, { children: [
+          /* @__PURE__ */ jsx7(
+            Input,
+            {
+              value: filterValue?.[0] ? filterValue?.[0].toISOString().slice(0, 16) : "",
+              type: "datetime-local",
+              placeholder: translation("startDate"),
+              onChangeText: (text) => {
+                const value = new Date(text);
+                setFilterValue((old) => [value, old?.[1]]);
+              },
+              className: "h-10 w-50"
+            }
+          ),
+          /* @__PURE__ */ jsx7(
+            Input,
+            {
+              value: filterValue?.[1] ? filterValue?.[1].toISOString().slice(0, 16) : "",
+              type: "datetime-local",
+              placeholder: translation("endDate"),
+              onChangeText: (text) => {
+                const value = new Date(text);
+                setFilterValue((old) => [old?.[0], value]);
+              },
+              className: "h-10 w-50"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs3("div", { className: "flex-row-2 justify-end w-full", children: [
+          hasFilter && /* @__PURE__ */ jsx7(SolidButton, { color: "negative", size: "small", onClick: () => {
+            column.setFilterValue(void 0);
+            close();
+          }, children: translation("remove") }),
+          /* @__PURE__ */ jsx7(SolidButton, { size: "small", onClick: () => {
+            column.setFilterValue(filterValue);
+            close();
+          }, children: translation("apply") })
+        ] })
+      ] })
     }
   );
-});
-var IconButton = ({
-  children,
-  color = "primary",
-  size = "medium",
-  className,
-  ...restProps
+};
+
+// src/components/table/FillerRowElement.tsx
+import { clsx as clsx6 } from "clsx";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var FillerRowElement = ({
+  className
 }) => {
-  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",
-    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__ */ jsx4(
-    "button",
-    {
-      className: clsx3(
-        colorClasses,
-        "not-disabled:hover:brightness-90",
-        "disabled:text-disabled-text",
-        {
-          "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
-      ),
-      ...restProps,
-      children
-    }
-  );
+  return /* @__PURE__ */ jsx8("div", { className: clsx6("flex flex-row items-center w-1/2 h-4 text-disabled-text font-bold", className), children: "-" });
 };
 
 // src/components/layout-and-navigation/Pagination.tsx
-import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+import { ChevronFirst, ChevronLast, ChevronLeft, ChevronRight } from "lucide-react";
+import clsx7 from "clsx";
+import { useEffect as useEffect9, useState as useState8 } from "react";
+import { jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
 var Pagination = ({
   overwriteTranslation,
   pageIndex,
@@ -632,11 +1021,11 @@ var Pagination = ({
   style
 }) => {
   const translation = useTranslation([formTranslation], overwriteTranslation);
-  const [value, setValue] = useState5((pageIndex + 1).toString());
+  const [value, setValue] = useState8((pageIndex + 1).toString());
   const noPages = pageCount === 0;
   const onFirstPage = pageIndex === 0 && !noPages;
   const onLastPage = pageIndex === pageCount - 1;
-  useEffect5(() => {
+  useEffect9(() => {
     if (noPages) {
       setValue("0");
     } else {
@@ -646,17 +1035,16 @@ var Pagination = ({
   const changePage = (page) => {
     onPageChanged(page);
   };
-  return /* @__PURE__ */ jsxs3("div", { className: clsx4("flex-row-1", className), style, children: [
-    /* @__PURE__ */ jsx5(IconButton, { color: "transparent", onClick: () => changePage(0), disabled: onFirstPage || noPages, children: /* @__PURE__ */ jsx5(ChevronFirst, {}) }),
-    /* @__PURE__ */ jsx5(IconButton, { color: "transparent", onClick: () => changePage(pageIndex - 1), disabled: onFirstPage || noPages, children: /* @__PURE__ */ jsx5(ChevronLeft, {}) }),
-    /* @__PURE__ */ jsxs3("div", { className: "flex-row-2 min-w-56 items-center justify-center mx-2 text-center", children: [
-      /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsxs4("div", { className: clsx7("flex-row-1", className), style, children: [
+    /* @__PURE__ */ jsx9(IconButton, { color: "transparent", onClick: () => changePage(0), disabled: onFirstPage || noPages, children: /* @__PURE__ */ jsx9(ChevronFirst, {}) }),
+    /* @__PURE__ */ jsx9(IconButton, { color: "transparent", onClick: () => changePage(pageIndex - 1), disabled: onFirstPage || noPages, children: /* @__PURE__ */ jsx9(ChevronLeft, {}) }),
+    /* @__PURE__ */ jsxs4("div", { className: "flex-row-2 min-w-56 items-center justify-center mx-2 text-center", children: [
+      /* @__PURE__ */ jsx9(
         Input,
         {
           value,
-          containerClassName: "flex flex-1 h-10",
-          className: clsx4(
-            "w-full text-center font-bold input-indicator-hidden"
+          className: clsx7(
+            "w-full text-center font-bold input-indicator-hidden h-10"
           ),
           type: "number",
           min: 1,
@@ -664,19 +1052,19 @@ var Pagination = ({
           disabled: noPages,
           onChangeText: (value2) => {
             if (value2) {
-              setValue(clamp(Number(value2), 1, pageCount).toString());
+              setValue(clamp(Number(value2), [1, pageCount]).toString());
             } else {
               setValue(value2);
             }
           },
           onEditCompleted: (value2) => {
-            changePage(clamp(Number(value2) - 1, 0, pageCount - 1));
+            changePage(clamp(Number(value2) - 1, [0, pageCount - 1]));
           },
           editCompleteOptions: { delay: 800 }
         }
       ),
-      /* @__PURE__ */ jsx5("span", { className: "select-none w-10", children: translation("of") }),
-      /* @__PURE__ */ jsx5(
+      /* @__PURE__ */ jsx9("span", { className: "select-none w-10", children: translation("of") }),
+      /* @__PURE__ */ jsx9(
         "span",
         {
           className: "flex-row-2 flex-1 items-center justify-center select-none h-10 bg-input-background text-input-text rounded-md font-bold",
@@ -684,578 +1072,816 @@ var Pagination = ({
         }
       )
     ] }),
-    /* @__PURE__ */ jsx5(IconButton, { color: "transparent", onClick: () => changePage(pageIndex + 1), disabled: onLastPage || noPages, children: /* @__PURE__ */ jsx5(ChevronRight, {}) }),
-    /* @__PURE__ */ jsx5(IconButton, { color: "transparent", onClick: () => changePage(pageCount - 1), disabled: onLastPage || noPages, children: /* @__PURE__ */ jsx5(ChevronLast, {}) })
+    /* @__PURE__ */ jsx9(IconButton, { color: "transparent", onClick: () => changePage(pageIndex + 1), disabled: onLastPage || noPages, children: /* @__PURE__ */ jsx9(ChevronRight, {}) }),
+    /* @__PURE__ */ jsx9(IconButton, { color: "transparent", onClick: () => changePage(pageCount - 1), disabled: onLastPage || noPages, children: /* @__PURE__ */ jsx9(ChevronLast, {}) })
   ] });
 };
 
-// src/components/table/Table.tsx
-import clsx10 from "clsx";
-import {
-  flexRender,
-  getCoreRowModel,
-  getFilteredRowModel,
-  getPaginationRowModel,
-  getSortedRowModel,
-  useReactTable
-} from "@tanstack/react-table";
-
-// src/util/array.ts
-var defaultRangeOptions = {
-  allowEmptyRange: false,
-  stepSize: 1,
-  exclusiveStart: false,
-  exclusiveEnd: true
-};
-var range = (endOrRange, options) => {
-  const { allowEmptyRange, stepSize, exclusiveStart, exclusiveEnd } = { ...defaultRangeOptions, ...options };
-  let start = 0;
-  let end;
-  if (typeof endOrRange === "number") {
-    end = endOrRange;
-  } else {
-    start = endOrRange[0];
-    end = endOrRange[1];
-  }
-  if (!exclusiveEnd) {
-    end -= 1;
-  }
-  if (exclusiveStart) {
-    start += 1;
-  }
-  if (end - 1 < start) {
-    if (!allowEmptyRange) {
-      console.warn(`range: end (${end}) < start (${start}) should be allowed explicitly, set options.allowEmptyRange to true`);
-    }
-    return [];
-  }
-  return Array.from({ length: end - start }, (_, index) => index * stepSize + start);
-};
-
-// src/components/table/Table.tsx
-import { Scrollbars } from "react-custom-scrollbars-2";
-
 // src/components/user-action/Checkbox.tsx
-import { useState as useState6 } from "react";
-import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+import { useEffect as useEffect14, useState as useState13 } from "react";
 import { Check, Minus } from "lucide-react";
-import clsx5 from "clsx";
-import { jsx as jsx6, jsxs as jsxs4 } 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);
+import clsx8 from "clsx";
+
+// node_modules/@radix-ui/react-checkbox/dist/index.mjs
+import * as React11 from "react";
+
+// node_modules/@radix-ui/react-compose-refs/dist/index.mjs
+import * as React2 from "react";
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    return ref(value);
+  } else if (ref !== null && ref !== void 0) {
+    ref.current = value;
+  }
+}
+function composeRefs(...refs) {
+  return (node) => {
+    let hasCleanup = false;
+    const cleanups = refs.map((ref) => {
+      const cleanup = setRef(ref, node);
+      if (!hasCleanup && typeof cleanup == "function") {
+        hasCleanup = true;
+      }
+      return cleanup;
+    });
+    if (hasCleanup) {
+      return () => {
+        for (let i = 0; i < cleanups.length; i++) {
+          const cleanup = cleanups[i];
+          if (typeof cleanup == "function") {
+            cleanup();
+          } else {
+            setRef(refs[i], null);
+          }
+        }
+      };
     }
   };
-  const changeValue = () => {
-    if (disabled) {
-      return;
+}
+function useComposedRefs(...refs) {
+  return React2.useCallback(composeRefs(...refs), refs);
+}
+
+// node_modules/@radix-ui/react-context/dist/index.mjs
+import * as React3 from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+function createContextScope(scopeName, createContextScopeDeps = []) {
+  let defaultContexts = [];
+  function createContext3(rootComponentName, defaultContext) {
+    const BaseContext = React3.createContext(defaultContext);
+    const index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    const Provider = (props) => {
+      const { scope, children, ...context } = props;
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const value = React3.useMemo(() => context, Object.values(context));
+      return /* @__PURE__ */ jsx10(Context.Provider, { value, children });
+    };
+    Provider.displayName = rootComponentName + "Provider";
+    function useContext22(consumerName, scope) {
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const context = React3.useContext(Context);
+      if (context) return context;
+      if (defaultContext !== void 0) return defaultContext;
+      throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
     }
-    const newValue = checked === "indeterminate" ? false : !checked;
-    propagateChange(newValue);
+    return [Provider, useContext22];
+  }
+  const createScope = () => {
+    const scopeContexts = defaultContexts.map((defaultContext) => {
+      return React3.createContext(defaultContext);
+    });
+    return function useScope(scope) {
+      const contexts = scope?.[scopeName] || scopeContexts;
+      return React3.useMemo(
+        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
+        [scope, contexts]
+      );
+    };
   };
-  return /* @__PURE__ */ jsxs4(
-    "div",
-    {
-      className: clsx5("group flex-row-2 items-center", {
-        "cursor-pointer": !disabled,
-        "cursor-not-allowed": disabled
-      }, containerClassName),
-      onClick: changeValue,
-      children: [
-        /* @__PURE__ */ jsx6(
-          CheckboxPrimitive.Root,
-          {
-            onCheckedChange: propagateChange,
-            checked,
-            disabled,
-            id,
-            className: clsx5(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__ */ jsxs4(CheckboxPrimitive.Indicator, { children: [
-              checked === true && /* @__PURE__ */ jsx6(Check, { className: innerIconSize }),
-              checked === "indeterminate" && /* @__PURE__ */ jsx6(Minus, { className: innerIconSize })
-            ] })
-          }
-        ),
-        label && /* @__PURE__ */ jsx6(
-          Label,
-          {
-            ...label,
-            className: clsx5(
-              label.className,
-              {
-                "cursor-pointer": !disabled,
-                "cursor-not-allowed": disabled
-              }
-            ),
-            htmlFor: id
-          }
-        )
-      ]
+  createScope.scopeName = scopeName;
+  return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];
+}
+function composeContextScopes(...scopes) {
+  const baseScope = scopes[0];
+  if (scopes.length === 1) return baseScope;
+  const createScope = () => {
+    const scopeHooks = scopes.map((createScope2) => ({
+      useScope: createScope2(),
+      scopeName: createScope2.scopeName
+    }));
+    return function useComposedScopes(overrideScopes) {
+      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
+        const scopeProps = useScope(overrideScopes);
+        const currentScope = scopeProps[`__scope${scopeName}`];
+        return { ...nextScopes2, ...currentScope };
+      }, {});
+      return React3.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
+    };
+  };
+  createScope.scopeName = baseScope.scopeName;
+  return createScope;
+}
+
+// node_modules/@radix-ui/primitive/dist/index.mjs
+function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+  return function handleEvent(event) {
+    originalEventHandler?.(event);
+    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
+      return ourEventHandler?.(event);
     }
-  );
-};
+  };
+}
 
-// src/components/table/TableFilterButton.tsx
-import { FilterIcon } from "lucide-react";
+// node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
+import * as React5 from "react";
 
-// src/components/user-action/Menu.tsx
-import { useEffect as useEffect8, useRef as useRef2, useState as useState8 } from "react";
-import clsx6 from "clsx";
+// node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs
+import * as React4 from "react";
+var useLayoutEffect2 = globalThis?.document ? React4.useLayoutEffect : () => {
+};
 
-// src/hooks/useOutsideClick.ts
-import { useEffect as useEffect6 } from "react";
-var useOutsideClick = (refs, handler) => {
-  useEffect6(() => {
-    const listener = (event) => {
-      if (event.target === null) return;
-      if (refs.some((ref) => !ref.current || ref.current.contains(event.target))) {
-        return;
+// node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
+import * as React22 from "react";
+var useInsertionEffect = React5[" useInsertionEffect ".trim().toString()] || useLayoutEffect2;
+function useControllableState({
+  prop,
+  defaultProp,
+  onChange = () => {
+  },
+  caller
+}) {
+  const [uncontrolledProp, setUncontrolledProp, onChangeRef] = useUncontrolledState({
+    defaultProp,
+    onChange
+  });
+  const isControlled = prop !== void 0;
+  const value = isControlled ? prop : uncontrolledProp;
+  if (true) {
+    const isControlledRef = React5.useRef(prop !== void 0);
+    React5.useEffect(() => {
+      const wasControlled = isControlledRef.current;
+      if (wasControlled !== isControlled) {
+        const from = wasControlled ? "controlled" : "uncontrolled";
+        const to = isControlled ? "controlled" : "uncontrolled";
+        console.warn(
+          `${caller} is changing from ${from} to ${to}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
+        );
       }
-      handler();
-    };
-    document.addEventListener("mousedown", listener);
-    document.addEventListener("touchstart", listener);
-    return () => {
-      document.removeEventListener("mousedown", listener);
-      document.removeEventListener("touchstart", listener);
-    };
-  }, [refs, handler]);
-};
+      isControlledRef.current = isControlled;
+    }, [isControlled, caller]);
+  }
+  const setValue = React5.useCallback(
+    (nextValue) => {
+      if (isControlled) {
+        const value2 = isFunction(nextValue) ? nextValue(prop) : nextValue;
+        if (value2 !== prop) {
+          onChangeRef.current?.(value2);
+        }
+      } else {
+        setUncontrolledProp(nextValue);
+      }
+    },
+    [isControlled, prop, setUncontrolledProp, onChangeRef]
+  );
+  return [value, setValue];
+}
+function useUncontrolledState({
+  defaultProp,
+  onChange
+}) {
+  const [value, setValue] = React5.useState(defaultProp);
+  const prevValueRef = React5.useRef(value);
+  const onChangeRef = React5.useRef(onChange);
+  useInsertionEffect(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+  React5.useEffect(() => {
+    if (prevValueRef.current !== value) {
+      onChangeRef.current?.(value);
+      prevValueRef.current = value;
+    }
+  }, [value, prevValueRef]);
+  return [value, setValue, onChangeRef];
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+var SYNC_STATE = Symbol("RADIX:SYNC_STATE");
 
-// src/hooks/useHoverState.ts
-import { useEffect as useEffect7, useState as useState7 } from "react";
-var defaultUseHoverStateProps = {
-  closingDelay: 200,
-  isDisabled: false
+// node_modules/@radix-ui/react-use-previous/dist/index.mjs
+import * as React6 from "react";
+function usePrevious(value) {
+  const ref = React6.useRef({ value, previous: value });
+  return React6.useMemo(() => {
+    if (ref.current.value !== value) {
+      ref.current.previous = ref.current.value;
+      ref.current.value = value;
+    }
+    return ref.current.previous;
+  }, [value]);
+}
+
+// node_modules/@radix-ui/react-use-size/dist/index.mjs
+import * as React7 from "react";
+function useSize(element) {
+  const [size, setSize] = React7.useState(void 0);
+  useLayoutEffect2(() => {
+    if (element) {
+      setSize({ width: element.offsetWidth, height: element.offsetHeight });
+      const resizeObserver = new ResizeObserver((entries) => {
+        if (!Array.isArray(entries)) {
+          return;
+        }
+        if (!entries.length) {
+          return;
+        }
+        const entry = entries[0];
+        let width;
+        let height;
+        if ("borderBoxSize" in entry) {
+          const borderSizeEntry = entry["borderBoxSize"];
+          const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
+          width = borderSize["inlineSize"];
+          height = borderSize["blockSize"];
+        } else {
+          width = element.offsetWidth;
+          height = element.offsetHeight;
+        }
+        setSize({ width, height });
+      });
+      resizeObserver.observe(element, { box: "border-box" });
+      return () => resizeObserver.unobserve(element);
+    } else {
+      setSize(void 0);
+    }
+  }, [element]);
+  return size;
+}
+
+// node_modules/@radix-ui/react-presence/dist/index.mjs
+import * as React23 from "react";
+import * as React8 from "react";
+function useStateMachine(initialState, machine) {
+  return React8.useReducer((state, event) => {
+    const nextState = machine[state][event];
+    return nextState ?? state;
+  }, initialState);
+}
+var Presence = (props) => {
+  const { present, children } = props;
+  const presence = usePresence(present);
+  const child = typeof children === "function" ? children({ present: presence.isPresent }) : React23.Children.only(children);
+  const ref = useComposedRefs(presence.ref, getElementRef(child));
+  const forceMount = typeof children === "function";
+  return forceMount || presence.isPresent ? React23.cloneElement(child, { ref }) : null;
 };
-var useHoverState = (props = void 0) => {
-  const { closingDelay, isDisabled } = { ...defaultUseHoverStateProps, ...props };
-  const [isHovered, setIsHovered] = useState7(false);
-  const [timer, setTimer] = useState7();
-  const onMouseEnter = () => {
-    if (isDisabled) {
-      return;
+Presence.displayName = "Presence";
+function usePresence(present) {
+  const [node, setNode] = React23.useState();
+  const stylesRef = React23.useRef(null);
+  const prevPresentRef = React23.useRef(present);
+  const prevAnimationNameRef = React23.useRef("none");
+  const initialState = present ? "mounted" : "unmounted";
+  const [state, send] = useStateMachine(initialState, {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: {
+      MOUNT: "mounted"
     }
-    clearTimeout(timer);
-    setIsHovered(true);
-  };
-  const onMouseLeave = () => {
-    if (isDisabled) {
-      return;
+  });
+  React23.useEffect(() => {
+    const currentAnimationName = getAnimationName(stylesRef.current);
+    prevAnimationNameRef.current = state === "mounted" ? currentAnimationName : "none";
+  }, [state]);
+  useLayoutEffect2(() => {
+    const styles = stylesRef.current;
+    const wasPresent = prevPresentRef.current;
+    const hasPresentChanged = wasPresent !== present;
+    if (hasPresentChanged) {
+      const prevAnimationName = prevAnimationNameRef.current;
+      const currentAnimationName = getAnimationName(styles);
+      if (present) {
+        send("MOUNT");
+      } else if (currentAnimationName === "none" || styles?.display === "none") {
+        send("UNMOUNT");
+      } else {
+        const isAnimating = prevAnimationName !== currentAnimationName;
+        if (wasPresent && isAnimating) {
+          send("ANIMATION_OUT");
+        } else {
+          send("UNMOUNT");
+        }
+      }
+      prevPresentRef.current = present;
     }
-    setTimer(setTimeout(() => {
-      setIsHovered(false);
-    }, closingDelay));
-  };
-  useEffect7(() => {
-    if (timer) {
+  }, [present, send]);
+  useLayoutEffect2(() => {
+    if (node) {
+      let timeoutId;
+      const ownerWindow = node.ownerDocument.defaultView ?? window;
+      const handleAnimationEnd = (event) => {
+        const currentAnimationName = getAnimationName(stylesRef.current);
+        const isCurrentAnimation = currentAnimationName.includes(event.animationName);
+        if (event.target === node && isCurrentAnimation) {
+          send("ANIMATION_END");
+          if (!prevPresentRef.current) {
+            const currentFillMode = node.style.animationFillMode;
+            node.style.animationFillMode = "forwards";
+            timeoutId = ownerWindow.setTimeout(() => {
+              if (node.style.animationFillMode === "forwards") {
+                node.style.animationFillMode = currentFillMode;
+              }
+            });
+          }
+        }
+      };
+      const handleAnimationStart = (event) => {
+        if (event.target === node) {
+          prevAnimationNameRef.current = getAnimationName(stylesRef.current);
+        }
+      };
+      node.addEventListener("animationstart", handleAnimationStart);
+      node.addEventListener("animationcancel", handleAnimationEnd);
+      node.addEventListener("animationend", handleAnimationEnd);
       return () => {
-        clearTimeout(timer);
+        ownerWindow.clearTimeout(timeoutId);
+        node.removeEventListener("animationstart", handleAnimationStart);
+        node.removeEventListener("animationcancel", handleAnimationEnd);
+        node.removeEventListener("animationend", handleAnimationEnd);
       };
+    } else {
+      send("ANIMATION_END");
     }
-  });
-  useEffect7(() => {
-    if (timer) {
-      clearTimeout(timer);
-    }
-  }, [isDisabled]);
+  }, [node, send]);
   return {
-    isHovered,
-    setIsHovered,
-    handlers: { onMouseEnter, onMouseLeave }
+    isPresent: ["mounted", "unmountSuspended"].includes(state),
+    ref: React23.useCallback((node2) => {
+      stylesRef.current = node2 ? getComputedStyle(node2) : null;
+      setNode(node2);
+    }, [])
   };
-};
-
-// 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 {};
+}
+function getAnimationName(styles) {
+  return styles?.animationName || "none";
+}
+function getElementRef(element) {
+  let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.ref;
   }
-  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 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;
+  getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.props.ref;
   }
-  return scrollables;
+  return element.props.ref || element.ref;
 }
-var Menu = ({
-  trigger,
-  children,
-  alignmentHorizontal = "leftInside",
-  alignmentVertical = "bottomOutside",
-  showOnHover = false,
-  disabled = false,
-  menuClassName = ""
-}) => {
-  const { isHovered: isOpen, setIsHovered: setIsOpen } = useHoverState({ isDisabled: !showOnHover || disabled });
-  const triggerRef = useRef2(null);
-  const menuRef = useRef2(null);
-  useOutsideClick([triggerRef, menuRef], () => setIsOpen(false));
-  const [isHidden, setIsHidden] = useState8(true);
-  const bag = {
-    isOpen,
-    close: () => setIsOpen(false),
-    toggleOpen: () => setIsOpen((prevState) => !prevState),
-    disabled
-  };
-  const menuPosition = usePopoverPosition(
-    triggerRef.current?.getBoundingClientRect(),
-    { verticalAlignment: alignmentVertical, horizontalAlignment: alignmentHorizontal, disabled }
-  );
-  useEffect8(() => {
-    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);
+
+// node_modules/@radix-ui/react-primitive/dist/index.mjs
+import * as React10 from "react";
+import * as ReactDOM from "react-dom";
+
+// node_modules/@radix-ui/react-slot/dist/index.mjs
+import * as React9 from "react";
+import { Fragment as Fragment22, jsx as jsx11 } from "react/jsx-runtime";
+// @__NO_SIDE_EFFECTS__
+function createSlot(ownerName) {
+  const SlotClone = /* @__PURE__ */ createSlotClone(ownerName);
+  const Slot2 = React9.forwardRef((props, forwardedRef) => {
+    const { children, ...slotProps } = props;
+    const childrenArray = React9.Children.toArray(children);
+    const slottable = childrenArray.find(isSlottable);
+    if (slottable) {
+      const newElement = slottable.props.children;
+      const newChildren = childrenArray.map((child) => {
+        if (child === slottable) {
+          if (React9.Children.count(newElement) > 1) return React9.Children.only(null);
+          return React9.isValidElement(newElement) ? newElement.props.children : null;
+        } else {
+          return child;
+        }
       });
-      window.removeEventListener("resize", close);
-    };
-  }, [isOpen, setIsOpen]);
-  useEffect8(() => {
-    if (isOpen) {
-      setIsHidden(false);
+      return /* @__PURE__ */ jsx11(SlotClone, { ...slotProps, ref: forwardedRef, children: React9.isValidElement(newElement) ? React9.cloneElement(newElement, void 0, newChildren) : null });
+    }
+    return /* @__PURE__ */ jsx11(SlotClone, { ...slotProps, ref: forwardedRef, children });
+  });
+  Slot2.displayName = `${ownerName}.Slot`;
+  return Slot2;
+}
+// @__NO_SIDE_EFFECTS__
+function createSlotClone(ownerName) {
+  const SlotClone = React9.forwardRef((props, forwardedRef) => {
+    const { children, ...slotProps } = props;
+    if (React9.isValidElement(children)) {
+      const childrenRef = getElementRef2(children);
+      const props2 = mergeProps(slotProps, children.props);
+      if (children.type !== React9.Fragment) {
+        props2.ref = forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef;
+      }
+      return React9.cloneElement(children, props2);
     }
-  }, [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)
+    return React9.Children.count(children) > 1 ? React9.Children.only(null) : null;
+  });
+  SlotClone.displayName = `${ownerName}.SlotClone`;
+  return SlotClone;
+}
+var SLOTTABLE_IDENTIFIER = Symbol("radix.slottable");
+function isSlottable(child) {
+  return React9.isValidElement(child) && typeof child.type === "function" && "__radixId" in child.type && child.type.__radixId === SLOTTABLE_IDENTIFIER;
+}
+function mergeProps(slotProps, childProps) {
+  const overrideProps = { ...childProps };
+  for (const propName in childProps) {
+    const slotPropValue = slotProps[propName];
+    const childPropValue = childProps[propName];
+    const isHandler = /^on[A-Z]/.test(propName);
+    if (isHandler) {
+      if (slotPropValue && childPropValue) {
+        overrideProps[propName] = (...args) => {
+          const result = childPropValue(...args);
+          slotPropValue(...args);
+          return result;
+        };
+      } else if (slotPropValue) {
+        overrideProps[propName] = slotPropValue;
       }
-    ), document.body)
-  ] });
-};
-
-// src/components/table/TableFilterButton.tsx
-import { useEffect as useEffect9, useState as useState9 } from "react";
-import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
-var defaultTableFilterTranslation = {
-  en: {
-    filter: "Filter",
-    min: "Min",
-    max: "Max",
-    startDate: "Start",
-    endDate: "End",
-    text: "Text..."
-  },
-  de: {
-    filter: "Filter",
-    min: "Min",
-    max: "Max",
-    startDate: "Start",
-    endDate: "Ende",
-    text: "Text..."
+    } else if (propName === "style") {
+      overrideProps[propName] = { ...slotPropValue, ...childPropValue };
+    } else if (propName === "className") {
+      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+    }
   }
-};
-var TableFilterButton = ({
-  filterType,
-  column
-}) => {
-  const translation = useTranslation([formTranslation, defaultTableFilterTranslation]);
-  const columnFilterValue = column.getFilterValue();
-  const [filterValue, setFilterValue] = useState9(columnFilterValue);
-  const hasFilter = !!filterValue;
-  useEffect9(() => {
-    setFilterValue(columnFilterValue);
-  }, [columnFilterValue]);
-  return /* @__PURE__ */ jsx8(
-    Menu,
+  return { ...slotProps, ...overrideProps };
+}
+function getElementRef2(element) {
+  let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.ref;
+  }
+  getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.props.ref;
+  }
+  return element.props.ref || element.ref;
+}
+
+// node_modules/@radix-ui/react-primitive/dist/index.mjs
+import { jsx as jsx12 } from "react/jsx-runtime";
+var NODES = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "select",
+  "span",
+  "svg",
+  "ul"
+];
+var Primitive = NODES.reduce((primitive, node) => {
+  const Slot = createSlot(`Primitive.${node}`);
+  const Node = React10.forwardRef((props, forwardedRef) => {
+    const { asChild, ...primitiveProps } = props;
+    const Comp = asChild ? Slot : node;
+    if (typeof window !== "undefined") {
+      window[Symbol.for("radix-ui")] = true;
+    }
+    return /* @__PURE__ */ jsx12(Comp, { ...primitiveProps, ref: forwardedRef });
+  });
+  Node.displayName = `Primitive.${node}`;
+  return { ...primitive, [node]: Node };
+}, {});
+
+// node_modules/@radix-ui/react-checkbox/dist/index.mjs
+import { Fragment as Fragment4, jsx as jsx13, jsxs as jsxs5 } from "react/jsx-runtime";
+var CHECKBOX_NAME = "Checkbox";
+var [createCheckboxContext, createCheckboxScope] = createContextScope(CHECKBOX_NAME);
+var [CheckboxProviderImpl, useCheckboxContext] = createCheckboxContext(CHECKBOX_NAME);
+function CheckboxProvider(props) {
+  const {
+    __scopeCheckbox,
+    checked: checkedProp,
+    children,
+    defaultChecked,
+    disabled,
+    form,
+    name,
+    onCheckedChange,
+    required,
+    value = "on",
+    // @ts-expect-error
+    internal_do_not_use_render
+  } = props;
+  const [checked, setChecked] = useControllableState({
+    prop: checkedProp,
+    defaultProp: defaultChecked ?? false,
+    onChange: onCheckedChange,
+    caller: CHECKBOX_NAME
+  });
+  const [control, setControl] = React11.useState(null);
+  const [bubbleInput, setBubbleInput] = React11.useState(null);
+  const hasConsumerStoppedPropagationRef = React11.useRef(false);
+  const isFormControl = control ? !!form || !!control.closest("form") : (
+    // We set this to true by default so that events bubble to forms without JS (SSR)
+    true
+  );
+  const context = {
+    checked,
+    disabled,
+    setChecked,
+    control,
+    setControl,
+    name,
+    form,
+    value,
+    hasConsumerStoppedPropagationRef,
+    required,
+    defaultChecked: isIndeterminate(defaultChecked) ? false : defaultChecked,
+    isFormControl,
+    bubbleInput,
+    setBubbleInput
+  };
+  return /* @__PURE__ */ jsx13(
+    CheckboxProviderImpl,
     {
-      trigger: ({ toggleOpen }, ref) => /* @__PURE__ */ jsxs6("div", { ref, className: "relative", children: [
-        /* @__PURE__ */ jsx8(IconButton, { color: "neutral", size: "tiny", onClick: toggleOpen, children: /* @__PURE__ */ jsx8(FilterIcon, {}) }),
-        hasFilter && /* @__PURE__ */ jsx8(
-          "div",
-          {
-            className: "absolute top-0.5 right-0.5 w-2 h-2 rounded-full bg-primary pointer-events-none",
-            "aria-hidden": true
-          }
-        )
-      ] }),
-      children: ({ close }) => /* @__PURE__ */ jsxs6("div", { className: "flex-col-1 p-2 items-start font-normal text-menu-text", children: [
-        /* @__PURE__ */ jsx8("h4", { className: "textstyle-title-sm", children: translation("filter") }),
-        filterType === "text" && /* @__PURE__ */ jsx8(
-          Input,
-          {
-            value: filterValue ?? "",
-            autoFocus: true,
-            placeholder: translation("text"),
-            onChangeText: setFilterValue,
-            className: "h-10"
+      scope: __scopeCheckbox,
+      ...context,
+      children: isFunction2(internal_do_not_use_render) ? internal_do_not_use_render(context) : children
+    }
+  );
+}
+var TRIGGER_NAME = "CheckboxTrigger";
+var CheckboxTrigger = React11.forwardRef(
+  ({ __scopeCheckbox, onKeyDown, onClick, ...checkboxProps }, forwardedRef) => {
+    const {
+      control,
+      value,
+      disabled,
+      checked,
+      required,
+      setControl,
+      setChecked,
+      hasConsumerStoppedPropagationRef,
+      isFormControl,
+      bubbleInput
+    } = useCheckboxContext(TRIGGER_NAME, __scopeCheckbox);
+    const composedRefs = useComposedRefs(forwardedRef, setControl);
+    const initialCheckedStateRef = React11.useRef(checked);
+    React11.useEffect(() => {
+      const form = control?.form;
+      if (form) {
+        const reset = () => setChecked(initialCheckedStateRef.current);
+        form.addEventListener("reset", reset);
+        return () => form.removeEventListener("reset", reset);
+      }
+    }, [control, setChecked]);
+    return /* @__PURE__ */ jsx13(
+      Primitive.button,
+      {
+        type: "button",
+        role: "checkbox",
+        "aria-checked": isIndeterminate(checked) ? "mixed" : checked,
+        "aria-required": required,
+        "data-state": getState(checked),
+        "data-disabled": disabled ? "" : void 0,
+        disabled,
+        value,
+        ...checkboxProps,
+        ref: composedRefs,
+        onKeyDown: composeEventHandlers(onKeyDown, (event) => {
+          if (event.key === "Enter") event.preventDefault();
+        }),
+        onClick: composeEventHandlers(onClick, (event) => {
+          setChecked((prevChecked) => isIndeterminate(prevChecked) ? true : !prevChecked);
+          if (bubbleInput && isFormControl) {
+            hasConsumerStoppedPropagationRef.current = event.isPropagationStopped();
+            if (!hasConsumerStoppedPropagationRef.current) event.stopPropagation();
           }
-        ),
-        filterType === "range" && /* @__PURE__ */ jsxs6("div", { className: "flex-row-2 items-center", children: [
-          /* @__PURE__ */ jsx8(
-            Input,
-            {
-              value: filterValue?.[0] ?? "",
-              type: "number",
-              placeholder: translation("min"),
-              onChangeText: (text) => {
-                const num = Number(text);
-                setFilterValue((old) => [num, old?.[1]]);
-              },
-              className: "h-10 input-indicator-hidden w-40"
-            }
-          ),
-          /* @__PURE__ */ jsx8("span", { className: "font-bold", children: "-" }),
-          /* @__PURE__ */ jsx8(
-            Input,
-            {
-              value: filterValue?.[1] ?? "",
-              type: "number",
-              placeholder: translation("max"),
-              onChangeText: (text) => {
-                const num = Number(text);
-                setFilterValue((old) => [old?.[0], num]);
-              },
-              className: "h-10 input-indicator-hidden w-40"
-            }
-          )
-        ] }),
-        filterType === "dateRange" && /* @__PURE__ */ jsxs6(Fragment2, { children: [
-          /* @__PURE__ */ jsx8(
-            Input,
+        })
+      }
+    );
+  }
+);
+CheckboxTrigger.displayName = TRIGGER_NAME;
+var Checkbox = React11.forwardRef(
+  (props, forwardedRef) => {
+    const {
+      __scopeCheckbox,
+      name,
+      checked,
+      defaultChecked,
+      required,
+      disabled,
+      value,
+      onCheckedChange,
+      form,
+      ...checkboxProps
+    } = props;
+    return /* @__PURE__ */ jsx13(
+      CheckboxProvider,
+      {
+        __scopeCheckbox,
+        checked,
+        defaultChecked,
+        disabled,
+        required,
+        onCheckedChange,
+        name,
+        form,
+        value,
+        internal_do_not_use_render: ({ isFormControl }) => /* @__PURE__ */ jsxs5(Fragment4, { children: [
+          /* @__PURE__ */ jsx13(
+            CheckboxTrigger,
             {
-              value: filterValue?.[0] ? filterValue?.[0].toISOString().slice(0, 16) : "",
-              type: "datetime-local",
-              placeholder: translation("startDate"),
-              onChangeText: (text) => {
-                const value = new Date(text);
-                setFilterValue((old) => [value, old?.[1]]);
-              },
-              className: "h-10 w-50"
+              ...checkboxProps,
+              ref: forwardedRef,
+              __scopeCheckbox
             }
           ),
-          /* @__PURE__ */ jsx8(
-            Input,
+          isFormControl && /* @__PURE__ */ jsx13(
+            CheckboxBubbleInput,
             {
-              value: filterValue?.[1] ? filterValue?.[1].toISOString().slice(0, 16) : "",
-              type: "datetime-local",
-              placeholder: translation("endDate"),
-              onChangeText: (text) => {
-                const value = new Date(text);
-                setFilterValue((old) => [old?.[0], value]);
-              },
-              className: "h-10 w-50"
+              __scopeCheckbox
             }
           )
-        ] }),
-        /* @__PURE__ */ jsxs6("div", { className: "flex-row-2 justify-end w-full", children: [
-          hasFilter && /* @__PURE__ */ jsx8(SolidButton, { color: "negative", size: "small", onClick: () => {
-            column.setFilterValue(void 0);
-            close();
-          }, children: translation("remove") }),
-          /* @__PURE__ */ jsx8(SolidButton, { size: "small", onClick: () => {
-            column.setFilterValue(filterValue);
-            close();
-          }, children: translation("apply") })
         ] })
-      ] })
-    }
-  );
-};
-
-// src/components/table/TableSortButton.tsx
-import { ChevronDown, ChevronsUpDown, ChevronUp } from "lucide-react";
-import clsx7 from "clsx";
-import { jsx as jsx9 } from "react/jsx-runtime";
-var TableSortButton = ({
-  sortDirection,
-  invert = false,
-  color = "neutral",
-  className,
-  ...buttonProps
-}) => {
-  let icon = /* @__PURE__ */ jsx9(ChevronsUpDown, { className: "w-full h-full" });
-  if (sortDirection) {
-    let usedSortDirection = sortDirection;
-    if (invert) {
-      usedSortDirection = usedSortDirection === "desc" ? "asc" : "desc";
-    }
-    icon = usedSortDirection === "asc" ? /* @__PURE__ */ jsx9(ChevronUp, { className: "w-full h-full" }) : /* @__PURE__ */ jsx9(ChevronDown, { className: "w-full h-full" });
+      }
+    );
   }
-  return /* @__PURE__ */ jsx9(
-    IconButton,
-    {
-      size: "tiny",
-      color,
-      className: clsx7(className),
-      ...buttonProps,
-      children: icon
-    }
-  );
-};
-
-// src/components/table/FillerRowElement.tsx
-import { clsx as clsx8 } from "clsx";
-import { jsx as jsx10 } from "react/jsx-runtime";
-var FillerRowElement = ({
-  className
-}) => {
-  return /* @__PURE__ */ jsx10("div", { className: clsx8("flex flex-row items-center w-1/2 h-4 text-disabled-text font-bold", className), children: "-" });
-};
+);
+Checkbox.displayName = CHECKBOX_NAME;
+var INDICATOR_NAME = "CheckboxIndicator";
+var CheckboxIndicator = React11.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeCheckbox, forceMount, ...indicatorProps } = props;
+    const context = useCheckboxContext(INDICATOR_NAME, __scopeCheckbox);
+    return /* @__PURE__ */ jsx13(
+      Presence,
+      {
+        present: forceMount || isIndeterminate(context.checked) || context.checked === true,
+        children: /* @__PURE__ */ jsx13(
+          Primitive.span,
+          {
+            "data-state": getState(context.checked),
+            "data-disabled": context.disabled ? "" : void 0,
+            ...indicatorProps,
+            ref: forwardedRef,
+            style: { pointerEvents: "none", ...props.style }
+          }
+        )
+      }
+    );
+  }
+);
+CheckboxIndicator.displayName = INDICATOR_NAME;
+var BUBBLE_INPUT_NAME = "CheckboxBubbleInput";
+var CheckboxBubbleInput = React11.forwardRef(
+  ({ __scopeCheckbox, ...props }, forwardedRef) => {
+    const {
+      control,
+      hasConsumerStoppedPropagationRef,
+      checked,
+      defaultChecked,
+      required,
+      disabled,
+      name,
+      value,
+      form,
+      bubbleInput,
+      setBubbleInput
+    } = useCheckboxContext(BUBBLE_INPUT_NAME, __scopeCheckbox);
+    const composedRefs = useComposedRefs(forwardedRef, setBubbleInput);
+    const prevChecked = usePrevious(checked);
+    const controlSize = useSize(control);
+    React11.useEffect(() => {
+      const input = bubbleInput;
+      if (!input) return;
+      const inputProto = window.HTMLInputElement.prototype;
+      const descriptor = Object.getOwnPropertyDescriptor(
+        inputProto,
+        "checked"
+      );
+      const setChecked = descriptor.set;
+      const bubbles = !hasConsumerStoppedPropagationRef.current;
+      if (prevChecked !== checked && setChecked) {
+        const event = new Event("click", { bubbles });
+        input.indeterminate = isIndeterminate(checked);
+        setChecked.call(input, isIndeterminate(checked) ? false : checked);
+        input.dispatchEvent(event);
+      }
+    }, [bubbleInput, prevChecked, checked, hasConsumerStoppedPropagationRef]);
+    const defaultCheckedRef = React11.useRef(isIndeterminate(checked) ? false : checked);
+    return /* @__PURE__ */ jsx13(
+      Primitive.input,
+      {
+        type: "checkbox",
+        "aria-hidden": true,
+        defaultChecked: defaultChecked ?? defaultCheckedRef.current,
+        required,
+        disabled,
+        name,
+        value,
+        form,
+        ...props,
+        tabIndex: -1,
+        ref: composedRefs,
+        style: {
+          ...props.style,
+          ...controlSize,
+          position: "absolute",
+          pointerEvents: "none",
+          opacity: 0,
+          margin: 0,
+          // We transform because the input is absolutely positioned but we have
+          // rendered it **after** the button. This pulls it back to sit on top
+          // of the button.
+          transform: "translateX(-100%)"
+        }
+      }
+    );
+  }
+);
+CheckboxBubbleInput.displayName = BUBBLE_INPUT_NAME;
+function isFunction2(value) {
+  return typeof value === "function";
+}
+function isIndeterminate(checked) {
+  return checked === "indeterminate";
+}
+function getState(checked) {
+  return isIndeterminate(checked) ? "indeterminate" : checked ? "checked" : "unchecked";
+}
 
-// src/components/table/Filter.ts
-var dateRange = (row, columnId, filterValue) => {
-  const [min, max] = filterValue;
-  const value = row.getValue(columnId);
-  const date = value instanceof Date ? value : new Date(value);
-  if (isNaN(date.getTime())) return false;
-  if (min && date < min) return false;
-  if (max && date > max) return false;
-  return true;
-};
-var TableFilters = {
-  dateRange
+// src/components/user-action/Checkbox.tsx
+import { jsx as jsx14, jsxs as jsxs6 } from "react/jsx-runtime";
+var checkboxSizeMapping = {
+  sm: "size-5 border-1",
+  md: "size-6 border-1",
+  lg: "size-8 border-2"
 };
-
-// src/hooks/useResizeCallbackWrapper.ts
-import { useEffect as useEffect10 } from "react";
-var useResizeCallbackWrapper = (callback) => {
-  useEffect10(() => {
-    window.addEventListener("resize", callback);
-    return () => {
-      window.removeEventListener("resize", callback);
-    };
-  }, [callback]);
+var checkboxIconSizeMapping = {
+  sm: "size-4 stroke-3",
+  md: "size-5 stroke-3",
+  lg: "size-7 stroke-3"
 };
-
-// src/components/table/TableCell.tsx
-import { clsx as clsx9 } from "clsx";
-import { jsx as jsx11 } from "react/jsx-runtime";
-var TableCell = ({
-  children,
-  className
+var Checkbox2 = ({
+  disabled,
+  checked = false,
+  indeterminate = false,
+  onChange,
+  size = "md",
+  className = "",
+  ...props
 }) => {
-  return /* @__PURE__ */ jsx11("span", { className: clsx9("block max-w-full overflow-ellipsis truncate", className), children });
+  const usedSizeClass = checkboxSizeMapping[size];
+  const innerIconSize = checkboxIconSizeMapping[size];
+  return /* @__PURE__ */ jsx14(
+    Checkbox,
+    {
+      ...props,
+      disabled,
+      checked: indeterminate ? "indeterminate" : checked,
+      onCheckedChange: onChange,
+      className: clsx8(
+        usedSizeClass,
+        `flex-col-0 items-center justify-center rounded outline-none`,
+        {
+          "text-disabled-text border-disabled-outline bg-disabled-background cursor-not-allowed": disabled,
+          "hover:border-primary": !disabled,
+          "bg-input-background": !disabled && !checked,
+          "bg-primary/30 border-primary text-primary": !disabled && (checked || indeterminate)
+        },
+        className
+      ),
+      children: /* @__PURE__ */ jsxs6(CheckboxIndicator, { children: [
+        !checked && !indeterminate && /* @__PURE__ */ jsx14("div", { className: clsx8("bg-input-background", innerIconSize) }),
+        checked && !indeterminate && /* @__PURE__ */ jsx14(Check, { className: innerIconSize }),
+        indeterminate && /* @__PURE__ */ jsx14(Minus, { className: innerIconSize })
+      ] })
+    }
+  );
 };
 
 // src/components/table/Table.tsx
-import { jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx15, jsxs as jsxs7 } from "react/jsx-runtime";
 var Table = ({
   data,
   fillerRow,
@@ -1268,22 +1894,22 @@ var Table = ({
   columns,
   ...tableOptions
 }) => {
-  const ref = useRef3(null);
-  const tableRef = useRef3(null);
-  const [columnSizing, setColumnSizing] = useState10(columns.reduce((previousValue, currentValue) => {
+  const ref = useRef8(null);
+  const tableRef = useRef8(null);
+  const [columnSizing, setColumnSizing] = useState14(columns.reduce((previousValue, currentValue) => {
     return {
       ...previousValue,
       [currentValue.id]: currentValue.minSize ?? defaultColumn.minSize
     };
   }, {}));
-  const [columnSizingInfo, setColumnSizingInfo] = useState10();
-  const [pagination, setPagination] = useState10({
+  const [columnSizingInfo, setColumnSizingInfo] = useState14();
+  const [pagination, setPagination] = useState14({
     pageSize: 10,
     pageIndex: 0,
     ...initialState?.pagination
   });
-  const [columnFilters, setColumnFilters] = useState10(initialState?.columnFilters);
-  const computedColumnMinWidths = useMemo(() => {
+  const [columnFilters, setColumnFilters] = useState14(initialState?.columnFilters);
+  const computedColumnMinWidths = useMemo4(() => {
     return columns.reduce((previousValue, column) => {
       return {
         ...previousValue,
@@ -1292,7 +1918,7 @@ var Table = ({
       };
     }, {});
   }, [columns, defaultColumn]);
-  const computedColumnMaxWidths = useMemo(() => {
+  const computedColumnMaxWidths = useMemo4(() => {
     return columns.reduce((previousValue, column) => {
       return {
         ...previousValue,
@@ -1300,12 +1926,12 @@ var Table = ({
       };
     }, {});
   }, [columns, defaultColumn]);
-  const tableMinWidth = useMemo(() => {
+  const tableMinWidth = useMemo4(() => {
     return columns.reduce((sum, column) => {
       return sum + computedColumnMinWidths[column.id];
     }, 0);
   }, [columns, computedColumnMinWidths]);
-  const updateColumnSizes = useMemo(() => {
+  const updateColumnSizes = useMemo4(() => {
     return (previous) => {
       const updateSizing = {
         ...columnSizing,
@@ -1313,7 +1939,7 @@ var Table = ({
       };
       const containerWidth = ref.current.offsetWidth;
       columns.forEach((column) => {
-        updateSizing[column.id] = clamp(updateSizing[column.id], computedColumnMinWidths[column.id], computedColumnMaxWidths[column.id] ?? containerWidth);
+        updateSizing[column.id] = clamp(updateSizing[column.id], [computedColumnMinWidths[column.id], computedColumnMaxWidths[column.id] ?? containerWidth]);
       });
       const width = columns.reduce((previousValue, currentValue) => previousValue + updateSizing[currentValue.id], 0);
       if (width > containerWidth) {
@@ -1374,7 +2000,7 @@ var Table = ({
       minSize: 60,
       maxSize: 700,
       cell: ({ cell }) => {
-        return /* @__PURE__ */ jsx12(TableCell, { children: cell.getValue() });
+        return /* @__PURE__ */ jsx15(TableCell, { children: cell.getValue() });
       },
       ...defaultColumn
     },
@@ -1422,18 +2048,18 @@ var Table = ({
     columnResizeMode: "onChange",
     ...tableOptions
   });
-  const [hasInitializedSizing, setHasInitializedSizing] = useState10(false);
-  useEffect11(() => {
+  const [hasInitializedSizing, setHasInitializedSizing] = useState14(false);
+  useEffect15(() => {
     if (!hasInitializedSizing && ref.current) {
       setHasInitializedSizing(true);
       table.setColumnSizing(updateColumnSizes(columnSizing));
     }
   }, [columnSizing, hasInitializedSizing]);
-  useResizeCallbackWrapper(useCallback3(() => {
+  useResizeCallbackWrapper(useCallback6(() => {
     table.setColumnSizing(updateColumnSizes);
   }, [updateColumnSizes]));
   const pageCount = table.getPageCount();
-  useEffect11(() => {
+  useEffect15(() => {
     const totalPages = pageCount;
     if (totalPages === 0) {
       if (pagination.pageIndex !== 0) {
@@ -1449,7 +2075,7 @@ var Table = ({
       }));
     }
   }, [data, pageCount, pagination.pageSize, pagination.pageIndex]);
-  const columnSizeVars = useMemo(() => {
+  const columnSizeVars = useMemo4(() => {
     const headers = table.getFlatHeaders();
     const colSizes = {};
     for (let i = 0; i < headers.length; i++) {
@@ -1459,8 +2085,8 @@ var Table = ({
     }
     return colSizes;
   }, [table.getState().columnSizingInfo, table.getState().columnSizing]);
-  return /* @__PURE__ */ jsxs7("div", { ref, className: clsx10("flex-col-4", className), children: [
-    /* @__PURE__ */ jsx12(
+  return /* @__PURE__ */ jsxs7("div", { ref, className: clsx9("flex-col-4", className), children: [
+    /* @__PURE__ */ jsx15(
       Scrollbars,
       {
         autoHeight: true,
@@ -1470,13 +2096,13 @@ var Table = ({
           "table",
           {
             ref: tableRef,
-            className: clsx10(tableClassName),
+            className: clsx9(tableClassName),
             style: {
               ...columnSizeVars,
               width: Math.floor(Math.max(table.getTotalSize() - columns.length, ref.current?.offsetWidth ?? table.getTotalSize()))
             },
             children: [
-              table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ jsx12("colgroup", { children: headerGroup.headers.map((header) => /* @__PURE__ */ jsx12(
+              table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ jsx15("colgroup", { children: headerGroup.headers.map((header) => /* @__PURE__ */ jsx15(
                 "col",
                 {
                   style: {
@@ -1487,22 +2113,22 @@ var Table = ({
                 },
                 header.id
               )) }, headerGroup.id)),
-              /* @__PURE__ */ jsx12("thead", { children: table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ jsx12("tr", { className: table.options.meta?.headerRowClassName, children: headerGroup.headers.map((header) => {
+              /* @__PURE__ */ jsx15("thead", { children: table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ jsx15("tr", { className: table.options.meta?.headerRowClassName, children: headerGroup.headers.map((header) => {
                 return /* @__PURE__ */ jsxs7(
                   "th",
                   {
                     colSpan: header.colSpan,
-                    className: clsx10("relative group", header.column.columnDef.meta?.className),
+                    className: clsx9("relative group", header.column.columnDef.meta?.className),
                     children: [
-                      /* @__PURE__ */ jsx12("div", { className: "flex-row-2 w-full", children: header.isPlaceholder ? null : /* @__PURE__ */ jsxs7("div", { className: "flex-row-1 items-center", children: [
-                        header.column.getCanSort() && /* @__PURE__ */ jsx12(
+                      /* @__PURE__ */ jsx15("div", { className: "flex-row-2 w-full", children: header.isPlaceholder ? null : /* @__PURE__ */ jsxs7("div", { className: "flex-row-1 items-center", children: [
+                        header.column.getCanSort() && /* @__PURE__ */ jsx15(
                           TableSortButton,
                           {
                             sortDirection: header.column.getIsSorted(),
                             onClick: () => header.column.toggleSorting()
                           }
                         ),
-                        header.column.getCanFilter() && header.column.columnDef.meta?.filterType ? /* @__PURE__ */ jsx12(
+                        header.column.getCanFilter() && header.column.columnDef.meta?.filterType ? /* @__PURE__ */ jsx15(
                           TableFilterButton,
                           {
                             column: header.column,
@@ -1514,7 +2140,7 @@ var Table = ({
                           header.getContext()
                         )
                       ] }) }),
-                      header.column.getCanResize() && /* @__PURE__ */ jsx12(
+                      header.column.getCanResize() && /* @__PURE__ */ jsx15(
                         "div",
                         {
                           onMouseDown: header.getResizeHandler(),
@@ -1535,16 +2161,16 @@ var Table = ({
               }) }, headerGroup.id)) }),
               /* @__PURE__ */ jsxs7("tbody", { children: [
                 table.getRowModel().rows.map((row) => {
-                  return /* @__PURE__ */ jsx12("tr", { onClick: () => onRowClick(row, table), className: table.options.meta?.bodyRowClassName, children: row.getVisibleCells().map((cell) => {
-                    return /* @__PURE__ */ jsx12("td", { children: flexRender(
+                  return /* @__PURE__ */ jsx15("tr", { onClick: () => onRowClick(row, table), className: table.options.meta?.bodyRowClassName, children: row.getVisibleCells().map((cell) => {
+                    return /* @__PURE__ */ jsx15("td", { children: flexRender(
                       cell.column.columnDef.cell,
                       cell.getContext()
                     ) }, cell.id);
                   }) }, row.id);
                 }),
                 range(table.getState().pagination.pageSize - table.getRowModel().rows.length, { allowEmptyRange: true }).map((row, index) => {
-                  return /* @__PURE__ */ jsx12("tr", { children: columns.map((column) => {
-                    return /* @__PURE__ */ jsx12("td", { children: fillerRow ? fillerRow(column.id, table) : /* @__PURE__ */ jsx12(FillerRowElement, {}) }, column.id);
+                  return /* @__PURE__ */ jsx15("tr", { children: columns.map((column) => {
+                    return /* @__PURE__ */ jsx15("td", { children: fillerRow ? fillerRow(column.id, table) : /* @__PURE__ */ jsx15(FillerRowElement, {}) }, column.id);
                   }) }, "filler-row-" + index);
                 })
               ] })
@@ -1553,7 +2179,7 @@ var Table = ({
         )
       }
     ),
-    /* @__PURE__ */ jsx12("div", { className: "flex-row-2 justify-center", children: /* @__PURE__ */ jsx12(
+    /* @__PURE__ */ jsx15("div", { className: "flex-row-2 justify-center", children: /* @__PURE__ */ jsx15(
       Pagination,
       {
         pageIndex: table.getState().pagination.pageIndex,
@@ -1564,11 +2190,11 @@ var Table = ({
   ] });
 };
 var TableUncontrolled = ({ data, ...props }) => {
-  const [usedDate, setUsedData] = useState10(data);
-  useEffect11(() => {
+  const [usedDate, setUsedData] = useState14(data);
+  useEffect15(() => {
     setUsedData(data);
   }, [data]);
-  return /* @__PURE__ */ jsx12(
+  return /* @__PURE__ */ jsx15(
     Table,
     {
       ...props,
@@ -1587,31 +2213,30 @@ var TableWithSelection = ({
   meta,
   ...props
 }) => {
-  const columnsWithSelection = useMemo(() => {
+  const columnsWithSelection = useMemo4(() => {
     return [
       {
         id: selectionRowId,
         header: ({ table }) => {
-          return /* @__PURE__ */ jsx12(
-            Checkbox,
+          return /* @__PURE__ */ jsx15(
+            Checkbox2,
             {
-              checked: table.getIsSomeRowsSelected() ? "indeterminate" : table.getIsAllRowsSelected(),
-              onChangeTristate: (value) => {
+              checked: table.getIsAllRowsSelected(),
+              indeterminate: table.getIsSomeRowsSelected(),
+              onChange: (value) => {
                 const newValue = !!value;
                 table.toggleAllRowsSelected(newValue);
-              },
-              containerClassName: "max-w-6"
+              }
             }
           );
         },
         cell: ({ row }) => {
-          return /* @__PURE__ */ jsx12(
-            Checkbox,
+          return /* @__PURE__ */ jsx15(
+            Checkbox2,
             {
               disabled: !row.getCanSelect(),
               checked: row.getIsSelected(),
-              onChange: row.getToggleSelectedHandler(),
-              containerClassName: "max-w-6"
+              onChange: row.getToggleSelectedHandler()
             }
           );
         },
@@ -1624,15 +2249,15 @@ var TableWithSelection = ({
       ...columns
     ];
   }, [columns, selectionRowId]);
-  return /* @__PURE__ */ jsx12(
+  return /* @__PURE__ */ jsx15(
     Table,
     {
       columns: columnsWithSelection,
       fillerRow: (columnId, table) => {
         if (columnId === selectionRowId) {
-          return /* @__PURE__ */ jsx12(Checkbox, { checked: false, disabled: true, containerClassName: "max-w-6" });
+          return /* @__PURE__ */ jsx15(Checkbox2, { checked: false, disabled: true, className: "max-w-6" });
         }
-        return fillerRow ? fillerRow(columnId, table) : /* @__PURE__ */ jsx12(FillerRowElement, {});
+        return fillerRow ? fillerRow(columnId, table) : /* @__PURE__ */ jsx15(FillerRowElement, {});
       },
       state: {
         rowSelection,
@@ -1646,7 +2271,7 @@ var TableWithSelection = ({
       },
       meta: {
         ...meta,
-        bodyRowClassName: clsx10(
+        bodyRowClassName: clsx9(
           { "cursor-pointer": !disableClickRowClickSelection },
           meta?.bodyRowClassName
         )