@adaptabletools/adaptable 18.0.0-canary.2 → 18.0.0-canary.20

package/src/Api/Implementation/GridApiImpl.d.ts

@@ -8,20 +8,23 @@ import { ColumnSort } from '../../PredefinedConfig/Common/ColumnSort';
 import { DataUpdateConfig } from '../../PredefinedConfig/Common/DataUpdateConfig';
 import { CellHighlightInfo } from '../../PredefinedConfig/Common/CellHighlightInfo';
 import { RowHighlightInfo } from '../../PredefinedConfig/Common/RowHighlightInfo';
-import { GridOptions, IRowNode, RowModelType } from '@ag-grid-community/core';
+import { IRowNode, RowModelType } from '@ag-grid-community/core';
 import { GridCellRange } from '../../PredefinedConfig/Selection/GridCellRange';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { RowsHighlightInfo } from '../../PredefinedConfig/Common/RowsHighlightInfo';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { GridInternalApi } from '../Internal/GridInternalApi';
+import { TransposeConfig } from '../../PredefinedConfig/Common/TransposeConfig';
 export declare class GridApiImpl extends ApiBase implements GridApi {
     internalApi: GridInternalApi;
     constructor(adaptable: IAdaptable);
     getGridState(): GridState;
+    loadGridData(dataSource: any): void;
     resetGridData(dataSource: any[]): void;
     setInitialGridData(data: any): void;
     getGridData(): any[];
     getFilteredData(): any[];
+    getVisibleData(): any[];
     updateGridData(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
     addOrUpdateGridData(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<{
         addedRows: IRowNode[];
@@ -40,7 +43,6 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     hideFilterForm(): void;
     applyGridFiltering(): void;
     clearGridFiltering(): void;
-    getAgGridInstance(): GridOptions;
     getColumnSorts(): ColumnSort[];
     getColumnSortForColumn(columnId: string): ColumnSort | undefined;
     setAdaptableSorting(columnSorts: ColumnSort[]): void;
@@ -120,7 +122,6 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     isCellEditable(gridCell: GridCell): boolean;
     isEveryCellEditable(gridCells: GridCell[]): boolean;
     getRowCount(): number;
-    getVisibleRowCount(): number;
     getRowsInViewport(): IRowNode[];
     getColumnCount(): number;
     getVisibleColumnCount(): number;
@@ -130,4 +131,6 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     getGridContainerElement(): HTMLElement | null;
     openGridInfoSettingsPanel(): void;
     getAgGridRowModelType(): RowModelType;
+    getVisibleRowCount(): number;
+    showTransposedView(transposeConfig?: TransposeConfig): void;
 }

package/src/Api/Implementation/GridApiImpl.js

@@ -4,6 +4,8 @@ import { SystemHighlightCellAdd, SystemHighlightCellDelete, SystemHighlightCellD
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import { GridInternalApi } from '../Internal/GridInternalApi';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
+import { logDeprecation } from '../../Utilities/logDeprecation';
+import { WINDOW_SHOW_TRANSPOSED_VIEW } from '../../View/Components/Popups/WindowPopups/windowFactory';
 export class GridApiImpl extends ApiBase {
     constructor(adaptable) {
         super(adaptable);
@@ -12,13 +14,18 @@ export class GridApiImpl extends ApiBase {
     getGridState() {
         return this.getAdaptableState().Grid;
     }
-    resetGridData(dataSource) {
+    loadGridData(dataSource) {
         this.adaptable.setGridData(dataSource);
         const allRowNodes = this.getAllRowNodes();
-        this.internalApi.fireGridDataChangedEvent(dataSource, allRowNodes, 'Add');
+        this.internalApi.fireGridDataChangedEvent(dataSource, allRowNodes, 'Load');
+    }
+    resetGridData(dataSource) {
+        logDeprecation(this.adaptable.logger, 'GridApi', 'resetGridData', 'loadGridData');
+        this.loadGridData(dataSource);
     }
     setInitialGridData(data) {
-        this.adaptable.setGridData(data);
+        logDeprecation(this.adaptable.logger, 'GridApi', 'setInitialGridData', 'loadGridData');
+        this.loadGridData(data);
     }
     getGridData() {
         return this.adaptable.getGridData();
@@ -26,6 +33,15 @@ export class GridApiImpl extends ApiBase {
     getFilteredData() {
         return this.adaptable.getFilteredData();
     }
+    getVisibleData() {
+        const data = [];
+        this.adaptable.forAllVisibleRowNodesDo((rowNode) => {
+            if (!this.isGroupRowNode(rowNode)) {
+                data.push(rowNode.data);
+            }
+        });
+        return data;
+    }
     async updateGridData(dataRows, dataUpdateConfig) {
         const rowNodes = await this.adaptable.updateRows(dataRows, dataUpdateConfig);
         this.internalApi.fireGridDataChangedEvent(dataRows, rowNodes, 'Edit');
@@ -114,9 +130,6 @@ export class GridApiImpl extends ApiBase {
         // slightly round the houses but we have to call ColumnFilterAPI as it does it properly
         this.adaptable.api.columnFilterApi.clearColumnFilters();
     }
-    getAgGridInstance() {
-        return this.adaptable.gridOptions;
-    }
     getColumnSorts() {
         return this.getAdaptableState().Grid.ColumnSorts;
     }
@@ -271,7 +284,9 @@ export class GridApiImpl extends ApiBase {
         return this.adaptable.getFirstDisplayedRowNode();
     }
     getVisibleRowNodes(config) {
-        return this.adaptable.getVisibleRowNodes();
+        const rowNodes = [];
+        this.adaptable.forAllVisibleRowNodesDo((rowNode) => rowNodes.push(rowNode), config);
+        return rowNodes;
     }
     getAllRowNodes(config) {
         return this.adaptable.getAllRowNodes(config);
@@ -330,10 +345,10 @@ export class GridApiImpl extends ApiBase {
         this.adaptable.expandRowGroupsForValues(columnValues);
     }
     isGridPivotable() {
-        return this.adaptable.isGridPivotable();
+        return !this.getAdaptableApi().internalApi.isGridInTreeMode();
     }
     isGridGroupable() {
-        return this.adaptable.isGridGroupable();
+        return !this.getAdaptableApi().internalApi.isGridInTreeMode();
     }
     isGridSelectable() {
         return this.adaptable.isGridSelectable();
@@ -349,7 +364,7 @@ export class GridApiImpl extends ApiBase {
     }
     redrawGrid() {
         this.adaptable.redrawBody();
-        this.adaptable.redrawHeader();
+        this.adaptable.refreshHeader();
     }
     getGridCellsForRawValue(columnId, rawValue) {
         const gridCells = this.adaptable.getGridCellsForColumn(columnId);
@@ -452,7 +467,7 @@ export class GridApiImpl extends ApiBase {
     }
     refreshGroupRowNodes() {
         // see https://www.ag-grid.com/javascript-data-grid/client-side-row-stages/#refreshing-the-client-side-model
-        this.getAgGridInstance().api.refreshClientSideRowModel('group');
+        this.getAdaptableApi().agGridApi.refreshClientSideRowModel('group');
         this.adaptable.updateRowGroupsExpandedState();
     }
     isCellEditable(gridCell) {
@@ -479,9 +494,6 @@ export class GridApiImpl extends ApiBase {
     getRowCount() {
         return this.adaptable.getRowCount();
     }
-    getVisibleRowCount() {
-        return this.adaptable.getVisibleRowCount();
-    }
     getRowsInViewport() {
         return this.adaptable.getRowsInViewport();
     }
@@ -509,4 +521,27 @@ export class GridApiImpl extends ApiBase {
     getAgGridRowModelType() {
         return this.adaptable.getAgGridRowModelType();
     }
+    getVisibleRowCount() {
+        logDeprecation(this.adaptable.logger, 'GridApi', 'getVisibleRowCount', 'getRowCount');
+        return this.getRowCount();
+    }
+    showTransposedView(transposeConfig = {}) {
+        var _a, _b, _c, _d;
+        const transposedColumnId = (_a = transposeConfig.transposedColumnId) !== null && _a !== void 0 ? _a : this.getAdaptableApi().optionsApi.getPrimaryKey();
+        const hideTransposedColumn = (_b = transposeConfig.hideTransposedColumn) !== null && _b !== void 0 ? _b : true;
+        const visibleColumns = (_c = transposeConfig.visibleColumns) !== null && _c !== void 0 ? _c : false;
+        const visibleRows = (_d = transposeConfig.visibleRows) !== null && _d !== void 0 ? _d : false;
+        this.adaptable.api.internalApi.showPopupWindow({
+            id: WINDOW_SHOW_TRANSPOSED_VIEW,
+            factoryId: WINDOW_SHOW_TRANSPOSED_VIEW,
+            title: 'Transposed View',
+            icon: 'grid',
+            popupProps: {
+                transposedColumnId,
+                hideTransposedColumn,
+                visibleColumns,
+                visibleRows,
+            },
+        });
+    }
 }

package/src/Api/Implementation/LayoutApiImpl.d.ts

@@ -9,6 +9,7 @@ import { LayoutInternalApi } from '../Internal/LayoutInternalApi';
 export declare class LayoutApiImpl extends ApiBase implements LayoutApi {
     internalApi: LayoutInternalApi;
     constructor(adaptable: IAdaptable);
+    isCurrentLayoutPivot(): boolean;
     getLayoutState(): LayoutState;
     shouldAutoSaveLayouts: () => boolean;
     getCurrentVisibleColumnIdsMap(): {
@@ -41,6 +42,8 @@ export declare class LayoutApiImpl extends ApiBase implements LayoutApi {
     removeColumnFromCurrentLayout(columnId: string): void;
     removeColumnFromAllLayouts(columnId: string): void;
     removeColumnFromLayout(columnId: string, layoutName: string): void;
+    addColumnToLayout(columnId: string, layoutName: string): void;
+    addColumnToCurrentLayout(columnId: string): void;
     getLayoutSupportedFeatures(): {
         RowGroupedColumns: boolean;
         AggregationColumns: boolean;

package/src/Api/Implementation/LayoutApiImpl.js

@@ -18,6 +18,9 @@ export class LayoutApiImpl extends ApiBase {
         };
         this.internalApi = new LayoutInternalApi(adaptable);
     }
+    isCurrentLayoutPivot() {
+        return this.getCurrentLayout().EnablePivot;
+    }
     getLayoutState() {
         return this.getAdaptableState().Layout;
     }
@@ -221,6 +224,21 @@ export class LayoutApiImpl extends ApiBase {
             }
         }
     }
+    addColumnToLayout(columnId, layoutName) {
+        const column = this.getAdaptableApi().columnApi.getColumnWithColumnId(columnId);
+        if (column) {
+            const layout = this.getLayoutByName(layoutName);
+            if (layout) {
+                if (!layout.Columns.includes(columnId)) {
+                    this.dispatchAction(LayoutRedux.LayoutAddColumn(layoutName, columnId));
+                    this.getAdaptableApi().columnApi.showColumn(columnId);
+                }
+            }
+        }
+    }
+    addColumnToCurrentLayout(columnId) {
+        this.addColumnToLayout(columnId, this.getCurrentLayoutName());
+    }
     getLayoutSupportedFeatures() {
         const layoutSupportedFeatures = {
             RowGroupedColumns: true,

package/src/Api/Implementation/NoteApiImpl.d.ts

@@ -0,0 +1,18 @@
+import { ApiBase } from './ApiBase';
+import { NoteApi } from '../NoteApi';
+import { AdaptableNote, AdaptableNotes, NoteState } from '../../PredefinedConfig/NoteState';
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { NoteInternalApi } from '../Internal/NoteInternalApi';
+import { CellAddress } from '../../types';
+export declare class NoteApiImpl extends ApiBase implements NoteApi {
+    internalApi: NoteInternalApi;
+    constructor(adaptable: IAdaptable);
+    addNote(noteStr: string, primaryKeyValue: any, columnId: string): void;
+    editNote(note: AdaptableNote): void;
+    updateNoteText(noteStr: string, note: AdaptableNote): void;
+    deleteNote(note: AdaptableNote): void;
+    getNoteState(): NoteState;
+    getAllNotes(): AdaptableNotes;
+    getNotesForCell(address: CellAddress): AdaptableNote[];
+    getNoteByUuid(uuid: string): AdaptableNote | undefined;
+}

package/src/Api/Implementation/NoteApiImpl.js

@@ -0,0 +1,40 @@
+import { ApiBase } from './ApiBase';
+import * as NoteRedux from '../../Redux/ActionsReducers/NoteRedux';
+import { NoteInternalApi } from '../Internal/NoteInternalApi';
+export class NoteApiImpl extends ApiBase {
+    constructor(adaptable) {
+        super(adaptable);
+        this.internalApi = new NoteInternalApi(adaptable);
+    }
+    addNote(noteStr, primaryKeyValue, columnId) {
+        const note = {
+            Text: noteStr,
+            PrimaryKeyValue: primaryKeyValue,
+            ColumnId: columnId,
+            Timestamp: Date.now(),
+        };
+        this.dispatchAction(NoteRedux.NoteAdd(note));
+    }
+    editNote(note) {
+        note.Timestamp = Date.now();
+        this.dispatchAction(NoteRedux.NoteEdit(note));
+    }
+    updateNoteText(noteStr, note) {
+        this.editNote(Object.assign(Object.assign({}, note), { Text: noteStr }));
+    }
+    deleteNote(note) {
+        this.dispatchAction(NoteRedux.NoteDelete(note));
+    }
+    getNoteState() {
+        return this.getAdaptableState().Note;
+    }
+    getAllNotes() {
+        return this.getNoteState().Notes;
+    }
+    getNotesForCell(address) {
+        return NoteRedux.GetNotesSelector(this.getAdaptableState().Note, address);
+    }
+    getNoteByUuid(uuid) {
+        return this.getAllNotes().find((note) => note.Uuid === uuid);
+    }
+}

package/src/Api/Implementation/OptionsApiImpl.d.ts

@@ -1,11 +1,11 @@
 import { ApiBase } from './ApiBase';
-import { ActionColumnOptions, ActionRowOptions, AdaptableOptions, AlertOptions, CalendarOptions, CellSummaryOptions, ChartingOptions, ColumnOptions, NotesOptions, ContainerOptions, DashboardOptions, DataChangeHistoryOptions, DataSetOptions, EditOptions, EntitlementOptions, ExportOptions, FlashingCellOptions, FormatColumnOptions, LayoutOptions, MenuOptions, NotificationsOptions, OptionsApi, QuickSearchOptions, SettingsPanelOptions, StateOptions, TeamSharingOptions, ToolPanelOptions, UserInterfaceOptions, GridFilterOptions } from '../../types';
+import { ActionColumnOptions, ActionRowOptions, AdaptableOptions, AlertOptions, CalendarOptions, CellSummaryOptions, ChartingOptions, ColumnOptions, NoteOptions, ContainerOptions, DashboardOptions, DataChangeHistoryOptions, DataSetOptions, EditOptions, EntitlementOptions, ExportOptions, FlashingCellOptions, FormatColumnOptions, LayoutOptions, MenuOptions, NotificationsOptions, OptionsApi, QuickSearchOptions, SettingsPanelOptions, StateOptions, TeamSharingOptions, ToolPanelOptions, UserInterfaceOptions, GridFilterOptions } from '../../types';
 import { GroupingOptions } from '../../AdaptableOptions/GroupingOptions';
 import { CustomSortOptions } from '../../AdaptableOptions/CustomSortOptions';
 import { Fdc3Options } from '../../AdaptableOptions/Fdc3Options';
 import { ExpressionOptions } from '../../AdaptableOptions/ExpressionOptions';
 import { ColumnFilterOptions } from '../../AdaptableOptions/ColumnFilterOptions';
-import { CommentsOptions } from '../../AdaptableOptions/CommentsOptions';
+import { CommentOptions } from '../../AdaptableOptions/CommentOptions';
 export declare class OptionsApiImpl extends ApiBase implements OptionsApi {
     getAdaptableId(): string;
     getAdaptableStateKey(): string;
@@ -19,8 +19,8 @@ export declare class OptionsApiImpl extends ApiBase implements OptionsApi {
     getCellSummaryOptions(): CellSummaryOptions;
     getCalendarOptions(): CalendarOptions;
     getColumnOptions(): ColumnOptions;
-    getNotesOptions(): NotesOptions;
-    getCommentsOptions(): Readonly<CommentsOptions<any>>;
+    getNoteOptions(): NoteOptions;
+    getCommentOptions(): Readonly<CommentOptions<any>>;
     getCustomSortOptions(): CustomSortOptions;
     getContainerOptions(): ContainerOptions;
     getDataSetOptions(): DataSetOptions;

package/src/Api/Implementation/OptionsApiImpl.js

@@ -36,11 +36,11 @@ export class OptionsApiImpl extends ApiBase {
     getColumnOptions() {
         return this.getOptions().columnOptions;
     }
-    getNotesOptions() {
-        return this.getOptions().notesOptions;
+    getNoteOptions() {
+        return this.getOptions().noteOptions;
     }
-    getCommentsOptions() {
-        return this.getOptions().commentsOptions;
+    getCommentOptions() {
+        return this.getOptions().commentOptions;
     }
     getCustomSortOptions() {
         return this.getOptions().customSortOptions;

package/src/Api/Implementation/ScopeApiImpl.d.ts

@@ -10,6 +10,7 @@ export declare class ScopeApiImpl extends ApiBase implements ScopeApi {
     scopeIsEmpty(scope: AdaptableScope): boolean;
     scopeIsAll(scope: AdaptableScope): boolean;
     scopeHasDataType(scope: AdaptableScope): boolean;
+    scopeHasColumnType(scope: AdaptableScope): boolean;
     scopeHasOnlyBooleanDataType(scope: AdaptableScope): boolean;
     scopeHasColumns(scope: AdaptableScope): boolean;
     isSingleColumnScope(scope: AdaptableScope): boolean;
@@ -21,6 +22,7 @@ export declare class ScopeApiImpl extends ApiBase implements ScopeApi {
     isPrimaryKeyColumnInScopeColumns(scope: AdaptableScope): boolean;
     getScopeToString(scope: AdaptableScope): string;
     getColumnIdsInScope(scope: AdaptableScope): string[] | undefined;
+    getColumnTypesInScope(scope: AdaptableScope): string[] | undefined;
     getDataTypesInScope(scope: AdaptableScope): ScopeDataType[] | undefined;
     isColumnInNumericScope(column: AdaptableColumn, scope: AdaptableScope): boolean;
     isColumnInStringsScope(column: AdaptableColumn, scope: AdaptableScope): boolean;

package/src/Api/Implementation/ScopeApiImpl.js

@@ -13,6 +13,10 @@ export class ScopeApiImpl extends ApiBase {
         if ('DataTypes' in scope && scope.DataTypes.includes(column.dataType)) {
             return true;
         }
+        if ('ColumnTypes' in scope &&
+            scope.ColumnTypes.some((columnType) => { var _a; return (_a = column.columnTypes) === null || _a === void 0 ? void 0 : _a.includes(columnType); })) {
+            return true;
+        }
         if ('ColumnIds' in scope && scope.ColumnIds.includes(column.columnId)) {
             return true;
         }
@@ -27,13 +31,7 @@ export class ScopeApiImpl extends ApiBase {
             return columns;
         }
         return columns.filter((c) => {
-            if ('DataTypes' in scope && scope.DataTypes.includes(c.dataType)) {
-                return true;
-            }
-            if ('ColumnIds' in scope && scope.ColumnIds.includes(c.columnId)) {
-                return true;
-            }
-            return false;
+            return this.isColumnInScope(c, scope);
         });
     }
     getScopeDescription(scope) {
@@ -44,6 +42,9 @@ export class ScopeApiImpl extends ApiBase {
             // do we need a true check here?
             return 'Columns: All';
         }
+        if ('ColumnTypes' in scope) {
+            return ((scope.ColumnTypes.length > 0 ? 'ColumnTypes' : 'ColumnType') + ': ' + scope.ColumnTypes.join(', '));
+        }
         if ('DataTypes' in scope) {
             return ((scope.DataTypes.length > 0 ? 'DataTypes' : 'DataType') + ': ' + scope.DataTypes.join(', '));
         }
@@ -67,6 +68,9 @@ export class ScopeApiImpl extends ApiBase {
     scopeHasDataType(scope) {
         return scope !== undefined && 'DataTypes' in scope;
     }
+    scopeHasColumnType(scope) {
+        return scope !== undefined && 'ColumnTypes' in scope;
+    }
     scopeHasOnlyBooleanDataType(scope) {
         var _a;
         return 'DataTypes' in scope && ((_a = scope.DataTypes) === null || _a === void 0 ? void 0 : _a.length) == 1 && scope.DataTypes[0] == 'Boolean';
@@ -120,6 +124,9 @@ export class ScopeApiImpl extends ApiBase {
         if ('All' in scope) {
             return 'Columns: All';
         }
+        if ('ColumnTypes' in scope) {
+            return 'ColumnTypes: ' + scope.ColumnTypes.join(',');
+        }
         if ('DataTypes' in scope) {
             return 'DataTypes: ' + scope.DataTypes.join(',');
         }
@@ -140,6 +147,12 @@ export class ScopeApiImpl extends ApiBase {
         }
         return undefined;
     }
+    getColumnTypesInScope(scope) {
+        if (scope !== undefined && 'ColumnTypes' in scope) {
+            return scope.ColumnTypes;
+        }
+        return undefined;
+    }
     getDataTypesInScope(scope) {
         if (scope !== undefined && 'DataTypes' in scope) {
             return scope.DataTypes;

package/src/Api/Implementation/StatusBarApiImpl.d.ts

@@ -5,6 +5,5 @@ import { StatusPanelDef } from '@ag-grid-community/core';
 export declare class StatusBarApiImpl extends ApiBase implements StatusBarApi {
     getAdaptableStatusBars(): AdaptableStatusBar[];
     getAgGridStatusPanels(): StatusPanelDef[];
-    getAgGridStatusBar(): StatusPanelDef[];
     setStatusBarPanels(statusPanels: AdaptableStatusBar[]): void;
 }

package/src/Api/Implementation/StatusBarApiImpl.js

@@ -7,9 +7,6 @@ export class StatusBarApiImpl extends ApiBase {
     getAgGridStatusPanels() {
         return this.adaptable.getAgGridStatusPanels();
     }
-    getAgGridStatusBar() {
-        return this.adaptable.getAgGridStatusPanels();
-    }
     setStatusBarPanels(statusPanels) {
         this.dispatchAction(StatusBarSetPanels(statusPanels));
     }

package/src/Api/Implementation/ToolPanelApiImpl.js

@@ -10,15 +10,15 @@ export class ToolPanelApiImpl extends ApiBase {
         this.showModulePopup(ModuleConstants.ToolPanelModuleId);
     }
     openAdapTableToolPanel() {
-        let gridOptions = this.getGridApi().getAgGridInstance();
-        if (gridOptions) {
-            gridOptions.api.openToolPanel('adaptable');
+        const agGridApi = this.getAdaptableApi().agGridApi;
+        if (agGridApi) {
+            agGridApi.openToolPanel('adaptable');
         }
     }
     closeAdapTableToolPanel() {
-        let gridOptions = this.getGridApi().getAgGridInstance();
-        if (gridOptions) {
-            gridOptions.api.closeToolPanel();
+        const agGridApi = this.getAdaptableApi().agGridApi;
+        if (agGridApi) {
+            agGridApi.closeToolPanel();
         }
     }
     getCustomToolPanels() {

package/src/Api/Implementation/UserInterfaceApiImpl.d.ts

@@ -2,7 +2,6 @@ import { ApiBase } from './ApiBase';
 import { UserInterfaceApi } from '../UserInterfaceApi';
 import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableStyle } from '../../PredefinedConfig/Common/AdaptableStyle';
-import { ColumnMenuContext, ContextMenuContext, UserMenuItem } from '../../PredefinedConfig/Common/Menu';
 import { BulkUpdatePermittedValues, CustomSortPermittedValues, EditLookUpPermittedValues, FilterPermittedValues, PermittedValues } from '../../AdaptableOptions/UserInterfaceOptions';
 import { AdaptableObjectTag, CustomWindowConfig, GridCell } from '../../types';
 import { UserInterfaceInternalApi } from '../Internal/UserInterfaceInternalApi';
@@ -24,8 +23,6 @@ export declare class UserInterfaceApiImpl extends ApiBase implements UserInterfa
     getEditLookUpItems(): EditLookUpPermittedValues[];
     getEditLookUpItemForColumn(column: AdaptableColumn): EditLookUpPermittedValues | undefined;
     getEditLookUpValuesForEditLookUpItem(editLookUpItem: EditLookUpPermittedValues, gridCell: GridCell): any[] | undefined;
-    addColumnMenuItem(userMenuItem: UserMenuItem<ColumnMenuContext>): void;
-    addContextMenuItem(userMenuItem: UserMenuItem<ContextMenuContext>): void;
     getEditableCellStyle(): AdaptableStyle | undefined;
     getReadOnlyCellStyle(): AdaptableStyle | undefined;
     getAdaptableObjectTags(): AdaptableObjectTag[] | undefined;

package/src/Api/Implementation/UserInterfaceApiImpl.js

@@ -142,14 +142,6 @@ export class UserInterfaceApiImpl extends ApiBase {
         }
         return this.adaptable.api.gridApi.internalApi.getEditLookUpValuesForColumn(editLookUpItem, gridCell.column, gridCell);
     }
-    addColumnMenuItem(userMenuItem) {
-        var _a;
-        (_a = this.getMenuOptions().columnMenuItems) === null || _a === void 0 ? void 0 : _a.push(userMenuItem);
-    }
-    addContextMenuItem(userMenuItem) {
-        var _a;
-        (_a = this.getMenuOptions().contextMenuItems) === null || _a === void 0 ? void 0 : _a.push(userMenuItem);
-    }
     getEditableCellStyle() {
         return this.getUserInterfaceOptions().editableCellStyle;
     }

package/src/Api/Internal/ActionRowInternalApi.d.ts

@@ -1,7 +1,9 @@
-import { IRowNode } from '@ag-grid-community/core';
+import { ColDef, IRowNode } from '@ag-grid-community/core';
 import { AdaptableForm } from '../../PredefinedConfig/Common/AdaptableForm';
 import { CreateActionRowFormContext, EditActionRowFormContext } from '../../AdaptableOptions/ActionRowOptions';
+import { AdaptableButton } from '../../PredefinedConfig/Common/AdaptableButton';
 import { ApiBase } from '../Implementation/ApiBase';
+import { ActionColumnContext } from '../../AdaptableOptions/ActionColumnOptions';
 export declare class ActionRowInternalApi extends ApiBase {
     buildRowEditForm(rowNode: IRowNode): AdaptableForm<EditActionRowFormContext>;
     buildRowCreateForm(clonedRowNode?: IRowNode): AdaptableForm<CreateActionRowFormContext>;
@@ -21,4 +23,6 @@ export declare class ActionRowInternalApi extends ApiBase {
     private buildFormFieldLabelContext;
     private getFieldTypeFromColumnType;
     private getFieldValueOptions;
+    getColDefsForActionRowColumns(): ColDef[];
+    getActionRowButtonDefs(): AdaptableButton<ActionColumnContext<any>>[];
 }

package/src/Api/Internal/ActionRowInternalApi.js

@@ -1,4 +1,7 @@
 import { ApiBase } from '../Implementation/ApiBase';
+import { AB_SPECIAL_COLUMN, ADAPTABLE_ROW_ACTION_BUTTONS, } from '../../Utilities/Constants/GeneralConstants';
+import UIHelper from '../../View/UIHelper';
+import { ActionColumnRenderer, ReactActionColumnRenderer } from '../../agGrid/ActionColumnRenderer';
 export class ActionRowInternalApi extends ApiBase {
     buildRowEditForm(rowNode) {
         return this.buildActionRow('rowEdited', rowNode);
@@ -197,4 +200,107 @@ export class ActionRowInternalApi extends ApiBase {
             label: value,
         }));
     }
+    getColDefsForActionRowColumns() {
+        const actionButtons = this.getActionRowButtonDefs();
+        if (!actionButtons.length) {
+            return [];
+        }
+        return [
+            {
+                headerName: '',
+                colId: ADAPTABLE_ROW_ACTION_BUTTONS,
+                hide: false,
+                editable: false,
+                // 15px is the icon width + left&right padding + left&right border
+                width: Math.max(actionButtons.length * (UIHelper.getSimpleButtonPaddingWidth() * 2 + 15) + 2, 
+                // If the width of the column is to small, the width will not be applied
+                // this triggers the setLayout an infinite loop because the width read from the grid is always different
+                40),
+                resizable: false,
+                lockVisible: true,
+                suppressColumnsToolPanel: true,
+                suppressFiltersToolPanel: true,
+                suppressHeaderMenuButton: true,
+                suppressMovable: true,
+                filter: false,
+                sortable: false,
+                enableRowGroup: false,
+                pinned: this.getActionRowOptions().actionRowButtonOptions.position === 'pinnedRight'
+                    ? 'right'
+                    : 'left',
+                cellRenderer: this.getAdaptableVariant() === 'react' ? ReactActionColumnRenderer : ActionColumnRenderer,
+                cellClass: ADAPTABLE_ROW_ACTION_BUTTONS,
+                type: [AB_SPECIAL_COLUMN, 'abColDefObject'],
+            },
+        ];
+    }
+    getActionRowButtonDefs() {
+        const actionRowButtons = this.getActionRowApi().getActionRowButtons();
+        if (!(actionRowButtons === null || actionRowButtons === void 0 ? void 0 : actionRowButtons.length)) {
+            return [];
+        }
+        const defaultActionRowButtonConfiguration = {
+            create: {
+                icon: {
+                    name: 'add',
+                },
+                tooltip: 'Create',
+                onClick: () => {
+                    this.getActionRowApi().displayCreateActionRow();
+                },
+            },
+            edit: {
+                icon: {
+                    name: 'edit',
+                },
+                tooltip: 'Edit',
+                onClick: (button, context) => {
+                    this.getActionRowApi().displayEditActionRow(context.primaryKeyValue);
+                },
+            },
+            clone: {
+                icon: {
+                    name: 'clone',
+                },
+                tooltip: 'Clone',
+                onClick: (button, context) => {
+                    this.getActionRowApi().displayCloneActionRow(context.primaryKeyValue);
+                },
+            },
+            delete: {
+                icon: {
+                    name: 'delete',
+                },
+                tooltip: 'Delete',
+                onClick: (button, context) => {
+                    var _a, _b;
+                    const eventInfo = {
+                        type: 'rowDeleted',
+                        rowNode: context.rowNode,
+                        adaptableApi: context.adaptableApi,
+                        userName: context.userName,
+                        adaptableId: context.adaptableId,
+                    };
+                    this.getEventApi().emit('ActionRowSubmitted', eventInfo);
+                    (_b = (_a = this.getActionRowOptions().actionRowFormOptions).onFormSubmit) === null || _b === void 0 ? void 0 : _b.call(_a, eventInfo);
+                },
+            },
+        };
+        const actionButtons = actionRowButtons
+            .map((actionRowButtonType) => {
+            var _a, _b;
+            const defaultButtonConfig = defaultActionRowButtonConfiguration[actionRowButtonType];
+            if (!defaultButtonConfig) {
+                // should NOT happen unless the user sent some invalid button type in the predefined config
+                return;
+            }
+            const customButtonConfig = (_b = (_a = this.getActionRowOptions().actionRowButtonOptions).customConfiguration) === null || _b === void 0 ? void 0 : _b.call(_a, Object.assign(Object.assign({}, this.getAdaptableApi().internalApi.buildBaseContext()), { actionRowButtonType }));
+            if (!customButtonConfig) {
+                return defaultButtonConfig;
+            }
+            return Object.assign(Object.assign({}, defaultButtonConfig), customButtonConfig);
+        })
+            .filter(Boolean);
+        return actionButtons;
+    }
 }