added test for cell spanning

patryk0493 · patryk0493 · commit d7989719e457 · 2021-02-23T11:07:06.000+01:00
diff --git a/cypress/integration/common/utils.ts b/cypress/integration/common/utils.ts
@@ -22,11 +22,11 @@ export class Utilities {
         return this.config;
     }
 
-    isMacOs() {
+    isMacOs(): boolean {
         return Cypress.platform === 'darwin';
     }
 
-    selectCell(clientX: number, clientY: number, customEventArgs = undefined) {
+    selectCell(clientX: number, clientY: number, customEventArgs = undefined): void {
         const scrollableElement = this.getScrollableElement();
         if (customEventArgs !== undefined) {
             scrollableElement.trigger('pointerdown', clientX, clientY, { ...customEventArgs, pointerType: 'mouse' });
@@ -37,34 +37,35 @@ export class Utilities {
         cy.wait(500);
     }
 
-    scrollTo(left: number, top: number, duration = 500) {
-        return this.getConfig().pinToBody ? cy.scrollTo(left, top, { duration, ensureScrollable: true }) :
-            this.getScrollableElement().scrollTo(left, top, { duration, ensureScrollable: true });
+    scrollTo(left: number, top: number, duration = 500): void {
+        this.getConfig().pinToBody
+            ? cy.scrollTo(left, top, { duration, ensureScrollable: true })
+            : this.getScrollableElement().scrollTo(left, top, { duration, ensureScrollable: true });
     }
 
-    wait() {
+    wait(): number {
         return this.isMacOs() ? 50 : 100;
     }
 
-    scrollToBottom(left = 0) {
+    scrollToBottom(left = 0): void {
         const offset = this.getBottomAddtionalOffset(true);
-        return this.scrollTo(left, this.getConfig().rows * this.getConfig().cellHeight + offset);
+        this.scrollTo(left, this.getConfig().rows * this.getConfig().cellHeight + offset);
     }
 
-    scrollToRight(top = 0) {
+    scrollToRight(top = 0): void {
         const offset = this.getRightAddtionalOffset();
         this.scrollTo(this.getConfig().columns * this.getConfig().cellWidth + offset, top);
     }
 
-    getCellXCenter() {
+    getCellXCenter(): number {
         return this.getConfig().cellWidth / 2;
     }
 
-    getCellYCenter() {
+    getCellYCenter(): number {
         return this.getConfig().cellHeight / 2;
     }
 
-    selectCellInEditMode(clientX: number, clientY: number) {
+    selectCellInEditMode(clientX: number, clientY: number): void {
         this.selectCell(clientX, clientY);
         this.keyDown(constants.keyCodes.Enter, { force: true });
     }
@@ -79,12 +80,12 @@ export class Utilities {
         return +(Math.round(((value + "e+" + places) as unknown) as number) + "e-" + places);
     }
 
-    resetSelection(x: number, y: number) {
+    resetSelection(x: number, y: number): void {
         this.selectCell(x, y + this.getConfig().cellHeight);
         this.selectCell(x, y);
     }
 
-    keyDown(keyCode: number, customEventArgs?: {}, timeout = 200, log = true) {
+    keyDown(keyCode: number, customEventArgs?: Record<string, unknown>, timeout = 200, log = true): void {
         const rg = this.getReactGridContent();
         if (customEventArgs !== undefined) {
             rg.trigger('keydown', { ...customEventArgs, keyCode, log, force: true });
@@ -95,62 +96,62 @@ export class Utilities {
         cy.wait(timeout, { log });
     }
 
-    getCell(x: number, y: number) {
+    getCell(x: number, y: number): Cypress.Chainable {
         return cy.get(`[data-cell-colidx=${x}][data-cell-rowidx=${y}]`).eq(0);
     }
 
-    getScrollableElement() {
+    getScrollableElement(): Cypress.Chainable {
         // TODO is Body correct element for getting scroll and sroll view?
         return this.config.pinToBody ? this.getBody() : this.getDivScrollableElement();
     }
 
-    getDivScrollableElement() {
+    getDivScrollableElement(): Cypress.Chainable {
         return cy.get('.test-grid-container');
     }
 
-    getReactGrid() {
+    getReactGrid(): Cypress.Chainable {
         return cy.get('.reactgrid');
     }
 
-    getReactGridContent() {
+    getReactGridContent(): Cypress.Chainable {
         return cy.get('.reactgrid-content');
     }
 
-    getOuterInput() {
+    getOuterInput(): Cypress.Chainable {
         return cy.get('[data-cy=outer-input]');
     }
 
-    getCellEditor() {
+    getCellEditor(): Cypress.Chainable {
         return cy.get('.rg-celleditor');
     }
 
-    getBody() {
+    getBody(): Cypress.Chainable {
         return cy.get('body');
     }
 
-    getLeftStickyPane() {
+    getLeftStickyPane(): Cypress.Chainable {
         return cy.get('.rg-pane-left');
     }
 
-    getTopStickyPane() {
+    getTopStickyPane(): Cypress.Chainable {
         return cy.get('.rg-pane-top');
     }
 
-    getCellFocus() {
+    getCellFocus(): Cypress.Chainable {
         const cell = cy.get('.rg-cell-focus');
         cell.should('exist');
         return cell;
     }
 
-    getCellHighlight() {
+    getCellHighlight(): Cypress.Chainable {
         return cy.get('.rg-cell-highlight');
     }
 
-    getDropdownMenu() {
+    getDropdownMenu(): Cypress.Chainable {
         return cy.get('.dropdown-menu');
     }
 
-    click(x: number, y: number) {
+    click(x: number, y: number): void {
         this.getScrollableElement().trigger('pointerdown', x, y, { pointerType: 'mouse' });
         this.getBody().trigger('pointerup', 0, 0, { pointerType: 'mouse', force: true }); // 
     }
@@ -300,7 +301,7 @@ export class Utilities {
         }
     }
 
-    assertIsReactGridFocused() {
+    assertIsReactGridFocused(): void {
         cy.focused().should('have.class', 'rg-hidden-element');
     }
 
@@ -339,7 +340,7 @@ export class Utilities {
         }
     }
 
-    testCellEditor(testCase: CellEditorTestParams) {
+    testCellEditor(testCase: CellEditorTestParams): void {
         let test: CellEditorTestParams = this.setScrollValues(testCase);
         test = this.moveClickPosByOnePixel(test);
         this.scrollTo(test.scroll.x, test.scroll.y);
@@ -348,7 +349,7 @@ export class Utilities {
     }
 
 
-    testCellEditorOnSticky(testCase: CellEditorTestParams) {
+    testCellEditorOnSticky(testCase: CellEditorTestParams): void {
         let test: CellEditorTestParams = this.setScrollValues(testCase);
         test = this.moveClickPosByOnePixel(test);
         if (this.getConfig().pinToBody) {
diff --git a/cypress/integration/common/visit.ts b/cypress/integration/common/visit.ts
@@ -1,61 +1,65 @@
 /// <reference types="cypress" />
 
-export function visit() {
+export function visit(): void {
     cy.visit('/');
 }
 
-export function visitSticky() {
+export function visitSticky(): void {
     cy.visit('/enableSticky');
 }
 
-export function visitFrozenFocus() {
+export function visitFrozenFocus(): void {
     cy.visit('/enableFrozenFocus');
 }
 
-export function visitPinnedToBody() {
+export function visitPinnedToBody(): void {
     cy.visit('/enablePinnedToBody');
 }
 
-export function visitAdditionalContent() {
+export function visitAdditionalContent(): void {
     cy.visit('/enableAdditionalContent');
 }
 
-export function visitAdditionalContentWithFlexRow() {
+export function visitAdditionalContentWithFlexRow(): void {
     cy.visit('/enableAdditionalContent?flexRow=true');
 }
 
-export function visitStickyPinnedToBody() {
+export function visitStickyPinnedToBody(): void {
     cy.visit('/enableStickyPinnedToBody');
 }
 
-export function visitHeaders() {
+export function visitHeaders(): void {
     cy.visit('/enableHeaders');
 }
 
-export function visitColumnAndRowSelections() {
+export function visitColumnAndRowSelections(): void {
     cy.visit('/enableColumnAndRowSelection');
 }
 
-export function visitColumnAndRowSelectionsWithSticky() {
+export function visitColumnAndRowSelectionsWithSticky(): void {
     cy.visit('/enableColumnAndRowSelectionWithSticky');
 }
 
-export function visitSymetric() {
+export function visitSymetric(): void {
     cy.visit('/enableSymetric');
 }
 
-export function visitResponsiveSticky() {
+export function visitSpannedCells(): void {
+    cy.visit('/enableSpannedCells');
+}
+
+export function visitResponsiveSticky(): void {
     cy.visit('/enableResponsiveSticky');
 }
 
-export function visitResponsiveStickyPinnedToBody() {
+export function visitResponsiveStickyPinnedToBody(): void {
     cy.visit('/enableResponsiveStickyPinnedToBody');
 }
 
-export function visitResponsiveStickyPro() {
+export function visitResponsiveStickyPro(): void {
     cy.visit('/enableResponsiveStickyPro');
 }
 
-export function visitResponsiveStickyPinnedToBodyPro() {
+export function visitResponsiveStickyPinnedToBodyPro(): void {
     cy.visit('/enableResponsiveStickyPinnedToBodyPro');
 }
diff --git a/cypress/integration/tests/spannedCells/spannedCells.spec.ts b/cypress/integration/tests/spannedCells/spannedCells.spec.ts
@@ -0,0 +1,43 @@
+import { visitSpannedCells } from '../../common/visit';
+import { Utilities } from '../../common/utils';
+import { enableSpannedCells as config } from '../../../../src/test/testEnvConfig';
+
+const utils = new Utilities(config);
+
+context('Spanning', () => {
+
+    beforeEach(() => {
+        visitSpannedCells();
+    });
+
+    it('should span cells in both axes', () => {
+        const { idx, idy, colspan = 1, rowspan = 1 } = utils.getConfig().spannedCells[0];
+
+        utils.assertElementWidthIsEqual(utils.getCell(idx, idy), utils.getConfig().cellWidth * colspan);
+        utils.assertElementHeightIsEqual(utils.getCell(idx, idy), utils.getConfig().cellHeight * rowspan);
+    });
+
+    it('should span cells horizontally', () => {
+        const { idx, idy, colspan = 1, rowspan = 1 } = utils.getConfig().spannedCells[1];
+
+        utils.assertElementWidthIsEqual(utils.getCell(idx, idy), utils.getConfig().cellWidth * colspan);
+        utils.assertElementHeightIsEqual(utils.getCell(idx, idy), utils.getConfig().cellHeight * rowspan);
+    });
+
+    it('should span cells vertically', () => {
+        const { idx, idy, colspan = 1, rowspan = 1 } = utils.getConfig().spannedCells[2];
+
+        utils.assertElementWidthIsEqual(utils.getCell(idx, idy), utils.getConfig().cellWidth * colspan);
+        utils.assertElementHeightIsEqual(utils.getCell(idx, idy), utils.getConfig().cellHeight * rowspan);
+    });
+
+
+    it('should render cell highlight on a spanned cell', () => {
+        const { colspan = 1, rowspan = 1 } = utils.getConfig().spannedCells[0];
+
+        utils.assertElementWidthIsEqual(utils.getCellHighlight().eq(0), utils.getConfig().cellWidth * colspan + 1);
+        utils.assertElementHeightIsEqual(utils.getCellHighlight().eq(0), utils.getConfig().cellHeight * rowspan + 1);
+
+    });
+
+});
diff --git a/package.json b/package.json
@@ -74,6 +74,7 @@
     "cy:headerRow": "npx cypress run --headless --quiet --browser firefox -s 'cypress/integration/tests/headerRow/*'",
     "cy:pinnedToBody": "npx cypress run --headless --quiet --browser firefox -s 'cypress/integration/tests/pinnedToBody/*'",
     "cy:stickyPinnedToBody": "npx cypress run --headless --quiet --browser firefox -s 'cypress/integration/tests/stickyPinnedToBody/*'",
+    "cy:spannedCells": "npx cypress run --headless --quiet --browser firefox -s 'cypress/integration/tests/spannedCells/*'",
     "remove-suffix": "cross-env SUFFIX=rc node ./node_modules/npm-version-suffix/run-remove-suffix.js"
   },
   "husky": {
diff --git a/src/test/testEnvConfig.ts b/src/test/testEnvConfig.ts
@@ -136,18 +136,22 @@ export const enableResponsiveStickyPinnedToBody: TestConfig = {
 
 export const enableSpannedCells: TestConfig = {
     ...config,
-    columns: 5,
-    rows: 5,
     spannedCells: [
         { idx: 1, idy: 1, rowspan: 2, colspan: 2 },
-        { idx: 2, idy: 3, rowspan: 0, colspan: 3 },
+        { idx: 2, idy: 3, colspan: 3 },
+        { idx: 6, idy: 5, rowspan: 5 },
     ],
     headerCells: [
         { idx: 2, idy: 1 },
         { idx: 1, idy: 2 },
         { idx: 2, idy: 2 },
         { idx: 3, idy: 3 },
         { idx: 4, idy: 3 },
+        { idx: 6, idy: 5 },
+        { idx: 6, idy: 6 },
+        { idx: 6, idy: 7 },
+        { idx: 6, idy: 8 },
+        { idx: 6, idy: 9 },
     ]
 }
 
diff --git a/tsconfig.json b/tsconfig.json
@@ -22,6 +22,9 @@
     "allowJs": true,
     "skipLibCheck": true,
     "experimentalDecorators": true,
+    "types": [
+      "cypress"
+    ],
     "noFallthroughCasesInSwitch": true
   },
   "include": [

Original file line number	Diff line number	Diff line change
`@@ -22,11 +22,11 @@ export class Utilities {`
`22`	`22`	`return this.config;`
`23`	`23`	`}`
`24`	`24`
`25`		`- isMacOs() {`
	`25`	`+ isMacOs(): boolean {`
`26`	`26`	`return Cypress.platform === 'darwin';`
`27`	`27`	`}`
`28`	`28`
`29`		`- selectCell(clientX: number, clientY: number, customEventArgs = undefined) {`
	`29`	`+ selectCell(clientX: number, clientY: number, customEventArgs = undefined): void {`
`30`	`30`	`const scrollableElement = this.getScrollableElement();`
`31`	`31`	`if (customEventArgs !== undefined) {`
`32`	`32`	`scrollableElement.trigger('pointerdown', clientX, clientY, { ...customEventArgs, pointerType: 'mouse' });`
`@@ -37,34 +37,35 @@ export class Utilities {`
`37`	`37`	`cy.wait(500);`
`38`	`38`	`}`
`39`	`39`
`40`		`- scrollTo(left: number, top: number, duration = 500) {`
`41`		`- return this.getConfig().pinToBody ? cy.scrollTo(left, top, { duration, ensureScrollable: true }) :`
`42`		`- this.getScrollableElement().scrollTo(left, top, { duration, ensureScrollable: true });`
	`40`	`+ scrollTo(left: number, top: number, duration = 500): void {`
	`41`	`+ this.getConfig().pinToBody`
	`42`	`+ ? cy.scrollTo(left, top, { duration, ensureScrollable: true })`
	`43`	`+ : this.getScrollableElement().scrollTo(left, top, { duration, ensureScrollable: true });`
`43`	`44`	`}`
`44`	`45`
`45`		`- wait() {`
	`46`	`+ wait(): number {`
`46`	`47`	`return this.isMacOs() ? 50 : 100;`
`47`	`48`	`}`
`48`	`49`
`49`		`- scrollToBottom(left = 0) {`
	`50`	`+ scrollToBottom(left = 0): void {`
`50`	`51`	`const offset = this.getBottomAddtionalOffset(true);`
`51`		`- return this.scrollTo(left, this.getConfig().rows * this.getConfig().cellHeight + offset);`
	`52`	`+ this.scrollTo(left, this.getConfig().rows * this.getConfig().cellHeight + offset);`
`52`	`53`	`}`
`53`	`54`
`54`		`- scrollToRight(top = 0) {`
	`55`	`+ scrollToRight(top = 0): void {`
`55`	`56`	`const offset = this.getRightAddtionalOffset();`
`56`	`57`	`this.scrollTo(this.getConfig().columns * this.getConfig().cellWidth + offset, top);`
`57`	`58`	`}`
`58`	`59`
`59`		`- getCellXCenter() {`
	`60`	`+ getCellXCenter(): number {`
`60`	`61`	`return this.getConfig().cellWidth / 2;`
`61`	`62`	`}`
`62`	`63`
`63`		`- getCellYCenter() {`
	`64`	`+ getCellYCenter(): number {`
`64`	`65`	`return this.getConfig().cellHeight / 2;`
`65`	`66`	`}`
`66`	`67`
`67`		`- selectCellInEditMode(clientX: number, clientY: number) {`
	`68`	`+ selectCellInEditMode(clientX: number, clientY: number): void {`
`68`	`69`	`this.selectCell(clientX, clientY);`
`69`	`70`	`this.keyDown(constants.keyCodes.Enter, { force: true });`
`70`	`71`	`}`
`@@ -79,12 +80,12 @@ export class Utilities {`
`79`	`80`	`return +(Math.round(((value + "e+" + places) as unknown) as number) + "e-" + places);`
`80`	`81`	`}`
`81`	`82`
`82`		`- resetSelection(x: number, y: number) {`
	`83`	`+ resetSelection(x: number, y: number): void {`
`83`	`84`	`this.selectCell(x, y + this.getConfig().cellHeight);`
`84`	`85`	`this.selectCell(x, y);`
`85`	`86`	`}`
`86`	`87`
`87`		`- keyDown(keyCode: number, customEventArgs?: {}, timeout = 200, log = true) {`
	`88`	`+ keyDown(keyCode: number, customEventArgs?: Record<string, unknown>, timeout = 200, log = true): void {`
`88`	`89`	`const rg = this.getReactGridContent();`
`89`	`90`	`if (customEventArgs !== undefined) {`
`90`	`91`	`rg.trigger('keydown', { ...customEventArgs, keyCode, log, force: true });`
`@@ -95,62 +96,62 @@ export class Utilities {`
`95`	`96`	`cy.wait(timeout, { log });`
`96`	`97`	`}`
`97`	`98`
`98`		`- getCell(x: number, y: number) {`
	`99`	`+ getCell(x: number, y: number): Cypress.Chainable {`
`99`	`100`	return cy.get(`[data-cell-colidx=${x}][data-cell-rowidx=${y}]`).eq(0);
`100`	`101`	`}`
`101`	`102`
`102`		`- getScrollableElement() {`
	`103`	`+ getScrollableElement(): Cypress.Chainable {`
`103`	`104`	`// TODO is Body correct element for getting scroll and sroll view?`
`104`	`105`	`return this.config.pinToBody ? this.getBody() : this.getDivScrollableElement();`
`105`	`106`	`}`
`106`	`107`
`107`		`- getDivScrollableElement() {`
	`108`	`+ getDivScrollableElement(): Cypress.Chainable {`
`108`	`109`	`return cy.get('.test-grid-container');`
`109`	`110`	`}`
`110`	`111`
`111`		`- getReactGrid() {`
	`112`	`+ getReactGrid(): Cypress.Chainable {`
`112`	`113`	`return cy.get('.reactgrid');`
`113`	`114`	`}`
`114`	`115`
`115`		`- getReactGridContent() {`
	`116`	`+ getReactGridContent(): Cypress.Chainable {`
`116`	`117`	`return cy.get('.reactgrid-content');`
`117`	`118`	`}`
`118`	`119`
`119`		`- getOuterInput() {`
	`120`	`+ getOuterInput(): Cypress.Chainable {`
`120`	`121`	`return cy.get('[data-cy=outer-input]');`
`121`	`122`	`}`
`122`	`123`
`123`		`- getCellEditor() {`
	`124`	`+ getCellEditor(): Cypress.Chainable {`
`124`	`125`	`return cy.get('.rg-celleditor');`
`125`	`126`	`}`
`126`	`127`
`127`		`- getBody() {`
	`128`	`+ getBody(): Cypress.Chainable {`
`128`	`129`	`return cy.get('body');`
`129`	`130`	`}`
`130`	`131`
`131`		`- getLeftStickyPane() {`
	`132`	`+ getLeftStickyPane(): Cypress.Chainable {`
`132`	`133`	`return cy.get('.rg-pane-left');`
`133`	`134`	`}`
`134`	`135`
`135`		`- getTopStickyPane() {`
	`136`	`+ getTopStickyPane(): Cypress.Chainable {`
`136`	`137`	`return cy.get('.rg-pane-top');`
`137`	`138`	`}`
`138`	`139`
`139`		`- getCellFocus() {`
	`140`	`+ getCellFocus(): Cypress.Chainable {`
`140`	`141`	`const cell = cy.get('.rg-cell-focus');`
`141`	`142`	`cell.should('exist');`
`142`	`143`	`return cell;`
`143`	`144`	`}`
`144`	`145`
`145`		`- getCellHighlight() {`
	`146`	`+ getCellHighlight(): Cypress.Chainable {`
`146`	`147`	`return cy.get('.rg-cell-highlight');`
`147`	`148`	`}`
`148`	`149`
`149`		`- getDropdownMenu() {`
	`150`	`+ getDropdownMenu(): Cypress.Chainable {`
`150`	`151`	`return cy.get('.dropdown-menu');`
`151`	`152`	`}`
`152`	`153`
`153`		`- click(x: number, y: number) {`
	`154`	`+ click(x: number, y: number): void {`
`154`	`155`	`this.getScrollableElement().trigger('pointerdown', x, y, { pointerType: 'mouse' });`
`155`	`156`	`this.getBody().trigger('pointerup', 0, 0, { pointerType: 'mouse', force: true }); //`
`156`	`157`	`}`
`@@ -300,7 +301,7 @@ export class Utilities {`
`300`	`301`	`}`
`301`	`302`	`}`
`302`	`303`
`303`		`- assertIsReactGridFocused() {`
	`304`	`+ assertIsReactGridFocused(): void {`
`304`	`305`	`cy.focused().should('have.class', 'rg-hidden-element');`
`305`	`306`	`}`
`306`	`307`
`@@ -339,7 +340,7 @@ export class Utilities {`
`339`	`340`	`}`
`340`	`341`	`}`
`341`	`342`
`342`		`- testCellEditor(testCase: CellEditorTestParams) {`
	`343`	`+ testCellEditor(testCase: CellEditorTestParams): void {`
`343`	`344`	`let test: CellEditorTestParams = this.setScrollValues(testCase);`
`344`	`345`	`test = this.moveClickPosByOnePixel(test);`
`345`	`346`	`this.scrollTo(test.scroll.x, test.scroll.y);`
`@@ -348,7 +349,7 @@ export class Utilities {`
`348`	`349`	`}`
`349`	`350`
`350`	`351`
`351`		`- testCellEditorOnSticky(testCase: CellEditorTestParams) {`
	`352`	`+ testCellEditorOnSticky(testCase: CellEditorTestParams): void {`
`352`	`353`	`let test: CellEditorTestParams = this.setScrollValues(testCase);`
`353`	`354`	`test = this.moveClickPosByOnePixel(test);`
`354`	`355`	`if (this.getConfig().pinToBody) {`
Original file line number	Diff line number	Diff line change
`@@ -1,61 +1,65 @@`
`1`	`1`	`/// <reference types="cypress" />`
`2`	`2`
`3`		`-export function visit() {`
	`3`	`+export function visit(): void {`
`4`	`4`	`cy.visit('/');`
`5`	`5`	`}`
`6`	`6`
`7`		`-export function visitSticky() {`
	`7`	`+export function visitSticky(): void {`
`8`	`8`	`cy.visit('/enableSticky');`
`9`	`9`	`}`
`10`	`10`
`11`		`-export function visitFrozenFocus() {`
	`11`	`+export function visitFrozenFocus(): void {`
`12`	`12`	`cy.visit('/enableFrozenFocus');`
`13`	`13`	`}`
`14`	`14`
`15`		`-export function visitPinnedToBody() {`
	`15`	`+export function visitPinnedToBody(): void {`
`16`	`16`	`cy.visit('/enablePinnedToBody');`
`17`	`17`	`}`
`18`	`18`
`19`		`-export function visitAdditionalContent() {`
	`19`	`+export function visitAdditionalContent(): void {`
`20`	`20`	`cy.visit('/enableAdditionalContent');`
`21`	`21`	`}`
`22`	`22`
`23`		`-export function visitAdditionalContentWithFlexRow() {`
	`23`	`+export function visitAdditionalContentWithFlexRow(): void {`
`24`	`24`	`cy.visit('/enableAdditionalContent?flexRow=true');`
`25`	`25`	`}`
`26`	`26`
`27`		`-export function visitStickyPinnedToBody() {`
	`27`	`+export function visitStickyPinnedToBody(): void {`
`28`	`28`	`cy.visit('/enableStickyPinnedToBody');`
`29`	`29`	`}`
`30`	`30`
`31`		`-export function visitHeaders() {`
	`31`	`+export function visitHeaders(): void {`
`32`	`32`	`cy.visit('/enableHeaders');`
`33`	`33`	`}`
`34`	`34`
`35`		`-export function visitColumnAndRowSelections() {`
	`35`	`+export function visitColumnAndRowSelections(): void {`
`36`	`36`	`cy.visit('/enableColumnAndRowSelection');`
`37`	`37`	`}`
`38`	`38`
`39`		`-export function visitColumnAndRowSelectionsWithSticky() {`
	`39`	`+export function visitColumnAndRowSelectionsWithSticky(): void {`
`40`	`40`	`cy.visit('/enableColumnAndRowSelectionWithSticky');`
`41`	`41`	`}`
`42`	`42`
`43`		`-export function visitSymetric() {`
	`43`	`+export function visitSymetric(): void {`
`44`	`44`	`cy.visit('/enableSymetric');`
`45`	`45`	`}`
`46`	`46`
`47`		`-export function visitResponsiveSticky() {`
	`47`	`+export function visitSpannedCells(): void {`
	`48`	`+ cy.visit('/enableSpannedCells');`
	`49`	`+}`
	`50`	`+`
	`51`	`+export function visitResponsiveSticky(): void {`
`48`	`52`	`cy.visit('/enableResponsiveSticky');`
`49`	`53`	`}`
`50`	`54`
`51`		`-export function visitResponsiveStickyPinnedToBody() {`
	`55`	`+export function visitResponsiveStickyPinnedToBody(): void {`
`52`	`56`	`cy.visit('/enableResponsiveStickyPinnedToBody');`
`53`	`57`	`}`
`54`	`58`
`55`		`-export function visitResponsiveStickyPro() {`
	`59`	`+export function visitResponsiveStickyPro(): void {`
`56`	`60`	`cy.visit('/enableResponsiveStickyPro');`
`57`	`61`	`}`
`58`	`62`
`59`		`-export function visitResponsiveStickyPinnedToBodyPro() {`
	`63`	`+export function visitResponsiveStickyPinnedToBodyPro(): void {`
`60`	`64`	`cy.visit('/enableResponsiveStickyPinnedToBodyPro');`
`61`	`65`	`}`