mytek-components 2.0.4 → 2.0.6

package/dist/main.es.js

@@ -1,9 +1,16 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import * as React from "react";
-import React__default, { useState, useRef, useEffect, useCallback, useContext, useMemo, useLayoutEffect, createContext, cloneElement } from "react";
+import React__default, { useState, useRef, useEffect, useCallback, useContext, useMemo, useLayoutEffect, createContext, cloneElement, forwardRef, createElement } from "react";
 import emStyled from "@emotion/styled";
 import "@emotion/react";
-import { FormControlLabel, Radio, IconButton, Menu, MenuItem, Divider, Box, TextField, FormControl as FormControl$2, Select, Button as Button$1, Typography, Checkbox, Tabs, Tab, TableContainer, Paper, Table, TableHead, TableRow, TableCell, TableBody } from "@mui/material";
+import { FormControlLabel, Radio, IconButton, Menu, MenuItem, Divider, Box, TextField, FormControl as FormControl$2, Select, Button as Button$1, Typography, Checkbox, Tabs, Tab, TableContainer, Paper, Table as Table$1, TableHead, TableRow, TableCell, TableBody, useMediaQuery, InputAdornment, Popover as Popover$2, Tooltip as Tooltip$3, CircularProgress, ListItemIcon, ListItemText } from "@mui/material";
 import ReactDOM from "react-dom";
