@adaptabletools/adaptable 18.0.0-canary.4 → 18.0.0-canary.6

package/src/agGrid/agGridMenuHelper.js

@@ -1,668 +0,0 @@
-import { ArrayExtensions } from '../Utilities/Extensions/ArrayExtensions';
-import { iconToString } from '../components/icons';
-import flatten from 'lodash/flatten';
-import { isAdaptableElementIcon } from '../components/Icon';
-import { logDeprecation } from '../Utilities/logDeprecation';
-import { DEFAULT_ADAPTABLE_COLUMN_MENU_STRUCTURE, DEFAULT_ADAPTABLE_CONTEXT_MENU_STRUCTURE, } from '../AdaptableOptions/MenuOptions';
-// tslint:disable-next-line: class-name
-export class agGridMenuHelper {
-    constructor(adaptable, gridOptions) {
-        this.adaptable = adaptable;
-        this.gridOptions = gridOptions;
-        this.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;
-            });
-        };
-    }
-    destroy() {
-        this.adaptable = null;
-        this.gridOptions = null;
-    }
-    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));
-            }
-            return Object.assign(Object.assign({}, menuItem), { menuType: 'Adaptable', subItems });
-        });
-    }
-    buildColumnMenu(params, originalGetMainMenuItems) {
-        var _a;
-        const menuOptions = this.adaptable.adaptableOptions.menuOptions;
-        const hasDeprecatedOptions = this.logMenuDeprecation('ColumnMenu');
-        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 adaptableColumn = this.adaptable.api.columnApi.getColumnWithColumnId((_a = params.column) === null || _a === void 0 ? void 0 : _a.getColId());
-        const menuContext = this.createColumnMenuContextObject(adaptableColumn, params.column);
-        const adaptableMenuItems = this.createAdaptableColumnMenuItems(menuContext);
-        // sort Adaptable menu items by default order
-        const structuredAdaptableMenuItems = this.buildGroupedModuleItems(DEFAULT_ADAPTABLE_COLUMN_MENU_STRUCTURE, adaptableMenuItems);
-        // 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,
-            }));
-            const defaultAdaptableMenuItems = adaptableMenuItems.map((adaptableItem) => (Object.assign({ menuType: 'Adaptable' }, adaptableItem)));
-            const customMenuItems = menuOptions
-                .customColumnMenu(Object.assign(Object.assign({}, menuContext), { defaultAgGridMenuItems,
-                defaultAdaptableMenuItems, structuredAdaptableMenuItems: this.mapAdaptableMenuItemToSystemMenuItems(structuredAdaptableMenuItems) }))
-                .filter(Boolean);
-            return customMenuItems
-                .map((customMenuItem) => this.mapCustomMenuItemToAgGridMenuDefinition(customMenuItem, menuContext))
-                .filter(Boolean);
-        }
-        if (hasDeprecatedOptions) {
-            return this.buildColumnMenuDeprecated(params, originalGetMainMenuItems);
-        }
-        // 2. if not, return the default context menu
-        const defaultContextMenu = [
-            ...agGridMenuItems,
-            'separator',
-            ...structuredAdaptableMenuItems.map((adaptableItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(adaptableItem)),
-        ];
-        return defaultContextMenu;
-    }
-    buildContextMenu(params, originalGetContextMenuItems) {
-        var _a;
-        // 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.adaptable.setSelectedCells();
-        const menuOptions = this.adaptable.adaptableOptions.menuOptions;
-        const hasDeprecatedOptions = this.logMenuDeprecation('ContextMenu');
-        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 adaptableColumn = this.adaptable.api.columnApi.getColumnWithColumnId((_a = params.column) === null || _a === void 0 ? void 0 : _a.getColId());
-        const menuContext = this.createContextMenuContextObject(params, adaptableColumn);
-        const adaptableMenuItems = this.createAdaptableContextMenuItems(menuContext);
-        // sort Adaptable menu items by default order
-        const structuredAdaptableMenuItems = this.buildGroupedModuleItems(DEFAULT_ADAPTABLE_CONTEXT_MENU_STRUCTURE, adaptableMenuItems);
-        // 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,
-            }));
-            const defaultAdaptableMenuItems = adaptableMenuItems.map((adaptableItem) => (Object.assign({ menuType: 'Adaptable' }, adaptableItem)));
-            const customMenuItems = menuOptions
-                .customContextMenu(Object.assign(Object.assign({}, menuContext), { defaultAgGridMenuItems,
-                defaultAdaptableMenuItems, structuredAdaptableMenuItems: this.mapAdaptableMenuItemToSystemMenuItems(structuredAdaptableMenuItems) }))
-                .filter(Boolean);
-            return customMenuItems
-                .map((customMenuItem) => this.mapCustomMenuItemToAgGridMenuDefinition(customMenuItem, menuContext))
-                .filter(Boolean);
-        }
-        if (hasDeprecatedOptions) {
-            return this.buildContextMenuDeprecated(params, originalGetContextMenuItems);
-        }
-        // 2. if not, return the default context menu
-        const defaultContextMenu = [
-            ...agGridMenuItems,
-            'separator',
-            ...structuredAdaptableMenuItems.map((adaptableItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(adaptableItem)),
-        ];
-        return defaultContextMenu;
-    }
-    createAdaptableColumnMenuItems(menuContext) {
-        let contextMenuItems = [];
-        this.adaptable.adaptableModules.forEach((s) => {
-            let menuItems = s.addColumnMenuItems(menuContext.adaptableColumn);
-            if (menuItems) {
-                contextMenuItems.push(...menuItems.filter(Boolean).filter((item) => item.isVisible !== false));
-            }
-        });
-        return contextMenuItems;
-    }
-    mapCustomMenuItemToAgGridMenuDefinition(customMenuItem, menuContext) {
-        var _a;
-        if (customMenuItem === '-') {
-            return 'separator';
-        }
-        if (customMenuItem.menuType === 'Group') {
-            return {
-                name: customMenuItem.label,
-                icon: this.mapAdaptableIconToAgGridIcon(customMenuItem.icon, {
-                    fill: 'var(--ab-color-text-on-primary)',
-                }),
-                disabled: customMenuItem.disabled,
-                subMenu: !customMenuItem.disabled
-                    ? (_a = customMenuItem.subMenuItems) === null || _a === void 0 ? void 0 : _a.map((subMenuItem) => this.mapCustomMenuItemToAgGridMenuDefinition(subMenuItem, menuContext)).filter(Boolean)
-                    : undefined,
-            };
-        }
-        if (customMenuItem.menuType === 'AgGrid') {
-            return customMenuItem.name;
-        }
-        if (customMenuItem.menuType === 'Adaptable') {
-            return this.mapAdaptableMenuItemToAgGridMenuDefinition(customMenuItem);
-        }
-        if (customMenuItem.menuType === 'User') {
-            return this.mapUserMenuItemToAgGridMenuDefinition(customMenuItem, menuContext);
-        }
-    }
-    mapAdaptableMenuItemToAgGridMenuDefinition(adaptableMenuItem) {
-        var _a;
-        return {
-            name: adaptableMenuItem.label,
-            action: adaptableMenuItem.onClick
-                ? adaptableMenuItem.onClick
-                : adaptableMenuItem.reduxAction
-                    ? () => this.adaptable.api.internalApi.dispatchReduxAction(adaptableMenuItem.reduxAction)
-                    : undefined,
-            icon: this.mapAdaptableIconToAgGridIcon(adaptableMenuItem.icon, {
-                fill: 'var(--ab-color-text-on-primary)',
-            }),
-            subMenu: (_a = adaptableMenuItem.subItems) === null || _a === void 0 ? void 0 : _a.map((subMenuItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(subMenuItem)),
-        };
-    }
-    mapUserMenuItemToAgGridMenuDefinition(userMenuItem, menuContext) {
-        var _a;
-        if (userMenuItem.hidden) {
-            return;
-        }
-        return {
-            name: userMenuItem.label,
-            action: () => (userMenuItem.onClick ? userMenuItem.onClick(menuContext) : null),
-            icon: this.mapAdaptableIconToAgGridIcon(userMenuItem.icon, {
-                fill: 'var(--ab-color-text-on-primary)',
-            }),
-            disabled: userMenuItem.disabled,
-            subMenu: (_a = userMenuItem.subMenuItems) === null || _a === void 0 ? void 0 : _a.map((subMenuItem) => {
-                return this.mapCustomMenuItemToAgGridMenuDefinition(subMenuItem, menuContext);
-            }).filter(Boolean),
-        };
-    }
-    logMenuDeprecation(type) {
-        let hasDeprecatedOptions = false;
-        if (type === 'ColumnMenu') {
-            // if any of the deprecated options has a non-default value, log a deprecation warning
-            const deprecatedProps = [
-                'columnMenuItems',
-                'columnMenuOrder',
-                'showAdaptableColumnMenu',
-            ];
-            deprecatedProps.forEach((propName) => {
-                var _a, _b;
-                if ((_b = (_a = this.adaptable._rawAdaptableOptions) === null || _a === void 0 ? void 0 : _a.menuOptions) === null || _b === void 0 ? void 0 : _b[propName]) {
-                    logDeprecation(this.adaptable.logger, 'MenuOptions', propName, 'customColumnMenu');
-                    hasDeprecatedOptions = true;
-                }
-            });
-        }
-        if (type === 'ContextMenu') {
-            // if any of the deprecated options has a non-default value, log a deprecation warning
-            const deprecatedProps = [
-                'contextMenuItems',
-                'contextMenuOrder',
-                'showAdaptableContextMenu',
-            ];
-            deprecatedProps.forEach((propName) => {
-                var _a, _b;
-                if ((_b = (_a = this.adaptable._rawAdaptableOptions) === null || _a === void 0 ? void 0 : _a.menuOptions) === null || _b === void 0 ? void 0 : _b[propName]) {
-                    logDeprecation(this.adaptable.logger, 'MenuOptions', propName, 'customContextMenu');
-                    hasDeprecatedOptions = true;
-                }
-            });
-        }
-        return hasDeprecatedOptions;
-    }
-    createAgGridMenuDefFromAdaptableMenu(adaptableMenuItem) {
-        const subMenuItems = ArrayExtensions.IsNotNullOrEmpty(adaptableMenuItem.subItems)
-            ? adaptableMenuItem.subItems.map((amu) => {
-                return this.createAgGridMenuDefFromAdaptableMenu(amu);
-            })
-            : undefined;
-        return {
-            name: adaptableMenuItem.label,
-            action: adaptableMenuItem.onClick
-                ? adaptableMenuItem.onClick
-                : adaptableMenuItem.reduxAction
-                    ? () => this.adaptable.api.internalApi.dispatchReduxAction(adaptableMenuItem.reduxAction)
-                    : undefined,
-            icon: this.mapAdaptableIconToAgGridIcon(adaptableMenuItem.icon, {
-                fill: 'var(--ab-color-text-on-primary)',
-            }),
-            subMenu: subMenuItems,
-        };
-    }
-    createAgGridColumnMenuDefFromUserMenu(menuItem, menuContext) {
-        const fn = menuItem.onClick;
-        const disabled = menuItem.disabled && menuItem.disabled(menuContext);
-        const icon = typeof menuItem.icon === 'function' ? menuItem.icon(menuContext) : menuItem.icon;
-        return {
-            name: this.getLabelFromUserColumnMenuItem(menuItem, menuContext),
-            action: () => (fn ? fn(menuContext) : null),
-            icon: this.mapAdaptableIconToAgGridIcon(icon, {
-                fill: 'var(--ab-color-text-on-primary)',
-            }),
-            disabled: disabled,
-            subMenu: ArrayExtensions.IsNullOrEmpty(menuItem.subMenuItems)
-                ? undefined
-                : menuItem.subMenuItems.map((subMenuItem) => {
-                    return this.createAgGridColumnMenuDefFromUserMenu(subMenuItem, menuContext);
-                }),
-        };
-    }
-    createAgGridContextMenuDefFromUserMenu(menuItem, menuContext) {
-        const fn = menuItem.onClick;
-        const disabled = menuItem.disabled && menuItem.disabled(menuContext);
-        const icon = typeof menuItem.icon === 'function' ? menuItem.icon(menuContext) : menuItem.icon;
-        return {
-            name: this.getLabelFromUserContextMenuItem(menuItem, menuContext),
-            action: () => (fn ? fn(menuContext) : null),
-            icon: this.mapAdaptableIconToAgGridIcon(icon, {
-                fill: 'var(--ab-color-text-on-primary)',
-            }),
-            disabled: disabled,
-            subMenu: ArrayExtensions.IsNullOrEmpty(menuItem.subMenuItems)
-                ? undefined
-                : menuItem.subMenuItems.map((subMenuItem) => {
-                    return this.createAgGridContextMenuDefFromUserMenu(subMenuItem, menuContext);
-                }),
-        };
-    }
-    mapAdaptableIconToAgGridIcon(adaptableIcon, style) {
-        const icon = this.adaptable.api.userInterfaceApi.internalApi.prepareAdaptableIconDef(adaptableIcon);
-        if (isAdaptableElementIcon(icon)) {
-            let element = icon.element;
-            if (typeof element === 'string') {
-                return element;
-            }
-            // THe element neets to be cloned.
-            // when it is used in more than one plce the element is removed from the DOM
-            return element.cloneNode(true);
-        }
-        else {
-            return iconToString(icon, {
-                fill: 'var(--ab-color-text-on-primary)',
-            });
-        }
-    }
-    createAdaptableColumnMenuItemFromUserMenu(menuItem, menuContext) {
-        const fn = menuItem.onClick;
-        let adaptableMenuItem = {
-            module: 'General',
-            label: this.getLabelFromUserColumnMenuItem(menuItem, menuContext),
-            reduxAction: null,
-            onClick: () => (fn ? fn(menuContext) : null),
-            isVisible: true,
-            icon: menuItem.icon,
-        };
-        return adaptableMenuItem;
-    }
-    createAgGridColumnMenuItems(originalgetMainMenuItems, params) {
-        // if there was an initial implementation we init the list of menu items with this one; otherwise we take the default items
-        return originalgetMainMenuItems
-            ? originalgetMainMenuItems(params)
-            : params.defaultItems.slice(0);
-    }
-    createAdaptableColumnMenuItems_DEPRECATED(adaptableColumn, menuContext) {
-        let columnMenuItems = [];
-        // First get all the Module based Adaptable Menu Items
-        const adaptableMenuItems = this.getAdaptableMenuItemsColumnHeader(adaptableColumn, menuContext);
-        // sort Adaptable menu items by default order
-        adaptableMenuItems.sort((first, second) => {
-            const firstPriority = DEFAULT_ADAPTABLE_COLUMN_MENU_STRUCTURE.indexOf(first.module);
-            const secondPriority = DEFAULT_ADAPTABLE_COLUMN_MENU_STRUCTURE.indexOf(second.module);
-            return firstPriority - secondPriority;
-        });
-        // And then convert them into Menu Item Defs
-        adaptableMenuItems.forEach((adaptableMenuItem) => {
-            let menuItem = this.createAgGridMenuDefFromAdaptableMenu(adaptableMenuItem);
-            columnMenuItems.push(menuItem);
-        });
-        return columnMenuItems;
-    }
-    createUserColumnMenuItems(menuContext) {
-        let columnMenuItems = [];
-        let userColumnMenuItems = this.getUserMenuItemsColumnHeader(menuContext);
-        if (ArrayExtensions.IsNotNullOrEmpty(userColumnMenuItems)) {
-            userColumnMenuItems.forEach((userMenuItem) => {
-                // And then convert them into Menu Item Defs
-                let menuItem = this.createAgGridColumnMenuDefFromUserMenu(userMenuItem, menuContext);
-                columnMenuItems.push(menuItem);
-            });
-        }
-        return columnMenuItems;
-    }
-    createColumnMenuContextObject(adaptableColumn, agGridColumn) {
-        return {
-            adaptableColumn: adaptableColumn,
-            agGridColumn: agGridColumn,
-            adaptableApi: this.adaptable.api,
-            userName: this.adaptable.adaptableOptions.userName,
-            adaptableId: this.adaptable.adaptableOptions.adaptableId,
-            isRowGroupColumn: this.adaptable.api.columnApi.isAutoRowGroupColumn(agGridColumn.getColId()),
-        };
-    }
-    createContextMenuContextObject(params, adaptableColumn) {
-        // lets build a picture of what has been right clicked.  Will take time to get right but lets start
-        let isSingleSelectedColumn = false;
-        let isSelectedCell = false;
-        let isSelectedRow = false;
-        // row group columns dont provide an AdapTable Column so return bare minimum
-        if (!adaptableColumn) {
-            return {
-                isSelectedCell: false,
-                isSelectedRow: false,
-                gridCell: undefined,
-                adaptableColumn: undefined,
-                agGridColumn: params.column,
-                rowNode: params.node,
-                isGroupedNode: params.node ? params.node.group : false,
-                isSingleSelectedColumn: false,
-                isSingleSelectedCell: false,
-                primaryKeyValue: undefined,
-                adaptableApi: this.adaptable.api,
-                userName: this.adaptable.adaptableOptions.userName,
-                adaptableId: this.adaptable.adaptableOptions.adaptableId,
-                selectedCellInfo: undefined,
-                selectedRowInfo: undefined,
-                isRowGroupColumn: this.adaptable.api.columnApi.isAutoRowGroupColumn(params.column.getColId()),
-            };
-        }
-        const clickedCell = this.adaptable.getGridCellFromRowNode(params.node, adaptableColumn.columnId);
-        const selectedCellInfo = this.adaptable.api.gridApi.getSelectedCellInfo();
-        if (selectedCellInfo) {
-            let matchedCell = selectedCellInfo.gridCells.find((gc) => gc != null &&
-                gc.column == clickedCell.column &&
-                gc.primaryKeyValue == clickedCell.primaryKeyValue);
-            isSelectedCell = matchedCell != null;
-            if (isSelectedCell) {
-                isSingleSelectedColumn = ArrayExtensions.CorrectLength(selectedCellInfo.columns, 1);
-            }
-        }
-        const selectedRowInfo = this.adaptable.api.gridApi.getSelectedRowInfo();
-        if (selectedRowInfo) {
-            const matchedPKValue = selectedRowInfo.gridRows.find((gr) => gr != null && gr.primaryKeyValue == clickedCell.primaryKeyValue);
-            isSelectedRow = matchedPKValue != null;
-        }
-        return {
-            isSelectedCell: isSelectedCell,
-            isSelectedRow: isSelectedRow,
-            gridCell: clickedCell,
-            adaptableColumn: adaptableColumn,
-            agGridColumn: params.column,
-            rowNode: params.node,
-            isGroupedNode: params.node ? params.node.group : false,
-            isSingleSelectedColumn: isSingleSelectedColumn,
-            isSingleSelectedCell: isSelectedCell && (selectedCellInfo === null || selectedCellInfo === void 0 ? void 0 : selectedCellInfo.gridCells.length) == 1,
-            primaryKeyValue: clickedCell ? clickedCell.primaryKeyValue : undefined,
-            adaptableApi: this.adaptable.api,
-            userName: this.adaptable.adaptableOptions.userName,
-            adaptableId: this.adaptable.adaptableOptions.adaptableId,
-            selectedCellInfo: selectedCellInfo,
-            selectedRowInfo: selectedRowInfo,
-            isRowGroupColumn: this.adaptable.api.columnApi.isAutoRowGroupColumn(params.column.getColId()),
-        };
-    }
-    createAgGridContextMenuItems(originalgetContextMenuItems, params) {
-        // if there was an initial implementation we init the list of menu items with this one, otherwise we take default items
-        // this allows us to ensure that devs can still create their own agGrid context menu without losing ours
-        return originalgetContextMenuItems
-            ? originalgetContextMenuItems(params).slice(0)
-            : params.defaultItems
-                ? params.defaultItems.slice(0)
-                : [];
-    }
-    createAdaptableContextMenuItems(menuContext) {
-        let contextMenuItems = [];
-        this.adaptable.adaptableModules.forEach((module) => {
-            let menuItems = module.addContextMenuItems(menuContext);
-            if (menuItems) {
-                contextMenuItems.push(...menuItems.filter(Boolean).filter((item) => item.isVisible !== false));
-            }
-        });
-        this.adaptable._emitSync('CreateAdaptableContextMenuItems', {
-            items: contextMenuItems,
-            menuContext: menuContext,
-        });
-        return contextMenuItems;
-    }
-    createAgGridAdaptableContextMenuItems(adaptableMenuItems, menuContext) {
-        // here we create agGrid Menu items based on Adaptable Menu Items
-        // user has ability to decide whether to show or not
-        let contextMenuItems = [];
-        let showAdaptableContextMenu = this.adaptable.adaptableOptions.menuOptions.showAdaptableContextMenu;
-        if (showAdaptableContextMenu == null || showAdaptableContextMenu !== false) {
-            adaptableMenuItems.forEach((adaptableMenuItem) => {
-                if (adaptableMenuItem) {
-                    let addContextMenuItem = true;
-                    if (showAdaptableContextMenu != null && typeof showAdaptableContextMenu === 'function') {
-                        addContextMenuItem = showAdaptableContextMenu(adaptableMenuItem, menuContext);
-                    }
-                    if (addContextMenuItem) {
-                        let menuItem = this.createAgGridMenuDefFromAdaptableMenu(adaptableMenuItem);
-                        contextMenuItems.push(menuItem);
-                    }
-                }
-            });
-        }
-        return contextMenuItems;
-    }
-    createAgGridUserContextMenuItems(userContextMenuItems, menuContext) {
-        // here we create agGrid Menu items based on Adaptable Menu Items
-        // user has ability to decide whether to show or not
-        let contextMenuItems = [];
-        userContextMenuItems
-            .filter((userMenuItem) => !!userMenuItem)
-            .filter((userMenuItem) => {
-            return userMenuItem.hidden ? !userMenuItem.hidden(menuContext) : true;
-        })
-            .forEach((userMenuItem) => {
-            let menuItem = this.createAgGridContextMenuDefFromUserMenu(userMenuItem, menuContext);
-            contextMenuItems.push(menuItem);
-        });
-        return contextMenuItems;
-    }
-    // method to get all the Adaptable Menu Items - together with running the function where user can choose whether or not to display
-    getAdaptableMenuItemsColumnHeader(adaptableColumn, menuContext) {
-        const adaptableMenuItems = [];
-        let showAdaptableColumnMenu = this.adaptable.adaptableOptions.menuOptions.showAdaptableColumnMenu;
-        let runCheck = showAdaptableColumnMenu == null || showAdaptableColumnMenu !== false;
-        //  if (adaptableColumn != null) {
-        this.adaptable.adaptableModules.forEach((s) => {
-            let menuItems = s.addColumnMenuItems(adaptableColumn);
-            if (menuItems) {
-                if (runCheck) {
-                    menuItems.forEach((adaptableMenuItem) => {
-                        if (adaptableMenuItem) {
-                            let addColumnMenuItem = true;
-                            if (showAdaptableColumnMenu != null &&
-                                typeof showAdaptableColumnMenu === 'function') {
-                                addColumnMenuItem = showAdaptableColumnMenu(adaptableMenuItem, menuContext);
-                            }
-                            if (addColumnMenuItem) {
-                                adaptableMenuItems.push(adaptableMenuItem);
-                            }
-                        }
-                    });
-                }
-                else {
-                    adaptableMenuItems.push(...menuItems);
-                }
-            }
-        });
-        //  }
-        return adaptableMenuItems;
-    }
-    getLabelFromUserColumnMenuItem(userColumnMenuItem, menuContext) {
-        return typeof userColumnMenuItem.label === 'function'
-            ? userColumnMenuItem.label(menuContext)
-            : userColumnMenuItem.label;
-    }
-    getLabelFromUserContextMenuItem(userContextMenuItem, menuContext) {
-        return typeof userContextMenuItem.label === 'function'
-            ? userContextMenuItem.label(menuContext)
-            : userContextMenuItem.label;
-    }
-    getUserMenuItemsColumnHeader(menuContext) {
-        var _a, _b;
-        return (_b = (_a = this.adaptable.adaptableOptions.menuOptions) === null || _a === void 0 ? void 0 : _a.columnMenuItems) === null || _b === void 0 ? void 0 : _b.filter((userMenuItem) => {
-            return userMenuItem.hidden ? !userMenuItem.hidden(menuContext) : true;
-        });
-    }
-    buildStandaloneColumnHeader(adaptableColumn) {
-        const agGridColumn = this.adaptable.api.columnApi.internalApi.getAgGridColumnForAdaptableColumn(adaptableColumn.columnId);
-        let menuContext = this.createColumnMenuContextObject(adaptableColumn, agGridColumn);
-        let returnMenuItems = [];
-        returnMenuItems.push(...this.getAdaptableMenuItemsColumnHeader(adaptableColumn, menuContext));
-        let userColumnMenuItems = this.getUserMenuItemsColumnHeader(menuContext);
-        if (ArrayExtensions.IsNotNullOrEmpty(userColumnMenuItems)) {
-            userColumnMenuItems.forEach((userMenuItem) => {
-                let adaptableMenuItem = this.createAdaptableColumnMenuItemFromUserMenu(userMenuItem, menuContext);
-                returnMenuItems.push(adaptableMenuItem);
-            });
-        }
-        return returnMenuItems;
-    }
-    /**
-     *  !!! This should be deleted once MenuOptions loses all the deprecated options
-     */
-    buildContextMenuDeprecated(params, originalGetContextMenuItems) {
-        let agGridContextMenuItems = [];
-        let adaptableContextMenuItems = [];
-        let userContextMenuItems = [];
-        const menuOptions = this.adaptable.adaptableOptions.menuOptions;
-        let showAdaptableContextMenu = menuOptions.showAdaptableContextMenu;
-        let hasAdaptableContextMenuItems = showAdaptableContextMenu == null || showAdaptableContextMenu !== false;
-        let userDefinedContextMenuItems = menuOptions.contextMenuItems;
-        let hasUserDefinedContextMenuItems = ArrayExtensions.IsNotNullOrEmpty(userDefinedContextMenuItems);
-        const agGridMenuItems = this.createAgGridContextMenuItems(originalGetContextMenuItems, params);
-        if (agGridMenuItems === null || agGridMenuItems === void 0 ? void 0 : agGridMenuItems.length) {
-            agGridContextMenuItems.push(...agGridMenuItems);
-            if (hasAdaptableContextMenuItems || hasUserDefinedContextMenuItems) {
-                agGridContextMenuItems.push('separator');
-            }
-        }
-        const adaptableMenuItems = [];
-        const agGridColumn = params.column;
-        let adaptableColumn;
-        if (agGridColumn) {
-            adaptableColumn = this.adaptable.api.columnApi.getColumnWithColumnId(agGridColumn.getColId());
-            // if (adaptableColumn != undefined) {
-            let menuContext = this.createContextMenuContextObject(params, adaptableColumn);
-            // keep it simple for now - if its a grouped cell then don't add the shipped menu items
-            // if (adaptableColumn && !params.node.group) {
-            const allAdaptableMenuItems = this.createAdaptableContextMenuItems(menuContext);
-            if (ArrayExtensions.IsNotNullOrEmpty(allAdaptableMenuItems)) {
-                adaptableMenuItems.push(...allAdaptableMenuItems);
-            }
-            adaptableMenuItems.sort((first, second) => {
-                const firstPriority = DEFAULT_ADAPTABLE_CONTEXT_MENU_STRUCTURE.indexOf(first.module);
-                const secondPriority = DEFAULT_ADAPTABLE_CONTEXT_MENU_STRUCTURE.indexOf(second.module);
-                return firstPriority - secondPriority;
-            });
-            // }
-            // create agGrid Menu items based on Adaptable Menu Items - user can decide whether to show or not
-            if (ArrayExtensions.IsNotNullOrEmpty(adaptableMenuItems) && hasAdaptableContextMenuItems) {
-                adaptableContextMenuItems.push(...this.createAgGridAdaptableContextMenuItems(adaptableMenuItems, menuContext));
-            }
-            // create agGrid Menu items based on User Menu Items - user can decide whether to show or not
-            if (hasUserDefinedContextMenuItems) {
-                userContextMenuItems.push(...this.createAgGridUserContextMenuItems(userDefinedContextMenuItems, menuContext));
-            }
-        }
-        const map = {
-            aggrid: agGridContextMenuItems,
-            adaptable: adaptableContextMenuItems,
-            user: userContextMenuItems,
-        };
-        const menuItemsArray = menuOptions.contextMenuOrder;
-        let arr = [];
-        if (menuItemsArray != null && typeof menuItemsArray === 'function') {
-            arr = menuItemsArray({
-                adaptableApi: this.adaptable.api,
-                userName: this.adaptable.adaptableOptions.userName,
-                adaptableId: this.adaptable.adaptableOptions.adaptableId,
-                column: adaptableColumn,
-            });
-        }
-        else {
-            arr = menuItemsArray;
-        }
-        return flatten(arr.map((c) => {
-            return map[c];
-        }));
-    }
-    /**
-     *  !!! This should be deleted once MenuOptions loses all the deprecated options
-     */
-    buildColumnMenuDeprecated(params, originalgetMainMenuItems) {
-        // couldnt find a way to listen for menu close. There is a Menu Item Select, but you can also close menu from filter and clicking outside menu....
-        const colId = params.column.getColId();
-        let agGridColumnMenuItems = [];
-        let adaptableColumnMenuItems = [];
-        let userColumnMenuItems = [];
-        const menuOptions = this.adaptable.adaptableOptions.menuOptions;
-        //First get Ag Grid Column Items
-        agGridColumnMenuItems.push(...this.createAgGridColumnMenuItems(originalgetMainMenuItems, params));
-        let showAdaptableColumnMenu = menuOptions.showAdaptableColumnMenu;
-        let hasAdaptableColumnMenuItems = showAdaptableColumnMenu == null || showAdaptableColumnMenu !== false;
-        if (hasAdaptableColumnMenuItems) {
-            agGridColumnMenuItems.push('separator');
-        }
-        const adaptableColumn = this.adaptable.api.columnApi.getColumnWithColumnId(colId);
-        const menuContext = this.createColumnMenuContextObject(adaptableColumn, params.column);
-        //  if (adaptableColumn != undefined) {
-        if (hasAdaptableColumnMenuItems) {
-            adaptableColumnMenuItems.push(...this.createAdaptableColumnMenuItems_DEPRECATED(adaptableColumn, menuContext));
-        }
-        //   }
-        // Finally get all the User Menu Items
-        userColumnMenuItems.push(...this.createUserColumnMenuItems(menuContext));
-        const map = {
-            aggrid: agGridColumnMenuItems,
-            adaptable: adaptableColumnMenuItems,
-            user: userColumnMenuItems,
-        };
-        const menuItemsArray = menuOptions.columnMenuOrder;
-        let arr = [];
-        if (menuItemsArray != null && typeof menuItemsArray === 'function') {
-            arr = menuItemsArray({
-                adaptableApi: this.adaptable.api,
-                userName: this.adaptable.adaptableOptions.userName,
-                adaptableId: this.adaptable.adaptableOptions.adaptableId,
-                column: adaptableColumn,
-            });
-        }
-        else {
-            arr = menuItemsArray;
-        }
-        return flatten(arr.map((c) => {
-            return map[c];
-        }));
-    }
-}