@vuu-ui/vuu-data-editing 3.0.0-beta.3 → 3.1.0-beta.1

package/package.json

@@ -1,18 +1,24 @@
 {
-  "version": "3.0.0-beta.3",
+  "version": "3.1.0-beta.1",
   "description": "Shared data editing APIs and React components for VUU UI",
+  "main": "src/index.ts",
   "author": "heswell",
   "license": "Apache-2.0",
   "type": "module",
+  "scripts": {
+    "build": "node ../../scripts/run-build-rslib.ts",
+    "test": "vitest run",
+    "type-defs": "node ../../scripts/build-type-defs.mjs"
+  },
   "dependencies": {
     "@salt-ds/core": "1.54.1",
-    "@vuu-ui/vuu-ui-controls": "3.0.0-beta.3",
-    "@vuu-ui/vuu-utils": "3.0.0-beta.3"
+    "@vuu-ui/vuu-ui-controls": "3.1.0-beta.1",
+    "@vuu-ui/vuu-utils": "3.1.0-beta.1"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "3.0.0-beta.3",
-    "@vuu-ui/vuu-protocol-types": "3.0.0-beta.3",
-    "@vuu-ui/vuu-table-types": "3.0.0-beta.3"
+    "@vuu-ui/vuu-data-types": "3.1.0-beta.1",
+    "@vuu-ui/vuu-protocol-types": "3.1.0-beta.1",
+    "@vuu-ui/vuu-table-types": "3.1.0-beta.1"
   },
   "peerDependencies": {
     "react": "^19.2.3"
@@ -20,19 +26,16 @@
   "sideEffects": false,
   "files": [
     "README.md",
-    "esm",
-    "cjs",
+    "src",
     "/types"
   ],
   "exports": {
     ".": {
-      "require": "./cjs/index.js",
-      "import": "./esm/index.js",
+      "import": "./src/index.js",
       "types": "./types/index.d.ts"
     }
   },
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
+  "module": "index.js",
   "name": "@vuu-ui/vuu-data-editing",
   "types": "types/index.d.ts"
 }

package/src/DataEditingProvider.js

@@ -0,0 +1,13 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const DataEditingContext = /*#__PURE__*/ createContext(void 0);
+const DataEditingProvider = ({ children, editSession })=>/*#__PURE__*/ jsx(DataEditingContext.Provider, {
+        value: editSession,
+        children: children
+    });
+function useEditSession(throwIfUnavailable = false) {
+    const editSession = useContext(DataEditingContext);
+    if (void 0 !== editSession) return editSession;
+    if (throwIfUnavailable) throw Error("[useEditSession] no DataEditingContext in scope. You need to enclose editable component(s) with DataEditingProvider");
+}
+export { DataEditingProvider, useEditSession };

package/src/EditButtons.js

@@ -0,0 +1,58 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Button } from "@salt-ds/core";
+import { useCallback, useEffect, useState } from "react";
+const EditButtons = ({ canCancel, canSave, confirmCancel, confirmSave, editSession, hasSelection = false, onCancel, onDelete, onSave, saveLabel = "Save" })=>{
+    const [editState, setEditState] = useState(()=>editSession?.editState ?? "clean");
+    const handleSave = useCallback(async ()=>{
+        if (confirmSave) {
+            const confirmed = await confirmSave();
+            if (!confirmed) return;
+        }
+        onSave("stale" === editState);
+    }, [
+        confirmSave,
+        editState,
+        onSave
+    ]);
+    const handleCancel = useCallback(async ()=>{
+        if (confirmCancel) {
+            const confirmed = await confirmCancel();
+            if (!confirmed) return;
+        }
+        onCancel?.();
+    }, [
+        confirmCancel,
+        onCancel
+    ]);
+    useEffect(()=>{
+        if (editSession) {
+            setEditState(editSession.editState);
+            editSession.on("editState", setEditState);
+            return ()=>editSession.removeListener("editState", setEditState);
+        }
+    }, [
+        editSession
+    ]);
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            onDelete && /*#__PURE__*/ jsx(Button, {
+                disabled: !hasSelection,
+                onClick: onDelete,
+                sentiment: "negative",
+                children: "Delete"
+            }),
+            /*#__PURE__*/ jsx(Button, {
+                disabled: !canSave,
+                onClick: handleSave,
+                sentiment: "accented",
+                children: "stale" === editState ? `${saveLabel} (force)` : saveLabel
+            }),
+            onCancel && /*#__PURE__*/ jsx(Button, {
+                disabled: !canCancel,
+                onClick: handleCancel,
+                children: "Cancel"
+            })
+        ]
+    });
+};
+export { EditButtons };

