@economic/taco 2.48.5 → 2.49.0-server.2

package/dist/esm/packages/taco/src/components/Table3/features/useEditingState.js

@@ -1,4 +1,5 @@
 import React__default from 'react';
+import { extends as _extends, objectDestructuringEmpty as _objectDestructuringEmpty } from '../../../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { useLocalization } from '../../Provider/Localization.js';
 import { v4 } from 'uuid';
 import { _forOf, _catch } from '../../../../../../node_modules/babel-plugin-transform-async-to-promises/helpers.mjs.js';
@@ -6,185 +7,185 @@ import { isTemporaryRow, willRowMove, TEMPORARY_ROW_ID_PREFIX } from '../util/ed
 import omit from 'lodash-es/omit';
 import setWith from 'lodash-es/setWith';
 
-const DELAY_BEFORE_REMOVING_SAVE_STATUS = 3000;
+var DELAY_BEFORE_REMOVING_SAVE_STATUS = 3000;
 function reducer(state, action) {
-  const {
-    type,
-    rowId,
-    payload
-  } = action;
+  var type = action.type,
+    rowId = action.rowId,
+    payload = action.payload;
   switch (type) {
     case 'setCellValue':
       {
-        const {
-          columnId,
-          row,
-          value
-        } = payload;
-        return {
-          ...state,
-          changes: {
-            ...state.changes,
-            rows: setWith(state.changes.rows, `${rowId}.${columnId}`, value, Object),
+        var columnId = payload.columnId,
+          index = payload.index,
+          row = payload.row,
+          value = payload.value;
+        return _extends({}, state, {
+          changes: _extends({}, state.changes, {
+            rows: setWith(state.changes.rows, rowId + "." + columnId, value, Object),
             originals: setWith(state.changes.originals, rowId, row, Object)
-          }
-        };
+          }),
+          indexes: setWith(state.indexes, rowId, index, Object)
+        });
       }
     case 'removeCellValue':
       {
-        const {
-          columnId,
-          rowIdentityAccessor
-        } = payload;
-        const changes = omit(state.changes.rows, `${rowId}.${columnId}`);
+        var _columnId = payload.columnId,
+          rowIdentityAccessor = payload.rowIdentityAccessor;
+        var changes = omit(state.changes.rows, rowId + "." + _columnId);
         // if there are no changes left, remove the row
         if (!Object.keys(changes[rowId]).length) {
           return reducer(state, {
             type: 'removeRow',
-            rowId,
+            rowId: rowId,
             payload: {
-              rowIdentityAccessor
+              rowIdentityAccessor: rowIdentityAccessor
             }
           });
         }
-        return {
-          ...state,
-          changes: {
-            ...state.changes,
-            rows: omit(state.changes.rows, `${rowId}.${columnId}`),
-            errors: omit(state.changes.errors, `${rowId}.cells.${columnId}`),
-            moveReasons: omit(state.changes.moveReasons, `${rowId}.${columnId}`)
-          }
-        };
+        return _extends({}, state, {
+          changes: _extends({}, state.changes, {
+            rows: omit(state.changes.rows, rowId + "." + _columnId),
+            errors: omit(state.changes.errors, rowId + ".cells." + _columnId),
+            moveReasons: omit(state.changes.moveReasons, rowId + "." + _columnId)
+          })
+        });
       }
     case 'updateRow':
       {
-        const {
-          cellErrors,
-          moveReasons,
-          original,
-          value
-        } = payload;
-        return {
-          ...state,
-          changes: {
-            ...state.changes,
-            rows: setWith(state.changes.rows, rowId, value, Object),
-            errors: setWith(state.changes.errors, `${rowId}.cells`, cellErrors !== null && cellErrors !== void 0 ? cellErrors : state.changes.errors.cells[rowId], Object),
+        var cellErrors = payload.cellErrors,
+          _index = payload.index,
+          moveReasons = payload.moveReasons,
+          original = payload.original,
+          _value = payload.value;
+        return _extends({}, state, {
+          changes: _extends({}, state.changes, {
+            rows: setWith(state.changes.rows, rowId, _value, Object),
+            errors: setWith(state.changes.errors, rowId + ".cells", cellErrors !== null && cellErrors !== void 0 ? cellErrors : state.changes.errors.cells[rowId], Object),
             originals: setWith(state.changes.originals, rowId, original !== null && original !== void 0 ? original : state.changes.originals[rowId], Object),
             moveReasons: setWith(state.changes.moveReasons, rowId, moveReasons !== null && moveReasons !== void 0 ? moveReasons : state.changes.moveReasons[rowId], Object),
             // status can be undefined, so don't use ??
             status: setWith(state.changes.status, rowId, undefined, Object)
-          }
-        };
+          }),
+          indexes: setWith(state.indexes, rowId, _index, Object)
+        });
       }
     case 'removeRow':
       {
-        const {
-          rowIdentityAccessor
-        } = payload;
-        return {
-          ...state,
-          changes: {
-            ...state.changes,
+        var _rowIdentityAccessor = payload.rowIdentityAccessor;
+        return _extends({}, state, {
+          changes: _extends({}, state.changes, {
             rows: omit(state.changes.rows, rowId),
             errors: omit(state.changes.errors, rowId),
             moveReasons: omit(state.changes.moveReasons, rowId),
             originals: omit(state.changes.originals, rowId),
             status: omit(state.changes.status, rowId)
-          },
-          temporaryRows: state.temporaryRows.filter(row => row[rowIdentityAccessor] !== rowId)
-        };
+          }),
+          indexes: omit(state.indexes, rowId),
+          temporaryRows: state.temporaryRows.filter(function (row) {
+            return row[_rowIdentityAccessor] !== rowId;
+          })
+        });
       }
     case 'setRowStatus':
       {
-        const {
-          status
-        } = payload;
-        return {
-          ...state,
-          changes: {
-            ...state.changes,
+        var status = payload.status;
+        return _extends({}, state, {
+          changes: _extends({}, state.changes, {
             status: status ? setWith(state.changes.status, rowId, status, Object) : omit(state.changes.status, rowId)
-          }
-        };
+          })
+        });
       }
     case 'setRowErrors':
       {
-        const {
-          ...errors
-        } = payload;
-        return {
-          ...state,
-          changes: {
-            ...state.changes,
+        var errors = _extends({}, (_objectDestructuringEmpty(payload), payload));
+        return _extends({}, state, {
+          changes: _extends({}, state.changes, {
             errors: setWith(state.changes.errors, rowId, errors, Object)
-          }
-        };
+          })
+        });
       }
     case 'insertTemporaryRow':
       {
-        const {
-          value
-        } = payload;
-        return {
-          ...state,
-          temporaryRows: state.temporaryRows.concat(value),
-          changes: {
-            ...state.changes,
-            rows: setWith(state.changes.rows, rowId, value, Object),
-            originals: setWith(state.changes.originals, rowId, value, Object)
-          }
-        };
+        var _index2 = payload.index,
+          _value2 = payload.value;
+        return _extends({}, state, {
+          temporaryRows: state.temporaryRows.concat(_value2),
+          changes: _extends({}, state.changes, {
+            rows: setWith(state.changes.rows, rowId, _value2, Object),
+            originals: setWith(state.changes.originals, rowId, _value2, Object)
+          }),
+          indexes: setWith(state.indexes, rowId, _index2, Object)
+        });
       }
     default:
       return state;
   }
 }
