@adaptabletools/adaptable
Version:
Powerful AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements
717 lines (716 loc) • 33.1 kB
JavaScript
import { isAdaptableElementIcon } from '../components/Icon';
import { iconToString } from '../components/icons';
import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
import { MENU_SEPARATOR } from '../Utilities/Constants/GeneralConstants';
import { getAggFuncName, getDisplayAggFuncNames, isWeightedAverageAggregation, WEIGHTED_AVERAGE_AGG_FN_NAME, } from '../AdaptableState/Common/AggregationColumns';
function createAgGridIcon(name) {
const element = document.createElement('span');
element.className = `ag-icon ag-icon-${name}`;
element.setAttribute('role', 'presentation');
element.setAttribute('unselectable', 'on');
return element;
}
const toFuncLabel = (funcName) => {
if (funcName === 'avg') {
return 'Average';
}
if (funcName === 'weightedAvg') {
return 'Weighted Average';
}
return funcName ? funcName.charAt(0).toUpperCase() + funcName.slice(1) : funcName;
};
function buildValueAggregationMenuItem(adaptableApi, menuContext) {
const column = menuContext.adaptableColumn;
const columnId = column.columnId;
const currentLayout = adaptableApi.layoutApi.getCurrentLayout();
const aggregationColumns = currentLayout.TableAggregationColumns || [];
const currentAggFunc = aggregationColumns.find((agg) => agg.ColumnId === columnId)?.AggFunc;
let activeAggFuncName;
if (currentAggFunc != null) {
const aggFuncName = getAggFuncName(currentAggFunc);
activeAggFuncName = aggFuncName === true ? column.aggregationFunction : aggFuncName;
}
const activeWeightColumnId = isWeightedAverageAggregation(currentAggFunc)
? currentAggFunc.weightedColumnId
: undefined;
const applyAggregation = (aggFuncValue) => {
const upsert = (cols) => {
const list = cols ? [...cols] : [];
const index = list.findIndex((col) => col.ColumnId === columnId);
if (index >= 0) {
list[index] = { ...list[index], AggFunc: aggFuncValue };
}
else {
list.push({ ColumnId: columnId, AggFunc: aggFuncValue });
}
return list;
};
adaptableApi.layoutApi.updateCurrentLayout((layout) => {
const tableLayout = layout;
return {
...tableLayout,
TableAggregationColumns: upsert(tableLayout.TableAggregationColumns),
};
});
};
const removeAggregation = () => {
adaptableApi.layoutApi.updateCurrentLayout((layout) => {
const tableLayout = layout;
return {
...tableLayout,
TableAggregationColumns: (tableLayout.TableAggregationColumns || []).filter((col) => col.ColumnId !== columnId),
};
});
};
const subMenu = [
{
name: 'None',
checked: activeAggFuncName == null,
action: () => removeAggregation(),
},
];
const aggFuncItems = getDisplayAggFuncNames(column).map((funcName) => {
if (funcName === WEIGHTED_AVERAGE_AGG_FN_NAME) {
const weightColumnItems = adaptableApi.columnApi
.getNumericColumns()
.filter((numericColumn) => numericColumn.columnId !== columnId)
.map((numericColumn) => ({
name: numericColumn.friendlyName ?? numericColumn.columnId,
checked: activeWeightColumnId === numericColumn.columnId,
action: () => applyAggregation({
type: 'weightedAverage',
weightedColumnId: numericColumn.columnId,
}),
}));
return {
name: 'Weighted Average',
checked: activeAggFuncName === WEIGHTED_AVERAGE_AGG_FN_NAME,
subMenu: weightColumnItems,
};
}
return {
name: toFuncLabel(funcName),
checked: activeAggFuncName === funcName,
action: () => applyAggregation(funcName),
};
});
subMenu.push(...aggFuncItems);
return {
name: 'Value Aggregation',
subMenu,
};
}
export class AgGridMenuAdapter {
_adaptableInstance;
constructor(_adaptableInstance) {
this._adaptableInstance = _adaptableInstance;
}
get adaptableOptions() {
return this._adaptableInstance.adaptableOptions;
}
get adaptableApi() {
return this._adaptableInstance.api;
}
destroy() {
this._adaptableInstance = null;
}
buildColumnMenu(params, originalGetMainMenuItems) {
const agGridMenuItems = (params.defaultItems ? [...params.defaultItems] : []);
if (!params.column) {
return agGridMenuItems;
}
if (!this.adaptableApi.userInterfaceApi.isAdaptableUIVisible()) {
return agGridMenuItems;
}
const columnMenuOptions = this.adaptableOptions.columnMenuOptions;
const adaptableColumn = this.adaptableApi.columnApi.getColumnWithColumnId(params.column?.getColId());
const menuContext = this.createColumnMenuContextObject(adaptableColumn, params.column);
const agGridDefaultStructure = agGridMenuItems.map((itemName) => this.mapAgGridItemTypeToAgGridMenuItem(itemName));
const adaptableMenuItems = this.createAdaptableColumnMenuItems(menuContext);
const defaultColumnMenuStructure = this.buildColumnMenuDefaultStructure(adaptableMenuItems, menuContext);
if (typeof columnMenuOptions.customColumnMenu === 'function') {
const defaultAgGridMenuItems = agGridMenuItems.map((itemName) => this.mapAgGridItemTypeToAgGridMenuItem(itemName));
const defaultAdaptableMenuItems = adaptableMenuItems.map((adaptableItem) => ({ menuType: 'Adaptable', ...adaptableItem }));
const customMenuItems = columnMenuOptions
.customColumnMenu({
...menuContext,
defaultAgGridMenuItems,
defaultAdaptableMenuItems,
defaultAdaptableMenuStructure: this.mapAdaptableMenuItemToSystemMenuItems(defaultColumnMenuStructure),
defaultAgGridMenuStructure: agGridDefaultStructure,
})
.filter(Boolean);
return customMenuItems
.map((customMenuItem) => this.mapCustomMenuItemToAgGridMenuDefinition(customMenuItem, menuContext))
.filter(Boolean);
}
const isPivotLayout = this.adaptableApi.layoutApi.isCurrentLayoutPivot();
const mappedAgGridMenuItems = agGridMenuItems.map((itemName) => itemName === 'valueAggSubMenu' && !isPivotLayout
? {
...buildValueAggregationMenuItem(this.adaptableApi, menuContext),
icon: createAgGridIcon('aggregation'),
}
: itemName);
const defaultContextMenu = [
...mappedAgGridMenuItems,
'separator',
...defaultColumnMenuStructure.map((adaptableItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(adaptableItem)),
];
return this.removeConsecutiveSeparators(defaultContextMenu);
}
buildContextMenu(params, originalGetContextMenuItems) {
if (!params.column) {
return [];
}
if (!this.adaptableApi.userInterfaceApi.isAdaptableUIVisible()) {
return (params.defaultItems ? [...params.defaultItems] : []);
}
this._adaptableInstance.refreshSelectedCellsState();
const contextMenuOptions = this.adaptableOptions.contextMenuOptions;
const adaptableColumn = this.adaptableApi.columnApi.getColumnWithColumnId(params.column?.getColId());
const menuContext = this.createContextMenuContextObject(params, adaptableColumn);
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) &&
!['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)),
];
const adaptableMenuItems = this.createAdaptableContextMenuItems(menuContext);
const adaptableDefaultStructure = this.buildContextMenuDefaultStructure(adaptableMenuItems, menuContext);
if (typeof contextMenuOptions.customContextMenu === 'function') {
const defaultAgGridMenuItems = agGridMenuItems.map((itemName) => this.mapAgGridItemTypeToAgGridMenuItem(itemName));
const defaultAdaptableMenuItems = adaptableMenuItems.map((adaptableItem) => ({ menuType: 'Adaptable', ...adaptableItem }));
const defaultAdaptableMenuStructure = this.mapAdaptableMenuItemToSystemMenuItems(adaptableDefaultStructure);
const defaultAgGridMenuStructure = agGridDefaultStructure;
const customMenuItems = contextMenuOptions
.customContextMenu({
...menuContext,
defaultAgGridMenuItems,
defaultAdaptableMenuItems,
defaultAdaptableMenuStructure,
defaultAgGridMenuStructure,
})
.filter(Boolean);
return customMenuItems
.map((customMenuItem) => this.mapCustomMenuItemToAgGridMenuDefinition(customMenuItem, menuContext))
.filter(Boolean);
}
const defaultContextMenu = [
...agGridDefaultStructure.map((agGridItem) => this.mapCustomMenuItemToAgGridMenuDefinition(agGridItem, menuContext)),
'separator',
...adaptableDefaultStructure.map((adaptableItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(adaptableItem)),
];
return this.removeConsecutiveSeparators(defaultContextMenu);
}
mapAgGridItemTypeToAgGridMenuItem(itemName) {
return {
menuType: 'AgGrid',
name: itemName,
};
}
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 {
...this.adaptableApi.internalApi.buildBaseContext(),
adaptableColumn: adaptableColumn,
agGridColumn: agGridColumn,
isRowGroupColumn: this.adaptableApi.columnApi.isAutoRowGroupColumn(agGridColumn.getColId()),
};
}
createAdaptableContextMenuItems(menuContext) {
let contextMenuItems = [];
this.adaptableApi.internalApi.getModules().forEach((module) => {
let menuItems = module.createContextMenuItems(menuContext);
if (menuItems) {
contextMenuItems.push(...menuItems.filter(Boolean).filter((item) => item.isVisible !== false));
}
});
this._adaptableInstance._emitSync('CreateAdaptableContextMenuItems', {
items: contextMenuItems,
menuContext: menuContext,
});
return contextMenuItems;
}
createContextMenuContextObject(params, adaptableColumn) {
let isSingleSelectedColumn = false;
let isSelectedCell = false;
let isSelectedRow = false;
if (!adaptableColumn) {
return {
...this.adaptableApi.internalApi.buildBaseContext(),
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,
selectedCellInfo: undefined,
selectedRowInfo: undefined,
isRowGroupColumn: this.adaptableApi.columnApi.isAutoRowGroupColumn(params.column.getColId()),
};
}
const clickedCell = this.adaptableApi.gridApi.getGridCellFromRowNode(params.node, adaptableColumn.columnId);
const selectedCellInfo = this.adaptableApi.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.adaptableApi.gridApi.getSelectedRowInfo();
if (selectedRowInfo) {
const matchedPKValue = selectedRowInfo.gridRows.find((gr) => gr != null && gr.primaryKeyValue == clickedCell.primaryKeyValue);
isSelectedRow = matchedPKValue != null;
}
return {
...this.adaptableApi.internalApi.buildBaseContext(),
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?.gridCells.length == 1,
primaryKeyValue: clickedCell ? clickedCell.primaryKeyValue : undefined,
selectedCellInfo: selectedCellInfo,
selectedRowInfo: selectedRowInfo,
isRowGroupColumn: this.adaptableApi.columnApi.isAutoRowGroupColumn(params.column.getColId()),
};
}
mapAdaptableMenuItemToAgGridMenuDefinition(adaptableMenuItem) {
if (adaptableMenuItem === MENU_SEPARATOR) {
return 'separator';
}
const fullMenuItem = adaptableMenuItem;
return {
name: fullMenuItem.label,
action: fullMenuItem.onClick
? fullMenuItem.onClick
: fullMenuItem.reduxAction
? () => this.adaptableApi.internalApi.dispatchReduxAction(fullMenuItem.reduxAction)
: undefined,
icon: this.mapAdaptableIconToAgGridIcon(fullMenuItem.icon, {
fill: 'var(--ab-color-primary-foreground)',
}),
subMenu: fullMenuItem.subItems?.map((subMenuItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(subMenuItem)),
};
}
mapCustomMenuItemToAgGridMenuDefinition(customMenuItem, menuContext) {
if (customMenuItem === '-') {
return 'separator';
}
if (customMenuItem.menuType === 'Group') {
return {
name: customMenuItem.label,
icon: this.mapAdaptableIconToAgGridIcon(customMenuItem.icon, {
fill: 'var(--ab-color-primary-foreground)',
}),
disabled: customMenuItem.disabled,
subMenu: !customMenuItem.disabled
? customMenuItem.subMenuItems
?.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);
}
}
mapUserMenuItemToAgGridMenuDefinition(userMenuItem, menuContext) {
if (userMenuItem.hidden) {
return;
}
const menuItemDef = {
name: userMenuItem.label,
action: () => (userMenuItem.onClick ? userMenuItem.onClick(menuContext) : null),
icon: this.mapAdaptableIconToAgGridIcon(userMenuItem.icon, {
fill: 'var(--ab-color-primary-foreground)',
}),
disabled: userMenuItem.disabled,
subMenu: userMenuItem.subMenuItems
?.map((subMenuItem) => {
return this.mapCustomMenuItemToAgGridMenuDefinition(subMenuItem, menuContext);
})
.filter(Boolean),
};
if (userMenuItem.frameworkComponent) {
const variant = this.adaptableApi.gridApi.getVariant();
let menuItemComponent;
if (variant === 'react') {
menuItemComponent = userMenuItem.frameworkComponent;
}
else if (variant === 'vue') {
try {
menuItemComponent = userMenuItem.frameworkComponent({
adaptableApi: this.adaptableApi,
});
}
catch (err) {
this._adaptableInstance.logger.consoleWarn(`Could not resolve Vue framework component for menu item "${userMenuItem.label}"`, err);
menuItemComponent = undefined;
}
}
else if (variant === 'angular') {
const angularComponent = userMenuItem.frameworkComponent;
menuItemComponent = angularComponent.type;
}
if (menuItemComponent) {
menuItemDef.menuItem = menuItemComponent;
menuItemDef.menuItemParams = {
adaptableApi: this.adaptableApi,
menuContext,
...(userMenuItem.menuItemParams ?? {}),
};
}
}
return menuItemDef;
}
buildContextMenuDefaultStructure(availableMenuItems, menuContext) {
const alertMenuItems = this.getModuleSpecificStructure('Alert', availableMenuItems);
const bulkUpdateMenuItems = this.getModuleSpecificStructure('BulkUpdate', availableMenuItems);
const calculatedColumnMenuItems = this.getModuleSpecificStructure('CalculatedColumn', availableMenuItems);
const cellSummaryMenuItems = this.getModuleSpecificStructure('CellSummary', availableMenuItems);
const columnFilterMenuItems = this.getModuleSpecificStructure('ColumnFilter', availableMenuItems, 'column-filter-group');
const columnInfoMenuItems = this.getModuleSpecificStructure('ColumnInfo', availableMenuItems);
const commentMenuItems = this.getModuleSpecificStructure('Comment', availableMenuItems);
const dashboardMenuItems = this.getModuleSpecificStructure('Dashboard', availableMenuItems, 'dashboard-group');
const dataImportMenuItems = this.getModuleSpecificStructure('DataImport', availableMenuItems);
const exportMenuItems = this.getModuleSpecificStructure('Export', availableMenuItems, 'export-group');
const fdc3MenuItems = this.getModuleSpecificStructure('Fdc3', availableMenuItems);
const flashingCellMenuItems = this.getModuleSpecificStructure('FlashingCell', availableMenuItems);
const gridInfoMenuItems = this.getModuleSpecificStructure('GridInfo', availableMenuItems);
const [gridActionItems, otherLayoutItems] = this.getLayoutContextMenuStructure(availableMenuItems);
const noteMenuItems = this.getModuleSpecificStructure('Note', availableMenuItems);
const settingsPanelMenuItems = this.getModuleSpecificStructure('SettingsPanel', availableMenuItems);
const smartEditMenuItems = this.getModuleSpecificStructure('SmartEdit', availableMenuItems);
const systemStatusMenuItems = this.getModuleSpecificStructure('SystemStatus', availableMenuItems);
const gridMenuItem = {
name: 'grid-group',
label: 'Grid',
category: 'Group',
isVisible: true,
icon: {
name: 'grid',
},
subItems: [
...gridActionItems,
...otherLayoutItems,
...cellSummaryMenuItems,
...dataImportMenuItems,
...systemStatusMenuItems,
...gridInfoMenuItems,
],
};
const editMenuItem = {
name: 'edit-group',
label: 'Edit',
category: '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,
], '-');
}
normalizeMenuGroup(menuItem) {
if (!menuItem.subItems?.length) {
return [];
}
if (menuItem.subItems?.length === 1) {
return [menuItem.subItems[0]];
}
return [menuItem];
}
getModuleSpecificStructure(module, menuItems, groupName) {
const moduleItems = menuItems.filter((menuItem) => menuItem.category === module);
if (moduleItems.length > 1) {
return [this.buildMenuGroupParent(module, moduleItems, { groupName })];
}
else {
return moduleItems;
}
}
getLayoutContextMenuStructure(menuItems) {
const layoutMenuItems = menuItems.filter((menuItem) => menuItem.category === '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) {
const moduleInfo = this.adaptableApi.internalApi
.getModuleService()
.getModuleInfoByModule(module);
const icon = config && config.icon === false
? undefined
: { name: config?.icon ?? moduleInfo.Glyph };
return {
name: config?.groupName ?? 'menu-group',
label: config?.label ?? moduleInfo.FriendlyName,
isVisible: true,
category: moduleInfo.ModuleName,
icon,
subItems: menuItems,
};
}
buildColumnMenuDefaultStructure(availableMenuItems, menuContext) {
const calculatedColumnMenuItems = this.getModuleSpecificStructure('CalculatedColumn', availableMenuItems);
const cellSummaryMenuItems = this.getModuleSpecificStructure('CellSummary', availableMenuItems);
const chartMenuItems = this.getModuleSpecificStructure('Charting', availableMenuItems);
const [columnFilterGroup, filterVisibilityItems] = this.getColumnFilterColumnMenuStructure(availableMenuItems);
const columnInfoMenuItems = this.getModuleSpecificStructure('ColumnInfo', availableMenuItems);
const customSortMenuItems = this.getModuleSpecificStructure('CustomSort', availableMenuItems);
const dashboardMenuItems = this.getModuleSpecificStructure('Dashboard', availableMenuItems, 'dashboard-group');
const dataImportMenuItems = this.getModuleSpecificStructure('DataImport', availableMenuItems);
const flashingCellMenuItems = this.getModuleSpecificStructure('FlashingCell', availableMenuItems);
const formatColumnMenuItems = this.getModuleSpecificStructure('FormatColumn', availableMenuItems);
const freeTextColumnMenuItems = this.getModuleSpecificStructure('FreeTextColumn', availableMenuItems);
const gridInfoMenuItems = this.getModuleSpecificStructure('GridInfo', availableMenuItems);
const [gridSelectItems, columnSelectItems, columnActionGroup, otherLayoutItems] = this.getLayoutColumnMenuStructure(availableMenuItems);
const selectionMenuItems = this.buildSelectColumnMenuGroup(gridSelectItems, columnSelectItems);
const plusMinusMenuItems = this.getModuleSpecificStructure('PlusMinus', availableMenuItems);
const settingsPanelMenuItems = this.getModuleSpecificStructure('SettingsPanel', availableMenuItems);
const styledColumnMenuItems = this.getStyledColumnColumnMenuStructure(availableMenuItems);
const systemStatusMenuItems = this.getModuleSpecificStructure('SystemStatus', availableMenuItems);
const gridMenuItem = {
name: 'grid-group',
label: 'Grid',
category: 'Group',
isVisible: true,
icon: {
name: 'grid',
},
subItems: [
...otherLayoutItems,
...filterVisibilityItems,
...selectionMenuItems,
...cellSummaryMenuItems,
...chartMenuItems,
...dataImportMenuItems,
...systemStatusMenuItems,
...gridInfoMenuItems,
],
};
const columnMenuItem = {
name: 'column-group',
label: 'Column',
category: 'Group',
isVisible: true,
icon: {
name: 'columns',
},
subItems: [
...columnActionGroup,
...freeTextColumnMenuItems,
...customSortMenuItems,
...plusMinusMenuItems,
...columnInfoMenuItems,
],
};
const createStyleMenuItem = {
name: 'styling-group',
label: 'Styling',
category: 'Group',
isVisible: true,
icon: {
name: 'brush',
},
subItems: [...formatColumnMenuItems, ...styledColumnMenuItems, ...flashingCellMenuItems],
};
return this.removeConsecutiveSeparators([
...calculatedColumnMenuItems,
...settingsPanelMenuItems,
...dashboardMenuItems,
...columnFilterGroup,
...this.normalizeMenuGroup(createStyleMenuItem),
...this.normalizeMenuGroup(gridMenuItem),
...this.normalizeMenuGroup(columnMenuItem),
], '-');
}
getColumnFilterColumnMenuStructure(menuItems) {
const columnFilterMenuItems = menuItems.filter((menuItem) => menuItem.category === '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',
category: 'ColumnFilter',
isVisible: true,
icon: {
name: 'filter',
},
subItems: filterActionItems,
},
]
: [];
return [columnFilterGroup, filterVisibilityItems];
}
getLayoutColumnMenuStructure(menuItems) {
const layoutMenuItems = menuItems.filter((menuItem) => menuItem.category === '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];
}
buildSelectColumnMenuGroup(gridSelectItems, columnSelectItems) {
const childGroups = [];
if (gridSelectItems.length) {
const gridGroup = {
name: 'select-grid-group',
label: 'Grid',
category: 'Group',
isVisible: true,
subItems: gridSelectItems,
};
childGroups.push(...this.normalizeMenuGroup(gridGroup));
}
if (columnSelectItems.length) {
const columnGroup = {
name: 'select-column-group',
label: 'Column',
category: 'Group',
isVisible: true,
subItems: columnSelectItems,
};
childGroups.push(...this.normalizeMenuGroup(columnGroup));
}
if (!childGroups.length) {
return [];
}
const selectGroup = {
name: 'select-group',
label: 'Select',
category: 'Group',
isVisible: true,
icon: {
name: 'select-all',
},
subItems: childGroups,
};
return this.normalizeMenuGroup(selectGroup);
}
getStyledColumnColumnMenuStructure(menuItems) {
const styledColumnMenuItems = menuItems.filter((menuItem) => menuItem.category === 'StyledColumn');
return styledColumnMenuItems;
}
mapAdaptableMenuItemToSystemMenuItems(adaptableMenuItems) {
if (!adaptableMenuItems) {
return;
}
return adaptableMenuItems.map((menuItem) => {
if (menuItem === '-') {
return menuItem;
}
const subItems = this.mapAdaptableMenuItemToSystemMenuItems(menuItem.subItems);
return {
...menuItem,
menuType: 'Adaptable',
subItems,
};
});
}
createAdaptableColumnMenuItems(menuContext) {
let columnMenuItems = [];
this.adaptableApi.internalApi.getModules().forEach((s) => {
let menuItems = s.createColumnMenuItems(menuContext.adaptableColumn);
if (menuItems) {
columnMenuItems.push(...menuItems.filter(Boolean).filter((item) => item.isVisible !== false));
}
});
return columnMenuItems;
}
mapAdaptableIconToAgGridIcon(adaptableIcon, style) {
const icon = this.adaptableApi.userInterfaceApi.internalApi.prepareAdaptableIconDef(adaptableIcon);
if (isAdaptableElementIcon(icon)) {
let element = icon.element;
if (typeof element === 'string') {
return element;
}
return element.cloneNode(true);
}
else {
return iconToString(icon, {
fill: 'var(--ab-color-primary-foreground)',
});
}
}
buildStandaloneColumnHeader(adaptableColumn) {
const agGridColumn = this._adaptableInstance.getAgGridColumnForColumnId(adaptableColumn.columnId);
const menuContext = this.createColumnMenuContextObject(adaptableColumn, agGridColumn);
return this.createAdaptableColumnMenuItems(menuContext);
}
}