Merge branch 'master' of http://192.168.1.41:3000/SmartCost/SCCommon

# Conflicts:
#	tree/package-lock.json

handsontable/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "handsontable",
+  "name": "@sc/handsontable",
   "description": "Handsontable is a JavaScript Spreadsheet Component available for React, Angular and Vue.",
   "homepage": "https://handsontable.com/",
   "repository": {
@@ -10,7 +10,7 @@
     "url": "https://github.com/handsontable/handsontable/issues"
   },
   "author": "Handsoncode <hello@handsontable.com>",
-  "version": "6.2.2",
+  "version": "6.2.21",
   "browser": "dist/handsontable.js",
   "main": "commonjs/index.js",
   "module": "es/index.js",

handsontable/src/plugins/index.js

@@ -19,6 +19,7 @@ import ObserveChanges from './observeChanges/observeChanges';
 import Search from './search/search';
 import TouchScroll from './touchScroll/touchScroll';
 import UndoRedo from './undoRedo/undoRedo';
+import TrimRows from './trimRows/trimRows';
 import Base from './_base';
 
 export {
@@ -42,6 +43,7 @@ export {
   PersistentState,
   Search,
   TouchScroll,
+  TrimRows,
   UndoRedo,
   Base,
 };

handsontable/src/plugins/manualRowMove/manualRowMove.js

@@ -1,8 +1,8 @@
 import BasePlugin from './../_base';
 import Hooks from './../../pluginHooks';
-import { arrayEach } from './../../helpers/array';
+import { arrayEach } from '../../helpers/array';
 import { addClass, removeClass, offset } from './../../helpers/dom/element';
-import { rangeEach } from './../../helpers/number';
+import { rangeEach } from '../../helpers/number';
 import EventManager from './../../eventManager';
 import { registerPlugin } from './../../plugins';
 import RowsMapper from './rowsMapper';

handsontable/src/plugins/shieldRows/shieldRows.js

@@ -0,0 +1,191 @@
+import BasePlugin from '../_base';
+import { arrayEach } from '../../helpers/array';
+import { rangeEach } from '../../helpers/number';
+import { registerPlugin } from '../../plugins';
+import { mixin } from '../../helpers/object';
+import arrayMapper from '../../mixins/arrayMapper';
+
+class Mapper {
+  constructor(shieldRows) {
+    this.shieldRows = shieldRows;
+  }
+
+  createMap(length) {
+    let rowOffset = 0;
+    const originLength = length ? this._arrayMap.length : length;
+
+    this._arrayMap.length = 0;
+
+    rangeEach(originLength - 1, (itemIndex) => {
+      if (this.shieldRows.isShield(itemIndex)) {
+        rowOffset += 1;
+      } else {
+        this._arrayMap[itemIndex - rowOffset] = itemIndex;
+      }
+    });
+  }
+
+  destroy() {
+    this._arrayMap = null;
+  }
+}
+
+mixin(Mapper, arrayMapper);
+
+class TrimRows extends BasePlugin {
+  constructor(hotInstance) {
+    super(hotInstance);
+
+    this.trimmedRows = [];
+
+    this.removedRows = [];
+
+    this.rowsMapper = new Mapper(this);
+  }
+
+  isEnabled() {
+    return !!this.hot.getSettings().trimRows;
+  }
+
+  enablePlugin() {
+    if (this.enabled) {
+      return;
+    }
+    const settings = this.hot.getSettings().trimRows;
+
+    if (Array.isArray(settings)) {
+      this.trimmedRows = settings;
+    }
+    this.rowsMapper.createMap(this.hot.countSourceRows());
+
+    this.addHook('modifyRow', (row, source) => this.onModifyRow(row, source));
+    this.addHook('unmodifyRow', (row, source) => this.onUnmodifyRow(row, source));
+    this.addHook('beforeCreateRow', (index, amount, source) => this.onBeforeCreateRow(index, amount, source));
+    this.addHook('afterCreateRow', (index, amount) => this.onAfterCreateRow(index, amount));
+    this.addHook('beforeRemoveRow', (index, amount) => this.onBeforeRemoveRow(index, amount));
+    this.addHook('afterRemoveRow', () => this.onAfterRemoveRow());
+    this.addHook('afterLoadData', firstRun => this.onAfterLoadData(firstRun));
+
+    super.enablePlugin();
+  }
+
+  updatePlugin() {
+    const settings = this.hot.getSettings().trimRows;
+
+    if (Array.isArray(settings)) {
+      this.disablePlugin();
+      this.enablePlugin();
+    }
+
+    super.updatePlugin();
+  }
+
+  disablePlugin() {
+    this.trimmedRows = [];
+    this.removedRows.length = 0;
+    this.rowsMapper.clearMap();
+    super.disablePlugin();
+  }
+
+  trimRows(rows) {
+    arrayEach(rows, (row) => {
+      const physicalRow = parseInt(row, 10);
+
+      if (!this.isShield(physicalRow)) {
+        this.trimmedRows.push(physicalRow);
+      }
+    });
+
+    this.hot.runHooks('skipLengthCache', 100);
+    this.rowsMapper.createMap(this.hot.countSourceRows());
+    this.hot.runHooks('afterTrimRow', rows);
+  }
+
+  trimRow(...row) {
+    this.trimRows(row);
+  }
+
+  untrimRows(rows) {
+    arrayEach(rows, (row) => {
+      const physicalRow = parseInt(row, 10);
+
+      if (this.isShield(physicalRow)) {
+        this.trimmedRows.splice(this.trimmedRows.indexOf(physicalRow), 1);
+      }
+    });
+
+    this.hot.runHooks('skipLengthCache', 100);
+    this.rowsMapper.createMap(this.hot.countSourceRows());
+    this.hot.runHooks('afterUntrimRow', rows);
+  }
+
+  untrimRow(...row) {
+    this.untrimRows(row);
+  }
+
+  isShield(row) {
+    return this.trimmedRows.indexOf(row) > -1;
+  }
+
+  untrimAll() {
+    this.untrimRows([].concat(this.trimmedRows));
+  }
+
+  onModifyRow(row, source) {
+    let physicalRow = row;
+
+    if (source !== this.pluginName) {
+      physicalRow = this.rowsMapper.getValueByIndex(physicalRow);
+    }
+
+    return physicalRow;
+  }
+
+  onUnmodifyRow(row, source) {
+    let visualRow = row;
+
+    if (source !== this.pluginName) {
+      visualRow = this.rowsMapper.getIndexByValue(visualRow);
+    }
+
+    return visualRow;
+  }
+
+  onBeforeCreateRow(index, amount, source) {
+    return !(this.isEnabled() && this.trimmedRows.length > 0 && source === 'auto');
+  }
+
+  onAfterCreateRow(index, amount) {
+    this.rowsMapper.shiftItems(index, amount);
+  }
+
+  onBeforeRemoveRow(index, amount) {
+    this.removedRows.length = 0;
+
+    if (index !== false) {
+      // Collect physical row index.
+      rangeEach(index, index + amount - 1, (removedIndex) => {
+        this.removedRows.push(this.hot.runHooks('modifyRow', removedIndex, this.pluginName));
+      });
+    }
+  }
+
+  onAfterRemoveRow() {
+    this.rowsMapper.unshiftItems(this.removedRows);
+  }
+
+  onAfterLoadData(firstRun) {
+    if (!firstRun) {
+      this.rowsMapper.createMap(this.hot.countSourceRows());
+    }
+  }
+
+  destroy() {
+    this.rowsMapper.destroy();
+    super.destroy();
+  }
+}
+
+registerPlugin('trimRows', TrimRows);
+
+export default TrimRows;

handsontable/src/plugins/trimRows/rowsMapper.js

@@ -0,0 +1,50 @@
+import arrayMapper from '../../mixins/arrayMapper';
+import { mixin } from '../../helpers/object';
+import { rangeEach } from '../../helpers/number';
+
+/**
+ * @class RowsMapper
+ * @plugin TrimRows
+ * @pro
+ */
+class RowsMapper {
+  constructor(trimRows) {
+    /**
+     * Instance of TrimRows plugin.
+     *
+     * @type {TrimRows}
+     */
+    this.trimRows = trimRows;
+  }
+
+  /**
+   * Reset current map array and create new one.
+   *
+   * @param {Number} [length] Custom generated map length.
+   */
+  createMap(length) {
+    let rowOffset = 0;
+    const originLength = length === void 0 ? this._arrayMap.length : length;
+
+    this._arrayMap.length = 0;
+
+    rangeEach(originLength - 1, (itemIndex) => {
+      if (this.trimRows.isTrimmed(itemIndex)) {
+        rowOffset += 1;
+      } else {
+        this._arrayMap[itemIndex - rowOffset] = itemIndex;
+      }
+    });
+  }
+
+  /**
+   * Destroy class.
+   */
+  destroy() {
+    this._arrayMap = null;
+  }
+}
+
+mixin(RowsMapper, arrayMapper);
+
+export default RowsMapper;

handsontable/src/plugins/trimRows/test/rowsMapper.unit.js

@@ -0,0 +1,81 @@
+import RowsMapper from '../../trimRows/rowsMapper';
+
+describe('TrimRows -> RowsMapper', () => {
+  it('should set trimRows plugin while constructing', () => {
+    const trimRowsMock = {};
+    const mapper = new RowsMapper(trimRowsMock);
+
+    expect(mapper.trimRows).toBe(trimRowsMock);
+  });
+
+  it('should be mixed with arrayMapper object', () => {
+    expect(RowsMapper.MIXINS).toEqual(['arrayMapper']);
+  });
+
+  it('should destroy array after calling destroy method', () => {
+    const mapper = new RowsMapper();
+
+    expect(mapper._arrayMap).toEqual([]);
+
+    mapper.destroy();
+
+    expect(mapper._arrayMap).toBe(null);
+  });
+
+  it('should call isTrimmed method "length" times', () => {
+    const trimRowsMock = {
+      isTrimmed() {
+        return false;
+      }
+    };
+    const mapper = new RowsMapper(trimRowsMock);
+
+    spyOn(trimRowsMock, 'isTrimmed').and.callThrough();
+    mapper.createMap(5);
+
+    expect(trimRowsMock.isTrimmed.calls.count()).toBe(5);
+    expect(trimRowsMock.isTrimmed.calls.argsFor(0)).toEqual([0]);
+    expect(trimRowsMock.isTrimmed.calls.argsFor(1)).toEqual([1]);
+    expect(trimRowsMock.isTrimmed.calls.argsFor(2)).toEqual([2]);
+    expect(trimRowsMock.isTrimmed.calls.argsFor(3)).toEqual([3]);
+    expect(trimRowsMock.isTrimmed.calls.argsFor(4)).toEqual([4]);
+  });
+
+  it('should create map with pairs index->value', () => {
+    const trimRowsMock = {
+      isTrimmed() {
+        return false;
+      }
+    };
+    const mapper = new RowsMapper(trimRowsMock);
+
+    spyOn(trimRowsMock, 'isTrimmed').and.callThrough();
+    mapper.createMap(6);
+
+    expect(mapper._arrayMap[0]).toBe(0);
+    expect(mapper._arrayMap[1]).toBe(1);
+    expect(mapper._arrayMap[2]).toBe(2);
+    expect(mapper._arrayMap[3]).toBe(3);
+    expect(mapper._arrayMap[4]).toBe(4);
+    expect(mapper._arrayMap[5]).toBe(5);
+  });
+
+  it('should create map with pairs index->value with some gaps', () => {
+    const trimRowsMock = {
+      isTrimmed(index) {
+        return index === 2 || index === 5;
+      }
+    };
+    const mapper = new RowsMapper(trimRowsMock);
+
+    spyOn(trimRowsMock, 'isTrimmed').and.callThrough();
+    mapper.createMap(6);
+
+    expect(mapper._arrayMap[0]).toBe(0);
+    expect(mapper._arrayMap[1]).toBe(1);
+    expect(mapper._arrayMap[2]).toBe(3);
+    expect(mapper._arrayMap[3]).toBe(4);
+    expect(mapper._arrayMap[4]).toBeUndefined();
+    expect(mapper._arrayMap[5]).toBeUndefined();
+  });
+});

handsontable/src/plugins/trimRows/test/trimRows.e2e.js

@@ -0,0 +1,668 @@
+describe('TrimRows', () => {
+  const id = 'testContainer';
+
+  function getMultilineData(rows, cols) {
+    const data = Handsontable.helper.createSpreadsheetData(rows, cols);
+
+    // Column C
+    data[0][2] += '\nline';
+    data[1][2] += '\nline\nline';
+
+    return data;
+  }
+
+  beforeEach(function() {
+    this.$container = $(`<div id="${id}"></div>`).appendTo('body');
+  });
+
+  afterEach(function() {
+    if (this.$container) {
+      destroy();
+      this.$container.remove();
+    }
+  });
+
+  it('should trim rows defined in `trimRows` property', () => {
+    handsontable({
+      data: Handsontable.helper.createSpreadsheetData(10, 10),
+      trimRows: [2, 6, 7],
+      cells(row) {
+        const meta = {};
+
+        if (row === 2) {
+          meta.type = 'date';
+        }
+
+        return meta;
+      },
+      width: 500,
+      height: 300
+    });
+
+    expect(getDataAtCell(0, 0)).toBe('A1');
+    expect(getDataAtCell(1, 0)).toBe('A2');
+    expect(getDataAtCell(2, 0)).toBe('A4');
+    expect(getDataAtCell(3, 0)).toBe('A5');
+    expect(getDataAtCell(4, 0)).toBe('A6');
+    expect(getDataAtCell(5, 0)).toBe('A9');
+    expect(getDataAtCell(6, 0)).toBe('A10');
+    expect(getCellMeta(0, 0).type).toBe('text');
+    expect(getCellMeta(1, 0).type).toBe('text');
+    expect(getCellMeta(2, 0).type).toBe('text');
+    expect(getCellMeta(3, 0).type).toBe('text');
+    expect(getCellMeta(4, 0).type).toBe('text');
+    expect(getCellMeta(5, 0).type).toBe('text');
+    expect(getCellMeta(6, 0).type).toBe('text');
+  });
+
+  it('should trim rows after re-load data calling loadData method', () => {
+    const hot = handsontable({
+      data: Handsontable.helper.createSpreadsheetData(10, 10),
+      trimRows: [0, 2],
+      width: 500,
+      height: 300
+    });
+
+    hot.loadData(Handsontable.helper.createSpreadsheetData(5, 5));
+
+    expect(getDataAtCell(0, 0)).toBe('A2');
+    expect(getDataAtCell(1, 0)).toBe('A4');
+    expect(getDataAtCell(2, 0)).toBe('A5');
+    expect(getDataAtCell(3, 0)).toBe(null);
+    expect(getDataAtCell(4, 0)).toBe(null);
+  });
+
+  it('should return to default state after call disablePlugin method', () => {
+    const hot = handsontable({
+      data: getMultilineData(10, 10),
+      trimRows: [2, 6, 7],
+      width: 500,
+      height: 300
+    });
+    hot.getPlugin('trimRows').disablePlugin();
+    hot.render();
+
+    expect(getDataAtCell(0, 0)).toBe('A1');
+    expect(getDataAtCell(1, 0)).toBe('A2');
+    expect(getDataAtCell(2, 0)).toBe('A3');
+    expect(getDataAtCell(3, 0)).toBe('A4');
+    expect(getDataAtCell(4, 0)).toBe('A5');
+    expect(getDataAtCell(5, 0)).toBe('A6');
+    expect(getDataAtCell(6, 0)).toBe('A7');
+  });
+
+  it('should trim rows after call enablePlugin method', () => {
+    const hot = handsontable({
+      data: getMultilineData(10, 10),
+      trimRows: [2, 6, 7],
+      width: 500,
+      height: 300
+    });
+    hot.getPlugin('hiddenRows').disablePlugin();
+    hot.getPlugin('hiddenRows').enablePlugin();
+    hot.render();
+
+    expect(getDataAtCell(0, 0)).toBe('A1');
+    expect(getDataAtCell(1, 0)).toBe('A2');
+    expect(getDataAtCell(2, 0)).toBe('A4');
+    expect(getDataAtCell(3, 0)).toBe('A5');
+    expect(getDataAtCell(4, 0)).toBe('A6');
+    expect(getDataAtCell(5, 0)).toBe('A9');
+    expect(getDataAtCell(6, 0)).toBe('A10');
+  });
+
+  it('should trim row after call trimRow method', () => {
+    const hot = handsontable({
+      data: getMultilineData(5, 10),
+      trimRows: true,
+      width: 500,
+      height: 300
+    });
+
+    expect(getDataAtCell(1, 0)).toBe('A2');
+
+    hot.getPlugin('trimRows').trimRow(1);
+    hot.render();
+
+    expect(getDataAtCell(1, 0)).toBe('A3');
+  });
+
+  it('should untrim row after call untrimRow method', () => {
+    const hot = handsontable({
+      data: getMultilineData(5, 10),
+      trimRows: [1],
+      width: 500,
+      height: 300
+    });
+
+    expect(getDataAtCell(1, 0)).toBe('A3');
+
+    hot.getPlugin('trimRows').untrimRow(1);
+    hot.render();
+
+    expect(getDataAtCell(1, 0)).toBe('A2');
+  });
+
+  it('should call hook after trim row', () => {
+    const callback = jasmine.createSpy();
+    const hot = handsontable({
+      data: getMultilineData(5, 10),
+      trimRows: true,
+      width: 500,
+      height: 300,
+    });
+
+    expect(callback).not.toHaveBeenCalled();
+
+    hot.addHook('afterTrimRow', callback);
+    hot.getPlugin('trimRows').trimRow(1);
+    hot.render();
+
+    expect(callback).toHaveBeenCalledWith([1], void 0, void 0, void 0, void 0, void 0);
+  });
+
+  it('should call hook after untrim row', () => {
+    const callback = jasmine.createSpy();
+    const hot = handsontable({
+      data: getMultilineData(5, 10),
+      trimRows: [1],
+      width: 500,
+      height: 300,
+    });
+
+    expect(callback).not.toHaveBeenCalled();
+
+    hot.addHook('afterUntrimRow', callback);
+    hot.getPlugin('trimRows').untrimRow(1);
+    hot.render();
+
+    expect(callback).toHaveBeenCalledWith([1], void 0, void 0, void 0, void 0, void 0);
+  });
+
+  it('should trim big data set', () => {
+    handsontable({
+      data: Handsontable.helper.createSpreadsheetData(1000, 5),
+      // leave first row and last 3 rows
+      trimRows: Array(...Array(996)).map((v, i) => i + 1),
+      width: 500,
+      height: 300
+    });
+
+    expect(getDataAtCell(0, 0)).toBe('A1');
+    expect(getDataAtCell(1, 0)).toBe('A998');
+    expect(getDataAtCell(2, 0)).toBe('A999');
+    expect(getDataAtCell(3, 0)).toBe('A1000');
+    expect(getDataAtCell(4, 0)).toBe(null);
+  });
+
+  it('should remove correct rows', () => {
+    handsontable({
+      data: getMultilineData(5, 10),
+      trimRows: [1],
+      width: 500,
+      height: 300
+    });
+
+    alter('remove_row', 0, 2);
+
+    expect(getDataAtCell(0, 0)).toBe('A4');
+    expect(getDataAtCell(1, 0)).toBe('A5');
+    expect(getDataAtCell(2, 0)).toBe(null);
+  });
+
+  it('should remove correct rows after inserting new ones', () => {
+    handsontable({
+      data: getMultilineData(6, 10),
+      trimRows: [1, 4],
+      width: 500,
+      height: 300
+    });
+
+    alter('insert_row', 1);
+    alter('insert_row', 3);
+    alter('remove_row', 0, 3);
+
+    expect(getDataAtCell(0, 0)).toBe(null);
+    expect(getDataAtCell(1, 0)).toBe('A4');
+    expect(getDataAtCell(2, 0)).toBe('A6');
+    expect(getDataAtCell(3, 0)).toBe(null);
+  });
+
+  it('should clear cache after loading new data by `loadData` function, when plugin `trimRows` is enabled #92', function(done) {
+    const hot = handsontable({
+      data: Handsontable.helper.createSpreadsheetData(5, 5),
+      trimRows: true
+    });
+
+    hot.loadData(Handsontable.helper.createSpreadsheetData(10, 10));
+
+    setTimeout(() => {
+      expect(this.$container.find('td').length).toEqual(100);
+      done();
+    }, 100);
+  });
+
+  it('should not affect `afterValidate` hook #11', (done) => {
+    const hot = handsontable({
+      data: Handsontable.helper.createSpreadsheetData(5, 2),
+      trimRows: true,
+      cells() {
+        return { type: 'numeric' };
+      }
+    });
+
+    hot.populateFromArray(5, 1, [
+      ['A1', 'A2'],
+      ['B1', 'B2'],
+      ['C1', 'C2'],
+      ['D1', 'D2'],
+      ['E1', 'E2'],
+    ]);
+
+    setTimeout(() => {
+      const $addedCell = $(getCell(5, 1));
+
+      expect($addedCell.hasClass('htInvalid')).toEqual(true);
+
+      done();
+    }, 100);
+  });
+
+  describe('copy-paste functionality', () => {
+    class DataTransferObject {
+      constructor() {
+        this.data = {
+          'text/plain': '',
+          'text/html': ''
+        };
+      }
+      getData(type) {
+        return this.data[type];
+      }
+      setData(type, value) {
+        this.data[type] = value;
+      }
+    }
+
+    function getClipboardEventMock() {
+      const event = {};
+      event.clipboardData = new DataTransferObject();
+      event.preventDefault = () => {};
+      return event;
+    }
+
+    it('should skip trimmed rows, while copying data', () => {
+      const hot = handsontable({
+        data: getMultilineData(10, 10),
+        trimRows: [1, 5, 6, 7, 8],
+        width: 500,
+        height: 300
+      });
+
+      const copyEvent = getClipboardEventMock('copy');
+      const plugin = hot.getPlugin('CopyPaste');
+
+      selectCell(0, 0, 4, 9);
+
+      plugin.setCopyableText();
+      plugin.onCopy(copyEvent);
+
+      /* eslint-disable no-tabs */
+      expect(copyEvent.clipboardData.getData('text/plain')).toEqual('A1	B1	"C1\n' +
+        'line"	D1	E1	F1	G1	H1	I1	J1\n' +
+        'A3	B3	C3	D3	E3	F3	G3	H3	I3	J3\n' +
+        'A4	B4	C4	D4	E4	F4	G4	H4	I4	J4\n' +
+        'A5	B5	C5	D5	E5	F5	G5	H5	I5	J5\n' +
+        'A10	B10	C10	D10	E10	F10	G10	H10	I10	J10'
+      );
+    });
+  });
+
+  describe('navigation', () => {
+    it('should ignore trimmed rows while navigating by arrow keys', () => {
+      handsontable({
+        data: getMultilineData(50, 10),
+        trimRows: [1, 5, 6, 7, 8],
+        width: 500,
+        height: 300
+      });
+
+      selectCell(0, 0, 0, 0);
+
+      expect(getValue()).toEqual('A1');
+
+      keyDownUp(Handsontable.helper.KEY_CODES.ARROW_DOWN);
+
+      expect(getValue()).toEqual('A3');
+
+      keyDownUp(Handsontable.helper.KEY_CODES.ARROW_DOWN);
+
+      expect(getValue()).toEqual('A4');
+
+      keyDownUp(Handsontable.helper.KEY_CODES.ARROW_DOWN);
+
+      expect(getValue()).toEqual('A5');
+
+      keyDownUp(Handsontable.helper.KEY_CODES.ARROW_DOWN);
+
+      expect(getValue()).toEqual('A10');
+    });
+  });
+
+  describe('column sorting', () => {
+    it('should remove correct rows after sorting', () => {
+      handsontable({
+        data: getMultilineData(5, 10),
+        columnSorting: {
+          initialConfig: {
+            column: 0,
+            sortOrder: 'desc'
+          }
+        },
+        trimRows: [1],
+        width: 500,
+        height: 300
+      });
+      alter('remove_row', 2, 1);
+
+      expect(getDataAtCell(0, 0)).toBe('A5');
+      expect(getDataAtCell(1, 0)).toBe('A4');
+      expect(getDataAtCell(2, 0)).toBe('A1');
+    });
+
+    it('should remove correct rows after insert new rows in sorted column', (done) => {
+      handsontable({
+        data: getMultilineData(5, 10),
+        colHeaders: true,
+        columnSorting: {
+          initialConfig: {
+            column: 0,
+            sortOrder: 'desc'
+          }
+        },
+        trimRows: [1],
+        width: 500,
+        height: 300
+      });
+
+      setTimeout(() => {
+        alter('insert_row', 2, 1);
+        getHtCore().find('th span.columnSorting:eq(2)').simulate('mousedown');
+        getHtCore().find('th span.columnSorting:eq(2)').simulate('mouseup');
+        getHtCore().find('th span.columnSorting:eq(2)').simulate('click');
+        alter('remove_row', 2, 1);
+
+        expect(getDataAtCell(0, 0)).toBe('A1');
+        expect(getDataAtCell(1, 0)).toBe('A3');
+        expect(getDataAtCell(2, 0)).toBe('A5');
+        expect(getDataAtCell(3, 0)).toBe(null);
+        done();
+      }, 100);
+    });
+
+    it('should remove correct rows after insert new rows in sorted column (multiple sort click)', (done) => {
+      handsontable({
+        data: getMultilineData(5, 10),
+        colHeaders: true,
+        columnSorting: {
+          initialConfig: {
+            column: 0,
+            sortOrder: 'desc'
+          }
+        },
+        trimRows: [1],
+        width: 500,
+        height: 300
+      });
+
+      setTimeout(() => {
+        alter('insert_row', 2, 1);
+        getHtCore().find('th span.columnSorting:eq(2)').simulate('mousedown');
+        getHtCore().find('th span.columnSorting:eq(2)').simulate('mouseup');
+        getHtCore().find('th span.columnSorting:eq(2)').simulate('click');
+        alter('insert_row', 0, 1);
+        getHtCore().find('th span.columnSorting:eq(2)').simulate('mousedown');
+        getHtCore().find('th span.columnSorting:eq(2)').simulate('mouseup');
+        getHtCore().find('th span.columnSorting:eq(2)').simulate('click');
+        alter('remove_row', 0, 3);
+
+        expect(getDataAtCell(0, 0)).toBe('A1');
+        expect(getDataAtCell(1, 0)).toBe(null);
+        expect(getDataAtCell(2, 0)).toBe(null);
+        expect(getDataAtCell(3, 0)).toBe(null);
+        done();
+      }, 100);
+    });
+  });
+
+  describe('maxRows option set', () => {
+    it('should return properly data after trimming', (done) => {
+      handsontable({
+        data: Handsontable.helper.createSpreadsheetData(10, 10),
+        maxRows: 3,
+        trimRows: [2, 3]
+      });
+
+      setTimeout(() => {
+        expect(getData().length).toEqual(3);
+        expect(getDataAtCell(2, 1)).toEqual('B5');
+        done();
+      }, 100);
+    });
+  });
+
+  describe('minRows option set', () => {
+    it('should not fill the table with empty rows (to the `minRows` limit), when editing rows in a table with trimmed rows', (done) => {
+      const hot = handsontable({
+        data: Handsontable.helper.createSpreadsheetData(10, 10),
+        minRows: 10,
+        trimRows: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      });
+
+      expect(hot.countRows()).toEqual(1);
+
+      hot.setDataAtCell(0, 0, 'test');
+
+      setTimeout(() => {
+        expect(hot.countRows()).toEqual(1);
+
+        done();
+      }, 100);
+    });
+  });
+
+  describe('minSpareRows option set', () => {
+    it('should not fill the table with empty rows (to the `minSpareRows` limit), when editing rows in a table with trimmed rows', (done) => {
+      const hot = handsontable({
+        data: Handsontable.helper.createSpreadsheetData(10, 10),
+        minSpareRows: 4,
+        trimRows: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      });
+
+      expect(hot.countRows()).toEqual(1);
+
+      hot.setDataAtCell(0, 0, 'test');
+
+      setTimeout(() => {
+        expect(hot.countRows()).toEqual(1);
+
+        done();
+      }, 100);
+    });
+  });
+
+  describe('updateSettings', () => {
+    it('should update list of trimmed rows when array of indexes is passed to the method - test no. 1', () => {
+      const hot = handsontable({
+        data: getMultilineData(10, 10),
+        trimRows: [2, 6, 7],
+        width: 500,
+        height: 300
+      });
+      hot.updateSettings({
+        trimRows: [1, 2, 3, 4, 5]
+      });
+
+      expect(getDataAtCell(0, 0)).toBe('A1');
+      expect(getDataAtCell(1, 0)).toBe('A7');
+      expect(getDataAtCell(2, 0)).toBe('A8');
+      expect(getDataAtCell(3, 0)).toBe('A9');
+      expect(getDataAtCell(4, 0)).toBe('A10');
+    });
+
+    it('should update list of trimmed rows when array of indexes is passed to the method - test no. 2', () => {
+      const hot = handsontable({
+        data: getMultilineData(10, 10),
+        trimRows: true,
+        width: 500,
+        height: 300
+      });
+
+      hot.getPlugin('trimRows').trimRows([2, 6, 7]);
+      hot.render();
+
+      hot.updateSettings({
+        trimRows: [1, 2, 3, 4, 5]
+      });
+
+      expect(getDataAtCell(0, 0)).toBe('A1');
+      expect(getDataAtCell(1, 0)).toBe('A7');
+      expect(getDataAtCell(2, 0)).toBe('A8');
+      expect(getDataAtCell(3, 0)).toBe('A9');
+      expect(getDataAtCell(4, 0)).toBe('A10');
+    });
+
+    it('should clear list of trimmed rows when empty array is passed to the method - test no. 1', function() {
+      const hot = handsontable({
+        data: getMultilineData(10, 10),
+        trimRows: [2, 6, 7],
+        width: 500,
+        height: 300
+      });
+
+      hot.updateSettings({
+        trimRows: []
+      });
+
+      expect(this.$container.find('td').length).toEqual(100);
+    });
+
+    it('should clear list of trimmed rows when empty array is passed to the method - test no. 2', function() {
+      const hot = handsontable({
+        data: getMultilineData(10, 10),
+        trimRows: true,
+        width: 500,
+        height: 300
+      });
+
+      hot.getPlugin('trimRows').trimRows([2, 6, 7]);
+      hot.render();
+
+      hot.updateSettings({
+        trimRows: []
+      });
+
+      expect(this.$container.find('td').length).toEqual(100);
+    });
+
+    it('should clear list of trimmed rows when handled setting object has key `trimRows` with value ' +
+      'set to `false` - test no. 1', function() {
+      const hot = handsontable({
+        data: getMultilineData(10, 10),
+        trimRows: [2, 6, 7],
+        width: 500,
+        height: 300
+      });
+
+      hot.updateSettings({
+        trimRows: false
+      });
+
+      expect(this.$container.find('td').length).toEqual(100);
+    });
+
+    it('should clear list of trimmed rows when handled setting object has key `trimRows` with value ' +
+      'set to `false` - test no. 2', function() {
+      const hot = handsontable({
+        data: getMultilineData(10, 10),
+        trimRows: true,
+        width: 500,
+        height: 300
+      });
+
+      hot.getPlugin('trimRows').trimRows([2, 6, 7]);
+      hot.render();
+
+      hot.updateSettings({
+        trimRows: false
+      });
+
+      expect(this.$container.find('td').length).toEqual(100);
+    });
+
+    it('shouldn\'t clear list of trimmed rows when handled setting object has key `trimRows` with value ' +
+      'set to `true` - test no. 1', () => {
+      const hot = handsontable({
+        data: getMultilineData(10, 10),
+        trimRows: [2, 6, 7],
+        width: 500,
+        height: 300
+      });
+
+      hot.updateSettings({
+        trimRows: true
+      });
+
+      expect(getData().length).toEqual(7);
+    });
+
+    it('shouldn\'t clear list of trimmed rows when handled setting object has key `trimRows` with value ' +
+      'set to `true` - test no. 2', () => {
+      const hot = handsontable({
+        data: getMultilineData(10, 10),
+        trimRows: true,
+        width: 500,
+        height: 300
+      });
+
+      hot.getPlugin('trimRows').trimRows([2, 6, 7]);
+      hot.render();
+
+      hot.updateSettings({
+        trimRows: true
+      });
+
+      expect(getData().length).toEqual(7);
+    });
+
+    it('shouldn\'t change list of trimmed rows when handled setting object don\'t have `trimRows` key - test no. 1', () => {
+      const hot = handsontable({
+        data: getMultilineData(10, 10),
+        trimRows: [2, 6, 7],
+        width: 500,
+        height: 300
+      });
+
+      hot.updateSettings({});
+
+      hot.render();
+
+      expect(getData().length).toEqual(7);
+    });
+
+    it('shouldn\'t change list of trimmed rows when handled setting object don\'t have `trimRows` key - test no. 2', () => {
+      const hot = handsontable({
+        data: getMultilineData(10, 10),
+        trimRows: true,
+        width: 500,
+        height: 300
+      });
+
+      hot.getPlugin('trimRows').trimRows([2, 6, 7]);
+      hot.render();
+      hot.updateSettings({});
+
+      expect(getData().length).toEqual(7);
+    });
+  });
+});

handsontable/src/plugins/trimRows/trimRows.js

@@ -0,0 +1,322 @@
+import BasePlugin from '../_base';
+import { arrayEach } from '../../helpers/array';
+import { rangeEach } from '../../helpers/number';
+import { registerPlugin } from '../../plugins';
+import RowsMapper from './rowsMapper';
+
+/**
+ * @plugin TrimRows
+ * @pro
+ *
+ * @description
+ * The plugin allows to trim certain rows. The trimming is achieved by applying the transformation algorithm to the data
+ * transformation. In this case, when the row is trimmed it is not accessible using `getData*` methods thus the trimmed
+ * data is not visible to other plugins.
+ *
+ * @example
+ * ```js
+ * const container = document.getElementById('example');
+ * const hot = new Handsontable(container, {
+ *   date: getData(),
+ *   // hide selected rows on table initialization
+ *   trimRows: [1, 2, 5]
+ * });
+ *
+ * // access the trimRows plugin instance
+ * const trimRowsPlugin = hot.getPlugin('trimRows');
+ *
+ * // hide single row
+ * trimRowsPlugin.trimRow(1);
+ *
+ * // hide multiple rows
+ * trimRowsPlugin.trimRow(1, 2, 9);
+ *
+ * // or as an array
+ * trimRowsPlugin.trimRows([1, 2, 9]);
+ *
+ * // show single row
+ * trimRowsPlugin.untrimRow(1);
+ *
+ * // show multiple rows
+ * trimRowsPlugin.untrimRow(1, 2, 9);
+ *
+ * // or as an array
+ * trimRowsPlugin.untrimRows([1, 2, 9]);
+ *
+ * // rerender table to see the changes
+ * hot.render();
+ * ```
+ */
+class TrimRows extends BasePlugin {
+  constructor(hotInstance) {
+    super(hotInstance);
+    /**
+     * List of trimmed row indexes.
+     *
+     * @private
+     * @type {Array}
+     */
+    this.trimmedRows = [];
+    /**
+     * List of last removed row indexes.
+     *
+     * @private
+     * @type {Array}
+     */
+    this.removedRows = [];
+    /**
+     * Object containing visual row indexes mapped to data source indexes.
+     *
+     * @private
+     * @type {RowsMapper}
+     */
+    this.rowsMapper = new RowsMapper(this);
+  }
+
+  /**
+   * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit}
+   * hook and if it returns `true` than the {@link AutoRowSize#enablePlugin} method is called.
+   *
+   * @returns {Boolean}
+   */
+  isEnabled() {
+    return !!this.hot.getSettings().trimRows;
+  }
+
+  /**
+   * Enables the plugin functionality for this Handsontable instance.
+   */
+  enablePlugin() {
+    if (this.enabled) {
+      return;
+    }
+    const settings = this.hot.getSettings().trimRows;
+
+    if (Array.isArray(settings)) {
+      this.trimmedRows = settings;
+    }
+    this.rowsMapper.createMap(this.hot.countSourceRows());
+
+    this.addHook('modifyRow', (row, source) => this.onModifyRow(row, source));
+    this.addHook('unmodifyRow', (row, source) => this.onUnmodifyRow(row, source));
+    this.addHook('beforeCreateRow', (index, amount, source) => this.onBeforeCreateRow(index, amount, source));
+    this.addHook('afterCreateRow', (index, amount) => this.onAfterCreateRow(index, amount));
+    this.addHook('beforeRemoveRow', (index, amount) => this.onBeforeRemoveRow(index, amount));
+    this.addHook('afterRemoveRow', () => this.onAfterRemoveRow());
+    this.addHook('afterLoadData', firstRun => this.onAfterLoadData(firstRun));
+
+    super.enablePlugin();
+  }
+
+  /**
+   * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked.
+   */
+  updatePlugin() {
+    const settings = this.hot.getSettings().trimRows;
+
+    if (Array.isArray(settings)) {
+      this.disablePlugin();
+      this.enablePlugin();
+    }
+
+    super.updatePlugin();
+  }
+
+  /**
+   * Disables the plugin functionality for this Handsontable instance.
+   */
+  disablePlugin() {
+    this.trimmedRows = [];
+    this.removedRows.length = 0;
+    this.rowsMapper.clearMap();
+    super.disablePlugin();
+  }
+
+  /**
+   * Trims the rows provided in the array.
+   *
+   * @param {Number[]} rows Array of physical row indexes.
+   * @fires Hooks#skipLengthCache
+   * @fires Hooks#afterTrimRow
+   */
+  trimRows(rows) {
+    arrayEach(rows, (row) => {
+      const physicalRow = parseInt(row, 10);
+
+      if (!this.isTrimmed(physicalRow)) {
+        this.trimmedRows.push(physicalRow);
+      }
+    });
+
+    this.hot.runHooks('skipLengthCache', 100);
+    this.rowsMapper.createMap(this.hot.countSourceRows());
+    this.hot.runHooks('afterTrimRow', rows);
+  }
+
+  /**
+   * Trims the row provided as physical row index (counting from 0).
+   *
+   * @param {...Number} row Physical row index.
+   */
+  trimRow(...row) {
+    this.trimRows(row);
+  }
+
+  /**
+   * Untrims the rows provided in the array.
+   *
+   * @param {Number[]} rows Array of physical row indexes.
+   * @fires Hooks#skipLengthCache
+   * @fires Hooks#afterUntrimRow
+   */
+  untrimRows(rows) {
+    arrayEach(rows, (row) => {
+      const physicalRow = parseInt(row, 10);
+
+      if (this.isTrimmed(physicalRow)) {
+        this.trimmedRows.splice(this.trimmedRows.indexOf(physicalRow), 1);
+      }
+    });
+
+    this.hot.runHooks('skipLengthCache', 100);
+    this.rowsMapper.createMap(this.hot.countSourceRows());
+    this.hot.runHooks('afterUntrimRow', rows);
+  }
+
+  /**
+   * Untrims the row provided as row index (counting from 0).
+   *
+   * @param {...Number} row Physical row index.
+   */
+  untrimRow(...row) {
+    this.untrimRows(row);
+  }
+
+  /**
+   * Checks if given physical row is hidden.
+   *
+   * @returns {Boolean}
+   */
+  isTrimmed(row) {
+    return this.trimmedRows.indexOf(row) > -1;
+  }
+
+  /**
+   * Untrims all trimmed rows.
+   */
+  untrimAll() {
+    this.untrimRows([].concat(this.trimmedRows));
+  }
+
+  /**
+   * On modify row listener.
+   *
+   * @private
+   * @param {Number} row Visual row index.
+   * @param {String} source Source name.
+   * @returns {Number|null}
+   */
+  onModifyRow(row, source) {
+    let physicalRow = row;
+
+    if (source !== this.pluginName) {
+      physicalRow = this.rowsMapper.getValueByIndex(physicalRow);
+    }
+
+    return physicalRow;
+  }
+
+  /**
+   * On unmodifyRow listener.
+   *
+   * @private
+   * @param {Number} row Physical row index.
+   * @param {String} source Source name.
+   * @returns {Number|null}
+   */
+  onUnmodifyRow(row, source) {
+    let visualRow = row;
+
+    if (source !== this.pluginName) {
+      visualRow = this.rowsMapper.getIndexByValue(visualRow);
+    }
+
+    return visualRow;
+  }
+
+  /**
+   * `beforeCreateRow` hook callback.
+   *
+   * @private
+   * @param {Number} index Index of the newly created row.
+   * @param {Number} amount Amount of created rows.
+   * @param {String} source Source of the change.
+   */
+  onBeforeCreateRow(index, amount, source) {
+    return !(this.isEnabled() && this.trimmedRows.length > 0 && source === 'auto');
+  }
+
+  /**
+   * On after create row listener.
+   *
+   * @private
+   * @param {Number} index Visual row index.
+   * @param {Number} amount Defines how many rows removed.
+   */
+  onAfterCreateRow(index, amount) {
+    this.rowsMapper.shiftItems(index, amount);
+  }
+
+  /**
+   * On before remove row listener.
+   *
+   * @private
+   * @param {Number} index Visual row index.
+   * @param {Number} amount Defines how many rows removed.
+   *
+   * @fires Hooks#modifyRow
+   */
+  onBeforeRemoveRow(index, amount) {
+    this.removedRows.length = 0;
+
+    if (index !== false) {
+      // Collect physical row index.
+      rangeEach(index, index + amount - 1, (removedIndex) => {
+        this.removedRows.push(this.hot.runHooks('modifyRow', removedIndex, this.pluginName));
+      });
+    }
+  }
+
+  /**
+   * On after remove row listener.
+   *
+   * @private
+   */
+  onAfterRemoveRow() {
+    this.rowsMapper.unshiftItems(this.removedRows);
+  }
+
+  /**
+   * On after load data listener.
+   *
+   * @private
+   * @param {Boolean} firstRun Indicates if hook was fired while Handsontable initialization.
+   */
+  onAfterLoadData(firstRun) {
+    if (!firstRun) {
+      this.rowsMapper.createMap(this.hot.countSourceRows());
+    }
+  }
+
+  /**
+   * Destroys the plugin instance.
+   */
+  destroy() {
+    this.rowsMapper.destroy();
+    super.destroy();
+  }
+}
+
+registerPlugin('trimRows', TrimRows);
+
+export default TrimRows;