@zeedhi/common 1.111.1 → 3.0.0

package/tests/unit/components/tek-grid/grouped-data-selector.spec.ts

@@ -0,0 +1,136 @@
+import { GroupedDataSelector } from '../../../../src';
+
+describe('GroupedDataSelector', () => {
+  let groupedDataSelector: GroupedDataSelector;
+  let mockIterable: any;
+
+  beforeEach(() => {
+    mockIterable = {
+      selectionState: { allSelected: false, except: [] },
+      selectedRows: [],
+      selectable: true,
+      isGrouped: jest.fn(),
+      getGroupedData: jest.fn(),
+      getData: jest.fn(),
+      getRowKey: jest.fn((row) => row.id),
+    };
+
+    groupedDataSelector = new GroupedDataSelector(mockIterable);
+  });
+
+  describe('selectAll', () => {
+    it('should do nothing if iterable is not selectable', () => {
+      mockIterable.selectable = false;
+      groupedDataSelector.selectAll(true);
+      expect(mockIterable.selectionState).toEqual({ allSelected: false, except: [] });
+      expect(mockIterable.selectedRows).toEqual([]);
+    });
+
+    const testData = [
+      { id: 1, name: 'Item 1' },
+      { id: 2, name: 'Item 2' },
+      { id: 3, name: 'Item 3' },
+    ];
+
+    it('when selecting all, should set selectionState and add all rows to selectedRows', () => {
+      mockIterable.getData = jest.fn(() => testData);
+      groupedDataSelector.selectAll(true);
+
+      expect(mockIterable.selectionState).toEqual({ allSelected: true, except: [] });
+      expect(mockIterable.selectedRows).toEqual(testData);
+    });
+
+    it('when selecting all, should skip rows where callDisableSelection returns true', () => {
+      mockIterable.getData = jest.fn(() => testData);
+      groupedDataSelector.callDisableSelection = jest.fn((row) => row.id === 2);
+      
+      groupedDataSelector.selectAll(true);
+      
+      expect(mockIterable.selectedRows).toEqual([
+        { id: 1, name: 'Item 1' },
+        { id: 3, name: 'Item 3' },
+      ]);
+    });
+
+    it('when selecting all, should skip rows that are already selected', () => {
+      mockIterable.getData = jest.fn(() => testData);
+      mockIterable.selectedRows = [testData[0]];
+      
+      groupedDataSelector.selectAll(true);
+      
+      expect(mockIterable.selectedRows).toEqual(testData); // should not duplicate
+    });
+
+    it('when selecting all, should work with grouped data', () => {
+      const groupedData = [
+        { id: 1, group: '1' }, { id: 2, group: '1' }, { id: 3, group: '2' },
+      ];
+      
+      mockIterable.isGrouped = jest.fn(() => true);
+      mockIterable.getGroupedData = jest.fn(() => groupedData);
+      
+      groupedDataSelector.selectAll(true);
+      
+      expect(mockIterable.selectedRows).toEqual(groupedData);
+    });
+
+    it('when deselecting all, should set selectionState and remove all rows from selectedRows', () => {
+      mockIterable.getData = jest.fn(() => testData);
+      mockIterable.selectedRows = [...testData];
+      groupedDataSelector.selectAll(false);
+
+      expect(mockIterable.selectionState).toEqual({ allSelected: false, except: [] });
+      expect(mockIterable.selectedRows).toEqual([]);
+    });
+
+    it('when deselecting all, should only remove rows that exist in the data', () => {
+      mockIterable.getData = jest.fn(() => []);
+      mockIterable.selectedRows.push({ id: 99, name: 'Extra item' });
+      
+      groupedDataSelector.selectAll(false);
+      
+      expect(mockIterable.selectedRows).toEqual([{ id: 99, name: 'Extra item' }]);
+    });
+
+    it('when deselecting all, should work with grouped data', () => {
+      const groupedData = [
+        { id: 1, group: '1' }, { id: 2, group: '1' }, { id: 3, group: '2' },
+      ];
+      
+      mockIterable.isGrouped = jest.fn(() => true);
+      mockIterable.getGroupedData = jest.fn(() => groupedData);
+      
+      groupedDataSelector.selectAll(false);
+      
+      expect(mockIterable.selectedRows).toEqual([]);
+    });
+  });
+
+  describe('getData', () => {
+    it('should call getGroupedData when iterable is grouped', () => {
+      mockIterable.isGrouped.mockReturnValue(true);
+      const expectedData = [{ group: 'Test', items: [] }];
+      mockIterable.getGroupedData.mockReturnValue(expectedData);
+
+      // @ts-ignore - access private method for testing
+      const result = groupedDataSelector.getData();
+
+      expect(result).toEqual(expectedData);
+      expect(mockIterable.isGrouped).toHaveBeenCalled();
+      expect(mockIterable.getGroupedData).toHaveBeenCalled();
+    });
+
+    it('should call getData when iterable is not grouped', () => {
+      mockIterable.isGrouped.mockReturnValue(false);
+      const expectedData = [{ id: 1 }, { id: 2 }];
+      mockIterable.getData.mockReturnValue(expectedData);
+
+      // @ts-ignore - access private method for testing
+      const result = groupedDataSelector.getData();
+
+      expect(result).toEqual(expectedData);
+      expect(mockIterable.isGrouped).toHaveBeenCalled();
+      expect(mockIterable.getData).toHaveBeenCalled();
+    });
+  });
+});

