@adaptabletools/adaptable-cjs 20.0.0-canary.7 → 20.0.0-canary.9

package/package.json

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

package/src/AdaptableOptions/ExportOptions.d.ts

@@ -1,6 +1,6 @@
 import { AdaptableForm } from '../PredefinedConfig/Common/AdaptableForm';
 import { FormContext } from '../PredefinedConfig/Common/FormContext';
-import { Report, ReportData, ReportFormatType, ReportNameType, SystemReportFormat, SystemReportName } from '../PredefinedConfig/ExportState';
+import { Report, ReportColumn, ReportData, ReportFormatType, ReportNameType, SystemReportFormat, SystemReportName } from '../PredefinedConfig/ExportState';
 import { AdaptableColumn, BaseContext, AdaptableColumnContext } from '../types';
 import { TypeHint } from '../PredefinedConfig/Common/Types';
 import { CsvCell, ExcelCell, ExcelDataType, ExcelRow, IRowNode } from 'ag-grid-enterprise';
@@ -164,7 +164,7 @@ export interface ExternalReport {
     /**
      * Function invoked to return the data (in the form of a `ExportResultData` object)
      */
-    onExport: (context: BaseExportContext) => Promise<ExportResultData>;
+    onExport: (context: ExternalReportContext) => Promise<ExportResultData>;
 }
 /**
  * Defines a custom Export destination
@@ -257,6 +257,11 @@ export interface ReportContext extends BaseExportContext {
      */
     reportData: ExportResultData;
 }
+export interface ExternalReportContext extends BaseExportContext {
+    getGridReportColumns: () => ReportColumn[];
+    convertToExcel: (reportData: ReportData) => Blob;
+    convertToCsv: (reportData: ReportData) => string;
+}
 /**
  * Context used for providing a custom filename for a Report
  */

package/src/Api/Internal/AdaptableInternalApi.js

