@adaptabletools/adaptable 20.0.13 → 20.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "20.0.13",
+  "version": "20.1.0",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",
@@ -63,7 +63,7 @@
     "uuid": "9.0.1"
   },
   "peerDependencies": {
-    "ag-grid-enterprise": ">=33.0.0"
+    "ag-grid-enterprise": ">=33.2.0"
   },
   "publishTimestamp": 0,
   "type": "module",

package/src/Api/Implementation/ExportApiImpl.js

@@ -159,8 +159,8 @@ export class ExportApiImpl extends ApiBase {
                 destination,
                 showProgressIndicator: true,
             });
-            if (destination === 'Download' &&
-                (format === 'Excel' || format === 'VisualExcel' || format === 'Csv')) {
+            if (!exportedReport) {
+                // for destination 'Download' and format 'Excel', 'VisualExcel' or 'Csv', AG Grid handles the download as well
                 return;
             }
             this.internalApi.sendReportToDestination(exportedReport, report, format, destination);

package/src/Api/Implementation/LayoutApiImpl.js

@@ -41,7 +41,7 @@ export class LayoutApiImpl extends ApiBase {
         if (isPivotLayout(layout)) {
             return [];
         }
-        return layout.TableColumns.filter((colId) => layout.ColumnVisibility?.[colId] !== false);
+        return layout.TableColumns.filter((colId) => !layout.ColumnVisibility || layout.ColumnVisibility?.[colId] !== false);
     }
     getCurrentRowGroupsColumnIds() {
         const layout = this.getCurrentLayout();

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

@@ -4,6 +4,7 @@ import { Report, ReportData, ReportFormatType, ReportNameType, SystemReportName
 import { CsvCell, ExcelCell, ExcelDataType, IRowNode } from 'ag-grid-enterprise';
 import { AdaptableColumn, AdaptableColumnDataType } from '../../AdaptableState/Common/AdaptableColumn';
 import { BaseExportContext, DataFormatType, ExportDestinationType, ExportResultData, ProcessExportContext } from '../../AdaptableOptions/ExportOptions';
+import { ExportProcessData } from '../../agGrid/AgGridExportAdapter';
 export declare class ExportInternalApi extends ApiBase {
     /**
      * Value Items for Report Name Selection
@@ -35,6 +36,7 @@ export declare class ExportInternalApi extends ApiBase {
     createCellExcel(cellContent: any, cellType: ExcelDataType): ExcelCell;
     createCellHeader(cellContent: any): ExcelCell;
     buildProcessExportContext(report: Report, format: ReportFormatType, destination: ExportDestinationType): ProcessExportContext;
+    exportAllDataInPivotMode(exportProcessData: ExportProcessData): ExportResultData | null;
     private buildExcelConverter;
     private buildCsvConverter;
     private executeGridExport;

package/src/Api/Internal/ExportInternalApi.js

@@ -387,6 +387,42 @@ export class ExportInternalApi extends ApiBase {
                 .filter(Boolean),
         };
     }
+    exportAllDataInPivotMode(exportProcessData) {
+        const { exportContext, exportParams } = exportProcessData;
+        const exportedColumns = this.getColumnApi()
+            .getExportableColumns()
+            .filter((column) => !column.isGeneratedPivotResultColumn);
+        const exportedRowData = this.getGridApi().getGridData();
+        const reportData = {
+            columns: exportedColumns,
+            rows: exportedRowData,
+        };
+        const exportFormat = exportContext.format;
+        if (exportFormat === 'JSON') {
+            return {
+                data: reportData,
+                type: 'json',
+            };
+        }
+        if (exportFormat === 'CSV') {
+            const csvExportConverter = this.buildCsvConverter(exportContext.report.Name, exportFormat, exportContext.destination);
+            const csvData = csvExportConverter(reportData);
+            return {
+                data: csvData,
+                type: 'csv',
+            };
+        }
+        // theoretically 'VisualExcel' is not a valid export format for this function and should be suppressed from UI
+        // but just in case, we handle it here and return a "raw", unstyled Excel file
+        if (exportFormat === 'Excel' || exportFormat === 'VisualExcel') {
+            const excelExportConverter = this.buildExcelConverter(exportContext.report.Name, exportFormat, exportContext.destination);
+            const excelData = excelExportConverter(reportData);
+            return {
+                data: excelData,
+                type: 'excel',
+            };
+        }
+    }
     buildExcelConverter(reportName, reportFormat, exportDestination) {
         return (reportData) => {
             return this.executeGridExport(reportData, reportName, reportFormat, exportDestination, (gridApi, exportParams) => gridApi.getDataAsExcel({ ...exportParams }));
@@ -413,6 +449,7 @@ export class ExportInternalApi extends ApiBase {
                 rowData: reportData.rows,
                 theme: this.getAgGridApi().getGridOption('theme'),
                 dataTypeDefinitions: this.getAgGridApi().getGridOption('dataTypeDefinitions'),
+                columnTypes: this.getAgGridApi().getGridOption('columnTypes'),
             };
             const gridParams = {
                 modules: this.getAdaptableApi()

package/src/View/Export/ReportFormatSelector.js

@@ -16,7 +16,5 @@ export const ReportFormatSelector = (props) => {
     });
     const elementType = props.viewType === 'Toolbar' ? 'DashboardToolbar' : 'ToolPanel';
     return (React.createElement(Flex, { "data-name": "report-format-selector", flex: 1, minWidth: 140 },
-        React.createElement(Select, { 
-            // style={{ width: '100%' }}
-            size: size, placeholder: SELECT_REPORT_FORMAT_STRING, disabled: !allFormats.length || reportName == undefined, className: `ab-${elementType}__Export__format-select`, options: formatItems, onChange: (format) => onReportFormatSelected(format), value: reportFormat, isClearable: true })));
+        React.createElement(Select, { style: { width: '100%' }, size: size, placeholder: SELECT_REPORT_FORMAT_STRING, disabled: !allFormats.length || reportName == undefined, className: `ab-${elementType}__Export__format-select`, options: formatItems, onChange: (format) => onReportFormatSelected(format), value: reportFormat, isClearable: true })));
 };

package/src/View/Export/ReportNameSelector.js

@@ -15,6 +15,6 @@ export const ReportNameSelector = (props) => {
         };
     });
     const elementType = props.viewType === 'Toolbar' ? 'DashboardToolbar' : 'ToolPanel';
-    return (React.createElement(Flex, { flex: 1, minWidth: props.viewType !== 'StatusBar' ? 160 : undefined },
+    return (React.createElement(Flex, { "data-name": "report-name-selector", flex: 1, minWidth: 160 },
         React.createElement(Select, { style: { width: '100%' }, size: size, "data-name": "report-name-selector", placeholder: SELECT_REPORT_STRING, disabled: !allReportNames.length, className: `ab-${elementType}__Export__report-select`, options: reportItems, onChange: (report) => onReportNameSelected(report), value: reportName, isClearable: true })));
 };

package/src/View/StyledColumn/Wizard/StyledColumnSparklineSettingsSection.js

@@ -232,54 +232,56 @@ const SparklineAxisOptions = ({ options, onChange, }) => {
 };
 const SparklineTooltipOptions = ({ options, onChange, }) => {
     const sparklineOptions = options;
-    const handleChange = (key, value) => {
-        onChange({ ...options, [key]: value });
+    const isTooltipEnabled = sparklineOptions.tooltip?.enabled ?? false;
+    const handleChange = (property, value) => {
+        onChange({
+            ...options,
+            tooltip: {
+                ...options.tooltip,
+                [property]: value,
+            },
+        });
     };
-    const isTooltipEnabled = sparklineOptions.tooltip?.enabled;
-    const positionTypes = [
+    const anchorToOptions = [
         { value: 'pointer', label: 'Pointer' },
         { value: 'node', label: 'Node' },
+        { value: 'chart', label: 'Chart' },
+    ];
+    const placementOptions = [
         { value: 'top', label: 'Top' },
         { value: 'right', label: 'Right' },
         { value: 'bottom', label: 'Bottom' },
         { value: 'left', label: 'Left' },
-        { value: 'top-left', label: 'Top Left' },
         { value: 'top-right', label: 'Top Right' },
         { value: 'bottom-right', label: 'Bottom Right' },
         { value: 'bottom-left', label: 'Bottom Left' },
-    ];
-    const interactionRanges = [
-        { value: 'exact', label: 'Exact' },
-        { value: 'nearest', label: 'Nearest' },
+        { value: 'top-left', label: 'Top Left' },
+        { value: 'center', label: 'Center' },
     ];
     return (React.createElement(FormLayout, null,
-        React.createElement(FormRow, { label: "Enabled" },
-            React.createElement(CheckBox, { checked: sparklineOptions.tooltip?.enabled, onChange: (enabled) => handleChange('tooltip', { ...sparklineOptions.tooltip, enabled }) })),
-        React.createElement(FormRow, { label: "Show Arrow" },
-            React.createElement(CheckBox, { disabled: !isTooltipEnabled, checked: sparklineOptions.tooltip?.showArrow, onChange: (showArrow) => handleChange('tooltip', { ...sparklineOptions.tooltip, showArrow }) })),
-        React.createElement(FormRow, { label: "Interaction Enabled" },
-            React.createElement(CheckBox, { disabled: !isTooltipEnabled, checked: sparklineOptions.tooltip?.interaction?.enabled, onChange: (enabled) => handleChange('tooltip', {
-                    ...sparklineOptions.tooltip,
-                    interaction: { enabled },
-                }) })),
-        React.createElement(FormRow, { label: "Range" },
+        React.createElement(FormRow, { label: "Show Tooltip" },
+            React.createElement(CheckBox, { checked: isTooltipEnabled, onChange: (enabled) => handleChange('enabled', enabled) })),
+        React.createElement(FormRow, { label: "Anchor To" },
             React.createElement(Box, { maxWidth: 160 },
-                React.createElement(Select, { disabled: !isTooltipEnabled, value: sparklineOptions.tooltip?.range ?? 'nearest', onChange: (range) => handleChange('tooltip', { ...sparklineOptions.tooltip, range }), options: interactionRanges }))),
-        React.createElement(FormRow, { label: "Position Type" },
+                React.createElement(Select, { disabled: !isTooltipEnabled, value: sparklineOptions.tooltip?.position?.anchorTo, onChange: (value) => handleChange('position', {
+                        ...sparklineOptions.tooltip?.position,
+                        anchorTo: value,
+                    }), options: anchorToOptions }))),
+        React.createElement(FormRow, { label: "Placement" },
             React.createElement(Box, { maxWidth: 160 },
-                React.createElement(Select, { disabled: !isTooltipEnabled, value: sparklineOptions.tooltip?.position?.type ?? 'pointer', onChange: (type) => handleChange('tooltip', {
-                        ...sparklineOptions.tooltip,
-                        position: { ...sparklineOptions.tooltip?.position, type },
-                    }), options: positionTypes }))),
+                React.createElement(Select, { disabled: !isTooltipEnabled, value: sparklineOptions.tooltip?.position?.placement, onChange: (value) => handleChange('position', {
+                        ...sparklineOptions.tooltip?.position,
+                        placement: value,
+                    }), options: placementOptions }))),
         React.createElement(FormRow, { label: "Position Offset X" },
-            React.createElement(AdaptableInput, { disabled: !isTooltipEnabled, title: "The horizontal offset in pixels for the position of the tooltip.", type: "number", value: sparklineOptions.tooltip?.position?.xOffset ?? '', onChange: (e) => handleChange('tooltip', {
-                    ...sparklineOptions.tooltip,
-                    position: { ...sparklineOptions.tooltip?.position, xOffset: Number(e.target.value) },
+            React.createElement(AdaptableInput, { disabled: !isTooltipEnabled, title: "The horizontal offset in pixels for the position of the tooltip.", type: "number", value: sparklineOptions.tooltip?.position?.xOffset ?? '', onChange: (e) => handleChange('position', {
+                    ...sparklineOptions.tooltip?.position,
+                    xOffset: Number(e.target.value),
                 }) })),
         React.createElement(FormRow, { label: "Position Offset Y" },
-            React.createElement(AdaptableInput, { disabled: !isTooltipEnabled, title: "The vertical offset in pixels for the position of the tooltip.", type: "number", value: sparklineOptions.tooltip?.position?.yOffset ?? '', onChange: (e) => handleChange('tooltip', {
-                    ...sparklineOptions.tooltip,
-                    position: { ...sparklineOptions.tooltip?.position, yOffset: Number(e.target.value) },
+            React.createElement(AdaptableInput, { disabled: !isTooltipEnabled, title: "The vertical offset in pixels for the position of the tooltip.", type: "number", value: sparklineOptions.tooltip?.position?.yOffset ?? '', onChange: (e) => handleChange('position', {
+                    ...sparklineOptions.tooltip?.position,
+                    yOffset: Number(e.target.value),
                 }) }))));
 };
 const SparklineMarkerOptions = ({ options, onChange }) => {

package/src/agGrid/AgGridAdapter.js

@@ -1,6 +1,6 @@
 import { ColumnApiModule, } from 'ag-grid-enterprise';
 import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT_COLUMN_TYPE, } from '../AdaptableState/Common/AdaptableColumn';
-import { ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME } from '../Utilities/Constants/GeneralConstants';
+import { ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME, AG_GRID_GROUPED_COLUMN, AG_GRID_SELECTION_COLUMN, } from '../Utilities/Constants/GeneralConstants';
 import { createUuid } from '../AdaptableState/Uuid';
 import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
 import * as ModuleConstants from '../Utilities/Constants/ModuleConstants';
@@ -453,6 +453,10 @@ export class AgGridAdapter {
             this.logger.warn(`Column is undefined, returning 'text' for Type`);
             return 'text';
         }
+        if (agColumn.getId() === AG_GRID_GROUPED_COLUMN ||
+            agColumn.getId() === AG_GRID_SELECTION_COLUMN) {
+            return 'unknown';
+        }
         const colDefType = [].concat(agColumn.getColDef()?.type || []).filter(Boolean);
         const skippedSpecialCols = ['actionColumn', 'fdc3Column'];
         if (skippedSpecialCols.some((specialColType) => colDefType.includes(specialColType))) {

package/src/agGrid/AgGridExportAdapter.js

@@ -50,6 +50,7 @@ export class AgGridExportAdapter {
     }
     async exportData(config) {
         const { report, format, showProgressIndicator } = config;
+        let excelStylesWerePatched = false;
         try {
             if (showProgressIndicator) {
                 this.adaptableApi.userInterfaceApi.showProgressIndicator({
@@ -60,11 +61,19 @@ export class AgGridExportAdapter {
                 await waitForTimeout(16);
             }
             this.adaptableApi.exportApi.internalApi.setExportInProgress(config.report.Name, config.format, config.destination);
-            const { exportContext, exportParams } = this.buildExportProcessData(config);
+            const exportProcessData = this.buildExportProcessData(config);
+            const { exportContext, exportParams } = exportProcessData;
+            if (this.adaptableApi.layoutApi.isCurrentLayoutPivot() &&
+                config.report.ReportRowScope === 'AllRows') {
+                // if in pivot mode but the user wants to export all rows (aka the table row data), we cannot use AG Grids row model
+                // we have to use an intermediary transient AG Grid instance
+                return this.adaptableApi.exportApi.internalApi.exportAllDataInPivotMode(exportProcessData);
+            }
             if (exportContext.isVisualExcelReport) {
                 // FIXME AFL patch styles only for exported columns!
                 // or even better, only cells
                 this.patchExcelStyles();
+                excelStylesWerePatched = true;
             }
             // 1. easiest case, we download the file using AG Grid
             // these methods will automatically handle the file download
@@ -106,7 +115,7 @@ export class AgGridExportAdapter {
              * Cleanup export process
              */
             this.adaptableApi.exportApi.internalApi.setExportComplete();
-            if (format === 'VisualExcel') {
+            if (excelStylesWerePatched) {
                 this.resetExcelStyles();
             }
             if (showProgressIndicator) {
@@ -119,9 +128,6 @@ export class AgGridExportAdapter {
      */
     buildExportProcessData(config) {
         const exportContext = this.buildExportProcessContext(config);
-        if (exportContext.isVisualExcelReport) {
-            this.patchExcelStyles();
-        }
         const exportParams = this.buildExportParams(exportContext);
         exportContext.exportedColumnIds = exportParams.columnKeys;
         return {

package/src/env.js

@@ -1,5 +1,5 @@
 export 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: 1746196666403 || Date.now(),
-    VERSION: "20.0.13" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1746214089071 || Date.now(),
+    VERSION: "20.1.0" || '--current-version--',
 };