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

Integ Grid Tools

'use strict';

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

var _map = require('ramda/src/map');

var _map2 = _interopRequireDefault(_map);

var _compose = require('ramda/src/compose');

var _compose2 = _interopRequireDefault(_compose);

var _filter = require('ramda/src/filter');

var _filter2 = _interopRequireDefault(_filter);

var _isNil = require('ramda/src/isNil');

var _isNil2 = _interopRequireDefault(_isNil);

var _isEmpty = require('ramda/src/isEmpty');

var _isEmpty2 = _interopRequireDefault(_isEmpty);

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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

function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

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

var generateInitialEditInfo = exports.generateInitialEditInfo = function generateInitialEditInfo() {
  return {
    updated: [],
    added: [],
    removed: [],
    // originalRow => editedRow
    updatedMap: new Map(),
    // editedRow => orignalRow
    dirtyMap: new Map(),
    history: []
  };
};

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 = exports.batchRemove = function batchRemove(_ref) {
  var _ref$editInfo = _ref.editInfo,
      editInfo = _ref$editInfo === undefined ? generateInitialEditInfo() : _ref$editInfo,
      rows = _ref.rows;
  var history = editInfo.history;

  var finalEdit = editInfo;
  for (var i = 0; i < rows.length; i++) {
    if (rows[i]) {
      finalEdit = removeRow({ editInfo: finalEdit, row: rows }, false);
    }
  }
  return _extends({}, finalEdit, { history: [].concat(_toConsumableArray(history), [finalEdit]) });
};

var removeRow = function removeRow(_ref2, ignoreHistory) {
  var _ref2$editInfo = _ref2.editInfo,
      editInfo = _ref2$editInfo === undefined ? generateInitialEditInfo() : _ref2$editInfo,
      currentRow = _ref2.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 _extends({
    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 : [].concat(_toConsumableArray(history), [editInfo])
  }, rest);
};

exports.removeRow = removeRow;
var batchAddRow = exports.batchAddRow = function batchAddRow(_ref3) {
  var _ref3$editInfo = _ref3.editInfo,
      editInfo = _ref3$editInfo === undefined ? generateInitialEditInfo() : _ref3$editInfo,
      rows = _ref3.rows;
  return batchUpdateRow({ editInfo: editInfo, updates: rows.map(function (editedRow) {
      return { editedRow: editedRow };
    }) });
};

var addRow = exports.addRow = function addRow(_ref4) {
  var _ref4$editInfo = _ref4.editInfo,
      editInfo = _ref4$editInfo === undefined ? generateInitialEditInfo() : _ref4$editInfo,
      editedRow = _ref4.editedRow;
  return updateRow({ editInfo: editInfo, editedRow: editedRow });
};

var batchUpdateRow = exports.batchUpdateRow = function batchUpdateRow(_ref5) {
  var _ref5$editInfo = _ref5.editInfo,
      editInfo = _ref5$editInfo === undefined ? generateInitialEditInfo() : _ref5$editInfo,
      updates = _ref5.updates;
  var history = editInfo.history;

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

      finalEdit = updateRow({ editInfo: finalEdit, currentRow: currentRow, editedRow: editedRow }, false);
    }
  }
  return _extends({}, finalEdit, { history: [].concat(_toConsumableArray(history), [finalEdit]) });
};

var updateRow = function updateRow(_ref6, ignoreHistory) {
  var _ref6$editInfo = _ref6.editInfo,
      editInfo = _ref6$editInfo === undefined ? generateInitialEditInfo() : _ref6$editInfo,
      currentRow = _ref6.currentRow,
      editedRow = _ref6.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 _extends({
      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 _extends({
        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 _extends({
        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 _extends({
        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 = exports.undo = function undo() {
  var editInfo = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : generateInitialEditInfo();
  return editInfo.history[0] || generateInitialEditInfo();
};

var isDirty = exports.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;
};

var apply = exports.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;
  }));
};

var applyEdits = exports.applyEdits = function applyEdits(_ref7) {
  var data = _ref7.data,
      editInfo = _ref7.editInfo;
  return isDirty(editInfo) ? [].concat(_toConsumableArray(apply(editInfo)(data)), _toConsumableArray(editInfo.added)) : data;
};
//# sourceMappingURL=editEngine.js.map