package/tests/unit/components/tek-grid/grouped-view-navigator.spec.ts

@@ -0,0 +1,244 @@
+import { IEventParam } from '@zeedhi/core';
+import { GroupedViewNavigator, ViewNavigator } from '../../../../src';
+import { spyOnAllMethods } from '../../__helpers__';
+
+describe('GroupedViewNavigator', () => {
+  let navigator: GroupedViewNavigator;
+  let mockGrid: any;
+
+  beforeEach(() => {
+    mockGrid = {
+      isGrouped: jest.fn(),
+      cellSelection: false,
+      getGroupedData: jest.fn(),
+      datasource: { currentRow: {} } as any,
+      getRowKey: jest.fn(),
+      isItemVisible: jest.fn().mockReturnValue(true),
+      setCurrentRow: jest.fn(),
+    };
+
+    navigator = new GroupedViewNavigator(mockGrid);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with the provided grid', () => {
+      expect(navigator).toBeInstanceOf(GroupedViewNavigator);
+      // @ts-ignore - access protected property for testing
+      expect(navigator.grid).toBe(mockGrid);
+    });
+  });
+
+  describe('basic navigation methods', () => {
+    it('should delegate to ViewNavigator', () => {
+      const spyObj = spyOnAllMethods(ViewNavigator.prototype);
+
+      const param = {} as IEventParam<any>;
+      navigator.navigateLeft(param);
+      expect(spyObj.navigateLeft).toHaveBeenCalledWith(param);
+
+      navigator.navigateRight(param);
+      expect(spyObj.navigateRight).toHaveBeenCalledWith(param);
+
+      const fn = jest.fn();
+      navigator.setViewNavigate(fn);
+      expect(spyObj.setViewNavigate).toHaveBeenCalledWith(fn);
+    });
+  });
+
+  describe('getRowIndex', () => {
+    const groupedData = [
+      { group: true, groupValue: 'Group1' },
+      { id: 1, name: 'Item1' },
+      { id: 2, name: 'Item2' },
+      { group: true, groupValue: 'Group2' },
+      { id: 3, name: 'Item3' },
+    ];
+
+    it('should return provided index if given', () => {
+      // @ts-ignore - access private method for testing
+      const result = navigator.getRowIndex(groupedData, 2);
+      expect(result).toBe(2);
+    });
+
+    it('should find index by groupValue when currentRow is a group', () => {
+      mockGrid.datasource.currentRow = { group: true, groupValue: 'Group2' };
+      // @ts-ignore - access private method for testing
+      const result = navigator.getRowIndex(groupedData);
+      expect(result).toBe(3);
+    });
+
+    it('should find index by rowKey when currentRow is not a group', () => {
+      mockGrid.datasource.currentRow = { id: 2, name: 'Item2' };
+      mockGrid.getRowKey.mockImplementation((row: any) => row.id);
+      // @ts-ignore - access private method for testing
+      const result = navigator.getRowIndex(groupedData);
+      expect(result).toBe(2);
+      expect(mockGrid.getRowKey).toHaveBeenCalledWith({ id: 2, name: 'Item2' });
+    });
+
+    it('should return -1 when row not found', () => {
+      mockGrid.datasource.currentRow = { id: 99, name: 'NotFound' };
+      mockGrid.getRowKey.mockImplementation((row: any) => row.id);
+      // @ts-ignore - access private method for testing
+      const result = navigator.getRowIndex(groupedData);
+      expect(result).toBe(-1);
+    });
+  });
+
+  describe('navigateUp', () => {
+    const groupedData = [
+      { group: true, groupValue: 'Group1' },
+      { id: 1, name: 'Item1' },
+      { id: 2, name: 'Item2' },
+      { group: true, groupValue: 'Group2' },
+      { id: 3, name: 'Item3' },
+      { groupFooter: true, groupValue: 'Group2' },
+    ];
+
+    beforeEach(() => {
+      mockGrid.getGroupedData.mockReturnValue(groupedData);
+    });
+
+    it('should delegate to ViewNavigator when not grouped or cellSelection is true', () => {
+      const spyObj = spyOnAllMethods(ViewNavigator.prototype);
+
+      mockGrid.isGrouped.mockReturnValue(false);
+      navigator.navigateUp();
+      expect(spyObj.navigateUp).toHaveBeenCalled();
+
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.cellSelection = true;
+      navigator.navigateUp();
+      expect(spyObj.navigateUp).toHaveBeenCalledTimes(2);
+    });
+
+    it('should do nothing when groupedData is empty', () => {
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.getGroupedData.mockReturnValue([]);
+      navigator.navigateUp();
+      expect(mockGrid.setCurrentRow).not.toHaveBeenCalled();
+    });
+
+    it('should navigate to previous visible row', () => {
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.datasource.currentRow = groupedData[2]; // Item2
+      mockGrid.getRowKey.mockImplementation((row: any) => row.id);
+
+      navigator.navigateUp();
+      expect(mockGrid.setCurrentRow).toHaveBeenCalledWith(groupedData[1]); // Item1
+    });
+
+    it('should skip group footers and invisible items', () => {
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.datasource.currentRow = groupedData[4]; // Item3
+      mockGrid.getRowKey.mockImplementation((row: any) => row.id);
+      mockGrid.isItemVisible.mockImplementation((row: any) => !row.groupFooter);
+
+      navigator.navigateUp();
+      // Should skip groupFooter and land on Group2
+      expect(mockGrid.setCurrentRow).toHaveBeenCalledWith(groupedData[3]);
+    });
+
+    it('should recursively find previous visible item', () => {
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.datasource.currentRow = groupedData[4]; // Item3
+      mockGrid.getRowKey.mockImplementation((row: any) => row.id);
+      // Make Group2 invisible
+      mockGrid.isItemVisible.mockImplementation((row: any) => row !== groupedData[3]);
+
+      navigator.navigateUp();
+      // Should skip invisible Group2 and land on Item2
+      expect(mockGrid.setCurrentRow).toHaveBeenCalledWith(groupedData[2]);
+    });
+
+    it('should stop at beginning of list', () => {
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.datasource.currentRow = groupedData[0]; // Group1
+      mockGrid.getRowKey.mockImplementation((row: any) => row.groupValue);
+
+      navigator.navigateUp();
+      expect(mockGrid.setCurrentRow).not.toHaveBeenCalled();
+    });
+
+    it('should navigate to last row when currentRow is not defined', () => {
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.datasource.currentRow = {};
+      mockGrid.getRowKey.mockImplementation((row: any) => row.id);
+
+      navigator.navigateUp();
+      expect(mockGrid.setCurrentRow).toHaveBeenCalledWith(groupedData[4]);
+    });
+  });
+
+  describe('navigateDown', () => {
+    const groupedData = [
+      { group: true, groupValue: 'Group1' },
+      { id: 1, name: 'Item1' },
+      { id: 2, name: 'Item2' },
+      { group: true, groupValue: 'Group2' },
+      { id: 3, name: 'Item3' }
+    ];
+
+    beforeEach(() => {
+      mockGrid.getGroupedData.mockReturnValue(groupedData);
+    });
+
+    it('should delegate to ViewNavigator when not grouped or cellSelection is true', () => {
+      const spyObj = spyOnAllMethods(ViewNavigator.prototype);
+
+      mockGrid.isGrouped.mockReturnValue(false);
+      navigator.navigateDown();
+      expect(spyObj.navigateDown).toHaveBeenCalled();
+
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.cellSelection = true;
+      navigator.navigateDown();
+      expect(spyObj.navigateDown).toHaveBeenCalledTimes(2);
+    });
+
+    it('should navigate to next visible row', () => {
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.datasource.currentRow = groupedData[1]; // Item1
+      mockGrid.getRowKey.mockImplementation((row: any) => row.id);
+
+      navigator.navigateDown();
+      expect(mockGrid.setCurrentRow).toHaveBeenCalledWith(groupedData[2]); // Item2
+    });
+
+    it('should skip group footers and invisible items', () => {
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.datasource.currentRow = groupedData[3]; // Group2
+      mockGrid.getRowKey.mockImplementation((row: any) => row.groupValue);
+      mockGrid.isItemVisible.mockImplementation((row: any) => !row.groupFooter);
+
+      navigator.navigateDown();
+      // Should skip groupFooter and land on Item3
+      expect(mockGrid.setCurrentRow).toHaveBeenCalledWith(groupedData[4]);
+    });
+
+    it('should recursively find next visible item', () => {
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.datasource.currentRow = groupedData[1]; // Item1
+      mockGrid.getRowKey.mockImplementation((row: any) => row.id);
+      // Make Item2 invisible
+      mockGrid.isItemVisible.mockImplementation((row: any) => row !== groupedData[2]);
+
+      navigator.navigateDown();
+      // Should skip invisible Item2 and land on Group2
+      expect(mockGrid.setCurrentRow).toHaveBeenCalledWith(groupedData[3]);
+    });
+
+    it('should do nothing when at end of list', () => {
+      mockGrid.isGrouped.mockReturnValue(true);
+      mockGrid.datasource.currentRow = groupedData[4];
+      mockGrid.getRowKey.mockImplementation((row: any) => row.id);
+
+      navigator.navigateDown();
+      expect(mockGrid.setCurrentRow).not.toHaveBeenCalled();
+    });
+  });
+});

package/tests/unit/components/tek-grid/keymap-grouped.spec.ts

@@ -0,0 +1,20 @@
+import { KeyMapGrouped } from '../../../../src';
+
+describe('KeyMapGrouped', () => {
+  it('should return a keymap', () => {
+    const instance = { directionalLeft: jest.fn(), directionalRight: jest.fn() } as any;
+    const keyMap = new KeyMapGrouped().getMap(instance);
+    expect(keyMap).toEqual(expect.objectContaining({
+      left: {
+        event: expect.any(Function),
+        stop: true,
+        active: true,
+      },
+      right: {
+        event: expect.any(Function),
+        stop: true,
+        active: true,
+      },
+    }));
+  });
+});