@toolbox-web/grid-react 0.9.0 → 0.11.0

package/features/export.d.ts

@@ -1,16 +1,59 @@
+import { ExportFormat, ExportParams } from '@toolbox-web/grid/plugins/export';
 /**
- * Export feature for @toolbox-web/grid-react
+ * Export methods returned from useGridExport.
+ */
+export interface ExportMethods {
+    /**
+     * Export grid data to CSV file.
+     * @param filename - Optional filename (defaults to 'export.csv')
+     * @param params - Optional export parameters
+     */
+    exportToCsv: (filename?: string, params?: Partial<ExportParams>) => void;
+    /**
+     * Export grid data to Excel file (XML Spreadsheet format).
+     * @param filename - Optional filename (defaults to 'export.xlsx')
+     * @param params - Optional export parameters
+     */
+    exportToExcel: (filename?: string, params?: Partial<ExportParams>) => void;
+    /**
+     * Export grid data to JSON file.
+     * @param filename - Optional filename (defaults to 'export.json')
+     * @param params - Optional export parameters
+     */
+    exportToJson: (filename?: string, params?: Partial<ExportParams>) => void;
+    /**
+     * Check if an export is currently in progress.
+     */
+    isExporting: () => boolean;
+    /**
+     * Get information about the last export.
+     */
+    getLastExport: () => {
+        format: ExportFormat;
+        timestamp: Date;
+    } | null;
+}
+/**
+ * Hook for programmatic export control.
  *
- * Import this module to enable the `export` prop on DataGrid.
+ * Must be used within a DataGrid component tree with the export feature enabled.
  *
  * @example
  * ```tsx
- * import '@toolbox-web/grid-react/features/export';
+ * import { useGridExport } from '@toolbox-web/grid-react/features/export';
  *
- * <DataGrid export />
- * ```
+ * function ExportToolbar() {
+ *   const { exportToCsv, exportToExcel, exportToJson, isExporting } = useGridExport();
  *
- * @packageDocumentation
+ *   return (
+ *     <div>
+ *       <button onClick={() => exportToCsv()} disabled={isExporting()}>CSV</button>
+ *       <button onClick={() => exportToExcel()} disabled={isExporting()}>Excel</button>
+ *       <button onClick={() => exportToJson()} disabled={isExporting()}>JSON</button>
+ *     </div>
+ *   );
+ * }
+ * ```
  */
-export {};
+export declare function useGridExport(): ExportMethods;
 //# sourceMappingURL=export.d.ts.map

package/features/export.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../../libs/grid-react/src/features/export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../../libs/grid-react/src/features/export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,EAAgB,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAUtG;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,WAAW,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,IAAI,CAAC;IAEzE;;;;OAIG;IACH,aAAa,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,IAAI,CAAC;IAE3E;;;;OAIG;IACH,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,IAAI,CAAC;IAE1E;;OAEG;IACH,WAAW,EAAE,MAAM,OAAO,CAAC;IAE3B;;OAEG;IACH,aAAa,EAAE,MAAM;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;CACvE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,IAAI,aAAa,CAuE7C"}

package/features/export.js

