@solostylist/ui-kit 1.0.0

package/dist/AppDataTable/AppDataTable.js

@@ -0,0 +1,1178 @@
+import { j as r } from "../jsx-runtime-B6kdoens.js";
+import { v4 as be } from "uuid";
+import ye from "../AppNoData/AppNoData.js";
+import * as g from "react";
+import { P as e, c as C, j as $, l as ge, k as he } from "../createTheme-C97xvI-s.js";
+import { c as w } from "../clsx-C-FXfxyk.js";
+import { s as O, r as te, c as N, m as U } from "../memoTheme-B2qvAi64.js";
+import { a as S, g as B } from "../generateUtilityClasses-CuEy5gtx.js";
+import { u as H } from "../DefaultPropsProvider-BV4t9fEW.js";
+import { t as me, g as ve } from "../tableCellClasses-BIg5orIQ.js";
+import { u as xe, a as Ce, c as A } from "../useControlled-CYUofcJ9.js";
+import { B as Te, r as ae } from "../ButtonBase-p_uz8ITC.js";
+import { c as Q } from "../createSimplePaletteValueFilter-B7--0ryQ.js";
+function ke(o) {
+  return S("PrivateSwitchBase", o);
+}
+B("PrivateSwitchBase", ["root", "checked", "disabled", "input", "edgeStart", "edgeEnd"]);
+const je = (o) => {
+  const {
+    classes: t,
+    checked: a,
+    disabled: s,
+    edge: i
+  } = o, n = {
+    root: ["root", a && "checked", s && "disabled", i && `edge${C(i)}`],
+    input: ["input"]
+  };
+  return N(n, ke, t);
+}, Re = O(Te)({
+  padding: 9,
+  borderRadius: "50%",
+  variants: [{
+    props: {
+      edge: "start",
+      size: "small"
+    },
+    style: {
+      marginLeft: -3
+    }
+  }, {
+    props: ({
+      edge: o,
+      ownerState: t
+    }) => o === "start" && t.size !== "small",
+    style: {
+      marginLeft: -12
+    }
+  }, {
+    props: {
+      edge: "end",
+      size: "small"
+    },
+    style: {
+      marginRight: -3
+    }
+  }, {
+    props: ({
+      edge: o,
+      ownerState: t
+    }) => o === "end" && t.size !== "small",
+    style: {
+      marginRight: -12
+    }
+  }]
+}), Oe = O("input", {
+  shouldForwardProp: te
+})({
+  cursor: "inherit",
+  position: "absolute",
+  opacity: 0,
+  width: "100%",
+  height: "100%",
+  top: 0,
+  left: 0,
+  margin: 0,
+  padding: 0,
+  zIndex: 1
+}), se = /* @__PURE__ */ g.forwardRef(function(t, a) {
+  const {
+    autoFocus: s,
+    checked: i,
+    checkedIcon: n,
+    className: p,
+    defaultChecked: d,
+    disabled: u,
+    disableFocusRipple: b = !1,
+    edge: l = !1,
+    icon: h,
+    id: T,
+    inputProps: m,
+    inputRef: x,
+    name: c,
+    onBlur: v,
+    onChange: y,
+    onFocus: k,
+    readOnly: f,
+    required: V = !1,
+    tabIndex: I,
+    type: E,
+    value: q,
+    ...le
+  } = t, [G, ce] = xe({
+    controlled: i,
+    default: !!d,
+    name: "SwitchBase",
+    state: "checked"
+  }), R = Ce(), de = (j) => {
+    k && k(j), R && R.onFocus && R.onFocus(j);
+  }, pe = (j) => {
+    v && v(j), R && R.onBlur && R.onBlur(j);
+  }, ue = (j) => {
+    if (j.nativeEvent.defaultPrevented)
+      return;
+    const K = j.target.checked;
+    ce(K), y && y(j, K);
+  };
+  let P = u;
+  R && typeof P > "u" && (P = R.disabled);
+  const fe = E === "checkbox" || E === "radio", _ = {
+    ...t,
+    checked: G,
+    disabled: P,
+    disableFocusRipple: b,
+    edge: l
+  }, J = je(_);
+  return /* @__PURE__ */ r.jsxs(Re, {
+    component: "span",
+    className: w(J.root, p),
+    centerRipple: !0,
+    focusRipple: !b,
+    disabled: P,
+    tabIndex: null,
+    role: void 0,
+    onFocus: de,
+    onBlur: pe,
+    ownerState: _,
+    ref: a,
+    ...le,
+    children: [/* @__PURE__ */ r.jsx(Oe, {
+      autoFocus: s,
+      checked: i,
+      defaultChecked: d,
+      className: J.input,
+      disabled: P,
+      id: fe ? T : void 0,
+      name: c,
+      onChange: ue,
+      readOnly: f,
+      ref: x,
+      required: V,
+      ownerState: _,
+      tabIndex: I,
+      type: E,
+      ...E === "checkbox" && q === void 0 ? {} : {
+        value: q
+      },
+      ...m
+    }), G ? n : h]
+  });
+});
+process.env.NODE_ENV !== "production" && (se.propTypes = {
+  /**
+   * If `true`, the `input` element is focused during the first mount.
+   */
+  autoFocus: e.bool,
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: e.bool,
+  /**
+   * The icon to display when the component is checked.
+   */
+  checkedIcon: e.node.isRequired,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * @ignore
+   */
+  defaultChecked: e.bool,
+  /**
+   * If `true`, the component is disabled.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the  keyboard focus ripple is disabled.
+   * @default false
+   */
+  disableFocusRipple: e.bool,
+  /**
+   * If given, uses a negative margin to counteract the padding on one
+   * side (this is often helpful for aligning the left or right
+   * side of the icon with content above or below, without ruining the border
+   * size and shape).
+   * @default false
+   */
+  edge: e.oneOf(["end", "start", !1]),
+  /**
+   * The icon to display when the component is unchecked.
+   */
+  icon: e.node.isRequired,
+  /**
+   * The id of the `input` element.
+   */
+  id: e.string,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   */
+  inputProps: e.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: ae,
+  /*
+   * @ignore
+   */
+  name: e.string,
+  /**
+   * @ignore
+   */
+  onBlur: e.func,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {object} event The event source of the callback.
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: e.func,
+  /**
+   * @ignore
+   */
+  onFocus: e.func,
+  /**
+   * It prevents the user from changing the value of the field
+   * (not from interacting with the field).
+   */
+  readOnly: e.bool,
+  /**
+   * If `true`, the `input` element is required.
+   */
+  required: e.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.object,
+  /**
+   * @ignore
+   */
+  tabIndex: e.oneOfType([e.number, e.string]),
+  /**
+   * The input component prop `type`.
+   */
+  type: e.string.isRequired,
+  /**
+   * The value of the component.
+   */
+  value: e.any
+});
+const we = A(/* @__PURE__ */ r.jsx("path", {
+  d: "M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"
+}), "CheckBoxOutlineBlank"), Ne = A(/* @__PURE__ */ r.jsx("path", {
+  d: "M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"
+}), "CheckBox"), ze = A(/* @__PURE__ */ r.jsx("path", {
+  d: "M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z"
+}), "IndeterminateCheckBox");
+function $e(o) {
+  return S("MuiCheckbox", o);
+}
+const D = B("MuiCheckbox", ["root", "checked", "disabled", "indeterminate", "colorPrimary", "colorSecondary", "sizeSmall", "sizeMedium"]), Se = (o) => {
+  const {
+    classes: t,
+    indeterminate: a,
+    color: s,
+    size: i
+  } = o, n = {
+    root: ["root", a && "indeterminate", `color${C(s)}`, `size${C(i)}`]
+  }, p = N(n, $e, t);
+  return {
+    ...t,
+    // forward the disabled and checked classes to the SwitchBase
+    ...p
+  };
+}, Be = O(se, {
+  shouldForwardProp: (o) => te(o) || o === "classes",
+  name: "MuiCheckbox",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: a
+    } = o;
+    return [t.root, a.indeterminate && t.indeterminate, t[`size${C(a.size)}`], a.color !== "default" && t[`color${C(a.color)}`]];
+  }
+})(U(({
+  theme: o
+}) => ({
+  color: (o.vars || o).palette.text.secondary,
+  variants: [{
+    props: {
+      color: "default",
+      disableRipple: !1
+    },
+    style: {
+      "&:hover": {
+        backgroundColor: o.vars ? `rgba(${o.vars.palette.action.activeChannel} / ${o.vars.palette.action.hoverOpacity})` : $(o.palette.action.active, o.palette.action.hoverOpacity)
+      }
+    }
+  }, ...Object.entries(o.palette).filter(Q()).map(([t]) => ({
+    props: {
+      color: t,
+      disableRipple: !1
+    },
+    style: {
+      "&:hover": {
+        backgroundColor: o.vars ? `rgba(${o.vars.palette[t].mainChannel} / ${o.vars.palette.action.hoverOpacity})` : $(o.palette[t].main, o.palette.action.hoverOpacity)
+      }
+    }
+  })), ...Object.entries(o.palette).filter(Q()).map(([t]) => ({
+    props: {
+      color: t
+    },
+    style: {
+      [`&.${D.checked}, &.${D.indeterminate}`]: {
+        color: (o.vars || o).palette[t].main
+      },
+      [`&.${D.disabled}`]: {
+        color: (o.vars || o).palette.action.disabled
+      }
+    }
+  })), {
+    // Should be last to override other colors
+    props: {
+      disableRipple: !1
+    },
+    style: {
+      // Reset on touch devices, it doesn't add specificity
+      "&:hover": {
+        "@media (hover: none)": {
+          backgroundColor: "transparent"
+        }
+      }
+    }
+  }]
+}))), He = /* @__PURE__ */ r.jsx(Ne, {}), Pe = /* @__PURE__ */ r.jsx(we, {}), Me = /* @__PURE__ */ r.jsx(ze, {}), W = /* @__PURE__ */ g.forwardRef(function(t, a) {
+  const s = H({
+    props: t,
+    name: "MuiCheckbox"
+  }), {
+    checkedIcon: i = He,
+    color: n = "primary",
+    icon: p = Pe,
+    indeterminate: d = !1,
+    indeterminateIcon: u = Me,
+    inputProps: b,
+    size: l = "medium",
+    disableRipple: h = !1,
+    className: T,
+    ...m
+  } = s, x = d ? u : p, c = d ? u : i, v = {
+    ...s,
+    disableRipple: h,
+    color: n,
+    indeterminate: d,
+    size: l
+  }, y = Se(v);
+  return /* @__PURE__ */ r.jsx(Be, {
+    type: "checkbox",
+    inputProps: {
+      "data-indeterminate": d,
+      ...b
+    },
+    icon: /* @__PURE__ */ g.cloneElement(x, {
+      fontSize: x.props.fontSize ?? l
+    }),
+    checkedIcon: /* @__PURE__ */ g.cloneElement(c, {
+      fontSize: c.props.fontSize ?? l
+    }),
+    ownerState: v,
+    ref: a,
+    className: w(y.root, T),
+    disableRipple: h,
+    ...m,
+    classes: y
+  });
+});
+process.env.NODE_ENV !== "production" && (W.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: e.bool,
+  /**
+   * The icon to display when the component is checked.
+   * @default <CheckBoxIcon />
+   */
+  checkedIcon: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: e.oneOfType([e.oneOf(["default", "primary", "secondary", "error", "info", "success", "warning"]), e.string]),
+  /**
+   * The default checked state. Use when the component is not controlled.
+   */
+  defaultChecked: e.bool,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   * @default false
+   */
+  disableRipple: e.bool,
+  /**
+   * The icon to display when the component is unchecked.
+   * @default <CheckBoxOutlineBlankIcon />
+   */
+  icon: e.node,
+  /**
+   * The id of the `input` element.
+   */
+  id: e.string,
+  /**
+   * If `true`, the component appears indeterminate.
+   * This does not set the native input element to indeterminate due
+   * to inconsistent behavior across browsers.
+   * However, we set a `data-indeterminate` attribute on the `input`.
+   * @default false
+   */
+  indeterminate: e.bool,
+  /**
+   * The icon to display when the component is indeterminate.
+   * @default <IndeterminateCheckBoxIcon />
+   */
+  indeterminateIcon: e.node,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   */
+  inputProps: e.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: ae,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: e.func,
+  /**
+   * If `true`, the `input` element is required.
+   * @default false
+   */
+  required: e.bool,
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense checkbox styling.
+   * @default 'medium'
+   */
+  size: e.oneOfType([e.oneOf(["medium", "small"]), e.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The value of the component. The DOM API casts this to a string.
+   * The browser uses "on" as the default value.
+   */
+  value: e.any
+});
+const L = /* @__PURE__ */ g.createContext();
+process.env.NODE_ENV !== "production" && (L.displayName = "TableContext");
+function Ie(o) {
+  return S("MuiTable", o);
+}
+B("MuiTable", ["root", "stickyHeader"]);
+const Ee = (o) => {
+  const {
+    classes: t,
+    stickyHeader: a
+  } = o;
+  return N({
+    root: ["root", a && "stickyHeader"]
+  }, Ie, t);
+}, Fe = O("table", {
+  name: "MuiTable",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: a
+    } = o;
+    return [t.root, a.stickyHeader && t.stickyHeader];
+  }
+})(U(({
+  theme: o
+}) => ({
+  display: "table",
+  width: "100%",
+  borderCollapse: "collapse",
+  borderSpacing: 0,
+  "& caption": {
+    ...o.typography.body2,
+    padding: o.spacing(2),
+    color: (o.vars || o).palette.text.secondary,
+    textAlign: "left",
+    captionSide: "bottom"
+  },
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => t.stickyHeader,
+    style: {
+      borderCollapse: "separate"
+    }
+  }]
+}))), X = "table", ne = /* @__PURE__ */ g.forwardRef(function(t, a) {
+  const s = H({
+    props: t,
+    name: "MuiTable"
+  }), {
+    className: i,
+    component: n = X,
+    padding: p = "normal",
+    size: d = "medium",
+    stickyHeader: u = !1,
+    ...b
+  } = s, l = {
+    ...s,
+    component: n,
+    padding: p,
+    size: d,
+    stickyHeader: u
+  }, h = Ee(l), T = g.useMemo(() => ({
+    padding: p,
+    size: d,
+    stickyHeader: u
+  }), [p, d, u]);
+  return /* @__PURE__ */ r.jsx(L.Provider, {
+    value: T,
+    children: /* @__PURE__ */ r.jsx(Fe, {
+      as: n,
+      role: n === X ? null : "table",
+      ref: a,
+      className: w(h.root, i),
+      ownerState: l,
+      ...b
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (ne.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the table, normally `TableHead` and `TableBody`.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * Allows TableCells to inherit padding of the Table.
+   * @default 'normal'
+   */
+  padding: e.oneOf(["checkbox", "none", "normal"]),
+  /**
+   * Allows TableCells to inherit size of the Table.
+   * @default 'medium'
+   */
+  size: e.oneOfType([e.oneOf(["medium", "small"]), e.string]),
+  /**
+   * Set the header sticky.
+   * @default false
+   */
+  stickyHeader: e.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+const M = /* @__PURE__ */ g.createContext();
+process.env.NODE_ENV !== "production" && (M.displayName = "Tablelvl2Context");
+function Ue(o) {
+  return S("MuiTableBody", o);
+}
+B("MuiTableBody", ["root"]);
+const Ve = (o) => {
+  const {
+    classes: t
+  } = o;
+  return N({
+    root: ["root"]
+  }, Ue, t);
+}, _e = O("tbody", {
+  name: "MuiTableBody",
+  slot: "Root",
+  overridesResolver: (o, t) => t.root
+})({
+  display: "table-row-group"
+}), De = {
+  variant: "body"
+}, Y = "tbody", re = /* @__PURE__ */ g.forwardRef(function(t, a) {
+  const s = H({
+    props: t,
+    name: "MuiTableBody"
+  }), {
+    className: i,
+    component: n = Y,
+    ...p
+  } = s, d = {
+    ...s,
+    component: n
+  }, u = Ve(d);
+  return /* @__PURE__ */ r.jsx(M.Provider, {
+    value: De,
+    children: /* @__PURE__ */ r.jsx(_e, {
+      className: w(u.root, i),
+      as: n,
+      ref: a,
+      role: n === Y ? null : "rowgroup",
+      ownerState: d,
+      ...p
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (re.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component, normally `TableRow`.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+const We = (o) => {
+  const {
+    classes: t,
+    variant: a,
+    align: s,
+    padding: i,
+    size: n,
+    stickyHeader: p
+  } = o, d = {
+    root: ["root", a, p && "stickyHeader", s !== "inherit" && `align${C(s)}`, i !== "normal" && `padding${C(i)}`, `size${C(n)}`]
+  };
+  return N(d, ve, t);
+}, Ae = O("td", {
+  name: "MuiTableCell",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: a
+    } = o;
+    return [t.root, t[a.variant], t[`size${C(a.size)}`], a.padding !== "normal" && t[`padding${C(a.padding)}`], a.align !== "inherit" && t[`align${C(a.align)}`], a.stickyHeader && t.stickyHeader];
+  }
+})(U(({
+  theme: o
+}) => ({
+  ...o.typography.body2,
+  display: "table-cell",
+  verticalAlign: "inherit",
+  // Workaround for a rendering bug with spanned columns in Chrome 62.0.
+  // Removes the alpha (sets it to 1), and lightens or darkens the theme color.
+  borderBottom: o.vars ? `1px solid ${o.vars.palette.TableCell.border}` : `1px solid
+    ${o.palette.mode === "light" ? ge($(o.palette.divider, 1), 0.88) : he($(o.palette.divider, 1), 0.68)}`,
+  textAlign: "left",
+  padding: 16,
+  variants: [{
+    props: {
+      variant: "head"
+    },
+    style: {
+      color: (o.vars || o).palette.text.primary,
+      lineHeight: o.typography.pxToRem(24),
+      fontWeight: o.typography.fontWeightMedium
+    }
+  }, {
+    props: {
+      variant: "body"
+    },
+    style: {
+      color: (o.vars || o).palette.text.primary
+    }
+  }, {
+    props: {
+      variant: "footer"
+    },
+    style: {
+      color: (o.vars || o).palette.text.secondary,
+      lineHeight: o.typography.pxToRem(21),
+      fontSize: o.typography.pxToRem(12)
+    }
+  }, {
+    props: {
+      size: "small"
+    },
+    style: {
+      padding: "6px 16px",
+      [`&.${me.paddingCheckbox}`]: {
+        width: 24,
+        // prevent the checkbox column from growing
+        padding: "0 12px 0 16px",
+        "& > *": {
+          padding: 0
+        }
+      }
+    }
+  }, {
+    props: {
+      padding: "checkbox"
+    },
+    style: {
+      width: 48,
+      // prevent the checkbox column from growing
+      padding: "0 0 0 4px"
+    }
+  }, {
+    props: {
+      padding: "none"
+    },
+    style: {
+      padding: 0
+    }
+  }, {
+    props: {
+      align: "left"
+    },
+    style: {
+      textAlign: "left"
+    }
+  }, {
+    props: {
+      align: "center"
+    },
+    style: {
+      textAlign: "center"
+    }
+  }, {
+    props: {
+      align: "right"
+    },
+    style: {
+      textAlign: "right",
+      flexDirection: "row-reverse"
+    }
+  }, {
+    props: {
+      align: "justify"
+    },
+    style: {
+      textAlign: "justify"
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.stickyHeader,
+    style: {
+      position: "sticky",
+      top: 0,
+      zIndex: 2,
+      backgroundColor: (o.vars || o).palette.background.default
+    }
+  }]
+}))), z = /* @__PURE__ */ g.forwardRef(function(t, a) {
+  const s = H({
+    props: t,
+    name: "MuiTableCell"
+  }), {
+    align: i = "inherit",
+    className: n,
+    component: p,
+    padding: d,
+    scope: u,
+    size: b,
+    sortDirection: l,
+    variant: h,
+    ...T
+  } = s, m = g.useContext(L), x = g.useContext(M), c = x && x.variant === "head";
+  let v;
+  p ? v = p : v = c ? "th" : "td";
+  let y = u;
+  v === "td" ? y = void 0 : !y && c && (y = "col");
+  const k = h || x && x.variant, f = {
+    ...s,
+    align: i,
+    component: v,
+    padding: d || (m && m.padding ? m.padding : "normal"),
+    size: b || (m && m.size ? m.size : "medium"),
+    sortDirection: l,
+    stickyHeader: k === "head" && m && m.stickyHeader,
+    variant: k
+  }, V = We(f);
+  let I = null;
+  return l && (I = l === "asc" ? "ascending" : "descending"), /* @__PURE__ */ r.jsx(Ae, {
+    as: v,
+    ref: a,
+    className: w(V.root, n),
+    "aria-sort": I,
+    scope: y,
+    ownerState: f,
+    ...T
+  });
+});
+process.env.NODE_ENV !== "production" && (z.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Set the text-align on the table cell content.
+   *
+   * Monetary or generally number fields **should be right aligned** as that allows
+   * you to add them up quickly in your head without having to worry about decimals.
+   * @default 'inherit'
+   */
+  align: e.oneOf(["center", "inherit", "justify", "left", "right"]),
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * Sets the padding applied to the cell.
+   * The prop defaults to the value (`'default'`) inherited from the parent Table component.
+   */
+  padding: e.oneOf(["checkbox", "none", "normal"]),
+  /**
+   * Set scope attribute.
+   */
+  scope: e.string,
+  /**
+   * Specify the size of the cell.
+   * The prop defaults to the value (`'medium'`) inherited from the parent Table component.
+   */
+  size: e.oneOfType([e.oneOf(["medium", "small"]), e.string]),
+  /**
+   * Set aria-sort direction.
+   */
+  sortDirection: e.oneOf(["asc", "desc", !1]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * Specify the cell type.
+   * The prop defaults to the value inherited from the parent TableHead, TableBody, or TableFooter components.
+   */
+  variant: e.oneOfType([e.oneOf(["body", "footer", "head"]), e.string])
+});
+function Le(o) {
+  return S("MuiTableHead", o);
+}
+B("MuiTableHead", ["root"]);
+const qe = (o) => {
+  const {
+    classes: t
+  } = o;
+  return N({
+    root: ["root"]
+  }, Le, t);
+}, Ge = O("thead", {
+  name: "MuiTableHead",
+  slot: "Root",
+  overridesResolver: (o, t) => t.root
+})({
+  display: "table-header-group"
+}), Je = {
+  variant: "head"
+}, Z = "thead", ie = /* @__PURE__ */ g.forwardRef(function(t, a) {
+  const s = H({
+    props: t,
+    name: "MuiTableHead"
+  }), {
+    className: i,
+    component: n = Z,
+    ...p
+  } = s, d = {
+    ...s,
+    component: n
+  }, u = qe(d);
+  return /* @__PURE__ */ r.jsx(M.Provider, {
+    value: Je,
+    children: /* @__PURE__ */ r.jsx(Ge, {
+      as: n,
+      className: w(u.root, i),
+      ref: a,
+      role: n === Z ? null : "rowgroup",
+      ownerState: d,
+      ...p
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (ie.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component, normally `TableRow`.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+function Ke(o) {
+  return S("MuiTableRow", o);
+}
+const ee = B("MuiTableRow", ["root", "selected", "hover", "head", "footer"]), Qe = (o) => {
+  const {
+    classes: t,
+    selected: a,
+    hover: s,
+    head: i,
+    footer: n
+  } = o;
+  return N({
+    root: ["root", a && "selected", s && "hover", i && "head", n && "footer"]
+  }, Ke, t);
+}, Xe = O("tr", {
+  name: "MuiTableRow",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: a
+    } = o;
+    return [t.root, a.head && t.head, a.footer && t.footer];
+  }
+})(U(({
+  theme: o
+}) => ({
+  color: "inherit",
+  display: "table-row",
+  verticalAlign: "middle",
+  // We disable the focus ring for mouse, touch and keyboard users.
+  outline: 0,
+  [`&.${ee.hover}:hover`]: {
+    backgroundColor: (o.vars || o).palette.action.hover
+  },
+  [`&.${ee.selected}`]: {
+    backgroundColor: o.vars ? `rgba(${o.vars.palette.primary.mainChannel} / ${o.vars.palette.action.selectedOpacity})` : $(o.palette.primary.main, o.palette.action.selectedOpacity),
+    "&:hover": {
+      backgroundColor: o.vars ? `rgba(${o.vars.palette.primary.mainChannel} / calc(${o.vars.palette.action.selectedOpacity} + ${o.vars.palette.action.hoverOpacity}))` : $(o.palette.primary.main, o.palette.action.selectedOpacity + o.palette.action.hoverOpacity)
+    }
+  }
+}))), oe = "tr", F = /* @__PURE__ */ g.forwardRef(function(t, a) {
+  const s = H({
+    props: t,
+    name: "MuiTableRow"
+  }), {
+    className: i,
+    component: n = oe,
+    hover: p = !1,
+    selected: d = !1,
+    ...u
+  } = s, b = g.useContext(M), l = {
+    ...s,
+    component: n,
+    hover: p,
+    selected: d,
+    head: b && b.variant === "head",
+    footer: b && b.variant === "footer"
+  }, h = Qe(l);
+  return /* @__PURE__ */ r.jsx(Xe, {
+    as: n,
+    ref: a,
+    className: w(h.root, i),
+    role: n === oe ? null : "row",
+    ownerState: l,
+    ...u
+  });
+});
+process.env.NODE_ENV !== "production" && (F.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Should be valid `<tr>` children such as `TableCell`.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * If `true`, the table row will shade on hover.
+   * @default false
+   */
+  hover: e.bool,
+  /**
+   * If `true`, the table row will have the selected shading.
+   * @default false
+   */
+  selected: e.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+function po({
+  columns: o,
+  hideHead: t,
+  hover: a,
+  onClick: s,
+  onDeselectAll: i,
+  onDeselectOne: n,
+  onSelectOne: p,
+  onSelectAll: d,
+  rows: u,
+  selectable: b,
+  selected: l,
+  uniqueRowId: h,
+  ...T
+}) {
+  const m = ((l == null ? void 0 : l.size) ?? 0) > 0 && ((l == null ? void 0 : l.size) ?? 0) < u.length, x = u.length > 0 && (l == null ? void 0 : l.size) === u.length;
+  return /* @__PURE__ */ r.jsxs(ne, { ...T, sx: { mt: 1 }, children: [
+    /* @__PURE__ */ r.jsx(
+      ie,
+      {
+        sx: {
+          ...t && {
+            visibility: "collapse",
+            "--TableCell-borderWidth": 0
+          }
+        },
+        children: /* @__PURE__ */ r.jsxs(F, { children: [
+          b ? /* @__PURE__ */ r.jsx(z, { padding: "checkbox", sx: { width: "40px", minWidth: "40px", maxWidth: "40px" }, children: /* @__PURE__ */ r.jsx(
+            W,
+            {
+              checked: x,
+              indeterminate: m,
+              onChange: (c) => {
+                x ? i == null || i(c) : d == null || d(c);
+              }
+            }
+          ) }) : null,
+          o.map(
+            (c) => /* @__PURE__ */ r.jsx(
+              z,
+              {
+                sx: {
+                  width: c.width,
+                  minWidth: c.width,
+                  maxWidth: c.width,
+                  ...c.align && { textAlign: c.align }
+                },
+                children: c.hideName ? null : c.name
+              },
+              c.name ?? be()
+            )
+          )
+        ] })
+      }
+    ),
+    /* @__PURE__ */ r.jsx(re, { children: u.length ? u.map((c, v) => {
+      const y = c.id ? c.id : h == null ? void 0 : h(c), k = y ? l == null ? void 0 : l.has(y) : !1;
+      return /* @__PURE__ */ r.jsxs(
+        F,
+        {
+          hover: a,
+          selected: k,
+          ...s && {
+            onClick: (f) => {
+              s(f, c);
+            }
+          },
+          sx: { ...s && { cursor: "pointer" } },
+          children: [
+            b ? /* @__PURE__ */ r.jsx(z, { padding: "checkbox", children: /* @__PURE__ */ r.jsx(
+              W,
+              {
+                checked: y ? k : !1,
+                onChange: (f) => {
+                  k ? n == null || n(f, c) : p == null || p(f, c);
+                },
+                onClick: (f) => {
+                  s && f.stopPropagation();
+                }
+              }
+            ) }) : null,
+            o.map(
+              (f) => /* @__PURE__ */ r.jsx(z, { sx: { ...f.align && { textAlign: f.align } }, children: f.formatter ? f.formatter(c, v) : f.field ? c[f.field] : null }, f.name)
+            )
+          ]
+        },
+        y ?? v
+      );
+    }) : /* @__PURE__ */ r.jsx(F, { children: /* @__PURE__ */ r.jsx(z, { align: "center", colSpan: o.length, children: /* @__PURE__ */ r.jsx(ye, {}) }) }) })
+  ] });
+}
+export {
+  po as default
+};