@omnitron-dev/prism 0.3.1 → 0.3.3

package/dist/chunk-F6RZ7LW6.js

@@ -0,0 +1,1271 @@
+import { TableViewport, isRowActionTarget } from './chunk-2KG2NI73.js';
+import { SearchInput } from './chunk-CT46KJOR.js';
+import { FilterIcon, EmptyIcon } from './chunk-VQVVHMPG.js';
+import { useCallback, useState, useMemo, useTransition, useRef, useEffect, Fragment as Fragment$1 } from 'react';
+import Stack from '@mui/material/Stack';
+import TextField2 from '@mui/material/TextField';
+import Chip from '@mui/material/Chip';
+import MenuItem from '@mui/material/MenuItem';
+import Box2 from '@mui/material/Box';
+import Button from '@mui/material/Button';
+import Typography2 from '@mui/material/Typography';
+import Badge from '@mui/material/Badge';
+import { styled, alpha } from '@mui/material/styles';
+import dayjs from 'dayjs';
+import InputAdornment from '@mui/material/InputAdornment';
+import IconButton from '@mui/material/IconButton';
+import Dialog from '@mui/material/Dialog';
+import DialogTitle from '@mui/material/DialogTitle';
+import DialogActions from '@mui/material/DialogActions';
+import DialogContent from '@mui/material/DialogContent';
+import useMediaQuery from '@mui/material/useMediaQuery';
+import FormHelperText from '@mui/material/FormHelperText';
+import { DatePicker } from '@mui/x-date-pickers/DatePicker';
+import { DateCalendar, dateCalendarClasses } from '@mui/x-date-pickers/DateCalendar';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import MuiTable from '@mui/material/Table';
+import TableBody from '@mui/material/TableBody';
+import TableCell from '@mui/material/TableCell';
+import TableHead from '@mui/material/TableHead';
+import TableRow from '@mui/material/TableRow';
+import TableSortLabel from '@mui/material/TableSortLabel';
+import TablePagination from '@mui/material/TablePagination';
+import Paper from '@mui/material/Paper';
+import Checkbox from '@mui/material/Checkbox';
+import Skeleton from '@mui/material/Skeleton';
+
+function DateRangePicker({
+  open,
+  error,
+  onClose,
+  onSubmit,
+  startDate,
+  endDate,
+  onChangeStartDate,
+  onChangeEndDate,
+  slotProps,
+  variant = "input",
+  title,
+  translations,
+  // Exclude hook props that shouldn't go to Dialog
+  selected: _selected,
+  label: _label,
+  shortLabel: _shortLabel,
+  onOpen: _onOpen,
+  onReset: _onReset,
+  setStartDate: _setStartDate,
+  setEndDate: _setEndDate,
+  ...other
+}) {
+  const txTitle = translations?.title ?? title ?? "Select date range";
+  const txStart = translations?.startDate ?? "Start date";
+  const txEnd = translations?.endDate ?? "End date";
+  const txErrorRange = translations?.errorRange ?? "End date cannot be earlier than start date";
+  const txCancel = translations?.cancel ?? "Cancel";
+  const txApply = translations?.apply ?? "Apply";
+  const mdUp = useMediaQuery((theme) => theme.breakpoints.up("md"));
+  const isCalendarView = mdUp && variant === "calendar";
+  const handleSubmit = useCallback(() => {
+    onClose({}, "backdropClick");
+    onSubmit?.();
+  }, [onClose, onSubmit]);
+  const handleClose = useCallback(() => {
+    onClose({}, "backdropClick");
+  }, [onClose]);
+  const dialogPaperSx = slotProps?.paper?.sx;
+  return /* @__PURE__ */ jsxs(
+    Dialog,
+    {
+      fullWidth: true,
+      open,
+      onClose,
+      maxWidth: isCalendarView ? false : "xs",
+      slotProps: {
+        ...slotProps,
+        paper: {
+          ...slotProps?.paper,
+          sx: [
+            { ...isCalendarView && { maxWidth: 720 } },
+            ...Array.isArray(dialogPaperSx) ? dialogPaperSx : dialogPaperSx ? [dialogPaperSx] : []
+          ]
+        }
+      },
+      ...other,
+      children: [
+        /* @__PURE__ */ jsx(DialogTitle, { children: txTitle }),
+        /* @__PURE__ */ jsxs(
+          DialogContent,
+          {
+            sx: [
+              (theme) => ({
+                gap: 3,
+                display: "flex",
+                overflow: "unset",
+                flexDirection: isCalendarView ? "row" : "column",
+                [`& .${dateCalendarClasses.root}`]: {
+                  borderRadius: 2,
+                  border: `dashed 1px ${theme.palette.divider}`
+                }
+              })
+            ],
+            children: [
+              isCalendarView ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsx(DateCalendar, { value: startDate, onChange: onChangeStartDate }),
+                /* @__PURE__ */ jsx(DateCalendar, { value: endDate, onChange: onChangeEndDate })
+              ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsx(DatePicker, { label: txStart, value: startDate, onChange: onChangeStartDate }),
+                /* @__PURE__ */ jsx(DatePicker, { label: txEnd, value: endDate, onChange: onChangeEndDate })
+              ] }),
+              error && /* @__PURE__ */ jsx(FormHelperText, { error: true, sx: { px: 2 }, children: txErrorRange })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(DialogActions, { children: [
+          /* @__PURE__ */ jsx(Button, { variant: "outlined", color: "inherit", onClick: handleClose, children: txCancel }),
+          /* @__PURE__ */ jsx(Button, { disabled: error, variant: "contained", onClick: handleSubmit, children: txApply })
+        ] })
+      ]
+    }
+  );
+}
+function CalendarIcon() {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "18",
+      height: "18",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx("rect", { x: "3", y: "4", width: "18", height: "18", rx: "2", ry: "2" }),
+        /* @__PURE__ */ jsx("line", { x1: "16", y1: "2", x2: "16", y2: "6" }),
+        /* @__PURE__ */ jsx("line", { x1: "8", y1: "2", x2: "8", y2: "6" }),
+        /* @__PURE__ */ jsx("line", { x1: "3", y1: "10", x2: "21", y2: "10" })
+      ]
+    }
+  );
+}
+function ClearIcon() {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "14",
+      height: "14",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+        /* @__PURE__ */ jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+      ]
+    }
+  );
+}
+function toDayjs(value) {
+  if (!value) return null;
+  const d = dayjs(value);
+  return d.isValid() ? d : null;
+}
+function toIso(value) {
+  if (!value || !value.isValid()) return "";
+  return value.format("YYYY-MM-DD");
+}
+function formatLabel(start, end, fromPrefix, toPrefix) {
+  if (!start && !end) return "";
+  const s = toDayjs(start);
+  const e = toDayjs(end);
+  if (s && e) {
+    if (s.isSame(e, "day")) return e.format("DD MMM YYYY");
+    if (s.isSame(e, "month")) return `${s.format("DD")} \u2013 ${e.format("DD MMM YYYY")}`;
+    if (s.isSame(e, "year")) return `${s.format("DD MMM")} \u2013 ${e.format("DD MMM YYYY")}`;
+    return `${s.format("DD MMM YYYY")} \u2013 ${e.format("DD MMM YYYY")}`;
+  }
+  if (s) return `${fromPrefix} ${s.format("DD MMM YYYY")}`;
+  if (e) return `${toPrefix} ${e.format("DD MMM YYYY")}`;
+  return "";
+}
+function DateRangeInput({
+  label = "Date range",
+  startDate,
+  endDate,
+  onChange,
+  width = 220,
+  variant = "input",
+  size = "small",
+  translations,
+  pickerTranslations
+}) {
+  const [open, setOpen] = useState(false);
+  const [tempStart, setTempStart] = useState(toDayjs(startDate));
+  const [tempEnd, setTempEnd] = useState(toDayjs(endDate));
+  const txPlaceholder = translations?.placeholder ?? "Select dates...";
+  const txFrom = translations?.from ?? "From";
+  const txTo = translations?.to ?? "To";
+  const txClear = translations?.clear ?? "Clear date range";
+  const displayLabel = useMemo(
+    () => formatLabel(startDate, endDate, txFrom, txTo),
+    [startDate, endDate, txFrom, txTo]
+  );
+  const hasValue = !!startDate || !!endDate;
+  const handleOpen = useCallback(() => {
+    setTempStart(toDayjs(startDate));
+    setTempEnd(toDayjs(endDate));
+    setOpen(true);
+  }, [startDate, endDate]);
+  const handleClose = useCallback(() => {
+    setOpen(false);
+  }, []);
+  const handleSubmit = useCallback(() => {
+    onChange(toIso(tempStart), toIso(tempEnd));
+    setOpen(false);
+  }, [tempStart, tempEnd, onChange]);
+  const handleClear = useCallback(
+    (e) => {
+      e.stopPropagation();
+      onChange("", "");
+    },
+    [onChange]
+  );
+  const error = !!(tempStart && tempEnd && tempStart.isAfter(tempEnd));
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      TextField2,
+      {
+        size,
+        label,
+        value: displayLabel,
+        placeholder: txPlaceholder,
+        onClick: handleOpen,
+        slotProps: {
+          input: {
+            readOnly: true,
+            sx: { cursor: "pointer" },
+            startAdornment: /* @__PURE__ */ jsx(InputAdornment, { position: "start", sx: { color: "text.disabled" }, children: /* @__PURE__ */ jsx(CalendarIcon, {}) }),
+            ...hasValue && {
+              endAdornment: /* @__PURE__ */ jsx(InputAdornment, { position: "end", children: /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: handleClear, "aria-label": txClear, sx: { p: 0.25 }, children: /* @__PURE__ */ jsx(ClearIcon, {}) }) })
+            }
+          },
+          inputLabel: { shrink: true }
+        },
+        sx: {
+          minWidth: width,
+          "& .MuiOutlinedInput-root": { borderRadius: 1 },
+          "& .MuiInputBase-input": { cursor: "pointer" }
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      DateRangePicker,
+      {
+        open,
+        error,
+        onClose: handleClose,
+        onSubmit: handleSubmit,
+        startDate: tempStart,
+        endDate: tempEnd,
+        onChangeStartDate: setTempStart,
+        onChangeEndDate: setTempEnd,
+        variant,
+        translations: pickerTranslations,
+        selected: !!(tempStart && tempEnd),
+        label: "",
+        shortLabel: "",
+        onOpen: handleOpen,
+        onReset: () => {
+          setTempStart(null);
+          setTempEnd(null);
+        },
+        setStartDate: setTempStart,
+        setEndDate: setTempEnd
+      }
+    )
+  ] });
+}
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(() => setDebouncedValue(value), delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debouncedValue;
+}
+function isFilterActive(config, values) {
+  if (config.type === "date-range") return !!(values[`${config.key}From`] || values[`${config.key}To`]);
+  if (config.type === "number-range") {
+    return ["Min", "Max"].some((suffix) => {
+      const end = values[`${config.key}${suffix}`];
+      return end !== void 0 && end !== null && end !== "";
+    });
+  }
+  const value = values[config.key];
+  if (value === void 0 || value === null || value === "") return false;
+  if (Array.isArray(value) && value.length === 0) return false;
+  if (config.type === "boolean" && value === false) return false;
+  if (config.type === "select" && value === "") return false;
+  return true;
+}
+function FilterToolbar({
+  filters,
+  values,
+  onChange,
+  onReset,
+  total,
+  searchDebounce = 300,
+  compact = false,
+  sx,
+  resetLabel = "Reset",
+  resultsLabel
+}) {
+  const [, startTransition] = useTransition();
+  const searchFilter = filters.find((f) => f.type === "search");
+  const [localSearch, setLocalSearch] = useState(values[searchFilter?.key ?? "search"] ?? "");
+  const debouncedSearch = useDebounce(localSearch, searchDebounce);
+  const prevDebouncedRef = useRef(debouncedSearch);
+  useEffect(() => {
+    if (debouncedSearch !== prevDebouncedRef.current) {
+      prevDebouncedRef.current = debouncedSearch;
+      const key = searchFilter?.key ?? "search";
+      startTransition(() => {
+        onChange({ ...values, [key]: debouncedSearch });
+      });
+    }
+  }, [debouncedSearch, searchFilter?.key, onChange, values]);
+  const searchValue = values[searchFilter?.key ?? "search"] ?? "";
+  useEffect(() => {
+    if (searchValue === prevDebouncedRef.current) return;
+    prevDebouncedRef.current = searchValue;
+    setLocalSearch(searchValue);
+  }, [searchValue]);
+  const activeCount = useMemo(
+    () => filters.filter((f) => f.type !== "search" && isFilterActive(f, values)).length,
+    [filters, values]
+  );
+  const hasAnyActive = useMemo(
+    () => filters.some((f) => isFilterActive(f, f.type === "search" ? { [f.key]: localSearch } : values)),
+    [filters, values, localSearch]
+  );
+  const handleChange = useCallback(
+    (key, value) => {
+      startTransition(() => {
+        onChange({ ...values, [key]: value });
+      });
+    },
+    [onChange, values]
+  );
+  const handleReset = useCallback(() => {
+    setLocalSearch("");
+    if (onReset) {
+      onReset();
+    } else {
+      const resetValues = {};
+      for (const f of filters) {
+        if (f.type === "search") resetValues[f.key] = "";
+        else if (f.type === "multi-select") resetValues[f.key] = [];
+        else if (f.type === "boolean") resetValues[f.key] = false;
+        else if (f.type === "date-range") {
+          resetValues[`${f.key}From`] = "";
+          resetValues[`${f.key}To`] = "";
+        } else if (f.type === "number-range") {
+          resetValues[`${f.key}Min`] = "";
+          resetValues[`${f.key}Max`] = "";
+        } else {
+          resetValues[f.key] = "";
+        }
+      }
+      onChange(resetValues);
+    }
+  }, [onReset, onChange, filters]);
+  const renderFilter = useCallback(
+    (config) => {
+      const { key, type, label, placeholder, options } = config;
+      switch (type) {
+        case "search":
+          return /* @__PURE__ */ jsx(
+            SearchInput,
+            {
+              value: localSearch,
+              onChange: setLocalSearch,
+              placeholder: placeholder ?? "Search...",
+              "aria-label": label,
+              fullWidth: true
+            },
+            key
+          );
+        case "select":
+          return /* @__PURE__ */ jsxs(
+            TextField2,
+            {
+              select: true,
+              size: "small",
+              value: values[key] ?? "",
+              onChange: (e) => handleChange(key, e.target.value),
+              slotProps: { select: { displayEmpty: true, "aria-label": label } },
+              sx: {
+                minWidth: 0,
+                width: "100%",
+                "& .MuiOutlinedInput-root": { borderRadius: 1 }
+              },
+              children: [
+                /* @__PURE__ */ jsx(MenuItem, { value: "", children: /* @__PURE__ */ jsx(
+                  Typography2,
+                  {
+                    variant: "body2",
+                    sx: {
+                      color: "text.secondary"
+                    },
+                    children: label
+                  }
+                ) }),
+                options?.map((opt) => /* @__PURE__ */ jsx(MenuItem, { value: opt.value, children: opt.label }, opt.value))
+              ]
+            },
+            key
+          );
+        case "multi-select": {
+          const selectedValues = values[key] ?? [];
+          return /* @__PURE__ */ jsx(
+            TextField2,
+            {
+              select: true,
+              size: "small",
+              value: selectedValues,
+              onChange: (e) => handleChange(key, e.target.value),
+              slotProps: {
+                select: {
+                  multiple: true,
+                  displayEmpty: true,
+                  // Same reason as the single select above: the label lives in
+                  // `renderValue` as placeholder text, leaving the control
+                  // without an accessible name.
+                  "aria-label": label,
+                  renderValue: (selected) => {
+                    const sel = selected;
+                    if (sel.length === 0) {
+                      return /* @__PURE__ */ jsx(
+                        Typography2,
+                        {
+                          variant: "body2",
+                          sx: {
+                            color: "text.secondary"
+                          },
+                          children: label
+                        }
+                      );
+                    }
+                    return /* @__PURE__ */ jsx(Stack, { direction: "row", spacing: 0.5, sx: { overflow: "hidden" }, children: sel.map((val) => {
+                      const opt = options?.find((o) => o.value === val);
+                      return /* @__PURE__ */ jsx(
+                        Chip,
+                        {
+                          label: opt?.label ?? val,
+                          size: "small",
+                          sx: { height: 20, fontSize: "0.75rem" }
+                        },
+                        val
+                      );
+                    }) });
+                  }
+                }
+              },
+              sx: {
+                minWidth: 0,
+                width: "100%",
+                "& .MuiOutlinedInput-root": { borderRadius: 1 }
+              },
+              children: options?.map((opt) => /* @__PURE__ */ jsx(MenuItem, { value: opt.value, children: opt.label }, opt.value))
+            },
+            key
+          );
+        }
+        case "date-range":
+          return /* @__PURE__ */ jsx(
+            DateRangeInput,
+            {
+              label,
+              startDate: values[`${key}From`] ?? "",
+              endDate: values[`${key}To`] ?? "",
+              onChange: (from, to) => {
+                startTransition(() => onChange({ ...values, [`${key}From`]: from, [`${key}To`]: to }));
+              },
+              width: "100%",
+              size: "small"
+            },
+            key
+          );
+        case "boolean":
+          return /* @__PURE__ */ jsx(
+            Chip,
+            {
+              label,
+              variant: values[key] ? "filled" : "outlined",
+              color: values[key] ? "primary" : "default",
+              onClick: () => handleChange(key, !values[key]),
+              size: "small",
+              sx: {
+                borderRadius: 1,
+                fontWeight: 500,
+                height: 32,
+                cursor: "pointer",
+                transition: (theme) => theme.transitions.create(["background-color", "color", "border-color"], {
+                  duration: theme.transitions.duration.shorter
+                })
+              }
+            },
+            key
+          );
+        case "number-range":
+          return /* @__PURE__ */ jsxs(
+            Stack,
+            {
+              direction: "row",
+              spacing: 1,
+              sx: {
+                alignItems: "center"
+              },
+              children: [
+                /* @__PURE__ */ jsx(
+                  TextField2,
+                  {
+                    type: "number",
+                    size: "small",
+                    label: `${label} min`,
+                    value: values[`${key}Min`] ?? "",
+                    onChange: (e) => handleChange(`${key}Min`, e.target.value),
+                    sx: { flex: 1, minWidth: 0 }
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Typography2,
+                  {
+                    variant: "body2",
+                    sx: {
+                      color: "text.disabled",
+                      px: 0.5
+                    },
+                    children: "\u2014"
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  TextField2,
+                  {
+                    type: "number",
+                    size: "small",
+                    label: `${label} max`,
+                    value: values[`${key}Max`] ?? "",
+                    onChange: (e) => handleChange(`${key}Max`, e.target.value),
+                    sx: { flex: 1, minWidth: 0 }
+                  }
+                )
+              ]
+            },
+            key
+          );
+        default:
+          return null;
+      }
+    },
+    [localSearch, values, handleChange, onChange]
+  );
+  return /* @__PURE__ */ jsxs(
+    Stack,
+    {
+      spacing: compact ? 0 : 1.5,
+      sx: {
+        p: 1.5,
+        minWidth: 0,
+        borderRadius: 1,
+        border: (theme) => `1px solid ${theme.palette.divider}`,
+        bgcolor: (theme) => alpha(theme.palette.background.default, 0.5),
+        ...sx
+      },
+      children: [
+        /* @__PURE__ */ jsxs(
+          Stack,
+          {
+            direction: "row",
+            sx: {
+              alignItems: "center",
+              flexWrap: "wrap",
+              gap: 1.5
+            },
+            children: [
+              filters.map((filter) => /* @__PURE__ */ jsx(
+                Box2,
+                {
+                  sx: {
+                    flex: filter.type === "search" ? "1 1 220px" : "0 1 auto",
+                    width: filter.width ?? (filter.type === "number-range" ? 260 : filter.type === "boolean" ? "auto" : 180),
+                    minWidth: 0,
+                    maxWidth: "100%",
+                    "& > .MuiFormControl-root": { width: "100%", minWidth: 0 }
+                  },
+                  children: renderFilter(filter)
+                },
+                filter.key
+              )),
+              /* @__PURE__ */ jsxs(
+                Stack,
+                {
+                  direction: "row",
+                  spacing: 1,
+                  sx: {
+                    alignItems: "center",
+                    ml: "auto"
+                  },
+                  children: [
+                    activeCount > 0 && /* @__PURE__ */ jsx(Badge, { badgeContent: activeCount, color: "primary", sx: { "& .MuiBadge-badge": { fontSize: "0.65rem" } }, children: /* @__PURE__ */ jsx(Box2, { sx: { color: "text.secondary", display: "flex", alignItems: "center" }, children: /* @__PURE__ */ jsx(FilterIcon, {}) }) }),
+                    hasAnyActive && /* @__PURE__ */ jsx(
+                      Button,
+                      {
+                        size: "small",
+                        onClick: handleReset,
+                        sx: {
+                          minWidth: 0,
+                          px: 1.5,
+                          fontSize: "0.75rem",
+                          fontWeight: 500,
+                          color: "text.secondary",
+                          "&:hover": { color: "text.primary" }
+                        },
+                        children: resetLabel
+                      }
+                    )
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        total !== void 0 && !compact && /* @__PURE__ */ jsx(
+          Typography2,
+          {
+            variant: "caption",
+            sx: {
+              color: "text.disabled",
+              mt: 0.5
+            },
+            children: resultsLabel ? resultsLabel(total) : `${total.toLocaleString()} result${total !== 1 ? "s" : ""}`
+          }
+        )
+      ]
+    }
+  );
+}
+var StyledTableContainer = styled(Paper)(({ theme }) => ({
+  borderRadius: theme.shape.borderRadius,
+  border: `1px solid ${theme.palette.divider}`,
+  overflow: "hidden",
+  minWidth: 0,
+  maxWidth: "100%"
+}));
+var StyledTableHead = styled(TableHead)(({ theme }) => ({
+  backgroundColor: alpha(theme.palette.grey[500], 0.08),
+  "& .MuiTableCell-head": {
+    fontWeight: 600,
+    fontSize: theme.typography.pxToRem(13),
+    color: theme.palette.text.secondary,
+    backgroundColor: theme.vars?.palette.background.paper ?? theme.palette.background.paper,
+    whiteSpace: "nowrap",
+    borderBottom: `1px solid ${theme.palette.divider}`
+  }
+}));
+var StyledTableRow = styled(TableRow)(({ theme }) => ({
+  transition: theme.transitions.create("background-color", {
+    duration: theme.transitions.duration.shortest
+  }),
+  // `:nth-child(even)` for zebra-striping — table rows are homogeneous
+  // siblings, so child-position is equivalent to of-type but doesn't
+  // assume the rendered tag never changes (e.g. a row replaced by a
+  // skeleton placeholder still alternates correctly).
+  "&:nth-child(even)": {
+    backgroundColor: alpha(theme.palette.grey[500], 0.02)
+  },
+  "&:hover": {
+    backgroundColor: alpha(theme.palette.primary.main, 0.04)
+  },
+  "& .MuiTableCell-body": {
+    borderBottom: `1px solid ${alpha(theme.palette.divider, 0.6)}`
+  }
+}));
+var EMPTY_SELECTION = /* @__PURE__ */ new Set();
+function AdminDataTable({
+  columns,
+  data,
+  total,
+  loading = false,
+  loadingRows = 5,
+  page,
+  pageSize,
+  onPageChange,
+  onPageSizeChange,
+  sortBy,
+  sortOrder = "asc",
+  onSort,
+  emptyMessage = "No data found",
+  loadError = null,
+  loadErrorLabels,
+  rowKey,
+  onRowClick,
+  rowSx,
+  renderExpanded,
+  pageSizeOptions = [10, 25, 50, 100],
+  stickyHeader = false,
+  dense = false,
+  maxHeight,
+  minWidth,
+  scrollLabel,
+  paginationLabels,
+  sx,
+  selectable = false,
+  selectedKeys,
+  onSelectionChange,
+  bulkActions
+}) {
+  const getRowKey = useCallback(
+    (row, index) => {
+      if (rowKey) return rowKey(row);
+      const record = row;
+      if (record["id"] !== void 0) return String(record["id"]);
+      if (selectable && process.env["NODE_ENV"] !== "production") {
+        console.error(
+          "[AdminDataTable] `selectable` is on but rows have no stable key: pass `rowKey`, or give each row an `id`. Index-based keys make the selection positional, so sorting or paging silently re-targets it."
+        );
+      }
+      return String(index);
+    },
+    [rowKey, selectable]
+  );
+  const selection = selectedKeys ?? EMPTY_SELECTION;
+  const pageRowKeys = useMemo(
+    () => selectable ? data.map((row, index) => getRowKey(row, index)) : [],
+    [selectable, data, getRowKey]
+  );
+  const allPageSelected = pageRowKeys.length > 0 && pageRowKeys.every((k) => selection.has(k));
+  const somePageSelected = !allPageSelected && pageRowKeys.some((k) => selection.has(k));
+  const toggleAllOnPage = useCallback(() => {
+    if (!onSelectionChange) return;
+    const next = new Set(selection);
+    if (allPageSelected) {
+      pageRowKeys.forEach((k) => next.delete(k));
+    } else {
+      pageRowKeys.forEach((k) => next.add(k));
+    }
+    onSelectionChange(next);
+  }, [onSelectionChange, selection, allPageSelected, pageRowKeys]);
+  const toggleRow = useCallback(
+    (key) => {
+      if (!onSelectionChange) return;
+      const next = new Set(selection);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      onSelectionChange(next);
+    },
+    [onSelectionChange, selection]
+  );
+  const handleSort = useCallback(
+    (columnKey) => {
+      onSort?.(columnKey);
+    },
+    [onSort]
+  );
+  const handlePageChange = useCallback(
+    (_, newPage) => {
+      onPageChange(newPage);
+    },
+    [onPageChange]
+  );
+  const handlePageSizeChange = useCallback(
+    (event) => {
+      onPageSizeChange?.(parseInt(event.target.value, 10));
+      onPageChange(0);
+    },
+    [onPageSizeChange, onPageChange]
+  );
+  const skeletonRowCount = Math.max(1, Math.min(pageSize, loadingRows));
+  const skeletonRows = useMemo(
+    () => Array.from({ length: skeletonRowCount }, (_, i) => /* @__PURE__ */ jsxs(TableRow, { children: [
+      selectable && /* @__PURE__ */ jsx(TableCell, { padding: "checkbox", children: /* @__PURE__ */ jsx(Skeleton, { variant: "rectangular", width: 18, height: 18, sx: { borderRadius: 0.5 } }) }),
+      columns.map((col) => /* @__PURE__ */ jsx(TableCell, { align: col.align ?? "left", children: /* @__PURE__ */ jsx(
+        Skeleton,
+        {
+          variant: "text",
+          width: col.align === "right" ? "60%" : "80%",
+          sx: {
+            ml: col.align === "right" ? "auto" : 0,
+            borderRadius: 0.5
+          }
+        }
+      ) }, col.key))
+    ] }, `skeleton-${i}`)),
+    [skeletonRowCount, columns, selectable]
+  );
+  const showBulkBar = selectable && selection.size > 0 && !!bulkActions;
+  if (!loading && data.length === 0) {
+    return /* @__PURE__ */ jsxs(StyledTableContainer, { sx, children: [
+      /* @__PURE__ */ jsx(TableViewport, { label: scrollLabel, children: /* @__PURE__ */ jsx(MuiTable, { sx: { minWidth }, size: dense ? "small" : "medium", stickyHeader, children: /* @__PURE__ */ jsx(StyledTableHead, { children: /* @__PURE__ */ jsxs(TableRow, { children: [
+        selectable && /* @__PURE__ */ jsx(TableCell, { padding: "checkbox" }),
+        columns.map((col) => /* @__PURE__ */ jsx(
+          TableCell,
+          {
+            align: col.align ?? "left",
+            style: { width: col.width, minWidth: col.minWidth },
+            children: col.header
+          },
+          col.key
+        ))
+      ] }) }) }) }),
+      /* @__PURE__ */ jsxs(
+        Box2,
+        {
+          sx: {
+            py: 6,
+            px: 2,
+            textAlign: "center",
+            overflowWrap: "anywhere",
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            gap: 1.5
+          },
+          children: [
+            /* @__PURE__ */ jsx(EmptyIcon, {}),
+            /* @__PURE__ */ jsx(
+              Typography2,
+              {
+                variant: "body2",
+                sx: { color: loadError ? "text.secondary" : "text.disabled" },
+                children: loadError ? loadErrorLabels?.empty ?? "Could not load this data" : emptyMessage
+              }
+            ),
+            loadError && /* @__PURE__ */ jsx(Typography2, { variant: "caption", sx: { color: "text.disabled", maxWidth: 420, textAlign: "center" }, children: loadError })
+          ]
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(StyledTableContainer, { sx, children: [
+    loadError && /* @__PURE__ */ jsxs(
+      Box2,
+      {
+        role: "status",
+        sx: {
+          display: "flex",
+          alignItems: "center",
+          gap: 1,
+          px: 2,
+          py: 1,
+          borderBottom: 1,
+          borderColor: "divider",
+          bgcolor: (theme) => alpha(theme.palette.warning.main, 0.12)
+        },
+        children: [
+          /* @__PURE__ */ jsx(Typography2, { variant: "body2", sx: { color: "warning.dark", fontWeight: 600 }, children: loadErrorLabels?.partial ?? "Some of this data could not be loaded" }),
+          /* @__PURE__ */ jsx(Typography2, { variant: "caption", sx: { color: "text.secondary" }, children: loadError })
+        ]
+      }
+    ),
+    showBulkBar && /* @__PURE__ */ jsxs(
+      Stack,
+      {
+        direction: "row",
+        spacing: 2,
+        sx: {
+          alignItems: "center",
+          px: 2,
+          py: 1,
+          borderBottom: (theme) => `1px solid ${theme.palette.divider}`,
+          bgcolor: (theme) => alpha(theme.palette.primary.main, 0.06)
+        },
+        children: [
+          /* @__PURE__ */ jsxs(
+            Typography2,
+            {
+              variant: "body2",
+              sx: {
+                fontWeight: 600
+              },
+              children: [
+                selection.size,
+                " selected"
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx(Box2, { sx: { flex: 1 } }),
+          bulkActions(selection)
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(TableViewport, { label: scrollLabel, maxHeight, children: /* @__PURE__ */ jsxs(MuiTable, { sx: { minWidth }, size: dense ? "small" : "medium", stickyHeader, children: [
+      /* @__PURE__ */ jsx(StyledTableHead, { children: /* @__PURE__ */ jsxs(TableRow, { children: [
+        selectable && /* @__PURE__ */ jsx(TableCell, { padding: "checkbox", children: /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            size: "small",
+            indeterminate: somePageSelected,
+            checked: allPageSelected,
+            disabled: loading || pageRowKeys.length === 0,
+            onChange: toggleAllOnPage,
+            slotProps: {
+              input: { "aria-label": "select all rows on page" }
+            }
+          }
+        ) }),
+        columns.map((col) => /* @__PURE__ */ jsx(
+          TableCell,
+          {
+            align: col.align ?? "left",
+            style: { width: col.width, minWidth: col.minWidth },
+            sortDirection: sortBy === col.key ? sortOrder : false,
+            children: col.sortable && onSort ? /* @__PURE__ */ jsx(
+              TableSortLabel,
+              {
+                active: sortBy === col.key,
+                direction: sortBy === col.key ? sortOrder : "asc",
+                onClick: () => handleSort(col.key),
+                children: col.header
+              }
+            ) : col.header
+          },
+          col.key
+        ))
+      ] }) }),
+      /* @__PURE__ */ jsx(TableBody, { children: loading ? skeletonRows : data.map((row, index) => {
+        const key = getRowKey(row, index);
+        const isSelected = selectable && selection.has(key);
+        const body = /* @__PURE__ */ jsxs(
+          StyledTableRow,
+          {
+            hover: true,
+            selected: isSelected,
+            tabIndex: onRowClick || selectable ? -1 : void 0,
+            "data-row-action": onRowClick ? true : void 0,
+            onClick: onRowClick ? (event) => {
+              if (isRowActionTarget(event.target)) onRowClick(row);
+            } : void 0,
+            sx: {
+              cursor: onRowClick ? "pointer" : "default",
+              "&:focus-visible": { outline: "2px solid", outlineColor: "primary.main", outlineOffset: -2 },
+              ...rowSx?.(row, index)
+            },
+            children: [
+              selectable && /* @__PURE__ */ jsx(
+                TableCell,
+                {
+                  padding: "checkbox",
+                  onClick: (e) => e.stopPropagation(),
+                  children: /* @__PURE__ */ jsx(
+                    Checkbox,
+                    {
+                      size: "small",
+                      checked: isSelected,
+                      onChange: () => toggleRow(key),
+                      slotProps: {
+                        input: { "aria-label": "select row" }
+                      }
+                    }
+                  )
+                }
+              ),
+              columns.map((col) => /* @__PURE__ */ jsx(TableCell, { align: col.align ?? "left", children: col.render(row, index) }, col.key))
+            ]
+          },
+          key
+        );
+        const detail = renderExpanded?.(row, index);
+        if (detail == null) return body;
+        return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+          body,
+          /* @__PURE__ */ jsx(TableRow, { children: /* @__PURE__ */ jsx(TableCell, { colSpan: columns.length + (selectable ? 1 : 0), sx: { py: 0, borderBottom: 0 }, children: detail }) })
+        ] }, `${key}-group`);
+      }) })
+    ] }) }),
+    /* @__PURE__ */ jsx(
+      TablePagination,
+      {
+        component: "div",
+        count: total,
+        page,
+        rowsPerPage: pageSize,
+        rowsPerPageOptions: pageSizeOptions,
+        onPageChange: handlePageChange,
+        onRowsPerPageChange: handlePageSizeChange,
+        ...paginationLabels?.rowsPerPage != null && { labelRowsPerPage: paginationLabels.rowsPerPage },
+        ...paginationLabels?.displayedRows != null && { labelDisplayedRows: paginationLabels.displayedRows },
+        sx: {
+          borderTop: (theme) => `1px solid ${theme.palette.divider}`,
+          "& .MuiTablePagination-displayedRows": {
+            fontSize: "0.8rem"
+          },
+          "& .MuiTablePagination-selectLabel": {
+            fontSize: "0.8rem"
+          }
+        }
+      }
+    )
+  ] });
+}
+var DEFAULT_COLOR_MAP = {
+  active: "success",
+  completed: "success",
+  confirmed: "success",
+  approved: "success",
+  enabled: "success",
+  online: "success",
+  paid: "success",
+  resolved: "success",
+  success: "success",
+  pending: "warning",
+  processing: "warning",
+  waiting: "warning",
+  review: "warning",
+  draft: "warning",
+  failed: "error",
+  error: "error",
+  rejected: "error",
+  blocked: "error",
+  banned: "error",
+  disabled: "error",
+  cancelled: "error",
+  expired: "error",
+  suspended: "error",
+  offline: "error",
+  info: "info",
+  new: "info",
+  open: "info"
+};
+function StatusChip({ status, label, colorMap, size = "small", sx, ref, ...other }) {
+  const normalizedStatus = status.toLowerCase();
+  const mergedMap = colorMap ? { ...DEFAULT_COLOR_MAP, ...colorMap } : DEFAULT_COLOR_MAP;
+  const mapped = Object.hasOwn(mergedMap, normalizedStatus) ? mergedMap[normalizedStatus] : void 0;
+  const color = mapped ?? "default";
+  const displayLabel = label ?? status.charAt(0).toUpperCase() + status.slice(1).toLowerCase();
+  return /* @__PURE__ */ jsx(
+    Chip,
+    {
+      ref,
+      ...other,
+      label: displayLabel,
+      size,
+      sx: [
+        {
+          height: size === "small" ? 22 : 28,
+          fontSize: size === "small" ? "0.7rem" : "0.775rem",
+          fontWeight: 600,
+          borderRadius: 0.75,
+          letterSpacing: "0.01em",
+          ...color !== "default" && {
+            color: (theme) => theme.palette[color].main,
+            bgcolor: (theme) => alpha(theme.palette[color].main, 0.1),
+            border: (theme) => `1px solid ${alpha(theme.palette[color].main, 0.2)}`
+          },
+          ...color === "default" && {
+            color: "text.secondary",
+            bgcolor: (theme) => alpha(theme.palette.grey[500], 0.08),
+            border: (theme) => `1px solid ${alpha(theme.palette.grey[500], 0.16)}`
+          }
+        },
+        ...Array.isArray(sx) ? sx : sx ? [sx] : []
+      ]
+    }
+  );
+}
+
+// src/utils/format-crypto.ts
+var COIN_DISPLAY_DECIMALS = Object.freeze(
+  // Prototype-free: a plain literal answers `COIN_DISPLAY_DECIMALS['constructor']`
+  // with a function, which `?? FALLBACK_DECIMALS` accepts as a precision. That
+  // produced `toFixed(NaN)` — silently formatting with zero decimals instead
+  // of eight, for any coin code that collides with an Object.prototype key.
+  Object.assign(/* @__PURE__ */ Object.create(null), { btc: 8, xmr: 8 })
+);
+var COIN_WIRE_DECIMALS = Object.freeze(
+  Object.assign(/* @__PURE__ */ Object.create(null), { btc: 8, xmr: 12 })
+);
+var FALLBACK_DECIMALS = 8;
+var FALLBACK_WIRE_DECIMALS = 12;
+var DECIMAL = /^([+-]?)(\d*)(?:\.(\d*))?$/;
+function getCoinDecimals(coin) {
+  const decimals = COIN_DISPLAY_DECIMALS[coin.toLowerCase()];
+  return typeof decimals === "number" ? decimals : FALLBACK_DECIMALS;
+}
+function getCoinWireDecimals(coin) {
+  const decimals = COIN_WIRE_DECIMALS[coin.toLowerCase()];
+  return typeof decimals === "number" ? decimals : FALLBACK_WIRE_DECIMALS;
+}
+function formatDecimalString(raw, decimals, rounding = "down") {
+  const scaled = toScaledInteger(raw, decimals, rounding);
+  return scaled === null ? null : fromScaledInteger(scaled, decimals);
+}
+function toScaledInteger(raw, decimals, rounding = "half-up") {
+  const match = DECIMAL.exec(raw.trim());
+  if (!match) return null;
+  const [, sign = "", intPart = "", fracPart = ""] = match;
+  if (intPart === "" && fracPart === "") return null;
+  const digits = `${intPart || "0"}${fracPart.slice(0, decimals).padEnd(decimals, "0")}`;
+  const roundUp = rounding === "half-up" && (fracPart[decimals] ?? "0") >= "5";
+  const magnitude = BigInt(digits) + (roundUp ? 1n : 0n);
+  return sign === "-" ? -magnitude : magnitude;
+}
+function fromScaledInteger(scaled, decimals) {
+  const negative = scaled < 0n;
+  const asString = (negative ? -scaled : scaled).toString().padStart(decimals + 1, "0");
+  const whole = asString.slice(0, asString.length - decimals) || "0";
+  const fraction = decimals > 0 ? asString.slice(asString.length - decimals) : "";
+  const magnitude = decimals > 0 ? `${whole}.${fraction}` : whole;
+  return `${negative && scaled !== 0n ? "-" : ""}${magnitude}`;
+}
+function isNonZeroDecimal(raw) {
+  const match = DECIMAL.exec(raw.trim());
+  if (!match) return false;
+  const [, , intPart = "", fracPart = ""] = match;
+  if (intPart === "" && fracPart === "") return false;
+  return /[1-9]/.test(intPart) || /[1-9]/.test(fracPart);
+}
+function sumDecimalStrings(values, decimals, options) {
+  const rounding = options?.rounding ?? "half-up";
+  let total = 0n;
+  for (const value of values) {
+    if (value === null || value === void 0 || value === "") continue;
+    const scaled = toScaledInteger(
+      typeof value === "number" ? String(value) : value,
+      decimals,
+      rounding
+    );
+    if (scaled !== null) total += scaled;
+  }
+  return fromScaledInteger(total, decimals);
+}
+function subtractDecimalStrings(minuend, subtrahends, decimals, options) {
+  if (minuend === null || minuend === void 0 || minuend === "") return null;
+  const rounding = options?.rounding ?? "half-up";
+  let total = toScaledInteger(
+    typeof minuend === "number" ? String(minuend) : minuend,
+    decimals,
+    rounding
+  );
+  if (total === null) return null;
+  for (const value of subtrahends) {
+    if (value === null || value === void 0 || value === "") continue;
+    const scaled = toScaledInteger(
+      typeof value === "number" ? String(value) : value,
+      decimals,
+      rounding
+    );
+    if (scaled !== null) total -= scaled;
+  }
+  if (options?.clampAtZero && total < 0n) total = 0n;
+  return fromScaledInteger(total, decimals);
+}
+function formatCoinAmount(value, coin, options) {
+  const code = coin.toLowerCase();
+  const symbol = options?.symbol ?? coin.toUpperCase();
+  const withSymbol = options?.withSymbol !== false;
+  const decimals = Math.max(0, options?.precision ?? getCoinDecimals(code));
+  const trim = options?.trim === true;
+  const rounding = options?.rounding ?? "down";
+  const markDust = options?.markDust !== false;
+  const raw = typeof value === "string" ? value.trim() : typeof value === "number" && Number.isFinite(value) ? String(Object.is(value, -0) ? 0 : value) : "";
+  let formatted = raw === "" ? null : formatDecimalString(raw, decimals, rounding);
+  const exact = formatted !== null;
+  if (formatted === null) {
+    let n = typeof value === "number" ? value : Number(raw);
+    if (!Number.isFinite(n)) n = 0;
+    if (Object.is(n, -0)) n = 0;
+    formatted = n.toFixed(decimals);
+  }
+  if (markDust && exact && !/[1-9]/.test(formatted) && isNonZeroDecimal(raw)) {
+    const epsilon = fromScaledInteger(1n, decimals);
+    const below = raw.startsWith("-");
+    return withSymbol ? `${below ? ">" : "<"} ${below ? "-" : ""}${epsilon} ${symbol}` : `${below ? ">" : "<"} ${below ? "-" : ""}${epsilon}`;
+  }
+  if (trim && formatted.includes(".")) {
+    formatted = formatted.replace(/\.?0+$/, "");
+    if (formatted === "" || formatted === "-") formatted = "0";
+  }
+  return withSymbol ? `${formatted} ${symbol}` : formatted;
+}
+function formatCoinAmountList(totals, options) {
+  const sep = options?.separator ?? " \xB7 ";
+  return Object.keys(totals).sort().map((coin) => formatCoinAmount(totals[coin], coin, options)).join(sep);
+}
+function formatAmount(amount, decimals) {
+  const num = parseFloat(amount);
+  if (Number.isNaN(num)) return amount;
+  const scaled = decimals !== void 0 ? formatDecimalString(amount, decimals) : null;
+  const fixed = scaled ?? (decimals !== void 0 ? num.toFixed(decimals) : amount);
+  const [intPart, decPart] = fixed.split(".");
+  const absInt = intPart.replace("-", "");
+  const formatted = absInt.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  const prefix = num < 0 ? "-" : "";
+  return decPart !== void 0 ? `${prefix}${formatted}.${decPart}` : `${prefix}${formatted}`;
+}
+function AmountCell({
+  amount,
+  currency,
+  decimals,
+  showSign = false,
+  color = false,
+  sx
+}) {
+  const num = parseFloat(amount);
+  const isNegative = num < 0;
+  const isPositive = num > 0;
+  const formatted = useMemo(() => formatAmount(amount, decimals), [amount, decimals]);
+  const signPrefix = useMemo(() => {
+    if (!showSign) return "";
+    if (isPositive) return "+";
+    return "";
+  }, [showSign, isPositive]);
+  const textColor = useMemo(() => {
+    if (!color) return void 0;
+    if (isPositive) return "success.main";
+    if (isNegative) return "error.main";
+    return "text.secondary";
+  }, [color, isPositive, isNegative]);
+  return /* @__PURE__ */ jsxs(
+    Typography2,
+    {
+      variant: "body2",
+      color: textColor,
+      sx: {
+        fontFamily: '"JetBrains Mono", "Fira Code", "SF Mono", "Consolas", monospace',
+        fontVariantNumeric: "tabular-nums",
+        fontSize: "0.8rem",
+        fontWeight: 500,
+        whiteSpace: "nowrap",
+        textAlign: "right",
+        ...sx
+      },
+      children: [
+        signPrefix,
+        formatted,
+        currency && /* @__PURE__ */ jsx(
+          Typography2,
+          {
+            component: "span",
+            variant: "caption",
+            sx: {
+              color: "text.disabled",
+              ml: 0.5,
+              fontFamily: "inherit",
+              fontSize: "0.7rem",
+              fontWeight: 400
+            },
+            children: currency
+          }
+        )
+      ]
+    }
+  );
+}
+
+export { AdminDataTable, AmountCell, COIN_DISPLAY_DECIMALS, COIN_WIRE_DECIMALS, DateRangeInput, DateRangePicker, FilterToolbar, StatusChip, formatCoinAmount, formatCoinAmountList, formatDecimalString, fromScaledInteger, getCoinDecimals, getCoinWireDecimals, subtractDecimalStrings, sumDecimalStrings, toScaledInteger };
+//# sourceMappingURL=chunk-F6RZ7LW6.js.map
+//# sourceMappingURL=chunk-F6RZ7LW6.js.map