@@ -191,7 +191,7 @@ class AdaptableInternalApi extends ApiBase_1.ApiBase {
         if (firstRowNode == undefined) {
             return {};
         }
-        const firstRowData = { ...firstRowNode?.data } ?? {};
+        const firstRowData = firstRowNode?.data ? { ...firstRowNode?.data } : {};
         // handle CalcCols which are not persisted in the rowModel
         this.getCalculatedColumnApi()
             .getCalculatedColumns()

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

@@ -1,7 +1,7 @@
 import { ApiBase } from '../Implementation/ApiBase';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { Report, ReportData, ReportFormatType, ReportNameType, SystemReportName } from '../../PredefinedConfig/ExportState';
-import { IRowNode } from 'ag-grid-enterprise';
+import { CsvCell, ExcelCell, ExcelDataType, IRowNode } from 'ag-grid-enterprise';
 import { AdaptableColumn, AdaptableColumnDataType } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { BaseExportContext, DataFormatType, ExportDestinationType, ExportResultData } from '../../AdaptableOptions/ExportOptions';
 export declare class ExportInternalApi extends ApiBase {
@@ -31,5 +31,13 @@ export declare class ExportInternalApi extends ApiBase {
     sendReportToDestination(reportResult: ExportResultData, report: Report, format: ReportFormatType, destination: ExportDestinationType): void;
     private sendReportToCustomDestination;
     buildBaseExportContext(reportName: ReportNameType, reportFormat: ReportFormatType, exportDestination?: ExportDestinationType): BaseExportContext;
+    createCellCsv(cellContent: any): CsvCell;
+    createCellExcel(cellContent: any, cellType: ExcelDataType): ExcelCell;
+    createCellHeader(cellContent: any): ExcelCell;
     getExternalReportData(externalReportName: ReportNameType, reportFormat: ReportFormatType, exportDestination: ExportDestinationType): Promise<ExportResultData | undefined>;
+    private buildGridReportColumns;
+    private buildExcelConverter;
+    private buildCsvConverter;
+    private executeGridExport;
+    private buildCsvExportParams;
 }

package/src/Api/Internal/ExportInternalApi.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExportInternalApi = void 0;
 const tslib_1 = require("tslib");
 const ApiBase_1 = require("../Implementation/ApiBase");
+const ag_grid_enterprise_1 = require("ag-grid-enterprise");
 const Uuid_1 = require("../../PredefinedConfig/Uuid");
 const GeneralConstants_1 = require("../../Utilities/Constants/GeneralConstants");
 const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
@@ -226,7 +227,7 @@ class ExportInternalApi extends ApiBase_1.ApiBase {
     convertReportDataToArray(reportData) {
         return [
             reportData.columns.map((column) => column.friendlyName),
-            ...reportData.rows.map((row) => reportData.columns.map((column) => row[column.columnId])),
+            ...reportData.rows.map((row) => reportData.columns.map((column) => row[column.field ?? column.columnId])),
         ];
     }
     publishLiveLiveDataChangedEvent(reportDestination, liveDataTrigger, liveReport) {
@@ -302,9 +303,8 @@ class ExportInternalApi extends ApiBase_1.ApiBase {
             this.sendReportToCustomDestination(reportResult, report, format, destination);
         }
         if (destination === 'Download') {
-            if (format === 'Excel' || format === 'VisualExcel') {
-                this.logWarn(`Download of Excel files should already be handed by internal APIs, something went wrong`);
-                return;
+            if (reportResult.type === 'excel') {
+                Helper_1.default.createDownloadedFile(reportResult.data, this.getReportFileName(report.Name, format, destination), 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
             }
             if (reportResult.type === 'csv') {
                 Helper_1.default.createDownloadedFile(reportResult.data, this.getReportFileName(report.Name, format, destination), 'text/csv;encoding:utf-8');
@@ -363,6 +363,29 @@ class ExportInternalApi extends ApiBase_1.ApiBase {
             exportDestination,
         };
     }
+    createCellCsv(cellContent) {
+        return {
+            data: {
+                value: cellContent != undefined ? String(cellContent) : null,
+            },
+        };
+    }
+    createCellExcel(cellContent, cellType) {
+        return {
+            data: {
+                value: cellContent != undefined ? String(cellContent) : null,
+                type: cellType,
+            },
+        };
+    }
+    createCellHeader(cellContent) {
+        return {
+            data: {
+                value: cellContent != undefined ? String(cellContent) : null,
+                type: 'String',
+            },
+        };
+    }
     getExternalReportData(externalReportName, reportFormat, exportDestination) {
         const externalReport = this.getExportApi()
             .getExternalReports()
@@ -371,7 +394,74 @@ class ExportInternalApi extends ApiBase_1.ApiBase {
             this.logWarn(`External Report '${externalReportName}' not found!`);
             return undefined;
         }
-        return externalReport.onExport(this.buildBaseExportContext(externalReportName, reportFormat, exportDestination));
+        return externalReport.onExport({
+            ...this.buildBaseExportContext(externalReportName, reportFormat, exportDestination),
+            convertToExcel: this.buildExcelConverter(externalReportName, reportFormat, exportDestination),
+            convertToCsv: this.buildCsvConverter(externalReportName, reportFormat, exportDestination),
+            getGridReportColumns: this.buildGridReportColumns(),
+        });
+    }
+    buildGridReportColumns() {
+        return () => this.getAdaptableApi().columnApi.getColumns();
+    }
+    buildExcelConverter(externalReportName, reportFormat, exportDestination) {
+        return (reportData) => {
+            return this.executeGridExport(reportData, externalReportName, reportFormat, exportDestination, (gridApi, exportParams) => gridApi.getDataAsExcel({ ...exportParams }));
+        };
+    }
+    buildCsvConverter(externalReportName, reportFormat, exportDestination) {
+        return (reportData) => {
+            const csvParams = this.buildCsvExportParams(externalReportName, reportFormat, exportDestination);
+            return this.executeGridExport(reportData, externalReportName, reportFormat, exportDestination, (gridApi, exportParams) => gridApi.getDataAsCsv({ ...exportParams, ...csvParams }));
+        };
+    }
+    executeGridExport(reportData, externalReportName, reportFormat, exportDestination, exportFn) {
+        const htmlDivElement = document.createElement('div');
+        let ephemeralGridApi = null;
+        try {
+            const columnDefs = reportData.columns.map((col) => ({
+                colId: col.columnId,
+                field: col.field ?? col.columnId,
+                headerName: col.friendlyName ?? col.columnId,
+                type: col.dataType ?? 'text',
+            }));
+            const gridOptions = { columnDefs, rowData: reportData.rows };
+            const gridParams = {
+                modules: this.getAdaptableApi()
+                    .internalApi.getAdaptableInstance()
+                    .getAgGridRegisteredModules(),
+            };
+            htmlDivElement.style.display = 'none';
+            document.body.appendChild(htmlDivElement);
+            ephemeralGridApi = (0, ag_grid_enterprise_1.createGrid)(htmlDivElement, gridOptions, gridParams);
+            const exportParams = {
+                fileName: this.getReportFileName(externalReportName, reportFormat, exportDestination),
+                allColumns: true,
+                exportedRows: 'all',
+            };
+            return exportFn(ephemeralGridApi, exportParams);
+        }
+        catch (error) {
+            this.logWarn('Failed to export data:', error);
+            return null;
+        }
+        finally {
+            if (ephemeralGridApi) {
+                ephemeralGridApi.destroy();
+            }
+            if (htmlDivElement?.parentNode) {
+                document.body.removeChild(htmlDivElement);
+            }
+        }
+    }
+    buildCsvExportParams(externalReportName, reportFormat, exportDestination) {
+        const exportOptions = this.getAdaptableApi().optionsApi.getExportOptions();
+        const csvSeparator = typeof exportOptions.csvSeparator === 'function'
+            ? exportOptions.csvSeparator(this.buildBaseExportContext(externalReportName, reportFormat, exportDestination))
+            : exportOptions.csvSeparator;
+        return {
+            columnSeparator: csvSeparator,
+        };
     }
 }
 exports.ExportInternalApi = ExportInternalApi;

package/src/PredefinedConfig/ExportState.d.ts

@@ -65,6 +65,12 @@ export interface ReportSchedule extends BaseSchedule {
      */
     ExportDestination?: ExportDestinationType;
 }
+export interface ReportColumn extends AdaptableColumnBase {
+    /**
+     * Field in the row to get cell data from; defaults to `columnId`
+     */
+    field?: string;
+}
 /**
  * Defines the data in a Report run by AdapTable
  */
@@ -76,7 +82,7 @@ export interface ReportData {
     /**
      * Columns in the Report
      */
-    columns: AdaptableColumnBase[];
+    columns: ReportColumn[];
     /**
      * Group columns IDs in the Report
      */

package/src/Redux/Store/AdaptableStore.js

@@ -667,7 +667,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     }
                     return ret;
                 }
-                case InternalRedux.HIGHLIGHT_CELL_DELETE_ALL: {
+                case InternalRedux.HIGHLIGHT_ROW_DELETE_ALL: {
                     const rowHighlightInfos = middlewareAPI.getState().Internal.RowHighlightInfo;
                     const ret = next(action);
                     rowHighlightInfos.forEach((rowHighlightInfo) => {

package/src/agGrid/AgGridExportAdapter.d.ts

@@ -1,13 +1,30 @@
 import { AdaptableAgGrid } from './AdaptableAgGrid';
 import { Report, ReportFormatType } from '../PredefinedConfig/ExportState';
-import { ExcelStyle } from 'ag-grid-enterprise';
+import { CsvExportParams, ExcelExportParams, ExcelStyle } from 'ag-grid-enterprise';
 import { ExportDestinationType, ExportResultData } from '../AdaptableOptions/ExportOptions';
+import { Layout } from '../PredefinedConfig/LayoutState';
 export interface ExportConfig {
     report: Report;
     format: ReportFormatType;
     destination: ExportDestinationType;
     showProgressIndicator: boolean;
 }
+interface ExportProcessContext extends ExportConfig {
+    exportedColumnIds: string[];
+    isExcelReport: boolean;
+    isVisualExcelReport: boolean;
+    isExportingVisibleColumnToJSON: boolean;
+    getCurrent: () => {
+        layout: Layout;
+        groupColumnIds: string[];
+        pivotColumnIds: string[];
+    };
+    isCellPartOfSelection: (rowId: string, columnId: string) => boolean;
+}
+export interface ExportProcessData {
+    exportContext: ExportProcessContext;
+    exportParams: ExcelExportParams | CsvExportParams;
+}
 export declare class AgGridExportAdapter {
     private _adaptableInstance;
     /**
@@ -27,6 +44,10 @@ export declare class AgGridExportAdapter {
     static getExcelClassNameForCell(colId: string, primaryKeyValue: any, userDefinedCellClass?: string | string[]): string;
     destroy(): void;
     exportData(config: ExportConfig): Promise<null | ExportResultData>;
+    /**
+     * Creates export context and parameters for a given export configuration
+     */
+    buildExportProcessData(config: ExportConfig): ExportProcessData;
     private buildExportParams;
     private buildBaseExportParams;
     private computeProcessRowGroupCallback;
@@ -51,3 +72,4 @@ export declare class AgGridExportAdapter {
     private computeSkipColumnHeaders;
     private computeGetCustomContentBelowRow;
 }
+export {};

package/src/agGrid/AgGridExportAdapter.js

@@ -64,14 +64,12 @@ class AgGridExportAdapter {
                 await (0, waitForTimeout_1.waitForTimeout)(16);
             }
             this.adaptableApi.exportApi.internalApi.setExportInProgress(config.report.Name, config.format, config.destination);
-            const exportContext = this.buildExportProcessContext(config);
+            const { exportContext, exportParams } = this.buildExportProcessData(config);
             if (exportContext.isVisualExcelReport) {
                 // FIXME AFL patch styles only for exported columns!
                 // or even better, only cells
                 this.patchExcelStyles();
             }
-            const exportParams = this.buildExportParams(exportContext);
-            exportContext.exportedColumnIds = exportParams.columnKeys;
             // 1. easiest case, we download the file using AG Grid
             // these methods will automatically handle the file download
             if (exportContext.destination === 'Download' && exportContext.isExcelReport) {
@@ -120,6 +118,21 @@ class AgGridExportAdapter {
             }
         }
     }
+    /**
+     * Creates export context and parameters for a given export configuration
+     */
+    buildExportProcessData(config) {
+        const exportContext = this.buildExportProcessContext(config);
+        if (exportContext.isVisualExcelReport) {
+            this.patchExcelStyles();
+        }
+        const exportParams = this.buildExportParams(exportContext);
+        exportContext.exportedColumnIds = exportParams.columnKeys;
+        return {
+            exportContext,
+            exportParams,
+        };
+    }
     buildExportParams(exportContext) {
         const baseExportParams = this.buildBaseExportParams(exportContext);
         if (exportContext.format === 'Excel' || exportContext.format === 'VisualExcel') {
@@ -658,9 +671,9 @@ class AgGridExportAdapter {
             .map((columnId) => this.adaptableApi.columnApi.getColumnWithColumnId(columnId))
             .map((column) => ({
             columnId: column.columnId,
+            field: column.field ?? column.columnId,
             friendlyName: column.friendlyName,
             dataType: column.dataType,
-            field: column.field ?? column.columnId,
         }));
         const reportData = {
             columns,
@@ -732,27 +745,11 @@ class AgGridExportAdapter {
                 masterRowNode: node,
                 masterRowData: node?.data,
                 isExpanded: node.expanded,
-                createCellCsv: (cellContent) => {
-                    return {
-                        data: {
-                            value: cellContent != undefined ? String(cellContent) : null,
-                        },
-                    };
-                },
-                createCellExcel: (cellContent, cellType) => {
-                    return {
-                        data: {
-                            value: cellContent != undefined ? String(cellContent) : null,
-                            type: cellType,
-                        },
-                    };
-                },
+                createCellCsv: (cellContent) => this.adaptableApi.exportApi.internalApi.createCellCsv(cellContent),
+                createCellExcel: (cellContent, cellType) => this.adaptableApi.exportApi.internalApi.createCellExcel(cellContent, cellType),
                 createCellHeader: (cellContent) => {
                     return {
-                        data: {
-                            value: cellContent != undefined ? String(cellContent) : null,
-                            type: 'String',
-                        },
+                        ...this.adaptableApi.exportApi.internalApi.createCellHeader(cellContent),
                         // see #masterDetailHeader
                         styleId: '_masterDetailHeader',
                     };

package/src/agGrid/cellRenderers/BadgeRenderer.js

@@ -39,7 +39,8 @@ const getBadgeRendererForColumn = (badgeStyle, abColumn, api) => {
                 this.eGui.innerHTML = formattedValue;
                 return;
             }
-            if (['NumberArray', 'StringArray'].includes(abColumn.dataType)) {
+            const arrayTypes = ['numberArray', 'textArray'];
+            if (arrayTypes.includes(abColumn.dataType)) {
                 this.renderArrayValues(params, adaptableApi);
             }
             else {

package/src/env.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     NEXT_PUBLIC_INFINITE_TABLE_LICENSE_KEY: "StartDate=2021-06-29|EndDate=2030-01-01|Owner=Adaptable|Type=distribution|TS=1624971462479|C=137829811,1004007071,2756196225,1839832928,3994409405,636616862" || '',
-    PUBLISH_TIMESTAMP: 1741274250893 || Date.now(),
-    VERSION: "20.0.0-canary.7" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1741700578376 || Date.now(),
+    VERSION: "20.0.0-canary.9" || '--current-version--',
 };

package/src/migration/VersionUpgrade20.js

@@ -35,6 +35,37 @@ function transition_pre_20(layout) {
             layout.PivotAggregationColumns = layout.TableAggregationColumns;
         }
     }
+    if (l.ColumnFilters) {
+        layout.ColumnFilters = l.ColumnFilters.map((columnFilter) => {
+            const filter = {
+                ...columnFilter,
+            };
+            // version 19 had a single predicate
+            // while version 20 has an array of predicates
+            // @ts-ignore
+            if (filter.Predicate) {
+                // @ts-ignore
+                delete filter.Predicate;
+                // @ts-ignore
+                filter.Predicates = [filter.Predicate];
+            }
+            filter.Predicates = filter.Predicates.map((p) => {
+                // the following predicate ids were renamed:
+                // Values -> In
+                if (p.PredicateId === 'Values') {
+                    p = { ...p };
+                    p.PredicateId = 'In';
+                }
+                // ExcludeValues -> NotIn
+                if (p.PredicateId === 'ExcludeValues') {
+                    p = { ...p };
+                    p.PredicateId = 'NotIn';
+                }
+                return p;
+            });
+            return filter;
+        });
+    }
     return layout;
 }
 function hasUpToDateDataType(dataType) {

package/src/types.d.ts

@@ -185,7 +185,7 @@ export type { AdaptableModule, AdaptableToolPanel, AdaptableQLModule, AdaptableS
 export type { ChartDefinition, ChartingState, ChartingAggFunc, } from './PredefinedConfig/ChartingState';
 export type { CustomSort, CustomSortState } from './PredefinedConfig/CustomSortState';
 export type { DashboardState, DashboardTab, AdaptableCoordinate, } from './PredefinedConfig/DashboardState';
-export type { ExportState, Report, ReportData, ReportSchedule, SystemReportName, SystemReportNames, SystemReportFormat, ReportRowScope, ReportColumnScope, ReportNameType, ReportFormatType, } from './PredefinedConfig/ExportState';
+export type { ExportState, Report, ReportData, ReportColumn, ReportSchedule, SystemReportName, SystemReportNames, SystemReportFormat, ReportRowScope, ReportColumnScope, ReportNameType, ReportFormatType, } from './PredefinedConfig/ExportState';
 export type { ColumnFilter, ColumnFilterPredicate, SystemFilterPredicateIds, SystemFilterPredicateId, } from './PredefinedConfig/Common/ColumnFilter';
 export type { GridFilter } from './PredefinedConfig/Common/GridFilter';
 export type { FormatColumn, FormatColumnState, FormatColumnRule, FormatColumnPredicate, SystemFormatColumnPredicateId, SystemFormatColumnPredicateIds, } from './PredefinedConfig/FormatColumnState';