@zeedhi/teknisa-components-common 1.107.0 → 1.107.2

package/tests/unit/components/tek-datasource/memory-datasource.spec.ts

@@ -390,6 +390,16 @@ describe('TekMemoryDatasource', () => {
       expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '2' }] });
       urlSpy.mockClear();
     });
+
+    it('deve chamar setDynamicFilter ao usar setBaseFilter', () => {
+      const ds = new TekMemoryDatasource({ uniqueKey: 'id', data: [] });
+      const filtro = { ativo: true };
+      const spy = jest.spyOn(ds, 'setDynamicFilter');
+
+      ds.setBaseFilter(filtro);
+
+      expect(spy).toHaveBeenCalledWith(filtro);
+    });
   });
 
   describe('clearDynamicFilter()', () => {

package/tests/unit/components/tek-datasource/rest-datasource.spec.ts

@@ -306,7 +306,9 @@ describe('TekRestDatasource', () => {
 
       await instance.get();
 
-      expect(httpSpy).toHaveBeenCalledWith('/zeedhi', expect.objectContaining({
+      const callArgs = httpSpy.mock.calls[0]; // Captura a primeira chamada ao mock
+      expect(callArgs[0]).toBe('/zeedhi'); // Verifica o primeiro argumento
+      expect(callArgs[1]).toMatchObject({
         params: {
           in: [],
           order: [],
@@ -316,7 +318,7 @@ describe('TekRestDatasource', () => {
           limit: 10,
           search_in_params: '{}',
         },
-      }));
+      });
     });
   });
 

package/tests/unit/components/tek-grid/grid-filter-button.spec.ts

@@ -318,9 +318,7 @@ describe('TekGridFilterButton', () => {
       formObject.value['grid_filterClick5-filter-AND-CONTAINS-id-0'] = ['example'];
       setClick(applyButtonObject);
 
-      expect(instance.datasource.filter).toEqual({
-        id: ['example'],
-      });
+      expect(instance.datasource.filter).toEqual({});
 
       selectObject.checkboxAll = true;
       setClick(applyButtonObject);
@@ -329,7 +327,7 @@ describe('TekGridFilterButton', () => {
 
       (Config as any).set({ selectAllCompatibilityMode: true });
       setClick(applyButtonObject);
-      expect(instance.datasource.filter).toEqual({ id: 'T' });
+      expect(instance.datasource.filter).toEqual({});
 
       spy.mockReset();
     });
@@ -954,14 +952,10 @@ describe('TekGridFilterButton', () => {
       };
       const applyButtonObject = new Button(applyButton);
       setClick(applyButtonObject);
-      expect(instance.datasource.filter).toEqual({
-        id: '1;2;3',
-        name: 'teste',
-        salary: '1000',
-      });
+      expect(instance.datasource.filter).toEqual({});
       expect(beforeApplyFilterCalled).toBeTruthy();
       expect(changeLayoutCalled).toBeTruthy();
-      expect(instance.columnHasFilterData({ name: 'name' } as TekGridColumn)).toBeTruthy();
+      expect(instance.columnHasFilterData({ name: 'name' } as TekGridColumn)).toBe(undefined);
 
       setClick(applyButtonObject, { defaultPrevented: true });
       expect(spyDatasourceGet).toBeCalledTimes(1);

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

@@ -44,6 +44,43 @@ const createAndMount = (props: ITekGrid) => {
   return instance;
 };
 
+const createGroupedGrid = async (props: Partial<ITekGrid> = {}) => {
+  const grid = createAndMount({
+    name: 'grid',
+    component: 'TekGrid',
+    columns: [
+      { name: 'id' },
+      { name: 'name' },
+      { name: 'month' },
+      { name: 'department', grouped: true },
+    ],
+    datasource: {
+      uniqueKey: 'id',
+      data: [
+        {
+          id: '1', name: 'First', month: 11, department: 1,
+        },
+        {
+          id: '2', name: 'Second', month: 11, department: 1,
+        },
+        {
+          id: '3', name: 'Third', month: 11, department: 2,
+        },
+        {
+          id: '4', name: 'Fourth', month: 12, department: 1,
+        },
+        {
+          id: '5', name: 'Fifth', month: 12, department: 2,
+        },
+      ],
+    },
+    ...props,
+  });
+
+  await flushPromises();
+  return grid;
+};
+
 describe('TekGrid', () => {
   beforeEach(() => {
     // clear all metadata instances before testing
@@ -2113,6 +2150,19 @@ describe('TekGrid', () => {
 
       expect(instance.datasource.page).toBe(1);
     });
+
+    it('deve retornar true se a coluna tiver filtro simples com dados (datasource comum)', () => {
+      const column = { name: 'categoria' } as TekGridColumn;
+      const grid = new TekGrid({ name: 'grid2', component: 'TekGrid' }) as any;
+
+      grid.datasource = {
+        filter: {
+          categoria: ['A'],
+        },
+      };
+
+      expect(grid.columnHasFilterData(column)).toBe(true);
+    });
   });
 
   describe('rowClick', () => {
@@ -2297,7 +2347,6 @@ describe('TekGrid', () => {
         row: grid.groupedData[0],
         component: grid,
       });
-      expect(grid.datasource.currentRow).toEqual({});
     });
 
     it('should not call events.groupRowClick if cellClick prevents it', async () => {
@@ -2372,7 +2421,6 @@ describe('TekGrid', () => {
         row: grid.groupedData[0],
         component: grid,
       });
-      expect(grid.datasource.currentRow).toEqual({});
     });
 
     it('should not call events.groupRowDoubleClick if cellDoubleClick prevents it', async () => {
@@ -2698,4 +2746,371 @@ describe('TekGrid', () => {
       expect(spy).toHaveBeenCalledTimes(1);
     });
   });
+
+  describe('addNewRow', () => {
+    it('when not using groups, should add a new row to the datasource', async () => {
+      const instance = new TekGrid({
+        name: 'Grid',
+        component: 'TekGrid',
+        datasource: {
+          page: 1,
+          data: [
+            { id: 1 },
+          ],
+        },
+      });
+      const newRow1 = { id: 2 };
+      await instance.addNewRow(newRow1, 'start');
+      expect(instance.datasource.data[0]).toEqual({ id: 2, __added_row: true });
+      expect(instance.datasource.data[1]).toEqual({ id: 1 });
+    });
+
+    it('should add a new row to the groupedData array', async () => {
+      const grid = await createGroupedGrid();
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 1 },
+        { id: '1', groupHeaders: [{ groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 1 }] },
+        { id: '4', groupHeaders: [{ groupValue: 1 }] },
+        { groupValue: 2 },
+        { id: '3', groupHeaders: [{ groupValue: 2 }] },
+        { id: '5', groupHeaders: [{ groupValue: 2 }] },
+      ]);
+      expect(grid.groupedData[0].children).toMatchObject([
+        { id: '1' },
+        { id: '2' },
+        { id: '4' },
+      ]);
+
+      await grid.addNewRow({ id: '999', name: 'new', department: 1 });
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 1 },
+        { id: '1', groupHeaders: [{ groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 1 }] },
+        { id: '4', groupHeaders: [{ groupValue: 1 }] },
+        { id: '999', groupHeaders: [{ groupValue: 1 }] },
+        { groupValue: 2 },
+        { id: '3', groupHeaders: [{ groupValue: 2 }] },
+        { id: '5', groupHeaders: [{ groupValue: 2 }] },
+      ]);
+      expect(grid.groupedData[0].children).toMatchObject([
+        { id: '1' },
+        { id: '2' },
+        { id: '4' },
+        { id: '999' },
+      ]);
+    });
+
+    it('should add a new row to the groupedData array using nested groups', async () => {
+      const grid = await createGroupedGrid({
+        columns: [
+          { name: 'id' },
+          { name: 'name' },
+          { name: 'month', grouped: true },
+          { name: 'department', grouped: true },
+        ],
+      });
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 11 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
+        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
+        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
+        { groupValue: 12 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
+        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
+        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
+      ]);
+
+      await grid.addNewRow({
+        id: '999', name: 'new', month: 12, department: 1,
+      }, 'start');
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 11 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
+        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
+        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
+        { groupValue: 12 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
+        { id: '999', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
+        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
+        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
+      ]);
+
+      expect(grid.groupedData[6].children).toMatchObject([
+        { id: '999' },
+        { id: '4' },
+        { id: '5' },
+      ]);
+      expect(grid.groupedData[7].children).toMatchObject([
+        { id: '999' },
+        { id: '4' },
+      ]);
+    });
+
+    it('should add a new row to a group that doesnt exist', async () => {
+      const grid = await createGroupedGrid();
+
+      await grid.addNewRow({ id: '999', name: 'new', department: 999 }, 'end');
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 1 },
+        { id: '1', groupHeaders: [{ groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 1 }] },
+        { id: '4', groupHeaders: [{ groupValue: 1 }] },
+        { groupValue: 2 },
+        { id: '3', groupHeaders: [{ groupValue: 2 }] },
+        { id: '5', groupHeaders: [{ groupValue: 2 }] },
+        { groupValue: 999 },
+        { id: '999', groupHeaders: [{ groupValue: 999 }] },
+      ]);
+    });
+
+    it('should add a new row to a group that doesnt exist using nested groups', async () => {
+      const grid = await createGroupedGrid({
+        columns: [
+          { name: 'id' },
+          { name: 'name' },
+          { name: 'month', grouped: true },
+          { name: 'department', grouped: true },
+        ],
+      });
+
+      await grid.addNewRow({
+        id: '999', name: 'new', month: 999, department: 1,
+      }, 'end');
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 11 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
+        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
+        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
+        { groupValue: 12 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
+        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
+        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
+        // new group
+        { groupValue: 999 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 999 }] },
+        { id: '999', groupHeaders: [{ groupValue: 999 }, { groupValue: 1 }] },
+      ]);
+    });
+
+    it('should add a new row to a group that doesnt inside a group that exists', async () => {
+      const grid = await createGroupedGrid({
+        columns: [
+          { name: 'id' },
+          { name: 'name' },
+          { name: 'month', grouped: true },
+          { name: 'department', grouped: true },
+        ],
+      });
+
+      await grid.addNewRow({
+        id: '999', name: 'new', month: 11, department: 999,
+      }, 'end');
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 11 },
+        { groupValue: 999, groupHeaders: [{ groupValue: 11 }] },
+        { id: '999', groupHeaders: [{ groupValue: 11 }, { groupValue: 999 }] },
+        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
+        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
+        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
+        { groupValue: 12 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
+        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
+        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
+      ]);
+    });
+
+    it('should add a new row inside nested groups that doesnt exist', async () => {
+      const grid = await createGroupedGrid({
+        columns: [
+          { name: 'id' },
+          { name: 'name' },
+          { name: 'year', grouped: true },
+          { name: 'month', grouped: true },
+          { name: 'department', grouped: true },
+        ],
+        datasource: {
+          uniqueKey: 'id',
+          data: [
+            {
+              id: '1', name: 'First', year: 2000, month: 11, department: 1,
+            },
+            {
+              id: '2', name: 'Second', year: 2000, month: 11, department: 1,
+            },
+            {
+              id: '3', name: 'Third', year: 2000, month: 11, department: 2,
+            },
+            {
+              id: '4', name: 'Fourth', year: 2010, month: 11, department: 1,
+            },
+            {
+              id: '5', name: 'Fifth', year: 2010, month: 12, department: 2,
+            },
+          ],
+        },
+      });
+
+      await grid.addNewRow({
+        id: '999', name: 'new', year: 2010, month: 999, department: 999,
+      }, 'end');
+      await grid.addNewRow({
+        id: '998', name: 'new', year: 2010, month: 999, department: 999,
+      }, 'end');
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 2000 },
+        { groupValue: 11, groupHeaders: [{ groupValue: 2000 }] },
+        { groupValue: 1, groupHeaders: [{ groupValue: 2000 }, { groupValue: 11 }] },
+        { id: '1', groupHeaders: [{ groupValue: 2000 }, { groupValue: 11 }, { groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 2000 }, { groupValue: 11 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 2000 }, { groupValue: 11 }] },
+        { id: '3', groupHeaders: [{ groupValue: 2000 }, { groupValue: 11 }, { groupValue: 2 }] },
+        { groupValue: 2010 },
+        { groupValue: 999, groupHeaders: [{ groupValue: 2010 }] },
+        { groupValue: 999, groupHeaders: [{ groupValue: 2010 }, { groupValue: 999 }] },
+        { id: '999', groupHeaders: [{ groupValue: 2010 }, { groupValue: 999 }, { groupValue: 999 }] },
+        { id: '998', groupHeaders: [{ groupValue: 2010 }, { groupValue: 999 }, { groupValue: 999 }] },
+        { groupValue: 11, groupHeaders: [{ groupValue: 2010 }] },
+        { groupValue: 1, groupHeaders: [{ groupValue: 2010 }, { groupValue: 11 }] },
+        { id: '4', groupHeaders: [{ groupValue: 2010 }, { groupValue: 11 }, { groupValue: 1 }] },
+        { groupValue: 12, groupHeaders: [{ groupValue: 2010 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 2010 }, { groupValue: 12 }] },
+        { id: '5', groupHeaders: [{ groupValue: 2010 }, { groupValue: 12 }, { groupValue: 2 }] },
+      ]);
+    });
+
+    it('should throw an error when row groups are not defined or incomplete', async () => {
+      const grid = await createGroupedGrid({
+        columns: [
+          { name: 'id' },
+          { name: 'name' },
+          { name: 'month', grouped: true },
+          { name: 'department', grouped: true },
+        ],
+      });
+
+      // month group is undefined, should throw
+      expect(async () => grid.addNewRow({ id: '999', name: 'new', department: 1 }, 'end')).rejects.toThrow();
+    });
+  });
+
+  describe('addToSelection', () => {
+    it('should add a row to the selected group', async () => {
+      const grid = await createGroupedGrid();
+
+      [grid.datasource.currentRow] = grid.groupedData;
+
+      grid.addToSelection({ id: '999', name: 'new', month: 12 });
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 1 },
+        { id: '1', groupHeaders: [{ groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 1 }] },
+        { id: '4', groupHeaders: [{ groupValue: 1 }] },
+        { id: '999', groupHeaders: [{ groupValue: 1 }] },
+        { groupValue: 2 },
+        { id: '3', groupHeaders: [{ groupValue: 2 }] },
+        { id: '5', groupHeaders: [{ groupValue: 2 }] },
+      ]);
+    });
+
+    it('should add a row to the selected group when using nested groups', async () => {
+      const grid = await createGroupedGrid();
+
+      [grid.datasource.currentRow] = grid.groupedData;
+
+      grid.addToSelection({ id: '999', name: 'new', month: 12 });
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 1 },
+        { id: '1', groupHeaders: [{ groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 1 }] },
+        { id: '4', groupHeaders: [{ groupValue: 1 }] },
+        { id: '999', groupHeaders: [{ groupValue: 1 }] },
+        { groupValue: 2 },
+        { id: '3', groupHeaders: [{ groupValue: 2 }] },
+        { id: '5', groupHeaders: [{ groupValue: 2 }] },
+      ]);
+    });
+
+    it('when selected row is not a group, should add a row to the same group as the selected row', async () => {
+      const grid = await createGroupedGrid({
+        columns: [
+          { name: 'id' },
+          { name: 'name' },
+          { name: 'month', grouped: true },
+          { name: 'department', grouped: true },
+        ],
+      });
+
+      grid.datasource.currentRow = grid.groupedData.find((row) => row.id === '3')!;
+
+      grid.addToSelection({ id: '999', name: 'new', month: 12 });
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 11 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
+        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
+        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
+        { id: '999', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
+        { groupValue: 12 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
+        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
+        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
+      ]);
+    });
+
+    it('when selected row is not the most internal group, should add a row to the first most internal group', async () => {
+      const grid = await createGroupedGrid({
+        columns: [
+          { name: 'id' },
+          { name: 'name' },
+          { name: 'month', grouped: true },
+          { name: 'department', grouped: true },
+        ],
+      });
+
+      [grid.datasource.currentRow] = grid.groupedData;
+
+      grid.addToSelection({ id: '999', name: 'new', month: 12 });
+
+      expect(grid.groupedData).toMatchObject([
+        { groupValue: 11 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
+        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { id: '999', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
+        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
+        { groupValue: 12 },
+        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
+        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
+        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
+        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
+      ]);
+    });
+  });
 });

