/handsontable/src/plugins/hiddenRows/__tests__/plugins/mergeCells.spec.js

https://github.com/handsontable/jquery-handsontable · JavaScript · 1402 lines · 1034 code · 294 blank · 74 comment · 6 complexity · 3d2d7f36c798488973fd9f5f78d82685 MD5 · raw file 

    

  1. describe('HiddenRows', () => {
    2. 

  2.   const id = 'testContainer';
    3. 

  3. 

  4.   beforeEach(function() {
    5. 

  5.     this.$container = $(`<div id="${id}"></div>`).appendTo('body');
    6. 

  6.   });
    7. 

  7. 

  8.   afterEach(function() {
    9. 

  9.     if (this.$container) {
    10. 

  10.       destroy();
    11. 

  11.       this.$container.remove();
    12. 

  12.     }
    13. 

  13.   });
    14. 

  14. 

  15.   describe('MergeCells', () => {
    16. 

  16.     it('should display properly merged cells based on the settings', () => {
    17. 

  17.       handsontable({
    18. 

  18.         data: Handsontable.helper.createSpreadsheetObjectData(5, 5),
    19. 

  19.         mergeCells: [
    20. 

  20.           { row: 0, col: 0, rowspan: 3, colspan: 3 }
    21. 

  21.         ],
    22. 

  22.         hiddenRows: {
    23. 

  23.           rows: [1],
    24. 

  24.         },
    25. 

  25.       });
    26. 

  26. 

  27.       expect(getData()).toEqual([
    28. 

  28.         ['A1', null, null, 'D1', 'E1'],
    29. 

  29.         [null, null, null, 'D2', 'E2'],
    30. 

  30.         [null, null, null, 'D3', 'E3'],
    31. 

  31.         ['A4', 'B4', 'C4', 'D4', 'E4'],
    32. 

  32.         ['A5', 'B5', 'C5', 'D5', 'E5'],
    33. 

  33.       ]);
    34. 

  34. 

  35.       expect(getHtCore().outerHeight()).toBe(93);
    36. 

  36.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(47);
    37. 

  37. 

  38.       getPlugin('hiddenRows').showRows([1]);
    39. 

  39.       render();
    40. 

  40. 

  41.       expect(getHtCore().outerHeight()).toBe(116);
    42. 

  42.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(70);
    43. 

  43. 

  44.       getPlugin('hiddenRows').hideRows([1]);
    45. 

  45.       render();
    46. 

  46. 

  47.       expect(getHtCore().outerHeight()).toBe(93);
    48. 

  48.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(47);
    49. 

  49.     });
    50. 

  50. 

  51.     it('should display properly merged cells containing hidden rows (merge area from visible cell to visible cell)', () => {
    52. 

  52.       handsontable({
    53. 

  53.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    54. 

  54.         rowHeaders: true, // It has to be enabled due the bug in mergeCells plugin (#4907)
    55. 

  55.         hiddenRows: {
    56. 

  56.           rows: [0, 2, 4],
    57. 

  57.         },
    58. 

  58.         mergeCells: true
    59. 

  59.       });
    60. 

  60. 

  61.       getPlugin('mergeCells').merge(1, 0, 3, 0);
    62. 

  62. 

  63.       // Merged from visual row index 1 (visible) to visual row index 3 (visible).
    64. 

  64.       //                                 ↓    merged data     ↓
    65. 

  65.       expect(getData()).toEqual([['A1'], ['A2'], [null], [null], ['A5']]);
    66. 

  66.       expect(getHtCore().find('td:eq(0)').text()).toBe('A2');
    67. 

  67.       expect(getHtCore().outerHeight()).toBe(47);
    68. 

  68.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(47);
    69. 

  69. 

  70.       getPlugin('hiddenRows').showRows([2]);
    71. 

  71.       render();
    72. 

  72. 

  73.       expect(getHtCore().outerHeight()).toBe(70);
    74. 

  74.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(70);
    75. 

  75. 

  76.       getPlugin('hiddenRows').hideRows([2]);
    77. 

  77.       render();
    78. 

  78. 

  79.       expect(getHtCore().outerHeight()).toBe(47);
    80. 

  80.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(47);
    81. 

  81. 

  82.       getPlugin('hiddenRows').showRows([0, 2, 4]);
    83. 

  83.       render();
    84. 

  84. 

  85.       expect(getHtCore().outerHeight()).toBe(116);
    86. 

  86.       expect(getHtCore().find('td:eq(1)').outerHeight()).toBe(69);
    87. 

  87.     });
    88. 

  88. 

  89.     it('should display properly merged cells containing hidden rows (merge area from invisible cell to visible cell)', () => {
    90. 

  90.       handsontable({
    91. 

  91.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    92. 

  92.         rowHeaders: true, // It has to be enabled due the bug in mergeCells plugin (#4907)
    93. 

  93.         hiddenRows: {
    94. 

  94.           rows: [0, 2, 4],
    95. 

  95.         },
    96. 

  96.         mergeCells: true
    97. 

  97.       });
    98. 

  98. 

  99.       getPlugin('mergeCells').merge(0, 0, 3, 0);
    100. 

  100. 

  101.       // Merged from visual row index 0 (invisible) to visual row index 3 (visible).
    102. 

  102.       //                         ↓        merged data         ↓
    103. 

  103.       expect(getData()).toEqual([['A1'], [null], [null], [null], ['A5']]);
    104. 

  104. 

  105.       expect(getHtCore().find('td:eq(0)').text()).toBe('A1');
    106. 

  106. 

  107.       expect(getHtCore().outerHeight()).toBe(47);
    108. 

  108.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(47);
    109. 

  109. 

  110.       getPlugin('hiddenRows').showRows([0]);
    111. 

  111.       render();
    112. 

  112. 

  113.       expect(getHtCore().outerHeight()).toBe(70);
    114. 

  114.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(70);
    115. 

  115. 

  116.       getPlugin('hiddenRows').showRows([2]);
    117. 

  117.       render();
    118. 

  118. 

  119.       expect(getHtCore().outerHeight()).toBe(93);
    120. 

  120.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(93);
    121. 

  121. 

  122.       getPlugin('hiddenRows').hideRows([0, 2]);
    123. 

  123.       render();
    124. 

  124. 

  125.       expect(getHtCore().outerHeight()).toBe(47);
    126. 

  126.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(47);
    127. 

  127. 

  128.       getPlugin('hiddenRows').showRows([0, 2, 4]);
    129. 

  129.       render();
    130. 

  130. 

  131.       expect(getHtCore().outerHeight()).toBe(116);
    132. 

  132.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(93);
    133. 

  133.     });
    134. 

  134. 

  135.     it('should display properly merged cells containing hidden rows (merge area from visible cell to invisible cell)', () => {
    136. 

  136.       handsontable({
    137. 

  137.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    138. 

  138.         rowHeaders: true, // It has to be enabled due the bug in mergeCells plugin (#4907)
    139. 

  139.         hiddenRows: {
    140. 

  140.           rows: [0, 2, 4],
    141. 

  141.         },
    142. 

  142.         mergeCells: true
    143. 

  143.       });
    144. 

  144. 

  145.       getPlugin('mergeCells').merge(1, 0, 4, 0);
    146. 

  146. 

  147.       // Merged from visual row index 1 (visible) to visual row index 4 (invisible).
    148. 

  148.       //                                 ↓        merged data         ↓
    149. 

  149.       expect(getData()).toEqual([['A1'], ['A2'], [null], [null], [null]]);
    150. 

  150.       expect(getHtCore().find('td:eq(0)').text()).toBe('A2');
    151. 

  151. 

  152.       expect(getHtCore().outerHeight()).toBe(47);
    153. 

  153.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(47);
    154. 

  154. 

  155.       getPlugin('hiddenRows').showRows([2]);
    156. 

  156.       render();
    157. 

  157. 

  158.       expect(getHtCore().outerHeight()).toBe(70);
    159. 

  159.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(70);
    160. 

  160. 

  161.       getPlugin('hiddenRows').showRows([4]);
    162. 

  162.       render();
    163. 

  163. 

  164.       expect(getHtCore().outerHeight()).toBe(93);
    165. 

  165.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(93);
    166. 

  166. 

  167.       getPlugin('hiddenRows').hideRows([2, 4]);
    168. 

  168.       render();
    169. 

  169. 

  170.       expect(getHtCore().outerHeight()).toBe(47);
    171. 

  171.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(47);
    172. 

  172. 

  173.       getPlugin('hiddenRows').showRows([0, 2, 4]);
    174. 

  174.       render();
    175. 

  175. 

  176.       expect(getHtCore().outerHeight()).toBe(116);
    177. 

  177.       expect(getHtCore().find('td:eq(1)').outerHeight()).toBe(92);
    178. 

  178.     });
    179. 

  179. 

  180.     it('should display properly merged cells containing hidden rows (merge area from invisible cell to invisible cell)', () => {
    181. 

  181.       handsontable({
    182. 

  182.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    183. 

  183.         rowHeaders: true, // It has to be enabled due the bug in mergeCells plugin (#4907)
    184. 

  184.         hiddenRows: {
    185. 

  185.           rows: [0, 2, 4],
    186. 

  186.         },
    187. 

  187.         mergeCells: true
    188. 

  188.       });
    189. 

  189. 

  190.       getPlugin('mergeCells').merge(0, 0, 4, 0);
    191. 

  191. 

  192.       // Merged from visual row index 0 (invisible) to visual row index 4 (invisible).
    193. 

  193.       //                         ↓           merged data               ↓
    194. 

  194.       expect(getData()).toEqual([['A1'], [null], [null], [null], [null]]);
    195. 

  195.       expect(getHtCore().find('td:eq(0)').text()).toBe('A1');
    196. 

  196. 

  197.       expect(getHtCore().outerHeight()).toBe(47);
    198. 

  198.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(47);
    199. 

  199. 

  200.       getPlugin('hiddenRows').showRows([0]);
    201. 

  201.       render();
    202. 

  202. 

  203.       expect(getHtCore().outerHeight()).toBe(70);
    204. 

  204.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(70);
    205. 

  205. 

  206.       getPlugin('hiddenRows').showRows([2]);
    207. 

  207.       render();
    208. 

  208. 

  209.       expect(getHtCore().outerHeight()).toBe(93);
    210. 

  210.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(93);
    211. 

  211. 

  212.       getPlugin('hiddenRows').showRows([4]);
    213. 

  213.       render();
    214. 

  214. 

  215.       expect(getHtCore().outerHeight()).toBe(116);
    216. 

  216.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(116);
    217. 

  217. 

  218.       getPlugin('hiddenRows').hideRows([0, 2, 4]);
    219. 

  219.       render();
    220. 

  220. 

  221.       expect(getHtCore().outerHeight()).toBe(47);
    222. 

  222.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(47);
    223. 

  223. 

  224.       getPlugin('hiddenRows').showRows([0, 2, 4]);
    225. 

  225.       render();
    226. 

  226. 

  227.       expect(getHtCore().outerHeight()).toBe(116);
    228. 

  228.       expect(getHtCore().find('td:eq(0)').outerHeight()).toBe(116);
    229. 

  229.     });
    230. 

  230. 

  231.     it('should return proper values from the `getCell` function', () => {
    232. 

  232.       handsontable({
    233. 

  233.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    234. 

  234.         rowHeaders: true, // It has to be enabled due the bug in mergeCells plugin (#4907)
    235. 

  235.         hiddenRows: {
    236. 

  236.           rows: [0, 2, 4],
    237. 

  237.         },
    238. 

  238.         mergeCells: true
    239. 

  239.       });
    240. 

  240. 

  241.       getPlugin('mergeCells').merge(1, 0, 3, 0);
    242. 

  242. 

  243.       expect(getCell(0, 0)).toBe(null);
    244. 

  244.       expect(getCell(1, 0)).toBe(getHtCore().find('td')[0]);
    245. 

  245.       expect(getCell(2, 0)).toBe(null);
    246. 

  246.       expect(getCell(3, 0)).toBe(getHtCore().find('td')[0]);
    247. 

  247.       expect(getCell(4, 0)).toBe(null);
    248. 

  248. 

  249.       getPlugin('hiddenRows').showRows([2]);
    250. 

  250.       render();
    251. 

  251. 

  252.       expect(getCell(0, 0)).toBe(null);
    253. 

  253.       expect(getCell(1, 0)).toBe(getHtCore().find('td')[0]);
    254. 

  254.       expect(getCell(2, 0)).toBe(getHtCore().find('td')[0]);
    255. 

  255.       expect(getCell(3, 0)).toBe(getHtCore().find('td')[0]);
    256. 

  256.       expect(getCell(4, 0)).toBe(null);
    257. 

  257.     });
    258. 

  258. 

  259.     it('should translate row indexes properly - regression check', () => {
    260. 

  260.       // An error have been thrown and too many rows have been drawn in the specific case. There haven't been done
    261. 

  261.       // index translation (from renderable to visual rows indexes and the other way around).
    262. 

  262.       handsontable({
    263. 

  263.         data: Handsontable.helper.createSpreadsheetData(7, 1),
    264. 

  264.         rowHeaders: true, // It has to be enabled due the bug in mergeCells plugin (#4907)
    265. 

  265.         hiddenRows: {
    266. 

  266.           rows: [0, 2],
    267. 

  267.         },
    268. 

  268.         mergeCells: true
    269. 

  269.       });
    270. 

  270. 

  271.       getPlugin('mergeCells').merge(3, 0, 5, 0);
    272. 

  272. 

  273.       // The same as at the start.
    274. 

  274.       expect($(getHtCore()).find('td').length).toBe(5);
    275. 

  275.       // Still the same height for the whole table.
    276. 

  276.       expect(getHtCore().outerHeight()).toBe(116);
    277. 

  277.       expect(getHtCore().find('td:eq(1)').outerHeight()).toBe(69);
    278. 

  278.     });
    279. 

  279. 

  280.     // Please keep in mind that this test doesn't fulfil checks for all types of renderers. Change code carefully
    281. 

  281.     // when something is failing.
    282. 

  282.     it('should show start of the merge area properly also when first row from the area is hidden', () => {
    283. 

  283.       handsontable({
    284. 

  284.         data: [
    285. 

  285.           ['<b>Hello world</b>', 123, 'secret'],
    286. 

  286.           ['Hello!', 'not numeric', 'secret too']
    287. 

  287.         ],
    288. 

  288.         columns: [
    289. 

  289.           { renderer: 'html' },
    290. 

  290.           { renderer: 'numeric' },
    291. 

  291.           { renderer: 'password' },
    292. 

  292.         ],
    293. 

  293.         mergeCells: [
    294. 

  294.           { row: 0, col: 0, rowspan: 2, colspan: 1 },
    295. 

  295.           { row: 0, col: 1, rowspan: 2, colspan: 1 },
    296. 

  296.           { row: 0, col: 2, rowspan: 2, colspan: 1 },
    297. 

  297.         ],
    298. 

  298.         hiddenRows: {
    299. 

  299.           rows: [0]
    300. 

  300.         }
    301. 

  301.       });
    302. 

  302. 

  303.       expect($(getHtCore()).find('td')[0].innerHTML).toBe('<b>Hello world</b>');
    304. 

  304.       expect($(getHtCore()).find('td')[1].innerText).toBe('123');
    305. 

  305.       expect($(getHtCore()).find('td')[2].innerText).toBe('******');
    306. 

  306.     });
    307. 

  307. 

  308.     it('should select proper cells when calling the `selectCell` within area of merge ' +
    309. 

  309.       '(contains few hidden rows)', () => {
    310. 

  310.       handsontable({
    311. 

  311.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    312. 

  312.         rowHeaders: true, // It has to be enabled due the bug in mergeCells plugin (#4907)
    313. 

  313.         hiddenRows: {
    314. 

  314.           rows: [0, 2],
    315. 

  315.         },
    316. 

  316.         mergeCells: [
    317. 

  317.           { row: 1, col: 0, rowspan: 4, colspan: 1 }
    318. 

  318.         ]
    319. 

  319.       });
    320. 

  320. 

  321.       // First visible cell (merged area).
    322. 

  322.       const $mergeArea = spec().$container.find('tr:eq(0) td:eq(0)');
    323. 

  323. 

  324.       selectCell(1, 0);
    325. 

  325. 

  326.       // Second and third rows are not displayed (CSS - display: none).
    327. 

  327.       expect(getSelected()).toEqual([[1, 0, 4, 0]]);
    328. 

  328.       expect(getSelectedRangeLast().highlight.row).toBe(1);
    329. 

  329.       expect(getSelectedRangeLast().highlight.col).toBe(0);
    330. 

  330.       expect(getSelectedRangeLast().from.row).toBe(1);
    331. 

  331.       expect(getSelectedRangeLast().from.col).toBe(0);
    332. 

  332.       expect(getSelectedRangeLast().to.row).toBe(4);
    333. 

  333.       expect(getSelectedRangeLast().to.col).toBe(0);
    334. 

  334.       expect(`
    335. 

  335.         | - ║ # |
    336. 

  336.         | - ║   |
    337. 

  337.         | - ║   |
    338. 

  338.       `).toBeMatchToSelectionPattern();
    339. 

  339.       expect($mergeArea.hasClass('fullySelectedMergedCell')).toBeFalse();
    340. 

  340.       expect($mergeArea.hasClass('fullySelectedMergedCell-multiple')).toBeFalse();
    341. 

  341.       expect($mergeArea.hasClass('fullySelectedMergedCell-0')).toBeFalse();
    342. 

  342.       expect($mergeArea.hasClass('fullySelectedMergedCell-1')).toBeFalse();
    343. 

  343.       expect($mergeArea.hasClass('fullySelectedMergedCell-2')).toBeFalse();
    344. 

  344.       expect($mergeArea.hasClass('fullySelectedMergedCell-3')).toBeFalse();
    345. 

  345.       expect($mergeArea.hasClass('fullySelectedMergedCell-4')).toBeFalse();
    346. 

  346.       expect($mergeArea.hasClass('fullySelectedMergedCell-5')).toBeFalse();
    347. 

  347.       expect($mergeArea.hasClass('fullySelectedMergedCell-6')).toBeFalse();
    348. 

  348.       expect($mergeArea.hasClass('fullySelectedMergedCell-7')).toBeFalse();
    349. 

  349. 

  350.       deselectCell();
    351. 

  351.       selectCell(2, 0);
    352. 

  352. 

  353.       // Second and third rows are not displayed (CSS - display: none).
    354. 

  354.       expect(getSelected()).toEqual([[1, 0, 4, 0]]);
    355. 

  355.       expect(getSelectedRangeLast().highlight.row).toBe(1);
    356. 

  356.       expect(getSelectedRangeLast().highlight.col).toBe(0);
    357. 

  357.       expect(getSelectedRangeLast().from.row).toBe(1);
    358. 

  358.       expect(getSelectedRangeLast().from.col).toBe(0);
    359. 

  359.       expect(getSelectedRangeLast().to.row).toBe(4);
    360. 

  360.       expect(getSelectedRangeLast().to.col).toBe(0);
    361. 

  361.       expect(`
    362. 

  362.         | - ║ # |
    363. 

  363.         | - ║   |
    364. 

  364.         | - ║   |
    365. 

  365.       `).toBeMatchToSelectionPattern();
    366. 

  366.       expect($mergeArea.hasClass('fullySelectedMergedCell')).toBeFalse();
    367. 

  367.       expect($mergeArea.hasClass('fullySelectedMergedCell-multiple')).toBeFalse();
    368. 

  368.       expect($mergeArea.hasClass('fullySelectedMergedCell-0')).toBeFalse();
    369. 

  369.       expect($mergeArea.hasClass('fullySelectedMergedCell-1')).toBeFalse();
    370. 

  370.       expect($mergeArea.hasClass('fullySelectedMergedCell-2')).toBeFalse();
    371. 

  371.       expect($mergeArea.hasClass('fullySelectedMergedCell-3')).toBeFalse();
    372. 

  372.       expect($mergeArea.hasClass('fullySelectedMergedCell-4')).toBeFalse();
    373. 

  373.       expect($mergeArea.hasClass('fullySelectedMergedCell-5')).toBeFalse();
    374. 

  374.       expect($mergeArea.hasClass('fullySelectedMergedCell-6')).toBeFalse();
    375. 

  375.       expect($mergeArea.hasClass('fullySelectedMergedCell-7')).toBeFalse();
    376. 

  376. 

  377.       deselectCell();
    378. 

  378.       selectCell(3, 0);
    379. 

  379. 

  380.       // Second and third rows are not displayed (CSS - display: none).
    381. 

  381.       expect(getSelected()).toEqual([[1, 0, 4, 0]]);
    382. 

  382.       expect(getSelectedRangeLast().highlight.row).toBe(1);
    383. 

  383.       expect(getSelectedRangeLast().highlight.col).toBe(0);
    384. 

  384.       expect(getSelectedRangeLast().from.row).toBe(1);
    385. 

  385.       expect(getSelectedRangeLast().from.col).toBe(0);
    386. 

  386.       expect(getSelectedRangeLast().to.row).toBe(4);
    387. 

  387.       expect(getSelectedRangeLast().to.col).toBe(0);
    388. 

  388.       expect(`
    389. 

  389.         | - ║ # |
    390. 

  390.         | - ║   |
    391. 

  391.         | - ║   |
    392. 

  392.       `).toBeMatchToSelectionPattern();
    393. 

  393.       expect($mergeArea.hasClass('fullySelectedMergedCell')).toBeFalse();
    394. 

  394.       expect($mergeArea.hasClass('fullySelectedMergedCell-multiple')).toBeFalse();
    395. 

  395.       expect($mergeArea.hasClass('fullySelectedMergedCell-0')).toBeFalse();
    396. 

  396.       expect($mergeArea.hasClass('fullySelectedMergedCell-1')).toBeFalse();
    397. 

  397.       expect($mergeArea.hasClass('fullySelectedMergedCell-2')).toBeFalse();
    398. 

  398.       expect($mergeArea.hasClass('fullySelectedMergedCell-3')).toBeFalse();
    399. 

  399.       expect($mergeArea.hasClass('fullySelectedMergedCell-4')).toBeFalse();
    400. 

  400.       expect($mergeArea.hasClass('fullySelectedMergedCell-5')).toBeFalse();
    401. 

  401.       expect($mergeArea.hasClass('fullySelectedMergedCell-6')).toBeFalse();
    402. 

  402.       expect($mergeArea.hasClass('fullySelectedMergedCell-7')).toBeFalse();
    403. 

  403. 

  404.       // TODO: `selectCell(4, 0)` should give the same effect. There is bug at least from Handsontable 7.
    405. 

  405.     });
    406. 

  406. 

  407.     it('should select proper cells when calling the `selectCell` within area of merge ' +
    408. 

  408.       '(contains just one hidden and one not hidden row)', () => {
    409. 

  409.       handsontable({
    410. 

  410.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    411. 

  411.         rowHeaders: true, // It has to be enabled due the bug in mergeCells plugin (#4907)
    412. 

  412.         hiddenRows: {
    413. 

  413.           rows: [0],
    414. 

  414.         },
    415. 

  415.         mergeCells: [
    416. 

  416.           { row: 0, col: 0, rowspan: 2, colspan: 1 }
    417. 

  417.         ]
    418. 

  418.       });
    419. 

  419. 

  420.       // First visible cell (merged area).
    421. 

  421.       const $mergeArea = spec().$container.find('tr:eq(0) td:eq(0)');
    422. 

  422. 

  423.       selectCell(0, 0);
    424. 

  424. 

  425.       expect(`
    426. 

  426.       | - ║ # |
    427. 

  427.       |   ║   |
    428. 

  428.       |   ║   |
    429. 

  429.       |   ║   |
    430. 

  430.       `).toBeMatchToSelectionPattern();
    431. 

  431.       expect(getSelected()).toEqual([[0, 0, 1, 0]]);
    432. 

  432.       expect(getSelectedRangeLast().highlight.row).toBe(1);
    433. 

  433.       expect(getSelectedRangeLast().highlight.col).toBe(0);
    434. 

  434.       expect(getSelectedRangeLast().from.row).toBe(0);
    435. 

  435.       expect(getSelectedRangeLast().from.col).toBe(0);
    436. 

  436.       expect(getSelectedRangeLast().to.row).toBe(1);
    437. 

  437.       expect(getSelectedRangeLast().to.col).toBe(0);
    438. 

  438.       expect($mergeArea.hasClass('fullySelectedMergedCell')).toBeFalse();
    439. 

  439.       expect($mergeArea.hasClass('fullySelectedMergedCell-multiple')).toBeFalse();
    440. 

  440.       expect($mergeArea.hasClass('fullySelectedMergedCell-0')).toBeFalse();
    441. 

  441.       expect($mergeArea.hasClass('fullySelectedMergedCell-1')).toBeFalse();
    442. 

  442.       expect($mergeArea.hasClass('fullySelectedMergedCell-2')).toBeFalse();
    443. 

  443.       expect($mergeArea.hasClass('fullySelectedMergedCell-3')).toBeFalse();
    444. 

  444.       expect($mergeArea.hasClass('fullySelectedMergedCell-4')).toBeFalse();
    445. 

  445.       expect($mergeArea.hasClass('fullySelectedMergedCell-5')).toBeFalse();
    446. 

  446.       expect($mergeArea.hasClass('fullySelectedMergedCell-6')).toBeFalse();
    447. 

  447.       expect($mergeArea.hasClass('fullySelectedMergedCell-7')).toBeFalse();
    448. 

  448. 

  449.       deselectCell();
    450. 

  450.       selectCell(1, 0);
    451. 

  451. 

  452.       expect(`
    453. 

  453.       | - ║ # |
    454. 

  454.       |   ║   |
    455. 

  455.       |   ║   |
    456. 

  456.       |   ║   |
    457. 

  457.       `).toBeMatchToSelectionPattern();
    458. 

  458.       expect(getSelected()).toEqual([[0, 0, 1, 0]]);
    459. 

  459.       expect(getSelectedRangeLast().highlight.row).toBe(1);
    460. 

  460.       expect(getSelectedRangeLast().highlight.col).toBe(0);
    461. 

  461.       expect(getSelectedRangeLast().from.row).toBe(0);
    462. 

  462.       expect(getSelectedRangeLast().from.col).toBe(0);
    463. 

  463.       expect(getSelectedRangeLast().to.row).toBe(1);
    464. 

  464.       expect(getSelectedRangeLast().to.col).toBe(0);
    465. 

  465.       expect($mergeArea.hasClass('fullySelectedMergedCell')).toBeFalse();
    466. 

  466.       expect($mergeArea.hasClass('fullySelectedMergedCell-multiple')).toBeFalse();
    467. 

  467.       expect($mergeArea.hasClass('fullySelectedMergedCell-0')).toBeFalse();
    468. 

  468.       expect($mergeArea.hasClass('fullySelectedMergedCell-1')).toBeFalse();
    469. 

  469.       expect($mergeArea.hasClass('fullySelectedMergedCell-2')).toBeFalse();
    470. 

  470.       expect($mergeArea.hasClass('fullySelectedMergedCell-3')).toBeFalse();
    471. 

  471.       expect($mergeArea.hasClass('fullySelectedMergedCell-4')).toBeFalse();
    472. 

  472.       expect($mergeArea.hasClass('fullySelectedMergedCell-5')).toBeFalse();
    473. 

  473.       expect($mergeArea.hasClass('fullySelectedMergedCell-6')).toBeFalse();
    474. 

  474.       expect($mergeArea.hasClass('fullySelectedMergedCell-7')).toBeFalse();
    475. 

  475.     });
    476. 

  476. 

  477.     it('should select proper cells when calling the `selectCells` within area of merge ' +
    478. 

  478.       '(contains just one hidden and one not hidden rows) + singe cell', () => {
    479. 

  479.       handsontable({
    480. 

  480.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    481. 

  481.         hiddenRows: {
    482. 

  482.           rows: [0],
    483. 

  483.         },
    484. 

  484.         mergeCells: [
    485. 

  485.           { row: 0, col: 0, rowspan: 2, colspan: 1 }
    486. 

  486.         ]
    487. 

  487.       });
    488. 

  488. 

  489.       // First visible cell (merged area).
    490. 

  490.       const $mergeArea = spec().$container.find('tr:eq(0) td:eq(0)');
    491. 

  491. 

  492.       selectCells([[1, 0], [4, 0]]);
    493. 

  493. 

  494.       expect(`
    495. 

  495.       | 0 |
    496. 

  496.       |   |
    497. 

  497.       |   |
    498. 

  498.       | A |
    499. 

  499.       `).toBeMatchToSelectionPattern();
    500. 

  500.       expect(getSelected()).toEqual([[0, 0, 1, 0], [4, 0, 4, 0]]);
    501. 

  501.       expect(getSelectedRangeLast().highlight.row).toBe(4);
    502. 

  502.       expect(getSelectedRangeLast().highlight.col).toBe(0);
    503. 

  503.       expect(getSelectedRangeLast().from.row).toBe(4);
    504. 

  504.       expect(getSelectedRangeLast().from.col).toBe(0);
    505. 

  505.       expect(getSelectedRangeLast().to.row).toBe(4);
    506. 

  506.       expect(getSelectedRangeLast().to.col).toBe(0);
    507. 

  507.       expect($mergeArea.hasClass('area')).toBeTrue();
    508. 

  508.       expect($mergeArea.hasClass('fullySelectedMergedCell')).toBeFalse();
    509. 

  509.       // TODO: Probably it should return `false`.
    510. 

  510.       expect($mergeArea.hasClass('fullySelectedMergedCell-multiple')).toBeTrue();
    511. 

  511.       // Probably it should return `true`, changed since 8.0.0.
    512. 

  512.       expect($mergeArea.hasClass('fullySelectedMergedCell-0')).toBeTrue();
    513. 

  513.       expect($mergeArea.hasClass('fullySelectedMergedCell-1')).toBeFalse();
    514. 

  514.       expect($mergeArea.hasClass('fullySelectedMergedCell-2')).toBeFalse();
    515. 

  515.       expect($mergeArea.hasClass('fullySelectedMergedCell-3')).toBeFalse();
    516. 

  516.       expect($mergeArea.hasClass('fullySelectedMergedCell-4')).toBeFalse();
    517. 

  517.       expect($mergeArea.hasClass('fullySelectedMergedCell-5')).toBeFalse();
    518. 

  518.       expect($mergeArea.hasClass('fullySelectedMergedCell-6')).toBeFalse();
    519. 

  519.       expect($mergeArea.hasClass('fullySelectedMergedCell-7')).toBeFalse();
    520. 

  520.     });
    521. 

  521. 

  522.     it('should open properly merged cells containing hidden rows (merge area from visible cell to visible cell)', () => {
    523. 

  523.       handsontable({
    524. 

  524.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    525. 

  525.         hiddenRows: {
    526. 

  526.           rows: [0, 2, 4],
    527. 

  527.         },
    528. 

  528.         mergeCells: true
    529. 

  529.       });
    530. 

  530. 

  531.       getPlugin('mergeCells').merge(1, 0, 3, 0);
    532. 

  532. 

  533.       selectCell(1, 0);
    534. 

  534.       keyDownUp('enter');
    535. 

  535. 

  536.       let editor = getActiveEditor();
    537. 

  537. 

  538.       expect(editor.isOpened()).toBe(true);
    539. 

  539.       expect(editor.isInFullEditMode()).toBe(true);
    540. 

  540.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A2');
    541. 

  541. 

  542.       // Closing the editor.
    543. 

  543.       keyDownUp('enter');
    544. 

  544. 

  545.       editor = getActiveEditor();
    546. 

  546. 

  547.       expect(editor.isOpened()).toBe(false);
    548. 

  548.       expect(editor.isInFullEditMode()).toBe(false);
    549. 

  549. 

  550.       selectCell(2, 0);
    551. 

  551.       keyDownUp('enter');
    552. 

  552. 

  553.       editor = getActiveEditor();
    554. 

  554. 

  555.       expect(editor.isOpened()).toBe(true);
    556. 

  556.       expect(editor.isInFullEditMode()).toBe(true);
    557. 

  557.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A2');
    558. 

  558. 

  559.       // Closing the editor.
    560. 

  560.       keyDownUp('enter');
    561. 

  561. 

  562.       editor = getActiveEditor();
    563. 

  563. 

  564.       expect(editor.isOpened()).toBe(false);
    565. 

  565.       expect(editor.isInFullEditMode()).toBe(false);
    566. 

  566. 

  567.       selectCell(3, 0);
    568. 

  568.       keyDownUp('enter');
    569. 

  569. 

  570.       editor = getActiveEditor();
    571. 

  571. 

  572.       expect(editor.isOpened()).toBe(true);
    573. 

  573.       expect(editor.isInFullEditMode()).toBe(true);
    574. 

  574.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A2');
    575. 

  575. 

  576.       // Closing the editor.
    577. 

  577.       keyDownUp('enter');
    578. 

  578. 

  579.       editor = getActiveEditor();
    580. 

  580. 

  581.       expect(editor.isOpened()).toBe(false);
    582. 

  582.       expect(editor.isInFullEditMode()).toBe(false);
    583. 

  583. 

  584.       // Double click on the first visible cell (merged area).
    585. 

  585.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    586. 

  586. 

  587.       editor = getActiveEditor();
    588. 

  588. 

  589.       expect(editor.isOpened()).toBe(true);
    590. 

  590.       expect(editor.isInFullEditMode()).toBe(true);
    591. 

  591.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A2');
    592. 

  592.     });
    593. 

  593. 

  594.     it('should open properly merged cells containing hidden rows (merge area from invisible cell to visible cell)', () => {
    595. 

  595.       handsontable({
    596. 

  596.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    597. 

  597.         hiddenRows: {
    598. 

  598.           rows: [0, 2, 4],
    599. 

  599.         },
    600. 

  600.         mergeCells: true
    601. 

  601.       });
    602. 

  602. 

  603.       getPlugin('mergeCells').merge(0, 0, 3, 0);
    604. 

  604. 

  605.       selectCell(0, 0);
    606. 

  606.       keyDownUp('enter');
    607. 

  607. 

  608.       let editor = getActiveEditor();
    609. 

  609. 

  610.       expect(editor.isOpened()).toBe(true);
    611. 

  611.       expect(editor.isInFullEditMode()).toBe(true);
    612. 

  612.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A1');
    613. 

  613. 

  614.       // Closing the editor.
    615. 

  615.       keyDownUp('enter');
    616. 

  616. 

  617.       editor = getActiveEditor();
    618. 

  618. 

  619.       expect(editor.isOpened()).toBe(false);
    620. 

  620.       expect(editor.isInFullEditMode()).toBe(false);
    621. 

  621. 

  622.       selectCell(1, 0);
    623. 

  623.       keyDownUp('enter');
    624. 

  624. 

  625.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A1');
    626. 

  626. 

  627.       // Closing the editor.
    628. 

  628.       keyDownUp('enter');
    629. 

  629. 

  630.       editor = getActiveEditor();
    631. 

  631. 

  632.       expect(editor.isOpened()).toBe(false);
    633. 

  633.       expect(editor.isInFullEditMode()).toBe(false);
    634. 

  634. 

  635.       selectCell(2, 0);
    636. 

  636.       keyDownUp('enter');
    637. 

  637. 

  638.       editor = getActiveEditor();
    639. 

  639. 

  640.       expect(editor.isOpened()).toBe(true);
    641. 

  641.       expect(editor.isInFullEditMode()).toBe(true);
    642. 

  642.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A1');
    643. 

  643. 

  644.       // Closing the editor.
    645. 

  645.       keyDownUp('enter');
    646. 

  646. 

  647.       editor = getActiveEditor();
    648. 

  648. 

  649.       expect(editor.isOpened()).toBe(false);
    650. 

  650.       expect(editor.isInFullEditMode()).toBe(false);
    651. 

  651. 

  652.       selectCell(3, 0);
    653. 

  653.       keyDownUp('enter');
    654. 

  654. 

  655.       editor = getActiveEditor();
    656. 

  656. 

  657.       expect(editor.isOpened()).toBe(true);
    658. 

  658.       expect(editor.isInFullEditMode()).toBe(true);
    659. 

  659.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A1');
    660. 

  660. 

  661.       // Closing the editor.
    662. 

  662.       keyDownUp('enter');
    663. 

  663. 

  664.       editor = getActiveEditor();
    665. 

  665. 

  666.       expect(editor.isOpened()).toBe(false);
    667. 

  667.       expect(editor.isInFullEditMode()).toBe(false);
    668. 

  668. 

  669.       // Double click on the first visible cell (merged area).
    670. 

  670.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    671. 

  671. 

  672.       editor = getActiveEditor();
    673. 

  673. 

  674.       expect(editor.isOpened()).toBe(true);
    675. 

  675.       expect(editor.isInFullEditMode()).toBe(true);
    676. 

  676.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A1');
    677. 

  677.     });
    678. 

  678. 

  679.     it('should open properly merged cells containing hidden rows (merge area from visible cell to invisible cell)', () => {
    680. 

  680.       handsontable({
    681. 

  681.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    682. 

  682.         hiddenRows: {
    683. 

  683.           rows: [0, 2, 4],
    684. 

  684.         },
    685. 

  685.         mergeCells: true
    686. 

  686.       });
    687. 

  687. 

  688.       getPlugin('mergeCells').merge(1, 0, 4, 0);
    689. 

  689. 

  690.       selectCell(1, 0);
    691. 

  691.       keyDownUp('enter');
    692. 

  692. 

  693.       let editor = getActiveEditor();
    694. 

  694. 

  695.       expect(editor.isOpened()).toBe(true);
    696. 

  696.       expect(editor.isInFullEditMode()).toBe(true);
    697. 

  697.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A2');
    698. 

  698. 

  699.       // Closing the editor.
    700. 

  700.       keyDownUp('enter');
    701. 

  701. 

  702.       editor = getActiveEditor();
    703. 

  703. 

  704.       expect(editor.isOpened()).toBe(false);
    705. 

  705.       expect(editor.isInFullEditMode()).toBe(false);
    706. 

  706. 

  707.       selectCell(2, 0);
    708. 

  708.       keyDownUp('enter');
    709. 

  709. 

  710.       editor = getActiveEditor();
    711. 

  711. 

  712.       expect(editor.isOpened()).toBe(true);
    713. 

  713.       expect(editor.isInFullEditMode()).toBe(true);
    714. 

  714.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A2');
    715. 

  715. 

  716.       // Closing the editor.
    717. 

  717.       keyDownUp('enter');
    718. 

  718. 

  719.       editor = getActiveEditor();
    720. 

  720. 

  721.       expect(editor.isOpened()).toBe(false);
    722. 

  722.       expect(editor.isInFullEditMode()).toBe(false);
    723. 

  723. 

  724.       selectCell(3, 0);
    725. 

  725.       keyDownUp('enter');
    726. 

  726. 

  727.       editor = getActiveEditor();
    728. 

  728. 

  729.       expect(editor.isOpened()).toBe(true);
    730. 

  730.       expect(editor.isInFullEditMode()).toBe(true);
    731. 

  731.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A2');
    732. 

  732. 

  733.       // Closing the editor.
    734. 

  734.       keyDownUp('enter');
    735. 

  735. 

  736.       editor = getActiveEditor();
    737. 

  737. 

  738.       expect(editor.isOpened()).toBe(false);
    739. 

  739.       expect(editor.isInFullEditMode()).toBe(false);
    740. 

  740. 

  741.       selectCell(4, 0);
    742. 

  742.       keyDownUp('enter');
    743. 

  743. 

  744.       editor = getActiveEditor();
    745. 

  745. 

  746.       expect(editor.isOpened()).toBe(true);
    747. 

  747.       expect(editor.isInFullEditMode()).toBe(true);
    748. 

  748.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A2');
    749. 

  749. 

  750.       // Closing the editor.
    751. 

  751.       keyDownUp('enter');
    752. 

  752. 

  753.       editor = getActiveEditor();
    754. 

  754. 

  755.       expect(editor.isOpened()).toBe(false);
    756. 

  756.       expect(editor.isInFullEditMode()).toBe(false);
    757. 

  757. 

  758.       // Double click on the first visible cell (merged area).
    759. 

  759.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    760. 

  760. 

  761.       editor = getActiveEditor();
    762. 

  762. 

  763.       expect(editor.isOpened()).toBe(true);
    764. 

  764.       expect(editor.isInFullEditMode()).toBe(true);
    765. 

  765.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A2');
    766. 

  766.     });
    767. 

  767. 

  768.     it('should open properly merged cells containing hidden rows (merge area from invisible cell to invisible cell)', () => {
    769. 

  769.       handsontable({
    770. 

  770.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    771. 

  771.         hiddenRows: {
    772. 

  772.           rows: [0, 2, 4],
    773. 

  773.         },
    774. 

  774.         mergeCells: true
    775. 

  775.       });
    776. 

  776. 

  777.       getPlugin('mergeCells').merge(0, 0, 4, 0);
    778. 

  778. 

  779.       selectCell(0, 0);
    780. 

  780.       keyDownUp('enter');
    781. 

  781. 

  782.       let editor = getActiveEditor();
    783. 

  783. 

  784.       expect(editor.isOpened()).toBe(true);
    785. 

  785.       expect(editor.isInFullEditMode()).toBe(true);
    786. 

  786.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A1');
    787. 

  787. 

  788.       // Closing the editor.
    789. 

  789.       keyDownUp('enter');
    790. 

  790. 

  791.       editor = getActiveEditor();
    792. 

  792. 

  793.       expect(editor.isOpened()).toBe(false);
    794. 

  794.       expect(editor.isInFullEditMode()).toBe(false);
    795. 

  795. 

  796.       selectCell(1, 0);
    797. 

  797.       keyDownUp('enter');
    798. 

  798. 

  799.       editor = getActiveEditor();
    800. 

  800. 

  801.       expect(editor.isOpened()).toBe(true);
    802. 

  802.       expect(editor.isInFullEditMode()).toBe(true);
    803. 

  803.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A1');
    804. 

  804. 

  805.       // Closing the editor.
    806. 

  806.       keyDownUp('enter');
    807. 

  807. 

  808.       editor = getActiveEditor();
    809. 

  809. 

  810.       expect(editor.isOpened()).toBe(false);
    811. 

  811.       expect(editor.isInFullEditMode()).toBe(false);
    812. 

  812. 

  813.       selectCell(2, 0);
    814. 

  814.       keyDownUp('enter');
    815. 

  815. 

  816.       editor = getActiveEditor();
    817. 

  817. 

  818.       expect(editor.isOpened()).toBe(true);
    819. 

  819.       expect(editor.isInFullEditMode()).toBe(true);
    820. 

  820.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A1');
    821. 

  821. 

  822.       // Closing the editor.
    823. 

  823.       keyDownUp('enter');
    824. 

  824. 

  825.       editor = getActiveEditor();
    826. 

  826. 

  827.       expect(editor.isOpened()).toBe(false);
    828. 

  828.       expect(editor.isInFullEditMode()).toBe(false);
    829. 

  829. 

  830.       selectCell(3, 0);
    831. 

  831.       keyDownUp('enter');
    832. 

  832. 

  833.       editor = getActiveEditor();
    834. 

  834. 

  835.       expect(editor.isOpened()).toBe(true);
    836. 

  836.       expect(editor.isInFullEditMode()).toBe(true);
    837. 

  837.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A1');
    838. 

  838. 

  839.       // Closing the editor.
    840. 

  840.       keyDownUp('enter');
    841. 

  841. 

  842.       editor = getActiveEditor();
    843. 

  843. 

  844.       expect(editor.isOpened()).toBe(false);
    845. 

  845.       expect(editor.isInFullEditMode()).toBe(false);
    846. 

  846. 

  847.       selectCell(4, 0);
    848. 

  848.       keyDownUp('enter');
    849. 

  849. 

  850.       editor = getActiveEditor();
    851. 

  851. 

  852.       expect(editor.isOpened()).toBe(true);
    853. 

  853.       expect(editor.isInFullEditMode()).toBe(true);
    854. 

  854.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A1');
    855. 

  855. 

  856.       // Closing the editor.
    857. 

  857.       keyDownUp('enter');
    858. 

  858. 

  859.       editor = getActiveEditor();
    860. 

  860. 

  861.       expect(editor.isOpened()).toBe(false);
    862. 

  862.       expect(editor.isInFullEditMode()).toBe(false);
    863. 

  863. 

  864.       // Double click on the first visible cell (merged area).
    865. 

  865.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    866. 

  866. 

  867.       editor = getActiveEditor();
    868. 

  868. 

  869.       expect(editor.isOpened()).toBe(true);
    870. 

  870.       expect(editor.isInFullEditMode()).toBe(true);
    871. 

  871.       expect(spec().$container.find('.handsontableInputHolder textarea').val()).toEqual('A1');
    872. 

  872.     });
    873. 

  873. 

  874.     it('should edit merged cells properly (merge area from visible cell to visible cell)', () => {
    875. 

  875.       handsontable({
    876. 

  876.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    877. 

  877.         hiddenRows: {
    878. 

  878.           rows: [0, 2, 4],
    879. 

  879.         },
    880. 

  880.         mergeCells: [
    881. 

  881.           { row: 1, col: 0, rowspan: 3, colspan: 1 }
    882. 

  882.         ]
    883. 

  883.       });
    884. 

  884. 

  885.       // Double click on the first visible cell (merged area).
    886. 

  886.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    887. 

  887. 

  888.       const textarea = spec().$container.find('.handsontableInputHolder textarea')[0];
    889. 

  889. 

  890.       textarea.value = 'Edited value';
    891. 

  891. 

  892.       // Closing the editor.
    893. 

  893.       keyDownUp('enter');
    894. 

  894. 

  895.       expect(getData()).toEqual([['A1'], ['Edited value'], [null], [null], ['A5']]);
    896. 

  896.     });
    897. 

  897. 

  898.     it('should edit merged cells properly (merge area from invisible cell to visible cell)', () => {
    899. 

  899.       handsontable({
    900. 

  900.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    901. 

  901.         hiddenRows: {
    902. 

  902.           rows: [0, 2, 4],
    903. 

  903.         },
    904. 

  904.         mergeCells: [
    905. 

  905.           { row: 0, col: 0, rowspan: 4, colspan: 1 }
    906. 

  906.         ]
    907. 

  907.       });
    908. 

  908. 

  909.       // Double click on the first visible cell (merged area).
    910. 

  910.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    911. 

  911. 

  912.       const textarea = spec().$container.find('.handsontableInputHolder textarea')[0];
    913. 

  913. 

  914.       textarea.value = 'Edited value';
    915. 

  915. 

  916.       // Closing the editor.
    917. 

  917.       keyDownUp('enter');
    918. 

  918. 

  919.       expect(getData()).toEqual([['Edited value'], [null], [null], [null], ['A5']]);
    920. 

  920.     });
    921. 

  921. 

  922.     it('should edit merged cells properly (merge area from visible cell to invisible cell)', () => {
    923. 

  923.       handsontable({
    924. 

  924.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    925. 

  925.         hiddenRows: {
    926. 

  926.           rows: [0, 2, 4],
    927. 

  927.         },
    928. 

  928.         mergeCells: [
    929. 

  929.           { row: 1, col: 0, rowspan: 4, colspan: 1 }
    930. 

  930.         ],
    931. 

  931.       });
    932. 

  932. 

  933.       // Double click on the first visible cell (merged area).
    934. 

  934.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    935. 

  935. 

  936.       const textarea = spec().$container.find('.handsontableInputHolder textarea')[0];
    937. 

  937. 

  938.       textarea.value = 'Edited value';
    939. 

  939. 

  940.       // Closing the editor.
    941. 

  941.       keyDownUp('enter');
    942. 

  942. 

  943.       expect(getData()).toEqual([['A1'], ['Edited value'], [null], [null], [null]]);
    944. 

  944.     });
    945. 

  945. 

  946.     it('should edit merged cells properly (merge area from invisible cell to invisible cell)', () => {
    947. 

  947.       handsontable({
    948. 

  948.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    949. 

  949.         hiddenRows: {
    950. 

  950.           rows: [0, 2, 4],
    951. 

  951.         },
    952. 

  952.         mergeCells: [
    953. 

  953.           { row: 0, col: 0, rowspan: 5, colspan: 1 }
    954. 

  954.         ],
    955. 

  955.       });
    956. 

  956. 

  957.       // Double click on the first visible cell (merged area).
    958. 

  958.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    959. 

  959. 

  960.       const textarea = spec().$container.find('.handsontableInputHolder textarea')[0];
    961. 

  961. 

  962.       textarea.value = 'Edited value';
    963. 

  963. 

  964.       // Closing the editor.
    965. 

  965.       keyDownUp('enter');
    966. 

  966. 

  967.       expect(getData()).toEqual([['Edited value'], [null], [null], [null], [null]]);
    968. 

  968.     });
    969. 

  969. 

  970.     it('should work properly when hidden row is read only', () => {
    971. 

  971.       handsontable({
    972. 

  972.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    973. 

  973.         hiddenRows: {
    974. 

  974.           rows: [0, 2, 4],
    975. 

  975.         },
    976. 

  976.         mergeCells: [
    977. 

  977.           { row: 0, col: 0, rowspan: 5, colspan: 1 }
    978. 

  978.         ],
    979. 

  979.         cells(physicalRow, physicalColumn) {
    980. 

  980.           const cellProperties = {};
    981. 

  981.           const visualRowIndex = this.instance.toVisualRow(physicalRow);
    982. 

  982.           const visualColIndex = this.instance.toVisualColumn(physicalColumn);
    983. 

  983. 

  984.           if (visualRowIndex === 0 && visualColIndex === 0) {
    985. 

  985.             cellProperties.readOnly = true;
    986. 

  986.           }
    987. 

  987. 

  988.           return cellProperties;
    989. 

  989.         }
    990. 

  990.       });
    991. 

  991. 

  992.       // Double click on the first visible cell (merged area).
    993. 

  993.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    994. 

  994. 

  995.       let editor = getActiveEditor();
    996. 

  996. 

  997.       expect(editor).toBeUndefined();
    998. 

  998. 

  999.       // Try of opening the editor.
    1000. 

  1000.       keyDownUp('enter');
    1001. 

  1001. 

  1002.       editor = getActiveEditor();
    1003. 

  1003. 

  1004.       expect(editor).toBeUndefined();
    1005. 

  1005.     });
    1006. 

  1006. 

  1007.     it('should work properly when editor is set to `false` for hidden row', () => {
    1008. 

  1008.       handsontable({
    1009. 

  1009.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    1010. 

  1010.         hiddenRows: {
    1011. 

  1011.           rows: [0, 2, 4],
    1012. 

  1012.         },
    1013. 

  1013.         mergeCells: [
    1014. 

  1014.           { row: 0, col: 0, rowspan: 5, colspan: 1 }
    1015. 

  1015.         ],
    1016. 

  1016.         cells(physicalRow, physicalColumn) {
    1017. 

  1017.           const cellProperties = {};
    1018. 

  1018.           const visualRowIndex = this.instance.toVisualRow(physicalRow);
    1019. 

  1019.           const visualColIndex = this.instance.toVisualColumn(physicalColumn);
    1020. 

  1020. 

  1021.           if (visualRowIndex === 0 && visualColIndex === 0) {
    1022. 

  1022.             cellProperties.editor = false;
    1023. 

  1023.           }
    1024. 

  1024. 

  1025.           return cellProperties;
    1026. 

  1026.         }
    1027. 

  1027.       });
    1028. 

  1028. 

  1029.       // Double click on the first visible cell (merged area).
    1030. 

  1030.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    1031. 

  1031. 

  1032.       let editor = getActiveEditor();
    1033. 

  1033. 

  1034.       expect(editor).toBeUndefined();
    1035. 

  1035. 

  1036.       // Try of opening the editor.
    1037. 

  1037.       keyDownUp('enter');
    1038. 

  1038. 

  1039.       editor = getActiveEditor();
    1040. 

  1040. 

  1041.       expect(editor).toBeUndefined();
    1042. 

  1042.     });
    1043. 

  1043. 

  1044.     it('should edit merged cells properly (merge area from visible cell to visible cell)', () => {
    1045. 

  1045.       handsontable({
    1046. 

  1046.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    1047. 

  1047.         hiddenRows: {
    1048. 

  1048.           rows: [0, 2, 4],
    1049. 

  1049.         },
    1050. 

  1050.         mergeCells: [
    1051. 

  1051.           { row: 1, col: 0, rowspan: 3, colspan: 1 }
    1052. 

  1052.         ]
    1053. 

  1053.       });
    1054. 

  1054. 

  1055.       // Double click on the first visible cell (merged area).
    1056. 

  1056.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    1057. 

  1057. 

  1058.       const textarea = spec().$container.find('.handsontableInputHolder textarea')[0];
    1059. 

  1059. 

  1060.       textarea.value = 'Edited value';
    1061. 

  1061. 

  1062.       // Closing the editor.
    1063. 

  1063.       keyDownUp('enter');
    1064. 

  1064. 

  1065.       expect(getData()).toEqual([['A1'], ['Edited value'], [null], [null], ['A5']]);
    1066. 

  1066.     });
    1067. 

  1067. 

  1068.     it('should edit merged cells properly (merge area from invisible cell to visible cell)', () => {
    1069. 

  1069.       handsontable({
    1070. 

  1070.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    1071. 

  1071.         hiddenRows: {
    1072. 

  1072.           rows: [0, 2, 4],
    1073. 

  1073.         },
    1074. 

  1074.         mergeCells: [
    1075. 

  1075.           { row: 0, col: 0, rowspan: 4, colspan: 1 }
    1076. 

  1076.         ]
    1077. 

  1077.       });
    1078. 

  1078. 

  1079.       // Double click on the first visible cell (merged area).
    1080. 

  1080.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    1081. 

  1081. 

  1082.       const textarea = spec().$container.find('.handsontableInputHolder textarea')[0];
    1083. 

  1083. 

  1084.       textarea.value = 'Edited value';
    1085. 

  1085. 

  1086.       // Closing the editor.
    1087. 

  1087.       keyDownUp('enter');
    1088. 

  1088. 

  1089.       expect(getData()).toEqual([['Edited value'], [null], [null], [null], ['A5']]);
    1090. 

  1090.     });
    1091. 

  1091. 

  1092.     it('should edit merged cells properly (merge area from visible cell to invisible cell)', () => {
    1093. 

  1093.       handsontable({
    1094. 

  1094.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    1095. 

  1095.         hiddenRows: {
    1096. 

  1096.           rows: [0, 2, 4],
    1097. 

  1097.         },
    1098. 

  1098.         mergeCells: [
    1099. 

  1099.           { row: 1, col: 0, rowspan: 4, colspan: 1 }
    1100. 

  1100.         ],
    1101. 

  1101.       });
    1102. 

  1102. 

  1103.       // Double click on the first visible cell (merged area).
    1104. 

  1104.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    1105. 

  1105. 

  1106.       const textarea = spec().$container.find('.handsontableInputHolder textarea')[0];
    1107. 

  1107. 

  1108.       textarea.value = 'Edited value';
    1109. 

  1109. 

  1110.       // Closing the editor.
    1111. 

  1111.       keyDownUp('enter');
    1112. 

  1112. 

  1113.       expect(getData()).toEqual([['A1'], ['Edited value'], [null], [null], [null]]);
    1114. 

  1114.     });
    1115. 

  1115. 

  1116.     it('should edit merged cells properly (merge area from invisible cell to invisible cell)', () => {
    1117. 

  1117.       handsontable({
    1118. 

  1118.         data: Handsontable.helper.createSpreadsheetData(5, 1),
    1119. 

  1119.         hiddenRows: {
    1120. 

  1120.           rows: [0, 2, 4],
    1121. 

  1121.         },
    1122. 

  1122.         mergeCells: [
    1123. 

  1123.           { row: 0, col: 0, rowspan: 5, colspan: 1 }
    1124. 

  1124.         ],
    1125. 

  1125.       });
    1126. 

  1126. 

  1127.       // Double click on the first visible cell (merged area).
    1128. 

  1128.       mouseDoubleClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    1129. 

  1129. 

  1130.       const textarea = spec().$container.find('.handsontableInputHolder textarea')[0];
    1131. 

  1131. 

  1132.       textarea.value = 'Edited value';
    1133. 

  1133. 

  1134.       // Closing the editor.
    1135. 

  1135.       keyDownUp('enter');
    1136. 

  1136. 

  1137.       expect(getData()).toEqual([['Edited value'], [null], [null], [null], [null]]);
    1138. 

  1138.     });
    1139. 

  1139. 

  1140.     it('should populate merged cells properly (merge area from visible cell to visible cell)', () => {
    1141. 

  1141.       handsontable({
    1142. 

  1142.         data: Handsontable.helper.createSpreadsheetData(5, 5),
    1143. 

  1143.         hiddenRows: {
    1144. 

  1144.           rows: [0, 2, 4],
    1145. 

  1145.         },
    1146. 

  1146.         mergeCells: [
    1147. 

  1147.           { row: 1, col: 0, rowspan: 3, colspan: 1 }
    1148. 

  1148.         ]
    1149. 

  1149.       });
    1150. 

  1150. 

  1151.       // Click on the first visible cell (merged area).
    1152. 

  1152.       simulateClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    1153. 

  1153.       spec().$container.find('.wtBorder.current.corner').simulate('mousedown');
    1154. 

  1154.       spec().$container.find('tbody tr:eq(1) td:eq(4)').simulate('mouseover').simulate('mouseup');
    1155. 

  1155. 

  1156.       // TODO Empty strings should be equal to the `null` probably.
    1157. 

  1157.       expect(getData()).toEqual([
    1158. 

  1158.         ['A1', 'B1', 'C1', 'D1', 'E1'],
    1159. 

  1159.         ['A2', 'A2', 'A2', 'A2', 'A2'],
    1160. 

  1160.         [null, '', '', '', ''],
    1161. 

  1161.         [null, '', '', '', ''],
    1162. 

  1162.         ['A5', 'B5', 'C5', 'D5', 'E5'],
    1163. 

  1163.       ]);
    1164. 

  1164.     });
    1165. 

  1165. 

  1166.     it('should populate merged cells properly (merge area from invisible cell to visible cell)', () => {
    1167. 

  1167.       handsontable({
    1168. 

  1168.         data: Handsontable.helper.createSpreadsheetData(5, 5),
    1169. 

  1169.         hiddenRows: {
    1170. 

  1170.           rows: [0, 2, 4],
    1171. 

  1171.         },
    1172. 

  1172.         mergeCells: [
    1173. 

  1173.           { row: 0, col: 0, rowspan: 4, colspan: 1 }
    1174. 

  1174.         ]
    1175. 

  1175.       });
    1176. 

  1176. 

  1177.       // Click on the first visible cell (merged area).
    1178. 

  1178.       simulateClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    1179. 

  1179.       spec().$container.find('.ht_master .wtBorder.current.corner').simulate('mousedown');
    1180. 

  1180.       spec().$container.find('tbody tr:eq(1) td:eq(4)').simulate('mouseover').simulate('mouseup');
    1181. 

  1181. 

  1182.       // TODO Empty strings should be equal to the `null` probably.
    1183. 

  1183.       expect(getData()).toEqual([
    1184. 

  1184.         ['A1', 'A1', 'A1', 'A1', 'A1'],
    1185. 

  1185.         [null, '', '', '', ''],
    1186. 

  1186.         [null, '', '', '', ''],
    1187. 

  1187.         [null, '', '', '', ''],
    1188. 

  1188.         ['A5', 'B5', 'C5', 'D5', 'E5'],
    1189. 

  1189.       ]);
    1190. 

  1190.     });
    1191. 

  1191. 

  1192.     it('should populate merged cells properly (merge area from visible cell to invisible cell)', () => {
    1193. 

  1193.       handsontable({
    1194. 

  1194.         data: Handsontable.helper.createSpreadsheetData(5, 5),
    1195. 

  1195.         hiddenRows: {
    1196. 

  1196.           rows: [0, 2, 4],
    1197. 

  1197.         },
    1198. 

  1198.         mergeCells: [
    1199. 

  1199.           { row: 1, col: 0, rowspan: 4, colspan: 1 }
    1200. 

  1200.         ],
    1201. 

  1201.       });
    1202. 

  1202. 

  1203.       // Click on the first visible cell (merged area).
    1204. 

  1204.       simulateClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    1205. 

  1205.       spec().$container.find('.wtBorder.current.corner').simulate('mousedown');
    1206. 

  1206.       spec().$container.find('tbody tr:eq(1) td:eq(4)').simulate('mouseover').simulate('mouseup');
    1207. 

  1207. 

  1208.       // TODO Empty strings should be equal to the `null` probably.
    1209. 

  1209.       expect(getData()).toEqual([
    1210. 

  1210.         ['A1', 'B1', 'C1', 'D1', 'E1'],
    1211. 

  1211.         ['A2', 'A2', 'A2', 'A2', 'A2'],
    1212. 

  1212.         [null, '', '', '', ''],
    1213. 

  1213.         [null, '', '', '', ''],
    1214. 

  1214.         [null, '', '', '', ''],
    1215. 

  1215.       ]);
    1216. 

  1216.     });
    1217. 

  1217. 

  1218.     it('should populate merged cells properly (merge area from invisible cell to invisible cell)', () => {
    1219. 

  1219.       handsontable({
    1220. 

  1220.         data: Handsontable.helper.createSpreadsheetData(5, 5),
    1221. 

  1221.         hiddenRows: {
    1222. 

  1222.           rows: [0, 2, 4],
    1223. 

  1223.         },
    1224. 

  1224.         mergeCells: [
    1225. 

  1225.           { row: 0, col: 0, rowspan: 5, colspan: 1 }
    1226. 

  1226.         ],
    1227. 

  1227.       });
    1228. 

  1228. 

  1229.       // Click on the first visible cell (merged area).
    1230. 

  1230.       simulateClick(spec().$container.find('tr:eq(0) td:eq(0)'));
    1231. 

  1231.       spec().$container.find('.wtBorder.current.corner').simulate('mousedown');
    1232. 

  1232.       spec().$container.find('tbody tr:eq(1) td:eq(4)').simulate('mouseover').simulate('mouseup');
    1233. 

  1233. 

  1234.       // TODO Empty strings should be equal to the `null` probably.
    1235. 

  1235.       expect(getData()).toEqual([
    1236. 

  1236.         ['A1', 'A1', 'A1', 'A1', 'A1'],
    1237. 

  1237.         [null, '', '', '', ''],
    1238. 

  1238.         [null, '', '', '', ''],
    1239. 

  1239.         [null, '', '', '', ''],
    1240. 

  1240.         [null, '', '', '', ''],
    1241. 

  1241.       ]);
    1242. 

  1242.     });
    1243. 

  1243. 

  1244.     it('should select single merged area properly when it starts with hidden row', () => {
    1245. 

  1245.       handsontable({
    1246. 

  1246.         data: Handsontable.helper.createSpreadsheetData(5, 5),
    1247. 

  1247.         rowHeaders: true,
    1248. 

  1248.         colHeaders: true,
    1249. 

  1249.         hiddenRows: {
    1250. 

  1250.           rows: [1],
    1251. 

  1251.           indicators: true
    1252. 

  1252.         },
    1253. 

  1253.         mergeCells: [{ row: 1, col: 1, rowspan: 3, colspan: 3 }]
    1254. 

  1254.       });
    1255. 

  1255. 

  1256.       const mergedCell = spec().$container.find('tr:eq(2) td:eq(1)');
    1257. 

  1257. 

  1258.       simulateClick(mergedCell);
    1259. 

  1259. 

  1260.       // Third row is not displayed (CSS - display: none).
    1261. 

  1261.       expect(`
    1262. 

  1262.       |   ║   : - : - : - :   |
    1263. 

  1263.       |===:===:===:===:===:===|
    1264. 

  1264.       |   ║   :   :   :   :   |
    1265. 

  1265.       | - ║   : # :   :   :   |
    1266. 

  1266.       | - ║   :   :   :   :   |
    1267. 

  1267.       |   ║   :   :   :   :   |
    1268. 

  1268.       `).toBeMatchToSelectionPattern();
    1269. 

  1269.       expect(getSelected()).toEqual([[1, 1, 3, 3]]);
    1270. 

  1270.       expect(getSelectedRangeLast().highlight.row).toBe(2);
    1271. 

  1271.       expect(getSelectedRangeLast().highlight.col).toBe(1);
    1272. 

  1272.       expect(getSelectedRangeLast().from.row).toBe(1);
    1273. 

  1273.       expect(getSelectedRangeLast().from.col).toBe(1);
    1274. 

  1274.       expect(getSelectedRangeLast().to.row).toBe(3);
    1275. 

  1275.       expect(getSelectedRangeLast().to.col).toBe(3);
    1276. 

  1276.       expect($(mergedCell).hasClass('fullySelectedMergedCell')).toBeFalse();
    1277. 

  1277.       expect($(mergedCell).hasClass('fullySelectedMergedCell-multiple')).toBeFalse();
    1278. 

  1278.       expect($(mergedCell).hasClass('fullySelectedMergedCell-0')).toBeFalse();
    1279. 

  1279.       expect($(mergedCell).hasClass('fullySelectedMergedCell-1')).toBeFalse();
    1280. 

  1280.       expect($(mergedCell).hasClass('fullySelectedMergedCell-2')).toBeFalse();
    1281. 

  1281.       expect($(mergedCell).hasClass('fullySelectedMergedCell-3')).toBeFalse();
    1282. 

  1282.       expect($(mergedCell).hasClass('fullySelectedMergedCell-4')).toBeFalse();
    1283. 

  1283.       expect($(mergedCell).hasClass('fullySelectedMergedCell-5')).toBeFalse();
    1284. 

  1284.       expect($(mergedCell).hasClass('fullySelectedMergedCell-6')).toBeFalse();
    1285. 

  1285.       expect($(mergedCell).hasClass('fullySelectedMergedCell-7')).toBeFalse();
    1286. 

  1286.     });
    1287. 

  1287. 

  1288.     it('should select cells properly when there is a merged area within the selection' +
    1289. 

  1289.       '(selecting from non-merged cell to the merged cell; from the left to the right)', () => {
    1290. 

  1290.       handsontable({
    1291. 

  1291.         data: Handsontable.helper.createSpreadsheetData(5, 5),
    1292. 

  1292.         rowHeaders: true,
    1293. 

  1293.         colHeaders: true,
    1294. 

  1294.         contextMenu: true,
    1295. 

  1295.         hiddenRows: {
    1296. 

  1296.           rows: [1],
    1297. 

  1297.           indicators: true
    1298. 

  1298.         },
    1299. 

  1299.         mergeCells: [{ row: 1, col: 1, rowspan: 3, colspan: 1 }]
    1300. 

  1300.       });
    1301. 

  1301. 

  1302.       const dragStart = spec().$container.find('tr:eq(2) td:eq(0)');
    1303. 

  1303.       const dragEnd = spec().$container.find('tr:eq(2) td:eq(1)'); // Merged cell.
    1304. 

  1304. 

  1305.       mouseDown(dragStart);
    1306. 

  1306.       mouseOver(dragEnd);
    1307. 

  1307.       mouseUp(dragEnd);
    1308. 

  1308. 

  1309.       // Third row is not displayed (CSS - display: none).
    1310. 

  1310.       expect(`
    1311. 

  1311.       |   ║ - : - :   :   :   |
    1312. 

  1312.       |===:===:===:===:===:===|
    1313. 

  1313.       |   ║   :   :   :   :   |
    1314. 

  1314.       | - ║ A : 0 :   :   :   |
    1315. 

  1315.       | - ║ 0 :   :   :   :   |
    1316. 

  1316.       |   ║   :   :   :   :   |
    1317. 

  1317.       `).toBeMatchToSelectionPattern();
    1318. 

  1318.       expect(getSelected()).toEqual([[1, 0, 3, 1]]);
    1319. 

  1319.       expect(getSelectedRangeLast().highlight.row).toBe(2);
    1320. 

  1320.       expect(getSelectedRangeLast().highlight.col).toBe(0);
    1321. 

  1321.       expect(getSelectedRangeLast().from.row).toBe(1);
    1322. 

  1322.       expect(getSelectedRangeLast().from.col).toBe(0);
    1323. 

  1323.       expect(getSelectedRangeLast().to.row).toBe(3);
    1324. 

  1324.       expect(getSelectedRangeLast().to.col).toBe(1);
    1325. 

  1325.       expect($(dragEnd).hasClass('fullySelectedMergedCell')).toBeFalse();
    1326. 

  1326.       expect($(dragEnd).hasClass('fullySelectedMergedCell-multiple')).toBeFalse();
    1327. 

  1327.       expect($(dragEnd).hasClass('fullySelectedMergedCell-0')).toBeTrue();
    1328. 

  1328.       expect($(dragEnd).hasClass('fullySelectedMergedCell-1')).toBeFalse();
    1329. 

  1329.       expect($(dragEnd).hasClass('fullySelectedMergedCell-2')).toBeFalse();
    1330. 

  1330.       expect($(dragEnd).hasClass('fullySelectedMergedCell-3')).toBeFalse();
    1331. 

  1331.       expect($(dragEnd).hasClass('fullySelectedMergedCell-4')).toBeFalse();
    1332. 

  1332.       expect($(dragEnd).hasClass('fullySelectedMergedCell-5')).toBeFalse();
    1333. 

  1333.       expect($(dragEnd).hasClass('fullySelectedMergedCell-6')).toBeFalse();
    1334. 

  1334.       expect($(dragEnd).hasClass('fullySelectedMergedCell-7')).toBeFalse();
    1335. 

  1335.     });
    1336. 

  1336. 

  1337.     it('should select cells properly when there is a merged area within the selection' +
    1338. 

  1338.       '(selecting from non-merged cell to the merged cell; from the top to the bottom)', () => {
    1339. 

  1339.       handsontable({
    1340. 

  1340.         data: Handsontable.helper.createSpreadsheetData(5, 5),
    1341. 

  1341.         rowHeaders: true,
    1342. 

  1342.         colHeaders: true,
    1343. 

  1343.         contextMenu: true,
    1344. 

  1344.         hiddenRows: {
    1345. 

  1345.           rows: [1],
    1346. 

  1346.           indicators: true
    1347. 

  1347.         },
    1348. 

  1348.         mergeCells: [{ row: 1, col: 1, rowspan: 3, colspan: 1 }]
    1349. 

  1349.       });
    1350. 

  1350. 

  1351.       const dragStart = spec().$container.find('tr:eq(1) td:eq(1)');
    1352. 

  1352.       const dragEnd = spec().$container.find('tr:eq(2) td:eq(1)'); // Merged cell.
    1353. 

  1353. 

  1354.       mouseDown(dragStart);
    1355. 

  1355.       mouseOver(dragEnd);
    1356. 

  1356.       mouseUp(dragEnd);
    1357. 

  1357. 

  1358.       // Third row is not displayed (CSS - display: none).
    1359. 

  1359.       expect(`
    1360. 

  1360.       |   ║   : - :   :   :   |
    1361. 

  1361.       |===:===:===:===:===:===|
    1362. 

  1362.       | - ║   : A :   :   :   |
    1363. 

  1363.       | - ║   : 0 :   :   :   |
    1364. 

  1364.       | - ║   :   :   :   :   |
    1365. 

  1365.       |   ║   :   :   :   :   |
    1366. 

  1366.       `).toBeMatchToSelectionPattern();
    1367. 

  1367.       expect(getSelected()).toEqual([[0, 1, 3, 1]]);
    1368. 

  1368.       expect(getSelectedRangeLast().highlight.row).toBe(0);
    1369. 

  1369.       expect(getSelectedRangeLast().highlight.col).toBe(1);
    1370. 

  1370.       expect(getSelectedRangeLast().from.row).toBe(0);
    1371. 

  1371.       expect(getSelectedRangeLast().from.col).toBe(1);
    1372. 

  1372.       expect(getSelectedRangeLast().to.row).toBe(3);
    1373. 

  1373.       expect(getSelectedRangeLast().to.col).toBe(1);
    1374. 

  1374.       expect($(dragEnd).hasClass('fullySelectedMergedCell')).toBeFalse();
    1375. 

  1375.       expect($(dragEnd).hasClass('fullySelectedMergedCell-multiple')).toBeFalse();
    1376. 

  1376.       expect($(dragEnd).hasClass('fullySelectedMergedCell-0')).toBeTrue();
    1377. 

  1377.       expect($(dragEnd).hasClass('fullySelectedMergedCell-1')).toBeFalse();
    1378. 

  1378.       expect($(dragEnd).hasClass('fullySelectedMergedCell-2')).toBeFalse();
    1379. 

  1379.       expect($(dragEnd).hasClass('fullySelectedMergedCell-3')).toBeFalse();
    1380. 

  1380.       expect($(dragEnd).hasClass('fullySelectedMergedCell-4')).toBeFalse();
    1381. 

  1381.       expect($(dragEnd).hasClass('fullySelectedMergedCell-5')).toBeFalse();
    1382. 

  1382.       expect($(dragEnd).hasClass('fullySelectedMergedCell-6')).toBeFalse();
    1383. 

  1383.       expect($(dragEnd).hasClass('fullySelectedMergedCell-7')).toBeFalse();
    1384. 

  1384.     });
    1385. 

  1385. 

  1386.     it('should select cells properly when there is a merged area within the selection' +
    1387. 

  1387.       '(selecting from non-merged cell to the merged cell; from the right to the left)', () => {
    1388. 

  1388.       handsontable({
    1389. 

  1389.         data: Handsontable.helper.createSpreadsheetData(5, 5),
    1390. 

  1390.         rowHeaders: true,
    1391. 

  1391.         colHeaders: true,
    1392. 

  1392.         contextMenu: true,
    1393. 

  1393.         hiddenRows: {
    1394. 

  1394.           rows: [1],
    1395. 

  1395.           indicators: true
    1396. 

  1396.         },
    1397. 

  1397.         mergeCells: [{ row: 1, col: 1, rowspan: 3, colspan: 1 }]
    1398. 

  1398.       });
    1399. 

  1399. 

  1400.       const dragStart = spec().$container.find('tr:eq(2) td:eq(2)');
    1401. 

  1401.       const dragEnd = spec().$container.find('tr:eq(2) td:eq(1)'); // Merged cell.
    1402.