-function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, validator) {
-  const saveChanges = function (table, rowId = undefined) {
+function usePendingChangesState(handleSave, handleChange, handleDiscard, rowIdentityAccessor, validator) {
+  var discardChanges = function discardChanges(rowId, table) {
+    try {
+      // remove any new rows from pinned state before discarding them
+      table.resetRowPinning(true);
+      dispatch({
+        type: 'removeRow',
+        rowId: rowId,
+        payload: {
+          rowIdentityAccessor: rowIdentityAccessor
+        }
+      });
+      var _temp8 = function () {
+        if (typeof handleDiscard === 'function') {
+          return Promise.resolve(handleDiscard()).then(function () {});
+        }
+      }();
+      return Promise.resolve(_temp8 && _temp8.then ? _temp8.then(function () {}) : void 0);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  var saveChanges = function saveChanges(table, rowId) {
+    if (rowId === void 0) {
+      rowId = undefined;
+    }
     try {
-      let _exit = false;
+      var _ref;
+      var _exit = false;
       if (!handleSave) {
         console.warn('Tried to save, but Table has no onEditingSave handler');
         return Promise.resolve(false);
       }
       // sometimes we only want to save one row
-      const changes = rowId ? {
-        [rowId]: state.changes.rows[rowId]
-      } : state.changes.rows;
-      let completed = true;
-      const _temp9 = _forOf(Object.keys(changes), function (rowId) {
-        const status = getRowStatus(rowId);
+      var changes = rowId ? (_ref = {}, _ref[rowId] = state.changes.rows[rowId], _ref) : state.changes.rows;
+      var completed = true;
+      var _temp7 = _forOf(Object.keys(changes), function (rowId) {
+        var status = getRowStatus(rowId);
         return _catch(function () {
           var _changes$rowId;
-          function _temp8(_result) {
+          function _temp6(_result) {
             return _exit ? _result : Promise.resolve(handleSave(changeSet)).then(function () {
               // cleanup changes, we don't need them after saving
-              discardChanges(rowId, table);
-              // show the saved status, then remove it after a delay
-              setRowStatus(rowId, 'saved');
-              setTimeout(() => {
-                setRowStatus(rowId, undefined);
-              }, DELAY_BEFORE_REMOVING_SAVE_STATUS);
+              return Promise.resolve(discardChanges(rowId, table)).then(function () {
+                // show the saved status, then remove it after a delay
+                setRowStatus(rowId, 'saved');
+                setTimeout(function () {
+                  setRowStatus(rowId, undefined);
+                }, DELAY_BEFORE_REMOVING_SAVE_STATUS);
+              });
             });
           }
-          const rowChanges = (_changes$rowId = changes[rowId]) !== null && _changes$rowId !== void 0 ? _changes$rowId : {};
+          var rowChanges = (_changes$rowId = changes[rowId]) !== null && _changes$rowId !== void 0 ? _changes$rowId : {};
           // don't try to save if - already saving, or there are known errors
           if (!Object.keys(rowChanges).length || status === 'saving' || status === 'errored') {
             return;
           }
           setRowStatus(rowId, 'saving');
-          const changeSet = {
-            ...state.changes.originals[rowId],
-            ...rowChanges
-          };
+          var changeSet = _extends({}, state.changes.originals[rowId], rowChanges);
           // if we had to create a temporary id, delete it first - it's our data, not theirs
           if (isTemporaryRow(changeSet[rowIdentityAccessor])) {
             delete changeSet[rowIdentityAccessor];
           }
           // re-run validation, maybe a cell is already invalid but has never been blurred
-          const _temp7 = function () {
+          var _temp5 = function () {
             if (validator) {
               return Promise.resolve(validator(changeSet)).then(function (errors) {
                 if (errors && Object.keys(errors).length) {
@@ -193,7 +194,7 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
               });
             }
           }();
-          return _temp7 && _temp7.then ? _temp7.then(_temp8) : _temp8(_temp7); // send new data to the server
+          return _temp5 && _temp5.then ? _temp5.then(_temp6) : _temp6(_temp5); // send new data to the server
         }, function (error) {
           var _error$response;
           if (error instanceof ReferenceError || error instanceof TypeError || (error === null || error === void 0 ? void 0 : (_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) >= 500) {
@@ -201,8 +202,8 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
           }
           // the onEditingSave handler should throw errors when something fails, e.g. validation, network errors etc
           // this code handles those errors and maps them either to row errors or cell specific errors
-          let rowError;
-          let cellErrors;
+          var rowError;
+          var cellErrors;
           if (typeof error === 'string') {
             rowError = error;
           } else if (error instanceof Error) {
@@ -219,7 +220,7 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
           if (rowError || cellErrors) {
             dispatch({
               type: 'setRowErrors',
-              rowId,
+              rowId: rowId,
               payload: {
                 row: rowError,
                 cells: cellErrors,
@@ -233,23 +234,27 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
       }, function () {
         return _exit;
       });
-      return Promise.resolve(_temp9 && _temp9.then ? _temp9.then(function (_result3) {
+      return Promise.resolve(_temp7 && _temp7.then ? _temp7.then(function (_result3) {
         return _exit ? _result3 : completed;
-      }) : _exit ? _temp9 : completed);
+      }) : _exit ? _temp7 : completed);
     } catch (e) {
       return Promise.reject(e);
     }
   };
-  const onCellChanged = function (cell, rowIndex, nextValue, shouldRunUpdaters = true) {
+  var onCellChanged = function onCellChanged(cell, rowIndex, nextValue, shouldRunUpdaters) {
+    if (shouldRunUpdaters === void 0) {
+      shouldRunUpdaters = true;
+    }
     try {
-      function _temp6() {
+      var _extends3;
+      var _temp4 = function _temp4() {
         var _state$changes$errors11;
-        function _temp4() {
+        function _temp2() {
           // only set errors and move reasons for the cells we're currently acting on
           // why? because the UX is not good if we set them for cells the user hasn't touched yet
-          const cellsToActOn = [cell.column.id, ...Object.keys(updatesForOtherCells)];
-          const allCells = cell.row._getAllCellsByColumnId();
-          cellsToActOn.forEach(accessor => {
+          var cellsToActOn = [cell.column.id].concat(Object.keys(updatesForOtherCells));
+          var allCells = cell.row._getAllCellsByColumnId();
+          cellsToActOn.forEach(function (accessor) {
             if (validationErrors[accessor]) {
               nextCellErrors[accessor] = validationErrors[accessor];
               // don't show move indicator for cells with errors, they aren't valid and can't be saved
@@ -260,7 +265,7 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
               delete nextCellErrors[accessor];
               if ((_allCells$accessor = allCells[accessor]) !== null && _allCells$accessor !== void 0 && _allCells$accessor.column.getIsSorted()) {
                 // run row move determination
-                const reason = willRowMove(cell, nextChanges[accessor], rowIndex, localization);
+                var reason = willRowMove(cell, nextChanges[accessor], rowIndex, localization);
                 // if the row will move based on this change save why, otherwise delete any existing state
                 if (reason) {
                   nextMoveReasons[accessor] = reason;
@@ -275,111 +280,64 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
             rowId: cell.row.id,
             payload: {
               cellErrors: nextCellErrors,
+              index: rowIndex,
               moveReasons: nextMoveReasons,
               value: nextChanges
             }
           });
         }
         // create a projection of the next state, so we can act against it
-        const nextChanges = {
-          ...changes,
-          ...updatesForOtherCells
-        };
-        const nextMoveReasons = {
-          ...state.changes.moveReasons[cell.row.id]
-        };
-        const nextCellErrors = {
-          ...((_state$changes$errors11 = state.changes.errors[cell.row.id]) === null || _state$changes$errors11 === void 0 ? void 0 : _state$changes$errors11.cells)
-        };
+        var nextChanges = _extends({}, changes, updatesForOtherCells);
+        var nextMoveReasons = _extends({}, state.changes.moveReasons[cell.row.id]);
+        var nextCellErrors = _extends({}, (_state$changes$errors11 = state.changes.errors[cell.row.id]) === null || _state$changes$errors11 === void 0 ? void 0 : _state$changes$errors11.cells);
         // run validation - if there are changes, and if there is an original stored
-        let validationErrors = {};
-        const _temp3 = function () {
+        var validationErrors = {};
+        var _temp = function () {
           if (validator && Object.keys(nextChanges).length && state.changes.originals[cell.row.id]) {
             // merge with the original so we get a full row
-            const nextRowValue = {
-              ...state.changes.originals[cell.row.id],
-              ...changes,
-              ...updatesForOtherCells
-            };
-            return Promise.resolve(validator(nextRowValue)).then(function (_validator2) {
-              validationErrors = _validator2 !== null && _validator2 !== void 0 ? _validator2 : {};
+            var nextRowValue = _extends({}, state.changes.originals[cell.row.id], changes, updatesForOtherCells);
+            return Promise.resolve(validator(nextRowValue)).then(function (_validator) {
+              validationErrors = _validator !== null && _validator !== void 0 ? _validator : {};
             });
           }
         }();
-        return _temp3 && _temp3.then ? _temp3.then(_temp4) : _temp4(_temp3);
-      }
-      const changes = nextValue !== undefined ? {
-        ...state.changes.rows[cell.row.id],
-        [cell.column.id]: nextValue
-      } : {
-        ...state.changes.rows[cell.row.id]
+        return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
       };
+      var changes = nextValue !== undefined ? _extends({}, state.changes.rows[cell.row.id], (_extends3 = {}, _extends3[cell.column.id] = nextValue, _extends3)) : _extends({}, state.changes.rows[cell.row.id]);
       if (!Object.keys(changes).length) {
         return Promise.resolve();
       }
-      let updatesForOtherCells = {};
+      var updatesForOtherCells = {};
       // run the updater handler if there is one, to see if there are any other cells to update
-      const _temp5 = function () {
+      var _temp3 = function () {
         if (typeof handleChange === 'function' && shouldRunUpdaters) {
-          const previousRowValue = {
-            ...state.changes.originals[cell.row.id]
-          };
-          const nextRowValue = {
-            ...state.changes.originals[cell.row.id],
-            ...changes
-          };
+          var previousRowValue = _extends({}, state.changes.originals[cell.row.id]);
+          var nextRowValue = _extends({}, state.changes.originals[cell.row.id], changes);
           return Promise.resolve(handleChange(cell.column.id, changes[cell.column.id], nextRowValue, previousRowValue)).then(function (_handleChange) {
             updatesForOtherCells = _handleChange !== null && _handleChange !== void 0 ? _handleChange : {};
           });
         }
       }();
-      return Promise.resolve(_temp5 && _temp5.then ? _temp5.then(_temp6) : _temp6(_temp5));
+      return Promise.resolve(_temp3 && _temp3.then ? _temp3.then(_temp4) : _temp4(_temp3));
     } catch (e) {
       return Promise.reject(e);
     }
   }; // general
+  var localization = useLocalization();
+  var _React$useReducer = React__default.useReducer(reducer, {
+      changes: {
+        rows: {},
+        errors: {},
+        moveReasons: {},
+        originals: {},
+        status: {}
+      },
+      indexes: {},
+      temporaryRows: []
+    }),
+    state = _React$useReducer[0],
+    dispatch = _React$useReducer[1];
   // rows
-  const setRowValue = function (rowId, original, value) {
-    try {
-      function _temp2() {
-        dispatch({
-          type: 'updateRow',
-          rowId,
-          payload: {
-            cellErrors,
-            original,
-            value
-          }
-        });
-      }
-      let cellErrors;
-      const _temp = function () {
-        if (validator) {
-          const row = {
-            ...original,
-            ...value
-          };
-          return Promise.resolve(validator(row)).then(function (_validator) {
-            cellErrors = _validator !== null && _validator !== void 0 ? _validator : {};
-          });
-        }
-      }();
-      return Promise.resolve(_temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-  const localization = useLocalization();
-  const [state, dispatch] = React__default.useReducer(reducer, {
-    changes: {
-      rows: {},
-      errors: {},
-      moveReasons: {},
-      originals: {},
-      status: {}
-    },
-    temporaryRows: []
-  });
   function getRowValue(rowId) {
     var _state$changes$rows$r, _state$changes$rows;
     return (_state$changes$rows$r = (_state$changes$rows = state.changes.rows) === null || _state$changes$rows === void 0 ? void 0 : _state$changes$rows[rowId]) !== null && _state$changes$rows$r !== void 0 ? _state$changes$rows$r : undefined;
@@ -398,11 +356,11 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
   }
   function hasTemporaryRowErrors() {
     var _state$temporaryRows, _state$changes$errors5, _state$changes$errors6, _state$changes$errors7;
-    const newRow = (_state$temporaryRows = state.temporaryRows) === null || _state$temporaryRows === void 0 ? void 0 : _state$temporaryRows[0];
+    var newRow = (_state$temporaryRows = state.temporaryRows) === null || _state$temporaryRows === void 0 ? void 0 : _state$temporaryRows[0];
     if (!newRow) {
       return false;
     }
-    const rowId = newRow[rowIdentityAccessor];
+    var rowId = newRow[rowIdentityAccessor];
     return !!((_state$changes$errors5 = state.changes.errors[rowId]) !== null && _state$changes$errors5 !== void 0 && _state$changes$errors5.row) || !!Object.keys((_state$changes$errors6 = (_state$changes$errors7 = state.changes.errors[rowId]) === null || _state$changes$errors7 === void 0 ? void 0 : _state$changes$errors7.cells) !== null && _state$changes$errors6 !== void 0 ? _state$changes$errors6 : {}).length;
   }
   function getRowStatus(rowId) {
@@ -411,40 +369,40 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
   function setRowStatus(rowId, status) {
     dispatch({
       type: 'setRowStatus',
-      rowId,
+      rowId: rowId,
       payload: {
-        status
+        status: status
       }
     });
   }
-  function insertTemporaryRow(data) {
-    const newRowId = `${TEMPORARY_ROW_ID_PREFIX}${v4()}`;
-    const value = {
-      ...data,
-      [rowIdentityAccessor]: newRowId
-    };
+  function insertTemporaryRow(data, rowIndex) {
+    var _extends2;
+    var newRowId = "" + TEMPORARY_ROW_ID_PREFIX + v4();
+    var value = _extends({}, data, (_extends2 = {}, _extends2[rowIdentityAccessor] = newRowId, _extends2));
     dispatch({
       type: 'insertTemporaryRow',
       rowId: newRowId,
       payload: {
-        value
+        index: rowIndex,
+        value: value
       }
     });
     return newRowId;
   }
   // cells
-  function setCellValue(cell, value) {
-    const rowId = cell.row.id;
-    const columnId = cell.column.id;
+  function setCellValue(cell, rowIndex, value) {
+    var rowId = cell.row.id;
+    var columnId = cell.column.id;
     // update if the change is different to the original value
     if (value !== cell.row.original[columnId]) {
       dispatch({
         type: 'setCellValue',
-        rowId,
+        rowId: rowId,
         payload: {
-          columnId,
+          columnId: columnId,
+          index: rowIndex,
           row: cell.row.original,
-          value
+          value: value
         }
       });
     }
@@ -452,10 +410,10 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
     else if (cell.row.id in state.changes.rows) {
       dispatch({
         type: 'removeCellValue',
-        rowId,
+        rowId: rowId,
         payload: {
-          columnId,
-          rowIdentityAccessor
+          columnId: columnId,
+          rowIdentityAccessor: rowIdentityAccessor
         }
       });
     }
@@ -469,56 +427,49 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
     return (_state$changes$errors8 = state.changes.errors) === null || _state$changes$errors8 === void 0 ? void 0 : (_state$changes$errors9 = _state$changes$errors8[cell.row.id]) === null || _state$changes$errors9 === void 0 ? void 0 : (_state$changes$errors10 = _state$changes$errors9.cells) === null || _state$changes$errors10 === void 0 ? void 0 : _state$changes$errors10[cell.column.id];
   }
   function getErrorsShownInAlert() {
-    const rowsWithErrors = Object.keys(state.changes.errors);
+    var rowsWithErrors = Object.keys(state.changes.errors);
     if (!rowsWithErrors.length) {
       return [];
     }
-    return rowsWithErrors.filter(hasRowErrorsShownInAlert).map(rowId => ({
-      rowId,
-      changes: state.changes.rows[rowId],
-      errors: state.changes.errors[rowId]
-    }));
+    return rowsWithErrors.filter(hasRowErrorsShownInAlert).map(function (rowId) {
+      return {
+        rowId: rowId,
+        index: state.indexes[rowId],
+        changes: state.changes.rows[rowId],
+        errors: state.changes.errors[rowId]
+      };
+    });
   }
   function hasSaved() {
-    return !!Object.values(state.changes.status).filter(value => value === 'saved').length;
+    return !!Object.values(state.changes.status).filter(function (value) {
+      return value === 'saved';
+    }).length;
   }
   function hasChanges(rowId) {
     return rowId ? !!state.changes.rows[rowId] : !!Object.keys(state.changes.rows).length;
   }
-  function discardChanges(rowId, table) {
-    // remove any new rows from pinned state before discarding them
-    table.resetRowPinning(true);
-    dispatch({
-      type: 'removeRow',
-      rowId,
-      payload: {
-        rowIdentityAccessor
-      }
-    });
-  }
   return {
     // row
-    setRowValue,
-    getRowValue,
-    getRowMoveReason,
-    hasRowErrors,
-    hasRowErrorsShownInAlert,
-    hasTemporaryRowErrors,
-    getRowStatus,
-    setRowStatus,
+    getRowValue: getRowValue,
+    getRowMoveReason: getRowMoveReason,
+    hasRowErrors: hasRowErrors,
+    hasRowErrorsShownInAlert: hasRowErrorsShownInAlert,
+    hasTemporaryRowErrors: hasTemporaryRowErrors,
+    getRowStatus: getRowStatus,
+    setRowStatus: setRowStatus,
     // cells
-    setCellValue,
-    getCellValue,
-    getCellError,
-    onCellChanged,
+    setCellValue: setCellValue,
+    getCellValue: getCellValue,
+    getCellError: getCellError,
+    onCellChanged: onCellChanged,
     // general
-    getErrorsShownInAlert,
-    hasChanges,
-    saveChanges,
-    discardChanges,
-    hasSaved,
+    getErrorsShownInAlert: getErrorsShownInAlert,
+    hasChanges: hasChanges,
+    saveChanges: saveChanges,
+    discardChanges: discardChanges,
+    hasSaved: hasSaved,
     // new rows
-    insertTemporaryRow,
+    insertTemporaryRow: insertTemporaryRow,
     temporaryRows: state.temporaryRows
   };
 }