@helpwave/hightide 0.1.27 → 0.1.28

package/dist/components/table/index.mjs

@@ -0,0 +1,2293 @@
+// src/components/table/FillerRowElement.tsx
+import { clsx } from "clsx";
+import { jsx } from "react/jsx-runtime";
+var FillerRowElement = ({
+  className
+}) => {
+  return /* @__PURE__ */ jsx("div", { className: clsx("flex flex-row items-center w-1/2 h-4 text-disabled-text font-bold", 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/components/table/Table.tsx
+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/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 as clsx2 } from "clsx";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var TableCell = ({
+  children,
+  className
+}) => {
+  return /* @__PURE__ */ jsx2("span", { className: clsx2("block max-w-full overflow-ellipsis truncate", className), children });
+};
+
+// 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 clsx3 from "clsx";
+import { jsx as jsx3, 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: 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__ */ jsx3(
+          "span",
+          {
+            className: clsx3(
+              iconColorClasses,
+              "group-disabled:text-disabled-icon"
+            ),
+            children: startIcon
+          }
+        ),
+        children,
+        endIcon && /* @__PURE__ */ jsx3(
+          "span",
+          {
+            className: clsx3(
+              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__ */ jsx3(
+    "button",
+    {
+      ref,
+      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
+    }
+  );
+});
+
+// src/components/table/TableSortButton.tsx
+import clsx4 from "clsx";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var TableSortButton = ({
+  sortDirection,
+  invert = false,
+  color = "neutral",
+  className,
+  ...buttonProps
+}) => {
+  let icon = /* @__PURE__ */ jsx4(ChevronsUpDown, { className: "w-full h-full" });
+  if (sortDirection) {
+    let usedSortDirection = sortDirection;
+    if (invert) {
+      usedSortDirection = usedSortDirection === "desc" ? "asc" : "desc";
+    }
+    icon = usedSortDirection === "asc" ? /* @__PURE__ */ jsx4(ChevronUp, { className: "w-full h-full" }) : /* @__PURE__ */ jsx4(ChevronDown, { className: "w-full h-full" });
+  }
+  return /* @__PURE__ */ jsx4(
+    IconButton,
+    {
+      size: "tiny",
+      color,
+      className: clsx4(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 clsx5 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 jsx5 } 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__ */ jsx5(
+    "input",
+    {
+      ...props,
+      ref: innerRef,
+      value,
+      disabled,
+      className: defaultStyle ? clsx5(
+        "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 clsx6 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 jsx6, 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__ */ jsx6(
+      "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)
+      }
+    ), document.body)
+  ] });
+};
+
+// src/localization/LanguageProvider.tsx
+import { createContext, useContext, useEffect as useEffect7, useState as useState6 } from "react";
+
+// src/hooks/useLocalStorage.ts
+import { useCallback as useCallback2, useState as useState5 } from "react";
+
+// src/localization/util.ts
+var languages = ["en", "de"];
+var languagesLocalNames = {
+  en: "English",
+  de: "Deutsch"
+};
+var DEFAULT_LANGUAGE = "en";
+var LanguageUtil = {
+  languages,
+  DEFAULT_LANGUAGE,
+  languagesLocalNames
+};
+
+// src/localization/LanguageProvider.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var LanguageContext = createContext({
+  language: LanguageUtil.DEFAULT_LANGUAGE,
+  setLanguage: (v) => v
+});
+var useLanguage = () => useContext(LanguageContext);
+
+// src/localization/useTranslation.ts
+var TranslationPluralCount = {
+  zero: 0,
+  one: 1,
+  two: 2,
+  few: 3,
+  many: 11,
+  other: -1
+};
+var useTranslation = (translations, overwriteTranslation = {}) => {
+  const { language: languageProp, translation: overwrite } = overwriteTranslation;
+  const { language: inferredLanguage } = useLanguage();
+  const usedLanguage = languageProp ?? inferredLanguage;
+  const usedTranslations = [...translations];
+  if (overwrite) {
+    usedTranslations.push(overwrite);
+  }
+  return (key, options) => {
+    const { count, replacements } = { ...{ count: 0, replacements: {} }, ...options };
+    try {
+      for (let i = translations.length - 1; i >= 0; i--) {
+        const translation = translations[i];
+        const localizedTranslation = translation[usedLanguage];
+        if (!localizedTranslation) {
+          continue;
+        }
+        const value = localizedTranslation[key];
+        if (!value) {
+          continue;
+        }
+        let forProcessing;
+        if (typeof value !== "string") {
+          if (count === TranslationPluralCount.zero && value?.zero) {
+            forProcessing = value.zero;
+          } else if (count === TranslationPluralCount.one && value?.one) {
+            forProcessing = value.one;
+          } else if (count === TranslationPluralCount.two && value?.two) {
+            forProcessing = value.two;
+          } else if (TranslationPluralCount.few <= count && count < TranslationPluralCount.many && value?.few) {
+            forProcessing = value.few;
+          } else if (count > TranslationPluralCount.many && value?.many) {
+            forProcessing = value.many;
+          } else {
+            forProcessing = value.other;
+          }
+        } else {
+          forProcessing = value;
+        }
+        forProcessing = forProcessing.replace(/\{\{(\w+)}}/g, (_, placeholder) => {
+          return replacements[placeholder] ?? `{{key:${placeholder}}}`;
+        });
+        return forProcessing;
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    return `{{${usedLanguage}:${key}}}`;
+  };
+};
+
+// src/localization/defaults/form.ts
+var formTranslation = {
+  en: {
+    add: "Add",
+    all: "All",
+    apply: "Apply",
+    back: "Back",
+    cancel: "Cancel",
+    change: "Change",
+    clear: "Clear",
+    click: "Click",
+    clickToCopy: "Click to Copy",
+    close: "Close",
+    confirm: "Confirm",
+    copy: "Copy",
+    copied: "Copied",
+    create: "Create",
+    decline: "Decline",
+    delete: "Delete",
+    discard: "Discard",
+    discardChanges: "Discard Changes",
+    done: "Done",
+    edit: "Edit",
+    enterText: "Enter text here",
+    error: "Error",
+    exit: "Exit",
+    fieldRequiredError: "This field is required.",
+    invalidEmailError: "Please enter a valid email address.",
+    less: "Less",
+    loading: "Loading",
+    maxLengthError: "Maximum length exceeded.",
+    minLengthError: "Minimum length not met.",
+    more: "More",
+    next: "Next",
+    no: "No",
+    none: "None",
+    nothingFound: "Nothing found",
+    of: "of",
+    optional: "Optional",
+    pleaseWait: "Please wait...",
+    previous: "Previous",
+    remove: "Remove",
+    required: "Required",
+    reset: "Reset",
+    save: "Save",
+    saved: "Saved",
+    search: "Search",
+    select: "Select",
+    selectOption: "Select an option",
+    show: "Show",
+    showMore: "Show more",
+    showLess: "Show less",
+    submit: "Submit",
+    success: "Success",
+    update: "Update",
+    unsavedChanges: "Unsaved Changes",
+    unsavedChangesSaveQuestion: "Do you want to save your changes?",
+    yes: "Yes"
+  },
+  de: {
+    add: "Hinzuf\xFCgen",
+    all: "Alle",
+    apply: "Anwenden",
+    back: "Zur\xFCck",
+    cancel: "Abbrechen",
+    change: "\xC4ndern",
+    clear: "L\xF6schen",
+    click: "Klicken",
+    clickToCopy: "Zum kopieren klicken",
+    close: "Schlie\xDFen",
+    confirm: "Best\xE4tigen",
+    copy: "Kopieren",
+    copied: "Kopiert",
+    create: "Erstellen",
+    decline: "Ablehnen",
+    delete: "L\xF6schen",
+    discard: "Verwerfen",
+    discardChanges: "\xC4nderungen Verwerfen",
+    done: "Fertig",
+    edit: "Bearbeiten",
+    enterText: "Text hier eingeben",
+    error: "Fehler",
+    exit: "Beenden",
+    fieldRequiredError: "Dieses Feld ist erforderlich.",
+    invalidEmailError: "Bitte geben Sie eine g\xFCltige E-Mail-Adresse ein.",
+    less: "Weniger",
+    loading: "L\xE4dt",
+    maxLengthError: "Maximale L\xE4nge \xFCberschritten.",
+    minLengthError: "Mindestl\xE4nge nicht erreicht.",
+    more: "Mehr",
+    next: "Weiter",
+    no: "Nein",
+    none: "Nichts",
+    nothingFound: "Nichts gefunden",
+    of: "von",
+    optional: "Optional",
+    pleaseWait: "Bitte warten...",
+    previous: "Vorherige",
+    remove: "Entfernen",
+    required: "Erforderlich",
+    reset: "Zur\xFCcksetzen",
+    save: "Speichern",
+    saved: "Gespeichert",
+    search: "Suche",
+    select: "Select",
+    selectOption: "Option ausw\xE4hlen",
+    show: "Anzeigen",
+    showMore: "Mehr anzeigen",
+    showLess: "Weniger anzeigen",
+    submit: "Abschicken",
+    success: "Erfolg",
+    update: "Update",
+    unsavedChanges: "Ungespeicherte \xC4nderungen",
+    unsavedChangesSaveQuestion: "M\xF6chtest du die \xC4nderungen speichern?",
+    yes: "Ja"
+  }
+};
+
+// src/components/table/TableFilterButton.tsx
+import { useEffect as useEffect8, useState as useState7 } from "react";
+import { Fragment as Fragment2, jsx as jsx8, 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__ */ jsx8(
+    Menu,
+    {
+      trigger: ({ toggleOpen }, ref) => /* @__PURE__ */ jsxs3("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__ */ jsxs3("div", { className: "flex-col-1 p-2 items-start font-normal text-menu-text", children: [
+        /* @__PURE__ */ jsx8("h4", { className: "typography-label-md-semibold", children: translation("filter") }),
+        filterType === "text" && /* @__PURE__ */ jsx8(
+          Input,
+          {
+            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__ */ 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__ */ jsxs3(Fragment2, { children: [
+          /* @__PURE__ */ jsx8(
+            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__ */ jsx8(
+            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__ */ 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/navigation/Pagination.tsx
+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,
+  pageCount,
+  onPageChanged,
+  className,
+  style
+}) => {
+  const translation = useTranslation([formTranslation], overwriteTranslation);
+  const [value, setValue] = useState8((pageIndex + 1).toString());
+  const noPages = pageCount === 0;
+  const onFirstPage = pageIndex === 0 && !noPages;
+  const onLastPage = pageIndex === pageCount - 1;
+  useEffect9(() => {
+    if (noPages) {
+      setValue("0");
+    } else {
+      setValue((pageIndex + 1).toString());
+    }
+  }, [pageIndex, noPages]);
+  const changePage = (page) => {
+    onPageChanged(page);
+  };
+  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,
+          className: clsx7(
+            "w-full text-center font-bold input-indicator-hidden h-10"
+          ),
+          type: "number",
+          min: 1,
+          max: pageCount,
+          disabled: noPages,
+          onChangeText: (value2) => {
+            if (value2) {
+              setValue(clamp(Number(value2), [1, pageCount]).toString());
+            } else {
+              setValue(value2);
+            }
+          },
+          onEditCompleted: (value2) => {
+            changePage(clamp(Number(value2) - 1, [0, pageCount - 1]));
+          },
+          editCompleteOptions: { delay: 800 }
+        }
+      ),
+      /* @__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",
+          children: pageCount
+        }
+      )
+    ] }),
+    /* @__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/user-action/Checkbox.tsx
+import { useEffect as useEffect14, useState as useState13 } from "react";
+import { Check, Minus } from "lucide-react";
+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);
+          }
+        }
+      };
+    }
+  };
+}
+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}\``);
+    }
+    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]
+      );
+    };
+  };
+  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);
+    }
+  };
+}
+
+// node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
+import * as React5 from "react";
+
+// node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs
+import * as React4 from "react";
+var useLayoutEffect2 = globalThis?.document ? React4.useLayoutEffect : () => {
+};
+
+// 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.`
+        );
+      }
+      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");
+
+// 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;
+};
+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"
+    }
+  });
+  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;
+    }
+  }, [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 () => {
+        ownerWindow.clearTimeout(timeoutId);
+        node.removeEventListener("animationstart", handleAnimationStart);
+        node.removeEventListener("animationcancel", handleAnimationEnd);
+        node.removeEventListener("animationend", handleAnimationEnd);
+      };
+    } else {
+      send("ANIMATION_END");
+    }
+  }, [node, send]);
+  return {
+    isPresent: ["mounted", "unmountSuspended"].includes(state),
+    ref: React23.useCallback((node2) => {
+      stylesRef.current = node2 ? getComputedStyle(node2) : null;
+      setNode(node2);
+    }, [])
+  };
+}
+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;
+  }
+  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 * 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;
+        }
+      });
+      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);
+    }
+    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;
+      }
+    } else if (propName === "style") {
+      overrideProps[propName] = { ...slotPropValue, ...childPropValue };
+    } else if (propName === "className") {
+      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+    }
+  }
+  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,
+    {
+      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();
+          }
+        })
+      }
+    );
+  }
+);
+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,
+            {
+              ...checkboxProps,
+              ref: forwardedRef,
+              __scopeCheckbox
+            }
+          ),
+          isFormControl && /* @__PURE__ */ jsx13(
+            CheckboxBubbleInput,
+            {
+              __scopeCheckbox
+            }
+          )
+        ] })
+      }
+    );
+  }
+);
+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/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"
+};
+var checkboxIconSizeMapping = {
+  sm: "size-4 stroke-3",
+  md: "size-5 stroke-3",
+  lg: "size-7 stroke-3"
+};
+var Checkbox2 = ({
+  disabled,
+  checked = false,
+  indeterminate = false,
+  onChange,
+  size = "md",
+  className = "",
+  ...props
+}) => {
+  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 jsx15, jsxs as jsxs7 } from "react/jsx-runtime";
+var Table = ({
+  data,
+  fillerRow,
+  initialState,
+  onRowClick = noop,
+  className,
+  tableClassName,
+  defaultColumn,
+  state,
+  columns,
+  ...tableOptions
+}) => {
+  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] = useState14();
+  const [pagination, setPagination] = useState14({
+    pageSize: 10,
+    pageIndex: 0,
+    ...initialState?.pagination
+  });
+  const [columnFilters, setColumnFilters] = useState14(initialState?.columnFilters);
+  const computedColumnMinWidths = useMemo4(() => {
+    return columns.reduce((previousValue, column) => {
+      return {
+        ...previousValue,
+        // every column is at least 12px wide
+        [column.id]: column.minSize ?? defaultColumn?.minSize ?? 12
+      };
+    }, {});
+  }, [columns, defaultColumn]);
+  const computedColumnMaxWidths = useMemo4(() => {
+    return columns.reduce((previousValue, column) => {
+      return {
+        ...previousValue,
+        [column.id]: column.maxSize ?? defaultColumn?.maxSize
+      };
+    }, {});
+  }, [columns, defaultColumn]);
+  const tableMinWidth = useMemo4(() => {
+    return columns.reduce((sum, column) => {
+      return sum + computedColumnMinWidths[column.id];
+    }, 0);
+  }, [columns, computedColumnMinWidths]);
+  const updateColumnSizes = useMemo4(() => {
+    return (previous) => {
+      const updateSizing = {
+        ...columnSizing,
+        ...previous
+      };
+      const containerWidth = ref.current.offsetWidth;
+      columns.forEach((column) => {
+        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) {
+        if (tableMinWidth >= containerWidth) {
+          return columns.reduce((previousValue, currentValue) => ({
+            ...previousValue,
+            [currentValue.id]: computedColumnMinWidths[currentValue.id]
+          }), {});
+        }
+        let reduceableColumns = columns.map((value) => value.id).filter((id) => updateSizing[id] - computedColumnMinWidths[id] > 0);
+        let spaceToReduce = width - containerWidth;
+        while (spaceToReduce > 0 && reduceableColumns.length > 0) {
+          let maxReduceAmount = reduceableColumns.reduce((previousValue, id) => Math.max(previousValue, updateSizing[id] - computedColumnMinWidths[id]), 0);
+          if (maxReduceAmount * reduceableColumns.length > spaceToReduce) {
+            maxReduceAmount = spaceToReduce / reduceableColumns.length;
+          }
+          reduceableColumns.forEach((id) => {
+            updateSizing[id] -= maxReduceAmount;
+          });
+          spaceToReduce -= maxReduceAmount * reduceableColumns.length;
+          reduceableColumns = reduceableColumns.filter((id) => updateSizing[id] - computedColumnMinWidths[id] > 0);
+        }
+      } else if (width <= containerWidth) {
+        let distributableWidth = containerWidth - width;
+        const violatingColumns = columns.filter((value) => computedColumnMaxWidths[value.id] && updateSizing[value.id] > computedColumnMaxWidths[value.id]);
+        const violationColumnsAmount = violatingColumns.reduce(
+          (previousValue, column) => previousValue + updateSizing[column.id] - computedColumnMaxWidths[column.id],
+          0
+        );
+        distributableWidth += violationColumnsAmount;
+        let enlargeableColumns = columns.filter((col) => !computedColumnMaxWidths[col.id] || updateSizing[col.id] < computedColumnMaxWidths[col.id]).map((value) => value.id);
+        while (distributableWidth > 0 && enlargeableColumns.length > 0) {
+          let minEnlargeableAmount = enlargeableColumns.reduce((previousValue, id) => Math.min(previousValue, computedColumnMaxWidths[id] ? computedColumnMaxWidths[id] - updateSizing[id] : distributableWidth), distributableWidth);
+          if (minEnlargeableAmount * enlargeableColumns.length > distributableWidth) {
+            minEnlargeableAmount = distributableWidth / enlargeableColumns.length;
+          }
+          enlargeableColumns.forEach((id) => {
+            updateSizing[id] += minEnlargeableAmount;
+          });
+          distributableWidth -= minEnlargeableAmount * enlargeableColumns.length;
+          enlargeableColumns = enlargeableColumns.filter((id) => !computedColumnMaxWidths[id] || updateSizing[id] < computedColumnMaxWidths[id]);
+        }
+        if (distributableWidth > 0) {
+          updateSizing[columns[columns.length - 1].id] += distributableWidth;
+        }
+      }
+      return updateSizing;
+    };
+  }, [columns, computedColumnMaxWidths, computedColumnMinWidths, tableMinWidth]);
+  const table = useReactTable({
+    data,
+    getCoreRowModel: getCoreRowModel(),
+    getFilteredRowModel: getFilteredRowModel(),
+    getSortedRowModel: getSortedRowModel(),
+    getPaginationRowModel: getPaginationRowModel(),
+    initialState,
+    defaultColumn: {
+      minSize: 60,
+      maxSize: 700,
+      cell: ({ cell }) => {
+        return /* @__PURE__ */ jsx15(TableCell, { children: cell.getValue() });
+      },
+      ...defaultColumn
+    },
+    columns,
+    state: {
+      columnSizing,
+      columnSizingInfo,
+      pagination,
+      columnFilters,
+      ...state
+    },
+    filterFns: {
+      ...tableOptions?.filterFns,
+      dateRange: TableFilters.dateRange
+    },
+    onColumnSizingInfoChange: (updaterOrValue) => {
+      setColumnSizingInfo(updaterOrValue);
+      if (tableOptions.onColumnSizingInfoChange) {
+        tableOptions?.onColumnSizingInfoChange(updaterOrValue);
+      }
+    },
+    onColumnSizingChange: (updaterOrValue) => {
+      setColumnSizing((previous) => {
+        const newSizing = typeof updaterOrValue === "function" ? updaterOrValue(previous) : updaterOrValue;
+        return updateColumnSizes(newSizing);
+      });
+      if (tableOptions.onColumnSizingChange) {
+        tableOptions.onColumnSizingChange(updaterOrValue);
+      }
+    },
+    onPaginationChange: (updaterOrValue) => {
+      setPagination(updaterOrValue);
+      if (tableOptions.onPaginationChange) {
+        tableOptions.onPaginationChange(updaterOrValue);
+      }
+    },
+    onColumnFiltersChange: (updaterOrValue) => {
+      setColumnFilters(updaterOrValue);
+      table.toggleAllRowsSelected(false);
+      if (tableOptions.onColumnFiltersChange) {
+        tableOptions.onColumnFiltersChange(updaterOrValue);
+      }
+    },
+    autoResetPageIndex: false,
+    columnResizeMode: "onChange",
+    ...tableOptions
+  });
+  const [hasInitializedSizing, setHasInitializedSizing] = useState14(false);
+  useEffect15(() => {
+    if (!hasInitializedSizing && ref.current) {
+      setHasInitializedSizing(true);
+      table.setColumnSizing(updateColumnSizes(columnSizing));
+    }
+  }, [columnSizing, hasInitializedSizing]);
+  useResizeCallbackWrapper(useCallback6(() => {
+    table.setColumnSizing(updateColumnSizes);
+  }, [updateColumnSizes]));
+  const pageCount = table.getPageCount();
+  useEffect15(() => {
+    const totalPages = pageCount;
+    if (totalPages === 0) {
+      if (pagination.pageIndex !== 0) {
+        table.setPagination((prevState) => ({
+          ...prevState,
+          pageIndex: 0
+        }));
+      }
+    } else if (pagination.pageIndex >= totalPages) {
+      table.setPagination((prev) => ({
+        ...prev,
+        pageIndex: totalPages - 1
+      }));
+    }
+  }, [data, pageCount, pagination.pageSize, pagination.pageIndex]);
+  const columnSizeVars = useMemo4(() => {
+    const headers = table.getFlatHeaders();
+    const colSizes = {};
+    for (let i = 0; i < headers.length; i++) {
+      const header = headers[i];
+      colSizes[`--header-${header.id}-size`] = Math.floor(header.getSize());
+      colSizes[`--col-${header.column.id}-size`] = Math.floor(header.column.getSize());
+    }
+    return colSizes;
+  }, [table.getState().columnSizingInfo, table.getState().columnSizing]);
+  return /* @__PURE__ */ jsxs7("div", { ref, className: clsx9("flex-col-4", className), children: [
+    /* @__PURE__ */ jsx15(
+      Scrollbars,
+      {
+        autoHeight: true,
+        autoHeightMax: tableRef.current?.offsetHeight ? tableRef.current?.offsetHeight + 2 : void 0,
+        autoHide: true,
+        children: /* @__PURE__ */ jsxs7(
+          "table",
+          {
+            ref: tableRef,
+            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__ */ jsx15("colgroup", { children: headerGroup.headers.map((header) => /* @__PURE__ */ jsx15(
+                "col",
+                {
+                  style: {
+                    width: `calc(var(--header-${header?.id}-size) * 1px)`,
+                    minWidth: header.column.columnDef.minSize,
+                    maxWidth: header.column.columnDef.maxSize
+                  }
+                },
+                header.id
+              )) }, headerGroup.id)),
+              /* @__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: clsx9("relative group", header.column.columnDef.meta?.className),
+                    children: [
+                      /* @__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__ */ jsx15(
+                          TableFilterButton,
+                          {
+                            column: header.column,
+                            filterType: header.column.columnDef.meta.filterType
+                          }
+                        ) : null,
+                        flexRender(
+                          header.column.columnDef.header,
+                          header.getContext()
+                        )
+                      ] }) }),
+                      header.column.getCanResize() && /* @__PURE__ */ jsx15(
+                        "div",
+                        {
+                          onMouseDown: header.getResizeHandler(),
+                          onTouchStart: header.getResizeHandler(),
+                          onDoubleClick: () => {
+                            header.column.resetSize();
+                          },
+                          className: "table-resize-indicator w-2 rounded bg-primary cursor-col-resize select-none touch-none opacity-0 group-hover:opacity-100 transition-opacity",
+                          style: {
+                            opacity: !columnSizingInfo?.columnSizingStart ? void 0 : columnSizingInfo?.columnSizingStart?.findIndex(([id, _]) => id === header.column.id) !== -1 ? 1 : columnSizingInfo?.columnSizingStart?.length !== 0 ? 0 : void 0
+                          }
+                        }
+                      )
+                    ]
+                  },
+                  header.id
+                );
+              }) }, headerGroup.id)) }),
+              /* @__PURE__ */ jsxs7("tbody", { children: [
+                table.getRowModel().rows.map((row) => {
+                  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__ */ jsx15("tr", { children: columns.map((column) => {
+                    return /* @__PURE__ */ jsx15("td", { children: fillerRow ? fillerRow(column.id, table) : /* @__PURE__ */ jsx15(FillerRowElement, {}) }, column.id);
+                  }) }, "filler-row-" + index);
+                })
+              ] })
+            ]
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx15("div", { className: "flex-row-2 justify-center", children: /* @__PURE__ */ jsx15(
+      Pagination,
+      {
+        pageIndex: table.getState().pagination.pageIndex,
+        pageCount: table.getPageCount(),
+        onPageChanged: (page) => table.setPageIndex(page)
+      }
+    ) })
+  ] });
+};
+var TableUncontrolled = ({ data, ...props }) => {
+  const [usedDate, setUsedData] = useState14(data);
+  useEffect15(() => {
+    setUsedData(data);
+  }, [data]);
+  return /* @__PURE__ */ jsx15(
+    Table,
+    {
+      ...props,
+      data: usedDate
+    }
+  );
+};
+var TableWithSelection = ({
+  columns,
+  state,
+  fillerRow,
+  rowSelection,
+  disableClickRowClickSelection = false,
+  selectionRowId = "selection",
+  onRowClick = noop,
+  meta,
+  ...props
+}) => {
+  const columnsWithSelection = useMemo4(() => {
+    return [
+      {
+        id: selectionRowId,
+        header: ({ table }) => {
+          return /* @__PURE__ */ jsx15(
+            Checkbox2,
+            {
+              checked: table.getIsAllRowsSelected(),
+              indeterminate: table.getIsSomeRowsSelected(),
+              onChange: (value) => {
+                const newValue = !!value;
+                table.toggleAllRowsSelected(newValue);
+              }
+            }
+          );
+        },
+        cell: ({ row }) => {
+          return /* @__PURE__ */ jsx15(
+            Checkbox2,
+            {
+              disabled: !row.getCanSelect(),
+              checked: row.getIsSelected(),
+              onChange: row.getToggleSelectedHandler()
+            }
+          );
+        },
+        size: 60,
+        minSize: 60,
+        maxSize: 60,
+        enableResizing: false,
+        enableSorting: false
+      },
+      ...columns
+    ];
+  }, [columns, selectionRowId]);
+  return /* @__PURE__ */ jsx15(
+    Table,
+    {
+      columns: columnsWithSelection,
+      fillerRow: (columnId, table) => {
+        if (columnId === selectionRowId) {
+          return /* @__PURE__ */ jsx15(Checkbox2, { checked: false, disabled: true, className: "max-w-6" });
+        }
+        return fillerRow ? fillerRow(columnId, table) : /* @__PURE__ */ jsx15(FillerRowElement, {});
+      },
+      state: {
+        rowSelection,
+        ...state
+      },
+      onRowClick: (row, table) => {
+        if (!disableClickRowClickSelection) {
+          row.toggleSelected();
+        }
+        onRowClick(row, table);
+      },
+      meta: {
+        ...meta,
+        bodyRowClassName: clsx9(
+          { "cursor-pointer": !disableClickRowClickSelection },
+          meta?.bodyRowClassName
+        )
+      },
+      ...props
+    }
+  );
+};
+export {
+  FillerRowElement,
+  Table,
+  TableCell,
+  TableFilterButton,
+  TableFilters,
+  TableSortButton,
+  TableUncontrolled,
+  TableWithSelection
+};
+//# sourceMappingURL=index.mjs.map