@adaptabletools/adaptable 21.1.2 → 21.1.3

package/package.json

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

package/src/Strategy/CommentModule.js

@@ -30,7 +30,9 @@ export class CommentModule extends AdaptableModuleBase {
         if (!this.api.commentApi.internalApi.areCommentsSupportedInLayout()) {
             return;
         }
-        if (menuContext.isRowGroupColumn || menuContext.isGroupedNode) {
+        if (menuContext.isRowGroupColumn ||
+            menuContext.isGroupedNode ||
+            !menuContext.isSingleSelectedCell) {
             return;
         }
         const items = [];

package/src/Strategy/LayoutModule.js

@@ -283,7 +283,8 @@ export class LayoutModule extends AdaptableModuleBase {
         };
         let columns = (layout.TableColumns || [])
             .filter((c) => !this.api.columnApi.isAutoRowGroupColumn(c))
-            .filter((c) => !this.api.columnApi.isPivotResultColumn(c));
+            .filter((c) => !this.api.columnApi.isPivotResultColumn(c))
+            .filter((c) => !this.api.columnApi.isSelectionColumn(c));
         if (columns.length >
             maxColumnsToDisplay + 1 /* +1 is to show tag only beginning with 2, 'other 2' */) {
             const extraColumns = columns.length - maxColumnsToDisplay;

package/src/Strategy/NoteModule.js

@@ -18,7 +18,9 @@ export class NoteModule extends AdaptableModuleBase {
         if (!this.api.noteApi.internalApi.areNotesSupported()) {
             return;
         }
-        if (menuContext.isRowGroupColumn || menuContext.isGroupedNode) {
+        if (menuContext.isRowGroupColumn ||
+            menuContext.isGroupedNode ||
+            !menuContext.isSingleSelectedCell) {
             return;
         }
         const isReadOnly = this.api.entitlementApi.getEntitlementAccessLevelForModule(this.moduleInfo.ModuleName) ===

package/src/View/Layout/Wizard/sections/ColumnsSection.js

@@ -40,7 +40,8 @@ export const ColumnsSectionSummary = () => {
     const data = React.useMemo(() => {
         return ColumnIds.map((columnId) => {
             if (adaptable.api.columnApi.isPivotResultColumn(columnId) ||
-                adaptable.api.columnApi.isAutoRowGroupColumn(columnId)) {
+                adaptable.api.columnApi.isAutoRowGroupColumn(columnId) ||
+                adaptable.api.columnApi.isSelectionColumn(columnId)) {
                 return null;
             }
             const friendlyName = adaptable.api.columnApi.getFriendlyNameForColumnId(columnId, layout);

package/src/agGrid/AdaptableAgGrid.js

@@ -1144,8 +1144,9 @@ You need to define at least one Layout!`);
                     format: '0.###############',
                 },
             });
-            this.agGridExportAdapter.originalExcelStyles = excelStyles;
-            this.agGridExportAdapter.DANGER_excelStyles = this.agGridExportAdapter.originalExcelStyles;
+            // store original excel styles, we will have to revert to them after each VISUAL EXPORT
+            this.agGridExportAdapter.originalExcelStyles = [...excelStyles];
+            this.agGridExportAdapter.DANGER_excelStyles = excelStyles;
             // this array reference will be used for the entire AG Grid session
             return this.agGridExportAdapter.DANGER_excelStyles;
         });

package/src/agGrid/AgGridColumnAdapter.js

@@ -185,7 +185,7 @@ export class AgGridColumnAdapter {
                     }
                     if (isVisualDataExport) {
                         const cellClassKey = AgGridExportAdapter.getExcelClassNameForCell(colId, gridCell.primaryKeyValue, userDefinedCellClass);
-                        const customCellClass = this.adaptableInstance.agGridExportAdapter.getExcelStyleIdForCellClassKey(cellClassKey);
+                        const customCellClass = this.adaptableInstance.agGridExportAdapter.getExcelStyleIdForClassKey(cellClassKey);
                         if (customCellClass) {
                             excelStyleClasses.push(customCellClass);
                         }
@@ -251,6 +251,27 @@ export class AgGridColumnAdapter {
                     // see https://github.com/AdaptableTools/adaptable/issues/2947#issuecomment-3062304655
                     return baseHeaderClass;
                 }
+                const isExcelExport = this.adaptableApi.exportApi.internalApi.isExcelExportInProgress();
+                const isVisualDataExport = this.adaptableApi.exportApi.internalApi.isVisualDataExportInProgress();
+                if (isExcelExport || isVisualDataExport) {
+                    const excelStyleHeaderClasses = [];
+                    if (userDefinedHeaderClass) {
+                        if (Array.isArray(userDefinedHeaderClass)) {
+                            excelStyleHeaderClasses.push(...userDefinedHeaderClass.filter(Boolean));
+                        }
+                        else {
+                            excelStyleHeaderClasses.push(userDefinedHeaderClass);
+                        }
+                    }
+                    if (isVisualDataExport) {
+                        const headerClassKey = AgGridExportAdapter.getExcelClassNameForHeader(colId, userDefinedHeaderClass);
+                        const customHeaderClass = this.adaptableInstance.agGridExportAdapter.getExcelStyleIdForClassKey(headerClassKey);
+                        if (customHeaderClass) {
+                            excelStyleHeaderClasses.push(customHeaderClass);
+                        }
+                    }
+                    return excelStyleHeaderClasses.length ? excelStyleHeaderClasses : null;
+                }
                 const columnId = params.column.getColId();
                 const adaptableColumn = this.adaptableApi.columnApi.getColumnWithColumnId(columnId);
                 if (!adaptableColumn) {

package/src/agGrid/AgGridExportAdapter.d.ts

@@ -35,7 +35,7 @@ export declare class AgGridExportAdapter {
     DANGER_excelStyles: ExcelStyle[];
     originalExcelStyles: ExcelStyle[];
     private excelStylesCache;
-    private cellClassKey2excelStyleIdMap;
+    private cellOrHeaderClassKey2ExcelStyleIdMap;
     private excelStylesWithFormattedDate;
     constructor(_adaptableInstance: AdaptableAgGrid);
     private get agGridApi();
@@ -43,6 +43,7 @@ export declare class AgGridExportAdapter {
     private get exportOptions();
     private get logger();
     static getExcelClassNameForCell(colId: string, primaryKeyValue: any, userDefinedCellClass?: string | string[]): string;
+    static getExcelClassNameForHeader(colId: string, userDefinedHeaderClass?: string | string[]): string;
     destroy(): void;
     exportData(config: ExportConfig): Promise<null | ExportResultData>;
     /**
@@ -66,7 +67,7 @@ export declare class AgGridExportAdapter {
     private isDateCellExportedAsFormattedValue;
     private convertCSSToExcelStyle;
     private getExcelDataType;
-    getExcelStyleIdForCellClassKey(cellClassKey: string): string;
+    getExcelStyleIdForClassKey(cellOrHeaderClassKey: string): string;
     private getExcelStyleWithFormattedDate;
     private mapCsvToJson;
     private getCsvSeparator;

package/src/agGrid/AgGridExportAdapter.js

@@ -17,7 +17,7 @@ export class AgGridExportAdapter {
         this.DANGER_excelStyles = [];
         this.originalExcelStyles = [];
         this.excelStylesCache = {};
-        this.cellClassKey2excelStyleIdMap = {};
+        this.cellOrHeaderClassKey2ExcelStyleIdMap = {};
         this.excelStylesWithFormattedDate = {};
     }
     get agGridApi() {
@@ -43,9 +43,20 @@ export class AgGridExportAdapter {
                 : userDefinedCellClass}`
             : excelClassName;
     }
+    static getExcelClassNameForHeader(colId, userDefinedHeaderClass) {
+        let excelClassName = `--excel-header-${colId}`;
+        if (excelClassName.indexOf(' ') > 0) {
+            excelClassName = excelClassName.replace(/\s/g, '_');
+        }
+        return userDefinedHeaderClass != null
+            ? `${excelClassName}-${Array.isArray(userDefinedHeaderClass)
+                ? userDefinedHeaderClass.join('-')
+                : userDefinedHeaderClass}`
+            : excelClassName;
+    }
     destroy() {
         this.excelStylesCache = null;
-        this.cellClassKey2excelStyleIdMap = null;
+        this.cellOrHeaderClassKey2ExcelStyleIdMap = null;
         this.excelStylesWithFormattedDate = null;
     }
     async exportData(config) {
@@ -446,13 +457,14 @@ export class AgGridExportAdapter {
     }
     patchExcelStyles(exportContext) {
         const exportExcelStyles = this.buildExcelStyles(exportContext);
-        // set DANGER_excelStyles without changing the array reference
-        this.DANGER_excelStyles.splice(0, this.DANGER_excelStyles.length, ...exportExcelStyles);
+        // Concatenate exportExcelStyles to DANGER_excelStyles without changing the array reference
+        this.DANGER_excelStyles.push(...exportExcelStyles);
     }
     resetExcelStyles() {
+        // Revert to original state without changing the array reference
         this.DANGER_excelStyles.splice(0, this.DANGER_excelStyles.length, ...this.originalExcelStyles);
         this.excelStylesCache = {};
-        this.cellClassKey2excelStyleIdMap = {};
+        this.cellOrHeaderClassKey2ExcelStyleIdMap = {};
         this.excelStylesWithFormattedDate = {};
     }
     buildExcelStyles(exportContext) {
@@ -489,6 +501,60 @@ export class AgGridExportAdapter {
         });
         const forAllVisibleRowNodesDoConfig = { includeGroupRows: true };
         const userExcelStyles = this.DANGER_excelStyles;
+        // 1. Header Styles
+        agGridDisplayedColumns.forEach((column, columnIndex) => {
+            const colDef = colDefs[columnIndex];
+            const columnId = column.getId();
+            const adaptableColumn = getAdaptableColumnWithColumnId(columnId);
+            if (!adaptableColumn) {
+                this.logger.warn(`Export Styling: Column with id ${columnId} not found in Adaptable`);
+                return;
+            }
+            let headerClassParams = {
+                colDef,
+                column,
+                floatingFilter: false,
+                api: this.agGridApi,
+                context: this.agGridApi.getGridOption('context'),
+            };
+            const headerStyle = typeof colDef.headerStyle === 'function' ? colDef.headerStyle(headerClassParams) : {};
+            const excelHeaderStyles = [];
+            // add user defined excel styles
+            let userColDefHeaderClass = this._adaptableInstance.agGridColumnAdapter.getUserColDefProperty(column.getColId(), 'headerClass');
+            const userDefinedHeaderClass = typeof userColDefHeaderClass === 'function'
+                ? userColDefHeaderClass(headerClassParams)
+                : userColDefHeaderClass;
+            const userDefinedExcelHeaderStyle = userDefinedHeaderClass &&
+                userExcelStyles.find((excelStyle) => {
+                    return typeof userDefinedHeaderClass === 'string'
+                        ? userDefinedHeaderClass === excelStyle.id
+                        : userDefinedHeaderClass?.includes?.(excelStyle.id);
+                });
+            if (userDefinedExcelHeaderStyle) {
+                excelHeaderStyles.push(userDefinedExcelHeaderStyle);
+            }
+            // add adaptable derived styles (format column etc.)
+            const adaptableHeaderStyle = {
+                ...Object.keys(headerStyle).reduce((result, key) => {
+                    if (headerStyle[key] !== null) {
+                        result[key] = headerStyle[key];
+                    }
+                    return result;
+                }, {}),
+            };
+            const sanitizedAdaptableHeaderStyle = sanitizeStyle(adaptableHeaderStyle);
+            if (Object.values(sanitizedAdaptableHeaderStyle).some((style) => style != null)) {
+                excelHeaderStyles.push(this.convertCSSToExcelStyle(sanitizedAdaptableHeaderStyle));
+            }
+            // don't add the header style if it has no adaptable custom styles
+            if (!excelHeaderStyles.length) {
+                return;
+            }
+            const headerClassId = AgGridExportAdapter.getExcelClassNameForHeader(column.getId(), userDefinedHeaderClass);
+            const finalHeaderExcelStyle = Object.assign({}, ...excelHeaderStyles);
+            this.registerExcelStyle(finalHeaderExcelStyle, headerClassId);
+        });
+        // 2. Cell Styles
         this.adaptableApi.internalApi.forAllVisibleRowNodesDo((node, rowIndex) => {
             const rowParams = {
                 node,
@@ -525,7 +591,7 @@ export class AgGridExportAdapter {
                     return cellClassParams;
                 };
                 const cellStyle = typeof colDef.cellStyle === 'function' ? colDef.cellStyle(getLazyCellClassParams()) : {};
-                const excelStyles = [];
+                const excelCellStyles = [];
                 // add user defined excel styles
                 let userColDefCellClass = this._adaptableInstance.agGridColumnAdapter.getUserColDefProperty(column.getColId(), 'cellClass');
                 const userDefinedCellClass = typeof userColDefCellClass === 'function'
@@ -538,10 +604,10 @@ export class AgGridExportAdapter {
                             : userDefinedCellClass?.includes?.(excelStyle.id);
                     });
                 if (userDefinedExcelStyle) {
-                    excelStyles.push(userDefinedExcelStyle);
+                    excelCellStyles.push(userDefinedExcelStyle);
                 }
                 // add adaptable derived styles (format column etc.)
-                const adaptableStyle = {
+                const adaptableCellStyle = {
                     ...rowStyle,
                     ...Object.keys(cellStyle).reduce((result, key) => {
                         if (cellStyle[key] !== null) {
@@ -550,20 +616,20 @@ export class AgGridExportAdapter {
                         return result;
                     }, {}),
                 };
-                const sanitizedAdaptableStyle = sanitizeStyle(adaptableStyle);
-                if (Object.values(sanitizedAdaptableStyle).some((style) => style != null)) {
-                    excelStyles.push(this.convertCSSToExcelStyle(sanitizedAdaptableStyle));
+                const sanitizedAdaptableCellStyle = sanitizeStyle(adaptableCellStyle);
+                if (Object.values(sanitizedAdaptableCellStyle).some((style) => style != null)) {
+                    excelCellStyles.push(this.convertCSSToExcelStyle(sanitizedAdaptableCellStyle));
                 }
                 const excelDataType = this.getExcelDataType(adaptableColumn.dataType);
                 const rawValue = this.adaptableApi.gridApi.getRawValueFromRowNode(node, column.getId());
                 // don't add the cell style if it has no adaptable custom styles
-                if (!excelStyles.length &&
+                if (!excelCellStyles.length &&
                     // if this is a formatted Date value, we still need to add the AG GRID specific type & numberFormat below
                     !(excelDataType === 'DateTime' && isDateCellExportedAsFormattedValue)) {
                     return;
                 }
                 const cellClassId = AgGridExportAdapter.getExcelClassNameForCell(column.getId(), this.adaptableApi.gridApi.getPrimaryKeyValueForRowNode(node), userDefinedCellClass);
-                const finalCellExcelStyle = Object.assign({}, ...excelStyles);
+                const finalCellExcelStyle = Object.assign({}, ...excelCellStyles);
                 if (excelDataType === 'DateTime' && isDateCellExportedAsFormattedValue) {
                     let dateFormatPattern = this.exportOptions.exportDateFormat;
                     const abColumn = getAdaptableColumnWithColumnId(column.getColId());
@@ -602,27 +668,6 @@ export class AgGridExportAdapter {
                 this.registerExcelStyle(finalCellExcelStyle, cellClassId);
             });
         }, forAllVisibleRowNodesDoConfig);
-        // see #EXCEL_EXPORT_DATA_TYPES
-        this.excelStylesCache['stringExcelType'] = {
-            id: 'stringExcelType',
-            dataType: 'String',
-        };
-        this.excelStylesCache['booleanExcelType'] = {
-            id: 'booleanExcelType',
-            dataType: 'Boolean',
-        };
-        this.excelStylesCache['dateExcelType'] = {
-            id: 'dateExcelType',
-            dataType: 'DateTime',
-        };
-        this.excelStylesCache['numberExcelType'] = {
-            id: 'numberExcelType',
-            // dataType: 'Number',
-            // AG Grid requires either dataType or numberFormat to be set for Numbers
-            numberFormat: {
-                format: '0.###############',
-            },
-        };
         return Object.values(this.excelStylesCache);
     }
     registerExcelStyle(excelStyle, cellClassKey) {
@@ -632,7 +677,8 @@ export class AgGridExportAdapter {
             const excelStyleWithId = { ...excelStyle, id: excelStyleId };
             this.excelStylesCache[excelStyleKey] = excelStyleWithId;
         }
-        this.cellClassKey2excelStyleIdMap[cellClassKey] = this.excelStylesCache[excelStyleKey].id;
+        this.cellOrHeaderClassKey2ExcelStyleIdMap[cellClassKey] =
+            this.excelStylesCache[excelStyleKey].id;
     }
     registerExcelStyleWithFormattedDate(cellClassId, isoFormattedValue) {
         this.excelStylesWithFormattedDate[cellClassId] = isoFormattedValue;
@@ -716,8 +762,8 @@ export class AgGridExportAdapter {
                 return 'String';
         }
     }
-    getExcelStyleIdForCellClassKey(cellClassKey) {
-        return this.cellClassKey2excelStyleIdMap[cellClassKey];
+    getExcelStyleIdForClassKey(cellOrHeaderClassKey) {
+        return this.cellOrHeaderClassKey2ExcelStyleIdMap[cellOrHeaderClassKey];
     }
     getExcelStyleWithFormattedDate(cellClassId) {
         return this.excelStylesWithFormattedDate[cellClassId];

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: 1764941773702 || Date.now(),
-    VERSION: "21.1.2" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1765888673719 || Date.now(),
+    VERSION: "21.1.3" || '--current-version--',
 };