@gridsuite/commons-ui 0.29.1 → 0.30.0

package/lib/components/MuiVirtualizedTable/KeyedColumnsRowIndexer.js

@@ -0,0 +1,667 @@
+"use strict";
+
+exports.__esModule = true;
+exports.noOpHelper = exports.getHelper = exports.forTesting = exports.collectibleHelper = exports.KeyedColumnsRowIndexer = exports.CHANGE_WAYS = void 0;
+
+var _algos = require("../../utils/algos");
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+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; }
+
+var CHANGE_WAYS = {
+  SIMPLE: 'Simple',
+  TAIL: 'Tail',
+  AMEND: 'Amend',
+  REMOVE: 'Remove'
+};
+/*
+const someTypicalColumns = [
+    { label: 'strings column', dataKey: 'key1' },
+    {
+        label: 'integers column',
+        dataKey: 'key2',
+        numeric: true,
+        fractionDigits: 0,
+    },
+    {
+        label: 'column to ignore',
+        dataKey: 'key3',
+        nostat: true,
+    },
+];
+ */
+
+exports.CHANGE_WAYS = CHANGE_WAYS;
+var noOpHelper = Object.freeze({
+  debugName: 'noOp',
+  maintainsStats: false,
+  initStat: function initStat() {
+    return undefined;
+  },
+  updateStat: function updateStat(colStat, value) {},
+  accepts: function accepts(value, userParams, outerParams) {
+    return true;
+  }
+});
+exports.noOpHelper = noOpHelper;
+var numericHelper = Object.freeze({
+  debugName: 'num',
+  maintainsStats: true,
+  initStat: function initStat() {
+    return {
+      imin: null,
+      imax: null
+    };
+  },
+  updateStat: function updateStat(colStat, value) {
+    if (colStat.imin === null || colStat.imin > value) {
+      colStat.imin = value;
+    }
+
+    if (colStat.imax === null || colStat.imax < value) {
+      colStat.imax = value;
+    }
+  },
+  accepts: function accepts(value, userParams, outerParams) {
+    return true;
+  }
+});
+var collectibleHelper = Object.freeze({
+  debugName: 'collectible',
+  maintainsStats: true,
+  initStat: function initStat() {
+    return {
+      seen: {},
+      kept: {}
+    };
+  },
+  updateStat: function updateStat(colStat, cellValue, isForKeep) {
+    var m = isForKeep ? colStat.kept : colStat.seen;
+    if (!m[cellValue]) m[cellValue] = 1;else m[cellValue] += 1;
+  },
+  accepts: function accepts(value, userParams, outerParams) {
+    return !userParams || userParams.some(function (v) {
+      return v === value;
+    });
+  }
+});
+exports.collectibleHelper = collectibleHelper;
+
+var getHelper = function getHelper(column) {
+  if (column === null || column === void 0 ? void 0 : column.numeric) {
+    return numericHelper;
+  } else if (!(column === null || column === void 0 ? void 0 : column.nostat)) {
+    return collectibleHelper;
+  } else {
+    return noOpHelper;
+  }
+};
+/**
+ * A rows indexer for MuiVirtualizedTable to delegate to an instance of it
+ * for filtering, grouping and multi-column sorting via
+ * a view index to model index array.
+ */
+
+
+exports.getHelper = getHelper;
+
+var KeyedColumnsRowIndexer = /*#__PURE__*/function () {
+  function KeyedColumnsRowIndexer(isThreeState, singleColumnByDefault, delegatorCallback, versionSetter) {
+    var _this = this;
+
+    if (isThreeState === void 0) {
+      isThreeState = true;
+    }
+
+    if (singleColumnByDefault === void 0) {
+      singleColumnByDefault = false;
+    }
+
+    if (delegatorCallback === void 0) {
+      delegatorCallback = null;
+    }
+
+    if (versionSetter === void 0) {
+      versionSetter = null;
+    }
+
+    _defineProperty(this, "hasVersionSetter", function () {
+      return !!_this._versionSetter;
+    });
+
+    _defineProperty(this, "getVersion", function () {
+      return _this.version;
+    });
+
+    _defineProperty(this, "_bumpVersion", function (isFilter) {
+      if (isFilter === void 0) {
+        isFilter = false;
+      }
+
+      _this.version += 1;
+
+      if (isFilter) {
+        _this.filterVersion = _this.version;
+      }
+
+      if (_this.delegatorCallback) {
+        _this.indirectionStatus = 'to sort';
+
+        _this.delegatorCallback(_this, function (updated_ok) {
+          _this.indirectionStatus = updated_ok ? 'done' : 'no_luck';
+        });
+      }
+
+      if (_this._versionSetter) {
+        _this._versionSetter(_this.version);
+      }
+    });
+
+    _defineProperty(this, "updatePreferences", function (preferences) {
+      if (preferences.isThreeState === _this.isThreeState && preferences.singleColumnByDefault === _this.singleColumnByDefault) {
+        return false;
+      }
+
+      if (preferences.isThreeState !== _this.isThreeState) {
+        _this.isThreeState = preferences.isThreeState;
+      }
+
+      if (preferences.singleColumnByDefault !== _this.singleColumnByDefault) {
+        _this.singleColumnByDefault = preferences.singleColumnByDefault;
+      }
+
+      _this._bumpVersion();
+    });
+
+    _defineProperty(this, "preFilterRowMapping", function (columns, rows) {
+      if (!(rows === null || rows === void 0 ? void 0 : rows.length) || !(columns === null || columns === void 0 ? void 0 : columns.length)) return null;
+      var ri = [];
+      var cs = {};
+
+      for (var colIdx = 0; colIdx < columns.length; colIdx++) {
+        var col = columns[colIdx];
+        var helper = getHelper(col);
+        var colStat = helper.initStat();
+
+        if (colStat) {
+          cs[col.dataKey] = colStat;
+        }
+      }
+
+      for (var rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+        var row = rows[rowIdx];
+        var acceptsRow = true;
+        var acceptedOnRow = {};
+
+        for (var _colIdx = 0; _colIdx < columns.length; _colIdx++) {
+          var _this$byColFilter;
+
+          var _col = columns[_colIdx];
+
+          var _helper = getHelper(_col);
+
+          var colKey = _col.dataKey;
+          var cellValue = row[colKey];
+
+          _helper.updateStat(cs[colKey], cellValue, false);
+
+          var colFilterParams = (_this$byColFilter = _this.byColFilter) === null || _this$byColFilter === void 0 ? void 0 : _this$byColFilter[colKey];
+          var acceptsCell = true;
+
+          if (colFilterParams) {
+            var up = colFilterParams.userParams;
+            var op = colFilterParams.outerParams;
+
+            if (!_helper.accepts(cellValue, up, op)) {
+              acceptsCell = false;
+            }
+          }
+
+          if (_helper.maintainsStats && acceptsCell) {
+            acceptedOnRow[_colIdx] = cellValue;
+          }
+
+          acceptsRow &= acceptsCell;
+        }
+
+        if (acceptsRow && _this.byRowFilter) {
+          acceptsRow = _this.byRowFilter(row);
+        }
+
+        if (acceptsRow) {
+          for (var _i = 0, _Object$entries = Object.entries(acceptedOnRow); _i < _Object$entries.length; _i++) {
+            var _Object$entries$_i = _Object$entries[_i],
+                idx = _Object$entries$_i[0],
+                value = _Object$entries$_i[1];
+            var _col2 = columns[idx];
+
+            var _helper2 = getHelper(_col2);
+
+            _helper2.updateStat(cs[_col2.dataKey], value, true);
+          }
+
+          ri.push([row, rowIdx]);
+        }
+      }
+
+      return {
+        rowAndOrigIndex: ri,
+        colsStats: cs,
+        rowsCount: rows.length
+      };
+    });
+
+    _defineProperty(this, "makeGroupAndSortIndirector", function (preFilteredRowPairs, columns) {
+      if (!preFilteredRowPairs) return null;
+      var codedColumns = !_this.sortingState ? null : codedColumnsFromKeyAndDirection(_this.sortingState, columns);
+      var groupingColumnsCount = _this.groupingCount;
+      var indexedArray = groupAndSort(preFilteredRowPairs, codedColumns, groupingColumnsCount, columns);
+      return !indexedArray ? null : indexedArray.map(function (k) {
+        return k[1];
+      });
+    });
+
+    _defineProperty(this, "getSortingAsKeyAndCodedRank", function () {
+      if (!_this.sortingState) return [];
+      return _this.sortingState.map(function (kd, i) {
+        var sign = giveDirSignFor(kd[1]);
+        var codedRank = sign * (i + 1);
+        return [kd[0], codedRank];
+      });
+    });
+
+    _defineProperty(this, "updateSortingFromUser", function (colKey, change_way) {
+      var keyAndDirections = _this.sortingState;
+
+      if (change_way === CHANGE_WAYS.REMOVE) {
+        if (!keyAndDirections) {
+          return false;
+        }
+
+        var would = keyAndDirections.filter(function (p) {
+          return p[0] !== colKey;
+        });
+
+        if (would.length === keyAndDirections.length) {
+          return false;
+        }
+
+        _this.sortingState = would.length ? would : null;
+      } else if (!keyAndDirections) {
+        _this.sortingState = [[colKey, canonicalForSign(1)]];
+        _this.lastUsedRank = 1;
+      } else {
+        var wasAtIdx = keyAndDirections.findIndex(function (p) {
+          return p[0] === colKey;
+        });
+        var wasFuzzyDir = wasAtIdx < 0 ? 0 : keyAndDirections[wasAtIdx][1];
+        var wasSignDir = giveDirSignFor(wasFuzzyDir);
+
+        if (change_way === CHANGE_WAYS.SIMPLE) {
+          if (wasSignDir < 0 && _this.isThreeState) {
+            if (_this.sortingState.length === 1) {
+              _this.sortingState = null;
+            } else {
+              _this.sortingState.splice(wasAtIdx, 1);
+            }
+          } else {
+            if (_this.singleColumnByDefault || wasAtIdx < 0) {
+              _this.sortingState = [];
+            } else {
+              _this.sortingState.splice(wasAtIdx, 1);
+            }
+
+            var nextSign = wasSignDir ? -wasSignDir : 1;
+            var nextKD = [colKey, canonicalForSign(nextSign)];
+
+            _this.sortingState.unshift(nextKD);
+          }
+        } else if (change_way === CHANGE_WAYS.TAIL) {
+          if (wasAtIdx < 0) {
+            _this.sortingState.push([colKey, canonicalForSign(1)]);
+          } else if (wasAtIdx !== keyAndDirections.length - 1) {
+            return false;
+          } else if (!(_this.isThreeState && wasSignDir === -1)) {
+            _this.sortingState[wasAtIdx][1] = canonicalForSign(-wasSignDir);
+          } else {
+            _this.sortingState.splice(wasAtIdx, 1);
+          }
+        } else {
+          // AMEND
+          if (wasAtIdx < 0) {
+            if (_this.lastUsedRank - 1 > _this.sortingState.length) {
+              return false;
+            } else {
+              _this.sortingState.splice(_this.lastUsedRank - 1, 0, [colKey, canonicalForSign(1)]);
+            }
+          } else if (!(_this.isThreeState && wasSignDir === -1)) {
+            _this.sortingState[wasAtIdx][1] = canonicalForSign(-wasSignDir);
+          } else {
+            _this.lastUsedRank = wasAtIdx + 1;
+
+            _this.sortingState.splice(wasAtIdx, 1);
+          }
+        }
+      }
+
+      _this._bumpVersion();
+
+      return true;
+    });
+
+    _defineProperty(this, "codedRankByColumnIndex", function (columns) {
+      return codedColumnsFromKeyAndDirection(_this.sortingState, columns);
+    });
+
+    _defineProperty(this, "columnSortingSignedRank", function (colKey) {
+      var _this$sortingState;
+
+      if (!(_this === null || _this === void 0 ? void 0 : (_this$sortingState = _this.sortingState) === null || _this$sortingState === void 0 ? void 0 : _this$sortingState.length)) return 0;
+
+      var idx = _this.sortingState.findIndex(function (kd) {
+        return kd[0] === colKey;
+      });
+
+      if (idx < 0) return 0;
+      var colSorting = _this.sortingState[idx];
+      return giveDirSignFor(colSorting[1]) * (idx + 1);
+    });
+
+    _defineProperty(this, "highestCodedColumn", function (columns) {
+      var _this$sortingState2;
+
+      if (!(_this === null || _this === void 0 ? void 0 : (_this$sortingState2 = _this.sortingState) === null || _this$sortingState2 === void 0 ? void 0 : _this$sortingState2.length)) return 0;
+      var colSorting = _this.sortingState[0];
+      var colKey = colSorting[0];
+      var idx = columns.findIndex(function (col) {
+        return col.dataKey === colKey;
+      });
+      if (idx < 0) return 0;
+      return giveDirSignFor(colSorting[1]) * (idx + 1);
+    });
+
+    _defineProperty(this, "_getColFilterParams", function (colKey, isForUser) {
+      if (!colKey || !_this.byColFilter) {
+        return undefined;
+      }
+
+      var colFilter = _this.byColFilter[colKey];
+
+      if (!colFilter) {
+        return undefined;
+      }
+
+      return colFilter[isForUser ? 'userParams' : 'outerParams'];
+    });
+
+    _defineProperty(this, "_setColFilterParams", function (colKey, params, isForUser) {
+      if (!colKey) {
+        if (params) {
+          throw new Error('column key has to be defined');
+        }
+
+        return false;
+      }
+
+      var fieldName = isForUser ? 'userParams' : 'outerParams';
+
+      if (params) {
+        if (!_this.byColFilter) {
+          _this.byColFilter = {};
+        }
+
+        var colFilter = _this.byColFilter[colKey];
+
+        if (!colFilter) {
+          colFilter = {};
+          _this.byColFilter[colKey] = colFilter;
+        } else if (colFilter[fieldName] === params) {
+          return false;
+        }
+
+        colFilter[fieldName] = params;
+      } else {
+        var _this$byColFilter$col;
+
+        if (!_this.byColFilter) {
+          return false;
+        }
+
+        var otherFieldName = !isForUser ? 'userParams' : 'outerParams';
+
+        if ((_this$byColFilter$col = _this.byColFilter[colKey]) === null || _this$byColFilter$col === void 0 ? void 0 : _this$byColFilter$col[otherFieldName]) {
+          delete _this.byColFilter[colKey][fieldName];
+        } else {
+          delete _this.byColFilter[colKey];
+        }
+      }
+
+      if (isForUser) {
+        _this._bumpVersion(true);
+      }
+
+      return true;
+    });
+
+    _defineProperty(this, "getColFilterOuterParams", function (colKey) {
+      return _this._getColFilterParams(colKey, false);
+    });
+
+    _defineProperty(this, "setColFilterOuterParams", function (colKey, outerParams) {
+      return _this._setColFilterParams(colKey, outerParams, false);
+    });
+
+    _defineProperty(this, "getColFilterUserParams", function (colKey) {
+      return _this._getColFilterParams(colKey, true);
+    });
+
+    _defineProperty(this, "setColFilterUserParams", function (colKey, params) {
+      return _this._setColFilterParams(colKey, params, true);
+    });
+
+    _defineProperty(this, "getUserFiltering", function () {
+      var ret = {};
+
+      if (_this.byColFilter) {
+        Object.entries(_this.byColFilter).forEach(function (_ref) {
+          var k = _ref[0],
+              v = _ref[1];
+          if (!v.userParams) return;
+          ret[k] = [].concat(v.userParams);
+        });
+      }
+
+      return ret;
+    });
+
+    _defineProperty(this, "updateRowFiltering", function (rowFilterFunc) {
+      if (typeof rowFilterFunc !== 'function') {
+        throw new Error('row filter should be a function');
+      }
+
+      _this.byRowFilter = rowFilterFunc;
+
+      _this._bumpVersion();
+    });
+
+    console.debug('KeyedColumnsRowIndexer');
+    this._versionSetter = versionSetter;
+    this.version = 0;
+    this.filterVersion = 0;
+    this.delegatorCallback = delegatorCallback;
+    this.indirectionStatus = null;
+    this.isThreeState = isThreeState;
+    this.singleColumnByDefault = singleColumnByDefault;
+    this.lastUsedRank = 1;
+    this.sortingState = null;
+    this.groupingCount = 0;
+    this.byColFilter = null; // common
+
+    this.byRowFilter = null;
+  }
+
+  _createClass(KeyedColumnsRowIndexer, null, [{
+    key: "CHANGE_WAYS",
+    get: function get() {
+      return CHANGE_WAYS;
+    }
+  }]);
+
+  return KeyedColumnsRowIndexer;
+}();
+
+exports.KeyedColumnsRowIndexer = KeyedColumnsRowIndexer;
+
+var giveDirSignFor = function giveDirSignFor(fuzzySign) {
+  if (fuzzySign < 0) return -1;
+  if (fuzzySign > 0) return 1;
+  if (fuzzySign === 'asc') return 1;
+  if (fuzzySign === 'desc') return -1;
+  return 0;
+};
+
+var canonicalForSign = function canonicalForSign(dirSign) {
+  if (dirSign > 0) return 'asc';
+  if (dirSign < 0) return 'desc';
+  return undefined;
+};
+
+var codedColumnsFromKeyAndDirection = function codedColumnsFromKeyAndDirection(keyAndDirections, columns) {
+  if (!keyAndDirections) return null;
+  var ret = [];
+  var columIndexByKey = {};
+
+  for (var colIdx = 0; colIdx < columns.length; colIdx++) {
+    var col = columns[colIdx];
+    var colKey = col.dataKey;
+    columIndexByKey[colKey] = colIdx;
+  }
+
+  for (var i = 0; i < keyAndDirections.length; i++) {
+    var knd = keyAndDirections[i];
+    var _colKey = knd[0];
+    var dir = knd[1];
+    var _colIdx2 = columIndexByKey[_colKey];
+    if (_colIdx2 === undefined) continue;
+    var sign = giveDirSignFor(dir);
+    ret.push((_colIdx2 + 1) * sign);
+  }
+
+  return ret;
+};
+
+var compareValue = function compareValue(a, b, isNumeric, undefSign) {
+  if (undefSign === void 0) {
+    undefSign = -1;
+  }
+
+  if (a === undefined && b === undefined) return 0;else if (a === undefined) return undefSign;else if (b === undefined) return -undefSign;
+  return isNumeric ? Math.sign(Number(a) - Number(b)) : ('' + a).localeCompare(b);
+};
+
+var makeCompositeComparatorFromCodedColumns = function makeCompositeComparatorFromCodedColumns(codedColumns, columns, rowExtractor) {
+  return function (row_a_i, row_b_i) {
+    var row_a = rowExtractor(row_a_i);
+    var row_b = rowExtractor(row_b_i);
+
+    for (var _iterator = _createForOfIteratorHelperLoose(codedColumns), _step; !(_step = _iterator()).done;) {
+      var cc = _step.value;
+      var i = Math.abs(cc) - 1;
+      var mul = Math.sign(cc);
+      var col = columns[i];
+      var key = col.dataKey;
+      var sgn = compareValue(row_a[key], row_b[key], col.numeric);
+
+      if (sgn) {
+        return mul * sgn;
+      }
+    }
+
+    return 0;
+  };
+};
+
+var groupRows = function groupRows(groupingColumnsCount, columns, indexedArray) {
+  var groupingComparator = makeCompositeComparatorFromCodedColumns(Array(groupingColumnsCount).map(function (x, i) {
+    return i + 1;
+  }), columns, function (ar) {
+    return ar[0];
+  });
+  indexedArray.sort(groupingComparator);
+  var groups = [];
+  var prevSlice = null;
+  var inBuildGroup = [];
+  groups.push(inBuildGroup);
+
+  for (var _iterator2 = _createForOfIteratorHelperLoose(indexedArray), _step2; !(_step2 = _iterator2()).done;) {
+    var p = _step2.value;
+    var nextSlice = p[0].slice(0, groupingColumnsCount);
+
+    if (prevSlice === null || !(0, _algos.equalsArray)(prevSlice, nextSlice)) {
+      inBuildGroup = [];
+      groups.push(inBuildGroup);
+    }
+
+    inBuildGroup.push(p);
+    prevSlice = nextSlice;
+  }
+
+  return groups;
+};
+
+var groupAndSort = function groupAndSort(preFilteredRowPairs, codedColumns, groupingColumnsCount, columns) {
+  var nothingToDo = !codedColumns && !groupingColumnsCount;
+  var indexedArray = preFilteredRowPairs.rowAndOrigIndex;
+  var noOutFiltered = preFilteredRowPairs.rowsCount === indexedArray.length;
+
+  if (nothingToDo && noOutFiltered) {
+    return null;
+  } else if (!nothingToDo) {
+    // make a copy for not losing base order
+    indexedArray = [].concat(indexedArray);
+  }
+
+  if (nothingToDo) {// just nothing
+  } else if (!groupingColumnsCount) {
+    var sortingComparator = makeCompositeComparatorFromCodedColumns(codedColumns, columns, function (ar) {
+      return ar[0];
+    });
+    indexedArray.sort(sortingComparator);
+  } else {
+    var groups = groupRows(groupingColumnsCount, columns, indexedArray);
+    var interGroupSortingComparator = makeCompositeComparatorFromCodedColumns(codedColumns, columns, function (ar) {
+      return ar[0][0];
+    });
+    groups.sort(interGroupSortingComparator);
+    var intraGroupSortingComparator = makeCompositeComparatorFromCodedColumns(codedColumns, columns, function (ar) {
+      return ar[0];
+    });
+    indexedArray = [];
+
+    for (var _iterator3 = _createForOfIteratorHelperLoose(groups), _step3; !(_step3 = _iterator3()).done;) {
+      var _indexedArray;
+
+      var group = _step3.value;
+      group.sort(intraGroupSortingComparator);
+
+      (_indexedArray = indexedArray).push.apply(_indexedArray, group);
+    }
+  }
+
+  return indexedArray;
+};
+
+var forTesting = {
+  codedColumnsFromKeyAndDirection: codedColumnsFromKeyAndDirection,
+  makeCompositeComparatorFromCodedColumns: makeCompositeComparatorFromCodedColumns
+};
+exports.forTesting = forTesting;