+import { useMaterialReactTable, MaterialReactTable, MRT_ToggleFiltersButton, MRT_ToggleDensePaddingButton, MRT_ShowHideColumnsButton, MRT_ToggleFullScreenButton } from "material-react-table";
+import { LocalizationProvider, DatePicker } from "@mui/x-date-pickers";
+import dayjs from "dayjs";
+import * as XLSX from "xlsx";
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -616,8 +623,8 @@ function _objectWithoutPropertiesLoose$4(source, excluded) {
   }
   return target;
 }
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function(target) {
+function _extends$1() {
+  _extends$1 = Object.assign ? Object.assign.bind() : function(target) {
     for (var i = 1; i < arguments.length; i++) {
       var source = arguments[i];
       for (var key in source) {
@@ -628,7 +635,7 @@ function _extends() {
     }
     return target;
   };
-  return _extends.apply(this, arguments);
+  return _extends$1.apply(this, arguments);
 }
 function ownKeys$4(e, r2) {
   var t = Object.keys(e);
@@ -680,7 +687,7 @@ function Tree2Element(tree) {
   }, node.attr), Tree2Element(node.child)));
 }
 function GenIcon(data) {
-  return (props) => /* @__PURE__ */ React__default.createElement(IconBase, _extends({
+  return (props) => /* @__PURE__ */ React__default.createElement(IconBase, _extends$1({
     attr: _objectSpread$4({}, data.attr)
   }, props), Tree2Element(data.child));
 }
@@ -695,7 +702,7 @@ function IconBase(props) {
     var className;
     if (conf.className) className = conf.className;
     if (props.className) className = (className ? className + " " : "") + props.className;
-    return /* @__PURE__ */ React__default.createElement("svg", _extends({
+    return /* @__PURE__ */ React__default.createElement("svg", _extends$1({
       stroke: "currentColor",
       fill: "currentColor",
       strokeWidth: "0"
@@ -6474,6 +6481,15 @@ function requireClassnames() {
 }
 var classnamesExports = requireClassnames();
 const classNames = /* @__PURE__ */ getDefaultExportFromCjs(classnamesExports);
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r2 in t) ({}).hasOwnProperty.call(t, r2) && (n[r2] = t[r2]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
 function _objectWithoutPropertiesLoose$3(r2, e) {
   if (null == r2) return {};
   var t = {};
@@ -15065,7 +15081,7 @@ const MasterTable = ({
     onSelectionChange(updated);
   };
   const isAllSelected = data.length > 0 && selectedRows.length === data.length;
-  const formatDate = (value, format = "YYYY-MM-DD") => {
+  const formatDate2 = (value, format = "YYYY-MM-DD") => {
     if (!value) return "";
     const date = new Date(value);
     if (isNaN(date)) return value;
@@ -15258,7 +15274,7 @@ const MasterTable = ({
                       checked: selectedRows.includes(rowIndex),
                       onChange: () => handleRowSelect(rowIndex)
                     }
-                  ) : column.key === "__sr_no" ? rowIndex + 1 : column.render ? column.render(row) : column.type === "date" ? formatDate(value, column.format) : column.type === "category" ? /* @__PURE__ */ jsxRuntimeExports.jsx(
+                  ) : column.key === "__sr_no" ? rowIndex + 1 : column.render ? column.render(row) : column.type === "date" ? formatDate2(value, column.format) : column.type === "category" ? /* @__PURE__ */ jsxRuntimeExports.jsx(
                     "span",
                     {
                       className: `
@@ -16272,7 +16288,7 @@ const PowerDropdown = ({
               component: Paper,
               className: "table-container overflow-x-hidden w-ful mt-0 h-full max-h-[60vh] overflow-y-auto shadow-2xl",
               children: /* @__PURE__ */ jsxRuntimeExports.jsxs(
-                Table,
+                Table$1,
                 {
                   stickyHeader: true,
                   size: "small",
@@ -16426,6 +16442,2189 @@ const PowerDropdown = ({
     )
   ] });
 };
+/**
+ * @license lucide-react v0.542.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const toKebabCase = (string) => string.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+const toCamelCase = (string) => string.replace(
+  /^([A-Z])|[\s-_]+(\w)/g,
+  (match, p1, p2) => p2 ? p2.toUpperCase() : p1.toLowerCase()
+);
+const toPascalCase = (string) => {
+  const camelCase = toCamelCase(string);
+  return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+};
+const mergeClasses = (...classes) => classes.filter((className, index, array) => {
+  return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index;
+}).join(" ").trim();
+const hasA11yProp = (props) => {
+  for (const prop in props) {
+    if (prop.startsWith("aria-") || prop === "role" || prop === "title") {
+      return true;
+    }
+  }
+};
+/**
+ * @license lucide-react v0.542.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+var defaultAttributes = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+/**
+ * @license lucide-react v0.542.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Icon = forwardRef(
+  ({
+    color: color2 = "currentColor",
+    size = 24,
+    strokeWidth = 2,
+    absoluteStrokeWidth,
+    className = "",
+    children,
+    iconNode,
+    ...rest
+  }, ref) => createElement(
+    "svg",
+    {
+      ref,
+      ...defaultAttributes,
+      width: size,
+      height: size,
+      stroke: color2,
+      strokeWidth: absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth,
+      className: mergeClasses("lucide", className),
+      ...!children && !hasA11yProp(rest) && { "aria-hidden": "true" },
+      ...rest
+    },
+    [
+      ...iconNode.map(([tag, attrs]) => createElement(tag, attrs)),
+      ...Array.isArray(children) ? children : [children]
+    ]
+  )
+);
+/**
+ * @license lucide-react v0.542.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const createLucideIcon = (iconName, iconNode) => {
+  const Component = forwardRef(
+    ({ className, ...props }, ref) => createElement(Icon, {
+      ref,
+      iconNode,
+      className: mergeClasses(
+        `lucide-${toKebabCase(toPascalCase(iconName))}`,
+        `lucide-${iconName}`,
+        className
+      ),
+      ...props
+    })
+  );
+  Component.displayName = toPascalCase(iconName);
+  return Component;
+};
+/**
+ * @license lucide-react v0.542.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$4 = [
+  ["path", { d: "M12 15V3", key: "m9g1x1" }],
+  ["path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4", key: "ih7n3h" }],
+  ["path", { d: "m7 10 5 5 5-5", key: "brsn70" }]
+];
+const Download = createLucideIcon("download", __iconNode$4);
+/**
+ * @license lucide-react v0.542.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$3 = [
+  [
+    "path",
+    {
+      d: "M10 20a1 1 0 0 0 .553.895l2 1A1 1 0 0 0 14 21v-7a2 2 0 0 1 .517-1.341L21.74 4.67A1 1 0 0 0 21 3H3a1 1 0 0 0-.742 1.67l7.225 7.989A2 2 0 0 1 10 14z",
+      key: "sc7q7i"
+    }
+  ]
+];
+const Funnel = createLucideIcon("funnel", __iconNode$3);
+/**
+ * @license lucide-react v0.542.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$2 = [
+  ["path", { d: "m8 11 2 2 4-4", key: "1sed1v" }],
+  ["circle", { cx: "11", cy: "11", r: "8", key: "4ej97u" }],
+  ["path", { d: "m21 21-4.3-4.3", key: "1qie3q" }]
+];
+const SearchCheck = createLucideIcon("search-check", __iconNode$2);
+/**
+ * @license lucide-react v0.542.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$1 = [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", ry: "2", key: "1m3agn" }],
+  ["line", { x1: "3", x2: "21", y1: "9", y2: "9", key: "1vqk6q" }],
+  ["line", { x1: "3", x2: "21", y1: "15", y2: "15", key: "o2sbyz" }],
+  ["line", { x1: "9", x2: "9", y1: "9", y2: "21", key: "1ib60c" }],
+  ["line", { x1: "15", x2: "15", y1: "9", y2: "21", key: "1n26ft" }]
+];
+const Sheet = createLucideIcon("sheet", __iconNode$1);
+/**
+ * @license lucide-react v0.542.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode = [
+  ["path", { d: "M12 3v18", key: "108xh3" }],
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", key: "afitv7" }],
+  ["path", { d: "M3 9h18", key: "1pudct" }],
+  ["path", { d: "M3 15h18", key: "5xshup" }]
+];
+const Table = createLucideIcon("table", __iconNode);
+var weekOfYear$1 = { exports: {} };
+var weekOfYear = weekOfYear$1.exports;
+var hasRequiredWeekOfYear;
+function requireWeekOfYear() {
+  if (hasRequiredWeekOfYear) return weekOfYear$1.exports;
+  hasRequiredWeekOfYear = 1;
+  (function(module, exports$1) {
+    !(function(e, t) {
+      module.exports = t();
+    })(weekOfYear, (function() {
+      var e = "week", t = "year";
+      return function(i, n, r2) {
+        var f = n.prototype;
+        f.week = function(i2) {
+          if (void 0 === i2 && (i2 = null), null !== i2) return this.add(7 * (i2 - this.week()), "day");
+          var n2 = this.$locale().yearStart || 1;
+          if (11 === this.month() && this.date() > 25) {
+            var f2 = r2(this).startOf(t).add(1, t).date(n2), s = r2(this).endOf(e);
+            if (f2.isBefore(s)) return 1;
+          }
+          var a = r2(this).startOf(t).date(n2).startOf(e).subtract(1, "millisecond"), o = this.diff(a, e, true);
+          return o < 0 ? r2(this).startOf("week").week() : Math.ceil(o);
+        }, f.weeks = function(e2) {
+          return void 0 === e2 && (e2 = null), this.week(e2);
+        };
+      };
+    }));
+  })(weekOfYear$1);
+  return weekOfYear$1.exports;
+}
+var weekOfYearExports = requireWeekOfYear();
+const weekOfYearPlugin = /* @__PURE__ */ getDefaultExportFromCjs(weekOfYearExports);
+var customParseFormat$1 = { exports: {} };
+var customParseFormat = customParseFormat$1.exports;
+var hasRequiredCustomParseFormat;
+function requireCustomParseFormat() {
+  if (hasRequiredCustomParseFormat) return customParseFormat$1.exports;
+  hasRequiredCustomParseFormat = 1;
+  (function(module, exports$1) {
+    !(function(e, t) {
+      module.exports = t();
+    })(customParseFormat, (function() {
+      var e = { LTS: "h:mm:ss A", LT: "h:mm A", L: "MM/DD/YYYY", LL: "MMMM D, YYYY", LLL: "MMMM D, YYYY h:mm A", LLLL: "dddd, MMMM D, YYYY h:mm A" }, t = /(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|Q|YYYY|YY?|ww?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g, n = /\d/, r2 = /\d\d/, i = /\d\d?/, o = /\d*[^-_:/,()\s\d]+/, s = {}, a = function(e2) {
+        return (e2 = +e2) + (e2 > 68 ? 1900 : 2e3);
+      };
+      var f = function(e2) {
+        return function(t2) {
+          this[e2] = +t2;
+        };
+      }, h = [/[+-]\d\d:?(\d\d)?|Z/, function(e2) {
+        (this.zone || (this.zone = {})).offset = (function(e3) {
+          if (!e3) return 0;
+          if ("Z" === e3) return 0;
+          var t2 = e3.match(/([+-]|\d\d)/g), n2 = 60 * t2[1] + (+t2[2] || 0);
+          return 0 === n2 ? 0 : "+" === t2[0] ? -n2 : n2;
+        })(e2);
+      }], u = function(e2) {
+        var t2 = s[e2];
+        return t2 && (t2.indexOf ? t2 : t2.s.concat(t2.f));
+      }, d = function(e2, t2) {
+        var n2, r3 = s.meridiem;
+        if (r3) {
+          for (var i2 = 1; i2 <= 24; i2 += 1) if (e2.indexOf(r3(i2, 0, t2)) > -1) {
+            n2 = i2 > 12;
+            break;
+          }
+        } else n2 = e2 === (t2 ? "pm" : "PM");
+        return n2;
+      }, c = { A: [o, function(e2) {
+        this.afternoon = d(e2, false);
+      }], a: [o, function(e2) {
+        this.afternoon = d(e2, true);
+      }], Q: [n, function(e2) {
+        this.month = 3 * (e2 - 1) + 1;
+      }], S: [n, function(e2) {
+        this.milliseconds = 100 * +e2;
+      }], SS: [r2, function(e2) {
+        this.milliseconds = 10 * +e2;
+      }], SSS: [/\d{3}/, function(e2) {
+        this.milliseconds = +e2;
+      }], s: [i, f("seconds")], ss: [i, f("seconds")], m: [i, f("minutes")], mm: [i, f("minutes")], H: [i, f("hours")], h: [i, f("hours")], HH: [i, f("hours")], hh: [i, f("hours")], D: [i, f("day")], DD: [r2, f("day")], Do: [o, function(e2) {
+        var t2 = s.ordinal, n2 = e2.match(/\d+/);
+        if (this.day = n2[0], t2) for (var r3 = 1; r3 <= 31; r3 += 1) t2(r3).replace(/\[|\]/g, "") === e2 && (this.day = r3);
+      }], w: [i, f("week")], ww: [r2, f("week")], M: [i, f("month")], MM: [r2, f("month")], MMM: [o, function(e2) {
+        var t2 = u("months"), n2 = (u("monthsShort") || t2.map((function(e3) {
+          return e3.slice(0, 3);
+        }))).indexOf(e2) + 1;
+        if (n2 < 1) throw new Error();
+        this.month = n2 % 12 || n2;
+      }], MMMM: [o, function(e2) {
+        var t2 = u("months").indexOf(e2) + 1;
+        if (t2 < 1) throw new Error();
+        this.month = t2 % 12 || t2;
+      }], Y: [/[+-]?\d+/, f("year")], YY: [r2, function(e2) {
+        this.year = a(e2);
+      }], YYYY: [/\d{4}/, f("year")], Z: h, ZZ: h };
+      function l(n2) {
+        var r3, i2;
+        r3 = n2, i2 = s && s.formats;
+        for (var o2 = (n2 = r3.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, (function(t2, n3, r4) {
+          var o3 = r4 && r4.toUpperCase();
+          return n3 || i2[r4] || e[r4] || i2[o3].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, (function(e2, t3, n4) {
+            return t3 || n4.slice(1);
+          }));
+        }))).match(t), a2 = o2.length, f2 = 0; f2 < a2; f2 += 1) {
+          var h2 = o2[f2], u2 = c[h2], d2 = u2 && u2[0], l2 = u2 && u2[1];
+          o2[f2] = l2 ? { regex: d2, parser: l2 } : h2.replace(/^\[|\]$/g, "");
+        }
+        return function(e2) {
+          for (var t2 = {}, n3 = 0, r4 = 0; n3 < a2; n3 += 1) {
+            var i3 = o2[n3];
+            if ("string" == typeof i3) r4 += i3.length;
+            else {
+              var s2 = i3.regex, f3 = i3.parser, h3 = e2.slice(r4), u3 = s2.exec(h3)[0];
+              f3.call(t2, u3), e2 = e2.replace(u3, "");
+            }
+          }
+          return (function(e3) {
+            var t3 = e3.afternoon;
+            if (void 0 !== t3) {
+              var n4 = e3.hours;
+              t3 ? n4 < 12 && (e3.hours += 12) : 12 === n4 && (e3.hours = 0), delete e3.afternoon;
+            }
+          })(t2), t2;
+        };
+      }
+      return function(e2, t2, n2) {
+        n2.p.customParseFormat = true, e2 && e2.parseTwoDigitYear && (a = e2.parseTwoDigitYear);
+        var r3 = t2.prototype, i2 = r3.parse;
+        r3.parse = function(e3) {
+          var t3 = e3.date, r4 = e3.utc, o2 = e3.args;
+          this.$u = r4;
+          var a2 = o2[1];
+          if ("string" == typeof a2) {
+            var f2 = true === o2[2], h2 = true === o2[3], u2 = f2 || h2, d2 = o2[2];
+            h2 && (d2 = o2[2]), s = this.$locale(), !f2 && d2 && (s = n2.Ls[d2]), this.$d = (function(e4, t4, n3, r5) {
+              try {
+                if (["x", "X"].indexOf(t4) > -1) return new Date(("X" === t4 ? 1e3 : 1) * e4);
+                var i3 = l(t4)(e4), o3 = i3.year, s2 = i3.month, a3 = i3.day, f3 = i3.hours, h3 = i3.minutes, u3 = i3.seconds, d3 = i3.milliseconds, c3 = i3.zone, m2 = i3.week, M2 = /* @__PURE__ */ new Date(), Y = a3 || (o3 || s2 ? 1 : M2.getDate()), p = o3 || M2.getFullYear(), v = 0;
+                o3 && !s2 || (v = s2 > 0 ? s2 - 1 : M2.getMonth());
+                var D, w = f3 || 0, g = h3 || 0, y = u3 || 0, L = d3 || 0;
+                return c3 ? new Date(Date.UTC(p, v, Y, w, g, y, L + 60 * c3.offset * 1e3)) : n3 ? new Date(Date.UTC(p, v, Y, w, g, y, L)) : (D = new Date(p, v, Y, w, g, y, L), m2 && (D = r5(D).week(m2).toDate()), D);
+              } catch (e5) {
+                return /* @__PURE__ */ new Date("");
+              }
+            })(t3, a2, r4, n2), this.init(), d2 && true !== d2 && (this.$L = this.locale(d2).$L), u2 && t3 != this.format(a2) && (this.$d = /* @__PURE__ */ new Date("")), s = {};
+          } else if (a2 instanceof Array) for (var c2 = a2.length, m = 1; m <= c2; m += 1) {
+            o2[1] = a2[m - 1];
+            var M = n2.apply(this, o2);
+            if (M.isValid()) {
+              this.$d = M.$d, this.$L = M.$L, this.init();
+              break;
+            }
+            m === c2 && (this.$d = /* @__PURE__ */ new Date(""));
+          }
+          else i2.call(this, e3);
+        };
+      };
+    }));
+  })(customParseFormat$1);
+  return customParseFormat$1.exports;
+}
+var customParseFormatExports = requireCustomParseFormat();
+const customParseFormatPlugin = /* @__PURE__ */ getDefaultExportFromCjs(customParseFormatExports);
+var localizedFormat$1 = { exports: {} };
+var localizedFormat = localizedFormat$1.exports;
+var hasRequiredLocalizedFormat;
+function requireLocalizedFormat() {
+  if (hasRequiredLocalizedFormat) return localizedFormat$1.exports;
+  hasRequiredLocalizedFormat = 1;
+  (function(module, exports$1) {
+    !(function(e, t) {
+      module.exports = t();
+    })(localizedFormat, (function() {
+      var e = { LTS: "h:mm:ss A", LT: "h:mm A", L: "MM/DD/YYYY", LL: "MMMM D, YYYY", LLL: "MMMM D, YYYY h:mm A", LLLL: "dddd, MMMM D, YYYY h:mm A" };
+      return function(t, o, n) {
+        var r2 = o.prototype, i = r2.format;
+        n.en.formats = e, r2.format = function(t2) {
+          void 0 === t2 && (t2 = "YYYY-MM-DDTHH:mm:ssZ");
+          var o2 = this.$locale().formats, n2 = (function(t3, o3) {
+            return t3.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, (function(t4, n3, r3) {
+              var i2 = r3 && r3.toUpperCase();
+              return n3 || o3[r3] || e[r3] || o3[i2].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, (function(e2, t5, o4) {
+                return t5 || o4.slice(1);
+              }));
+            }));
+          })(t2, void 0 === o2 ? {} : o2);
+          return i.call(this, n2);
+        };
+      };
+    }));
+  })(localizedFormat$1);
+  return localizedFormat$1.exports;
+}
+var localizedFormatExports = requireLocalizedFormat();
+const localizedFormatPlugin = /* @__PURE__ */ getDefaultExportFromCjs(localizedFormatExports);
+var isBetween$1 = { exports: {} };
+var isBetween = isBetween$1.exports;
+var hasRequiredIsBetween;
+function requireIsBetween() {
+  if (hasRequiredIsBetween) return isBetween$1.exports;
+  hasRequiredIsBetween = 1;
+  (function(module, exports$1) {
+    !(function(e, i) {
+      module.exports = i();
+    })(isBetween, (function() {
+      return function(e, i, t) {
+        i.prototype.isBetween = function(e2, i2, s, f) {
+          var n = t(e2), o = t(i2), r2 = "(" === (f = f || "()")[0], u = ")" === f[1];
+          return (r2 ? this.isAfter(n, s) : !this.isBefore(n, s)) && (u ? this.isBefore(o, s) : !this.isAfter(o, s)) || (r2 ? this.isBefore(n, s) : !this.isAfter(n, s)) && (u ? this.isAfter(o, s) : !this.isBefore(o, s));
+        };
+      };
+    }));
+  })(isBetween$1);
+  return isBetween$1.exports;
+}
+var isBetweenExports = requireIsBetween();
+const isBetweenPlugin = /* @__PURE__ */ getDefaultExportFromCjs(isBetweenExports);
+var advancedFormat$1 = { exports: {} };
+var advancedFormat = advancedFormat$1.exports;
+var hasRequiredAdvancedFormat;
+function requireAdvancedFormat() {
+  if (hasRequiredAdvancedFormat) return advancedFormat$1.exports;
+  hasRequiredAdvancedFormat = 1;
+  (function(module, exports$1) {
+    !(function(e, t) {
+      module.exports = t();
+    })(advancedFormat, (function() {
+      return function(e, t) {
+        var r2 = t.prototype, n = r2.format;
+        r2.format = function(e2) {
+          var t2 = this, r3 = this.$locale();
+          if (!this.isValid()) return n.bind(this)(e2);
+          var s = this.$utils(), a = (e2 || "YYYY-MM-DDTHH:mm:ssZ").replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g, (function(e3) {
+            switch (e3) {
+              case "Q":
+                return Math.ceil((t2.$M + 1) / 3);
+              case "Do":
+                return r3.ordinal(t2.$D);
+              case "gggg":
+                return t2.weekYear();
+              case "GGGG":
+                return t2.isoWeekYear();
+              case "wo":
+                return r3.ordinal(t2.week(), "W");
+              case "w":
+              case "ww":
+                return s.s(t2.week(), "w" === e3 ? 1 : 2, "0");
+              case "W":
+              case "WW":
+                return s.s(t2.isoWeek(), "W" === e3 ? 1 : 2, "0");
+              case "k":
+              case "kk":
+                return s.s(String(0 === t2.$H ? 24 : t2.$H), "k" === e3 ? 1 : 2, "0");
+              case "X":
+                return Math.floor(t2.$d.getTime() / 1e3);
+              case "x":
+                return t2.$d.getTime();
+              case "z":
+                return "[" + t2.offsetName() + "]";
+              case "zzz":
+                return "[" + t2.offsetName("long") + "]";
+              default:
+                return e3;
+            }
+          }));
+          return n.bind(this)(a);
+        };
+      };
+    }));
+  })(advancedFormat$1);
+  return advancedFormat$1.exports;
+}
+var advancedFormatExports = requireAdvancedFormat();
+const advancedFormatPlugin = /* @__PURE__ */ getDefaultExportFromCjs(advancedFormatExports);
+const warnedOnceCache = /* @__PURE__ */ new Set();
+function warnOnce(message, gravity = "warning") {
+  if (process.env.NODE_ENV === "production") {
+    return;
+  }
+  const cleanMessage = Array.isArray(message) ? message.join("\n") : message;
+  if (!warnedOnceCache.has(cleanMessage)) {
+    warnedOnceCache.add(cleanMessage);
+    if (gravity === "error") {
+      console.error(cleanMessage);
+    } else {
+      console.warn(cleanMessage);
+    }
+  }
+}
+dayjs.extend(localizedFormatPlugin);
+dayjs.extend(weekOfYearPlugin);
+dayjs.extend(isBetweenPlugin);
+dayjs.extend(advancedFormatPlugin);
+const formatTokenMap = {
+  // Year
+  YY: "year",
+  YYYY: {
+    sectionType: "year",
+    contentType: "digit",
+    maxLength: 4
+  },
+  // Month
+  M: {
+    sectionType: "month",
+    contentType: "digit",
+    maxLength: 2
+  },
+  MM: "month",
+  MMM: {
+    sectionType: "month",
+    contentType: "letter"
+  },
+  MMMM: {
+    sectionType: "month",
+    contentType: "letter"
+  },
+  // Day of the month
+  D: {
+    sectionType: "day",
+    contentType: "digit",
+    maxLength: 2
+  },
+  DD: "day",
+  Do: {
+    sectionType: "day",
+    contentType: "digit-with-letter"
+  },
+  // Day of the week
+  d: {
+    sectionType: "weekDay",
+    contentType: "digit",
+    maxLength: 2
+  },
+  dd: {
+    sectionType: "weekDay",
+    contentType: "letter"
+  },
+  ddd: {
+    sectionType: "weekDay",
+    contentType: "letter"
+  },
+  dddd: {
+    sectionType: "weekDay",
+    contentType: "letter"
+  },
+  // Meridiem
+  A: "meridiem",
+  a: "meridiem",
+  // Hours
+  H: {
+    sectionType: "hours",
+    contentType: "digit",
+    maxLength: 2
+  },
+  HH: "hours",
+  h: {
+    sectionType: "hours",
+    contentType: "digit",
+    maxLength: 2
+  },
+  hh: "hours",
+  // Minutes
+  m: {
+    sectionType: "minutes",
+    contentType: "digit",
+    maxLength: 2
+  },
+  mm: "minutes",
+  // Seconds
+  s: {
+    sectionType: "seconds",
+    contentType: "digit",
+    maxLength: 2
+  },
+  ss: "seconds"
+};
+const defaultFormats = {
+  year: "YYYY",
+  month: "MMMM",
+  monthShort: "MMM",
+  dayOfMonth: "D",
+  dayOfMonthFull: "Do",
+  weekday: "dddd",
+  weekdayShort: "dd",
+  hours24h: "HH",
+  hours12h: "hh",
+  meridiem: "A",
+  minutes: "mm",
+  seconds: "ss",
+  fullDate: "ll",
+  keyboardDate: "L",
+  shortDate: "MMM D",
+  normalDate: "D MMMM",
+  normalDateWithWeekday: "ddd, MMM D",
+  fullTime12h: "hh:mm A",
+  fullTime24h: "HH:mm",
+  keyboardDateTime12h: "L hh:mm A",
+  keyboardDateTime24h: "L HH:mm"
+};
+const MISSING_UTC_PLUGIN = ["Missing UTC plugin", "To be able to use UTC or timezones, you have to enable the `utc` plugin", "Find more information on https://mui.com/x/react-date-pickers/timezone/#day-js-and-utc"].join("\n");
+const MISSING_TIMEZONE_PLUGIN = ["Missing timezone plugin", "To be able to use timezones, you have to enable both the `utc` and the `timezone` plugin", "Find more information on https://mui.com/x/react-date-pickers/timezone/#day-js-and-timezone"].join("\n");
+class AdapterDayjs {
+  constructor({
+    locale,
+    formats
+  } = {}) {
+    __publicField(this, "isMUIAdapter", true);
+    __publicField(this, "isTimezoneCompatible", true);
+    __publicField(this, "lib", "dayjs");
+    __publicField(this, "escapedCharacters", {
+      start: "[",
+      end: "]"
+    });
+    __publicField(this, "formatTokenMap", /* @__PURE__ */ (() => formatTokenMap)());
+    __publicField(this, "setLocaleToValue", (value) => {
+      const expectedLocale = this.getCurrentLocaleCode();
+      if (expectedLocale === value.locale()) {
+        return value;
+      }
+      return value.locale(expectedLocale);
+    });
+    __publicField(this, "hasUTCPlugin", () => typeof dayjs.utc !== "undefined");
+    __publicField(this, "hasTimezonePlugin", () => typeof dayjs.tz !== "undefined");
+    __publicField(this, "isSame", (value, comparing, comparisonTemplate) => {
+      const comparingInValueTimezone = this.setTimezone(comparing, this.getTimezone(value));
+      return value.format(comparisonTemplate) === comparingInValueTimezone.format(comparisonTemplate);
+    });
+    /**
+     * Replaces "default" by undefined and "system" by the system timezone before passing it to `dayjs`.
+     */
+    __publicField(this, "cleanTimezone", (timezone) => {
+      switch (timezone) {
+        case "default": {
+          return void 0;
+        }
+        case "system": {
+          return dayjs.tz.guess();
+        }
+        default: {
+          return timezone;
+        }
+      }
+    });
+    __publicField(this, "createSystemDate", (value) => {
+      let date;
+      if (this.hasUTCPlugin() && this.hasTimezonePlugin()) {
+        const timezone = dayjs.tz.guess();
+        if (timezone === "UTC") {
+          date = dayjs(value);
+        } else {
+          date = dayjs.tz(value, timezone);
+        }
+      } else {
+        date = dayjs(value);
+      }
+      return this.setLocaleToValue(date);
+    });
+    __publicField(this, "createUTCDate", (value) => {
+      if (!this.hasUTCPlugin()) {
+        throw new Error(MISSING_UTC_PLUGIN);
+      }
+      return this.setLocaleToValue(dayjs.utc(value));
+    });
+    __publicField(this, "createTZDate", (value, timezone) => {
+      if (!this.hasUTCPlugin()) {
+        throw new Error(MISSING_UTC_PLUGIN);
+      }
+      if (!this.hasTimezonePlugin()) {
+        throw new Error(MISSING_TIMEZONE_PLUGIN);
+      }
+      const keepLocalTime = value !== void 0 && !value.endsWith("Z");
+      return this.setLocaleToValue(dayjs(value).tz(this.cleanTimezone(timezone), keepLocalTime));
+    });
+    __publicField(this, "getLocaleFormats", () => {
+      const locales = dayjs.Ls;
+      const locale = this.locale || "en";
+      let localeObject = locales[locale];
+      if (localeObject === void 0) {
+        if (process.env.NODE_ENV !== "production") {
+          warnOnce(["MUI X: Your locale has not been found.", "Either the locale key is not a supported one. Locales supported by dayjs are available here: https://github.com/iamkun/dayjs/tree/dev/src/locale.", "Or you forget to import the locale from 'dayjs/locale/{localeUsed}'", "fallback on English locale."]);
+        }
+        localeObject = locales.en;
+      }
+      return localeObject.formats;
+    });
+    /**
+     * If the new day does not have the same offset as the old one (when switching to summer day time for example),
+     * Then dayjs will not automatically adjust the offset (moment does).
+     * We have to parse again the value to make sure the `fixOffset` method is applied.
+     * See https://github.com/iamkun/dayjs/blob/b3624de619d6e734cd0ffdbbd3502185041c1b60/src/plugin/timezone/index.js#L72
+     */
+    __publicField(this, "adjustOffset", (value) => {
+      if (!this.hasTimezonePlugin()) {
+        return value;
+      }
+      const timezone = this.getTimezone(value);
+      if (timezone !== "UTC") {
+        const fixedValue = value.tz(this.cleanTimezone(timezone), true);
+        if (fixedValue.$offset === (value.$offset ?? 0)) {
+          return value;
+        }
+        value.$offset = fixedValue.$offset;
+      }
+      return value;
+    });
+    __publicField(this, "date", (value, timezone = "default") => {
+      if (value === null) {
+        return null;
+      }
+      if (timezone === "UTC") {
+        return this.createUTCDate(value);
+      }
+      if (timezone === "system" || timezone === "default" && !this.hasTimezonePlugin()) {
+        return this.createSystemDate(value);
+      }
+      return this.createTZDate(value, timezone);
+    });
+    __publicField(this, "getInvalidDate", () => dayjs(/* @__PURE__ */ new Date("Invalid date")));
+    __publicField(this, "getTimezone", (value) => {
+      var _a;
+      if (this.hasTimezonePlugin()) {
+        const zone = (_a = value.$x) == null ? void 0 : _a.$timezone;
+        if (zone) {
+          return zone;
+        }
+      }
+      if (this.hasUTCPlugin() && value.isUTC()) {
+        return "UTC";
+      }
+      return "system";
+    });
+    __publicField(this, "setTimezone", (value, timezone) => {
+      if (this.getTimezone(value) === timezone) {
+        return value;
+      }
+      if (timezone === "UTC") {
+        if (!this.hasUTCPlugin()) {
+          throw new Error(MISSING_UTC_PLUGIN);
+        }
+        return value.utc();
+      }
+      if (timezone === "system") {
+        return value.local();
+      }
+      if (!this.hasTimezonePlugin()) {
+        if (timezone === "default") {
+          return value;
+        }
+        throw new Error(MISSING_TIMEZONE_PLUGIN);
+      }
+      return this.setLocaleToValue(dayjs.tz(value, this.cleanTimezone(timezone)));
+    });
+    __publicField(this, "toJsDate", (value) => {
+      return value.toDate();
+    });
+    __publicField(this, "parse", (value, format) => {
+      if (value === "") {
+        return null;
+      }
+      return dayjs(value, format, this.locale, true);
+    });
+    __publicField(this, "getCurrentLocaleCode", () => {
+      return this.locale || "en";
+    });
+    __publicField(this, "is12HourCycleInCurrentLocale", () => {
+      return /A|a/.test(this.getLocaleFormats().LT || "");
+    });
+    __publicField(this, "expandFormat", (format) => {
+      const localeFormats = this.getLocaleFormats();
+      const t = (formatBis) => formatBis.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, (_, a, b) => a || b.slice(1));
+      return format.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, (_, a, b) => {
+        const B = b && b.toUpperCase();
+        return a || localeFormats[b] || t(localeFormats[B]);
+      });
+    });
+    __publicField(this, "isValid", (value) => {
+      if (value == null) {
+        return false;
+      }
+      return value.isValid();
+    });
+    __publicField(this, "format", (value, formatKey) => {
+      return this.formatByString(value, this.formats[formatKey]);
+    });
+    __publicField(this, "formatByString", (value, formatString) => {
+      return this.setLocaleToValue(value).format(formatString);
+    });
+    __publicField(this, "formatNumber", (numberToFormat) => {
+      return numberToFormat;
+    });
+    __publicField(this, "isEqual", (value, comparing) => {
+      if (value === null && comparing === null) {
+        return true;
+      }
+      if (value === null || comparing === null) {
+        return false;
+      }
+      return value.toDate().getTime() === comparing.toDate().getTime();
+    });
+    __publicField(this, "isSameYear", (value, comparing) => {
+      return this.isSame(value, comparing, "YYYY");
+    });
+    __publicField(this, "isSameMonth", (value, comparing) => {
+      return this.isSame(value, comparing, "YYYY-MM");
+    });
+    __publicField(this, "isSameDay", (value, comparing) => {
+      return this.isSame(value, comparing, "YYYY-MM-DD");
+    });
+    __publicField(this, "isSameHour", (value, comparing) => {
+      return value.isSame(comparing, "hour");
+    });
+    __publicField(this, "isAfter", (value, comparing) => {
+      return value > comparing;
+    });
+    __publicField(this, "isAfterYear", (value, comparing) => {
+      if (!this.hasUTCPlugin()) {
+        return value.isAfter(comparing, "year");
+      }
+      return !this.isSameYear(value, comparing) && value.utc() > comparing.utc();
+    });
+    __publicField(this, "isAfterDay", (value, comparing) => {
+      if (!this.hasUTCPlugin()) {
+        return value.isAfter(comparing, "day");
+      }
+      return !this.isSameDay(value, comparing) && value.utc() > comparing.utc();
+    });
+    __publicField(this, "isBefore", (value, comparing) => {
+      return value < comparing;
+    });
+    __publicField(this, "isBeforeYear", (value, comparing) => {
+      if (!this.hasUTCPlugin()) {
+        return value.isBefore(comparing, "year");
+      }
+      return !this.isSameYear(value, comparing) && value.utc() < comparing.utc();
+    });
+    __publicField(this, "isBeforeDay", (value, comparing) => {
+      if (!this.hasUTCPlugin()) {
+        return value.isBefore(comparing, "day");
+      }
+      return !this.isSameDay(value, comparing) && value.utc() < comparing.utc();
+    });
+    __publicField(this, "isWithinRange", (value, [start2, end2]) => {
+      return value >= start2 && value <= end2;
+    });
+    __publicField(this, "startOfYear", (value) => {
+      return this.adjustOffset(value.startOf("year"));
+    });
+    __publicField(this, "startOfMonth", (value) => {
+      return this.adjustOffset(value.startOf("month"));
+    });
+    __publicField(this, "startOfWeek", (value) => {
+      return this.adjustOffset(this.setLocaleToValue(value).startOf("week"));
+    });
+    __publicField(this, "startOfDay", (value) => {
+      return this.adjustOffset(value.startOf("day"));
+    });
+    __publicField(this, "endOfYear", (value) => {
+      return this.adjustOffset(value.endOf("year"));
+    });
+    __publicField(this, "endOfMonth", (value) => {
+      return this.adjustOffset(value.endOf("month"));
+    });
+    __publicField(this, "endOfWeek", (value) => {
+      return this.adjustOffset(this.setLocaleToValue(value).endOf("week"));
+    });
+    __publicField(this, "endOfDay", (value) => {
+      return this.adjustOffset(value.endOf("day"));
+    });
+    __publicField(this, "addYears", (value, amount) => {
+      return this.adjustOffset(value.add(amount, "year"));
+    });
+    __publicField(this, "addMonths", (value, amount) => {
+      return this.adjustOffset(value.add(amount, "month"));
+    });
+    __publicField(this, "addWeeks", (value, amount) => {
+      return this.adjustOffset(value.add(amount, "week"));
+    });
+    __publicField(this, "addDays", (value, amount) => {
+      return this.adjustOffset(value.add(amount, "day"));
+    });
+    __publicField(this, "addHours", (value, amount) => {
+      return this.adjustOffset(value.add(amount, "hour"));
+    });
+    __publicField(this, "addMinutes", (value, amount) => {
+      return this.adjustOffset(value.add(amount, "minute"));
+    });
+    __publicField(this, "addSeconds", (value, amount) => {
+      return this.adjustOffset(value.add(amount, "second"));
+    });
+    __publicField(this, "getYear", (value) => {
+      return value.year();
+    });
+    __publicField(this, "getMonth", (value) => {
+      return value.month();
+    });
+    __publicField(this, "getDate", (value) => {
+      return value.date();
+    });
+    __publicField(this, "getHours", (value) => {
+      return value.hour();
+    });
+    __publicField(this, "getMinutes", (value) => {
+      return value.minute();
+    });
+    __publicField(this, "getSeconds", (value) => {
+      return value.second();
+    });
+    __publicField(this, "getMilliseconds", (value) => {
+      return value.millisecond();
+    });
+    __publicField(this, "setYear", (value, year) => {
+      return this.adjustOffset(value.set("year", year));
+    });
+    __publicField(this, "setMonth", (value, month) => {
+      return this.adjustOffset(value.set("month", month));
+    });
+    __publicField(this, "setDate", (value, date) => {
+      return this.adjustOffset(value.set("date", date));
+    });
+    __publicField(this, "setHours", (value, hours) => {
+      return this.adjustOffset(value.set("hour", hours));
+    });
+    __publicField(this, "setMinutes", (value, minutes) => {
+      return this.adjustOffset(value.set("minute", minutes));
+    });
+    __publicField(this, "setSeconds", (value, seconds) => {
+      return this.adjustOffset(value.set("second", seconds));
+    });
+    __publicField(this, "setMilliseconds", (value, milliseconds) => {
+      return this.adjustOffset(value.set("millisecond", milliseconds));
+    });
+    __publicField(this, "getDaysInMonth", (value) => {
+      return value.daysInMonth();
+    });
+    __publicField(this, "getWeekArray", (value) => {
+      const start2 = this.startOfWeek(this.startOfMonth(value));
+      const end2 = this.endOfWeek(this.endOfMonth(value));
+      let count = 0;
+      let current = start2;
+      const nestedWeeks = [];
+      while (current < end2) {
+        const weekNumber = Math.floor(count / 7);
+        nestedWeeks[weekNumber] = nestedWeeks[weekNumber] || [];
+        nestedWeeks[weekNumber].push(current);
+        current = this.addDays(current, 1);
+        count += 1;
+      }
+      return nestedWeeks;
+    });
+    __publicField(this, "getWeekNumber", (value) => {
+      return value.week();
+    });
+    __publicField(this, "getYearRange", ([start2, end2]) => {
+      const startDate = this.startOfYear(start2);
+      const endDate = this.endOfYear(end2);
+      const years = [];
+      let current = startDate;
+      while (this.isBefore(current, endDate)) {
+        years.push(current);
+        current = this.addYears(current, 1);
+      }
+      return years;
+    });
+    this.locale = locale;
+    this.formats = _extends({}, defaultFormats, formats);
+    dayjs.extend(customParseFormatPlugin);
+  }
+  getDayOfWeek(value) {
+    return value.day() + 1;
+  }
+}
+const DEFAULT_THEME = {
+  headerBg: "#3f5fa3",
+  headerText: "#ffffff",
+  bodyBg: "#ffffff",
+  border: "#cfd6e4"
+};
+const percentToGrow = (p) => Math.max(1, Math.round((p || 10) / 10));
+const MONTHS_SHORT = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+const pad = (n) => String(n).padStart(2, "0");
+const isNumericValue = (v) => v !== null && v !== void 0 && v !== "" && !isNaN(v) && typeof v !== "boolean";
+const isDateValue = (v) => {
+  if (v instanceof Date && !isNaN(v)) return true;
+  if (typeof v === "string") {
+    return /^\d{4}-\d{2}-\d{2}/.test(v) || /^\d{4}\/\d{2}\/\d{2}/.test(v) || /^\d{2}-\d{2}-\d{4}/.test(v);
+  }
+  return false;
+};
+const isBooleanValue = (v) => typeof v === "boolean" || v === "true" || v === "false";
+const formatDate = (value, format = "dd/MM/yyyy") => {
+  if (!value) return "";
+  const d = value instanceof Date ? value : new Date(value);
+  if (isNaN(d)) return "";
+  const dd = pad(d.getDate());
+  const mm = pad(d.getMonth() + 1);
+  const yyyy = d.getFullYear();
+  const MMM = MONTHS_SHORT[d.getMonth()];
+  pad(d.getHours());
+  const hh12 = pad(d.getHours() % 12 || 12);
+  const min2 = pad(d.getMinutes());
+  const ampm = d.getHours() >= 12 ? "PM" : "AM";
+  switch (format) {
+    case "dd/MM/yyyy":
+      return `${dd}/${mm}/${yyyy}`;
+    case "dd-MM-yyyy":
+      return `${dd}-${mm}-${yyyy}`;
+    case "yyyy/MM/dd":
+      return `${yyyy}/${mm}/${dd}`;
+    case "dd-MMM-yyyy":
+      return `${dd}-${MMM}-${yyyy}`;
+    case "dd-MMM-yyyy hh:mm a":
+      return `${dd}-${MMM}-${yyyy} ${hh12}:${min2} ${ampm}`;
+    case "yyyy-MM-dd":
+      return `${yyyy}-${mm}-${dd}`;
+    default:
+      return `${dd}/${mm}/${yyyy}`;
+  }
+};
+const CURRENCY_LOCALE_MAP = {
+  INR: "en-IN",
+  USD: "en-US",
+  EUR: "de-DE",
+  GBP: "en-GB",
+  JPY: "ja-JP",
+  AUD: "en-AU",
+  CAD: "en-CA",
+  SGD: "en-SG"
+};
+const getLocaleFromCurrency = (currency) => {
+  return CURRENCY_LOCALE_MAP[currency] || "en-IN";
+};
+const formatCurrency = ({
+  value,
+  decimal = 0,
+  // 👈 NO DEFAULT
+  currency,
+  showSymbol = false
+}) => {
+  if (value === null || value === void 0 || value === "") return "";
+  const num = Number(value);
+  if (isNaN(num)) return "";
+  const locale = getLocaleFromCurrency(currency);
+  const options = {};
+  if (typeof decimal === "number") {
+    options.minimumFractionDigits = decimal;
+    options.maximumFractionDigits = decimal;
+  }
+  if (currency && showSymbol) {
+    options.style = "currency";
+    options.currency = currency;
+  }
+  return new Intl.NumberFormat(locale, options).format(num);
+};
+const formatPercentage = ({
+  value,
+  decimal,
+  showSymbol = true
+}) => {
+  if (value === null || value === void 0 || value === "") return "";
+  const num = Number(value);
+  if (isNaN(num)) return "";
+  const options = {};
+  if (typeof decimal === "number") {
+    options.minimumFractionDigits = decimal;
+    options.maximumFractionDigits = decimal;
+  }
+  const formatted = new Intl.NumberFormat("en-IN", options).format(num);
+  return showSymbol ? `${formatted}%` : formatted;
+};
+const sanitizeColumns = (columns = []) => {
+  if (!Array.isArray(columns)) return [];
+  return columns.filter((col) => col && typeof col === "object").filter((col) => {
+    if (!col.ColFields || typeof col.ColFields !== "string") return false;
+    if (!col.ColHeading || typeof col.ColHeading !== "string") return false;
+    return true;
+  }).map((col, index) => ({
+    // 🔒 enforce safe defaults
+    ColOrder: typeof col.ColOrder === "number" ? col.ColOrder : index + 1,
+    ...col
+  }));
+};
+const getFinancialRange = (fy, quarter) => {
+  const [startYear, endYear] = fy.split("-").map(Number);
+  if (!quarter) {
+    return {
+      start: new Date(startYear, 3, 1),
+      end: new Date(endYear, 2, 31)
+    };
+  }
+  const map = {
+    Q1: [3, 0, startYear],
+    Q2: [6, 0, startYear],
+    Q3: [9, 0, startYear],
+    Q4: [0, 0, endYear]
+  };
+  const [month, day, year] = map[quarter];
+  const start2 = new Date(year, month, 1);
+  const end2 = new Date(year, month + 3, 0);
+  return { start: start2, end: end2 };
+};
+function RangeDateFilter({ column, onClose }) {
+  const current = column.getFilterValue() || {};
+  const [from, setFrom] = useState(
+    (current == null ? void 0 : current.from) ? dayjs(current.from) : null
+  );
+  const [to, setTo] = useState(
+    (current == null ? void 0 : current.to) ? dayjs(current.to) : null
+  );
+  const canApply = Boolean(from && to);
+  const handleApply = () => {
+    column.setFilterValue({
+      mode: "range",
+      from: from.toDate(),
+      // 🔥 convert here
+      to: to.toDate()
+    });
+    onClose == null ? void 0 : onClose();
+  };
+  const handleClear = () => {
+    setFrom(null);
+    setTo(null);
+    column.setFilterValue(void 0);
+    onClose == null ? void 0 : onClose();
+  };
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(Box, { p: 2, width: 240, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      DatePicker,
+      {
+        label: "From",
+        value: from,
+        onChange: (v) => {
+          setFrom(v);
+          setTo(null);
+        },
+        slotProps: {
+          textField: {
+            size: "small",
+            // Options: 'small', 'medium'
+            style: { height: "40px", width: "100%" }
+            // Custom height
+          }
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      DatePicker,
+      {
+        label: "To",
+        value: to,
+        minDate: from,
+        disabled: !from,
+        onChange: (v) => setTo(v),
+        sx: { mt: 2 },
+        slotProps: {
+          textField: {
+            size: "small",
+            // Options: 'small', 'medium'
+            style: { height: "40px", width: "100%" }
+            // Custom height
+          }
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      Button$1,
+      {
+        fullWidth: true,
+        size: "small",
+        variant: "contained",
+        sx: { mt: 1 },
+        disabled: !canApply,
+        onClick: handleApply,
+        children: "Apply"
+      }
+    ),
+    current.from && current.to && /* @__PURE__ */ jsxRuntimeExports.jsx(
+      Button$1,
+      {
+        fullWidth: true,
+        size: "small",
+        sx: { mt: 0.5 },
+        color: "error",
+        onClick: handleClear,
+        children: "Clear"
+      }
+    )
+  ] });
+}
+const financialDateFilterFn = (row, columnId, filterValue) => {
+  if (!filterValue) return true;
+  const rowDate = row.getValue(columnId);
+  if (!(rowDate instanceof Date)) return false;
+  const { mode, from, to, fy, quarter } = filterValue;
+  if (mode === "range") {
+    if (from && rowDate < from) return false;
+    if (to && rowDate > to) return false;
+    return true;
+  }
+  if (mode === "financial") {
+    const { start: start2, end: end2 } = getFinancialRange(fy, quarter);
+    return rowDate >= start2 && rowDate <= end2;
+  }
+  return true;
+};
+const getFinancialYear = (date) => {
+  const d = date instanceof Date ? date : new Date(date);
+  if (isNaN(d)) return null;
+  const year = d.getFullYear();
+  return d.getMonth() >= 3 ? `${year}-${year + 1}` : `${year - 1}-${year}`;
+};
+function FinancialDateFilter({ column, fyOptions = [], closePopover }) {
+  const activeFilter = column.getFilterValue();
+  const [from, setFrom] = useState(
+    (activeFilter == null ? void 0 : activeFilter.from) ? dayjs(activeFilter.from) : null
+  );
+  const [to, setTo] = useState(
+    (activeFilter == null ? void 0 : activeFilter.to) ? dayjs(activeFilter.to) : null
+  );
+  const [fy, setFy] = useState((activeFilter == null ? void 0 : activeFilter.fy) || "");
+  const [quarter, setQuarter] = useState((activeFilter == null ? void 0 : activeFilter.quarter) || "");
+  const isManual = !fy;
+  const isFinancial = Boolean(fy);
+  const apply = () => {
+    if (isFinancial) {
+      const { start: start2, end: end2 } = getFinancialRange(fy, quarter || null);
+      column.setFilterValue({
+        mode: "financial",
+        fy,
+        quarter: quarter || null,
+        from: start2,
+        // Date
+        to: end2
+        // Date
+      });
+      closePopover();
+      return;
+    }
+    if (from && to) {
+      column.setFilterValue({
+        mode: "range",
+        from: from.toDate(),
+        // ✅ convert HERE only
+        to: to.toDate()
+      });
+      closePopover();
+    }
+  };
+  const clear = () => {
+    column.setFilterValue(void 0);
+    setFrom(null);
+    setTo(null);
+    setFy("");
+    setQuarter("");
+    closePopover();
+  };
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(Box, { p: 2, width: 240, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      DatePicker,
+      {
+        label: "From",
+        value: from,
+        disabled: !isManual,
+        onChange: (v) => {
+          setFrom(v);
+          setTo(null);
+        },
+        slotProps: {
+          textField: {
+            size: "small",
+            // Options: 'small', 'medium'
+            style: { height: "40px", width: "100%" }
+            // Custom height
+          }
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      DatePicker,
+      {
+        sx: { mt: 2 },
+        label: "To",
+        value: to,
+        minDate: from,
+        disabled: !isManual || !from,
+        onChange: (v) => setTo(v),
+        slotProps: {
+          textField: {
+            size: "small",
+            // Options: 'small', 'medium'
+            style: { height: "40px", width: "100%" }
+            // Custom height
+          }
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      Select,
+      {
+        fullWidth: true,
+        value: fy,
+        onChange: (e) => {
+          setFy(e.target.value);
+          setQuarter("");
+          setFrom(null);
+          setTo(null);
+        },
+        sx: { mt: 1 },
+        displayEmpty: true,
+        size: "small",
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(MenuItem, { value: "", children: "Financial Year" }),
+          fyOptions.map((y) => /* @__PURE__ */ jsxRuntimeExports.jsx(MenuItem, { value: y, children: y }, y))
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      Select,
+      {
+        fullWidth: true,
+        disabled: !fy,
+        value: quarter,
+        onChange: (e) => setQuarter(e.target.value),
+        sx: { mt: 1 },
+        displayEmpty: true,
+        size: "small",
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(MenuItem, { value: "", disabled: true, children: "Quarter" }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(MenuItem, { value: "Q1", children: "Q1 (Apr–Jun)" }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(MenuItem, { value: "Q2", children: "Q2 (Jul–Sep)" }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(MenuItem, { value: "Q3", children: "Q3 (Oct–Dec)" }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(MenuItem, { value: "Q4", children: "Q4 (Jan–Mar)" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      Button$1,
+      {
+        fullWidth: true,
+        variant: "contained",
+        sx: { mt: 1 },
+        disabled: !(isFinancial || from && to),
+        onClick: apply,
+        children: "APPLY"
+      }
+    ),
+    activeFilter && /* @__PURE__ */ jsxRuntimeExports.jsx(
+      Button$1,
+      {
+        fullWidth: true,
+        color: "error",
+        sx: { mt: 1 },
+        onClick: clear,
+        children: "CLEAR"
+      }
+    )
+  ] });
+}
+function DateFilterHeader({ title, column, mode, fyOptions = [] }) {
+  const [anchorEl, setAnchorEl] = useState(null);
+  const open = Boolean(anchorEl);
+  const filterValue = column.getFilterValue();
+  const hasFilter = filterValue && (filterValue.mode === "range" && filterValue.from && filterValue.to || filterValue.mode === "financial" && filterValue.fy);
+  const tooltipText = (() => {
+    if (!hasFilter) return "";
+    if (filterValue.mode === "range") {
+      return `${filterValue.from.toLocaleDateString()} → ${filterValue.to.toLocaleDateString()}`;
+    }
+    if (filterValue.mode === "financial") {
+      return filterValue.quarter ? `${filterValue.fy} - ${filterValue.quarter}` : `${filterValue.fy}`;
+    }
+    return "";
+  })();
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { display: "flex", alignItems: "center", gap: 6 }, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: title }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      IconButton,
+      {
+        size: "small",
+        onClick: (e) => setAnchorEl(e.currentTarget),
+        title: tooltipText,
+        color: hasFilter ? "primary" : "default",
+        children: /* @__PURE__ */ jsxRuntimeExports.jsx(Funnel, { size: 14 })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      Popover$2,
+      {
+        open,
+        anchorEl,
+        onClose: () => setAnchorEl(null),
+        anchorOrigin: { vertical: "bottom", horizontal: "left" },
+        children: mode === "financial" ? /* @__PURE__ */ jsxRuntimeExports.jsx(
+          FinancialDateFilter,
+          {
+            column,
+            fyOptions,
+            closePopover: () => setAnchorEl(null)
+          }
+        ) : /* @__PURE__ */ jsxRuntimeExports.jsx(
+          RangeDateFilter,
+          {
+            column,
+            onClose: () => setAnchorEl(null)
+          }
+        )
+      }
+    )
+  ] });
+}
+const alignOpt = ["left", "center", "right"];
+const buildColumn = (col, fyOptions, detectedColumnTypes, aggregates) => {
+  const grow = percentToGrow(col.ColSize);
+  const resolvedType = col.ColDataType || detectedColumnTypes[col.ColFields] || "string";
+  const isNumericColumn = resolvedType === "number";
+  const isDateColumn = resolvedType === "date";
+  const isBooleanColumn = resolvedType === "boolean";
+  let align = "left";
+  if (typeof col.ColAllignment === "string") {
+    align = alignOpt.includes(col.ColAllignment.toLowerCase()) ? col.ColAllignment.toLowerCase() : "left";
+  } else if (isNumericColumn) {
+    align = "right";
+  } else if (isDateColumn || isBooleanColumn) {
+    align = "center";
+  }
+  const column = {
+    header: col.ColHeading,
+    accessorKey: col.ColFields,
+    size: grow * 50,
+    grow,
+    enableSorting: !!col.ColSortable,
+    enableEditing: !!col.ColEditable,
+    enableHiding: true,
+    enablePinning: Boolean(col.Pin),
+    muiTableBodyCellProps: {
+      align,
+      sx: {
+        fontFamily: col.FntName,
+        color: col.FColor || "#1f2937",
+        backgroundColor: col.BColor || "#ffffff",
+        fontSize: col.FntSize || 13,
+        fontWeight: col.FntBold ? 600 : 400
+      }
+    },
+    muiTableFooterCellProps: {
+      align,
+      sx: {
+        fontWeight: "bold",
+        fontSize: col.FntSize || 14
+      }
+    }
+  };
+  if (typeof col.Render === "function") {
+    column.Cell = ({ row, cell }) => col.Render({
+      row,
+      cell,
+      value: row.original[col.ColFields]
+    });
+    if (col.IsUIOnly) {
+      column.enableSorting = false;
+      column.enableColumnFilter = false;
+      column.enableGrouping = false;
+      column.enableEditing = false;
+      column.enableColumnOrdering = false;
+      column.enableColumnActions = false;
+      column.enableHiding = false;
+      column.enablePinning = Boolean(col.Pin);
+    }
+    return column;
+  }
+  if (isDateColumn) {
+    column.id = col.ColFields;
+    column.accessorFn = (row) => {
+      const v = row[col.ColFields];
+      if (!v) return null;
+      const d = v instanceof Date ? v : new Date(v);
+      return isNaN(d) ? null : d;
+    };
+    column.Cell = ({ cell }) => formatDate(cell.getValue(), col.DateFormat || "dd/MM/yyyy");
+    if (!col.DateMode || col.DateMode === "single") {
+      column.filterVariant = "date";
+      column.filterFn = (row, columnId, filterValue) => {
+        if (!filterValue) return true;
+        const rowDate = row.getValue(columnId);
+        if (!(rowDate instanceof Date)) return false;
+        const f = filterValue instanceof Date ? filterValue : filterValue.toDate();
+        return rowDate.getFullYear() === f.getFullYear() && rowDate.getMonth() === f.getMonth() && rowDate.getDate() === f.getDate();
+      };
+      return column;
+    }
+    if (col.DateMode === "range" || col.DateMode === "financial") {
+      delete column.filterVariant;
+      column.enableColumnFilter = false;
+      column.filterFn = financialDateFilterFn;
+      column.Header = ({ column: column2 }) => /* @__PURE__ */ jsxRuntimeExports.jsx(
+        DateFilterHeader,
+        {
+          title: col.ColHeading,
+          column: column2,
+          mode: col.DateMode,
+          fyOptions
+        }
+      );
+    }
+    return column;
+  }
+  if (isNumericColumn) {
+    column.Cell = ({ cell }) => {
+      const value = cell.getValue();
+      if (col.IsPercentage) {
+        return formatPercentage({
+          value,
+          decimal: col.Decimal
+        });
+      }
+      if (col.Currency) {
+        return formatCurrency({
+          value,
+          decimal: col.Decimal,
+          currency: col.Currency,
+          showSymbol: col.ShowCurrencySymbol
+        });
+      }
+      return formatCurrency({
+        value,
+        decimal: col.Decimal
+      });
+    };
+  }
+  if (col.TotTyp) {
+    column.Footer = () => {
+      const value = aggregates[col.ColFields];
+      if (value === void 0 || value === null) return "";
+      if (isNumericColumn && col.IsPercentage) {
+        return formatPercentage({
+          value,
+          decimal: col.Decimal
+        });
+      }
+      if (isNumericColumn && col.Currency) {
+        return formatCurrency({
+          value,
+          decimal: col.Decimal,
+          currency: col.Currency,
+          showSymbol: col.ShowCurrencySymbol
+        });
+      }
+      if (isNumericColumn) {
+        return formatCurrency({
+          value,
+          decimal: col.Decimal
+        });
+      }
+      return String(value);
+    };
+  }
+  return column;
+};
+const defaultToolBarOpt = {
+  enabled: true,
+  globalSearch: true,
+  columnFilters: true,
+  densityToggle: true,
+  fullscreenToggle: true,
+  exportBtn: true,
+  showHideColumnsBtn: true
+};
+const defaultControlOpt = {
+  columnActions: true,
+  dragging: true,
+  colPinning: true,
+  pagination: true,
+  rowSelection: false,
+  rowPinning: false,
+  grouping: false,
+  sorting: true,
+  editing: false,
+  resizing: true
+};
+function SmartGridTable({
+  columns = [],
+  data = [],
+  height: height2 = "100%",
+  width: width2 = "100%",
+  theme = DEFAULT_THEME,
+  paginationStyle = "default",
+  topToolbar = defaultToolBarOpt,
+  controls = defaultControlOpt,
+  onRowSelectionChange,
+  isLoading = false
+}) {
+  const safeColumns = useMemo(
+    () => sanitizeColumns(columns),
+    [columns]
+  );
+  const safeData = useMemo(
+    () => Array.isArray(data) ? data : [],
+    [data]
+  );
+  const [rowSelection, setRowSelection] = useState({});
+  const isMobile = useMediaQuery("(max-width:600px)");
+  const mergedTheme = { ...DEFAULT_THEME, ...theme };
+  topToolbar = { ...defaultToolBarOpt, ...topToolbar };
+  controls = { ...defaultControlOpt, ...controls };
+  const isGridDisabled = isLoading || safeColumns.length === 0 || safeData.length === 0;
+  const resolvedTopToolbar = {
+    ...defaultToolBarOpt,
+    ...topToolbar,
+    enabled: !isGridDisabled && (topToolbar == null ? void 0 : topToolbar.enabled) !== false
+  };
+  const detectedColumnTypes = useMemo(() => {
+    if (!Array.isArray(data) || !safeData.length) return {};
+    const sample = safeData[0];
+    const map = {};
+    Object.keys(sample).forEach((key) => {
+      const v = sample[key];
+      if (isDateValue(v)) map[key] = "date";
+      else if (isNumericValue(v)) map[key] = "number";
+      else if (isBooleanValue(v)) map[key] = "boolean";
+      else map[key] = "string";
+    });
+    return map;
+  }, [safeData]);
+  const aggregates = useMemo(() => {
+    if (isLoading || safeData.length === 0 || safeColumns.length === 0) {
+      return {};
+    }
+    if (!Array.isArray(data) || data.length === 0) return {};
+    const result2 = {};
+    columns == null ? void 0 : columns.forEach((col) => {
+      if (!col.TotTyp) return;
+      let count = 0;
+      let sum = 0;
+      let min2 = Infinity;
+      let max2 = -Infinity;
+      for (const row of data) {
+        const val = Number(row[col.ColFields]);
+        if (isNaN(val)) continue;
+        count++;
+        sum += val;
+        if (val < min2) min2 = val;
+        if (val > max2) max2 = val;
+      }
+      switch (col.TotTyp) {
+        case "SUM":
+          result2[col.ColFields] = sum;
+          break;
+        case "AVG":
+          result2[col.ColFields] = count ? sum / count : 0;
+          break;
+        case "MIN":
+          result2[col.ColFields] = count ? min2 : "";
+          break;
+        case "MAX":
+          result2[col.ColFields] = count ? max2 : "";
+          break;
+        case "COUNT":
+          result2[col.ColFields] = count;
+          break;
+      }
+    });
+    return result2;
+  }, [safeData, safeColumns, isLoading]);
+  const fyOptions = useMemo(() => {
+    if (!Array.isArray(data)) return [];
+    const fyColumn = columns == null ? void 0 : columns.find(
+      (c) => c.ColDataType === "date" && c.DateMode === "financial"
+    );
+    if (!fyColumn) return [];
+    return [
+      ...new Set(
+        data.map((r2) => getFinancialYear(r2[fyColumn.ColFields])).filter(Boolean)
+      )
+    ];
+  }, [data, columns]);
+  const finalColumns = useMemo(() => {
+    if (safeColumns.length === 0) return [];
+    return safeColumns.sort((a, b) => a.ColOrder - b.ColOrder).map(
+      (col) => buildColumn(col, fyOptions, detectedColumnTypes, aggregates)
+    );
+  }, [safeColumns, fyOptions, detectedColumnTypes, aggregates]);
+  const columnPinning = useMemo(() => {
+    const left2 = [];
+    const right2 = [];
+    (safeColumns || []).forEach((col) => {
+      if (col.Pin === "left") left2.push(col.ColFields);
+      if (col.Pin === "right") right2.push(col.ColFields);
+    });
+    return { left: left2, right: right2 };
+  }, [safeColumns]);
+  const columnVisibility = useMemo(() => {
+    const visibility = {};
+    (safeColumns || []).forEach((col) => {
+      if (col.IsHidden === true) {
+        visibility[col.ColFields] = false;
+      }
+    });
+    return visibility;
+  }, [safeColumns]);
+  const hasValidColumns = safeColumns.length > 0;
+  const hasData = safeData.length > 0;
+  const disableAllActions = isLoading || !hasValidColumns || !hasData;
+  const safeFinalColumns = finalColumns.length ? finalColumns : [];
+  if (!hasValidColumns) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { p: 3, textAlign: "center", color: "text.secondary", children: "No valid columns provided" });
+  }
+  const table = useMaterialReactTable({
+    columns: safeFinalColumns,
+    data: safeData,
+    /* ===============================
+       CORE LAYOUT (🔥 MUST BE semantic)
+    ================================ */
+    layoutMode: "semantic",
+    getRowId: (row, index) => {
+      var _a;
+      return ((_a = row.id) == null ? void 0 : _a.toString()) ?? index.toString();
+    },
+    /* ===============================
+       FEATURES
+    ================================ */
+    enableTopToolbar: resolvedTopToolbar.enabled,
+    enableGlobalFilter: resolvedTopToolbar.globalSearch && !isGridDisabled,
+    enableColumnFilters: resolvedTopToolbar.columnFilters && !isGridDisabled,
+    enableDensityToggle: resolvedTopToolbar.densityToggle && !isGridDisabled,
+    enableFullScreenToggle: resolvedTopToolbar.fullscreenToggle && !isGridDisabled,
+    enableColumnOrdering: !isGridDisabled && (controls == null ? void 0 : controls.dragging),
+    enableColumnPinning: !isGridDisabled && controls.colPinning,
+    enablePagination: !isGridDisabled && controls.pagination,
+    enableColumnActions: !isGridDisabled && controls.columnActions,
+    enableRowSelection: !isGridDisabled && controls.rowSelection,
+    enableGrouping: !isGridDisabled && controls.grouping,
+    enableSorting: !isGridDisabled && controls.sorting,
+    enableEditing: !isGridDisabled && controls.editing,
+    editDisplayMode: "cell",
+    enableColumnResizing: !disableAllActions && (controls == null ? void 0 : controls.resizing),
+    enableRowVirtualization: !controls.rowPinning && true,
+    enableStickyHeader: true,
+    enableStickyFooter: true,
+    enableBottomToolbar: !disableAllActions && (controls == null ? void 0 : controls.pagination),
+    enableRowPinning: !disableAllActions && controls.rowPinning,
+    enableGlobalFilterRankedResults: false,
+    enableFilterMatchHighlighting: true,
+    rowVirtualizerOptions: {
+      overscan: 20
+    },
+    muiPaginationProps: {
+      showRowsPerPage: !isMobile,
+      // ✅ mobile = false, desktop = true
+      showFirstButton: !isMobile,
+      showLastButton: !isMobile,
+      sx: {
+        flexDirection: {
+          xs: "column",
+          sm: "row"
+        },
+        alignItems: {
+          xs: "flex-start",
+          sm: "center"
+        },
+        gap: 1
+      }
+    },
+    //render top menu
+    renderTopToolbar: ({ table: table2 }) => /* @__PURE__ */ jsxRuntimeExports.jsx(
+      SmartGridTopToolbar,
+      {
+        table: table2,
+        theme: mergedTheme,
+        topToolbar,
+        isGridDisabled,
+        isLoading,
+        safeColumns,
+        safeData
+      }
+    ),
+    /* ===============================
+       INITIAL STATE
+    ================================ */
+    initialState: {
+      pagination: {
+        pageIndex: 0,
+        pageSize: 50
+      },
+      density: "comfortable",
+      columnPinning: (controls == null ? void 0 : controls.colPinning) ? columnPinning : { left: [], right: [] },
+      columnVisibility
+    },
+    paginationDisplayMode: paginationStyle,
+    /* ===============================
+       ROW SELECTION STATE
+    ================================ */
+    state: {
+      rowSelection,
+      isLoading,
+      showProgressBars: isLoading
+    },
+    onRowSelectionChange: (updater) => {
+      const next = typeof updater === "function" ? updater(rowSelection) : updater;
+      setRowSelection(next);
+      if (onRowSelectionChange) {
+        const selectedRows = Object.keys(next).map((rowId) => {
+          var _a;
+          return (_a = table.getRow(rowId)) == null ? void 0 : _a.original;
+        }).filter(Boolean);
+        onRowSelectionChange(selectedRows);
+      }
+    },
+    muiTableBodyProps: {
+      sx: {
+        "&.MuiTableBody-root": {
+          transform: "translateY(0px) !important"
+        }
+      }
+    },
+    /* ===============================
+       ROOT (TABLE WRAPPER)
+    ================================ */
+    muiTablePaperProps: useCallback(
+      ({ table: table2 }) => {
+        const isFullScreen = table2.getState().isFullScreen;
+        return {
+          elevation: 0,
+          sx: {
+            height: height2,
+            width: width2,
+            display: "flex",
+            flexDirection: "column",
+            border: `1px solid ${mergedTheme.border}`,
+            backgroundColor: mergedTheme.bodyBg,
+            ...isFullScreen && {
+              position: "fixed",
+              inset: 0,
+              borderRadius: 0,
+              zIndex: "9999999 !important"
+            }
+          }
+        };
+      },
+      [height2, width2, mergedTheme]
+    ),
+    /* ===============================
+       TOP TOOLBAR (STICKY)
+    ================================ */
+    muiTopToolbarProps: {
+      sx: {
+        position: "sticky",
+        top: 0,
+        zIndex: 4,
+        backgroundColor: mergedTheme.bodyBg,
+        borderBottom: `1px solid ${mergedTheme.border}`
+      }
+    },
+    /* ===============================
+       HEADER (PIN SAFE)
+    ================================ */
+    muiTableHeadCellProps: {
+      sx: {
+        backgroundColor: mergedTheme.headerBg,
+        color: mergedTheme.headerText,
+        fontWeight: 600,
+        borderRight: `1px solid ${mergedTheme.border}`,
+        /* =============================== FILTER INPUT (WHEN OPEN) ================================ */
+        "& .MuiInputBase-root": { color: mergedTheme.headerText },
+        "& .MuiInputBase-input": { color: mergedTheme.headerText },
+        "& .MuiInputBase-input::placeholder": { color: mergedTheme.headerText, opacity: 1 },
+        "& .MuiInput-underline:before": { borderBottomColor: mergedTheme.headerText },
+        "& .MuiInput-underline:hover:not(.Mui-disabled):before": { borderBottomColor: mergedTheme.headerText },
+        "& .MuiInput-underline:after": { borderBottomColor: mergedTheme.headerText },
+        '&[data-pinned="true"]': {
+          backgroundColor: mergedTheme.headerBg
+        },
+        "& .MuiTableSortLabel-root": {
+          color: `${mergedTheme.headerText} !important`
+        },
+        "& .MuiTableSortLabel-icon": {
+          color: `${mergedTheme.headerText} !important`,
+          opacity: "1 !important"
+        },
+        "& .MuiIconButton-root": {
+          color: `${mergedTheme.headerText} !important`
+        },
+        "& .MuiSvgIcon-root": {
+          color: `${mergedTheme.headerText} !important`,
+          fill: `${mergedTheme.headerText} !important`
+        },
+        /* =============================== DATE PICKER FILTER (MUI X) ================================ */
+        "& .MuiPickersInputBase-root": { color: mergedTheme.headerText },
+        "& .MuiPickersInputBase-input": { color: mergedTheme.headerText },
+        "& .MuiPickersSectionList-sectionContent": { color: mergedTheme.headerText },
+        "& .MuiPickersSectionList-sectionSeparator": { color: mergedTheme.headerText },
+        "& .MuiPickersInputAdornment-root .MuiIconButton-root": { color: mergedTheme.headerText },
+        "& .MuiPickersInputAdornment-root .MuiSvgIcon-root": { color: mergedTheme.headerText, fill: mergedTheme.headerText },
+        /* underline for filled/outlined pickers */
+        "& .MuiFilledInput-underline:before": { borderBottomColor: "rgba(255,255,255,0.6)" },
+        "& .MuiFilledInput-underline:hover:not(.Mui-disabled):before": { borderBottomColor: mergedTheme.headerText },
+        "& .MuiFilledInput-underline:after": { borderBottomColor: mergedTheme.headerText }
+      }
+    },
+    /* ===============================
+       BODY CONTAINER
+    ================================ */
+    muiTableContainerProps: {
+      sx: {
+        overflow: "auto"
+      }
+    },
+    /* ===============================
+       BODY CELLS (PIN SAFE)
+    ================================ */
+    muiTableBodyCellProps: ({ cell }) => {
+      var _a;
+      return {
+        title: (_a = cell.renderValue) == null ? void 0 : _a.call(cell),
+        sx: {
+          borderRight: `1px solid ${mergedTheme.border}`,
+          backgroundColor: mergedTheme.bodyBg,
+          "&.mrt-table-body-cell-pinned": {
+            backgroundColor: mergedTheme.bodyBg,
+            zIndex: 1
+          }
+        }
+      };
+    },
+    /* ===============================
+       ROW HOVER
+    ================================ */
+    muiTableBodyRowProps: {
+      sx: {
+        "&:hover .MuiTableCell-root::after": {
+          content: '""',
+          position: "absolute",
+          inset: 0,
+          backgroundColor: "rgba(0,0,0,0.03)",
+          pointerEvents: "none"
+        }
+      }
+    },
+    /* ===============================
+       FOOTER / PAGINATION (STICKY)
+    ================================ */
+    muiTableFooterRowProps: {
+      sx: {
+        backgroundColor: mergedTheme.bodyBg,
+        color: mergedTheme.headerText
+      }
+    },
+    muiBottomToolbarProps: {
+      sx: {
+        backgroundColor: mergedTheme.bodyBg,
+        borderTop: `1px solid ${mergedTheme.border}`
+      }
+    },
+    muiTablePaginationProps: {
+      rowsPerPageOptions: [25, 50, 100],
+      showFirstButton: true,
+      showLastButton: true
+    }
+  });
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(MaterialReactTable, { table });
+}
+function SmartGridTopToolbar({
+  table,
+  theme,
+  topToolbar,
+  isGridDisabled,
+  isLoading,
+  safeColumns,
+  safeData
+}) {
+  const [searchValue, setSearchValue] = useState(
+    table.getState().globalFilter ?? ""
+  );
+  const disable = isGridDisabled;
+  useEffect(() => {
+    if (disable) return;
+    const t = setTimeout(() => {
+      table.setGlobalFilter(searchValue || void 0);
+    }, 300);
+    return () => clearTimeout(t);
+  }, [searchValue, table, disable]);
+  const exportData = table.getFilteredRowModel().rows.map((row) => row.original);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { sx: { px: 2, py: 2 }, children: /* @__PURE__ */ jsxRuntimeExports.jsxs(
+    Box,
+    {
+      sx: {
+        display: "grid",
+        gridTemplateColumns: {
+          xs: "1fr",
+          sm: "1fr auto"
+        },
+        gap: 2,
+        alignItems: "center",
+        width: "100%"
+      },
+      children: [
+        (topToolbar == null ? void 0 : topToolbar.globalSearch) && /* @__PURE__ */ jsxRuntimeExports.jsx(
+          TextField,
+          {
+            size: "small",
+            fullWidth: true,
+            disabled: disable,
+            placeholder: isLoading ? "Loading..." : safeColumns.length === 0 ? "No columns configured" : safeData.length === 0 ? "No data available" : "Search...",
+            value: searchValue,
+            onChange: (e) => setSearchValue(e.target.value),
+            InputProps: {
+              startAdornment: /* @__PURE__ */ jsxRuntimeExports.jsx(InputAdornment, { position: "start", children: /* @__PURE__ */ jsxRuntimeExports.jsx(SearchCheck, {}) })
+            },
+            sx: {
+              "& .MuiOutlinedInput-root": {
+                borderRadius: 1.5,
+                "& fieldset": { borderColor: theme == null ? void 0 : theme.headerBg },
+                "&:hover fieldset": { borderColor: theme == null ? void 0 : theme.headerBg },
+                "&.Mui-focused fieldset": {
+                  borderColor: theme == null ? void 0 : theme.headerBg,
+                  borderWidth: 2
+                }
+              },
+              "& .MuiOutlinedInput-input::placeholder": {
+                opacity: 0.7
+              },
+              "& .MuiInputAdornment-root svg": {
+                color: theme == null ? void 0 : theme.headerBg
+              }
+            }
+          }
+        ),
+        ((topToolbar == null ? void 0 : topToolbar.exportBtn) || (topToolbar == null ? void 0 : topToolbar.columnFilters) || (topToolbar == null ? void 0 : topToolbar.densityToggle) || (topToolbar == null ? void 0 : topToolbar.showHideColumnsBtn) || (topToolbar == null ? void 0 : topToolbar.fullscreenToggle)) && /* @__PURE__ */ jsxRuntimeExports.jsxs(
+          Paper,
+          {
+            elevation: 3,
+            sx: {
+              justifySelf: "end",
+              // ✅ THIS IS THE KEY
+              display: "inline-flex",
+              alignItems: "center",
+              width: "fit-content",
+              px: 1,
+              py: 0.2,
+              borderRadius: 2,
+              bgcolor: "background.paper",
+              border: `1px solid ${theme == null ? void 0 : theme.headerBg}`,
+              whiteSpace: "nowrap",
+              opacity: disable ? 0.6 : 1,
+              pointerEvents: disable ? "none" : "auto"
+            },
+            children: [
+              (topToolbar == null ? void 0 : topToolbar.exportBtn) && /* @__PURE__ */ jsxRuntimeExports.jsx(
+                ExportButton,
+                {
+                  data: exportData,
+                  color: theme == null ? void 0 : theme.headerBg,
+                  filename: "table-data",
+                  disabled: disable
+                }
+              ),
+              (topToolbar == null ? void 0 : topToolbar.columnFilters) && /* @__PURE__ */ jsxRuntimeExports.jsx(MRT_ToggleFiltersButton, { table, disabled: disable }),
+              (topToolbar == null ? void 0 : topToolbar.densityToggle) && /* @__PURE__ */ jsxRuntimeExports.jsx(MRT_ToggleDensePaddingButton, { table, disabled: disable }),
+              (topToolbar == null ? void 0 : topToolbar.showHideColumnsBtn) && /* @__PURE__ */ jsxRuntimeExports.jsx(MRT_ShowHideColumnsButton, { table, disabled: disable }),
+              (topToolbar == null ? void 0 : topToolbar.fullscreenToggle) && /* @__PURE__ */ jsxRuntimeExports.jsx(MRT_ToggleFullScreenButton, { table, disabled: disable })
+            ]
+          }
+        )
+      ]
+    }
+  ) });
+}
+const ExportButton = ({
+  data,
+  filename = "data",
+  disabled = false
+}) => {
+  const [anchorEl, setAnchorEl] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const open = Boolean(anchorEl);
+  const handleOpen = (event) => {
+    if (!disabled && !loading) {
+      setAnchorEl(event.currentTarget);
+    }
+  };
+  const handleClose = () => {
+    setAnchorEl(null);
+  };
+  const downloadCSV = () => {
+    if (!data || data.length === 0) {
+      return;
+    }
+    const csvContent = [
+      Object.keys(data[0]).join(","),
+      ...data.map(
+        (row) => Object.values(row).map((v) => `"${v}"`).join(",")
+      )
+    ].join("\n");
+    const blob = new Blob([csvContent], {
+      type: "text/csv;charset=utf-8;"
+    });
+    const url = window.URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `${filename}.csv`;
+    a.click();
+    window.URL.revokeObjectURL(url);
+  };
+  const downloadXLSX = () => {
+    if (!data || data.length === 0) {
+      return;
+    }
+    const worksheet = XLSX.utils.json_to_sheet(data);
+    const workbook = XLSX.utils.book_new();
+    XLSX.utils.book_append_sheet(workbook, worksheet, "Data");
+    XLSX.writeFile(workbook, `${filename}.xlsx`);
+  };
+  const handleExport = async (type) => {
+    handleClose();
+    setLoading(true);
+    setTimeout(() => {
+      try {
+        type === "csv" ? downloadCSV() : downloadXLSX();
+      } catch (err) {
+        console.error(err);
+      } finally {
+        setLoading(false);
+      }
+    }, 200);
+  };
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx(Tooltip$3, { title: loading ? "Exporting…" : "Export", children: /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+      IconButton,
+      {
+        onClick: handleOpen,
+        disabled: disabled || loading,
+        sx: {
+          width: 40,
+          height: 40
+        },
+        children: loading ? /* @__PURE__ */ jsxRuntimeExports.jsx(CircularProgress, { size: 20, color: "inherit" }) : /* @__PURE__ */ jsxRuntimeExports.jsx(Download, {})
+      }
+    ) }) }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      Menu,
+      {
+        anchorEl,
+        open,
+        onClose: handleClose,
+        anchorOrigin: { vertical: "bottom", horizontal: "right" },
+        transformOrigin: { vertical: "top", horizontal: "right" },
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsxs(MenuItem, { onClick: () => handleExport("csv"), children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ListItemIcon, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(Table, { color: "#3b74eeb2" }) }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              ListItemText,
+              {
+                primary: "Export as CSV",
+                secondary: "Comma-separated values"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs(MenuItem, { onClick: () => handleExport("xlsx"), children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ListItemIcon, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(Sheet, { color: "#3bee86b2" }) }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              ListItemText,
+              {
+                primary: "Export as XLSX",
+                secondary: "Excel spreadsheet"
+              }
+            )
+          ] })
+        ]
+      }
+    )
+  ] });
+};
+const SmartTable = ({
+  controls = {
+    columnActions: true,
+    dragging: true,
+    colPinning: true,
+    pagination: true,
+    rowSelection: false,
+    rowPinning: false,
+    grouping: false,
+    sorting: true,
+    editing: false,
+    resizing: true
+  },
+  topToolbar = {
+    enabled: true,
+    globalSearch: true,
+    columnFilters: true,
+    densityToggle: true,
+    fullscreenToggle: true,
+    exportBtn: true,
+    showHideColumnsBtn: true
+  },
+  height: height2 = "100%",
+  width: width2 = "100%",
+  columns = [],
+  data = [],
+  isLoading = false,
+  onRowSelectionChange = () => {
+  }
+}) => {
+  const props = { controls, topToolbar, height: height2, width: width2, isLoading, columns, data, onRowSelectionChange };
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(LocalizationProvider, { dateAdapter: AdapterDayjs, children: /* @__PURE__ */ jsxRuntimeExports.jsx(SmartGridTable, { ...props }) });
+};
 export {
   ComboDropdown as MytekComboDropdown,
   CustomInput as MytekInputField,
@@ -16433,6 +18632,7 @@ export {
   Mt_MessageBox as MytekMessageBox,
   PowerDropdown as MytekPowerCombo,
   RadioButton as MytekRadioButton,
+  SmartTable as MytekSmartTable,
   DynamicTabs as MytekTab,
   MasterTable as MytekTable,
   Tooltip as MytekTooltip,