@progress/kendo-react-webmcp 15.0.0-develop.2

package/adapters/grid.mjs

@@ -0,0 +1,692 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2026 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+import * as O from "react";
+import { getGridToolSchema as Q } from "../commands/grid.mjs";
+function C(r, n, e, t, a) {
+  const i = r.current;
+  if (n)
+    n({ ...e, target: a });
+  else if (i.onDataStateChange) {
+    const o = {
+      filter: i.filter,
+      sort: i.sort,
+      skip: i.skip,
+      take: i.take,
+      group: i.group
+    };
+    i.onDataStateChange({
+      dataState: { ...o, ...t },
+      target: a
+    });
+  }
+}
+function Y(r) {
+  const n = [];
+  return O.Children.forEach(r, (e) => {
+    if (O.isValidElement(e) && e.props.field) {
+      const t = e.props;
+      n.push({ field: t.field, id: t.id || t.field });
+    }
+  }), n;
+}
+function Z(r, n, e) {
+  if (!r.field)
+    return { content: [{ type: "text", text: "Missing required argument: field" }], isError: !0 };
+  const t = r.field, a = r.dir || "asc", i = [{ field: t, dir: a }];
+  return C(n, n.current.onSortChange, { sort: i }, { sort: i }, e), { content: [{ type: "text", text: `Sorted by ${t} ${a}.` }] };
+}
+function V(r, n, e, t) {
+  var u, s;
+  if (!r.field || !r.operator)
+    return { content: [{ type: "text", text: "Missing required arguments: field, operator" }], isError: !0 };
+  const a = r.field, i = r.operator, o = r.value, l = n.current, c = {
+    logic: "and",
+    filters: [...(s = t != null ? t : (u = l.filter) == null ? void 0 : u.filters) != null ? s : [], { field: a, operator: i, value: o }]
+  };
+  return C(n, l.onFilterChange, { filter: c }, { filter: c, skip: 0 }, e), { content: [{ type: "text", text: `Filter applied: ${a} ${i} "${o}".` }] };
+}
+function R(r, n, e) {
+  var l;
+  if (!r.field)
+    return { content: [{ type: "text", text: "Missing required argument: field" }], isError: !0 };
+  const t = r.field, a = r.dir || "asc", i = n.current, o = [...(l = i.group) != null ? l : [], { field: t, dir: a }];
+  return C(n, i.onGroupChange, { group: o }, { group: o }, e), { content: [{ type: "text", text: `Grouped by ${t} ${a}.` }] };
+}
+function ee(r, n, e) {
+  var o;
+  const t = Number(r.page);
+  if (!t || t < 1)
+    return { content: [{ type: "text", text: "Invalid page number." }], isError: !0 };
+  const a = (o = n.current.take) != null ? o : 10, i = (t - 1) * a;
+  return C(n, n.current.onPageChange, { page: { skip: i, take: a } }, { skip: i, take: a }, e), { content: [{ type: "text", text: `Navigated to page ${t}.` }] };
+}
+function te(r, n, e) {
+  const t = Number(r.pageSize);
+  return !t || t < 1 ? { content: [{ type: "text", text: "Invalid page size." }], isError: !0 } : (C(
+    n,
+    n.current.onPageChange,
+    { page: { skip: 0, take: t } },
+    { skip: 0, take: t },
+    e
+  ), { content: [{ type: "text", text: `Page size set to ${t}.` }] });
+}
+function re(r, n, e, t, a) {
+  const i = e.current;
+  switch (r) {
+    case "GridSort":
+      return Z(n, e, t);
+    case "GridClearSort":
+      return C(e, i.onSortChange, { sort: [] }, { sort: [] }, t), { content: [{ type: "text", text: "Sorting cleared." }] };
+    case "GridFilter":
+      return V(n, e, t, a);
+    case "GridClearFilter": {
+      const o = { logic: "and", filters: [] };
+      return C(
+        e,
+        i.onFilterChange,
+        { filter: o },
+        { filter: o, skip: 0 },
+        t
+      ), { content: [{ type: "text", text: "All filters cleared." }] };
+    }
+    case "GridGroup":
+      return R(n, e, t);
+    case "GridClearGroup":
+      return C(e, i.onGroupChange, { group: [] }, { group: [] }, t), { content: [{ type: "text", text: "Grouping cleared." }] };
+    case "GridPage":
+      return ee(n, e, t);
+    case "GridPageSize":
+      return te(n, e, t);
+    default:
+      return null;
+  }
+}
+function $(r) {
+  return Array.isArray(r) ? r : r && typeof r == "object" && Array.isArray(r.data) ? r.data : [];
+}
+function ne(r, n, e) {
+  var c, u;
+  if (!r.field || !r.operator)
+    return { content: [{ type: "text", text: "Missing required arguments: field, operator" }], isError: !0 };
+  const t = r.field, a = r.operator, i = r.value, o = n.current.dataItemKey;
+  if (!o)
+    return { content: [{ type: "text", text: "dataItemKey prop is required for highlighting." }], isError: !0 };
+  const l = (u = (c = e == null ? void 0 : e.getLeafDataItems) == null ? void 0 : c.call(e)) != null ? u : $(n.current.data), d = {};
+  for (const s of l) {
+    const p = s;
+    if (k(p[t], a, i)) {
+      const g = N(p[o]);
+      g !== null && (d[g] = !0);
+    }
+  }
+  return n.current.onHighlightChange && n.current.onHighlightChange({ highlight: d }), {
+    content: [{ type: "text", text: `Highlighted rows where ${t} ${a} "${JSON.stringify(i)}".` }]
+  };
+}
+function oe(r, n, e) {
+  var c, u;
+  if (!r.field || !r.operator)
+    return { content: [{ type: "text", text: "Missing required arguments: field, operator" }], isError: !0 };
+  const t = r.field, a = r.operator, i = r.value, o = n.current.dataItemKey;
+  if (!o)
+    return { content: [{ type: "text", text: "dataItemKey prop is required for selection." }], isError: !0 };
+  const l = (u = (c = e == null ? void 0 : e.getLeafDataItems) == null ? void 0 : c.call(e)) != null ? u : $(n.current.data), d = {};
+  for (const s of l) {
+    const p = s;
+    if (k(p[t], a, i)) {
+      const g = N(p[o]);
+      g !== null && (d[g] = !0);
+    }
+  }
+  return n.current.onSelectionChange && n.current.onSelectionChange({
+    select: d,
+    dataItem: null,
+    dataItems: l,
+    startDataItem: null,
+    endDataItem: null,
+    target: e
+  }), {
+    content: [{ type: "text", text: `Selected rows where ${t} ${a} "${JSON.stringify(i)}".` }]
+  };
+}
+function ae(r, n, e, t, a) {
+  const i = n.id;
+  if (!i)
+    return { content: [{ type: "text", text: "Missing required argument: id" }], isError: !0 };
+  const o = e.current;
+  if (!o.onColumnsStateChange || !t)
+    return { content: [{ type: "text", text: "Column state changes not supported." }], isError: !0 };
+  const l = o.columnsState || t.columns || [], d = (c) => c.id === i || c.field === i;
+  switch (r) {
+    case "GridColumnReorder": {
+      const c = Number(n.position);
+      if (Number.isNaN(c))
+        return { content: [{ type: "text", text: "Missing required argument: position" }], isError: !0 };
+      const u = l.findIndex(d), s = l[u];
+      if (s) {
+        const p = [...l];
+        p.splice(u, 1), p.splice(c, 0, s), o.onColumnsStateChange({
+          columnsState: p.map((g, G) => ({ ...g, orderIndex: G })),
+          target: t
+        });
+      }
+      return { content: [{ type: "text", text: `Column ${i} moved to position ${c}.` }] };
+    }
+    case "GridColumnResize": {
+      const c = Number.parseInt(n.size, 10);
+      if (Number.isNaN(c))
+        return { content: [{ type: "text", text: "Missing required argument: size" }], isError: !0 };
+      const u = l.map((s) => d(s) ? { ...s, width: c } : s);
+      return o.onColumnsStateChange({ columnsState: u, target: t }), { content: [{ type: "text", text: `Column ${i} resized to ${c}px.` }] };
+    }
+    case "GridColumnShow": {
+      const c = l.map((u) => d(u) ? { ...u, hidden: !1 } : u);
+      return o.onColumnsStateChange({ columnsState: c, target: t }), { content: [{ type: "text", text: `Column ${i} is now visible.` }] };
+    }
+    case "GridColumnHide": {
+      const c = l.map((u) => d(u) ? { ...u, hidden: !0 } : u);
+      return o.onColumnsStateChange({ columnsState: c, target: t }), { content: [{ type: "text", text: `Column ${i} is now hidden.` }] };
+    }
+    case "GridColumnLock": {
+      const c = l.map((u) => d(u) ? { ...u, locked: !0 } : u);
+      return o.onColumnsStateChange({ columnsState: c, target: t }), { content: [{ type: "text", text: `Column ${i} locked.` }] };
+    }
+    case "GridColumnUnlock": {
+      const c = l.map((u) => d(u) ? { ...u, locked: !1 } : u);
+      return o.onColumnsStateChange({ columnsState: c, target: t }), { content: [{ type: "text", text: `Column ${i} unlocked.` }] };
+    }
+    default:
+      return null;
+  }
+}
+function ie(r, n, e, t) {
+  const a = e.current;
+  if (!a.onItemChange)
+    return null;
+  switch (r) {
+    case "GridAdd":
+      return a.onItemChange({
+        dataItem: n,
+        dataIndex: -1,
+        field: void 0,
+        value: void 0,
+        target: t
+      }), { content: [{ type: "text", text: "Record added." }] };
+    case "GridUpdate":
+      return a.onItemChange({
+        dataItem: n,
+        dataIndex: -1,
+        field: void 0,
+        value: void 0,
+        target: t
+      }), { content: [{ type: "text", text: "Record updated." }] };
+    case "GridDelete":
+      return a.onItemChange({ dataItem: n, dataIndex: -1, field: "_deleted", value: !0, target: t }), { content: [{ type: "text", text: "Record deleted." }] };
+    default:
+      return null;
+  }
+}
+function ce(r, n, e, t, a) {
+  switch (r) {
+    case "GridHighlight":
+      return ne(n, e, t);
+    case "GridClearHighlight":
+      return e.current.onHighlightChange && e.current.onHighlightChange({ highlight: {} }), { content: [{ type: "text", text: "Highlights cleared." }] };
+    case "GridSelect":
+      return oe(n, e, t);
+    case "GridClearSelect":
+      return e.current.onSelectionChange && e.current.onSelectionChange({ select: {}, target: t }), { content: [{ type: "text", text: "Selection cleared." }] };
+    case "GridSelectAll":
+      return de(e, t);
+    case "GridDetailExpand":
+    case "GridDetailCollapse":
+    case "GridDetailExpandAll":
+    case "GridDetailCollapseAll":
+      return le(r, n, e, t);
+    case "GridGroupExpand":
+    case "GridGroupCollapse":
+    case "GridGroupExpandAll":
+    case "GridGroupCollapseAll":
+      return ge(r, n, e, t);
+    case "GridSetAggregates":
+      return se(n, e, t);
+    case "GridExportPDF":
+      return t != null && t.exportAsPdf && t.exportAsPdf(), { content: [{ type: "text", text: "PDF export triggered." }] };
+    case "GridExportCSV":
+      return t != null && t.saveAsCsv ? t.saveAsCsv().then(() => ({ content: [{ type: "text", text: "CSV export triggered." }] })) : { content: [{ type: "text", text: "CSV export not available." }], isError: !0 };
+    case "GridExportExcel":
+      return t != null && t.saveAsExcel && t.saveAsExcel(), { content: [{ type: "text", text: "Excel export triggered." }] };
+    case "GridColumnReorder":
+    case "GridColumnResize":
+    case "GridColumnShow":
+    case "GridColumnHide":
+    case "GridColumnLock":
+    case "GridColumnUnlock":
+      return ae(r, n, e, t);
+    case "GridAdd":
+    case "GridUpdate":
+    case "GridDelete":
+      return ie(r, n, e, t);
+    default:
+      return null;
+  }
+}
+function N(r) {
+  return r == null ? null : typeof r == "string" || typeof r == "number" ? String(r) : null;
+}
+function I(r, n) {
+  const e = {};
+  for (const t of r) {
+    const a = N(t[n]);
+    a !== null && (e[a] = !0);
+  }
+  return e;
+}
+function de(r, n) {
+  var i, o;
+  const e = r.current;
+  if (!e.onHeaderSelectionChange && !e.onSelectionChange)
+    return { content: [{ type: "text", text: "Selection not enabled." }], isError: !0 };
+  const t = (o = (i = n == null ? void 0 : n.getLeafDataItems) == null ? void 0 : i.call(n)) != null ? o : [], a = e.dataItemKey;
+  if (e.onHeaderSelectionChange) {
+    const l = a ? I(t, a) : {};
+    e.onHeaderSelectionChange({
+      select: l,
+      field: void 0,
+      dataItems: t,
+      target: n
+    });
+  } else if (e.onSelectionChange) {
+    if (!a)
+      return { content: [{ type: "text", text: "dataItemKey prop is required for select all." }], isError: !0 };
+    e.onSelectionChange({ select: I(t, a), dataItems: t, target: n });
+  }
+  return { content: [{ type: "text", text: "All rows selected." }] };
+}
+function le(r, n, e, t) {
+  var l, d;
+  const a = e.current;
+  if (!a.onDetailExpandChange)
+    return { content: [{ type: "text", text: "onDetailExpandChange callback not provided." }], isError: !0 };
+  const i = a.dataItemKey;
+  if (!i)
+    return { content: [{ type: "text", text: "dataItemKey prop is required for detail expand." }], isError: !0 };
+  const o = (d = (l = t == null ? void 0 : t.getLeafDataItems) == null ? void 0 : l.call(t)) != null ? d : [];
+  switch (r) {
+    case "GridDetailExpandAll":
+      return a.onDetailExpandChange({ detailExpand: I(o, i), target: t }), { content: [{ type: "text", text: "All detail rows expanded." }] };
+    case "GridDetailCollapseAll":
+      return a.onDetailExpandChange({ detailExpand: {}, target: t }), { content: [{ type: "text", text: "All detail rows collapsed." }] };
+    case "GridDetailExpand":
+    case "GridDetailCollapse":
+      return ue(r, n, a, t, i, o);
+    default:
+      return { content: [{ type: "text", text: `Unknown expand command: ${r}` }], isError: !0 };
+  }
+}
+function ue(r, n, e, t, a, i) {
+  var g;
+  if (!n.field || !n.operator)
+    return {
+      content: [{ type: "text", text: "Missing required arguments: field, operator" }],
+      isError: !0
+    };
+  const o = n.field, l = n.operator, d = n.value, c = r === "GridDetailExpand", s = { ...(g = e.detailExpand) != null ? g : {} };
+  for (const G of i) {
+    const w = G[o];
+    if (k(w, l, d)) {
+      const S = N(G[a]);
+      S !== null && (c ? s[S] = !0 : delete s[S]);
+    }
+  }
+  return e.onDetailExpandChange && e.onDetailExpandChange({ detailExpand: s, target: t }), {
+    content: [{ type: "text", text: `Detail rows ${c ? "expanded" : "collapsed"} where ${o} ${l} "${d}".` }]
+  };
+}
+function k(r, n, e) {
+  switch (n) {
+    case "eq":
+      return r === e || String(r) === String(e);
+    case "neq":
+      return r !== e && String(r) !== String(e);
+    case "contains":
+      return typeof r == "string" && typeof e == "string" && r.toLowerCase().includes(e.toLowerCase());
+    case "startswith":
+      return typeof r == "string" && typeof e == "string" && r.toLowerCase().startsWith(e.toLowerCase());
+    case "gt":
+      return Number(r) > Number(e);
+    case "gte":
+      return Number(r) >= Number(e);
+    case "lt":
+      return Number(r) < Number(e);
+    case "lte":
+      return Number(r) <= Number(e);
+    default:
+      return !1;
+  }
+}
+function se(r, n, e) {
+  const t = n.current;
+  if (!t.groupable)
+    return {
+      content: [{ type: "text", text: "Grouping not enabled — aggregates require grouped data." }],
+      isError: !0
+    };
+  if (!t.group || t.group.length === 0)
+    return { content: [{ type: "text", text: "No active grouping — group the data first." }], isError: !0 };
+  if (!r.field || !r.aggregate)
+    return { content: [{ type: "text", text: "Missing required arguments: field, aggregate" }], isError: !0 };
+  const a = r.field, i = r.aggregate, o = { field: a, aggregate: i }, l = t.group.map((d) => {
+    var s;
+    const c = (s = d.aggregates) != null ? s : [];
+    return c.some((p) => p.field === a && p.aggregate === i) ? d : { ...d, aggregates: [...c, o] };
+  });
+  return C(n, t.onGroupChange, { group: l }, { group: l }, e), { content: [{ type: "text", text: `Aggregate "${i}" added for column "${a}".` }] };
+}
+function pe(r, n) {
+  const e = [];
+  for (const t of r) {
+    const a = /* @__PURE__ */ new Set();
+    for (const i of n) {
+      const o = i[t.field];
+      a.has(o) || (a.add(o), e.push({ field: t.field, value: o, expanded: !1 }));
+    }
+  }
+  return e;
+}
+function me(r, n, e) {
+  if (!r.field || r.value == null)
+    return null;
+  const t = r.field, a = r.value, i = typeof a == "string" || typeof a == "number" ? String(a) : JSON.stringify(a);
+  return { updated: n.find((d) => d.field === t && String(d.value) === i) ? n.map((d) => d.field === t && String(d.value) === i ? { ...d, expanded: e } : d) : [...n, { field: t, value: a, expanded: e }], field: t, valueStr: i };
+}
+function ge(r, n, e, t) {
+  var i, o, l;
+  const a = e.current;
+  if (!a.groupable)
+    return { content: [{ type: "text", text: "Grouping not enabled." }], isError: !0 };
+  if (!a.onGroupExpandChange)
+    return { content: [{ type: "text", text: "onGroupExpandChange callback not provided." }], isError: !0 };
+  switch (r) {
+    case "GridGroupExpandAll":
+      return a.onGroupExpandChange({ groupExpand: [], target: t }), { content: [{ type: "text", text: "All groups expanded." }] };
+    case "GridGroupCollapseAll": {
+      if (!a.group || a.group.length === 0)
+        return { content: [{ type: "text", text: "No active grouping." }], isError: !0 };
+      const d = (o = (i = t == null ? void 0 : t.getLeafDataItems) == null ? void 0 : i.call(t)) != null ? o : $(a.data), c = pe(a.group, d);
+      return a.onGroupExpandChange({ groupExpand: c, target: t }), { content: [{ type: "text", text: "All groups collapsed." }] };
+    }
+    case "GridGroupExpand":
+    case "GridGroupCollapse": {
+      const d = r === "GridGroupExpand", c = me(n, (l = a.groupExpand) != null ? l : [], d);
+      if (!c)
+        return { content: [{ type: "text", text: "Missing required arguments: field, value" }], isError: !0 };
+      a.onGroupExpandChange({ groupExpand: c.updated, target: t });
+      const u = d ? "expanded" : "collapsed";
+      return { content: [{ type: "text", text: `Group "${c.field}=${c.valueStr}" ${u}.` }] };
+    }
+    default:
+      return { content: [{ type: "text", text: `Unknown group expand command: ${r}` }], isError: !0 };
+  }
+}
+const ye = {
+  componentSuffix: "grid",
+  createTools(r, n, e, t) {
+    const a = [], i = (m) => `${e.groupName}_${m}`, o = n.current, l = Y(o.children), d = !!o.onHighlightChange, c = !!o.selectable, u = c && (!!o.onHeaderSelectionChange || !!o.dataItemKey), s = !!o.onDetailExpandChange, p = !!o.groupable && !!o.onGroupExpandChange, g = !!o.pdf, G = !!o.excel, w = !!o.csv, S = !!o.reorderable, J = !!o.resizable, h = !!o.onColumnsStateChange, D = !!o.onItemChange || !!o.editable, _ = [
+      {
+        name: "sort",
+        description: `Sort the ${e.dataName} grid by a column`,
+        commandType: "GridSort",
+        enabled: !!(o.sortable || o.columnMenu)
+      },
+      {
+        name: "clear_sort",
+        description: `Remove all sorting from the ${e.dataName} grid`,
+        commandType: "GridClearSort",
+        enabled: !!(o.sortable || o.columnMenu)
+      },
+      {
+        name: "filter",
+        description: `Filter the ${e.dataName} grid on a column`,
+        commandType: "GridFilter",
+        enabled: !!(o.filterable || o.columnMenu)
+      },
+      {
+        name: "clear_filters",
+        description: `Remove all filters from the ${e.dataName} grid`,
+        commandType: "GridClearFilter",
+        enabled: !!(o.filterable || o.columnMenu)
+      },
+      {
+        name: "group",
+        description: `Group the ${e.dataName} grid rows by a column`,
+        commandType: "GridGroup",
+        enabled: !!(o.groupable || o.columnMenu)
+      },
+      {
+        name: "clear_group",
+        description: `Remove all grouping from the ${e.dataName} grid`,
+        commandType: "GridClearGroup",
+        enabled: !!(o.groupable || o.columnMenu)
+      },
+      {
+        name: "page",
+        description: `Navigate to a specific page in the ${e.dataName} grid`,
+        commandType: "GridPage",
+        enabled: !!o.pageable
+      },
+      {
+        name: "set_page_size",
+        description: `Change the number of items per page in the ${e.dataName} grid`,
+        commandType: "GridPageSize",
+        enabled: !!o.pageable
+      },
+      {
+        name: "highlight",
+        description: `Visually highlight rows in the ${e.dataName} grid`,
+        commandType: "GridHighlight",
+        enabled: d
+      },
+      {
+        name: "clear_highlight",
+        description: `Remove all row highlighting from the ${e.dataName} grid`,
+        commandType: "GridClearHighlight",
+        enabled: d
+      },
+      {
+        name: "select",
+        description: `Select rows in the ${e.dataName} grid`,
+        commandType: "GridSelect",
+        enabled: c
+      },
+      {
+        name: "clear_select",
+        description: `Clear all row selections in the ${e.dataName} grid`,
+        commandType: "GridClearSelect",
+        enabled: c
+      },
+      {
+        name: "select_all",
+        description: `Select all rows in the ${e.dataName} grid`,
+        commandType: "GridSelectAll",
+        enabled: u
+      },
+      {
+        name: "detail_expand",
+        description: `Expand detail rows matching a condition in the ${e.dataName} grid`,
+        commandType: "GridDetailExpand",
+        enabled: s
+      },
+      {
+        name: "detail_collapse",
+        description: `Collapse detail rows matching a condition in the ${e.dataName} grid`,
+        commandType: "GridDetailCollapse",
+        enabled: s
+      },
+      {
+        name: "detail_expand_all",
+        description: `Expand all detail rows in the ${e.dataName} grid`,
+        commandType: "GridDetailExpandAll",
+        enabled: s
+      },
+      {
+        name: "detail_collapse_all",
+        description: `Collapse all detail rows in the ${e.dataName} grid`,
+        commandType: "GridDetailCollapseAll",
+        enabled: s
+      },
+      {
+        name: "group_expand",
+        description: `Expand a specific group in the ${e.dataName} grid`,
+        commandType: "GridGroupExpand",
+        enabled: p
+      },
+      {
+        name: "group_collapse",
+        description: `Collapse a specific group in the ${e.dataName} grid`,
+        commandType: "GridGroupCollapse",
+        enabled: p
+      },
+      {
+        name: "group_expand_all",
+        description: `Expand all groups in the ${e.dataName} grid`,
+        commandType: "GridGroupExpandAll",
+        enabled: p
+      },
+      {
+        name: "group_collapse_all",
+        description: `Collapse all groups in the ${e.dataName} grid`,
+        commandType: "GridGroupCollapseAll",
+        enabled: p
+      },
+      {
+        name: "set_aggregates",
+        description: `Add an aggregate function (sum, average, count, min, max) to a column in the ${e.dataName} grid. Requires active grouping.`,
+        commandType: "GridSetAggregates",
+        enabled: !!o.groupable
+      },
+      {
+        name: "export_pdf",
+        description: `Export the ${e.dataName} grid to PDF`,
+        commandType: "GridExportPDF",
+        enabled: g
+      },
+      {
+        name: "export_csv",
+        description: `Export the ${e.dataName} grid to CSV`,
+        commandType: "GridExportCSV",
+        enabled: w
+      },
+      {
+        name: "export_excel",
+        description: `Export the ${e.dataName} grid to Excel`,
+        commandType: "GridExportExcel",
+        enabled: G
+      },
+      {
+        name: "reorder_column",
+        description: `Reorder a column in the ${e.dataName} grid`,
+        commandType: "GridColumnReorder",
+        enabled: S
+      },
+      {
+        name: "resize_column",
+        description: `Resize a column in the ${e.dataName} grid`,
+        commandType: "GridColumnResize",
+        enabled: J
+      },
+      {
+        name: "show_column",
+        description: `Show a hidden column in the ${e.dataName} grid`,
+        commandType: "GridColumnShow",
+        enabled: h
+      },
+      {
+        name: "hide_column",
+        description: `Hide a column in the ${e.dataName} grid`,
+        commandType: "GridColumnHide",
+        enabled: h
+      },
+      {
+        name: "lock_column",
+        description: `Lock a column in the ${e.dataName} grid`,
+        commandType: "GridColumnLock",
+        enabled: h
+      },
+      {
+        name: "unlock_column",
+        description: `Unlock a column in the ${e.dataName} grid`,
+        commandType: "GridColumnUnlock",
+        enabled: h
+      },
+      {
+        name: "add",
+        description: `Add a new record to the ${e.dataName} grid`,
+        commandType: "GridAdd",
+        enabled: D
+      },
+      {
+        name: "update",
+        description: `Update a record in the ${e.dataName} grid`,
+        commandType: "GridUpdate",
+        enabled: D
+      },
+      {
+        name: "delete",
+        description: `Delete a record from the ${e.dataName} grid`,
+        commandType: "GridDelete",
+        enabled: D
+      },
+      {
+        name: "get_data",
+        description: `Read the data currently visible in the ${e.dataName} grid as JSON`,
+        commandType: "GridGetData",
+        enabled: !0
+      }
+    ], E = n.current.webMcp, T = typeof E == "object" && E !== null && typeof E.tools == "function" ? E.tools : void 0, j = { tname: i, columns: l, data: o.data }, W = T ? T(_, j) : _;
+    let x = null;
+    const X = async (m, f) => {
+      var M, q, z, P, F, K, L;
+      const v = (q = x == null ? void 0 : x.filters) != null ? q : (M = n.current.filter) == null ? void 0 : M.filters, b = re(m, f, n, r, v);
+      if (b)
+        return m === "GridFilter" && f.field && f.operator ? x = {
+          logic: "and",
+          filters: [...(F = (P = x == null ? void 0 : x.filters) != null ? P : (z = n.current.filter) == null ? void 0 : z.filters) != null ? F : [], { field: f.field, operator: f.operator, value: f.value }]
+        } : m === "GridClearFilter" && (x = { logic: "and", filters: [] }), b;
+      const H = ce(m, f, n, r);
+      if (H)
+        return H;
+      if (m === "GridGetData") {
+        x && await new Promise((B) => setTimeout(B, 100));
+        const A = 1e3, y = (L = (K = r == null ? void 0 : r.getLeafDataItems) == null ? void 0 : K.call(r)) != null ? L : $(n.current.data), U = Array.isArray(y) && y.length > A ? y.slice(0, A) : y;
+        return { content: [{ type: "text", text: JSON.stringify(U !== y ? { rows: U, truncated: !0, total: y.length } : y) }] };
+      }
+      return { content: [{ type: "text", text: `Unknown command: ${m}` }], isError: !0 };
+    };
+    for (const m of W) {
+      if (!m.enabled)
+        continue;
+      const f = Q(m.commandType, l), v = m.commandType;
+      try {
+        a.push(
+          t.registerTool({
+            name: i(m.name),
+            description: m.description,
+            inputSchema: f,
+            execute: async (b) => X(v, b || {})
+          })
+        );
+      } catch {
+      }
+    }
+    return a;
+  }
+};
+export {
+  ye as gridAdapter
+};