@adaptabletools/adaptable 20.0.12 → 20.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "20.0.12",
+  "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/AdaptableState/Common/AggregationColumns.d.ts

@@ -1,6 +1,7 @@
 /**
  * Defines which Columns in a Layout display Aggregated values when Row-Grouped
  */
+import { PivotTotalPosition } from '../LayoutState';
 export type AggregationColumnValue = string | true | WeightedAverageAggregation;
 /**
  * Defines an Aggregated Column in a Table Layout
@@ -24,9 +25,9 @@ export type PivotAggregationColumns = {
     /**
      * Whether to show the total for this column; it can be also customized for specific Pivot Columns
      */
-    Total?: boolean | 'before' | 'after' | {
+    Total?: PivotTotalPosition | {
         PivotColumnId: string;
-        ShowTotal?: boolean | 'before' | 'after';
+        ShowTotal?: PivotTotalPosition;
     }[];
 }[];
 export declare const WEIGHTED_AVERAGE_AGG_FN_NAME = "weightedAvg";

package/src/AdaptableState/Common/AggregationColumns.js

@@ -1,6 +1,3 @@
-/**
- * Defines which Columns in a Layout display Aggregated values when Row-Grouped
- */
 export const WEIGHTED_AVERAGE_AGG_FN_NAME = 'weightedAvg';
 export const isWeightedAverageAggFuncName = (aggFunc) => {
     return aggFunc === WEIGHTED_AVERAGE_AGG_FN_NAME;

package/src/AdaptableState/LayoutState.d.ts

@@ -155,12 +155,16 @@ export interface PivotLayout extends LayoutBase {
     /**
      * Display automatically calculated Totals of all Pivot Columns, in the position specified
      */
-    PivotGrandTotal?: 'before' | 'after' | boolean;
+    PivotGrandTotal?: PivotTotalPosition;
     /**
      * Display automatically calculated Totals within EACH Pivot Column Group, in the position specified
      */
-    PivotColumnTotal?: 'before' | 'after' | boolean;
+    PivotColumnTotal?: PivotTotalPosition;
 }
+/**
+ * Defines the position of Pivot Total position - 'before' or 'after' the Value Column(s)
+ */
+export type PivotTotalPosition = 'before' | 'after' | boolean;
 /**
  * Manages how (and which) Row Group values are stored
  */

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/Layout/Wizard/sections/PivotAggregationsSection.js

@@ -179,7 +179,7 @@ const PivotColumnRow = (props) => {
                     ' ',
                     React.createElement(DropdownButton, { columns: ['label'], items: numericColumnsOptions, ml: 2 }, weightName))),
                 aggValue && (React.createElement(Flex, { backgroundColor: "primary", ml: 3, alignItems: "center" },
-                    React.createElement(Text, null, "Total Column"),
+                    React.createElement(Text, null, "Total"),
                     ' ',
                     React.createElement(DropdownButton, { columns: ['label'], items: totalOptions, ml: 2 }, currentTotal)))),
             hasPivotSpecificTotals && (React.createElement(Flex, { ml: 2, pl: 2, flexWrap: "wrap", flex: "1 1 auto", alignItems: "center", style: {
@@ -333,7 +333,7 @@ export const PivotAggregationsSection = (props) => {
                                     GrandTotalRow: value,
                                 });
                             }, isClearable: true })),
