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

Integ Grid Tools

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.applyEdits = exports.apply = exports.isDirty = exports.undo = exports.updateRow = exports.addRow = exports.removeRow = 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"));

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() {
  return {
    updated: [],
    added: [],
    removed: [],
    // originalRow => editedRow
    updatedMap: new Map(),
    // editedRow => orignalRow
    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;
  });
}; // eslint-disable-next-line standard/object-curly-even-spacing


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

exports.removeRow = removeRow;

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

exports.addRow = addRow;

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

  if (currentRow === undefined && !(0, _isNil2["default"])(editedRow)) {
    // eslint-disable-next-line standard/object-curly-even-spacing
    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,
        // dirtyMap: immutableOp(m => {
        //   // remove  transitive row
        //   m.delete(currentRow)
        //   // add new edited row
        //   m.set(editedRow, undefined)
        //   return m
        // })(dirtyMap),
        updatedMap: updatedMap,
        updated: updated,
        history: [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: [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: [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 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(_ref4) {
  var data = _ref4.data,
      editInfo = _ref4.editInfo;
  return isDirty(editInfo) ? [].concat(_toConsumableArray(apply(editInfo)(data)), _toConsumableArray(editInfo.added)) : data;
};

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