@integec/grid-tools/lib/editEngine.js

Integ Grid Tools

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.applyEdits = exports.apply = exports.validateEditedData = exports.validateData = exports.isDirty = exports.undo = exports.updateRow = exports.batchUpdateRow = exports.addRow = exports.batchAddRow = exports.removeRow = exports.batchRemove = exports.generateInitialEditInfo = void 0;

var _map2 = _interopRequireDefault(require("ramda/src/map"));

var _compose2 = _interopRequireDefault(require("ramda/src/compose"));

var _filter2 = _interopRequireDefault(require("ramda/src/filter"));

var _isNil2 = _interopRequireDefault(require("ramda/src/isNil"));

var _isEmpty2 = _interopRequireDefault(require("ramda/src/isEmpty"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { if (i % 2) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } else { Object.defineProperties(target, Object.getOwnPropertyDescriptors(arguments[i])); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }

function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }

var generateInitialEditInfo = function generateInitialEditInfo() {
  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      addedFirst = _ref.addedFirst;

  return {
    updated: [],
    added: [],
    addedFirst: addedFirst,
    removed: [],
    // originalRow => editedRow
    updatedMap: new Map(),
    // editedRow => originalRow
    dirtyMap: new Map(),
    history: []
  };
};

exports.generateInitialEditInfo = generateInitialEditInfo;

var immutableOp = function immutableOp(op) {
  return function (map) {
    return op(new Map(map));
  };
};

var immutableSet = function immutableSet(key, value) {
  return immutableOp(function (m) {
    m.set(key, value);
    return m;
  });
};

var batchRemove = function batchRemove(_ref2) {
  var _ref2$editInfo = _ref2.editInfo,
      editInfo = _ref2$editInfo === void 0 ? generateInitialEditInfo() : _ref2$editInfo,
      rows = _ref2.rows;

  var added = editInfo.added,
      updated = editInfo.updated,
      dirtyMap = editInfo.dirtyMap,
      updatedMap = editInfo.updatedMap,
      removed = editInfo.removed,
      history = editInfo.history,
      rest = _objectWithoutProperties(editInfo, ["added", "updated", "dirtyMap", "updatedMap", "removed", "history"]);

  var rowsToRemoveFromAdded = [];
  var rowsToRemoveFromUpdated = [];
  var rowsToAddInRemoved = [];
  var modifiedDirtyMap = new Map(dirtyMap);
  var modifiedUpdatedMap = new Map(updatedMap);

  for (var i = 0; i < rows.length; i++) {
    var currentRow = rows[i];

    if (currentRow) {
      var isAdded = added.includes(currentRow);

      if (isAdded) {
        rowsToRemoveFromAdded.push(currentRow);
      } else {
        var originalRow = dirtyMap.get(currentRow);
        var isUpdated = dirtyMap.has(currentRow);

        if (isUpdated) {
          rowsToRemoveFromUpdated.push(currentRow);
          rowsToAddInRemoved.push(originalRow);
          modifiedDirtyMap["delete"](currentRow);
          modifiedUpdatedMap["delete"](originalRow);
        } else {
          rowsToAddInRemoved.push(currentRow);
        }
      }
    }
  }

  return _objectSpread({
    removed: [].concat(_toConsumableArray(removed), rowsToAddInRemoved),
    added: added.filter(function (row) {
      return !rowsToRemoveFromAdded.includes(row);
    }),
    updated: updated.filter(function (row) {
      return !rowsToRemoveFromUpdated.includes(row);
    }),
    dirtyMap: modifiedDirtyMap,
    updatedMap: modifiedUpdatedMap,
    history: [editInfo].concat(_toConsumableArray(history))
  }, rest);
};

exports.batchRemove = batchRemove;

var removeRow = function removeRow(_ref3, ignoreHistory) {
  var _ref3$editInfo = _ref3.editInfo,
      editInfo = _ref3$editInfo === void 0 ? generateInitialEditInfo() : _ref3$editInfo,
      currentRow = _ref3.currentRow;

  var added = editInfo.added,
      updated = editInfo.updated,
      dirtyMap = editInfo.dirtyMap,
      updatedMap = editInfo.updatedMap,
      removed = editInfo.removed,
      history = editInfo.history,
      rest = _objectWithoutProperties(editInfo, ["added", "updated", "dirtyMap", "updatedMap", "removed", "history"]);

  var originalRow = dirtyMap.get(currentRow);
  var isUpdated = dirtyMap.has(currentRow);
  var isAdded = added.includes(currentRow);
  return _objectSpread({
    removed: isAdded ? removed : [].concat(_toConsumableArray(removed), [isUpdated ? originalRow : currentRow]),
    added: isAdded ? added.filter(function (row) {
      return row !== currentRow;
    }) : added,
    updated: isUpdated ? updated.filter(function (row) {
      return row !== currentRow;
    }) : updated,
    dirtyMap: isUpdated ? immutableOp(function (m) {
      m["delete"](currentRow);
      return m;
    })(dirtyMap) : dirtyMap,
    updatedMap: isUpdated ? immutableOp(function (m) {
      m["delete"](originalRow);
      return m;
    })(updatedMap) : updatedMap,
    history: ignoreHistory ? undefined : [editInfo].concat(_toConsumableArray(history))
  }, rest);
};

exports.removeRow = removeRow;

var batchAddRow = function batchAddRow(_ref4) {
  var _ref4$editInfo = _ref4.editInfo,
      editInfo = _ref4$editInfo === void 0 ? generateInitialEditInfo() : _ref4$editInfo,
      rows = _ref4.rows;

  var added = editInfo.added,
      history = editInfo.history,
      rest = _objectWithoutProperties(editInfo, ["added", "history"]);

  return _objectSpread({
    added: [].concat(_toConsumableArray(added), _toConsumableArray(rows)),
    // dirtyMap: immutableSet(editedRow, undefined)(dirtyMap),
    history: [editInfo].concat(_toConsumableArray(history))
  }, rest);
};

exports.batchAddRow = batchAddRow;

var addRow = function addRow(_ref5) {
  var _ref5$editInfo = _ref5.editInfo,
      editInfo = _ref5$editInfo === void 0 ? generateInitialEditInfo() : _ref5$editInfo,
      editedRow = _ref5.editedRow;
  return updateRow({
    editInfo: editInfo,
    editedRow: editedRow
  });
};

exports.addRow = addRow;

var batchUpdateRow = function batchUpdateRow(_ref6) {
  var _ref6$editInfo = _ref6.editInfo,
      editInfo = _ref6$editInfo === void 0 ? generateInitialEditInfo() : _ref6$editInfo,
      _ref6$updates = _ref6.updates,
      updates = _ref6$updates === void 0 ? [] : _ref6$updates;

  var added = editInfo.added,
      dirtyMap = editInfo.dirtyMap,
      updatedMap = editInfo.updatedMap,
      updated = editInfo.updated,
      history = editInfo.history,
      rest = _objectWithoutProperties(editInfo, ["added", "dirtyMap", "updatedMap", "updated", "history"]);

  var rowsToRemoveFromAdded = [];
  var rowsToAddInAdded = [];
  var rowsToRemoveFromUpdated = [];
  var rowsToAddInUpdated = [];
  var modifiedDirtyMap = new Map(dirtyMap);
  var modifiedUpdatedMap = new Map(updatedMap);

  for (var i = 0; i < updates.length; i++) {
    if (updates[i]) {
      var _updates$i = updates[i],
          currentRow = _updates$i.currentRow,
          editedRow = _updates$i.editedRow;

      if ((currentRow === undefined || (0, _isEmpty2["default"])(currentRow)) && !(0, _isNil2["default"])(editedRow)) {
        rowsToAddInAdded.push(editedRow);
      } else if (added.includes(currentRow)) {
        rowsToRemoveFromAdded.push(currentRow);
        rowsToAddInAdded.push(editedRow);
      } else {
        if (dirtyMap.has(currentRow)) {
          var originalRow = dirtyMap.get(currentRow);
          rowsToRemoveFromUpdated.push(currentRow);
          modifiedDirtyMap["delete"](currentRow);
          modifiedDirtyMap.set(editedRow, originalRow);
          modifiedUpdatedMap.set(originalRow, editedRow);
        } else {
          modifiedDirtyMap.set(editedRow, currentRow);
          modifiedUpdatedMap.set(currentRow, editedRow);
        }

        rowsToAddInUpdated.push(editedRow);
      }
    }
  }

  return _objectSpread({
    added: [].concat(_toConsumableArray(added.filter(function (row) {
      return !rowsToRemoveFromAdded.includes(row);
    })), rowsToAddInAdded),
    updated: [].concat(_toConsumableArray(updated.filter(function (row) {
      return !rowsToRemoveFromUpdated.includes(row);
    })), rowsToAddInUpdated),
    dirtyMap: modifiedDirtyMap,
    updatedMap: modifiedUpdatedMap,
    history: [editInfo].concat(_toConsumableArray(history))
  }, rest);
};

exports.batchUpdateRow = batchUpdateRow;

var updateRow = function updateRow(_ref7, ignoreHistory) {
  var _ref7$editInfo = _ref7.editInfo,
      editInfo = _ref7$editInfo === void 0 ? generateInitialEditInfo() : _ref7$editInfo,
      currentRow = _ref7.currentRow,
      editedRow = _ref7.editedRow;

  if ((currentRow === undefined || (0, _isEmpty2["default"])(currentRow)) && !(0, _isNil2["default"])(editedRow)) {
    var added = editInfo.added,
        history = editInfo.history,
        rest = _objectWithoutProperties(editInfo, ["added", "history"]);

    return _objectSpread({
      added: [].concat(_toConsumableArray(added), [editedRow]),
      // dirtyMap: immutableSet(editedRow, undefined)(dirtyMap),
      history: [editInfo].concat(_toConsumableArray(history))
    }, rest);
  } else if (currentRow !== editedRow) {
    var _added = editInfo.added,
        dirtyMap = editInfo.dirtyMap,
        updatedMap = editInfo.updatedMap,
        updated = editInfo.updated,
        _history = editInfo.history,
        _rest = _objectWithoutProperties(editInfo, ["added", "dirtyMap", "updatedMap", "updated", "history"]);

    if (_added.includes(currentRow)) {
      return _objectSpread({
        added: [].concat(_toConsumableArray(_added.filter(function (row) {
          return row !== currentRow;
        })), [editedRow]),
        dirtyMap: dirtyMap,
        updatedMap: updatedMap,
        updated: updated,
        history: ignoreHistory ? undefined : [editInfo].concat(_toConsumableArray(_history))
      }, _rest); // editing data that has been editted before
    } else if (dirtyMap.has(currentRow)) {
      var originalRow = dirtyMap.get(currentRow);
      return _objectSpread({
        added: _added,
        dirtyMap: immutableOp(function (m) {
          // remove  transitive row
          m["delete"](currentRow); // add new edited row

          m.set(editedRow, originalRow);
          return m;
        })(dirtyMap),
        updatedMap: immutableSet(originalRow, editedRow)(updatedMap),
        updated: [].concat(_toConsumableArray((0, _filter2["default"])(function (row) {
          return row !== currentRow;
        }, updated)), [editedRow]),
        history: ignoreHistory ? undefined : [editInfo].concat(_toConsumableArray(_history))
      }, _rest);
    } else {
      return _objectSpread({
        added: _added,
        dirtyMap: immutableSet(editedRow, currentRow)(dirtyMap),
        updatedMap: immutableSet(currentRow, editedRow)(updatedMap),
        updated: [].concat(_toConsumableArray(updated), [editedRow]),
        history: ignoreHistory ? undefined : [editInfo].concat(_toConsumableArray(_history))
      }, _rest);
    }
  }

  return editInfo;
};

exports.updateRow = updateRow;

var undo = function undo() {
  var editInfo = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : generateInitialEditInfo();
  return editInfo.history[0] || generateInitialEditInfo();
};

exports.undo = undo;

var isDirty = function isDirty() {
  var editInfo = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : generateInitialEditInfo();
  return editInfo.added.length > 0 || editInfo.removed.length > 0 || editInfo.updated.length > 0;
};

exports.isDirty = isDirty;

var validateData = function validateData(_ref8) {
  var originalData = _ref8.originalData,
      _ref8$editInfo = _ref8.editInfo,
      editInfo = _ref8$editInfo === void 0 ? generateInitialEditInfo() : _ref8$editInfo,
      headers = _ref8.headers;
  var editedData = applyEdits({
    data: originalData,
    editInfo: editInfo
  });
  return validateEditedData({
    editedData: editedData,
    headers: headers
  });
};

exports.validateData = validateData;

var validateEditedData = function validateEditedData(_ref9) {
  var editedData = _ref9.editedData,
      headers = _ref9.headers;
  var errors = [];
  var headersWithValidation = headers.filter(function (h) {
    return h.setInvalidMessage;
  });
  editedData.forEach(function (rowData, rowIndex) {
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = headersWithValidation[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var header = _step.value;
        var errMessage = header.setInvalidMessage({
          header: header,
          rowData: rowData,
          value: rowData[header.ident],
          rowIndex: rowIndex,
          data: editedData
        });
        if (errMessage) errors.push(errMessage);
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator["return"] != null) {
          _iterator["return"]();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
  });
  return errors;
};

exports.validateEditedData = validateEditedData;

var apply = function apply(editInfo) {
  return (0, _compose2["default"])((0, _filter2["default"])(function (row) {
    return !editInfo.removed.includes(row);
  }), (0, _map2["default"])(function (row) {
    return editInfo.updatedMap.get(row) || row;
  }));
};

exports.apply = apply;

var applyEdits = function applyEdits(_ref10) {
  var data = _ref10.data,
      editInfo = _ref10.editInfo;
  return isDirty(editInfo) ? editInfo.addedFirst ? [].concat(_toConsumableArray(editInfo.added), _toConsumableArray(apply(editInfo)(data))) : [].concat(_toConsumableArray(apply(editInfo)(data)), _toConsumableArray(editInfo.added)) : data;
};

exports.applyEdits = applyEdits;
//# sourceMappingURL=editEngine.js.map