@vuu-ui/vuu-data-editing 3.5.10 → 3.5.12

package/README.md

@@ -162,7 +162,10 @@ A cell is considered edited only when `originalValue !== editedValue && isValid
 - Exits early if `selectedRowsCount === 0`.
 - Calls `dataSource.deleteSelectedRows(deleteMode)`.
 - On success:
-  - Increments `deleteCount` by `selectedRowsCount`.
+  - If the server returns `response.data.deletedKeys`, keys are partitioned against `#addedRowKeys`:
+    - Deleting a newly added row cancels out the addition (`addCount` decrements, key removed from `#addedRowKeys`, any cell edits on that row are discarded, and `deleteCount` remains unaffected).
+    - Deleting an existing source row increments `deleteCount`.
+  - Fallback: if `deletedKeys` is not returned, increments `deleteCount` by `selectedRowsCount`.
   - **Clears selection**: Dispatches `dataSource.select({ type: "DESELECT_ALL" })` so deleted rows are immediately deselected, preventing accidental double-deletion and disabling the Delete button.
 
 ### Undo Flow (`undoRowChange`)

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.10",
+  "version": "3.5.12",
   "description": "Shared data editing APIs and React components for VUU UI",
   "main": "./src/index.js",
   "author": "heswell",
@@ -12,13 +12,13 @@
   },
   "dependencies": {
     "@salt-ds/core": "1.54.1",
-    "@vuu-ui/vuu-ui-controls": "3.5.10",
-    "@vuu-ui/vuu-utils": "3.5.10"
+    "@vuu-ui/vuu-ui-controls": "3.5.12",
+    "@vuu-ui/vuu-utils": "3.5.12"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "3.5.10",
-    "@vuu-ui/vuu-protocol-types": "3.5.10",
-    "@vuu-ui/vuu-table-types": "3.5.10"
+    "@vuu-ui/vuu-data-types": "3.5.12",
+    "@vuu-ui/vuu-protocol-types": "3.5.12",
+    "@vuu-ui/vuu-table-types": "3.5.12"
   },
   "peerDependencies": {
     "react": "^19.2.3"

package/src/EditSession.js

@@ -241,10 +241,24 @@ class EditSession extends EventEmitter {
             data: void 0,
             type: "SUCCESS_RESULT"
         };
+        const deleteRevision = this.#commitRevision;
         const response = await deleteSelectedRows.call(this.dataSource, this.#deleteMode);
         if (void 0 === response) throw Error("[EditSession] datasource returned no response when deleting rows");
         if (isRpcError(response)) return response;
-        if (selectedRowsCount > 0) this.#setDeleteCount(this.#deleteCount + selectedRowsCount);
+        const deletedKeys = response.data?.deletedKeys;
+        if (deletedKeys && deletedKeys.length > 0) {
+            const oldState = this.editState;
+            let addedRowsDeleted = 0;
+            for (const key of deletedKeys)if (this.#addedRowKeys.has(key)) {
+                this.#addedRowKeys.delete(key);
+                this.#discardRowEdits(key, deleteRevision);
+                addedRowsDeleted++;
+            }
+            const sourceRowsDeleted = deletedKeys.length - addedRowsDeleted;
+            if (sourceRowsDeleted > 0) this.#deleteCount += sourceRowsDeleted;
+            if (addedRowsDeleted > 0) this.#addCount = Math.max(0, this.#addCount - addedRowsDeleted);
+            this.#emitEditStateChange(oldState);
+        } else if (selectedRowsCount > 0) this.#setDeleteCount(this.#deleteCount + selectedRowsCount);
         await this.dataSource?.select?.({
             type: "DESELECT_ALL"
         });
@@ -272,6 +286,28 @@ class EditSession extends EventEmitter {
         const cellEdit = this.#rowEdits.get(key)?.cellEdits.get(columnName);
         return cellEdit?.isValid === true && cellEdit.originalValue !== cellEdit.editedValue;
     }
+    #discardRowEdits(key, maxRevision, columnsToDiscard) {
+        const rowEdits = this.#rowEdits.get(key);
+        if (!rowEdits) return;
+        const columns = columnsToDiscard ?? new Set(rowEdits.cellEdits.keys());
+        const changedColumns = [];
+        let removedValidCount = 0;
+        let removedInvalidCount = 0;
+        for (const columnName of columns){
+            const latestRevision = this.#cellCommitRevisions.get(key)?.get(columnName) ?? 0;
+            if (latestRevision > maxRevision) continue;
+            const existing = rowEdits.cellEdits.get(columnName);
+            if (existing) if (existing.isValid) removedValidCount++;
+            else removedInvalidCount++;
+            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.#editCount -= removedValidCount;
+        this.#invalidCount -= removedInvalidCount;
+        for (const columnName of changedColumns)this.emit("cellEditChanged", key, columnName);
+    }
     async undoRowChange(key, action) {
         if (!this.inEditMode) return;
         const undoRevision = this.#commitRevision;
@@ -281,26 +317,7 @@ class EditSession extends EventEmitter {
         if (void 0 === response) return;
         if (isRpcError(response)) return response;
         const oldState = this.editState;
-        const rowEdits = this.#rowEdits.get(key);
-        if (rowEdits) {
-            const changedColumns = [];
-            let removedValidCount = 0;
-            let removedInvalidCount = 0;
-            for (const columnName of columnsAtRequest){
-                const latestRevision = this.#cellCommitRevisions.get(key)?.get(columnName) ?? 0;
-                if (latestRevision > undoRevision) continue;
-                const existing = rowEdits.cellEdits.get(columnName);
-                if (existing) if (existing.isValid) removedValidCount++;
-                else removedInvalidCount++;
-                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.#editCount -= removedValidCount;
-            this.#invalidCount -= removedInvalidCount;
-            for (const columnName of changedColumns)this.emit("cellEditChanged", key, columnName);
-        }
+        this.#discardRowEdits(key, undoRevision, columnsAtRequest);
         if ("deleteRow" === action) this.#deleteCount = Math.max(0, this.#deleteCount - 1);
         const wasInsertedRow = "addRow" === action || this.#addedRowKeys.has(key);
         if (wasInsertedRow) {

package/types/EditSession.d.ts

@@ -24,6 +24,9 @@ export type EditSessionConstructorProps = {
 export type AddRowResultData = {
     key?: string | number;
 };
+export type DeleteSelectedRowsResultData = {
+    deletedKeys?: string[];
+};
 export type NewRowState = {
     columns: readonly string[];
     requiredColumns?: readonly string[];

package/types/index.d.ts

@@ -8,7 +8,7 @@ export { EditButtons, type EditButtonProps } from "./EditButtons";
 export { EditField, type DropdownEditFieldProps, type EditFieldProps, type EditFieldType, type TextFieldType, } from "./edit-field/EditField";
 export { useEditField, type EditFieldHookProps, } from "./edit-field/useEditField";
 export { EditModeProvider, useEditMode, type EditModeContextProps, } from "./EditModeProvider";
-export { EditError, EditSession, SupersededEditError, type AddRowResultData, type EditActionType, type EditCommitOptions, type EditLifecycle, type EditSessionConstructorProps, type EditSessionValue, type NewRowState, type EditState, type RowDefaultDataItemValues, } from "./EditSession";
+export { EditError, EditSession, SupersededEditError, type AddRowResultData, type DeleteSelectedRowsResultData, type EditActionType, type EditCommitOptions, type EditLifecycle, type EditSessionConstructorProps, type EditSessionValue, type NewRowState, type EditState, type RowDefaultDataItemValues, } from "./EditSession";
 export { StaleUpdateError } from "@vuu-ui/vuu-utils";
 export { lookupOptionsFromRows, useLookupValues, type LookupOption, type LookupValuedHookProps, type OptionMap, } from "./lookup-values/useLookupValues";
 export { useEditable, type EditableHookProps } from "./useEditable";