@adaptabletools/adaptable 15.2.0-canary.1 → 15.2.0-canary.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "15.2.0-canary.1",
+  "version": "15.2.0-canary.2",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",

package/publishTimestamp.d.ts

@@ -1,2 +1,2 @@
-declare const _default: 1680766462195;
+declare const _default: 1680846291184;
 export default _default;

package/publishTimestamp.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = 1680766462195;
+exports.default = 1680846291184;

package/src/AdaptableInterfaces/IAdaptable.d.ts

@@ -196,8 +196,14 @@ export interface IAdaptable {
         includeGroupRows?: boolean;
         filterFn?: (rowNode: IRowNode) => boolean;
     }): void;
-    forAllVisibleRowNodesDo(func: (rowNode: IRowNode) => void): void;
-    getVisibleRowNodes(): IRowNode[];
+    forAllVisibleRowNodesDo(func: (rowNode: IRowNode, rowIndex: number) => void, config?: {
+        includeGroupRows?: boolean;
+        filterFn?: (rowNode: IRowNode) => boolean;
+    }): void;
+    getVisibleRowNodes(config?: {
+        includeGroupRows?: boolean;
+        filterFn?: (rowNode: IRowNode) => boolean;
+    }): IRowNode[];
     getAllRowNodes(config?: {
         includeGroupRows?: boolean;
         filterFn?: (rowNode: IRowNode) => boolean;

package/src/AdaptableOptions/ExportOptions.d.ts

@@ -57,6 +57,33 @@ export interface ExportOptions {
      * @defaultValue true
      */
     isColumnExportable?: (exportableColumnContext: ExportableColumnContext) => boolean;
+    /**
+     * Function invoked when a Report is run, enabling you to preload the data before it is exported.
+     * If the function returns a `ReportData` object, that will be used as the data for the Report;
+     * if it returns `TRUE`, the Report will be run as normal, using the data from the grid;
+     * if it returns `FALSE`, the Report will be cancelled.
+     */
+    preProcessExport?: (context: PreProcessExportContext) => boolean | Promise<ReportData | boolean>;
+}
+/**
+ * Context provided to `ExportOptions.processExport()` callback
+ */
+export interface PreProcessExportContext extends BaseContext {
+    /**
+     * The report to be exported
+     */
+    report: Report;
+    /**
+     * Returns the columns which would be included in the report based on the `Report.ReportColumnScope`
+     * @param includePrimaryKey - whether to include the primary key column (defaults to `false`)
+     */
+    getReportColumns: (includePrimaryKey?: boolean) => AdaptableColumnBase[];
+    /**
+     * Returns the row data which would be included in the report based on the `Report.ReportRowScope`
+     * @param reportColumns - the columns to include in the report
+     * @param includePrimaryKey - whether to include the primary key column (defaults to `false`)
+     */
+    getReportRowData: (reportColumns: AdaptableColumnBase[], includePrimaryKey?: boolean) => Record<string, any>[];
 }
 /**
  * Format of exported Data - 'rawValue' or 'formattedValue'

package/src/Api/GridApi.d.ts

@@ -211,8 +211,12 @@ export interface GridApi {
     getFirstDisplayedRowNode(): IRowNode | undefined;
     /**
      * Retrieves all filtered Row Nodes currently in the Grid (i.e. after applying the current filter)
+     * @param config - configuration
      */
-    getVisibleRowNodes(): IRowNode[];
+    getVisibleRowNodes(config?: {
+        includeGroupRows?: boolean;
+        filterFn?: (rowNode: IRowNode) => boolean;
+    }): IRowNode[];
     /**
      * Retrieves all Row Nodes currently in the Grid (by default excluding the group rows)
      * @param config - configuration

package/src/Api/Implementation/AdaptableApiImpl.d.ts

@@ -101,4 +101,6 @@ export declare class AdaptableApiImpl implements AdaptableApi {
     logSuccess(message: string, ...optionalParams: any[]): void;
     logWarn(message: string, ...optionalParams: any[]): void;
     logError(message: string, ...optionalParams: any[]): void;
+    consoleError(message: string, ...optionalParams: any[]): void;
+    consoleWarn(message: string, ...optionalParams: any[]): void;
 }

package/src/Api/Implementation/AdaptableApiImpl.js

@@ -161,5 +161,11 @@ class AdaptableApiImpl {
     logError(message, ...optionalParams) {
         this.adaptable.logger.error(message, optionalParams);
     }
+    consoleError(message, ...optionalParams) {
+        this.adaptable.logger.consoleError(message, optionalParams);
+    }
+    consoleWarn(message, ...optionalParams) {
+        this.adaptable.logger.consoleWarn(message, optionalParams);
+    }
 }
 exports.AdaptableApiImpl = AdaptableApiImpl;

package/src/Api/Implementation/GridApiImpl.d.ts

@@ -70,7 +70,10 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     selectColumns(columnIds: string[]): void;
     getFirstRowNode(): IRowNode;
     getFirstDisplayedRowNode(): IRowNode;
-    getVisibleRowNodes(): IRowNode[];
+    getVisibleRowNodes(config?: {
+        includeGroupRows?: boolean;
+        filterFn?: (rowNode: IRowNode) => boolean;
+    }): IRowNode[];
     getAllRowNodes(config?: {
         includeGroupRows?: boolean;
         filterFn?: (rowNode: IRowNode) => boolean;

package/src/Api/Implementation/GridApiImpl.js

@@ -262,7 +262,7 @@ class GridApiImpl extends ApiBase_1.ApiBase {
     getFirstDisplayedRowNode() {
         return this.adaptable.getFirstDisplayedRowNode();
     }
-    getVisibleRowNodes() {
+    getVisibleRowNodes(config) {
         return this.adaptable.getVisibleRowNodes();
     }
     getAllRowNodes(config) {

package/src/Api/Internal/AdaptableInternalApi.d.ts

@@ -77,8 +77,14 @@ export declare class AdaptableInternalApi extends ApiBase {
     getRowEditService(): IRowEditService;
     getModules(): IModuleCollection;
     getModuleFriendlyName(adaptableModule: AdaptableModule): string;
-    forAllRowNodesDo(func: (rowNode: IRowNode) => void): void;
-    forAllVisibleRowNodesDo(func: (rowNode: IRowNode) => void): void;
+    forAllRowNodesDo(func: (rowNode: IRowNode) => void, config?: {
+        includeGroupRows?: boolean;
+        filterFn?: (rowNode: IRowNode) => boolean;
+    }): void;
+    forAllVisibleRowNodesDo(func: (rowNode: IRowNode) => void, config?: {
+        includeGroupRows?: boolean;
+        filterFn?: (rowNode: IRowNode) => boolean;
+    }): void;
     getLabelForButton(button: AdaptableButton<BaseContext>, context: BaseContext): string | undefined;
     getTooltipForButton(button: AdaptableButton<BaseContext>, context: BaseContext): string | undefined;
     getStyleForButton(button: AdaptableButton<BaseContext>, context: BaseContext): ButtonStyle | undefined;

package/src/Api/Internal/AdaptableInternalApi.js

@@ -143,11 +143,11 @@ class AdaptableInternalApi extends ApiBase_1.ApiBase {
         var _a, _b;
         return ((_b = (_a = this.adaptable.ModuleService.getModuleInfoByModule(adaptableModule)) === null || _a === void 0 ? void 0 : _a.FriendlyName) !== null && _b !== void 0 ? _b : adaptableModule);
     }
-    forAllRowNodesDo(func) {
-        this.adaptable.forAllRowNodesDo(func);
+    forAllRowNodesDo(func, config) {
+        this.adaptable.forAllRowNodesDo(func, config);
     }
-    forAllVisibleRowNodesDo(func) {
-        this.adaptable.forAllVisibleRowNodesDo(func);
+    forAllVisibleRowNodesDo(func, config) {
+        this.adaptable.forAllVisibleRowNodesDo(func, config);
     }
     getLabelForButton(button, context) {
         if (!button.label) {

package/src/PredefinedConfig/ExportState.d.ts

@@ -74,7 +74,7 @@ export interface ReportData {
      */
     columns: AdaptableColumnBase[];
     /**
-     * Rows in the Report
+     * Row Data in the Report
      */
     rows: Record<string, any>[];
 }

package/src/Strategy/ExportModule.d.ts

@@ -13,7 +13,8 @@ export declare class ExportModule extends AdaptableModuleBase implements IExport
     getExplicitlyReferencedColumnIds(report: Report): string[];
     getReferencedNamedQueryNames(report: Report): string[];
     addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
-    export(report: Report, exportDestination: ExportDestination | string): void;
+    export(report: Report, exportDestination: ExportDestination | string): Promise<void>;
+    private preProcessExport;
     private isCustomDestination;
     private convertReportToJSON;
     private openReportInTablePopup;

package/src/Strategy/ExportModule.js

@@ -21,6 +21,7 @@ const ExportSelector_1 = require("../View/Export/ExportSelector");
 const SystemRedux_1 = require("../Redux/ActionsReducers/SystemRedux");
 const windowFactory_1 = require("../View/Components/Popups/WindowPopups/windowFactory");
 const Uuid_1 = require("../PredefinedConfig/Uuid");
+const waitForTimeout_1 = require("../Utilities/waitForTimeout");
 class ExportModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.ExportModuleId, ModuleConstants.ExportFriendlyName, 'export-data', 'ExportPopup', 'Export data from the Grid to numerous locations in numerous formatso', api);