package/src/EditModeProvider.js

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState } from "react";
+const EditModeContext = /*#__PURE__*/ createContext({
+    isEditMode: false,
+    setEditMode: ()=>"EditModeProvider in place"
+});
+const EditModeProvider = ({ children })=>{
+    const [isEditMode, setEditMode] = useState(false);
+    return /*#__PURE__*/ jsx(EditModeContext.Provider, {
+        value: {
+            isEditMode,
+            setEditMode
+        },
+        children: children
+    });
+};
+const useEditMode = ()=>useContext(EditModeContext);
+export { EditModeProvider, useEditMode };

package/src/EditSession.js

@@ -0,0 +1,482 @@
+import { EventEmitter, StaleUpdateError, isRpcError } from "@vuu-ui/vuu-utils";
+const toEditSessionMode = (copyOption)=>{
+    switch(copyOption){
+        case "All":
+            return "all-rows";
+        case "Selected":
+            return "selected-rows";
+        case "Empty":
+            return "empty-session-table";
+    }
+};
+class EditError extends Error {
+}
+class SupersededEditError extends Error {
+}
+class EditSession extends EventEmitter {
+    static newRowKey = "__vuu_new_row__";
+    #rowEdits = new Map();
+    #deletedRows = new Set();
+    #deleteRevision = 0;
+    #rowDeleteRevisions = new Map();
+    #editCount = 0;
+    #deleteCount = 0;
+    #addCount = 0;
+    #invalidCount = 0;
+    #isStale = false;
+    #commitRevision = 0;
+    #cellCommitRevisions = new Map();
+    #deleteMode;
+    #editSessionApi;
+    #sourceTableDataSource;
+    #sessionDataSource;
+    #newRowState = {
+        columns: [],
+        draftRevision: 0,
+        errors: {},
+        submitting: false,
+        values: {}
+    };
+    #lifecycle = {
+        status: "idle"
+    };
+    #transitionQueue = Promise.resolve();
+    constructor(dataSource, deleteMode = "soft", editSessionApi = "createSessionDataSource"){
+        super();
+        this.#sourceTableDataSource = dataSource;
+        this.#deleteMode = deleteMode;
+        this.#editSessionApi = editSessionApi;
+    }
+    get editCount() {
+        return this.#editCount;
+    }
+    set editCount(val) {
+        this.#setEditCounts(val, this.#invalidCount);
+    }
+    get invalidCount() {
+        return this.#invalidCount;
+    }
+    set invalidCount(val) {
+        this.#setEditCounts(this.#editCount, val);
+    }
+    get deleteCount() {
+        return this.#deleteCount;
+    }
+    set deleteCount(val) {
+        if (val !== this.#deleteCount) {
+            const oldState = this.editState;
+            const oldCount = this.#deleteCount;
+            this.#deleteCount = val;
+            this.#emitEditStateChange(oldState, 0 === oldCount || 0 === val);
+        }
+    }
+    get addCount() {
+        return this.#addCount;
+    }
+    set addCount(val) {
+        if (val !== this.#addCount) {
+            const oldState = this.editState;
+            const oldCount = this.#addCount;
+            this.#addCount = val;
+            this.#emitEditStateChange(oldState, 0 === oldCount || 0 === val);
+        }
+    }
+    get editState() {
+        if (this.#invalidCount > 0) return "invalid";
+        if (this.#isStale) return "stale";
+        return 0 === this.#editCount && 0 === this.#deleteCount && 0 === this.#addCount ? "clean" : "dirty";
+    }
+    #emitEditStateChange(oldState, force = false) {
+        const newState = this.editState;
+        if (force || newState !== oldState) this.emit("editState", newState);
+    }
+    #setEditCounts(editCount, invalidCount) {
+        if (editCount !== this.#editCount || invalidCount !== this.#invalidCount) {
+            const oldState = this.editState;
+            this.#editCount = editCount;
+            this.#invalidCount = invalidCount;
+            this.#emitEditStateChange(oldState);
+        }
+    }
+    #setStale(isStale) {
+        if (isStale !== this.#isStale) {
+            const oldState = this.editState;
+            this.#isStale = isStale;
+            this.#emitEditStateChange(oldState);
+        }
+    }
+    #refreshEditCounts() {
+        let editCount = 0;
+        let invalidCount = 0;
+        for (const { cellEdits } of this.#rowEdits.values())for (const cellEdit of cellEdits.values())if (cellEdit.isValid) editCount++;
+        else invalidCount++;
+        this.#setEditCounts(editCount, invalidCount);
+    }
+    get newRowState() {
+        return this.#newRowState;
+    }
+    isNewRow(key) {
+        return key === EditSession.newRowKey;
+    }
+    isNewRowFinalColumn(columnName) {
+        return this.#newRowState.columns.at(-1) === columnName;
+    }
+    isNewRowComplete() {
+        return this.#newRowState.columns.every((column)=>{
+            const value = this.#newRowState.values[column];
+            return void 0 !== value && ("string" != typeof value || "" !== value.trim());
+        });
+    }
+    configureNewRow(columns) {
+        if (columns.length === this.#newRowState.columns.length && columns.every((column, index)=>column === this.#newRowState.columns[index])) return;
+        const columnSet = new Set(columns);
+        const errors = Object.fromEntries(Object.entries(this.#newRowState.errors).filter(([column])=>columnSet.has(column)));
+        this.#setNewRowState({
+            ...this.#newRowState,
+            columns: [
+                ...columns
+            ],
+            errors
+        });
+    }
+    setNewRowValue(column, value) {
+        const errors = {
+            ...this.#newRowState.errors
+        };
+        delete errors[column];
+        this.#setNewRowState({
+            ...this.#newRowState,
+            errors,
+            values: {
+                ...this.#newRowState.values,
+                [column]: value
+            }
+        });
+    }
+    async addNewRow() {
+        const missingErrors = Object.fromEntries(this.#newRowState.columns.filter((column)=>{
+            const value = this.#newRowState.values[column];
+            return void 0 === value || "string" == typeof value && "" === value.trim();
+        }).map((column)=>[
+                column,
+                "Value required"
+            ]));
+        const errors = {
+            ...this.#newRowState.errors,
+            ...missingErrors
+        };
+        if (Object.keys(errors).length > 0) {
+            this.#setNewRowState({
+                ...this.#newRowState,
+                errors
+            });
+            return {
+                data: void 0,
+                type: "SUCCESS_RESULT"
+            };
+        }
+        if (this.#newRowState.submitting) return {
+            data: void 0,
+            type: "SUCCESS_RESULT"
+        };
+        this.#setNewRowState({
+            ...this.#newRowState,
+            submitting: true
+        });
+        try {
+            const response = await this.addRow({
+                ...this.#newRowState.values
+            });
+            if (isRpcError(response)) {
+                const finalColumn = this.#newRowState.columns.at(-1);
+                this.#setNewRowState({
+                    ...this.#newRowState,
+                    errors: finalColumn ? {
+                        [finalColumn]: response.errorMessage
+                    } : this.#newRowState.errors,
+                    submitting: false
+                });
+                return response;
+            }
+            this.#setNewRowState({
+                columns: this.#newRowState.columns,
+                draftRevision: this.#newRowState.draftRevision + 1,
+                errors: {},
+                submitting: false,
+                values: {}
+            });
+            return response;
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unable to add row";
+            const finalColumn = this.#newRowState.columns.at(-1);
+            this.#setNewRowState({
+                ...this.#newRowState,
+                errors: finalColumn ? {
+                    [finalColumn]: errorMessage
+                } : this.#newRowState.errors,
+                submitting: false
+            });
+            return {
+                errorMessage,
+                type: "ERROR_RESULT"
+            };
+        }
+    }
+    #setNewRowState(newRowState) {
+        this.#newRowState = newRowState;
+        this.emit("newRow", newRowState);
+    }
+    async deleteSelectedRows() {
+        const response = await this.dataSource?.deleteSelectedRows?.(this.#deleteMode);
+        if (isRpcError(response)) return;
+        const deletedKeys = response?.data?.deletedKeys;
+        if (deletedKeys && deletedKeys.length > 0) {
+            let newCount = 0;
+            for (const key of deletedKeys){
+                this.#rowDeleteRevisions.set(key, ++this.#deleteRevision);
+                if (!this.#deletedRows.has(key)) {
+                    this.#deletedRows.add(key);
+                    newCount++;
+                }
+            }
+            if (newCount > 0) this.deleteCount = this.#deleteCount + newCount;
+        }
+    }
+    async addRow(rowData = {}) {
+        const addRow = this.dataSource?.addRow;
+        if (void 0 === addRow) throw Error("[EditSession] datasource does not support adding rows");
+        const response = await addRow.call(this.dataSource, rowData);
+        if (void 0 === response) throw Error("[EditSession] datasource returned no response when adding row");
+        if (!isRpcError(response)) this.addCount = this.#addCount + 1;
+        return response;
+    }
+    restoreRows(keys) {
+        for (const key of keys)if (this.#deletedRows.has(key)) {
+            this.#deletedRows.delete(key);
+            this.#rowDeleteRevisions.delete(key);
+            this.deleteCount = this.#deleteCount - 1;
+        }
+    }
+    hasRowChanges(key) {
+        return this.#rowEdits.has(key) || this.#deletedRows.has(key);
+    }
+    isCellEdited(key, columnName) {
+        const cellEdit = this.#rowEdits.get(key)?.cellEdits.get(columnName);
+        return cellEdit?.isValid === true && cellEdit.originalValue !== cellEdit.editedValue;
+    }
+    async undoRowChange(key) {
+        if (!this.inEditMode) return;
+        const undoRevision = this.#commitRevision;
+        const deleteRevisionAtRequest = this.#rowDeleteRevisions.get(key);
+        const rowEditsAtRequest = this.#rowEdits.get(key);
+        const columnsAtRequest = new Set(rowEditsAtRequest?.cellEdits.keys());
+        const wasDeleted = this.#deletedRows.has(key);
+        const response = await this.dataSource?.undoRowChange?.(key);
+        if (isRpcError(response)) return;
+        const rowEdits = this.#rowEdits.get(key);
+        if (rowEdits) {
+            const changedColumns = [];
+            for (const columnName of columnsAtRequest){
+                const latestRevision = this.#cellCommitRevisions.get(key)?.get(columnName) ?? 0;
+                if (!(latestRevision > undoRevision)) {
+                    if (this.isCellEdited(key, columnName)) changedColumns.push(columnName);
+                    rowEdits.cellEdits.delete(columnName);
+                    this.#setCellCommitRevision(key, columnName);
+                }
+            }
+            if (0 === rowEdits.cellEdits.size) this.#rowEdits.delete(key);
+            this.#refreshEditCounts();
+            for (const columnName of changedColumns)this.emit("cellEditChanged", key, columnName);
+        }
+        if (wasDeleted && this.#deletedRows.has(key) && this.#rowDeleteRevisions.get(key) === deleteRevisionAtRequest) {
+            this.#deletedRows.delete(key);
+            this.#rowDeleteRevisions.delete(key);
+            this.deleteCount = this.#deleteCount - 1;
+        }
+        const wasInsertedRow = response?.data?.wasInsertedRow === true;
+        if (wasInsertedRow) this.addCount = this.#addCount - 1;
+    }
+    #clearEdits() {
+        const oldState = this.editState;
+        const editedCells = [
+            ...this.#rowEdits
+        ].flatMap(([key, { cellEdits }])=>[
+                ...cellEdits.keys()
+            ].filter((columnName)=>this.isCellEdited(key, columnName)).map((columnName)=>[
+                    key,
+                    columnName
+                ]));
+        this.#rowEdits.clear();
+        this.#deletedRows.clear();
+        this.#rowDeleteRevisions.clear();
+        this.#cellCommitRevisions.clear();
+        this.#editCount = 0;
+        this.#deleteCount = 0;
+        this.#addCount = 0;
+        this.#invalidCount = 0;
+        this.#isStale = false;
+        this.#setNewRowState({
+            columns: this.#newRowState.columns,
+            draftRevision: this.#newRowState.draftRevision + 1,
+            errors: {},
+            submitting: false,
+            values: {}
+        });
+        for (const [key, columnName] of editedCells)this.emit("cellEditChanged", key, columnName);
+        this.#emitEditStateChange(oldState);
+    }
+    #setLifecycle(lifecycle) {
+        this.#lifecycle = lifecycle;
+        this.emit("lifecycle", lifecycle);
+    }
+    #enqueue(operation) {
+        const result = this.#transitionQueue.then(operation);
+        this.#transitionQueue = result.then(()=>void 0, ()=>void 0);
+        return result;
+    }
+    begin(copyOption = "All") {
+        return this.#enqueue(async ()=>{
+            if ("active" === this.#lifecycle.status || "error" === this.#lifecycle.status && "end" === this.#lifecycle.operation) {
+                const sessionDataSource = this.#sessionDataSource;
+                if (!sessionDataSource) throw new Error("[EditSession] active lifecycle has no datasource");
+                if ("error" === this.#lifecycle.status) this.#setLifecycle({
+                    status: "active",
+                    sessionDataSource
+                });
+                return sessionDataSource;
+            }
+            this.#setLifecycle({
+                status: "starting"
+            });
+            try {
+                const sourceDataSource = this.#sourceTableDataSource;
+                const sessionDataSource = "beginEditSession" === this.#editSessionApi ? await sourceDataSource?.beginEditSession?.(toEditSessionMode(copyOption)) : await sourceDataSource?.createSessionDataSource?.(copyOption);
+                if (!sessionDataSource) throw new Error(`[EditSession] datasource does not support ${this.#editSessionApi}`);
+                this.#sessionDataSource = sessionDataSource;
+                this.#setStale(false);
+                this.#setLifecycle({
+                    status: "active",
+                    sessionDataSource
+                });
+                return sessionDataSource;
+            } catch (cause) {
+                const error = cause instanceof Error ? cause : new Error(String(cause));
+                this.#setLifecycle({
+                    status: "error",
+                    operation: "begin",
+                    error
+                });
+                throw error;
+            }
+        });
+    }
+    get dataSource() {
+        return this.#sessionDataSource ?? this.#sourceTableDataSource;
+    }
+    get sessionDataSource() {
+        return this.#sessionDataSource;
+    }
+    end(saveChanges = false, force = false) {
+        return this.#enqueue(async ()=>{
+            if ("idle" === this.#lifecycle.status || "error" === this.#lifecycle.status && "begin" === this.#lifecycle.operation) {
+                if ("idle" !== this.#lifecycle.status) this.#setLifecycle({
+                    status: "idle"
+                });
+                return;
+            }
+            const sessionDataSource = this.#sessionDataSource;
+            if (!sessionDataSource) throw new Error("[EditSession] ending lifecycle has no datasource");
+            this.#setLifecycle({
+                status: "ending",
+                sessionDataSource
+            });
+            try {
+                await this.dataSource?.endEditSession?.(saveChanges, force);
+                this.#clearEdits();
+                this.#sessionDataSource = void 0;
+                this.#setLifecycle({
+                    status: "idle"
+                });
+            } catch (cause) {
+                const error = cause instanceof Error ? cause : new Error(String(cause));
+                if (error instanceof StaleUpdateError) this.#setStale(true);
+                this.#setLifecycle({
+                    status: "error",
+                    operation: "end",
+                    error,
+                    sessionDataSource
+                });
+                throw error;
+            }
+        });
+    }
+    get lifecycle() {
+        return this.#lifecycle;
+    }
+    get inEditMode() {
+        return "active" === this.#lifecycle.status || "ending" === this.#lifecycle.status || "error" === this.#lifecycle.status && "end" === this.#lifecycle.operation;
+    }
+    #getOrCreateRowEdits(key) {
+        const rowEditDetails = this.#rowEdits.get(key);
+        if (rowEditDetails) return rowEditDetails;
+        {
+            const rowEditDetails = {
+                cellEdits: new Map()
+            };
+            this.#rowEdits.set(key, rowEditDetails);
+            return rowEditDetails;
+        }
+    }
+    #storeCellEdit(key, cellEdits, column, originalValue, editedValue, isValid) {
+        const wasEdited = this.isCellEdited(key, column);
+        const existingCellEdit = cellEdits.get(column);
+        const cellEdit = {
+            originalValue: existingCellEdit?.originalValue ?? originalValue,
+            editedValue,
+            isValid
+        };
+        if (isValid && cellEdit.originalValue === editedValue) cellEdits.delete(column);
+        else cellEdits.set(column, cellEdit);
+        this.#refreshEditCounts();
+        if (wasEdited !== this.isCellEdited(key, column)) this.emit("cellEditChanged", key, column);
+        return cellEdit;
+    }
+    #setCellCommitRevision(key, columnName) {
+        const revision = ++this.#commitRevision;
+        const rowRevisions = this.#cellCommitRevisions.get(key) ?? new Map();
+        rowRevisions.set(columnName, revision);
+        this.#cellCommitRevisions.set(key, rowRevisions);
+        return revision;
+    }
+    #isLatestCellCommit(key, columnName, revision) {
+        return this.#cellCommitRevisions.get(key)?.get(columnName) === revision;
+    }
+    async commit(key, columnName, originalValue, typedValue, isValid) {
+        if ("active" !== this.#lifecycle.status && !("error" === this.#lifecycle.status && "end" === this.#lifecycle.operation)) throw new Error("No edit session in progress");
+        const revision = this.#setCellCommitRevision(key, columnName);
+        const rowEditDetails = this.#getOrCreateRowEdits(key);
+        const { cellEdits } = rowEditDetails;
+        if (isValid) {
+            const cellEdit = this.#storeCellEdit(key, cellEdits, columnName, originalValue, typedValue, isValid);
+            if (this.dataSource?.editCell) {
+                const response = await this.dataSource.editCell(key, columnName, typedValue);
+                if (!this.#isLatestCellCommit(key, columnName, revision)) throw new SupersededEditError(`Edit response superseded for ${key}:${columnName}`);
+                const currentCellEdits = this.#getOrCreateRowEdits(key).cellEdits;
+                if (isRpcError(response)) this.#storeCellEdit(key, currentCellEdits, columnName, cellEdit.originalValue, typedValue, false);
+                else if (0 === currentCellEdits.size) this.#rowEdits.delete(key);
+                return response;
+            }
+            if (0 === cellEdits.size) this.#rowEdits.delete(key);
+            return {
+                data: void 0,
+                type: "SUCCESS_RESULT"
+            };
+        }
+        this.#storeCellEdit(key, cellEdits, columnName, originalValue, typedValue, isValid);
+        return {
+            data: void 0,
+            type: "SUCCESS_RESULT"
+        };
+    }
+}
+export { EditError, EditSession, SupersededEditError };

package/src/UndoCellRenderer.js

@@ -0,0 +1,38 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Button, Tooltip } from "@salt-ds/core";
+import { Icon } from "@vuu-ui/vuu-ui-controls";
+import { registerComponent } from "@vuu-ui/vuu-utils";
+import { useEditSession } from "./DataEditingProvider.js";
+const UNDO_CELL_RENDERER = "vuu.undo-cell";
+const getUndoButtonContent = (componentProps)=>({
+        icon: componentProps?.icon,
+        text: componentProps?.text === void 0 ? "UNDO" : componentProps.text || void 0
+    });
+const getUndoTooltipContent = (action)=>"deleteRow" === action ? "Undo delete row" : "addRow" === action ? "Undo insert row" : "editCell" === action ? "Undo row edits" : void 0;
+const UndoCellRenderer = ({ column, dataRow })=>{
+    const editSession = useEditSession();
+    const renderer = column.type?.renderer;
+    const { icon, text } = getUndoButtonContent(renderer?.componentProps);
+    const tooltipContent = getUndoTooltipContent(dataRow.vuu_action);
+    if (void 0 === tooltipContent) return null;
+    return /*#__PURE__*/ jsx(Tooltip, {
+        content: tooltipContent,
+        children: /*#__PURE__*/ jsxs(Button, {
+            appearance: "transparent",
+            "aria-label": tooltipContent,
+            onClick: ()=>editSession?.undoRowChange(dataRow.key),
+            style: {
+                height: "100%",
+                width: "100%"
+            },
+            children: [
+                icon ? /*#__PURE__*/ jsx(Icon, {
+                    name: icon
+                }) : null,
+                text
+            ]
+        })
+    });
+};
+registerComponent(UNDO_CELL_RENDERER, UndoCellRenderer, "cell-renderer");
+export { UNDO_CELL_RENDERER, UndoCellRenderer, getUndoButtonContent, getUndoTooltipContent };