@helpwave/hightide 0.1.11 → 0.1.13

package/dist/components/table/Table.js

@@ -0,0 +1,1549 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/table/Table.tsx
+var Table_exports = {};
+__export(Table_exports, {
+  Table: () => Table,
+  TableUncontrolled: () => TableUncontrolled,
+  TableWithSelection: () => TableWithSelection
+});
+module.exports = __toCommonJS(Table_exports);
+var import_react14 = require("react");
+
+// src/components/layout-and-navigation/Pagination.tsx
+var import_lucide_react = require("lucide-react");
+var import_clsx4 = __toESM(require("clsx"));
+
+// src/localization/LanguageProvider.tsx
+var import_react2 = require("react");
+
+// src/hooks/useLocalStorage.ts
+var import_react = require("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
+var import_jsx_runtime = require("react/jsx-runtime");
+var LanguageContext = (0, import_react2.createContext)({
+  language: LanguageUtil.DEFAULT_LANGUAGE,
+  setLanguage: (v) => v
+});
+var useLanguage = () => (0, import_react2.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: {
+    all: "All",
+    apply: "Apply",
+    back: "Back",
+    cancel: "Cancel",
+    change: "Change",
+    clear: "Clear",
+    close: "Close",
+    confirm: "Confirm",
+    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",
+    of: "of",
+    optional: "Optional",
+    pleaseWait: "Please wait...",
+    previous: "Previous",
+    remove: "Remove",
+    required: "Required",
+    reset: "Reset",
+    save: "Save",
+    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: {
+    all: "Alle",
+    apply: "Anwenden",
+    back: "Zur\xFCck",
+    cancel: "Abbrechen",
+    change: "\xC4ndern",
+    clear: "L\xF6schen",
+    close: "Schlie\xDFen",
+    confirm: "Best\xE4tigen",
+    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",
+    of: "von",
+    optional: "Optional",
+    pleaseWait: "Bitte warten...",
+    previous: "Vorherige",
+    remove: "Entfernen",
+    required: "Erforderlich",
+    reset: "Zur\xFCcksetzen",
+    save: "Speichern",
+    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/user-action/Input.tsx
+var import_react6 = require("react");
+var import_clsx2 = __toESM(require("clsx"));
+
+// src/hooks/useDelay.ts
+var import_react3 = require("react");
+var defaultOptions = {
+  delay: 3e3,
+  disabled: false
+};
+function useDelay(options) {
+  const [timer, setTimer] = (0, import_react3.useState)(void 0);
+  const { delay, disabled } = {
+    ...defaultOptions,
+    ...options
+  };
+  const restartTimer = (onDelayFinish) => {
+    if (disabled) {
+      return;
+    }
+    clearTimeout(timer);
+    setTimer(setTimeout(() => {
+      onDelayFinish();
+    }, delay));
+  };
+  const clearTimer = () => {
+    clearTimeout(timer);
+  };
+  (0, import_react3.useEffect)(() => {
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [timer]);
+  (0, import_react3.useEffect)(() => {
+    if (disabled) {
+      clearTimeout(timer);
+    }
+  }, [disabled, timer]);
+  return { restartTimer, clearTimer };
+}
+
+// src/util/noop.ts
+var noop = () => void 0;
+
+// src/components/user-action/Label.tsx
+var import_clsx = __toESM(require("clsx"));
+var import_jsx_runtime2 = require("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__ */ (0, import_jsx_runtime2.jsx)("label", { ...props, className: (0, import_clsx.default)(styleMapping[labelType], className), children: children ? children : name });
+};
+
+// src/hooks/useFocusManagement.ts
+var import_react4 = require("react");
+function useFocusManagement() {
+  const getFocusableElements = (0, import_react4.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 = (0, import_react4.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 = (0, import_react4.useCallback)(() => {
+    const nextElement = getNextFocusElement();
+    nextElement?.focus();
+  }, [getNextFocusElement]);
+  const getPreviousFocusElement = (0, import_react4.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 = (0, import_react4.useCallback)(() => {
+    const previousElement = getPreviousFocusElement();
+    if (previousElement) previousElement.focus();
+  }, [getPreviousFocusElement]);
+  return {
+    getFocusableElements,
+    getNextFocusElement,
+    getPreviousFocusElement,
+    focusNext,
+    focusPrevious
+  };
+}
+
+// src/hooks/useFocusOnceVisible.ts
+var import_react5 = __toESM(require("react"));
+var useFocusOnceVisible = (ref, disable = false) => {
+  const [hasUsedFocus, setHasUsedFocus] = import_react5.default.useState(false);
+  (0, import_react5.useEffect)(() => {
+    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
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var getInputClassName = ({ disabled = false, hasError = false }) => {
+  return (0, import_clsx2.default)(
+    "px-2 py-1.5 rounded-md border-2",
+    {
+      "bg-surface text-on-surface 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 = (0, import_react6.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 = (0, import_react6.useRef)(null);
+  const { focusNext } = useFocusManagement();
+  useFocusOnceVisible(innerRef, !autoFocus);
+  (0, import_react6.useImperativeHandle)(forwardedRef, () => innerRef.current);
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      innerRef.current?.blur();
+      focusNext();
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: (0, import_clsx2.default)({ "w-full": expanded }, containerClassName), children: [
+    label && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Label, { ...label, htmlFor: id, className: (0, import_clsx2.default)("mb-1", label.className) }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "input",
+      {
+        ...restProps,
+        ref: innerRef,
+        value,
+        id,
+        type,
+        disabled,
+        className: (0, import_clsx2.default)(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 = (0, import_react6.forwardRef)(function FormInput2({
+  id,
+  labelText,
+  errorText,
+  className,
+  labelClassName,
+  errorClassName,
+  containerClassName,
+  required,
+  disabled,
+  ...restProps
+}, ref) {
+  const input = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    "input",
+    {
+      ...restProps,
+      ref,
+      id,
+      disabled,
+      className: (0, import_clsx2.default)(
+        getInputClassName({ disabled, hasError: !!errorText }),
+        className
+      )
+    }
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: (0, import_clsx2.default)("flex flex-col gap-y-1", containerClassName), children: [
+    labelText && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("label", { htmlFor: id, className: (0, import_clsx2.default)("textstyle-label-md", labelClassName), children: [
+      labelText,
+      required && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "text-primary font-bold", children: "*" })
+    ] }),
+    input,
+    errorText && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("label", { htmlFor: id, className: (0, import_clsx2.default)("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
+var import_react7 = require("react");
+
+// src/components/user-action/Button.tsx
+var import_clsx3 = __toESM(require("clsx"));
+var import_jsx_runtime4 = require("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 = ({
+  children,
+  disabled = false,
+  color = "primary",
+  size = "medium",
+  startIcon,
+  endIcon,
+  onClick,
+  className,
+  ...restProps
+}) => {
+  const colorClasses = {
+    primary: "bg-button-solid-primary-background text-button-solid-primary-text",
+    secondary: "bg-button-solid-secondary-background text-button-solid-secondary-text",
+    tertiary: "bg-button-solid-tertiary-background text-button-solid-tertiary-text",
+    positive: "bg-button-solid-positive-background text-button-solid-positive-text",
+    warning: "bg-button-solid-warning-background text-button-solid-warning-text",
+    negative: "bg-button-solid-negative-background text-button-solid-negative-text",
+    neutral: "bg-button-solid-neutral-background text-button-solid-neutral-text"
+  }[color];
+  const iconColorClasses = {
+    primary: "text-button-solid-primary-icon",
+    secondary: "text-button-solid-secondary-icon",
+    tertiary: "text-button-solid-tertiary-icon",
+    positive: "text-button-solid-positive-icon",
+    warning: "text-button-solid-warning-icon",
+    negative: "text-button-solid-negative-icon",
+    neutral: "text-button-solid-neutral-icon"
+  }[color];
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+    "button",
+    {
+      onClick: disabled ? void 0 : onClick,
+      disabled: disabled || onClick === void 0,
+      className: (0, import_clsx3.default)(
+        {
+          "text-disabled-text bg-disabled-background cursor-not-allowed": disabled,
+          [(0, import_clsx3.default)(colorClasses, "hover:brightness-90")]: !disabled
+        },
+        ButtonUtil.paddingMapping[size],
+        className
+      ),
+      ...restProps,
+      children: [
+        startIcon && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          "span",
+          {
+            className: (0, import_clsx3.default)({
+              [iconColorClasses]: !disabled,
+              [`text-disabled-icon`]: disabled
+            }),
+            children: startIcon
+          }
+        ),
+        children,
+        endIcon && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          "span",
+          {
+            className: (0, import_clsx3.default)({
+              [iconColorClasses]: !disabled,
+              [`text-disabled-icon`]: disabled
+            }),
+            children: endIcon
+          }
+        )
+      ]
+    }
+  );
+};
+var IconButton = ({
+  children,
+  disabled = false,
+  color = "primary",
+  size = "medium",
+  onClick,
+  className,
+  ...restProps
+}) => {
+  const colorClasses = {
+    primary: "bg-button-solid-primary-background text-button-solid-primary-text",
+    secondary: "bg-button-solid-secondary-background text-button-solid-secondary-text",
+    tertiary: "bg-button-solid-tertiary-background text-button-solid-tertiary-text",
+    positive: "bg-button-solid-positive-background text-button-solid-positive-text",
+    warning: "bg-button-solid-warning-background text-button-solid-warning-text",
+    negative: "bg-button-solid-negative-background text-button-solid-negative-text",
+    neutral: "bg-button-solid-neutral-background text-button-solid-neutral-text",
+    transparent: "bg-transparent"
+  }[color];
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    "button",
+    {
+      onClick: disabled ? void 0 : onClick,
+      disabled: disabled || onClick === void 0,
+      className: (0, import_clsx3.default)(
+        {
+          "text-disabled-text bg-disabled-background cursor-not-allowed": disabled && color !== "transparent",
+          "text-disabled-text cursor-not-allowed opacity-70": disabled && color === "transparent",
+          "hover:bg-button-text-hover-background": !disabled && color === "transparent",
+          [(0, import_clsx3.default)(colorClasses, "hover:brightness-90")]: !disabled
+        },
+        ButtonUtil.iconPaddingMapping[size],
+        className
+      ),
+      ...restProps,
+      children
+    }
+  );
+};
+
+// src/components/layout-and-navigation/Pagination.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var Pagination = ({
+  overwriteTranslation,
+  pageIndex,
+  pageCount,
+  onPageChanged,
+  className,
+  style
+}) => {
+  const translation = useTranslation([formTranslation], overwriteTranslation);
+  const [value, setValue] = (0, import_react7.useState)((pageIndex + 1).toString());
+  const noPages = pageCount === 0;
+  const onFirstPage = pageIndex === 0 && !noPages;
+  const onLastPage = pageIndex === pageCount - 1;
+  (0, import_react7.useEffect)(() => {
+    if (noPages) {
+      setValue("0");
+    } else {
+      setValue((pageIndex + 1).toString());
+    }
+  }, [pageIndex, noPages]);
+  const changePage = (page) => {
+    onPageChanged(page);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: (0, import_clsx4.default)("row gap-x-1", className), style, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(IconButton, { color: "transparent", onClick: () => changePage(0), disabled: onFirstPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_lucide_react.ChevronFirst, {}) }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(IconButton, { color: "transparent", onClick: () => changePage(pageIndex - 1), disabled: onFirstPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_lucide_react.ChevronLeft, {}) }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: "row min-w-56 gap-x-2 items-center justify-center mx-2 text-center", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+        Input,
+        {
+          value,
+          containerClassName: "flex flex-1 h-10",
+          className: (0, import_clsx4.default)(
+            "w-full text-center font-bold input-indicator-hidden"
+          ),
+          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__ */ (0, import_jsx_runtime5.jsx)("span", { className: "select-none w-10", children: translation("of") }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+        "span",
+        {
+          className: "row flex-1 items-center justify-center select-none h-10 bg-surface text-on-surface rounded-md font-bold",
+          children: pageCount
+        }
+      )
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(IconButton, { color: "transparent", onClick: () => changePage(pageIndex + 1), disabled: onLastPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_lucide_react.ChevronRight, {}) }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(IconButton, { color: "transparent", onClick: () => changePage(pageCount - 1), disabled: onLastPage || noPages, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_lucide_react.ChevronLast, {}) })
+  ] });
+};
+
+// src/components/table/Table.tsx
+var import_clsx10 = __toESM(require("clsx"));
+var import_react_table = require("@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
+var import_react_custom_scrollbars_2 = require("react-custom-scrollbars-2");
+
+// src/components/user-action/Checkbox.tsx
+var import_react8 = require("react");
+var CheckboxPrimitive = __toESM(require("@radix-ui/react-checkbox"));
+var import_lucide_react2 = require("lucide-react");
+var import_clsx5 = __toESM(require("clsx"));
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var checkboxSizeMapping = {
+  small: "size-4",
+  medium: "size-6",
+  large: "size-8"
+};
+var checkboxIconSizeMapping = {
+  small: "size-3",
+  medium: "size-5",
+  large: "size-7"
+};
+var Checkbox = ({
+  id,
+  label,
+  checked,
+  disabled,
+  onChange,
+  onChangeTristate,
+  size = "medium",
+  className = "",
+  containerClassName
+}) => {
+  const usedSizeClass = checkboxSizeMapping[size];
+  const innerIconSize = checkboxIconSizeMapping[size];
+  const propagateChange = (checked2) => {
+    if (onChangeTristate) {
+      onChangeTristate(checked2);
+    }
+    if (onChange) {
+      onChange(checked2 === "indeterminate" ? false : checked2);
+    }
+  };
+  const changeValue = () => {
+    const newValue = checked === "indeterminate" ? false : !checked;
+    propagateChange(newValue);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { className: (0, import_clsx5.default)("row justify-center items-center", containerClassName), children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      CheckboxPrimitive.Root,
+      {
+        onCheckedChange: propagateChange,
+        checked,
+        disabled,
+        id,
+        className: (0, import_clsx5.default)(usedSizeClass, `items-center border-2 rounded outline-none `, {
+          "text-disabled-text border-disabled-outline bg-disabled-background cursor-not-allowed": disabled,
+          "focus:border-primary": !disabled,
+          "bg-surface": !disabled && !checked,
+          "bg-primary/30 border-primary text-primary": !disabled && checked === true || checked === "indeterminate",
+          "hover:border-primary focus:hover:border-primary": !disabled && !checked
+        }, className),
+        children: /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(CheckboxPrimitive.Indicator, { children: [
+          checked === true && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_lucide_react2.Check, { className: innerIconSize }),
+          checked === "indeterminate" && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_lucide_react2.Minus, { className: innerIconSize })
+        ] })
+      }
+    ),
+    label && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      Label,
+      {
+        ...label,
+        className: (0, import_clsx5.default)("cursor-pointer", label.className),
+        htmlFor: id,
+        onClick: changeValue
+      }
+    )
+  ] });
+};
+
+// src/components/table/TableFilterButton.tsx
+var import_lucide_react3 = require("lucide-react");
+
+// src/components/user-action/Menu.tsx
+var import_react11 = require("react");
+var import_clsx6 = __toESM(require("clsx"));
+
+// src/hooks/useOutsideClick.ts
+var import_react9 = require("react");
+var useOutsideClick = (refs, handler) => {
+  (0, import_react9.useEffect)(() => {
+    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
+var import_react10 = require("react");
+var defaultUseHoverStateProps = {
+  closingDelay: 200,
+  isDisabled: false
+};
+var useHoverState = (props = void 0) => {
+  const { closingDelay, isDisabled } = { ...defaultUseHoverStateProps, ...props };
+  const [isHovered, setIsHovered] = (0, import_react10.useState)(false);
+  const [timer, setTimer] = (0, import_react10.useState)();
+  const onMouseEnter = () => {
+    if (isDisabled) {
+      return;
+    }
+    clearTimeout(timer);
+    setIsHovered(true);
+  };
+  const onMouseLeave = () => {
+    if (isDisabled) {
+      return;
+    }
+    setTimer(setTimeout(() => {
+      setIsHovered(false);
+    }, closingDelay));
+  };
+  (0, import_react10.useEffect)(() => {
+    if (timer) {
+      return () => {
+        clearTimeout(timer);
+      };
+    }
+  });
+  (0, import_react10.useEffect)(() => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }, [isDisabled]);
+  return {
+    isHovered,
+    setIsHovered,
+    handlers: { onMouseEnter, onMouseLeave }
+  };
+};
+
+// src/util/PropsWithFunctionChildren.ts
+var resolve = (children, bag) => {
+  if (typeof children === "function") {
+    return children(bag);
+  }
+  return children ?? void 0;
+};
+var BagFunctionUtil = {
+  resolve
+};
+
+// src/components/user-action/Menu.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var Menu = ({
+  trigger,
+  children,
+  alignment = "tl",
+  showOnHover = false,
+  menuClassName = ""
+}) => {
+  const { isHovered: isOpen, setIsHovered: setIsOpen, handlers } = useHoverState({ isDisabled: !showOnHover });
+  const triggerRef = (0, import_react11.useRef)(null);
+  const menuRef = (0, import_react11.useRef)(null);
+  useOutsideClick([triggerRef, menuRef], () => setIsOpen(false));
+  const bag = { isOpen, close: () => setIsOpen(false) };
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+    "div",
+    {
+      className: "relative",
+      ...handlers,
+      children: [
+        trigger(() => setIsOpen(!isOpen), triggerRef),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          "div",
+          {
+            ref: menuRef,
+            onClick: (e) => e.stopPropagation(),
+            className: (0, import_clsx6.default)(
+              "absolute top-full mt-1 min-w-40 rounded-lg bg-menu-background text-menu-text shadow-around-lg z-10",
+              {
+                "top-0": alignment[0] === "t",
+                "bottom-0": alignment[0] === "b",
+                "left-0": alignment[1] === "l",
+                "right-0": alignment[1] === "r",
+                "hidden": !isOpen
+              },
+              menuClassName
+            ),
+            children: BagFunctionUtil.resolve(children, bag)
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/components/table/TableFilterButton.tsx
+var import_react12 = require("react");
+var import_jsx_runtime8 = require("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] = (0, import_react12.useState)(columnFilterValue);
+  const hasFilter = !!filterValue;
+  (0, import_react12.useEffect)(() => {
+    setFilterValue(columnFilterValue);
+  }, [columnFilterValue]);
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    Menu,
+    {
+      trigger: (onClick, ref) => /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { ref, className: "relative", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(IconButton, { color: "neutral", size: "tiny", onClick, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_lucide_react3.FilterIcon, {}) }),
+        hasFilter && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          "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__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "col gap-y-1 p-2 items-start font-normal text-menu-text", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("h4", { className: "textstyle-title-sm", children: translation("filter") }),
+        filterType === "text" && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          Input,
+          {
+            value: filterValue ?? "",
+            autoFocus: true,
+            placeholder: translation("text"),
+            onChangeText: setFilterValue,
+            className: "h-10"
+          }
+        ),
+        filterType === "range" && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "row gap-x-2 items-center", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+            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__ */ (0, import_jsx_runtime8.jsx)("span", { className: "font-bold", children: "-" }),
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+            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__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+            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__ */ (0, import_jsx_runtime8.jsx)(
+            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__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "row justify-end w-full", children: [
+          hasFilter && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SolidButton, { color: "negative", size: "small", onClick: () => {
+            column.setFilterValue(void 0);
+            close();
+          }, children: translation("remove") }),
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SolidButton, { size: "small", onClick: () => {
+            column.setFilterValue(filterValue);
+            close();
+          }, children: translation("apply") })
+        ] })
+      ] })
+    }
+  );
+};
+
+// src/components/table/TableSortButton.tsx
+var import_lucide_react4 = require("lucide-react");
+var import_clsx7 = __toESM(require("clsx"));
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var TableSortButton = ({
+  sortDirection,
+  invert = false,
+  color = "neutral",
+  className,
+  ...buttonProps
+}) => {
+  let icon = /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_lucide_react4.ChevronsUpDown, { className: "w-full h-full" });
+  if (sortDirection) {
+    let usedSortDirection = sortDirection;
+    if (invert) {
+      usedSortDirection = usedSortDirection === "desc" ? "asc" : "desc";
+    }
+    icon = usedSortDirection === "asc" ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_lucide_react4.ChevronUp, { className: "w-full h-full" }) : /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_lucide_react4.ChevronDown, { className: "w-full h-full" });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+    IconButton,
+    {
+      size: "tiny",
+      color,
+      className: (0, import_clsx7.default)(className),
+      ...buttonProps,
+      children: icon
+    }
+  );
+};
+
+// src/components/table/FillerRowElement.tsx
+var import_clsx8 = require("clsx");
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var FillerRowElement = ({
+  className
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: (0, import_clsx8.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/hooks/useResizeCallbackWrapper.ts
+var import_react13 = require("react");
+var useResizeCallbackWrapper = (callback) => {
+  (0, import_react13.useEffect)(() => {
+    window.addEventListener("resize", callback);
+    return () => {
+      window.removeEventListener("resize", callback);
+    };
+  }, [callback]);
+};
+
+// src/components/table/TableCell.tsx
+var import_clsx9 = require("clsx");
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var TableCell = ({
+  children,
+  className
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", { className: (0, import_clsx9.clsx)("block max-w-full overflow-ellipsis truncate", className), children });
+};
+
+// src/components/table/Table.tsx
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var Table = ({
+  data,
+  fillerRow,
+  initialState,
+  onRowClick = noop,
+  className,
+  tableClassName,
+  defaultColumn,
+  state,
+  columns,
+  ...tableOptions
+}) => {
+  const ref = (0, import_react14.useRef)(null);
+  const tableRef = (0, import_react14.useRef)(null);
+  const [columnSizing, setColumnSizing] = (0, import_react14.useState)(columns.reduce((previousValue, currentValue) => {
+    return {
+      ...previousValue,
+      [currentValue.id]: currentValue.minSize ?? defaultColumn.minSize
+    };
+  }, {}));
+  const [columnSizingInfo, setColumnSizingInfo] = (0, import_react14.useState)();
+  const [pagination, setPagination] = (0, import_react14.useState)({
+    pageSize: 10,
+    pageIndex: 0,
+    ...initialState?.pagination
+  });
+  const [columnFilters, setColumnFilters] = (0, import_react14.useState)(initialState?.columnFilters);
+  const computedColumnMinWidths = (0, import_react14.useMemo)(() => {
+    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 = (0, import_react14.useMemo)(() => {
+    return columns.reduce((previousValue, column) => {
+      return {
+        ...previousValue,
+        [column.id]: column.maxSize ?? defaultColumn?.maxSize
+      };
+    }, {});
+  }, [columns, defaultColumn]);
+  const tableMinWidth = (0, import_react14.useMemo)(() => {
+    return columns.reduce((sum, column) => {
+      return sum + computedColumnMinWidths[column.id];
+    }, 0);
+  }, [columns, computedColumnMinWidths]);
+  const updateColumnSizes = (0, import_react14.useMemo)(() => {
+    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 = (0, import_react_table.useReactTable)({
+    data,
+    getCoreRowModel: (0, import_react_table.getCoreRowModel)(),
+    getFilteredRowModel: (0, import_react_table.getFilteredRowModel)(),
+    getSortedRowModel: (0, import_react_table.getSortedRowModel)(),
+    getPaginationRowModel: (0, import_react_table.getPaginationRowModel)(),
+    initialState,
+    defaultColumn: {
+      minSize: 60,
+      maxSize: 700,
+      cell: ({ cell }) => {
+        return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(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] = (0, import_react14.useState)(false);
+  (0, import_react14.useEffect)(() => {
+    if (!hasInitializedSizing && ref.current) {
+      setHasInitializedSizing(true);
+      table.setColumnSizing(updateColumnSizes(columnSizing));
+    }
+  }, [columnSizing, hasInitializedSizing]);
+  useResizeCallbackWrapper((0, import_react14.useCallback)(() => {
+    table.setColumnSizing(updateColumnSizes);
+  }, [updateColumnSizes]));
+  const pageCount = table.getPageCount();
+  (0, import_react14.useEffect)(() => {
+    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 = (0, import_react14.useMemo)(() => {
+    const headers = table.getFlatHeaders();
+    const colSizes = {};
+    for (let i = 0; i < headers.length; i++) {
+      const header = headers[i];
+      colSizes[`--header-${header.id}-size`] = header.getSize();
+      colSizes[`--col-${header.column.id}-size`] = header.column.getSize();
+    }
+    return colSizes;
+  }, [table.getState().columnSizingInfo, table.getState().columnSizing]);
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { ref, className: (0, import_clsx10.default)("col gap-y-4", className), children: [
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_react_custom_scrollbars_2.Scrollbars, { autoHeight: true, autoHeightMax: tableRef.current?.offsetHeight, autoHide: true, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
+      "table",
+      {
+        ref: tableRef,
+        className: (0, import_clsx10.default)(tableClassName),
+        style: {
+          ...columnSizeVars,
+          width: Math.max(table.getTotalSize(), ref.current?.offsetWidth ?? table.getTotalSize())
+        },
+        children: [
+          table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("colgroup", { children: headerGroup.headers.map((header) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+            "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__ */ (0, import_jsx_runtime12.jsx)("thead", { children: table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("tr", { className: table.options.meta?.headerRowClassName, children: headerGroup.headers.map((header) => {
+            return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
+              "th",
+              {
+                colSpan: header.colSpan,
+                className: (0, import_clsx10.default)("relative group", header.column.columnDef.meta?.className),
+                children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { className: "row w-full", children: header.isPlaceholder ? null : /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { className: "row gap-x-1 items-center", children: [
+                    header.column.getCanSort() && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+                      TableSortButton,
+                      {
+                        sortDirection: header.column.getIsSorted(),
+                        onClick: () => header.column.toggleSorting()
+                      }
+                    ),
+                    header.column.getCanFilter() && header.column.columnDef.meta?.filterType ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+                      TableFilterButton,
+                      {
+                        column: header.column,
+                        filterType: header.column.columnDef.meta.filterType
+                      }
+                    ) : null,
+                    (0, import_react_table.flexRender)(
+                      header.column.columnDef.header,
+                      header.getContext()
+                    )
+                  ] }) }),
+                  header.column.getCanResize() && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+                    "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__ */ (0, import_jsx_runtime12.jsxs)("tbody", { children: [
+            table.getRowModel().rows.map((row) => {
+              return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("tr", { onClick: () => onRowClick(row, table), className: table.options.meta?.bodyRowClassName, children: row.getVisibleCells().map((cell) => {
+                return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("td", { children: (0, import_react_table.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__ */ (0, import_jsx_runtime12.jsx)("tr", { children: columns.map((column) => {
+                return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("td", { children: fillerRow ? fillerRow(column.id, table) : /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(FillerRowElement, {}) }, column.id);
+              }) }, "filler-row-" + index);
+            })
+          ] })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { className: "row justify-center", children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+      Pagination,
+      {
+        pageIndex: table.getState().pagination.pageIndex,
+        pageCount: table.getPageCount(),
+        onPageChanged: (page) => table.setPageIndex(page)
+      }
+    ) })
+  ] });
+};
+var TableUncontrolled = ({ data, ...props }) => {
+  const [usedDate, setUsedData] = (0, import_react14.useState)(data);
+  (0, import_react14.useEffect)(() => {
+    setUsedData(data);
+  }, [data]);
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+    Table,
+    {
+      ...props,
+      data: usedDate
+    }
+  );
+};
+var TableWithSelection = ({
+  columns,
+  state,
+  fillerRow,
+  rowSelection,
+  selectionRowId = "selection",
+  onRowClick = noop,
+  meta,
+  ...props
+}) => {
+  const columnsWithSelection = (0, import_react14.useMemo)(() => {
+    return [
+      {
+        id: selectionRowId,
+        header: ({ table }) => {
+          return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+            Checkbox,
+            {
+              checked: table.getIsSomeRowsSelected() ? "indeterminate" : table.getIsAllRowsSelected(),
+              onChangeTristate: (value) => {
+                const newValue = !!value;
+                table.toggleAllRowsSelected(newValue);
+              },
+              containerClassName: "max-w-6"
+            }
+          );
+        },
+        cell: ({ row }) => {
+          return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+            Checkbox,
+            {
+              disabled: !row.getCanSelect(),
+              checked: row.getIsSelected(),
+              onChange: row.getToggleSelectedHandler(),
+              containerClassName: "max-w-6"
+            }
+          );
+        },
+        size: 60,
+        minSize: 60,
+        maxSize: 60,
+        enableResizing: false,
+        enableSorting: false
+      },
+      ...columns
+    ];
+  }, [columns, selectionRowId]);
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+    Table,
+    {
+      columns: columnsWithSelection,
+      fillerRow: (columnId, table) => {
+        if (columnId === selectionRowId) {
+          return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Checkbox, { checked: false, disabled: true, containerClassName: "max-w-6" });
+        }
+        return fillerRow ? fillerRow(columnId, table) : /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(FillerRowElement, {});
+      },
+      state: {
+        rowSelection,
+        ...state
+      },
+      onRowClick: (row, table) => {
+        row.toggleSelected();
+        onRowClick(row, table);
+      },
+      meta: {
+        bodyRowClassName: "cursor-pointer",
+        ...meta
+      },
+      ...props
+    }
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Table,
+  TableUncontrolled,
+  TableWithSelection
+});
+//# sourceMappingURL=Table.js.map