@@ -70,12 +71,46 @@ class ExportModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             },
         ];
     }
-    export(report, exportDestination) {
+    async export(report, exportDestination) {
+        var _a;
+        const cleanupExportProcess = () => {
+            this.api.internalApi.dispatchReduxAction((0, SystemRedux_1.SystemVisualExportEnd)());
+            this.api.internalApi.hideProgressIndicator();
+        };
         if (report.Name === GeneralConstants_1.VISUAL_DATA_REPORT) {
             this.api.internalApi.dispatchReduxAction((0, SystemRedux_1.SystemVisualExportBegin)());
         }
-        this.api.internalApi.executeWithProgressIndicator(`${report.Name} Export in progress...`, () => {
-            var _a;
+        this.api.internalApi.dispatchReduxAction((0, SystemRedux_1.SystemProgressIndicatorShow)(`${report.Name} Export in progress...`));
+        try {
+            // waitForTimeout required to give the ProgressIndicator rendering a head-start (see rAF in ProgressIndicator implementation)
+            await (0, waitForTimeout_1.waitForTimeout)(16);
+            if (report.Name === GeneralConstants_1.VISUAL_DATA_REPORT) {
+                this.api.logInfo(`Export ${report.Name} (${exportDestination})`);
+                this.api.exportApi.exportVisualDataToExcel();
+                // WYSIWYG is fully delegated to the AG Grid excel export, so we don't need to do anything else
+                cleanupExportProcess();
+                return;
+            }
+            const preProcessedExport = await this.preProcessExport(report);
+            let reportData;
+            if (preProcessedExport === false) {
+                this.api.logInfo(`Export ${report.Name} (${exportDestination}) cancelled by preProcessExport()`);
+                cleanupExportProcess();
+                return;
+            }
+            else if (preProcessedExport === true) {
+                this.api.logInfo(`Export ${report.Name} (${exportDestination}) using data from the grid`);
+                reportData = this.api.internalApi.getReportService().getReportData(report);
+            }
+            else if ((preProcessedExport === null || preProcessedExport === void 0 ? void 0 : preProcessedExport.rows) == undefined ||
+                (preProcessedExport === null || preProcessedExport === void 0 ? void 0 : preProcessedExport.columns) == undefined) {
+                this.api.logWarn(`Export ${report.Name} (${exportDestination}) : preProcessExport() returned an invalid ReportData object, fallback to data from the grid`);
+                reportData = this.api.internalApi.getReportService().getReportData(report);
+            }
+            else {
+                this.api.logInfo(`Export ${report.Name} (${exportDestination}) using data from preProcessExport()`);
+                reportData = preProcessedExport;
+            }
             if (this.isCustomDestination(exportDestination)) {
                 const customDestination = (_a = this.api.optionsApi
                     .getAdaptableOptions()
@@ -90,7 +125,8 @@ class ExportModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                             return new Promise((resolve) => {
                                 setTimeout(() => {
                                     const preparedContext = Object.assign(Object.assign({}, context), { report,
-                                        customDestination, reportData: this.api.internalApi.getReportService().getReportData(report) });
+                                        customDestination,
+                                        reportData });
                                     resolve(preparedContext);
                                 }, 20);
                             });
@@ -100,7 +136,7 @@ class ExportModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                 else if (customDestination) {
                     const reportContext = {
                         report: report,
-                        reportData: this.api.internalApi.getReportService().getReportData(report),
+                        reportData,
                         adaptableApi: this.api,
                     };
                     customDestination.onExport(reportContext);
@@ -109,33 +145,49 @@ class ExportModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             else {
                 switch (exportDestination) {
                     case Enums_1.ExportDestination.Excel:
-                        if (report.Name === GeneralConstants_1.VISUAL_DATA_REPORT) {
-                            // WYSIWYG is fully delegated to the AG Grid excel export
-                            this.api.exportApi.exportVisualDataToExcel();
-                        }
-                        else {
-                            this.convertReportToExcel(report);
-                        }
+                        this.convertReportToExcel(report, reportData);
                         break;
                     case Enums_1.ExportDestination.Clipboard:
-                        this.copyToClipboard(report);
+                        this.copyToClipboard(report, reportData);
                         break;
                     case Enums_1.ExportDestination.CSV:
-                        this.convertReportToCsv(report);
+                        this.convertReportToCsv(report, reportData);
                         break;
                     case Enums_1.ExportDestination.JSON:
-                        this.convertReportToJSON(report);
+                        this.convertReportToJSON(report, reportData);
                         break;
                     case Enums_1.ExportDestination.Table:
-                        this.openReportInTablePopup(report);
+                        this.openReportInTablePopup(report, reportData);
                         break;
                 }
             }
-            this.api.internalApi.dispatchReduxAction((0, SystemRedux_1.SystemVisualExportEnd)());
-            this.api.internalApi.hideProgressIndicator();
-        }, () => {
-            this.api.internalApi.dispatchReduxAction((0, SystemRedux_1.SystemVisualExportEnd)());
-        });
+            cleanupExportProcess();
+        }
+        catch (e) {
+            this.api.consoleError(`Error while exporting ${report.Name}}`, e);
+            cleanupExportProcess();
+        }
+    }
+    async preProcessExport(report) {
+        const preProcessExportFn = this.api.optionsApi.getAdaptableOptions().exportOptions.preProcessExport;
+        if (preProcessExportFn) {
+            this.api.logInfo(`Export ${report.Name} : preProcessExport()`);
+            return preProcessExportFn({
+                report,
+                adaptableApi: this.api,
+                getReportColumns: (includePrimaryKey) => {
+                    return this.api.internalApi
+                        .getReportService()
+                        .getReportDataColumns(report, includePrimaryKey);
+                },
+                getReportRowData: (reportColumns, includePrimaryKey) => {
+                    return this.api.internalApi
+                        .getReportService()
+                        .getReportDataRows(report, reportColumns, includePrimaryKey);
+                },
+            });
+        }
+        return true;
     }
     isCustomDestination(exportDestination) {
         if (Object.values(Enums_1.ExportDestination).some((val) => val === exportDestination)) {
@@ -143,8 +195,7 @@ class ExportModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         }
         return this.api.exportApi.isExportDestinationCustom(exportDestination);
     }
-    convertReportToJSON(report) {
-        const reportData = this.api.internalApi.getReportService().getReportData(report);
+    convertReportToJSON(report, reportData) {
         if (this.isEmptyReportData(reportData)) {
             this.showEmptyExportWarning();
             return;
@@ -153,8 +204,7 @@ class ExportModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         const jsonFileName = this.api.internalApi.getReportService().getReportFileName(report.Name) + '.json';
         Helper_1.Helper.createDownloadedFile(jsonContent, jsonFileName, 'application/json');
     }
-    openReportInTablePopup(report) {
-        const reportData = this.api.internalApi.getReportService().getReportData(report, true);
+    openReportInTablePopup(report, reportData) {
         if (this.isEmptyReportData(reportData)) {
             this.showEmptyExportWarning();
             return;
@@ -191,7 +241,7 @@ class ExportModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             popupProps,
         });
     }
-    convertReportToCsv(report) {
+    convertReportToCsv(report, reportData) {
         const csvContent = this.createCSVContent(report);
         if (StringExtensions_1.default.IsNullOrEmpty(csvContent)) {
             this.showEmptyExportWarning();
@@ -200,15 +250,14 @@ class ExportModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         const csvFileName = this.api.internalApi.getReportService().getReportFileName(report.Name) + '.csv';
         Helper_1.Helper.createDownloadedFile(csvContent, csvFileName, 'text/csv;encoding:utf-8');
     }
-    convertReportToExcel(report) {
-        const reportData = this.api.internalApi.getReportService().getReportData(report);
+    convertReportToExcel(report, reportData) {
         if (this.isEmptyReportData(reportData)) {
             this.showEmptyExportWarning();
             return;
         }
         this.api.exportApi.exportDataToExcel(reportData, this.api.internalApi.getReportService().getReportFileName(report.Name));
     }
-    copyToClipboard(report) {
+    copyToClipboard(report, reportData) {
         const csvContent = this.createTabularContent(report);
         if (StringExtensions_1.default.IsNullOrEmpty(csvContent)) {
             this.showEmptyExportWarning();

package/src/Utilities/Services/Interface/IReportService.d.ts

@@ -1,5 +1,5 @@
 import { Report, ReportData, SystemReportName } from '../../../PredefinedConfig/ExportState';
-import { AdaptableColumn } from '../../../PredefinedConfig/Common/AdaptableColumn';
+import { AdaptableColumn, AdaptableColumnBase } from '../../../PredefinedConfig/Common/AdaptableColumn';
 import { IAdaptableService } from './IAdaptableService';
 import { ExcelStyle, IRowNode } from '@ag-grid-community/core';
 import { SystemExportDestination } from '../../../types';
@@ -17,10 +17,12 @@ export interface IReportService extends IAdaptableService {
     GetReportColumnScopeShortDescription(report: Report): string[];
     GetReportColumnScopeLongDescription(report: Report): string;
     GetReportExpressionDescription(Report: Report, cols: AdaptableColumn[]): string;
-    GetReportColumnsForReport(report: Report): AdaptableColumn[];
     PublishLiveLiveDataChangedEvent(reportDestination: 'OpenFin' | 'ipushpull' | 'Glue42', liveDataChangedTrigger: 'Connected' | 'Disconnected' | 'SnapshotSent' | 'LiveDataStarted' | 'LiveDataStopped' | 'LiveDataUpdated', liveReport?: any): void;
+    getReportDataColumns(report: Report, includePrimaryKey?: boolean): AdaptableColumnBase[];
+    getReportDataRows(report: Report, columns: AdaptableColumnBase[], includePrimaryKey?: boolean): Record<string, any>[];
     getReportData(report: Report, includePrimaryKey?: boolean): ReportData;
     getReportDataAsArray(report: Report, includePrimaryKey?: boolean): any[][];
+    getReportDataColumns(report: Report, includePrimaryKey?: boolean): AdaptableColumnBase[];
     convertReportDataToArray(reportData: ReportData): any[][];
     getCellExportValueFromRowNode(rowNode: IRowNode, columnId: string): any;
     getCellExportValueFromRawValue(rowNode: IRowNode, rawValue: any, columnId: string): any;

package/src/Utilities/Services/ReportService.d.ts

@@ -1,4 +1,4 @@
-import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { AdaptableColumn, AdaptableColumnBase } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { Report, ReportData, SystemReportName } from '../../PredefinedConfig/ExportState';
 import { IReportService } from './Interface/IReportService';
 import { ExcelStyle, IRowNode } from '@ag-grid-community/core';
@@ -23,7 +23,8 @@ export declare class ReportService implements IReportService {
     GetReportColumnScopeShortDescription(report: Report): string[];
     GetReportColumnScopeLongDescription(report: Report): string;
     GetReportExpressionDescription(report: Report, cols: AdaptableColumn[]): string;
-    GetReportColumnsForReport(report: Report, includePrimaryKey?: boolean): AdaptableColumn[];
+    getReportDataColumns(report: Report, includePrimaryKey?: boolean): AdaptableColumnBase[];
+    getReportDataRows(report: Report, columns: AdaptableColumnBase[], includePrimaryKey?: boolean): Record<string, any>[];
     getReportData(report: Report, includePrimaryKey?: boolean): ReportData;
     getReportDataAsArray(report: Report, includePrimaryKey?: boolean): any[][];
     convertReportDataToArray(reportData: ReportData): any[][];

package/src/Utilities/Services/ReportService.js

@@ -186,7 +186,7 @@ class ReportService {
             }
         }
     }
-    GetReportColumnsForReport(report, includePrimaryKey = false) {
+    getReportDataColumns(report, includePrimaryKey = false) {
         let reportColumns = [];
         let gridColumns = this.adaptableApi.columnApi.getExportableColumns();
         if (this.adaptableApi.exportApi.isServerReport(report)) {
@@ -224,38 +224,28 @@ class ReportService {
                 reportColumns.push(this.adaptableApi.columnApi.getPrimaryKeyColumn());
             }
         }
-        return reportColumns;
-    }
-    getReportData(report, includePrimaryKey = false) {
-        var _a, _b;
-        const columns = this.GetReportColumnsForReport(report, includePrimaryKey).map((column) => ({
+        return reportColumns.map((column) => ({
             columnId: column.columnId,
             friendlyName: column.friendlyName,
             dataType: column.dataType,
         }));
-        if (this.adaptableApi.exportApi.isServerReport(report)) {
-            return this.adaptableApi.exportApi.runServerReport(report.Name);
-        }
+    }
+    getReportDataRows(report, columns, includePrimaryKey) {
+        var _a, _b;
         if (ArrayExtensions_1.default.IsNullOrEmpty(columns)) {
-            return { columns: [], rows: [] };
+            return [];
         }
-        const data = { columns, rows: [] };
         const columnIds = columns.map((column) => column.columnId);
+        const resultRowData = [];
         switch (report.ReportRowScope) {
             case 'AllRows':
                 this.adaptableApi.internalApi.forAllRowNodesDo((rowNode) => {
-                    // skip row groups
-                    if (!rowNode.group) {
-                        data.rows.push(this.getRowObjectForColumnIds(rowNode, columnIds));
-                    }
+                    resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
                 });
                 break;
             case 'VisibleRows':
                 this.adaptableApi.internalApi.forAllVisibleRowNodesDo((rowNode) => {
-                    // skip row groups
-                    if (!rowNode.group) {
-                        data.rows.push(this.getRowObjectForColumnIds(rowNode, columnIds));
-                    }
+                    resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
                 });
                 break;
             case 'ExpressionRows':
@@ -264,7 +254,7 @@ class ReportService {
                     if (this.adaptableApi.internalApi
                         .getQueryLanguageService()
                         .evaluateBooleanExpression((_a = report.Query) === null || _a === void 0 ? void 0 : _a.BooleanExpression, ModuleConstants_1.ExportModuleId, rowNode)) {
-                        data.rows.push(this.getRowObjectForColumnIds(rowNode, columnIds));
+                        resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
                     }
                 });
                 break;
@@ -283,7 +273,7 @@ class ReportService {
                         if (includePrimaryKey) {
                             row[this.adaptableApi.optionsApi.getPrimaryKey()] = rowPrimaryKeyValue;
                         }
-                        data.rows.push(row);
+                        resultRowData.push(row);
                     }
                 });
                 break;
@@ -294,13 +284,21 @@ class ReportService {
                     this.adaptableApi.internalApi.forAllRowNodesDo((rowNode) => {
                         const rowPrimaryKeyValue = this.adaptableApi.gridApi.getPrimaryKeyValueForRowNode(rowNode);
                         if (selectedGridRowPrimaryKeys.includes(rowPrimaryKeyValue)) {
-                            data.rows.push(this.getRowObjectForColumnIds(rowNode, columnIds));
+                            resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
                         }
                     });
                 }
                 break;
         }
-        return data;
+        return resultRowData;
+    }
+    getReportData(report, includePrimaryKey = false) {
+        if (this.adaptableApi.exportApi.isServerReport(report)) {
+            return this.adaptableApi.exportApi.runServerReport(report.Name);
+        }
+        const columns = this.getReportDataColumns(report, includePrimaryKey);
+        const rows = this.getReportDataRows(report, columns, includePrimaryKey);
+        return { columns, rows };
     }
     getReportDataAsArray(report, includePrimaryKey = false) {
         const reportData = this.getReportData(report, includePrimaryKey);

package/src/Utilities/waitForTimeout.d.ts

@@ -0,0 +1 @@
+export declare function waitForTimeout(ms: number): Promise<void>;

package/src/Utilities/waitForTimeout.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForTimeout = void 0;
+// waits for the given ms milliseconds
+function waitForTimeout(ms) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, ms);
+    });
+}
+exports.waitForTimeout = waitForTimeout;

package/src/View/Export/ExportTablePopup.js

@@ -15,18 +15,17 @@ const tableDOMProps = {
 const ExportTablePopup = (props) => {
     const adaptable = (0, AdaptableContext_1.useAdaptable)();
     const adaptableApi = adaptable.api;
-    const primaryKey = adaptableApi.optionsApi.getPrimaryKey();
+    const primaryKey = '_rowIndex';
     const { reportData, } = props.popupProps;
-    const data = reportData.rows;
+    const data = reportData.rows.map((row, index) => (Object.assign(Object.assign({}, row), { [primaryKey]: index + 1 })));
     const columns = React.useMemo(() => {
-        const getFriendlyName = (columnId) => adaptableApi.columnApi.getFriendlyNameForColumnId(columnId);
         const columns = {
-            [primaryKey]: { field: primaryKey, header: getFriendlyName(primaryKey) },
+            [primaryKey]: { field: primaryKey, header: 'Index' },
         };
         for (let column of reportData.columns) {
             columns[column.columnId] = {
                 field: column.columnId,
-                header: getFriendlyName(column.columnId),
+                header: column.friendlyName,
                 dataType: column.dataType,
             };
             if (column.dataType === 'Date') {
@@ -49,6 +48,9 @@ const ExportTablePopup = (props) => {
         }
         return columns;
     }, [props.popupProps]);
+    const columnOrder = React.useMemo(() => {
+        return Object.keys(columns);
+    }, [columns]);
     return (React.createElement(InfiniteTable_1.DataSource, { data: data, primaryKey: primaryKey },
         React.createElement(InfiniteTable_1.InfiniteTable, { columnTypes: {
                 default: {

package/src/agGrid/Adaptable.d.ts

@@ -223,8 +223,14 @@ export declare class Adaptable implements IAdaptable {
         includeGroupRows?: boolean;
         filterFn?: (rowNode: IRowNode) => boolean;
     }): void;
-    forAllVisibleRowNodesDo(func: (rowNode: IRowNode, rowIndex: number) => void): void;
-    getVisibleRowNodes(): IRowNode[];
+    forAllVisibleRowNodesDo(func: (rowNode: IRowNode, rowIndex: number) => void, config?: {
+        includeGroupRows?: boolean;
+        filterFn?: (rowNode: IRowNode) => boolean;
+    }): void;
+    getVisibleRowNodes(config?: {
+        includeGroupRows?: boolean;
+        filterFn?: (rowNode: IRowNode) => boolean;
+    }): IRowNode[];
     getAllRowNodes(config?: {
         includeGroupRows?: boolean;
         filterFn?: (rowNode: IRowNode) => boolean;

package/src/agGrid/Adaptable.js

@@ -2112,16 +2112,18 @@ class Adaptable {
             }
         });
     }
-    forAllVisibleRowNodesDo(func) {
+    forAllVisibleRowNodesDo(func, config) {
         this.gridOptions.api.forEachNodeAfterFilterAndSort((rowNode, rowIndex) => {
-            func(rowNode, rowIndex);
+            const includeGroupRows = (config === null || config === void 0 ? void 0 : config.includeGroupRows) || !this.isGroupRowNode(rowNode);
+            const filterFnFulfilled = !(config === null || config === void 0 ? void 0 : config.filterFn) || (config === null || config === void 0 ? void 0 : config.filterFn(rowNode));
+            if (includeGroupRows && filterFnFulfilled) {
+                func(rowNode, rowIndex);
+            }
         });
     }
-    getVisibleRowNodes() {
+    getVisibleRowNodes(config) {
         let rowNodes = [];
-        this.gridOptions.api.forEachNodeAfterFilterAndSort((rowNode, rowIndex) => {
-            rowNodes.push(rowNode);
-        });
+        this.forAllVisibleRowNodesDo((rowNode) => rowNodes.push(rowNode), config);
         return rowNodes;
     }
     getAllRowNodes(config) {
@@ -4584,6 +4586,7 @@ import "@adaptabletools/adaptable/themes/${themeName}.css"`);
             const colDefs = displayedColumns.map((column) => {
                 return column.getColDef();
             });
+            const forAllVisibleRowNodesDoConfig = { includeGroupRows: true };
             this.forAllVisibleRowNodesDo((node, rowIndex) => {
                 const rowParams = {
                     node,
@@ -4684,7 +4687,7 @@ import "@adaptabletools/adaptable/themes/${themeName}.css"`);
                         .getReportService()
                         .registerExcelStyle(finalCellExcelStyle, cellClassId);
                 });
-            });
+            }, forAllVisibleRowNodesDoConfig);
             return this.api.internalApi.getReportService().getRegisteredExcelStyles();
         });
     }

package/src/components/ProgressIndicator/ProgressIndicator.js

@@ -40,7 +40,7 @@ const ProgressIndicator = () => {
         disableAdaptableGrid(adaptable.getAdaptableContainerElement(), active);
         disableAdaptableGrid(adaptable.getAgGridContainerElement(), active);
         updateGridContainerCoordinates(adaptable.getAdaptableContainerElement());
-        // without RAF the progress indicator would be rendered instantly, without the 'transition-delay' defined via CSS
+        // without rAF the progress indicator would be rendered instantly, without the 'transition-delay' defined via CSS
         requestAnimationFrame(() => {
             setVisible(active);
         });