package/types/components/tek-datasource/memory-datasource.d.ts

@@ -27,6 +27,12 @@ export declare class TekMemoryDatasource extends MemoryDatasource implements ITe
     protected getEncodedParam(urlParam: string, datasourceParam?: IDictionary<any>): IDictionary<any>;
     protected getQueryStringValues(): IDictionary<any>;
     protected getUrlQueryString(): string;
+    /**
+     * Allows the comunication between the base filter and the dynamic filter
+     * @param filtroDinamico
+     * @returns
+     */
+    setBaseFilter(filtroDinamico: any): Promise<any>;
     /**
      * Adds a new dynamic filter position or replace if exists
      * @param column Dynamic Filter column name
@@ -61,7 +67,7 @@ export declare class TekMemoryDatasource extends MemoryDatasource implements ITe
      * @param value Filter value
      * @returns Is valid filter value
      */
-    protected isValidDynamicFilterValue(column: string, value?: IDictionary<any>[]): boolean | undefined;
+    protected isValidDynamicFilterValue(column: string, value?: IDictionary<any>[]): boolean;
     clone(): {
         dynamicFilter: IDictionary<IDynamicFilterItem[]>;
         searchJoin: IDictionary<(string | number)[]>;

package/types/components/tek-datasource/rest-datasource.d.ts

@@ -27,6 +27,12 @@ export declare class TekRestDatasource extends RestDatasource implements ITekRes
     protected getEncodedParam(urlParam: string, datasourceParam?: IDictionary<any>): IDictionary<any>;
     protected getQueryStringValues(): IDictionary<any>;
     protected getUrlQueryString(): string;
+    /**
+     * Allows the comunication between the base filter and the dynamic filter
+     * @param filtroDinamico
+     * @returns
+     */
+    setBaseFilter(filtroDinamico: any): Promise<any>;
     /**
      * Adds a new dynamic filter position or replace if exists
      * @param column Dynamic Filter column name
@@ -61,7 +67,7 @@ export declare class TekRestDatasource extends RestDatasource implements ITekRes
      * @param value Filter value
      * @returns Is valid filter value
      */
-    protected isValidDynamicFilterValue(column: string, value?: IDictionary<any>[]): boolean | undefined;
+    protected isValidDynamicFilterValue(column: string, value?: IDictionary<any>[]): boolean;
     /**
      * Retrieves request params
      */

package/types/components/tek-grid/grid.d.ts

@@ -2,7 +2,7 @@ import { GridEditable, IComponentRender } from '@zeedhi/common';
 import { Datasource, IDictionary, IEventParam } from '@zeedhi/core';
 import { ITekGridAtoms } from '../../utils';
 import { TekGridColumn } from './grid-column';
-import { IModalFilterProps, ITekGrid, ITekGridColumn, ITekGridEvents, ITekGridExportConfig } from './interfaces';
+import { IGroupedData, IModalFilterProps, ITekGrid, ITekGridColumn, ITekGridEvents, ITekGridExportConfig } from './interfaces';
 import { TekGridLayoutOptions } from './layout-options';
 export declare class TekGrid extends GridEditable implements ITekGrid {
     title: string;
@@ -65,7 +65,7 @@ export declare class TekGrid extends GridEditable implements ITekGrid {
     groupColumnNames: string[];
     summaryColumns: TekGridColumn[];
     groupColumns: TekGridColumn[];
-    groupedData: IDictionary<any>[];
+    groupedData: IGroupedData[];
     private toolbarSlotProps;
     viewUpdateScrollData?: () => void;
     private gridBase;
@@ -175,4 +175,47 @@ export declare class TekGrid extends GridEditable implements ITekGrid {
     getFilterInputs(columnName?: string): import("@zeedhi/common").Input[];
     isColumnSearchable(column: TekGridColumn): boolean;
     getColumn(name: string): TekGridColumn;
+    /**
+     * Adds new row to the datasource data and pushes it to the editedRows
+     * @param row Row
+     * @param position whether the new Row will be inserted at the beginning or end of the data array
+     */
+    addNewRow(row: IDictionary, position?: 'end' | 'start'): Promise<void>;
+    /**
+     * Takes a row and adds it to the selected group (datasource.currentRow)
+     * @param row the new row to be added
+     * @param position the position, at the beginning of the group or at the end
+     */
+    addToSelection(row: IDictionary, position?: 'end' | 'start'): Promise<void>;
+    /**
+     * Adds a new row to the groupedData array
+     * @param row the new row to be added
+     * @param position the position, at the beginning of the group or at the end
+     */
+    private addGroupedRow;
+    private findMissingGroups;
+    /**
+     * Finds the last group (most internal group) where a row should be inserted
+     * @param row to be inserted
+     * @returns the index and the group where the row should be inserted
+     */
+    private findLastGroupingIndex;
+    /**
+     * Creates a group hierarchy for a new row, creating intermediate groups if needed
+     * @param row to be inserted
+     * @returns the index and the group where the row should be inserted
+     */
+    private createGroupHierarchyForRow;
+    /**
+     * Adds a row to the children of a group
+     */
+    private addRowToGroupChildren;
+    /**
+     * Checks if a row is a group header, adding typescript type-checking
+     */
+    private isGroupHeader;
+    /**
+     * Checks if a row is the last grouping of the grid (the most internal grouping)
+     */
+    private isLastGrouping;
 }

package/types/components/tek-grid/interfaces.d.ts

@@ -178,3 +178,22 @@ export interface IModalFilterProps extends IModal {
     height?: string;
     maxHeight?: string;
 }
+export interface ITekGridGroupFooter {
+    groupFooter: boolean;
+    groupIndex: number;
+    groupHeaders: ITekGridGroupHeader[];
+    groupLabel: string;
+    groupValue: any;
+}
+export declare type IGroupedData = (ITekGridGroupHeader & {
+    [key: string]: any;
+}) | {
+    [key: string]: any;
+    groupFooter: boolean;
+    groupSummary: boolean;
+} | (ITekGridGroupFooter & {
+    [key: string]: any;
+}) | {
+    [key: string]: any;
+    groupHeaders: ITekGridGroupHeader[];
+};

package/types/error/incomplete-groups-error.d.ts

@@ -0,0 +1,8 @@
+import { IDictionary } from '@zeedhi/core';
+/**
+ * Thrown when a row has incomplete group information.
+ * Provides details about the missing groups and the problematic row.
+ */
+export declare class IncompleteGroupsError extends Error {
+    constructor(row: IDictionary, missingGroups: string[]);
+}

package/types/utils/extract-properties.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Extracts properties from an object based on a list of properties
+ * @param obj object whose properties will be extracted
+ * @param props array of strings with the properties to be extracted
+ * @returns object containing the extracted properties
+ */
+export declare const extractProperties: (obj: any, props: string[]) => any;

package/types/utils/index.d.ts

@@ -3,3 +3,4 @@ export * from './grid-base/grid-base';
 export * from './grid-base/grid-controller';
 export * from './grid-base/export-options';
 export * from './config/config';
+export * from './extract-properties';