@economic/taco 2.47.0-server.8 → 2.47.0

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

@@ -1,5 +1,4 @@
 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';
@@ -7,165 +6,185 @@ import { isTemporaryRow, willRowMove, TEMPORARY_ROW_ID_PREFIX } from '../util/ed
 import omit from 'lodash-es/omit';
 import setWith from 'lodash-es/setWith';
 
-var DELAY_BEFORE_REMOVING_SAVE_STATUS = 3000;
+const DELAY_BEFORE_REMOVING_SAVE_STATUS = 3000;
 function reducer(state, action) {
-  var type = action.type,
-    rowId = action.rowId,
-    payload = action.payload;
+  const {
+    type,
+    rowId,
+    payload
+  } = action;
   switch (type) {
     case 'setCellValue':
       {
-        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),
+        const {
+          columnId,
+          row,
+          value
+        } = payload;
+        return {
+          ...state,
+          changes: {
+            ...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':
       {
-        var _columnId = payload.columnId,
-          rowIdentityAccessor = payload.rowIdentityAccessor;
-        var changes = omit(state.changes.rows, rowId + "." + _columnId);
+        const {
+          columnId,
+          rowIdentityAccessor
+        } = payload;
+        const 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 _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)
-          })
-        });
+        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}`)
+          }
+        };
       }
     case 'updateRow':
       {
-        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),
+        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),
             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':
       {
-        var _rowIdentityAccessor = payload.rowIdentityAccessor;
-        return _extends({}, state, {
-          changes: _extends({}, state.changes, {
+        const {
+          rowIdentityAccessor
+        } = payload;
+        return {
+          ...state,
+          changes: {
+            ...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)
-          }),
-          indexes: omit(state.indexes, rowId),
-          temporaryRows: state.temporaryRows.filter(function (row) {
-            return row[_rowIdentityAccessor] !== rowId;
-          })
-        });
+          },
+          temporaryRows: state.temporaryRows.filter(row => row[rowIdentityAccessor] !== rowId)
+        };
       }
     case 'setRowStatus':
       {
-        var status = payload.status;
-        return _extends({}, state, {
-          changes: _extends({}, state.changes, {
+        const {
+          status
+        } = payload;
+        return {
+          ...state,
+          changes: {
+            ...state.changes,
             status: status ? setWith(state.changes.status, rowId, status, Object) : omit(state.changes.status, rowId)
-          })
-        });
+          }
+        };
       }
     case 'setRowErrors':
       {
-        var errors = _extends({}, (_objectDestructuringEmpty(payload), payload));
-        return _extends({}, state, {
-          changes: _extends({}, state.changes, {
+        const {
+          ...errors
+        } = payload;
+        return {
+          ...state,
+          changes: {
+            ...state.changes,
             errors: setWith(state.changes.errors, rowId, errors, Object)
-          })
-        });
+          }
+        };
       }
     case 'insertTemporaryRow':
       {
-        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)
-        });
+        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)
+          }
+        };
       }
     default:
       return state;
   }
 }
 function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, validator) {
-  var saveChanges = function saveChanges(table, rowId) {
-    if (rowId === void 0) {
-      rowId = undefined;
-    }
+  const saveChanges = function (table, rowId = undefined) {
     try {
-      var _ref;
-      var _exit = false;
+      let _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
-      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);
+      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);
         return _catch(function () {
-          function _temp6(_result) {
+          var _changes$rowId;
+          function _temp8(_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(function () {
+              setTimeout(() => {
                 setRowStatus(rowId, undefined);
               }, DELAY_BEFORE_REMOVING_SAVE_STATUS);
             });
           }
+          const 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 (status === 'saving' || status === 'errored') {
+          if (!Object.keys(rowChanges).length || status === 'saving' || status === 'errored') {
             return;
           }
-          var changeSet = _extends({}, state.changes.originals[rowId], changes[rowId]);
-          // there are no changes to save, just go ahead and skip the save
-          if (!Object.keys(changeSet).length) {
-            _exit = true;
-            return true;
-          }
           setRowStatus(rowId, 'saving');
+          const changeSet = {
+            ...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
-          var _temp5 = function () {
+          const _temp7 = function () {
             if (validator) {
               return Promise.resolve(validator(changeSet)).then(function (errors) {
                 if (errors && Object.keys(errors).length) {
@@ -174,7 +193,7 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
               });
             }
           }();
-          return _temp5 && _temp5.then ? _temp5.then(_temp6) : _temp6(_temp5); // send new data to the server
+          return _temp7 && _temp7.then ? _temp7.then(_temp8) : _temp8(_temp7); // 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) {
@@ -182,8 +201,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
-          var rowError;
-          var cellErrors;
+          let rowError;
+          let cellErrors;
           if (typeof error === 'string') {
             rowError = error;
           } else if (error instanceof Error) {
@@ -200,7 +219,7 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
           if (rowError || cellErrors) {
             dispatch({
               type: 'setRowErrors',
-              rowId: rowId,
+              rowId,
               payload: {
                 row: rowError,
                 cells: cellErrors,
@@ -214,27 +233,23 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
       }, function () {
         return _exit;
       });
-      return Promise.resolve(_temp7 && _temp7.then ? _temp7.then(function (_result3) {
+      return Promise.resolve(_temp9 && _temp9.then ? _temp9.then(function (_result3) {
         return _exit ? _result3 : completed;
-      }) : _exit ? _temp7 : completed);
+      }) : _exit ? _temp9 : completed);
     } catch (e) {
       return Promise.reject(e);
     }
   };
-  var onCellChanged = function onCellChanged(cell, rowIndex, nextValue, shouldRunUpdaters) {
-    if (shouldRunUpdaters === void 0) {
-      shouldRunUpdaters = true;
-    }
+  const onCellChanged = function (cell, rowIndex, nextValue, shouldRunUpdaters = true) {
     try {
-      var _extends3;
-      var _temp4 = function _temp4() {
+      function _temp6() {
         var _state$changes$errors11;
-        function _temp2() {
+        function _temp4() {
           // 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
-          var cellsToActOn = [cell.column.id].concat(Object.keys(updatesForOtherCells));
-          var allCells = cell.row._getAllCellsByColumnId();
-          cellsToActOn.forEach(function (accessor) {
+          const cellsToActOn = [cell.column.id, ...Object.keys(updatesForOtherCells)];
+          const allCells = cell.row._getAllCellsByColumnId();
+          cellsToActOn.forEach(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
@@ -245,7 +260,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
-                var reason = willRowMove(cell, nextChanges[accessor], rowIndex, localization);
+                const 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;
@@ -260,63 +275,111 @@ 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
-        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
-        var validationErrors = {};
-        var _temp = function () {
-          if (validator) {
-            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 : {};
+        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)
+        };
+        // run validation - if there are changes, and if there is an original stored
+        let validationErrors = {};
+        const _temp3 = 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 : {};
             });
           }
         }();
-        return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
+        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]
       };
-      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();
       }
-      var updatesForOtherCells = {};
+      let updatesForOtherCells = {};
       // run the updater handler if there is one, to see if there are any other cells to update
-      var _temp3 = function () {
+      const _temp5 = function () {
         if (typeof handleChange === 'function' && shouldRunUpdaters) {
-          var previousRowValue = _extends({}, state.changes.originals[cell.row.id]);
-          var nextRowValue = _extends({}, state.changes.originals[cell.row.id], changes);
+          const previousRowValue = {
+            ...state.changes.originals[cell.row.id]
+          };
+          const nextRowValue = {
+            ...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(_temp3 && _temp3.then ? _temp3.then(_temp4) : _temp4(_temp3));
+      return Promise.resolve(_temp5 && _temp5.then ? _temp5.then(_temp6) : _temp6(_temp5));
     } 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;
@@ -335,11 +398,11 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
   }
   function hasTemporaryRowErrors() {
     var _state$temporaryRows, _state$changes$errors5, _state$changes$errors6, _state$changes$errors7;
-    var newRow = (_state$temporaryRows = state.temporaryRows) === null || _state$temporaryRows === void 0 ? void 0 : _state$temporaryRows[0];
+    const newRow = (_state$temporaryRows = state.temporaryRows) === null || _state$temporaryRows === void 0 ? void 0 : _state$temporaryRows[0];
     if (!newRow) {
       return false;
     }
-    var rowId = newRow[rowIdentityAccessor];
+    const 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) {
@@ -348,40 +411,40 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
   function setRowStatus(rowId, status) {
     dispatch({
       type: 'setRowStatus',
-      rowId: rowId,
+      rowId,
       payload: {
-        status: status
+        status
       }
     });
   }
-  function insertTemporaryRow(data, rowIndex) {
-    var _extends2;
-    var newRowId = "" + TEMPORARY_ROW_ID_PREFIX + v4();
-    var value = _extends({}, data, (_extends2 = {}, _extends2[rowIdentityAccessor] = newRowId, _extends2));
+  function insertTemporaryRow(data) {
+    const newRowId = `${TEMPORARY_ROW_ID_PREFIX}${v4()}`;
+    const value = {
+      ...data,
+      [rowIdentityAccessor]: newRowId
+    };
     dispatch({
       type: 'insertTemporaryRow',
       rowId: newRowId,
       payload: {
-        index: rowIndex,
-        value: value
+        value
       }
     });
     return newRowId;
   }
   // cells
-  function setCellValue(cell, rowIndex, value) {
-    var rowId = cell.row.id;
-    var columnId = cell.column.id;
+  function setCellValue(cell, value) {
+    const rowId = cell.row.id;
+    const 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,
-          index: rowIndex,
+          columnId,
           row: cell.row.original,
-          value: value
+          value
         }
       });
     }
@@ -389,10 +452,10 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
     else if (cell.row.id in state.changes.rows) {
       dispatch({
         type: 'removeCellValue',
-        rowId: rowId,
+        rowId,
         payload: {
-          columnId: columnId,
-          rowIdentityAccessor: rowIdentityAccessor
+          columnId,
+          rowIdentityAccessor
         }
       });
     }
@@ -406,23 +469,18 @@ 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() {
-    var rowsWithErrors = Object.keys(state.changes.errors);
+    const rowsWithErrors = Object.keys(state.changes.errors);
     if (!rowsWithErrors.length) {
       return [];
     }
-    return rowsWithErrors.filter(hasRowErrorsShownInAlert).map(function (rowId) {
-      return {
-        rowId: rowId,
-        index: state.indexes[rowId],
-        changes: state.changes.rows[rowId],
-        errors: state.changes.errors[rowId]
-      };
-    });
+    return rowsWithErrors.filter(hasRowErrorsShownInAlert).map(rowId => ({
+      rowId,
+      changes: state.changes.rows[rowId],
+      errors: state.changes.errors[rowId]
+    }));
   }
   function hasSaved() {
-    return !!Object.values(state.changes.status).filter(function (value) {
-      return value === 'saved';
-    }).length;
+    return !!Object.values(state.changes.status).filter(value => value === 'saved').length;
   }
   function hasChanges(rowId) {
     return rowId ? !!state.changes.rows[rowId] : !!Object.keys(state.changes.rows).length;
@@ -432,34 +490,35 @@ function usePendingChangesState(handleSave, handleChange, rowIdentityAccessor, v
     table.resetRowPinning(true);
     dispatch({
       type: 'removeRow',
-      rowId: rowId,
+      rowId,
       payload: {
-        rowIdentityAccessor: rowIdentityAccessor
+        rowIdentityAccessor
       }
     });
   }
   return {
     // row
-    getRowValue: getRowValue,
-    getRowMoveReason: getRowMoveReason,
-    hasRowErrors: hasRowErrors,
-    hasRowErrorsShownInAlert: hasRowErrorsShownInAlert,
-    hasTemporaryRowErrors: hasTemporaryRowErrors,
-    getRowStatus: getRowStatus,
-    setRowStatus: setRowStatus,
+    setRowValue,
+    getRowValue,
+    getRowMoveReason,
+    hasRowErrors,
+    hasRowErrorsShownInAlert,
+    hasTemporaryRowErrors,
+    getRowStatus,
+    setRowStatus,
     // cells
-    setCellValue: setCellValue,
-    getCellValue: getCellValue,
-    getCellError: getCellError,
-    onCellChanged: onCellChanged,
+    setCellValue,
+    getCellValue,
+    getCellError,
+    onCellChanged,
     // general
-    getErrorsShownInAlert: getErrorsShownInAlert,
-    hasChanges: hasChanges,
-    saveChanges: saveChanges,
-    discardChanges: discardChanges,
-    hasSaved: hasSaved,
+    getErrorsShownInAlert,
+    hasChanges,
+    saveChanges,
+    discardChanges,
+    hasSaved,
     // new rows
-    insertTemporaryRow: insertTemporaryRow,
+    insertTemporaryRow,
     temporaryRows: state.temporaryRows
   };
 }