@adaptabletools/adaptable 18.0.0-canary.9 → 18.0.0

package/src/agGrid/AgGridMenuAdapter.js

@@ -1,4 +1,3 @@
-import { DEFAULT_ADAPTABLE_COLUMN_MENU_STRUCTURE, DEFAULT_ADAPTABLE_CONTEXT_MENU_STRUCTURE, } from '../AdaptableOptions/MenuOptions';
 import { isAdaptableElementIcon } from '../components/Icon';
 import { iconToString } from '../components/icons';
 import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
@@ -17,7 +16,7 @@ export class AgGridMenuAdapter {
     }
     buildColumnMenu(params, originalGetMainMenuItems) {
         var _a;
-        const menuOptions = this.adaptableOptions.menuOptions;
+        const columnMenuOptions = this.adaptableOptions.columnMenuOptions;
         const agGridMenuItems = (params.defaultItems ? [...params.defaultItems] : []);
         if (!params.column) {
             // return only AG Grid context if the Adaptable column is not found (should not happen)
@@ -25,17 +24,19 @@ export class AgGridMenuAdapter {
         }
         const adaptableColumn = this.adaptableApi.columnApi.getColumnWithColumnId((_a = params.column) === null || _a === void 0 ? void 0 : _a.getColId());
         const menuContext = this.createColumnMenuContextObject(adaptableColumn, params.column);
-        const { adaptableMenuItems, structuredAdaptableMenuItems } = this.buildStructuredAdaptableColumnItems(menuContext);
+        /**
+         * AG Grid items
+         */
+        const agGridDefaultStructure = agGridMenuItems.map((itemName) => this.mapAgGridItemTypeToAgGridMenuItem(itemName));
+        const adaptableMenuItems = this.createAdaptableColumnMenuItems(menuContext);
+        const defaultColumnMenuStructure = this.buildColumnMenuDefaultStructure(adaptableMenuItems, menuContext);
         // 1. first check if there is a custom column menu defined
-        if (typeof menuOptions.customColumnMenu === 'function') {
-            const defaultAgGridMenuItems = agGridMenuItems.map((itemName) => ({
-                menuType: 'AgGrid',
-                name: itemName,
-            }));
+        if (typeof columnMenuOptions.customColumnMenu === 'function') {
+            const defaultAgGridMenuItems = agGridMenuItems.map((itemName) => this.mapAgGridItemTypeToAgGridMenuItem(itemName));
             const defaultAdaptableMenuItems = adaptableMenuItems.map((adaptableItem) => (Object.assign({ menuType: 'Adaptable' }, adaptableItem)));
-            const customMenuItems = menuOptions
+            const customMenuItems = columnMenuOptions
                 .customColumnMenu(Object.assign(Object.assign({}, menuContext), { defaultAgGridMenuItems,
-                defaultAdaptableMenuItems, structuredAdaptableMenuItems: this.mapAdaptableMenuItemToSystemMenuItems(structuredAdaptableMenuItems) }))
+                defaultAdaptableMenuItems, defaultAdaptableMenuStructure: this.mapAdaptableMenuItemToSystemMenuItems(defaultColumnMenuStructure), defaultAgGridMenuStructure: agGridDefaultStructure }))
                 .filter(Boolean);
             return customMenuItems
                 .map((customMenuItem) => this.mapCustomMenuItemToAgGridMenuDefinition(customMenuItem, menuContext))
@@ -45,42 +46,57 @@ export class AgGridMenuAdapter {
         const defaultContextMenu = [
             ...agGridMenuItems,
             'separator',
-            ...structuredAdaptableMenuItems.map((adaptableItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(adaptableItem)),
+            ...defaultColumnMenuStructure.map((adaptableItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(adaptableItem)),
         ];
-        return defaultContextMenu;
-    }
-    buildStructuredAdaptableColumnItems(menuContext) {
-        const adaptableMenuItems = this.createAdaptableColumnMenuItems(menuContext);
-        // sort Adaptable menu items by default order
-        const structuredAdaptableMenuItems = this.buildGroupedModuleItems(DEFAULT_ADAPTABLE_COLUMN_MENU_STRUCTURE, adaptableMenuItems);
-        return { adaptableMenuItems, structuredAdaptableMenuItems };
+        return this.removeConsecutiveSeparators(defaultContextMenu);
     }
     buildContextMenu(params, originalGetContextMenuItems) {
         var _a;
+        if (!params.column) {
+            return [];
+        }
         // we do this in order to refresh the internal state of selected cells (technically query the AG Grid cellRanges)
         // (right-click selected the current cell, but this was not reflected in the internal state of the selected cells)
         this.adaptableInstance.refreshSelectedCellsState();
-        const menuOptions = this.adaptableOptions.menuOptions;
-        const agGridMenuItems = (params.defaultItems ? [...params.defaultItems] : []);
-        if (!params.column) {
-            // return only AG Grid context if the Adaptable column is not found (should not happen)
-            return agGridMenuItems;
-        }
+        const contextMenuOptions = this.adaptableOptions.contextMenuOptions;
         const adaptableColumn = this.adaptableApi.columnApi.getColumnWithColumnId((_a = params.column) === null || _a === void 0 ? void 0 : _a.getColId());
         const menuContext = this.createContextMenuContextObject(params, adaptableColumn);
+        /**
+         * AG Grid Items
+         */
+        const agGridMenuItems = (params.defaultItems ? [...params.defaultItems] : []);
+        const agGridCopyItems = agGridMenuItems.filter((item) => ['copy', 'copyWithHeaders', 'copyWithGroupHeaders', 'cut', 'paste'].includes(item));
+        const otherAgGridItems = agGridMenuItems.filter((item) => !agGridCopyItems.includes(item) &&
+            // we provide Adaptable exports in the context menu
+            !['export', 'csvExport', 'excelExport'].includes(item));
+        const agGridDefaultStructure = [
+            {
+                menuType: 'Group',
+                label: 'Copy & Paste',
+                icon: {
+                    name: 'copy',
+                },
+                subMenuItems: agGridCopyItems.map((item) => this.mapAgGridItemTypeToAgGridMenuItem(item)),
+            },
+            ...otherAgGridItems
+                .filter((itemName) => itemName !== 'separator')
+                .map((itemName) => this.mapAgGridItemTypeToAgGridMenuItem(itemName)),
+        ];
+        /**
+         * Adaptable Items
+         */
         const adaptableMenuItems = this.createAdaptableContextMenuItems(menuContext);
-        // sort Adaptable menu items by default order
-        const structuredAdaptableMenuItems = this.buildGroupedModuleItems(DEFAULT_ADAPTABLE_CONTEXT_MENU_STRUCTURE, adaptableMenuItems);
+        const adaptableDefaultStructure = this.buildContextMenuDefaultStructure(adaptableMenuItems, menuContext);
+        /**
+         * Build the context menu
+         */
         // 1. first check if there is a custom context menu defined
-        if (typeof menuOptions.customContextMenu === 'function') {
-            const defaultAgGridMenuItems = agGridMenuItems.map((itemName) => ({
-                menuType: 'AgGrid',
-                name: itemName,
-            }));
+        if (typeof contextMenuOptions.customContextMenu === 'function') {
+            const defaultAgGridMenuItems = agGridMenuItems.map((itemName) => this.mapAgGridItemTypeToAgGridMenuItem(itemName));
             const defaultAdaptableMenuItems = adaptableMenuItems.map((adaptableItem) => (Object.assign({ menuType: 'Adaptable' }, adaptableItem)));
-            const customMenuItems = menuOptions
+            const customMenuItems = contextMenuOptions
                 .customContextMenu(Object.assign(Object.assign({}, menuContext), { defaultAgGridMenuItems,
-                defaultAdaptableMenuItems, structuredAdaptableMenuItems: this.mapAdaptableMenuItemToSystemMenuItems(structuredAdaptableMenuItems) }))
+                defaultAdaptableMenuItems, defaultAdaptableMenuStructure: this.mapAdaptableMenuItemToSystemMenuItems(adaptableDefaultStructure), defaultAgGridMenuStructure: agGridDefaultStructure }))
                 .filter(Boolean);
             return customMenuItems
                 .map((customMenuItem) => this.mapCustomMenuItemToAgGridMenuDefinition(customMenuItem, menuContext))
@@ -88,11 +104,27 @@ export class AgGridMenuAdapter {
         }
         // 2. if not, return the default context menu
         const defaultContextMenu = [
-            ...agGridMenuItems,
+            ...agGridDefaultStructure.map((agGridItem) => this.mapCustomMenuItemToAgGridMenuDefinition(agGridItem, menuContext)),
             'separator',
-            ...structuredAdaptableMenuItems.map((adaptableItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(adaptableItem)),
+            ...adaptableDefaultStructure.map((adaptableItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(adaptableItem)),
         ];
-        return defaultContextMenu;
+        return this.removeConsecutiveSeparators(defaultContextMenu);
+    }
+    mapAgGridItemTypeToAgGridMenuItem(itemName) {
+        return {
+            menuType: 'AgGrid',
+            name: itemName,
+        };
+    }
+    // due to entitlements or other reasons, some menu items might be hidden, leading to consecutive separators
+    removeConsecutiveSeparators(menuItems, separator = 'separator') {
+        return menuItems.reduce((acc, item, index, array) => {
+            if (item === separator && array[index + 1] === separator) {
+                return acc;
+            }
+            acc.push(item);
+            return acc;
+        }, []);
     }
     createColumnMenuContextObject(adaptableColumn, agGridColumn) {
         return Object.assign(Object.assign({}, this.adaptableInstance.api.internalApi.buildBaseContext()), { adaptableColumn: adaptableColumn, agGridColumn: agGridColumn, isRowGroupColumn: this.adaptableInstance.api.columnApi.isAutoRowGroupColumn(agGridColumn.getColId()) });
@@ -100,7 +132,7 @@ export class AgGridMenuAdapter {
     createAdaptableContextMenuItems(menuContext) {
         let contextMenuItems = [];
         this.adaptableInstance.adaptableModules.forEach((module) => {
-            let menuItems = module.addContextMenuItems(menuContext);
+            let menuItems = module.createContextMenuItems(menuContext);
             if (menuItems) {
                 contextMenuItems.push(...menuItems.filter(Boolean).filter((item) => item.isVisible !== false));
             }
@@ -140,6 +172,9 @@ export class AgGridMenuAdapter {
     }
     mapAdaptableMenuItemToAgGridMenuDefinition(adaptableMenuItem) {
         var _a;
+        if (adaptableMenuItem === '-') {
+            return 'separator';
+        }
         return {
             name: adaptableMenuItem.label,
             action: adaptableMenuItem.onClick
@@ -197,53 +232,345 @@ export class AgGridMenuAdapter {
             }).filter(Boolean),
         };
     }
-    buildGroupedModuleItems(sortedMenuItems, adaptableMenuItems) {
-        return sortedMenuItems
-            .map((moduleOrGroup) => {
-            if (typeof moduleOrGroup === 'object') {
-                const submenuItems = this.buildGroupedModuleItems(moduleOrGroup.modules, adaptableMenuItems);
-                // if there is only one item in the submenu, we don't need to show the submenu
-                if (submenuItems.length === 1) {
-                    return submenuItems[0];
-                }
-                return {
-                    label: moduleOrGroup.title,
-                    icon: moduleOrGroup.icon,
-                    subItems: submenuItems,
-                };
-            }
-            else {
-                return adaptableMenuItems.find((menuItem) => menuItem.module === moduleOrGroup);
-            }
-        })
-            .filter((menuItem) => {
-            if (!menuItem) {
-                return false;
-            }
-            if (menuItem.subItems && menuItem.subItems.length === 0) {
-                return false;
-            }
-            return true;
-        });
+    buildContextMenuDefaultStructure(availableMenuItems, menuContext) {
+        // Alert
+        const alertMenuItems = this.getModuleSpecificStructure('Alert', availableMenuItems);
+        // BulkUpdate
+        const bulkUpdateMenuItems = this.getModuleSpecificStructure('BulkUpdate', availableMenuItems);
+        // CalculatedColumn
+        const calculatedColumnMenuItems = this.getModuleSpecificStructure('CalculatedColumn', availableMenuItems);
+        // CellSummary
+        const cellSummaryMenuItems = this.getModuleSpecificStructure('CellSummary', availableMenuItems);
+        // ColumnFilter
+        const columnFilterMenuItems = this.getModuleSpecificStructure('ColumnFilter', availableMenuItems);
+        // ColumnInfo
+        const columnInfoMenuItems = this.getModuleSpecificStructure('ColumnInfo', availableMenuItems);
+        // Comment
+        const commentMenuItems = this.getModuleSpecificStructure('Comment', availableMenuItems);
+        // Dashboard
+        const dashboardMenuItems = this.getModuleSpecificStructure('Dashboard', availableMenuItems, 'dashboard-group');
+        // DataImport
+        const dataImportMenuItems = this.getModuleSpecificStructure('DataImport', availableMenuItems);
+        // Export
+        const exportMenuItems = this.getExportContextMenuStructure(availableMenuItems);
+        // FDC3
+        const fdc3MenuItems = this.getModuleSpecificStructure('Fdc3', availableMenuItems);
+        // FlashingCell
+        const flashingCellMenuItems = this.getModuleSpecificStructure('FlashingCell', availableMenuItems);
+        // GridInfo
+        const gridInfoMenuItems = this.getModuleSpecificStructure('GridInfo', availableMenuItems);
+        // Layout
+        const [gridActionItems, otherLayoutItems] = this.getLayoutContextMenuStructure(availableMenuItems);
+        // Note
+        const noteMenuItems = this.getModuleSpecificStructure('Note', availableMenuItems);
+        // SettingsPanel
+        const settingsPanelMenuItems = this.getModuleSpecificStructure('SettingsPanel', availableMenuItems);
+        // SmartEdit
+        const smartEditMenuItems = this.getModuleSpecificStructure('SmartEdit', availableMenuItems);
+        // SystemStatus
+        const systemStatusMenuItems = this.getModuleSpecificStructure('SystemStatus', availableMenuItems);
+        /**
+         * Custom structures
+         */
+        const gridMenuItem = {
+            name: 'grid-group',
+            label: 'Grid',
+            module: 'Group',
+            isVisible: true,
+            icon: {
+                name: 'grid',
+            },
+            subItems: [
+                ...gridActionItems,
+                ...otherLayoutItems,
+                ...cellSummaryMenuItems,
+                ...dataImportMenuItems,
+                ...systemStatusMenuItems,
+                ...gridInfoMenuItems,
+            ],
+        };
+        const editMenuItem = {
+            name: 'edit-group',
+            label: 'Edit',
+            module: 'Group',
+            isVisible: true,
+            icon: {
+                name: 'edit-table',
+            },
+            subItems: [...bulkUpdateMenuItems, ...smartEditMenuItems],
+        };
+        return this.removeConsecutiveSeparators([
+            ...exportMenuItems,
+            '-',
+            ...calculatedColumnMenuItems,
+            ...noteMenuItems,
+            ...commentMenuItems,
+            ...columnFilterMenuItems,
+            ...flashingCellMenuItems,
+            ...alertMenuItems,
+            ...fdc3MenuItems,
+            '-',
+            ...settingsPanelMenuItems,
+            ...dashboardMenuItems,
+            '-',
+            ...this.normalizeMenuGroup(editMenuItem),
+            '-',
+            ...this.normalizeMenuGroup(gridMenuItem),
+            ...columnInfoMenuItems
+        ], '-');
+    }
+    /**
+     * Hide menu group with no subitems or elevate single subitem to parent level
+     */
+    normalizeMenuGroup(menuItem) {
+        var _a, _b;
+        if (!((_a = menuItem.subItems) === null || _a === void 0 ? void 0 : _a.length)) {
+            return [];
+        }
+        if (((_b = menuItem.subItems) === null || _b === void 0 ? void 0 : _b.length) === 1) {
+            return [menuItem.subItems[0]];
+        }
+        return [menuItem];
+    }
+    /**
+     * Default strategy for menu items: return as is if there is only one item, otherwise group them under a parent item
+     */
+    getModuleSpecificStructure(module, menuItems, groupName) {
+        const moduleItems = menuItems.filter((menuItem) => menuItem.module === module);
+        if (moduleItems.length > 1) {
+            const moduleInfo = this.adaptableInstance.ModuleService.getModuleInfoByModule(module);
+            return [this.buildMenuGroupParent(module, moduleItems, { groupName })];
+        }
+        else {
+            return moduleItems;
+        }
+    }
+    getExportContextMenuStructure(menuItems) {
+        const exportMenuItems = menuItems.filter((menuItem) => menuItem.module === 'Export');
+        if (!exportMenuItems.length) {
+            return [];
+        }
+        const visualReportItems = exportMenuItems.filter((item) => item.name.startsWith('export-visual-data-excel'));
+        const visualDataExportItems = visualReportItems.length
+            ? [
+                this.buildMenuGroupParent('Export', exportMenuItems.filter((item) => item.name.startsWith('export-visual-data-excel')), {
+                    label: 'Visual Data',
+                    icon: 'export-data',
+                }),
+            ]
+            : [];
+        const allDataExportItems = this.normalizeMenuGroup(this.buildMenuGroupParent('Export', exportMenuItems.filter((item) => item.name.startsWith('export-all-data')), {
+            label: 'All Data',
+            icon: 'export-data',
+        }));
+        const currentDataExportItems = this.normalizeMenuGroup(this.buildMenuGroupParent('Export', exportMenuItems.filter((item) => item.name.startsWith('export-current-data')), {
+            label: 'Current Data',
+            icon: 'export-data',
+        }));
+        const selectedCellsExportItems = this.normalizeMenuGroup(this.buildMenuGroupParent('Export', exportMenuItems.filter((item) => item.name.startsWith('export-selected-cells')), {
+            label: 'Selected Cells',
+            icon: 'export-data',
+        }));
+        const selectedRowsExportItems = this.normalizeMenuGroup(this.buildMenuGroupParent('Export', exportMenuItems.filter((item) => item.name.startsWith('export-selected-rows')), {
+            label: 'Selected Rows',
+            icon: 'export-data',
+        }));
+        return this.normalizeMenuGroup(this.buildMenuGroupParent('Export', [
+            ...visualDataExportItems,
+            ...allDataExportItems,
+            ...currentDataExportItems,
+            ...selectedCellsExportItems,
+            ...selectedRowsExportItems,
+        ], {
+            label: 'Export',
+            icon: 'export',
+            groupName: 'export-group',
+        }));
+    }
+    getLayoutContextMenuStructure(menuItems) {
+        const layoutMenuItems = menuItems.filter((menuItem) => menuItem.module === 'Layout');
+        if (!layoutMenuItems.length) {
+            return [[], []];
+        }
+        const gridActionsItemNames = [
+            'layout-clear-selection',
+            'layout-select-all',
+            'layout-auto-size',
+        ];
+        const gridActionsItems = layoutMenuItems.filter((item) => gridActionsItemNames.includes(item.name));
+        const otherLayoutItems = layoutMenuItems.filter((item) => !gridActionsItemNames.includes(item.name));
+        return [gridActionsItems, otherLayoutItems];
+    }
+    buildMenuGroupParent(module, menuItems, config) {
+        var _a, _b, _c;
+        const moduleInfo = this.adaptableInstance.ModuleService.getModuleInfoByModule(module);
+        const icon = config && config.icon === false
+            ? undefined
+            : { name: (_a = config === null || config === void 0 ? void 0 : config.icon) !== null && _a !== void 0 ? _a : moduleInfo.Glyph };
+        return {
+            name: (_b = config === null || config === void 0 ? void 0 : config.groupName) !== null && _b !== void 0 ? _b : 'menu-group',
+            label: (_c = config === null || config === void 0 ? void 0 : config.label) !== null && _c !== void 0 ? _c : moduleInfo.FriendlyName,
+            isVisible: true,
+            module: moduleInfo.ModuleName,
+            icon,
+            subItems: menuItems,
+        };
+    }
+    buildColumnMenuDefaultStructure(availableMenuItems, menuContext) {
+        // CalculatedColumn
+        const calculatedColumnMenuItems = this.getModuleSpecificStructure('CalculatedColumn', availableMenuItems);
+        // CellSummary
+        const cellSummaryMenuItems = this.getModuleSpecificStructure('CellSummary', availableMenuItems);
+        // ColumnFilter
+        const [columnFilterGroup, filterVisibilityItems] = this.getColumnFilterColumnMenuStructure(availableMenuItems);
+        // ColumnInfo
+        const columnInfoMenuItems = this.getModuleSpecificStructure('ColumnInfo', availableMenuItems);
+        // CustomSort
+        const customSortMenuItems = this.getModuleSpecificStructure('CustomSort', availableMenuItems);
+        // Dashboard
+        const dashboardMenuItems = this.getModuleSpecificStructure('Dashboard', availableMenuItems, 'dashboard-group');
+        // DataImport
+        const dataImportMenuItems = this.getModuleSpecificStructure('DataImport', availableMenuItems);
+        // FlashingCell
+        const flashingCellMenuItems = this.getModuleSpecificStructure('FlashingCell', availableMenuItems);
+        // FormatColumn
+        const formatColumnMenuItems = this.getModuleSpecificStructure('FormatColumn', availableMenuItems);
+        // FreeTextColumn
+        const freeTextColumnMenuItems = this.getModuleSpecificStructure('FreeTextColumn', availableMenuItems);
+        // GridInfo
+        const gridInfoMenuItems = this.getModuleSpecificStructure('GridInfo', availableMenuItems);
+        // Layout
+        const [gridSelectItems, columnSelectItems, columnActionGroup, otherLayoutItems] = this.getLayoutColumnMenuStructure(availableMenuItems);
+        // PlusMinus
+        const plusMinusMenuItems = this.getModuleSpecificStructure('PlusMinus', availableMenuItems);
+        // SettingsPanel
+        const settingsPanelMenuItems = this.getModuleSpecificStructure('SettingsPanel', availableMenuItems);
+        // StyledColumn
+        const styledColumnMenuItems = this.getStyledColumnColumnMenuStructure(availableMenuItems);
+        // SystemStatus
+        const systemStatusMenuItems = this.getModuleSpecificStructure('SystemStatus', availableMenuItems);
+        /**
+         * Custom structures
+         */
+        const gridMenuItem = {
+            name: 'grid-group',
+            label: 'Grid',
+            module: 'Group',
+            isVisible: true,
+            icon: {
+                name: 'grid',
+            },
+            subItems: [
+                ...otherLayoutItems,
+                ...filterVisibilityItems,
+                ...gridSelectItems,
+                ...cellSummaryMenuItems,
+                ...dataImportMenuItems,
+                ...systemStatusMenuItems,
+                ...gridInfoMenuItems,
+            ],
+        };
+        const columnMenuItem = {
+            name: 'column-group',
+            label: 'Column',
+            module: 'Group',
+            isVisible: true,
+            icon: {
+                name: 'columns',
+            },
+            subItems: [
+                ...columnActionGroup,
+                ...calculatedColumnMenuItems,
+                ...freeTextColumnMenuItems,
+                ...customSortMenuItems,
+                ...plusMinusMenuItems,
+                ...columnSelectItems,
+                ...columnInfoMenuItems,
+            ],
+        };
+        const createStyleMenuItem = {
+            name: 'styling-group',
+            label: 'Styling',
+            module: 'Group',
+            isVisible: true,
+            icon: {
+                name: 'brush',
+            },
+            subItems: [...formatColumnMenuItems, ...styledColumnMenuItems, ...flashingCellMenuItems],
+        };
+        return this.removeConsecutiveSeparators([
+            ...settingsPanelMenuItems,
+            ...dashboardMenuItems,
+            ...columnFilterGroup,
+            ...this.normalizeMenuGroup(createStyleMenuItem),
+            ...this.normalizeMenuGroup(gridMenuItem),
+            ...this.normalizeMenuGroup(columnMenuItem),
+        ], '-');
+    }
+    getColumnFilterColumnMenuStructure(menuItems) {
+        const columnFilterMenuItems = menuItems.filter((menuItem) => menuItem.module === 'ColumnFilter');
+        const filterVisibilityItems = columnFilterMenuItems.filter((item) => ['column-filter-bar-hide', 'column-filter-bar-show'].includes(item.name));
+        const filterActionItems = columnFilterMenuItems.filter((item) => ['column-filter-clear', 'column-filter-suspend', 'column-filter-unsuspend'].includes(item.name));
+        const columnFilterGroup = filterActionItems.length
+            ? [
+                {
+                    name: 'column-filter-group',
+                    label: 'Filter',
+                    module: 'ColumnFilter',
+                    isVisible: true,
+                    icon: {
+                        name: 'filter',
+                    },
+                    subItems: filterActionItems,
+                },
+            ]
+            : [];
+        return [columnFilterGroup, filterVisibilityItems];
+    }
+    getLayoutColumnMenuStructure(menuItems) {
+        const layoutMenuItems = menuItems.filter((menuItem) => menuItem.module === 'Layout');
+        if (!layoutMenuItems.length) {
+            return [[], [], [], []];
+        }
+        const columnSelectItemNames = [
+            'layout-column-select-preserve',
+            'layout-column-select-reset',
+            'layout-column-select',
+        ];
+        const columnSelectItems = layoutMenuItems.filter((item) => columnSelectItemNames.includes(item.name));
+        const gridSelectItems = layoutMenuItems.filter((item) => item.name === 'layout-grid-select');
+        const columnActionGroup = layoutMenuItems.filter((item) => ['layout-column-caption-change', 'layout-column-hide'].includes(item.name));
+        const otherLayoutItems = layoutMenuItems.filter((item) => !columnSelectItemNames.includes(item.name) &&
+            !['layout-column-caption-change', 'layout-column-hide'].includes(item.name) &&
+            item.name !== 'layout-grid-select');
+        return [gridSelectItems, columnSelectItems, columnActionGroup, otherLayoutItems];
+    }
+    getStyledColumnColumnMenuStructure(menuItems) {
+        const styledColumnMenuItems = menuItems.filter((menuItem) => menuItem.module === 'StyledColumn');
+        return styledColumnMenuItems;
     }
     mapAdaptableMenuItemToSystemMenuItems(adaptableMenuItems) {
-        return (adaptableMenuItems !== null && adaptableMenuItems !== void 0 ? adaptableMenuItems : []).map((menuItem) => {
-            let subItems = menuItem.subItems;
-            if (subItems && subItems.length > 0) {
-                subItems = subItems.map((subItem) => this.mapAdaptableMenuItemToSystemMenuItems(subItem.subItems));
+        if (!adaptableMenuItems) {
+            return;
+        }
+        return adaptableMenuItems.map((menuItem) => {
+            if (menuItem === '-') {
+                return menuItem;
             }
+            // @ts-ignore
+            const subItems = this.mapAdaptableMenuItemToSystemMenuItems(menuItem.subItems);
             return Object.assign(Object.assign({}, menuItem), { menuType: 'Adaptable', subItems });
         });
     }
     createAdaptableColumnMenuItems(menuContext) {
-        let contextMenuItems = [];
+        let columnMenuItems = [];
         this.adaptableInstance.adaptableModules.forEach((s) => {
-            let menuItems = s.addColumnMenuItems(menuContext.adaptableColumn);
+            let menuItems = s.createColumnMenuItems(menuContext.adaptableColumn);
             if (menuItems) {
-                contextMenuItems.push(...menuItems.filter(Boolean).filter((item) => item.isVisible !== false));
+                columnMenuItems.push(...menuItems.filter(Boolean).filter((item) => item.isVisible !== false));
             }
         });
-        return contextMenuItems;
+        return columnMenuItems;
     }
     // TODO AFL MIG: pretty sure this logic is duplicated in several other places
     mapAdaptableIconToAgGridIcon(adaptableIcon, style) {
@@ -263,9 +590,13 @@ export class AgGridMenuAdapter {
             });
         }
     }
+    /**
+     * The output of this function is used to build the column header menu if the AG Grid Menu Module is NOT present
+     * This is controlled by the AdaptableAgGrid.embedColumnMenu property
+     */
     buildStandaloneColumnHeader(adaptableColumn) {
         const agGridColumn = this.adaptableInstance.getAgGridColumnForColumnId(adaptableColumn.columnId);
         const menuContext = this.createColumnMenuContextObject(adaptableColumn, agGridColumn);
-        return this.buildStructuredAdaptableColumnItems(menuContext).adaptableMenuItems;
+        return this.createAdaptableColumnMenuItems(menuContext);
     }
 }

package/src/agGrid/AgGridOptionsService.d.ts

@@ -1,5 +1,5 @@
 import { AdaptableAgGrid } from './AdaptableAgGrid';
-import { GridOptions } from '@ag-grid-community/core';
+import { GridOptions, ManagedGridOptionKey } from '@ag-grid-community/core';
 export declare class AgGridOptionsService {
     private adaptableInstance;
     private gridOptionsPropertyCache;
@@ -7,6 +7,9 @@ export declare class AgGridOptionsService {
     constructor(adaptableInstance: AdaptableAgGrid);
     destroy(): void;
     setGridOptionsProperty<T extends keyof GridOptions>(gridOptions: GridOptions, propertyName: T, propertyGetter: (userPropertyValue: GridOptions[T]) => GridOptions[T] | undefined): GridOptions;
+    getUserGridOptionsProperty<T extends keyof GridOptions>(propertyName: T): GridOptions[T];
+    revertGridOptionsPropertyToUserValue(propertyName: ManagedGridOptionKey): void;
+    CAREFUL_patchGridOptionsProperty<T extends keyof GridOptions>(propertyName: T, value: GridOptions[T]): void;
     revertGridOptionsPropertiesToUserValue<T extends keyof GridOptions>(gridOptions: GridOptions, propertyNames: T[]): void;
     private get agGridAdapter();
 }

package/src/agGrid/AgGridOptionsService.js

@@ -40,6 +40,28 @@ export class AgGridOptionsService {
         gridOptions[propertyName] = adaptableValue !== null && adaptableValue !== void 0 ? adaptableValue : userValue;
         return gridOptions;
     }
+    getUserGridOptionsProperty(propertyName) {
+        const userKey = `user.${propertyName}`;
+        return this.gridOptionsPropertyCache.get(userKey);
+    }
+    revertGridOptionsPropertyToUserValue(propertyName) {
+        const userKey = `user.${propertyName}`;
+        const userValue = this.gridOptionsPropertyCache.get(userKey);
+        this.agGridAdapter.setGridOption(propertyName, userValue);
+    }
+    CAREFUL_patchGridOptionsProperty(propertyName, value) {
+        var _a;
+        // @ts-ignore this is required to set gridOptions peroperties which are marked as initial (writable once, before grid is initialised)
+        const gos = (_a = this.agGridAdapter.getAgGridApi()) === null || _a === void 0 ? void 0 : _a.gos;
+        if (gos) {
+            gos.updateGridOptions({
+                options: {
+                    [propertyName]: value,
+                },
+                source: 'api',
+            });
+        }
+    }
     revertGridOptionsPropertiesToUserValue(gridOptions, propertyNames) {
         for (const propertyName of propertyNames) {
             // see this.setGridOptionsProperty(...)

package/src/agGrid/BadgeRenderer.d.ts

@@ -1,4 +1,4 @@
-import { StyledColumn } from '../PredefinedConfig/StyledColumnState';
+import { BadgeStyle } from '../PredefinedConfig/StyledColumnState';
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
-export declare const getBadgeRendererForColumn: (styledColumn: StyledColumn, abColumn: AdaptableColumn, api: AdaptableApi) => any;
+export declare const getBadgeRendererForColumn: (badgeStyle: BadgeStyle, abColumn: AdaptableColumn, api: AdaptableApi) => any;