@@ -1,6 +1,66 @@
-import { ExportPlugin as t } from "@toolbox-web/grid/plugins/export";
-import { r as e } from "../chunks/feature-registry-Y3KvnN54.js";
-e("export", (r) => {
-  const o = typeof r == "boolean" ? {} : r ?? {};
-  return new t(o);
+import { ExportPlugin as p } from "@toolbox-web/grid/plugins/export";
+import { useContext as a, useCallback as n } from "react";
+import { G as c } from "../chunks/data-grid-GKyKxE6c.js";
+import { r as f } from "../chunks/feature-registry-Y3KvnN54.js";
+f("export", (i) => {
+  const t = typeof i == "boolean" ? {} : i ?? {};
+  return new p(t);
 });
+function w() {
+  const i = a(c), t = n(() => i?.current?.getPlugin(p), [i]), x = n(
+    (e, o) => {
+      const r = t();
+      if (!r) {
+        console.warn(
+          `[tbw-grid:export] ExportPlugin not found.
+
+  → Enable export on the grid:
+    <DataGrid export />`
+        );
+        return;
+      }
+      r.exportCsv({ ...o, fileName: e ?? o?.fileName ?? "export.csv" });
+    },
+    [t]
+  ), l = n(
+    (e, o) => {
+      const r = t();
+      if (!r) {
+        console.warn(
+          `[tbw-grid:export] ExportPlugin not found.
+
+  → Enable export on the grid:
+    <DataGrid export />`
+        );
+        return;
+      }
+      r.exportExcel({ ...o, fileName: e ?? o?.fileName ?? "export.xlsx" });
+    },
+    [t]
+  ), s = n(
+    (e, o) => {
+      const r = t();
+      if (!r) {
+        console.warn(
+          `[tbw-grid:export] ExportPlugin not found.
+
+  → Enable export on the grid:
+    <DataGrid export />`
+        );
+        return;
+      }
+      r.exportJson({ ...o, fileName: e ?? o?.fileName ?? "export.json" });
+    },
+    [t]
+  ), u = n(() => t()?.isExporting() ?? !1, [t]), g = n(() => t()?.getLastExport() ?? null, [t]);
+  return {
+    exportToCsv: x,
+    exportToExcel: l,
+    exportToJson: s,
+    isExporting: u,
+    getLastExport: g
+  };
+}
+export {
+  w as useGridExport
+};

package/features/filtering.d.ts

@@ -1,16 +1,71 @@
+import { FilterModel } from '@toolbox-web/grid/plugins/filtering';
 /**
- * Filtering feature for @toolbox-web/grid-react
+ * Filtering methods returned from useGridFiltering.
+ */
+export interface FilteringMethods {
+    /**
+     * Set a filter on a specific field.
+     * @param field - The field name to filter
+     * @param filter - Filter configuration, or null to remove
+     */
+    setFilter: (field: string, filter: Omit<FilterModel, 'field'> | null) => void;
+    /**
+     * Get the current filter for a field.
+     */
+    getFilter: (field: string) => FilterModel | undefined;
+    /**
+     * Get all active filters.
+     */
+    getFilters: () => FilterModel[];
+    /**
+     * Set all filters at once (replaces existing).
+     */
+    setFilterModel: (filters: FilterModel[]) => void;
+    /**
+     * Clear all active filters.
+     */
+    clearAllFilters: () => void;
+    /**
+     * Clear filter for a specific field.
+     */
+    clearFieldFilter: (field: string) => void;
+    /**
+     * Check if a field has an active filter.
+     */
+    isFieldFiltered: (field: string) => boolean;
+    /**
+     * Get the count of rows after filtering.
+     */
+    getFilteredRowCount: () => number;
+    /**
+     * Get unique values for a field (for building filter dropdowns).
+     */
+    getUniqueValues: (field: string) => unknown[];
+}
+/**
+ * Hook for programmatic filter control.
  *
- * Import this module to enable the `filtering` prop on DataGrid.
+ * Must be used within a DataGrid component tree with filtering enabled.
  *
  * @example
  * ```tsx
- * import '@toolbox-web/grid-react/features/filtering';
+ * import { useGridFiltering } from '@toolbox-web/grid-react/features/filtering';
  *
- * <DataGrid filtering={{ debounceMs: 200 }} />
- * ```
+ * function QuickFilters() {
+ *   const { setFilter, clearAllFilters, getFilteredRowCount, isFieldFiltered } = useGridFiltering();
  *
- * @packageDocumentation
+ *   return (
+ *     <div>
+ *       <input
+ *         placeholder="Filter by name..."
+ *         onChange={(e) => setFilter('name', e.target.value ? { operator: 'contains', value: e.target.value } : null)}
+ *       />
+ *       <span>{getFilteredRowCount()} rows</span>
+ *       <button onClick={clearAllFilters}>Clear All</button>
+ *     </div>
+ *   );
+ * }
+ * ```
  */
-export {};
+export declare function useGridFiltering(): FilteringMethods;
 //# sourceMappingURL=filtering.d.ts.map

package/features/filtering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filtering.d.ts","sourceRoot":"","sources":["../../../../libs/grid-react/src/features/filtering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}
+{"version":3,"file":"filtering.d.ts","sourceRoot":"","sources":["../../../../libs/grid-react/src/features/filtering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAUxF;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC;IAE9E;;OAEG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,CAAC;IAEtD;;OAEG;IACH,UAAU,EAAE,MAAM,WAAW,EAAE,CAAC;IAEhC;;OAEG;IACH,cAAc,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,IAAI,CAAC;IAEjD;;OAEG;IACH,eAAe,EAAE,MAAM,IAAI,CAAC;IAE5B;;OAEG;IACH,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAE1C;;OAEG;IACH,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAE5C;;OAEG;IACH,mBAAmB,EAAE,MAAM,MAAM,CAAC;IAElC;;OAEG;IACH,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,EAAE,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,IAAI,gBAAgB,CA0FnD"}

package/features/filtering.js

@@ -1,6 +1,82 @@
-import { FilteringPlugin as t } from "@toolbox-web/grid/plugins/filtering";
-import { r as o } from "../chunks/feature-registry-Y3KvnN54.js";
-o("filtering", (r) => {
-  const e = typeof r == "boolean" ? {} : r ?? {};
-  return new t(e);
+import { FilteringPlugin as o } from "@toolbox-web/grid/plugins/filtering";
+import { useContext as w, useCallback as i } from "react";
+import { G as b } from "../chunks/data-grid-GKyKxE6c.js";
+import { r as m } from "../chunks/feature-registry-Y3KvnN54.js";
+m("filtering", (r) => {
+  const t = typeof r == "boolean" ? {} : r ?? {};
+  return new o(t);
 });
+function h() {
+  const r = w(b), t = i(() => r?.current?.getPlugin(o), [r]), g = i(
+    (e, n) => {
+      const l = t();
+      if (!l) {
+        console.warn(
+          `[tbw-grid:filtering] FilteringPlugin not found.
+
+  → Enable filtering on the grid:
+    <DataGrid filtering />`
+        );
+        return;
+      }
+      l.setFilter(e, n);
+    },
+    [t]
+  ), s = i((e) => t()?.getFilter(e), [t]), u = i(() => t()?.getFilters() ?? [], [t]), d = i(
+    (e) => {
+      const n = t();
+      if (!n) {
+        console.warn(
+          `[tbw-grid:filtering] FilteringPlugin not found.
+
+  → Enable filtering on the grid:
+    <DataGrid filtering />`
+        );
+        return;
+      }
+      n.setFilterModel(e);
+    },
+    [t]
+  ), a = i(() => {
+    const e = t();
+    if (!e) {
+      console.warn(
+        `[tbw-grid:filtering] FilteringPlugin not found.
+
+  → Enable filtering on the grid:
+    <DataGrid filtering />`
+      );
+      return;
+    }
+    e.clearAllFilters();
+  }, [t]), f = i(
+    (e) => {
+      const n = t();
+      if (!n) {
+        console.warn(
+          `[tbw-grid:filtering] FilteringPlugin not found.
+
+  → Enable filtering on the grid:
+    <DataGrid filtering />`
+        );
+        return;
+      }
+      n.clearFieldFilter(e);
+    },
+    [t]
+  ), c = i((e) => t()?.isFieldFiltered(e) ?? !1, [t]), F = i(() => t()?.getFilteredRowCount() ?? 0, [t]), p = i((e) => t()?.getUniqueValues(e) ?? [], [t]);
+  return {
+    setFilter: g,
+    getFilter: s,
+    getFilters: u,
+    setFilterModel: d,
+    clearAllFilters: a,
+    clearFieldFilter: f,
+    isFieldFiltered: c,
+    getFilteredRowCount: F,
+    getUniqueValues: p
+  };
+}
+export {
+  h as useGridFiltering
+};

package/features/print.d.ts

@@ -1,16 +1,43 @@
+import { PrintParams } from '@toolbox-web/grid/plugins/print';
 /**
- * Print feature for @toolbox-web/grid-react
+ * Print methods returned from useGridPrint.
+ */
+export interface PrintMethods {
+    /**
+     * Print the grid.
+     * Opens browser print dialog after preparing the grid for printing.
+     * @param params - Optional print parameters
+     */
+    print: (params?: PrintParams) => Promise<void>;
+    /**
+     * Check if a print operation is currently in progress.
+     */
+    isPrinting: () => boolean;
+}
+/**
+ * Hook for programmatic print control.
  *
- * Import this module to enable the `print` prop on DataGrid.
+ * Must be used within a DataGrid component tree with print enabled.
  *
  * @example
  * ```tsx
- * import '@toolbox-web/grid-react/features/print';
+ * import { useGridPrint } from '@toolbox-web/grid-react/features/print';
  *
- * <DataGrid print />
- * ```
+ * function PrintToolbar() {
+ *   const { print, isPrinting } = useGridPrint();
  *
- * @packageDocumentation
+ *   const handlePrint = async () => {
+ *     await print({ title: 'My Report', isolate: true });
+ *     console.log('Print dialog closed');
+ *   };
+ *
+ *   return (
+ *     <button onClick={handlePrint} disabled={isPrinting()}>
+ *       {isPrinting() ? 'Printing...' : 'Print Report'}
+ *     </button>
+ *   );
+ * }
+ * ```
  */
-export {};
+export declare function useGridPrint(): PrintMethods;
 //# sourceMappingURL=print.d.ts.map

package/features/print.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../../../../libs/grid-react/src/features/print.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}
+{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../../../../libs/grid-react/src/features/print.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAYhF;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/C;;OAEG;IACH,UAAU,EAAE,MAAM,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,IAAI,YAAY,CAyB3C"}

package/features/print.js

@@ -1,3 +1,27 @@
-import { PrintPlugin as e } from "@toolbox-web/grid/plugins/print";
-import { r as t } from "../chunks/feature-registry-Y3KvnN54.js";
-t("print", (r) => r === !0 ? new e() : new e(r ?? void 0));
+import { PrintPlugin as i } from "@toolbox-web/grid/plugins/print";
+import { useContext as g, useCallback as n } from "react";
+import { G as a } from "../chunks/data-grid-GKyKxE6c.js";
+import { r as p } from "../chunks/feature-registry-Y3KvnN54.js";
+p("print", (r) => r === !0 ? new i() : new i(r ?? void 0));
+function m() {
+  const r = g(a), t = n(() => r?.current?.getPlugin(i), [r]), u = n(
+    async (e) => {
+      const o = t();
+      if (!o) {
+        console.warn(
+          `[tbw-grid:print] PrintPlugin not found.
+
+  → Enable print on the grid:
+    <DataGrid print />`
+        );
+        return;
+      }
+      await o.print(e);
+    },
+    [t]
+  ), s = n(() => t()?.isPrinting() ?? !1, [t]);
+  return { print: u, isPrinting: s };
+}
+export {
+  m as useGridPrint
+};

package/features/selection.d.ts

@@ -1,16 +1,56 @@
+import { CellRange, SelectionResult } from '@toolbox-web/grid/plugins/selection';
 /**
- * Selection feature for @toolbox-web/grid-react
+ * Selection methods returned from useGridSelection.
  *
- * Import this module to enable the `selection` prop on DataGrid.
+ * Uses React context to access the grid ref - works reliably regardless of
+ * when the grid mounts or conditional rendering.
+ */
+export interface SelectionMethods {
+    /**
+     * Select all rows (row mode) or all cells (range mode).
+     */
+    selectAll: () => void;
+    /**
+     * Clear all selection.
+     */
+    clearSelection: () => void;
+    /**
+     * Get the current selection state.
+     * Use this to derive selected rows, indices, etc.
+     */
+    getSelection: () => SelectionResult | null;
+    /**
+     * Check if a specific cell is selected.
+     */
+    isCellSelected: (row: number, col: number) => boolean;
+    /**
+     * Set selection ranges programmatically.
+     */
+    setRanges: (ranges: CellRange[]) => void;
+}
+/**
+ * Hook for programmatic selection control.
+ *
+ * Must be used within a DataGrid component tree with the selection feature enabled.
+ * Uses React context, so it works reliably regardless of when the grid mounts.
  *
  * @example
  * ```tsx
- * import '@toolbox-web/grid-react/features/selection';
+ * import { useGridSelection } from '@toolbox-web/grid-react/features/selection';
  *
- * <DataGrid selection="range" />
- * ```
+ * function ExportSelectedButton() {
+ *   const { getSelection, clearSelection } = useGridSelection();
+ *
+ *   const handleExport = () => {
+ *     const selection = getSelection();
+ *     if (!selection) return;
+ *     // Derive rows from selection.ranges and grid.rows
+ *     clearSelection();
+ *   };
  *
- * @packageDocumentation
+ *   return <button onClick={handleExport}>Export Selected</button>;
+ * }
+ * ```
  */
-export {};
+export declare function useGridSelection<TRow = unknown>(): SelectionMethods;
 //# sourceMappingURL=selection.d.ts.map

package/features/selection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../../../libs/grid-react/src/features/selection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../../../libs/grid-react/src/features/selection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,EAAmB,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAc5G;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,SAAS,EAAE,MAAM,IAAI,CAAC;IAEtB;;OAEG;IACH,cAAc,EAAE,MAAM,IAAI,CAAC;IAE3B;;;OAGG;IACH,YAAY,EAAE,MAAM,eAAe,GAAG,IAAI,CAAC;IAE3C;;OAEG;IACH,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IAEtD;;OAEG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,IAAI,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,GAAG,OAAO,KAAK,gBAAgB,CAkEnE"}

package/features/selection.js

@@ -1,3 +1,48 @@
-import { SelectionPlugin as r } from "@toolbox-web/grid/plugins/selection";
-import { r as t } from "../chunks/feature-registry-Y3KvnN54.js";
-t("selection", (e) => e === "cell" || e === "row" || e === "range" ? new r({ mode: e }) : new r(e ?? void 0));
+import { SelectionPlugin as i } from "@toolbox-web/grid/plugins/selection";
+import { useContext as w, useCallback as o } from "react";
+import { G as S } from "../chunks/data-grid-GKyKxE6c.js";
+import { r as C } from "../chunks/feature-registry-Y3KvnN54.js";
+C("selection", (e) => e === "cell" || e === "row" || e === "range" ? new i({ mode: e }) : new i(e ?? void 0));
+function P() {
+  const e = w(S), t = o(() => e?.current?.getPlugin(i), [e]), g = o(() => {
+    const n = t();
+    if (!n) {
+      console.warn(
+        `[tbw-grid:selection] SelectionPlugin not found.
+
+  → Enable selection on the grid:
+    <DataGrid selection="range" />`
+      );
+      return;
+    }
+    const r = e?.current, u = n.config?.mode;
+    if (u === "row") {
+      const s = r?.rows?.length ?? 0, l = /* @__PURE__ */ new Set();
+      for (let c = 0; c < s; c++) l.add(c);
+      n.selected = l, n.requestAfterRender?.();
+    } else if (u === "range") {
+      const s = r?.rows?.length ?? 0, l = r?._columns?.length ?? 0;
+      s > 0 && l > 0 && n.setRanges([{ from: { row: 0, col: 0 }, to: { row: s - 1, col: l - 1 } }]);
+    }
+  }, [t, e]), d = o(() => {
+    t()?.clearSelection();
+  }, [t]), a = o(() => t()?.getSelection() ?? null, [t]), m = o(
+    (n, r) => t()?.isCellSelected(n, r) ?? !1,
+    [t]
+  ), f = o(
+    (n) => {
+      t()?.setRanges(n);
+    },
+    [t]
+  );
+  return {
+    selectAll: g,
+    clearSelection: d,
+    getSelection: a,
+    isCellSelected: m,
+    setRanges: f
+  };
+}
+export {
+  P as useGridSelection
+};

package/features/undo-redo.d.ts

@@ -1,18 +1,60 @@
+import { EditAction } from '@toolbox-web/grid/plugins/undo-redo';
 /**
- * Undo/Redo feature for @toolbox-web/grid-react
+ * Undo/Redo methods returned from useGridUndoRedo.
+ */
+export interface UndoRedoMethods {
+    /**
+     * Undo the last edit action.
+     * @returns The undone action, or null if nothing to undo
+     */
+    undo: () => EditAction | null;
+    /**
+     * Redo the last undone action.
+     * @returns The redone action, or null if nothing to redo
+     */
+    redo: () => EditAction | null;
+    /**
+     * Check if there are any actions that can be undone.
+     */
+    canUndo: () => boolean;
+    /**
+     * Check if there are any actions that can be redone.
+     */
+    canRedo: () => boolean;
+    /**
+     * Clear all undo/redo history.
+     */
+    clearHistory: () => void;
+    /**
+     * Get a copy of the current undo stack.
+     */
+    getUndoStack: () => EditAction[];
+    /**
+     * Get a copy of the current redo stack.
+     */
+    getRedoStack: () => EditAction[];
+}
+/**
+ * Hook for programmatic undo/redo control.
  *
- * Import this module to enable the `undoRedo` prop on DataGrid.
- * Requires the editing feature to be enabled.
+ * Must be used within a DataGrid component tree with undoRedo and editing enabled.
  *
  * @example
  * ```tsx
- * import '@toolbox-web/grid-react/features/editing';
- * import '@toolbox-web/grid-react/features/undo-redo';
+ * import { useGridUndoRedo } from '@toolbox-web/grid-react/features/undo-redo';
  *
- * <DataGrid editing="dblclick" undoRedo={{ maxHistorySize: 100 }} />
- * ```
+ * function UndoRedoControls() {
+ *   const { undo, redo, canUndo, canRedo, clearHistory } = useGridUndoRedo();
  *
- * @packageDocumentation
+ *   return (
+ *     <div>
+ *       <button onClick={undo} disabled={!canUndo()}>Undo</button>
+ *       <button onClick={redo} disabled={!canRedo()}>Redo</button>
+ *       <button onClick={clearHistory}>Clear History</button>
+ *     </div>
+ *   );
+ * }
+ * ```
  */
-export {};
+export declare function useGridUndoRedo(): UndoRedoMethods;
 //# sourceMappingURL=undo-redo.d.ts.map

package/features/undo-redo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"undo-redo.d.ts","sourceRoot":"","sources":["../../../../libs/grid-react/src/features/undo-redo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG"}
+{"version":3,"file":"undo-redo.d.ts","sourceRoot":"","sources":["../../../../libs/grid-react/src/features/undo-redo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAUtF;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,IAAI,EAAE,MAAM,UAAU,GAAG,IAAI,CAAC;IAE9B;;;OAGG;IACH,IAAI,EAAE,MAAM,UAAU,GAAG,IAAI,CAAC;IAE9B;;OAEG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC;IAEvB;;OAEG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC;IAEvB;;OAEG;IACH,YAAY,EAAE,MAAM,IAAI,CAAC;IAEzB;;OAEG;IACH,YAAY,EAAE,MAAM,UAAU,EAAE,CAAC;IAEjC;;OAEG;IACH,YAAY,EAAE,MAAM,UAAU,EAAE,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,IAAI,eAAe,CAwDjD"}

package/features/undo-redo.js

@@ -1,6 +1,43 @@
-import { UndoRedoPlugin as r } from "@toolbox-web/grid/plugins/undo-redo";
-import { r as t } from "../chunks/feature-registry-Y3KvnN54.js";
-t("undoRedo", (o) => {
-  const e = typeof o == "boolean" ? {} : o ?? {};
-  return new r(e);
+import { UndoRedoPlugin as t } from "@toolbox-web/grid/plugins/undo-redo";
+import { useContext as g, useCallback as e } from "react";
+import { G as R } from "../chunks/data-grid-GKyKxE6c.js";
+import { r as f } from "../chunks/feature-registry-Y3KvnN54.js";
+f("undoRedo", (d) => {
+  const o = typeof d == "boolean" ? {} : d ?? {};
+  return new t(o);
 });
+function k() {
+  const d = g(R), o = e(() => d?.current?.getPlugin(t), [d]), r = e(() => {
+    const n = o();
+    return n ? n.undo() : (console.warn(
+      `[tbw-grid:undoRedo] UndoRedoPlugin not found.
+
+  → Enable undo/redo on the grid:
+    <DataGrid editing="dblclick" undoRedo />`
+    ), null);
+  }, [o]), i = e(() => {
+    const n = o();
+    return n ? n.redo() : (console.warn(
+      `[tbw-grid:undoRedo] UndoRedoPlugin not found.
+
+  → Enable undo/redo on the grid:
+    <DataGrid editing="dblclick" undoRedo />`
+    ), null);
+  }, [o]), u = e(() => o()?.canUndo() ?? !1, [o]), c = e(() => o()?.canRedo() ?? !1, [o]), l = e(() => {
+    const n = o();
+    if (!n) {
+      console.warn(
+        `[tbw-grid:undoRedo] UndoRedoPlugin not found.
+
+  → Enable undo/redo on the grid:
+    <DataGrid editing="dblclick" undoRedo />`
+      );
+      return;
+    }
+    n.clearHistory();
+  }, [o]), a = e(() => o()?.getUndoStack() ?? [], [o]), s = e(() => o()?.getRedoStack() ?? [], [o]);
+  return { undo: r, redo: i, canUndo: u, canRedo: c, clearHistory: l, getUndoStack: a, getRedoStack: s };
+}
+export {
+  k as useGridUndoRedo
+};