-                    React.createElement(FormRow, { label: 'Grand Total Column' },
+                    React.createElement(FormRow, { label: 'Pivot Grand Total' },
                         React.createElement(Select, { style: { width: 120 }, options: ['before', 'after'].map((position) => {
                                 return {
                                     label: StringExtensions.CapitaliseFirstLetter(position),
@@ -345,7 +345,7 @@ export const PivotAggregationsSection = (props) => {
                                     PivotGrandTotal: value,
                                 });
                             }, isClearable: true })),
-                    React.createElement(FormRow, { label: 'Pivot Group Total Column' }, isPivotColumnTotalEnabled === true ? (React.createElement(Select, { style: { width: 120 }, options: ['before', 'after'].map((position) => {
+                    React.createElement(FormRow, { label: 'Pivot Column Total' }, isPivotColumnTotalEnabled === true ? (React.createElement(Select, { style: { width: 120 }, options: ['before', 'after'].map((position) => {
                             return {
                                 label: StringExtensions.CapitaliseFirstLetter(position),
                                 value: position,

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/AdaptableAgGrid.js

@@ -93,7 +93,7 @@ import { AgGridExportAdapter } from './AgGridExportAdapter';
 import { checkForDuplicateColumns, isPivotLayout, layoutModelToLayoutState, layoutStateToLayoutModel, normalizeLayout, } from '../Api/Implementation/LayoutHelpers';
 import { LayoutManager } from '../layout-manager/src';
 import { isPivotLayoutModel } from '../layout-manager/src/isPivotLayoutModel';
-import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT_COLUMN_TYPE, } from '../AdaptableState/Common/AdaptableColumn';
+import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT_COLUMN_TYPE, PIVOT_AGGREGATION_TOTAL_COLUMN_TYPE, PIVOT_ANY_TOTAL_COLUMN_TYPE, PIVOT_COLUMN_TOTAL_COLUMN_TYPE, PIVOT_GRAND_TOTAL_COLUMN_TYPE, } from '../AdaptableState/Common/AdaptableColumn';
 import { agGridDataTypeDefinitions } from './agGridDataTypeDefinitions';
 import { AgGridThemeAdapter } from './AgGridThemeAdapter';
 import { mapOldTypeToDataType } from '../migration/VersionUpgrade20';
@@ -1076,6 +1076,10 @@ You need to define at least one Layout!`);
                 [FREE_TEXT_COLUMN_TYPE]: {},
                 [ACTION_COLUMN_TYPE]: {},
                 [FDC3_COLUMN_TYPE]: {},
+                [PIVOT_ANY_TOTAL_COLUMN_TYPE]: {},
+                [PIVOT_GRAND_TOTAL_COLUMN_TYPE]: {},
+                [PIVOT_COLUMN_TOTAL_COLUMN_TYPE]: {},
+                [PIVOT_AGGREGATION_TOTAL_COLUMN_TYPE]: {},
             };
             const patchedColumnTypes = Object.assign({}, providedColumnTypes, adaptableSpecialColumnTypes);
             const customColumnTypes = this.api.columnApi.getColumnTypes() ?? [];

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/AgGridColumnAdapter.js

@@ -202,14 +202,32 @@ export class AgGridColumnAdapter {
             const quickSearchStyle = this.getQuickSearchCellStyle();
             const hasQuickSearchStyle = quickSearchStyle != undefined;
             const cellStyle = (params) => {
-                const gridCell = this.adaptableApi.gridApi.getGridCellFromRowNode(params.node, abColumn.columnId);
+                const columnId = params.column.getColId();
+                const gridCell = this.adaptableApi.gridApi.getGridCellFromRowNode(params.node, columnId);
                 if (!gridCell || !gridCell.column) {
                     return {};
                 }
                 const isQuickSearchActive = hasQuickSearchStyle && this.isQuickSearchActive(gridCell, params);
-                const userDefined = typeof userCellStyle === 'function' ? userCellStyle(params) : userCellStyle;
+                let baseStyles = {};
+                // this is required because otherwise, when AG Grid filters, it refershed the pivotResultColDef and the base styles get lost
+                // if pivot result col: inherit styles from base column
+                if (this.adaptableApi.columnApi.isPivotResultColumn(columnId)) {
+                    const baseColumn = params.column.getColDef()?.pivotValueColumn;
+                    if (baseColumn) {
+                        const baseColDefCellStyle = baseColumn?.getColDef()?.cellStyle;
+                        const baseColParams = { ...params, column: baseColumn };
+                        baseStyles =
+                            typeof baseColDefCellStyle === 'function'
+                                ? baseColDefCellStyle(baseColParams)
+                                : baseColDefCellStyle;
+                    }
+                }
+                else {
+                    // inherit styles from user provided colDef property
+                    baseStyles = typeof userCellStyle === 'function' ? userCellStyle(params) : userCellStyle;
+                }
                 const result = {
-                    ...userDefined,
+                    ...baseStyles,
                     ...this.getReadOnlyCellStyle(gridCell, params),
                     ...this.getEditableCellStyle(gridCell, params),
                     ...this.getEditedCellStyle(gridCell, params),

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: 1746136567034 || Date.now(),
-    VERSION: "20.0.12" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1746214089071 || Date.now(),
+    VERSION: "20.1.0" || '--current-version--',
 };

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

@@ -4382,18 +4382,18 @@ export declare const ADAPTABLE_METAMODEL: {
             kind: string;
             desc: string;
             isOpt: boolean;
-            ref?: undefined;
+            ref: string;
         } | {
             name: string;
             kind: string;
             desc: string;
-            isOpt: boolean;
-            ref: string;
+            isOpt?: undefined;
+            ref?: undefined;
         } | {
             name: string;
             kind: string;
             desc: string;
-            isOpt?: undefined;
+            isOpt: boolean;
             ref?: undefined;
         })[];
     };