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

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,32 @@ class ReportService {
                 reportColumns.push(this.adaptableApi.columnApi.getPrimaryKeyColumn());
             }
         }
-        return reportColumns;
+        return reportColumns.map((column) => {
+            var _a;
+            return ({
+                columnId: column.columnId,
+                friendlyName: column.friendlyName,
+                dataType: column.dataType,
+                field: (_a = column.field) !== null && _a !== void 0 ? _a : column.columnId,
+            });
+        });
     }
-    getReportData(report, includePrimaryKey = false) {
+    getReportDataRows(report, columns, includePrimaryKey) {
         var _a, _b;
-        const columns = this.GetReportColumnsForReport(report, includePrimaryKey).map((column) => ({
-            columnId: column.columnId,
-            friendlyName: column.friendlyName,
-            dataType: column.dataType,
-        }));
-        if (this.adaptableApi.exportApi.isServerReport(report)) {
-            return this.adaptableApi.exportApi.runServerReport(report.Name);
-        }
         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 +258,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 +277,7 @@ class ReportService {
                         if (includePrimaryKey) {
                             row[this.adaptableApi.optionsApi.getPrimaryKey()] = rowPrimaryKeyValue;
                         }
-                        data.rows.push(row);
+                        resultRowData.push(row);
                     }
                 });
                 break;
@@ -294,13 +288,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

@@ -219,12 +219,18 @@ export declare class Adaptable implements IAdaptable {
     getRowNodeForPrimaryKey(primaryKeyValue: any): any;
     getRowNodeByIndex(index: number): IRowNode;
     getRowNodesForPrimaryKeys(primaryKeyValues: any[]): any[];
-    forAllRowNodesDo(func: (rowNode: IRowNode) => void, config?: {
+    forAllRowNodesDo(func: (rowNode: IRowNode, rowIndex: number) => void, config?: {
         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;
@@ -392,7 +398,7 @@ export declare class Adaptable implements IAdaptable {
     showChart(chartDefinition: ChartDefinition, container?: HTMLElement): ChartRef;
     getChartRef(chartId: string): ChartRef;
     getChartModels(): import("@ag-grid-community/core").ChartModel[];
-    getRowModel(): import("@ag-grid-community/core").RowModelType;
+    getRowModelType(): import("@ag-grid-community/core").RowModelType;
     private getActiveAdaptableAggFuncForCol;
     private registerAdaptableAggFuncs;
     /**

package/src/agGrid/Adaptable.js

@@ -2104,24 +2104,32 @@ class Adaptable {
         return rowNodes;
     }
     forAllRowNodesDo(func, config) {
-        this.gridOptions.api.forEachNode((rowNode) => {
+        this.gridOptions.api.forEachNode((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);
+                func(rowNode, rowIndex);
             }
         });
     }
-    forAllVisibleRowNodesDo(func) {
+    forAllVisibleRowNodesDo(func, config) {
+        if (this.getRowModelType() !== 'clientSide') {
+            // only in client-side row model can we loop through filtered&sorted rows
+            // see https://www.ag-grid.com/javascript-data-grid/accessing-data/#iterating-rows
+            this.logger.warn('`forAllVisibleRowNodesDo()` is only supported in client-side row model. `forAllRowNodesDo` will be used instead.');
+            return this.forAllRowNodesDo(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 +4592,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 +4693,7 @@ import "@adaptabletools/adaptable/themes/${themeName}.css"`);
                         .getReportService()
                         .registerExcelStyle(finalCellExcelStyle, cellClassId);
                 });
-            });
+            }, forAllVisibleRowNodesDoConfig);
             return this.api.internalApi.getReportService().getRegisteredExcelStyles();
         });
     }
@@ -4881,7 +4890,7 @@ import "@adaptabletools/adaptable/themes/${themeName}.css"`);
         }
         return this.gridOptions.api.getChartModels();
     }
-    getRowModel() {
+    getRowModelType() {
         return this.gridOptions.rowModelType;
     }
     getActiveAdaptableAggFuncForCol(columnId) {

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);
         });

package/src/metamodel/adaptable.metamodel.d.ts

@@ -790,6 +790,30 @@ export declare const ADAPTABLE_METAMODEL: {
         kind: string;
         desc: string;
     };
+    AdaptableReportColumn: {
+        name: string;
+        kind: string;
+        desc: string;
+        props: ({
+            name: string;
+            kind: string;
+            desc: string;
+            ref?: undefined;
+            isOpt?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            desc: string;
+            ref: string;
+            isOpt?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            desc: string;
+            isOpt: boolean;
+            ref?: undefined;
+        })[];
+    };
     AdaptableRowChangedAlert: {
         name: string;
         kind: string;
@@ -3629,6 +3653,22 @@ export declare const ADAPTABLE_METAMODEL: {
             isOpt: boolean;
         }[];
     };
+    PreProcessExportContext: {
+        name: string;
+        kind: string;
+        desc: string;
+        props: ({
+            name: string;
+            kind: string;
+            desc: string;
+            ref?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            desc: string;
+            ref: string;
+        })[];
+    };
     QueryableColumnContext: {
         name: string;
         kind: string;